开源软件构建与测试

Changes of Revision 2

_service:tar_scm:isl.spec Changed

@@ -1,35 +1,24 @@
 Summary: Integer point manipulation library
 Name: isl
-Version: 0.16.1
+Version: 0.24
 License: MIT
 URL: http://isl.gforge.inria.fr/
 
-%global libmajor 15
-%global libversion %{libmajor}.1.1
-
-%global oldversion 0.14
-%global oldlibmajor 13
-%global oldlibversion %{oldlibmajor}.1.0
+%global libmajor 23
+%global libversion %{libmajor}.1.0
 
 # Please set buildid below when building a private version of this rpm to
 # differentiate it from the stock rpm.
 #
 # % global buildid .local
 
-Release: 11%{?buildid}
+Release: 2
 
 BuildRequires:  gcc
 BuildRequires: gmp-devel
 BuildRequires: pkgconfig
-Provides: isl = %{oldversion}
-
-Source0: http://isl.gforge.inria.fr/isl-%{version}.tar.xz
-
-# Current gcc requires exactly 0.14
-Source1: http://isl.gforge.inria.fr/isl-%{oldversion}.tar.xz
 
-# update python2 src file to python3
-Patch0: python3.patch
+Source: http://isl.gforge.inria.fr/isl-%{version}.tar.gz
 
 %description
 isl is a library for manipulating sets and relations of integer points
@@ -58,24 +47,14 @@
 
 %prep
 %global docdir isl-%{version}
-%setup -a 1 -q -n isl -c
-%patch0 -p1
+%setup -a 0 -q -n isl -c
 
 %build
-cd isl-%{oldversion}
-%configure
-make %{?_smp_mflags} V=1
-cd ..
-
 cd isl-%{version}
-%configure
-make %{?_smp_mflags} V=1
+%configure 
+make %{?_smp_mflags}  V=1 CFLAGS="%{optflags}"
 
 %install
-cd isl-%{oldversion}
-%make_install INSTALL="install -p" install-libLTLIBRARIES
-cd ..
-
 cd isl-%{version}
 %make_install INSTALL="install -p"
 rm -f %{buildroot}/%{_libdir}/libisl.a
@@ -86,20 +65,12 @@
 mv %{buildroot}/%{_libdir}/*-gdb.py* %{buildroot}/%{gdbprettydir}
 
 %check
-cd isl-%{oldversion}
-#make check
-cd ..
-
 cd isl-%{version}
-#make check
-
-%ldconfig_scriptlets
+%make_build check
 
 %files
 %{_libdir}/libisl.so.%{libmajor}
 %{_libdir}/libisl.so.%{libversion}
-%{_libdir}/libisl.so.%{oldlibmajor}
-%{_libdir}/libisl.so.%{oldlibversion}
 %{gdbprettydir}/*
 %license %{docdir}/LICENSE
 %doc %{docdir}/AUTHORS %{docdir}/ChangeLog %{docdir}/README
@@ -112,6 +83,12 @@
 
 
 %changelog
+* Thu Feb 16 2023 jiangxinyu <jiangxinyu@kylinos.cn> - 0.24-2
+- Enable check
+
+* Mon Mar 7 2022 licihua <licihua@huawei.com> - 0.24-1
+- upgrade to 0.24
+
 * Tue Dec 14 2021 konglidong <konglidong@uniontech.com> - 0.16.1-11
 - delete %dist

_service:tar_scm:python3.patch Deleted

@@ -1,210 +0,0 @@
-diff --git a/isl-0.14/isl.py b/isl-0.14/isl.py
-index 6382f63..9b76f42 100644
---- a/isl-0.14/isl.py
-+++ b/isl-0.14/isl.py
-@@ -64,10 +64,10 @@ class IslPrintCommand (gdb.Command):
-                 printer = str_lookup_function(arg)
- 
-                 if printer == None:
--                        print "No isl printer for this type"
-+                        print("No isl printer for this type")
-                         return
- 
--                print printer.to_string()
-+                print(printer.to_string())
- 
- IslPrintCommand()
- 
-diff --git a/isl-0.16.1/isl.py b/isl-0.16.1/isl.py
-index 6382f63..9b76f42 100644
---- a/isl-0.16.1/isl.py
-+++ b/isl-0.16.1/isl.py
-@@ -64,10 +64,10 @@ class IslPrintCommand (gdb.Command):
-                 printer = str_lookup_function(arg)
- 
-                 if printer == None:
--                        print "No isl printer for this type"
-+                        print("No isl printer for this type")
-                         return
- 
--                print printer.to_string()
-+                print(printer.to_string())
- 
- IslPrintCommand()
- 
-diff --git a/isl-0.14/isl.py b/isl-0.14/isl.py
-index 9b76f42..06236ef 100644
---- a/isl-0.14/isl.py
-+++ b/isl-0.14/isl.py
-@@ -3,19 +3,19 @@ import re
- 
- # GDB Pretty Printers for most isl objects
- class IslObjectPrinter:
--	"""Print an isl object"""
--	def __init__ (self, val, type):
-+        """Print an isl object"""
-+        def __init__ (self, val, type):
-                 self.val = val
-                 self.type = type
- 
--	def to_string (self):
-+        def to_string (self):
-                 # Cast val to a void pointer to stop gdb using this pretty
-                 # printer for the pointer which would lead to an infinite loop.
-                 void_ptr = gdb.lookup_type('void').pointer()
-                 value = str(self.val.cast(void_ptr))
-                 printer = gdb.parse_and_eval("isl_printer_to_str(isl_"
-                                              + str(self.type)
--					     + "_get_ctx(" + value + "))")
-+                                             + "_get_ctx(" + value + "))")
-                 printer = gdb.parse_and_eval("isl_printer_print_"
-                                              + str(self.type) + "("
-                                              + str(printer) + ", "
-@@ -25,15 +25,15 @@ class IslObjectPrinter:
-                 gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
-                 return string
- 
--	def display_hint (self):
-+        def display_hint (self):
-                 return 'string'
- 
- class IslIntPrinter:
--	"""Print an isl_int """
--	def __init__ (self, val):
-+        """Print an isl_int """
-+        def __init__ (self, val):
-                 self.val = val
- 
--	def to_string (self):
-+        def to_string (self):
-                 # Cast val to a void pointer to stop gdb using this pretty
-                 # printer for the pointer which would lead to an infinite loop.
-                 void_ptr = gdb.lookup_type('void').pointer()
-@@ -51,7 +51,7 @@ class IslIntPrinter:
-                 gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")")
-                 return string
- 
--	def display_hint (self):
-+        def display_hint (self):
-                 return 'string'
- 
- class IslPrintCommand (gdb.Command):
-@@ -72,21 +72,21 @@ class IslPrintCommand (gdb.Command):
- IslPrintCommand()
- 
- def str_lookup_function (val):
--	if val.type.code != gdb.TYPE_CODE_PTR:
--		if str(val.type) == "isl_int":
--			return IslIntPrinter(val)
-+        if val.type.code != gdb.TYPE_CODE_PTR:
-+                if str(val.type) == "isl_int":
-+                        return IslIntPrinter(val)
-                 else:
-                         return None
- 
--	lookup_tag = val.type.target()
--	regex = re.compile ("^isl_(.*)$")
-+        lookup_tag = val.type.target()
-+        regex = re.compile ("^isl_(.*)$")
- 
--	if lookup_tag == None:
--		return None
-+        if lookup_tag == None:
-+                return None
- 
--	m = regex.match (str(lookup_tag))
-+        m = regex.match (str(lookup_tag))
- 
--	if m:
-+        if m:
-                 # Those types of printers defined in isl.
-                 if m.group(1) in "basic_set", "set", "union_set", "basic_map",
-                                   "map", "union_map", "qpolynomial",
-diff --git a/isl-0.16.1/isl.py b/isl-0.16.1/isl.py
-index 9b76f42..06236ef 100644
---- a/isl-0.16.1/isl.py
-+++ b/isl-0.16.1/isl.py
-@@ -3,19 +3,19 @@ import re
- 
- # GDB Pretty Printers for most isl objects
- class IslObjectPrinter:
--	"""Print an isl object"""
--	def __init__ (self, val, type):
-+        """Print an isl object"""
-+        def __init__ (self, val, type):
-                 self.val = val
-                 self.type = type
- 
--	def to_string (self):
-+        def to_string (self):
-                 # Cast val to a void pointer to stop gdb using this pretty
-                 # printer for the pointer which would lead to an infinite loop.
-                 void_ptr = gdb.lookup_type('void').pointer()
-                 value = str(self.val.cast(void_ptr))
-                 printer = gdb.parse_and_eval("isl_printer_to_str(isl_"
-                                              + str(self.type)
--					     + "_get_ctx(" + value + "))")
-+                                             + "_get_ctx(" + value + "))")
-                 printer = gdb.parse_and_eval("isl_printer_print_"
-                                              + str(self.type) + "("
-                                              + str(printer) + ", "
-@@ -25,15 +25,15 @@ class IslObjectPrinter:
-                 gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
-                 return string
- 
--	def display_hint (self):
-+        def display_hint (self):
-                 return 'string'
- 
- class IslIntPrinter:
--	"""Print an isl_int """
--	def __init__ (self, val):
-+        """Print an isl_int """
-+        def __init__ (self, val):
-                 self.val = val
- 
--	def to_string (self):
-+        def to_string (self):
-                 # Cast val to a void pointer to stop gdb using this pretty
-                 # printer for the pointer which would lead to an infinite loop.
-                 void_ptr = gdb.lookup_type('void').pointer()
-@@ -51,7 +51,7 @@ class IslIntPrinter:
-                 gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")")
-                 return string
- 
--	def display_hint (self):
-+        def display_hint (self):
-                 return 'string'
- 
- class IslPrintCommand (gdb.Command):
-@@ -72,21 +72,21 @@ class IslPrintCommand (gdb.Command):
- IslPrintCommand()
- 
- def str_lookup_function (val):
--	if val.type.code != gdb.TYPE_CODE_PTR:
--		if str(val.type) == "isl_int":
--			return IslIntPrinter(val)
-+        if val.type.code != gdb.TYPE_CODE_PTR:
-+                if str(val.type) == "isl_int":
-+                        return IslIntPrinter(val)
-                 else:
-                         return None
- 
--	lookup_tag = val.type.target()
--	regex = re.compile ("^isl_(.*)$")
-+        lookup_tag = val.type.target()
-+        regex = re.compile ("^isl_(.*)$")
- 
--	if lookup_tag == None:
--		return None
-+        if lookup_tag == None:
-+                return None
- 
--	m = regex.match (str(lookup_tag))
-+        m = regex.match (str(lookup_tag))
- 
--	if m:
-+        if m:
-                 # Those types of printers defined in isl.
-                 if m.group(1) in "basic_set", "set", "union_set", "basic_map",
-                                   "map", "union_map", "qpolynomial",

_service Changed

_service:tar_scm:isl-0.14.tar.xz/doc/chicago.bst Deleted

@@ -1,1726 +0,0 @@
-%%% ====================================================================
-%%%  @BibTeX-style-file{
-%%%     author          = "Glenn Paulley",
-%%%     version         = "4",
-%%%     date            = "28 August 1992",
-%%%     time            = "10:23:39 199",
-%%%     filename        = "chicago.bst",
-%%%     address         = "Data Structuring Group
-%%%                        Department of Computer Science
-%%%                        University of Waterloo
-%%%                        Waterloo, Ontario, Canada
-%%%                        N2L 3G1",
-%%%     telephone       = "(519) 885-1211",
-%%%     FAX             = "(519) 885-1208",
-%%%     checksum        = "26323 1654 5143 37417",
-%%%     email           = "gnpaulle@bluebox.uwaterloo.ca",
-%%%     codetable       = "ISO/ASCII",
-%%%     keywords        = "",
-%%%     supported       = "yes",
-%%%     abstract        = "A BibTeX bibliography style that follows the
-%%%                        `B' reference style of the 13th Edition of
-%%%                        the Chicago Manual of Style. A detailed
-%%%                        feature list is given below.",
-%%%     docstring       = "The checksum field above contains a CRC-16
-%%%                        checksum as the first value, followed by the
-%%%                        equivalent of the standard UNIX wc (word
-%%%                        count) utility output of lines, words, and
-%%%                        characters.  This is produced by Robert
-%%%                        Solovay's checksum utility.",
-%%%  }
-%%% ====================================================================
-%
-% "Chicago" BibTeX style, chicago.bst
-% ===================================
-%
-% BibTeX `chicago' style file for BibTeX version 0.99c, LaTeX version 2.09
-% Place it in a file called chicago.bst in the BibTeX search path.
-% You need to include chicago.sty as a \documentstyle option.
-% (Placing it in the same directory as the LaTeX document should also work.)
-% This "chicago" style is based on newapa.bst (American Psych. Assoc.)
-% found at ymir.claremont.edu.
-%
-%   Citation format: (author-last-name year)
-%             (author-last-name and author-last-name year)
-%             (author-last-name, author-last-name, and author-last-name year)
-%             (author-last-name et al. year)
-%             (author-last-name)
-%             author-last-name (year)
-%             (author-last-name and author-last-name)
-%             (author-last-name et al.)
-%             (year) or (year,year)
-%             year or year,year
-%
-%   Reference list ordering: alphabetical by author or whatever passes
-%    for author in the absence of one.
-%
-% This BibTeX style has support for abbreviated author lists and for
-%    year-only citations.  This is done by having the citations
-%    actually look like
-%
-%    \citeauthoryear{full-author-info}{abbrev-author-info}{year}
-%
-% The LaTeX style has to have the following (or similar)
-%
-%     \let\@internalcite\cite
-%     \def\fullcite{\def\citeauthoryear##1##2##3{##1, ##3}\@internalcite}
-%     \def\fullciteA{\def\citeauthoryear##1##2##3{##1}\@internalcite}
-%     \def\shortcite{\def\citeauthoryear##1##2##3{##2, ##3}\@internalcite}
-%     \def\shortciteA{\def\citeauthoryear##1##2##3{##2}\@internalcite}
-%     \def\citeyear{\def\citeauthoryear##1##2##3{##3}\@internalcite}
-%
-% These TeX macro definitions are found in chicago.sty. Additional
-% commands to manipulate different components of a citation can be defined
-% so that, for example, you can list author's names without parentheses
-% if using a citation as a noun or object in a sentence.
-%
-% This file was originally copied from newapa.bst at ymir.claremont.edu.
-%
-% Features of chicago.bst:
-% =======================
-%
-% - full names used in citations, but abbreviated citations are available
-%   (see above)
-% - if an entry has a "month", then the month and year are also printed
-%   as part of that bibitem.
-% - all conjunctions use "and" instead of "\&"
-% - major modification from Chicago Manual of Style (13th ed.) is that
-%   only the first author in a reference appears last name first-
-%   additional authors appear as J. Q. Public.
-% - pages are listed as "pp. xx-xx" in all entry types except
-%   article entries.
-% - book, inbook, and manual use "location: publisher" (or organization)
-%   for address and publisher. All other types list publishers separately.
-% - "pp." are used to identify page numbers for all entry types except
-%   articles.
-% - organization is used as a citation label if neither author nor editor
-%   is present (for manuals).
-% - "et al." is used for long author and editor lists, or when "others"
-%   is used.
-%
-% Modifications and bug fixes from newapa.bst:
-% ===========================================
-%
-%   - added month, year to bib entries if month is present
-%   - fixed bug with In proceedings, added necessary comma after title
-%   - all conjunctions changed to "and" from "\&"
-%   - fixed bug with author labels in my.full.label: "et al." now is
-%        generated when "others" is an author name
-%   - major modification from Chicago Manual of Style (13th ed.) is that
-%     only the first author in a reference appears last name first-
-%     additional authors appear as J. Q. Public.
-%   - pages are listed as "pp. xx-xx" in all entry types except
-%     article entries. Unnecessary (IMHO) "()" around page numbers
-%     were removed, and page numbers now don't end with a period.
-%   - created chicago.sty for use with this bibstyle (required).
-%   - fixed bugs in FUNCTION {format.vol.num.pages} for missing volume,
-%     number, and /or pages. Renamed to format.jour.vol.
-%   - fixed bug in formatting booktitles: additional period an error if
-%     book has a volume.
-%   - fixed bug: editors usually given redundant period before next clause
-%     (format.editors.dot) removed.
-%   - added label support for organizations, if both author and editor
-%     are missing (from alpha.bst). If organization is too long, then
-%     the key field is used for abbreviated citations.
-%   - In proceedings or books of several volumes, no comma was written
-%     between the "Volume x" and the page numbers (this was intentional
-%     in newapa.bst). Fixed.
-%   - Some journals may not have volumes/numbers, only month/year (eg.
-%     IEEE Computer). Fixed bug in article style that assumed volume/number
-%     was always present.
-%
-% Original documentation for newapa.sty:
-% =====================================
-%
-% This version was made by modifying the master file made by
-% Oren Patashnik (PATASHNIK@SCORE.STANFORD.EDU), and the 'named' BibTeX
-% style of Peter F. Patel-Schneider.
-%
-% Copyright (C) 1985, all rights reserved.
-% Copying of this file is authorized only if either
-% (1) you make absolutely no changes to your copy, including name, or
-% (2) if you do make changes, you name it something other than 'newapa.bst'.
-% There are undoubtably bugs in this style.  If you make bug fixes,
-% improvements, etc.  please let me know.  My e-mail address is:
-%    spencer@cgrg.ohio.state.edu or 71160.3141@compuserve.com
-%
-% This style was made from 'plain.bst', 'named.bst', and 'apalike.bst',
-% with lots of tweaking to make it look like APA style, along with tips
-% from Young Ryu and Brian Reiser's modifications of 'apalike.bst'.
-
-ENTRY
-  { address
-    author
-    booktitle
-    chapter
-    edition
-    editor
-    fjournal
-    howpublished
-    institution
-    journal
-    key
-    month
-    note
-    number
-    organization
-    pages
-    publisher
-    school
-    series
-    title
-    type
-    volume
-    year
-  }
-  {}
-  { label.year extra.label sort.year sort.label }
-
-INTEGERS { output.state before.all mid.sentence after.sentence after.block }
-
-FUNCTION {init.state.consts}
-{ #0 'before.all :=
-  #1 'mid.sentence :=
-  #2 'after.sentence :=
-  #3 'after.block :=
-}
-
-STRINGS { s t u }
-
-FUNCTION {output.nonnull}
-{ 's :=
-  output.state mid.sentence =
-    { ", " * write$ }
-    { output.state after.block =
-    { add.period$ write$
-      newline$
-      "\newblock " write$
-    }
-    { output.state before.all =
-        'write$
-        { add.period$ " " * write$ }
-      if$
-    }
-      if$
-      mid.sentence 'output.state :=
-    }
-  if$
-  s
-}
-
-% Use a colon to separate output. Used only for address/publisher
-% combination in book/inbook types, address/institution for manuals,
-% and organization:publisher for proceedings (inproceedings).
-%
-FUNCTION {output.nonnull.colon}
-{ 's :=
-  output.state mid.sentence =
-    { ": " * write$ }
-    { output.state after.block =
-    { add.period$ write$
-      newline$
-      "\newblock " write$
-    }
-    { output.state before.all =
-        'write$
-        { add.period$ " " * write$ }
-      if$
-    }
-      if$
-      mid.sentence 'output.state :=
-    }
-  if$
-  s
-}
-
-FUNCTION {output}
-{ duplicate$ empty$
-    'pop$
-    'output.nonnull
-  if$
-}
-
-FUNCTION {output.colon}
-{ duplicate$ empty$
-    'pop$
-    'output.nonnull.colon
-  if$
-}
-
-FUNCTION {output.check}
-{ 't :=
-  duplicate$ empty$
-    { pop$ "empty " t * " in " * cite$ * warning$ }
-    'output.nonnull
-  if$
-}
-
-FUNCTION {output.check.colon}
-{ 't :=
-  duplicate$ empty$
-    { pop$ "empty " t * " in " * cite$ * warning$ }
-    'output.nonnull.colon
-  if$
-}
-
-FUNCTION {output.year.check}
-{ year empty$
-     { "empty year in " cite$ * warning$ }
-     { write$
-        " (" year * extra.label *
-       month empty$
-          { ")" * }
-          { ", " * month * ")" * }
-       if$
-       mid.sentence 'output.state :=
-     }
-  if$
-}
-
-
-FUNCTION {fin.entry}
-{ add.period$
-  write$
-  newline$
-}
-
-FUNCTION {new.block}
-{ output.state before.all =
-    'skip$
-    { after.block 'output.state := }
-  if$
-}
-
-FUNCTION {new.sentence}
-{ output.state after.block =
-    'skip$
-    { output.state before.all =
-    'skip$
-    { after.sentence 'output.state := }
-      if$
-    }
-  if$
-}
-
-FUNCTION {not}
-{   { #0 }
-    { #1 }
-  if$
-}
-
-FUNCTION {and}
-{   'skip$
-    { pop$ #0 }
-  if$
-}
-
-FUNCTION {or}
-{   { pop$ #1 }
-    'skip$
-  if$
-}
-
-FUNCTION {new.block.checka}
-{ empty$
-    'skip$
-    'new.block
-  if$
-}
-
-FUNCTION {new.block.checkb}
-{ empty$
-  swap$ empty$
-  and
-    'skip$
-    'new.block
-  if$
-}
-
-FUNCTION {new.sentence.checka}
-{ empty$
-    'skip$
-    'new.sentence
-  if$
-}
-
-FUNCTION {new.sentence.checkb}
-{ empty$
-  swap$ empty$
-  and
-    'skip$
-    'new.sentence
-  if$
-}
-
-FUNCTION {field.or.null}
-{ duplicate$ empty$
-    { pop$ "" }
-    'skip$
-  if$
-}
-
-%
-% Emphasize the top string on the stack.
-%
-FUNCTION {emphasize}
-{ duplicate$ empty$
-    { pop$ "" }
-    { "{\em " swap$ * "}" * }
-  if$
-}
-
-%
-% Emphasize the top string on the stack, but add a trailing space.
-%
-FUNCTION {emphasize.space}
-{ duplicate$ empty$
-    { pop$ "" }
-    { "{\em " swap$ * "\/}" * }
-  if$
-}
-
-INTEGERS { nameptr namesleft numnames }
-%
-% Format bibliographical entries with the first author last name first,
-% and subsequent authors with initials followed by last name.
-% All names are formatted in this routine.
-%
-FUNCTION {format.names}
-{ 's :=
-  #1 'nameptr :=               % nameptr = 1;
-  s num.names$ 'numnames :=    % numnames = num.name$(s);
-  numnames 'namesleft :=
-    { namesleft #0 > }
-
-    { nameptr #1 =
-        {s nameptr "{vv~}{ll}{, jj}{, f.}" format.name$ 't := }
-        {s nameptr "{f.~}{vv~}{ll}{, jj}" format.name$ 't := }
-      if$
-      nameptr #1 >
-        { namesleft #1 >
-              { ", " * t * }
-              { numnames #2 >
-                  { "," * }
-                  'skip$
-                if$
-                t "others" =
-                    { " et~al." * }
-                    { " and " * t * } % from Chicago Manual of Style
-                  if$
-               }
-               if$
-             }
-            't
-        if$
-        s nameptr "{vv~}{ll}{, jj}{, f.}" format.name$ 't := 
-	"\protect \index {" * t * "|hyperemph}" *
-        nameptr #1 + 'nameptr :=          % nameptr += 1;
-        namesleft #1 - 'namesleft :=      % namesleft =- 1;
-    }
-  while$
-}
-
-FUNCTION {my.full.label}
-{ 's :=
-  #1 'nameptr :=               % nameptr = 1;
-  s num.names$ 'numnames :=    % numnames = num.name$(s);
-  numnames 'namesleft :=
-    { namesleft #0 > }
-
-    { s nameptr "{vv~}{ll}" format.name$ 't :=  % get the next name
-      nameptr #1 >
-        { namesleft #1 >
-              { ", " * t * }
-              { numnames #2 >
-                  { "," * }
-                  'skip$
-                if$
-                t "others" =
-                    { " et~al." * }
-                    { " and " * t * } % from Chicago Manual of Style
-                  if$
-               }
-               if$
-             }
-            't
-        if$
-        s nameptr "{vv~}{ll}{, jj}{, f.}" format.name$ 't := 
-	"\protect \index {" * t * "|bold}" *
-        nameptr #1 + 'nameptr :=          % nameptr += 1;
-        namesleft #1 - 'namesleft :=      % namesleft =- 1;
-    }
-  while$
-
-}
-
-FUNCTION {format.names.fml}
-%
-% Format names in "familiar" format, with first initial followed by
-% last name. Like format.names, ALL names are formatted.
-%
-{ 's :=
-  #1 'nameptr :=               % nameptr = 1;
-  s num.names$ 'numnames :=    % numnames = num.name$(s);
-  numnames 'namesleft :=
-    { namesleft #0 > }
-
-    { s nameptr "{f.~}{vv~}{ll}{, jj}" format.name$ 't :=
-
-      nameptr #1 >
-        { namesleft #1 >
-              { ", " * t * }
-               { numnames #2 >
-                    { "," * }
-                    'skip$
-                  if$
-                  t "others" =
-                        { " et~al." * }
-                        { " and " * t * }
-%                       { " \& " * t * }
-                      if$
-                }
-               if$
-             }
-            't
-        if$
-        nameptr #1 + 'nameptr :=          % nameptr += 1;
-        namesleft #1 - 'namesleft :=      % namesleft =- 1;
-    }
-  while$
-}
-
-FUNCTION {format.authors}
-{ author empty$
-    { "" }
-    { author format.names }
-  if$
-}
-
-FUNCTION {format.key}
-{ empty$
-    { key field.or.null }
-    { "" }
-  if$
-}
-
-%
-% Format editor names for use in the "in" types: inbook, incollection,
-% inproceedings: first initial, then last names. When editors are the
-% LABEL for an entry, then format.editor is used which lists editors
-% by last name first.
-%
-FUNCTION {format.editors.fml}
-{ editor empty$
-    { "" }
-    { editor format.names.fml
-      editor num.names$ #1 >
-    { " (Eds.)" * }
-    { " (Ed.)" * }
-      if$
-    }
-  if$
-}
-
-%
-% Format editor names for use in labels, last names first.
-%
-FUNCTION {format.editors}
-{ editor empty$
-    { "" }
-    { editor format.names
-      editor num.names$ #1 >
-    { " (Eds.)" * }
-    { " (Ed.)" * }
-      if$
-    }
-  if$
-}
-
-FUNCTION {format.title}
-{ title empty$
-    { "" }
-    { title "t" change.case$ }
-  if$
-}
-
-% Note that the APA style requres case changes
-% in article titles. The following does not
-% change cases. If you perfer it, uncomment the
-% following and comment out the above.
-
-%FUNCTION {format.title}
-%{ title empty$
-%    { "" }
-%    { title }
-%  if$
-%}
-
-FUNCTION {n.dashify}
-{ 't :=
-  ""
-    { t empty$ not }
-    { t #1 #1 substring$ "-" =
-    { t #1 #2 substring$ "--" = not
-        { "--" *
-          t #2 global.max$ substring$ 't :=
-        }
-        {   { t #1 #1 substring$ "-" = }
-        { "-" *
-          t #2 global.max$ substring$ 't :=
-        }
-          while$
-        }
-      if$
-    }
-    { t #1 #1 substring$ *
-      t #2 global.max$ substring$ 't :=
-    }
-      if$
-    }
-  while$
-}
-
-FUNCTION {format.btitle}
-{ edition empty$
-  { title emphasize }
-  { title empty$
-    { title emphasize }
-    { volume empty$     % gnp - check for volume, then don't need period
-       { "{\em " title * "\/} (" * edition * " ed.)" * "." * }
-       { "{\em " title * "\/} (" * edition * " ed.)" * }
-      if$
-    }
-    if$
-  }
-  if$
-}
-
-FUNCTION {format.emphasize.booktitle}
-{ edition empty$
-  { booktitle emphasize }
-  { booktitle empty$
-    { booktitle emphasize }
-    { volume empty$    % gnp - extra period an error if book has a volume
-        { "{\em " booktitle * "\/} (" * edition * " ed.)" * "." *}
-        { "{\em " booktitle * "\/} (" * edition * " ed.)" * }
-      if$
-      }
-    if$
-    }
-  if$
-  }
-
-
-FUNCTION {tie.or.space.connect}
-{ duplicate$ text.length$ #3 <
-    { "~" }
-    { " " }
-  if$
-  swap$ * *
-}
-
-FUNCTION {either.or.check}
-{ empty$
-    'pop$
-    { "can't use both " swap$ * " fields in " * cite$ * warning$ }
-  if$
-}
-
-FUNCTION {format.bvolume}
-{ volume empty$
-    { "" }
-    { "Volume" volume tie.or.space.connect % gnp - changed to mixed case
-      series empty$
-        'skip$
-        { " of " * series emphasize * }
-      if$
-      "volume and number" number either.or.check
-    }
-  if$
-}
-
-FUNCTION {format.number.series}
-{ volume empty$
-    { number empty$
-    { series field.or.null }
-    { output.state mid.sentence =
-        { "Number" } % gnp - changed to mixed case always
-        { "Number" }
-      if$
-      number tie.or.space.connect
-      series empty$
-        { "there's a number but no series in " cite$ * warning$ }
-        { " in " * series * }
-      if$
-    }
-      if$
-    }
-    { "" }
-  if$
-}
-
-INTEGERS { multiresult }
-
-FUNCTION {multi.page.check}
-{ 't :=
-  #0 'multiresult :=
-    { multiresult not
-      t empty$ not
-      and
-    }
-    { t #1 #1 substring$
-      duplicate$ "-" =
-      swap$ duplicate$ "," =
-      swap$ "+" =
-      or or
-    { #1 'multiresult := }
-    { t #2 global.max$ substring$ 't := }
-      if$
-    }
-  while$
-  multiresult
-}
-
-FUNCTION {format.pages}
-{ pages empty$
-  { "" }
-  { pages multi.page.check
-	{ "pp.\ " pages n.dashify tie.or.space.connect } % gnp - removed ()
-	{ "pp.\ " pages tie.or.space.connect }
-    if$
-  }
-  if$
-}
-
-% By Young (and Spencer)
-% GNP - fixed bugs with missing volume, number, and/or pages
-%
-% Format journal, volume, number, pages for article types.
-%
-FUNCTION {format.jour.vol}
-{ fjournal empty$
-    { journal empty$
-	{ "no journal in " cite$ * warning$
-	  "" }
-	{ journal emphasize.space }
-	if$
-    } 
-    { fjournal emphasize.space }
-    if$
-  number empty$
-    { volume empty$
-       { "no number and no volume in " cite$ * warning$
-         "" * }
-       { "~{\em " * Volume * "}" * }
-      if$
-    }
-    { volume empty$
-      {"no volume for " cite$ * warning$
-       "~(" * number * ")" * }
-      { "~" *
-        volume emphasize.space
-        "(" * number * ")" * * }
-      if$
-    }
-  if$
-  pages empty$
-    {"page numbers missing in " cite$ * warning$
-     "" * } % gnp - place a null string on the stack for output
-    { duplicate$ empty$
-      { pop$ format.pages }
-      { ", " *  pages n.dashify * } % gnp - removed pp. for articles
-      if$
-    }
-  if$
-}
-
-FUNCTION {format.chapter.pages}
-{ chapter empty$
-    'format.pages
-    { type empty$
-        { "Chapter" } % gnp - changed to mixed case
-        { type "t" change.case$ }
-      if$
-      chapter tie.or.space.connect
-      pages empty$
-        {"page numbers missing in " cite$ * warning$} % gnp - added check
-        { ", " * format.pages * }
-      if$
-    }
-  if$
-}
-
-FUNCTION {format.in.ed.booktitle}
-{ booktitle empty$
-  { "" }
-  { editor empty$
-    { "In " format.emphasize.booktitle * }
-    { "In " format.editors.fml * ", " * format.emphasize.booktitle * }
-    if$
-  }
-  if$
-}
-
-FUNCTION {format.thesis.type}
-{ type empty$
-    'skip$
-    { pop$
-      type "t" change.case$
-    }
-  if$
-}
-
-FUNCTION {format.tr.number}
-{ type empty$
-    { "Technical Report" }
-    'type
-  if$
-  number empty$
-    { "t" change.case$ }
-    { number tie.or.space.connect }
-  if$
-}
-
-FUNCTION {format.article.crossref}
-{ "See"
-  "\citeN{" * crossref * "}" *
-}
-
-FUNCTION {format.crossref.editor}
-{ editor #1 "{vv~}{ll}" format.name$
-  editor num.names$ duplicate$
-  #2 >
-    { pop$ " et~al." * }
-    { #2 <
-    'skip$
-    { editor #2 "{ff }{vv }{ll}{ jj}" format.name$ "others" =
-        { " et~al." * }
-        { " and " * editor #2 "{vv~}{ll}" format.name$ * }
-      if$
-    }
-      if$
-    }
-  if$
-}
-
-FUNCTION {format.book.crossref}
-{ volume empty$
-    { "empty volume in " cite$ * "'s crossref of " * crossref * warning$
-      "In "
-    }
-    { "Volume" volume tie.or.space.connect % gnp - changed to mixed case
-      " of " *
-    }
-  if$
-  editor empty$
-  editor field.or.null author field.or.null =
-  or
-    { key empty$
-    { series empty$
-        { "need editor, key, or series for " cite$ * " to crossref " *
-          crossref * warning$
-          "" *
-        }
-        { "{\em " * series * "\/}" * }
-      if$
-    }
-    { key * }
-      if$
-    }
-    { format.crossref.editor * }
-  if$
-  " \citeN{" * crossref * "}" *
-}
-
-FUNCTION {format.incoll.inproc.crossref}
-{ "See"
-  " \citeN{" * crossref * "}" *
-}
-
-% format.lab.names:
-%
-% determines "short" names for the abbreviated author information.
-% "Long" labels are created in calc.label, using the routine my.full.label
-% to format author and editor fields.
-%
-% There are 4 cases for labels.   (n=3 in the example)
-% a) one author             Foo
-% b) one to n               Foo, Bar and Baz
-% c) use of "and others"    Foo, Bar et al.
-% d) more than n            Foo et al.
-%
-FUNCTION {format.lab.names}
-{ 's :=
-  s num.names$ 'numnames :=
-  numnames #2 >    % change number to number of others allowed before
-		   % forcing "et al".
-    { s #1 "{vv~}{ll}" format.name$ 
-      "\protect \index {" * 
-      s #1 "{vv~}{ll}{, jj}{, f.}" format.name$ *
-      "}" *
-	"\protect\chicagoetal/" * }
-    {
-      numnames #1 - 'namesleft :=
-      #2 'nameptr :=
-      s #1 "{vv~}{ll}" format.name$
-      "\protect \index {" * 
-      s #1 "{vv~}{ll}{, jj}{, f.}" format.name$ *
-      "}" *
-	{ namesleft #0 > }
-	{ nameptr numnames =
-	    { s nameptr "{ff }{vv }{ll}{ jj}" format.name$ "others" =
-		{ "\protect\chicagoetal/" * }
-		{ "\protect\chicagoand/" * s nameptr "{vv~}{ll}" format.name$ * 
-		  "\protect \index {" * 
-		  s nameptr "{vv~}{ll}{, jj}{, f.}" format.name$ *
-		  "}" *
-                }
-	      if$
-	    }
-	    { ", " * s nameptr "{vv~}{ll}" format.name$ * }
-	  if$
-	  nameptr #1 + 'nameptr :=
-	  namesleft #1 - 'namesleft :=
-	}
-      while$
-    }
-  if$
-}
-
-FUNCTION {author.key.label}
-{ author empty$
-    { key empty$
-          { "no key, author in " cite$ * warning$
-            cite$ #1 #3 substring$ }
-         'key
-      if$
-    }
-    { author format.lab.names }
-  if$
-}
-
-FUNCTION {editor.key.label}
-{ editor empty$
-    { key empty$
-          { "no key, editor in " cite$ * warning$
-            cite$ #1 #3 substring$ }
-          'key
-        if$
-     }
-     { editor format.lab.names }
-  if$
-}
-
-FUNCTION {author.key.organization.label}
-%
-% added - gnp. Provide label formatting by organization if author is null.
-%
-{ author empty$
-    { organization empty$
-	{ key empty$
-	    { "no key, author or organization in " cite$ * warning$
-              cite$ #1 #3 substring$ }
-	    'key
-	  if$
-	}
-        { organization }
-      if$
-    }
-    { author format.lab.names }
-  if$
-}
-
-FUNCTION {editor.key.organization.label}
-%
-% added - gnp. Provide label formatting by organization if editor is null.
-%
-{ editor empty$
-    { organization empty$
-	{ key empty$
-	    { "no key, editor or organization in " cite$ * warning$
-              cite$ #1 #3 substring$ }
-	    'key
-	  if$
-	}
-        { organization }
-      if$
-    }
-    { editor format.lab.names }
-  if$
-}
-
-FUNCTION {author.editor.key.label}
-{ author empty$
-    { editor empty$
-          { key empty$
-               { "no key, author, or editor in " cite$ * warning$
-                 cite$ #1 #3 substring$ }
-             'key
-           if$
-         }
-          { editor format.lab.names }
-      if$
-    }
-    { author format.lab.names }
-  if$
-}
-
-FUNCTION {calc.label.orig}
-%
-% Changed - GNP. See also author.organization.sort, editor.organization.sort
-% Form label for BibTeX entry. The classification of which fields are used
-% for which type of entry (book, inbook, etc.) are taken from alpha.bst.
-% The change here from newapa is to also include organization as a
-% citation label if author or editor is missing.
-%
-{ type$ "book" =
-  type$ "inbook" =
-  or
-    'author.editor.key.label
-    { type$ "proceedings" =
-	'editor.key.organization.label
-	{ type$ "manual" =
-	    'author.key.organization.label
-	    'author.key.label
-	  if$
-	}
-      if$
-    }
-  if$
-
-  author empty$  % generate the full label citation information.
-    { editor empty$
-        { organization empty$
-           { "no author, editor, or organization in " cite$ * warning$
-             "??" }
-           { organization }
-           if$
-        }
-        { editor my.full.label }
-        if$
-    }
-    { author.key.label }
-  if$
-
-% leave label on the stack, to be popped when required.
-
-  "}{" * swap$ *
-%  year field.or.null purify$ #-1 #4 substring$ *
-%
-% save the year for sort processing afterwards (adding a, b, c, etc.)
-%
-  year field.or.null purify$ #-1 #4 substring$
-  'label.year :=
-}
-
-FUNCTION {calc.label}
-%
-% Changed - GNP. See also author.organization.sort, editor.organization.sort
-% Form label for BibTeX entry. The classification of which fields are used
-% for which type of entry (book, inbook, etc.) are taken from alpha.bst.
-% The change here from newapa is to also include organization as a
-% citation label if author or editor is missing.
-%
-{ type$ "book" =
-  type$ "inbook" =
-  or
-    'author.editor.key.label
-    { type$ "proceedings" =
-	'editor.key.organization.label
-	{ type$ "manual" =
-	    'author.key.organization.label
-	    'author.key.label
-	  if$
-	}
-      if$
-    }
-  if$
-
-  author empty$  % generate the full label citation information.
-    { editor empty$
-        { organization empty$
-           { "no author, editor, or organization in " cite$ * warning$
-             "??" }
-           { organization }
-           if$
-        }
-        { editor my.full.label }
-        if$
-    }
-    { author my.full.label }
-  if$
-
-% leave label on the stack, to be popped when required.
-
-  "}{" * swap$ * "}{" * title * "}{" *
-%  year field.or.null purify$ #-1 #4 substring$ *
-%
-% save the year for sort processing afterwards (adding a, b, c, etc.)
-%
-  year field.or.null purify$ #-1 #4 substring$
-  'label.year :=
-}
-
-FUNCTION {output.bibitem}
-{ newline$
-
-  "\bibitem\protect\citeauthortitleyear{" write$
-  calc.label write$
-  sort.year write$
-  "}{" write$
-
-  cite$ write$
-  "}" write$
-  newline$
-  ""
-  before.all 'output.state :=
-}
-
-FUNCTION {article}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output          % added
-  output.year.check                 % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  crossref missing$
-    { format.jour.vol output
-    }
-    { format.article.crossref output.nonnull
-      format.pages output
-    }
-  if$
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {book}
-{ output.bibitem
-  author empty$
-    { format.editors
-	  "author and editor" output.check }
-    { format.authors
-	  output.nonnull
-      crossref missing$
-    	{ "author and editor" editor either.or.check }
-    	'skip$
-      if$
-    }
-  if$
-  output.year.check       % added
-  new.block
-  format.btitle
-  "title" output.check
-  crossref missing$
-    { format.bvolume output
-      new.block
-      format.number.series output
-      new.sentence
-      address output
-      publisher "publisher" output.check.colon
-    }
-    { new.block
-      format.book.crossref output.nonnull
-    }
-  if$
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {booklet}
-{ output.bibitem
-  format.authors output
-  author format.key output          % added
-  output.year.check                 % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  howpublished output
-  address output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {inbook}
-{ output.bibitem
-  author empty$
-    { format.editors
-      "author and editor" output.check
-    }
-    { format.authors output.nonnull
-      crossref missing$
-    { "author and editor" editor either.or.check }
-    'skip$
-      if$
-    }
-  if$
-  output.year.check                 % added
-  new.block
-  format.btitle
-  "title" output.check
-  crossref missing$
-    { format.bvolume output
-      format.chapter.pages
-      "chapter and pages" output.check
-      new.block
-      format.number.series output
-      new.sentence
-      address output
-      publisher
-      "publisher" output.check.colon
-    }
-    { format.chapter.pages "chapter and pages" output.check
-      new.block
-      format.book.crossref output.nonnull
-    }
-  if$
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {incollection}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output       % added
-  output.year.check              % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  crossref missing$
-  { format.in.ed.booktitle
-    "booktitle" output.check
-    format.bvolume output
-    format.number.series output
-    format.chapter.pages output % gnp - was special.output.nonnull
-%                                 left out comma before page numbers
-    new.sentence
-    address output
-    publisher "publisher" output.check.colon
-  }
-  { format.incoll.inproc.crossref
-	output.nonnull
-    format.chapter.pages output
-  }
-  if$
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {inproceedings}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output            % added
-  output.year.check                   % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  crossref missing$
-    { format.in.ed.booktitle
-	  "booktitle" output.check
-      format.bvolume output
-      format.number.series output
-      address output
-      format.pages output
-      new.sentence
-      organization output
-      publisher output.colon
-      }
-    { format.incoll.inproc.crossref output.nonnull
-      format.pages output
-    }
-  if$
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {conference} { inproceedings }
-
-FUNCTION {manual}
-{ output.bibitem
-  author empty$
-    { editor empty$
-      { organization "organization" output.check
-        organization format.key output }  % if all else fails, use key
-      { format.editors "author and editor" output.check }
-      if$
-    }
-    { format.authors output.nonnull }
-    if$
-  output.year.check                 % added
-  new.block
-  format.btitle
-  "title" output.check
-  organization address new.block.checkb
-% Reversed the order of "address" and "organization", added the ":".
-  address output
-  organization "organization" output.check.colon
-%  address output
-%  ":" output
-%  organization output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {mastersthesis}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output          % added
-  output.year.check                 % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  "Master's thesis" format.thesis.type output.nonnull
-  school "school" output.check
-  address output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {misc}
-{ output.bibitem
-  format.authors output
-  author format.key output            % added
-  output.year.check                   % added
-  title howpublished new.block.checkb
-  format.title output
-  new.block
-  howpublished output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {phdthesis}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output            % added
-  output.year.check                   % added
-  new.block
-  format.btitle
-  "title" output.check
-  new.block
-  "Ph.\ D. thesis" format.thesis.type output.nonnull
-  school "school" output.check
-  address output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {proceedings}
-{ output.bibitem
-  editor empty$
-    { organization output
-      organization format.key output }  % gnp - changed from author format.key
-    { format.editors output.nonnull }
-  if$
-% author format.key output             % gnp - removed (should be either
-%                                        editor or organization
-  output.year.check                    % added (newapa)
-  new.block
-  format.btitle
-  "title" output.check
-  format.bvolume output
-  format.number.series output
-  address output
-  new.sentence
-  organization output
-  publisher output.colon
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {techreport}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output             % added
-  output.year.check                    % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  format.tr.number output.nonnull
-  institution
-  "institution" output.check
-  address output
-  new.block
-  note output
-  fin.entry
-}
-
-FUNCTION {unpublished}
-{ output.bibitem
-  format.authors
-  "author" output.check
-  author format.key output              % added
-  output.year.check                      % added
-  new.block
-  format.title
-  "title" output.check
-  new.block
-  note "note" output.check
-  fin.entry
-}
-
-FUNCTION {default.type} { misc }
-
-MACRO {jan} {"January"}
-
-MACRO {feb} {"February"}
-
-MACRO {mar} {"March"}
-
-MACRO {apr} {"April"}
-
-MACRO {may} {"May"}
-
-MACRO {jun} {"June"}
-
-MACRO {jul} {"July"}
-
-MACRO {aug} {"August"}
-
-MACRO {sep} {"September"}
-
-MACRO {oct} {"October"}
-
-MACRO {nov} {"November"}
-
-MACRO {dec} {"December"}
-
-MACRO {acmcs} {"ACM Computing Surveys"}
-
-MACRO {acta} {"Acta Informatica"}
-
-MACRO {ai} {"Artificial Intelligence"}
-
-MACRO {cacm} {"Communications of the ACM"}
-
-MACRO {ibmjrd} {"IBM Journal of Research and Development"}
-
-MACRO {ibmsj} {"IBM Systems Journal"}
-
-MACRO {ieeese} {"IEEE Transactions on Software Engineering"}
-
-MACRO {ieeetc} {"IEEE Transactions on Computers"}
-
-MACRO {ieeetcad}
- {"IEEE Transactions on Computer-Aided Design of Integrated Circuits"}
-
-MACRO {ipl} {"Information Processing Letters"}
-
-MACRO {jacm} {"Journal of the ACM"}
-
-MACRO {jcss} {"Journal of Computer and System Sciences"}
-
-MACRO {scp} {"Science of Computer Programming"}
-
-MACRO {sicomp} {"SIAM Journal on Computing"}
-
-MACRO {tocs} {"ACM Transactions on Computer Systems"}
-
-MACRO {tods} {"ACM Transactions on Database Systems"}
-
-MACRO {tog} {"ACM Transactions on Graphics"}
-
-MACRO {toms} {"ACM Transactions on Mathematical Software"}
-
-MACRO {toois} {"ACM Transactions on Office Information Systems"}
-
-MACRO {toplas} {"ACM Transactions on Programming Languages and Systems"}
-
-MACRO {tcs} {"Theoretical Computer Science"}
-
-READ
-
-FUNCTION {sortify}
-{ purify$
-  "l" change.case$
-}
-
-INTEGERS { len }
-
-FUNCTION {chop.word}
-{ 's :=
-  'len :=
-  s #1 len substring$ =
-    { s len #1 + global.max$ substring$ }
-    's
-  if$
-}
-
-
-
-FUNCTION {sort.format.names}
-{ 's :=
-  #1 'nameptr :=
-  ""
-  s num.names$ 'numnames :=
-  numnames 'namesleft :=
-    { namesleft #0 > }
-    { nameptr #2 =
-	{ year field.or.null purify$ #-1 #4 substring$ * }
-	'skip$
-      if$
-      nameptr #1 >
-          { "   " * }
-         'skip$
-      if$
-      s nameptr "{vv{ } }{ll{ }}{  f{ }}{  jj{ }}" format.name$ 't :=
-      nameptr numnames = t "others" = and
-          { " et~al" * }
-          { t sortify * }
-      if$
-      nameptr #1 + 'nameptr :=
-      namesleft #1 - 'namesleft :=
-    }
-  while$
-}
-
-FUNCTION {sort.format.title}
-{ 't :=
-  "A " #2
-    "An " #3
-      "The " #4 t chop.word
-    chop.word
-  chop.word
-  sortify
-  #1 global.max$ substring$
-}
-
-FUNCTION {author.sort}
-{ author empty$
-    { key empty$
-         { "to sort, need author or key in " cite$ * warning$
-           "" }
-         { key sortify }
-      if$
-    }
-    { author sort.format.names }
-  if$
-}
-
-FUNCTION {editor.sort}
-{ editor empty$
-    { key empty$
-         { "to sort, need editor or key in " cite$ * warning$
-           ""
-         }
-         { key sortify }
-      if$
-    }
-    { editor sort.format.names }
-  if$
-}
-
-FUNCTION {author.editor.sort}
-{ author empty$
-    { "missing author in " cite$ * warning$
-      editor empty$
-         { key empty$
-             { "to sort, need author, editor, or key in " cite$ * warning$
-               ""
-             }
-             { key sortify }
-           if$
-         }
-         { editor sort.format.names }
-      if$
-    }
-    { author sort.format.names }
-  if$
-}
-
-FUNCTION {author.organization.sort}
-%
-% added - GNP. Stack author or organization for sorting (from alpha.bst).
-% Unlike alpha.bst, we need entire names, not abbreviations
-%
-{ author empty$
-    { organization empty$
-	{ key empty$
-	    { "to sort, need author, organization, or key in " cite$ * warning$
-	      ""
-	    }
-	    { key sortify }
-	  if$
-	}
-	{ organization sortify }
-      if$
-    }
-    { author sort.format.names }
-  if$
-}
-
-FUNCTION {editor.organization.sort}
-%
-% added - GNP. Stack editor or organization for sorting (from alpha.bst).
-% Unlike alpha.bst, we need entire names, not abbreviations
-%
-{ editor empty$
-    { organization empty$
-	{ key empty$
-	    { "to sort, need editor, organization, or key in " cite$ * warning$
-	      ""
-	    }
-	    { key sortify }
-	  if$
-	}
-	{ organization sortify }
-      if$
-    }
-    { editor sort.format.names }
-  if$
-}
-
-FUNCTION {presort}
-%
-% Presort creates the bibentry's label via a call to calc.label, and then
-% sorts the entries based on entry type. Chicago.bst adds support for
-% including organizations as the sort key; the following is stolen from
-% alpha.bst.
-%
-{ %calc.label sortify % recalculate bibitem label
-  %year field.or.null purify$ #-1 #4 substring$ * % add year
-  %duplicate$ warning$
-  %"    "
-  %*
-  type$ "book" =
-  type$ "inbook" =
-  or
-    'author.editor.sort
-    { type$ "proceedings" =
-	'editor.organization.sort
-	{ type$ "manual" =
-	    'author.organization.sort
-	    'author.sort
-	  if$
-	}
-      if$
-    }
-  if$
-  #1 entry.max$ substring$        % added for newapa
-  'sort.label :=                  % added for newapa
-  sort.label                      % added for newapa
-  %*
-  "    "
-  *
-  title field.or.null
-  sort.format.title
-  *
-  #1 entry.max$ substring$
-  'sort.key$ :=
-}
-
-ITERATE {presort}
-
-SORT             % by label, year, author/editor, title
-
-STRINGS { last.label next.extra }
-
-INTEGERS { last.extra.num }
-
-FUNCTION {initialize.extra.label.stuff}
-{ #0 int.to.chr$ 'last.label :=
-  "" 'next.extra :=
-  #0 'last.extra.num :=
-}
-
-FUNCTION {forward.pass}
-%
-% Pass through all entries, comparing current entry to last one.
-% Need to concatenate year to the stack (done by calc.label) to determine
-% if two entries are the same (see presort)
-%
-{ last.label
-  calc.label.orig year field.or.null purify$ #-1 #4 substring$ * % add year
-  #1 entry.max$ substring$ =     % are they equal?
-     { last.extra.num #1 + 'last.extra.num :=
-       last.extra.num int.to.chr$ 'extra.label :=
-     }
-     { "a" chr.to.int$ 'last.extra.num :=
-       "" 'extra.label :=
-       calc.label.orig year field.or.null purify$ #-1 #4 substring$ * % add year
-       #1 entry.max$ substring$ 'last.label := % assign to last.label
-     }
-  if$
-}
-
-FUNCTION {reverse.pass}
-{ next.extra "b" =
-    { "a" 'extra.label := }
-     'skip$
-  if$
-  label.year extra.label * 'sort.year :=
-  extra.label 'next.extra :=
-}
-
-EXECUTE {initialize.extra.label.stuff}
-
-ITERATE {forward.pass}
-
-REVERSE {reverse.pass}
-
-FUNCTION {bib.sort.order}
-{ sort.label
-  "    "
-  *
-  year field.or.null sortify
-  *
-  "    "
-  *
-  title field.or.null
-  sort.format.title
-  *
-  #1 entry.max$ substring$
-  'sort.key$ :=
-}
-
-ITERATE {bib.sort.order}
-
-SORT             % by sort.label, year, title --- giving final bib. order.
-
-FUNCTION {begin.bib}
-
-{ preamble$ empty$
-    'skip$
-    { preamble$ write$ newline$ }
-  if$
-  "\begin{thebibliography}{}" write$ newline$
-}
-
-
-EXECUTE {begin.bib}
-
-EXECUTE {init.state.consts}
-
-ITERATE {call.type$}
-
-FUNCTION {end.bib}
-{ newline$
-  "\end{thebibliography}" write$ newline$
-}
-
-EXECUTE {end.bib}
-

_service:tar_scm:isl-0.14.tar.xz/doc/chicago.sty Deleted

@@ -1,320 +0,0 @@
-% -*- LaTeX -*-
-%%% ====================================================================
-%%%  @LaTeX-style-file{
-%%%     author          = "Glenn Paulley",
-%%%     version         = "4",
-%%%     date            = "31 August 1992",
-%%%     time            = "09:42:44 199",
-%%%     filename        = "chicago.sty",
-%%%     address         = "Data Structuring Group
-%%%                        Department of Computer Science
-%%%                        University of Waterloo
-%%%                        Waterloo, Ontario, Canada
-%%%                        N2L 3G1",
-%%%     telephone       = "(519) 885-1211",
-%%%     FAX             = "(519) 885-1208",
-%%%     checksum        = "44674 264 1050 10394",
-%%%     email           = "gnpaulle@bluebox.uwaterloo.ca",
-%%%     codetable       = "ISO/ASCII",
-%%%     keywords        = "",
-%%%     supported       = "yes",
-%%%     abstract        = "Contains the LaTeX style command definitions
-%%%                        for the Chicago BibTeX styles chicago.bst and
-%%%                        chicagoa.bst. For details, see below.",
-%%%     docstring       = "The checksum field above contains a CRC-16
-%%%                        checksum as the first value, followed by the
-%%%                        equivalent of the standard UNIX wc (word
-%%%                        count) utility output of lines, words, and
-%%%                        characters.  This is produced by Robert
-%%%                        Solovay's checksum utility.",
-%%%  }
-%%% ====================================================================
-%
-% chicago.sty: Style file for use with bibtex style chicago.bst, for
-% bibliographies formatted according to the 13th Edition of the Chicago
-% Manual of Style.
-%
-% 'newapa.bst' was made from 'plain.bst', 'named.bst', and 'apalike.bst',
-% with lots of tweaking to make it look like APA style, along with tips
-% from Young Ryu and Brian Reiser's modifications of 'apalike.bst'.
-% newapa.sty formed the basis of this style, chicago.sty. Author-date
-% references in newapa.bst formed the basis for chicago.bst. Chicagoa.bst
-% supports annotations.
-%
-% Version 4 (August, 1992):
-% - fixed chicago.bst and chicagoa.bst to handle long author lists in
-%   sorting
-% - fixed chicago.bst and chicagoa.bst so that missing page numbers in
-%   ``article'' entries are handled correctly
-% - modified chicago.sty to format entries with 2nd and subsequent lines
-%   indented.
-%
-%   Citation format: (author-last-name year)
-%             (author-last-name and author-last-name year)
-%             (author-last-name et al. year)
-%             (author-last-name)
-%             author-last-name
-%             author-last-name (year)
-%             (author-last-name and author-last-name)
-%             (author-last-name et al.)
-%             (year) or (year,year)
-%             year or year,year
-%
-%   Reference list ordering: alphabetical by author or whatever passes
-%    for author in the absence of one.
-%
-% This BibTeX style has support for abbreviated author lists and for
-%    year-only citations.  This is done by having the citations
-%    actually look like
-%
-%    \citeauthoryear{full-author-info}{abbrev-author-info}{year}
-%
-% The LaTeX style has to have the following (or similar)
-%
-%     \let\@internalcite\cite
-%     \def\fullcite{\def\citeauthoryear##1##2##3{##1, ##3}\@internalcite}
-%     \def\fullciteA{\def\citeauthoryear##1##2##3{##1}\@internalcite}
-%     \def\shortcite{\def\citeauthoryear##1##2##3{##2, ##3}\@internalcite}
-%     \def\shortciteA{\def\citeauthoryear##1##2##3{##2}\@internalcite}
-%     \def\citeyear{\def\citeauthoryear##1##2##3{##3}\@internalcite}
-%
-% -------------------------------------------------------------------------
-% This file implements citations for the ``chicago'' bibliography style.
-%  Place it in a file called chicago.sty in the TeX search path.
-%(Placing it in the same directory as the LaTeX document should also work.)
-%
-%    This file is a modification of the ``newapa'' LaTeX style,
-%    originally adapted by Steven Spencer from the ``apalike'' LaTeX style.
-%    It was originally modified by Stephen N. Spencer, with further
-%    modifications by Young U. Ryu.
-%
-% The ``chicago'' BibTeX bibliography style creates citations with labels:
-%       \citeauthoryear{author-info}{abbrev. author-info}{year}
-%
-% These labels are processed by the following LaTeX commands:
-%
-%  \cite{key}
-%    which produces citations with full author list and year.
-%    eg. (Brown 1978; Jarke, Turner, Stohl, et al. 1985)
-%  \citeNP{key}
-%    which produces citations with full author list and year, but without
-%    enclosing parentheses:
-%    eg. Brown 1978; Jarke, Turner and Stohl 1985
-%  \citeA{key}
-%    which produces citations with only the full author list.
-%    eg. (Brown; Jarke, Turner and Stohl)
-%  \citeANP{key}
-%    which produces citations with only the full author list, without
-%    parentheses eg. Brown; Jarke, Turner and Stohl
-%  \citeN{key}
-%    which produces citations with the full author list and year, but
-%    can be used as nouns in a sentence; no parentheses appear around
-%    the author names, but only around the year.
-%      eg. Shneiderman (1978) states that......
-%    \citeN should only be used for a single citation.
-%  \shortcite{key}
-%    which produces citations with abbreviated author list and year.
-%  \shortciteNP{key}
-%    which produces citations with abbreviated author list and year.
-%  \shortciteA{key}
-%    which produces only the abbreviated author list.
-%  \shortciteANP{key}
-%    which produces only the abbreviated author list.
-%  \shortciteN{key}
-%    which produces the abbreviated author list and year, with only the
-%    year in parentheses. Use with only one citation.
-%  \citeyear{key}
-%    which produces the year information only, within parentheses.
-%  \citeyearNP{key}
-%    which produces the year information only.
-%
-% Abbreviated author lists use the ``et al.'' construct.
-%
-% `NP' means `no parentheses'.
-%
-% This LaTeX style file must be used with the ``chicago'' or ``chicagoa''
-% (annotated chicago style) BibTeX styles.
-%
-\typeout{Using Chicago Manual of Style bibliography: 31 August 1992}
-%
-% -------------------------------------------------------------------------
-%
-% Citation macros.
-%
-\def\chicagoand/{ and }
-\def\chicagoetal/{ et~al.}
-%
-\let\@internalcite\cite
-%
-\def\cite{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{(##1\if@tempswa , ##2\fi)}%
-    \def\citeauthortitleyear##1##2##3##4{##1\ ##4}\@internalcite}
-\def\citeNP{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##1\ ##4}\@internalcite}
-\def\citetitleN{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2)\else{)}\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##3\ (##1; ##4}\@citedata}
-\def\citeN{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2)\else{)}\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##1\ (##4}\@citedata}
-\def\citeA{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{(##1\if@tempswa , ##2\fi)}%
-    \def\citeauthortitleyear##1##2##3##4{##1}\@internalcite}
-\def\citeANP{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##1}\@internalcite}
-%
-\def\shortcite{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{(##1\if@tempswa , ##2\fi)}%
-    \def\citeauthortitleyear##1##2##3##4{##2\ ##4}\@internalcite}
-\def\shortciteNP{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##2\ ##4}\@internalcite}
-\def\shortciteN{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2)\else{)}\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##2\ (##4}\@citedata}
-\def\shortciteA{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{(##1\if@tempswa , ##2\fi)}%
-    \def\citeauthortitleyear##1##2##3##4{##2}\@internalcite}
-\def\shortciteANP{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##2}\@internalcite}
-%
-\def\citeyear{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{(##1\if@tempswa , ##2\fi)}%
-    \def\citeauthortitleyear##1##2##3##4{##4}\@citedata}
-\def\citeyearNP{\def\@citeseppen{-1000}%
-    \def\@cite##1##2{##1\if@tempswa , ##2\fi}%
-    \def\citeauthortitleyear##1##2##3##4{##4}\@citedata}
-
-%
-% \@citedata and \@citedatax:
-%
-% Place commas in-between citations in the same \citeyear, \citeyearNP,
-% \citeN, or \shortciteN command.
-% Use something like \citeN{ref1,ref2,ref3} and \citeN{ref4} for a list.
-%
-\def\@citedata{%
-	\@ifnextchar {\@tempswatrue\@citedatax}%
-				  {\@tempswafalse\@citedatax}%
-}
-
-\def\@citedatax#1#2{%
-\if@filesw\immediate\write\@auxout{\string\citation{#2}}\fi%
-  \def\@citea{}\@cite{\@for\@citeb:=#2\do%
-    {\@citea\def\@citea{), }\@ifundefined% by Young
-       {b@\@citeb}{{\bf ?}%
-       \@warning{Citation `\@citeb' on page \thepage \space undefined}}%
-{\csname b@\@citeb\endcsname}}}{#1}}%
-
-\@ifpackageloaded{hyperref}{%
-  \let\BRorg@citedatax\@citedatax 
-  \def\@citedatax#1#2{%
-    \BRorg@citedatax#1{#2}%
-    \Hy@backout{#2}%
-  }%
-}{}
-\@ifpackageloaded{hyperref}{%
-\def\hyperemph#1{{\em\hyperpage{#1}}}%
-\def\bold#1{{\bf\hyperpage{#1}}}%
-}{%
-\def\hyperemph#1{{\em #1}}%
-\def\bold#1{{\bf #1}}%
-}
-
-\def\BR@@lbibitem#1#2#3\par{%
-  \BRorg@bibitem#1{#2}#3\hfill\penalty100\hbox{}
-  \newblock
-  \backref\hfill{\csname br@#2\endcsname}%
-  \parskip=-10pt\penalty-10000\hbox{}\nobreak\par
-}%
-\def\BR@@bibitem#1#2\par{%
-  \BRorg@bibitem{#1}#2
-  \newblock
-  \backref\penalty-100\hbox{}\nobreak\hfill\hbox{\csname br@#2\endcsname}%
-  \par
-}
-\def\thepageorcolor{\thepage}
-\def\Hy@backout#1{%
-  \@bsphack
-  \ifx\@empty\@currentlabel
-    \protected@write\@auxout{}{%
-      \string\@writefile{brf}{%
-        \string\backcite{#1}{{\thepageorcolor}{(document)}{Doc-Start}}%
-      }%
-    }%
-  \else
-   \protected@write\@auxout{}{%
-     \string\@writefile{brf}{%
-       \string\backcite{#1}{{\thepageorcolor}{\@currentlabel}{\@currentHref}}%
-     }%
-   }%
-  \fi
-  \@esphack
-}
-
-% don't box citations, separate with ; and a space
-% also, make the penalty between citations negative: a good place to break.
-%
-\def\@citex#1#2{%
-\if@filesw\immediate\write\@auxout{\string\citation{#2}}\fi%
-  \def\@citea{}\@cite{\@for\@citeb:=#2\do%
-    {\@citea\def\@citea{; }\@ifundefined% by Young
-       {b@\@citeb}{{\bf ?}%
-       \@warning{Citation `\@citeb' on page \thepage \space undefined}}%
-{\csname b@\@citeb\endcsname}}}{#1}}%
-
-% (from apalike.sty)
-% No labels in the bibliography.
-%
-\def\@biblabel#1{}
-
-% (from apalike.sty)
-% Set length of hanging indentation for bibliography entries.
-%
-\newlength{\bibhang}
-\setlength{\bibhang}{2em}
-
-% Indent second and subsequent lines of bibliographic entries. Stolen
-% from openbib.sty: \newblock is set to {}.
-
-\newdimen\bibindent
-\bibindent=1.5em
-\@ifundefined{refname}%
-   {\@ifundefined{chapter}%
-     {\newcommand{\refname}{References}}%
-     {\newcommand{\refname}{Bibliography}}%
-   }%
-   {}%
-\@ifundefined{chapter}%
- {\def\thebibliography#1{\section*{\refname\@mkboth
-   {\uppercase{\refname}}{\uppercase{\refname}}}
-   \addcontentsline{toc}{section}{References}
-   \list
-   {\arabic{enumi}}{\settowidth\labelwidth{#1}
-   \leftmargin\labelwidth
-   \advance\leftmargin\labelsep
-   \advance\leftmargin\bibindent
-   \itemindent -\bibindent
-   \listparindent \itemindent
-   \parsep \z@
-   \usecounter{enumi}}
-   \def\newblock{}
-   \sloppy
-   \sfcode`\.=1000\relax}}
- {\def\thebibliography#1{\chapter*{\refname\@mkboth
-   {\refname}{\refname}}
-   \addcontentsline{toc}{chapter}{References}
-   \list
-   {\arabic{enumi}}{\settowidth\labelwidth{#1}
-   \leftmargin\labelwidth
-   \advance\leftmargin\labelsep
-   \advance\leftmargin\bibindent
-   \itemindent -\bibindent
-   \listparindent \itemindent
-   \parsep \z@
-   \usecounter{enumi}}
-   \def\newblock{}
-   \sloppy
-   \sfcode`\.=1000\relax}}

_service:tar_scm:isl-0.14.tar.xz/include/isl/band.h Deleted

@@ -1,56 +0,0 @@
-#ifndef ISL_BAND_H
-#define ISL_BAND_H
-
-#include <isl/printer.h>
-#include <isl/list.h>
-#include <isl/union_map_type.h>
-#include <isl/vec.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-struct isl_band;
-typedef struct isl_band isl_band;
-
-ISL_DECLARE_LIST(band)
-
-__isl_give isl_band *isl_band_copy(__isl_keep isl_band *band);
-__isl_null isl_band *isl_band_free(__isl_take isl_band *band);
-
-isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
-
-int isl_band_has_children(__isl_keep isl_band *band);
-__isl_give isl_band_list *isl_band_get_children(
-	__isl_keep isl_band *band);
-
-__isl_give isl_union_map *isl_band_get_prefix_schedule(
-	__isl_keep isl_band *band);
-__isl_give isl_union_map *isl_band_get_partial_schedule(
-	__isl_keep isl_band *band);
-__isl_give isl_union_map *isl_band_get_suffix_schedule(
-	__isl_keep isl_band *band);
-
-int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx, int val);
-int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
-int isl_options_set_tile_shift_point_loops(isl_ctx *ctx, int val);
-int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
-
-int isl_band_tile(__isl_keep isl_band *band, __isl_take isl_vec *sizes);
-int isl_band_split(__isl_keep isl_band *band, int pos);
-
-int isl_band_n_member(__isl_keep isl_band *band);
-int isl_band_member_is_coincident(__isl_keep isl_band *band, int pos);
-
-int isl_band_list_foreach_band(__isl_keep isl_band_list *list,
-	int (*fn)(__isl_keep isl_band *band, void *user), void *user);
-
-__isl_give isl_printer *isl_printer_print_band(__isl_take isl_printer *p,
-	__isl_keep isl_band *band);
-void isl_band_dump(__isl_keep isl_band *band);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/aff_int.h Deleted

@@ -1,45 +0,0 @@
-#ifndef ISL_DEPRECATED_AFF_INT_H
-#define ISL_DEPRECATED_AFF_INT_H
-
-#include <isl/deprecated/int.h>
-#include <isl/aff_type.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-int isl_aff_get_constant(__isl_keep isl_aff *aff, isl_int *v);
-int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
-	enum isl_dim_type type, int pos, isl_int *v);
-int isl_aff_get_denominator(__isl_keep isl_aff *aff, isl_int *v);
-__isl_give isl_aff *isl_aff_set_constant(__isl_take isl_aff *aff, isl_int v);
-__isl_give isl_aff *isl_aff_set_coefficient(__isl_take isl_aff *aff,
-	enum isl_dim_type type, int pos, isl_int v);
-__isl_give isl_aff *isl_aff_set_denominator(__isl_take isl_aff *aff, isl_int v);
-__isl_give isl_aff *isl_aff_add_constant(__isl_take isl_aff *aff, isl_int v);
-__isl_give isl_aff *isl_aff_add_constant_num(__isl_take isl_aff *aff,
-	isl_int v);
-__isl_give isl_aff *isl_aff_add_coefficient(__isl_take isl_aff *aff,
-	enum isl_dim_type type, int pos, isl_int v);
-
-__isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff, isl_int mod);
-
-__isl_give isl_aff *isl_aff_scale(__isl_take isl_aff *aff, isl_int f);
-__isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff, isl_int f);
-
-__isl_give isl_pw_aff *isl_pw_aff_mod(__isl_take isl_pw_aff *pwaff,
-	isl_int mod);
-
-__isl_give isl_pw_aff *isl_pw_aff_scale(__isl_take isl_pw_aff *pwaff,
-	isl_int f);
-__isl_give isl_pw_aff *isl_pw_aff_scale_down(__isl_take isl_pw_aff *pwaff,
-	isl_int f);
-
-__isl_give isl_multi_aff *isl_multi_aff_scale(__isl_take isl_multi_aff *maff,
-	isl_int f);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/ast_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/constraint_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/ilp_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/int.h Deleted

@@ -1,136 +0,0 @@
-/*
- * Copyright 2008-2009 Katholieke Universiteit Leuven
- *
- * Use of this software is governed by the MIT license
- *
- * Written by Sven Verdoolaege, K.U.Leuven, Departement
- * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
- */
-
-#ifndef ISL_DEPRECATED_INT_H
-#define ISL_DEPRECATED_INT_H
-
-#include <isl/hash.h>
-#include <string.h>
-#include <gmp.h>
-#if defined(__cplusplus)
-#include <iostream>
-#endif
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#ifndef mp_get_memory_functions
-void mp_get_memory_functions(
-		void *(**alloc_func_ptr) (size_t),
-		void *(**realloc_func_ptr) (void *, size_t, size_t),
-		void (**free_func_ptr) (void *, size_t));
-#endif
-
-/* isl_int is the basic integer type.  It currently always corresponds
- * to a gmp mpz_t, but in the future, different types such as long long
- * or cln::cl_I will be supported.
- */
-typedef mpz_t	isl_int;
-
-#define isl_int_init(i)		mpz_init(i)
-#define isl_int_clear(i)	mpz_clear(i)
-
-#define isl_int_set(r,i)	mpz_set(r,i)
-#define isl_int_set_gmp(r,i)	mpz_set(r,i)
-#define isl_int_set_si(r,i)	mpz_set_si(r,i)
-#define isl_int_set_ui(r,i)	mpz_set_ui(r,i)
-#define isl_int_get_gmp(i,g)	mpz_set(g,i)
-#define isl_int_get_si(r)	mpz_get_si(r)
-#define isl_int_get_ui(r)	mpz_get_ui(r)
-#define isl_int_get_d(r)	mpz_get_d(r)
-#define isl_int_get_str(r)	mpz_get_str(0, 10, r)
-typedef void (*isl_int_print_gmp_free_t)(void *, size_t);
-#define isl_int_free_str(s)					\
-	do {								\
-		isl_int_print_gmp_free_t gmp_free;			\
-		mp_get_memory_functions(NULL, NULL, &gmp_free);		\
-		(*gmp_free)(s, strlen(s) + 1);				\
-	} while (0)
-#define isl_int_abs(r,i)	mpz_abs(r,i)
-#define isl_int_neg(r,i)	mpz_neg(r,i)
-#define isl_int_swap(i,j)	mpz_swap(i,j)
-#define isl_int_swap_or_set(i,j)	mpz_swap(i,j)
-#define isl_int_add_ui(r,i,j)	mpz_add_ui(r,i,j)
-#define isl_int_sub_ui(r,i,j)	mpz_sub_ui(r,i,j)
-
-#define isl_int_add(r,i,j)	mpz_add(r,i,j)
-#define isl_int_sub(r,i,j)	mpz_sub(r,i,j)
-#define isl_int_mul(r,i,j)	mpz_mul(r,i,j)
-#define isl_int_mul_2exp(r,i,j)	mpz_mul_2exp(r,i,j)
-#define isl_int_mul_ui(r,i,j)	mpz_mul_ui(r,i,j)
-#define isl_int_pow_ui(r,i,j)	mpz_pow_ui(r,i,j)
-#define isl_int_addmul(r,i,j)	mpz_addmul(r,i,j)
-#define isl_int_submul(r,i,j)	mpz_submul(r,i,j)
-
-#define isl_int_gcd(r,i,j)	mpz_gcd(r,i,j)
-#define isl_int_lcm(r,i,j)	mpz_lcm(r,i,j)
-#define isl_int_divexact(r,i,j)	mpz_divexact(r,i,j)
-#define isl_int_divexact_ui(r,i,j)	mpz_divexact_ui(r,i,j)
-#define isl_int_tdiv_q(r,i,j)	mpz_tdiv_q(r,i,j)
-#define isl_int_cdiv_q(r,i,j)	mpz_cdiv_q(r,i,j)
-#define isl_int_fdiv_q(r,i,j)	mpz_fdiv_q(r,i,j)
-#define isl_int_fdiv_r(r,i,j)	mpz_fdiv_r(r,i,j)
-#define isl_int_fdiv_q_ui(r,i,j)	mpz_fdiv_q_ui(r,i,j)
-
-#define isl_int_read(r,s)	mpz_set_str(r,s,10)
-#define isl_int_print(out,i,width)					\
-	do {								\
-		char *s;						\
-		s = mpz_get_str(0, 10, i);				\
-		fprintf(out, "%*s", width, s);				\
-		isl_int_free_str(s);                                        \
-	} while (0)
-
-#define isl_int_sgn(i)		mpz_sgn(i)
-#define isl_int_cmp(i,j)	mpz_cmp(i,j)
-#define isl_int_cmp_si(i,si)	mpz_cmp_si(i,si)
-#define isl_int_eq(i,j)		(mpz_cmp(i,j) == 0)
-#define isl_int_ne(i,j)		(mpz_cmp(i,j) != 0)
-#define isl_int_lt(i,j)		(mpz_cmp(i,j) < 0)
-#define isl_int_le(i,j)		(mpz_cmp(i,j) <= 0)
-#define isl_int_gt(i,j)		(mpz_cmp(i,j) > 0)
-#define isl_int_ge(i,j)		(mpz_cmp(i,j) >= 0)
-#define isl_int_abs_eq(i,j)	(mpz_cmpabs(i,j) == 0)
-#define isl_int_abs_ne(i,j)	(mpz_cmpabs(i,j) != 0)
-#define isl_int_abs_lt(i,j)	(mpz_cmpabs(i,j) < 0)
-#define isl_int_abs_gt(i,j)	(mpz_cmpabs(i,j) > 0)
-#define isl_int_abs_ge(i,j)	(mpz_cmpabs(i,j) >= 0)
-
-
-#define isl_int_is_zero(i)	(isl_int_sgn(i) == 0)
-#define isl_int_is_one(i)	(isl_int_cmp_si(i,1) == 0)
-#define isl_int_is_negone(i)	(isl_int_cmp_si(i,-1) == 0)
-#define isl_int_is_pos(i)	(isl_int_sgn(i) > 0)
-#define isl_int_is_neg(i)	(isl_int_sgn(i) < 0)
-#define isl_int_is_nonpos(i)	(isl_int_sgn(i) <= 0)
-#define isl_int_is_nonneg(i)	(isl_int_sgn(i) >= 0)
-#define isl_int_is_divisible_by(i,j)	mpz_divisible_p(i,j)
-
-uint32_t isl_gmp_hash(mpz_t v, uint32_t hash);
-#define isl_int_hash(v,h)	isl_gmp_hash(v,h)
-
-#if defined(__cplusplus)
-}
-#endif
-
-#if defined(__cplusplus)
-extern "C" { typedef void (*isl_gmp_free_t)(void *, size_t); }
-
-static inline std::ostream &operator<<(std::ostream &os, isl_int i)
-{
-	char *s;
-	s = mpz_get_str(0, 10, i);
-	os << s;
-	isl_int_free_str(s);
-	return os;
-}
-#endif
-
-#endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/map_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/mat_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/point_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/polynomial_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/set_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/union_map_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/val_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/deprecated/vec_int.h Deleted

_service:tar_scm:isl-0.14.tar.xz/include/isl/dim.h Deleted

@@ -1,174 +0,0 @@
-#ifndef ISL_DIM_H
-#define ISL_DIM_H
-
-#include <isl/space.h>
-#include <isl/local_space.h>
-#include <isl/aff_type.h>
-#include <isl/constraint.h>
-#include <isl/map_type.h>
-#include <isl/set_type.h>
-#include <isl/point.h>
-#include <isl/union_map.h>
-#include <isl/union_set.h>
-#include <isl/polynomial_type.h>
-
-#if defined(__cplusplus)
-extern "C" {
-#endif
-
-#define isl_dim isl_space
-
-ISL_DEPRECATED
-isl_ctx *isl_dim_get_ctx(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_alloc(isl_ctx *ctx,
-			unsigned nparam, unsigned n_in, unsigned n_out);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_alloc(isl_ctx *ctx,
-			unsigned nparam, unsigned dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_copy(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-void isl_dim_free(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-unsigned isl_dim_size(__isl_keep isl_space *dim, enum isl_dim_type type);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_dim_id(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
-ISL_DEPRECATED
-int isl_dim_has_dim_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos);
-ISL_DEPRECATED
-__isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos);
-
-ISL_DEPRECATED
-int isl_dim_find_dim_by_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, __isl_keep isl_id *id);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_tuple_id(__isl_take isl_space *dim,
-	enum isl_dim_type type, __isl_take isl_id *id);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_reset_tuple_id(__isl_take isl_space *dim,
-	enum isl_dim_type type);
-ISL_DEPRECATED
-int isl_dim_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type);
-ISL_DEPRECATED
-__isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_name(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, __isl_keep const char *name);
-ISL_DEPRECATED
-__isl_keep const char *isl_dim_get_name(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_set_tuple_name(__isl_take isl_space *dim,
-	enum isl_dim_type type, const char *s);
-ISL_DEPRECATED
-const char *isl_dim_get_tuple_name(__isl_keep isl_space *dim,
-				 enum isl_dim_type type);
-
-ISL_DEPRECATED
-int isl_dim_is_wrapping(__isl_keep isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_wrap(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_unwrap(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_domain(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_from_domain(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_range(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_from_range(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_reverse(__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_join(__isl_take isl_space *left,
-	__isl_take isl_space *right);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_align_params(__isl_take isl_space *dim1,
-	__isl_take isl_space *dim2);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_insert(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_add(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_drop(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned first, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_move(__isl_take isl_space *dim,
-	enum isl_dim_type dst_type, unsigned dst_pos,
-	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_map_from_set(
-	__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_dim_zip(__isl_take isl_space *dim);
-
-ISL_DEPRECATED
-__isl_give isl_local_space *isl_local_space_from_dim(
-	__isl_take isl_space *dim);
-ISL_DEPRECATED
-__isl_give isl_space *isl_local_space_get_dim(
-	__isl_keep isl_local_space *ls);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_aff_get_dim(__isl_keep isl_aff *aff);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_aff_get_dim(__isl_keep isl_pw_aff *pwaff);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_constraint_get_dim(
-	__isl_keep isl_constraint *constraint);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_basic_map_get_dim(__isl_keep isl_basic_map *bmap);
-ISL_DEPRECATED
-__isl_give isl_space *isl_map_get_dim(__isl_keep isl_map *map);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_map_get_dim(__isl_keep isl_union_map *umap);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_basic_set_get_dim(__isl_keep isl_basic_set *bset);
-ISL_DEPRECATED
-__isl_give isl_space *isl_set_get_dim(__isl_keep isl_set *set);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_set_get_dim(__isl_keep isl_union_set *uset);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_point_get_dim(__isl_keep isl_point *pnt);
-
-ISL_DEPRECATED
-__isl_give isl_space *isl_qpolynomial_get_dim(__isl_keep isl_qpolynomial *qp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_qpolynomial_get_dim(
-	__isl_keep isl_pw_qpolynomial *pwqp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_qpolynomial_fold_get_dim(
-	__isl_keep isl_qpolynomial_fold *fold);
-ISL_DEPRECATED
-__isl_give isl_space *isl_pw_qpolynomial_fold_get_dim(
-	__isl_keep isl_pw_qpolynomial_fold *pwf);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_pw_qpolynomial_get_dim(
-	__isl_keep isl_union_pw_qpolynomial *upwqp);
-ISL_DEPRECATED
-__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_dim(
-	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
-
-#if defined(__cplusplus)
-}
-#endif
-
-#endif

_service:tar_scm:isl-0.14.tar.xz/interface/all.h Deleted

_service:tar_scm:isl-0.14.tar.xz/interface/isl.py.top Deleted

_service:tar_scm:isl-0.14.tar.xz/isl.py Deleted

@@ -1,100 +0,0 @@
-import gdb
-import re
-
-# GDB Pretty Printers for most isl objects
-class IslObjectPrinter:
-	"""Print an isl object"""
-	def __init__ (self, val, type):
-                self.val = val
-                self.type = type
-
-	def to_string (self):
-                # Cast val to a void pointer to stop gdb using this pretty
-                # printer for the pointer which would lead to an infinite loop.
-                void_ptr = gdb.lookup_type('void').pointer()
-                value = str(self.val.cast(void_ptr))
-                printer = gdb.parse_and_eval("isl_printer_to_str(isl_"
-                                             + str(self.type)
-					     + "_get_ctx(" + value + "))")
-                printer = gdb.parse_and_eval("isl_printer_print_"
-                                             + str(self.type) + "("
-                                             + str(printer) + ", "
-                                             + value + ")")
-                string = gdb.parse_and_eval("(char*)isl_printer_get_str("
-                                            + str(printer) + ")")
-                gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
-                return string
-
-	def display_hint (self):
-                return 'string'
-
-class IslIntPrinter:
-	"""Print an isl_int """
-	def __init__ (self, val):
-                self.val = val
-
-	def to_string (self):
-                # Cast val to a void pointer to stop gdb using this pretty
-                # printer for the pointer which would lead to an infinite loop.
-                void_ptr = gdb.lookup_type('void').pointer()
-                value = str(self.val.cast(void_ptr))
-
-                context = gdb.parse_and_eval("isl_ctx_alloc()")
-                printer = gdb.parse_and_eval("isl_printer_to_str("
-                                             + str(context) + ")")
-                printer = gdb.parse_and_eval("isl_printer_print_isl_int("
-                                             + str(printer) + ", "
-                                             + value + ")")
-                string = gdb.parse_and_eval("(char*)isl_printer_get_str("
-                                            + str(printer) + ")")
-                gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
-                gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")")
-                return string
-
-	def display_hint (self):
-                return 'string'
-
-class IslPrintCommand (gdb.Command):
-        """Print an isl value."""
-        def __init__ (self):
-                super (IslPrintCommand, self).__init__ ("islprint",
-                                                        gdb.COMMAND_OBSCURE)
-        def invoke (self, arg, from_tty):
-                arg = gdb.parse_and_eval(arg);
-                printer = str_lookup_function(arg)
-
-                if printer == None:
-                        print "No isl printer for this type"
-                        return
-
-                print printer.to_string()
-
-IslPrintCommand()
-
-def str_lookup_function (val):
-	if val.type.code != gdb.TYPE_CODE_PTR:
-		if str(val.type) == "isl_int":
-			return IslIntPrinter(val)
-                else:
-                        return None
-
-	lookup_tag = val.type.target()
-	regex = re.compile ("^isl_(.*)$")
-
-	if lookup_tag == None:
-		return None
-
-	m = regex.match (str(lookup_tag))
-
-	if m:
-                # Those types of printers defined in isl.
-                if m.group(1) in "basic_set", "set", "union_set", "basic_map",
-                                  "map", "union_map", "qpolynomial",
-                                  "pw_qpolynomial", "pw_qpolynomial_fold",
-                                  "union_pw_qpolynomial",
-                                  "union_pw_qpolynomial_fold":
-                        return IslObjectPrinter(val, m.group(1))
-        return None
-
-# Do not register the pretty printer.
-# gdb.current_objfile().pretty_printers.append(str_lookup_function)

_service:tar_scm:isl-0.14.tar.xz/isl_ast_int.c Deleted

_service:tar_scm:isl-0.14.tar.xz/isl_band.c Deleted

@@ -1,726 +0,0 @@
-/*
- * Copyright 2011      INRIA Saclay
- * Copyright 2012-2013 Ecole Normale Superieure
- *
- * Use of this software is governed by the MIT license
- *
- * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
- * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
- * 91893 Orsay, France
- * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
- */
-
-#include <isl_band_private.h>
-#include <isl_schedule_private.h>
-
-#undef BASE
-#define BASE band
-
-#include <isl_list_templ.c>
-
-isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band)
-{
-	return band ? isl_union_pw_multi_aff_get_ctx(band->pma) : NULL;
-}
-
-__isl_give isl_band *isl_band_alloc(isl_ctx *ctx)
-{
-	isl_band *band;
-
-	band = isl_calloc_type(ctx, isl_band);
-	if (!band)
-		return NULL;
-
-	band->ref = 1;
-
-	return band;
-}
-
-/* Create a duplicate of the given band.  The duplicate refers
- * to the same schedule and parent as the input, but does not
- * increment their reference counts.
- */
-__isl_give isl_band *isl_band_dup(__isl_keep isl_band *band)
-{
-	int i;
-	isl_ctx *ctx;
-	isl_band *dup;
-
-	if (!band)
-		return NULL;
-
-	ctx = isl_band_get_ctx(band);
-	dup = isl_band_alloc(ctx);
-	if (!dup)
-		return NULL;
-
-	dup->n = band->n;
-	dup->coincident = isl_alloc_array(ctx, int, band->n);
-	if (band->n && !dup->coincident)
-		goto error;
-
-	for (i = 0; i < band->n; ++i)
-		dup->coincidenti = band->coincidenti;
-
-	dup->pma = isl_union_pw_multi_aff_copy(band->pma);
-	dup->schedule = band->schedule;
-	dup->parent = band->parent;
-
-	if (!dup->pma)
-		goto error;
-
-	return dup;
-error:
-	isl_band_free(dup);
-	return NULL;
-}
-
-/* We not only increment the reference count of the band,
- * but also that of the schedule that contains this band.
- * This ensures that the schedule won't disappear while there
- * is still a reference to the band outside of the schedule.
- * There is no need to increment the reference count of the parent
- * band as the parent band is part of the same schedule.
- */
-__isl_give isl_band *isl_band_copy(__isl_keep isl_band *band)
-{
-	if (!band)
-		return NULL;
-
-	band->ref++;
-	band->schedule->ref++;
-	return band;
-}
-
-/* If this is not the last reference to the band (the one from within the
- * schedule), then we also need to decrement the reference count of the
- * containing schedule as it was incremented in isl_band_copy.
- */
-__isl_null isl_band *isl_band_free(__isl_take isl_band *band)
-{
-	if (!band)
-		return NULL;
-
-	if (--band->ref > 0) {
-		isl_schedule_free(band->schedule);
-		return NULL;
-	}
-
-	isl_union_pw_multi_aff_free(band->pma);
-	isl_band_list_free(band->children);
-	free(band->coincident);
-	free(band);
-
-	return NULL;
-}
-
-int isl_band_has_children(__isl_keep isl_band *band)
-{
-	if (!band)
-		return -1;
-
-	return band->children != NULL;
-}
-
-__isl_give isl_band_list *isl_band_get_children(
-	__isl_keep isl_band *band)
-{
-	if (!band)
-		return NULL;
-	if (!band->children)
-		isl_die(isl_band_get_ctx(band), isl_error_invalid,
-			"band has no children", return NULL);
-	return isl_band_list_dup(band->children);
-}
-
-int isl_band_n_member(__isl_keep isl_band *band)
-{
-	return band ? band->n : 0;
-}
-
-/* Is the given scheduling dimension coincident within the band and
- * with respect to the coincidence constraints.
- */
-int isl_band_member_is_coincident(__isl_keep isl_band *band, int pos)
-{
-	if (!band)
-		return -1;
-
-	if (pos < 0 || pos >= band->n)
-		isl_die(isl_band_get_ctx(band), isl_error_invalid,
-			"invalid member position", return -1);
-
-	return band->coincidentpos;
-}
-
-/* Return the schedule that leads up to this band.
- */
-__isl_give isl_union_map *isl_band_get_prefix_schedule(
-	__isl_keep isl_band *band)
-{
-	isl_union_set *domain;
-	isl_union_pw_multi_aff *prefix;
-	isl_band *a;
-
-	if (!band)
-		return NULL;
-
-	prefix = isl_union_pw_multi_aff_copy(band->pma);
-	domain = isl_union_pw_multi_aff_domain(prefix);
-	prefix = isl_union_pw_multi_aff_from_domain(domain);
-
-	for (a = band->parent; a; a = a->parent) {
-		isl_union_pw_multi_aff *partial;
-
-		partial = isl_union_pw_multi_aff_copy(a->pma);
-		prefix = isl_union_pw_multi_aff_flat_range_product(partial,
-								   prefix);
-	}
-
-	return isl_union_map_from_union_pw_multi_aff(prefix);
-}
-
-/* Return the schedule of the band in isolation.
- */
-__isl_give isl_union_pw_multi_aff *
-isl_band_get_partial_schedule_union_pw_multi_aff(__isl_keep isl_band *band)
-{
-	return band ? isl_union_pw_multi_aff_copy(band->pma) : NULL;
-}
-
-/* Return the schedule of the band in isolation.
- */
-__isl_give isl_union_map *isl_band_get_partial_schedule(
-	__isl_keep isl_band *band)
-{
-	isl_union_pw_multi_aff *sched;
-
-	sched = isl_band_get_partial_schedule_union_pw_multi_aff(band);
-	return isl_union_map_from_union_pw_multi_aff(sched);
-}
-
-__isl_give isl_union_pw_multi_aff *
-isl_band_get_suffix_schedule_union_pw_multi_aff(__isl_keep isl_band *band);
-
-/* Return the schedule for the given band list.
- * For each band in the list, the schedule is composed of the partial
- * and suffix schedules of that band.
- */
-__isl_give isl_union_pw_multi_aff *
-isl_band_list_get_suffix_schedule_union_pw_multi_aff(
-	__isl_keep isl_band_list *list)
-{
-	isl_ctx *ctx;
-	int i, n;
-	isl_space *space;
-	isl_union_pw_multi_aff *suffix;
-
-	if (!list)
-		return NULL;
-
-	ctx = isl_band_list_get_ctx(list);
-	space = isl_space_alloc(ctx, 0, 0, 0);
-	suffix = isl_union_pw_multi_aff_empty(space);
-	n = isl_band_list_n_band(list);
-	for (i = 0; i < n; ++i) {
-		isl_band *el;
-		isl_union_pw_multi_aff *partial;
-		isl_union_pw_multi_aff *suffix_i;
-
-		el = isl_band_list_get_band(list, i);
-		partial = isl_band_get_partial_schedule_union_pw_multi_aff(el);
-		suffix_i = isl_band_get_suffix_schedule_union_pw_multi_aff(el);
-		suffix_i = isl_union_pw_multi_aff_flat_range_product(
-				partial, suffix_i);
-		suffix = isl_union_pw_multi_aff_add(suffix, suffix_i);
-
-		isl_band_free(el);
-	}
-
-	return suffix;
-}
-
-/* Return the schedule for the given band list.
- * For each band in the list, the schedule is composed of the partial
- * and suffix schedules of that band.
- */
-__isl_give isl_union_map *isl_band_list_get_suffix_schedule(
-	__isl_keep isl_band_list *list)
-{
-	isl_union_pw_multi_aff *suffix;
-
-	suffix = isl_band_list_get_suffix_schedule_union_pw_multi_aff(list);
-	return isl_union_map_from_union_pw_multi_aff(suffix);
-}
-
-/* Return the schedule for the forest underneath the given band.
- */
-__isl_give isl_union_pw_multi_aff *
-isl_band_get_suffix_schedule_union_pw_multi_aff(__isl_keep isl_band *band)
-{
-	isl_union_pw_multi_aff *suffix;
-
-	if (!band)
-		return NULL;
-
-	if (!isl_band_has_children(band)) {
-		isl_union_set *domain;
-
-		suffix = isl_union_pw_multi_aff_copy(band->pma);
-		domain = isl_union_pw_multi_aff_domain(suffix);
-		suffix = isl_union_pw_multi_aff_from_domain(domain);
-	} else {
-		isl_band_list *list;
-
-		list = isl_band_get_children(band);
-		suffix =
-		    isl_band_list_get_suffix_schedule_union_pw_multi_aff(list);
-		isl_band_list_free(list);
-	}
-
-	return suffix;
-}
-
-/* Return the schedule for the forest underneath the given band.
- */
-__isl_give isl_union_map *isl_band_get_suffix_schedule(
-	__isl_keep isl_band *band)
-{
-	isl_union_pw_multi_aff *suffix;
-
-	suffix = isl_band_get_suffix_schedule_union_pw_multi_aff(band);
-	return isl_union_map_from_union_pw_multi_aff(suffix);
-}
-
-/* Call "fn" on each band (recursively) in the list
- * in depth-first post-order.
- */
-int isl_band_list_foreach_band(__isl_keep isl_band_list *list,
-	int (*fn)(__isl_keep isl_band *band, void *user), void *user)
-{
-	int i, n;
-
-	if (!list)
-		return -1;
-
-	n = isl_band_list_n_band(list);
-	for (i = 0; i < n; ++i) {
-		isl_band *band;
-		int r = 0;
-
-		band = isl_band_list_get_band(list, i);
-		if (isl_band_has_children(band)) {
-			isl_band_list *children;
-
-			children = isl_band_get_children(band);
-			r = isl_band_list_foreach_band(children, fn, user);
-			isl_band_list_free(children);
-		}
-
-		if (!band)
-			r = -1;
-		if (r == 0)
-			r = fn(band, user);
-
-		isl_band_free(band);
-		if (r)
-			return r;
-	}
-
-	return 0;
-}
-
-/* Internal data used during the construction of the schedule
- * for the tile loops.
- *
- * sizes contains the tile sizes
- * scale is set if the tile loops should be scaled
- * tiled collects the result for a single statement
- * res collects the result for all statements
- */
-struct isl_band_tile_data {
-	isl_multi_val *sizes;
-	isl_union_pw_multi_aff *res;
-	isl_pw_multi_aff *tiled;
-	int scale;
-};
-
-/* Given part of the schedule of a band, construct the corresponding
- * schedule for the tile loops based on the tile sizes in data->sizes
- * and add the result to data->tiled.
- *
- * If data->scale is set, then dimension i of the schedule will be
- * of the form
- *
- *	m_i * floor(s_i(x) / m_i)
- *
- * where s_i(x) refers to the original schedule and m_i is the tile size.
- * If data->scale is not set, then dimension i of the schedule will be
- * of the form
- *
- *	floor(s_i(x) / m_i)
- *
- */
-static int multi_aff_tile(__isl_take isl_set *set,
-	__isl_take isl_multi_aff *ma, void *user)
-{
-	struct isl_band_tile_data *data = user;
-	isl_pw_multi_aff *pma;
-	int i, n;
-	isl_val *v;
-
-	n = isl_multi_aff_dim(ma, isl_dim_out);
-
-	for (i = 0; i < n; ++i) {
-		isl_aff *aff;
-
-		aff = isl_multi_aff_get_aff(ma, i);
-		v = isl_multi_val_get_val(data->sizes, i);
-
-		aff = isl_aff_scale_down_val(aff, isl_val_copy(v));
-		aff = isl_aff_floor(aff);
-		if (data->scale)
-			aff = isl_aff_scale_val(aff, isl_val_copy(v));
-		isl_val_free(v);
-
-		ma = isl_multi_aff_set_aff(ma, i, aff);
-	}
-
-	pma = isl_pw_multi_aff_alloc(set, ma);
-	data->tiled = isl_pw_multi_aff_union_add(data->tiled, pma);
-
-	return 0;
-}
-
-/* Given part of the schedule of a band, construct the corresponding
- * schedule for the tile loops based on the tile sizes in data->sizes
- * and add the result to data->res.
- */
-static int pw_multi_aff_tile(__isl_take isl_pw_multi_aff *pma, void *user)
-{
-	struct isl_band_tile_data *data = user;
-
-	data->tiled = isl_pw_multi_aff_empty(isl_pw_multi_aff_get_space(pma));
-
-	if (isl_pw_multi_aff_foreach_piece(pma, &multi_aff_tile, data) < 0)
-		goto error;
-
-	isl_pw_multi_aff_free(pma);
-	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res,
-								data->tiled);
-
-	return 0;
-error:
-	isl_pw_multi_aff_free(pma);
-	isl_pw_multi_aff_free(data->tiled);
-	return -1;
-}
-
-/* Given the schedule of a band, construct the corresponding
- * schedule for the tile loops based on the given tile sizes
- * and return the result.
- */
-static isl_union_pw_multi_aff *isl_union_pw_multi_aff_tile(
-	__isl_take isl_union_pw_multi_aff *sched,
-	__isl_keep isl_multi_val *sizes)
-{
-	isl_ctx *ctx;
-	isl_space *space;
-	struct isl_band_tile_data data = { sizes };
-
-	ctx = isl_multi_val_get_ctx(sizes);
-
-	space = isl_union_pw_multi_aff_get_space(sched);
-	data.res = isl_union_pw_multi_aff_empty(space);
-	data.scale = isl_options_get_tile_scale_tile_loops(ctx);
-
-	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(sched,
-						&pw_multi_aff_tile, &data) < 0)
-		goto error;
-
-	isl_union_pw_multi_aff_free(sched);
-	return data.res;
-error:
-	isl_union_pw_multi_aff_free(sched);
-	isl_union_pw_multi_aff_free(data.res);
-	return NULL;
-}
-
-/* Extract the range space from "pma" and store it in *user.
- * All entries are expected to have the same range space, so we can
- * stop after extracting the range space from the first entry.
- */
-static int extract_range_space(__isl_take isl_pw_multi_aff *pma, void *user)
-{
-	isl_space **space = user;
-
-	*space = isl_space_range(isl_pw_multi_aff_get_space(pma));
-	isl_pw_multi_aff_free(pma);
-
-	return -1;
-}
-
-/* Extract the range space of "band".  All entries in band->pma should
- * have the same range space.  Furthermore, band->pma should have at least
- * one entry.
- */
-static __isl_give isl_space *band_get_range_space(__isl_keep isl_band *band)
-{
-	isl_space *space;
-
-	if (!band)
-		return NULL;
-
-	space = NULL;
-	isl_union_pw_multi_aff_foreach_pw_multi_aff(band->pma,
-						&extract_range_space, &space);
-
-	return space;
-}
-
-/* Construct and return an isl_multi_val in the given space, with as entries
- * the first elements of "v", padded with ones if the size of "v" is smaller
- * than the dimension of "space".
- */
-static __isl_give isl_multi_val *multi_val_from_vec(__isl_take isl_space *space,
-	__isl_take isl_vec *v)
-{
-	isl_ctx *ctx;
-	isl_multi_val *mv;
-	int i, n, size;
-
-	if (!space || !v)
-		goto error;
-
-	ctx = isl_space_get_ctx(space);
-	mv = isl_multi_val_zero(space);
-	n = isl_multi_val_dim(mv, isl_dim_set);
-	size = isl_vec_size(v);
-	if (n < size)
-		size = n;
-
-	for (i = 0; i < size; ++i) {
-		isl_val *val = isl_vec_get_element_val(v, i);
-		mv = isl_multi_val_set_val(mv, i, val);
-	}
-	for (i = size; i < n; ++i)
-		mv = isl_multi_val_set_val(mv, i, isl_val_one(ctx));
-
-	isl_vec_free(v);
-	return mv;
-error:
-	isl_space_free(space);
-	isl_vec_free(v);
-	return NULL;
-}
-
-/* Tile the given band using the specified tile sizes.
- * The given band is modified to refer to the tile loops and
- * a child band is created to refer to the point loops.
- * The children of this point loop band are the children
- * of the original band.
- *
- * If the scale tile loops option is set, then the tile loops
- * are scaled by the tile sizes.  If the shift point loops option is set,
- * then the point loops are shifted to start at zero.
- * In particular, these options affect the tile and point loop schedules
- * as follows
- *
- *	scale	shift	original	tile		point
- *
- *	0	0	i		floor(i/s)	i
- *	1	0	i		s * floor(i/s)	i
- *	0	1	i		floor(i/s)	i - s * floor(i/s)
- *	1	1	i		s * floor(i/s)	i - s * floor(i/s)
- */
-int isl_band_tile(__isl_keep isl_band *band, __isl_take isl_vec *sizes)
-{
-	isl_ctx *ctx;
-	isl_band *child;
-	isl_band_list *list = NULL;
-	isl_union_pw_multi_aff *sched = NULL, *child_sched = NULL;
-	isl_space *space;
-	isl_multi_val *mv_sizes;
-
-	if (!band || !sizes)
-		goto error;
-
-	ctx = isl_vec_get_ctx(sizes);
-	child = isl_band_dup(band);
-	list = isl_band_list_alloc(ctx, 1);
-	list = isl_band_list_add(list, child);
-	if (!list)
-		goto error;
-
-	space = band_get_range_space(band);
-	mv_sizes = multi_val_from_vec(space, isl_vec_copy(sizes));
-	sched = isl_union_pw_multi_aff_copy(band->pma);
-	sched = isl_union_pw_multi_aff_tile(sched, mv_sizes);
-
-	child_sched = isl_union_pw_multi_aff_copy(child->pma);
-	if (isl_options_get_tile_shift_point_loops(ctx)) {
-		isl_union_pw_multi_aff *scaled;
-		scaled = isl_union_pw_multi_aff_copy(sched);
-		if (!isl_options_get_tile_scale_tile_loops(ctx))
-			scaled = isl_union_pw_multi_aff_scale_multi_val(scaled,
-						isl_multi_val_copy(mv_sizes));
-		child_sched = isl_union_pw_multi_aff_sub(child_sched, scaled);
-	}
-	isl_multi_val_free(mv_sizes);
-	if (!sched || !child_sched)
-		goto error;
-
-	child->children = band->children;
-	band->children = list;
-	child->parent = band;
-	isl_union_pw_multi_aff_free(band->pma);
-	band->pma = sched;
-	isl_union_pw_multi_aff_free(child->pma);
-	child->pma = child_sched;
-
-	isl_vec_free(sizes);
-	return 0;
-error:
-	isl_union_pw_multi_aff_free(sched);
-	isl_union_pw_multi_aff_free(child_sched);
-	isl_band_list_free(list);
-	isl_vec_free(sizes);
-	return -1;
-}
-
-/* Internal data structure used inside isl_union_pw_multi_aff_drop.
- *
- * "pos" is the position of the first dimension to drop.
- * "n" is the number of dimensions to drop.
- * "res" accumulates the result.
- */
-struct isl_union_pw_multi_aff_drop_data {
-	int pos;
-	int n;
-	isl_union_pw_multi_aff *res;
-};
-
-/* Drop the data->n output dimensions starting at data->pos from "pma"
- * and add the result to data->res.
- */
-static int pw_multi_aff_drop(__isl_take isl_pw_multi_aff *pma, void *user)
-{
-	struct isl_union_pw_multi_aff_drop_data *data = user;
-
-	pma = isl_pw_multi_aff_drop_dims(pma, isl_dim_out, data->pos, data->n);
-
-	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma);
-	if (!data->res)
-		return -1;
-
-	return 0;
-}
-
-/* Drop the "n" output dimensions starting at "pos" from "sched".
- */
-static isl_union_pw_multi_aff *isl_union_pw_multi_aff_drop(
-	__isl_take isl_union_pw_multi_aff *sched, int pos, int n)
-{
-	isl_space *space;
-	struct isl_union_pw_multi_aff_drop_data data = { pos, n };
-
-	space = isl_union_pw_multi_aff_get_space(sched);
-	data.res = isl_union_pw_multi_aff_empty(space);
-
-	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(sched,
-						&pw_multi_aff_drop, &data) < 0)
-		data.res = isl_union_pw_multi_aff_free(data.res);
-
-	isl_union_pw_multi_aff_free(sched);
-	return data.res;
-}
-
-/* Drop the "n" dimensions starting at "pos" from "band".
- */
-static int isl_band_drop(__isl_keep isl_band *band, int pos, int n)
-{
-	int i;
-	isl_union_pw_multi_aff *sched;
-
-	if (!band)
-		return -1;
-	if (n == 0)
-		return 0;
-
-	sched = isl_union_pw_multi_aff_copy(band->pma);
-	sched = isl_union_pw_multi_aff_drop(sched, pos, n);
-	if (!sched)
-		return -1;
-
-	isl_union_pw_multi_aff_free(band->pma);
-	band->pma = sched;
-
-	for (i = pos + n; i < band->n; ++i)
-		band->coincidenti - n = band->coincidenti;
-
-	band->n -= n;
-
-	return 0;
-}
-
-/* Split the given band into two nested bands, one with the first "pos"
- * dimensions of "band" and one with the remaining band->n - pos dimensions.
- */
-int isl_band_split(__isl_keep isl_band *band, int pos)
-{
-	isl_ctx *ctx;
-	isl_band *child;
-	isl_band_list *list;
-
-	if (!band)
-		return -1;
-
-	ctx = isl_band_get_ctx(band);
-
-	if (pos < 0 || pos > band->n)
-		isl_die(ctx, isl_error_invalid, "position out of bounds",
-			return -1);
-
-	child = isl_band_dup(band);
-	if (isl_band_drop(child, 0, pos) < 0)
-		child = isl_band_free(child);
-	list = isl_band_list_alloc(ctx, 1);
-	list = isl_band_list_add(list, child);
-	if (!list)
-		return -1;
-
-	if (isl_band_drop(band, pos, band->n - pos) < 0) {
-		isl_band_list_free(list);
-		return -1;
-	}
-
-	child->children = band->children;
-	band->children = list;
-	child->parent = band;
-
-	return 0;
-}
-
-__isl_give isl_printer *isl_printer_print_band(__isl_take isl_printer *p,
-	__isl_keep isl_band *band)
-{
-	isl_union_map *prefix, *partial, *suffix;
-
-	prefix = isl_band_get_prefix_schedule(band);
-	partial = isl_band_get_partial_schedule(band);
-	suffix = isl_band_get_suffix_schedule(band);
-
-	p = isl_printer_print_str(p, "(");
-	p = isl_printer_print_union_map(p, prefix);
-	p = isl_printer_print_str(p, ",");
-	p = isl_printer_print_union_map(p, partial);
-	p = isl_printer_print_str(p, ",");
-	p = isl_printer_print_union_map(p, suffix);
-	p = isl_printer_print_str(p, ")");
-
-	isl_union_map_free(prefix);
-	isl_union_map_free(partial);
-	isl_union_map_free(suffix);
-
-	return p;
-}

_service:tar_scm:isl-0.14.tar.xz/isl_band_private.h Deleted

@@ -1,47 +0,0 @@
-#ifndef ISL_BAND_PRIVATE_H
-#define ISL_BAND_PRIVATE_H
-
-#include <isl/aff.h>
-#include <isl/band.h>
-#include <isl/list.h>
-#include <isl/schedule.h>
-
-/* Information about a band within a schedule.
- *
- * n is the number of scheduling dimensions within the band.
- * coincident is an array of length n, indicating whether a scheduling dimension
- *	satisfies the coincidence constraints in the sense that
- *	the corresponding dependence distances are zero.
- * pma is the partial schedule corresponding to this band.
- * schedule is the schedule that contains this band.
- * parent is the parent of this band (or NULL if the band is a root).
- * children are the children of this band (or NULL if the band is a leaf).
- *
- * To avoid circular dependences in the reference counting,
- * the schedule and parent pointers are not reference counted.
- * isl_band_copy increments the reference count of schedule to ensure
- * that outside references to the band keep the schedule alive.
- */
-struct isl_band {
-	int ref;
-
-	int n;
-	int *coincident;
-
-	isl_union_pw_multi_aff *pma;
-	isl_schedule *schedule;
-	isl_band *parent;
-	isl_band_list *children;
-};
-
-#undef EL
-#define EL isl_band
-
-#include <isl_list_templ.h>
-
-__isl_give isl_band *isl_band_alloc(isl_ctx *ctx);
-
-__isl_give isl_union_map *isl_band_list_get_suffix_schedule(
-	__isl_keep isl_band_list *list);
-
-#endif

_service:tar_scm:isl-0.14.tar.xz/isl_dim.c Deleted

@@ -1,258 +0,0 @@
-#include <isl/dim.h>
-#include <isl/aff.h>
-#include <isl/map.h>
-#include <isl/set.h>
-#include <isl/polynomial.h>
-
-isl_ctx *isl_dim_get_ctx(__isl_keep isl_space *dim)
-{
-	return isl_space_get_ctx(dim);
-}
-
-__isl_give isl_space *isl_dim_alloc(isl_ctx *ctx,
-	unsigned nparam, unsigned n_in, unsigned n_out)
-{
-	return isl_space_alloc(ctx, nparam, n_in, n_out);
-}
-__isl_give isl_space *isl_dim_set_alloc(isl_ctx *ctx,
-	unsigned nparam, unsigned dim)
-{
-	return isl_space_set_alloc(ctx, nparam, dim);
-}
-__isl_give isl_space *isl_dim_copy(__isl_keep isl_space *dim)
-{
-	return isl_space_copy(dim);
-}
-void isl_dim_free(__isl_take isl_space *dim)
-{
-	isl_space_free(dim);
-}
-
-unsigned isl_dim_size(__isl_keep isl_space *dim, enum isl_dim_type type)
-{
-	return isl_space_dim(dim, type);
-}
-
-__isl_give isl_space *isl_dim_set_dim_id(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
-{
-	return isl_space_set_dim_id(dim, type, pos, id);
-}
-int isl_dim_has_dim_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos)
-{
-	return isl_space_has_dim_id(dim, type, pos);
-}
-__isl_give isl_id *isl_dim_get_dim_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos)
-{
-	return isl_space_get_dim_id(dim, type, pos);
-}
-
-int isl_dim_find_dim_by_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type, __isl_keep isl_id *id)
-{
-	return isl_space_find_dim_by_id(dim, type, id);
-}
-
-__isl_give isl_space *isl_dim_set_tuple_id(__isl_take isl_space *dim,
-	enum isl_dim_type type, __isl_take isl_id *id)
-{
-	return isl_space_set_tuple_id(dim, type, id);
-}
-__isl_give isl_space *isl_dim_reset_tuple_id(__isl_take isl_space *dim,
-	enum isl_dim_type type)
-{
-	return isl_space_reset_tuple_id(dim, type);
-}
-int isl_dim_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type)
-{
-	return isl_space_has_tuple_id(dim, type);
-}
-__isl_give isl_id *isl_dim_get_tuple_id(__isl_keep isl_space *dim,
-	enum isl_dim_type type)
-{
-	return isl_space_get_tuple_id(dim, type);
-}
-
-__isl_give isl_space *isl_dim_set_name(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, __isl_keep const char *name)
-{
-	return isl_space_set_dim_name(dim, type, pos, name);
-}
-__isl_keep const char *isl_dim_get_name(__isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned pos)
-{
-	return isl_space_get_dim_name(dim, type, pos);
-}
-
-__isl_give isl_space *isl_dim_set_tuple_name(__isl_take isl_space *dim,
-	enum isl_dim_type type, const char *s)
-{
-	return isl_space_set_tuple_name(dim, type, s);
-}
-const char *isl_dim_get_tuple_name(__isl_keep isl_space *dim,
-	enum isl_dim_type type)
-{
-	return isl_space_get_tuple_name(dim, type);
-}
-
-int isl_dim_is_wrapping(__isl_keep isl_space *dim)
-{
-	return isl_space_is_wrapping(dim);
-}
-__isl_give isl_space *isl_dim_wrap(__isl_take isl_space *dim)
-{
-	return isl_space_wrap(dim);
-}
-__isl_give isl_space *isl_dim_unwrap(__isl_take isl_space *dim)
-{
-	return isl_space_unwrap(dim);
-}
-
-__isl_give isl_space *isl_dim_domain(__isl_take isl_space *dim)
-{
-	return isl_space_domain(dim);
-}
-__isl_give isl_space *isl_dim_from_domain(__isl_take isl_space *dim)
-{
-	return isl_space_from_domain(dim);
-}
-__isl_give isl_space *isl_dim_range(__isl_take isl_space *dim)
-{
-	return isl_space_range(dim);
-}
-__isl_give isl_space *isl_dim_from_range(__isl_take isl_space *dim)
-{
-	return isl_space_from_range(dim);
-}
-__isl_give isl_space *isl_dim_reverse(__isl_take isl_space *dim)
-{
-	return isl_space_reverse(dim);
-}
-__isl_give isl_space *isl_dim_join(__isl_take isl_space *left,
-	__isl_take isl_space *right)
-{
-	return isl_space_join(left, right);
-}
-__isl_give isl_space *isl_dim_align_params(__isl_take isl_space *dim1,
-	__isl_take isl_space *dim2)
-{
-	return isl_space_align_params(dim1, dim2);
-}
-__isl_give isl_space *isl_dim_insert(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos, unsigned n)
-{
-	return isl_space_insert_dims(dim, type, pos, n);
-}
-__isl_give isl_space *isl_dim_add(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned n)
-{
-	return isl_space_add_dims(dim, type, n);
-}
-__isl_give isl_space *isl_dim_drop(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return isl_space_drop_dims(dim, type, first, n);
-}
-__isl_give isl_space *isl_dim_move(__isl_take isl_space *dim,
-	enum isl_dim_type dst_type, unsigned dst_pos,
-	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
-{
-	return isl_space_move_dims(dim, dst_type, dst_pos, src_type, src_pos, n);
-}
-__isl_give isl_space *isl_dim_map_from_set(__isl_take isl_space *dim)
-{
-	return isl_space_map_from_set(dim);
-}
-__isl_give isl_space *isl_dim_zip(__isl_take isl_space *dim)
-{
-	return isl_space_zip(dim);
-}
-
-__isl_give isl_local_space *isl_local_space_from_dim(
-	__isl_take isl_space *dim)
-{
-	return isl_local_space_from_space(dim);
-}
-__isl_give isl_space *isl_local_space_get_dim(
-	__isl_keep isl_local_space *ls)
-{
-	return isl_local_space_get_space(ls);
-}
-
-__isl_give isl_space *isl_aff_get_dim(__isl_keep isl_aff *aff)
-{
-	return isl_aff_get_space(aff);
-}
-__isl_give isl_space *isl_pw_aff_get_dim(__isl_keep isl_pw_aff *pwaff)
-{
-	return isl_pw_aff_get_space(pwaff);
-}
-
-__isl_give isl_space *isl_constraint_get_dim(
-	__isl_keep isl_constraint *constraint)
-{
-	return isl_constraint_get_space(constraint);
-}
-
-__isl_give isl_space *isl_basic_map_get_dim(__isl_keep isl_basic_map *bmap)
-{
-	return isl_basic_map_get_space(bmap);
-}
-__isl_give isl_space *isl_map_get_dim(__isl_keep isl_map *map)
-{
-	return isl_map_get_space(map);
-}
-__isl_give isl_space *isl_union_map_get_dim(__isl_keep isl_union_map *umap)
-{
-	return isl_union_map_get_space(umap);
-}
-
-__isl_give isl_space *isl_basic_set_get_dim(__isl_keep isl_basic_set *bset)
-{
-	return isl_basic_set_get_space(bset);
-}
-__isl_give isl_space *isl_set_get_dim(__isl_keep isl_set *set)
-{
-	return isl_set_get_space(set);
-}
-__isl_give isl_space *isl_union_set_get_dim(__isl_keep isl_union_set *uset)
-{
-	return isl_union_set_get_space(uset);
-}
-
-__isl_give isl_space *isl_point_get_dim(__isl_keep isl_point *pnt)
-{
-	return isl_point_get_space(pnt);
-}
-
-__isl_give isl_space *isl_qpolynomial_get_dim(__isl_keep isl_qpolynomial *qp)
-{
-	return isl_qpolynomial_get_space(qp);
-}
-__isl_give isl_space *isl_pw_qpolynomial_get_dim(
-	__isl_keep isl_pw_qpolynomial *pwqp)
-{
-	return isl_pw_qpolynomial_get_space(pwqp);
-}
-__isl_give isl_space *isl_qpolynomial_fold_get_dim(
-	__isl_keep isl_qpolynomial_fold *fold)
-{
-	return isl_qpolynomial_fold_get_space(fold);
-}
-__isl_give isl_space *isl_pw_qpolynomial_fold_get_dim(
-	__isl_keep isl_pw_qpolynomial_fold *pwf)
-{
-	return isl_pw_qpolynomial_fold_get_space(pwf);
-}
-__isl_give isl_space *isl_union_pw_qpolynomial_get_dim(
-	__isl_keep isl_union_pw_qpolynomial *upwqp)
-{
-	return isl_union_pw_qpolynomial_get_space(upwqp);
-}
-__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_dim(
-	__isl_keep isl_union_pw_qpolynomial_fold *upwf)
-{
-	return isl_union_pw_qpolynomial_fold_get_space(upwf);
-}

_service:tar_scm:isl-0.14.tar.xz/isl_hide_deprecated.h Deleted

@@ -1,53 +0,0 @@
-#define isl_aff_get_constant	isl_gmp_aff_get_constant
-#define isl_aff_get_coefficient	isl_gmp_aff_get_coefficient
-#define isl_aff_get_denominator	isl_gmp_aff_get_denominator
-#define isl_aff_set_constant	isl_gmp_aff_set_constant
-#define isl_aff_set_coefficient	isl_gmp_aff_set_coefficient
-#define isl_aff_set_denominator	isl_gmp_aff_set_denominator
-#define isl_aff_add_constant	isl_gmp_aff_add_constant
-#define isl_aff_add_constant_num	isl_gmp_aff_add_constant_num
-#define isl_aff_add_coefficient	isl_gmp_aff_add_coefficient
-#define isl_aff_mod	isl_gmp_aff_mod
-#define isl_aff_scale	isl_gmp_aff_scale
-#define isl_aff_scale_down	isl_gmp_aff_scale_down
-#define isl_pw_aff_mod	isl_gmp_pw_aff_mod
-#define isl_pw_aff_scale	isl_gmp_pw_aff_scale
-#define isl_pw_aff_scale_down	isl_gmp_pw_aff_scale_down
-#define isl_multi_aff_scale	isl_gmp_multi_aff_scale
-#define isl_ast_expr_get_int	isl_gmp_ast_expr_get_int
-#define isl_constraint_get_constant	isl_gmp_constraint_get_constant
-#define isl_constraint_get_coefficient	isl_gmp_constraint_get_coefficient
-#define isl_constraint_set_constant	isl_gmp_constraint_set_constant
-#define isl_constraint_set_coefficient	isl_gmp_constraint_set_coefficient
-#define isl_basic_set_max	isl_gmp_basic_set_max
-#define isl_set_min	isl_gmp_set_min
-#define isl_set_max	isl_gmp_set_max
-#define isl_gmp_hash	isl_gmp_gmp_hash
-#define isl_basic_map_plain_is_fixed	isl_gmp_basic_map_plain_is_fixed
-#define isl_map_fix	isl_gmp_map_fix
-#define isl_map_plain_is_fixed	isl_gmp_map_plain_is_fixed
-#define isl_map_fast_is_fixed	isl_gmp_map_fast_is_fixed
-#define isl_map_fixed_power	isl_gmp_map_fixed_power
-#define isl_mat_get_element	isl_gmp_mat_get_element
-#define isl_mat_set_element	isl_gmp_mat_set_element
-#define isl_point_get_coordinate	isl_gmp_point_get_coordinate
-#define isl_point_set_coordinate	isl_gmp_point_set_coordinate
-#define isl_qpolynomial_rat_cst_on_domain	isl_gmp_qpolynomial_rat_cst_on_domain
-#define isl_qpolynomial_is_cst	isl_gmp_qpolynomial_is_cst
-#define isl_qpolynomial_scale	isl_gmp_qpolynomial_scale
-#define isl_term_get_num	isl_gmp_term_get_num
-#define isl_term_get_den	isl_gmp_term_get_den
-#define isl_qpolynomial_fold_scale	isl_gmp_qpolynomial_fold_scale
-#define isl_pw_qpolynomial_fold_fix_dim	isl_gmp_pw_qpolynomial_fold_fix_dim
-#define isl_basic_set_fix	isl_gmp_basic_set_fix
-#define isl_set_lower_bound	isl_gmp_set_lower_bound
-#define isl_set_upper_bound	isl_gmp_set_upper_bound
-#define isl_set_fix	isl_gmp_set_fix
-#define isl_set_plain_is_fixed	isl_gmp_set_plain_is_fixed
-#define isl_union_map_fixed_power	isl_gmp_union_map_fixed_power
-#define isl_val_int_from_isl_int	isl_gmp_val_int_from_isl_int
-#define isl_val_get_num_isl_int	isl_gmp_val_get_num_isl_int
-#define isl_vec_get_element	isl_gmp_vec_get_element
-#define isl_vec_set_element	isl_gmp_vec_set_element
-#define isl_vec_set	isl_gmp_vec_set
-#define isl_vec_fdiv_r	isl_gmp_vec_fdiv_r

_service:tar_scm:isl-0.14.tar.xz/isl_hmap_templ.c Deleted

@@ -1,388 +0,0 @@
-/*
- * Copyright 2011      INRIA Saclay
- * Copyright 2013      Ecole Normale Superieure
- *
- * Use of this software is governed by the MIT license
- *
- * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
- * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
- * 91893 Orsay, France
- * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
- */
-
-#include <isl/ctx.h>
-#include <isl/hash.h>
-
-#define xCAT(A,B) A ## B
-#define CAT(A,B) xCAT(A,B)
-#define KEY CAT(isl_,KEY_BASE)
-#define VAL CAT(isl_,VAL_BASE)
-#define xFN(TYPE,NAME) TYPE ## _ ## NAME
-#define FN(TYPE,NAME) xFN(TYPE,NAME)
-#define xHMAP(KEY,VAL_BASE) KEY ## _to_ ## VAL_BASE
-#define yHMAP(KEY,VAL_BASE) xHMAP(KEY,VAL_BASE)
-#define HMAP yHMAP(KEY,VAL_BASE)
-#define HMAP_BASE yHMAP(KEY_BASE,VAL_BASE)
-#define xS(TYPE1,TYPE2,NAME) struct isl_ ## TYPE1 ## _ ## TYPE2 ## _ ## NAME
-#define yS(TYPE1,TYPE2,NAME) xS(TYPE1,TYPE2,NAME)
-#define S(NAME) yS(KEY_BASE,VAL_BASE,NAME)
-
-struct HMAP {
-	int ref;
-	isl_ctx *ctx;
-	struct isl_hash_table table;
-};
-
-S(pair) {
-	KEY *key;
-	VAL *val;
-};
-
-__isl_give HMAP *FN(HMAP,alloc)(isl_ctx *ctx, int min_size)
-{
-	HMAP *hmap;
-
-	hmap = isl_calloc_type(ctx, HMAP);
-	if (!hmap)
-		return NULL;
-
-	hmap->ctx = ctx;
-	isl_ctx_ref(ctx);
-	hmap->ref = 1;
-
-	if (isl_hash_table_init(ctx, &hmap->table, min_size) < 0)
-		return FN(HMAP,free)(hmap);
-
-	return hmap;
-}
-
-static int free_pair(void **entry, void *user)
-{
-	S(pair) *pair = *entry;
-	FN(KEY,free)(pair->key);
-	FN(VAL,free)(pair->val);
-	free(pair);
-	*entry = NULL;
-	return 0;
-}
-
-__isl_null HMAP *FN(HMAP,free)(__isl_take HMAP *hmap)
-{
-	if (!hmap)
-		return NULL;
-	if (--hmap->ref > 0)
-		return NULL;
-	isl_hash_table_foreach(hmap->ctx, &hmap->table, &free_pair, NULL);
-	isl_hash_table_clear(&hmap->table);
-	isl_ctx_deref(hmap->ctx);
-	free(hmap);
-	return NULL;
-}
-
-isl_ctx *FN(HMAP,get_ctx)(__isl_keep HMAP *hmap)
-{
-	return hmap ? hmap->ctx : NULL;
-}
-
-/* Add a mapping from "key" to "val" to the associative array
- * pointed to by user.
- */
-static int add_key_val(__isl_take KEY *key, __isl_take VAL *val, void *user)
-{
-	HMAP **hmap = (HMAP **) user;
-
-	*hmap = FN(HMAP,set)(*hmap, key, val);
-
-	if (!*hmap)
-		return -1;
-
-	return 0;
-}
-
-__isl_give HMAP *FN(HMAP,dup)(__isl_keep HMAP *hmap)
-{
-	HMAP *dup;
-
-	if (!hmap)
-		return NULL;
-
-	dup = FN(HMAP,alloc)(hmap->ctx, hmap->table.n);
-	if (FN(HMAP,foreach)(hmap, &add_key_val, &dup) < 0)
-		return FN(HMAP,free)(dup);
-
-	return dup;
-}
-
-__isl_give HMAP *FN(HMAP,cow)(__isl_take HMAP *hmap)
-{
-	if (!hmap)
-		return NULL;
-
-	if (hmap->ref == 1)
-		return hmap;
-	hmap->ref--;
-	return FN(HMAP,dup)(hmap);
-}
-
-__isl_give HMAP *FN(HMAP,copy)(__isl_keep HMAP *hmap)
-{
-	if (!hmap)
-		return NULL;
-
-	hmap->ref++;
-	return hmap;
-}
-
-static int has_key(const void *entry, const void *c_key)
-{
-	const S(pair) *pair = entry;
-	KEY *key = (KEY *) c_key;
-
-	return KEY_EQUAL(pair->key, key);
-}
-
-int FN(HMAP,has)(__isl_keep HMAP *hmap, __isl_keep KEY *key)
-{
-	uint32_t hash;
-
-	if (!hmap)
-		return -1;
-
-	hash = FN(KEY,get_hash)(key);
-	return !!isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 0);
-}
-
-__isl_give VAL *FN(HMAP,get)(__isl_keep HMAP *hmap, __isl_take KEY *key)
-{
-	struct isl_hash_table_entry *entry;
-	S(pair) *pair;
-	uint32_t hash;
-
-	if (!hmap || !key)
-		goto error;
-
-	hash = FN(KEY,get_hash)(key);
-	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 0);
-	FN(KEY,free)(key);
-
-	if (!entry)
-		return NULL;
-
-	pair = entry->data;
-
-	return FN(VAL,copy)(pair->val);
-error:
-	FN(KEY,free)(key);
-	return NULL;
-}
-
-/* Remove the mapping between "key" and its associated value (if any)
- * from "hmap".
- *
- * If "key" is not mapped to anything, then we leave "hmap" untouched"
- */
-__isl_give HMAP *FN(HMAP,drop)(__isl_take HMAP *hmap, __isl_take KEY *key)
-{
-	struct isl_hash_table_entry *entry;
-	S(pair) *pair;
-	uint32_t hash;
-
-	if (!hmap || !key)
-		goto error;
-
-	hash = FN(KEY,get_hash)(key);
-	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 0);
-	if (!entry) {
-		FN(KEY,free)(key);
-		return hmap;
-	}
-
-	hmap = FN(HMAP,cow)(hmap);
-	if (!hmap)
-		goto error;
-	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 0);
-	FN(KEY,free)(key);
-
-	if (!entry)
-		isl_die(hmap->ctx, isl_error_internal,
-			"missing entry" , goto error);
-
-	pair = entry->data;
-	isl_hash_table_remove(hmap->ctx, &hmap->table, entry);
-	FN(KEY,free)(pair->key);
-	FN(VAL,free)(pair->val);
-	free(pair);
-
-	return hmap;
-error:
-	FN(KEY,free)(key);
-	FN(HMAP,free)(hmap);
-	return NULL;
-}
-
-/* Add a mapping from "key" to "val" to "hmap".
- * If "key" was already mapped to something else, then that mapping
- * is replaced.
- * If key happened to be mapped to "val" already, then we leave
- * "hmap" untouched.
- */
-__isl_give HMAP *FN(HMAP,set)(__isl_take HMAP *hmap,
-	__isl_take KEY *key, __isl_take VAL *val)
-{
-	struct isl_hash_table_entry *entry;
-	S(pair) *pair;
-	uint32_t hash;
-
-	if (!hmap || !key || !val)
-		goto error;
-
-	hash = FN(KEY,get_hash)(key);
-	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 0);
-	if (entry) {
-		int equal;
-		pair = entry->data;
-		equal = VAL_EQUAL(pair->val, val);
-		if (equal < 0)
-			goto error;
-		if (equal) {
-			FN(KEY,free)(key);
-			FN(VAL,free)(val);
-			return hmap;
-		}
-	}
-
-	hmap = FN(HMAP,cow)(hmap);
-	if (!hmap)
-		goto error;
-
-	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
-					&has_key, key, 1);
-
-	if (!entry)
-		goto error;
-
-	if (entry->data) {
-		pair = entry->data;
-		FN(VAL,free)(pair->val);
-		pair->val = val;
-		FN(KEY,free)(key);
-		return hmap;
-	}
-
-	pair = isl_alloc_type(hmap->ctx, S(pair));
-	if (!pair)
-		goto error;
-
-	entry->data = pair;
-	pair->key = key;
-	pair->val = val;
-	return hmap;
-error:
-	FN(KEY,free)(key);
-	FN(VAL,free)(val);
-	return FN(HMAP,free)(hmap);
-}
-
-/* Internal data structure for isl_map_to_basic_set_foreach.
- *
- * fn is the function that should be called on each entry.
- * user is the user-specified final argument to fn.
- */
-S(foreach_data) {
-	int (*fn)(__isl_take KEY *key, __isl_take VAL *val, void *user);
-	void *user;
-};
-
-/* Call data->fn on a copy of the key and value in *entry.
- */
-static int call_on_copy(void **entry, void *user)
-{
-	S(pair) *pair = *entry;
-	S(foreach_data) *data = (S(foreach_data) *) user;
-
-	return data->fn(FN(KEY,copy)(pair->key), FN(VAL,copy)(pair->val),
-			data->user);
-}
-
-/* Call "fn" on each pair of key and value in "hmap".
- */
-int FN(HMAP,foreach)(__isl_keep HMAP *hmap,
-	int (*fn)(__isl_take KEY *key, __isl_take VAL *val, void *user),
-	void *user)
-{
-	S(foreach_data) data = { fn, user };
-
-	if (!hmap)
-		return -1;
-
-	return isl_hash_table_foreach(hmap->ctx, &hmap->table,
-				      &call_on_copy, &data);
-}
-
-/* Internal data structure for print_pair.
- *
- * p is the printer on which the associative array is being printed.
- * first is set if the current key-value pair is the first to be printed.
- */
-S(print_data) {
-	isl_printer *p;
-	int first;
-};
-
-/* Print the given key-value pair to data->p.
- */
-static int print_pair(__isl_take KEY *key, __isl_take VAL *val, void *user)
-{
-	S(print_data) *data = user;
-
-	if (!data->first)
-		data->p = isl_printer_print_str(data->p, ", ");
-	data->p = FN(isl_printer_print,KEY_BASE)(data->p, key);
-	data->p = isl_printer_print_str(data->p, ": ");
-	data->p = FN(isl_printer_print,VAL_BASE)(data->p, val);
-	data->first = 0;
-
-	FN(KEY,free)(key);
-	FN(VAL,free)(val);
-	return 0;
-}
-
-/* Print the associative array to "p".
- */
-__isl_give isl_printer *FN(isl_printer_print,HMAP_BASE)(
-	__isl_take isl_printer *p, __isl_keep HMAP *hmap)
-{
-	S(print_data) data;
-
-	if (!p || !hmap)
-		return isl_printer_free(p);
-
-	p = isl_printer_print_str(p, "{");
-	data.p = p;
-	data.first = 1;
-	if (FN(HMAP,foreach)(hmap, &print_pair, &data) < 0)
-		data.p = isl_printer_free(data.p);
-	p = data.p;
-	p = isl_printer_print_str(p, "}");
-
-	return p;
-}
-
-void FN(HMAP,dump)(__isl_keep HMAP *hmap)
-{
-	isl_printer *printer;
-
-	if (!hmap)
-		return;
-
-	printer = isl_printer_to_file(FN(HMAP,get_ctx)(hmap), stderr);
-	printer = FN(isl_printer_print,HMAP_BASE)(printer, hmap);
-	printer = isl_printer_end_line(printer);
-
-	isl_printer_free(printer);
-}

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/0D-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/0D-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/0D-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/1point-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/1point-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/4-param.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/backtrack.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/basic-bounds-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/basic-bounds-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/basic-bounds-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/basic-bounds-4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/basic-bounds-5.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/block.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/block2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/block3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/byu98-1-2-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/cholesky.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/cholesky2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/christian.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/classen.in Deleted

@@ -1,3 +0,0 @@
-m -> { S2i0, i1, 1 + i0, i1, 2 + i0 - i1, i1, 3 + i0 - i1, i1 -> i0, 0, i1, 2, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -3 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= m and i1 >= 3 - m + i0 and i1 >= 1; S4i0, i1, 2 + i0, 1 + i1, 2 + i0 - i1, i1, 3 + i0 - i1, 1 + i1 -> i0, 0, i1, 2, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -4 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= -1 + m and i1 >= 3 - m + i0 and i1 >= 1; S5i0, i1, 1 + i0, i1, 2 + i0 - i1, i1, 3 + i0 - i1, i1 -> 1 + i0, 0, i1, 0, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -3 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= m and i1 >= 3 - m + i0 and i1 >= 1; S7i0, i1, 2 + i0, 1 + i1, 2 + i0 - i1, i1, 3 + i0 - i1, 1 + i1 -> 1 + i0, 0, 1 + i1, 0, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -4 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= -1 + m and i1 >= 3 - m + i0 and i1 >= 1; S6i0, i1, 1 + i0, 1 + i1, 2 + i0 - i1, i1, 2 + i0 - i1, 1 + i1 -> 1 + i0, 0, 1 + i1, 0, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -3 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= -1 + m and i1 >= 2 - m + i0 and i1 >= 1; S3i0, i1, 1 + i0, 1 + i1, 2 + i0 - i1, i1, 2 + i0 - i1, 1 + i1 -> i0, 0, i1, 2, 2 + i0 - i1, i1, 1 : m >= 1 and i0 <= -3 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= -1 + m and i1 >= 2 - m + i0 and i1 >= 1; S8i0, i1 -> i0, 1, 0, 0, 0, 0, 0 : i0 <= -2 + 2m and i0 >= 0 and i1 <= 1 + i0 and i1 <= m and i1 >= 2 - m + i0 and i1 >= 1; S1i0, i1, 2 + i0 - i1, i1 -> i0, 0, i1, 1, 0, 0, 0 : m >= 1 and i1 >= 2 - m + i0 and i1 <= 1 + i0 and i1 <= m and i1 >= 1 }
-m -> {  : m >= 0 }
-m -> { i, j, k, l, m', n, o -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/classen2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/constant.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/constbound.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/darte.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dealII.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/donotsimp.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dot.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dot2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/durbin_e_s.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/emploi.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/equality.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/equality2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/esced.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/ex1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/faber.in Deleted

@@ -1,3 +0,0 @@
-{ S5idx4, idx5, idx6 -> idx4, idx5, idx6, 4 : 14idx6 <= 42 + idx4 and 14idx6 >= 6 + idx4 and idx6 <= idx5 and idx6 >= -12 + idx5 and idx6 >= 6 and idx6 <= 30 and 2idx6 <= 36 - idx5; S8idx4, idx5, idx6 -> idx4, idx5, idx6, 7 : 14idx6 >= 546 - 3idx4 + 14idx5 and 14idx6 <= 654 - 3idx4 + 14idx5 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 >= 30 - 2idx5; S2idx4, idx5, idx6 -> idx4, idx5, idx6, 1 : 14idx5 <= -84 + idx4 and 14idx5 >= -120 + idx4 and idx6 >= 24 + idx5 and idx6 <= 48 + idx5 and idx5 >= -6 and idx5 <= 18 and idx6 <= 24 - 2idx5; S10idx4, idx5, idx6 -> idx4, idx5, idx6, 9 : 7idx6 <= idx4 - 28idx5 and 7idx6 >= -36 + idx4 - 28idx5 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 <= -2idx5; S3idx4, idx5, idx6 -> idx4, idx5, idx6, 2 : idx4 >= 0 and idx4 <= 36 and idx6 >= -8idx5 and idx6 <= 24 - 8idx5 and idx5 >= 0 and idx5 <= 24; S1idx4, idx5, idx6 -> idx4, idx5, idx6, 0 : 14idx6 >= 672 - 3idx4 + 14idx5 and 14idx6 <= 780 - 3idx4 + 14idx5 and idx6 >= 24 + idx5 and idx6 <= 48 + idx5 and idx5 >= -6 and idx5 <= 18 and idx6 >= 30 - 2idx5; S7idx4, idx5, idx6 -> idx4, idx5, idx6, 6 : 21idx6 <= 84 + 2idx4 - 7idx5 and 21idx6 >= 12 + 2idx4 - 7idx5 and idx6 <= 12 + idx5 and idx6 >= 6 + idx5 and idx6 >= 6 and idx6 <= 30 and 5idx6 <= 36 + 2idx5; S9idx4, idx5, idx6 -> idx4, idx5, idx6, 8 : 14idx5 <= -42 + idx4 and 14idx5 >= -78 + idx4 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 <= 24 - 2idx5 and idx6 >= 6 - 2idx5; S4idx4, idx5, idx6 -> idx4, idx5, idx6, 3 : 14idx6 <= -462 + 3idx4 + 14idx5 and 14idx6 >= -570 + 3idx4 + 14idx5 and idx6 <= idx5 and idx6 >= -12 + idx5 and idx6 >= 6 and idx6 <= 30 and 2idx6 >= 42 - idx5; S6idx4, idx5, idx6 -> idx4, idx5, idx6, 5 : 77idx6 >= 924 - 6idx4 + 77idx5 and 77idx6 <= 1140 - 6idx4 + 77idx5 and idx6 <= 12 + idx5 and idx6 >= 6 + idx5 and idx6 >= 6 and idx6 <= 30 and 5idx6 >= 42 + 2idx5 }
-{  :  }
-{ i, j, k, l -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-1-1-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-2-1-2-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-3-1-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gauss.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/guide.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/iftest.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/iftest2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/infinite2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/jacobi-shared.in Deleted

@@ -1,3 +0,0 @@
-T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1i0, i1 -> 1 - g1 + i0, 1 - g2 + i1, t0, t1 : exists (e0 = (-1 + h0)/2, e1 = (-2016b0 - g1)/2048, e2 = (-992b1 - g2)/1024, e3 = (-1 + t0 - i0)/16, e4 = (-1 + t1 - i1)/32: g0 = h0 and 2e0 = -1 + h0 and 2048e1 = -2016b0 - g1 and 1024e2 = -992b1 - g2 and 16e3 = -1 + t0 - i0 and 32e4 = -1 + t1 - i1 and h0 >= 1 and h0 <= -1 + 2T and i0 >= 2 and i0 <= -2 + N and i1 >= 2 and i1 <= -2 + N and b1 <= 31 and b1 >= 0 and b0 <= 63 and b0 >= 0 and i1 <= 31 + g2 and i1 >= g2 and N >= 4 and i0 >= g1 and i0 <= 31 + g1 and g2 <= -2 + N and g2 >= -29 and g1 <= -2 + N and g1 >= -29 and g1 >= 32b0 and g2 >= 32b1 and 32b0 <= -2 + N and 32b1 <= -2 + N and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 31) }
-T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> {  : exists (e0 = (-32b0 + g1)/2048, e1 = (-32b1 + g2)/1024: g0 = h0 and 2048e0 = -32b0 + g1 and 1024e1 = -32b1 + g2 and g2 <= -2 + N and g2 >= -29 and g1 <= -2 + N and g1 >= -29 and b1 >= 0 and b1 <= 31 and b0 <= 63 and 32b1 <= -2 + N and 32b0 <= -2 + N and b0 >= 0 and N >= 4 and h0 >= 0 and h0 <= -1 + 2T and g2 >= 32b1 and g1 >= 32b0 and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 31) }
-T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { i, j, k, l -> separatex : x >= 3 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/largeur.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/levenshtein-1-2-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lex.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lineality-1-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lineality-2-1-2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/logo.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/logopar.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lu.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lu2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lux.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/merge.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/min-1-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/min-2-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/min-3-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/min-4-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mod.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mod2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mod3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mod4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mode.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/multi-mm-1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/multi-stride.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/multi-stride2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mxm-shared.in Deleted

@@ -1,3 +0,0 @@
-N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1g0 + t1, i1 -> -g1 + i1, t1, t0, t1 : (exists (e0 = (-g1)/128, e1 = (128b1 + 31g1)/4096, e2 = (t0 - i1)/16, e3 = (-120b0 - g0)/128: g4 = 0 and g2 = 8b0 and g3 = 128b1 and 128e0 = -g1 and 4096e1 = 128b1 + 31g1 and 16e2 = t0 - i1 and 128e3 = -120b0 - g0 and g1 >= 128b1 and t1 <= -1 + N - g0 and g0 >= 8b0 and i1 <= -1 + N and b0 <= 15 and b0 >= 0 and b1 <= 31 and b1 >= 0 and i1 <= 127 + g1 and t1 >= 0 and t1 <= 7 and i1 >= g1 and t0 >= 0 and t0 <= 15)) or (exists (e0 = (-g1)/128, e1 = (128b1 + 31g1)/4096, e2 = (t0 - i1)/16, e3 = (-120b0 - g0)/128: g4 = 0 and g2 = 8b0 and g3 = 128b1 and 128e0 = -g1 and 4096e1 = 128b1 + 31g1 and 16e2 = t0 - i1 and 128e3 = -120b0 - g0 and g1 >= 128b1 and t1 <= -1 + N - g0 and g0 >= 8b0 and i1 <= -1 + N and b0 <= 15 and b0 >= 0 and b1 <= 31 and b1 >= 0 and i1 <= 127 + g1 and t1 >= 0 and t1 <= 7 and i1 >= g1 and t0 >= 0 and t0 <= 15 and N >= 1)) or (exists (e0 = (-g1)/128, e1 = (128b1 + 31g1)/4096, e2 = (t0 - i1)/16, e3 = (-120b0 - g0)/128: g4 = 0 and g2 = 8b0 and g3 = 128b1 and 128e0 = -g1 and 4096e1 = 128b1 + 31g1 and 16e2 = t0 - i1 and 128e3 = -120b0 - g0 and g0 >= 8b0 and t1 <= -1 + N - g0 and g1 >= 128b1 and i1 <= -1 + N and N >= 1 and t1 <= 7 and b1 <= 31 and b1 >= 0 and b0 <= 15 and b0 >= 0 and t0 <= 15 and i1 <= 127 + g1 and i1 >= g1 and t1 >= 0 and t0 >= 0)); S1g0 + t1, i1 -> -g1 + i1, t1, t0, t1 : exists (e0 = (g4)/4, e1 = (-g1)/128, e2 = (128b1 + 31g1)/4096, e3 = (t0 - i1)/16, e4 = (-120b0 - g0)/128: g3 = 128b1 and g2 = 8b0 and 4e0 = g4 and 128e1 = -g1 and 4096e2 = 128b1 + 31g1 and 16e3 = t0 - i1 and 128e4 = -120b0 - g0 and g0 >= 8b0 and t1 <= -1 + N - g0 and g1 >= 128b1 and i1 <= -1 + N and g4 <= -1 + N and t1 <= 7 and b1 <= 31 and b1 >= 0 and b0 <= 15 and b0 >= 0 and g4 >= 0 and i1 <= 127 + g1 and i1 >= g1 and t1 >= 0 and t0 >= 0 and t0 <= 15) }
-N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> {  : exists (e0 = (g0)/8, e1 = (-128b1 + g1)/4096, e2 = (8b0 - g0)/128: g2 = 8b0 and g3 = 128b1 and 8e0 = g0 and 4096e1 = -128b1 + g1 and 128e2 = 8b0 - g0 and b0 >= 0 and g4 <= -1 + N and b0 <= 15 and g1 <= -1 + N and g4 >= 0 and b1 <= 31 and g0 <= -1 + N and g1 >= 128b1 and b1 >= 0 and g0 >= 8b0 and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 15) }
-N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { i, j, k, l -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/no_lindep.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_basic1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_basic2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_complex1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_lcpc.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/orc.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/otl.in Deleted

@@ -1,3 +0,0 @@
-M, N -> { S1i0, i1, i2, i3, i4, i2 -> i0, i1, i2, i3, i4, i2 : 5i0 <= -7 + 2M + 2N and i4 >= i0 - i2 and 10i2 >= -2 - N + 5i0 and i2 >= -1 + i0 - i1 and 2i4 >= i0 and i0 >= 1 and i1 >= 1 and 2i1 >= i0 and i2 >= 0 and 5i2 >= 1 - M - N + 5i0 and 5i4 >= -1 - M + 5i0 and i3 >= i0 and 5i1 >= -2 - M + 5i0 and i3 >= 1 and 5i3 >= -3 - N + 5i1 + 5i2 and 5i2 <= 4 + N + 5i0 - 5i1 and i4 >= 1 and i2 <= i0 and 5i3 >= -2N + 10i1 and 5i1 <= -5 + M + 2N and 10i1 <= 1 + 2N + 5i0 and 5i2 >= -1 - N + 5i1 and i4 >= i1 and i3 >= i1 and i2 <= i1 and i1 <= i0 and 5i4 <= 4 + N - 5i2 + 5i3 and 5i4 <= 5 + N + 5i0 - 5i2 and 5i3 >= -2 - N + 10i2 and 5i2 <= -2 + M + N and 10i2 <= 3 + N + 5i0 and N >= 4 and i4 >= i2 and i3 >= i2 and M >= 3 and i4 <= i0 and 5i3 <= -6 + 2M + 2N and i4 >= -1 - i2 + i3 and 5i3 <= 3 + N + 10i2 and i3 <= 1 + i1 + i2 and i4 <= 1 + i1 and 2i4 >= i3 and 5i4 <= 2 + N + 5i2 and i3 <= 1 + 2i1 and i4 <= i3 and 5i3 <= M + N + 5i2 and 5i4 >= -2 - M + 5i3 and 10i4 <= 3 + 2N + 5i0 and i3 <= 1 + i0 and 5i3 <= 3 + M + 5i1 and 5i4 <= -4 + M + 2N and 10i4 <= 2 + 2N + 5i3 }
-M, N -> {  : M >= 1 and N >= 1 }
-M, N -> { i, j, k, l, m, n -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/param-split.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/pouchet.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/rectangle.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-QR.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-bastoul3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-cholesky2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-fusion1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-fusion2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-jacobi2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-jacobi3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam5.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam6.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-liu-zhuge1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner5.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-interp.in Deleted

@@ -1,3 +0,0 @@
-M, N, O, P, Q, R, S, T, U -> { S8i0, i1, i2 -> 1, i0, 0, 2i1, 1, i2, 0 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S11i0, i1, i2 -> 0, i0, 0, 2i1, 4, i2, 1 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S6i0, i1, i2 -> 0, i0, 0, -2 + 2i1, 2, i2, 0 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S9i0, i1, i2 -> 1, i0, 0, 1 + 2i1, 3, i2, 1 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S1i0, i1, i2 -> 0, i0, 0, -3 + 2i1, 2, i2, 0 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S4i0, i1, i2 -> 2, i0, 0, i1, 1, i2, 0 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S2i0, i1, i2 -> 1, i0, 0, 2i1, 0, i2, 1 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S7i0, i1, i2 -> 0, i0, 0, -2 + 2i1, 2, i2, 1 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S10i0, i1, i2 -> 0, i0, 0, 1 + 2i1, 0, i2, 0 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S3i0, i1, i2 -> 0, i0, 0, -1 + 2i1, 1, i2, 2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S15i0, i1, i2 -> 7, i0, 1, i1, 1, i2, 0 : i0 >= R and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S5i0, i1, i2 -> 3, i0, 0, i1, 1, i2, 1 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S13i0, i1, i2 -> 5, i0, 0, i1, 1, i2, 0 : i0 >= R and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S12i0, i1, i2 -> 4, i0, 0, i1, 0, i2, 0 : i0 >= R and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S14i0, i1, i2 -> 6, i0, 1, i1, 0, i2, 0 : i0 >= R and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= P and i2 <= -1 + M }
-M, N, O, P, Q, R, S, T, U -> {  :  }
-M, N, O, P, Q, R, S, T, U -> { i, j, k, l, m, n, o -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-interp2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-psinv.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-resid.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-rprj3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali5.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali6.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-stride.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-stride2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-tang-xue1.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-two.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/singleton.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/square+triangle-1-1-2-3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride4.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/swim.in Deleted

@@ -1,3 +0,0 @@
-M, N, O, P, Q, R -> { S84i0 -> 34, i0, 31, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S6 -> 5, 0, 0, 0, 0, 0, 0 : M = 1; S25 -> 24, 0, 0, 0, 0, 0, 0 : M = 1; S115i0, i1 -> 34, i0, 48, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S64i0, i1 -> 34, i0, 13, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S62i0, i1 -> 34, i0, 13, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S40i0, i1, i2 -> 34, i0, 2, i1, 0, i2, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S123i0 -> 34, i0, 52, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S5 -> 4, 0, 0, 0, 0, 0, 0 : M = 1; S15 -> 14, 0, 0, 0, 0, 0, 0 : M = 1; S76i0 -> 34, i0, 23, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S39i0 -> 34, i0, 1, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S13 -> 12, 0, 0, 0, 0, 0, 0 : M = 1; S28i0, i1 -> 27, i0, 0, i1, 0, 0, 0 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S70i0 -> 34, i0, 17, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S53i0 -> 34, i0, 6, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S121i0 -> 34, i0, 50, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S47i0, i1 -> 34, i0, 3, i1, 3, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S59i0, i1, i2 -> 34, i0, 12, i1, 0, i2, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S71i0 -> 34, i0, 18, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S77i0 -> 34, i0, 24, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S63i0, i1 -> 34, i0, 13, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S51i0, i1 -> 34, i0, 4, i1, 3, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S100i0 -> 34, i0, 44, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S22 -> 21, 0, 0, 0, 0, 0, 0 : M = 1; S95i0, i1, i2 -> 34, i0, 42, i1, 0, i2, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S8 -> 7, 0, 0, 0, 0, 0, 0 : M = 1; S120i0 -> 34, i0, 49, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S50i0, i1 -> 34, i0, 4, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S45i0, i1 -> 34, i0, 3, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S72i0 -> 34, i0, 19, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S52i0 -> 34, i0, 5, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S7 -> 6, 0, 0, 0, 0, 0, 0 : M = 1; S78i0 -> 34, i0, 25, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S110i0, i1 -> 34, i0, 47, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S124i0 -> 34, i0, 53, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S60i0, i1, i2 -> 34, i0, 12, i1, 0, i2, 1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S27 -> 26, 0, 0, 0, 0, 0, 0 : M = 1; S114i0, i1 -> 34, i0, 48, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S49i0, i1 -> 34, i0, 4, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S94i0 -> 34, i0, 41, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S57i0 -> 34, i0, 10, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S66i0, i1 -> 34, i0, 14, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S18 -> 17, 0, 0, 0, 0, 0, 0 : M = 1; S92i0 -> 34, i0, 39, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S3 -> 2, 0, 0, 0, 0, 0, 0 : M = 1; S35 -> 31, 0, 0, 0, 0, 0, 0 : M = 1 and O <= 1; S36 -> 32, 0, 0, 0, 0, 0, 0 : M = 1; S10 -> 9, 0, 0, 0, 0, 0, 0 : M = 1; S2 -> 1, 0, 0, 0, 0, 0, 0 : M = 1; S48i0, i1 -> 34, i0, 4, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S30i0, i1 -> 27, i0, 0, i1, 2, 0, 0 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S75i0 -> 34, i0, 22, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S83i0 -> 34, i0, 30, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S87i0 -> 34, i0, 34, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S88i0 -> 34, i0, 35, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S33 -> 29, 0, 0, 0, 0, 0, 0 : M = 1; S101i0 -> 34, i0, 45, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S21 -> 20, 0, 0, 0, 0, 0, 0 : M = 1; S32 -> 28, 0, 0, 0, 0, 0, 0 : M = 1; S118i0, i1 -> 34, i0, 48, i1, 4, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S79i0 -> 34, i0, 26, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S38i0 -> 34, i0, 0, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S108i0, i1 -> 34, i0, 47, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S65i0, i1 -> 34, i0, 14, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S91i0 -> 34, i0, 38, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S17 -> 16, 0, 0, 0, 0, 0, 0 : M = 1; S80i0 -> 34, i0, 27, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S54i0 -> 34, i0, 7, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S46i0, i1 -> 34, i0, 3, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S68i0 -> 34, i0, 15, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S116i0, i1 -> 34, i0, 48, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S43i0, i1, i2 -> 34, i0, 2, i1, 0, i2, 3 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S26 -> 25, 0, 0, 0, 0, 0, 0 : M = 1; S31i0 -> 27, i0, 1, 0, 0, 0, 0 : M = 1 and i0 >= 1 and i0 <= N; S69i0 -> 34, i0, 16, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S24 -> 23, 0, 0, 0, 0, 0, 0 : M = 1; S90i0 -> 34, i0, 37, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S89i0 -> 34, i0, 36, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S82i0 -> 34, i0, 29, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S67i0, i1 -> 34, i0, 14, i1, 2, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S58i0 -> 34, i0, 11, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S109i0, i1 -> 34, i0, 47, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S122i0 -> 34, i0, 51, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S61i0, i1, i2 -> 34, i0, 12, i1, 0, i2, 2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S1 -> 0, 0, 0, 0, 0, 0, 0 : M = 1; S4 -> 3, 0, 0, 0, 0, 0, 0 : M = 1; S86i0 -> 34, i0, 33, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S14 -> 13, 0, 0, 0, 0, 0, 0 : M = 1; S93i0 -> 34, i0, 40, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S56i0 -> 34, i0, 9, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S37 -> 33, 0, 0, 0, 0, 0, 0 : M = 1; S125i0 -> 34, i0, 54, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S96i0, i1, i2 -> 34, i0, 42, i1, 0, i2, 1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S9 -> 8, 0, 0, 0, 0, 0, 0 : M = 1; S41i0, i1, i2 -> 34, i0, 2, i1, 0, i2, 1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S102i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S112i0, i1 -> 34, i0, 47, i1, 4, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S16 -> 15, 0, 0, 0, 0, 0, 0 : M = 1; S85i0 -> 34, i0, 32, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S42i0, i1, i2 -> 34, i0, 2, i1, 0, i2, 2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S12 -> 11, 0, 0, 0, 0, 0, 0 : M = 1; S55i0 -> 34, i0, 8, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S11 -> 10, 0, 0, 0, 0, 0, 0 : M = 1; S19 -> 18, 0, 0, 0, 0, 0, 0 : M = 1; S107i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 5 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S98i0, i1 -> 34, i0, 42, i1, 1, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N; S104i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S29i0, i1 -> 27, i0, 0, i1, 1, 0, 0 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S20 -> 19, 0, 0, 0, 0, 0, 0 : M = 1; S103i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S105i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 3 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S97i0, i1, i2 -> 34, i0, 42, i1, 0, i2, 2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S44i0, i1 -> 34, i0, 3, i1, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S106i0, i1, i2 -> 34, i0, 46, i1, 0, i2, 4 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S34 -> 30, 0, 0, 0, 0, 0, 0 : M = 1; S111i0, i1 -> 34, i0, 47, i1, 3, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S99i0 -> 34, i0, 43, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S81i0 -> 34, i0, 28, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S23 -> 22, 0, 0, 0, 0, 0, 0 : M = 1; S117i0, i1 -> 34, i0, 48, i1, 3, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S74i0 -> 34, i0, 21, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P; S113i0, i1 -> 34, i0, 47, i1, 5, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S119i0, i1 -> 34, i0, 48, i1, 5, 0, 0 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S73i0 -> 34, i0, 20, 0, 0, 0, 0 : M = 1 and i0 >= 2 and i0 <= P }
-M, N, O, P, Q, R -> {  :  }
-M, N, O, P, Q, R -> { i, j, k, l, m, n, o -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/test.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/thomasset.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/tiling.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/uday_scalars.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/union.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/unroll.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/unroll2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/usvd_e_t.in Deleted

@@ -1,3 +0,0 @@
-{ S19i0, i1, i2 -> i0, i1, i2, 18 : i0 >= 8 and i1 >= 1 and i2 <= 0 and i2 >= -10 + i0 and i1 <= -6 + i0; S21i0, i1, -7 + i0 -> i0, i1, -7 + i0, 20 : i0 <= 10 and i1 >= 4 and i1 <= 8 and i0 >= 7; S17i0, i1, -6 + i0 -> i0, i1, -6 + i0, 16 : i0 >= 7 and i1 >= 4 and i0 <= 10 and i1 <= -2 + i0; S4i0, i1, -1 -> i0, i1, -1, 3 : i0 <= 8 and i1 >= 1 and i1 <= -4 + i0; S1i0, 0, 0 -> i0, 0, 0, 0 : i0 >= 0 and i0 <= 4; S10i0, 4, 0 -> i0, 4, 0, 9 : i0 >= 7 and i0 <= 10; S16i0, i1, -6 + i0 -> i0, i1, -6 + i0, 15 : i0 <= 10 and i1 >= 4 and i0 >= 7 and i1 <= -2 + i0; S24i0, i1, i2 -> i0, i1, i2, 23 : i0 >= 8 and i1 >= 4 and i1 <= 8 and i2 <= 3 and i2 >= -7 + i0; S23i0, i1, i2 -> i0, i1, i2, 22 : i0 <= 9 and i1 >= 4 and i1 <= 8 and i2 >= 0 and i2 <= -7 + i0; S7i0, i1, 0 -> i0, i1, 0, 6 : i0 >= 5 and i1 <= 0 and i1 >= -9 + i0; S25i0, i1, 4 -> i0, i1, 4, 24 : i0 >= 10 and i0 <= 14 and i1 >= 1 and i1 <= 5; S18i0, i1, i2 -> i0, i1, i2, 17 : i0 <= 10 and i1 >= 1 and i2 >= 4 and i2 <= -4 + i0 and i1 <= -5 + i0; S14i0, i1, i2 -> i0, i1, i2, 13 : i0 >= 8 and i1 <= 4 and i2 <= 0 and i2 >= -12 + i0 and i1 >= -6 + i0; S6i0, i1, 0 -> i0, i1, 0, 5 : i0 <= 8 and i1 >= -4 and i1 <= -9 + i0; S8i0, i1, 0 -> i0, i1, 0, 7 : i0 >= 3 and i0 <= 7 and i1 >= 7 and i1 <= 11; S15i0, i1, i2 -> i0, i1, i2, 14 : i0 <= 10 and i1 >= 1 and i1 <= 5 and i2 >= 4 and i2 <= -4 + i0; S11i0, -3 + i0, i2 -> i0, -3 + i0, i2, 10 : i0 <= 10 and i0 >= 7 and i2 <= 4 and i2 >= -7 + i0; S20i0, i1, i2 -> i0, i1, i2, 19 : i0 >= 8 and i1 <= 4 and i2 >= -4 and i2 <= 0 and i1 >= -6 + i0; S12i0, -2 + i0, i2 -> i0, -2 + i0, i2, 11 : i0 >= 7 and i0 <= 10 and i2 <= 4 and i2 >= -7 + i0; S9i0, 4, 0 -> i0, 4, 0, 8 : i0 >= 7 and i0 <= 10; S22i0, i1, -7 + i0 -> i0, i1, -7 + i0, 21 : i0 >= 7 and i1 >= 5 and i1 <= 9 and i0 <= 10; S13i0, i1, i2 -> i0, i1, i2, 12 : i0 <= 10 and i1 >= 4 and i2 <= 4 and i2 >= -7 + i0 and i1 <= -4 + i0; S26i0, i1, 3 -> i0, i1, 3, 25 : i0 >= 10 and i0 <= 14 and i1 >= 1 and i1 <= 5; S3i0, 0, 0 -> i0, 0, 0, 2 : i0 >= 4 and i0 <= 8; S5i0, i1, 0 -> i0, i1, 0, 4 : i0 >= 4 and i1 <= 4 and i1 >= -4 + i0; S2i0, i1, 0 -> i0, i1, 0, 1 : i0 >= 0 and i0 <= 4 and i1 >= 0 and i1 <= 4 }
-{  :  }
-{ i, j, k, l -> separateo0 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vasilache.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vivien.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vivien2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters3.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/wavefront.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/yosr.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/yosr2.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/youcef.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/youcefn.in Deleted

_service:tar_scm:isl-0.14.tar.xz/test_inputs/gist1.polylib Deleted

_service:tar_scm:isl-0.16.1.tar.xz Deleted

_service:tar_scm:isl-0.14.tar.xz/AUTHORS -> _service:tar_scm:isl-0.24.tar.gz/AUTHORS Changed

_service:tar_scm:isl-0.14.tar.xz/ChangeLog -> _service:tar_scm:isl-0.24.tar.gz/ChangeLog Changed

@@ -1,3 +1,119 @@
+version: 0.24
+date: Sun 25 Apr 2021 03:56:37 PM CEST
+changes:
+	- improved (C++) bindings (inherit methods, renamed exports)
+	- initial templated C++ bindings
+	- detect bounds on constant polynomials as tight
+---
+version: 0.23
+date: Sun 01 Nov 2020 02:41:20 PM CET
+changes:
+	- minor improvements to coalescing
+	- use build compiler to build extract_interface
+	- add some convenience functions
+	- ignore parameters in isl_union_* hash tables
+---
+version: 0.22.1
+date: Sun Jan 12 10:48:18 CET 2020
+changes:
+	- fix error handling
+---
+version: 0.22
+date: Fri Nov  1 18:39:30 CET 2019
+changes:
+	- require C++11 to generate bindings
+	- improved bindings
+	- scheduler fix involving fixed dimensions
+	- accept ranges in tuples during parsing
+	- add some convenience functions
+---
+version: 0.21
+date: Sat Mar  9 15:25:29 CET 2019
+changes:
+	- preliminary C++ bindings
+	- use incremental scheduler by default
+	- introduce isl_size type
+	- rename isl_ast_op_type to isl_ast_expr_op_type
+	- fix coalescing bugs
+	- use isl_bool to return extra boolean argument
+---
+version: 0.20
+date: Sat Jul 21 18:10:08 CEST 2018
+changes:
+	- keep track of domain in 0D isl_multi_pw_aff and isl_multi_union_pw_aff
+	- add isl_aff_eval and isl_pw_aff_eval
+	- add fixed-size rectangular box hull
+---
+version: 0.19
+date: Sat Mar  3 10:44:49 CET 2018
+changes:
+	- minor improvements to coalescing
+	- minor improvement to parametric integer programming
+	- try harder to avoid large coefficients in scheduler
+	- support kill accesses in dependence analysis
+	- drop deprecated isl_int
+	- drop deprecated band forests
+	- drop deprecated functions
+---
+version: 0.18
+date: Sun Dec 18 11:01:58 CET 2016
+changes:
+	- improve elimination of redundant existentially quantified variables
+	- improve coalescing
+	- improve parametric integer programming
+	- preserve isolate option in isl_schedule_node_band_split
+	- print AST nodes in YAML format
+	- minor improvements to Python bindings
+---
+version: 0.17.1
+date: Fri May  6 12:02:48 CEST 2016
+changes:
+	- fix bug in coalescing treatment
+---
+version: 0.17
+date: Tue May  3 14:26:43 CEST 2016
+changes:
+	- optionally combine SCCs incrementally in scheduler
+	- optionally maximize coincidence in scheduler
+	- optionally avoid loop coalescing in scheduler
+	- fix handling of nested integer divisions
+	- optionally detect min/max expressions during AST generation
+	- minor AST generator improvements
+	- simplify stride constraints
+	- improve support for expansions in schedule trees
+---
+version: 0.16.1
+date: Thu Jan 14 18:08:06 CET 2016
+changes:
+	- fix bug in simplification
+---
+version: 0.16
+date: Tue Jan 12 09:56:16 CET 2016
+changes:
+	- add 32 bit integer optimization for IMath
+	- minor AST generator improvements
+	- add isl_union_flow_get_full_{may,must}_dependence
+	- minor improvements to Python bindings
+	- minor improvements to set and map printing
+---
+version: 0.15
+date: Thu Jun 11 12:45:33 CEST 2015
+changes:
+	- improve coalescing
+	- add isl_union_access_info_compute_flow
+	- add mark nodes in AST
+	- add isl_union_pw_aff and isl_multi_union_pw_aff
+	- add schedule trees
+	- deprecate band forests
+	- deprecate separation_class AST generation option
+	- introduce isl_bool and isl_stat types
+---
+version: 0.14.1
+date: Thu Apr  9 12:57:23 CEST 2015
+changes:
+	- fix bug in affine expression normalization
+	- fix handling of conditional validity constraints
+---
 version: 0.14
 date: Sat Oct 25 16:08:47 CEST 2014
 changes:

_service:tar_scm:isl-0.14.tar.xz/GIT_HEAD_ID -> _service:tar_scm:isl-0.24.tar.gz/GIT_HEAD_ID Changed

_service:tar_scm:isl-0.14.tar.xz/Makefile.am -> _service:tar_scm:isl-0.24.tar.gz/Makefile.am Changed

@@ -1,5 +1,10 @@
 if HAVE_CLANG
-    MAYBE_INTERFACE = interface
+if HAVE_CXX11
+MAYBE_INTERFACE = interface
+FORCE:
+interface/extract_interface$(BUILD_EXEEXT): FORCE
+	$(MAKE) $(AM_MAKEFLAGS) -C interface extract_interface$(BUILD_EXEEXT)
+endif
 endif
 SUBDIRS = . $(MAYBE_INTERFACE) doc
 DIST_SUBDIRS = $(MAYBE_INTERFACE) doc
@@ -11,17 +16,41 @@
 noinst_PROGRAMS = isl_test isl_polyhedron_sample isl_pip \
 	isl_polyhedron_minimize isl_polytope_scan \
 	isl_polyhedron_detect_equalities isl_cat \
-	isl_closure isl_bound isl_codegen
-TESTS = isl_test codegen_test.sh pip_test.sh bound_test.sh
+	isl_closure isl_bound isl_schedule isl_codegen isl_test_int \
+	isl_flow isl_flow_cmp isl_schedule_cmp
+TESTS = isl_test codegen_test.sh pip_test.sh bound_test.sh isl_test_int \
+	flow_test.sh schedule_test.sh
+if HAVE_CPP_ISL_H
+  CPP_H = include/isl/cpp.h include/isl/typed_cpp.h
+if HAVE_CXX11
+  noinst_PROGRAMS += isl_test_cpp
+  TESTS += isl_test_cpp isl_test_cpp_failed.sh
+endif
+endif
+if HAVE_CLANG
+if HAVE_CXX11
+  noinst_PROGRAMS += isl_test_cpp-checked isl_test_cpp-checked-conversion
+  TESTS += isl_test_cpp-checked isl_test_cpp-checked-conversion
+if HAVE_PYTHON
+  TESTS += isl_test_python.py
+  noinst_PYTHON = interface/isl.py
+  isl_test_python.py: interface/isl.py libisl.la
+endif
+endif
+endif
+TEST_EXTENSIONS = .py
+AM_TESTS_ENVIRONMENT = \
+	export PYTHONPATH=interface; \
+	export ISL_DYLD_LIBRARY_PATH=.libs; \
+	export LD_LIBRARY_PATH=".libs:$(LD_LIBRARY_PATH)";
+PY_LOG_COMPILER = $(PYTHON)
 
 if IMATH_FOR_MP
 
 MP_SRC = \
-	isl_hide_deprecated.h \
 	isl_imath.c \
 	isl_imath.h \
 	isl_int_imath.h \
-	isl_val_imath.c \
 	imath_wrap/gmp_compat.h \
 	imath_wrap/imath.h \
 	imath_wrap/imrat.h \
@@ -30,7 +59,17 @@
 	imath_wrap/imath.c \
 	imath_wrap/imrat.c
 
-DEPRECATED_SRC =
+noinst_PROGRAMS += isl_test_imath
+TESTS += isl_test_imath
+
+if SMALL_INT_OPT
+MP_SRC += isl_int_sioimath.h \
+	isl_int_sioimath.c \
+	isl_val_sioimath.c
+else
+MP_SRC += isl_val_imath.c
+endif
+
 MP_INCLUDE_H =
 endif
 
@@ -45,17 +84,17 @@
 	isl_gmp.c \
 	isl_val_gmp.c
 
-DEPRECATED_SRC = isl_ast_int.c
 MP_INCLUDE_H = include/isl/val_gmp.h
 endif
 
-AM_CPPFLAGS = -I. -I$(srcdir) -I$(srcdir)/include -Iinclude/ @MP_CPPFLAGS@
-AM_CFLAGS = @WARNING_FLAGS@
+includes = -I. -I$(srcdir) -I$(srcdir)/include -Iinclude/
+AM_CPPFLAGS = $(includes) @MP_CPPFLAGS@
+AM_CFLAGS = @WARNING_FLAGS@ @MP_CFLAGS@
 
 libisl_la_SOURCES = \
 	$(MP_SRC) \
-	$(DEPRECATED_SRC) \
 	isl_aff.c \
+	isl_aff_map.c \
 	isl_aff_private.h \
 	isl_affine_hull.c \
 	isl_arg.c \
@@ -68,8 +107,6 @@
 	isl_ast_codegen.c \
 	isl_ast_graft.c \
 	isl_ast_graft_private.h \
-	isl_band.c \
-	isl_band_private.h \
 	isl_basis_reduction.h \
 	basis_reduction_tab.c \
 	isl_bernstein.c \
@@ -78,6 +115,7 @@
 	isl_blk.h \
 	isl_bound.c \
 	isl_bound.h \
+	isl_box.c \
 	isl_coalesce.c \
 	isl_constraint.c \
 	isl_constraint_private.h \
@@ -85,7 +123,6 @@
 	isl_ctx.c \
 	isl_ctx_private.h \
 	isl_deprecated.c \
-	isl_dim.c \
 	isl_dim_map.h \
 	isl_dim_map.c \
 	isl_equalities.c \
@@ -93,20 +130,27 @@
 	isl_factorization.c \
 	isl_factorization.h \
 	isl_farkas.c \
+	isl_ffs.c \
 	isl_flow.c \
 	isl_fold.c \
 	isl_hash.c \
 	isl_id_to_ast_expr.c \
+	isl_id_to_id.c \
 	isl_id_to_pw_aff.c \
 	isl_ilp.c \
 	isl_ilp_private.h \
 	isl_input.c \
 	isl_int.h \
+	isl_list_private.h \
+	isl_local_private.h \
+	isl_local.h \
+	isl_local.c \
 	isl_local_space_private.h \
 	isl_local_space.c \
 	isl_lp.c \
 	isl_lp_private.h \
 	isl_map.c \
+	isl_map_list.c \
 	isl_map_simplify.c \
 	isl_map_subtract.c \
 	isl_map_private.h \
@@ -121,6 +165,7 @@
 	isl_options.c \
 	isl_options_private.h \
 	isl_output.c \
+	isl_output_private.h \
 	isl_point_private.h \
 	isl_point.c \
 	isl_polynomial_private.h \
@@ -137,7 +182,16 @@
 	isl_scan.c \
 	isl_scan.h \
 	isl_schedule.c \
+	isl_schedule_band.c \
+	isl_schedule_band.h \
+	isl_schedule_node.c \
+	isl_schedule_node_private.h \
+	isl_schedule_read.c \
+	isl_schedule_tree.c \
+	isl_schedule_tree.h \
 	isl_schedule_private.h \
+	isl_schedule_constraints.c \
+	isl_schedule_constraints.h \
 	isl_scheduler.c \
 	isl_set_list.c \
 	isl_sort.c \
@@ -148,6 +202,9 @@
 	isl_stream_private.h \
 	isl_seq.c \
 	isl_seq.h \
+	isl_set_to_ast_graft_list.c \
+	isl_set_to_ast_graft_list.h \
+	isl_stride.c \
 	isl_tab.c \
 	isl_tab.h \
 	isl_tab_pip.c \
@@ -156,13 +213,15 @@
 	isl_transitive_closure.c \
 	isl_union_map.c \
 	isl_union_map_private.h \
+	isl_union_set_private.h \
 	isl_val.c \
 	isl_val_private.h \
 	isl_vec_private.h \
 	isl_vec.c \
 	isl_version.c \
 	isl_vertices_private.h \
-	isl_vertices.c
+	isl_vertices.c \
+	isl_yaml.h
 libisl_la_LIBADD = @MP_LIBS@
 libisl_la_LDFLAGS = -version-info @versioninfo@ \
 	@MP_LDFLAGS@
@@ -170,6 +229,14 @@
 isl_test_LDFLAGS = @MP_LDFLAGS@
 isl_test_LDADD = libisl.la @MP_LIBS@
 
+isl_test_int_LDFLAGS = @MP_LDFLAGS@
+isl_test_int_LDADD = libisl.la @MP_LIBS@
+
+if IMATH_FOR_MP
+isl_test_imath_LDFLAGS = @MP_LDFLAGS@
+isl_test_imath_LDADD = libisl.la @MP_LIBS@
+endif
+
 isl_polyhedron_sample_LDADD = libisl.la
 isl_polyhedron_sample_SOURCES = \
 	polyhedron_sample.c
@@ -179,6 +246,26 @@
 isl_pip_SOURCES = \
 	pip.c
 
+isl_schedule_LDFLAGS = @MP_LDFLAGS@
+isl_schedule_LDADD = libisl.la @MP_LIBS@
+isl_schedule_SOURCES = \
+	schedule.c
+
+isl_schedule_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_schedule_cmp_LDADD = libisl.la @MP_LIBS@
+isl_schedule_cmp_SOURCES = \
+	schedule_cmp.c
+
+isl_flow_LDFLAGS = @MP_LDFLAGS@
+isl_flow_LDADD = libisl.la @MP_LIBS@
+isl_flow_SOURCES = \
+	flow.c
+
+isl_flow_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_flow_cmp_LDADD = libisl.la @MP_LIBS@
+isl_flow_cmp_SOURCES = \
+	flow_cmp.c
+
 isl_codegen_LDFLAGS = @MP_LDFLAGS@
 isl_codegen_LDADD = libisl.la @MP_LIBS@
 isl_codegen_SOURCES = \
@@ -210,9 +297,101 @@
 isl_closure_SOURCES = \
 	closure.c
 
+isl_test_cpp_CPPFLAGS = $(AM_CPPFLAGS) -UCOMPILE_ERROR
+isl_test_cpp_SOURCES = \
+	isl_test_cpp.cc \
+	include/isl/cpp.h
+isl_test_cpp_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_LDADD = libisl.la @MP_LIBS@
+
+# This program is not meant to be compiled by default.
+# In fact it is meant not to be compilable.
+# It is identical to isl_test_cpp, except that it gets compiled
+# with the COMPILE_ERROR flag set.
+EXTRA_PROGRAMS = isl_test_cpp_failed
+isl_test_cpp_failed_CPPFLAGS = $(AM_CPPFLAGS) -DCOMPILE_ERROR
+isl_test_cpp_failed_SOURCES = \
+	isl_test_cpp.cc \
+	include/isl/cpp.h
+isl_test_cpp_failed_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_failed_LDADD = libisl.la @MP_LIBS@
+
+isl_test_cpp_checked_SOURCES = \
+	isl_test_cpp-checked.cc \
+	include/isl/cpp-checked.h
+isl_test_cpp_checked_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_checked_LDADD = libisl.la @MP_LIBS@
+
+isl_test_cpp_checked_conversion_SOURCES = \
+	isl_test_cpp-checked-conversion.cc \
+	include/isl/cpp-checked-conversion.h
+isl_test_cpp_checked_conversion_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_checked_conversion_LDADD = libisl.la @MP_LIBS@
+
+# dummy library that captures the dependencies on all headers
+# that are relevant for the bindings
+noinst_LIBRARIES = libdep.a
+libdep_a_SOURCES = dep.c
+
+if HAVE_CLANG
+if HAVE_CXX11
+interface/isldlname.py: libisl.la
+	$(AM_V_GEN) $(GREP) dlname $< | $(SED) -e 's/dlname/isl_dlname/' > $@
+interface/isl.py: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+		python/isl.py.top interface/isldlname.py
+	(cat interface/isldlname.py $(srcdir)/python/isl.py.top && \
+		interface/extract_interface$(BUILD_EXEEXT) --language=python \
+			$(includes) $(srcdir)/all.h) \
+			> $@ || (rm $@ && false)
+
+include/isl/cpp.h: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+		cpp/cpp.h.top cpp/cpp.h.bot
+	$(MKDIR_P) "include/isl" && \
+	(cat $(srcdir)/cpp/cpp.h.top $(srcdir)/all.h && \
+		interface/extract_interface$(BUILD_EXEEXT) --language=cpp \
+			$(includes) $(srcdir)/all.h && \
+		cat $(srcdir)/cpp/cpp.h.bot) \
+			> $@ || (rm $@ && false)
+
+include/isl/cpp-checked.h: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+		cpp/cpp-checked.h.top cpp/cpp-checked.h.bot
+	$(MKDIR_P) "include/isl" && \
+	(cat $(srcdir)/cpp/cpp-checked.h.top $(srcdir)/all.h && \
+		interface/extract_interface$(BUILD_EXEEXT) \
+			--language=cpp-checked \
+			$(includes) $(srcdir)/all.h && \
+		cat $(srcdir)/cpp/cpp-checked.h.bot) \
+			> $@ || (rm $@ && false)
+
+include/isl/cpp-checked-conversion.h: \
+		interface/extract_interface$(BUILD_EXEEXT) \
+		libdep.a \
+		cpp/cpp-checked-conversion.h.top \
+		cpp/cpp-checked-conversion.h.bot
+	$(MKDIR_P) "include/isl" && \
+	(cat $(srcdir)/cpp/cpp-checked-conversion.h.top && \
+		interface/extract_interface$(BUILD_EXEEXT) \
+			--language=cpp-checked-conversion \
+			$(includes) $(srcdir)/all.h && \
+		cat $(srcdir)/cpp/cpp-checked-conversion.h.bot) \
+			> $@ || (rm $@ && false)
+
+include/isl/typed_cpp.h: interface/extract_interface$(BUILD_EXEEXT) \
+		libdep.a cpp/typed_cpp.h.top cpp/typed_cpp.h.bot
+	$(MKDIR_P) "include/isl" && \
+	(cat $(srcdir)/cpp/typed_cpp.h.top && \
+		interface/extract_interface$(BUILD_EXEEXT) \
+			--language=template-cpp \
+			$(includes) $(srcdir)/all.h && \
+		cat $(srcdir)/cpp/typed_cpp.h.bot) \
+			> $@ || (rm $@ && false)
+endif
+endif
+
 nodist_pkginclude_HEADERS = \
 	include/isl/stdint.h
 pkginclude_HEADERS = \
+	$(CPP_H) \
 	$(MP_INCLUDE_H) \
 	include/isl/aff.h \
 	include/isl/aff_type.h \
@@ -220,17 +399,19 @@
 	include/isl/ast.h \
 	include/isl/ast_type.h \
 	include/isl/ast_build.h \
-	include/isl/band.h \
 	include/isl/constraint.h \
 	include/isl/ctx.h \
-	include/isl/dim.h \
+	include/isl/fixed_box.h \
 	include/isl/flow.h \
 	include/isl/id.h \
+	include/isl/id_type.h \
 	include/isl/id_to_ast_expr.h \
+	include/isl/id_to_id.h \
 	include/isl/id_to_pw_aff.h \
 	include/isl/ilp.h \
 	include/isl/hash.h \
 	include/isl/hmap.h \
+	include/isl/hmap_templ.c \
 	include/isl/list.h \
 	include/isl/local_space.h \
 	include/isl/lp.h \
@@ -238,6 +419,12 @@
 	include/isl/map.h \
 	include/isl/map_to_basic_set.h \
 	include/isl/map_type.h \
+	include/isl/maybe.h \
+	include/isl/maybe_ast_expr.h \
+	include/isl/maybe_basic_set.h \
+	include/isl/maybe_id.h \
+	include/isl/maybe_pw_aff.h \
+	include/isl/maybe_templ.h \
 	include/isl/multi.h \
 	include/isl/obj.h \
 	include/isl/options.h \
@@ -245,57 +432,181 @@
 	include/isl/polynomial.h \
 	include/isl/polynomial_type.h \
 	include/isl/printer.h \
+	include/isl/printer_type.h \
 	include/isl/schedule.h \
+	include/isl/schedule_node.h \
+	include/isl/schedule_type.h \
 	include/isl/set.h \
 	include/isl/set_type.h \
 	include/isl/space.h \
+	include/isl/space_type.h \
 	include/isl/stream.h \
+	include/isl/stride_info.h \
 	include/isl/union_map.h \
 	include/isl/union_map_type.h \
 	include/isl/union_set.h \
 	include/isl/union_set_type.h \
 	include/isl/val.h \
+	include/isl/val_type.h \
 	include/isl/vec.h \
 	include/isl/version.h \
 	include/isl/vertices.h
-deprecateddir = $(pkgincludedir)/deprecated
-deprecated_HEADERS = \
-	include/isl/deprecated/int.h \
-	include/isl/deprecated/aff_int.h \
-	include/isl/deprecated/ast_int.h \
-	include/isl/deprecated/constraint_int.h \
-	include/isl/deprecated/ilp_int.h \
-	include/isl/deprecated/map_int.h \
-	include/isl/deprecated/mat_int.h \
-	include/isl/deprecated/point_int.h \
-	include/isl/deprecated/polynomial_int.h \
-	include/isl/deprecated/set_int.h \
-	include/isl/deprecated/union_map_int.h \
-	include/isl/deprecated/val_int.h \
-	include/isl/deprecated/vec_int.h
+
+if HAVE_CLANG
+if HAVE_CXX11
+    CPP_INTERFACES = \
+	include/isl/cpp.h \
+	include/isl/cpp-checked.h \
+	include/isl/cpp-checked-conversion.h \
+	include/isl/typed_cpp.h
+endif
+endif
+BUILT_SOURCES = gitversion.h $(CPP_INTERFACES)
+CLEANFILES = \
+	gitversion.h \
+	interface/isldlname.py \
+	interface/isl.py \
+	interface/isl.pyc \
+	$(CPP_INTERFACES)
+
+DISTCLEANFILES = \
+	isl-uninstalled.sh \
+	isl-uninstalled.pc \
+	isl.pc \
+	isl.pc.in \
+	include/isl/stdint.h
 
 EXTRA_DIST = \
 	LICENSE \
 	isl_config_post.h \
+	isl_aff_lex_templ.c \
+	isl_align_params_templ.c \
+	isl_align_params_bin_templ.c \
 	basis_reduction_templ.c \
-	isl_hmap_templ.c \
+	isl_bind_domain_templ.c \
+	bset_to_bmap.c \
+	bset_from_bmap.c \
+	isl_check_named_params_templ.c \
+	check_reparse_templ.c \
+	check_reparse_test_templ.c \
+	check_single_reference_templ.c \
+	check_type_range_templ.c \
+	isl_copy_tuple_id_templ.c \
+	isl_domain_factor_templ.c \
+	extract_key.c \
+	isl_ilp_opt_multi_val_templ.c \
+	isl_ilp_opt_val_templ.c \
+	has_single_reference_templ.c \
+	isl_insert_domain_templ.c \
+	isl_list_macro.h \
 	isl_list_templ.c \
 	isl_list_templ.h \
+	isl_map_bound_templ.c \
 	isl_map_lexopt_templ.c \
+	isl_maybe_ast_graft_list.h \
+	isl_maybe_map.h \
+	isl_multi_macro.h \
+	isl_multi_bind_templ.c \
+	isl_multi_explicit_domain.c \
+	isl_multi_pw_aff_explicit_domain.c \
+	isl_multi_union_pw_aff_explicit_domain.c \
+	isl_multi_no_explicit_domain.c \
+	isl_multi_no_domain_templ.c \
 	isl_multi_templ.c \
 	isl_multi_templ.h \
+	isl_multi_add_constant_templ.c \
+	isl_multi_align_templ.c \
+	isl_multi_align_set.c \
+	isl_multi_align_union_set.c \
+	isl_multi_apply_templ.c \
+	isl_multi_apply_set.c \
+	isl_multi_apply_union_set.c \
+	isl_multi_arith_templ.c \
+	isl_multi_bind_domain_templ.c \
+	isl_multi_cmp.c \
+	isl_multi_coalesce.c \
+	isl_multi_dim_id_templ.c \
+	isl_multi_dims.c \
+	isl_multi_domain_templ.c \
+	isl_multi_floor.c \
+	isl_multi_from_base_templ.c \
+	isl_multi_gist.c \
+	isl_multi_hash.c \
+	isl_multi_insert_domain_templ.c \
+	isl_multi_intersect.c \
+	isl_multi_identity_templ.c \
+	isl_multi_locals_templ.c \
+	isl_multi_min_max_templ.c \
+	isl_multi_move_dims_templ.c \
+	isl_multi_nan_templ.c \
+	isl_multi_param_templ.c \
+	isl_multi_product_templ.c \
+	isl_multi_read_no_explicit_domain_templ.c \
+	isl_multi_splice_templ.c \
+	isl_multi_tuple_id_templ.c \
+	isl_multi_unbind_params_templ.c \
+	isl_multi_union_add_templ.c \
+	isl_multi_zero_templ.c \
+	isl_multi_zero_space_templ.c \
+	isl_opt_mpa_templ.c \
+	opt_type.h \
 	print_templ.c \
+	print_templ_yaml.c \
+	print_yaml_field_templ.c \
 	isl_power_templ.c \
+	isl_project_out_all_params_templ.c \
+	isl_pw_macro.h \
 	isl_pw_templ.c \
+	isl_pw_templ.h \
+	isl_pw_add_constant_templ.c \
+	isl_pw_add_constant_multi_val_templ.c \
+	isl_pw_add_constant_val_templ.c \
+	isl_pw_bind_domain_templ.c \
+	isl_pw_eval.c \
+	isl_pw_hash.c \
+	isl_pw_insert_dims_templ.c \
+	isl_pw_insert_domain_templ.c \
+	isl_pw_lift_templ.c \
+	isl_pw_locals_templ.c \
+	isl_pw_morph_templ.c \
+	isl_pw_move_dims_templ.c \
+	isl_pw_neg_templ.c \
+	isl_pw_opt_templ.c \
+	isl_pw_pullback_templ.c \
+	isl_pw_range_tuple_id_templ.c \
+	isl_pw_sub_templ.c \
+	isl_pw_union_opt.c \
+	read_in_string_templ.c \
+	set_to_map.c \
+	set_from_map.c \
+	set_list_from_map_list_inl.c \
+	isl_tab_lexopt_templ.c \
+	isl_test_list_templ.c \
+	isl_test_plain_equal_templ.c \
+	isl_type_check_equal_space_templ.c \
+	isl_type_has_equal_space_bin_templ.c \
+	isl_type_has_equal_space_templ.c \
+	isl_type_has_space_templ.c \
+	isl_unbind_params_templ.c \
+	uset_to_umap.c \
+	uset_from_umap.c \
+	isl_union_macro.h \
 	isl_union_templ.c \
-	isl.py \
+	isl_union_single.c \
+	isl_union_multi.c \
+	isl_union_eval.c \
+	isl_union_locals_templ.c \
+	isl_union_map_lex_templ.c \
+	isl_union_neg.c \
+	isl_union_pw_templ.c \
+	libisl-gdb.py \
+	doc/CodingStyle \
 	doc/SubmittingPatches \
-	doc/chicago.bst \
-	doc/chicago.sty \
 	doc/implementation.tex \
 	doc/isl.bib \
 	doc/mypod2latex \
 	doc/manual.tex \
+	doc/reading.tex \
 	doc/user.pod \
 	imath/gmp_compat.c \
 	imath/gmp_compat.h \
@@ -303,8 +614,12 @@
 	imath/imath.h \
 	imath/imrat.c \
 	imath/imrat.h \
-	interface/all.h \
-	interface/isl.py.top \
+	all.h \
+	cpp \
+	python \
+	isl_test_cpp-generic.cc \
+	isl_test_cpp_failed.sh \
+	isl_test_python.py \
 	test_inputs
 
 dist-hook:
@@ -318,12 +633,21 @@
 gitversion.h: @GIT_HEAD@
 	$(AM_V_GEN)echo '#define GIT_HEAD_ID "'@GIT_HEAD_VERSION@'"' > $@
 
-install-data-local: $(srcdir)/isl.py
+install-data-local: $(srcdir)/libisl-gdb.py
 	@libisl=`sed -ne "/^library_names=/{s/.*='//;s/'$$//;s/ .*//;p;}" \
 		 $(builddir)/libisl.la`; \
 	case $$libisl in \
 	'') echo Cannot find isl library name. GDB bindings not installed.;; \
-	*) echo $(INSTALL_DATA) $(srcdir)/isl.py \
+	*) echo $(INSTALL_DATA) $(srcdir)/libisl-gdb.py \
 		$(DESTDIR)$(libdir)/$$libisl-gdb.py; \
 	test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"; \
-	$(INSTALL_DATA) $(srcdir)/isl.py $(DESTDIR)$(libdir)/$$libisl-gdb.py; esac
+	$(INSTALL_DATA) $(srcdir)/libisl-gdb.py \
+	    $(DESTDIR)$(libdir)/$$libisl-gdb.py; \
+	esac
+
+uninstall-local:
+	@libisl=`sed -ne "/^library_names=/{s/.*='//;s/'$$//;s/ .*//;p;}" \
+		 $(builddir)/libisl.la`; \
+	if test -n "$${libisl}"; then \
+		rm -f $(DESTDIR)$(libdir)/$$libisl-gdb.py; \
+	fi

_service:tar_scm:isl-0.14.tar.xz/Makefile.in -> _service:tar_scm:isl-0.24.tar.gz/Makefile.in Changed

@@ -1,7 +1,7 @@
-# Makefile.in generated by automake 1.14.1 from Makefile.am.
+# Makefile.in generated by automake 1.16.1 from Makefile.am.
 # @configure_input@
 
-# Copyright (C) 1994-2013 Free Software Foundation, Inc.
+# Copyright (C) 1994-2018 Free Software Foundation, Inc.
 
 # This Makefile.in is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -17,8 +17,19 @@
 
 
 
+
 VPATH = @srcdir@
-am__is_gnu_make = test -n '$(MAKEFILE_LIST)' && test -n '$(MAKELEVEL)'
+am__is_gnu_make = { \
+  if test -z '$(MAKELEVEL)'; then \
+    false; \
+  elif test -n '$(MAKE_HOST)'; then \
+    true; \
+  elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \
+    true; \
+  else \
+    false; \
+  fi; \
+}
 am__make_running_with_option = \
   case $${target_option-} in \
       ?) ;; \
@@ -85,16 +96,28 @@
 	isl_pip$(EXEEXT) isl_polyhedron_minimize$(EXEEXT) \
 	isl_polytope_scan$(EXEEXT) \
 	isl_polyhedron_detect_equalities$(EXEEXT) isl_cat$(EXEEXT) \
-	isl_closure$(EXEEXT) isl_bound$(EXEEXT) isl_codegen$(EXEEXT)
-TESTS = isl_test$(EXEEXT) codegen_test.sh pip_test.sh bound_test.sh
+	isl_closure$(EXEEXT) isl_bound$(EXEEXT) isl_schedule$(EXEEXT) \
+	isl_codegen$(EXEEXT) isl_test_int$(EXEEXT) isl_flow$(EXEEXT) \
+	isl_flow_cmp$(EXEEXT) isl_schedule_cmp$(EXEEXT) \
+	$(am__EXEEXT_1) $(am__EXEEXT_2) $(am__EXEEXT_3)
+TESTS = isl_test$(EXEEXT) codegen_test.sh pip_test.sh bound_test.sh \
+	isl_test_int$(EXEEXT) flow_test.sh schedule_test.sh \
+	$(am__EXEEXT_4) $(am__EXEEXT_2) $(am__append_5) \
+	$(am__EXEEXT_3)
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@am__append_1 = isl_test_cpp
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@am__append_2 = isl_test_cpp isl_test_cpp_failed.sh
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@am__append_3 = isl_test_cpp-checked isl_test_cpp-checked-conversion
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@am__append_4 = isl_test_cpp-checked isl_test_cpp-checked-conversion
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@@HAVE_PYTHON_TRUE@am__append_5 = isl_test_python.py
+@IMATH_FOR_MP_TRUE@am__append_6 = isl_test_imath
+@IMATH_FOR_MP_TRUE@am__append_7 = isl_test_imath
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@am__append_8 = isl_int_sioimath.h \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@	isl_int_sioimath.c \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@	isl_val_sioimath.c
+
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@am__append_9 = isl_val_imath.c
+EXTRA_PROGRAMS = isl_test_cpp_failed$(EXEEXT)
 subdir = .
-DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/Makefile.am \
-	$(top_srcdir)/configure $(am__configure_deps) \
-	$(srcdir)/isl_config.h.in $(srcdir)/bound_test.sh.in \
-	$(srcdir)/codegen_test.sh.in $(srcdir)/pip_test.sh.in depcomp \
-	$(deprecated_HEADERS) $(am__pkginclude_HEADERS_DIST) \
-	test-driver AUTHORS ChangeLog README compile config.guess \
-	config.sub install-sh missing ltmain.sh
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
 am__aclocal_m4_deps = $(top_srcdir)/m4/ax_c___attribute__.m4 \
 	$(top_srcdir)/m4/ax_cc_maxopt.m4 \
@@ -102,12 +125,16 @@
 	$(top_srcdir)/m4/ax_compiler_vendor.m4 \
 	$(top_srcdir)/m4/ax_create_pkgconfig_info.m4 \
 	$(top_srcdir)/m4/ax_create_stdint_h.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11.m4 \
+	$(top_srcdir)/m4/ax_cxx_compile_stdcxx_11_no_override.m4 \
 	$(top_srcdir)/m4/ax_detect_git_head.m4 \
 	$(top_srcdir)/m4/ax_detect_gmp.m4 \
 	$(top_srcdir)/m4/ax_detect_imath.m4 \
 	$(top_srcdir)/m4/ax_gcc_archflag.m4 \
 	$(top_srcdir)/m4/ax_gcc_warn_unused_result.m4 \
 	$(top_srcdir)/m4/ax_gcc_x86_cpuid.m4 \
+	$(top_srcdir)/m4/ax_prog_cc_for_build.m4 \
 	$(top_srcdir)/m4/ax_set_warning_flags.m4 \
 	$(top_srcdir)/m4/ax_submodule.m4 $(top_srcdir)/m4/libtool.m4 \
 	$(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \
@@ -115,12 +142,23 @@
 	$(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
 	$(ACLOCAL_M4)
+DIST_COMMON = $(srcdir)/Makefile.am $(top_srcdir)/configure \
+	$(am__configure_deps) $(am__noinst_PYTHON_DIST) \
+	$(am__pkginclude_HEADERS_DIST) $(am__DIST_COMMON)
 am__CONFIG_DISTCLEAN_FILES = config.status config.cache config.log \
  configure.lineno config.status.lineno
 mkinstalldirs = $(install_sh) -d
 CONFIG_HEADER = isl_config.h
-CONFIG_CLEAN_FILES = bound_test.sh codegen_test.sh pip_test.sh
+CONFIG_CLEAN_FILES = isl_srcdir.c bound_test.sh codegen_test.sh \
+	pip_test.sh flow_test.sh schedule_test.sh
 CONFIG_CLEAN_VPATH_FILES =
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@am__EXEEXT_1 =  \
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@	isl_test_cpp$(EXEEXT)
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@am__EXEEXT_2 = isl_test_cpp-checked$(EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	isl_test_cpp-checked-conversion$(EXEEXT)
+@IMATH_FOR_MP_TRUE@am__EXEEXT_3 = isl_test_imath$(EXEEXT)
+PROGRAMS = $(noinst_PROGRAMS)
+LIBRARIES = $(noinst_LIBRARIES)
 am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
 am__vpath_adj = case $$p in \
     $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
@@ -149,76 +187,100 @@
          $(am__cd) "$$dir" && rm -f $$files; }; \
   }
 am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" \
-	"$(DESTDIR)$(deprecateddir)" "$(DESTDIR)$(pkgincludedir)" \
-	"$(DESTDIR)$(pkgincludedir)"
+	"$(DESTDIR)$(pkgincludedir)" "$(DESTDIR)$(pkgincludedir)"
 LTLIBRARIES = $(lib_LTLIBRARIES)
+ARFLAGS = cru
+AM_V_AR = $(am__v_AR_@AM_V@)
+am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
+am__v_AR_0 = @echo "  AR      " $@;
+am__v_AR_1 = 
+libdep_a_AR = $(AR) $(ARFLAGS)
+libdep_a_LIBADD =
+am_libdep_a_OBJECTS = dep.$(OBJEXT)
+libdep_a_OBJECTS = $(am_libdep_a_OBJECTS)
 libisl_la_DEPENDENCIES =
 am__libisl_la_SOURCES_DIST = mp_get_memory_functions.c isl_int_gmp.h \
-	isl_gmp.c isl_val_gmp.c isl_hide_deprecated.h isl_imath.c \
-	isl_imath.h isl_int_imath.h isl_val_imath.c \
-	imath_wrap/gmp_compat.h imath_wrap/imath.h imath_wrap/imrat.h \
-	imath_wrap/wrap.h imath_wrap/gmp_compat.c imath_wrap/imath.c \
-	imath_wrap/imrat.c isl_ast_int.c isl_aff.c isl_aff_private.h \
-	isl_affine_hull.c isl_arg.c isl_ast.c isl_ast_private.h \
-	isl_ast_build.c isl_ast_build_private.h isl_ast_build_expr.c \
+	isl_gmp.c isl_val_gmp.c isl_imath.c isl_imath.h \
+	isl_int_imath.h imath_wrap/gmp_compat.h imath_wrap/imath.h \
+	imath_wrap/imrat.h imath_wrap/wrap.h imath_wrap/gmp_compat.c \
+	imath_wrap/imath.c imath_wrap/imrat.c isl_int_sioimath.h \
+	isl_int_sioimath.c isl_val_sioimath.c isl_val_imath.c \
+	isl_aff.c isl_aff_map.c isl_aff_private.h isl_affine_hull.c \
+	isl_arg.c isl_ast.c isl_ast_private.h isl_ast_build.c \
+	isl_ast_build_private.h isl_ast_build_expr.c \
 	isl_ast_build_expr.h isl_ast_codegen.c isl_ast_graft.c \
-	isl_ast_graft_private.h isl_band.c isl_band_private.h \
-	isl_basis_reduction.h basis_reduction_tab.c isl_bernstein.c \
-	isl_bernstein.h isl_blk.c isl_blk.h isl_bound.c isl_bound.h \
+	isl_ast_graft_private.h isl_basis_reduction.h \
+	basis_reduction_tab.c isl_bernstein.c isl_bernstein.h \
+	isl_blk.c isl_blk.h isl_bound.c isl_bound.h isl_box.c \
 	isl_coalesce.c isl_constraint.c isl_constraint_private.h \
 	isl_convex_hull.c isl_ctx.c isl_ctx_private.h isl_deprecated.c \
-	isl_dim.c isl_dim_map.h isl_dim_map.c isl_equalities.c \
-	isl_equalities.h isl_factorization.c isl_factorization.h \
-	isl_farkas.c isl_flow.c isl_fold.c isl_hash.c \
-	isl_id_to_ast_expr.c isl_id_to_pw_aff.c isl_ilp.c \
-	isl_ilp_private.h isl_input.c isl_int.h \
-	isl_local_space_private.h isl_local_space.c isl_lp.c \
-	isl_lp_private.h isl_map.c isl_map_simplify.c \
-	isl_map_subtract.c isl_map_private.h isl_map_to_basic_set.c \
-	isl_mat.c isl_mat_private.h isl_morph.c isl_morph.h isl_id.c \
+	isl_dim_map.h isl_dim_map.c isl_equalities.c isl_equalities.h \
+	isl_factorization.c isl_factorization.h isl_farkas.c isl_ffs.c \
+	isl_flow.c isl_fold.c isl_hash.c isl_id_to_ast_expr.c \
+	isl_id_to_id.c isl_id_to_pw_aff.c isl_ilp.c isl_ilp_private.h \
+	isl_input.c isl_int.h isl_list_private.h isl_local_private.h \
+	isl_local.h isl_local.c isl_local_space_private.h \
+	isl_local_space.c isl_lp.c isl_lp_private.h isl_map.c \
+	isl_map_list.c isl_map_simplify.c isl_map_subtract.c \
+	isl_map_private.h isl_map_to_basic_set.c isl_mat.c \
+	isl_mat_private.h isl_morph.c isl_morph.h isl_id.c \
 	isl_id_private.h isl_obj.c isl_options.c isl_options_private.h \
-	isl_output.c isl_point_private.h isl_point.c \
-	isl_polynomial_private.h isl_polynomial.c \
+	isl_output.c isl_output_private.h isl_point_private.h \
+	isl_point.c isl_polynomial_private.h isl_polynomial.c \
 	isl_printer_private.h isl_printer.c print.c isl_range.c \
 	isl_range.h isl_reordering.c isl_reordering.h isl_sample.h \
 	isl_sample.c isl_scan.c isl_scan.h isl_schedule.c \
-	isl_schedule_private.h isl_scheduler.c isl_set_list.c \
-	isl_sort.c isl_sort.h isl_space.c isl_space_private.h \
-	isl_stream.c isl_stream_private.h isl_seq.c isl_seq.h \
-	isl_tab.c isl_tab.h isl_tab_pip.c isl_tarjan.c isl_tarjan.h \
-	isl_transitive_closure.c isl_union_map.c \
-	isl_union_map_private.h isl_val.c isl_val_private.h \
-	isl_vec_private.h isl_vec.c isl_version.c \
-	isl_vertices_private.h isl_vertices.c
+	isl_schedule_band.c isl_schedule_band.h isl_schedule_node.c \
+	isl_schedule_node_private.h isl_schedule_read.c \
+	isl_schedule_tree.c isl_schedule_tree.h isl_schedule_private.h \
+	isl_schedule_constraints.c isl_schedule_constraints.h \
+	isl_scheduler.c isl_set_list.c isl_sort.c isl_sort.h \
+	isl_space.c isl_space_private.h isl_stream.c \
+	isl_stream_private.h isl_seq.c isl_seq.h \
+	isl_set_to_ast_graft_list.c isl_set_to_ast_graft_list.h \
+	isl_stride.c isl_tab.c isl_tab.h isl_tab_pip.c isl_tarjan.c \
+	isl_tarjan.h isl_transitive_closure.c isl_union_map.c \
+	isl_union_map_private.h isl_union_set_private.h isl_val.c \
+	isl_val_private.h isl_vec_private.h isl_vec.c isl_version.c \
+	isl_vertices_private.h isl_vertices.c isl_yaml.h
 @GMP_FOR_MP_TRUE@@NEED_GET_MEMORY_FUNCTIONS_TRUE@am__objects_1 = mp_get_memory_functions.lo
 am__dirstamp = $(am__leading_dot)dirstamp
-@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@am__objects_2 = isl_imath.lo \
-@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	isl_val_imath.lo \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@am__objects_2 =  \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@	isl_int_sioimath.lo \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_TRUE@	isl_val_sioimath.lo
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@am__objects_3 =  \
+@IMATH_FOR_MP_TRUE@@SMALL_INT_OPT_FALSE@	isl_val_imath.lo
+@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@am__objects_4 = isl_imath.lo \
 @GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	imath_wrap/gmp_compat.lo \
 @GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	imath_wrap/imath.lo \
-@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.lo
-@GMP_FOR_MP_TRUE@am__objects_2 = $(am__objects_1) isl_gmp.lo \
+@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.lo \
+@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	$(am__objects_2) \
+@GMP_FOR_MP_FALSE@@IMATH_FOR_MP_TRUE@	$(am__objects_3)
+@GMP_FOR_MP_TRUE@am__objects_4 = $(am__objects_1) isl_gmp.lo \
 @GMP_FOR_MP_TRUE@	isl_val_gmp.lo
-@GMP_FOR_MP_TRUE@am__objects_3 = isl_ast_int.lo
-am_libisl_la_OBJECTS = $(am__objects_2) $(am__objects_3) isl_aff.lo \
+am_libisl_la_OBJECTS = $(am__objects_4) isl_aff.lo isl_aff_map.lo \
 	isl_affine_hull.lo isl_arg.lo isl_ast.lo isl_ast_build.lo \
 	isl_ast_build_expr.lo isl_ast_codegen.lo isl_ast_graft.lo \
-	isl_band.lo basis_reduction_tab.lo isl_bernstein.lo isl_blk.lo \
-	isl_bound.lo isl_coalesce.lo isl_constraint.lo \
-	isl_convex_hull.lo isl_ctx.lo isl_deprecated.lo isl_dim.lo \
-	isl_dim_map.lo isl_equalities.lo isl_factorization.lo \
-	isl_farkas.lo isl_flow.lo isl_fold.lo isl_hash.lo \
-	isl_id_to_ast_expr.lo isl_id_to_pw_aff.lo isl_ilp.lo \
-	isl_input.lo isl_local_space.lo isl_lp.lo isl_map.lo \
-	isl_map_simplify.lo isl_map_subtract.lo \
-	isl_map_to_basic_set.lo isl_mat.lo isl_morph.lo isl_id.lo \
-	isl_obj.lo isl_options.lo isl_output.lo isl_point.lo \
-	isl_polynomial.lo isl_printer.lo print.lo isl_range.lo \
-	isl_reordering.lo isl_sample.lo isl_scan.lo isl_schedule.lo \
-	isl_scheduler.lo isl_set_list.lo isl_sort.lo isl_space.lo \
-	isl_stream.lo isl_seq.lo isl_tab.lo isl_tab_pip.lo \
-	isl_tarjan.lo isl_transitive_closure.lo isl_union_map.lo \
-	isl_val.lo isl_vec.lo isl_version.lo isl_vertices.lo
+	basis_reduction_tab.lo isl_bernstein.lo isl_blk.lo \
+	isl_bound.lo isl_box.lo isl_coalesce.lo isl_constraint.lo \
+	isl_convex_hull.lo isl_ctx.lo isl_deprecated.lo isl_dim_map.lo \
+	isl_equalities.lo isl_factorization.lo isl_farkas.lo \
+	isl_ffs.lo isl_flow.lo isl_fold.lo isl_hash.lo \
+	isl_id_to_ast_expr.lo isl_id_to_id.lo isl_id_to_pw_aff.lo \
+	isl_ilp.lo isl_input.lo isl_local.lo isl_local_space.lo \
+	isl_lp.lo isl_map.lo isl_map_list.lo isl_map_simplify.lo \
+	isl_map_subtract.lo isl_map_to_basic_set.lo isl_mat.lo \
+	isl_morph.lo isl_id.lo isl_obj.lo isl_options.lo isl_output.lo \
+	isl_point.lo isl_polynomial.lo isl_printer.lo print.lo \
+	isl_range.lo isl_reordering.lo isl_sample.lo isl_scan.lo \
+	isl_schedule.lo isl_schedule_band.lo isl_schedule_node.lo \
+	isl_schedule_read.lo isl_schedule_tree.lo \
+	isl_schedule_constraints.lo isl_scheduler.lo isl_set_list.lo \
+	isl_sort.lo isl_space.lo isl_stream.lo isl_seq.lo \
+	isl_set_to_ast_graft_list.lo isl_stride.lo isl_tab.lo \
+	isl_tab_pip.lo isl_tarjan.lo isl_transitive_closure.lo \
+	isl_union_map.lo isl_val.lo isl_vec.lo isl_version.lo \
+	isl_vertices.lo
 libisl_la_OBJECTS = $(am_libisl_la_OBJECTS)
 AM_V_lt = $(am__v_lt_@AM_V@)
 am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
@@ -227,7 +289,6 @@
 libisl_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(libisl_la_LDFLAGS) $(LDFLAGS) -o $@
-PROGRAMS = $(noinst_PROGRAMS)
 am_isl_bound_OBJECTS = bound.$(OBJEXT)
 isl_bound_OBJECTS = $(am_isl_bound_OBJECTS)
 isl_bound_DEPENDENCIES = libisl.la
@@ -246,6 +307,18 @@
 isl_codegen_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(isl_codegen_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_flow_OBJECTS = flow.$(OBJEXT)
+isl_flow_OBJECTS = $(am_isl_flow_OBJECTS)
+isl_flow_DEPENDENCIES = libisl.la
+isl_flow_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(isl_flow_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_flow_cmp_OBJECTS = flow_cmp.$(OBJEXT)
+isl_flow_cmp_OBJECTS = $(am_isl_flow_cmp_OBJECTS)
+isl_flow_cmp_DEPENDENCIES = libisl.la
+isl_flow_cmp_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(isl_flow_cmp_LDFLAGS) $(LDFLAGS) -o $@
 am_isl_pip_OBJECTS = pip.$(OBJEXT)
 isl_pip_OBJECTS = $(am_isl_pip_OBJECTS)
 isl_pip_DEPENDENCIES = libisl.la
@@ -271,12 +344,68 @@
 am_isl_polytope_scan_OBJECTS = polytope_scan.$(OBJEXT)
 isl_polytope_scan_OBJECTS = $(am_isl_polytope_scan_OBJECTS)
 isl_polytope_scan_DEPENDENCIES = libisl.la
+am_isl_schedule_OBJECTS = schedule.$(OBJEXT)
+isl_schedule_OBJECTS = $(am_isl_schedule_OBJECTS)
+isl_schedule_DEPENDENCIES = libisl.la
+isl_schedule_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(isl_schedule_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_schedule_cmp_OBJECTS = schedule_cmp.$(OBJEXT)
+isl_schedule_cmp_OBJECTS = $(am_isl_schedule_cmp_OBJECTS)
+isl_schedule_cmp_DEPENDENCIES = libisl.la
+isl_schedule_cmp_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+	$(AM_CFLAGS) $(CFLAGS) $(isl_schedule_cmp_LDFLAGS) $(LDFLAGS) \
+	-o $@
 isl_test_SOURCES = isl_test.c
 isl_test_OBJECTS = isl_test.$(OBJEXT)
 isl_test_DEPENDENCIES = libisl.la
 isl_test_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
 	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
 	$(isl_test_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_test_cpp_OBJECTS = isl_test_cpp-isl_test_cpp.$(OBJEXT)
+isl_test_cpp_OBJECTS = $(am_isl_test_cpp_OBJECTS)
+isl_test_cpp_DEPENDENCIES = libisl.la
+isl_test_cpp_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(isl_test_cpp_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_test_cpp_checked_OBJECTS = isl_test_cpp-checked.$(OBJEXT)
+isl_test_cpp_checked_OBJECTS = $(am_isl_test_cpp_checked_OBJECTS)
+isl_test_cpp_checked_DEPENDENCIES = libisl.la
+isl_test_cpp_checked_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+	$(AM_CXXFLAGS) $(CXXFLAGS) $(isl_test_cpp_checked_LDFLAGS) \
+	$(LDFLAGS) -o $@
+am_isl_test_cpp_checked_conversion_OBJECTS =  \
+	isl_test_cpp-checked-conversion.$(OBJEXT)
+isl_test_cpp_checked_conversion_OBJECTS =  \
+	$(am_isl_test_cpp_checked_conversion_OBJECTS)
+isl_test_cpp_checked_conversion_DEPENDENCIES = libisl.la
+isl_test_cpp_checked_conversion_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+	$(AM_CXXFLAGS) $(CXXFLAGS) \
+	$(isl_test_cpp_checked_conversion_LDFLAGS) $(LDFLAGS) -o $@
+am_isl_test_cpp_failed_OBJECTS =  \
+	isl_test_cpp_failed-isl_test_cpp.$(OBJEXT)
+isl_test_cpp_failed_OBJECTS = $(am_isl_test_cpp_failed_OBJECTS)
+isl_test_cpp_failed_DEPENDENCIES = libisl.la
+isl_test_cpp_failed_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CXXLD) \
+	$(AM_CXXFLAGS) $(CXXFLAGS) $(isl_test_cpp_failed_LDFLAGS) \
+	$(LDFLAGS) -o $@
+isl_test_imath_SOURCES = isl_test_imath.c
+isl_test_imath_OBJECTS = isl_test_imath.$(OBJEXT)
+@IMATH_FOR_MP_TRUE@isl_test_imath_DEPENDENCIES = libisl.la
+isl_test_imath_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \
+	$(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+	$(AM_CFLAGS) $(CFLAGS) $(isl_test_imath_LDFLAGS) $(LDFLAGS) -o \
+	$@
+isl_test_int_SOURCES = isl_test_int.c
+isl_test_int_OBJECTS = isl_test_int.$(OBJEXT)
+isl_test_int_DEPENDENCIES = libisl.la
+isl_test_int_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+	$(isl_test_int_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_P = $(am__v_P_@AM_V@)
 am__v_P_ = $(am__v_P_@AM_DEFAULT_V@)
 am__v_P_0 = false
@@ -291,7 +420,71 @@
 am__v_at_1 = 
 DEFAULT_INCLUDES = 
 depcomp = $(SHELL) $(top_srcdir)/depcomp
-am__depfiles_maybe = depfiles
+am__maybe_remake_depfiles = depfiles
+am__depfiles_remade = ./$(DEPDIR)/basis_reduction_tab.Plo \
+	./$(DEPDIR)/bound.Po ./$(DEPDIR)/cat.Po ./$(DEPDIR)/closure.Po \
+	./$(DEPDIR)/codegen.Po ./$(DEPDIR)/dep.Po ./$(DEPDIR)/flow.Po \
+	./$(DEPDIR)/flow_cmp.Po ./$(DEPDIR)/isl_aff.Plo \
+	./$(DEPDIR)/isl_aff_map.Plo ./$(DEPDIR)/isl_affine_hull.Plo \
+	./$(DEPDIR)/isl_arg.Plo ./$(DEPDIR)/isl_ast.Plo \
+	./$(DEPDIR)/isl_ast_build.Plo \
+	./$(DEPDIR)/isl_ast_build_expr.Plo \
+	./$(DEPDIR)/isl_ast_codegen.Plo ./$(DEPDIR)/isl_ast_graft.Plo \
+	./$(DEPDIR)/isl_bernstein.Plo ./$(DEPDIR)/isl_blk.Plo \
+	./$(DEPDIR)/isl_bound.Plo ./$(DEPDIR)/isl_box.Plo \
+	./$(DEPDIR)/isl_coalesce.Plo ./$(DEPDIR)/isl_constraint.Plo \
+	./$(DEPDIR)/isl_convex_hull.Plo ./$(DEPDIR)/isl_ctx.Plo \
+	./$(DEPDIR)/isl_deprecated.Plo ./$(DEPDIR)/isl_dim_map.Plo \
+	./$(DEPDIR)/isl_equalities.Plo \
+	./$(DEPDIR)/isl_factorization.Plo ./$(DEPDIR)/isl_farkas.Plo \
+	./$(DEPDIR)/isl_ffs.Plo ./$(DEPDIR)/isl_flow.Plo \
+	./$(DEPDIR)/isl_fold.Plo ./$(DEPDIR)/isl_gmp.Plo \
+	./$(DEPDIR)/isl_hash.Plo ./$(DEPDIR)/isl_id.Plo \
+	./$(DEPDIR)/isl_id_to_ast_expr.Plo \
+	./$(DEPDIR)/isl_id_to_id.Plo ./$(DEPDIR)/isl_id_to_pw_aff.Plo \
+	./$(DEPDIR)/isl_ilp.Plo ./$(DEPDIR)/isl_imath.Plo \
+	./$(DEPDIR)/isl_input.Plo ./$(DEPDIR)/isl_int_sioimath.Plo \
+	./$(DEPDIR)/isl_local.Plo ./$(DEPDIR)/isl_local_space.Plo \
+	./$(DEPDIR)/isl_lp.Plo ./$(DEPDIR)/isl_map.Plo \
+	./$(DEPDIR)/isl_map_list.Plo ./$(DEPDIR)/isl_map_simplify.Plo \
+	./$(DEPDIR)/isl_map_subtract.Plo \
+	./$(DEPDIR)/isl_map_to_basic_set.Plo ./$(DEPDIR)/isl_mat.Plo \
+	./$(DEPDIR)/isl_morph.Plo ./$(DEPDIR)/isl_obj.Plo \
+	./$(DEPDIR)/isl_options.Plo ./$(DEPDIR)/isl_output.Plo \
+	./$(DEPDIR)/isl_point.Plo ./$(DEPDIR)/isl_polynomial.Plo \
+	./$(DEPDIR)/isl_printer.Plo ./$(DEPDIR)/isl_range.Plo \
+	./$(DEPDIR)/isl_reordering.Plo ./$(DEPDIR)/isl_sample.Plo \
+	./$(DEPDIR)/isl_scan.Plo ./$(DEPDIR)/isl_schedule.Plo \
+	./$(DEPDIR)/isl_schedule_band.Plo \
+	./$(DEPDIR)/isl_schedule_constraints.Plo \
+	./$(DEPDIR)/isl_schedule_node.Plo \
+	./$(DEPDIR)/isl_schedule_read.Plo \
+	./$(DEPDIR)/isl_schedule_tree.Plo \
+	./$(DEPDIR)/isl_scheduler.Plo ./$(DEPDIR)/isl_seq.Plo \
+	./$(DEPDIR)/isl_set_list.Plo \
+	./$(DEPDIR)/isl_set_to_ast_graft_list.Plo \
+	./$(DEPDIR)/isl_sort.Plo ./$(DEPDIR)/isl_space.Plo \
+	./$(DEPDIR)/isl_stream.Plo ./$(DEPDIR)/isl_stride.Plo \
+	./$(DEPDIR)/isl_tab.Plo ./$(DEPDIR)/isl_tab_pip.Plo \
+	./$(DEPDIR)/isl_tarjan.Plo ./$(DEPDIR)/isl_test.Po \
+	./$(DEPDIR)/isl_test_cpp-checked-conversion.Po \
+	./$(DEPDIR)/isl_test_cpp-checked.Po \
+	./$(DEPDIR)/isl_test_cpp-isl_test_cpp.Po \
+	./$(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po \
+	./$(DEPDIR)/isl_test_imath.Po ./$(DEPDIR)/isl_test_int.Po \
+	./$(DEPDIR)/isl_transitive_closure.Plo \
+	./$(DEPDIR)/isl_union_map.Plo ./$(DEPDIR)/isl_val.Plo \
+	./$(DEPDIR)/isl_val_gmp.Plo ./$(DEPDIR)/isl_val_imath.Plo \
+	./$(DEPDIR)/isl_val_sioimath.Plo ./$(DEPDIR)/isl_vec.Plo \
+	./$(DEPDIR)/isl_version.Plo ./$(DEPDIR)/isl_vertices.Plo \
+	./$(DEPDIR)/mp_get_memory_functions.Plo ./$(DEPDIR)/pip.Po \
+	./$(DEPDIR)/polyhedron_detect_equalities.Po \
+	./$(DEPDIR)/polyhedron_minimize.Po \
+	./$(DEPDIR)/polyhedron_sample.Po ./$(DEPDIR)/polytope_scan.Po \
+	./$(DEPDIR)/print.Plo ./$(DEPDIR)/schedule.Po \
+	./$(DEPDIR)/schedule_cmp.Po \
+	imath_wrap/$(DEPDIR)/gmp_compat.Plo \
+	imath_wrap/$(DEPDIR)/imath.Plo imath_wrap/$(DEPDIR)/imrat.Plo
 am__mv = mv -f
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
 	$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
@@ -311,19 +504,46 @@
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
 am__v_CCLD_0 = @echo "  CCLD    " $@;
 am__v_CCLD_1 = 
-SOURCES = $(libisl_la_SOURCES) $(isl_bound_SOURCES) $(isl_cat_SOURCES) \
-	$(isl_closure_SOURCES) $(isl_codegen_SOURCES) \
-	$(isl_pip_SOURCES) $(isl_polyhedron_detect_equalities_SOURCES) \
+CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
+	$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+	$(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+	$(AM_CXXFLAGS) $(CXXFLAGS)
+AM_V_CXX = $(am__v_CXX_@AM_V@)
+am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
+am__v_CXX_0 = @echo "  CXX     " $@;
+am__v_CXX_1 = 
+CXXLD = $(CXX)
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+	$(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+	$(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
+am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
+am__v_CXXLD_0 = @echo "  CXXLD   " $@;
+am__v_CXXLD_1 = 
+SOURCES = $(libdep_a_SOURCES) $(libisl_la_SOURCES) \
+	$(isl_bound_SOURCES) $(isl_cat_SOURCES) $(isl_closure_SOURCES) \
+	$(isl_codegen_SOURCES) $(isl_flow_SOURCES) \
+	$(isl_flow_cmp_SOURCES) $(isl_pip_SOURCES) \
+	$(isl_polyhedron_detect_equalities_SOURCES) \
 	$(isl_polyhedron_minimize_SOURCES) \
 	$(isl_polyhedron_sample_SOURCES) $(isl_polytope_scan_SOURCES) \
-	isl_test.c
-DIST_SOURCES = $(am__libisl_la_SOURCES_DIST) $(isl_bound_SOURCES) \
-	$(isl_cat_SOURCES) $(isl_closure_SOURCES) \
-	$(isl_codegen_SOURCES) $(isl_pip_SOURCES) \
+	$(isl_schedule_SOURCES) $(isl_schedule_cmp_SOURCES) isl_test.c \
+	$(isl_test_cpp_SOURCES) $(isl_test_cpp_checked_SOURCES) \
+	$(isl_test_cpp_checked_conversion_SOURCES) \
+	$(isl_test_cpp_failed_SOURCES) isl_test_imath.c isl_test_int.c
+DIST_SOURCES = $(libdep_a_SOURCES) $(am__libisl_la_SOURCES_DIST) \
+	$(isl_bound_SOURCES) $(isl_cat_SOURCES) $(isl_closure_SOURCES) \
+	$(isl_codegen_SOURCES) $(isl_flow_SOURCES) \
+	$(isl_flow_cmp_SOURCES) $(isl_pip_SOURCES) \
 	$(isl_polyhedron_detect_equalities_SOURCES) \
 	$(isl_polyhedron_minimize_SOURCES) \
 	$(isl_polyhedron_sample_SOURCES) $(isl_polytope_scan_SOURCES) \
-	isl_test.c
+	$(isl_schedule_SOURCES) $(isl_schedule_cmp_SOURCES) isl_test.c \
+	$(isl_test_cpp_SOURCES) $(isl_test_cpp_checked_SOURCES) \
+	$(isl_test_cpp_checked_conversion_SOURCES) \
+	$(isl_test_cpp_failed_SOURCES) isl_test_imath.c isl_test_int.c
 RECURSIVE_TARGETS = all-recursive check-recursive cscopelist-recursive \
 	ctags-recursive dvi-recursive html-recursive info-recursive \
 	install-data-recursive install-dvi-recursive \
@@ -337,28 +557,39 @@
     n|no|NO) false;; \
     *) (install-info --version) >/dev/null 2>&1;; \
   esac
+am__noinst_PYTHON_DIST = interface/isl.py
+am__py_compile = PYTHON=$(PYTHON) $(SHELL) $(py_compile)
+py_compile = $(top_srcdir)/py-compile
 DATA = $(pkgconfig_DATA)
-am__pkginclude_HEADERS_DIST = include/isl/val_gmp.h include/isl/aff.h \
-	include/isl/aff_type.h include/isl/arg.h include/isl/ast.h \
-	include/isl/ast_type.h include/isl/ast_build.h \
-	include/isl/band.h include/isl/constraint.h include/isl/ctx.h \
-	include/isl/dim.h include/isl/flow.h include/isl/id.h \
-	include/isl/id_to_ast_expr.h include/isl/id_to_pw_aff.h \
-	include/isl/ilp.h include/isl/hash.h include/isl/hmap.h \
+am__pkginclude_HEADERS_DIST = include/isl/cpp.h \
+	include/isl/typed_cpp.h include/isl/val_gmp.h \
+	include/isl/aff.h include/isl/aff_type.h include/isl/arg.h \
+	include/isl/ast.h include/isl/ast_type.h \
+	include/isl/ast_build.h include/isl/constraint.h \
+	include/isl/ctx.h include/isl/fixed_box.h include/isl/flow.h \
+	include/isl/id.h include/isl/id_type.h \
+	include/isl/id_to_ast_expr.h include/isl/id_to_id.h \
+	include/isl/id_to_pw_aff.h include/isl/ilp.h \
+	include/isl/hash.h include/isl/hmap.h include/isl/hmap_templ.c \
 	include/isl/list.h include/isl/local_space.h include/isl/lp.h \
 	include/isl/mat.h include/isl/map.h \
 	include/isl/map_to_basic_set.h include/isl/map_type.h \
+	include/isl/maybe.h include/isl/maybe_ast_expr.h \
+	include/isl/maybe_basic_set.h include/isl/maybe_id.h \
+	include/isl/maybe_pw_aff.h include/isl/maybe_templ.h \
 	include/isl/multi.h include/isl/obj.h include/isl/options.h \
 	include/isl/point.h include/isl/polynomial.h \
 	include/isl/polynomial_type.h include/isl/printer.h \
-	include/isl/schedule.h include/isl/set.h \
-	include/isl/set_type.h include/isl/space.h \
-	include/isl/stream.h include/isl/union_map.h \
+	include/isl/printer_type.h include/isl/schedule.h \
+	include/isl/schedule_node.h include/isl/schedule_type.h \
+	include/isl/set.h include/isl/set_type.h include/isl/space.h \
+	include/isl/space_type.h include/isl/stream.h \
+	include/isl/stride_info.h include/isl/union_map.h \
 	include/isl/union_map_type.h include/isl/union_set.h \
 	include/isl/union_set_type.h include/isl/val.h \
-	include/isl/vec.h include/isl/version.h include/isl/vertices.h
-HEADERS = $(deprecated_HEADERS) $(nodist_pkginclude_HEADERS) \
-	$(pkginclude_HEADERS)
+	include/isl/val_type.h include/isl/vec.h include/isl/version.h \
+	include/isl/vertices.h
+HEADERS = $(nodist_pkginclude_HEADERS) $(pkginclude_HEADERS)
 RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive	\
   distclean-recursive maintainer-clean-recursive
 am__recursive_targets = \
@@ -366,7 +597,8 @@
   $(RECURSIVE_CLEAN_TARGETS) \
   $(am__extra_recursive_targets)
 AM_RECURSIVE_TARGETS = $(am__recursive_targets:-recursive=) TAGS CTAGS \
-	cscope check recheck distdir dist dist-all distcheck
+	cscope check recheck distdir distdir-am dist dist-all \
+	distcheck
 am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) \
 	$(LISP)isl_config.h.in
 # Read a list of newline-separated strings from the standard input,
@@ -544,8 +776,10 @@
   bases=`for i in $$bases; do echo $$i; done | sed 's/\.log$$//'`; \
   bases=`echo $$bases`
 RECHECK_LOGS = $(TEST_LOGS)
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@am__EXEEXT_4 =  \
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@	isl_test_cpp$(EXEEXT) \
+@HAVE_CPP_ISL_H_TRUE@@HAVE_CXX11_TRUE@	isl_test_cpp_failed.sh
 TEST_SUITE_LOG = test-suite.log
-TEST_EXTENSIONS = @EXEEXT@ .test
 LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
 LOG_COMPILE = $(LOG_COMPILER) $(AM_LOG_FLAGS) $(LOG_FLAGS)
 am__set_b = \
@@ -560,10 +794,15 @@
   esac
 am__test_logs1 = $(TESTS:=.log)
 am__test_logs2 = $(am__test_logs1:@EXEEXT@.log=.log)
-TEST_LOGS = $(am__test_logs2:.test.log=.log)
-TEST_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
-TEST_LOG_COMPILE = $(TEST_LOG_COMPILER) $(AM_TEST_LOG_FLAGS) \
-	$(TEST_LOG_FLAGS)
+TEST_LOGS = $(am__test_logs2:.py.log=.log)
+PY_LOG_DRIVER = $(SHELL) $(top_srcdir)/test-driver
+PY_LOG_COMPILE = $(PY_LOG_COMPILER) $(AM_PY_LOG_FLAGS) $(PY_LOG_FLAGS)
+am__DIST_COMMON = $(srcdir)/Makefile.in $(srcdir)/bound_test.sh.in \
+	$(srcdir)/codegen_test.sh.in $(srcdir)/flow_test.sh.in \
+	$(srcdir)/isl_config.h.in $(srcdir)/isl_srcdir.c.in \
+	$(srcdir)/pip_test.sh.in $(srcdir)/schedule_test.sh.in AUTHORS \
+	ChangeLog README compile config.guess config.sub depcomp \
+	install-sh ltmain.sh missing py-compile test-driver
 DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
 distdir = $(PACKAGE)-$(VERSION)
 top_distdir = $(distdir)
@@ -614,18 +853,22 @@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
+BUILD_EXEEXT = @BUILD_EXEEXT@
+BUILD_OBJEXT = @BUILD_OBJEXT@
 CC = @CC@
 CCDEPMODE = @CCDEPMODE@
+CC_FOR_BUILD = @CC_FOR_BUILD@
 CFLAGS = @CFLAGS@
-CLANG_CXXFLAGS = @CLANG_CXXFLAGS@
-CLANG_LDFLAGS = @CLANG_LDFLAGS@
-CLANG_LIBS = @CLANG_LIBS@
+CFLAGS_FOR_BUILD = @CFLAGS_FOR_BUILD@
 CPP = @CPP@
 CPPFLAGS = @CPPFLAGS@
+CPPFLAGS_FOR_BUILD = @CPPFLAGS_FOR_BUILD@
+CPP_FOR_BUILD = @CPP_FOR_BUILD@
 CXX = @CXX@
 CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
+CYGPATH = @CYGPATH@
 CYGPATH_W = @CYGPATH_W@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
@@ -642,6 +885,7 @@
 GIT_HEAD_ID = @GIT_HEAD_ID@
 GIT_HEAD_VERSION = @GIT_HEAD_VERSION@
 GREP = @GREP@
+HAVE_CXX11 = @HAVE_CXX11@
 INSTALL = @INSTALL@
 INSTALL_DATA = @INSTALL_DATA@
 INSTALL_PROGRAM = @INSTALL_PROGRAM@
@@ -649,16 +893,18 @@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
 LD = @LD@
 LDFLAGS = @LDFLAGS@
+LDFLAGS_FOR_BUILD = @LDFLAGS_FOR_BUILD@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
 LIBTOOL = @LIBTOOL@
-LIB_CLANG_EDIT = @LIB_CLANG_EDIT@
 LIPO = @LIPO@
 LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
 MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
+MP_CFLAGS = @MP_CFLAGS@
 MP_CPPFLAGS = @MP_CPPFLAGS@
 MP_LDFLAGS = @MP_LDFLAGS@
 MP_LIBS = @MP_LIBS@
@@ -666,6 +912,7 @@
 NMEDIT = @NMEDIT@
 OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
+OS_SRCDIR = @OS_SRCDIR@
 OTOOL = @OTOOL@
 OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
@@ -680,6 +927,11 @@
 PERL = @PERL@
 POD2HTML = @POD2HTML@
 PRTDIAG = @PRTDIAG@
+PYTHON = @PYTHON@
+PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@
+PYTHON_PLATFORM = @PYTHON_PLATFORM@
+PYTHON_PREFIX = @PYTHON_PREFIX@
+PYTHON_VERSION = @PYTHON_VERSION@
 RANLIB = @RANLIB@
 SED = @SED@
 SET_MAKE = @SET_MAKE@
@@ -693,6 +945,7 @@
 abs_top_srcdir = @abs_top_srcdir@
 ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
+ac_ct_CC_FOR_BUILD = @ac_ct_CC_FOR_BUILD@
 ac_ct_CXX = @ac_ct_CXX@
 ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
@@ -723,7 +976,6 @@
 install_sh = @install_sh@
 libdir = @libdir@
 libexecdir = @libexecdir@
-llvm_config_found = @llvm_config_found@
 localedir = @localedir@
 localstatedir = @localstatedir@
 mandir = @mandir@
@@ -732,55 +984,61 @@
 pdfdir = @pdfdir@
 pkgconfig_libdir = @pkgconfig_libdir@
 pkgconfig_libfile = @pkgconfig_libfile@
+pkgpyexecdir = @pkgpyexecdir@
+pkgpythondir = @pkgpythondir@
 prefix = @prefix@
 program_transform_name = @program_transform_name@
 psdir = @psdir@
+pyexecdir = @pyexecdir@
+pythondir = @pythondir@
+runstatedir = @runstatedir@
 sbindir = @sbindir@
 sharedstatedir = @sharedstatedir@
 srcdir = @srcdir@
+subdirs = @subdirs@
 sysconfdir = @sysconfdir@
 target_alias = @target_alias@
 top_build_prefix = @top_build_prefix@
 top_builddir = @top_builddir@
 top_srcdir = @top_srcdir@
 versioninfo = @versioninfo@
-@HAVE_CLANG_TRUE@MAYBE_INTERFACE = interface
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@MAYBE_INTERFACE = interface
 SUBDIRS = . $(MAYBE_INTERFACE) doc
 DIST_SUBDIRS = $(MAYBE_INTERFACE) doc
 ACLOCAL_AMFLAGS = -I m4
 AUTOMAKE_OPTIONS = nostdinc subdir-objects
 lib_LTLIBRARIES = libisl.la
+@HAVE_CPP_ISL_H_TRUE@CPP_H = include/isl/cpp.h include/isl/typed_cpp.h
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@@HAVE_PYTHON_TRUE@noinst_PYTHON = interface/isl.py
+TEST_EXTENSIONS = .py
+AM_TESTS_ENVIRONMENT = \
+	export PYTHONPATH=interface; \
+	export ISL_DYLD_LIBRARY_PATH=.libs; \
+	export LD_LIBRARY_PATH=".libs:$(LD_LIBRARY_PATH)";
+
+PY_LOG_COMPILER = $(PYTHON)
 @GMP_FOR_MP_TRUE@MP_SRC = \
 @GMP_FOR_MP_TRUE@	$(GET_MEMORY_FUNCTIONS) \
 @GMP_FOR_MP_TRUE@	isl_int_gmp.h \
 @GMP_FOR_MP_TRUE@	isl_gmp.c \
 @GMP_FOR_MP_TRUE@	isl_val_gmp.c
 
-@IMATH_FOR_MP_TRUE@MP_SRC = \
-@IMATH_FOR_MP_TRUE@	isl_hide_deprecated.h \
-@IMATH_FOR_MP_TRUE@	isl_imath.c \
-@IMATH_FOR_MP_TRUE@	isl_imath.h \
-@IMATH_FOR_MP_TRUE@	isl_int_imath.h \
-@IMATH_FOR_MP_TRUE@	isl_val_imath.c \
-@IMATH_FOR_MP_TRUE@	imath_wrap/gmp_compat.h \
-@IMATH_FOR_MP_TRUE@	imath_wrap/imath.h \
-@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.h \
-@IMATH_FOR_MP_TRUE@	imath_wrap/wrap.h \
-@IMATH_FOR_MP_TRUE@	imath_wrap/gmp_compat.c \
-@IMATH_FOR_MP_TRUE@	imath_wrap/imath.c \
-@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.c
-
-@GMP_FOR_MP_TRUE@DEPRECATED_SRC = isl_ast_int.c
-@IMATH_FOR_MP_TRUE@DEPRECATED_SRC = 
+@IMATH_FOR_MP_TRUE@MP_SRC = isl_imath.c isl_imath.h isl_int_imath.h \
+@IMATH_FOR_MP_TRUE@	imath_wrap/gmp_compat.h imath_wrap/imath.h \
+@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.h imath_wrap/wrap.h \
+@IMATH_FOR_MP_TRUE@	imath_wrap/gmp_compat.c imath_wrap/imath.c \
+@IMATH_FOR_MP_TRUE@	imath_wrap/imrat.c $(am__append_8) \
+@IMATH_FOR_MP_TRUE@	$(am__append_9)
 @GMP_FOR_MP_TRUE@MP_INCLUDE_H = include/isl/val_gmp.h
 @IMATH_FOR_MP_TRUE@MP_INCLUDE_H = 
 @GMP_FOR_MP_TRUE@@NEED_GET_MEMORY_FUNCTIONS_TRUE@GET_MEMORY_FUNCTIONS = mp_get_memory_functions.c
-AM_CPPFLAGS = -I. -I$(srcdir) -I$(srcdir)/include -Iinclude/ @MP_CPPFLAGS@
-AM_CFLAGS = @WARNING_FLAGS@
+includes = -I. -I$(srcdir) -I$(srcdir)/include -Iinclude/
+AM_CPPFLAGS = $(includes) @MP_CPPFLAGS@
+AM_CFLAGS = @WARNING_FLAGS@ @MP_CFLAGS@
 libisl_la_SOURCES = \
 	$(MP_SRC) \
-	$(DEPRECATED_SRC) \
 	isl_aff.c \
+	isl_aff_map.c \
 	isl_aff_private.h \
 	isl_affine_hull.c \
 	isl_arg.c \
@@ -793,8 +1051,6 @@
 	isl_ast_codegen.c \
 	isl_ast_graft.c \
 	isl_ast_graft_private.h \
-	isl_band.c \
-	isl_band_private.h \
 	isl_basis_reduction.h \
 	basis_reduction_tab.c \
 	isl_bernstein.c \
@@ -803,6 +1059,7 @@
 	isl_blk.h \
 	isl_bound.c \
 	isl_bound.h \
+	isl_box.c \
 	isl_coalesce.c \
 	isl_constraint.c \
 	isl_constraint_private.h \
@@ -810,7 +1067,6 @@
 	isl_ctx.c \
 	isl_ctx_private.h \
 	isl_deprecated.c \
-	isl_dim.c \
 	isl_dim_map.h \
 	isl_dim_map.c \
 	isl_equalities.c \
@@ -818,20 +1074,27 @@
 	isl_factorization.c \
 	isl_factorization.h \
 	isl_farkas.c \
+	isl_ffs.c \
 	isl_flow.c \
 	isl_fold.c \
 	isl_hash.c \
 	isl_id_to_ast_expr.c \
+	isl_id_to_id.c \
 	isl_id_to_pw_aff.c \
 	isl_ilp.c \
 	isl_ilp_private.h \
 	isl_input.c \
 	isl_int.h \
+	isl_list_private.h \
+	isl_local_private.h \
+	isl_local.h \
+	isl_local.c \
 	isl_local_space_private.h \
 	isl_local_space.c \
 	isl_lp.c \
 	isl_lp_private.h \
 	isl_map.c \
+	isl_map_list.c \
 	isl_map_simplify.c \
 	isl_map_subtract.c \
 	isl_map_private.h \
@@ -846,6 +1109,7 @@
 	isl_options.c \
 	isl_options_private.h \
 	isl_output.c \
+	isl_output_private.h \
 	isl_point_private.h \
 	isl_point.c \
 	isl_polynomial_private.h \
@@ -862,7 +1126,16 @@
 	isl_scan.c \
 	isl_scan.h \
 	isl_schedule.c \
+	isl_schedule_band.c \
+	isl_schedule_band.h \
+	isl_schedule_node.c \
+	isl_schedule_node_private.h \
+	isl_schedule_read.c \
+	isl_schedule_tree.c \
+	isl_schedule_tree.h \
 	isl_schedule_private.h \
+	isl_schedule_constraints.c \
+	isl_schedule_constraints.h \
 	isl_scheduler.c \
 	isl_set_list.c \
 	isl_sort.c \
@@ -873,6 +1146,9 @@
 	isl_stream_private.h \
 	isl_seq.c \
 	isl_seq.h \
+	isl_set_to_ast_graft_list.c \
+	isl_set_to_ast_graft_list.h \
+	isl_stride.c \
 	isl_tab.c \
 	isl_tab.h \
 	isl_tab_pip.c \
@@ -881,13 +1157,15 @@
 	isl_transitive_closure.c \
 	isl_union_map.c \
 	isl_union_map_private.h \
+	isl_union_set_private.h \
 	isl_val.c \
 	isl_val_private.h \
 	isl_vec_private.h \
 	isl_vec.c \
 	isl_version.c \
 	isl_vertices_private.h \
-	isl_vertices.c
+	isl_vertices.c \
+	isl_yaml.h
 
 libisl_la_LIBADD = @MP_LIBS@
 libisl_la_LDFLAGS = -version-info @versioninfo@ \
@@ -895,6 +1173,10 @@
 
 isl_test_LDFLAGS = @MP_LDFLAGS@
 isl_test_LDADD = libisl.la @MP_LIBS@
+isl_test_int_LDFLAGS = @MP_LDFLAGS@
+isl_test_int_LDADD = libisl.la @MP_LIBS@
+@IMATH_FOR_MP_TRUE@isl_test_imath_LDFLAGS = @MP_LDFLAGS@
+@IMATH_FOR_MP_TRUE@isl_test_imath_LDADD = libisl.la @MP_LIBS@
 isl_polyhedron_sample_LDADD = libisl.la
 isl_polyhedron_sample_SOURCES = \
 	polyhedron_sample.c
@@ -904,6 +1186,26 @@
 isl_pip_SOURCES = \
 	pip.c
 
+isl_schedule_LDFLAGS = @MP_LDFLAGS@
+isl_schedule_LDADD = libisl.la @MP_LIBS@
+isl_schedule_SOURCES = \
+	schedule.c
+
+isl_schedule_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_schedule_cmp_LDADD = libisl.la @MP_LIBS@
+isl_schedule_cmp_SOURCES = \
+	schedule_cmp.c
+
+isl_flow_LDFLAGS = @MP_LDFLAGS@
+isl_flow_LDADD = libisl.la @MP_LIBS@
+isl_flow_SOURCES = \
+	flow.c
+
+isl_flow_cmp_LDFLAGS = @MP_LDFLAGS@
+isl_flow_cmp_LDADD = libisl.la @MP_LIBS@
+isl_flow_cmp_SOURCES = \
+	flow_cmp.c
+
 isl_codegen_LDFLAGS = @MP_LDFLAGS@
 isl_codegen_LDADD = libisl.la @MP_LIBS@
 isl_codegen_SOURCES = \
@@ -935,10 +1237,42 @@
 isl_closure_SOURCES = \
 	closure.c
 
+isl_test_cpp_CPPFLAGS = $(AM_CPPFLAGS) -UCOMPILE_ERROR
+isl_test_cpp_SOURCES = \
+	isl_test_cpp.cc \
+	include/isl/cpp.h
+
+isl_test_cpp_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_LDADD = libisl.la @MP_LIBS@
+isl_test_cpp_failed_CPPFLAGS = $(AM_CPPFLAGS) -DCOMPILE_ERROR
+isl_test_cpp_failed_SOURCES = \
+	isl_test_cpp.cc \
+	include/isl/cpp.h
+
+isl_test_cpp_failed_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_failed_LDADD = libisl.la @MP_LIBS@
+isl_test_cpp_checked_SOURCES = \
+	isl_test_cpp-checked.cc \
+	include/isl/cpp-checked.h
+
+isl_test_cpp_checked_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_checked_LDADD = libisl.la @MP_LIBS@
+isl_test_cpp_checked_conversion_SOURCES = \
+	isl_test_cpp-checked-conversion.cc \
+	include/isl/cpp-checked-conversion.h
+
+isl_test_cpp_checked_conversion_LDFLAGS = @MP_LDFLAGS@
+isl_test_cpp_checked_conversion_LDADD = libisl.la @MP_LIBS@
+
+# dummy library that captures the dependencies on all headers
+# that are relevant for the bindings
+noinst_LIBRARIES = libdep.a
+libdep_a_SOURCES = dep.c
 nodist_pkginclude_HEADERS = \
 	include/isl/stdint.h
 
 pkginclude_HEADERS = \
+	$(CPP_H) \
 	$(MP_INCLUDE_H) \
 	include/isl/aff.h \
 	include/isl/aff_type.h \
@@ -946,17 +1280,19 @@
 	include/isl/ast.h \
 	include/isl/ast_type.h \
 	include/isl/ast_build.h \
-	include/isl/band.h \
 	include/isl/constraint.h \
 	include/isl/ctx.h \
-	include/isl/dim.h \
+	include/isl/fixed_box.h \
 	include/isl/flow.h \
 	include/isl/id.h \
+	include/isl/id_type.h \
 	include/isl/id_to_ast_expr.h \
+	include/isl/id_to_id.h \
 	include/isl/id_to_pw_aff.h \
 	include/isl/ilp.h \
 	include/isl/hash.h \
 	include/isl/hmap.h \
+	include/isl/hmap_templ.c \
 	include/isl/list.h \
 	include/isl/local_space.h \
 	include/isl/lp.h \
@@ -964,6 +1300,12 @@
 	include/isl/map.h \
 	include/isl/map_to_basic_set.h \
 	include/isl/map_type.h \
+	include/isl/maybe.h \
+	include/isl/maybe_ast_expr.h \
+	include/isl/maybe_basic_set.h \
+	include/isl/maybe_id.h \
+	include/isl/maybe_pw_aff.h \
+	include/isl/maybe_templ.h \
 	include/isl/multi.h \
 	include/isl/obj.h \
 	include/isl/options.h \
@@ -971,58 +1313,178 @@
 	include/isl/polynomial.h \
 	include/isl/polynomial_type.h \
 	include/isl/printer.h \
+	include/isl/printer_type.h \
 	include/isl/schedule.h \
+	include/isl/schedule_node.h \
+	include/isl/schedule_type.h \
 	include/isl/set.h \
 	include/isl/set_type.h \
 	include/isl/space.h \
+	include/isl/space_type.h \
 	include/isl/stream.h \
+	include/isl/stride_info.h \
 	include/isl/union_map.h \
 	include/isl/union_map_type.h \
 	include/isl/union_set.h \
 	include/isl/union_set_type.h \
 	include/isl/val.h \
+	include/isl/val_type.h \
 	include/isl/vec.h \
 	include/isl/version.h \
 	include/isl/vertices.h
 
-deprecateddir = $(pkgincludedir)/deprecated
-deprecated_HEADERS = \
-	include/isl/deprecated/int.h \
-	include/isl/deprecated/aff_int.h \
-	include/isl/deprecated/ast_int.h \
-	include/isl/deprecated/constraint_int.h \
-	include/isl/deprecated/ilp_int.h \
-	include/isl/deprecated/map_int.h \
-	include/isl/deprecated/mat_int.h \
-	include/isl/deprecated/point_int.h \
-	include/isl/deprecated/polynomial_int.h \
-	include/isl/deprecated/set_int.h \
-	include/isl/deprecated/union_map_int.h \
-	include/isl/deprecated/val_int.h \
-	include/isl/deprecated/vec_int.h
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@CPP_INTERFACES = \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	include/isl/cpp.h \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	include/isl/cpp-checked.h \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	include/isl/cpp-checked-conversion.h \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	include/isl/typed_cpp.h
+
+BUILT_SOURCES = gitversion.h $(CPP_INTERFACES)
+CLEANFILES = \
+	gitversion.h \
+	interface/isldlname.py \
+	interface/isl.py \
+	interface/isl.pyc \
+	$(CPP_INTERFACES)
+
+DISTCLEANFILES = \
+	isl-uninstalled.sh \
+	isl-uninstalled.pc \
+	isl.pc \
+	isl.pc.in \
+	include/isl/stdint.h
 
 EXTRA_DIST = \
 	LICENSE \
 	isl_config_post.h \
+	isl_aff_lex_templ.c \
+	isl_align_params_templ.c \
+	isl_align_params_bin_templ.c \
 	basis_reduction_templ.c \
-	isl_hmap_templ.c \
+	isl_bind_domain_templ.c \
+	bset_to_bmap.c \
+	bset_from_bmap.c \
+	isl_check_named_params_templ.c \
+	check_reparse_templ.c \
+	check_reparse_test_templ.c \
+	check_single_reference_templ.c \
+	check_type_range_templ.c \
+	isl_copy_tuple_id_templ.c \
+	isl_domain_factor_templ.c \
+	extract_key.c \
+	isl_ilp_opt_multi_val_templ.c \
+	isl_ilp_opt_val_templ.c \
+	has_single_reference_templ.c \
+	isl_insert_domain_templ.c \
+	isl_list_macro.h \
 	isl_list_templ.c \
 	isl_list_templ.h \
+	isl_map_bound_templ.c \
 	isl_map_lexopt_templ.c \
+	isl_maybe_ast_graft_list.h \
+	isl_maybe_map.h \
+	isl_multi_macro.h \
+	isl_multi_bind_templ.c \
+	isl_multi_explicit_domain.c \
+	isl_multi_pw_aff_explicit_domain.c \
+	isl_multi_union_pw_aff_explicit_domain.c \
+	isl_multi_no_explicit_domain.c \
+	isl_multi_no_domain_templ.c \
 	isl_multi_templ.c \
 	isl_multi_templ.h \
+	isl_multi_add_constant_templ.c \
+	isl_multi_align_templ.c \
+	isl_multi_align_set.c \
+	isl_multi_align_union_set.c \
+	isl_multi_apply_templ.c \
+	isl_multi_apply_set.c \
+	isl_multi_apply_union_set.c \
+	isl_multi_arith_templ.c \
+	isl_multi_bind_domain_templ.c \
+	isl_multi_cmp.c \
+	isl_multi_coalesce.c \
+	isl_multi_dim_id_templ.c \
+	isl_multi_dims.c \
+	isl_multi_domain_templ.c \
+	isl_multi_floor.c \
+	isl_multi_from_base_templ.c \
+	isl_multi_gist.c \
+	isl_multi_hash.c \
+	isl_multi_insert_domain_templ.c \
+	isl_multi_intersect.c \
+	isl_multi_identity_templ.c \
+	isl_multi_locals_templ.c \
+	isl_multi_min_max_templ.c \
+	isl_multi_move_dims_templ.c \
+	isl_multi_nan_templ.c \
+	isl_multi_param_templ.c \
+	isl_multi_product_templ.c \
+	isl_multi_read_no_explicit_domain_templ.c \
+	isl_multi_splice_templ.c \
+	isl_multi_tuple_id_templ.c \
+	isl_multi_unbind_params_templ.c \
+	isl_multi_union_add_templ.c \
+	isl_multi_zero_templ.c \
+	isl_multi_zero_space_templ.c \
+	isl_opt_mpa_templ.c \
+	opt_type.h \
 	print_templ.c \
+	print_templ_yaml.c \
+	print_yaml_field_templ.c \
 	isl_power_templ.c \
+	isl_project_out_all_params_templ.c \
+	isl_pw_macro.h \
 	isl_pw_templ.c \
+	isl_pw_templ.h \
+	isl_pw_add_constant_templ.c \
+	isl_pw_add_constant_multi_val_templ.c \
+	isl_pw_add_constant_val_templ.c \
+	isl_pw_bind_domain_templ.c \
+	isl_pw_eval.c \
+	isl_pw_hash.c \
+	isl_pw_insert_dims_templ.c \
+	isl_pw_insert_domain_templ.c \
+	isl_pw_lift_templ.c \
+	isl_pw_locals_templ.c \
+	isl_pw_morph_templ.c \
+	isl_pw_move_dims_templ.c \
+	isl_pw_neg_templ.c \
+	isl_pw_opt_templ.c \
+	isl_pw_pullback_templ.c \
+	isl_pw_range_tuple_id_templ.c \
+	isl_pw_sub_templ.c \
+	isl_pw_union_opt.c \
+	read_in_string_templ.c \
+	set_to_map.c \
+	set_from_map.c \
+	set_list_from_map_list_inl.c \
+	isl_tab_lexopt_templ.c \
+	isl_test_list_templ.c \
+	isl_test_plain_equal_templ.c \
+	isl_type_check_equal_space_templ.c \
+	isl_type_has_equal_space_bin_templ.c \
+	isl_type_has_equal_space_templ.c \
+	isl_type_has_space_templ.c \
+	isl_unbind_params_templ.c \
+	uset_to_umap.c \
+	uset_from_umap.c \
+	isl_union_macro.h \
 	isl_union_templ.c \
-	isl.py \
+	isl_union_single.c \
+	isl_union_multi.c \
+	isl_union_eval.c \
+	isl_union_locals_templ.c \
+	isl_union_map_lex_templ.c \
+	isl_union_neg.c \
+	isl_union_pw_templ.c \
+	libisl-gdb.py \
+	doc/CodingStyle \
 	doc/SubmittingPatches \
-	doc/chicago.bst \
-	doc/chicago.sty \
 	doc/implementation.tex \
 	doc/isl.bib \
 	doc/mypod2latex \
 	doc/manual.tex \
+	doc/reading.tex \
 	doc/user.pod \
 	imath/gmp_compat.c \
 	imath/gmp_compat.h \
@@ -1030,17 +1492,21 @@
 	imath/imath.h \
 	imath/imrat.c \
 	imath/imrat.h \
-	interface/all.h \
-	interface/isl.py.top \
+	all.h \
+	cpp \
+	python \
+	isl_test_cpp-generic.cc \
+	isl_test_cpp_failed.sh \
+	isl_test_python.py \
 	test_inputs
 
 pkgconfigdir = $(pkgconfig_libdir)
 pkgconfig_DATA = $(pkgconfig_libfile)
-all: isl_config.h
+all: $(BUILT_SOURCES) isl_config.h
 	$(MAKE) $(AM_MAKEFLAGS) all-recursive
 
 .SUFFIXES:
-.SUFFIXES: .c .lo .log .o .obj .test .test$(EXEEXT) .trs
+.SUFFIXES: .c .cc .lo .log .o .obj .py .py$(EXEEXT) .trs
 am--refresh: Makefile
 	@:
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
@@ -1056,15 +1522,14 @@
 	echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign Makefile'; \
 	$(am__cd) $(top_srcdir) && \
 	  $(AUTOMAKE) --foreign Makefile
-.PRECIOUS: Makefile
 Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
 	@case '$?' in \
 	  *config.status*) \
 	    echo ' $(SHELL) ./config.status'; \
 	    $(SHELL) ./config.status;; \
 	  *) \
-	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe)'; \
-	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__depfiles_maybe);; \
+	    echo ' cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles)'; \
+	    cd $(top_builddir) && $(SHELL) ./config.status $@ $(am__maybe_remake_depfiles);; \
 	esac;
 
 $(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
@@ -1090,12 +1555,30 @@
 
 distclean-hdr:
 	-rm -f isl_config.h stamp-h1
+isl_srcdir.c: $(top_builddir)/config.status $(srcdir)/isl_srcdir.c.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
 bound_test.sh: $(top_builddir)/config.status $(srcdir)/bound_test.sh.in
 	cd $(top_builddir) && $(SHELL) ./config.status $@
 codegen_test.sh: $(top_builddir)/config.status $(srcdir)/codegen_test.sh.in
 	cd $(top_builddir) && $(SHELL) ./config.status $@
 pip_test.sh: $(top_builddir)/config.status $(srcdir)/pip_test.sh.in
 	cd $(top_builddir) && $(SHELL) ./config.status $@
+flow_test.sh: $(top_builddir)/config.status $(srcdir)/flow_test.sh.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+schedule_test.sh: $(top_builddir)/config.status $(srcdir)/schedule_test.sh.in
+	cd $(top_builddir) && $(SHELL) ./config.status $@
+
+clean-noinstPROGRAMS:
+	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
+	echo " rm -f" $$list; \
+	rm -f $$list || exit $$?; \
+	test -n "$(EXEEXT)" || exit 0; \
+	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+	echo " rm -f" $$list; \
+	rm -f $$list
+
+clean-noinstLIBRARIES:
+	-test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES)
 
 install-libLTLIBRARIES: $(lib_LTLIBRARIES)
 	@$(NORMAL_INSTALL)
@@ -1131,6 +1614,11 @@
 	  echo rm -f $${locs}; \
 	  rm -f $${locs}; \
 	}
+
+libdep.a: $(libdep_a_OBJECTS) $(libdep_a_DEPENDENCIES) $(EXTRA_libdep_a_DEPENDENCIES) 
+	$(AM_V_at)-rm -f libdep.a
+	$(AM_V_AR)$(libdep_a_AR) libdep.a $(libdep_a_OBJECTS) $(libdep_a_LIBADD)
+	$(AM_V_at)$(RANLIB) libdep.a
 imath_wrap/$(am__dirstamp):
 	@$(MKDIR_P) imath_wrap
 	@: > imath_wrap/$(am__dirstamp)
@@ -1147,15 +1635,6 @@
 libisl.la: $(libisl_la_OBJECTS) $(libisl_la_DEPENDENCIES) $(EXTRA_libisl_la_DEPENDENCIES) 
 	$(AM_V_CCLD)$(libisl_la_LINK) -rpath $(libdir) $(libisl_la_OBJECTS) $(libisl_la_LIBADD) $(LIBS)
 
-clean-noinstPROGRAMS:
-	@list='$(noinst_PROGRAMS)'; test -n "$$list" || exit 0; \
-	echo " rm -f" $$list; \
-	rm -f $$list || exit $$?; \
-	test -n "$(EXEEXT)" || exit 0; \
-	list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
-	echo " rm -f" $$list; \
-	rm -f $$list
-
 isl_bound$(EXEEXT): $(isl_bound_OBJECTS) $(isl_bound_DEPENDENCIES) $(EXTRA_isl_bound_DEPENDENCIES) 
 	@rm -f isl_bound$(EXEEXT)
 	$(AM_V_CCLD)$(isl_bound_LINK) $(isl_bound_OBJECTS) $(isl_bound_LDADD) $(LIBS)
@@ -1172,6 +1651,14 @@
 	@rm -f isl_codegen$(EXEEXT)
 	$(AM_V_CCLD)$(isl_codegen_LINK) $(isl_codegen_OBJECTS) $(isl_codegen_LDADD) $(LIBS)
 
+isl_flow$(EXEEXT): $(isl_flow_OBJECTS) $(isl_flow_DEPENDENCIES) $(EXTRA_isl_flow_DEPENDENCIES) 
+	@rm -f isl_flow$(EXEEXT)
+	$(AM_V_CCLD)$(isl_flow_LINK) $(isl_flow_OBJECTS) $(isl_flow_LDADD) $(LIBS)
+
+isl_flow_cmp$(EXEEXT): $(isl_flow_cmp_OBJECTS) $(isl_flow_cmp_DEPENDENCIES) $(EXTRA_isl_flow_cmp_DEPENDENCIES) 
+	@rm -f isl_flow_cmp$(EXEEXT)
+	$(AM_V_CCLD)$(isl_flow_cmp_LINK) $(isl_flow_cmp_OBJECTS) $(isl_flow_cmp_LDADD) $(LIBS)
+
 isl_pip$(EXEEXT): $(isl_pip_OBJECTS) $(isl_pip_DEPENDENCIES) $(EXTRA_isl_pip_DEPENDENCIES) 
 	@rm -f isl_pip$(EXEEXT)
 	$(AM_V_CCLD)$(isl_pip_LINK) $(isl_pip_OBJECTS) $(isl_pip_LDADD) $(LIBS)
@@ -1192,10 +1679,42 @@
 	@rm -f isl_polytope_scan$(EXEEXT)
 	$(AM_V_CCLD)$(LINK) $(isl_polytope_scan_OBJECTS) $(isl_polytope_scan_LDADD) $(LIBS)
 
+isl_schedule$(EXEEXT): $(isl_schedule_OBJECTS) $(isl_schedule_DEPENDENCIES) $(EXTRA_isl_schedule_DEPENDENCIES) 
+	@rm -f isl_schedule$(EXEEXT)
+	$(AM_V_CCLD)$(isl_schedule_LINK) $(isl_schedule_OBJECTS) $(isl_schedule_LDADD) $(LIBS)
+
+isl_schedule_cmp$(EXEEXT): $(isl_schedule_cmp_OBJECTS) $(isl_schedule_cmp_DEPENDENCIES) $(EXTRA_isl_schedule_cmp_DEPENDENCIES) 
+	@rm -f isl_schedule_cmp$(EXEEXT)
+	$(AM_V_CCLD)$(isl_schedule_cmp_LINK) $(isl_schedule_cmp_OBJECTS) $(isl_schedule_cmp_LDADD) $(LIBS)
+
 isl_test$(EXEEXT): $(isl_test_OBJECTS) $(isl_test_DEPENDENCIES) $(EXTRA_isl_test_DEPENDENCIES) 
 	@rm -f isl_test$(EXEEXT)
 	$(AM_V_CCLD)$(isl_test_LINK) $(isl_test_OBJECTS) $(isl_test_LDADD) $(LIBS)
 
+isl_test_cpp$(EXEEXT): $(isl_test_cpp_OBJECTS) $(isl_test_cpp_DEPENDENCIES) $(EXTRA_isl_test_cpp_DEPENDENCIES) 
+	@rm -f isl_test_cpp$(EXEEXT)
+	$(AM_V_CXXLD)$(isl_test_cpp_LINK) $(isl_test_cpp_OBJECTS) $(isl_test_cpp_LDADD) $(LIBS)
+
+isl_test_cpp-checked$(EXEEXT): $(isl_test_cpp_checked_OBJECTS) $(isl_test_cpp_checked_DEPENDENCIES) $(EXTRA_isl_test_cpp_checked_DEPENDENCIES) 
+	@rm -f isl_test_cpp-checked$(EXEEXT)
+	$(AM_V_CXXLD)$(isl_test_cpp_checked_LINK) $(isl_test_cpp_checked_OBJECTS) $(isl_test_cpp_checked_LDADD) $(LIBS)
+
+isl_test_cpp-checked-conversion$(EXEEXT): $(isl_test_cpp_checked_conversion_OBJECTS) $(isl_test_cpp_checked_conversion_DEPENDENCIES) $(EXTRA_isl_test_cpp_checked_conversion_DEPENDENCIES) 
+	@rm -f isl_test_cpp-checked-conversion$(EXEEXT)
+	$(AM_V_CXXLD)$(isl_test_cpp_checked_conversion_LINK) $(isl_test_cpp_checked_conversion_OBJECTS) $(isl_test_cpp_checked_conversion_LDADD) $(LIBS)
+
+isl_test_cpp_failed$(EXEEXT): $(isl_test_cpp_failed_OBJECTS) $(isl_test_cpp_failed_DEPENDENCIES) $(EXTRA_isl_test_cpp_failed_DEPENDENCIES) 
+	@rm -f isl_test_cpp_failed$(EXEEXT)
+	$(AM_V_CXXLD)$(isl_test_cpp_failed_LINK) $(isl_test_cpp_failed_OBJECTS) $(isl_test_cpp_failed_LDADD) $(LIBS)
+
+isl_test_imath$(EXEEXT): $(isl_test_imath_OBJECTS) $(isl_test_imath_DEPENDENCIES) $(EXTRA_isl_test_imath_DEPENDENCIES) 
+	@rm -f isl_test_imath$(EXEEXT)
+	$(AM_V_CCLD)$(isl_test_imath_LINK) $(isl_test_imath_OBJECTS) $(isl_test_imath_LDADD) $(LIBS)
+
+isl_test_int$(EXEEXT): $(isl_test_int_OBJECTS) $(isl_test_int_DEPENDENCIES) $(EXTRA_isl_test_int_DEPENDENCIES) 
+	@rm -f isl_test_int$(EXEEXT)
+	$(AM_V_CCLD)$(isl_test_int_LINK) $(isl_test_int_OBJECTS) $(isl_test_int_LDADD) $(LIBS)
+
 mostlyclean-compile:
 	-rm -f *.$(OBJEXT)
 	-rm -f imath_wrap/*.$(OBJEXT)
@@ -1204,91 +1723,120 @@
 distclean-compile:
 	-rm -f *.tab.c
 
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/basis_reduction_tab.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bound.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cat.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/codegen.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_aff.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_affine_hull.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_arg.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build_expr.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_codegen.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_graft.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_int.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_band.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_bernstein.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_blk.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_bound.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_coalesce.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_constraint.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_convex_hull.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ctx.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_deprecated.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_dim.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_dim_map.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_equalities.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_factorization.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_farkas.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_flow.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_fold.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_gmp.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_hash.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id_to_ast_expr.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id_to_pw_aff.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ilp.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_imath.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_input.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_local_space.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_lp.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_simplify.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_subtract.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_to_basic_set.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_mat.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_morph.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_obj.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_options.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_output.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_point.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_polynomial.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_printer.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_range.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_reordering.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_sample.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_scan.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_scheduler.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_seq.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_set_list.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_sort.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_space.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_stream.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tab.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tab_pip.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tarjan.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_transitive_closure.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_union_map.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val_gmp.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val_imath.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_vec.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_version.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_vertices.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp_get_memory_functions.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pip.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_detect_equalities.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_minimize.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_sample.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polytope_scan.Po@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/gmp_compat.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/imath.Plo@am__quote@
-@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/imrat.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/basis_reduction_tab.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bound.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/cat.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/closure.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/codegen.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dep.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flow.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flow_cmp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_aff.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_aff_map.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_affine_hull.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_arg.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_build_expr.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_codegen.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ast_graft.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_bernstein.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_blk.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_bound.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_box.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_coalesce.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_constraint.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_convex_hull.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ctx.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_deprecated.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_dim_map.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_equalities.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_factorization.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_farkas.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ffs.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_flow.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_fold.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_gmp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_hash.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id_to_ast_expr.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id_to_id.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_id_to_pw_aff.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_ilp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_imath.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_input.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_int_sioimath.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_local.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_local_space.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_lp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_list.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_simplify.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_subtract.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_map_to_basic_set.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_mat.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_morph.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_obj.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_options.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_output.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_point.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_polynomial.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_printer.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_range.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_reordering.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_sample.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_scan.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule_band.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule_constraints.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule_node.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule_read.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_schedule_tree.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_scheduler.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_seq.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_set_list.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_set_to_ast_graft_list.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_sort.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_space.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_stream.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_stride.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tab.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tab_pip.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_tarjan.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_cpp-checked-conversion.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_cpp-checked.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_cpp-isl_test_cpp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_imath.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_test_int.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_transitive_closure.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_union_map.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val_gmp.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val_imath.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_val_sioimath.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_vec.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_version.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/isl_vertices.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mp_get_memory_functions.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pip.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_detect_equalities.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_minimize.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polyhedron_sample.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/polytope_scan.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/print.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/schedule.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/schedule_cmp.Po@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/gmp_compat.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/imath.Plo@am__quote@ # am--include-marker
+@AMDEP_TRUE@@am__include@ @am__quote@imath_wrap/$(DEPDIR)/imrat.Plo@am__quote@ # am--include-marker
+
+$(am__depfiles_remade):
+	@$(MKDIR_P) $(@D)
+	@echo '# dummy' >$@-t && $(am__mv) $@-t $@
+
+am--depfiles: $(am__depfiles_remade)
 
 .c.o:
 @am__fastdepCC_TRUE@	$(AM_V_CC)depbase=`echo $@ | sed 's|^/*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
@@ -1314,6 +1862,58 @@
 @AMDEP_TRUE@@am__fastdepCC_FALSE@	DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCC_FALSE@	$(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $<
 
+.cc.o:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|^/*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ $<
+
+.cc.obj:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|^/*$$|$(DEPDIR)/&|;s|\.obj$$||'`;\
+@am__fastdepCXX_TRUE@	$(CXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ `$(CYGPATH_W) '$<'` &&\
+@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
+
+.cc.lo:
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)depbase=`echo $@ | sed 's|^/*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@	$(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@	$(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
+isl_test_cpp-isl_test_cpp.o: isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT isl_test_cpp-isl_test_cpp.o -MD -MP -MF $(DEPDIR)/isl_test_cpp-isl_test_cpp.Tpo -c -o isl_test_cpp-isl_test_cpp.o `test -f 'isl_test_cpp.cc' || echo '$(srcdir)/'`isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/isl_test_cpp-isl_test_cpp.Tpo $(DEPDIR)/isl_test_cpp-isl_test_cpp.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='isl_test_cpp.cc' object='isl_test_cpp-isl_test_cpp.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o isl_test_cpp-isl_test_cpp.o `test -f 'isl_test_cpp.cc' || echo '$(srcdir)/'`isl_test_cpp.cc
+
+isl_test_cpp-isl_test_cpp.obj: isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT isl_test_cpp-isl_test_cpp.obj -MD -MP -MF $(DEPDIR)/isl_test_cpp-isl_test_cpp.Tpo -c -o isl_test_cpp-isl_test_cpp.obj `if test -f 'isl_test_cpp.cc'; then $(CYGPATH_W) 'isl_test_cpp.cc'; else $(CYGPATH_W) '$(srcdir)/isl_test_cpp.cc'; fi`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/isl_test_cpp-isl_test_cpp.Tpo $(DEPDIR)/isl_test_cpp-isl_test_cpp.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='isl_test_cpp.cc' object='isl_test_cpp-isl_test_cpp.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o isl_test_cpp-isl_test_cpp.obj `if test -f 'isl_test_cpp.cc'; then $(CYGPATH_W) 'isl_test_cpp.cc'; else $(CYGPATH_W) '$(srcdir)/isl_test_cpp.cc'; fi`
+
+isl_test_cpp_failed-isl_test_cpp.o: isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_failed_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT isl_test_cpp_failed-isl_test_cpp.o -MD -MP -MF $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Tpo -c -o isl_test_cpp_failed-isl_test_cpp.o `test -f 'isl_test_cpp.cc' || echo '$(srcdir)/'`isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Tpo $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='isl_test_cpp.cc' object='isl_test_cpp_failed-isl_test_cpp.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_failed_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o isl_test_cpp_failed-isl_test_cpp.o `test -f 'isl_test_cpp.cc' || echo '$(srcdir)/'`isl_test_cpp.cc
+
+isl_test_cpp_failed-isl_test_cpp.obj: isl_test_cpp.cc
+@am__fastdepCXX_TRUE@	$(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_failed_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -MT isl_test_cpp_failed-isl_test_cpp.obj -MD -MP -MF $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Tpo -c -o isl_test_cpp_failed-isl_test_cpp.obj `if test -f 'isl_test_cpp.cc'; then $(CYGPATH_W) 'isl_test_cpp.cc'; else $(CYGPATH_W) '$(srcdir)/isl_test_cpp.cc'; fi`
+@am__fastdepCXX_TRUE@	$(AM_V_at)$(am__mv) $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Tpo $(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	$(AM_V_CXX)source='isl_test_cpp.cc' object='isl_test_cpp_failed-isl_test_cpp.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@	DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@	$(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(isl_test_cpp_failed_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) -c -o isl_test_cpp_failed-isl_test_cpp.obj `if test -f 'isl_test_cpp.cc'; then $(CYGPATH_W) 'isl_test_cpp.cc'; else $(CYGPATH_W) '$(srcdir)/isl_test_cpp.cc'; fi`
+
 mostlyclean-libtool:
 	-rm -f *.lo
 
@@ -1344,27 +1944,6 @@
 	@list='$(pkgconfig_DATA)'; test -n "$(pkgconfigdir)" || list=; \
 	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
 	dir='$(DESTDIR)$(pkgconfigdir)'; $(am__uninstall_files_from_dir)
-install-deprecatedHEADERS: $(deprecated_HEADERS)
-	@$(NORMAL_INSTALL)
-	@list='$(deprecated_HEADERS)'; test -n "$(deprecateddir)" || list=; \
-	if test -n "$$list"; then \
-	  echo " $(MKDIR_P) '$(DESTDIR)$(deprecateddir)'"; \
-	  $(MKDIR_P) "$(DESTDIR)$(deprecateddir)" || exit 1; \
-	fi; \
-	for p in $$list; do \
-	  if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
-	  echo "$$d$$p"; \
-	done | $(am__base_list) | \
-	while read files; do \
-	  echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(deprecateddir)'"; \
-	  $(INSTALL_HEADER) $$files "$(DESTDIR)$(deprecateddir)" || exit $$?; \
-	done
-
-uninstall-deprecatedHEADERS:
-	@$(NORMAL_UNINSTALL)
-	@list='$(deprecated_HEADERS)'; test -n "$(deprecateddir)" || list=; \
-	files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
-	dir='$(DESTDIR)$(deprecateddir)'; $(am__uninstall_files_from_dir)
 install-nodist_pkgincludeHEADERS: $(nodist_pkginclude_HEADERS)
 	@$(NORMAL_INSTALL)
 	@list='$(nodist_pkginclude_HEADERS)'; test -n "$(pkgincludedir)" || list=; \
@@ -1544,7 +2123,7 @@
 	if test -n "$$am__remaking_logs"; then \
 	  echo "fatal: making $(TEST_SUITE_LOG): possible infinite" \
 	       "recursion detected" >&2; \
-	else \
+	elif test -n "$$redo_logs"; then \
 	  am__remaking_logs=yes $(MAKE) $(AM_MAKEFLAGS) $$redo_logs; \
 	fi; \
 	if $(am__make_dryrun); then :; else \
@@ -1634,7 +2213,7 @@
 	fi;								\
 	$$success || exit 1
 
-check-TESTS:
+check-TESTS: 
 	@list='$(RECHECK_LOGS)';           test -z "$$list" || rm -f $$list
 	@list='$(RECHECK_LOGS:.log=.trs)'; test -z "$$list" || rm -f $$list
 	@test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
@@ -1683,22 +2262,81 @@
 	--log-file $$b.log --trs-file $$b.trs \
 	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
-.test.log:
+isl_test_int.log: isl_test_int$(EXEEXT)
+	@p='isl_test_int$(EXEEXT)'; \
+	b='isl_test_int'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+flow_test.sh.log: flow_test.sh
+	@p='flow_test.sh'; \
+	b='flow_test.sh'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+schedule_test.sh.log: schedule_test.sh
+	@p='schedule_test.sh'; \
+	b='schedule_test.sh'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+isl_test_cpp.log: isl_test_cpp$(EXEEXT)
+	@p='isl_test_cpp$(EXEEXT)'; \
+	b='isl_test_cpp'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+isl_test_cpp_failed.sh.log: isl_test_cpp_failed.sh
+	@p='isl_test_cpp_failed.sh'; \
+	b='isl_test_cpp_failed.sh'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+isl_test_cpp-checked.log: isl_test_cpp-checked$(EXEEXT)
+	@p='isl_test_cpp-checked$(EXEEXT)'; \
+	b='isl_test_cpp-checked'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+isl_test_cpp-checked-conversion.log: isl_test_cpp-checked-conversion$(EXEEXT)
+	@p='isl_test_cpp-checked-conversion$(EXEEXT)'; \
+	b='isl_test_cpp-checked-conversion'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+isl_test_imath.log: isl_test_imath$(EXEEXT)
+	@p='isl_test_imath$(EXEEXT)'; \
+	b='isl_test_imath'; \
+	$(am__check_pre) $(LOG_DRIVER) --test-name "$$f" \
+	--log-file $$b.log --trs-file $$b.trs \
+	$(am__common_driver_flags) $(AM_LOG_DRIVER_FLAGS) $(LOG_DRIVER_FLAGS) -- $(LOG_COMPILE) \
+	"$$tst" $(AM_TESTS_FD_REDIRECT)
+.py.log:
 	@p='$<'; \
 	$(am__set_b); \
-	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+	$(am__check_pre) $(PY_LOG_DRIVER) --test-name "$$f" \
 	--log-file $$b.log --trs-file $$b.trs \
-	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+	$(am__common_driver_flags) $(AM_PY_LOG_DRIVER_FLAGS) $(PY_LOG_DRIVER_FLAGS) -- $(PY_LOG_COMPILE) \
 	"$$tst" $(AM_TESTS_FD_REDIRECT)
-@am__EXEEXT_TRUE@.test$(EXEEXT).log:
+@am__EXEEXT_TRUE@.py$(EXEEXT).log:
 @am__EXEEXT_TRUE@	@p='$<'; \
 @am__EXEEXT_TRUE@	$(am__set_b); \
-@am__EXEEXT_TRUE@	$(am__check_pre) $(TEST_LOG_DRIVER) --test-name "$$f" \
+@am__EXEEXT_TRUE@	$(am__check_pre) $(PY_LOG_DRIVER) --test-name "$$f" \
 @am__EXEEXT_TRUE@	--log-file $$b.log --trs-file $$b.trs \
-@am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_TEST_LOG_DRIVER_FLAGS) $(TEST_LOG_DRIVER_FLAGS) -- $(TEST_LOG_COMPILE) \
+@am__EXEEXT_TRUE@	$(am__common_driver_flags) $(AM_PY_LOG_DRIVER_FLAGS) $(PY_LOG_DRIVER_FLAGS) -- $(PY_LOG_COMPILE) \
 @am__EXEEXT_TRUE@	"$$tst" $(AM_TESTS_FD_REDIRECT)
 
-distdir: $(DISTFILES)
+distdir: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) distdir-am
+
+distdir-am: $(DISTFILES)
 	$(am__remove_distdir)
 	test -d "$(distdir)" || mkdir "$(distdir)"
 	@srcdirstrip=`echo "$(srcdir)" | sed 's/.^$$\\*/\\\\&/g'`; \
@@ -1766,7 +2404,7 @@
 	  ! -type d ! -perm -444 -exec $(install_sh) -c -m a+r {} {} \; \
 	|| chmod -R a+r "$(distdir)"
 dist-gzip: distdir
-	tardir=$(distdir) && $(am__tar) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).tar.gz
+	tardir=$(distdir) && $(am__tar) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).tar.gz
 	$(am__post_remove_distdir)
 
 dist-bzip2: distdir
@@ -1782,17 +2420,17 @@
 	$(am__post_remove_distdir)
 
 dist-tarZ: distdir
-	@echo WARNING: "Support for shar distribution archives is" \
-	               "deprecated." >&2
+	@echo WARNING: "Support for distribution archives compressed with" \
+		       "legacy program 'compress' is deprecated." >&2
 	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
 	tardir=$(distdir) && $(am__tar) | compress -c >$(distdir).tar.Z
 	$(am__post_remove_distdir)
 
 dist-shar: distdir
-	@echo WARNING: "Support for distribution archives compressed with" \
-		       "legacy program 'compress' is deprecated." >&2
+	@echo WARNING: "Support for shar distribution archives is" \
+	               "deprecated." >&2
 	@echo WARNING: "It will be removed altogether in Automake 2.0" >&2
-	shar $(distdir) | GZIP=$(GZIP_ENV) gzip -c >$(distdir).shar.gz
+	shar $(distdir) | eval GZIP= gzip $(GZIP_ENV) -c >$(distdir).shar.gz
 	$(am__post_remove_distdir)
 
 dist-zip: distdir
@@ -1810,7 +2448,7 @@
 distcheck: dist
 	case '$(DIST_ARCHIVES)' in \
 	*.tar.gz*) \
-	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).tar.gz | $(am__untar) ;;\
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).tar.gz | $(am__untar) ;;\
 	*.tar.bz2*) \
 	  bzip2 -dc $(distdir).tar.bz2 | $(am__untar) ;;\
 	*.tar.lz*) \
@@ -1820,23 +2458,23 @@
 	*.tar.Z*) \
 	  uncompress -c $(distdir).tar.Z | $(am__untar) ;;\
 	*.shar.gz*) \
-	  GZIP=$(GZIP_ENV) gzip -dc $(distdir).shar.gz | unshar ;;\
+	  eval GZIP= gzip $(GZIP_ENV) -dc $(distdir).shar.gz | unshar ;;\
 	*.zip*) \
 	  unzip $(distdir).zip ;;\
 	esac
 	chmod -R a-w $(distdir)
 	chmod u+w $(distdir)
-	mkdir $(distdir)/_build $(distdir)/_inst
+	mkdir $(distdir)/_build $(distdir)/_build/sub $(distdir)/_inst
 	chmod a-w $(distdir)
 	test -d $(distdir)/_build || exit 0; \
 	dc_install_base=`$(am__cd) $(distdir)/_inst && pwd | sed -e 's,^^:\\/:\\/,/,'` \
 	  && dc_destdir="$${TMPDIR-/tmp}/am-dc-$$$$/" \
 	  && am__cwd=`pwd` \
-	  && $(am__cd) $(distdir)/_build \
-	  && ../configure \
+	  && $(am__cd) $(distdir)/_build/sub \
+	  && ../../configure \
 	    $(AM_DISTCHECK_CONFIGURE_FLAGS) \
 	    $(DISTCHECK_CONFIGURE_FLAGS) \
-	    --srcdir=.. --prefix="$$dc_install_base" \
+	    --srcdir=../.. --prefix="$$dc_install_base" \
 	  && $(MAKE) $(AM_MAKEFLAGS) \
 	  && $(MAKE) $(AM_MAKEFLAGS) dvi \
 	  && $(MAKE) $(AM_MAKEFLAGS) check \
@@ -1891,15 +2529,17 @@
 	       exit 1; } >&2
 check-am: all-am
 	$(MAKE) $(AM_MAKEFLAGS) check-TESTS
-check: check-recursive
-all-am: Makefile $(LTLIBRARIES) $(PROGRAMS) $(DATA) $(HEADERS) \
-		isl_config.h
+check: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) check-recursive
+all-am: Makefile $(PROGRAMS) $(LIBRARIES) $(LTLIBRARIES) $(DATA) \
+		$(HEADERS) isl_config.h
 installdirs: installdirs-recursive
 installdirs-am:
-	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(deprecateddir)" "$(DESTDIR)$(pkgincludedir)" "$(DESTDIR)$(pkgincludedir)"; do \
+	for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(pkgconfigdir)" "$(DESTDIR)$(pkgincludedir)" "$(DESTDIR)$(pkgincludedir)"; do \
 	  test -z "$$dir" || $(MKDIR_P) "$$dir"; \
 	done
-install: install-recursive
+install: $(BUILT_SOURCES)
+	$(MAKE) $(AM_MAKEFLAGS) install-recursive
 install-exec: install-exec-recursive
 install-data: install-data-recursive
 uninstall: uninstall-recursive
@@ -1924,24 +2564,134 @@
 	-test -z "$(TEST_SUITE_LOG)" || rm -f $(TEST_SUITE_LOG)
 
 clean-generic:
+	-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
 
 distclean-generic:
 	-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
 	-test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
 	-rm -f imath_wrap/$(DEPDIR)/$(am__dirstamp)
 	-rm -f imath_wrap/$(am__dirstamp)
+	-test -z "$(DISTCLEANFILES)" || rm -f $(DISTCLEANFILES)
 
 maintainer-clean-generic:
 	@echo "This command is intended for maintainers to use"
 	@echo "it deletes files that may require special tools to rebuild."
+	-test -z "$(BUILT_SOURCES)" || rm -f $(BUILT_SOURCES)
 clean: clean-recursive
 
 clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
-	clean-noinstPROGRAMS mostlyclean-am
+	clean-noinstLIBRARIES clean-noinstPROGRAMS mostlyclean-am
 
 distclean: distclean-recursive
 	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
-	-rm -rf ./$(DEPDIR) imath_wrap/$(DEPDIR)
+		-rm -f ./$(DEPDIR)/basis_reduction_tab.Plo
+	-rm -f ./$(DEPDIR)/bound.Po
+	-rm -f ./$(DEPDIR)/cat.Po
+	-rm -f ./$(DEPDIR)/closure.Po
+	-rm -f ./$(DEPDIR)/codegen.Po
+	-rm -f ./$(DEPDIR)/dep.Po
+	-rm -f ./$(DEPDIR)/flow.Po
+	-rm -f ./$(DEPDIR)/flow_cmp.Po
+	-rm -f ./$(DEPDIR)/isl_aff.Plo
+	-rm -f ./$(DEPDIR)/isl_aff_map.Plo
+	-rm -f ./$(DEPDIR)/isl_affine_hull.Plo
+	-rm -f ./$(DEPDIR)/isl_arg.Plo
+	-rm -f ./$(DEPDIR)/isl_ast.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_build.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_build_expr.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_codegen.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_graft.Plo
+	-rm -f ./$(DEPDIR)/isl_bernstein.Plo
+	-rm -f ./$(DEPDIR)/isl_blk.Plo
+	-rm -f ./$(DEPDIR)/isl_bound.Plo
+	-rm -f ./$(DEPDIR)/isl_box.Plo
+	-rm -f ./$(DEPDIR)/isl_coalesce.Plo
+	-rm -f ./$(DEPDIR)/isl_constraint.Plo
+	-rm -f ./$(DEPDIR)/isl_convex_hull.Plo
+	-rm -f ./$(DEPDIR)/isl_ctx.Plo
+	-rm -f ./$(DEPDIR)/isl_deprecated.Plo
+	-rm -f ./$(DEPDIR)/isl_dim_map.Plo
+	-rm -f ./$(DEPDIR)/isl_equalities.Plo
+	-rm -f ./$(DEPDIR)/isl_factorization.Plo
+	-rm -f ./$(DEPDIR)/isl_farkas.Plo
+	-rm -f ./$(DEPDIR)/isl_ffs.Plo
+	-rm -f ./$(DEPDIR)/isl_flow.Plo
+	-rm -f ./$(DEPDIR)/isl_fold.Plo
+	-rm -f ./$(DEPDIR)/isl_gmp.Plo
+	-rm -f ./$(DEPDIR)/isl_hash.Plo
+	-rm -f ./$(DEPDIR)/isl_id.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_ast_expr.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_id.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_pw_aff.Plo
+	-rm -f ./$(DEPDIR)/isl_ilp.Plo
+	-rm -f ./$(DEPDIR)/isl_imath.Plo
+	-rm -f ./$(DEPDIR)/isl_input.Plo
+	-rm -f ./$(DEPDIR)/isl_int_sioimath.Plo
+	-rm -f ./$(DEPDIR)/isl_local.Plo
+	-rm -f ./$(DEPDIR)/isl_local_space.Plo
+	-rm -f ./$(DEPDIR)/isl_lp.Plo
+	-rm -f ./$(DEPDIR)/isl_map.Plo
+	-rm -f ./$(DEPDIR)/isl_map_list.Plo
+	-rm -f ./$(DEPDIR)/isl_map_simplify.Plo
+	-rm -f ./$(DEPDIR)/isl_map_subtract.Plo
+	-rm -f ./$(DEPDIR)/isl_map_to_basic_set.Plo
+	-rm -f ./$(DEPDIR)/isl_mat.Plo
+	-rm -f ./$(DEPDIR)/isl_morph.Plo
+	-rm -f ./$(DEPDIR)/isl_obj.Plo
+	-rm -f ./$(DEPDIR)/isl_options.Plo
+	-rm -f ./$(DEPDIR)/isl_output.Plo
+	-rm -f ./$(DEPDIR)/isl_point.Plo
+	-rm -f ./$(DEPDIR)/isl_polynomial.Plo
+	-rm -f ./$(DEPDIR)/isl_printer.Plo
+	-rm -f ./$(DEPDIR)/isl_range.Plo
+	-rm -f ./$(DEPDIR)/isl_reordering.Plo
+	-rm -f ./$(DEPDIR)/isl_sample.Plo
+	-rm -f ./$(DEPDIR)/isl_scan.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_band.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_constraints.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_node.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_read.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_tree.Plo
+	-rm -f ./$(DEPDIR)/isl_scheduler.Plo
+	-rm -f ./$(DEPDIR)/isl_seq.Plo
+	-rm -f ./$(DEPDIR)/isl_set_list.Plo
+	-rm -f ./$(DEPDIR)/isl_set_to_ast_graft_list.Plo
+	-rm -f ./$(DEPDIR)/isl_sort.Plo
+	-rm -f ./$(DEPDIR)/isl_space.Plo
+	-rm -f ./$(DEPDIR)/isl_stream.Plo
+	-rm -f ./$(DEPDIR)/isl_stride.Plo
+	-rm -f ./$(DEPDIR)/isl_tab.Plo
+	-rm -f ./$(DEPDIR)/isl_tab_pip.Plo
+	-rm -f ./$(DEPDIR)/isl_tarjan.Plo
+	-rm -f ./$(DEPDIR)/isl_test.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-checked-conversion.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-checked.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-isl_test_cpp.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po
+	-rm -f ./$(DEPDIR)/isl_test_imath.Po
+	-rm -f ./$(DEPDIR)/isl_test_int.Po
+	-rm -f ./$(DEPDIR)/isl_transitive_closure.Plo
+	-rm -f ./$(DEPDIR)/isl_union_map.Plo
+	-rm -f ./$(DEPDIR)/isl_val.Plo
+	-rm -f ./$(DEPDIR)/isl_val_gmp.Plo
+	-rm -f ./$(DEPDIR)/isl_val_imath.Plo
+	-rm -f ./$(DEPDIR)/isl_val_sioimath.Plo
+	-rm -f ./$(DEPDIR)/isl_vec.Plo
+	-rm -f ./$(DEPDIR)/isl_version.Plo
+	-rm -f ./$(DEPDIR)/isl_vertices.Plo
+	-rm -f ./$(DEPDIR)/mp_get_memory_functions.Plo
+	-rm -f ./$(DEPDIR)/pip.Po
+	-rm -f ./$(DEPDIR)/polyhedron_detect_equalities.Po
+	-rm -f ./$(DEPDIR)/polyhedron_minimize.Po
+	-rm -f ./$(DEPDIR)/polyhedron_sample.Po
+	-rm -f ./$(DEPDIR)/polytope_scan.Po
+	-rm -f ./$(DEPDIR)/print.Plo
+	-rm -f ./$(DEPDIR)/schedule.Po
+	-rm -f ./$(DEPDIR)/schedule_cmp.Po
+	-rm -f imath_wrap/$(DEPDIR)/gmp_compat.Plo
+	-rm -f imath_wrap/$(DEPDIR)/imath.Plo
+	-rm -f imath_wrap/$(DEPDIR)/imrat.Plo
 	-rm -f Makefile
 distclean-am: clean-am distclean-compile distclean-generic \
 	distclean-hdr distclean-libtool distclean-tags
@@ -1958,9 +2708,8 @@
 
 info-am:
 
-install-data-am: install-data-local install-deprecatedHEADERS \
-	install-nodist_pkgincludeHEADERS install-pkgconfigDATA \
-	install-pkgincludeHEADERS
+install-data-am: install-data-local install-nodist_pkgincludeHEADERS \
+	install-pkgconfigDATA install-pkgincludeHEADERS
 
 install-dvi: install-dvi-recursive
 
@@ -1991,7 +2740,114 @@
 maintainer-clean: maintainer-clean-recursive
 	-rm -f $(am__CONFIG_DISTCLEAN_FILES)
 	-rm -rf $(top_srcdir)/autom4te.cache
-	-rm -rf ./$(DEPDIR) imath_wrap/$(DEPDIR)
+		-rm -f ./$(DEPDIR)/basis_reduction_tab.Plo
+	-rm -f ./$(DEPDIR)/bound.Po
+	-rm -f ./$(DEPDIR)/cat.Po
+	-rm -f ./$(DEPDIR)/closure.Po
+	-rm -f ./$(DEPDIR)/codegen.Po
+	-rm -f ./$(DEPDIR)/dep.Po
+	-rm -f ./$(DEPDIR)/flow.Po
+	-rm -f ./$(DEPDIR)/flow_cmp.Po
+	-rm -f ./$(DEPDIR)/isl_aff.Plo
+	-rm -f ./$(DEPDIR)/isl_aff_map.Plo
+	-rm -f ./$(DEPDIR)/isl_affine_hull.Plo
+	-rm -f ./$(DEPDIR)/isl_arg.Plo
+	-rm -f ./$(DEPDIR)/isl_ast.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_build.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_build_expr.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_codegen.Plo
+	-rm -f ./$(DEPDIR)/isl_ast_graft.Plo
+	-rm -f ./$(DEPDIR)/isl_bernstein.Plo
+	-rm -f ./$(DEPDIR)/isl_blk.Plo
+	-rm -f ./$(DEPDIR)/isl_bound.Plo
+	-rm -f ./$(DEPDIR)/isl_box.Plo
+	-rm -f ./$(DEPDIR)/isl_coalesce.Plo
+	-rm -f ./$(DEPDIR)/isl_constraint.Plo
+	-rm -f ./$(DEPDIR)/isl_convex_hull.Plo
+	-rm -f ./$(DEPDIR)/isl_ctx.Plo
+	-rm -f ./$(DEPDIR)/isl_deprecated.Plo
+	-rm -f ./$(DEPDIR)/isl_dim_map.Plo
+	-rm -f ./$(DEPDIR)/isl_equalities.Plo
+	-rm -f ./$(DEPDIR)/isl_factorization.Plo
+	-rm -f ./$(DEPDIR)/isl_farkas.Plo
+	-rm -f ./$(DEPDIR)/isl_ffs.Plo
+	-rm -f ./$(DEPDIR)/isl_flow.Plo
+	-rm -f ./$(DEPDIR)/isl_fold.Plo
+	-rm -f ./$(DEPDIR)/isl_gmp.Plo
+	-rm -f ./$(DEPDIR)/isl_hash.Plo
+	-rm -f ./$(DEPDIR)/isl_id.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_ast_expr.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_id.Plo
+	-rm -f ./$(DEPDIR)/isl_id_to_pw_aff.Plo
+	-rm -f ./$(DEPDIR)/isl_ilp.Plo
+	-rm -f ./$(DEPDIR)/isl_imath.Plo
+	-rm -f ./$(DEPDIR)/isl_input.Plo
+	-rm -f ./$(DEPDIR)/isl_int_sioimath.Plo
+	-rm -f ./$(DEPDIR)/isl_local.Plo
+	-rm -f ./$(DEPDIR)/isl_local_space.Plo
+	-rm -f ./$(DEPDIR)/isl_lp.Plo
+	-rm -f ./$(DEPDIR)/isl_map.Plo
+	-rm -f ./$(DEPDIR)/isl_map_list.Plo
+	-rm -f ./$(DEPDIR)/isl_map_simplify.Plo
+	-rm -f ./$(DEPDIR)/isl_map_subtract.Plo
+	-rm -f ./$(DEPDIR)/isl_map_to_basic_set.Plo
+	-rm -f ./$(DEPDIR)/isl_mat.Plo
+	-rm -f ./$(DEPDIR)/isl_morph.Plo
+	-rm -f ./$(DEPDIR)/isl_obj.Plo
+	-rm -f ./$(DEPDIR)/isl_options.Plo
+	-rm -f ./$(DEPDIR)/isl_output.Plo
+	-rm -f ./$(DEPDIR)/isl_point.Plo
+	-rm -f ./$(DEPDIR)/isl_polynomial.Plo
+	-rm -f ./$(DEPDIR)/isl_printer.Plo
+	-rm -f ./$(DEPDIR)/isl_range.Plo
+	-rm -f ./$(DEPDIR)/isl_reordering.Plo
+	-rm -f ./$(DEPDIR)/isl_sample.Plo
+	-rm -f ./$(DEPDIR)/isl_scan.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_band.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_constraints.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_node.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_read.Plo
+	-rm -f ./$(DEPDIR)/isl_schedule_tree.Plo
+	-rm -f ./$(DEPDIR)/isl_scheduler.Plo
+	-rm -f ./$(DEPDIR)/isl_seq.Plo
+	-rm -f ./$(DEPDIR)/isl_set_list.Plo
+	-rm -f ./$(DEPDIR)/isl_set_to_ast_graft_list.Plo
+	-rm -f ./$(DEPDIR)/isl_sort.Plo
+	-rm -f ./$(DEPDIR)/isl_space.Plo
+	-rm -f ./$(DEPDIR)/isl_stream.Plo
+	-rm -f ./$(DEPDIR)/isl_stride.Plo
+	-rm -f ./$(DEPDIR)/isl_tab.Plo
+	-rm -f ./$(DEPDIR)/isl_tab_pip.Plo
+	-rm -f ./$(DEPDIR)/isl_tarjan.Plo
+	-rm -f ./$(DEPDIR)/isl_test.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-checked-conversion.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-checked.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp-isl_test_cpp.Po
+	-rm -f ./$(DEPDIR)/isl_test_cpp_failed-isl_test_cpp.Po
+	-rm -f ./$(DEPDIR)/isl_test_imath.Po
+	-rm -f ./$(DEPDIR)/isl_test_int.Po
+	-rm -f ./$(DEPDIR)/isl_transitive_closure.Plo
+	-rm -f ./$(DEPDIR)/isl_union_map.Plo
+	-rm -f ./$(DEPDIR)/isl_val.Plo
+	-rm -f ./$(DEPDIR)/isl_val_gmp.Plo
+	-rm -f ./$(DEPDIR)/isl_val_imath.Plo
+	-rm -f ./$(DEPDIR)/isl_val_sioimath.Plo
+	-rm -f ./$(DEPDIR)/isl_vec.Plo
+	-rm -f ./$(DEPDIR)/isl_version.Plo
+	-rm -f ./$(DEPDIR)/isl_vertices.Plo
+	-rm -f ./$(DEPDIR)/mp_get_memory_functions.Plo
+	-rm -f ./$(DEPDIR)/pip.Po
+	-rm -f ./$(DEPDIR)/polyhedron_detect_equalities.Po
+	-rm -f ./$(DEPDIR)/polyhedron_minimize.Po
+	-rm -f ./$(DEPDIR)/polyhedron_sample.Po
+	-rm -f ./$(DEPDIR)/polytope_scan.Po
+	-rm -f ./$(DEPDIR)/print.Plo
+	-rm -f ./$(DEPDIR)/schedule.Po
+	-rm -f ./$(DEPDIR)/schedule_cmp.Po
+	-rm -f imath_wrap/$(DEPDIR)/gmp_compat.Plo
+	-rm -f imath_wrap/$(DEPDIR)/imath.Plo
+	-rm -f imath_wrap/$(DEPDIR)/imrat.Plo
 	-rm -f Makefile
 maintainer-clean-am: distclean-am maintainer-clean-generic
 
@@ -2008,23 +2864,24 @@
 
 ps-am:
 
-uninstall-am: uninstall-deprecatedHEADERS uninstall-libLTLIBRARIES \
+uninstall-am: uninstall-libLTLIBRARIES uninstall-local \
 	uninstall-nodist_pkgincludeHEADERS uninstall-pkgconfigDATA \
 	uninstall-pkgincludeHEADERS
 
-.MAKE: $(am__recursive_targets) all check-am install-am install-strip
+.MAKE: $(am__recursive_targets) all check check-am install install-am \
+	install-strip
 
 .PHONY: $(am__recursive_targets) CTAGS GTAGS TAGS all all-am \
-	am--refresh check check-TESTS check-am clean clean-cscope \
-	clean-generic clean-libLTLIBRARIES clean-libtool \
-	clean-noinstPROGRAMS cscope cscopelist-am ctags ctags-am dist \
-	dist-all dist-bzip2 dist-gzip dist-hook dist-lzip dist-shar \
-	dist-tarZ dist-xz dist-zip distcheck distclean \
-	distclean-compile distclean-generic distclean-hdr \
-	distclean-libtool distclean-tags distcleancheck distdir \
-	distuninstallcheck dvi dvi-am html html-am info info-am \
-	install install-am install-data install-data-am \
-	install-data-local install-deprecatedHEADERS install-dvi \
+	am--depfiles am--refresh check check-TESTS check-am clean \
+	clean-cscope clean-generic clean-libLTLIBRARIES clean-libtool \
+	clean-noinstLIBRARIES clean-noinstPROGRAMS cscope \
+	cscopelist-am ctags ctags-am dist dist-all dist-bzip2 \
+	dist-gzip dist-hook dist-lzip dist-shar dist-tarZ dist-xz \
+	dist-zip distcheck distclean distclean-compile \
+	distclean-generic distclean-hdr distclean-libtool \
+	distclean-tags distcleancheck distdir distuninstallcheck dvi \
+	dvi-am html html-am info info-am install install-am \
+	install-data install-data-am install-data-local install-dvi \
 	install-dvi-am install-exec install-exec-am install-html \
 	install-html-am install-info install-info-am \
 	install-libLTLIBRARIES install-man \
@@ -2035,10 +2892,67 @@
 	maintainer-clean-generic mostlyclean mostlyclean-compile \
 	mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
 	recheck tags tags-am uninstall uninstall-am \
-	uninstall-deprecatedHEADERS uninstall-libLTLIBRARIES \
+	uninstall-libLTLIBRARIES uninstall-local \
 	uninstall-nodist_pkgincludeHEADERS uninstall-pkgconfigDATA \
 	uninstall-pkgincludeHEADERS
 
+.PRECIOUS: Makefile
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@FORCE:
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@interface/extract_interface$(BUILD_EXEEXT): FORCE
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(MAKE) $(AM_MAKEFLAGS) -C interface extract_interface$(BUILD_EXEEXT)
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@@HAVE_PYTHON_TRUE@  isl_test_python.py: interface/isl.py libisl.la
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@interface/isldlname.py: libisl.la
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(AM_V_GEN) $(GREP) dlname $< | $(SED) -e 's/dlname/isl_dlname/' > $@
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@interface/isl.py: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		python/isl.py.top interface/isldlname.py
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	(cat interface/isldlname.py $(srcdir)/python/isl.py.top && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) --language=python \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			$(includes) $(srcdir)/all.h) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			> $@ || (rm $@ && false)
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@include/isl/cpp.h: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cpp/cpp.h.top cpp/cpp.h.bot
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(MKDIR_P) "include/isl" && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	(cat $(srcdir)/cpp/cpp.h.top $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) --language=cpp \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			$(includes) $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cat $(srcdir)/cpp/cpp.h.bot) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			> $@ || (rm $@ && false)
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@include/isl/cpp-checked.h: interface/extract_interface$(BUILD_EXEEXT) libdep.a \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cpp/cpp-checked.h.top cpp/cpp-checked.h.bot
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(MKDIR_P) "include/isl" && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	(cat $(srcdir)/cpp/cpp-checked.h.top $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			--language=cpp-checked \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			$(includes) $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cat $(srcdir)/cpp/cpp-checked.h.bot) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			> $@ || (rm $@ && false)
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@include/isl/cpp-checked-conversion.h: \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		libdep.a \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cpp/cpp-checked-conversion.h.top \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cpp/cpp-checked-conversion.h.bot
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(MKDIR_P) "include/isl" && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	(cat $(srcdir)/cpp/cpp-checked-conversion.h.top && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			--language=cpp-checked-conversion \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			$(includes) $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cat $(srcdir)/cpp/cpp-checked-conversion.h.bot) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			> $@ || (rm $@ && false)
+
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@include/isl/typed_cpp.h: interface/extract_interface$(BUILD_EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		libdep.a cpp/typed_cpp.h.top cpp/typed_cpp.h.bot
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	$(MKDIR_P) "include/isl" && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@	(cat $(srcdir)/cpp/typed_cpp.h.top && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		interface/extract_interface$(BUILD_EXEEXT) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			--language=template-cpp \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			$(includes) $(srcdir)/all.h && \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@		cat $(srcdir)/cpp/typed_cpp.h.bot) \
+@HAVE_CLANG_TRUE@@HAVE_CXX11_TRUE@			> $@ || (rm $@ && false)
 
 dist-hook:
 	echo @GIT_HEAD_VERSION@ > $(distdir)/GIT_HEAD_ID
@@ -2048,15 +2962,24 @@
 gitversion.h: @GIT_HEAD@
 	$(AM_V_GEN)echo '#define GIT_HEAD_ID "'@GIT_HEAD_VERSION@'"' > $@
 
-install-data-local: $(srcdir)/isl.py
+install-data-local: $(srcdir)/libisl-gdb.py
 	@libisl=`sed -ne "/^library_names=/{s/.*='//;s/'$$//;s/ .*//;p;}" \
 		 $(builddir)/libisl.la`; \
 	case $$libisl in \
 	'') echo Cannot find isl library name. GDB bindings not installed.;; \
-	*) echo $(INSTALL_DATA) $(srcdir)/isl.py \
+	*) echo $(INSTALL_DATA) $(srcdir)/libisl-gdb.py \
 		$(DESTDIR)$(libdir)/$$libisl-gdb.py; \
 	test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"; \
-	$(INSTALL_DATA) $(srcdir)/isl.py $(DESTDIR)$(libdir)/$$libisl-gdb.py; esac
+	$(INSTALL_DATA) $(srcdir)/libisl-gdb.py \
+	    $(DESTDIR)$(libdir)/$$libisl-gdb.py; \
+	esac
+
+uninstall-local:
+	@libisl=`sed -ne "/^library_names=/{s/.*='//;s/'$$//;s/ .*//;p;}" \
+		 $(builddir)/libisl.la`; \
+	if test -n "$${libisl}"; then \
+		rm -f $(DESTDIR)$(libdir)/$$libisl-gdb.py; \
+	fi
 
 # Tell versions 3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

_service:tar_scm:isl-0.14.tar.xz/README -> _service:tar_scm:isl-0.24.tar.gz/README Changed

_service:tar_scm:isl-0.14.tar.xz/aclocal.m4 -> _service:tar_scm:isl-0.24.tar.gz/aclocal.m4 Changed

@@ -1,6 +1,6 @@
-# generated automatically by aclocal 1.14.1 -*- Autoconf -*-
+# generated automatically by aclocal 1.16.1 -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -20,7 +20,7 @@
 If you have problems, you may need to regenerate the build system entirely.
 To do so, use the procedure documented by the package, typically 'autoreconf'.))
 
-# Copyright (C) 2002-2013 Free Software Foundation, Inc.
+# Copyright (C) 2002-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -32,10 +32,10 @@
 # generated from the m4 files accompanying Automake X.Y.
 # (This private macro should not be called outside this file.)
 AC_DEFUN(AM_AUTOMAKE_VERSION,
-am__api_version='1.14'
+am__api_version='1.16'
 dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
 dnl require some minimum version.  Point them to the right macro.
-m4_if($1, 1.14.1, ,
+m4_if($1, 1.16.1, ,
       AC_FATAL(Do not call $0, use AM_INIT_AUTOMAKE($1).))dnl
 )
 
@@ -51,14 +51,14 @@
 # Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
 # This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
 AC_DEFUN(AM_SET_CURRENT_AUTOMAKE_VERSION,
-AM_AUTOMAKE_VERSION(1.14.1)dnl
+AM_AUTOMAKE_VERSION(1.16.1)dnl
 m4_ifndef(AC_AUTOCONF_VERSION,
   m4_copy(m4_PACKAGE_VERSION, AC_AUTOCONF_VERSION))dnl
 _AM_AUTOCONF_VERSION(m4_defn(AC_AUTOCONF_VERSION)))
 
 # AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -103,15 +103,14 @@
 # configured tree to be moved without reconfiguration.
 
 AC_DEFUN(AM_AUX_DIR_EXPAND,
-dnl Rely on autoconf to set up CDPATH properly.
-AC_PREREQ(2.50)dnl
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
+AC_REQUIRE(AC_CONFIG_AUX_DIR_DEFAULT)dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
 )
 
 # AM_CONDITIONAL                                            -*- Autoconf -*-
 
-# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -142,7 +141,7 @@
 Usually this means the macro was only invoked conditionally.)
 fi))
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -333,13 +332,12 @@
 
 # Generate code to set up dependency tracking.              -*- Autoconf -*-
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
 # with or without modifications, as long as this notice is preserved.
 
-
 # _AM_OUTPUT_DEPENDENCY_COMMANDS
 # ------------------------------
 AC_DEFUN(_AM_OUTPUT_DEPENDENCY_COMMANDS,
@@ -347,49 +345,41 @@
   # Older Autoconf quotes --file arguments for eval, but not when files
   # are listed without --file.  Let's play safe and only enable the eval
   # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE($CONFIG_FILES,
+          *\'*, eval set x "$CONFIG_FILES",
+          *, set x $CONFIG_FILES)
   shift
-  for mf
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
   do
     # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named 'Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
+    am_mf=`AS_ECHO("$am_mf") | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
     # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`AS_DIRNAME("$mf")`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running 'make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "$am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote$.*(DEPDIR).*$$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`AS_DIRNAME("$file")`
-      AS_MKDIR_P($dirpart/$fdir)
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME("$am_mf")`
+    am_filepart=`AS_BASENAME("$am_mf")`
+    AM_RUN_LOG(cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) || am_rc=$?
   done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE(Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).)
+  fi
+  AS_UNSET(am_dirpart)
+  AS_UNSET(am_filepart)
+  AS_UNSET(am_mf)
+  AS_UNSET(am_rc)
+  rm -f conftest-deps.mk
 }
 )# _AM_OUTPUT_DEPENDENCY_COMMANDS
 
@@ -398,18 +388,17 @@
 # -----------------------------
 # This macro should only be invoked once -- use via AC_REQUIRE.
 #
-# This code is only required when automatic dependency tracking
-# is enabled.  FIXME.  This creates each '.P' file that we will
-# need in order to bootstrap the dependency handling code.
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
 AC_DEFUN(AM_OUTPUT_DEPENDENCY_COMMANDS,
 AC_CONFIG_COMMANDS(depfiles,
      test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS,
-     AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir")
-)
+     AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"))
 
 # Do all the work for Automake.                             -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -496,11 +485,11 @@
 AC_REQUIRE(AC_PROG_MKDIR_P)dnl
 # For better backward compatibility.  To be removed once Automake 1.9.x
 # dies out for good.  For more background, see:
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
 AC_SUBST(mkdir_p, '$(MKDIR_P)')
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
 AC_REQUIRE(AC_PROG_AWK)dnl
 AC_REQUIRE(AC_PROG_MAKE_SET)dnl
 AC_REQUIRE(AM_SET_LEADING_DOT)dnl
@@ -564,7 +553,7 @@
 Aborting the configuration process, to ensure you take notice of the issue.
 
 You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <http://www.gnu.org/software/coreutils/>.
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
 
 If you want to complete the configuration process using your problematic
 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
@@ -573,7 +562,11 @@
 END
     AC_MSG_ERROR(Your 'rm' program is bad, sorry.)
   fi
-fi)
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+)
 
 dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
 dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
@@ -602,7 +595,7 @@
 done
 echo "timestamp for $_am_arg" >`AS_DIRNAME("$_am_arg")`/stamp-h$_am_stamp_count)
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -613,7 +606,7 @@
 # Define $install_sh.
 AC_DEFUN(AM_PROG_INSTALL_SH,
 AC_REQUIRE(AM_AUX_DIR_EXPAND)dnl
-if test x"${install_sh}" != xset; then
+if test x"${install_sh+set}" != xset; then
   case $am_aux_dir in
   *\ * | *\	*)
     install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
@@ -623,7 +616,7 @@
 fi
 AC_SUBST(install_sh))
 
-# Copyright (C) 2003-2013 Free Software Foundation, Inc.
+# Copyright (C) 2003-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -644,7 +637,7 @@
 
 # Check to see how 'make' treats includes.	            -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -652,49 +645,42 @@
 
 # AM_MAKE_INCLUDE()
 # -----------------
-# Check to see how make treats includes.
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
 AC_DEFUN(AM_MAKE_INCLUDE,
-am_make=${MAKE-make}
-cat > confinc << 'END'
+AC_MSG_CHECKING(whether ${MAKE-make} supports the include directive)
+cat > confinc.mk << 'END'
 am__doit:
-	@echo this is the am__doit target
+	@echo this is the am__doit target >confinc.out
 .PHONY: am__doit
 END
-# If we don't find an include directive, just comment out the code.
-AC_MSG_CHECKING(for style of include used by $am_make)
 am__include="#"
 am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from 'make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
-     ;;
-   esac
-fi
-AC_SUBST(am__include)
-AC_SUBST(am__quote)
-AC_MSG_RESULT($_am_result)
-rm -f confinc confmf
-)
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG(${MAKE-make} -f confmf.$s && cat confinc.out)
+  AS_CASE($?:`cat confinc.out 2>/dev/null`,
+      '0:this is the am__doit target',
+      AS_CASE($s,
+          BSD, am__include='.include' am__quote='"',
+          am__include='include' am__quote=''))
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT(${_am_result})
+AC_SUBST(am__include))
+AC_SUBST(am__quote))
 
 # Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
 
-# Copyright (C) 1997-2013 Free Software Foundation, Inc.
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -733,7 +719,7 @@
 
 # Helper functions for option handling.                     -*- Autoconf -*-
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -762,7 +748,7 @@
 AC_DEFUN(_AM_IF_OPTION,
 m4_ifset(_AM_MANGLE_OPTION($1), $2, $3))
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -809,7 +795,245 @@
 # For backward compatibility.
 AC_DEFUN_ONCE(AM_PROG_CC_C_O, AC_REQUIRE(AC_PROG_CC))
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# AM_PATH_PYTHON(MINIMUM-VERSION, ACTION-IF-FOUND, ACTION-IF-NOT-FOUND)
+# ---------------------------------------------------------------------------
+# Adds support for distributing Python modules and packages.  To
+# install modules, copy them to $(pythondir), using the python_PYTHON
+# automake variable.  To install a package with the same name as the
+# automake package, install to $(pkgpythondir), or use the
+# pkgpython_PYTHON automake variable.
+#
+# The variables $(pyexecdir) and $(pkgpyexecdir) are provided as
+# locations to install python extension modules (shared libraries).
+# Another macro is required to find the appropriate flags to compile
+# extension modules.
+#
+# If your package is configured with a different prefix to python,
+# users will have to add the install directory to the PYTHONPATH
+# environment variable, or create a .pth file (see the python
+# documentation for details).
+#
+# If the MINIMUM-VERSION argument is passed, AM_PATH_PYTHON will
+# cause an error if the version of python installed on the system
+# doesn't meet the requirement.  MINIMUM-VERSION should consist of
+# numbers and dots only.
+AC_DEFUN(AM_PATH_PYTHON,
+ 
+  dnl Find a Python interpreter.  Python versions prior to 2.0 are not
+  dnl supported. (2.0 was released on October 16, 2000).
+  m4_define_default(_AM_PYTHON_INTERPRETER_LIST,
+python python2 python3 dnl
+ python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3 dnl
+ python3.2 python3.1 python3.0 dnl
+ python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1 dnl
+ python2.0)
+
+  AC_ARG_VAR(PYTHON, the Python interpreter)
+
+  m4_if($1,,
+    dnl No version check is needed.
+    # Find any Python interpreter.
+    if test -z "$PYTHON"; then
+      AC_PATH_PROGS(PYTHON, _AM_PYTHON_INTERPRETER_LIST, :)
+    fi
+    am_display_PYTHON=python
+  , 
+    dnl A version check is needed.
+    if test -n "$PYTHON"; then
+      # If the user set $PYTHON, use it and don't search something else.
+      AC_MSG_CHECKING(whether $PYTHON version is >= $1)
+      AM_PYTHON_CHECK_VERSION($PYTHON, $1,
+			      AC_MSG_RESULT(yes),
+			      AC_MSG_RESULT(no)
+			       AC_MSG_ERROR(Python interpreter is too old))
+      am_display_PYTHON=$PYTHON
+    else
+      # Otherwise, try each interpreter until we find one that satisfies
+      # VERSION.
+      AC_CACHE_CHECK(for a Python interpreter with version >= $1,
+	am_cv_pathless_PYTHON,
+	for am_cv_pathless_PYTHON in _AM_PYTHON_INTERPRETER_LIST none; do
+	  test "$am_cv_pathless_PYTHON" = none && break
+	  AM_PYTHON_CHECK_VERSION($am_cv_pathless_PYTHON, $1, break)
+	done)
+      # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
+      if test "$am_cv_pathless_PYTHON" = none; then
+	PYTHON=:
+      else
+        AC_PATH_PROG(PYTHON, $am_cv_pathless_PYTHON)
+      fi
+      am_display_PYTHON=$am_cv_pathless_PYTHON
+    fi
+  )
+
+  if test "$PYTHON" = :; then
+  dnl Run any user-specified action, or abort.
+    m4_default($3, AC_MSG_ERROR(no suitable Python interpreter found))
+  else
+
+  dnl Query Python for its version number.  Getting :3 seems to be
+  dnl the best way to do this; it's what "site.py" does in the standard
+  dnl library.
+
+  AC_CACHE_CHECK(for $am_display_PYTHON version, am_cv_python_version,
+    am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version:3)"`)
+  AC_SUBST(PYTHON_VERSION, $am_cv_python_version)
+
+  dnl Use the values of $prefix and $exec_prefix for the corresponding
+  dnl values of PYTHON_PREFIX and PYTHON_EXEC_PREFIX.  These are made
+  dnl distinct variables so they can be overridden if need be.  However,
+  dnl general consensus is that you shouldn't need this ability.
+
+  AC_SUBST(PYTHON_PREFIX, '${prefix}')
+  AC_SUBST(PYTHON_EXEC_PREFIX, '${exec_prefix}')
+
+  dnl At times (like when building shared libraries) you may want
+  dnl to know which OS platform Python thinks this is.
+
+  AC_CACHE_CHECK(for $am_display_PYTHON platform, am_cv_python_platform,
+    am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`)
+  AC_SUBST(PYTHON_PLATFORM, $am_cv_python_platform)
+
+  # Just factor out some code duplication.
+  am_python_setup_sysconfig="\
+import sys
+# Prefer sysconfig over distutils.sysconfig, for better compatibility
+# with python 3.x.  See automake bug#10227.
+try:
+    import sysconfig
+except ImportError:
+    can_use_sysconfig = 0
+else:
+    can_use_sysconfig = 1
+# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
+# <https://github.com/pypa/virtualenv/issues/118>
+try:
+    from platform import python_implementation
+    if python_implementation() == 'CPython' and sys.version:3 == '2.7':
+        can_use_sysconfig = 0
+except ImportError:
+    pass"
+
+  dnl Set up 4 directories:
+
+  dnl pythondir -- where to install python scripts.  This is the
+  dnl   site-packages directory, not the python standard library
+  dnl   directory like in previous automake betas.  This behavior
+  dnl   is more consistent with lispdir.m4 for example.
+  dnl Query distutils for this directory.
+  AC_CACHE_CHECK(for $am_display_PYTHON script directory,
+    am_cv_python_pythondir,
+    if test "x$prefix" = xNONE
+     then
+       am_py_prefix=$ac_default_prefix
+     else
+       am_py_prefix=$prefix
+     fi
+     am_cv_python_pythondir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+    sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'})
+else:
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+     case $am_cv_python_pythondir in
+     $am_py_prefix*)
+       am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
+       am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"`
+       ;;
+     *)
+       case $am_py_prefix in
+         /usr|/System*) ;;
+         *)
+	  am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	  ;;
+       esac
+       ;;
+     esac
+    )
+  AC_SUBST(pythondir, $am_cv_python_pythondir)
+
+  dnl pkgpythondir -- $PACKAGE directory under pythondir.  Was
+  dnl   PYTHON_SITE_PACKAGE in previous betas, but this naming is
+  dnl   more consistent with the rest of automake.
+
+  AC_SUBST(pkgpythondir, \${pythondir}/$PACKAGE)
+
+  dnl pyexecdir -- directory for installing python extension modules
+  dnl   (shared libraries)
+  dnl Query distutils for this directory.
+  AC_CACHE_CHECK(for $am_display_PYTHON extension module directory,
+    am_cv_python_pyexecdir,
+    if test "x$exec_prefix" = xNONE
+     then
+       am_py_exec_prefix=$am_py_prefix
+     else
+       am_py_exec_prefix=$exec_prefix
+     fi
+     am_cv_python_pyexecdir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+    sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'})
+else:
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+     case $am_cv_python_pyexecdir in
+     $am_py_exec_prefix*)
+       am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
+       am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"`
+       ;;
+     *)
+       case $am_py_exec_prefix in
+         /usr|/System*) ;;
+         *)
+	   am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	   ;;
+       esac
+       ;;
+     esac
+    )
+  AC_SUBST(pyexecdir, $am_cv_python_pyexecdir)
+
+  dnl pkgpyexecdir -- $(pyexecdir)/$(PACKAGE)
+
+  AC_SUBST(pkgpyexecdir, \${pyexecdir}/$PACKAGE)
+
+  dnl Run any user-specified action.
+  $2
+  fi
+
+)
+
+
+# AM_PYTHON_CHECK_VERSION(PROG, VERSION, ACTION-IF-TRUE, ACTION-IF-FALSE)
+# ---------------------------------------------------------------------------
+# Run ACTION-IF-TRUE if the Python interpreter PROG has version >= VERSION.
+# Run ACTION-IF-FALSE otherwise.
+# This test uses sys.hexversion instead of the string equivalent (first
+# word of sys.version), in order to cope with versions such as 2.2c1.
+# This supports Python 2.0 or higher. (2.0 was released on October 16, 2000).
+AC_DEFUN(AM_PYTHON_CHECK_VERSION,
+ prog="import sys
+# split strings by '.' and convert to numeric.  Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '$2'.split('.'))) + 0, 0, 0
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minveri
+sys.exit(sys.hexversion < minverhex)"
+  AS_IF(AM_RUN_LOG($1 -c "$prog"), $3, $4))
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -828,7 +1052,7 @@
 
 # Check to make sure that the build environment is sane.    -*- Autoconf -*-
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -909,7 +1133,7 @@
 rm -f conftest.file
 )
 
-# Copyright (C) 2009-2013 Free Software Foundation, Inc.
+# Copyright (C) 2009-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -969,7 +1193,7 @@
 _AM_SUBST_NOTMAKE(AM_BACKSLASH)dnl
 )
 
-# Copyright (C) 2001-2013 Free Software Foundation, Inc.
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -997,7 +1221,7 @@
 INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
 AC_SUBST(INSTALL_STRIP_PROGRAM))
 
-# Copyright (C) 2006-2013 Free Software Foundation, Inc.
+# Copyright (C) 2006-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1016,7 +1240,7 @@
 
 # Check how to create a tarball.                            -*- Autoconf -*-
 
-# Copyright (C) 2004-2013 Free Software Foundation, Inc.
+# Copyright (C) 2004-2018 Free Software Foundation, Inc.
 #
 # This file is free software; the Free Software Foundation
 # gives unlimited permission to copy and/or distribute it,
@@ -1153,12 +1377,16 @@
 m4_include(m4/ax_compiler_vendor.m4)
 m4_include(m4/ax_create_pkgconfig_info.m4)
 m4_include(m4/ax_create_stdint_h.m4)
+m4_include(m4/ax_cxx_compile_stdcxx.m4)
+m4_include(m4/ax_cxx_compile_stdcxx_11.m4)
+m4_include(m4/ax_cxx_compile_stdcxx_11_no_override.m4)
 m4_include(m4/ax_detect_git_head.m4)
 m4_include(m4/ax_detect_gmp.m4)
 m4_include(m4/ax_detect_imath.m4)
 m4_include(m4/ax_gcc_archflag.m4)
 m4_include(m4/ax_gcc_warn_unused_result.m4)
 m4_include(m4/ax_gcc_x86_cpuid.m4)
+m4_include(m4/ax_prog_cc_for_build.m4)
 m4_include(m4/ax_set_warning_flags.m4)
 m4_include(m4/ax_submodule.m4)
 m4_include(m4/libtool.m4)

_service:tar_scm:isl-0.24.tar.gz/all.h Added

_service:tar_scm:isl-0.14.tar.xz/basis_reduction_tab.c -> _service:tar_scm:isl-0.24.tar.gz/basis_reduction_tab.c Changed

@@ -45,6 +45,8 @@
 #define GBR_denref(a)			    mpq_denref(a)
 #define GBR_floor(a,b)			    mpz_fdiv_q(a,GBR_numref(b),GBR_denref(b))
 #define GBR_ceil(a,b)			    mpz_cdiv_q(a,GBR_numref(b),GBR_denref(b))
+#define GBR_set_num_neg(a, b)		    mpz_neg(GBR_numref(*a), b);
+#define GBR_set_den(a, b)		    mpz_set(GBR_denref(*a), b);
 #endif /* USE_GMP_FOR_MP */
 
 #ifdef USE_IMATH_FOR_MP
@@ -58,10 +60,31 @@
 #define GBR_mul(a,b,c)			    mp_rat_mul(b,c,a)
 #define GBR_lt(a,b)			    (mp_rat_compare(a,b) < 0)
 #define GBR_is_zero(a)			    (mp_rat_compare_zero(a) == 0)
-#define GBR_numref(a)			    mp_rat_numer_ref(a)
-#define GBR_denref(a)			    mp_rat_denom_ref(a)
-#define GBR_floor(a,b)			    impz_fdiv_q(a,GBR_numref(b),GBR_denref(b))
-#define GBR_ceil(a,b)			    impz_cdiv_q(a,GBR_numref(b),GBR_denref(b))
+#ifdef USE_SMALL_INT_OPT
+#define GBR_numref(a)	isl_sioimath_encode_big(mp_rat_numer_ref(a))
+#define GBR_denref(a)	isl_sioimath_encode_big(mp_rat_denom_ref(a))
+#define GBR_floor(a, b)	isl_sioimath_fdiv_q((a), GBR_numref(b), GBR_denref(b))
+#define GBR_ceil(a, b)	isl_sioimath_cdiv_q((a), GBR_numref(b), GBR_denref(b))
+#define GBR_set_num_neg(a, b)                              \
+	do {                                               \
+		isl_sioimath_scratchspace_t scratch;       \
+		impz_neg(mp_rat_numer_ref(*a),             \
+		    isl_sioimath_bigarg_src(*b, &scratch));\
+	} while (0)
+#define GBR_set_den(a, b)                                  \
+	do {                                               \
+		isl_sioimath_scratchspace_t scratch;       \
+		impz_set(mp_rat_denom_ref(*a),             \
+		    isl_sioimath_bigarg_src(*b, &scratch));\
+	} while (0)
+#else /* USE_SMALL_INT_OPT */
+#define GBR_numref(a)		mp_rat_numer_ref(a)
+#define GBR_denref(a)		mp_rat_denom_ref(a)
+#define GBR_floor(a,b)		impz_fdiv_q(a,GBR_numref(b),GBR_denref(b))
+#define GBR_ceil(a,b)		impz_cdiv_q(a,GBR_numref(b),GBR_denref(b))
+#define GBR_set_num_neg(a, b)	impz_neg(GBR_numref(*a), b)
+#define GBR_set_den(a, b)	impz_set(GBR_denref(*a), b)
+#endif /* USE_SMALL_INT_OPT */
 #endif /* USE_IMATH_FOR_MP */
 
 static struct tab_lp *init_lp(struct isl_tab *tab);
@@ -181,8 +204,11 @@
 		isl_vec_free(sample);
 	}
 	isl_int_divexact_ui(lp->opt_denom, lp->opt_denom, 2);
-	if (res != isl_lp_ok)
+	if (res < 0)
 		return -1;
+	if (res != isl_lp_ok)
+		isl_die(lp->ctx, isl_error_internal,
+			"unexpected missing (bounded) solution", return -1);
 	return 0;
 }
 
@@ -219,8 +245,8 @@
 
 static void get_obj_val(struct tab_lp* lp, GBR_type *F)
 {
-	isl_int_neg(GBR_numref(*F), lp->opt);
-	isl_int_set(GBR_denref(*F), lp->opt_denom);
+	GBR_set_num_neg(F, lp->opt);
+	GBR_set_den(F, lp->opt_denom);
 }
 
 static void delete_lp(struct tab_lp *lp)
@@ -256,8 +282,8 @@
 static void get_alpha(struct tab_lp* lp, int row, GBR_type *alpha)
 {
 	row += lp->con_offset;
-	isl_int_neg(GBR_numref(*alpha), lp->tab->dual->el1 + row);
-	isl_int_set(GBR_denref(*alpha), lp->tab->dual->el0);
+	GBR_set_num_neg(alpha, lp->tab->dual->el1 + row);
+	GBR_set_den(alpha, lp->tab->dual->el0);
 }
 
 static int del_lp_row(struct tab_lp *lp)

_service:tar_scm:isl-0.14.tar.xz/basis_reduction_templ.c -> _service:tar_scm:isl-0.24.tar.gz/basis_reduction_templ.c Changed

@@ -51,7 +51,6 @@
 	unsigned dim;
 	struct isl_ctx *ctx;
 	struct isl_mat *B;
-	int unbounded;
 	int i;
 	GBR_LP *lp = NULL;
 	GBR_type F_old, alpha, F_new;
@@ -133,8 +132,8 @@
 
 	GBR_lp_set_obj(lp, B->row1+i+1, dim);
 	ctx->stats->gbr_solved_lps++;
-	unbounded = GBR_lp_solve(lp);
-	isl_assert(ctx, !unbounded, goto error);
+	if (GBR_lp_solve(lp) < 0)
+		goto error;
 	GBR_lp_get_obj_val(lp, &Fi);
 
 	if (GBR_lt(Fi, one)) {
@@ -151,8 +150,8 @@
 		if (i+1 == tab->n_zero) {
 			GBR_lp_set_obj(lp, B->row1+i+1+1, dim);
 			ctx->stats->gbr_solved_lps++;
-			unbounded = GBR_lp_solve(lp);
-			isl_assert(ctx, !unbounded, goto error);
+			if (GBR_lp_solve(lp) < 0)
+				goto error;
 			GBR_lp_get_obj_val(lp, &F_new);
 			fixed = GBR_lp_is_fixed(lp);
 			GBR_set_ui(alpha, 0);
@@ -166,8 +165,8 @@
 			row = GBR_lp_add_row(lp, B->row1+i+1, dim);
 			GBR_lp_set_obj(lp, B->row1+i+1+1, dim);
 			ctx->stats->gbr_solved_lps++;
-			unbounded = GBR_lp_solve(lp);
-			isl_assert(ctx, !unbounded, goto error);
+			if (GBR_lp_solve(lp) < 0)
+				goto error;
 			GBR_lp_get_obj_val(lp, &F_new);
 			fixed = GBR_lp_is_fixed(lp);
 
@@ -196,8 +195,8 @@
 						tmp, B->row1+i+1, dim);
 				GBR_lp_set_obj(lp, b_tmp->el, dim);
 				ctx->stats->gbr_solved_lps++;
-				unbounded = GBR_lp_solve(lp);
-				isl_assert(ctx, !unbounded, goto error);
+				if (GBR_lp_solve(lp) < 0)
+					goto error;
 				GBR_lp_get_obj_val(lp, &mu_Fj);
 				mu_fixedj = GBR_lp_is_fixed(lp);
 				if (i > 0)
@@ -315,21 +314,15 @@
  * basis with the equalities first.  Otherwise, we start off with
  * the identity matrix.
  */
-struct isl_mat *isl_basic_set_reduced_basis(struct isl_basic_set *bset)
+__isl_give isl_mat *isl_basic_set_reduced_basis(__isl_keep isl_basic_set *bset)
 {
 	struct isl_mat *basis;
 	struct isl_tab *tab;
 
-	if (!bset)
+	if (isl_basic_set_check_no_locals(bset) < 0 ||
+	    isl_basic_set_check_no_params(bset) < 0)
 		return NULL;
 
-	if (isl_basic_set_dim(bset, isl_dim_div) != 0)
-		isl_die(bset->ctx, isl_error_invalid,
-			"no integer division allowed", return NULL);
-	if (isl_basic_set_dim(bset, isl_dim_param) != 0)
-		isl_die(bset->ctx, isl_error_invalid,
-			"no parameters allowed", return NULL);
-
 	tab = isl_tab_from_basic_set(bset, 0);
 	if (!tab)
 		return NULL;
@@ -338,7 +331,9 @@
 		tab->basis = isl_mat_identity(bset->ctx, 1 + tab->n_var);
 	else {
 		isl_mat *eq;
-		unsigned nvar = isl_basic_set_total_dim(bset);
+		isl_size nvar = isl_basic_set_dim(bset, isl_dim_all);
+		if (nvar < 0)
+			goto error;
 		eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq,
 					1, nvar);
 		eq = isl_mat_left_hermite(eq, 0, NULL, &tab->basis);
@@ -355,4 +350,7 @@
 	isl_tab_free(tab);
 
 	return basis;
+error:
+	isl_tab_free(tab);
+	return NULL;
 }

_service:tar_scm:isl-0.14.tar.xz/bound.c -> _service:tar_scm:isl-0.24.tar.gz/bound.c Changed

@@ -1,11 +1,10 @@
 #include <assert.h>
 #include <isl/stream.h>
 #include <isl_map_private.h>
-#include <isl_polynomial_private.h>
+#include <isl/polynomial.h>
 #include <isl_scan.h>
+#include <isl/val.h>
 #include <isl/options.h>
-#include <isl/deprecated/point_int.h>
-#include <isl/deprecated/polynomial_int.h>
 
 struct bound_options {
 	struct isl_options	*isl;
@@ -26,12 +25,14 @@
 
 static __isl_give isl_set *set_bounds(__isl_take isl_set *set)
 {
-	unsigned nparam;
+	isl_size nparam;
 	int i, r;
 	isl_point *pt, *pt2;
 	isl_set *box;
 
 	nparam = isl_set_dim(set, isl_dim_param);
+	if (nparam < 0)
+		return isl_set_free(set);
 	r = nparam >= 8 ? 5 : nparam >= 5 ? 15 : 50;
 
 	pt = isl_set_sample_point(isl_set_copy(set));
@@ -58,13 +59,12 @@
 	isl_pw_qpolynomial_fold *bound;
 };
 
-static int verify_point(__isl_take isl_point *pnt, void *user)
+static isl_stat verify_point(__isl_take isl_point *pnt, void *user)
 {
 	int i;
-	unsigned nvar;
-	unsigned nparam;
+	isl_size nparam;
 	struct verify_point_bound *vpb = (struct verify_point_bound *) user;
-	isl_int t;
+	isl_val *v;
 	isl_ctx *ctx;
 	isl_pw_qpolynomial_fold *pwf;
 	isl_val *bound = NULL;
@@ -72,7 +72,7 @@
 	isl_set *dom = NULL;
 	isl_printer *p;
 	const char *minmax;
-	int bounded;
+	isl_bool bounded;
 	int sign;
 	int ok;
 	FILE *out = vpb->options->print_all ? stdout : stderr;
@@ -90,14 +90,14 @@
 	ctx = isl_point_get_ctx(pnt);
 	p = isl_printer_to_file(ctx, out);
 
-	isl_int_init(t);
-
 	pwf = isl_pw_qpolynomial_fold_copy(vpb->pwf);
 
 	nparam = isl_pw_qpolynomial_fold_dim(pwf, isl_dim_param);
+	if (nparam < 0)
+		pwf = isl_pw_qpolynomial_fold_free(pwf);
 	for (i = 0; i < nparam; ++i) {
-		isl_point_get_coordinate(pnt, isl_dim_param, i, &t);
-		pwf = isl_pw_qpolynomial_fold_fix_dim(pwf, isl_dim_param, i, t);
+		v = isl_point_get_coordinate_val(pnt, isl_dim_param, i);
+		pwf = isl_pw_qpolynomial_fold_fix_val(pwf, isl_dim_param, i, v);
 	}
 
 	bound = isl_pw_qpolynomial_fold_eval(
@@ -119,7 +119,6 @@
 	else
 		opt = isl_pw_qpolynomial_fold_min(isl_pw_qpolynomial_fold_copy(pwf));
 
-	nvar = isl_set_dim(dom, isl_dim_set);
 	if (vpb->exact && bounded)
 		ok = isl_val_eq(opt, bound);
 	else if (sign > 0)
@@ -135,8 +134,9 @@
 		for (i = 0; i < nparam; ++i) {
 			if (i)
 				p = isl_printer_print_str(p, ", ");
-			isl_point_get_coordinate(pnt, isl_dim_param, i, &t);
-			p = isl_printer_print_isl_int(p, t);
+			v = isl_point_get_coordinate_val(pnt, isl_dim_param, i);
+			p = isl_printer_print_val(p, v);
+			isl_val_free(v);
 		}
 		p = isl_printer_print_str(p, ") = ");
 		p = isl_printer_print_val(p, bound);
@@ -165,8 +165,6 @@
 	isl_point_free(pnt);
 	isl_set_free(dom);
 
-	isl_int_clear(t);
-
 	isl_printer_free(p);
 
 	if (!ok)
@@ -175,7 +173,7 @@
 	if (vpb->options->continue_on_error)
 		ok = 1;
 
-	return (vpb->n >= 1 && ok) ? 0 : -1;
+	return (vpb->n >= 1 && ok) ? isl_stat_ok : isl_stat_error;
 }
 
 static int check_solution(__isl_take isl_pw_qpolynomial_fold *pwf,
@@ -242,10 +240,10 @@
 	isl_ctx *ctx;
 	isl_pw_qpolynomial_fold *copy;
 	isl_pw_qpolynomial_fold *pwf;
-	struct isl_stream *s;
+	isl_stream *s;
 	struct isl_obj obj;
 	struct bound_options *options;
-	int exact;
+	isl_bool exact;
 	int r = 0;
 
 	options = bound_options_new_with_defaults();

_service:tar_scm:isl-0.14.tar.xz/bound_test.sh.in -> _service:tar_scm:isl-0.24.tar.gz/bound_test.sh.in Changed

_service:tar_scm:isl-0.24.tar.gz/bset_from_bmap.c Added

_service:tar_scm:isl-0.24.tar.gz/bset_to_bmap.c Added

_service:tar_scm:isl-0.14.tar.xz/cat.c -> _service:tar_scm:isl-0.24.tar.gz/cat.c Changed

@@ -10,18 +10,28 @@
 	{"polylib",	ISL_FORMAT_POLYLIB},
 	{"ext-polylib",	ISL_FORMAT_EXT_POLYLIB},
 	{"latex",	ISL_FORMAT_LATEX},
+	{"C",		ISL_FORMAT_C},
 	{0}
 };
 
+struct isl_arg_choice cat_yaml_style = {
+	{ "block",	ISL_YAML_STYLE_BLOCK },
+	{ "flow",	ISL_YAML_STYLE_FLOW },
+	{ 0 }
+};
+
 struct cat_options {
 	struct isl_options	*isl;
 	unsigned		 format;
+	unsigned		 yaml_style;
 };
 
 ISL_ARGS_START(struct cat_options, cat_options_args)
 ISL_ARG_CHILD(struct cat_options, isl, "isl", &isl_options_args, "isl options")
 ISL_ARG_CHOICE(struct cat_options, format, 0, "format", \
 	cat_format,	ISL_FORMAT_ISL, "output format")
+ISL_ARG_CHOICE(struct cat_options, yaml_style, 0, "yaml-style", \
+	cat_yaml_style, ISL_YAML_STYLE_BLOCK, "output YAML style")
 ISL_ARGS_END
 
 ISL_ARG_DEF(cat_options, struct cat_options, cat_options_args)
@@ -29,7 +39,7 @@
 int main(int argc, char **argv)
 {
 	struct isl_ctx *ctx;
-	struct isl_stream *s;
+	isl_stream *s;
 	struct isl_obj obj;
 	struct cat_options *options;
 	isl_printer *p;
@@ -46,6 +56,7 @@
 
 	p = isl_printer_to_file(ctx, stdout);
 	p = isl_printer_set_output_format(p, options->format);
+	p = isl_printer_set_yaml_style(p, options->yaml_style);
 	p = obj.type->print(p, obj.v);
 	p = isl_printer_end_line(p);
 	isl_printer_free(p);

_service:tar_scm:isl-0.24.tar.gz/check_reparse_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/check_reparse_test_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/check_single_reference_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/check_type_range_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/closure.c -> _service:tar_scm:isl-0.24.tar.gz/closure.c Changed

@@ -7,7 +7,8 @@
 	struct isl_ctx *ctx;
 	struct isl_map *map;
 	struct isl_options *options;
-	int exact;
+	isl_printer *p;
+	isl_bool exact;
 
 	options = isl_options_new_with_defaults();
 	assert(options);
@@ -15,19 +16,23 @@
 
 	ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
 
+	p = isl_printer_to_file(ctx, stdout);
+
 	map = isl_map_read_from_file(ctx, stdin);
 	map = isl_map_transitive_closure(map, &exact);
 	if (!exact)
-		printf("# NOT exact\n");
-	isl_map_print(map, stdout, 0, ISL_FORMAT_ISL);
-	printf("\n");
+		p = isl_printer_print_str(p, "# NOT exact\n");
+	p = isl_printer_print_map(p, map);
+	p = isl_printer_end_line(p);
 	map = isl_map_compute_divs(map);
 	map = isl_map_coalesce(map);
-	printf("# coalesced\n");
-	isl_map_print(map, stdout, 0, ISL_FORMAT_ISL);
-	printf("\n");
+	p = isl_printer_print_str(p, "# coalesced\n");
+	p = isl_printer_print_map(p, map);
+	p = isl_printer_end_line(p);
 	isl_map_free(map);
 
+	isl_printer_free(p);
+
 	isl_ctx_free(ctx);
 
 	return 0;

_service:tar_scm:isl-0.14.tar.xz/codegen.c -> _service:tar_scm:isl-0.24.tar.gz/codegen.c Changed

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012      Ecole Normale Superieure
+ * Copyright 2012,2014 Ecole Normale Superieure
  *
  * Use of this software is governed by the MIT license
  *
@@ -8,19 +8,27 @@
  */
 
 /* This program prints an AST that scans the domain elements of
- * the domain of a given schedule in the order of their image(s).
+ * the domain of a given schedule in the order specified by
+ * the schedule tree or by their image(s) in the schedule map.
  *
- * The input consists of three sets/relations.
- * - a schedule
+ * The input consists of either a schedule tree or
+ * a sequence of three sets/relations.
+ * - a schedule map
  * - a context
  * - a relation describing AST generation options
  */
 
 #include <assert.h>
+#include <stdlib.h>
 #include <isl/ast.h>
 #include <isl/ast_build.h>
 #include <isl/options.h>
+#include <isl/space.h>
 #include <isl/set.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
+#include <isl/stream.h>
+#include <isl/schedule_node.h>
 
 struct options {
 	struct isl_options	*isl;
@@ -36,7 +44,8 @@
 	"globally set the separate option")
 ISL_ARGS_END
 
-ISL_ARG_DEF(options, struct options, options_args)
+ISL_ARG_DEF(cg_options, struct options, options_args)
+ISL_ARG_CTX_DEF(cg_options, struct options, options_args)
 
 /* Return a universal, 1-dimensional set with the given name.
  */
@@ -100,32 +109,134 @@
 	return build;
 }
 
-int main(int argc, char **argv)
+/* Construct an AST in case the schedule is specified by a union map.
+ *
+ * We read the context and the options from "s" and construct the AST.
+ */
+static __isl_give isl_ast_node *construct_ast_from_union_map(
+	__isl_take isl_union_map *schedule, __isl_keep isl_stream *s)
 {
-	isl_ctx *ctx;
 	isl_set *context;
-	isl_union_map *schedule;
 	isl_union_map *options_map;
 	isl_ast_build *build;
 	isl_ast_node *tree;
 	struct options *options;
-	isl_printer *p;
 
-	options = options_new_with_defaults();
-	assert(options);
-	argc = options_parse(options, argc, argv, ISL_ARG_ALL);
+	options = isl_ctx_peek_cg_options(isl_stream_get_ctx(s));
 
-	ctx = isl_ctx_alloc_with_options(&options_args, options);
-
-	schedule = isl_union_map_read_from_file(ctx, stdin);
-	context = isl_set_read_from_file(ctx, stdin);
-	options_map = isl_union_map_read_from_file(ctx, stdin);
+	context = isl_stream_read_set(s);
+	options_map = isl_stream_read_union_map(s);
 
 	build = isl_ast_build_from_context(context);
 	build = set_options(build, options_map, options, schedule);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 
+	return tree;
+}
+
+/* If "node" is a band node, then replace the AST build options
+ * by "options".
+ */
+static __isl_give isl_schedule_node *node_set_options(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	enum isl_ast_loop_type *type = user;
+	int i;
+	isl_size n;
+
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_band)
+		return node;
+
+	n = isl_schedule_node_band_n_member(node);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	for (i = 0; i < n; ++i)
+		node = isl_schedule_node_band_member_set_ast_loop_type(node,
+								i, *type);
+	return node;
+}
+
+/* Replace the AST build options on all band nodes if requested
+ * by the user.
+ */
+static __isl_give isl_schedule *schedule_set_options(
+	__isl_take isl_schedule *schedule, struct options *options)
+{
+	enum isl_ast_loop_type type;
+
+	if (!options->separate && !options->atomic)
+		return schedule;
+
+	type = options->separate ? isl_ast_loop_separate : isl_ast_loop_atomic;
+	schedule = isl_schedule_map_schedule_node_bottom_up(schedule,
+						&node_set_options, &type);
+
+	return schedule;
+}
+
+/* Construct an AST in case the schedule is specified by a schedule tree.
+ */
+static __isl_give isl_ast_node *construct_ast_from_schedule(
+	__isl_take isl_schedule *schedule)
+{
+	isl_ast_build *build;
+	isl_ast_node *tree;
+	struct options *options;
+
+	options = isl_ctx_peek_cg_options(isl_schedule_get_ctx(schedule));
+
+	build = isl_ast_build_alloc(isl_schedule_get_ctx(schedule));
+	schedule = schedule_set_options(schedule, options);
+	tree = isl_ast_build_node_from_schedule(build, schedule);
+	isl_ast_build_free(build);
+
+	return tree;
+}
+
+/* Read an object from stdin.
+ * If it is a (union) map, then assume an input specified by
+ * schedule map, context and options and construct an AST from
+ * those elements
+ * If it is a schedule object, then construct the AST from the schedule.
+ */
+int main(int argc, char **argv)
+{
+	isl_ctx *ctx;
+	isl_stream *s;
+	isl_ast_node *tree = NULL;
+	struct options *options;
+	isl_printer *p;
+	struct isl_obj obj;
+	int r = EXIT_SUCCESS;
+
+	options = cg_options_new_with_defaults();
+	assert(options);
+	ctx = isl_ctx_alloc_with_options(&options_args, options);
+	isl_options_set_ast_build_detect_min_max(ctx, 1);
+	isl_options_set_ast_print_outermost_block(ctx, 0);
+	argc = cg_options_parse(options, argc, argv, ISL_ARG_ALL);
+
+	s = isl_stream_new_file(ctx, stdin);
+	obj = isl_stream_read_obj(s);
+	if (obj.v == NULL) {
+		r = EXIT_FAILURE;
+	} else if (obj.type == isl_obj_map) {
+		isl_union_map *umap;
+
+		umap = isl_union_map_from_map(obj.v);
+		tree = construct_ast_from_union_map(umap, s);
+	} else if (obj.type == isl_obj_union_map) {
+		tree = construct_ast_from_union_map(obj.v, s);
+	} else if (obj.type == isl_obj_schedule) {
+		tree = construct_ast_from_schedule(obj.v);
+	} else {
+		obj.type->free(obj.v);
+		isl_die(ctx, isl_error_invalid, "unknown input",
+			r = EXIT_FAILURE);
+	}
+	isl_stream_free(s);
+
 	p = isl_printer_to_file(ctx, stdout);
 	p = isl_printer_set_output_format(p, ISL_FORMAT_C);
 	p = isl_printer_print_ast_node(p, tree);
@@ -134,5 +245,5 @@
 	isl_ast_node_free(tree);
 
 	isl_ctx_free(ctx);
-	return 0;
+	return r;
 }

_service:tar_scm:isl-0.14.tar.xz/codegen_test.sh.in -> _service:tar_scm:isl-0.24.tar.gz/codegen_test.sh.in Changed

_service:tar_scm:isl-0.14.tar.xz/compile -> _service:tar_scm:isl-0.24.tar.gz/compile Changed

@@ -1,9 +1,9 @@
 #! /bin/sh
 # Wrapper for compilers which do not understand '-c -o'.
 
-scriptversion=2012-10-14.11; # UTC
+scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 # Written by Tom Tromey <tromey@cygnus.com>.
 #
 # This program is free software; you can redistribute it and/or modify
@@ -17,7 +17,7 @@
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -255,7 +255,8 @@
     echo "compile $scriptversion"
     exit $?
     ;;
-  cl | */\\cl | cl.exe | */\\cl.exe )
+  cl | */\\cl | cl.exe | */\\cl.exe | \
+  icl | */\\icl | icl.exe | */\\icl.exe )
     func_cl_wrapper "$@"      # Doesn't return...
     ;;
 esac
@@ -339,9 +340,9 @@
 # Local Variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:

_service:tar_scm:isl-0.14.tar.xz/config.guess -> _service:tar_scm:isl-0.24.tar.gz/config.guess Changed

@@ -1,8 +1,8 @@
 #! /bin/sh
 # Attempt to guess a canonical system name.
-#   Copyright 1992-2013 Free Software Foundation, Inc.
+#   Copyright 1992-2018 Free Software Foundation, Inc.
 
-timestamp='2013-06-10'
+timestamp='2018-02-24'
 
 # This file is free software; you can redistribute it and/or modify it
 # under the terms of the GNU General Public License as published by
@@ -15,7 +15,7 @@
 # General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program; if not, see <http://www.gnu.org/licenses/>.
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
 #
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -24,12 +24,12 @@
 # program.  This Exception is an additional permission under section 7
 # of the GNU General Public License, version 3 ("GPLv3").
 #
-# Originally written by Per Bothner.
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
 #
 # You can get the latest version of this script from:
-# http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
 #
-# Please send patches with a ChangeLog entry to config-patches@gnu.org.
+# Please send patches to <config-patches@gnu.org>.
 
 
 me=`echo "$0" | sed -e 's,.*/,,'`
@@ -39,7 +39,7 @@
 
 Output the configuration name of the system \`$me' is run on.
 
-Operation modes:
+Options:
   -h, --help         print this help, then exit
   -t, --time-stamp   print date of last modification, then exit
   -v, --version      print version number, then exit
@@ -50,7 +50,7 @@
 GNU config.guess ($timestamp)
 
 Originally written by Per Bothner.
-Copyright 1992-2013 Free Software Foundation, Inc.
+Copyright 1992-2018 Free Software Foundation, Inc.
 
 This is free software; see the source for copying conditions.  There is NO
 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
@@ -107,9 +107,9 @@
 dummy=$tmp/dummy ;
 tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
 case $CC_FOR_BUILD,$HOST_CC,$CC in
- ,,)    echo "int x;" > $dummy.c ;
+ ,,)    echo "int x;" > "$dummy.c" ;
 	for c in cc gcc c89 c99 ; do
-	  if ($c -c -o $dummy.o $dummy.c) >/dev/null 2>&1 ; then
+	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
 	     CC_FOR_BUILD="$c"; break ;
 	  fi ;
 	done ;
@@ -132,14 +132,14 @@
 UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
 UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
 
-case "${UNAME_SYSTEM}" in
+case "$UNAME_SYSTEM" in
 Linux|GNU|GNU/*)
 	# If the system lacks a compiler, then just pick glibc.
 	# We could probably try harder.
 	LIBC=gnu
 
-	eval $set_cc_for_build
-	cat <<-EOF > $dummy.c
+	eval "$set_cc_for_build"
+	cat <<-EOF > "$dummy.c"
 	#include <features.h>
 	#if defined(__UCLIBC__)
 	LIBC=uclibc
@@ -149,13 +149,20 @@
 	LIBC=gnu
 	#endif
 	EOF
-	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^LIBC'`
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
+
+	# If ldd exists, use it to detect musl libc.
+	if command -v ldd >/dev/null && \
+		ldd --version 2>&1 | grep -q ^musl
+	then
+	    LIBC=musl
+	fi
 	;;
 esac
 
 # Note: order is significant - the case branches are not exclusive.
 
-case "${UNAME_MACHINE}:${UNAME_SYSTEM}:${UNAME_RELEASE}:${UNAME_VERSION}" in
+case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
     *:NetBSD:*:*)
 	# NetBSD (nbsd) targets should (where applicable) match one or
 	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
@@ -168,21 +175,31 @@
 	# Note: NetBSD doesn't particularly care about the vendor
 	# portion of the name.  We always set it to "unknown".
 	sysctl="sysctl -n hw.machine_arch"
-	UNAME_MACHINE_ARCH=`(/sbin/$sysctl 2>/dev/null || \
-	    /usr/sbin/$sysctl 2>/dev/null || echo unknown)`
-	case "${UNAME_MACHINE_ARCH}" in
+	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+	    "/sbin/$sysctl" 2>/dev/null || \
+	    "/usr/sbin/$sysctl" 2>/dev/null || \
+	    echo unknown)`
+	case "$UNAME_MACHINE_ARCH" in
 	    armeb) machine=armeb-unknown ;;
 	    arm*) machine=arm-unknown ;;
 	    sh3el) machine=shl-unknown ;;
 	    sh3eb) machine=sh-unknown ;;
 	    sh5el) machine=sh5le-unknown ;;
-	    *) machine=${UNAME_MACHINE_ARCH}-unknown ;;
+	    earmv*)
+		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e$armv0-9$.*$,\1,'`
+		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*$eb$$,\1,p'`
+		machine="${arch}${endian}"-unknown
+		;;
+	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
 	esac
 	# The Operating System including object format, if it has switched
-	# to ELF recently, or will in the future.
-	case "${UNAME_MACHINE_ARCH}" in
+	# to ELF recently (or will in the future) and ABI.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		os=netbsdelf
+		;;
 	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
-		eval $set_cc_for_build
+		eval "$set_cc_for_build"
 		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
 			| grep -q __ELF__
 		then
@@ -197,44 +214,67 @@
 		os=netbsd
 		;;
 	esac
+	# Determine ABI tags.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		expr='s/^earmv0-9/-eabi/;s/eb$//'
+		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
+		;;
+	esac
 	# The OS release
 	# Debian GNU/NetBSD machines have a different userland, and
 	# thus, need a distinct triplet. However, they do not need
 	# kernel version information, so it can be replaced with a
 	# suitable tag, in the style of linux-gnu.
-	case "${UNAME_VERSION}" in
+	case "$UNAME_VERSION" in
 	    Debian*)
 		release='-gnu'
 		;;
 	    *)
-		release=`echo ${UNAME_RELEASE}|sed -e 's/-_.*/\./'`
+		release=`echo "$UNAME_RELEASE" | sed -e 's/-_.*//' | cut -d. -f1,2`
 		;;
 	esac
 	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
 	# contains redundant information, the shorter form:
 	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
-	echo "${machine}-${os}${release}"
+	echo "$machine-${os}${release}${abi}"
 	exit ;;
     *:Bitrig:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
-	echo ${UNAME_MACHINE_ARCH}-unknown-bitrig${UNAME_RELEASE}
+	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
 	exit ;;
     *:OpenBSD:*:*)
 	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
-	echo ${UNAME_MACHINE_ARCH}-unknown-openbsd${UNAME_RELEASE}
+	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
+	exit ;;
+    *:LibertyBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
+	exit ;;
+    *:MidnightBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
 	exit ;;
     *:ekkoBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-ekkobsd${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
 	exit ;;
     *:SolidBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-solidbsd${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
 	exit ;;
     macppc:MirBSD:*:*)
-	echo powerpc-unknown-mirbsd${UNAME_RELEASE}
+	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
 	exit ;;
     *:MirBSD:*:*)
-	echo ${UNAME_MACHINE}-unknown-mirbsd${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
 	exit ;;
+    *:Sortix:*:*)
+	echo "$UNAME_MACHINE"-unknown-sortix
+	exit ;;
+    *:Redox:*:*)
+	echo "$UNAME_MACHINE"-unknown-redox
+	exit ;;
+    mips:OSF1:*.*)
+        echo mips-dec-osf1
+        exit ;;
     alpha:OSF1:*:*)
 	case $UNAME_RELEASE in
 	*4.0)
@@ -251,63 +291,54 @@
 	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha $.*$ processor.*$/\1/p' | head -n 1`
 	case "$ALPHA_CPU_TYPE" in
 	    "EV4 (21064)")
-		UNAME_MACHINE="alpha" ;;
+		UNAME_MACHINE=alpha ;;
 	    "EV4.5 (21064)")
-		UNAME_MACHINE="alpha" ;;
+		UNAME_MACHINE=alpha ;;
 	    "LCA4 (21066/21068)")
-		UNAME_MACHINE="alpha" ;;
+		UNAME_MACHINE=alpha ;;
 	    "EV5 (21164)")
-		UNAME_MACHINE="alphaev5" ;;
+		UNAME_MACHINE=alphaev5 ;;
 	    "EV5.6 (21164A)")
-		UNAME_MACHINE="alphaev56" ;;
+		UNAME_MACHINE=alphaev56 ;;
 	    "EV5.6 (21164PC)")
-		UNAME_MACHINE="alphapca56" ;;
+		UNAME_MACHINE=alphapca56 ;;
 	    "EV5.7 (21164PC)")
-		UNAME_MACHINE="alphapca57" ;;
+		UNAME_MACHINE=alphapca57 ;;
 	    "EV6 (21264)")
-		UNAME_MACHINE="alphaev6" ;;
+		UNAME_MACHINE=alphaev6 ;;
 	    "EV6.7 (21264A)")
-		UNAME_MACHINE="alphaev67" ;;
+		UNAME_MACHINE=alphaev67 ;;
 	    "EV6.8CB (21264C)")
-		UNAME_MACHINE="alphaev68" ;;
+		UNAME_MACHINE=alphaev68 ;;
 	    "EV6.8AL (21264B)")
-		UNAME_MACHINE="alphaev68" ;;
+		UNAME_MACHINE=alphaev68 ;;
 	    "EV6.8CX (21264D)")
-		UNAME_MACHINE="alphaev68" ;;
+		UNAME_MACHINE=alphaev68 ;;
 	    "EV6.9A (21264/EV69A)")
-		UNAME_MACHINE="alphaev69" ;;
+		UNAME_MACHINE=alphaev69 ;;
 	    "EV7 (21364)")
-		UNAME_MACHINE="alphaev7" ;;
+		UNAME_MACHINE=alphaev7 ;;
 	    "EV7.9 (21364A)")
-		UNAME_MACHINE="alphaev79" ;;
+		UNAME_MACHINE=alphaev79 ;;
 	esac
 	# A Pn.n version is a patched version.
 	# A Vn.n version is a released version.
 	# A Tn.n version is a released field test version.
 	# A Xn.n version is an unreleased experimental baselevel.
 	# 1.2 uses "1.2" for uname -r.
-	echo ${UNAME_MACHINE}-dec-osf`echo ${UNAME_RELEASE} | sed -e 's/^PVTX//' | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
+	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^PVTX//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
 	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
 	exitcode=$?
 	trap '' 0
 	exit $exitcode ;;
-    Alpha\ *:Windows_NT*:*)
-	# How do we know it's Interix rather than the generic POSIX subsystem?
-	# Should we change UNAME_MACHINE based on the output of uname instead
-	# of the specific Alpha model?
-	echo alpha-pc-interix
-	exit ;;
-    21064:Windows_NT:50:3)
-	echo alpha-dec-winnt3.5
-	exit ;;
     Amiga*:UNIX_System_V:4.0:*)
 	echo m68k-unknown-sysv4
 	exit ;;
     *:AamigaOoSs:*:*)
-	echo ${UNAME_MACHINE}-unknown-amigaos
+	echo "$UNAME_MACHINE"-unknown-amigaos
 	exit ;;
     *:MmorphOoSs:*:*)
-	echo ${UNAME_MACHINE}-unknown-morphos
+	echo "$UNAME_MACHINE"-unknown-morphos
 	exit ;;
     *:OS/390:*:*)
 	echo i370-ibm-openedition
@@ -319,7 +350,7 @@
 	echo powerpc-ibm-os400
 	exit ;;
     arm:RISC*:1.012*:*|arm:riscix:1.012*:*)
-	echo arm-acorn-riscix${UNAME_RELEASE}
+	echo arm-acorn-riscix"$UNAME_RELEASE"
 	exit ;;
     arm*:riscos:*:*|arm*:RISCOS:*:*)
 	echo arm-unknown-riscos
@@ -346,38 +377,38 @@
 	    sparc) echo sparc-icl-nx7; exit ;;
 	esac ;;
     s390x:SunOS:*:*)
-	echo ${UNAME_MACHINE}-ibm-solaris2`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/^.*//'`"
 	exit ;;
     sun4H:SunOS:5.*:*)
-	echo sparc-hal-solaris2`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
 	exit ;;
     sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
-	echo sparc-sun-solaris2`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/^.*//'`"
 	exit ;;
     i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
-	echo i386-pc-auroraux${UNAME_RELEASE}
+	echo i386-pc-auroraux"$UNAME_RELEASE"
 	exit ;;
     i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
-	eval $set_cc_for_build
-	SUN_ARCH="i386"
+	eval "$set_cc_for_build"
+	SUN_ARCH=i386
 	# If there is a compiler, see if it is configured for 64-bit objects.
 	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
 	# This test works for both compilers.
-	if  "$CC_FOR_BUILD" != 'no_compiler_found' ; then
+	if  "$CC_FOR_BUILD" != no_compiler_found ; then
 	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
 		grep IS_64BIT_ARCH >/dev/null
 	    then
-		SUN_ARCH="x86_64"
+		SUN_ARCH=x86_64
 	    fi
 	fi
-	echo ${SUN_ARCH}-pc-solaris2`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
 	exit ;;
     sun4*:SunOS:6*:*)
 	# According to config.sub, this is the proper way to canonicalize
 	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
 	# it's likely to be more like Solaris than SunOS4.
-	echo sparc-sun-solaris3`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
 	exit ;;
     sun4*:SunOS:*:*)
 	case "`/usr/bin/arch -k`" in
@@ -386,25 +417,25 @@
 		;;
 	esac
 	# Japanese Language versions have a version number like `4.1.3-JL'.
-	echo sparc-sun-sunos`echo ${UNAME_RELEASE}|sed -e 's/-/_/'`
+	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
 	exit ;;
     sun3*:SunOS:*:*)
-	echo m68k-sun-sunos${UNAME_RELEASE}
+	echo m68k-sun-sunos"$UNAME_RELEASE"
 	exit ;;
     sun*:*:4.2BSD:*)
 	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
-	test "x${UNAME_RELEASE}" = "x" && UNAME_RELEASE=3
+	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
 	case "`/bin/arch`" in
 	    sun3)
-		echo m68k-sun-sunos${UNAME_RELEASE}
+		echo m68k-sun-sunos"$UNAME_RELEASE"
 		;;
 	    sun4)
-		echo sparc-sun-sunos${UNAME_RELEASE}
+		echo sparc-sun-sunos"$UNAME_RELEASE"
 		;;
 	esac
 	exit ;;
     aushp:SunOS:*:*)
-	echo sparc-auspex-sunos${UNAME_RELEASE}
+	echo sparc-auspex-sunos"$UNAME_RELEASE"
 	exit ;;
     # The situation for MiNT is a little confusing.  The machine name
     # can be virtually everything (everything which is not
@@ -415,44 +446,44 @@
     # MiNT.  But MiNT is downward compatible to TOS, so this should
     # be no problem.
     atariste:*MiNT:*:* | atariste:*mint:*:* | atariste:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
+	echo m68k-atari-mint"$UNAME_RELEASE"
 	exit ;;
     atari*:*MiNT:*:* | atari*:*mint:*:* | atariste:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
+	echo m68k-atari-mint"$UNAME_RELEASE"
 	exit ;;
     *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
-	echo m68k-atari-mint${UNAME_RELEASE}
+	echo m68k-atari-mint"$UNAME_RELEASE"
 	exit ;;
     milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
-	echo m68k-milan-mint${UNAME_RELEASE}
+	echo m68k-milan-mint"$UNAME_RELEASE"
 	exit ;;
     hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
-	echo m68k-hades-mint${UNAME_RELEASE}
+	echo m68k-hades-mint"$UNAME_RELEASE"
 	exit ;;
     *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
-	echo m68k-unknown-mint${UNAME_RELEASE}
+	echo m68k-unknown-mint"$UNAME_RELEASE"
 	exit ;;
     m68k:machten:*:*)
-	echo m68k-apple-machten${UNAME_RELEASE}
+	echo m68k-apple-machten"$UNAME_RELEASE"
 	exit ;;
     powerpc:machten:*:*)
-	echo powerpc-apple-machten${UNAME_RELEASE}
+	echo powerpc-apple-machten"$UNAME_RELEASE"
 	exit ;;
     RISC*:Mach:*:*)
 	echo mips-dec-mach_bsd4.3
 	exit ;;
     RISC*:ULTRIX:*:*)
-	echo mips-dec-ultrix${UNAME_RELEASE}
+	echo mips-dec-ultrix"$UNAME_RELEASE"
 	exit ;;
     VAX*:ULTRIX*:*:*)
-	echo vax-dec-ultrix${UNAME_RELEASE}
+	echo vax-dec-ultrix"$UNAME_RELEASE"
 	exit ;;
     2020:CLIX:*:* | 2430:CLIX:*:*)
-	echo clipper-intergraph-clix${UNAME_RELEASE}
+	echo clipper-intergraph-clix"$UNAME_RELEASE"
 	exit ;;
     mips:*:*:UMIPS | mips:*:*:RISCos)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
 #ifdef __cplusplus
 #include <stdio.h>  /* for printf() prototype */
 	int main (int argc, char *argv) {
@@ -461,23 +492,23 @@
 #endif
 	#if defined (host_mips) && defined (MIPSEB)
 	#if defined (SYSTYPE_SYSV)
-	  printf ("mips-mips-riscos%ssysv\n", argv1); exit (0);
+	  printf ("mips-mips-riscos%ssysv\\n", argv1); exit (0);
 	#endif
 	#if defined (SYSTYPE_SVR4)
-	  printf ("mips-mips-riscos%ssvr4\n", argv1); exit (0);
+	  printf ("mips-mips-riscos%ssvr4\\n", argv1); exit (0);
 	#endif
 	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
-	  printf ("mips-mips-riscos%sbsd\n", argv1); exit (0);
+	  printf ("mips-mips-riscos%sbsd\\n", argv1); exit (0);
 	#endif
 	#endif
 	  exit (-1);
 	}
 EOF
-	$CC_FOR_BUILD -o $dummy $dummy.c &&
-	  dummyarg=`echo "${UNAME_RELEASE}" | sed -n 's/$0-9*$.*/\1/p'` &&
-	  SYSTEM_NAME=`$dummy $dummyarg` &&
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
+	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/$0-9*$.*/\1/p'` &&
+	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
 	    { echo "$SYSTEM_NAME"; exit; }
-	echo mips-mips-riscos${UNAME_RELEASE}
+	echo mips-mips-riscos"$UNAME_RELEASE"
 	exit ;;
     Motorola:PowerMAX_OS:*:*)
 	echo powerpc-motorola-powermax
@@ -503,17 +534,17 @@
     AViiON:dgux:*:*)
 	# DG/UX returns AViiON for all architectures
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	if  $UNAME_PROCESSOR = mc88100  ||  $UNAME_PROCESSOR = mc88110 
+	if  "$UNAME_PROCESSOR" = mc88100  ||  "$UNAME_PROCESSOR" = mc88110 
 	then
-	    if  ${TARGET_BINARY_INTERFACE}x = m88kdguxelfx  || \
-	        ${TARGET_BINARY_INTERFACE}x = x 
+	    if  "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx  || \
+	        "$TARGET_BINARY_INTERFACE"x = x 
 	    then
-		echo m88k-dg-dgux${UNAME_RELEASE}
+		echo m88k-dg-dgux"$UNAME_RELEASE"
 	    else
-		echo m88k-dg-dguxbcs${UNAME_RELEASE}
+		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
 	    fi
 	else
-	    echo i586-dg-dgux${UNAME_RELEASE}
+	    echo i586-dg-dgux"$UNAME_RELEASE"
 	fi
 	exit ;;
     M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
@@ -530,7 +561,7 @@
 	echo m68k-tektronix-bsd
 	exit ;;
     *:IRIX*:*:*)
-	echo mips-sgi-irix`echo ${UNAME_RELEASE}|sed -e 's/-/_/g'`
+	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
 	exit ;;
     ????????:AIX?:12.1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
 	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
@@ -542,14 +573,14 @@
 	if  -x /usr/bin/oslevel  ; then
 		IBM_REV=`/usr/bin/oslevel`
 	else
-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
 	fi
-	echo ${UNAME_MACHINE}-ibm-aix${IBM_REV}
+	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
 	exit ;;
     *:AIX:2:3)
 	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
-		eval $set_cc_for_build
-		sed 's/^		//' << EOF >$dummy.c
+		eval "$set_cc_for_build"
+		sed 's/^		//' << EOF > "$dummy.c"
 		#include <sys/systemcfg.h>
 
 		main()
@@ -560,7 +591,7 @@
 			exit(0);
 			}
 EOF
-		if $CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy`
+		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
 		then
 			echo "$SYSTEM_NAME"
 		else
@@ -574,26 +605,27 @@
 	exit ;;
     *:AIX:*:4567)
 	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
-	if /usr/sbin/lsattr -El ${IBM_CPU_ID} | grep ' POWER' >/dev/null 2>&1; then
+	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
 		IBM_ARCH=rs6000
 	else
 		IBM_ARCH=powerpc
 	fi
-	if  -x /usr/bin/oslevel  ; then
-		IBM_REV=`/usr/bin/oslevel`
+	if  -x /usr/bin/lslpp  ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+			   awk -F: '{ print $3 }' | sed s/0-9*$/0/`
 	else
-		IBM_REV=${UNAME_VERSION}.${UNAME_RELEASE}
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
 	fi
-	echo ${IBM_ARCH}-ibm-aix${IBM_REV}
+	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
 	exit ;;
     *:AIX:*:*)
 	echo rs6000-ibm-aix
 	exit ;;
-    ibmrt:4.4BSD:*|romp-ibm:BSD:*)
+    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
 	echo romp-ibm-bsd4.4
 	exit ;;
     ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
-	echo romp-ibm-bsd${UNAME_RELEASE}   # 4.3 with uname added to
+	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
 	exit ;;                             # report: romp-ibm BSD 4.3
     *:BOSX:*:*)
 	echo rs6000-bull-bosx
@@ -608,28 +640,28 @@
 	echo m68k-hp-bsd4.4
 	exit ;;
     9000/34678??:HP-UX:*:*)
-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/^.*.0B*//'`
-	case "${UNAME_MACHINE}" in
-	    9000/31? )            HP_ARCH=m68000 ;;
-	    9000/34?? )         HP_ARCH=m68k ;;
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/^.*.0B*//'`
+	case "$UNAME_MACHINE" in
+	    9000/31?)            HP_ARCH=m68000 ;;
+	    9000/34??)         HP_ARCH=m68k ;;
 	    9000/6780-90-9)
 		if  -x /usr/bin/getconf ; then
 		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
 		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
-		    case "${sc_cpu_version}" in
-		      523) HP_ARCH="hppa1.0" ;; # CPU_PA_RISC1_0
-		      528) HP_ARCH="hppa1.1" ;; # CPU_PA_RISC1_1
+		    case "$sc_cpu_version" in
+		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
 		      532)                      # CPU_PA_RISC2_0
-			case "${sc_kernel_bits}" in
-			  32) HP_ARCH="hppa2.0n" ;;
-			  64) HP_ARCH="hppa2.0w" ;;
-			  '') HP_ARCH="hppa2.0" ;;   # HP-UX 10.20
+			case "$sc_kernel_bits" in
+			  32) HP_ARCH=hppa2.0n ;;
+			  64) HP_ARCH=hppa2.0w ;;
+			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
 			esac ;;
 		    esac
 		fi
-		if  "${HP_ARCH}" = "" ; then
-		    eval $set_cc_for_build
-		    sed 's/^		//' << EOF >$dummy.c
+		if  "$HP_ARCH" = "" ; then
+		    eval "$set_cc_for_build"
+		    sed 's/^		//' << EOF > "$dummy.c"
 
 		#define _HPUX_SOURCE
 		#include <stdlib.h>
@@ -662,13 +694,13 @@
 		    exit (0);
 		}
 EOF
-		    (CCOPTS= $CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null) && HP_ARCH=`$dummy`
+		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
 		    test -z "$HP_ARCH" && HP_ARCH=hppa
 		fi ;;
 	esac
-	if  ${HP_ARCH} = "hppa2.0w" 
+	if  "$HP_ARCH" = hppa2.0w 
 	then
-	    eval $set_cc_for_build
+	    eval "$set_cc_for_build"
 
 	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
 	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
@@ -679,23 +711,23 @@
 	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
 	    # => hppa64-hp-hpux11.23
 
-	    if echo __LP64__ | (CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) |
+	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
 		grep -q __LP64__
 	    then
-		HP_ARCH="hppa2.0w"
+		HP_ARCH=hppa2.0w
 	    else
-		HP_ARCH="hppa64"
+		HP_ARCH=hppa64
 	    fi
 	fi
-	echo ${HP_ARCH}-hp-hpux${HPUX_REV}
+	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
 	exit ;;
     ia64:HP-UX:*:*)
-	HPUX_REV=`echo ${UNAME_RELEASE}|sed -e 's/^.*.0B*//'`
-	echo ia64-hp-hpux${HPUX_REV}
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/^.*.0B*//'`
+	echo ia64-hp-hpux"$HPUX_REV"
 	exit ;;
     3050*:HI-UX:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
 	#include <unistd.h>
 	int
 	main ()
@@ -720,11 +752,11 @@
 	  exit (0);
 	}
 EOF
-	$CC_FOR_BUILD -o $dummy $dummy.c && SYSTEM_NAME=`$dummy` &&
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
 		{ echo "$SYSTEM_NAME"; exit; }
 	echo unknown-hitachi-hiuxwe2
 	exit ;;
-    9000/7??:4.3bsd:*:* | 9000/8?79:4.3bsd:*:* )
+    9000/7??:4.3bsd:*:* | 9000/8?79:4.3bsd:*:*)
 	echo hppa1.1-hp-bsd
 	exit ;;
     9000/8??:4.3bsd:*:*)
@@ -733,7 +765,7 @@
     *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
 	echo hppa1.0-hp-mpeix
 	exit ;;
-    hp7??:OSF1:*:* | hp8?79:OSF1:*:* )
+    hp7??:OSF1:*:* | hp8?79:OSF1:*:*)
 	echo hppa1.1-hp-osf
 	exit ;;
     hp8??:OSF1:*:*)
@@ -741,9 +773,9 @@
 	exit ;;
     i*86:OSF1:*:*)
 	if  -x /usr/sbin/sysversion  ; then
-	    echo ${UNAME_MACHINE}-unknown-osf1mk
+	    echo "$UNAME_MACHINE"-unknown-osf1mk
 	else
-	    echo ${UNAME_MACHINE}-unknown-osf1
+	    echo "$UNAME_MACHINE"-unknown-osf1
 	fi
 	exit ;;
     parisc*:Lites*:*:*)
@@ -768,127 +800,109 @@
 	echo c4-convex-bsd
 	exit ;;
     CRAY*Y-MP:*:*:*)
-	echo ymp-cray-unicos${UNAME_RELEASE} | sed -e 's/\.^.*$/.X/'
+	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
 	exit ;;
     CRAY*A-Z90:*:*:*)
-	echo ${UNAME_MACHINE}-cray-unicos${UNAME_RELEASE} \
+	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
 	| sed -e 's/CRAY.*$A-Z90$/\1/' \
 	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
 	      -e 's/\.^.*$/.X/'
 	exit ;;
     CRAY*TS:*:*:*)
-	echo t90-cray-unicos${UNAME_RELEASE} | sed -e 's/\.^.*$/.X/'
+	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
 	exit ;;
     CRAY*T3E:*:*:*)
-	echo alphaev5-cray-unicosmk${UNAME_RELEASE} | sed -e 's/\.^.*$/.X/'
+	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
 	exit ;;
     CRAY*SV1:*:*:*)
-	echo sv1-cray-unicos${UNAME_RELEASE} | sed -e 's/\.^.*$/.X/'
+	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
 	exit ;;
     *:UNICOS/mp:*:*)
-	echo craynv-cray-unicosmp${UNAME_RELEASE} | sed -e 's/\.^.*$/.X/'
+	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
 	exit ;;
     F3001:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
-	FUJITSU_PROC=`uname -m | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz'`
-	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
-	FUJITSU_REL=`echo ${UNAME_RELEASE} | sed -e 's/ /_/'`
+	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
 	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
 	exit ;;
     5000:UNIX_System_V:4.*:*)
-	FUJITSU_SYS=`uname -p | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/\///'`
-	FUJITSU_REL=`echo ${UNAME_RELEASE} | tr 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' 'abcdefghijklmnopqrstuvwxyz' | sed -e 's/ /_/'`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
 	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
 	exit ;;
     i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
-	echo ${UNAME_MACHINE}-pc-bsdi${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
 	exit ;;
     sparc*:BSD/OS:*:*)
-	echo sparc-unknown-bsdi${UNAME_RELEASE}
+	echo sparc-unknown-bsdi"$UNAME_RELEASE"
 	exit ;;
     *:BSD/OS:*:*)
-	echo ${UNAME_MACHINE}-unknown-bsdi${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
 	exit ;;
     *:FreeBSD:*:*)
 	UNAME_PROCESSOR=`/usr/bin/uname -p`
-	case ${UNAME_PROCESSOR} in
+	case "$UNAME_PROCESSOR" in
 	    amd64)
-		echo x86_64-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/-(.*//'` ;;
-	    *)
-		echo ${UNAME_PROCESSOR}-unknown-freebsd`echo ${UNAME_RELEASE}|sed -e 's/-(.*//'` ;;
+		UNAME_PROCESSOR=x86_64 ;;
+	    i386)
+		UNAME_PROCESSOR=i586 ;;
 	esac
+	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`"
 	exit ;;
     i*:CYGWIN*:*)
-	echo ${UNAME_MACHINE}-pc-cygwin
+	echo "$UNAME_MACHINE"-pc-cygwin
 	exit ;;
     *:MINGW64*:*)
-	echo ${UNAME_MACHINE}-pc-mingw64
+	echo "$UNAME_MACHINE"-pc-mingw64
 	exit ;;
     *:MINGW*:*)
-	echo ${UNAME_MACHINE}-pc-mingw32
-	exit ;;
-    i*:MSYS*:*)
-	echo ${UNAME_MACHINE}-pc-msys
+	echo "$UNAME_MACHINE"-pc-mingw32
 	exit ;;
-    i*:windows32*:*)
-	# uname -m includes "-pc" on this system.
-	echo ${UNAME_MACHINE}-mingw32
+    *:MSYS*:*)
+	echo "$UNAME_MACHINE"-pc-msys
 	exit ;;
     i*:PW*:*)
-	echo ${UNAME_MACHINE}-pc-pw32
+	echo "$UNAME_MACHINE"-pc-pw32
 	exit ;;
     *:Interix*:*)
-	case ${UNAME_MACHINE} in
+	case "$UNAME_MACHINE" in
 	    x86)
-		echo i586-pc-interix${UNAME_RELEASE}
+		echo i586-pc-interix"$UNAME_RELEASE"
 		exit ;;
 	    authenticamd | genuineintel | EM64T)
-		echo x86_64-unknown-interix${UNAME_RELEASE}
+		echo x86_64-unknown-interix"$UNAME_RELEASE"
 		exit ;;
 	    IA64)
-		echo ia64-unknown-interix${UNAME_RELEASE}
+		echo ia64-unknown-interix"$UNAME_RELEASE"
 		exit ;;
 	esac ;;
-    34586:Windows_95:* | 34586:Windows_98:* | 34586:Windows_NT:*)
-	echo i${UNAME_MACHINE}-pc-mks
-	exit ;;
-    8664:Windows_NT:*)
-	echo x86_64-pc-mks
-	exit ;;
-    i*:Windows_NT*:* | Pentium*:Windows_NT*:*)
-	# How do we know it's Interix rather than the generic POSIX subsystem?
-	# It also conflicts with pre-2.0 versions of AT&T UWIN. Should we
-	# UNAME_MACHINE based on the output of uname instead of i386?
-	echo i586-pc-interix
-	exit ;;
     i*:UWIN*:*)
-	echo ${UNAME_MACHINE}-pc-uwin
+	echo "$UNAME_MACHINE"-pc-uwin
 	exit ;;
     amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
 	echo x86_64-unknown-cygwin
 	exit ;;
-    p*:CYGWIN*:*)
-	echo powerpcle-unknown-cygwin
-	exit ;;
     prep*:SunOS:5.*:*)
-	echo powerpcle-unknown-solaris2`echo ${UNAME_RELEASE}|sed -e 's/^.*//'`
+	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
 	exit ;;
     *:GNU:*:*)
 	# the GNU system
-	echo `echo ${UNAME_MACHINE}|sed -e 's,-/.*$,,'`-unknown-${LIBC}`echo ${UNAME_RELEASE}|sed -e 's,/.*$,,'`
+	echo "`echo "$UNAME_MACHINE"|sed -e 's,-/.*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
 	exit ;;
     *:GNU/*:*:*)
 	# other systems with GNU libc and userland
-	echo ${UNAME_MACHINE}-unknown-`echo ${UNAME_SYSTEM} | sed 's,^^/*/,,' | tr 'A-Z' 'a-z'``echo ${UNAME_RELEASE}|sed -e 's/-(.*//'`-${LIBC}
+	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^^/*/,,' | tr ":upper:" ":lower:"``echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`-$LIBC"
 	exit ;;
     i*86:Minix:*:*)
-	echo ${UNAME_MACHINE}-pc-minix
+	echo "$UNAME_MACHINE"-pc-minix
 	exit ;;
     aarch64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     aarch64_be:Linux:*:*)
 	UNAME_MACHINE=aarch64_be
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     alpha:Linux:*:*)
 	case `sed -n '/^cpu model/s/^.*: $.*$/\1/p' < /proc/cpuinfo` in
@@ -901,58 +915,64 @@
 	  EV68*) UNAME_MACHINE=alphaev68 ;;
 	esac
 	objdump --private-headers /bin/sh | grep -q ld.so.1
-	if test "$?" = 0 ; then LIBC="gnulibc1" ; fi
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     arc:Linux:*:* | arceb:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     arm*:Linux:*:*)
-	eval $set_cc_for_build
+	eval "$set_cc_for_build"
 	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
 	    | grep -q __ARM_EABI__
 	then
-	    echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	else
 	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
 		| grep -q __ARM_PCS_VFP
 	    then
-		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabi
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
 	    else
-		echo ${UNAME_MACHINE}-unknown-linux-${LIBC}eabihf
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
 	    fi
 	fi
 	exit ;;
     avr32*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     cris:Linux:*:*)
-	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
 	exit ;;
     crisv32:Linux:*:*)
-	echo ${UNAME_MACHINE}-axis-linux-${LIBC}
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
+	exit ;;
+    e2k:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     frv:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     hexagon:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     i*86:Linux:*:*)
-	echo ${UNAME_MACHINE}-pc-linux-${LIBC}
+	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
 	exit ;;
     ia64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    k1om:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     m32r*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     m68*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     mips:Linux:*:* | mips64:Linux:*:*)
-	eval $set_cc_for_build
-	sed 's/^	//' << EOF >$dummy.c
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
 	#undef CPU
 	#undef ${UNAME_MACHINE}
 	#undef ${UNAME_MACHINE}el
@@ -966,64 +986,74 @@
 	#endif
 	#endif
 EOF
-	eval `$CC_FOR_BUILD -E $dummy.c 2>/dev/null | grep '^CPU'`
-	test x"${CPU}" != x && { echo "${CPU}-unknown-linux-${LIBC}"; exit; }
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
+	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
 	;;
-    or1k:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+    mips64el:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
-    or32:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+    openrisc*:Linux:*:*)
+	echo or1k-unknown-linux-"$LIBC"
+	exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     padre:Linux:*:*)
-	echo sparc-unknown-linux-${LIBC}
+	echo sparc-unknown-linux-"$LIBC"
 	exit ;;
     parisc64:Linux:*:* | hppa64:Linux:*:*)
-	echo hppa64-unknown-linux-${LIBC}
+	echo hppa64-unknown-linux-"$LIBC"
 	exit ;;
     parisc:Linux:*:* | hppa:Linux:*:*)
 	# Look for CPU level
 	case `grep '^cpu^a-z*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
-	  PA7*) echo hppa1.1-unknown-linux-${LIBC} ;;
-	  PA8*) echo hppa2.0-unknown-linux-${LIBC} ;;
-	  *)    echo hppa-unknown-linux-${LIBC} ;;
+	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
+	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
+	  *)    echo hppa-unknown-linux-"$LIBC" ;;
 	esac
 	exit ;;
     ppc64:Linux:*:*)
-	echo powerpc64-unknown-linux-${LIBC}
+	echo powerpc64-unknown-linux-"$LIBC"
 	exit ;;
     ppc:Linux:*:*)
-	echo powerpc-unknown-linux-${LIBC}
+	echo powerpc-unknown-linux-"$LIBC"
 	exit ;;
     ppc64le:Linux:*:*)
-	echo powerpc64le-unknown-linux-${LIBC}
+	echo powerpc64le-unknown-linux-"$LIBC"
 	exit ;;
     ppcle:Linux:*:*)
-	echo powerpcle-unknown-linux-${LIBC}
+	echo powerpcle-unknown-linux-"$LIBC"
+	exit ;;
+    riscv32:Linux:*:* | riscv64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     s390:Linux:*:* | s390x:Linux:*:*)
-	echo ${UNAME_MACHINE}-ibm-linux-${LIBC}
+	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
 	exit ;;
     sh64*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     sh*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     sparc:Linux:*:* | sparc64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     tile*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     vax:Linux:*:*)
-	echo ${UNAME_MACHINE}-dec-linux-${LIBC}
+	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
 	exit ;;
     x86_64:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	if objdump -f /bin/sh | grep -q elf32-x86-64; then
+	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
+	else
+	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	fi
 	exit ;;
     xtensa*:Linux:*:*)
-	echo ${UNAME_MACHINE}-unknown-linux-${LIBC}
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
 	exit ;;
     i*86:DYNIX/ptx:4*:*)
 	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
@@ -1037,34 +1067,34 @@
 	# I am not positive that other SVR4 systems won't match this,
 	# I just have to hope.  -- rms.
 	# Use sysv4.2uw... so that sysv4* matches it.
-	echo ${UNAME_MACHINE}-pc-sysv4.2uw${UNAME_VERSION}
+	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
 	exit ;;
     i*86:OS/2:*:*)
 	# If we were able to find `uname', then EMX Unix compatibility
 	# is probably installed.
-	echo ${UNAME_MACHINE}-pc-os2-emx
+	echo "$UNAME_MACHINE"-pc-os2-emx
 	exit ;;
     i*86:XTS-300:*:STOP)
-	echo ${UNAME_MACHINE}-unknown-stop
+	echo "$UNAME_MACHINE"-unknown-stop
 	exit ;;
     i*86:atheos:*:*)
-	echo ${UNAME_MACHINE}-unknown-atheos
+	echo "$UNAME_MACHINE"-unknown-atheos
 	exit ;;
     i*86:syllable:*:*)
-	echo ${UNAME_MACHINE}-pc-syllable
+	echo "$UNAME_MACHINE"-pc-syllable
 	exit ;;
     i*86:LynxOS:2.*:* | i*86:LynxOS:3.01*:* | i*86:LynxOS:4.02*:*)
-	echo i386-unknown-lynxos${UNAME_RELEASE}
+	echo i386-unknown-lynxos"$UNAME_RELEASE"
 	exit ;;
     i*86:*DOS:*:*)
-	echo ${UNAME_MACHINE}-pc-msdosdjgpp
+	echo "$UNAME_MACHINE"-pc-msdosdjgpp
 	exit ;;
-    i*86:*:4.*:* | i*86:SYSTEM_V:4.*:*)
-	UNAME_REL=`echo ${UNAME_RELEASE} | sed 's/\/MP$//'`
+    i*86:*:4.*:*)
+	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
 	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
-		echo ${UNAME_MACHINE}-univel-sysv${UNAME_REL}
+		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
 	else
-		echo ${UNAME_MACHINE}-pc-sysv${UNAME_REL}
+		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
 	fi
 	exit ;;
     i*86:*:5:678*)
@@ -1074,12 +1104,12 @@
 	    *Pentium)	     UNAME_MACHINE=i586 ;;
 	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
 	esac
-	echo ${UNAME_MACHINE}-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}${UNAME_VERSION}
+	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
 	exit ;;
     i*86:*:3.2:*)
 	if test -f /usr/options/cb.name; then
 		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
-		echo ${UNAME_MACHINE}-pc-isc$UNAME_REL
+		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
 	elif /bin/uname -X 2>/dev/null >/dev/null ; then
 		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
 		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
@@ -1089,9 +1119,9 @@
 			&& UNAME_MACHINE=i686
 		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
 			&& UNAME_MACHINE=i686
-		echo ${UNAME_MACHINE}-pc-sco$UNAME_REL
+		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
 	else
-		echo ${UNAME_MACHINE}-pc-sysv32
+		echo "$UNAME_MACHINE"-pc-sysv32
 	fi
 	exit ;;
     pc:*:*:*)
@@ -1099,7 +1129,7 @@
 	# uname -m prints for DJGPP always 'pc', but it prints nothing about
 	# the processor, so we play safe by assuming i586.
 	# Note: whatever this is, it MUST be the same as what config.sub
-	# prints for the "djgpp" host, or else GDB configury will decide that
+	# prints for the "djgpp" host, or else GDB configure will decide that
 	# this is a cross-build.
 	echo i586-pc-msdosdjgpp
 	exit ;;
@@ -1111,9 +1141,9 @@
 	exit ;;
     i860:*:4.*:*) # i860-SVR4
 	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
-	  echo i860-stardent-sysv${UNAME_RELEASE} # Stardent Vistra i860-SVR4
+	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
 	else # Add other i860-SVR4 vendors below as they are discovered.
-	  echo i860-unknown-sysv${UNAME_RELEASE}  # Unknown i860-SVR4
+	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
 	fi
 	exit ;;
     mini*:CTIX:SYS*5:*)
@@ -1133,9 +1163,9 @@
 	test -r /etc/.relid \
 	&& OS_REL=.`sed -n 's/^ * ^ * $0-90-9$.*/\1/p' < /etc/.relid`
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	  && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	  && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
     334??:*:4.0:* | 334??,*:*:4.0:*)
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
 	  && { echo i486-ncr-sysv4; exit; } ;;
@@ -1144,28 +1174,28 @@
 	test -r /etc/.relid \
 	    && OS_REL=.`sed -n 's/^ * ^ * $0-90-9$.*/\1/p' < /etc/.relid`
 	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
-	    && { echo i486-ncr-sysv4.3${OS_REL}; exit; }
+	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
-	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; }
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
 	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
-	    && { echo i586-ncr-sysv4.3${OS_REL}; exit; } ;;
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
     m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
-	echo m68k-unknown-lynxos${UNAME_RELEASE}
+	echo m68k-unknown-lynxos"$UNAME_RELEASE"
 	exit ;;
     mc68030:UNIX_System_V:4.*:*)
 	echo m68k-atari-sysv4
 	exit ;;
     TSUNAMI:LynxOS:2.*:*)
-	echo sparc-unknown-lynxos${UNAME_RELEASE}
+	echo sparc-unknown-lynxos"$UNAME_RELEASE"
 	exit ;;
     rs6000:LynxOS:2.*:*)
-	echo rs6000-unknown-lynxos${UNAME_RELEASE}
+	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
 	exit ;;
     PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.01*:* | PowerPC:LynxOS:4.02*:*)
-	echo powerpc-unknown-lynxos${UNAME_RELEASE}
+	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
 	exit ;;
     SMBES:UNIX_SV:*:*)
-	echo mips-dde-sysv${UNAME_RELEASE}
+	echo mips-dde-sysv"$UNAME_RELEASE"
 	exit ;;
     RM*:ReliantUNIX-*:*:*)
 	echo mips-sni-sysv4
@@ -1176,7 +1206,7 @@
     *:SINIX-*:*:*)
 	if uname -p 2>/dev/null >/dev/null ; then
 		UNAME_MACHINE=`(uname -p) 2>/dev/null`
-		echo ${UNAME_MACHINE}-sni-sysv4
+		echo "$UNAME_MACHINE"-sni-sysv4
 	else
 		echo ns32k-sni-sysv
 	fi
@@ -1196,23 +1226,23 @@
 	exit ;;
     i*86:VOS:*:*)
 	# From Paul.Green@stratus.com.
-	echo ${UNAME_MACHINE}-stratus-vos
+	echo "$UNAME_MACHINE"-stratus-vos
 	exit ;;
     *:VOS:*:*)
 	# From Paul.Green@stratus.com.
 	echo hppa1.1-stratus-vos
 	exit ;;
     mc68*:A/UX:*:*)
-	echo m68k-apple-aux${UNAME_RELEASE}
+	echo m68k-apple-aux"$UNAME_RELEASE"
 	exit ;;
     news*:NEWS-OS:6*:*)
 	echo mips-sony-newsos6
 	exit ;;
     R34000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
 	if  -d /usr/nec ; then
-		echo mips-nec-sysv${UNAME_RELEASE}
+		echo mips-nec-sysv"$UNAME_RELEASE"
 	else
-		echo mips-unknown-sysv${UNAME_RELEASE}
+		echo mips-unknown-sysv"$UNAME_RELEASE"
 	fi
 	exit ;;
     BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
@@ -1231,67 +1261,93 @@
 	echo x86_64-unknown-haiku
 	exit ;;
     SX-4:SUPER-UX:*:*)
-	echo sx4-nec-superux${UNAME_RELEASE}
+	echo sx4-nec-superux"$UNAME_RELEASE"
 	exit ;;
     SX-5:SUPER-UX:*:*)
-	echo sx5-nec-superux${UNAME_RELEASE}
+	echo sx5-nec-superux"$UNAME_RELEASE"
 	exit ;;
     SX-6:SUPER-UX:*:*)
-	echo sx6-nec-superux${UNAME_RELEASE}
+	echo sx6-nec-superux"$UNAME_RELEASE"
 	exit ;;
     SX-7:SUPER-UX:*:*)
-	echo sx7-nec-superux${UNAME_RELEASE}
+	echo sx7-nec-superux"$UNAME_RELEASE"
 	exit ;;
     SX-8:SUPER-UX:*:*)
-	echo sx8-nec-superux${UNAME_RELEASE}
+	echo sx8-nec-superux"$UNAME_RELEASE"
 	exit ;;
     SX-8R:SUPER-UX:*:*)
-	echo sx8r-nec-superux${UNAME_RELEASE}
+	echo sx8r-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-ACE:SUPER-UX:*:*)
+	echo sxace-nec-superux"$UNAME_RELEASE"
 	exit ;;
     Power*:Rhapsody:*:*)
-	echo powerpc-apple-rhapsody${UNAME_RELEASE}
+	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
 	exit ;;
     *:Rhapsody:*:*)
-	echo ${UNAME_MACHINE}-apple-rhapsody${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
 	exit ;;
     *:Darwin:*:*)
 	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
-	eval $set_cc_for_build
+	eval "$set_cc_for_build"
 	if test "$UNAME_PROCESSOR" = unknown ; then
 	    UNAME_PROCESSOR=powerpc
 	fi
-	if  "$CC_FOR_BUILD" != 'no_compiler_found' ; then
-	    if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
-		(CCOPTS= $CC_FOR_BUILD -E - 2>/dev/null) | \
-		grep IS_64BIT_ARCH >/dev/null
-	    then
-		case $UNAME_PROCESSOR in
-		    i386) UNAME_PROCESSOR=x86_64 ;;
-		    powerpc) UNAME_PROCESSOR=powerpc64 ;;
-		esac
+	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
+	    if  "$CC_FOR_BUILD" != no_compiler_found ; then
+		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_64BIT_ARCH >/dev/null
+		then
+		    case $UNAME_PROCESSOR in
+			i386) UNAME_PROCESSOR=x86_64 ;;
+			powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		    esac
+		fi
+		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_PPC >/dev/null
+		then
+		    UNAME_PROCESSOR=powerpc
+		fi
 	    fi
+	elif test "$UNAME_PROCESSOR" = i386 ; then
+	    # Avoid executing cc on OS X 10.9, as it ships with a stub
+	    # that puts up a graphical alert prompting to install
+	    # developer tools.  Any system running Mac OS X 10.7 or
+	    # later (Darwin 11 and later) is required to have a 64-bit
+	    # processor. This is not true of the ARM version of Darwin
+	    # that Apple uses in portable devices.
+	    UNAME_PROCESSOR=x86_64
 	fi
-	echo ${UNAME_PROCESSOR}-apple-darwin${UNAME_RELEASE}
+	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
 	exit ;;
     *:procnto*:*:* | *:QNX:0123456789*:*)
 	UNAME_PROCESSOR=`uname -p`
-	if test "$UNAME_PROCESSOR" = "x86"; then
+	if test "$UNAME_PROCESSOR" = x86; then
 		UNAME_PROCESSOR=i386
 		UNAME_MACHINE=pc
 	fi
-	echo ${UNAME_PROCESSOR}-${UNAME_MACHINE}-nto-qnx${UNAME_RELEASE}
+	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
 	exit ;;
     *:QNX:*:4*)
 	echo i386-pc-qnx
 	exit ;;
-    NEO-?:NONSTOP_KERNEL:*:*)
-	echo neo-tandem-nsk${UNAME_RELEASE}
+    NEO-*:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk"$UNAME_RELEASE"
 	exit ;;
     NSE-*:NONSTOP_KERNEL:*:*)
-	echo nse-tandem-nsk${UNAME_RELEASE}
+	echo nse-tandem-nsk"$UNAME_RELEASE"
 	exit ;;
-    NSR-?:NONSTOP_KERNEL:*:*)
-	echo nsr-tandem-nsk${UNAME_RELEASE}
+    NSR-*:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSV-*:NONSTOP_KERNEL:*:*)
+	echo nsv-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSX-*:NONSTOP_KERNEL:*:*)
+	echo nsx-tandem-nsk"$UNAME_RELEASE"
 	exit ;;
     *:NonStop-UX:*:*)
 	echo mips-compaq-nonstopux
@@ -1300,18 +1356,18 @@
 	echo bs2000-siemens-sysv
 	exit ;;
     DS/*:UNIX_System_V:*:*)
-	echo ${UNAME_MACHINE}-${UNAME_SYSTEM}-${UNAME_RELEASE}
+	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
 	exit ;;
     *:Plan9:*:*)
 	# "uname -m" is not consistent, so use $cputype instead. 386
 	# is converted to i386 for consistency with other x86
 	# operating systems.
-	if test "$cputype" = "386"; then
+	if test "$cputype" = 386; then
 	    UNAME_MACHINE=i386
 	else
 	    UNAME_MACHINE="$cputype"
 	fi
-	echo ${UNAME_MACHINE}-unknown-plan9
+	echo "$UNAME_MACHINE"-unknown-plan9
 	exit ;;
     *:TOPS-10:*:*)
 	echo pdp10-unknown-tops10
@@ -1332,14 +1388,14 @@
 	echo pdp10-unknown-its
 	exit ;;
     SEI:*:*:SEIUX)
-	echo mips-sei-seiux${UNAME_RELEASE}
+	echo mips-sei-seiux"$UNAME_RELEASE"
 	exit ;;
     *:DragonFly:*:*)
-	echo ${UNAME_MACHINE}-unknown-dragonfly`echo ${UNAME_RELEASE}|sed -e 's/-(.*//'`
+	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`"
 	exit ;;
     *:*VMS:*:*)
 	UNAME_MACHINE=`(uname -p) 2>/dev/null`
-	case "${UNAME_MACHINE}" in
+	case "$UNAME_MACHINE" in
 	    A*) echo alpha-dec-vms ; exit ;;
 	    I*) echo ia64-dec-vms ; exit ;;
 	    V*) echo vax-dec-vms ; exit ;;
@@ -1348,182 +1404,48 @@
 	echo i386-pc-xenix
 	exit ;;
     i*86:skyos:*:*)
-	echo ${UNAME_MACHINE}-pc-skyos`echo ${UNAME_RELEASE}` | sed -e 's/ .*$//'
+	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
 	exit ;;
     i*86:rdos:*:*)
-	echo ${UNAME_MACHINE}-pc-rdos
+	echo "$UNAME_MACHINE"-pc-rdos
 	exit ;;
     i*86:AROS:*:*)
-	echo ${UNAME_MACHINE}-pc-aros
+	echo "$UNAME_MACHINE"-pc-aros
 	exit ;;
     x86_64:VMkernel:*:*)
-	echo ${UNAME_MACHINE}-unknown-esx
+	echo "$UNAME_MACHINE"-unknown-esx
+	exit ;;
+    amd64:Isilon\ OneFS:*:*)
+	echo x86_64-unknown-onefs
 	exit ;;
 esac
 
-eval $set_cc_for_build
-cat >$dummy.c <<EOF
-#ifdef _SEQUENT_
-# include <sys/types.h>
-# include <sys/utsname.h>
-#endif
-main ()
-{
-#if defined (sony)
-#if defined (MIPSEB)
-  /* BFD wants "bsd" instead of "newsos".  Perhaps BFD should be changed,
-     I don't know....  */
-  printf ("mips-sony-bsd\n"); exit (0);
-#else
-#include <sys/param.h>
-  printf ("m68k-sony-newsos%s\n",
-#ifdef NEWSOS4
-	"4"
-#else
-	""
-#endif
-	); exit (0);
-#endif
-#endif
-
-#if defined (__arm) && defined (__acorn) && defined (__unix)
-  printf ("arm-acorn-riscix\n"); exit (0);
-#endif
-
-#if defined (hp300) && !defined (hpux)
-  printf ("m68k-hp-bsd\n"); exit (0);
-#endif
-
-#if defined (NeXT)
-#if !defined (__ARCHITECTURE__)
-#define __ARCHITECTURE__ "m68k"
-#endif
-  int version;
-  version=`(hostinfo | sed -n 's/.*NeXT Mach $0-9*$.*/\1/p') 2>/dev/null`;
-  if (version < 4)
-    printf ("%s-next-nextstep%d\n", __ARCHITECTURE__, version);
-  else
-    printf ("%s-next-openstep%d\n", __ARCHITECTURE__, version);
-  exit (0);
-#endif
-
-#if defined (MULTIMAX) || defined (n16)
-#if defined (UMAXV)
-  printf ("ns32k-encore-sysv\n"); exit (0);
-#else
-#if defined (CMU)
-  printf ("ns32k-encore-mach\n"); exit (0);
-#else
-  printf ("ns32k-encore-bsd\n"); exit (0);
-#endif
-#endif
-#endif
-
-#if defined (__386BSD__)
-  printf ("i386-pc-bsd\n"); exit (0);
-#endif
-
-#if defined (sequent)
-#if defined (i386)
-  printf ("i386-sequent-dynix\n"); exit (0);
-#endif
-#if defined (ns32000)
-  printf ("ns32k-sequent-dynix\n"); exit (0);
-#endif
-#endif
-
-#if defined (_SEQUENT_)
-    struct utsname un;
-
-    uname(&un);
-
-    if (strncmp(un.version, "V2", 2) == 0) {
-	printf ("i386-sequent-ptx2\n"); exit (0);
-    }
-    if (strncmp(un.version, "V1", 2) == 0) { /* XXX is V1 correct? */
-	printf ("i386-sequent-ptx1\n"); exit (0);
-    }
-    printf ("i386-sequent-ptx\n"); exit (0);
-
-#endif
-
-#if defined (vax)
-# if !defined (ultrix)
-#  include <sys/param.h>
-#  if defined (BSD)
-#   if BSD == 43
-      printf ("vax-dec-bsd4.3\n"); exit (0);
-#   else
-#    if BSD == 199006
-      printf ("vax-dec-bsd4.3reno\n"); exit (0);
-#    else
-      printf ("vax-dec-bsd\n"); exit (0);
-#    endif
-#   endif
-#  else
-    printf ("vax-dec-bsd\n"); exit (0);
-#  endif
-# else
-    printf ("vax-dec-ultrix\n"); exit (0);
-# endif
-#endif
+echo "$0: unable to guess system type" >&2
 
-#if defined (alliant) && defined (i860)
-  printf ("i860-alliant-bsd\n"); exit (0);
-#endif
+case "$UNAME_MACHINE:$UNAME_SYSTEM" in
+    mips:Linux | mips64:Linux)
+	# If we got here on MIPS GNU/Linux, output extra information.
+	cat >&2 <<EOF
 
-  exit (1);
-}
+NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
+the system type. Please install a C compiler and try again.
 EOF
-
-$CC_FOR_BUILD -o $dummy $dummy.c 2>/dev/null && SYSTEM_NAME=`$dummy` &&
-	{ echo "$SYSTEM_NAME"; exit; }
-
-# Apollos put the system type in the environment.
-
-test -d /usr/apollo && { echo ${ISP}-apollo-${SYSTYPE}; exit; }
-
-# Convex versions that predate uname can use getsysinfo(1)
-
-if  -x /usr/convex/getsysinfo 
-then
-    case `getsysinfo -f cpu_type` in
-    c1*)
-	echo c1-convex-bsd
-	exit ;;
-    c2*)
-	if getsysinfo -f scalar_acc
-	then echo c32-convex-bsd
-	else echo c2-convex-bsd
-	fi
-	exit ;;
-    c34*)
-	echo c34-convex-bsd
-	exit ;;
-    c38*)
-	echo c38-convex-bsd
-	exit ;;
-    c4*)
-	echo c4-convex-bsd
-	exit ;;
-    esac
-fi
+	;;
+esac
 
 cat >&2 <<EOF
-$0: unable to guess system type
 
-This script, last modified $timestamp, has failed to recognize
-the operating system you are using. It is advised that you
-download the most up to date version of the config scripts from
+This script (version $timestamp), has failed to recognize the
+operating system you are using. If your script is old, overwrite *all*
+copies of config.guess and config.sub with the latest versions from:
 
-  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
 and
-  http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
 
-If the version you run ($0) is already up to date, please
-send the following data and any information you think might be
-pertinent to <config-patches@gnu.org> in order to provide the needed
-information to handle your system.
+If $0 has already been updated, send the following data and any
+information you think might be pertinent to config-patches@gnu.org to
+provide the necessary information to handle your system.
 
 config.guess timestamp = $timestamp
 
@@ -1542,16 +1464,16 @@
 /usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
 /usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
 
-UNAME_MACHINE = ${UNAME_MACHINE}
-UNAME_RELEASE = ${UNAME_RELEASE}
-UNAME_SYSTEM  = ${UNAME_SYSTEM}
-UNAME_VERSION = ${UNAME_VERSION}
+UNAME_MACHINE = "$UNAME_MACHINE"
+UNAME_RELEASE = "$UNAME_RELEASE"
+UNAME_SYSTEM  = "$UNAME_SYSTEM"
+UNAME_VERSION = "$UNAME_VERSION"
 EOF
 
 exit 1
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'write-file-functions 'time-stamp)
 # time-stamp-start: "timestamp='"
 # time-stamp-format: "%:y-%02m-%02d"
 # time-stamp-end: "'"

_service:tar_scm:isl-0.14.tar.xz/config.sub -> _service:tar_scm:isl-0.24.tar.gz/config.sub Changed

_service:tar_scm:isl-0.14.tar.xz/configure -> _service:tar_scm:isl-0.24.tar.gz/configure Changed

@@ -1,6 +1,6 @@
 #! /bin/sh
 # Guess values for system-dependent variables and create Makefiles.
-# Generated by GNU Autoconf 2.69 for isl 0.14.
+# Generated by GNU Autoconf 2.69 for isl 0.24.
 #
 # Report bugs to <isl-development@googlegroups.com>.
 #
@@ -198,6 +198,7 @@
   as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
   eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
   test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1
 
   test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
     ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
@@ -205,8 +206,7 @@
     ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
     PATH=/empty FPATH=/empty; export PATH FPATH
     test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
-      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1
-test \$(( 1 + 1 )) = 2 || exit 1"
+      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1"
   if (eval "$as_required") 2>/dev/null; then :
   as_have_required=yes
 else
@@ -590,8 +590,8 @@
 # Identity of this package.
 PACKAGE_NAME='isl'
 PACKAGE_TARNAME='isl'
-PACKAGE_VERSION='0.14'
-PACKAGE_STRING='isl 0.14'
+PACKAGE_VERSION='0.24'
+PACKAGE_STRING='isl 0.24'
 PACKAGE_BUGREPORT='isl-development@googlegroups.com'
 PACKAGE_URL=''
 
@@ -631,23 +631,26 @@
 # include <unistd.h>
 #endif"
 
+enable_option_checking=no
 ac_subst_vars='am__EXEEXT_FALSE
 am__EXEEXT_TRUE
 LTLIBOBJS
 LIBOBJS
+subdirs
 GIT_HEAD_VERSION
 GIT_HEAD
 GIT_HEAD_ID
 pkgconfig_libfile
 pkgconfig_libdir
 WARNING_FLAGS
+HAVE_CPP_ISL_H_FALSE
+HAVE_CPP_ISL_H_TRUE
 HAVE_CLANG_FALSE
 HAVE_CLANG_TRUE
-LIB_CLANG_EDIT
-llvm_config_found
-CLANG_LIBS
-CLANG_LDFLAGS
-CLANG_CXXFLAGS
+SMALL_INT_OPT_FALSE
+SMALL_INT_OPT_TRUE
+HAVE_CXX11_FALSE
+HAVE_CXX11_TRUE
 GMP_FOR_MP_FALSE
 GMP_FOR_MP_TRUE
 IMATH_FOR_MP_FALSE
@@ -656,14 +659,28 @@
 NEED_GET_MEMORY_FUNCTIONS_TRUE
 MP_LIBS
 MP_LDFLAGS
+MP_CFLAGS
 MP_CPPFLAGS
 GENERATE_DOC_FALSE
 GENERATE_DOC_TRUE
+OS_SRCDIR
 POD2HTML
 PDFLATEX
 PERL
+CYGPATH
+HAVE_PYTHON_FALSE
+HAVE_PYTHON_TRUE
+pkgpyexecdir
+pyexecdir
+pkgpythondir
+pythondir
+PYTHON_PLATFORM
+PYTHON_EXEC_PREFIX
+PYTHON_PREFIX
+PYTHON_VERSION
+PYTHON
 CXXCPP
-CPP
+LT_SYS_LIBRARY_PATH
 OTOOL64
 OTOOL
 LIPO
@@ -682,18 +699,28 @@
 LD
 FGREP
 EGREP
-GREP
 SED
 LIBTOOL
+HAVE_CXX11
+GREP
 PRTDIAG
 host_os
 host_vendor
 host_cpu
 host
+LDFLAGS_FOR_BUILD
+CPPFLAGS_FOR_BUILD
+CFLAGS_FOR_BUILD
+BUILD_OBJEXT
+BUILD_EXEEXT
+CPP_FOR_BUILD
+ac_ct_CC_FOR_BUILD
+CC_FOR_BUILD
 build_os
 build_vendor
 build_cpu
 build
+CPP
 am__fastdepCXX_FALSE
 am__fastdepCXX_TRUE
 CXXDEPMODE
@@ -707,7 +734,6 @@
 AMDEPBACKSLASH
 AMDEP_FALSE
 AMDEP_TRUE
-am__quote
 am__include
 DEPDIR
 OBJEXT
@@ -764,6 +790,7 @@
 docdir
 oldincludedir
 includedir
+runstatedir
 localstatedir
 sharedstatedir
 sysconfdir
@@ -782,7 +809,8 @@
 PACKAGE_TARNAME
 PACKAGE_NAME
 PATH_SEPARATOR
-SHELL'
+SHELL
+am__quote'
 ac_subst_files=''
 ac_user_opts='
 enable_option_checking
@@ -794,6 +822,7 @@
 enable_static
 with_pic
 enable_fast_install
+with_aix_soname
 with_gnu_ld
 with_sysroot
 enable_libtool_lock
@@ -818,8 +847,10 @@
 CXXFLAGS
 CCC
 CPP
-CXXCPP'
-
+LT_SYS_LIBRARY_PATH
+CXXCPP
+PYTHON'
+ac_subdirs_all='interface'
 
 # Initialize some variables set by options.
 ac_init_help=
@@ -857,6 +888,7 @@
 sysconfdir='${prefix}/etc'
 sharedstatedir='${prefix}/com'
 localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
 includedir='${prefix}/include'
 oldincludedir='/usr/include'
 docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
@@ -1109,6 +1141,15 @@
   | -silent | --silent | --silen | --sile | --sil)
     silent=yes ;;
 
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
   -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
     ac_prev=sbindir ;;
   -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
@@ -1246,7 +1287,7 @@
 for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
 		datadir sysconfdir sharedstatedir localstatedir includedir \
 		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
-		libdir localedir mandir
+		libdir localedir mandir runstatedir
 do
   eval ac_val=\$$ac_var
   # Remove trailing slashes.
@@ -1359,7 +1400,7 @@
   # Omit some internal or obsolete options to make the list less imposing.
   # This message is too long to be a string in the A/UX 3.1 sh.
   cat <<_ACEOF
-\`configure' configures isl 0.14 to adapt to many kinds of systems.
+\`configure' configures isl 0.24 to adapt to many kinds of systems.
 
 Usage: $0 OPTION... VAR=VALUE...
 
@@ -1399,6 +1440,7 @@
   --sysconfdir=DIR        read-only single-machine data PREFIX/etc
   --sharedstatedir=DIR    modifiable architecture-independent data PREFIX/com
   --localstatedir=DIR     modifiable single-machine data PREFIX/var
+  --runstatedir=DIR       modifiable per-process data LOCALSTATEDIR/run
   --libdir=DIR            object code libraries EPREFIX/lib
   --includedir=DIR        C header files PREFIX/include
   --oldincludedir=DIR     C header files for non-gcc /usr/include
@@ -1429,7 +1471,7 @@
 
 if test -n "$ac_init_help"; then
   case $ac_init_help in
-     short | recursive ) echo "Configuration of isl 0.14:";;
+     short | recursive ) echo "Configuration of isl 0.24:";;
    esac
   cat <<\_ACEOF
 
@@ -1459,10 +1501,14 @@
                           instead of guessing
   --with-pic=PKGS       try to use only PIC/non-PIC objects default=use
                           both
+  --with-aix-soname=aix|svr4|both
+                          shared library versioning (aka "SONAME") variant to
+                          provide on AIX, default=aix.
   --with-gnu-ld           assume the C compiler uses GNU ld default=no
   --with-sysroot=DIR    Search for dependent libraries within DIR (or the
                           compiler's sysroot if not specified).
-  --with-int=gmp|imath    Which package to use to represent multi-precision
+  --with-int=gmp|imath|imath-32
+                          Which package to use to represent multi-precision
                           integers default=gmp
   --with-gmp=system|build Which gmp to use default=system
   --with-gmp-prefix=DIR   Prefix of gmp installation
@@ -1485,7 +1531,10 @@
   CXX         C++ compiler command
   CXXFLAGS    C++ compiler flags
   CPP         C preprocessor
+  LT_SYS_LIBRARY_PATH
+              User-defined run-time library search path.
   CXXCPP      C++ preprocessor
+  PYTHON      the Python interpreter
 
 Use these variables to override the choices made by `configure' or to help
 it to find libraries and programs with nonstandard names/locations.
@@ -1553,7 +1602,7 @@
 test -n "$ac_init_help" && exit $ac_status
 if $ac_init_version; then
   cat <<\_ACEOF
-isl configure 0.14
+isl configure 0.24
 generated by GNU Autoconf 2.69
 
 Copyright (C) 2012 Free Software Foundation, Inc.
@@ -1643,6 +1692,43 @@
 
 } # ac_fn_cxx_try_compile
 
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
 # ac_fn_c_try_run LINENO
 # ----------------------
 # Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
@@ -1762,43 +1848,6 @@
 
 } # ac_fn_c_check_header_compile
 
-# ac_fn_c_try_cpp LINENO
-# ----------------------
-# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
-ac_fn_c_try_cpp ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if { { ac_try="$ac_cpp conftest.$ac_ext"
-case "(($ac_try" in
-  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
-  *) ac_try_echo=$ac_try;;
-esac
-eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
-$as_echo "$ac_try_echo"; } >&5
-  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
-  ac_status=$?
-  if test -s conftest.err; then
-    grep -v '^ *+' conftest.err >conftest.er1
-    cat conftest.er1 >&5
-    mv -f conftest.er1 conftest.err
-  fi
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } > conftest.i && {
-	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
-	 test ! -s conftest.err
-       }; then :
-  ac_retval=0
-else
-  $as_echo "$as_me: failed program was:" >&5
-sed 's/^/| /' conftest.$ac_ext >&5
-
-    ac_retval=1
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-  as_fn_set_status $ac_retval
-
-} # ac_fn_c_try_cpp
-
 # ac_fn_c_check_func LINENO FUNC VAR
 # ----------------------------------
 # Tests whether FUNC exists, setting the cache variable VAR accordingly
@@ -2322,102 +2371,11 @@
   eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
 
 } # ac_fn_c_check_decl
-
-# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
-# ---------------------------------------------------------
-# Tests whether HEADER exists, giving a warning if it cannot be compiled using
-# the include files in INCLUDES and setting the cache variable VAR
-# accordingly.
-ac_fn_cxx_check_header_mongrel ()
-{
-  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
-  if eval \${$3+:} false; then :
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-$as_echo_n "checking for $2... " >&6; }
-if eval \${$3+:} false; then :
-  $as_echo_n "(cached) " >&6
-fi
-eval ac_res=\$$3
-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-else
-  # Is the header compilable?
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
-$as_echo_n "checking $2 usability... " >&6; }
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-$4
-#include <$2>
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-  ac_header_compiler=yes
-else
-  ac_header_compiler=no
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
-$as_echo "$ac_header_compiler" >&6; }
-
-# Is the header present?
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
-$as_echo_n "checking $2 presence... " >&6; }
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <$2>
-_ACEOF
-if ac_fn_cxx_try_cpp "$LINENO"; then :
-  ac_header_preproc=yes
-else
-  ac_header_preproc=no
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
-$as_echo "$ac_header_preproc" >&6; }
-
-# So?  What about this header?
-case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
-  yes:no: )
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
-$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
-    ;;
-  no:yes:* )
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
-$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
-$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
-$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
-$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
-    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
-$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
-( $as_echo "## ----------------------------------------------- ##
-## Report this to isl-development@googlegroups.com ##
-## ----------------------------------------------- ##"
-     ) | sed "s/^/$as_me: WARNING:     /" >&2
-    ;;
-esac
-  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
-$as_echo_n "checking for $2... " >&6; }
-if eval \${$3+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  eval "$3=\$ac_header_compiler"
-fi
-eval ac_res=\$$3
-	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
-$as_echo "$ac_res" >&6; }
-fi
-  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
-
-} # ac_fn_cxx_check_header_mongrel
 cat >config.log <<_ACEOF
 This file contains any messages produced by compilers while
 running configure, to aid debugging if configure makes a mistake.
 
-It was created by isl $as_me 0.14, which was
+It was created by isl $as_me 0.24, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   $ $0 $@
@@ -2795,7 +2753,7 @@
 
 
 
-am__api_version='1.14'
+am__api_version='1.16'
 
 # Find a good install program.  We prefer a C program (faster),
 # so one script is as good as another.  But avoid the broken or
@@ -2967,8 +2925,8 @@
 ac_script='s/\\$/&&/g;s/;s,x,x,$//'
 program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
 
-# expand $ac_aux_dir to an absolute path
-am_aux_dir=`cd $ac_aux_dir && pwd`
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
 
 if test x"${MISSING+set}" != xset; then
   case $am_aux_dir in
@@ -2987,7 +2945,7 @@
 $as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
 fi
 
-if test x"${install_sh}" != xset; then
+if test x"${install_sh+set}" != xset; then
   case $am_aux_dir in
   *\ * | *\	*)
     install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
@@ -3281,7 +3239,7 @@
 
 # Define the identity of the package.
  PACKAGE='isl'
- VERSION='0.14'
+ VERSION='0.24'
 
 
 cat >>confdefs.h <<_ACEOF
@@ -3311,12 +3269,12 @@
 
 # For better backward compatibility.  To be removed once Automake 1.9.x
 # dies out for good.  For more background, see:
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
-# <http://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
 mkdir_p='$(MKDIR_P)'
 
-# We need awk for the "check" target.  The system "awk" is bad on
-# some platforms.
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
 # Always define AMTAR for backward compatibility.  Yes, it's still used
 # in the wild :-(  We should find a proper way to deprecate it ...
 AMTAR='$${TAR-tar}'
@@ -3363,7 +3321,7 @@
 Aborting the configuration process, to ensure you take notice of the issue.
 
 You can download and install GNU coreutils to get an 'rm' implementation
-that behaves properly: <http://www.gnu.org/software/coreutils/>.
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
 
 If you want to complete the configuration process using your problematic
 'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
@@ -3373,6 +3331,7 @@
     as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
   fi
 fi
+
 # Check whether --enable-silent-rules was given.
 if test "${enable_silent_rules+set}" = set; then :
   enableval=$enable_silent_rules;
@@ -3413,7 +3372,7 @@
 AM_BACKSLASH='\'
 
 
-versioninfo=14:0:1
+versioninfo=24:0:1
 
 if test "x$prefix" != "xNONE"; then
 	prefix_wd=`cd $prefix && pwd`
@@ -4278,45 +4237,45 @@
 
 ac_config_commands="$ac_config_commands depfiles"
 
-
-am_make=${MAKE-make}
-cat > confinc << 'END'
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
+cat > confinc.mk << 'END'
 am__doit:
-	@echo this is the am__doit target
+	@echo this is the am__doit target >confinc.out
 .PHONY: am__doit
 END
-# If we don't find an include directive, just comment out the code.
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for style of include used by $am_make" >&5
-$as_echo_n "checking for style of include used by $am_make... " >&6; }
 am__include="#"
 am__quote=
-_am_result=none
-# First try GNU make style include.
-echo "include confinc" > confmf
-# Ignore all kinds of additional output from 'make'.
-case `$am_make -s -f confmf 2> /dev/null` in #(
-*the\ am__doit\ target*)
-  am__include=include
-  am__quote=
-  _am_result=GNU
-  ;;
-esac
-# Now try BSD make style include.
-if test "$am__include" = "#"; then
-   echo '.include "confinc"' > confmf
-   case `$am_make -s -f confmf 2> /dev/null` in #(
-   *the\ am__doit\ target*)
-     am__include=.include
-     am__quote="\""
-     _am_result=BSD
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
+   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+  case $?:`cat confinc.out 2>/dev/null` in #(
+  '0:this is the am__doit target') :
+    case $s in #(
+  BSD) :
+    am__include='.include' am__quote='"' ;; #(
+  *) :
+    am__include='include' am__quote='' ;;
+esac ;; #(
+  *) :
      ;;
-   esac
-fi
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $_am_result" >&5
-$as_echo "$_am_result" >&6; }
-rm -f confinc confmf
+esac
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+$as_echo "${_am_result}" >&6; }
 
 # Check whether --enable-dependency-tracking was given.
 if test "${enable_dependency_tracking+set}" = set; then :
@@ -4851,42 +4810,142 @@
 fi
 
 
-
-
-
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler vendor" >&5
-$as_echo_n "checking for C compiler vendor... " >&6; }
-if ${ax_cv_c_compiler_vendor+:} false; then :
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
   $as_echo_n "(cached) " >&6
 else
-  ax_cv_c_compiler_vendor=unknown
-  # note: don't check for gcc first since some other compilers define __GNUC__
-  for ventest in intel:__ICC,__ECC,__INTEL_COMPILER ibm:__xlc__,__xlC__,__IBMC__,__IBMCPP__ pathscale:__PATHCC__,__PATHSCALE__ clang:__clang__ gnu:__GNUC__ sun:__SUNPRO_C,__SUNPRO_CC hp:__HP_cc,__HP_aCC dec:__DECC,__DECCXX,__DECC_VER,__DECCXX_VER borland:__BORLANDC__,__TURBOC__ comeau:__COMO__ cray:_CRAYC kai:__KCC lcc:__LCC__ metrowerks:__MWERKS__ sgi:__sgi,sgi microsoft:_MSC_VER watcom:__WATCOMC__ portland:__PGI; do
-    vencpp="defined("`echo $ventest | cut -d: -f2 | sed 's/,/) || defined(/g'`")"
-    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
 /* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
 
-int
-main ()
-{
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
 
-#if !($vencpp)
-      thisisanerror;
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
 #endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
 
-  ;
-  return 0;
-}
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
 _ACEOF
-if ac_fn_c_try_compile "$LINENO"; then :
-  ax_cv_c_compiler_vendor=`echo $ventest | cut -d: -f1`; break
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
 fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-  done
+rm -f conftest.err conftest.i conftest.$ac_ext
 
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
 fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_c_compiler_vendor" >&5
-$as_echo "$ax_cv_c_compiler_vendor" >&6; }
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
 
 # Make sure we can run config.sub.
 $SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
@@ -4926,6 +4985,1185 @@
 case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
 
 
+
+
+cross_compiling_build=no
+
+ac_build_tool_prefix=
+if test -n "$build"; then :
+  ac_build_tool_prefix="$build-"
+elif test -n "$build_alias"; then :
+  ac_build_tool_prefix="$build_alias-"
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+if test -n "$ac_build_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_build_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="${ac_build_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC_FOR_BUILD"; then
+  ac_ct_CC_FOR_BUILD=$CC_FOR_BUILD
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC_FOR_BUILD"; then
+  ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_ct_CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC_FOR_BUILD="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC_FOR_BUILD=$ac_cv_prog_ac_ct_CC_FOR_BUILD
+if test -n "$ac_ct_CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC_FOR_BUILD" >&5
+$as_echo "$ac_ct_CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC_FOR_BUILD" = x; then
+    CC_FOR_BUILD=""
+  else
+    case $cross_compiling_build:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with build triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with build triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC_FOR_BUILD=$ac_ct_CC_FOR_BUILD
+  fi
+else
+  CC_FOR_BUILD="$ac_cv_prog_CC_FOR_BUILD"
+fi
+
+if test -z "$CC_FOR_BUILD"; then
+          if test -n "$ac_build_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_build_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="${ac_build_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC_FOR_BUILD"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC_FOR_BUILD="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC_FOR_BUILD
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC_FOR_BUILD to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC_FOR_BUILD="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC_FOR_BUILD"; then
+  if test -n "$ac_build_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_build_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="$ac_build_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC_FOR_BUILD" && break
+  done
+fi
+if test -z "$CC_FOR_BUILD"; then
+  ac_ct_CC_FOR_BUILD=$CC_FOR_BUILD
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC_FOR_BUILD"; then
+  ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_ct_CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC_FOR_BUILD=$ac_cv_prog_ac_ct_CC_FOR_BUILD
+if test -n "$ac_ct_CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC_FOR_BUILD" >&5
+$as_echo "$ac_ct_CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC_FOR_BUILD" && break
+done
+
+  if test "x$ac_ct_CC_FOR_BUILD" = x; then
+    CC_FOR_BUILD=""
+  else
+    case $cross_compiling_build:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with build triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with build triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC_FOR_BUILD=$ac_ct_CC_FOR_BUILD
+  fi
+fi
+
+fi
+
+
+test -z "$CC_FOR_BUILD" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC_FOR_BUILD=yes
+else
+  GCC_FOR_BUILD=
+fi
+ac_test_CFLAGS=${CFLAGS_FOR_BUILD+set}
+ac_save_CFLAGS=$CFLAGS_FOR_BUILD
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC_FOR_BUILD accepts -g" >&5
+$as_echo_n "checking whether $CC_FOR_BUILD accepts -g... " >&6; }
+if ${ac_cv_build_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_build_prog_cc_g=no
+   CFLAGS_FOR_BUILD="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_g=yes
+else
+  CFLAGS_FOR_BUILD=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS_FOR_BUILD="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_prog_cc_g" >&5
+$as_echo "$ac_cv_build_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS_FOR_BUILD=$ac_save_CFLAGS
+elif test $ac_cv_build_prog_cc_g = yes; then
+  if test "$GCC_FOR_BUILD" = yes; then
+    CFLAGS_FOR_BUILD="-g -O2"
+  else
+    CFLAGS_FOR_BUILD="-g"
+  fi
+else
+  if test "$GCC_FOR_BUILD" = yes; then
+    CFLAGS_FOR_BUILD="-O2"
+  else
+    CFLAGS_FOR_BUILD=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC_FOR_BUILD option to accept ISO C89" >&5
+$as_echo_n "checking for $CC_FOR_BUILD option to accept ISO C89... " >&6; }
+if ${ac_cv_build_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_build_prog_cc_c89=no
+ac_save_CC=$CC_FOR_BUILD
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return pi;
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array '\x00' == 0 ? 1 : -1;
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_arrayFOO(a) == 'x' ? 1 : -1;
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv0  ||  f (e, argv, 1) != argv1;
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC_FOR_BUILD="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_build_objext
+  test "x$ac_cv_build_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC_FOR_BUILD=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_build_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC_FOR_BUILD="$CC_FOR_BUILD $ac_cv_build_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_prog_cc_c89" >&5
+$as_echo "$ac_cv_build_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_build_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC_FOR_BUILD understands -c and -o together" >&5
+$as_echo_n "checking whether $CC_FOR_BUILD understands -c and -o together... " >&6; }
+if ${am_cv_build_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_build_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC_FOR_BUILD -c conftest.$ac_ext -o conftest2.$ac_build_objext" >&5
+   ($CC_FOR_BUILD -c conftest.$ac_ext -o conftest2.$ac_build_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_build_objext; then
+      : OK
+    else
+      am_cv_build_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_build_prog_cc_c_o" >&5
+$as_echo "$am_cv_build_prog_cc_c_o" >&6; }
+if test "$am_cv_build_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC_FOR_BUILD="$am_aux_dir/compile $CC_FOR_BUILD"
+fi
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+
+depcc="$CC_FOR_BUILD"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_build_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_build_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${BUILD_OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${BUILD_OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_build_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_build_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_build_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_build_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE_FOR_BUILD=depmode=$am_cv_build_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_build_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_build_TRUE=
+  am__fastdepCC_build_FALSE='#'
+else
+  am__fastdepCC_build_TRUE='#'
+  am__fastdepCC_build_FALSE=
+fi
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest^ *//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    ab.out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_build_exeext+set}" = set && test "$ac_cv_build_exeext" != no;
+	then :; else
+	   ac_cv_build_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_build_exeext" = no && ac_cv_build_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_build_exeext=$ac_cv_build_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_build_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_build_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_build_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_exeext" >&5
+$as_echo "$ac_cv_build_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+BUILD_EXEEXT=$ac_cv_build_exeext
+ac_build_exeext=$BUILD_EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling_build" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_build_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling_build=no
+  else
+    if test "$cross_compiling_build" = maybe; then
+	cross_compiling_build=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--build'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling_build" >&5
+$as_echo "$cross_compiling_build" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_build_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_build_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_build_objext=`expr "$ac_file" : '.*\.$.*$'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_build_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_objext" >&5
+$as_echo "$ac_cv_build_objext" >&6; }
+BUILD_OBJEXT=$ac_cv_build_objext
+ac_build_objext=$BUILD_OBJEXT
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP_FOR_BUILD" && test -d "$CPP_FOR_BUILD"; then
+  CPP_FOR_BUILD=
+fi
+if test -z "$CPP_FOR_BUILD"; then
+  if ${ac_cv_build_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP_FOR_BUILD in "$CC_FOR_BUILD -E" "$CC_FOR_BUILD -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_build_prog_CPP=$CPP_FOR_BUILD
+
+fi
+  CPP_FOR_BUILD=$ac_cv_build_prog_CPP
+else
+  ac_cv_build_prog_CPP=$CPP_FOR_BUILD
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP_FOR_BUILD" >&5
+$as_echo "$CPP_FOR_BUILD" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP_FOR_BUILD\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler vendor" >&5
+$as_echo_n "checking for C compiler vendor... " >&6; }
+if ${ax_cv_c_compiler_vendor+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ax_cv_c_compiler_vendor=unknown
+  # note: don't check for gcc first since some other compilers define __GNUC__
+  for ventest in intel:__ICC,__ECC,__INTEL_COMPILER ibm:__xlc__,__xlC__,__IBMC__,__IBMCPP__ pathscale:__PATHCC__,__PATHSCALE__ clang:__clang__ gnu:__GNUC__ sun:__SUNPRO_C,__SUNPRO_CC hp:__HP_cc,__HP_aCC dec:__DECC,__DECCXX,__DECC_VER,__DECCXX_VER borland:__BORLANDC__,__TURBOC__ comeau:__COMO__ cray:_CRAYC kai:__KCC lcc:__LCC__ metrowerks:__MWERKS__ sgi:__sgi,sgi microsoft:_MSC_VER watcom:__WATCOMC__ portland:__PGI; do
+    vencpp="defined("`echo $ventest | cut -d: -f2 | sed 's/,/) || defined(/g'`")"
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+#if !($vencpp)
+      thisisanerror;
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ax_cv_c_compiler_vendor=`echo $ventest | cut -d: -f1`; break
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+  done
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_c_compiler_vendor" >&5
+$as_echo "$ax_cv_c_compiler_vendor" >&6; }
+
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
 $as_echo_n "checking host system type... " >&6; }
 if ${ac_cv_host+:} false; then :
@@ -5866,6 +7104,1132 @@
   fi
 
 
+
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+	echo $CXX | $GREP -e "-std=" > /dev/null 2> /dev/null
+	if test $? -eq 0; then
+		  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ax_cv_cxx_compile_cxx11=yes
+else
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+  else
+    HAVE_CXX11=1
+
+$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+
+  fi
+
+
+	else
+		  ax_cxx_compile_alternatives="11 0x"    ax_cxx_compile_cxx11_required=false
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ax_cv_cxx_compile_cxx11=yes
+else
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+
+
+    if test x$ac_success = xno; then
+                for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval \${$cachevar+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  eval $cachevar=yes
+else
+  eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+           CXX="$ac_save_CXX"
+fi
+eval ac_res=\$$cachevar
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+    { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5
+$as_echo "$as_me: No compiler with C++11 support was found" >&6;}
+  else
+    HAVE_CXX11=1
+
+$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+
+  fi
+
+
+
+	fi
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
 case `pwd` in
   *\ * | *\	*)
     { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
@@ -5874,8 +8238,8 @@
 
 
 
-macro_version='2.4.2.418'
-macro_revision='2.4.2.418'
+macro_version='2.4.6'
+macro_revision='2.4.6'
 
 
 
@@ -6042,69 +8406,6 @@
 
 
 
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
-if ${ac_cv_path_GREP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -z "$GREP"; then
-  ac_path_GREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_prog in grep ggrep; do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_GREP" || continue
-# Check for GNU ac_path_GREP and select it if it is found.
-  # Check for GNU $ac_path_GREP
-case `"$ac_path_GREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-*)
-  ac_count=0
-  $as_echo_n 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    $as_echo 'GREP' >> "conftest.nl"
-    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_GREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_GREP="$ac_path_GREP"
-      ac_path_GREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_GREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_GREP"; then
-    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_GREP=$GREP
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-$as_echo "$ac_cv_path_GREP" >&6; }
- GREP="$ac_cv_path_GREP"
-
-
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
 $as_echo_n "checking for egrep... " >&6; }
 if ${ac_cv_path_EGREP+:} false; then :
@@ -6394,8 +8695,13 @@
 	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
 	#   nm: unknown option "B" ignored
 	# Tru64's nm complains that /dev/null is an invalid object file
-	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
-	*/dev/null* | *'Invalid file or object type'*)
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
 	  lt_cv_path_NM="$tmp_nm -B"
 	  break 2
 	  ;;
@@ -7099,7 +9405,7 @@
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-netbsd*)
+netbsd* | netbsdelf*-gnu)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so\.0-9+\.0-9+|_pic\.a)$'
   else
@@ -7171,6 +9477,9 @@
 tpf*)
   lt_cv_deplibs_check_method=pass_all
   ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
 esac
 
 fi
@@ -7458,7 +9767,7 @@
 fi
 
 : ${AR=ar}
-: ${AR_FLAGS=cru}
+: ${AR_FLAGS=cr}
 
 
 
@@ -7959,11 +10268,8 @@
   test $ac_status = 0; }; then
     # Now try to grab the symbols.
     nlist=conftest.nm
-    if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist\""; } >&5
-  (eval $NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) 2>&5
-  ac_status=$?
-  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
-  test $ac_status = 0; } && test -s "$nlist"; then
+    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&5
+    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&5 && test -s "$nlist"; then
       # Try sorting and uniquifying the output.
       if sort "$nlist" | uniq > "$nlist"T; then
 	mv -f "$nlist"T "$nlist"
@@ -8153,6 +10459,86 @@
 
 
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+$as_echo_n "checking for a working dd... " >&6; }
+if ${ac_cv_path_lt_DD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+if test -z "$lt_DD"; then
+  ac_path_lt_DD_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in dd; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_lt_DD" || continue
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi
+      $ac_path_lt_DD_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_lt_DD"; then
+    :
+  fi
+else
+  ac_cv_path_lt_DD=$lt_DD
+fi
+
+rm -f conftest.i conftest2.i conftest.out
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+$as_echo "$ac_cv_path_lt_DD" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+$as_echo_n "checking how to truncate binary pipes... " >&6; }
+if ${lt_cv_truncate_bin+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+$as_echo "$lt_cv_truncate_bin" >&6; }
+
+
+
+
+
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *\\/compile | ccache | *\\/ccache ) ;;
+        distcc | *\\/distcc | purify | *\\/purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
 # Check whether --enable-libtool-lock was given.
 if test "${enable_libtool_lock+set}" = set; then :
   enableval=$enable_libtool_lock;
@@ -9102,8 +11488,8 @@
 _LT_EOF
       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
-      echo "$AR cru libconftest.a conftest.o" >&5
-      $AR cru libconftest.a conftest.o 2>&5
+      echo "$AR cr libconftest.a conftest.o" >&5
+      $AR cr libconftest.a conftest.o 2>&5
       echo "$RANLIB libconftest.a" >&5
       $RANLIB libconftest.a 2>&5
       cat > conftest.c << _LT_EOF
@@ -9137,7 +11523,7 @@
       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
 	10.0,*86*-darwin8*|10.0,*-darwin91*)
 	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.012*)
+	10.012,.*)
 	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
 	10.*)
 	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
@@ -9160,142 +11546,40 @@
     ;;
   esac
 
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
-$as_echo_n "checking how to run the C preprocessor... " >&6; }
-# On Suns, sometimes $CPP names a directory.
-if test -n "$CPP" && test -d "$CPP"; then
-  CPP=
-fi
-if test -z "$CPP"; then
-  if ${ac_cv_prog_CPP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-      # Double quotes because CPP needs to be expanded
-    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
-    do
-      ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
-else
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-  break
-fi
-
-    done
-    ac_cv_prog_CPP=$CPP
-
-fi
-  CPP=$ac_cv_prog_CPP
-else
-  ac_cv_prog_CPP=$CPP
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
-$as_echo "$CPP" >&6; }
-ac_preproc_ok=false
-for ac_c_preproc_warn_flag in '' yes
-do
-  # Use a header file that comes with gcc, so configuring glibc
-  # with a fresh cross-compiler works.
-  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
-  # <limits.h> exists even on freestanding compilers.
-  # On the NeXT, cc -E runs the code through the compiler's parser,
-  # not just through cpp. "Syntax error" is here to catch this case.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#ifdef __STDC__
-# include <limits.h>
-#else
-# include <assert.h>
-#endif
-		     Syntax error
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-
-else
-  # Broken: fails on valid input.
-continue
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-  # OK, works on sane cases.  Now check whether nonexistent headers
-  # can be detected and how.
-  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <ac_nonexistent.h>
-_ACEOF
-if ac_fn_c_try_cpp "$LINENO"; then :
-  # Broken: success on invalid input.
-continue
-else
-  # Passes both tests.
-ac_preproc_ok=:
-break
-fi
-rm -f conftest.err conftest.i conftest.$ac_ext
-
-done
-# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
-rm -f conftest.i conftest.err conftest.$ac_ext
-if $ac_preproc_ok; then :
-
-else
-  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
-$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
-as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
-See \`config.log' for more details" "$LINENO" 5; }
-fi
-
-ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR:DIR:"
+#       string "DIR DIR" will be prepended to VARIABLE
+# ":DIR:DIR"
+#       string "DIR DIR" will be appended to VARIABLE
+# "DIRP:DIRP::DIRA:DIRA"
+#       string "DIRP DIRP" will be prepended to VARIABLE and string
+#       "DIRA DIRA" will be appended to VARIABLE
+# "DIR:DIR"
+#       VARIABLE will be replaced by "DIR DIR"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
 
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
@@ -9442,7 +11726,6 @@
 
 
 
-
 func_stripname_cnf ()
 {
   case $2 in
@@ -9587,6 +11870,58 @@
 
 
 
+  shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix5-9*,yes)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+$as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
+
+# Check whether --with-aix-soname was given.
+if test "${with_aix_soname+set}" = set; then :
+  withval=$with_aix_soname; case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname
+else
+  if ${lt_cv_with_aix_soname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_with_aix_soname=aix
+fi
+
+    with_aix_soname=$lt_cv_with_aix_soname
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+$as_echo "$with_aix_soname" >&6; }
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+
+
+
+
+
+
 
 
 
@@ -9706,15 +12041,8 @@
 test -z "$LD" && LD=ld
 test -z "$ac_objext" && ac_objext=o
 
-for cc_temp in $compiler""; do
-  case $cc_temp in
-    compile | *\\/compile | ccache | *\\/ccache ) ;;
-    distcc | *\\/distcc | purify | *\\/purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
 
 
 # Only perform the check for file, if the check method requires it
@@ -10025,6 +12353,11 @@
       # Although the cygwin gcc ignores -fPIC, still need this for old-style
       # (--disable-auto-import) libraries
       lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
       ;;
 
     darwin* | rhapsody*)
@@ -10121,6 +12454,11 @@
       # This hack is so that the source file can tell whether it is being
       # built for inclusion in a dll (and should export symbols for example).
       lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
       ;;
 
     hpux9* | hpux10* | hpux11*)
@@ -10153,6 +12491,12 @@
 	lt_prog_compiler_pic='-KPIC'
 	lt_prog_compiler_static='-static'
         ;;
+      # flang / f18. f95 an alias for gfortran or flang on Debian
+      flang* | f18* | f95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
       # icc used to be incompatible with GCC.
       # ICC 10 doesn't accept -KPIC any more.
       icc* | ifort*)
@@ -10629,6 +12973,9 @@
   openbsd* | bitrig*)
     with_gnu_ld=no
     ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs=no
+    ;;
   esac
 
   ld_shlibs=yes
@@ -10761,6 +13108,34 @@
       link_all_deplibs=yes
       ;;
 
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
     interix3-9*)
       hardcode_direct=no
       hardcode_shlibpath_var=no
@@ -10834,6 +13209,9 @@
         fi
 
 	case $cc_basename in
+	tcc*)
+	  export_dynamic_flag_spec='-rdynamic'
+	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
 	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
 	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
@@ -10852,7 +13230,7 @@
       fi
       ;;
 
-    netbsd*)
+    netbsd* | netbsdelf*-gnu)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
 	wlarc=
@@ -10963,19 +13341,35 @@
 	no_entry_flag=
       else
 	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to AIX nm, but means don't demangle with GNU nm
-	# Also, AIX nm treats weak defined symbols like other global
-	# defined symbols, whereas GNU nm marks them as "W".
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  export_symbols_cmds='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
 	# Test if we are trying to use run time linking or normal
 	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# need to do runtime linking.
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
 	case $host_os in aix4.23|aix4.23.*|aix5-9*)
 	  for ld_flag in $LDFLAGS; do
 	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
@@ -10983,6 +13377,13 @@
 	    break
 	  fi
 	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
 	  ;;
 	esac
 
@@ -11002,6 +13403,14 @@
       hardcode_libdir_separator=':'
       link_all_deplibs=yes
       file_list_spec='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	hardcode_direct=no
+	hardcode_direct_absolute=no
+	;;
+      esac
 
       if test yes = "$GCC"; then
 	case $host_os in aix4.012|aix4.012.*)
@@ -11029,6 +13438,11 @@
 	if test yes = "$aix_use_runtimelinking"; then
 	  shared_flag="$shared_flag "'$wl-G'
 	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
       else
 	# not using gcc
 	if test ia64 = "$host_cpu"; then
@@ -11041,6 +13455,8 @@
 	  else
 	    shared_flag='$wl-bM:SRE'
 	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
 	fi
       fi
 
@@ -11048,7 +13464,7 @@
       # It seems that -bexpall does not export symbols beginning with
       # underscore (_), so it is better to generate a list of symbols to export.
       always_export_symbols=yes
-      if test yes = "$aix_use_runtimelinking"; then
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
 	# Warning - without using the other runtime loading flags (-brtl),
 	# -berok will link without error, but may produce a broken library.
 	allow_undefined_flag='-berok'
@@ -11163,8 +13579,20 @@
 	    whole_archive_flag_spec='$convenience'
 	  fi
 	  archive_cmds_need_lc=yes
-	  # This is similar to how AIX traditionally builds its shared libraries.
-	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $wl-bnoentry $compiler_flags $wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
 	fi
       fi
       ;;
@@ -11472,6 +13900,7 @@
 	if test yes = "$lt_cv_irix_exported_symbol"; then
           archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
 	fi
+	link_all_deplibs=no
       else
 	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
@@ -11483,7 +13912,17 @@
       link_all_deplibs=yes
       ;;
 
-    netbsd*)
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	ld_shlibs=yes
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
       else
@@ -11528,8 +13967,28 @@
       hardcode_libdir_flag_spec='-L$libdir'
       hardcode_minus_L=yes
       allow_undefined_flag=unsupported
-      archive_cmds='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
-      old_archive_from_new_cmds='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
       ;;
 
     osf3*)
@@ -12052,6 +14511,8 @@
 # flags to be left without arguments
 need_version=unknown
 
+
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
@@ -12088,20 +14549,70 @@
       fi
       ;;
     esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
     # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test yes = "$aix_use_runtimelinking"; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
       library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    else
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
       library_names_spec='$libname$release.a $libname.a'
       soname_spec='$libname$release$shared_ext$major'
-    fi
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -12289,7 +14800,8 @@
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
@@ -12349,10 +14861,11 @@
     soname_spec='$libname$release$shared_ext$major'
     if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -12504,7 +15017,12 @@
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^	 *hwcap	 /d;s/:,	/ /g;s/=^=*$//;s/=^= * / /g;s/"//g;/^$/d' | tr '\n' ' '`
     sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
@@ -12519,6 +15037,18 @@
   dynamic_linker='GNU/Linux ld.so'
   ;;
 
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
 netbsd*)
   version_type=sunos
   need_lib_prefix=no
@@ -12573,11 +15103,32 @@
 
 os2*)
   libname_spec='$name'
+  version_type=windows
   shrext_cmds=.dll
+  need_version=no
   need_lib_prefix=no
-  library_names_spec='$libname$shared_ext $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
@@ -12653,7 +15204,7 @@
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
   library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
@@ -12708,10 +15259,25 @@
 if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
   sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
+
 if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
   sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
 
 
 
@@ -13182,7 +15748,7 @@
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
 #if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
@@ -13288,7 +15854,7 @@
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
 #if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
@@ -13437,8 +16003,12 @@
     ;;
 
   aix4-9*)
-    if test ia64 != "$host_cpu" && test no = "$aix_use_runtimelinking"; then
-      test yes = "$enable_shared" && enable_static=no
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
     fi
     ;;
   esac
@@ -13706,15 +16276,8 @@
   CFLAGS=$CXXFLAGS
   compiler=$CC
   compiler_CXX=$CC
-  for cc_temp in $compiler""; do
-  case $cc_temp in
-    compile | *\\/compile | ccache | *\\/ccache ) ;;
-    distcc | *\\/distcc | purify | *\\/purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+  func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
 
 
   if test -n "$compiler"; then
@@ -13876,7 +16439,7 @@
       # Commands to make compiler produce verbose output that lists
       # what "hidden" libraries, object files and flags are used when
       # linking a shared library.
-      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 
     else
       GXX=no
@@ -13905,7 +16468,19 @@
 
           # Test if we are trying to use run time linking or normal
           # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # need to do runtime linking.
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
           case $host_os in aix4.23|aix4.23.*|aix5-9*)
 	    for ld_flag in $LDFLAGS; do
 	      case $ld_flag in
@@ -13915,6 +16490,13 @@
 	        ;;
 	      esac
 	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
 	    ;;
           esac
 
@@ -13934,6 +16516,14 @@
         hardcode_libdir_separator_CXX=':'
         link_all_deplibs_CXX=yes
         file_list_spec_CXX='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          hardcode_direct_CXX=no
+          hardcode_direct_absolute_CXX=no
+          ;;
+        esac
 
         if test yes = "$GXX"; then
           case $host_os in aix4.012|aix4.012.*)
@@ -13960,6 +16550,11 @@
 	  if test yes = "$aix_use_runtimelinking"; then
 	    shared_flag=$shared_flag' $wl-G'
 	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
         else
           # not using gcc
           if test ia64 = "$host_cpu"; then
@@ -13972,6 +16567,8 @@
 	    else
 	      shared_flag='$wl-bM:SRE'
 	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
           fi
         fi
 
@@ -13980,10 +16577,11 @@
         # underscore (_), so it is better to generate a list of symbols to
 	# export.
         always_export_symbols_CXX=yes
-        if test yes = "$aix_use_runtimelinking"; then
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
           # Warning - without using the other runtime loading flags (-brtl),
           # -berok will link without error, but may produce a broken library.
-          allow_undefined_flag_CXX='-berok'
+          # The "-G" linker flag allows undefined symbols.
+          no_undefined_flag_CXX='-bernotok'
           # Determine the default libpath from the value encoded in an empty
           # executable.
           if test set = "${lt_cv_aix_libpath+set}"; then
@@ -14096,9 +16694,21 @@
 	      whole_archive_flag_spec_CXX='$convenience'
 	    fi
 	    archive_cmds_need_lc_CXX=yes
-	    # This is similar to how AIX traditionally builds its shared
-	    # libraries.
-	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $wl-bnoentry $compiler_flags $wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	    archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d'
           fi
         fi
         ;;
@@ -14230,6 +16840,34 @@
 
 	;;
 
+      os2*)
+	hardcode_libdir_flag_spec_CXX='-L$libdir'
+	hardcode_minus_L_CXX=yes
+	allow_undefined_flag_CXX=unsupported
+	shrext_cmds=.dll
+	archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	enable_shared_with_static_runtimes_CXX=yes
+	;;
+
       dgux*)
         case $cc_basename in
           ec++*)
@@ -14293,7 +16931,7 @@
             # explicitly linking system object files so we need to strip them
             # from the output so that they don't get included in the library
             # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
             ;;
           *)
             if test yes = "$GXX"; then
@@ -14358,7 +16996,7 @@
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
           *)
 	    if test yes = "$GXX"; then
@@ -14697,7 +17335,7 @@
 	      # Commands to make compiler produce verbose output that lists
 	      # what "hidden" libraries, object files and flags are used when
 	      # linking a shared library.
-	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 
 	    else
 	      # FIXME: insert proper C++ library support
@@ -14781,7 +17419,7 @@
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 	      else
 	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
 	        # platform.
@@ -14792,7 +17430,7 @@
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 	      fi
 
 	      hardcode_libdir_flag_spec_CXX='$wl-R $wl$libdir'
@@ -15026,51 +17664,6 @@
   postdep_objects_CXX=
   postdeps_CXX=
   ;;
-
-linux*)
-  case `$CC -V 2>&1 | sed 5q` in
-  *Sun\ C*)
-    # Sun C++ 5.9
-
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    if test yes != "$solaris_use_stlport4"; then
-      postdeps_CXX='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
-
-solaris*)
-  case $cc_basename in
-  CC* | sunCC*)
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    # Adding this requires a known-good setup of shared libraries for
-    # Sun compiler versions before 5.6, else PIC objects from an old
-    # archive will be linked into the output, leading to subtle bugs.
-    if test yes != "$solaris_use_stlport4"; then
-      postdeps_CXX='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
 esac
 
 
@@ -15156,6 +17749,11 @@
       # Although the cygwin gcc ignores -fPIC, still need this for old-style
       # (--disable-auto-import) libraries
       lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static_CXX='$wl-static'
+	;;
+      esac
       ;;
     darwin* | rhapsody*)
       # PIC is the default on this platform
@@ -15345,7 +17943,7 @@
 	    ;;
 	esac
 	;;
-      netbsd*)
+      netbsd* | netbsdelf*-gnu)
 	;;
       *qnx* | *nto*)
         # QNX uses GNU C++, but need to define -shared option too, otherwise
@@ -15693,13 +18291,17 @@
   case $host_os in
   aix4-9*)
     # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to AIX nm, but means don't demangle with GNU nm
-    # Also, AIX nm treats weak defined symbols like other global defined
-    # symbols, whereas GNU nm marks them as "W".
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      export_symbols_cmds_CXX='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
@@ -15716,6 +18318,9 @@
       ;;
     esac
     ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs_CXX=no
+    ;;
   *)
     export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
     ;;
@@ -15885,6 +18490,8 @@
 # flags to be left without arguments
 need_version=unknown
 
+
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
@@ -15921,20 +18528,70 @@
       fi
       ;;
     esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
     # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test yes = "$aix_use_runtimelinking"; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
       library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    else
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
       library_names_spec='$libname$release.a $libname.a'
       soname_spec='$libname$release$shared_ext$major'
-    fi
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -16120,7 +18777,8 @@
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
@@ -16180,10 +18838,11 @@
     soname_spec='$libname$release$shared_ext$major'
     if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -16335,7 +18994,12 @@
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^	 *hwcap	 /d;s/:,	/ /g;s/=^=*$//;s/=^= * / /g;s/"//g;/^$/d' | tr '\n' ' '`
     sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
@@ -16350,6 +19014,18 @@
   dynamic_linker='GNU/Linux ld.so'
   ;;
 
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
 netbsd*)
   version_type=sunos
   need_lib_prefix=no
@@ -16404,11 +19080,32 @@
 
 os2*)
   libname_spec='$name'
+  version_type=windows
   shrext_cmds=.dll
+  need_version=no
   need_lib_prefix=no
-  library_names_spec='$libname$shared_ext $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
@@ -16484,7 +19181,7 @@
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
   library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
@@ -16539,10 +19236,22 @@
 if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
   sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
+
 if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
   sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
 
 
 
@@ -16666,6 +19375,381 @@
 # Only expand once:
 
 
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+
+
+
+
+
+
+        if test -n "$PYTHON"; then
+      # If the user set $PYTHON, use it and don't search something else.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $PYTHON version is >= 2.5" >&5
+$as_echo_n "checking whether $PYTHON version is >= 2.5... " >&6; }
+      prog="import sys
+# split strings by '.' and convert to numeric.  Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '2.5'.split('.'))) + 0, 0, 0
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minveri
+sys.exit(sys.hexversion < minverhex)"
+  if { echo "$as_me:$LINENO: $PYTHON -c "$prog"" >&5
+   ($PYTHON -c "$prog") >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+			       as_fn_error $? "Python interpreter is too old" "$LINENO" 5
+fi
+      am_display_PYTHON=$PYTHON
+    else
+      # Otherwise, try each interpreter until we find one that satisfies
+      # VERSION.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking for a Python interpreter with version >= 2.5" >&5
+$as_echo_n "checking for a Python interpreter with version >= 2.5... " >&6; }
+if ${am_cv_pathless_PYTHON+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+	for am_cv_pathless_PYTHON in python python2 python3  python3.9 python3.8 python3.7 python3.6 python3.5 python3.4 python3.3  python3.2 python3.1 python3.0  python2.7 python2.6 python2.5 python2.4 python2.3 python2.2 python2.1  python2.0 none; do
+	  test "$am_cv_pathless_PYTHON" = none && break
+	  prog="import sys
+# split strings by '.' and convert to numeric.  Append some zeros
+# because we need at least 4 digits for the hex conversion.
+# map returns an iterator in Python 3.0 and a list in 2.x
+minver = list(map(int, '2.5'.split('.'))) + 0, 0, 0
+minverhex = 0
+# xrange is not present in Python 3.0 and range returns an iterator
+for i in list(range(0, 4)): minverhex = (minverhex << 8) + minveri
+sys.exit(sys.hexversion < minverhex)"
+  if { echo "$as_me:$LINENO: $am_cv_pathless_PYTHON -c "$prog"" >&5
+   ($am_cv_pathless_PYTHON -c "$prog") >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }; then :
+  break
+fi
+	done
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_pathless_PYTHON" >&5
+$as_echo "$am_cv_pathless_PYTHON" >&6; }
+      # Set $PYTHON to the absolute path of $am_cv_pathless_PYTHON.
+      if test "$am_cv_pathless_PYTHON" = none; then
+	PYTHON=:
+      else
+        # Extract the first word of "$am_cv_pathless_PYTHON", so it can be a program name with args.
+set dummy $am_cv_pathless_PYTHON; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_PYTHON+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $PYTHON in
+  \\/* | ?:\\/*)
+  ac_cv_path_PYTHON="$PYTHON" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_PYTHON="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+PYTHON=$ac_cv_path_PYTHON
+if test -n "$PYTHON"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $PYTHON" >&5
+$as_echo "$PYTHON" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+      fi
+      am_display_PYTHON=$am_cv_pathless_PYTHON
+    fi
+
+
+  if test "$PYTHON" = :; then
+      :
+  else
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON version" >&5
+$as_echo_n "checking for $am_display_PYTHON version... " >&6; }
+if ${am_cv_python_version+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  am_cv_python_version=`$PYTHON -c "import sys; sys.stdout.write(sys.version:3)"`
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_version" >&5
+$as_echo "$am_cv_python_version" >&6; }
+  PYTHON_VERSION=$am_cv_python_version
+
+
+
+  PYTHON_PREFIX='${prefix}'
+
+  PYTHON_EXEC_PREFIX='${exec_prefix}'
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON platform" >&5
+$as_echo_n "checking for $am_display_PYTHON platform... " >&6; }
+if ${am_cv_python_platform+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  am_cv_python_platform=`$PYTHON -c "import sys; sys.stdout.write(sys.platform)"`
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_platform" >&5
+$as_echo "$am_cv_python_platform" >&6; }
+  PYTHON_PLATFORM=$am_cv_python_platform
+
+
+  # Just factor out some code duplication.
+  am_python_setup_sysconfig="\
+import sys
+# Prefer sysconfig over distutils.sysconfig, for better compatibility
+# with python 3.x.  See automake bug#10227.
+try:
+    import sysconfig
+except ImportError:
+    can_use_sysconfig = 0
+else:
+    can_use_sysconfig = 1
+# Can't use sysconfig in CPython 2.7, since it's broken in virtualenvs:
+# <https://github.com/pypa/virtualenv/issues/118>
+try:
+    from platform import python_implementation
+    if python_implementation() == 'CPython' and sys.version:3 == '2.7':
+        can_use_sysconfig = 0
+except ImportError:
+    pass"
+
+
+            { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON script directory" >&5
+$as_echo_n "checking for $am_display_PYTHON script directory... " >&6; }
+if ${am_cv_python_pythondir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$prefix" = xNONE
+     then
+       am_py_prefix=$ac_default_prefix
+     else
+       am_py_prefix=$prefix
+     fi
+     am_cv_python_pythondir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+    sitedir = sysconfig.get_path('purelib', vars={'base':'$am_py_prefix'})
+else:
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(0, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+     case $am_cv_python_pythondir in
+     $am_py_prefix*)
+       am__strip_prefix=`echo "$am_py_prefix" | sed 's|.|.|g'`
+       am_cv_python_pythondir=`echo "$am_cv_python_pythondir" | sed "s,^$am__strip_prefix,$PYTHON_PREFIX,"`
+       ;;
+     *)
+       case $am_py_prefix in
+         /usr|/System*) ;;
+         *)
+	  am_cv_python_pythondir=$PYTHON_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	  ;;
+       esac
+       ;;
+     esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pythondir" >&5
+$as_echo "$am_cv_python_pythondir" >&6; }
+  pythondir=$am_cv_python_pythondir
+
+
+
+  pkgpythondir=\${pythondir}/$PACKAGE
+
+
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $am_display_PYTHON extension module directory" >&5
+$as_echo_n "checking for $am_display_PYTHON extension module directory... " >&6; }
+if ${am_cv_python_pyexecdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$exec_prefix" = xNONE
+     then
+       am_py_exec_prefix=$am_py_prefix
+     else
+       am_py_exec_prefix=$exec_prefix
+     fi
+     am_cv_python_pyexecdir=`$PYTHON -c "
+$am_python_setup_sysconfig
+if can_use_sysconfig:
+    sitedir = sysconfig.get_path('platlib', vars={'platbase':'$am_py_prefix'})
+else:
+    from distutils import sysconfig
+    sitedir = sysconfig.get_python_lib(1, 0, prefix='$am_py_prefix')
+sys.stdout.write(sitedir)"`
+     case $am_cv_python_pyexecdir in
+     $am_py_exec_prefix*)
+       am__strip_prefix=`echo "$am_py_exec_prefix" | sed 's|.|.|g'`
+       am_cv_python_pyexecdir=`echo "$am_cv_python_pyexecdir" | sed "s,^$am__strip_prefix,$PYTHON_EXEC_PREFIX,"`
+       ;;
+     *)
+       case $am_py_exec_prefix in
+         /usr|/System*) ;;
+         *)
+	   am_cv_python_pyexecdir=$PYTHON_EXEC_PREFIX/lib/python$PYTHON_VERSION/site-packages
+	   ;;
+       esac
+       ;;
+     esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_python_pyexecdir" >&5
+$as_echo "$am_cv_python_pyexecdir" >&6; }
+  pyexecdir=$am_cv_python_pyexecdir
+
+
+
+  pkgpyexecdir=\${pyexecdir}/$PACKAGE
+
+
+
+  fi
+
+
+ if test "$PYTHON" != :; then
+  HAVE_PYTHON_TRUE=
+  HAVE_PYTHON_FALSE='#'
+else
+  HAVE_PYTHON_TRUE='#'
+  HAVE_PYTHON_FALSE=
+fi
+
+
+# Extract the first word of "cygpath", so it can be a program name with args.
+set dummy cygpath; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CYGPATH+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CYGPATH"; then
+  ac_cv_prog_CYGPATH="$CYGPATH" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CYGPATH="cygpath"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CYGPATH=$ac_cv_prog_CYGPATH
+if test -n "$CYGPATH"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CYGPATH" >&5
+$as_echo "$CYGPATH" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
 
 # Extract the first word of "perl", so it can be a program name with args.
 set dummy perl; ac_word=$2
@@ -16779,6 +19863,13 @@
 
 
 
+
+if test "$host_os" = "mingw32" -a -n "$CYGPATH"; then
+	OS_SRCDIR=`$CYGPATH -m "$srcdir"`
+else
+	OS_SRCDIR="$srcdir"
+fi
+
  if test -n "$PERL" -a -n "$PDFLATEX" -a -n "$POD2HTML"; then
   GENERATE_DOC_TRUE=
   GENERATE_DOC_FALSE='#'
@@ -17260,15 +20351,16 @@
 fi
 
 case "$with_int" in
-gmp|imath)
+gmp|imath|imath-32)
 	;;
 *)
-	as_fn_error $? "bad value ${withval} for --with-int (use gmp or imath)" "$LINENO" 5
+	as_fn_error $? "bad value ${withval} for --with-int (use gmp, imath or imath-32)" "$LINENO" 5
 esac
 
 
 
 
+
 case "$with_int" in
 gmp)
 
@@ -17366,7 +20458,6 @@
 case "$with_gmp" in
 system)
 	if test "x$with_gmp_prefix" != "x"; then
-		isl_configure_args="$isl_configure_args --with-gmp=$with_gmp_prefix"
 		MP_CPPFLAGS="-I$with_gmp_prefix/include"
 		MP_LDFLAGS="-L$with_gmp_prefix/lib"
 	fi
@@ -17496,7 +20587,7 @@
 
 
 	;;
-imath)
+imath|imath-32)
 
 
 $as_echo "#define USE_IMATH_FOR_MP /**/" >>confdefs.h
@@ -17537,8 +20628,11 @@
 
 	;;
 esac
+if test "x$with_int" = "ximath-32" -a "x$GCC" = "xyes"; then
+	MP_CFLAGS="-std=gnu99 $MP_CFLAGS"
+fi
 
- if test x$with_int = ximath; then
+ if test x$with_int = ximath -o x$with_int = ximath-32; then
   IMATH_FOR_MP_TRUE=
   IMATH_FOR_MP_FALSE='#'
 else
@@ -17554,6 +20648,31 @@
   GMP_FOR_MP_FALSE=
 fi
 
+
+ if test "x$HAVE_CXX11" = "x1"; then
+  HAVE_CXX11_TRUE=
+  HAVE_CXX11_FALSE='#'
+else
+  HAVE_CXX11_TRUE='#'
+  HAVE_CXX11_FALSE=
+fi
+
+ if test "x$with_int" == "ximath-32"; then
+  SMALL_INT_OPT_TRUE=
+  SMALL_INT_OPT_FALSE='#'
+else
+  SMALL_INT_OPT_TRUE='#'
+  SMALL_INT_OPT_FALSE=
+fi
+
+if test "x$with_int" == "ximath-32"; then :
+
+
+$as_echo "#define USE_SMALL_INT_OPT /**/" >>confdefs.h
+
+
+fi
+
 ac_fn_c_check_decl "$LINENO" "ffs" "ac_cv_have_decl_ffs" "#include <strings.h>
 "
 if test "x$ac_cv_have_decl_ffs" = xyes; then :
@@ -17577,9 +20696,104 @@
 #define HAVE_DECL___BUILTIN_FFS $ac_have_decl
 _ACEOF
 
+ac_fn_c_check_decl "$LINENO" "_BitScanForward" "ac_cv_have_decl__BitScanForward" "#include <intrin.h>
+"
+if test "x$ac_cv_have_decl__BitScanForward" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
 
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL__BITSCANFORWARD $ac_have_decl
+_ACEOF
 
+if test "x$ac_cv_have_decl_ffs" = xno -a \
+		"x$ac_cv_have_decl___builtin_ffs" = xno -a \
+		"x$ac_cv_have_decl__BitScanForward" = xno; then
+	as_fn_error $? "No ffs implementation found" "$LINENO" 5
+fi
+ac_fn_c_check_decl "$LINENO" "strcasecmp" "ac_cv_have_decl_strcasecmp" "#include <strings.h>
+"
+if test "x$ac_cv_have_decl_strcasecmp" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
 
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL_STRCASECMP $ac_have_decl
+_ACEOF
+ac_fn_c_check_decl "$LINENO" "strncasecmp" "ac_cv_have_decl_strncasecmp" "#include <strings.h>
+"
+if test "x$ac_cv_have_decl_strncasecmp" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL_STRNCASECMP $ac_have_decl
+_ACEOF
+
+ac_fn_c_check_decl "$LINENO" "_stricmp" "ac_cv_have_decl__stricmp" "#include <string.h>
+"
+if test "x$ac_cv_have_decl__stricmp" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL__STRICMP $ac_have_decl
+_ACEOF
+ac_fn_c_check_decl "$LINENO" "_strnicmp" "ac_cv_have_decl__strnicmp" "#include <string.h>
+"
+if test "x$ac_cv_have_decl__strnicmp" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL__STRNICMP $ac_have_decl
+_ACEOF
+
+if test "x$ac_cv_have_decl_strcasecmp" = xno -a \
+		"x$ac_cv_have_decl__stricmp" = xno; then
+	as_fn_error $? "No strcasecmp implementation found" "$LINENO" 5
+fi
+if test "x$ac_cv_have_decl_strncasecmp" = xno -a \
+		"x$ac_cv_have_decl__strnicmp" = xno; then
+	as_fn_error $? "No strncasecmp implementation found" "$LINENO" 5
+fi
+ac_fn_c_check_decl "$LINENO" "snprintf" "ac_cv_have_decl_snprintf" "#include <stdio.h>
+"
+if test "x$ac_cv_have_decl_snprintf" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL_SNPRINTF $ac_have_decl
+_ACEOF
+ac_fn_c_check_decl "$LINENO" "_snprintf" "ac_cv_have_decl__snprintf" "#include <stdio.h>
+"
+if test "x$ac_cv_have_decl__snprintf" = xyes; then :
+  ac_have_decl=1
+else
+  ac_have_decl=0
+fi
+
+cat >>confdefs.h <<_ACEOF
+#define HAVE_DECL__SNPRINTF $ac_have_decl
+_ACEOF
+
+if test "x$ac_cv_have_decl_snprintf" = xno -a \
+		"x$ac_cv_have_decl__snprintf" = xno; then
+	as_fn_error $? "No snprintf implementation found" "$LINENO" 5
+fi
 
 
 
@@ -17664,501 +20878,6 @@
 $as_echo "$with_clang" >&6; }
 
 
-case "$with_clang" in
-system)
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
-$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
-if ${ac_cv_path_GREP+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -z "$GREP"; then
-  ac_path_GREP_found=false
-  # Loop through the user's path and test for each of PROGNAME-LIST
-  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_prog in grep ggrep; do
-    for ac_exec_ext in '' $ac_executable_extensions; do
-      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
-      as_fn_executable_p "$ac_path_GREP" || continue
-# Check for GNU ac_path_GREP and select it if it is found.
-  # Check for GNU $ac_path_GREP
-case `"$ac_path_GREP" --version 2>&1` in
-*GNU*)
-  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
-*)
-  ac_count=0
-  $as_echo_n 0123456789 >"conftest.in"
-  while :
-  do
-    cat "conftest.in" "conftest.in" >"conftest.tmp"
-    mv "conftest.tmp" "conftest.in"
-    cp "conftest.in" "conftest.nl"
-    $as_echo 'GREP' >> "conftest.nl"
-    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
-    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
-    as_fn_arith $ac_count + 1 && ac_count=$as_val
-    if test $ac_count -gt ${ac_path_GREP_max-0}; then
-      # Best one so far, save it but keep looking for a better one
-      ac_cv_path_GREP="$ac_path_GREP"
-      ac_path_GREP_max=$ac_count
-    fi
-    # 10*(2^10) chars as input seems more than enough
-    test $ac_count -gt 10 && break
-  done
-  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
-esac
-
-      $ac_path_GREP_found && break 3
-    done
-  done
-  done
-IFS=$as_save_IFS
-  if test -z "$ac_cv_path_GREP"; then
-    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
-  fi
-else
-  ac_cv_path_GREP=$GREP
-fi
-
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
-$as_echo "$ac_cv_path_GREP" >&6; }
- GREP="$ac_cv_path_GREP"
-
-
-	llvm_config="llvm-config"
-	# Extract the first word of ""$llvm_config"", so it can be a program name with args.
-set dummy "$llvm_config"; ac_word=$2
-{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
-$as_echo_n "checking for $ac_word... " >&6; }
-if ${ac_cv_prog_llvm_config_found+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  if test -n "$llvm_config_found"; then
-  ac_cv_prog_llvm_config_found="$llvm_config_found" # Let the user override the test.
-else
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
-  IFS=$as_save_IFS
-  test -z "$as_dir" && as_dir=.
-    for ac_exec_ext in '' $ac_executable_extensions; do
-  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
-    ac_cv_prog_llvm_config_found="yes"
-    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
-    break 2
-  fi
-done
-  done
-IFS=$as_save_IFS
-
-fi
-fi
-llvm_config_found=$ac_cv_prog_llvm_config_found
-if test -n "$llvm_config_found"; then
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $llvm_config_found" >&5
-$as_echo "$llvm_config_found" >&6; }
-else
-  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
-$as_echo "no" >&6; }
-fi
-
-
-	if test "x$with_clang_prefix" != "x"; then
-		llvm_config="$with_clang_prefix/bin/llvm-config"
-		if test -x "$llvm_config"; then
-			llvm_config_found=yes
-		fi
-	fi
-	if test "$llvm_config_found" != yes; then
-		as_fn_error $? "llvm-config not found" "$LINENO" 5
-	fi
-	CLANG_CXXFLAGS=`$llvm_config --cxxflags`
-	CLANG_LDFLAGS=`$llvm_config --ldflags`
-	targets=`$llvm_config --targets-built`
-	components="$targets asmparser bitreader support mc"
-	$llvm_config --components | $GREP option > /dev/null 2> /dev/null
-	if test $? -eq 0; then
-		components="$components option"
-	fi
-	CLANG_LIBS=`$llvm_config --libs $components`
-	systemlibs=`$llvm_config --system-libs 2> /dev/null | tail -1`
-	if test $? -eq 0; then
-		CLANG_LIBS="$CLANG_LIBS $systemlibs"
-	fi
-	CLANG_PREFIX=`$llvm_config --prefix`
-
-cat >>confdefs.h <<_ACEOF
-#define CLANG_PREFIX "$CLANG_PREFIX"
-_ACEOF
-
-
-	SAVE_CPPFLAGS="$CPPFLAGS"
-	CPPFLAGS="$CLANG_CXXFLAGS $CPPFLAGS"
-	ac_ext=cpp
-ac_cpp='$CXXCPP $CPPFLAGS'
-ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
-
-
-ac_fn_cxx_check_header_mongrel "$LINENO" "clang/Basic/SourceLocation.h" "ac_cv_header_clang_Basic_SourceLocation_h" "$ac_includes_default"
-if test "x$ac_cv_header_clang_Basic_SourceLocation_h" = xyes; then :
-
-else
-  as_fn_error $? "clang header file not found" "$LINENO" 5
-fi
-
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <llvm/Support/Host.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "getDefaultTargetTriple" >/dev/null 2>&1; then :
-
-else
-
-$as_echo "#define getDefaultTargetTriple getHostTriple" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Basic/SourceLocation.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "getExpansionLineNumber" >/dev/null 2>&1; then :
-
-else
-
-$as_echo "#define getExpansionLineNumber getInstantiationLineNumber" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Basic/Diagnostic.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "DiagnosticsEngine" >/dev/null 2>&1; then :
-
-else
-
-$as_echo "#define DiagnosticsEngine Diagnostic" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Driver/Driver.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "ArrayRef" >/dev/null 2>&1; then :
-
-$as_echo "#define USE_ARRAYREF /**/" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Driver/Driver.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "CXXIsProduction" >/dev/null 2>&1; then :
-
-$as_echo "#define HAVE_CXXISPRODUCTION /**/" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Driver/Driver.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP " IsProduction" >/dev/null 2>&1; then :
-
-$as_echo "#define HAVE_ISPRODUCTION /**/" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Driver/Driver.h>
-int
-main ()
-{
-
-		using namespace clang;
-		DiagnosticsEngine *Diags;
-		new driver::Driver("", "", "", *Diags);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-$as_echo "#define DRIVER_CTOR_TAKES_DEFAULTIMAGENAME /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/AST/ASTConsumer.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "void HandleTopLevelDecl\(" >/dev/null 2>&1; then :
-
-$as_echo "#define HandleTopLevelDeclReturn void" >>confdefs.h
-
-
-$as_echo "#define HandleTopLevelDeclContinue /**/" >>confdefs.h
-
-else
-
-$as_echo "#define HandleTopLevelDeclReturn bool" >>confdefs.h
-
-
-$as_echo "#define HandleTopLevelDeclContinue true" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	ac_fn_cxx_check_header_mongrel "$LINENO" "clang/Basic/DiagnosticOptions.h" "ac_cv_header_clang_Basic_DiagnosticOptions_h" "$ac_includes_default"
-if test "x$ac_cv_header_clang_Basic_DiagnosticOptions_h" = xyes; then :
-
-$as_echo "#define HAVE_BASIC_DIAGNOSTICOPTIONS_H /**/" >>confdefs.h
-
-fi
-
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Basic/TargetInfo.h>
-int
-main ()
-{
-
-		using namespace clang;
-		std::shared_ptr<TargetOptions> TO;
-		DiagnosticsEngine *Diags;
-		TargetInfo::CreateTargetInfo(*Diags, TO);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-$as_echo "#define CREATETARGETINFO_TAKES_SHARED_PTR /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Basic/TargetInfo.h>
-int
-main ()
-{
-
-		using namespace clang;
-		TargetOptions *TO;
-		DiagnosticsEngine *Diags;
-		TargetInfo::CreateTargetInfo(*Diags, TO);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-$as_echo "#define CREATETARGETINFO_TAKES_POINTER /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Frontend/CompilerInstance.h>
-int
-main ()
-{
-
-		using namespace clang;
-		DiagnosticConsumer *client;
-		CompilerInstance *Clang;
-		Clang->createDiagnostics(client);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-else
-
-$as_echo "#define CREATEDIAGNOSTICS_TAKES_ARG /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Lex/HeaderSearchOptions.h>
-int
-main ()
-{
-
-		using namespace clang;
-		HeaderSearchOptions HSO;
-		HSO.AddPath("", frontend::Angled, false, false);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-$as_echo "#define ADDPATH_TAKES_4_ARGUMENTS /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/AST/CanonicalType.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "getNumParams" >/dev/null 2>&1; then :
-
-$as_echo "#define getNumArgs getNumParams" >>confdefs.h
-
-
-$as_echo "#define getArgType getParamType" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/AST/CanonicalType.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "getReturnType" >/dev/null 2>&1; then :
-
-else
-
-$as_echo "#define getReturnType getResultType" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Frontend/CompilerInstance.h>
-int
-main ()
-{
-
-		using namespace clang;
-		CompilerInstance *Clang;
-		Clang->createPreprocessor(TU_Complete);
-
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_cxx_try_compile "$LINENO"; then :
-
-$as_echo "#define CREATEPREPROCESSOR_TAKES_TUKIND /**/" >>confdefs.h
-
-fi
-rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
-	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-#include <clang/Basic/SourceManager.h>
-
-_ACEOF
-if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
-  $EGREP "setMainFileID" >/dev/null 2>&1; then :
-
-$as_echo "#define HAVE_SETMAINFILEID /**/" >>confdefs.h
-
-fi
-rm -f conftest*
-
-	ac_fn_cxx_check_header_mongrel "$LINENO" "llvm/ADT/OwningPtr.h" "ac_cv_header_llvm_ADT_OwningPtr_h" "$ac_includes_default"
-if test "x$ac_cv_header_llvm_ADT_OwningPtr_h" = xyes; then :
-
-$as_echo "#define HAVE_ADT_OWNINGPTR_H /**/" >>confdefs.h
-
-fi
-
-
-	ac_ext=c
-ac_cpp='$CPP $CPPFLAGS'
-ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
-ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
-ac_compiler_gnu=$ac_cv_c_compiler_gnu
-
-	CPPFLAGS="$SAVE_CPPFLAGS"
-
-	SAVE_LDFLAGS="$LDFLAGS"
-	LDFLAGS="$CLANG_LDFLAGS $LDFLAGS"
-
-	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lclangEdit" >&5
-$as_echo_n "checking for main in -lclangEdit... " >&6; }
-if ${ac_cv_lib_clangEdit_main+:} false; then :
-  $as_echo_n "(cached) " >&6
-else
-  ac_check_lib_save_LIBS=$LIBS
-LIBS="-lclangEdit  $LIBS"
-cat confdefs.h - <<_ACEOF >conftest.$ac_ext
-/* end confdefs.h.  */
-
-
-int
-main ()
-{
-return main ();
-  ;
-  return 0;
-}
-_ACEOF
-if ac_fn_c_try_link "$LINENO"; then :
-  ac_cv_lib_clangEdit_main=yes
-else
-  ac_cv_lib_clangEdit_main=no
-fi
-rm -f core conftest.err conftest.$ac_objext \
-    conftest$ac_exeext conftest.$ac_ext
-LIBS=$ac_check_lib_save_LIBS
-fi
-{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_clangEdit_main" >&5
-$as_echo "$ac_cv_lib_clangEdit_main" >&6; }
-if test "x$ac_cv_lib_clangEdit_main" = xyes; then :
-  LIB_CLANG_EDIT=-lclangEdit
-fi
-
-	LDFLAGS="$SAVE_LDFLAGS"
-	;;
-esac
  if test $with_clang = system; then
   HAVE_CLANG_TRUE=
   HAVE_CLANG_FALSE='#'
@@ -18167,6 +20886,15 @@
   HAVE_CLANG_FALSE=
 fi
 
+ if (test $with_clang = system -a "x$HAVE_CXX11" = "x1") || \
+     test -f $srcdir/include/isl/cpp.h; then
+  HAVE_CPP_ISL_H_TRUE=
+  HAVE_CPP_ISL_H_FALSE='#'
+else
+  HAVE_CPP_ISL_H_TRUE='#'
+  HAVE_CPP_ISL_H_FALSE=
+fi
+
 
 
 { $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler vendor" >&5
@@ -18433,17 +21161,20 @@
 	    GIT_HEAD_VERSION="\`GIT_DIR=$GIT_REPO git describe --always\`"
 	fi
 
-echo '#define GIT_HEAD_ID "'$GIT_HEAD_ID'"' > gitversion.h
 
 
 ac_config_headers="$ac_config_headers isl_config.h"
 
+ac_config_files="$ac_config_files isl_srcdir.c"
+
 ac_config_files="$ac_config_files Makefile"
 
 ac_config_files="$ac_config_files doc/Makefile"
 
 if test $with_clang = system; then
-	ac_config_files="$ac_config_files interface/Makefile"
+
+
+subdirs="$subdirs interface"
 
 fi
 ac_config_files="$ac_config_files bound_test.sh"
@@ -18452,6 +21183,9 @@
 
 ac_config_files="$ac_config_files pip_test.sh"
 
+ac_config_files="$ac_config_files flow_test.sh"
+
+ac_config_files="$ac_config_files schedule_test.sh"
 
 cat >confcache <<\_ACEOF
 # This file is a shell script that caches the results of configure
@@ -18590,6 +21324,14 @@
   as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${HAVE_PYTHON_TRUE}" && test -z "${HAVE_PYTHON_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_PYTHON\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
 if test -z "${GENERATE_DOC_TRUE}" && test -z "${GENERATE_DOC_FALSE}"; then
   as_fn_error $? "conditional \"GENERATE_DOC\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
@@ -18610,10 +21352,22 @@
   as_fn_error $? "conditional \"GMP_FOR_MP\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
+if test -z "${HAVE_CXX11_TRUE}" && test -z "${HAVE_CXX11_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_CXX11\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${SMALL_INT_OPT_TRUE}" && test -z "${SMALL_INT_OPT_FALSE}"; then
+  as_fn_error $? "conditional \"SMALL_INT_OPT\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
 if test -z "${HAVE_CLANG_TRUE}" && test -z "${HAVE_CLANG_FALSE}"; then
   as_fn_error $? "conditional \"HAVE_CLANG\" was never defined.
 Usually this means the macro was only invoked conditionally." "$LINENO" 5
 fi
+if test -z "${HAVE_CPP_ISL_H_TRUE}" && test -z "${HAVE_CPP_ISL_H_FALSE}"; then
+  as_fn_error $? "conditional \"HAVE_CPP_ISL_H\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
 
 : "${CONFIG_STATUS=./config.status}"
 ac_write_fail=0
@@ -19011,7 +21765,7 @@
 # report actual input values of CONFIG_FILES etc. instead of their
 # values after options handling.
 ac_log="
-This file was extended by isl $as_me 0.14, which was
+This file was extended by isl $as_me 0.24, which was
 generated by GNU Autoconf 2.69.  Invocation command line was
 
   CONFIG_FILES    = $CONFIG_FILES
@@ -19077,7 +21831,7 @@
 cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
 ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/\\""\`\$/\\\\&/g'`"
 ac_cs_version="\\
-isl config.status 0.14
+isl config.status 0.24
 configured by $0, generated by GNU Autoconf 2.69,
   with options \\"\$ac_cs_config\\"
 
@@ -19196,7 +21950,7 @@
 #
 # INIT-COMMANDS
 #
-AMDEP_TRUE="$AMDEP_TRUE" ac_aux_dir="$ac_aux_dir"
+AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
 
 
 # The HP-UX ksh and POSIX shell print the target directory to stdout
@@ -19212,6 +21966,7 @@
 enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
 pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
 enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
 SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
 ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
 PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
@@ -19267,6 +22022,7 @@
 lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
 nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
 lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
 objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
 MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
 lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
@@ -19331,7 +22087,8 @@
 finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
 hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
 sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
-sys_lib_dlsearch_path_spec='`$ECHO "$sys_lib_dlsearch_path_spec" | $SED "$delay_single_quote_subst"`'
+configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
+configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
 hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
 enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
 enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
@@ -19441,6 +22198,7 @@
 lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
 lt_cv_nm_interface \
 nm_file_list_spec \
+lt_cv_truncate_bin \
 lt_prog_compiler_no_builtin_flag \
 lt_prog_compiler_pic \
 lt_prog_compiler_wl \
@@ -19533,7 +22291,8 @@
 postuninstall_cmds \
 finish_cmds \
 sys_lib_search_path_spec \
-sys_lib_dlsearch_path_spec \
+configure_time_dlsearch_path \
+configure_time_lt_sys_library_path \
 reload_cmds_CXX \
 old_archive_cmds_CXX \
 old_archive_from_new_cmds_CXX \
@@ -19627,12 +22386,14 @@
     "$ac_stdint_h") CONFIG_COMMANDS="$CONFIG_COMMANDS $ac_stdint_h" ;;
     "$ax_create_pkgconfig_generate") CONFIG_COMMANDS="$CONFIG_COMMANDS $ax_create_pkgconfig_generate" ;;
     "isl_config.h") CONFIG_HEADERS="$CONFIG_HEADERS isl_config.h" ;;
+    "isl_srcdir.c") CONFIG_FILES="$CONFIG_FILES isl_srcdir.c" ;;
     "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
     "doc/Makefile") CONFIG_FILES="$CONFIG_FILES doc/Makefile" ;;
-    "interface/Makefile") CONFIG_FILES="$CONFIG_FILES interface/Makefile" ;;
     "bound_test.sh") CONFIG_FILES="$CONFIG_FILES bound_test.sh" ;;
     "codegen_test.sh") CONFIG_FILES="$CONFIG_FILES codegen_test.sh" ;;
     "pip_test.sh") CONFIG_FILES="$CONFIG_FILES pip_test.sh" ;;
+    "flow_test.sh") CONFIG_FILES="$CONFIG_FILES flow_test.sh" ;;
+    "schedule_test.sh") CONFIG_FILES="$CONFIG_FILES schedule_test.sh" ;;
 
   *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
   esac
@@ -20232,29 +22993,35 @@
   # Older Autoconf quotes --file arguments for eval, but not when files
   # are listed without --file.  Let's play safe and only enable the eval
   # if we detect the quoting.
-  case $CONFIG_FILES in
-  *\'*) eval set x "$CONFIG_FILES" ;;
-  *)   set x $CONFIG_FILES ;;
-  esac
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  case $CONFIG_FILES in #(
+  *\'*) :
+    eval set x "$CONFIG_FILES" ;; #(
+  *) :
+    set x $CONFIG_FILES ;; #(
+  *) :
+     ;;
+esac
   shift
-  for mf
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
   do
     # Strip MF so we end up with the name of the file.
-    mf=`echo "$mf" | sed -e 's/:.*$//'`
-    # Check whether this is an Automake generated Makefile or not.
-    # We used to match only the files named 'Makefile.in', but
-    # some people rename them; so instead we look at the file content.
-    # Grep'ing the first line is not enough: some people post-process
-    # each Makefile.in and add a new line on top of each file to say so.
-    # Grep'ing the whole file is not good either: AIX grep has a line
+    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
     # limit of 2048, but all sed's we know have understand at least 4000.
-    if sed -n 's,^#.*generated by automake.*,X,p' "$mf" | grep X >/dev/null 2>&1; then
-      dirpart=`$as_dirname -- "$mf" ||
-$as_expr X"$mf" : 'X$.*^/$//*^/^/*/*$' \| \
-	 X"$mf" : 'X$//$^/' \| \
-	 X"$mf" : 'X$//$$' \| \
-	 X"$mf" : 'X$/$' \| . 2>/dev/null ||
-$as_echo X"$mf" |
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`$as_dirname -- "$am_mf" ||
+$as_expr X"$am_mf" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$am_mf" : 'X$//$^/' \| \
+	 X"$am_mf" : 'X$//$$' \| \
+	 X"$am_mf" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$am_mf" |
     sed '/^X$.*^/$\/\/*^/^/*\/*$/{
 	    s//\1/
 	    q
@@ -20272,53 +23039,48 @@
 	    q
 	  }
 	  s/.*/./; q'`
-    else
-      continue
-    fi
-    # Extract the definition of DEPDIR, am__include, and am__quote
-    # from the Makefile without running 'make'.
-    DEPDIR=`sed -n 's/^DEPDIR = //p' < "$mf"`
-    test -z "$DEPDIR" && continue
-    am__include=`sed -n 's/^am__include = //p' < "$mf"`
-    test -z "$am__include" && continue
-    am__quote=`sed -n 's/^am__quote = //p' < "$mf"`
-    # Find all dependency output files, they are included files with
-    # $(DEPDIR) in their names.  We invoke sed twice because it is the
-    # simplest approach to changing $(DEPDIR) to its actual value in the
-    # expansion.
-    for file in `sed -n "
-      s/^$am__include $am__quote$.*(DEPDIR).*$$am__quote"'$/\1/p' <"$mf" | \
-	 sed -e 's/\$(DEPDIR)/'"$DEPDIR"'/g'`; do
-      # Make sure the directory exists.
-      test -f "$dirpart/$file" && continue
-      fdir=`$as_dirname -- "$file" ||
-$as_expr X"$file" : 'X$.*^/$//*^/^/*/*$' \| \
-	 X"$file" : 'X$//$^/' \| \
-	 X"$file" : 'X$//$$' \| \
-	 X"$file" : 'X$/$' \| . 2>/dev/null ||
-$as_echo X"$file" |
-    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
-	    s//\1/
-	    q
-	  }
-	  /^X$\/\/$^/.*/{
+    am_filepart=`$as_basename -- "$am_mf" ||
+$as_expr X/"$am_mf" : '.*/$^/^/*$/*$' \| \
+	 X"$am_mf" : 'X$//$$' \| \
+	 X"$am_mf" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X/"$am_mf" |
+    sed '/^.*\/$^/^/*$\/*$/{
 	    s//\1/
 	    q
 	  }
-	  /^X$\/\/$$/{
+	  /^X\/$\/\/$$/{
 	    s//\1/
 	    q
 	  }
-	  /^X$\/$.*/{
+	  /^X\/$\/$.*/{
 	    s//\1/
 	    q
 	  }
 	  s/.*/./; q'`
-      as_dir=$dirpart/$fdir; as_fn_mkdir_p
-      # echo "creating $dirpart/$file"
-      echo '# dummy' > "$dirpart/$file"
-    done
+    { echo "$as_me:$LINENO: cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles" >&5
+   (cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } || am_rc=$?
   done
+  if test $am_rc -ne 0; then
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+  { am_dirpart=; unset am_dirpart;}
+  { am_filepart=; unset am_filepart;}
+  { am_mf=; unset am_mf;}
+  { am_rc=; unset am_rc;}
+  rm -f conftest-deps.mk
 }
  ;;
     "libtool":C)
@@ -20335,44 +23097,41 @@
 
     cat <<_LT_EOF >> "$cfgfile"
 #! $SHELL
-
-# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
 # Generated automatically by $as_me ($PACKAGE) $VERSION
-# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
 #
-#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
-#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-#                 Foundation, Inc.
-#   Written by Gordon Matzigkeit, 1996
-#
-#   This file is part of GNU Libtool.
-#
-# GNU Libtool is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of
-# the License, or (at your option) any later version.
-#
-# As a special exception to the GNU General Public License,
-# if you distribute this file as part of a program or library that
-# is built using GNU Libtool, you may include this file under the
-# same distribution terms that you use for the rest of that program.
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
 #
-# GNU Libtool is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Libtool; see the file COPYING.  If not, a copy
-# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
-# obtained by writing to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 
 # The names of the tagged configurations supported by this script.
 available_tags='CXX '
 
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
 # ### BEGIN LIBTOOL CONFIG
 
 # Which release of libtool.m4 was used?
@@ -20391,6 +23150,9 @@
 # Whether or not to optimize for fast installation.
 fast_install=$enable_fast_install
 
+# Shared archive member basename,for filename based shared library versioning on AIX.
+shared_archive_member_spec=$shared_archive_member_spec
+
 # Shell to use when invoking shell scripts.
 SHELL=$lt_SHELL
 
@@ -20526,6 +23288,9 @@
 # The root where to search for dependent libraries,and where our libraries should be installed.
 lt_sysroot=$lt_sysroot
 
+# Command to truncate a binary pipe.
+lt_truncate_bin=$lt_lt_cv_truncate_bin
+
 # The name of the directory that contains temporary libtool files.
 objdir=$objdir
 
@@ -20616,8 +23381,11 @@
 # Compile-time system search path for libraries.
 sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
 
-# Run-time system search path for libraries.
-sys_lib_dlsearch_path_spec=$lt_sys_lib_dlsearch_path_spec
+# Detected run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
+
+# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
+configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
 
 # Whether dlopen is supported.
 dlopen_support=$enable_dlopen
@@ -20782,6 +23550,65 @@
 
 _LT_EOF
 
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR:DIR:"
+#       string "DIR DIR" will be prepended to VARIABLE
+# ":DIR:DIR"
+#       string "DIR DIR" will be appended to VARIABLE
+# "DIRP:DIRP::DIRA:DIRA"
+#       string "DIRP DIRP" will be prepended to VARIABLE and string
+#       "DIRA DIRA" will be appended to VARIABLE
+# "DIR:DIR"
+#       VARIABLE will be replaced by "DIR DIR"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *\\/compile | ccache | *\\/ccache ) ;;
+        distcc | *\\/distcc | purify | *\\/purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
   case $host_os in
   aix3*)
     cat <<\_LT_EOF >> "$cfgfile"
@@ -21569,6 +24396,8 @@
     "bound_test.sh":F) chmod +x bound_test.sh ;;
     "codegen_test.sh":F) chmod +x codegen_test.sh ;;
     "pip_test.sh":F) chmod +x pip_test.sh ;;
+    "flow_test.sh":F) chmod +x flow_test.sh ;;
+    "schedule_test.sh":F) chmod +x schedule_test.sh ;;
 
   esac
 done # for ac_tag
@@ -21582,9 +24411,6 @@
   as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
 
 
-			ac_configure_args="$ac_configure_args $isl_configure_args"
-
-
 # configure is writing to config.log, and then calls config.status.
 # config.status does its own redirection, appending to config.log.
 # Unfortunately, on DOS this fails, as config.log is still kept open
@@ -21605,6 +24431,151 @@
   # would make configure fail if this is the last instruction.
   $ac_cs_success || as_fn_exit 1
 fi
+
+#
+# CONFIG_SUBDIRS section.
+#
+if test "$no_recursion" != yes; then
+
+  # Remove --cache-file, --srcdir, and --disable-option-checking arguments
+  # so they do not pile up.
+  ac_sub_configure_args=
+  ac_prev=
+  eval "set x $ac_configure_args"
+  shift
+  for ac_arg
+  do
+    if test -n "$ac_prev"; then
+      ac_prev=
+      continue
+    fi
+    case $ac_arg in
+    -cache-file | --cache-file | --cache-fil | --cache-fi \
+    | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+      ac_prev=cache_file ;;
+    -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+    | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* \
+    | --c=*)
+      ;;
+    --config-cache | -C)
+      ;;
+    -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+      ac_prev=srcdir ;;
+    -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+      ;;
+    -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+      ac_prev=prefix ;;
+    -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+      ;;
+    --disable-option-checking)
+      ;;
+    *)
+      case $ac_arg in
+      *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+      esac
+      as_fn_append ac_sub_configure_args " '$ac_arg'" ;;
+    esac
+  done
+
+  # Always prepend --prefix to ensure using the same prefix
+  # in subdir configurations.
+  ac_arg="--prefix=$prefix"
+  case $ac_arg in
+  *\'*) ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+  esac
+  ac_sub_configure_args="'$ac_arg' $ac_sub_configure_args"
+
+  # Pass --silent
+  if test "$silent" = yes; then
+    ac_sub_configure_args="--silent $ac_sub_configure_args"
+  fi
+
+  # Always prepend --disable-option-checking to silence warnings, since
+  # different subdirs can have different --enable and --with options.
+  ac_sub_configure_args="--disable-option-checking $ac_sub_configure_args"
+
+  ac_popdir=`pwd`
+  for ac_dir in : $subdirs; do test "x$ac_dir" = x: && continue
+
+    # Do not complain, so a configure script can configure whichever
+    # parts of a large source tree are present.
+    test -d "$srcdir/$ac_dir" || continue
+
+    ac_msg="=== configuring in $ac_dir (`pwd`/$ac_dir)"
+    $as_echo "$as_me:${as_lineno-$LINENO}: $ac_msg" >&5
+    $as_echo "$ac_msg" >&6
+    as_dir="$ac_dir"; as_fn_mkdir_p
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.\\/||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/^\\/*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  \\/* | ?:\\/* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+    cd "$ac_dir"
+
+    # Check for guested configure; otherwise get Cygnus style configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      ac_sub_configure=$ac_srcdir/configure.gnu
+    elif test -f "$ac_srcdir/configure"; then
+      ac_sub_configure=$ac_srcdir/configure
+    elif test -f "$ac_srcdir/configure.in"; then
+      # This should be Cygnus configure.
+      ac_sub_configure=$ac_aux_dir/configure
+    else
+      { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: no configuration information is in $ac_dir" >&5
+$as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2;}
+      ac_sub_configure=
+    fi
+
+    # The recursion is here.
+    if test -n "$ac_sub_configure"; then
+      # Make the cache file name correct relative to the subdirectory.
+      case $cache_file in
+      \\/* | ?:\\/* ) ac_sub_cache_file=$cache_file ;;
+      *) # Relative name.
+	ac_sub_cache_file=$ac_top_build_prefix$cache_file ;;
+      esac
+
+      { $as_echo "$as_me:${as_lineno-$LINENO}: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&5
+$as_echo "$as_me: running $SHELL $ac_sub_configure $ac_sub_configure_args --cache-file=$ac_sub_cache_file --srcdir=$ac_srcdir" >&6;}
+      # The eval makes quoting arguments work.
+      eval "\$SHELL \"\$ac_sub_configure\" $ac_sub_configure_args \
+	   --cache-file=\"\$ac_sub_cache_file\" --srcdir=\"\$ac_srcdir\"" ||
+	as_fn_error $? "$ac_sub_configure failed for $ac_dir" "$LINENO" 5
+    fi
+
+    cd "$ac_popdir"
+  done
+fi
 if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
   { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
 $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}

_service:tar_scm:isl-0.14.tar.xz/configure.ac -> _service:tar_scm:isl-0.24.tar.gz/configure.ac Changed

@@ -1,10 +1,10 @@
-AC_INIT(isl, 0.14, isl-development@googlegroups.com)
+AC_INIT(isl, 0.24, isl-development@googlegroups.com)
 AC_CONFIG_AUX_DIR(.)
 AC_CONFIG_MACRO_DIR(m4)
 AM_INIT_AUTOMAKE(foreign)
 m4_ifdef(AM_SILENT_RULES,AM_SILENT_RULES(yes))
 AC_SUBST(versioninfo)
-versioninfo=14:0:1
+versioninfo=24:0:1
 
 if test "x$prefix" != "xNONE"; then
 	prefix_wd=`cd $prefix && pwd`
@@ -20,191 +20,103 @@
 
 AC_PROG_CC
 AC_PROG_CXX
+AX_PROG_CC_FOR_BUILD
 
 AX_CC_MAXOPT
 AX_GCC_WARN_UNUSED_RESULT
 AX_C___ATTRIBUTE__
 
+AX_CXX_COMPILE_STDCXX_11_NO_OVERRIDE
+
+AC_PROG_GREP
 AC_PROG_LIBTOOL
+AC_PROG_SED
+AM_PATH_PYTHON(2.5, , :)
+AM_CONDITIONAL(HAVE_PYTHON, test "$PYTHON" != :)
 
+AC_CHECK_PROG(CYGPATH, cygpath, cygpath, )
 AC_CHECK_PROG(PERL, perl, perl, )
 AC_CHECK_PROG(PDFLATEX, pdflatex, pdflatex, )
 AC_CHECK_PROG(POD2HTML, pod2html, pod2html, )
 
+AC_SUBST(OS_SRCDIR)
+if test "$host_os" = "mingw32" -a -n "$CYGPATH"; then
+	OS_SRCDIR=`$CYGPATH -m "$srcdir"`
+else
+	OS_SRCDIR="$srcdir"
+fi
+
 AM_CONDITIONAL(GENERATE_DOC, test -n "$PERL" -a -n "$PDFLATEX" -a -n "$POD2HTML")
 
 AX_CREATE_STDINT_H(include/isl/stdint.h)
 
 AC_ARG_WITH(int,
-	    AS_HELP_STRING(--with-int=gmp|imath,
+	    AS_HELP_STRING(--with-int=gmp|imath|imath-32,
 			    Which package to use to represent
 				multi-precision integers default=gmp),
 	    , with_int=gmp)
 case "$with_int" in
-gmp|imath)
+gmp|imath|imath-32)
 	;;
 *)
-	AC_MSG_ERROR(bad value ${withval} for --with-int (use gmp or imath))
+	AC_MSG_ERROR(
+	    bad value ${withval} for --with-int (use gmp, imath or imath-32))
 esac
 
 AC_SUBST(MP_CPPFLAGS)
+AC_SUBST(MP_CFLAGS)
 AC_SUBST(MP_LDFLAGS)
 AC_SUBST(MP_LIBS)
 case "$with_int" in
 gmp)
 	AX_DETECT_GMP
 	;;
-imath)
+imath|imath-32)
 	AX_DETECT_IMATH
 	;;
 esac
+if test "x$with_int" = "ximath-32" -a "x$GCC" = "xyes"; then
+	MP_CFLAGS="-std=gnu99 $MP_CFLAGS"
+fi
 
-AM_CONDITIONAL(IMATH_FOR_MP, test x$with_int = ximath)
+AM_CONDITIONAL(IMATH_FOR_MP, test x$with_int = ximath -o x$with_int = ximath-32)
 AM_CONDITIONAL(GMP_FOR_MP, test x$with_int = xgmp)
+
+AM_CONDITIONAL(HAVE_CXX11, test "x$HAVE_CXX11" = "x1")
+AM_CONDITIONAL(SMALL_INT_OPT, test "x$with_int" == "ximath-32")
+AS_IF(test "x$with_int" == "ximath-32", 
+	AC_DEFINE(USE_SMALL_INT_OPT, , Use small integer optimization)
+)
+
 AC_CHECK_DECLS(ffs,,,#include <strings.h>)
 AC_CHECK_DECLS(__builtin_ffs,,,)
+AC_CHECK_DECLS(_BitScanForward,,,#include <intrin.h>)
+if test "x$ac_cv_have_decl_ffs" = xno -a \
+		"x$ac_cv_have_decl___builtin_ffs" = xno -a \
+		"x$ac_cv_have_decl__BitScanForward" = xno; then
+	AC_MSG_ERROR(No ffs implementation found)
+fi
+AC_CHECK_DECLS(strcasecmp,strncasecmp,,,#include <strings.h>)
+AC_CHECK_DECLS(_stricmp,_strnicmp,,,#include <string.h>)
+if test "x$ac_cv_have_decl_strcasecmp" = xno -a \
+		"x$ac_cv_have_decl__stricmp" = xno; then
+	AC_MSG_ERROR(No strcasecmp implementation found)
+fi
+if test "x$ac_cv_have_decl_strncasecmp" = xno -a \
+		"x$ac_cv_have_decl__strnicmp" = xno; then
+	AC_MSG_ERROR(No strncasecmp implementation found)
+fi
+AC_CHECK_DECLS(snprintf,_snprintf,,,#include <stdio.h>)
+if test "x$ac_cv_have_decl_snprintf" = xno -a \
+		"x$ac_cv_have_decl__snprintf" = xno; then
+	AC_MSG_ERROR(No snprintf implementation found)
+fi
 
-AC_SUBST(CLANG_CXXFLAGS)
-AC_SUBST(CLANG_LDFLAGS)
-AC_SUBST(CLANG_LIBS)
 AX_SUBMODULE(clang,system|no,no)
-case "$with_clang" in
-system)
-	AC_PROG_GREP
-	llvm_config="llvm-config"
-	AC_CHECK_PROG(llvm_config_found, "$llvm_config", yes)
-	if test "x$with_clang_prefix" != "x"; then
-		llvm_config="$with_clang_prefix/bin/llvm-config"
-		if test -x "$llvm_config"; then
-			llvm_config_found=yes
-		fi
-	fi
-	if test "$llvm_config_found" != yes; then
-		AC_MSG_ERROR(llvm-config not found)
-	fi
-	CLANG_CXXFLAGS=`$llvm_config --cxxflags`
-	CLANG_LDFLAGS=`$llvm_config --ldflags`
-	targets=`$llvm_config --targets-built`
-	components="$targets asmparser bitreader support mc"
-	$llvm_config --components | $GREP option > /dev/null 2> /dev/null
-	if test $? -eq 0; then
-		components="$components option"
-	fi
-	CLANG_LIBS=`$llvm_config --libs $components`
-	systemlibs=`$llvm_config --system-libs 2> /dev/null | tail -1`
-	if test $? -eq 0; then
-		CLANG_LIBS="$CLANG_LIBS $systemlibs"
-	fi
-	CLANG_PREFIX=`$llvm_config --prefix`
-	AC_DEFINE_UNQUOTED(CLANG_PREFIX, "$CLANG_PREFIX",
-				Clang installation prefix)
-
-	SAVE_CPPFLAGS="$CPPFLAGS"
-	CPPFLAGS="$CLANG_CXXFLAGS $CPPFLAGS"
-	AC_LANG_PUSH(C++)
-	AC_CHECK_HEADER(clang/Basic/SourceLocation.h, ,
-		AC_ERROR(clang header file not found))
-	AC_EGREP_HEADER(getDefaultTargetTriple, llvm/Support/Host.h, ,
-		AC_DEFINE(getDefaultTargetTriple, getHostTriple,
-		Define to getHostTriple for older versions of clang))
-	AC_EGREP_HEADER(getExpansionLineNumber,
-		clang/Basic/SourceLocation.h, ,
-		AC_DEFINE(getExpansionLineNumber,
-			getInstantiationLineNumber,
-	    Define to getInstantiationLineNumber for older versions of clang))
-	AC_EGREP_HEADER(DiagnosticsEngine,
-		clang/Basic/Diagnostic.h, ,
-		AC_DEFINE(DiagnosticsEngine,
-			Diagnostic,
-	    Define to Diagnostic for older versions of clang))
-	AC_EGREP_HEADER(ArrayRef, clang/Driver/Driver.h,
-		AC_DEFINE(USE_ARRAYREF, ,
-			Define if Driver::BuildCompilation takes ArrayRef))
-	AC_EGREP_HEADER(CXXIsProduction, clang/Driver/Driver.h,
-		AC_DEFINE(HAVE_CXXISPRODUCTION, ,
-		Define if Driver constructor takes CXXIsProduction argument))
-	AC_EGREP_HEADER( IsProduction, clang/Driver/Driver.h,
-		AC_DEFINE(HAVE_ISPRODUCTION, ,
-		Define if Driver constructor takes IsProduction argument))
-	AC_TRY_COMPILE(#include <clang/Driver/Driver.h>, 
-		using namespace clang;
-		DiagnosticsEngine *Diags;
-		new driver::Driver("", "", "", *Diags);
-	, AC_DEFINE(DRIVER_CTOR_TAKES_DEFAULTIMAGENAME, ,
-		      Define if Driver constructor takes default image name))
-	AC_EGREP_HEADER(void HandleTopLevelDecl\(, clang/AST/ASTConsumer.h,
-		AC_DEFINE(HandleTopLevelDeclReturn, void,
-			   Return type of HandleTopLevelDeclReturn)
-		 AC_DEFINE(HandleTopLevelDeclContinue, ,
-			   Return type of HandleTopLevelDeclReturn),
-		AC_DEFINE(HandleTopLevelDeclReturn, bool,
-			   Return type of HandleTopLevelDeclReturn)
-		 AC_DEFINE(HandleTopLevelDeclContinue, true,
-			   Return type of HandleTopLevelDeclReturn))
-	AC_CHECK_HEADER(clang/Basic/DiagnosticOptions.h,
-		AC_DEFINE(HAVE_BASIC_DIAGNOSTICOPTIONS_H, ,
-			   Define if clang/Basic/DiagnosticOptions.h exists))
-	AC_TRY_COMPILE(#include <clang/Basic/TargetInfo.h>, 
-		using namespace clang;
-		std::shared_ptr<TargetOptions> TO;
-		DiagnosticsEngine *Diags;
-		TargetInfo::CreateTargetInfo(*Diags, TO);
-	, AC_DEFINE(CREATETARGETINFO_TAKES_SHARED_PTR, ,
-		    Define if TargetInfo::CreateTargetInfo takes shared_ptr))
-	AC_TRY_COMPILE(#include <clang/Basic/TargetInfo.h>, 
-		using namespace clang;
-		TargetOptions *TO;
-		DiagnosticsEngine *Diags;
-		TargetInfo::CreateTargetInfo(*Diags, TO);
-	, AC_DEFINE(CREATETARGETINFO_TAKES_POINTER, ,
-		      Define if TargetInfo::CreateTargetInfo takes pointer))
-	AC_TRY_COMPILE(#include <clang/Frontend/CompilerInstance.h>, 
-		using namespace clang;
-		DiagnosticConsumer *client;
-		CompilerInstance *Clang;
-		Clang->createDiagnostics(client);
-	, , AC_DEFINE(CREATEDIAGNOSTICS_TAKES_ARG, ,
-	Define if CompilerInstance::createDiagnostics takes argc and argv))
-	AC_TRY_COMPILE(#include <clang/Lex/HeaderSearchOptions.h>, 
-		using namespace clang;
-		HeaderSearchOptions HSO;
-		HSO.AddPath("", frontend::Angled, false, false);
-	, AC_DEFINE(ADDPATH_TAKES_4_ARGUMENTS, ,
-		Define if HeaderSearchOptions::AddPath takes 4 arguments))
-	AC_EGREP_HEADER(getNumParams,
-		clang/AST/CanonicalType.h,
-		AC_DEFINE(getNumArgs, getNumParams,
-		    Define to getNumParams for newer versions of clang)
-		 AC_DEFINE(getArgType, getParamType,
-		    Define to getParamType for newer versions of clang))
-	AC_EGREP_HEADER(getReturnType,
-		clang/AST/CanonicalType.h, ,
-		AC_DEFINE(getReturnType, getResultType,
-		    Define to getResultType for older versions of clang))
-	AC_TRY_COMPILE(#include <clang/Frontend/CompilerInstance.h>, 
-		using namespace clang;
-		CompilerInstance *Clang;
-		Clang->createPreprocessor(TU_Complete);
-	, AC_DEFINE(CREATEPREPROCESSOR_TAKES_TUKIND, ,
-	Define if CompilerInstance::createPreprocessor takes
-	 TranslationUnitKind))
-	AC_EGREP_HEADER(setMainFileID, clang/Basic/SourceManager.h,
-		AC_DEFINE(HAVE_SETMAINFILEID, ,
-		Define if SourceManager has a setMainFileID method))
-	AC_CHECK_HEADER(llvm/ADT/OwningPtr.h,
-		AC_DEFINE(HAVE_ADT_OWNINGPTR_H, ,
-			   Define if llvm/ADT/OwningPtr.h exists))
-	AC_LANG_POP
-	CPPFLAGS="$SAVE_CPPFLAGS"
-
-	SAVE_LDFLAGS="$LDFLAGS"
-	LDFLAGS="$CLANG_LDFLAGS $LDFLAGS"
-	AC_SUBST(LIB_CLANG_EDIT)
-	AC_CHECK_LIB(clangEdit, main, LIB_CLANG_EDIT=-lclangEdit, )
-	LDFLAGS="$SAVE_LDFLAGS"
-	;;
-esac
 AM_CONDITIONAL(HAVE_CLANG, test $with_clang = system)
+AM_CONDITIONAL(HAVE_CPP_ISL_H,
+    (test $with_clang = system -a "x$HAVE_CXX11" = "x1") || \
+     test -f $srcdir/include/isl/cpp.h)
 
 AX_SET_WARNING_FLAGS
 
@@ -216,21 +128,18 @@
 AX_CREATE_PKGCONFIG_INFO
 
 AX_DETECT_GIT_HEAD
-echo '#define GIT_HEAD_ID "'$GIT_HEAD_ID'"' > gitversion.h
 
 AH_BOTTOM(#include <isl_config_post.h>)
 AC_CONFIG_HEADERS(isl_config.h)
+AC_CONFIG_FILES(isl_srcdir.c)
 AC_CONFIG_FILES(Makefile)
 AC_CONFIG_FILES(doc/Makefile)
 if test $with_clang = system; then
-	AC_CONFIG_FILES(interface/Makefile)
+	AC_CONFIG_SUBDIRS(interface)
 fi
 AC_CONFIG_FILES(bound_test.sh, chmod +x bound_test.sh)
 AC_CONFIG_FILES(codegen_test.sh, chmod +x codegen_test.sh)
 AC_CONFIG_FILES(pip_test.sh, chmod +x pip_test.sh)
-AC_CONFIG_COMMANDS_POST(
-	dnl pass on arguments to subdir configures, but don't
-	dnl add them to config.status
-	ac_configure_args="$ac_configure_args $isl_configure_args"
-)
+AC_CONFIG_FILES(flow_test.sh, chmod +x flow_test.sh)
+AC_CONFIG_FILES(schedule_test.sh, chmod +x schedule_test.sh)
 AC_OUTPUT

_service:tar_scm:isl-0.24.tar.gz/cpp Added

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp-checked-conversion.h.bot Added

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp-checked-conversion.h.top Added

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp-checked.h.bot Added

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp-checked.h.top Added

@@ -0,0 +1,190 @@
+/// 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.
+
+#ifndef ISL_CPP_CHECKED
+#define ISL_CPP_CHECKED
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace isl {
+namespace checked {
+
+#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 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) {}
+
+  /* implicit */ boolean(bool val)
+      : val(val ? isl_bool_true : isl_bool_false) {}
+
+  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; }
+
+  explicit operator bool() const {
+    ISLPP_ASSERT(check->checked, "IMPLEMENTATION ERROR: Unchecked error state");
+    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
+    return is_true();
+  }
+
+  boolean negate() {
+    if (val == isl_bool_true)
+      val = isl_bool_false;
+    else if (val == isl_bool_false)
+      val = isl_bool_true;
+    return *this;
+  }
+
+  boolean operator!() const {
+    return boolean(*this).negate();
+  }
+};
+
+inline boolean manage(isl_bool val) {
+  return boolean(val);
+}
+
+class ctx {
+  isl_ctx *ptr;
+public:
+  /* implicit */ ctx(isl_ctx *ctx)
+      : ptr(ctx) {}
+  isl_ctx *release() {
+    auto tmp = ptr;
+    ptr = nullptr;
+    return tmp;
+  }
+  isl_ctx *get() {
+    return ptr;
+  }
+};
+
+/* Class encapsulating an isl_stat value.
+ */
+class stat {
+private:
+	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:
+	static stat ok() {
+		return stat(isl_stat_ok);
+	}
+	static stat error() {
+		return stat(isl_stat_error);
+	}
+	stat() : val(isl_stat_error) {}
+
+	isl_stat release() {
+		check->checked = true;
+		return val;
+	}
+
+	bool is_error() const {
+		check->checked = true;
+		return val == isl_stat_error;
+	}
+	bool is_ok() const {
+		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);
+}
+
+}
+} // namespace isl
+

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp.h.bot Added

_service:tar_scm:isl-0.24.tar.gz/cpp/cpp.h.top Added

@@ -0,0 +1,256 @@
+/// These are automatically generated 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.
+
+#ifndef ISL_CPP
+#define ISL_CPP
+
+#include <isl/ctx.h>
+#include <isl/options.h>
+
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+/* ISL_USE_EXCEPTIONS should be defined to 1 if exceptions are available.
+ * gcc and clang define __cpp_exceptions; MSVC and xlC define _CPPUNWIND.
+ * Older versions of gcc (e.g., 4.9) only define __EXCEPTIONS.
+ * If exceptions are not available, any error condition will result
+ * in an abort.
+ */
+#ifndef ISL_USE_EXCEPTIONS
+#if defined(__cpp_exceptions) || defined(_CPPUNWIND) || defined(__EXCEPTIONS)
+#define ISL_USE_EXCEPTIONS	1
+#else
+#define ISL_USE_EXCEPTIONS	0
+#endif
+#endif
+
+namespace isl {
+
+class ctx {
+	isl_ctx *ptr;
+public:
+	/* implicit */ ctx(isl_ctx *ctx) : ptr(ctx) {}
+	isl_ctx *release() {
+		auto tmp = ptr;
+		ptr = nullptr;
+		return tmp;
+	}
+	isl_ctx *get() {
+		return ptr;
+	}
+};
+
+/* Macros hiding try/catch.
+ * If exceptions are not available, then no exceptions will be thrown and
+ * there is nothing to catch.
+ */
+#if ISL_USE_EXCEPTIONS
+#define ISL_CPP_TRY		try
+#define ISL_CPP_CATCH_ALL	catch (...)
+#else
+#define ISL_CPP_TRY		if (1)
+#define ISL_CPP_CATCH_ALL	if (0)
+#endif
+
+#if ISL_USE_EXCEPTIONS
+
+/* Class capturing isl errors.
+ *
+ * The what() return value is stored in a reference counted string
+ * to ensure that the copy constructor and the assignment operator
+ * do not throw any exceptions.
+ */
+class exception : public std::exception {
+	std::shared_ptr<std::string> what_str;
+
+protected:
+	inline exception(const char *what_arg, const char *msg,
+		const char *file, int line);
+public:
+	exception() {}
+	exception(const char *what_arg) {
+		what_str = std::make_shared<std::string>(what_arg);
+	}
+	static inline void throw_error(enum isl_error error, const char *msg,
+		const char *file, int line);
+	virtual const char *what() const noexcept {
+		return what_str->c_str();
+	}
+
+	/* Default behavior on error conditions that occur inside isl calls
+	 * performed from inside the bindings.
+	 * In the case exceptions are available, isl should continue
+	 * without printing a warning since the warning message
+	 * will be included in the exception thrown from inside the bindings.
+	 */
+	static constexpr auto on_error = ISL_ON_ERROR_CONTINUE;
+	/* Wrapper for throwing an exception with the given message.
+	 */
+	static void throw_invalid(const char *msg, const char *file, int line) {
+		throw_error(isl_error_invalid, msg, file, line);
+	}
+	static inline void throw_last_error(ctx ctx);
+};
+
+/* Create an exception of a type described by "what_arg", with
+ * error message "msg" in line "line" of file "file".
+ *
+ * Create a string holding the what() return value that
+ * corresponds to what isl would have printed.
+ * If no error message or no error file was set, then use "what_arg" instead.
+ */
+exception::exception(const char *what_arg, const char *msg, const char *file,
+	int line)
+{
+	if (!msg || !file)
+		what_str = std::make_shared<std::string>(what_arg);
+	else
+		what_str = std::make_shared<std::string>(std::string(file) +
+				    ":" + std::to_string(line) + ": " + msg);
+}
+
+class exception_abort : public exception {
+	friend exception;
+	exception_abort(const char *msg, const char *file, int line) :
+		exception("execution aborted", msg, file, line) {}
+};
+
+class exception_alloc : public exception {
+	friend exception;
+	exception_alloc(const char *msg, const char *file, int line) :
+		exception("memory allocation failure", msg, file, line) {}
+};
+
+class exception_unknown : public exception {
+	friend exception;
+	exception_unknown(const char *msg, const char *file, int line) :
+		exception("unknown failure", msg, file, line) {}
+};
+
+class exception_internal : public exception {
+	friend exception;
+	exception_internal(const char *msg, const char *file, int line) :
+		exception("internal error", msg, file, line) {}
+};
+
+class exception_invalid : public exception {
+	friend exception;
+	exception_invalid(const char *msg, const char *file, int line) :
+		exception("invalid argument", msg, file, line) {}
+};
+
+class exception_quota : public exception {
+	friend exception;
+	exception_quota(const char *msg, const char *file, int line) :
+		exception("quota exceeded", msg, file, line) {}
+};
+
+class exception_unsupported : public exception {
+	friend exception;
+	exception_unsupported(const char *msg, const char *file, int line) :
+		exception("unsupported operation", msg, file, line) {}
+};
+
+/* Throw an exception of the class that corresponds to "error", with
+ * error message "msg" in line "line" of file "file".
+ *
+ * isl_error_none is treated as an invalid error type.
+ */
+void exception::throw_error(enum isl_error error, const char *msg,
+	const char *file, int line)
+{
+	switch (error) {
+	case isl_error_none:
+		break;
+	case isl_error_abort: throw exception_abort(msg, file, line);
+	case isl_error_alloc: throw exception_alloc(msg, file, line);
+	case isl_error_unknown: throw exception_unknown(msg, file, line);
+	case isl_error_internal: throw exception_internal(msg, file, line);
+	case isl_error_invalid: throw exception_invalid(msg, file, line);
+	case isl_error_quota: throw exception_quota(msg, file, line);
+	case isl_error_unsupported:
+				throw exception_unsupported(msg, file, line);
+	}
+
+	throw exception_invalid("invalid error type", file, line);
+}
+
+/* Throw an exception corresponding to the last error on "ctx" and
+ * reset the error.
+ *
+ * If "ctx" is NULL or if it is not in an error state at the start,
+ * then an invalid argument exception is thrown.
+ */
+void exception::throw_last_error(ctx ctx)
+{
+	enum isl_error error;
+	const char *msg, *file;
+	int line;
+
+	error = isl_ctx_last_error(ctx.get());
+	msg = isl_ctx_last_error_msg(ctx.get());
+	file = isl_ctx_last_error_file(ctx.get());
+	line = isl_ctx_last_error_line(ctx.get());
+	isl_ctx_reset_error(ctx.get());
+
+	throw_error(error, msg, file, line);
+}
+
+#else
+
+#include <stdio.h>
+#include <stdlib.h>
+
+class exception {
+public:
+	/* Default behavior on error conditions that occur inside isl calls
+	 * performed from inside the bindings.
+	 * In the case exceptions are not available, isl should abort.
+	 */
+	static constexpr auto on_error = ISL_ON_ERROR_ABORT;
+	/* Wrapper for throwing an exception with the given message.
+	 * In the case exceptions are not available, print an error and abort.
+	 */
+	static void throw_invalid(const char *msg, const char *file, int line) {
+		fprintf(stderr, "%s:%d: %s\n", file, line, msg);
+		abort();
+	}
+	/* Throw an exception corresponding to the last
+	 * error on "ctx".
+	 * isl should already abort when an error condition occurs,
+	 * so this function should never be called.
+	 */
+	static void throw_last_error(ctx ctx) {
+		abort();
+	}
+};
+
+#endif
+
+/* Helper class for setting the on_error and resetting the option
+ * to the original value when leaving the scope.
+ */
+class options_scoped_set_on_error {
+	isl_ctx *ctx;
+	int saved_on_error;
+public:
+	options_scoped_set_on_error(class ctx ctx, int on_error) {
+		this->ctx = ctx.get();
+		saved_on_error = isl_options_get_on_error(this->ctx);
+		isl_options_set_on_error(this->ctx, on_error);
+	}
+	~options_scoped_set_on_error() {
+		isl_options_set_on_error(ctx, saved_on_error);
+	}
+};
+
+} // namespace isl
+

_service:tar_scm:isl-0.24.tar.gz/cpp/typed_cpp.h.bot Added

_service:tar_scm:isl-0.24.tar.gz/cpp/typed_cpp.h.top Added

_service:tar_scm:isl-0.24.tar.gz/dep.c Added

_service:tar_scm:isl-0.14.tar.xz/depcomp -> _service:tar_scm:isl-0.24.tar.gz/depcomp Changed

@@ -1,9 +1,9 @@
 #! /bin/sh
 # depcomp - compile a program generating dependencies as side-effects
 
-scriptversion=2013-05-30.07; # UTC
+scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1999-2013 Free Software Foundation, Inc.
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
 # GNU General Public License for more details.
 
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -783,9 +783,9 @@
 # Local Variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:

_service:tar_scm:isl-0.24.tar.gz/doc/CodingStyle Added

@@ -0,0 +1,42 @@
+This document describes some aspects of the coding style of isl,
+which is similar to that of the linux kernel and git.
+
+The general rule is to use the same style as that of the surrounding code.
+
+More specific rules:
+	- every line should have at most 80 columns
+	- use tabs for indentation, where a tab counts for 8 characters
+	- use single spaces around binary operators such as '+', '-', '=', '!='
+	- no space after unary operators such as '!'
+	- use a single space after a comma and a semicolon
+	  (except at the end of a line)
+	- no space between function name and arguments
+	- use a single space after control keywords such as if, for and while
+	- use a single space between the type of a cast and the value
+	  that is being cast
+	- no whitespace at the end of a line
+	- opening brace of a function is placed on a new line
+	- opening brace of other blocks stays on the same line
+	- the body of a control statement is placed on the next line(s)
+	- an else appears on the same line as the closing brace of
+	  the then branch, if there is such a closing brace
+	- if either the then or the else branch of an if has braces,
+	  then they both have braces
+	- no parentheses around argument of return keyword
+	- use only C style comments (/* ... */)
+	- no comments inside function bodies;
+	  if some part of a function deserves additional comments, then
+	  extract it out into a separate function first
+	- no #ifs inside function bodies
+	- variables are declared at the start of a block, before any
+	  other statements
+
+There are some exceptions to the general rule of using
+the same style as the surrounding code, most notably
+when the surrounding code is very old.
+In particular, an "isl_space" used to be called "isl_dim" and
+some variables of this type are still called "dim" or some variant thereof.
+New variables of this type should be called "space" or a more specific name.
+Some old functions do not have memory management annotations yet.
+All new functions should have memory management annotations,
+whenever appropriate

_service:tar_scm:isl-0.14.tar.xz/doc/Makefile.am -> _service:tar_scm:isl-0.24.tar.gz/doc/Makefile.am Changed

_service:tar_scm:isl-0.14.tar.xz/doc/Makefile.in -> _service:tar_scm:isl-0.24.tar.gz/doc/Makefile.in Changed

_service:tar_scm:isl-0.14.tar.xz/doc/implementation.tex -> _service:tar_scm:isl-0.24.tar.gz/doc/implementation.tex Changed

@@ -155,13 +155,13 @@
 
 \subsection{Introduction}\label{s:intro}
 
-Parametric integer programming \shortcite{Feautrier88parametric}
+Parametric integer programming \parencite{Feautrier88parametric}
 is used to solve many problems within the context of the polyhedral model.
-Here, we are mainly interested in dependence analysis \shortcite{Fea91}
+Here, we are mainly interested in dependence analysis \parencite{Fea91}
 and in computing a unique representation for existentially quantified
 variables.  The latter operation has been used for counting elements
 in sets involving such variables
-\shortcite{BouletRe98,Verdoolaege2005experiences} and lies at the core
+\parencite{BouletRe98,Verdoolaege2005experiences} and lies at the core
 of the internal representation of {\tt isl}.
 
 Parametric integer programming was first implemented in \texttt{PipLib}.
@@ -169,7 +169,7 @@
 was later implemented in {\tt barvinok} \cite{barvinok-0.22}.
 This method is not based on Feautrier's algorithm, but on rational
 generating functions \cite{Woods2003short} and was inspired by the
-``digging'' technique of \shortciteN{DeLoera2004Three} for solving
+``digging'' technique of \textcite{DeLoera2004Three} for solving
 non-parametric integer programming problems.
 
 In the following sections, we briefly recall the dual simplex
@@ -186,9 +186,9 @@
 In {\tt isl}, the dual simplex method uses the same representation
 as that used by its incremental LP solver based on the \emph{primal}
 simplex method.  The implementation of this LP solver is based
-on that of {\tt Simplify} \shortcite{Detlefs2005simplify}, which, in turn,
-was derived from the work of \shortciteN{Nelson1980phd}.
-In the original \shortcite{Nelson1980phd}, the tableau was implemented
+on that of {\tt Simplify} \parencite{Detlefs2005simplify}, which, in turn,
+was derived from the work of \textcite{Nelson1980phd}.
+In the original \parencite{Nelson1980phd}, the tableau was implemented
 as a sparse matrix, but neither {\tt Simplify} nor the current
 implementation of {\tt isl} does so.
 
@@ -306,7 +306,7 @@
 are assumed to be non-negative: the initial tableau starts from
 sample value $\vec x = \vec 0$ and $\vec c$ is assumed to be non-negative
 during the construction of Gomory cuts.
-To deal with negative unknowns, \shortciteNAppendix A.2{Fea91}
+To deal with negative unknowns, \textciteAppendix A.2{Fea91}
 proposed to use a ``big parameter'', say $M$, that is taken to be
 an arbitrarily large positive number.  Instead of looking for the
 lexicographically minimal value of $\vec x$, we search instead
@@ -339,11 +339,11 @@
 
 The original version of {\tt PipLib} required the user to ``manually''
 add a big parameter, perform the reformulation and interpret the result
-\shortcite{Feautrier02}.  Recent versions allow the user to simply
+\parencite{Feautrier02}.  Recent versions allow the user to simply
 specify that the unknowns may be negative or that the maximum should
 be computed and then these transformations are performed internally.
 Although there are some application, e.g.,
-that of \shortciteN{Feautrier92multi},
+that of \textcite{Feautrier92multi},
 where it is useful to have explicit control over the big parameter,
 negative unknowns and maximization are by far the most common applications
 of the big parameter and we believe that the user should not be bothered
@@ -399,7 +399,7 @@
 If there are any (explicit) equalities in the input description,
 {\tt PipLib} converts each into a pair of inequalities.
 It is also possible to write $r$ equalities as $r+1$ inequalities
-\shortcite{Feautrier02}, but it is even better to \emph{exploit} the
+\parencite{Feautrier02}, but it is even better to \emph{exploit} the
 equalities to reduce the dimensionality of the problem.
 Given an equality involving at least one unknown, we pivot
 the row corresponding to the equality with the column corresponding
@@ -447,7 +447,7 @@
 
 \subsubsection{Offline Symmetry Detection}\label{s:offline}
 
-Some problems, notably those of \shortciteN{Bygde2010licentiate},
+Some problems, notably those of \textcite{Bygde2010licentiate},
 have a collection of constraints, say
 $b_i(\vec p) + \sp {\vec a} {\vec x} \ge 0$,
 that only differ in their (parametric) constant terms.
@@ -473,12 +473,24 @@
 and exploitation of symmetries that appear during the course of
 the dual simplex method.
 
+Note that the replacement of the $b_i(\vec p)$ by $u$ may lose
+information if the parameters that occur in $b_i(\vec p)$ also
+occur in other constraints.  The replacement is therefore currently
+only applied when all the parameters in all of the $b_i(\vec p)$
+only occur in a single constraint, i.e., the one in which
+the parameter is removed.
+This is the case for the examples from \textcite{Bygde2010licentiate}
+in \autoref{t:comparison}.
+The version of {\tt isl} that was used during the experiments
+of \autoref{s:pip:experiments} did not take into account
+this single-occurrence constraint.
+
 \subsubsection{Parameter Compression}\label{s:compression}
 
 It may in some cases be apparent from the equalities in the problem
 description that there can only be a solution for a sublattice
 of the parameters.  In such cases ``parameter compression''
-\shortcite{Meister2004PhD,Meister2008} can be used to replace
+\parencite{Meister2004PhD,Meister2008} can be used to replace
 the parameters by alternative ``dense'' parameters.
 For example, if there is a constraint $2x = n$, then the system
 will only have solutions for even values of $n$ and $n$ can be replaced
@@ -545,7 +557,7 @@
 This sign can be determined by solving two integer linear feasibility
 problems, one with a constraint added to the context that enforces
 the expression to be non-negative and one where the expression is
-negative.  As already mentioned by \shortciteN{Feautrier88parametric},
+negative.  As already mentioned by \textcite{Feautrier88parametric},
 any integer linear feasibility solver could be used, but the {\tt PipLib}
 implementation uses a recursive call to the dual simplex with Gomory
 cuts algorithm to determine the feasibility of a context.
@@ -632,9 +644,9 @@
 the big parameter of the main tableau also appears
 in the context tableau.
 
-Finally, it was reported by \shortciteN{Galea2009personal}, who
+Finally, it was reported by \textcite{Galea2009personal}, who
 worked on a parametric integer programming implementation
-in {\tt PPL} \shortcite{PPL},
+in {\tt PPL} \parencite{PPL},
 that it is beneficial to add cuts for \emph{all} rational coordinates
 in the context tableau.  Based on this report,
 the initial {\tt isl} implementation was adapted accordingly.
@@ -642,7 +654,7 @@
 \subsubsection{Generalized Basis Reduction}\label{s:GBR}
 
 The default algorithm used in {\tt isl} for feasibility checking
-is generalized basis reduction \shortcite{Cook1991implementation}.
+is generalized basis reduction \parencite{Cook1991implementation}.
 This algorithm is also used in the {\tt barvinok} implementation.
 The algorithm is fairly robust, but it has some overhead.
 We therefore try to avoid calling the algorithm in easy cases.
@@ -666,7 +678,7 @@
 affine combination of other variables.
 To detect such cases, we compute the affine hull of the context
 each time a new integer division is added.  The algorithm used
-for computing this affine hull is that of \shortciteN{Karr1976affine},
+for computing this affine hull is that of \textcite{Karr1976affine},
 while the points used in this algorithm are obtained by performing
 integer feasibility checks on that part of the context outside
 the current approximation of the affine hull.
@@ -678,12 +690,14 @@
 propagated to the main tableau, where it is used to eliminate that
 integer division.
 
-\subsection{Experiments}
+\subsection{Experiments}\label{s:pip:experiments}
 
 \autoref{t:comparison} compares the execution times of {\tt isl}
 (with both types of context tableau)
 on some more difficult instances to those of other tools,
 run on an Intel Xeon W3520 @ 2.66GHz.
+These instances are available in the \lstinline{testsets/pip} directory
+of the {\tt isl} distribution.
 Easier problems such as the
 test cases distributed with {\tt Pip\-Lib} can be solved so quickly
 that we would only be measuring overhead such as input/output and conversions
@@ -695,7 +709,7 @@
 and {\tt PPL} version 0.11.2.
 
 The first test case is the following dependence analysis problem
-originating from the Phideo project \shortcite{Verhaegh1995PhD}
+originating from the Phideo project \parencite{Verhaegh1995PhD}
 that was communicated to us by Bart Kienhuis:
 \begin{lstlisting}flexiblecolumns=true,breaklines=true{}
 lexmax { j1,j2 -> i1,i2,i3,i4,i5,i6,i7,i8,i9,i10 : 1 <= i1,j1 <= 8 and 1 <= i2,i3,i4,i5,i6,i7,i8,i9,i10 <= 2 and 1 <= j2 <= 128 and i1-1 = j1-1 and i2-1+2*i3-2+4*i4-4+8*i5-8+16*i6-16+32*i7-32+64*i8-64+128*i9-128+256*i10-256=3*j2-3+66 };
@@ -703,12 +717,12 @@
 This problem was the main inspiration
 for some of the optimizations in \autoref{s:GBR}.
 The second group of test cases are projections used during counting.
-The first nine of these come from \shortciteN{Seghir2006minimizing}.
-The remaining two come from \shortciteN{Verdoolaege2005experiences} and
+The first nine of these come from \textcite{Seghir2006minimizing}.
+The remaining two come from \textcite{Verdoolaege2005experiences} and
 were used to drive the first, Gomory cuts based, implementation
 in {\tt isl}.
 The third and final group of test cases are borrowed from
-\shortciteN{Bygde2010licentiate} and inspired the offline symmetry detection
+\textcite{Bygde2010licentiate} and inspired the offline symmetry detection
 of \autoref{s:offline}.  Without symmetry detection, the running times
 are 11s and 5.9s.
 All running times of {\tt barvinok} and {\tt isl} include a conversion
@@ -755,8 +769,8 @@
 \subsection{Online Symmetry Detection}\label{s:online}
 
 Manual experiments on small instances of the problems of
-\shortciteN{Bygde2010licentiate} and an analysis of the results
-by the approximate MPA method developed by \shortciteN{Bygde2010licentiate}
+\textcite{Bygde2010licentiate} and an analysis of the results
+by the approximate MPA method developed by \textcite{Bygde2010licentiate}
 have revealed that these problems contain many more symmetries
 than can be detected using the offline method of \autoref{s:offline}.
 In this section, we present an online detection mechanism that has
@@ -816,8 +830,7 @@
 
 \section{Coalescing}\label{s:coalescing}
 
-See \shortciteN{Verdoolaege2009isl}, for now.
-More details will be added later.
+See \textcite{Verdoolaege2015impact} for details on integer set coalescing.
 
 \section{Transitive Closure}
 
@@ -857,11 +870,11 @@
 \end{equation}
 
 Since the transitive closure of a polyhedral relation
-may no longer be a polyhedral relation \shortcite{Kelly1996closure},
+may no longer be a polyhedral relation \parencite{Kelly1996closure},
 we can, in the general case, only compute an approximation
 of the transitive closure.
-Whereas \shortciteN{Kelly1996closure} compute underapproximations,
-we, like \shortciteN{Beletska2009}, compute overapproximations.
+Whereas \textcite{Kelly1996closure} compute underapproximations,
+we, like \textcite{Beletska2009}, compute overapproximations.
 That is, given a relation $R$, we will compute a relation $T$
 such that $R^+ \subseteq T$.  Of course, we want this approximation
 to be as close as possible to the actual transitive closure
@@ -869,7 +882,7 @@
 exact, i.e., where $T = R^+$.
 
 For computing an approximation of the transitive closure of $R$,
-we follow the same general strategy as \shortciteN{Beletska2009}
+we follow the same general strategy as \textcite{Beletska2009}
 and first compute an approximation of $R^k$ for $k \ge 1$ and then project
 out the parameter $k$ from the resulting relation.
 
@@ -950,7 +963,7 @@
 \,\}
 \end{equation}
 and then the approximation computed in \eqref{eq:transitive:approx}
-is essentially the same as that of \shortciteN{Beletska2009}.
+is essentially the same as that of \textcite{Beletska2009}.
 If some of the $\Delta_i$s are not singleton sets or if
 some of $\vec \delta_i$s are parametric, then we need
 to resort to further approximations.
@@ -1106,9 +1119,9 @@
 A_1 & \vec c_1
 \end{matrix}
 \right \vec x' \,\}$ and therefore $\Delta'_i(\vec s)$ is
-a Hilbert basis of this cone \shortciteTheorem~16.4{Schrijver1986}.
+a Hilbert basis of this cone \parenciteTheorem~16.4{Schrijver1986}.
 
-Note however that, as pointed out by \shortciteN{DeSmet2010personal},
+Note however that, as pointed out by \textcite{DeSmet2010personal},
 if there \emph{are} any mixed constraints, then the above procedure may
 not compute the most accurate affine approximation of
 $k \, \Delta_i(\vec s)$ with $k \ge 1$.
@@ -1369,7 +1382,7 @@
 T \subseteq R \cup \left(R \circ T\right)
 .
 $$
-This is essentially Theorem~5 of \shortciteN{Kelly1996closure}.
+This is essentially Theorem~5 of \textcite{Kelly1996closure}.
 The only difference is that they only consider lexicographically
 forward relations, a special case of acyclic relations.
 
@@ -1443,7 +1456,7 @@
 .
 \end{equation}
 The components can be obtained from the graph by applying
-Tarjan's algorithm \shortcite{Tarjan1972}.
+Tarjan's algorithm \parencite{Tarjan1972}.
 
 In practice, we compute the (extended) powers $K_i'$ of each component
 separately and then compose them as in \eqref{eq:transitive:decompose}.
@@ -1496,7 +1509,7 @@
 \begin{example}
 \label{ex:closure4}
 Consider the relation in example {\tt closure4} that comes with
-the Omega calculator~\shortcite{Omega_calc}, $R = R_1 \cup R_2$,
+the Omega calculator~\parencite{Omega_calc}, $R = R_1 \cup R_2$,
 with
 $$
 \begin{aligned}
@@ -1575,7 +1588,7 @@
 \end{figure}
 \begin{example}
 \label{ex:decomposition}
-Consider the relation on the right of \shortciteNFigure~2{Beletska2009},
+Consider the relation on the right of \textciteFigure~2{Beletska2009},
 reproduced in \autoref{f:decomposition}.
 The relation can be described as $R = R_1 \cup R_2 \cup R_3$,
 with
@@ -1626,7 +1639,7 @@
 By computing the power of $R_3$ and $R_1 \cup R_2$ separately
 and composing the results, the power of $R$ can be computed exactly
 using \eqref{eq:transitive:singleton}.
-As explained by \shortciteN{Beletska2009}, applying the same formula
+As explained by \textcite{Beletska2009}, applying the same formula
 to $R$ directly, without a decomposition, would result in
 an overapproximation of the power.
 \end{example}
@@ -1641,11 +1654,11 @@
 domains, then this assumption no longer holds.
 In particular, when an entire dependence graph is encoded
 in a single relation, as is done by, e.g.,
-\shortciteNSection~6.1{Barthou2000MSE}, then it does not make
+\textciteSection~6.1{Barthou2000MSE}, then it does not make
 sense to look at differences between iterations of different domains.
 Now, arguably, a modified Floyd-Warshall algorithm should
 be applied to the dependence graph, as advocated by
-\shortciteN{Kelly1996closure}, with the transitive closure operation
+\textcite{Kelly1996closure}, with the transitive closure operation
 only being applied to relations from a given domain to itself.
 However, it is also possible to detect disjoint domains and ranges
 and to apply Floyd-Warshall internally.
@@ -1653,7 +1666,7 @@
 \LinesNumbered
 \begin{algorithm}
 \caption{The modified Floyd-Warshall algorithm of
-\protect\shortciteN{Kelly1996closure}}
+\protect\textcite{Kelly1996closure}}
 \label{a:Floyd}
 \SetKwInput{Input}{Input}
 \SetKwInput{Output}{Output}
@@ -1737,12 +1750,12 @@
 \end{tikzpicture}
 \end{center}
 \caption{The relation (solid arrows) on the right of Figure~1 of
-\protect\shortciteN{Beletska2009} and its transitive closure}
+\protect\textcite{Beletska2009} and its transitive closure}
 \label{f:COCOA:1}
 \end{figure}
 \begin{example}
 Consider the relation on the right of Figure~1 of
-\shortciteN{Beletska2009},
+\textcite{Beletska2009},
 reproduced in \autoref{f:COCOA:1}.
 This relation can be described as
 $$
@@ -1819,7 +1832,7 @@
 say on domain $D$.  We will use the notation
 ${\cal C}(R_i,D) = R_i^+ \cup \identity_D$ to represent
 this relaxed version of $R^+$.
-\shortciteN{Kelly1996closure} use the notation $R_i^?$.
+\textcite{Kelly1996closure} use the notation $R_i^?$.
 ${\cal C}(R_i,D)$ can be computed by allowing $k$ to attain
 the value $0$ in \eqref{eq:transitive:Q} and by using
 $$
@@ -1838,11 +1851,11 @@
 in \eqref{eq:transitive:incremental}, $D$ should be chosen
 to include both $\domain R$ and $\range R$, i.e., such
 that $\identity_D \circ R_j \circ \identity_D = R_j$ for all $j\ne i$.
-\shortciteN{Kelly1996closure} say that they use
+\textcite{Kelly1996closure} say that they use
 $D = \domain R_i \cup \range R_i$, but presumably they mean that
 they use $D = \domain R \cup \range R$.
 Now, this expression of $D$ contains a union, so it not directly usable.
-\shortciteN{Kelly1996closure} do not explain how they avoid this union.
+\textcite{Kelly1996closure} do not explain how they avoid this union.
 Apparently, in their implementation,
 they are using the convex hull of $\domain R \cup \range R$
 or at least an approximation of this convex hull.
@@ -1954,15 +1967,15 @@
 
 \subsection{An {\tt Omega}-like implementation}
 
-While the main algorithm of \shortciteN{Kelly1996closure} is
+While the main algorithm of \textcite{Kelly1996closure} is
 designed to compute and underapproximation of the transitive closure,
 the authors mention that they could also compute overapproximations.
 In this section, we describe our implementation of an algorithm
 that is based on their ideas.
 Note that the {\tt Omega} library computes underapproximations
-\shortciteSection 6.4{Omega_lib}.
+\parenciteSection 6.4{Omega_lib}.
 
-The main tool is Equation~(2) of \shortciteN{Kelly1996closure}.
+The main tool is Equation~(2) of \textcite{Kelly1996closure}.
 The input relation $R$ is first overapproximated by a ``d-form'' relation
 $$
 \{\, \vec i \to \vec j \mid \exists \vec \alpha :
@@ -2021,7 +2034,7 @@
 (\autoref{s:simple hull}) of $\domain R \cup \range R$.
 To determine whether it is safe to use ${\cal C}(R_i,D)$,
 we check the following conditions, as proposed by
-\shortciteN{Kelly1996closure}:
+\textcite{Kelly1996closure}:
 ${\cal C}(R_i,D) - R_i^+$ is not a union and for each $j \ne i$
 the condition
 $$

_service:tar_scm:isl-0.14.tar.xz/doc/isl.bib -> _service:tar_scm:isl-0.24.tar.gz/doc/isl.bib Changed

@@ -19,6 +19,7 @@
   volume    = {1033},
   year      = {1996},
   isbn      = {3-540-60765-X},
+	doi = "10.1007/BFb0014196",
 }
 
 @inproceedings{Beletska2009,
@@ -49,7 +50,8 @@
     publisher = {SIAM},
     title = {Depth-First Search and Linear Graph Algorithms},
     volume = {1},
-    year = {1972}
+    year = {1972},
+    doi = "10.1137/0201010",
 }
 
 @TechReport{ Omega_calc,
@@ -113,6 +115,7 @@
   pages =        {23--53},
   OPTnote =      {},
   OPTannote =    {},
+	doi = "10.1007/BF01407931",
 }
 
 @INPROCEEDINGS{BouletRe98,
@@ -140,6 +143,7 @@
   the data movements its program generates and thus find a good data
   distribution. Our method is based on parametric polyhedral
   computations. It can be applied to a large class of regular codes.},
+    doi = "10.1007/BFb0057861",
 }
 
 @INPROCEEDINGS {Verdoolaege2005experiences,
@@ -188,12 +192,13 @@
     title = {{Short rational generating functions for lattice point
         problems}},
     author = {Alexander Barvinok and Kevin Woods},
+    doi = "10.1090/S0894-0347-03-00428-4",
 }
 
 @misc{barvinok-0.22,
   author = {Sven Verdoolaege},
   title = {{\texttt{barvinok}}, version 0.22},
-  howpublished = {Available from \url{http://freshmeat.net/projects/barvinok/}},
+  howpublished = {Available from \url{http://barvinok.gforge.inria.fr/}},
   year = 2006
 }
 
@@ -206,6 +211,7 @@
     series = "Lecture Notes in Computer Science",
     Volume = 3064,
     Pages = "244-255",
+    doi = "10.1007/978-3-540-25960-2_19",
 }
 
 @TechReport{Feautrier02,
@@ -225,6 +231,7 @@
     year = "1992",
     month = dec,
     url = "citeseer.nj.nec.com/article/feautrier92some.html",
+	doi = "10.1007/BF01379404",
 }
 
 @misc{Bygde2010licentiate,
@@ -288,6 +295,7 @@
 year={1976},
 publisher={Springer-Verlag},
 ignore={ },
+	doi = "10.1007/BF00268497",
 }
 
 @PhdThesis{Verhaegh1995PhD,
@@ -302,7 +310,8 @@
   TITLE = {Memory Optimization by Counting Points in Integer Transformations of Parametric Polytopes},
   BOOKTITLE = {{P}roceedings of the {I}nternational {C}onference on {C}ompilers, {A}rchitectures, and {S}ynthesis for {E}mbedded Systems, CASES 2006, {S}eoul, {K}orea},
   month = oct,
-  YEAR = {2006}
+  YEAR = {2006},
+  doi = {10.1145/1176760.1176771},
 }
 
 @misc{DeSmet2010personal,
@@ -311,3 +320,166 @@
     year = 2010,
     month = apr,
 }
+
+@inproceedings{Verdoolaege2015impact,
+ author = {Verdoolaege, Sven},
+ title = {Integer Set Coalescing},
+ booktitle = {Proceedings of the 5th International Workshop on
+	Polyhedral Compilation Techniques},
+ year   = 2015,
+ month  = Jan,
+ address = {Amsterdam, The Netherlands},
+ abstract = {
+In polyhedral compilation, various core concepts such as the set
+of statement instances, the access relations, the dependences and
+the schedule are represented or approximated using sets and binary
+relations of sequences of integers bounded by (quasi-)affine constraints.
+When these sets and relations are represented in disjunctive normal form,
+it is important to keep the number of disjuncts small, both for efficiency
+and to improve the computation of transitive closure overapproximations
+and AST generation.  This paper describes the set coalescing operation
+of isl that looks for opportunities to combine several disjuncts into
+a single disjunct without affecting the elements in the set.  The main
+purpose of the paper is to explain the various heuristics and to prove
+their correctness.
+ },
+	doi = "10.13140/2.1.1313.6968",
+}
+
+@misc{Verdoolaege2016tutorial,
+	author = "Sven Verdoolaege",
+	title = "Presburger Formulas and Polyhedral Compilation",
+	year = 2016,
+	doi = "10.13140/RG.2.1.1174.6323",
+}
+
+@inproceedings{Verdoolaege2009equivalence,
+	author = "Sven Verdoolaege and Gerda Janssens and Maurice Bruynooghe",
+	title = "Equivalence checking of static affine programs using widening to handle recurrences",
+	booktitle = "Computer Aided Verification 21",
+	month = Jun,
+	year = 2009,
+	pages = "599--613",
+	publisher = "Springer",
+	doi = "10.1007/978-3-642-02658-4_44",
+}
+
+@incollection{Verdoolaege2010isl,
+   author = {Verdoolaege, Sven},
+   title = {isl: An Integer Set Library for the Polyhedral Model},
+   booktitle = {Mathematical Software - ICMS 2010},
+   series = {Lecture Notes in Computer Science},
+   editor = {Fukuda, Komei and Hoeven, Joris and Joswig, Michael and Takayama, Nobuki},
+   publisher = {Springer},
+   isbn = {},
+   pages = {299-302},
+   volume = {6327},
+   year = {2010},
+   doi = {10.1007/978-3-642-15582-6_49},
+}
+
+@incollection{Verdoolaege2010networks,
+  author = "Verdoolaege, Sven",
+  title = "Polyhedral process networks",
+  editor = "Bhattacharrya, Shuvra and Deprettere, Ed and Leupers, Rainer and Takala, Jarmo",
+  publisher = "Springer",
+  year = "2010",
+  doi = "10.1007/978-1-4419-6345-1\_{}33",
+  pages = "931--965",
+  booktitle = "Handbook of Signal Processing Systems",
+  url = "https://lirias.kuleuven.be/handle/123456789/235370",
+	doi = "10.1007/978-1-4419-6345-1_33",
+}
+
+@InProceedings{Verdoolaege2011iscc,
+  author = 	 {Sven Verdoolaege},
+  title = 	 {Counting Affine Calculator and Applications},
+  booktitle = { First International Workshop on Polyhedral Compilation Techniques (IMPACT'11)},
+  address = { Chamonix, France},
+  month = 	 apr,
+  year = 	 {2011},
+	doi = "10.13140/RG.2.1.2959.5601",
+}
+
+@inproceedings{Verdoolaege2011closure,
+ author = {Verdoolaege, Sven and Cohen, Albert and Beletska, Anna},
+ title = {Transitive Closures of Affine Integer Tuple Relations and Their Overapproximations},
+ booktitle = {Proceedings of the 18th International Conference on Static Analysis},
+ series = {SAS'11},
+ year = {2011},
+ isbn = {978-3-642-23701-0},
+ location = {Venice, Italy},
+ pages = {216--232},
+ numpages = {17},
+ acmid = {2041570},
+ publisher = {Springer-Verlag},
+ address = {Berlin, Heidelberg},
+ doi = "10.1007/978-3-642-23702-7_18",
+}
+
+@article{Verdoolaege2013PPCG,
+  title={Polyhedral parallel code generation for {CUDA}},
+  author={Verdoolaege, Sven and Juega, Juan Carlos and Cohen, Albert and G{\'o}mez, Jos{\'e} Ignacio and Tenllado, Christian and Catthoor, Francky},
+  journal = {ACM Trans. Archit. Code Optim.},
+  volume={9},
+  number={4},
+  pages={54},
+  year={2013},
+  publisher={ACM},
+    doi = {10.1145/2400682.2400713},
+}
+
+@inproceedings{Verdoolaege2014impact,
+ author = {Verdoolaege, Sven and Guelton, Serge and
+	Grosser, Tobias and Cohen, Albert},
+ title = {Schedule Trees},
+ booktitle = {Proceedings of the 4th International Workshop on Polyhedral Compilation Techniques},
+ year   = 2014,
+ month  = Jan,
+ address = {Vienna, Austria},
+ url = {http://impact.gforge.inria.fr/impact2014/papers/impact2014-verdoolaege.pdf},
+ abstract = {
+ Schedules in the polyhedral model, both those that represent the original
+execution order and those produced by scheduling algorithms, naturally have the
+form of a tree. Generic schedule representations proposed in the literature
+encode this tree structure such that it is only implicitly available.
+Following the internal representation of isl , we propose to represent
+schedules as explicit trees and further extend the concept by introducing
+different kinds of nodes. We compare our schedule trees to other
+representations in detail and illustrate how they have been successfully used
+to simplify the implementation of a non-trivial polyhedral compiler.
+ },
+	DOI = {10.13140/RG.2.1.4475.6001},
+}
+
+@article{Grosser2015AST,
+	author = "Tobias Grosser and Sven Verdoolaege and Albert Cohen",
+	title = "Polyhedral {AST} generation is more than scanning polyhedra",
+	journal = "ACM Transactions on Programming Languages and Systems",
+ issue_date = {August 2015},
+ volume = {37},
+ number = {4},
+ month = jul,
+ year = {2015},
+ issn = {0164-0925},
+ pages = {12:1--12:50},
+ articleno = {12},
+ numpages = {50},
+ url = {http://doi.acm.org/10.1145/2743016},
+ doi = {10.1145/2743016},
+ acmid = {2743016},
+ publisher = {ACM},
+ address = {New York, NY, USA},
+ keywords = {Polyhedral compilation, Presburger relations, code generation, index set splitting, unrolling},
+}
+
+@inproceedings{Verdoolaege2016reordering,
+	author = {Sven Verdoolaege and Albert Cohen},
+	title = "Live-Range Reordering",
+ booktitle = {Proceedings of the sixth International Workshop on
+	Polyhedral Compilation Techniques},
+ year   = 2016,
+ month  = Jan,
+ address = {Prague, Czech Republic},
+	doi = "10.13140/RG.2.1.3272.9680",
+}

_service:tar_scm:isl-0.14.tar.xz/doc/manual.pdf -> _service:tar_scm:isl-0.24.tar.gz/doc/manual.pdf Changed

_service:tar_scm:isl-0.14.tar.xz/doc/manual.tex -> _service:tar_scm:isl-0.24.tar.gz/doc/manual.tex Changed

@@ -1,9 +1,13 @@
 \documentclass{report}
-\usepackageplainpages=false,pdfpagelabels,breaklinks,pagebackref{hyperref}
+\usepackageT1{fontenc}
+\usepackageplainpages=false,pdfpagelabels,breaklinks{hyperref}
+\usepackagebackend=biber,isbn=false,url=false,doi=true,%
+maxbibnames=99,style=authoryear,sortcites=true,sorting=nyt,backref=true,%
+indexing=true,mincitenames=2,maxcitenames=2,datelabel=comp,dashed=false,%
+useprefix=true{biblatex}
 \usepackage{amsmath}
 \usepackage{amssymb}
 \usepackage{txfonts}
-\usepackage{chicago}
 \usepackage{aliascnt}
 \usepackage{tikz}
 \usepackage{calc}
@@ -11,6 +15,15 @@
 \usetikzlibrary{matrix,fit,backgrounds,decorations.pathmorphing,positioning}
 \usepackage{listings}
 
+\addbibresource{isl.bib}
+
+\renewbibmacro*{finentry}{\iflistundef{pageref}{}{\renewcommand{\finentrypunct}{}}\finentry}
+\renewbibmacro*{pageref}{%
+  \iflistundef{pageref}
+    {}
+    {\setunit{\adddot\addspace}\printtext{%
+  \mbox{}\penalty100\hfill\hbox{\printlistpageref-\value{listtotal}{pageref}}}}}
+
 \lstset{basicstyle=\tt,flexiblecolumns=false}
 
 \def\vec#1{\mathchoice{\mbox{\boldmath$\displaystyle\bf#1$}}
@@ -40,6 +53,10 @@
 \newcommand{\lstnumberautorefname}{Line}
 \renewcommand{\sectionautorefname}{Section}
 \renewcommand{\subsectionautorefname}{Section}
+\renewcommand{\algorithmautorefname}{Algorithm}
+
+\DeclareFieldFormat{date}{\hypertarget{\thefield{entrykey}}{#1}}
+\def\isl{\hyperlink{Verdoolaege2010isl}{\texttt{isl}}\xspace}
 
 \def\Z{\mathbb{Z}}
 \def\Q{\mathbb{Q}}
@@ -69,7 +86,10 @@
 
 \input{implementation}
 
-\bibliography{isl}
-\bibliographystyle{chicago}
+\chapter{Further Reading}
+
+\input{reading}
+
+\printbibliography
 
 \end{document}

_service:tar_scm:isl-0.24.tar.gz/doc/reading.tex Added

@@ -0,0 +1,46 @@
+\textcite{Verdoolaege2016tutorial} describes the concepts behind
+\isl in some detail, mainly focusing on Presburger formulas,
+but also including some information on polyhedral compilation,
+especially on dependence analysis.
+Individual aspects of \isl are described in the following publications.
+\begin{itemize}
+\item
+\textcite{Verdoolaege2009equivalence} introduce \isl as a library
+for manipulating sets of integers defined by linear inequalities and
+integer divisions that is used in their equivalence checker.
+
+\item
+\textcite{Verdoolaege2010isl} provides a more detailed description
+of \isl at the time and still stands as the official reference for
+\isl.  However, many features were only added later on and one or
+more of the publications below may be more appropriate as
+a reference to these features.
+
+\item
+\textciteSection 5.1{Verdoolaege2010networks} provides some
+details on the dataflow analysis step, but also see
+\textciteChapter 6{Verdoolaege2016tutorial} and
+\textcite{Verdoolaege2016reordering} for a more recent treatment.
+
+\item The concepts of structured and named spaces and the manipulation
+of sets containing elements in different spaces were introduced
+by \textcite{Verdoolaege2011iscc}.
+
+\item The transitive closure operation is described
+by \textcite{Verdoolaege2011closure}.
+
+\item The scheduler is briefly described by
+\textciteSection 6.2{Verdoolaege2013PPCG} and
+\textciteSection 2.4{Verdoolaege2016reordering}.
+
+\item Schedule trees started out as ``trees of bands''
+\parenciteSection 6.2{Verdoolaege2013PPCG}, were formally
+introduced by \textcite{Verdoolaege2014impact}, and were
+slightly refined by \textcite{Grosser2015AST}.
+
+\item The coalescing operation is described by
+\textcite{Verdoolaege2015impact}.
+
+\item The AST generator is described by \textcite{Grosser2015AST}.
+
+\end{itemize}

_service:tar_scm:isl-0.14.tar.xz/doc/user.pod -> _service:tar_scm:isl-0.24.tar.gz/doc/user.pod Changed

@@ -196,7 +196,7 @@
 
 =item * The function C<isl_band_member_is_zero_distance>
 has been removed.  Essentially the same functionality is available
-through C<isl_band_member_is_coincident>, except that is requires
+through C<isl_band_member_is_coincident>, except that it requires
 setting up coincidence constraints.
 The option C<schedule_outer_zero_distance> has accordingly been
 replaced by the option C<schedule_outer_coincidence>.
@@ -208,6 +208,103 @@
 
 =back
 
+=head3 Changes since isl-0.14
+
+=over
+
+=item * The function C<isl_union_pw_multi_aff_add> now consistently
+computes the sum on the shared definition domain.
+The function C<isl_union_pw_multi_aff_union_add> has been added
+to compute the sum on the union of definition domains.
+The original behavior of C<isl_union_pw_multi_aff_add> was
+confused and is no longer available.
+
+=item * Band forests have been replaced by schedule trees.
+
+=item * The function C<isl_union_map_compute_flow> has been
+replaced by the function C<isl_union_access_info_compute_flow>.
+Note that the may dependence relation returned by
+C<isl_union_flow_get_may_dependence> is the union of
+the two dependence relations returned by
+C<isl_union_map_compute_flow>.  Similarly for the no source relations.
+The function C<isl_union_map_compute_flow> is still available
+for backward compatibility, but it will be removed in the future.
+
+=item * The function C<isl_basic_set_drop_constraint> has been
+deprecated.
+
+=item * The function C<isl_ast_build_ast_from_schedule> has been
+renamed to C<isl_ast_build_node_from_schedule_map>.
+The original name is still available
+for backward compatibility, but it will be removed in the future.
+
+=item * The C<separation_class> AST generation option has been
+deprecated.
+
+=item * The functions C<isl_equality_alloc> and C<isl_inequality_alloc>
+have been renamed to C<isl_constraint_alloc_equality> and
+C<isl_constraint_alloc_inequality>.  The original names have been
+kept for backward compatibility, but they will be removed in the future.
+
+=item * The C<schedule_fuse> option has been replaced
+by the C<schedule_serialize_sccs> option.  The effect
+of setting the C<schedule_fuse> option to C<ISL_SCHEDULE_FUSE_MIN>
+is now obtained by turning on the C<schedule_serialize_sccs> option.
+
+=back
+
+=head3 Changes since isl-0.17
+
+=over
+
+=item * The function C<isl_printer_print_ast_expr> no longer prints
+in C format by default.  To print in C format, the output format
+of the printer needs to have been explicitly set to C<ISL_FORMAT_C>.
+As a result, the function C<isl_ast_expr_to_str> no longer prints
+the expression in C format.  Use C<isl_ast_expr_to_C_str> instead.
+
+=item * The functions C<isl_set_align_divs> and C<isl_map_align_divs>
+have been deprecated.  The function C<isl_set_lift> has an effect
+that is similar to C<isl_set_align_divs> and could in some cases
+be used as an alternative.
+
+=back
+
+=head3 Changes since isl-0.19
+
+=over
+
+=item * Zero-dimensional objects of type C<isl_multi_pw_aff> or
+C<isl_multi_union_pw_aff> can now keep track of an explicit domain.
+This explicit domain, if present, is taken into account
+by various operations that take such objects as input.
+
+=back
+
+=head3 Changes since isl-0.20
+
+=over
+
+=item * Several functions that used to return C<unsigned>
+now return C<isl_size>.  This means that these functions may
+now return a negative value in case an error occurred.
+The same holds for functions that used to return C<int>,
+although some of those were already returning
+a negative value in case of error.
+
+=item * The C<isl_ast_op_type> enumeration type has been
+renamed to C<isl_ast_expr_op_type>.  The corresponding
+enumeration constants have been similarly renamed.
+The old names are defined to the new names for backward
+compatibility.
+
+=item * Several functions returning an extra boolean value
+through an C<int *> argument now do so through an C<isl_bool *>
+argument.  The returned values are the same, only the type
+of the pointer has been changed.
+
+=back
+
 =head1 License
 
 C<isl> is released under the MIT license.
@@ -238,14 +335,15 @@
 under the GNU Lesser General Public License (LGPL).  This means
 that code linked against C<isl> is also linked against LGPL code.
 
-When configuring with C<--with-int=imath>, C<isl> will link against C<imath>, a
-library for exact integer arithmetic released under the MIT license.
+When configuring with C<--with-int=imath> or C<--with-int=imath-32>, C<isl>
+will link against C<imath>, a library for exact integer arithmetic released
+under the MIT license.
 
 =head1 Installation
 
 The source of C<isl> can be obtained either as a tarball
 or from the git repository.  Both are available from
-L<http://freshmeat.net/projects/isl/>.
+L<http://isl.gforge.inria.fr/>.
 The installation process depends on how you obtained
 the source.
 
@@ -316,10 +414,13 @@
 
 Installation prefix for C<isl>
 
-=item C<--with-int=gmp|imath>
+=item C<--with-int=gmp|imath|imath-32>
 
 Select the integer library to be used by C<isl>, the default is C<gmp>.
-Note that C<isl> may run significantly slower if you use C<imath>.
+With C<imath-32>, C<isl> will use 32 bit integers, but fall back to C<imath>
+for values out of the 32 bit range. In most applications, C<isl> will run
+fastest with the C<imath-32> option, followed by C<gmp> and C<imath>, the
+slowest.
 
 =item C<--with-gmp-prefix>
 
@@ -343,46 +444,6 @@
 
 =head1 Integer Set Library
 
-=head2 Initialization
-
-All manipulations of integer sets and relations occur within
-the context of an C<isl_ctx>.
-A given C<isl_ctx> can only be used within a single thread.
-All arguments of a function are required to have been allocated
-within the same context.
-There are currently no functions available for moving an object
-from one C<isl_ctx> to another C<isl_ctx>.  This means that
-there is currently no way of safely moving an object from one
-thread to another, unless the whole C<isl_ctx> is moved.
-
-An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
-freed using C<isl_ctx_free>.
-All objects allocated within an C<isl_ctx> should be freed
-before the C<isl_ctx> itself is freed.
-
-	isl_ctx *isl_ctx_alloc();
-	void isl_ctx_free(isl_ctx *ctx);
-
-The user can impose a bound on the number of low-level I<operations>
-that can be performed by an C<isl_ctx>.  This bound can be set and
-retrieved using the following functions.  A bound of zero means that
-no bound is imposed.  The number of operations performed can be
-reset using C<isl_ctx_reset_operations>.  Note that the number
-of low-level operations needed to perform a high-level computation
-may differ significantly across different versions
-of C<isl>, but it should be the same across different platforms
-for the same version of C<isl>.
-
-Warning: This feature is experimental.  C<isl> has good support to abort and
-bail out during the computation, but this feature may exercise error code paths
-that are normally not used that much. Consequently, it is not unlikely that
-hidden bugs will be exposed.
-
-	void isl_ctx_set_max_operations(isl_ctx *ctx,
-		unsigned long max_operations);
-	unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
-	void isl_ctx_reset_operations(isl_ctx *ctx);
-
 =head2 Memory Management
 
 Since a high-level operation on isl objects usually involves
@@ -410,8 +471,10 @@
 In between, it can be used as a value for as many
 C<__isl_keep> arguments as the user likes.
 There is one exception, and that is the case where the
-pointer returned is C<NULL>.  Is this case, the user
+pointer returned is C<NULL>.  In this case, the user
 is free to use it as an C<__isl_take> argument or not.
+When applied to a C<char *>, the returned pointer needs to be
+freed using C<free>.
 
 =item C<__isl_null>
 
@@ -437,9 +500,186 @@
 can still use it as an argument to other functions.
 A C<NULL> value will be treated in the same way as
 a C<NULL> value for an C<__isl_take> argument.
+This annotation may also be used on return values of
+type C<const char *>, in which case the returned pointer should
+not be freed by the user and is only valid until the object
+from which it was derived is updated or freed.
 
 =back
 
+=head2 Initialization
+
+All manipulations of integer sets and relations occur within
+the context of an C<isl_ctx>.
+A given C<isl_ctx> can only be used within a single thread.
+All arguments of a function are required to have been allocated
+within the same context.
+There are currently no functions available for moving an object
+from one C<isl_ctx> to another C<isl_ctx>.  This means that
+there is currently no way of safely moving an object from one
+thread to another, unless the whole C<isl_ctx> is moved.
+
+An C<isl_ctx> can be allocated using C<isl_ctx_alloc> and
+freed using C<isl_ctx_free>.
+All objects allocated within an C<isl_ctx> should be freed
+before the C<isl_ctx> itself is freed.
+
+	isl_ctx *isl_ctx_alloc();
+	void isl_ctx_free(isl_ctx *ctx);
+
+The user can impose a bound on the number of low-level I<operations>
+that can be performed by an C<isl_ctx>.  This bound can be set and
+retrieved using the following functions.  A bound of zero means that
+no bound is imposed.  The number of operations performed can be
+reset using C<isl_ctx_reset_operations>.  Note that the number
+of low-level operations needed to perform a high-level computation
+may differ significantly across different versions
+of C<isl>, but it should be the same across different platforms
+for the same version of C<isl>.
+
+Warning: This feature is experimental.  C<isl> has good support to abort and
+bail out during the computation, but this feature may exercise error code paths
+that are normally not used that much. Consequently, it is not unlikely that
+hidden bugs will be exposed.
+
+	void isl_ctx_set_max_operations(isl_ctx *ctx,
+		unsigned long max_operations);
+	unsigned long isl_ctx_get_max_operations(isl_ctx *ctx);
+	void isl_ctx_reset_operations(isl_ctx *ctx);
+
+In order to be able to create an object in the same context
+as another object, most object types (described later in
+this document) provide a function to obtain the context
+in which the object was created.
+
+	#include <isl/val.h>
+	isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
+	isl_ctx *isl_multi_val_get_ctx(
+		__isl_keep isl_multi_val *mv);
+
+	#include <isl/id.h>
+	isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
+	isl_ctx *isl_multi_id_get_ctx(
+		__isl_keep isl_multi_id *mi);
+
+	#include <isl/local_space.h>
+	isl_ctx *isl_local_space_get_ctx(
+		__isl_keep isl_local_space *ls);
+
+	#include <isl/set.h>
+	isl_ctx *isl_set_list_get_ctx(
+		__isl_keep isl_set_list *list);
+
+	#include <isl/aff.h>
+	isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
+	isl_ctx *isl_multi_aff_get_ctx(
+		__isl_keep isl_multi_aff *maff);
+	isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pa);
+	isl_ctx *isl_pw_multi_aff_get_ctx(
+		__isl_keep isl_pw_multi_aff *pma);
+	isl_ctx *isl_multi_pw_aff_get_ctx(
+		__isl_keep isl_multi_pw_aff *mpa);
+	isl_ctx *isl_union_pw_aff_get_ctx(
+		__isl_keep isl_union_pw_aff *upa);
+	isl_ctx *isl_union_pw_multi_aff_get_ctx(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	isl_ctx *isl_multi_union_pw_aff_get_ctx(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+	#include <isl/id_to_ast_expr.h>
+	isl_ctx *isl_id_to_ast_expr_get_ctx(
+		__isl_keep isl_id_to_ast_expr *id2expr);
+
+	#include <isl/point.h>
+	isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
+
+	#include <isl/vec.h>
+	isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
+
+	#include <isl/mat.h>
+	isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
+
+	#include <isl/vertices.h>
+	isl_ctx *isl_vertices_get_ctx(
+		__isl_keep isl_vertices *vertices);
+	isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
+	isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
+
+	#include <isl/flow.h>
+	isl_ctx *isl_restriction_get_ctx(
+		__isl_keep isl_restriction *restr);
+	isl_ctx *isl_union_access_info_get_ctx(
+		__isl_keep isl_union_access_info *access);
+	isl_ctx *isl_union_flow_get_ctx(
+		__isl_keep isl_union_flow *flow);
+
+	#include <isl/schedule.h>
+	isl_ctx *isl_schedule_get_ctx(
+		__isl_keep isl_schedule *sched);
+	isl_ctx *isl_schedule_constraints_get_ctx(
+		__isl_keep isl_schedule_constraints *sc);
+
+	#include <isl/schedule_node.h>
+	isl_ctx *isl_schedule_node_get_ctx(
+		__isl_keep isl_schedule_node *node);
+
+	#include <isl/ast_build.h>
+	isl_ctx *isl_ast_build_get_ctx(
+		__isl_keep isl_ast_build *build);
+
+	#include <isl/ast.h>
+	isl_ctx *isl_ast_expr_get_ctx(
+		__isl_keep isl_ast_expr *expr);
+	isl_ctx *isl_ast_node_get_ctx(
+		__isl_keep isl_ast_node *node);
+
+	#include <isl/stride_info.h>
+	isl_ctx *isl_stride_info_get_ctx(
+		__isl_keep isl_stride_info *si);
+
+	#include <isl/fixed_box.h>
+	isl_ctx *isl_fixed_box_get_ctx(
+		__isl_keep isl_fixed_box *box);
+
+=head2 Return Types
+
+C<isl> uses the special return type C<isl_size> for functions
+that return a non-negative value, typically a number or a position.
+Besides the regular non-negative return values, a special (negative)
+value C<isl_size_error> may be returned, indicating that something
+went wrong.
+
+C<isl> also uses two special return types for functions that either return
+a boolean or that in principle do not return anything.
+In particular, the C<isl_bool> type has three possible values:
+C<isl_bool_true> (a positive integer value), indicating I<true> or I<yes>;
+C<isl_bool_false> (the integer value zero), indicating I<false> or I<no>; and
+C<isl_bool_error> (a negative integer value), indicating that something
+went wrong.  The following operations are defined on C<isl_bool>. The function
+C<isl_bool_not> can be used to negate an C<isl_bool>, where the negation of
+C<isl_bool_error> is C<isl_bool_error> again. The function C<isl_bool_ok>
+converts an integer to an C<isl_bool>. Any non-zero values yields
+C<isl_bool_true> and zero yields C<isl_bool_false>.
+
+	#include <isl/ctx.h>
+	isl_bool isl_bool_not(isl_bool b);
+	isl_bool isl_bool_ok(int b);
+
+The C<isl_stat> type has two possible values:
+C<isl_stat_ok> (the integer value zero), indicating a successful
+operation; and
+C<isl_stat_error> (a negative integer value), indicating that something
+went wrong.
+The function C<isl_stat_non_null> converts an isl object pointer
+to an C<isl_stat>, returning C<isl_stat_ok> if the object pointer is valid and
+C<isl_stat_error> if it is C<NULL>.
+
+	#include <isl/ctx.h>
+	isl_stat isl_stat_non_null(void *obj);
+
+See L</"Error Handling"> for more information on
+C<isl_size_error>, C<isl_bool_error> and C<isl_stat_error>.
+
 =head2 Values
 
 An C<isl_val> represents an integer value, a rational value
@@ -477,13 +717,14 @@
 They can be inspected using the following functions.
 
 	#include <isl/val.h>
-	isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
 	long isl_val_get_num_si(__isl_keep isl_val *v);
 	long isl_val_get_den_si(__isl_keep isl_val *v);
+	__isl_give isl_val *isl_val_get_den_val(
+		__isl_keep isl_val *v);
 	double isl_val_get_d(__isl_keep isl_val *v);
-	size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
+	isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v,
 		size_t size);
-	int isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
+	isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v,
 		size_t size, void *chunks);
 
 C<isl_val_n_abs_num_chunks> returns the number of I<digits>
@@ -506,47 +747,59 @@
 
 	#include <isl/val.h>
 	int isl_val_sgn(__isl_keep isl_val *v);
-	int isl_val_is_zero(__isl_keep isl_val *v);
-	int isl_val_is_one(__isl_keep isl_val *v);
-	int isl_val_is_negone(__isl_keep isl_val *v);
-	int isl_val_is_nonneg(__isl_keep isl_val *v);
-	int isl_val_is_nonpos(__isl_keep isl_val *v);
-	int isl_val_is_pos(__isl_keep isl_val *v);
-	int isl_val_is_neg(__isl_keep isl_val *v);
-	int isl_val_is_int(__isl_keep isl_val *v);
-	int isl_val_is_rat(__isl_keep isl_val *v);
-	int isl_val_is_nan(__isl_keep isl_val *v);
-	int isl_val_is_infty(__isl_keep isl_val *v);
-	int isl_val_is_neginfty(__isl_keep isl_val *v);
+	isl_bool isl_val_is_zero(__isl_keep isl_val *v);
+	isl_bool isl_val_is_one(__isl_keep isl_val *v);
+	isl_bool isl_val_is_negone(__isl_keep isl_val *v);
+	isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
+	isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
+	isl_bool isl_val_is_pos(__isl_keep isl_val *v);
+	isl_bool isl_val_is_neg(__isl_keep isl_val *v);
+	isl_bool isl_val_is_int(__isl_keep isl_val *v);
+	isl_bool isl_val_is_rat(__isl_keep isl_val *v);
+	isl_bool isl_val_is_nan(__isl_keep isl_val *v);
+	isl_bool isl_val_is_infty(__isl_keep isl_val *v);
+	isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);
 
 Note that the sign of NaN is undefined.
 
 The following binary properties are defined on pairs of C<isl_val>s.
 
 	#include <isl/val.h>
-	int isl_val_lt(__isl_keep isl_val *v1,
+	isl_bool isl_val_lt(__isl_keep isl_val *v1,
+		__isl_keep isl_val *v2);
+	isl_bool isl_val_le(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
-	int isl_val_le(__isl_keep isl_val *v1,
+	isl_bool isl_val_gt(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
-	int isl_val_gt(__isl_keep isl_val *v1,
+	isl_bool isl_val_ge(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
-	int isl_val_ge(__isl_keep isl_val *v1,
+	isl_bool isl_val_eq(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
-	int isl_val_eq(__isl_keep isl_val *v1,
+	isl_bool isl_val_ne(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
-	int isl_val_ne(__isl_keep isl_val *v1,
+	isl_bool isl_val_abs_eq(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
 
+Comparisons to NaN always return false.
+That is, a NaN is not considered to hold any relative position
+with respect to any value.  In particular, a NaN
+is neither considered to be equal to nor to be different from
+any value (including another NaN).
+The function C<isl_val_abs_eq> checks whether its two arguments
+are equal in absolute value.
+
 For integer C<isl_val>s we additionally have the following binary property.
 
 	#include <isl/val.h>
-	int isl_val_is_divisible_by(__isl_keep isl_val *v1,
+	isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
 		__isl_keep isl_val *v2);
 
 An C<isl_val> can also be compared to an integer using the following
-function.  The result is undefined for NaN.
+functions.  The result of C<isl_val_cmp_si> is undefined for NaN.
 
 	#include <isl/val.h>
+	isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
+	isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);
 	int isl_val_cmp_si(__isl_keep isl_val *v, long i);
 
 The following unary operations are available on C<isl_val>s.
@@ -557,7 +810,7 @@
 	__isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
 	__isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
 	__isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
-	__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
+	__isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
 
 The following binary operations are available on C<isl_val>s.
 
@@ -580,10 +833,13 @@
 		unsigned long v2);
 	__isl_give isl_val *isl_val_div(__isl_take isl_val *v1,
 		__isl_take isl_val *v2);
+	__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1,
+		unsigned long v2);
 
 On integer values, we additionally have the following operations.
 
 	#include <isl/val.h>
+	__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);
 	__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
 	__isl_give isl_val *isl_val_mod(__isl_take isl_val *v1,
 		__isl_take isl_val *v2);
@@ -593,22 +849,11 @@
 		__isl_take isl_val *v2, __isl_give isl_val **x,
 		__isl_give isl_val **y);
 
+C<isl_val_2exp> is an alternative name for C<isl_val_pow2>.
 The function C<isl_val_gcdext> returns the greatest common divisor g
 of C<v1> and C<v2> as well as two integers C<*x> and C<*y> such
 that C<*x> * C<v1> + C<*y> * C<v2> = g.
 
-A value can be read from input using
-
-	#include <isl/val.h>
-	__isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
-		const char *str);
-
-A value can be printed using
-
-	#include <isl/val.h>
-	__isl_give isl_printer *isl_printer_print_val(
-		__isl_take isl_printer *p, __isl_keep isl_val *v);
-
 =head3 GMP specific functions
 
 These functions are only available if C<isl> has been compiled with C<GMP>
@@ -657,17 +902,31 @@
 
 The default behavior is to warn. In this mode, C<isl> prints a warning, stores
 the last error in the corresponding C<isl_ctx> and the function in which the
-error was triggered returns C<NULL>. An error does not corrupt internal state,
+error was triggered returns a value indicating that some error has
+occurred.  In case of functions returning a pointer, this value is
+C<NULL>.  In case of functions returning an C<isl_size>, C<isl_bool> or an
+C<isl_stat>, this value is C<isl_size_error>,
+C<isl_bool_error> or C<isl_stat_error>.
+An error does not corrupt internal state,
 such that isl can continue to be used. C<isl> also provides functions to
-read the last error and to reset the memory that stores the last error. The
+read the last error, including the specific error message,
+the isl source file where the error occurred and the line number,
+and to reset all information about the last error. The
 last error is only stored for information purposes. Its presence does not
 change the behavior of C<isl>. Hence, resetting an error is not required to
 continue to use isl, but only to observe new errors.
 
 	#include <isl/ctx.h>
 	enum isl_error isl_ctx_last_error(isl_ctx *ctx);
+	const char *isl_ctx_last_error_msg(isl_ctx *ctx);
+	const char *isl_ctx_last_error_file(isl_ctx *ctx);
+	int isl_ctx_last_error_line(isl_ctx *ctx);
 	void isl_ctx_reset_error(isl_ctx *ctx);
 
+If no error has occurred since the last call to C<isl_ctx_reset_error>,
+then the functions C<isl_ctx_last_error_msg> and
+C<isl_ctx_last_error_file> return C<NULL>.
+
 Another option is to continue on error. This is similar to warn on error mode,
 except that C<isl> does not print any warning. This allows a program to
 implement its own error reporting.
@@ -688,7 +947,7 @@
 It is also possible to query the current error mode.
 
 	#include <isl/options.h>
-	int isl_options_set_on_error(isl_ctx *ctx, int val);
+	isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
 	int isl_options_get_on_error(isl_ctx *ctx);
 
 =head2 Identifiers
@@ -711,11 +970,10 @@
 		__isl_keep const char *name, void *user);
 	__isl_give isl_id *isl_id_set_free_user(
 		__isl_take isl_id *id,
-		__isl_give void (*free_user)(void *user));
+		void (*free_user)(void *user));
 	__isl_give isl_id *isl_id_copy(isl_id *id);
 	__isl_null isl_id *isl_id_free(__isl_take isl_id *id);
 
-	isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
 	void *isl_id_get_user(__isl_keep isl_id *id);
 	__isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
 
@@ -749,6 +1007,7 @@
 parameters is discouraged.
 
 	#include <isl/space.h>
+	__isl_give isl_space *isl_space_unit(isl_ctx *ctx);
 	__isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
 		unsigned nparam, unsigned n_in, unsigned n_out);
 	__isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx,
@@ -757,40 +1016,41 @@
 		unsigned nparam, unsigned dim);
 	__isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
 	__isl_null isl_space *isl_space_free(__isl_take isl_space *space);
-	unsigned isl_space_dim(__isl_keep isl_space *space,
-		enum isl_dim_type type);
 
 The space used for creating a parameter domain
-needs to be created using C<isl_space_params_alloc>.
+needs to be created using C<isl_space_unit> or C<isl_space_params_alloc>.
 For other sets, the space
 needs to be created using C<isl_space_set_alloc>, while
 for a relation, the space
 needs to be created using C<isl_space_alloc>.
-C<isl_space_dim> can be used
-to find out the number of dimensions of each type in
-a space, where type may be
-C<isl_dim_param>, C<isl_dim_in> (only for relations),
-C<isl_dim_out> (only for relations), C<isl_dim_set>
-(only for sets) or C<isl_dim_all>.
+The use of C<isl_space_params_alloc>,
+C<isl_space_set_alloc> and C<isl_space_alloc> is discouraged as they allow
+for the introduction of unnamed parameters.
 
 To check whether a given space is that of a set or a map
 or whether it is a parameter space, use these functions:
 
 	#include <isl/space.h>
-	int isl_space_is_params(__isl_keep isl_space *space);
-	int isl_space_is_set(__isl_keep isl_space *space);
-	int isl_space_is_map(__isl_keep isl_space *space);
+	isl_bool isl_space_is_params(__isl_keep isl_space *space);
+	isl_bool isl_space_is_set(__isl_keep isl_space *space);
+	isl_bool isl_space_is_map(__isl_keep isl_space *space);
 
 Spaces can be compared using the following functions:
 
 	#include <isl/space.h>
-	int isl_space_is_equal(__isl_keep isl_space *space1,
+	isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
 		__isl_keep isl_space *space2);
-	int isl_space_is_domain(__isl_keep isl_space *space1,
+	isl_bool isl_space_has_equal_params(
+		__isl_keep isl_space *space1,
+		__isl_keep isl_space *space2);
+	isl_bool isl_space_has_equal_tuples(
+		__isl_keep isl_space *space1,
 		__isl_keep isl_space *space2);
-	int isl_space_is_range(__isl_keep isl_space *space1,
+	isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
 		__isl_keep isl_space *space2);
-	int isl_space_tuple_is_equal(
+	isl_bool isl_space_is_range(__isl_keep isl_space *space1,
+		__isl_keep isl_space *space2);
+	isl_bool isl_space_tuple_is_equal(
 		__isl_keep isl_space *space1,
 		enum isl_dim_type type1,
 		__isl_keep isl_space *space2,
@@ -804,12 +1064,25 @@
 spaces are the same.  That is, it checks if they have the same
 identifier (if any), the same dimension and the same internal structure
 (if any).
+The function
+C<isl_space_has_equal_params> checks whether two spaces
+have the same parameters in the same order.
+C<isl_space_has_equal_tuples> check whether two spaces have
+the same tuples.  In contrast to C<isl_space_is_equal> below,
+it does not check the
+parameters.  This is useful because many C<isl> functions align the
+parameters before they perform their operations, such that equivalence
+is not necessary.
+C<isl_space_is_equal> checks whether two spaces are identical,
+meaning that they have the same parameters and the same tuples.
+That is, it checks whether both C<isl_space_has_equal_params> and
+C<isl_space_has_equal_tuples> hold.
 
 It is often useful to create objects that live in the
 same space as some other object.  This can be accomplished
 by creating the new objects
 (see L</"Creating New Sets and Relations"> or
-L</"Creating New (Piecewise) Quasipolynomials">) based on the space
+L</"Functions">) based on the space
 of the original object.
 
 	#include <isl/set.h>
@@ -839,6 +1112,9 @@
 		__isl_keep isl_qpolynomial *qp);
 	__isl_give isl_space *isl_qpolynomial_get_space(
 		__isl_keep isl_qpolynomial *qp);
+	__isl_give isl_space *
+	isl_qpolynomial_fold_get_domain_space(
+		__isl_keep isl_qpolynomial_fold *fold);
 	__isl_give isl_space *isl_qpolynomial_fold_get_space(
 		__isl_keep isl_qpolynomial_fold *fold);
 	__isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
@@ -854,6 +1130,10 @@
 	__isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
 		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
 
+	#include <isl/id.h>
+	__isl_give isl_space *isl_multi_id_get_space(
+		__isl_keep isl_multi_id *mi);
+
 	#include <isl/val.h>
 	__isl_give isl_space *isl_multi_val_get_space(
 		__isl_keep isl_multi_val *mv);
@@ -875,26 +1155,140 @@
 		__isl_keep isl_pw_multi_aff *pma);
 	__isl_give isl_space *isl_pw_multi_aff_get_space(
 		__isl_keep isl_pw_multi_aff *pma);
+	__isl_give isl_space *isl_union_pw_aff_get_space(
+		__isl_keep isl_union_pw_aff *upa);
 	__isl_give isl_space *isl_union_pw_multi_aff_get_space(
 		__isl_keep isl_union_pw_multi_aff *upma);
 	__isl_give isl_space *isl_multi_pw_aff_get_domain_space(
 		__isl_keep isl_multi_pw_aff *mpa);
 	__isl_give isl_space *isl_multi_pw_aff_get_space(
 		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_give isl_space *
+	isl_multi_union_pw_aff_get_domain_space(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+	__isl_give isl_space *
+	isl_multi_union_pw_aff_get_space(
+		__isl_keep isl_multi_union_pw_aff *mupa);
 
 	#include <isl/point.h>
 	__isl_give isl_space *isl_point_get_space(
 		__isl_keep isl_point *pnt);
 
-The identifiers or names of the individual dimensions may be set or read off
-using the following functions.
+	#include <isl/fixed_box.h>
+	__isl_give isl_space *isl_fixed_box_get_space(
+		__isl_keep isl_fixed_box *box);
+
+The number of dimensions of a given type of space
+may be read off from a space or an object that lives
+in a space using the following functions.
+In case of C<isl_space_dim>, type may be
+C<isl_dim_param>, C<isl_dim_in> (only for relations),
+C<isl_dim_out> (only for relations), C<isl_dim_set>
+(only for sets) or C<isl_dim_all>.
+
+	#include <isl/space.h>
+	isl_size isl_space_dim(__isl_keep isl_space *space,
+		enum isl_dim_type type);
+
+	#include <isl/local_space.h>
+	isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
+		enum isl_dim_type type);
+
+	#include <isl/set.h>
+	isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
+		enum isl_dim_type type);
+	isl_size isl_set_dim(__isl_keep isl_set *set,
+		enum isl_dim_type type);
+
+	#include <isl/union_set.h>
+	isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
+		enum isl_dim_type type);
+
+	#include <isl/map.h>
+	isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type);
+	isl_size isl_map_dim(__isl_keep isl_map *map,
+		enum isl_dim_type type);
+
+	#include <isl/union_map.h>
+	isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
+		enum isl_dim_type type);
+
+	#include <isl/val.h>
+	isl_size isl_multi_val_dim(__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type);
+
+	#include <isl/aff.h>
+	isl_size isl_aff_dim(__isl_keep isl_aff *aff,
+		enum isl_dim_type type);
+	isl_size isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
+		enum isl_dim_type type);
+	isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
+		enum isl_dim_type type);
+	isl_size isl_pw_multi_aff_dim(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	isl_size isl_multi_pw_aff_dim(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type);
+	isl_size isl_union_pw_aff_dim(
+		__isl_keep isl_union_pw_aff *upa,
+		enum isl_dim_type type);
+	isl_size isl_union_pw_multi_aff_dim(
+		__isl_keep isl_union_pw_multi_aff *upma,
+		enum isl_dim_type type);
+	isl_size isl_multi_union_pw_aff_dim(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type);
+
+	#include <isl/polynomial.h>
+	isl_size isl_union_pw_qpolynomial_dim(
+		__isl_keep isl_union_pw_qpolynomial *upwqp,
+		enum isl_dim_type type);
+	isl_size isl_union_pw_qpolynomial_fold_dim(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+		enum isl_dim_type type);
+
+Note that an C<isl_union_set>, an C<isl_union_map>,
+an C<isl_union_pw_multi_aff>,
+an C<isl_union_pw_qpolynomial> and
+an C<isl_union_pw_qpolynomial_fold>
+only have parameters.
+
+Additional parameters can be added to a space using the following function.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_add_param_id(
+		__isl_take isl_space *space,
+		__isl_take isl_id *id);
+
+If a parameter with the given identifier already appears in the space,
+then it is not added again.
+
+Conversely, all parameters can be removed from a space
+using the following function.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_drop_all_params(
+		__isl_take isl_space *space);
+
+The identifiers or names of the individual dimensions of spaces
+may be set or read off using the following functions on spaces
+or objects that live in spaces.
+These functions are mostly useful to obtain the identifiers, positions
+or names of the parameters.  Identifiers of individual dimensions are
+essentially only useful for printing.  They are ignored by all other
+operations and may not be preserved across those operations.
+To keep track of a space along with names/identifiers of
+the set dimensions, use an C<isl_multi_id> as described in
+L</"Functions">.
 
 	#include <isl/space.h>
 	__isl_give isl_space *isl_space_set_dim_id(
 		__isl_take isl_space *space,
 		enum isl_dim_type type, unsigned pos,
 		__isl_take isl_id *id);
-	int isl_space_has_dim_id(__isl_keep isl_space *space,
+	isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
 		enum isl_dim_type type, unsigned pos);
 	__isl_give isl_id *isl_space_get_dim_id(
 		__isl_keep isl_space *space,
@@ -903,12 +1297,194 @@
 		__isl_take isl_space *space,
 		 enum isl_dim_type type, unsigned pos,
 		 __isl_keep const char *name);
-	int isl_space_has_dim_name(__isl_keep isl_space *space,
+	isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
 		enum isl_dim_type type, unsigned pos);
 	__isl_keep const char *isl_space_get_dim_name(
 		__isl_keep isl_space *space,
 		enum isl_dim_type type, unsigned pos);
 
+	#include <isl/local_space.h>
+	__isl_give isl_local_space *isl_local_space_set_dim_id(
+		__isl_take isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	isl_bool isl_local_space_has_dim_id(
+		__isl_keep isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_local_space_get_dim_id(
+		__isl_keep isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_local_space *isl_local_space_set_dim_name(
+		__isl_take isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos, const char *s);
+	isl_bool isl_local_space_has_dim_name(
+		__isl_keep isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos)
+	const char *isl_local_space_get_dim_name(
+		__isl_keep isl_local_space *ls,
+		enum isl_dim_type type, unsigned pos);
+
+	#include <isl/constraint.h>
+	const char *isl_constraint_get_dim_name(
+		__isl_keep isl_constraint *constraint,
+		enum isl_dim_type type, unsigned pos);
+
+	#include <isl/set.h>
+	__isl_give isl_id *isl_basic_set_get_dim_id(
+		__isl_keep isl_basic_set *bset,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_set *isl_set_set_dim_id(
+		__isl_take isl_set *set, enum isl_dim_type type,
+		unsigned pos, __isl_take isl_id *id);
+	isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_set_get_dim_id(
+		__isl_keep isl_set *set, enum isl_dim_type type,
+		unsigned pos);
+	const char *isl_basic_set_get_dim_name(
+		__isl_keep isl_basic_set *bset,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+	const char *isl_set_get_dim_name(
+		__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_set_dim_id(
+		__isl_take isl_map *map, enum isl_dim_type type,
+		unsigned pos, __isl_take isl_id *id);
+	isl_bool isl_basic_map_has_dim_id(
+		__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_map_get_dim_id(
+		__isl_keep isl_map *map, enum isl_dim_type type,
+		unsigned pos);
+	__isl_give isl_id *isl_union_map_get_dim_id(
+		__isl_keep isl_union_map *umap,
+		enum isl_dim_type type, unsigned pos);
+	const char *isl_basic_map_get_dim_name(
+		__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
+		enum isl_dim_type type, unsigned pos);
+	const char *isl_map_get_dim_name(
+		__isl_keep isl_map *map,
+		enum isl_dim_type type, unsigned pos);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_set_dim_id(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	__isl_give isl_id *isl_multi_val_get_dim_id(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_multi_val *isl_multi_val_set_dim_name(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, unsigned pos, const char *s);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_set_dim_id(
+		__isl_take isl_aff *aff, enum isl_dim_type type,
+		unsigned pos, __isl_take isl_id *id);
+	__isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
+		__isl_take isl_multi_aff *maff,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	__isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
+		__isl_take isl_pw_aff *pma,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_set_dim_id(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_dim_id(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_id *id);
+	__isl_give isl_id *isl_multi_aff_get_dim_id(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_pw_aff_get_dim_id(
+		__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_pw_multi_aff_get_dim_id(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_multi_pw_aff_get_dim_id(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_id *isl_multi_union_pw_aff_get_dim_id(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_aff *isl_aff_set_dim_name(
+		__isl_take isl_aff *aff, enum isl_dim_type type,
+		unsigned pos, const char *s);
+	__isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
+		__isl_take isl_multi_aff *maff,
+		enum isl_dim_type type, unsigned pos, const char *s);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_set_dim_name(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned pos, const char *s);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_set_dim_name(
+		__isl_take isl_union_pw_aff *upa,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_set_dim_name(
+		__isl_take isl_union_pw_multi_aff *upma,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_dim_name(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
+		enum isl_dim_type type, unsigned pos);
+	const char *isl_pw_aff_get_dim_name(
+		__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type, unsigned pos);
+	const char *isl_pw_multi_aff_get_dim_name(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type, unsigned pos);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
+		__isl_take isl_qpolynomial *qp,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_set_dim_name(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_set_dim_name(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_set_dim_name(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_set_dim_name(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		enum isl_dim_type type, unsigned pos,
+		const char *s);
+
 Note that C<isl_space_get_name> returns a pointer to some internal
 data structure, so the result can only be used while the
 corresponding C<isl_space> is alive.
@@ -922,7 +1498,7 @@
 the arguments.
 
 Given the identifier or name of a dimension (typically a parameter),
-its position can be obtained from the following function.
+its position can be obtained from the following functions.
 
 	#include <isl/space.h>
 	int isl_space_find_dim_by_id(__isl_keep isl_space *space,
@@ -930,25 +1506,345 @@
 	int isl_space_find_dim_by_name(__isl_keep isl_space *space,
 		enum isl_dim_type type, const char *name);
 
+	#include <isl/local_space.h>
+	int isl_local_space_find_dim_by_name(
+		__isl_keep isl_local_space *ls,
+		enum isl_dim_type type, const char *name);
+
+	#include <isl/val.h>
+	int isl_multi_val_find_dim_by_id(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_multi_val_find_dim_by_name(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type, const char *name);
+
+	#include <isl/set.h>
+	int isl_set_find_dim_by_id(__isl_keep isl_set *set,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_set_find_dim_by_name(__isl_keep isl_set *set,
+		enum isl_dim_type type, const char *name);
+
+	#include <isl/map.h>
+	int isl_map_find_dim_by_id(__isl_keep isl_map *map,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_basic_map_find_dim_by_name(
+		__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type, const char *name);
+	int isl_map_find_dim_by_name(__isl_keep isl_map *map,
+		enum isl_dim_type type, const char *name);
+	int isl_union_map_find_dim_by_name(
+		__isl_keep isl_union_map *umap,
+		enum isl_dim_type type, const char *name);
+
+	#include <isl/aff.h>
+	int isl_multi_aff_find_dim_by_id(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_multi_pw_aff_find_dim_by_id(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_multi_union_pw_aff_find_dim_by_id(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, __isl_keep isl_id *id);
+	int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff,
+		enum isl_dim_type type, const char *name);
+	int isl_multi_aff_find_dim_by_name(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type, const char *name);
+	int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type, const char *name);
+	int isl_multi_pw_aff_find_dim_by_name(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, const char *name);
+	int isl_pw_multi_aff_find_dim_by_name(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type, const char *name);
+	int isl_union_pw_aff_find_dim_by_name(
+		__isl_keep isl_union_pw_aff *upa,
+		enum isl_dim_type type, const char *name);
+	int isl_union_pw_multi_aff_find_dim_by_name(
+		__isl_keep isl_union_pw_multi_aff *upma,
+		enum isl_dim_type type, const char *name);
+	int isl_multi_union_pw_aff_find_dim_by_name(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, const char *name);
+
+	#include <isl/polynomial.h>
+	int isl_pw_qpolynomial_find_dim_by_name(
+		__isl_keep isl_pw_qpolynomial *pwqp,
+		enum isl_dim_type type, const char *name);
+	int isl_pw_qpolynomial_fold_find_dim_by_name(
+		__isl_keep isl_pw_qpolynomial_fold *pwf,
+		enum isl_dim_type type, const char *name);
+	int isl_union_pw_qpolynomial_find_dim_by_name(
+		__isl_keep isl_union_pw_qpolynomial *upwqp,
+		enum isl_dim_type type, const char *name);
+	int isl_union_pw_qpolynomial_fold_find_dim_by_name(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+		enum isl_dim_type type, const char *name);
+
 The identifiers or names of entire spaces may be set or read off
 using the following functions.
 
 	#include <isl/space.h>
+	__isl_give isl_space *isl_space_set_domain_tuple_id(
+		__isl_take isl_space *space,
+		__isl_take isl_id *id);
+	__isl_give isl_space *isl_space_set_range_tuple_id(
+		__isl_take isl_space *space,
+		__isl_take isl_id *id);
 	__isl_give isl_space *isl_space_set_tuple_id(
 		__isl_take isl_space *space,
 		enum isl_dim_type type, __isl_take isl_id *id);
 	__isl_give isl_space *isl_space_reset_tuple_id(
 		__isl_take isl_space *space, enum isl_dim_type type);
-	int isl_space_has_tuple_id(__isl_keep isl_space *space,
+	isl_bool isl_space_has_domain_tuple_id(
+		__isl_keep isl_space *space);
+	isl_bool isl_space_has_range_tuple_id(
+		__isl_keep isl_space *space);
+	isl_bool isl_space_has_tuple_id(
+		__isl_keep isl_space *space,
 		enum isl_dim_type type);
+	__isl_give isl_id *isl_space_get_domain_tuple_id(
+		__isl_keep isl_space *space);
+	__isl_give isl_id *isl_space_get_range_tuple_id(
+		__isl_keep isl_space *space);
 	__isl_give isl_id *isl_space_get_tuple_id(
 		__isl_keep isl_space *space, enum isl_dim_type type);
 	__isl_give isl_space *isl_space_set_tuple_name(
 		__isl_take isl_space *space,
 		enum isl_dim_type type, const char *s);
-	int isl_space_has_tuple_name(__isl_keep isl_space *space,
+	isl_bool isl_space_has_tuple_name(
+		__isl_keep isl_space *space,
 		enum isl_dim_type type);
-	const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
+	__isl_keep const char *isl_space_get_tuple_name(
+		__isl_keep isl_space *space,
+		enum isl_dim_type type);
+
+	#include <isl/local_space.h>
+	__isl_give isl_local_space *isl_local_space_set_tuple_id(
+		__isl_take isl_local_space *ls,
+		enum isl_dim_type type, __isl_take isl_id *id);
+
+	#include <isl/set.h>
+	__isl_give isl_basic_set *isl_basic_set_set_tuple_id(
+		__isl_take isl_basic_set *bset,
+		__isl_take isl_id *id);
+	__isl_give isl_set *isl_set_set_tuple_id(
+		__isl_take isl_set *set, __isl_take isl_id *id);
+	__isl_give isl_set *isl_set_reset_tuple_id(
+		__isl_take isl_set *set);
+	isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
+	__isl_give isl_id *isl_set_get_tuple_id(
+		__isl_keep isl_set *set);
+	__isl_give isl_basic_set *isl_basic_set_set_tuple_name(
+		__isl_take isl_basic_set *set, const char *s);
+	__isl_give isl_set *isl_set_set_tuple_name(
+		__isl_take isl_set *set, const char *s);
+	const char *isl_basic_set_get_tuple_name(
+		__isl_keep isl_basic_set *bset);
+	isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
+	const char *isl_set_get_tuple_name(
+		__isl_keep isl_set *set);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_map *isl_map_set_domain_tuple_id(
+		__isl_take isl_map *map, __isl_take isl_id *id);
+	__isl_give isl_map *isl_map_set_range_tuple_id(
+		__isl_take isl_map *map, __isl_take isl_id *id);
+	__isl_give isl_map *isl_map_set_tuple_id(
+		__isl_take isl_map *map, enum isl_dim_type type,
+		__isl_take isl_id *id);
+	__isl_give isl_map *isl_map_reset_tuple_id(
+		__isl_take isl_map *map, enum isl_dim_type type);
+	isl_bool isl_map_has_domain_tuple_id(
+		__isl_keep isl_map *map);
+	isl_bool isl_map_has_range_tuple_id(
+		__isl_keep isl_map *map);
+	isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_map_get_domain_tuple_id(
+		__isl_keep isl_map *map);
+	__isl_give isl_id *isl_map_get_range_tuple_id(
+		__isl_keep isl_map *map);
+	__isl_give isl_id *isl_map_get_tuple_id(
+		__isl_keep isl_map *map, enum isl_dim_type type);
+	__isl_give isl_map *isl_map_set_tuple_name(
+		__isl_take isl_map *map,
+		enum isl_dim_type type, const char *s);
+	const char *isl_basic_map_get_tuple_name(
+		__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type);
+	__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, const char *s);
+	isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
+		enum isl_dim_type type);
+	const char *isl_map_get_tuple_name(
+		__isl_keep isl_map *map,
+		enum isl_dim_type type);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_set_range_tuple_id(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_val *isl_multi_val_set_tuple_id(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_multi_val *
+	isl_multi_val_reset_range_tuple_id(
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type);
+	isl_bool isl_multi_val_has_range_tuple_id(
+		__isl_keep isl_multi_val *mv);
+	__isl_give isl_id *isl_multi_val_get_range_tuple_id(
+		__isl_keep isl_multi_val *mv);
+	isl_bool isl_multi_val_has_tuple_id(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_multi_val_get_tuple_id(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type);
+	__isl_give isl_multi_val *isl_multi_val_set_tuple_name(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, const char *s);
+	const char *isl_multi_val_get_tuple_name(
+		__isl_keep isl_multi_val *mv,
+		enum isl_dim_type type);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_set_tuple_id(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_multi_aff *isl_multi_aff_set_range_tuple_id(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
+		__isl_take isl_multi_aff *maff,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
+		__isl_take isl_pw_aff *pwaff,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_set_range_tuple_id(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_id *id);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
+		__isl_take isl_pw_multi_aff *pma,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_set_range_tuple_id(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_range_tuple_id(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_tuple_id(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, __isl_take isl_id *id);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_reset_range_tuple_id(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_reset_range_tuple_id(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_reset_range_tuple_id(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
+		__isl_take isl_multi_aff *ma,
+		enum isl_dim_type type);
+	__isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
+		__isl_take isl_pw_aff *pa,
+		enum isl_dim_type type);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_reset_tuple_id(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_reset_tuple_id(
+		__isl_take isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_reset_tuple_id(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type);
+	isl_bool isl_multi_aff_has_range_tuple_id(
+		__isl_keep isl_multi_aff *ma);
+	__isl_give isl_id *isl_multi_aff_get_range_tuple_id(
+		__isl_keep isl_multi_aff *ma);
+	isl_bool isl_multi_aff_has_tuple_id(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_multi_aff_get_tuple_id(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type);
+	isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_pw_aff_get_tuple_id(
+		__isl_keep isl_pw_aff *pa,
+		enum isl_dim_type type);
+	isl_bool isl_pw_multi_aff_has_range_tuple_id(
+		__isl_keep isl_pw_multi_aff *pma);
+	isl_bool isl_pw_multi_aff_has_tuple_id(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(
+		__isl_keep isl_pw_multi_aff *pma);
+	__isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	isl_bool isl_multi_pw_aff_has_range_tuple_id(
+		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_give isl_id *isl_multi_pw_aff_get_range_tuple_id(
+		__isl_keep isl_multi_pw_aff *mpa);
+	isl_bool isl_multi_pw_aff_has_tuple_id(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type);
+	isl_bool isl_multi_union_pw_aff_has_range_tuple_id(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+	__isl_give isl_id *
+	isl_multi_union_pw_aff_get_range_tuple_id(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+	isl_bool isl_multi_union_pw_aff_has_tuple_id(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type);
+	__isl_give isl_id *isl_multi_union_pw_aff_get_tuple_id(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type);
+	__isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
+		__isl_take isl_multi_aff *maff,
+		enum isl_dim_type type, const char *s);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_set_tuple_name(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, const char *s);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_tuple_name(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, const char *s);
+	const char *isl_multi_aff_get_tuple_name(
+		__isl_keep isl_multi_aff *multi,
+		enum isl_dim_type type);
+	isl_bool isl_pw_multi_aff_has_tuple_name(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	const char *isl_pw_multi_aff_get_tuple_name(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type);
+	const char *isl_multi_union_pw_aff_get_tuple_name(
+		__isl_keep isl_multi_union_pw_aff *mupa,
 		enum isl_dim_type type);
 
 The C<type> argument needs to be one of C<isl_dim_in>, C<isl_dim_out>
@@ -961,9 +1857,66 @@
 To keep the names of all parameters and tuples, but reset the user pointers
 of all the corresponding identifiers, use the following function.
 
+	#include <isl/space.h>
 	__isl_give isl_space *isl_space_reset_user(
 		__isl_take isl_space *space);
 
+	#include <isl/set.h>
+	__isl_give isl_set *isl_set_reset_user(
+		__isl_take isl_set *set);
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_reset_user(
+		__isl_take isl_map *map);
+
+	#include <isl/union_set.h>
+	__isl_give isl_union_set *isl_union_set_reset_user(
+		__isl_take isl_union_set *uset);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_reset_user(
+		__isl_take isl_union_map *umap);
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_reset_user(
+		__isl_take isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_reset_user(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_reset_user(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_reset_user(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_reset_user(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_reset_user(
+		__isl_take isl_union_pw_multi_aff *upma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_reset_user(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_reset_user(
+		__isl_take isl_union_pw_qpolynomial *upwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_reset_user(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_reset_user(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf);
+
 Spaces can be nested.  In particular, the domain of a set or
 the domain or range of a relation can be a nested relation.
 This process is also called I<wrapping>.
@@ -974,54 +1927,14 @@
 of L</"Basic Operations">.
 
 Spaces can be created from other spaces
-using the following functions.
-
-	__isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_range(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_domain_map(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_range_map(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_params(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_set_from_params(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_join(__isl_take isl_space *left,
-		__isl_take isl_space *right);
-	__isl_give isl_space *isl_space_align_params(
-		__isl_take isl_space *space1, __isl_take isl_space *space2)
-	__isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
-		enum isl_dim_type type, unsigned pos, unsigned n);
-	__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
-		enum isl_dim_type dst_type, unsigned dst_pos,
-		enum isl_dim_type src_type, unsigned src_pos,
-		unsigned n);
-	__isl_give isl_space *isl_space_map_from_set(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_map_from_domain_and_range(
-		__isl_take isl_space *domain,
-		__isl_take isl_space *range);
-	__isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_curry(
-		__isl_take isl_space *space);
-	__isl_give isl_space *isl_space_uncurry(
-		__isl_take isl_space *space);
-
-Note that if dimensions are added or removed from a space, then
-the name and the internal structure are lost.
+using the functions described in L</"Unary Operations">
+and L</"Binary Operations">.
 
 =head2 Local Spaces
 
 A local space is essentially a space with
 zero or more existentially quantified variables.
-The local space of a (constraint of a) basic set or relation can be obtained
+The local space of various objects can be obtained
 using the following functions.
 
 	#include <isl/constraint.h>
@@ -1036,6 +1949,12 @@
 	__isl_give isl_local_space *isl_basic_map_get_local_space(
 		__isl_keep isl_basic_map *bmap);
 
+	#include <isl/aff.h>
+	__isl_give isl_local_space *isl_aff_get_domain_local_space(
+		__isl_keep isl_aff *aff);
+	__isl_give isl_local_space *isl_aff_get_local_space(
+		__isl_keep isl_aff *aff);
+
 A new local space can be created from a space using
 
 	#include <isl/local_space.h>
@@ -1045,33 +1964,10 @@
 They can be inspected, modified, copied and freed using the following functions.
 
 	#include <isl/local_space.h>
-	isl_ctx *isl_local_space_get_ctx(
+	isl_bool isl_local_space_is_params(
+		__isl_keep isl_local_space *ls);
+	isl_bool isl_local_space_is_set(
 		__isl_keep isl_local_space *ls);
-	int isl_local_space_is_set(__isl_keep isl_local_space *ls);
-	int isl_local_space_dim(__isl_keep isl_local_space *ls,
-		enum isl_dim_type type);
-	__isl_give isl_local_space *isl_local_space_set_tuple_id(
-		__isl_take isl_local_space *ls,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	int isl_local_space_has_dim_id(
-		__isl_keep isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_local_space_get_dim_id(
-		__isl_keep isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos);
-	int isl_local_space_has_dim_name(
-		__isl_keep isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos)
-	const char *isl_local_space_get_dim_name(
-		__isl_keep isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_local_space *isl_local_space_set_dim_name(
-		__isl_take isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos, const char *s);
-	__isl_give isl_local_space *isl_local_space_set_dim_id(
-		__isl_take isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos,
-		__isl_take isl_id *id);
 	__isl_give isl_space *isl_local_space_get_space(
 		__isl_keep isl_local_space *ls);
 	__isl_give isl_aff *isl_local_space_get_div(
@@ -1086,194 +1982,14 @@
 
 Two local spaces can be compared using
 
-	int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
+	isl_bool isl_local_space_is_equal(
+		__isl_keep isl_local_space *ls1,
 		__isl_keep isl_local_space *ls2);
 
 Local spaces can be created from other local spaces
 using the functions described in L</"Unary Operations">
 and L</"Binary Operations">.
 
-=head2 Input and Output
-
-C<isl> supports its own input/output format, which is similar
-to the C<Omega> format, but also supports the C<PolyLib> format
-in some cases.
-
-=head3 C<isl> format
-
-The C<isl> format is similar to that of C<Omega>, but has a different
-syntax for describing the parameters and allows for the definition
-of an existentially quantified variable as the integer division
-of an affine expression.
-For example, the set of integers C<i> between C<0> and C<n>
-such that C<i % 10 <= 6> can be described as
-
-	n -> { i : exists (a = i/10 : 0 <= i and i <= n and
-				i - 10 a <= 6) }
-
-A set or relation can have several disjuncts, separated
-by the keyword C<or>.  Each disjunct is either a conjunction
-of constraints or a projection (C<exists>) of a conjunction
-of constraints.  The constraints are separated by the keyword
-C<and>.
-
-=head3 C<PolyLib> format
-
-If the represented set is a union, then the first line
-contains a single number representing the number of disjuncts.
-Otherwise, a line containing the number C<1> is optional.
-
-Each disjunct is represented by a matrix of constraints.
-The first line contains two numbers representing
-the number of rows and columns,
-where the number of rows is equal to the number of constraints
-and the number of columns is equal to two plus the number of variables.
-The following lines contain the actual rows of the constraint matrix.
-In each row, the first column indicates whether the constraint
-is an equality (C<0>) or inequality (C<1>).  The final column
-corresponds to the constant term.
-
-If the set is parametric, then the coefficients of the parameters
-appear in the last columns before the constant column.
-The coefficients of any existentially quantified variables appear
-between those of the set variables and those of the parameters.
-
-=head3 Extended C<PolyLib> format
-
-The extended C<PolyLib> format is nearly identical to the
-C<PolyLib> format.  The only difference is that the line
-containing the number of rows and columns of a constraint matrix
-also contains four additional numbers:
-the number of output dimensions, the number of input dimensions,
-the number of local dimensions (i.e., the number of existentially
-quantified variables) and the number of parameters.
-For sets, the number of ``output'' dimensions is equal
-to the number of set dimensions, while the number of ``input''
-dimensions is zero.
-
-=head3 Input
-
-	#include <isl/set.h>
-	__isl_give isl_basic_set *isl_basic_set_read_from_file(
-		isl_ctx *ctx, FILE *input);
-	__isl_give isl_basic_set *isl_basic_set_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
-		FILE *input);
-	__isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
-		const char *str);
-
-	#include <isl/map.h>
-	__isl_give isl_basic_map *isl_basic_map_read_from_file(
-		isl_ctx *ctx, FILE *input);
-	__isl_give isl_basic_map *isl_basic_map_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_map *isl_map_read_from_file(
-		isl_ctx *ctx, FILE *input);
-	__isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
-		const char *str);
-
-	#include <isl/union_set.h>
-	__isl_give isl_union_set *isl_union_set_read_from_file(
-		isl_ctx *ctx, FILE *input);
-	__isl_give isl_union_set *isl_union_set_read_from_str(
-		isl_ctx *ctx, const char *str);
-
-	#include <isl/union_map.h>
-	__isl_give isl_union_map *isl_union_map_read_from_file(
-		isl_ctx *ctx, FILE *input);
-	__isl_give isl_union_map *isl_union_map_read_from_str(
-		isl_ctx *ctx, const char *str);
-
-The input format is autodetected and may be either the C<PolyLib> format
-or the C<isl> format.
-
-=head3 Output
-
-Before anything can be printed, an C<isl_printer> needs to
-be created.
-
-	__isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
-		FILE *file);
-	__isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
-	__isl_null isl_printer *isl_printer_free(
-		__isl_take isl_printer *printer);
-	__isl_give char *isl_printer_get_str(
-		__isl_keep isl_printer *printer);
-
-The printer can be inspected using the following functions.
-
-	FILE *isl_printer_get_file(
-		__isl_keep isl_printer *printer);
-	int isl_printer_get_output_format(
-		__isl_keep isl_printer *p);
-
-The behavior of the printer can be modified in various ways
-
-	__isl_give isl_printer *isl_printer_set_output_format(
-		__isl_take isl_printer *p, int output_format);
-	__isl_give isl_printer *isl_printer_set_indent(
-		__isl_take isl_printer *p, int indent);
-	__isl_give isl_printer *isl_printer_set_indent_prefix(
-		__isl_take isl_printer *p, const char *prefix);
-	__isl_give isl_printer *isl_printer_indent(
-		__isl_take isl_printer *p, int indent);
-	__isl_give isl_printer *isl_printer_set_prefix(
-		__isl_take isl_printer *p, const char *prefix);
-	__isl_give isl_printer *isl_printer_set_suffix(
-		__isl_take isl_printer *p, const char *suffix);
-
-The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
-C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
-and defaults to C<ISL_FORMAT_ISL>.
-Each line in the output is prefixed by C<indent_prefix>,
-indented by C<indent> (set by C<isl_printer_set_indent>) spaces
-(default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
-In the C<PolyLib> format output,
-the coefficients of the existentially quantified variables
-appear between those of the set variables and those
-of the parameters.
-The function C<isl_printer_indent> increases the indentation
-by the specified amount (which may be negative).
-
-To actually print something, use
-
-	#include <isl/printer.h>
-	__isl_give isl_printer *isl_printer_print_double(
-		__isl_take isl_printer *p, double d);
-
-	#include <isl/set.h>
-	__isl_give isl_printer *isl_printer_print_basic_set(
-		__isl_take isl_printer *printer,
-		__isl_keep isl_basic_set *bset);
-	__isl_give isl_printer *isl_printer_print_set(
-		__isl_take isl_printer *printer,
-		__isl_keep isl_set *set);
-
-	#include <isl/map.h>
-	__isl_give isl_printer *isl_printer_print_basic_map(
-		__isl_take isl_printer *printer,
-		__isl_keep isl_basic_map *bmap);
-	__isl_give isl_printer *isl_printer_print_map(
-		__isl_take isl_printer *printer,
-		__isl_keep isl_map *map);
-
-	#include <isl/union_set.h>
-	__isl_give isl_printer *isl_printer_print_union_set(
-		__isl_take isl_printer *p,
-		__isl_keep isl_union_set *uset);
-
-	#include <isl/union_map.h>
-	__isl_give isl_printer *isl_printer_print_union_map(
-		__isl_take isl_printer *p,
-		__isl_keep isl_union_map *umap);
-
-When called on a file printer, the following function flushes
-the file.  When called on a string printer, the buffer is cleared.
-
-	__isl_give isl_printer *isl_printer_flush(
-		__isl_take isl_printer *p);
-
 =head2 Creating New Sets and Relations
 
 C<isl> has functions for creating some standard sets and relations.
@@ -1290,29 +2006,56 @@
 		__isl_take isl_space *space);
 	__isl_give isl_map *isl_map_empty(
 		__isl_take isl_space *space);
+	__isl_give isl_union_set *isl_union_set_empty_ctx(
+		isl_ctx *ctx);
+	__isl_give isl_union_set *isl_union_set_empty_space(
+		__isl_take isl_space *space);
 	__isl_give isl_union_set *isl_union_set_empty(
 		__isl_take isl_space *space);
+	__isl_give isl_union_map *isl_union_map_empty_ctx(
+		isl_ctx *ctx);
+	__isl_give isl_union_map *isl_union_map_empty_space(
+		__isl_take isl_space *space);
 	__isl_give isl_union_map *isl_union_map_empty(
 		__isl_take isl_space *space);
 
 For C<isl_union_set>s and C<isl_union_map>s, the space
 is only used to specify the parameters.
+C<isl_union_set_empty> is an alternative name for
+C<isl_union_set_empty_space>.
+Similarly for the other pair of functions.
 
 =item * Universe sets and relations
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_universe(
 		__isl_take isl_space *space);
-	__isl_give isl_basic_map *isl_basic_map_universe(
-		__isl_take isl_space *space);
 	__isl_give isl_set *isl_set_universe(
 		__isl_take isl_space *space);
+	__isl_give isl_set *isl_space_universe_set(
+		__isl_take isl_space *space);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_universe(
+		__isl_take isl_space *space);
 	__isl_give isl_map *isl_map_universe(
 		__isl_take isl_space *space);
+	__isl_give isl_map *isl_space_universe_map(
+		__isl_take isl_space *space);
+
+	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_universe(
 		__isl_take isl_union_set *uset);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_universe(
 		__isl_take isl_union_map *umap);
 
+C<isl_set_universe> and C<isl_space_universe_set>
+perform the same operation.
+Similarly
+for the pair C<isl_map_universe> and C<isl_space_universe_map>.
+
 The sets and relations constructed by the functions above
 contain all integer values, while those constructed by the
 functions below only contain non-negative values.
@@ -1373,11 +2116,16 @@
 A basic set or relation can be converted to a set or relation
 using the following functions.
 
+	__isl_give isl_set *isl_basic_set_to_set(
+		__isl_take isl_basic_set *bset);
 	__isl_give isl_set *isl_set_from_basic_set(
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_map *isl_map_from_basic_map(
 		__isl_take isl_basic_map *bmap);
 
+C<isl_basic_set_to_set> and C<isl_set_from_basic_set> perform
+the same operation.
+
 Sets and relations can be converted to union sets and relations
 using the following functions.
 
@@ -1385,27 +2133,42 @@
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_union_map *isl_union_map_from_basic_map(
 		__isl_take isl_basic_map *bmap);
+	__isl_give isl_union_set *isl_set_to_union_set(
+		__isl_take isl_set *set);
 	__isl_give isl_union_set *isl_union_set_from_set(
 		__isl_take isl_set *set);
+	__isl_give isl_union_map *isl_map_to_union_map(
+		__isl_take isl_map *map);
 	__isl_give isl_union_map *isl_union_map_from_map(
 		__isl_take isl_map *map);
 
+C<isl_map_to_union_map> and C<isl_union_map_from_map> perform
+the same operation.
+Similarly for C<isl_set_to_union_set> and C<isl_union_set_from_set>.
+
 The inverse conversions below can only be used if the input
 union set or relation is known to contain elements in exactly one
 space.
 
+	#include <isl/union_set.h>
+	isl_bool isl_union_set_isa_set(
+		__isl_keep isl_union_set *uset);
+	__isl_give isl_set *isl_union_set_as_set(
+		__isl_take isl_union_set *uset);
 	__isl_give isl_set *isl_set_from_union_set(
 		__isl_take isl_union_set *uset);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_isa_map(
+		__isl_keep isl_union_map *umap);
+	__isl_give isl_map *isl_union_map_as_map(
+		__isl_take isl_union_map *umap);
 	__isl_give isl_map *isl_map_from_union_map(
 		__isl_take isl_union_map *umap);
 
-A zero-dimensional (basic) set can be constructed on a given parameter domain
-using the following function.
-
-	__isl_give isl_basic_set *isl_basic_set_from_params(
-		__isl_take isl_basic_set *bset);
-	__isl_give isl_set *isl_set_from_params(
-		__isl_take isl_set *set);
+C<isl_union_map_as_map> and C<isl_map_from_union_map> perform
+the same operation.
+Similarly for C<isl_union_set_as_set> and C<isl_set_from_union_set>.
 
 Sets and relations can be copied and freed again using the following
 functions.
@@ -1440,9 +2203,9 @@
 using the following functions.
 
 	#include <isl/constraint.h>
-	__isl_give isl_constraint *isl_equality_alloc(
+	__isl_give isl_constraint *isl_constraint_alloc_equality(
 		__isl_take isl_local_space *ls);
-	__isl_give isl_constraint *isl_inequality_alloc(
+	__isl_give isl_constraint *isl_constraint_alloc_inequality(
 		__isl_take isl_local_space *ls);
 	__isl_give isl_constraint *isl_constraint_set_constant_si(
 		__isl_take isl_constraint *constraint, int v);
@@ -1469,12 +2232,9 @@
 	__isl_give isl_set *isl_set_add_constraint(
 		__isl_take isl_set *set,
 		__isl_take isl_constraint *constraint);
-	__isl_give isl_basic_set *isl_basic_set_drop_constraint(
-		__isl_take isl_basic_set *bset,
-		__isl_take isl_constraint *constraint);
 
 For example, to create a set containing the even integers
-between 10 and 42, you would use the following code.
+between 10 and 42, you could use the following code.
 
 	isl_space *space;
 	isl_local_space *ls;
@@ -1485,24 +2245,57 @@
 	bset = isl_basic_set_universe(isl_space_copy(space));
 	ls = isl_local_space_from_space(space);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
 	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
 	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 2);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_inequality_alloc(isl_local_space_copy(ls));
+	c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
 	c = isl_constraint_set_constant_si(c, -10);
 	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_inequality_alloc(ls);
+	c = isl_constraint_alloc_inequality(ls);
 	c = isl_constraint_set_constant_si(c, 42);
 	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 1);
 
-Or, alternatively,
+However, this is considered to be a fairly low-level approach.
+It is more appropriate to construct a (basic) set by means
+of affine expressions (defined below in L</"Functions">).
+For example, the same set could be constructed as follows.
+
+	isl_val *v, *two;
+	isl_space *space;
+	isl_multi_aff *ma;
+	isl_aff *var, *cst;
+	isl_basic_set *bset;
+
+	space = isl_space_unit(ctx);
+	space = isl_space_add_unnamed_tuple_ui(space, 1);
+	ma = isl_multi_aff_identity_on_domain_space(
+		isl_space_copy(space));
+	var = isl_multi_aff_get_at(ma, 0);
+	v = isl_val_int_from_si(ctx, 10);
+	cst = isl_aff_val_on_domain_space(isl_space_copy(space), v);
+	bset = isl_aff_ge_basic_set(isl_aff_copy(var), cst);
+
+	v = isl_val_int_from_si(ctx, 42);
+	cst = isl_aff_val_on_domain_space(space, v);
+	bset = isl_basic_set_intersect(bset,
+		isl_aff_le_basic_set(var, cst));
+
+	two = isl_val_int_from_si(ctx, 2);
+	ma = isl_multi_aff_scale_val(ma, isl_val_copy(two));
+	bset = isl_basic_set_preimage_multi_aff(bset,
+		isl_multi_aff_copy(ma));
+	ma = isl_multi_aff_scale_down_val(ma, isl_val_copy(two));
+	ma = isl_multi_aff_scale_down_val(ma, two);
+	bset = isl_basic_set_preimage_multi_aff(bset, ma);
+
+Alternatively, the set can be parsed from a string representation.
 
 	isl_basic_set *bset;
 	bset = isl_basic_set_read_from_str(ctx,
@@ -1526,47 +2319,92 @@
 
 The C<isl_dim_type> arguments indicate the order in which
 different kinds of variables appear in the input matrices
-and should be a permutation of C<isl_dim_cst>, C<isl_dim_param>,
-C<isl_dim_set> and C<isl_dim_div> for sets and
+and should be a permutation of C<isl_dim_cst> (the constant term),
+C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div> for sets and
 of C<isl_dim_cst>, C<isl_dim_param>,
 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div> for relations.
 
 A (basic or union) set or relation can also be constructed from a
 (union) (piecewise) (multiple) affine expression
 or a list of affine expressions
-(See L<"Piecewise Quasi Affine Expressions"> and
-L<"Piecewise Multiple Quasi Affine Expressions">).
+(See L</"Functions">), provided these affine expressions do not
+involve any NaN.
+
+	#include <isl/set.h>
+	__isl_give isl_basic_set *isl_basic_set_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_set *isl_multi_aff_as_set(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_set *isl_set_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
 
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_from_aff(
 		__isl_take isl_aff *aff);
 	__isl_give isl_map *isl_map_from_aff(
 		__isl_take isl_aff *aff);
-	__isl_give isl_set *isl_set_from_pw_aff(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_map *isl_map_from_pw_aff(
-		__isl_take isl_pw_aff *pwaff);
 	__isl_give isl_basic_map *isl_basic_map_from_aff_list(
 		__isl_take isl_space *domain_space,
 		__isl_take isl_aff_list *list);
 	__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
 		__isl_take isl_multi_aff *maff)
+	__isl_give isl_map *isl_multi_aff_as_map(
+		__isl_take isl_multi_aff *ma);
 	__isl_give isl_map *isl_map_from_multi_aff(
 		__isl_take isl_multi_aff *maff)
+
+	#include <isl/aff.h>
+	__isl_give isl_set *isl_set_from_pw_aff(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_map *isl_pw_aff_as_map(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_map *isl_map_from_pw_aff(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_set *isl_pw_multi_aff_as_set(
+		__isl_take isl_pw_multi_aff *pma);
 	__isl_give isl_set *isl_set_from_pw_multi_aff(
 		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_map *isl_pw_multi_aff_as_map(
+		__isl_take isl_pw_multi_aff *pma);
 	__isl_give isl_map *isl_map_from_pw_multi_aff(
 		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_set *isl_multi_pw_aff_as_set(
+		__isl_take isl_multi_pw_aff *mpa);
 	__isl_give isl_set *isl_set_from_multi_pw_aff(
 		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_map *isl_multi_pw_aff_as_map(
+		__isl_take isl_multi_pw_aff *mpa);
 	__isl_give isl_map *isl_map_from_multi_pw_aff(
 		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_union_map *isl_union_map_from_union_pw_aff(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_map *
+	isl_union_pw_multi_aff_as_union_map(
+		__isl_take isl_union_pw_multi_aff *upma);
 	__isl_give isl_union_map *
 	isl_union_map_from_union_pw_multi_aff(
 		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_union_map *
+	isl_union_map_from_multi_union_pw_aff(
+		__isl_take isl_multi_union_pw_aff *mupa);
 
 The C<domain_space> argument describes the domain of the resulting
 basic relation.  It is required because the C<list> may consist
 of zero affine expressions.
+The C<mupa> passed to C<isl_union_map_from_multi_union_pw_aff>
+is not allowed to be zero-dimensional.  The domain of the result
+is the shared domain of the union piecewise affine elements.
+C<isl_multi_aff_as_set> and C<isl_set_from_multi_aff> perform
+the same operation.
+Similarly for the pair C<isl_multi_aff_as_map> and C<isl_map_from_multi_aff>,
+for the pair C<isl_pw_aff_as_map> and C<isl_map_from_pw_aff>,
+for the pair C<isl_pw_multi_aff_as_set> and C<isl_set_from_pw_multi_aff>,
+for the pair C<isl_pw_multi_aff_as_map> and C<isl_map_from_pw_multi_aff>,
+the pair C<isl_multi_pw_aff_as_set> and C<isl_set_from_multi_pw_aff>,
+the pair C<isl_multi_pw_aff_as_map> and C<isl_map_from_multi_pw_aff>,
+and
+C<isl_union_pw_multi_aff_as_union_map> and
+C<isl_union_map_from_union_pw_multi_aff>.
 
 =head2 Inspecting Sets and Relations
 
@@ -1592,28 +2430,30 @@
 including earlier existentially quantified variables.
 An explicitly represented existentially quantified variable therefore
 has a unique value when the values of the other variables are known.
-If, furthermore, the same existentials, i.e., existentials
-with the same explicit representations, should appear in the
-same order in each of the disjuncts of a set or map, then the user should call
-either of the following functions.
-
-	__isl_give isl_set *isl_set_align_divs(
-		__isl_take isl_set *set);
-	__isl_give isl_map *isl_map_align_divs(
-		__isl_take isl_map *map);
 
 Alternatively, the existentially quantified variables can be removed
 using the following functions, which compute an overapproximation.
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_remove_divs(
 		__isl_take isl_basic_set *bset);
-	__isl_give isl_basic_map *isl_basic_map_remove_divs(
-		__isl_take isl_basic_map *bmap);
 	__isl_give isl_set *isl_set_remove_divs(
 		__isl_take isl_set *set);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_remove_divs(
+		__isl_take isl_basic_map *bmap);
 	__isl_give isl_map *isl_map_remove_divs(
 		__isl_take isl_map *map);
 
+	#include <isl/union_set.h>
+	__isl_give isl_union_set *isl_union_set_remove_divs(
+		__isl_take isl_union_set *bset);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_remove_divs(
+		__isl_take isl_union_map *bmap);
+
 It is also possible to only remove those divs that are defined
 in terms of a given range of dimensions or only those for which
 no explicit representation is known.
@@ -1645,18 +2485,42 @@
 
 To iterate over all the sets or maps in a union set or map, use
 
-	int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
-		int (*fn)(__isl_take isl_set *set, void *user),
+	#include <isl/union_set.h>
+	isl_stat isl_union_set_foreach_set(
+		__isl_keep isl_union_set *uset,
+		isl_stat (*fn)(__isl_take isl_set *set, void *user),
+		void *user);
+	isl_bool isl_union_set_every_set(
+		__isl_keep isl_union_set *uset,
+		isl_bool (*test)(__isl_keep isl_set *set,
+			void *user),
+		void *user);
+
+	#include <isl/union_map.h>
+	isl_stat isl_union_map_foreach_map(
+		__isl_keep isl_union_map *umap,
+		isl_stat (*fn)(__isl_take isl_map *map, void *user),
 		void *user);
-	int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
-		int (*fn)(__isl_take isl_map *map, void *user),
+	isl_bool isl_union_map_every_map(
+		__isl_keep isl_union_map *umap,
+		isl_bool (*test)(__isl_keep isl_map *map,
+			void *user),
 		void *user);
 
+These functions call the callback function once for each
+(pair of) space(s) for which there are elements in the input.
+The argument to the callback contains all elements in the input
+with that (pair of) space(s).
+The C<isl_union_set_every_set> and
+C<isl_union_map_every_map> variants check whether each
+call to the callback returns true and stops checking as soon as one
+of these calls returns false.
+
 The number of sets or maps in a union set or map can be obtained
 from
 
-	int isl_union_set_n_set(__isl_keep isl_union_set *uset);
-	int isl_union_map_n_map(__isl_keep isl_union_map *umap);
+	isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);
+	isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);
 
 To extract the set or map in a given space from a union, use
 
@@ -1669,16 +2533,18 @@
 
 To iterate over all the basic sets or maps in a set or map, use
 
-	int isl_set_foreach_basic_set(__isl_keep isl_set *set,
-		int (*fn)(__isl_take isl_basic_set *bset, void *user),
+	isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
+		isl_stat (*fn)(__isl_take isl_basic_set *bset,
+			void *user),
 		void *user);
-	int isl_map_foreach_basic_map(__isl_keep isl_map *map,
-		int (*fn)(__isl_take isl_basic_map *bmap, void *user),
+	isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
+		isl_stat (*fn)(__isl_take isl_basic_map *bmap,
+			void *user),
 		void *user);
 
-The callback function C<fn> should return 0 if successful and
--1 if an error occurs.  In the latter case, or if any other error
-occurs, the above functions will return -1.
+The callback function C<fn> should return C<isl_stat_ok> if successful and
+C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
+occurs, the above functions will return C<isl_stat_error>.
 
 It should be noted that C<isl> does not guarantee that
 the basic sets or maps passed to C<fn> are disjoint.
@@ -1695,38 +2561,66 @@
 from
 
 	#include <isl/set.h>
-	int isl_set_n_basic_set(__isl_keep isl_set *set);
+	isl_size isl_set_n_basic_set(__isl_keep isl_set *set);
 
 	#include <isl/map.h>
-	int isl_map_n_basic_map(__isl_keep isl_map *map);
+	isl_size isl_map_n_basic_map(__isl_keep isl_map *map);
+
+It is also possible to obtain a list of (basic) sets from a set
+or union set, a list of basic maps from a map and a list of maps from a union
+map.
+
+	#include <isl/set.h>
+	__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
+		__isl_keep isl_set *set);
+
+	#include <isl/union_set.h>
+	__isl_give isl_basic_set_list *
+	isl_union_set_get_basic_set_list(
+		__isl_keep isl_union_set *uset);
+	__isl_give isl_set_list *isl_union_set_get_set_list(
+		__isl_keep isl_union_set *uset);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
+		__isl_keep isl_map *map);
+
+	#include <isl/union_map.h>
+	__isl_give isl_map_list *isl_union_map_get_map_list(
+		__isl_keep isl_union_map *umap);
+
+The returned list can be manipulated using the functions in L<"Lists">.
 
 To iterate over the constraints of a basic set or map, use
 
 	#include <isl/constraint.h>
 
-	int isl_basic_set_n_constraint(
+	isl_size isl_basic_set_n_constraint(
 		__isl_keep isl_basic_set *bset);
-	int isl_basic_set_foreach_constraint(
+	isl_stat isl_basic_set_foreach_constraint(
 		__isl_keep isl_basic_set *bset,
-		int (*fn)(__isl_take isl_constraint *c, void *user),
+		isl_stat (*fn)(__isl_take isl_constraint *c,
+			void *user),
 		void *user);
-	int isl_basic_map_n_constraint(
+	isl_size isl_basic_map_n_constraint(
 		__isl_keep isl_basic_map *bmap);
-	int isl_basic_map_foreach_constraint(
+	isl_stat isl_basic_map_foreach_constraint(
 		__isl_keep isl_basic_map *bmap,
-		int (*fn)(__isl_take isl_constraint *c, void *user),
+		isl_stat (*fn)(__isl_take isl_constraint *c,
+			void *user),
 		void *user);
 	__isl_null isl_constraint *isl_constraint_free(
 		__isl_take isl_constraint *c);
 
-Again, the callback function C<fn> should return 0 if successful and
--1 if an error occurs.  In the latter case, or if any other error
-occurs, the above functions will return -1.
+Again, the callback function C<fn> should return C<isl_stat_ok>
+if successful and
+C<isl_stat_error> if an error occurs.  In the latter case, or if any other error
+occurs, the above functions will return C<isl_stat_error>.
 The constraint C<c> represents either an equality or an inequality.
 Use the following function to find out whether a constraint
 represents an equality.  If not, it represents an inequality.
 
-	int isl_constraint_is_equality(
+	isl_bool isl_constraint_is_equality(
 		__isl_keep isl_constraint *constraint);
 
 It is also possible to obtain a list of constraints from a basic
@@ -1747,10 +2641,10 @@
 The coefficients of the constraints can be inspected using
 the following functions.
 
-	int isl_constraint_is_lower_bound(
+	isl_bool isl_constraint_is_lower_bound(
 		__isl_keep isl_constraint *constraint,
 		enum isl_dim_type type, unsigned pos);
-	int isl_constraint_is_upper_bound(
+	isl_bool isl_constraint_is_upper_bound(
 		__isl_keep isl_constraint *constraint,
 		enum isl_dim_type type, unsigned pos);
 	__isl_give isl_val *isl_constraint_get_constant_val(
@@ -1758,9 +2652,6 @@
 	__isl_give isl_val *isl_constraint_get_coefficient_val(
 		__isl_keep isl_constraint *constraint,
 		enum isl_dim_type type, int pos);
-	int isl_constraint_involves_dims(
-		__isl_keep isl_constraint *constraint,
-		enum isl_dim_type type, unsigned first, unsigned n);
 
 The explicit representations of the existentially quantified
 variables can be inspected using the following function.
@@ -1770,7 +2661,7 @@
 The existentially quantified variable is equal to the floor
 of the returned affine expression.  The affine expression
 itself can be inspected using the functions in
-L<"Piecewise Quasi Affine Expressions">.
+L</"Functions">.
 
 	__isl_give isl_aff *isl_constraint_get_div(
 		__isl_keep isl_constraint *constraint, int pos);
@@ -1800,190 +2691,1948 @@
 The C<isl_dim_type> arguments dictate the order in which
 different kinds of variables appear in the resulting matrix.
 For set inputs, they should be a permutation of
-C<isl_dim_cst>, C<isl_dim_param>, C<isl_dim_set> and C<isl_dim_div>.
+C<isl_dim_cst> (the constant term), C<isl_dim_param>, C<isl_dim_set> and
+C<isl_dim_div>.
 For map inputs, they should be a permutation of
 C<isl_dim_cst>, C<isl_dim_param>,
 C<isl_dim_in>, C<isl_dim_out> and C<isl_dim_div>.
 
-The number of parameters, input, output or set dimensions can
-be obtained using the following functions.
+=head2 Points
 
-	unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
-		enum isl_dim_type type);
-	unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
-		enum isl_dim_type type);
-	unsigned isl_set_dim(__isl_keep isl_set *set,
-		enum isl_dim_type type);
-	unsigned isl_map_dim(__isl_keep isl_map *map,
-		enum isl_dim_type type);
-	unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
-		enum isl_dim_type type);
+Points are elements of a set.  They can be used to construct
+simple sets (boxes) or they can be used to represent the
+individual elements of a set.
+The zero point (the origin) can be created using
 
-Note that a C<isl_union_map> only has parameters.
+	__isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
 
-To check whether the description of a set or relation depends
-on one or more given dimensions, it is not necessary to iterate over all
-constraints.  Instead the following functions can be used.
+The coordinates of a point can be inspected, set and changed
+using
 
-	int isl_basic_set_involves_dims(
-		__isl_keep isl_basic_set *bset,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	int isl_set_involves_dims(__isl_keep isl_set *set,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	int isl_basic_map_involves_dims(
-		__isl_keep isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	int isl_map_involves_dims(__isl_keep isl_map *map,
-		enum isl_dim_type type, unsigned first, unsigned n);
+	#include <isl/point.h>
+	__isl_give isl_multi_val *isl_point_get_multi_val(
+		__isl_keep isl_point *pnt);
+	__isl_give isl_val *isl_point_get_coordinate_val(
+		__isl_keep isl_point *pnt,
+		enum isl_dim_type type, int pos);
+	__isl_give isl_point *isl_point_set_coordinate_val(
+		__isl_take isl_point *pnt,
+		enum isl_dim_type type, int pos,
+		__isl_take isl_val *v);
 
-Similarly, the following functions can be used to check whether
-a given dimension is involved in any lower or upper bound.
+	__isl_give isl_point *isl_point_add_ui(
+		__isl_take isl_point *pnt,
+		enum isl_dim_type type, int pos, unsigned val);
+	__isl_give isl_point *isl_point_sub_ui(
+		__isl_take isl_point *pnt,
+		enum isl_dim_type type, int pos, unsigned val);
+
+Points can be copied or freed using
+
+	__isl_give isl_point *isl_point_copy(
+		__isl_keep isl_point *pnt);
+	__isl_null isl_point *isl_point_free(
+		__isl_take isl_point *pnt);
+
+A singleton set can be created from a point using the following functions.
+
+	__isl_give isl_basic_set *isl_basic_set_from_point(
+		__isl_take isl_point *pnt);
+	__isl_give isl_set *isl_point_to_set(
+		__isl_take isl_point *pnt);
+	__isl_give isl_set *isl_set_from_point(
+		__isl_take isl_point *pnt);
+	__isl_give isl_union_set *isl_union_set_from_point(
+		__isl_take isl_point *pnt);
+
+C<isl_point_to_set> and C<isl_set_from_point> perform
+the same operation.
+
+A box can be created from two opposite extremal points using
+
+	__isl_give isl_basic_set *isl_basic_set_box_from_points(
+		__isl_take isl_point *pnt1,
+		__isl_take isl_point *pnt2);
+	__isl_give isl_set *isl_set_box_from_points(
+		__isl_take isl_point *pnt1,
+		__isl_take isl_point *pnt2);
+
+All elements of a B<bounded> (union) set can be enumerated using
+the following functions.
+
+	isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
+		isl_stat (*fn)(__isl_take isl_point *pnt,
+			void *user),
+		void *user);
+	isl_stat isl_union_set_foreach_point(
+		__isl_keep isl_union_set *uset,
+		isl_stat (*fn)(__isl_take isl_point *pnt,
+			void *user),
+		void *user);
+
+The function C<fn> is called for each integer point in
+C<set> with as second argument the last argument of
+the C<isl_set_foreach_point> call.  The function C<fn>
+should return C<isl_stat_ok> on success and C<isl_stat_error> on failure.
+In the latter case, C<isl_set_foreach_point> will stop
+enumerating and return C<isl_stat_error> as well.
+If the enumeration is performed successfully and to completion,
+then C<isl_set_foreach_point> returns C<isl_stat_ok>.
+
+To obtain a single point of a (basic or union) set, use
+
+	__isl_give isl_point *isl_basic_set_sample_point(
+		__isl_take isl_basic_set *bset);
+	__isl_give isl_point *isl_set_sample_point(
+		__isl_take isl_set *set);
+	__isl_give isl_point *isl_union_set_sample_point(
+		__isl_take isl_union_set *uset);
 
-	int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
+If C<set> does not contain any (integer) points, then the
+resulting point will be ``void'', a property that can be
+tested using
+
+	isl_bool isl_point_is_void(__isl_keep isl_point *pnt);
+
+=head2 Functions
+
+Besides sets and relation, C<isl> also supports various types of functions.
+Each of these types is derived from the value type (see L</"Values">)
+or from one of two primitive function types
+through the application of zero or more type constructors.
+As a special case, a multiple expression can also be derived
+from an identifier (see L</"Identifiers">) although the result
+is not really a function.
+We first describe the primitive type and then we describe
+the types derived from these primitive types.
+
+=head3 Primitive Functions
+
+C<isl> support two primitive function types, quasi-affine
+expressions and quasipolynomials.
+A quasi-affine expression is defined either over a parameter
+space or over a set and is composed of integer constants,
+parameters and set variables, addition, subtraction and
+integer division by an integer constant.
+For example, the quasi-affine expression
+
+	n -> { x -> 2*floor((4 n + x)/9) }
+
+maps C<x> to C<2*floor((4 n + x)/9>.
+A quasipolynomial is a polynomial expression in quasi-affine
+expression.  That is, it additionally allows for multiplication.
+Note, though, that it is not allowed to construct an integer
+division of an expression involving multiplications.
+Here is an example of a quasipolynomial that is not
+quasi-affine expression
+
+	n -> { x -> (n*floor((4 n + x)/9)) }
+
+Note that the external representations of quasi-affine expressions
+and quasipolynomials are different.  Quasi-affine expressions
+use a notation with square brackets just like binary relations,
+while quasipolynomials do not.  This might change at some point.
+
+If a primitive function is defined over a parameter space,
+then the space of the function itself is that of a set.
+If it is defined over a set, then the space of the function
+is that of a relation.  In both cases, the set space (or
+the output space) is single-dimensional, anonymous and unstructured.
+To create functions with multiple dimensions or with other kinds
+of set or output spaces, use multiple expressions
+(see L</"Multiple Expressions">).
+
+=over
+
+=item * Quasi-affine Expressions
+
+Besides the expressions described above, a quasi-affine
+expression can also be set to NaN.  Such expressions
+typically represent a failure to represent a result
+as a quasi-affine expression.
+
+The zero quasi affine expression or the quasi affine expression
+that is equal to a given value, parameter or
+a specified dimension on a given domain can be created using
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_zero_on_domain_space(
+		__isl_take isl_space *space);
+	__isl_give isl_aff *isl_space_zero_aff_on_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_aff *isl_aff_zero_on_domain(
+		__isl_take isl_local_space *ls);
+	__isl_give isl_aff *isl_aff_val_on_domain_space(
+		__isl_take isl_space *space,
+		__isl_take isl_val *val);
+	__isl_give isl_aff *isl_aff_val_on_domain(
+		__isl_take isl_local_space *ls,
+		__isl_take isl_val *val);
+	__isl_give isl_aff *isl_aff_param_on_domain_space_id(
+		__isl_take isl_space *space,
+		__isl_take isl_id *id);
+	__isl_give isl_aff *isl_aff_var_on_domain(
+		__isl_take isl_local_space *ls,
 		enum isl_dim_type type, unsigned pos);
-	int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
+	__isl_give isl_aff *isl_aff_nan_on_domain_space(
+		__isl_take isl_space *space);
+	__isl_give isl_aff *isl_aff_nan_on_domain(
+		__isl_take isl_local_space *ls);
+
+The space passed to C<isl_aff_param_on_domain_space_id>
+is required to have a parameter with the given identifier.
+
+C<isl_aff_zero_on_domain_space> and C<isl_space_zero_aff_on_domain>
+perform the same operation.
+
+Quasi affine expressions can be copied and freed using
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_copy(
+		__isl_keep isl_aff *aff);
+	__isl_null isl_aff *isl_aff_free(
+		__isl_take isl_aff *aff);
+
+A (rational) bound on a dimension can be extracted from an C<isl_constraint>
+using the following function.  The constraint is required to have
+a non-zero coefficient for the specified dimension.
+
+	#include <isl/constraint.h>
+	__isl_give isl_aff *isl_constraint_get_bound(
+		__isl_keep isl_constraint *constraint,
+		enum isl_dim_type type, int pos);
+
+The entire affine expression of the constraint can also be extracted
+using the following function.
+
+	#include <isl/constraint.h>
+	__isl_give isl_aff *isl_constraint_get_aff(
+		__isl_keep isl_constraint *constraint);
+
+Conversely, an equality constraint equating
+the affine expression to zero or an inequality constraint enforcing
+the affine expression to be non-negative, can be constructed using
+
+	__isl_give isl_constraint *isl_equality_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_constraint *isl_inequality_from_aff(
+		__isl_take isl_aff *aff);
+
+The coefficients and the integer divisions of an affine expression
+can be inspected using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_val *isl_aff_get_constant_val(
+		__isl_keep isl_aff *aff);
+	__isl_give isl_val *isl_aff_get_coefficient_val(
+		__isl_keep isl_aff *aff,
+		enum isl_dim_type type, int pos);
+	int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
+		enum isl_dim_type type, int pos);
+	__isl_give isl_val *isl_aff_get_denominator_val(
+		__isl_keep isl_aff *aff);
+	__isl_give isl_aff *isl_aff_get_div(
+		__isl_keep isl_aff *aff, int pos);
+
+They can be modified using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_set_constant_si(
+		__isl_take isl_aff *aff, int v);
+	__isl_give isl_aff *isl_aff_set_constant_val(
+		__isl_take isl_aff *aff, __isl_take isl_val *v);
+	__isl_give isl_aff *isl_aff_set_coefficient_si(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, int pos, int v);
+	__isl_give isl_aff *isl_aff_set_coefficient_val(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, int pos,
+		__isl_take isl_val *v);
+
+	__isl_give isl_aff *isl_aff_add_constant_si(
+		__isl_take isl_aff *aff, int v);
+	__isl_give isl_aff *isl_aff_add_constant_val(
+		__isl_take isl_aff *aff, __isl_take isl_val *v);
+	__isl_give isl_aff *isl_aff_add_constant_num_si(
+		__isl_take isl_aff *aff, int v);
+	__isl_give isl_aff *isl_aff_add_coefficient_si(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, int pos, int v);
+	__isl_give isl_aff *isl_aff_add_coefficient_val(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, int pos,
+		__isl_take isl_val *v);
+
+Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
+set the I<numerator> of the constant or coefficient, while
+C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
+the constant or coefficient as a whole.
+The C<add_constant> and C<add_coefficient> functions add an integer
+or rational value to
+the possibly rational constant or coefficient.
+The C<add_constant_num> functions add an integer value to
+the numerator.
+
+=item * Quasipolynomials
+
+Some simple quasipolynomials can be created using the following functions.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
+		__isl_take isl_space *domain);
+	__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
+		__isl_take isl_space *domain);
+	__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
+		__isl_take isl_space *domain);
+	__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
+		__isl_take isl_space *domain);
+	__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
+		__isl_take isl_space *domain);
+	__isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
+		__isl_take isl_space *domain,
+		__isl_take isl_val *val);
+	__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
+		__isl_take isl_space *domain,
 		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
+		__isl_take isl_aff *aff);
 
-Note that these functions return true even if there is a bound on
-the dimension on only some of the basic sets of C<set>.
-To check if they have a bound for all of the basic sets in C<set>,
-use the following functions instead.
+Recall that the space in which a quasipolynomial lives is a map space
+with a one-dimensional range.  The C<domain> argument in some of
+the functions above corresponds to the domain of this map space.
+
+Quasipolynomials can be copied and freed again using the following
+functions.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_copy(
+		__isl_keep isl_qpolynomial *qp);
+	__isl_null isl_qpolynomial *isl_qpolynomial_free(
+		__isl_take isl_qpolynomial *qp);
+
+The constant term of a quasipolynomial can be extracted using
+
+	__isl_give isl_val *isl_qpolynomial_get_constant_val(
+		__isl_keep isl_qpolynomial *qp);
+
+To iterate over all terms in a quasipolynomial,
+use
 
-	int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
+	isl_stat isl_qpolynomial_foreach_term(
+		__isl_keep isl_qpolynomial *qp,
+		isl_stat (*fn)(__isl_take isl_term *term,
+			  void *user), void *user);
+
+The terms themselves can be inspected and freed using
+these functions
+
+	isl_size isl_term_dim(__isl_keep isl_term *term,
+		enum isl_dim_type type);
+	__isl_give isl_val *isl_term_get_coefficient_val(
+		__isl_keep isl_term *term);
+	isl_size isl_term_get_exp(__isl_keep isl_term *term,
 		enum isl_dim_type type, unsigned pos);
-	int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
+	__isl_give isl_aff *isl_term_get_div(
+		__isl_keep isl_term *term, unsigned pos);
+	__isl_null isl_term *isl_term_free(
+		__isl_take isl_term *term);
+
+Each term is a product of parameters, set variables and
+integer divisions.  The function C<isl_term_get_exp>
+returns the exponent of a given dimensions in the given term.
+
+=back
+
+=head3 Reductions
+
+A reduction represents a maximum or a minimum of its
+base expressions.
+The only reduction type defined by C<isl> is
+C<isl_qpolynomial_fold>.
+
+There are currently no functions to directly create such
+objects, but they do appear in the piecewise quasipolynomial
+reductions returned by the C<isl_pw_qpolynomial_bound> function.
+See
+L</"Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions">.
+
+Reductions can be copied and freed using
+the following functions.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial_fold *
+	isl_qpolynomial_fold_copy(
+		__isl_keep isl_qpolynomial_fold *fold);
+	__isl_null isl_qpolynomial_fold *
+	isl_qpolynomial_fold_free(
+		__isl_take isl_qpolynomial_fold *fold);
+
+The type of a (union piecewise) reduction
+can be obtained using the following functions.
+
+	#include <isl/polynomial.h>
+	enum isl_fold isl_qpolynomial_fold_get_type(
+		__isl_keep isl_qpolynomial_fold *fold);
+	enum isl_fold isl_pw_qpolynomial_fold_get_type(
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+
+The type may be either C<isl_fold_min> or C<isl_fold_max>
+(or C<isl_fold_error> in case of error).
+
+To iterate over all quasipolynomials in a reduction, use
+
+	isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
+		__isl_keep isl_qpolynomial_fold *fold,
+		isl_stat (*fn)(__isl_take isl_qpolynomial *qp,
+			  void *user), void *user);
+
+=head3 Multiple Expressions
+
+A multiple expression represents a sequence of zero or
+more base expressions, all defined on the same domain space.
+The domain space of the multiple expression is the same
+as that of the base expressions, but the range space
+can be any space.  In case the base expressions have
+a set space, the corresponding multiple expression
+also has a set space.
+Objects of the value or identifier type do not have an associated space.
+The space of a multiple value or
+multiple identifier is therefore always a set space.
+Similarly, the space of a multiple union piecewise
+affine expression is always a set space.
+If the base expressions are not total, then
+a corresponding zero-dimensional multiple expression may
+have an explicit domain that keeps track of the domain
+outside of any base expressions.
+
+The multiple expression types defined by C<isl>
+are C<isl_multi_val>, C<isl_multi_id>, C<isl_multi_aff>, C<isl_multi_pw_aff>,
+C<isl_multi_union_pw_aff>.
+
+A multiple expression with the value zero for
+each output (or set) dimension can be created
+using the following functions.
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_zero(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_val *isl_space_zero_multi_val(
+		__isl_take isl_space *space);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_zero(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_space_zero_multi_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_pw_aff *isl_space_zero_multi_pw_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_zero(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_union_pw_aff *
+	isl_space_zero_multi_union_pw_aff(
+		__isl_take isl_space *space);
+
+Since there is no canonical way of representing a zero
+value of type C<isl_union_pw_aff>, the space passed
+to C<isl_multi_union_pw_aff_zero> needs to be zero-dimensional.
+C<isl_multi_val_zero> and C<isl_space_zero_multi_val>
+perform the same operation.
+Similarly
+for the pair C<isl_multi_aff_zero> and C<isl_space_zero_multi_aff>,
+for the pair C<isl_multi_pw_aff_zero> and C<isl_space_zero_multi_pw_aff> and
+for the pair C<isl_multi_union_pw_aff_zero> and
+C<isl_space_zero_multi_union_pw_aff>.
+
+
+An identity function can be created using the following
+functions.
+For the first group of functions, the space needs to be that of a set.
+For the second group,
+the space needs to be that of a relation
+with the same number of input and output dimensions.
+For the third group, the input function needs to live in a space
+with the same number of input and output dimensions and
+the identity function is created in that space.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *
+	isl_multi_aff_identity_on_domain_space(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *
+	isl_space_identity_multi_aff_on_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_identity_on_domain_space(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_pw_aff *
+	isl_space_identity_multi_pw_aff_on_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_multi_aff_identity(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_identity_multi_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_identity_multi_pw_aff(
+		__isl_take isl_multi_pw_aff *mpa);
+
+C<isl_multi_aff_identity_on_domain_space> and
+C<isl_space_identity_multi_aff_on_domain>
+perform the same operation.
+Similarly
+for the pair C<isl_multi_pw_aff_identity_on_domain_space> and
+C<isl_space_identity_multi_pw_aff_on_domain>.
+
+A function that performs a projection on a universe
+relation or set can be created using the following functions.
+See also the corresponding
+projection operations in L</"Unary Operations">.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_domain_map(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_multi_aff_range_map(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_multi_aff *isl_multi_aff_project_out_map(
+		__isl_take isl_space *space,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+
+C<isl_multi_aff_domain_map> and C<isl_space_domain_map_multi_aff> perform
+the same operation.
+Similarly
+for the pair C<isl_multi_aff_range_map> and C<isl_space_range_map_multi_aff>.
+
+A multiple expression can be created from a single
+base expression using the following functions.
+The space of the created multiple expression is the same
+as that of the base expression, except for
+C<isl_multi_union_pw_aff_from_union_pw_aff> where the input
+lives in a parameter space and the output lives
+in a single-dimensional set space.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_union_pw_aff(
+		__isl_take isl_union_pw_aff *upa);
+
+A multiple expression can be created from a list
+of base expression in a specified space.
+The domain of this space needs to be the same
+as the domains of the base expressions in the list.
+If the base expressions have a set space (or no associated space),
+then this space also needs to be a set space.
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_from_id_list(
+		__isl_take isl_space *space,
+		__isl_take isl_id_list *list);
+	__isl_give isl_multi_id *isl_space_multi_id(
+		__isl_take isl_space *space,
+		__isl_take isl_id_list *list);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_from_val_list(
+		__isl_take isl_space *space,
+		__isl_take isl_val_list *list);
+	__isl_give isl_multi_val *isl_space_multi_val(
+		__isl_take isl_space *space,
+		__isl_take isl_val_list *list);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
+		__isl_take isl_space *space,
+		__isl_take isl_aff_list *list);
+	__isl_give isl_multi_aff *isl_space_multi_aff(
+		__isl_take isl_space *space,
+		__isl_take isl_aff_list *list);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_from_pw_aff_list(
+		__isl_take isl_space *space,
+		__isl_take isl_pw_aff_list *list);
+	__isl_give isl_multi_pw_aff *
+	isl_space_multi_pw_aff(
+		__isl_take isl_space *space,
+		__isl_take isl_pw_aff_list *list);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_union_pw_aff_list(
+		__isl_take isl_space *space,
+		__isl_take isl_union_pw_aff_list *list);
+	__isl_give isl_multi_union_pw_aff *
+	isl_space_multi_union_pw_aff(
+		__isl_take isl_space *space,
+		__isl_take isl_union_pw_aff_list *list);
+
+C<isl_multi_id_from_id_list> and C<isl_space_multi_id> perform
+the same operation.
+Similarly for the pair C<isl_multi_val_from_val_list> and
+C<isl_space_multi_val>,
+for the pair C<isl_multi_aff_from_aff_list> and
+C<isl_space_multi_aff>,
+for the pair C<isl_multi_pw_aff_from_pw_aff_list> and
+C<isl_space_multi_pw_aff> and
+for the pair C<isl_multi_union_pw_aff_from_union_pw_aff_list> and
+C<isl_space_multi_union_pw_aff>.
+
+As a convenience, a multiple piecewise expression can
+also be created from a multiple expression,
+or even directly from a single base expression.
+Each piecewise expression in the result has a single
+universe cell.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_aff_to_multi_pw_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
+
+C<isl_multi_aff_to_multi_pw_aff> and
+C<isl_multi_pw_aff_from_multi_aff> perform the same operation.
+
+Similarly, a multiple union expression can be
+created from a multiple expression.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_aff_to_multi_union_pw_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_multi_pw_aff(
+		__isl_take isl_multi_pw_aff *mpa);
+
+C<isl_multi_aff_to_multi_union_pw_aff> and
+C<isl_multi_union_pw_aff_from_multi_aff> perform the same operation.
+
+A multiple quasi-affine expression can be created from
+a multiple value with a given domain space using the following
+function.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *
+	isl_multi_aff_multi_val_on_domain_space(
+		__isl_take isl_space *space,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_aff *
+	isl_space_multi_aff_on_domain_multi_val(
+		__isl_take isl_space *space,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_multi_val_on_space(
+		__isl_take isl_space *space,
+		__isl_take isl_multi_val *mv);
+
+C<isl_space_multi_aff_on_domain_multi_val> and
+C<isl_multi_aff_multi_val_on_space> are alternative names
+for C<isl_multi_aff_multi_val_on_domain_space>.
+
+Similarly,
+a multiple union piecewise affine expression can be created from
+a multiple value with a given domain or
+a (piecewise) multiple affine expression with a given domain
+using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_multi_val_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_multi_aff_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_pw_multi_aff_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_pw_multi_aff *pma);
+
+Multiple expressions can be copied and freed using
+the following functions.
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_copy(
+		__isl_keep isl_multi_id *mi);
+	__isl_null isl_multi_id *isl_multi_id_free(
+		__isl_take isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_copy(
+		__isl_keep isl_multi_val *mv);
+	__isl_null isl_multi_val *isl_multi_val_free(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_copy(
+		__isl_keep isl_multi_aff *maff);
+	__isl_null isl_multi_aff *isl_multi_aff_free(
+		__isl_take isl_multi_aff *maff);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
+		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_copy(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+	__isl_null isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_free(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+The number of base expressions in a multiple
+expression can be obtained using the following functions.
+
+	#include <isl/id.h>
+	int isl_multi_id_size(__isl_keep isl_multi_id *mi);
+
+	#include <isl/val.h>
+	isl_size isl_multi_val_size(__isl_keep isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	isl_size isl_multi_aff_size(
+		__isl_keep isl_multi_aff *multi);
+	isl_size isl_multi_pw_aff_size(
+		__isl_keep isl_multi_pw_aff *mpa);
+	isl_size isl_multi_union_pw_aff_size(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+The base expression at a given position of a multiple
+expression can be extracted using the following functions.
+
+	#include <isl/id.h>
+	__isl_give isl_id *isl_multi_id_get_at(
+		__isl_keep isl_multi_id *mi, int pos);
+	__isl_give isl_id *isl_multi_id_get_id(
+		__isl_keep isl_multi_id *mi, int pos);
+
+	#include <isl/val.h>
+	__isl_give isl_val *isl_multi_val_get_at(
+		__isl_keep isl_multi_val *mv, int pos);
+	__isl_give isl_val *isl_multi_val_get_val(
+		__isl_keep isl_multi_val *mv, int pos);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_multi_aff_get_at(
+		__isl_keep isl_multi_aff *ma, int pos);
+	__isl_give isl_aff *isl_multi_aff_get_aff(
+		__isl_keep isl_multi_aff *multi, int pos);
+	__isl_give isl_pw_aff *isl_multi_pw_aff_get_at(
+		__isl_keep isl_multi_pw_aff *mpa, int pos);
+	__isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
+		__isl_keep isl_multi_pw_aff *mpa, int pos);
+	__isl_give isl_union_pw_aff *
+	isl_multi_union_pw_aff_get_at(
+		__isl_keep isl_multi_union_pw_aff *mupa, int pos);
+	__isl_give isl_union_pw_aff *
+	isl_multi_union_pw_aff_get_union_pw_aff(
+		__isl_keep isl_multi_union_pw_aff *mupa, int pos);
+
+C<isl_multi_id_get_id> is an alternative name for C<isl_multi_id_get_at>.
+Similarly for the other pairs of functions.
+
+The base expression can be replaced using the following functions.
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_set_at(
+		__isl_take isl_multi_id *mi, int pos,
+		__isl_take isl_id *id);
+	__isl_give isl_multi_id *isl_multi_id_set_id(
+		__isl_take isl_multi_id *mi, int pos,
+		__isl_take isl_id *id);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_set_at(
+		__isl_take isl_multi_val *mv, int pos,
+		__isl_take isl_val *val);
+	__isl_give isl_multi_val *isl_multi_val_set_val(
+		__isl_take isl_multi_val *mv, int pos,
+		__isl_take isl_val *val);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_set_at(
+		__isl_take isl_multi_aff *ma, int pos,
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_aff *isl_multi_aff_set_aff(
+		__isl_take isl_multi_aff *multi, int pos,
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_at(
+		__isl_take isl_multi_pw_aff *mpa, int pos,
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_set_pw_aff(
+		__isl_take isl_multi_pw_aff *mpa, int pos,
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_at(
+		__isl_take isl_multi_union_pw_aff *mupa, int pos,
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_set_union_pw_aff(
+		__isl_take isl_multi_union_pw_aff *mupa, int pos,
+		__isl_take isl_union_pw_aff *upa);
+
+C<isl_multi_id_set_id> is an alternative name for C<isl_multi_id_set_at>.
+Similarly for the other pairs of functions.
+
+A list of all base expressions of a multiple
+expression can be extracted using the following functions.
+
+	#include <isl/id.h>
+	__isl_give isl_id_list *isl_multi_id_get_list(
+		__isl_keep isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_val_list *isl_multi_val_get_list(
+		__isl_keep isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff_list *isl_multi_aff_get_list(
+		__isl_keep isl_multi_aff *multi);
+	__isl_give isl_pw_aff_list *isl_multi_pw_aff_get_list(
+		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_give isl_union_pw_aff_list *
+	isl_multi_union_pw_aff_list(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+The constant terms of the base expressions can be obtained using
+the following function.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_val *
+	isl_multi_aff_get_constant_multi_val(
+		__isl_keep isl_multi_aff *ma);
+
+As a convenience, a sequence of base expressions that have
+their domains in a given space can be extracted from a sequence
+of union expressions using the following function.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_pw_aff *
+	isl_multi_union_pw_aff_extract_multi_pw_aff(
+		__isl_keep isl_multi_union_pw_aff *mupa,
+		__isl_take isl_space *space);
+
+Note that there is a difference between C<isl_multi_union_pw_aff>
+and C<isl_union_pw_multi_aff> objects.  The first is a sequence
+of unions of piecewise expressions, while the second is a union
+of piecewise sequences.  In particular, multiple affine expressions
+in an C<isl_union_pw_multi_aff> may live in different spaces,
+while there is only a single multiple expression in
+an C<isl_multi_union_pw_aff>, which can therefore only live
+in a single space.  This means that not every
+C<isl_union_pw_multi_aff> can be converted to
+an C<isl_multi_union_pw_aff>.  Conversely, the elements
+of an C<isl_multi_union_pw_aff> may be defined over different domains,
+while each multiple expression inside an C<isl_union_pw_multi_aff>
+has a single domain.  The conversion of an C<isl_union_pw_multi_aff>
+of dimension greater than one may therefore not be exact.
+The following functions can
+be used to perform these conversions when they are possible.
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_union_pw_aff *
+	isl_union_pw_multi_aff_as_multi_union_pw_aff(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_union_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_multi_union_pw_aff(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+C<isl_union_pw_multi_aff_as_multi_union_pw_aff> and
+C<isl_multi_union_pw_aff_from_union_pw_multi_aff>
+perform the same operation.
+
+=head3 Piecewise Expressions
+
+A piecewise expression is an expression that is described
+using zero or more base expression defined over the same
+number of cells in the domain space of the base expressions.
+All base expressions are defined over the same
+domain space and the cells are disjoint.
+The space of a piecewise expression is the same as
+that of the base expressions.
+If the union of the cells is a strict subset of the domain
+space, then the value of the piecewise expression outside
+this union is different for types derived from quasi-affine
+expressions and those derived from quasipolynomials.
+Piecewise expressions derived from quasi-affine expressions
+are considered to be undefined outside the union of their cells.
+Piecewise expressions derived from quasipolynomials
+are considered to be zero outside the union of their cells.
+
+Piecewise quasipolynomials are mainly used by the C<barvinok>
+library for representing the number of elements in a parametric set or map.
+For example, the piecewise quasipolynomial
+
+	n -> { x -> ((1 + n) - x) : x <= n and x >= 0 }
+
+represents the number of points in the map
+
+	n -> { x -> y : x,y >= 0 and 0 <= x + y <= n }
+
+The piecewise expression types defined by C<isl>
+are C<isl_pw_aff>, C<isl_pw_multi_aff>,
+C<isl_pw_qpolynomial> and C<isl_pw_qpolynomial_fold>.
+
+A piecewise expression with no cells can be created using
+the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_empty(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
+		__isl_take isl_space *space);
+
+A piecewise expression with a single universe cell can be
+created using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_pw_multi_aff *
+	isl_multi_aff_to_pw_multi_aff(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_from_qpolynomial(
+		__isl_take isl_qpolynomial *qp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_from_qpolynomial_fold(
+		__isl_take isl_qpolynomial_fold *fold);
+
+C<isl_multi_aff_to_pw_multi_aff> and C<isl_pw_multi_aff_from_multi_aff> perform
+the same operation.
+
+The inverse conversions below can only be used if the input
+expression is known to be defined over a single universe domain.
+
+	#include <isl/aff.h>
+	isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);
+	__isl_give isl_aff *isl_pw_aff_as_aff(
+		__isl_take isl_pw_aff *pa);
+	isl_bool isl_pw_multi_aff_isa_multi_aff(
+		__isl_keep isl_pw_multi_aff *pma);
+	__isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(
+		__isl_take isl_pw_multi_aff *pma);
+
+	#include <isl/polynomial.h>
+	isl_bool isl_pw_qpolynomial_isa_qpolynomial(
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	__isl_give isl_qpolynomial *
+	isl_pw_qpolynomial_as_qpolynomial(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_as_qpolynomial_fold(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+
+A piecewise expression with a single specified cell can be
+created using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_alloc(
+		__isl_take isl_set *set, __isl_take isl_aff *aff);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_aff *maff);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
+		__isl_take isl_set *set,
+		__isl_take isl_qpolynomial *qp);
+
+The following convenience functions first create a base expression and
+then create a piecewise expression over a universe domain.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
+		__isl_take isl_local_space *ls);
+	__isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
+		__isl_take isl_local_space *ls,
 		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
+		__isl_take isl_local_space *ls);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_identity_on_domain_space(
+		__isl_take isl_space *space)
+	__isl_give isl_pw_multi_aff *
+	isl_space_identity_pw_multi_aff_on_domain(
+		__isl_take isl_space *space)
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *
+	isl_space_domain_map_pw_multi_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *
+	isl_space_range_map_pw_multi_aff(
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_project_out_map(
+		__isl_take isl_space *space,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
 
-The identifiers or names of the domain and range spaces of a set
-or relation can be read off or set using the following functions.
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
+		__isl_take isl_space *space);
 
-	__isl_give isl_basic_set *isl_basic_set_set_tuple_id(
-		__isl_take isl_basic_set *bset,
+C<isl_pw_multi_aff_identity_on_domain_space> and
+C<isl_space_identity_pw_multi_aff_on_domain>
+perform the same operation.
+Similarly
+for the pair C<isl_pw_multi_aff_domain_map> and
+C<isl_space_domain_map_pw_multi_aff> and
+for the pair C<isl_pw_multi_aff_range_map> and
+C<isl_space_range_map_pw_multi_aff>.
+
+The following convenience functions first create a base expression and
+then create a piecewise expression over a given domain.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(
+		__isl_take isl_set *domain,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_multi_val_on_domain(
+		__isl_take isl_set *domain,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_pw_multi_aff *
+	isl_set_pw_multi_aff_on_domain_multi_val(
+		__isl_take isl_set *domain,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
+		__isl_take isl_set *domain,
 		__isl_take isl_id *id);
-	__isl_give isl_set *isl_set_set_tuple_id(
-		__isl_take isl_set *set, __isl_take isl_id *id);
-	__isl_give isl_set *isl_set_reset_tuple_id(
-		__isl_take isl_set *set);
-	int isl_set_has_tuple_id(__isl_keep isl_set *set);
-	__isl_give isl_id *isl_set_get_tuple_id(
-		__isl_keep isl_set *set);
-	__isl_give isl_basic_map *isl_basic_map_set_tuple_id(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_map *isl_map_set_tuple_id(
-		__isl_take isl_map *map, enum isl_dim_type type,
+
+C<isl_set_pw_multi_aff_on_domain_multi_val> is an alternative name
+for C<isl_pw_multi_aff_multi_val_on_domain>.
+
+As a convenience, a piecewise multiple expression can
+also be created from a piecewise expression.
+Each multiple expression in the result is derived
+from the corresponding base expression.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
+		__isl_take isl_pw_aff *pa);
+
+Similarly, a piecewise quasipolynomial can be
+created from a piecewise quasi-affine expression using
+the following function.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_from_pw_aff(
+		__isl_take isl_pw_aff *pwaff);
+
+Piecewise expressions can be copied and freed using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_copy(
+		__isl_keep isl_pw_aff *pwaff);
+	__isl_null isl_pw_aff *isl_pw_aff_free(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
+		__isl_keep isl_pw_multi_aff *pma);
+	__isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
+		__isl_take isl_pw_multi_aff *pma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	__isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_copy(
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	__isl_null isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_free(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+
+To iterate over the different cells of a piecewise expression,
+use the following functions.
+
+	#include <isl/aff.h>
+	isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
+	isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
+	isl_stat isl_pw_aff_foreach_piece(
+		__isl_keep isl_pw_aff *pwaff,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			  __isl_take isl_aff *aff,
+			  void *user), void *user);
+	isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,
+		isl_bool (*test)(__isl_keep isl_set *set,
+			__isl_keep isl_aff *aff, void *user),
+			void *user);
+	isl_size isl_pw_multi_aff_n_piece(
+		__isl_keep isl_pw_multi_aff *pma);
+	isl_stat isl_pw_multi_aff_foreach_piece(
+		__isl_keep isl_pw_multi_aff *pma,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			    __isl_take isl_multi_aff *maff,
+			    void *user), void *user);
+	isl_bool isl_pw_multi_aff_every_piece(
+		__isl_keep isl_pw_multi_aff *pma,
+		isl_bool (*test)(__isl_keep isl_set *set,
+			__isl_keep isl_multi_aff *ma, void *user),
+			void *user);
+
+	#include <isl/polynomial.h>
+	isl_size isl_pw_qpolynomial_n_piece(
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	isl_stat isl_pw_qpolynomial_foreach_piece(
+		__isl_keep isl_pw_qpolynomial *pwqp,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			  __isl_take isl_qpolynomial *qp,
+			  void *user), void *user);
+	isl_bool isl_pw_qpolynomial_every_piece(
+		__isl_keep isl_pw_qpolynomial *pwqp,
+		isl_bool (*test)(__isl_keep isl_set *set,
+			__isl_keep isl_qpolynomial *qp,
+			void *user), void *user);
+	isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
+		__isl_keep isl_pw_qpolynomial *pwqp,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			  __isl_take isl_qpolynomial *qp,
+			  void *user), void *user);
+	isl_size isl_pw_qpolynomial_fold_n_piece(
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	isl_stat isl_pw_qpolynomial_fold_foreach_piece(
+		__isl_keep isl_pw_qpolynomial_fold *pwf,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			  __isl_take isl_qpolynomial_fold *fold,
+			  void *user), void *user);
+	isl_bool isl_pw_qpolynomial_fold_every_piece(
+		__isl_keep isl_pw_qpolynomial_fold *pwf,
+		isl_bool (*test)(__isl_keep isl_set *set,
+			__isl_keep isl_qpolynomial_fold *fold,
+			void *user), void *user);
+	isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
+		__isl_keep isl_pw_qpolynomial_fold *pwf,
+		isl_stat (*fn)(__isl_take isl_set *set,
+			  __isl_take isl_qpolynomial_fold *fold,
+			  void *user), void *user);
+
+As usual, the function C<fn> should return C<isl_stat_ok> on success
+and C<isl_stat_error> on failure.  The difference between
+C<isl_pw_qpolynomial_foreach_piece> and
+C<isl_pw_qpolynomial_foreach_lifted_piece> is that
+C<isl_pw_qpolynomial_foreach_lifted_piece> will first
+compute unique representations for all existentially quantified
+variables and then turn these existentially quantified variables
+into extra set variables, adapting the associated quasipolynomial
+accordingly.  This means that the C<set> passed to C<fn>
+will not have any existentially quantified variables, but that
+the dimensions of the sets may be different for different
+invocations of C<fn>.
+Similarly for C<isl_pw_qpolynomial_fold_foreach_piece>
+and C<isl_pw_qpolynomial_fold_foreach_lifted_piece>.
+The function C<isl_pw_aff_every_piece> and its variants
+check whether each call to the callback returns true and
+stop checking as soon as one of these calls returns false (or error).
+
+A piecewise expression consisting of the expressions at a given
+position of a piecewise multiple expression can be extracted
+using the following function.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
+		__isl_keep isl_pw_multi_aff *pma, int pos);
+	__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
+		__isl_keep isl_pw_multi_aff *pma, int pos);
+
+C<isl_pw_multi_aff_get_pw_aff> is an alternative name for
+C<isl_pw_multi_aff_get_at>.
+
+These expressions can be replaced using the following function.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
+		__isl_take isl_pw_multi_aff *pma, unsigned pos,
+		__isl_take isl_pw_aff *pa);
+
+Note that there is a difference between C<isl_multi_pw_aff> and
+C<isl_pw_multi_aff> objects.  The first is a sequence of piecewise
+affine expressions, while the second is a piecewise sequence
+of affine expressions.  In particular, each of the piecewise
+affine expressions in an C<isl_multi_pw_aff> may have a different
+domain, while all multiple expressions associated to a cell
+in an C<isl_pw_multi_aff> have the same domain.
+It is possible to convert between the two, but when converting
+an C<isl_multi_pw_aff> to an C<isl_pw_multi_aff>, the domain
+of the result is the intersection of the domains of the input.
+The reverse conversion is exact.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_from_multi_pw_aff(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_pw_aff *
+	isl_pw_multi_aff_to_multi_pw_aff(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_from_pw_multi_aff(
+		__isl_take isl_pw_multi_aff *pma);
+
+C<isl_pw_multi_aff_to_multi_pw_aff> and
+C<isl_multi_pw_aff_from_pw_multi_aff> perform the same operation.
+
+=head3 Union Expressions
+
+A union expression collects base expressions defined
+over different domains.  The space of a union expression
+is that of the shared parameter space.
+
+The union expression types defined by C<isl>
+are C<isl_union_pw_aff>, C<isl_union_pw_multi_aff>,
+C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>.
+In case of
+C<isl_union_pw_aff>,
+C<isl_union_pw_qpolynomial> and C<isl_union_pw_qpolynomial_fold>,
+there can be at most one base expression for a given domain space.
+In case of
+C<isl_union_pw_multi_aff>,
+there can be multiple such expressions for a given domain space,
+but the domains of these expressions need to be disjoint.
+
+An empty union expression can be created using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_empty_ctx(
+		isl_ctx *ctx);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_empty_space(
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_empty_ctx(
+		isl_ctx *ctx);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_empty_space(
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_empty(
+		__isl_take isl_space *space);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_zero_ctx(
+		isl_ctx *ctx);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_zero_space(
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_zero(
+		__isl_take isl_space *space);
+
+C<isl_union_pw_aff_empty> is an alternative name for
+C<isl_union_pw_aff_empty_space>.
+Similarly for the other pairs of functions.
+
+A union expression containing a single base expression
+can be created using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *
+	isl_pw_aff_to_union_pw_aff(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_from_pw_aff(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_union_pw_multi_aff *
+	isl_pw_multi_aff_to_union_pw_multi_aff(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_pw_multi_aff(
+		__isl_take isl_pw_multi_aff *pma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_pw_qpolynomial_to_union_pw_qpolynomial(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_from_pw_qpolynomial(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+
+C<isl_pw_aff_to_union_pw_aff> and C<isl_union_pw_aff_from_pw_aff> perform
+the same operation.
+Similarly for C<isl_pw_multi_aff_to_union_pw_multi_aff> and
+C<isl_union_pw_multi_aff_from_pw_multi_aff>,
+for
+C<isl_pw_qpolynomial_to_union_pw_qpolynomial> and
+C<isl_union_pw_qpolynomial_from_pw_qpolynomial>, and
+for
+C<isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold> and
+C<isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold>.
+
+The inverse conversions below can only be used if the input
+expression is known to live in exactly one space.
+
+	#include <isl/aff.h>
+	isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	__isl_give isl_pw_multi_aff *
+	isl_union_pw_multi_aff_as_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma);
+
+A union piecewise expression containing a single base expression
+on a universe domain can also be created directly from
+a base expression using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(
+		__isl_take isl_aff *aff);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_multi_aff(
+		__isl_take isl_multi_aff *ma);
+
+The following functions create a base expression on each
+of the sets in the union set and collect the results.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_union_pw_aff(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_multi_aff_get_union_pw_aff(
+		__isl_keep isl_union_pw_multi_aff *upma, int pos);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_val_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_multi_val_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_param_on_domain_id(
+		__isl_take isl_union_set *domain,
 		__isl_take isl_id *id);
-	__isl_give isl_map *isl_map_reset_tuple_id(
-		__isl_take isl_map *map, enum isl_dim_type type);
-	int isl_map_has_tuple_id(__isl_keep isl_map *map,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_map_get_tuple_id(
-		__isl_keep isl_map *map, enum isl_dim_type type);
 
-	const char *isl_basic_set_get_tuple_name(
+The C<id> argument of C<isl_union_pw_aff_param_on_domain_id>
+is the identifier of a parameter that may or may not already
+be present in C<domain>.
+
+An C<isl_union_pw_aff> that is equal to a (parametric) affine
+or piecewise affine
+expression on a given domain can be created using the following
+functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_aff_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_aff *aff);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_pw_aff_on_domain(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_pw_aff *pa);
+
+A base expression can be added to a union expression using
+the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_add_pw_aff(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_add_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_pw_multi_aff *pma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_add_pw_qpolynomial(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_pw_qpolynomial *pwqp);
+
+Union expressions can be copied and freed using
+the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
+		__isl_keep isl_union_pw_aff *upa);
+	__isl_null isl_union_pw_aff *isl_union_pw_aff_free(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_copy(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	__isl_null isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_free(
+		__isl_take isl_union_pw_multi_aff *upma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_copy(
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
+	__isl_null isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_free(
+		__isl_take isl_union_pw_qpolynomial *upwqp);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_copy(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+	__isl_null isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_free(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf);
+
+To iterate over the base expressions in a union expression,
+use the following functions.
+
+	#include <isl/aff.h>
+	isl_size isl_union_pw_aff_n_pw_aff(
+		__isl_keep isl_union_pw_aff *upa);
+	isl_stat isl_union_pw_aff_foreach_pw_aff(
+		__isl_keep isl_union_pw_aff *upa,
+		isl_stat (*fn)(__isl_take isl_pw_aff *pa,
+			void *user), void *user);
+	isl_bool isl_union_pw_aff_every_pw_aff(
+		__isl_keep isl_union_pw_aff *upa,
+		isl_bool (*test)(__isl_keep isl_pw_aff *pa,
+			void *user), void *user);
+	isl_size isl_union_pw_multi_aff_n_pw_multi_aff(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
+		__isl_keep isl_union_pw_multi_aff *upma,
+		isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma,
+			    void *user), void *user);
+	isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(
+		__isl_keep isl_union_pw_multi_aff *upma,
+		isl_bool (*test)(
+			__isl_keep isl_pw_multi_aff *pma,
+			void *user), void *user);
+
+	#include <isl/polynomial.h>
+	isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
+	isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
+		__isl_keep isl_union_pw_qpolynomial *upwqp,
+		isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp,
+			    void *user), void *user);
+	isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(
+		__isl_keep isl_union_pw_qpolynomial *upwqp,
+		isl_bool (*test)(
+			__isl_keep isl_pw_qpolynomial *pwqp,
+			void *user), void *user);
+	isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+	isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+		isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
+			    void *user), void *user);
+	isl_bool
+	isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+		isl_bool (*test)(
+			__isl_keep isl_pw_qpolynomial_fold *pwf,
+			void *user), void *user);
+
+To extract the base expression in a given space from a union, use
+the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
+		__isl_keep isl_union_pw_aff *upa,
+		__isl_take isl_space *space);
+	__isl_give isl_pw_multi_aff *
+	isl_union_pw_multi_aff_extract_pw_multi_aff(
+		__isl_keep isl_union_pw_multi_aff *upma,
+		__isl_take isl_space *space);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_union_pw_qpolynomial_extract_pw_qpolynomial(
+		__isl_keep isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_space *space);
+
+It is also possible to obtain a list of the base expressions using
+the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff_list *
+	isl_union_pw_aff_get_pw_aff_list(
+		__isl_keep isl_union_pw_aff *upa);
+	__isl_give isl_pw_multi_aff_list *
+	isl_union_pw_multi_aff_get_pw_multi_aff_list(
+		__isl_keep isl_union_pw_multi_aff *upma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial_list *
+	isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
+	__isl_give isl_pw_qpolynomial_fold_list *
+	isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+
+The returned list can be manipulated using the functions in L<"Lists">.
+
+=head2 Input and Output
+
+For set and relation,
+C<isl> supports its own input/output format, which is similar
+to the C<Omega> format, but also supports the C<PolyLib> format
+in some cases.
+For other object types, typically only an C<isl> format is supported.
+
+=head3 C<isl> format
+
+The C<isl> format is similar to that of C<Omega>, but has a different
+syntax for describing the parameters and allows for the definition
+of an existentially quantified variable as the integer division
+of an affine expression.
+For example, the set of integers C<i> between C<0> and C<n>
+such that C<i % 10 <= 6> can be described as
+
+	n -> { i : exists (a = i/10 : 0 <= i and i <= n and
+				i - 10 a <= 6) }
+
+A set or relation can have several disjuncts, separated
+by the keyword C<or>.  Each disjunct is either a conjunction
+of constraints or a projection (C<exists>) of a conjunction
+of constraints.  The constraints are separated by the keyword
+C<and>.
+
+=head3 C<PolyLib> format
+
+If the represented set is a union, then the first line
+contains a single number representing the number of disjuncts.
+Otherwise, a line containing the number C<1> is optional.
+
+Each disjunct is represented by a matrix of constraints.
+The first line contains two numbers representing
+the number of rows and columns,
+where the number of rows is equal to the number of constraints
+and the number of columns is equal to two plus the number of variables.
+The following lines contain the actual rows of the constraint matrix.
+In each row, the first column indicates whether the constraint
+is an equality (C<0>) or inequality (C<1>).  The final column
+corresponds to the constant term.
+
+If the set is parametric, then the coefficients of the parameters
+appear in the last columns before the constant column.
+The coefficients of any existentially quantified variables appear
+between those of the set variables and those of the parameters.
+
+=head3 Extended C<PolyLib> format
+
+The extended C<PolyLib> format is nearly identical to the
+C<PolyLib> format.  The only difference is that the line
+containing the number of rows and columns of a constraint matrix
+also contains four additional numbers:
+the number of output dimensions, the number of input dimensions,
+the number of local dimensions (i.e., the number of existentially
+quantified variables) and the number of parameters.
+For sets, the number of ``output'' dimensions is equal
+to the number of set dimensions, while the number of ``input''
+dimensions is zero.
+
+=head3 Input
+
+Objects can be read from input using the following functions.
+
+	#include <isl/id.h>
+	__isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx,
+		const char *str);
+	__isl_give isl_multi_id *isl_multi_id_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	#include <isl/val.h>
+	__isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx,
+		const char *str);
+	__isl_give isl_multi_val *isl_multi_val_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	#include <isl/set.h>
+	__isl_give isl_basic_set *isl_basic_set_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_basic_set *isl_basic_set_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_set *isl_set_read_from_file(isl_ctx *ctx,
+		FILE *input);
+	__isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx,
+		const char *str);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_basic_map *isl_basic_map_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_map *isl_map_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx,
+		const char *str);
+
+	#include <isl/union_set.h>
+	__isl_give isl_union_set *isl_union_set_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_union_set *isl_union_set_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_union_map *isl_union_map_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_multi_aff *isl_multi_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_pw_aff *isl_pw_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_read_from_str(
+		isl_ctx *ctx, const char *str);
+
+For sets and relations,
+the input format is autodetected and may be either the C<PolyLib> format
+or the C<isl> format.
+
+=head3 Output
+
+Before anything can be printed, an C<isl_printer> needs to
+be created.
+
+	__isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx,
+		FILE *file);
+	__isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
+	__isl_null isl_printer *isl_printer_free(
+		__isl_take isl_printer *printer);
+
+C<isl_printer_to_file> prints to the given file, while
+C<isl_printer_to_str> prints to a string that can be extracted
+using the following function.
+
+	#include <isl/printer.h>
+	__isl_give char *isl_printer_get_str(
+		__isl_keep isl_printer *printer);
+
+The printer can be inspected using the following functions.
+
+	FILE *isl_printer_get_file(
+		__isl_keep isl_printer *printer);
+	int isl_printer_get_output_format(
+		__isl_keep isl_printer *p);
+	int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
+
+The behavior of the printer can be modified in various ways
+
+	__isl_give isl_printer *isl_printer_set_output_format(
+		__isl_take isl_printer *p, int output_format);
+	__isl_give isl_printer *isl_printer_set_indent(
+		__isl_take isl_printer *p, int indent);
+	__isl_give isl_printer *isl_printer_set_indent_prefix(
+		__isl_take isl_printer *p, const char *prefix);
+	__isl_give isl_printer *isl_printer_indent(
+		__isl_take isl_printer *p, int indent);
+	__isl_give isl_printer *isl_printer_set_prefix(
+		__isl_take isl_printer *p, const char *prefix);
+	__isl_give isl_printer *isl_printer_set_suffix(
+		__isl_take isl_printer *p, const char *suffix);
+	__isl_give isl_printer *isl_printer_set_yaml_style(
+		__isl_take isl_printer *p, int yaml_style);
+
+The C<output_format> may be either C<ISL_FORMAT_ISL>, C<ISL_FORMAT_OMEGA>,
+C<ISL_FORMAT_POLYLIB>, C<ISL_FORMAT_EXT_POLYLIB> or C<ISL_FORMAT_LATEX>
+and defaults to C<ISL_FORMAT_ISL>.
+Each line in the output is prefixed by C<indent_prefix>,
+indented by C<indent> (set by C<isl_printer_set_indent>) spaces
+(default: 0), prefixed by C<prefix> and suffixed by C<suffix>.
+In the C<PolyLib> format output,
+the coefficients of the existentially quantified variables
+appear between those of the set variables and those
+of the parameters.
+The function C<isl_printer_indent> increases the indentation
+by the specified amount (which may be negative).
+The YAML style may be either C<ISL_YAML_STYLE_BLOCK> or
+C<ISL_YAML_STYLE_FLOW> and when we are printing something
+in YAML format.
+
+To actually print something, use
+
+	#include <isl/printer.h>
+	__isl_give isl_printer *isl_printer_print_double(
+		__isl_take isl_printer *p, double d);
+
+	#include <isl/val.h>
+	__isl_give isl_printer *isl_printer_print_val(
+		__isl_take isl_printer *p, __isl_keep isl_val *v);
+
+	#include <isl/set.h>
+	__isl_give isl_printer *isl_printer_print_basic_set(
+		__isl_take isl_printer *printer,
 		__isl_keep isl_basic_set *bset);
-	__isl_give isl_basic_set *isl_basic_set_set_tuple_name(
-		__isl_take isl_basic_set *set, const char *s);
-	int isl_set_has_tuple_name(__isl_keep isl_set *set);
-	const char *isl_set_get_tuple_name(
+	__isl_give isl_printer *isl_printer_print_set(
+		__isl_take isl_printer *printer,
 		__isl_keep isl_set *set);
-	__isl_give isl_set *isl_set_set_tuple_name(
-		__isl_take isl_set *set, const char *s);
-	const char *isl_basic_map_get_tuple_name(
-		__isl_keep isl_basic_map *bmap,
-		enum isl_dim_type type);
-	__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, const char *s);
-	int isl_map_has_tuple_name(__isl_keep isl_map *map,
-		enum isl_dim_type type);
-	const char *isl_map_get_tuple_name(
-		__isl_keep isl_map *map,
-		enum isl_dim_type type);
-	__isl_give isl_map *isl_map_set_tuple_name(
-		__isl_take isl_map *map,
-		enum isl_dim_type type, const char *s);
 
-As with C<isl_space_get_tuple_name>, the value returned points to
-an internal data structure.
-The identifiers, positions or names of individual dimensions can be
-read off using the following functions.
+	#include <isl/map.h>
+	__isl_give isl_printer *isl_printer_print_basic_map(
+		__isl_take isl_printer *printer,
+		__isl_keep isl_basic_map *bmap);
+	__isl_give isl_printer *isl_printer_print_map(
+		__isl_take isl_printer *printer,
+		__isl_keep isl_map *map);
 
-	__isl_give isl_id *isl_basic_set_get_dim_id(
-		__isl_keep isl_basic_set *bset,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_set *isl_set_set_dim_id(
-		__isl_take isl_set *set, enum isl_dim_type type,
-		unsigned pos, __isl_take isl_id *id);
-	int isl_set_has_dim_id(__isl_keep isl_set *set,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_set_get_dim_id(
-		__isl_keep isl_set *set, enum isl_dim_type type,
-		unsigned pos);
-	int isl_basic_map_has_dim_id(
-		__isl_keep isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_map *isl_map_set_dim_id(
-		__isl_take isl_map *map, enum isl_dim_type type,
-		unsigned pos, __isl_take isl_id *id);
-	int isl_map_has_dim_id(__isl_keep isl_map *map,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_map_get_dim_id(
-		__isl_keep isl_map *map, enum isl_dim_type type,
-		unsigned pos);
-	__isl_give isl_id *isl_union_map_get_dim_id(
-		__isl_keep isl_union_map *umap,
-		enum isl_dim_type type, unsigned pos);
+	#include <isl/union_set.h>
+	__isl_give isl_printer *isl_printer_print_union_set(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_set *uset);
 
-	int isl_set_find_dim_by_id(__isl_keep isl_set *set,
-		enum isl_dim_type type, __isl_keep isl_id *id);
-	int isl_map_find_dim_by_id(__isl_keep isl_map *map,
-		enum isl_dim_type type, __isl_keep isl_id *id);
-	int isl_set_find_dim_by_name(__isl_keep isl_set *set,
-		enum isl_dim_type type, const char *name);
-	int isl_map_find_dim_by_name(__isl_keep isl_map *map,
-		enum isl_dim_type type, const char *name);
+	#include <isl/union_map.h>
+	__isl_give isl_printer *isl_printer_print_union_map(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_map *umap);
 
-	const char *isl_constraint_get_dim_name(
-		__isl_keep isl_constraint *constraint,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_basic_set_get_dim_name(
-		__isl_keep isl_basic_set *bset,
-		enum isl_dim_type type, unsigned pos);
-	int isl_set_has_dim_name(__isl_keep isl_set *set,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_set_get_dim_name(
-		__isl_keep isl_set *set,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_basic_map_get_dim_name(
-		__isl_keep isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos);
-	int isl_map_has_dim_name(__isl_keep isl_map *map,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_map_get_dim_name(
-		__isl_keep isl_map *map,
-		enum isl_dim_type type, unsigned pos);
+	#include <isl/val.h>
+	__isl_give isl_printer *isl_printer_print_multi_val(
+		__isl_take isl_printer *p,
+		__isl_keep isl_multi_val *mv);
 
-These functions are mostly useful to obtain the identifiers, positions
-or names of the parameters.  Identifiers of individual dimensions are
-essentially only useful for printing.  They are ignored by all other
-operations and may not be preserved across those operations.
+	#include <isl/id.h>
+	__isl_give isl_printer *isl_printer_print_multi_id(
+		__isl_take isl_printer *p,
+		__isl_keep isl_multi_id *mi);
 
-The user pointers on all parameters and tuples can be reset
-using the following functions.
+	#include <isl/aff.h>
+	__isl_give isl_printer *isl_printer_print_aff(
+		__isl_take isl_printer *p, __isl_keep isl_aff *aff);
+	__isl_give isl_printer *isl_printer_print_multi_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_multi_aff *maff);
+	__isl_give isl_printer *isl_printer_print_pw_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_pw_aff *pwaff);
+	__isl_give isl_printer *isl_printer_print_pw_multi_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_pw_multi_aff *pma);
+	__isl_give isl_printer *isl_printer_print_multi_pw_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_give isl_printer *isl_printer_print_union_pw_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_pw_aff *upa);
+	__isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_pw_multi_aff *upma);
+	__isl_give isl_printer *
+	isl_printer_print_multi_union_pw_aff(
+		__isl_take isl_printer *p,
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_printer *isl_printer_print_qpolynomial(
+		__isl_take isl_printer *p,
+		__isl_keep isl_qpolynomial *qp);
+	__isl_give isl_printer *isl_printer_print_pw_qpolynomial(
+		__isl_take isl_printer *p,
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	__isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
+
+	__isl_give isl_printer *
+	isl_printer_print_pw_qpolynomial_fold(
+		__isl_take isl_printer *p,
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_printer *
+	isl_printer_print_union_pw_qpolynomial_fold(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+
+For C<isl_printer_print_qpolynomial>,
+C<isl_printer_print_pw_qpolynomial> and
+C<isl_printer_print_pw_qpolynomial_fold>,
+the output format of the printer
+needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
+For C<isl_printer_print_union_pw_qpolynomial> and
+C<isl_printer_print_union_pw_qpolynomial_fold>, only C<ISL_FORMAT_ISL>
+is supported.
+In case of printing in C<ISL_FORMAT_C>, the user may want
+to set the names of all dimensions first.
+
+C<isl> also provides limited support for printing YAML documents,
+just enough for the internal use for printing such documents.
+
+	#include <isl/printer.h>
+	__isl_give isl_printer *isl_printer_yaml_start_mapping(
+		__isl_take isl_printer *p);
+	__isl_give isl_printer *isl_printer_yaml_end_mapping(
+		__isl_take isl_printer *p);
+	__isl_give isl_printer *isl_printer_yaml_start_sequence(
+		__isl_take isl_printer *p);
+	__isl_give isl_printer *isl_printer_yaml_end_sequence(
+		__isl_take isl_printer *p);
+	__isl_give isl_printer *isl_printer_yaml_next(
+		__isl_take isl_printer *p);
+
+A document is started by a call to either
+C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
+Anything printed to the printer after such a call belong to the
+first key of the mapping or the first element in the sequence.
+The function C<isl_printer_yaml_next> moves to the value if
+we are currently printing a mapping key, the next key if we
+are printing a value or the next element if we are printing
+an element in a sequence.
+Nested mappings and sequences are initiated by the same
+C<isl_printer_yaml_start_mapping> or C<isl_printer_yaml_start_sequence>.
+Each call to these functions needs to have a corresponding call to
+C<isl_printer_yaml_end_mapping> or C<isl_printer_yaml_end_sequence>.
+
+When called on a file printer, the following function flushes
+the file.  When called on a string printer, the buffer is cleared.
+
+	__isl_give isl_printer *isl_printer_flush(
+		__isl_take isl_printer *p);
+
+The following functions allow the user to attach
+notes to a printer in order to keep track of additional state.
+
+	#include <isl/printer.h>
+	isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
+		__isl_keep isl_id *id);
+	__isl_give isl_id *isl_printer_get_note(
+		__isl_keep isl_printer *p, __isl_take isl_id *id);
+	__isl_give isl_printer *isl_printer_set_note(
+		__isl_take isl_printer *p,
+		__isl_take isl_id *id, __isl_take isl_id *note);
+
+C<isl_printer_set_note> associates the given note to the given
+identifier in the printer.
+C<isl_printer_get_note> retrieves a note associated to an
+identifier, while
+C<isl_printer_has_note> checks if there is such a note.
+C<isl_printer_get_note> fails if the requested note does not exist.
+
+Alternatively, a string representation can be obtained
+directly using the following functions, which always print
+in isl format.
+
+	#include <isl/id.h>
+	__isl_give char *isl_id_to_str(
+		__isl_keep isl_id *id);
+	__isl_give char *isl_multi_id_to_str(
+		__isl_keep isl_multi_id *mi);
+
+	#include <isl/space.h>
+	__isl_give char *isl_space_to_str(
+		__isl_keep isl_space *space);
+
+	#include <isl/val.h>
+	__isl_give char *isl_val_to_str(__isl_keep isl_val *v);
+	__isl_give char *isl_multi_val_to_str(
+		__isl_keep isl_multi_val *mv);
 
 	#include <isl/set.h>
-	__isl_give isl_set *isl_set_reset_user(
-		__isl_take isl_set *set);
-	#include <isl/map.h>
-	__isl_give isl_map *isl_map_reset_user(
-		__isl_take isl_map *map);
+	__isl_give char *isl_basic_set_to_str(
+		__isl_keep isl_basic_set *bset);
+	__isl_give char *isl_set_to_str(
+		__isl_keep isl_set *set);
+
 	#include <isl/union_set.h>
-	__isl_give isl_union_set *isl_union_set_reset_user(
-		__isl_take isl_union_set *uset);
+	__isl_give char *isl_union_set_to_str(
+		__isl_keep isl_union_set *uset);
+
+	#include <isl/map.h>
+	__isl_give char *isl_basic_map_to_str(
+		__isl_keep isl_basic_map *bmap);
+	__isl_give char *isl_map_to_str(
+		__isl_keep isl_map *map);
+
 	#include <isl/union_map.h>
-	__isl_give isl_union_map *isl_union_map_reset_user(
-		__isl_take isl_union_map *umap);
+	__isl_give char *isl_union_map_to_str(
+		__isl_keep isl_union_map *umap);
+
+	#include <isl/aff.h>
+	__isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
+	__isl_give char *isl_pw_aff_to_str(
+		__isl_keep isl_pw_aff *pa);
+	__isl_give char *isl_multi_aff_to_str(
+		__isl_keep isl_multi_aff *ma);
+	__isl_give char *isl_pw_multi_aff_to_str(
+		__isl_keep isl_pw_multi_aff *pma);
+	__isl_give char *isl_multi_pw_aff_to_str(
+		__isl_keep isl_multi_pw_aff *mpa);
+	__isl_give char *isl_union_pw_aff_to_str(
+		__isl_keep isl_union_pw_aff *upa);
+	__isl_give char *isl_union_pw_multi_aff_to_str(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	__isl_give char *isl_multi_union_pw_aff_to_str(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+	#include <isl/point.h>
+	__isl_give char *isl_point_to_str(
+		__isl_keep isl_point *pnt);
+
+	#include <isl/polynomial.h>
+	__isl_give char *isl_pw_qpolynomial_to_str(
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	__isl_give char *isl_union_pw_qpolynomial_to_str(
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
 
 =head2 Properties
 
@@ -1998,51 +4647,99 @@
 any computations, but simply check if the given set or relation
 is already known to be empty.
 
-	int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
-	int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
-	int isl_set_plain_is_empty(__isl_keep isl_set *set);
-	int isl_set_is_empty(__isl_keep isl_set *set);
-	int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
-	int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
-	int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
-	int isl_map_plain_is_empty(__isl_keep isl_map *map);
-	int isl_map_is_empty(__isl_keep isl_map *map);
-	int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
+	#include <isl/set.h>
+	isl_bool isl_basic_set_plain_is_empty(
+		__isl_keep isl_basic_set *bset);
+	isl_bool isl_basic_set_is_empty(
+		__isl_keep isl_basic_set *bset);
+	isl_bool isl_set_plain_is_empty(
+		__isl_keep isl_set *set);
+	isl_bool isl_set_is_empty(__isl_keep isl_set *set);
+
+	#include <isl/union_set.h>
+	isl_bool isl_union_set_is_empty(
+		__isl_keep isl_union_set *uset);
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_plain_is_empty(
+		__isl_keep isl_basic_map *bmap);
+	isl_bool isl_basic_map_is_empty(
+		__isl_keep isl_basic_map *bmap);
+	isl_bool isl_map_plain_is_empty(
+		__isl_keep isl_map *map);
+	isl_bool isl_map_is_empty(__isl_keep isl_map *map);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_plain_is_empty(
+		__isl_keep isl_union_map *umap);
+	isl_bool isl_union_map_is_empty(
+		__isl_keep isl_union_map *umap);
+
+	#include <isl/aff.h>
+	isl_bool isl_union_pw_multi_aff_plain_is_empty(
+		__isl_keep isl_union_pw_multi_aff *upma);
 
 =item * Universality
 
-	int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
-	int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
-	int isl_set_plain_is_universe(__isl_keep isl_set *set);
+	isl_bool isl_basic_set_plain_is_universe(
+		__isl_keep isl_basic_set *bset);
+	isl_bool isl_basic_set_is_universe(
+		__isl_keep isl_basic_set *bset);
+	isl_bool isl_basic_map_plain_is_universe(
+		__isl_keep isl_basic_map *bmap);
+	isl_bool isl_basic_map_is_universe(
+		__isl_keep isl_basic_map *bmap);
+	isl_bool isl_set_plain_is_universe(
+		__isl_keep isl_set *set);
+	isl_bool isl_map_plain_is_universe(
+		__isl_keep isl_map *map);
 
 =item * Single-valuedness
 
 	#include <isl/set.h>
-	int isl_set_is_singleton(__isl_keep isl_set *set);
+	isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
 
 	#include <isl/map.h>
-	int isl_basic_map_is_single_valued(
+	isl_bool isl_basic_map_is_single_valued(
 		__isl_keep isl_basic_map *bmap);
-	int isl_map_plain_is_single_valued(
+	isl_bool isl_map_plain_is_single_valued(
 		__isl_keep isl_map *map);
-	int isl_map_is_single_valued(__isl_keep isl_map *map);
+	isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
 
 	#include <isl/union_map.h>
-	int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
+	isl_bool isl_union_map_is_single_valued(
+		__isl_keep isl_union_map *umap);
 
 =item * Injectivity
 
-	int isl_map_plain_is_injective(__isl_keep isl_map *map);
-	int isl_map_is_injective(__isl_keep isl_map *map);
-	int isl_union_map_plain_is_injective(
+	isl_bool isl_map_plain_is_injective(
+		__isl_keep isl_map *map);
+	isl_bool isl_map_is_injective(
+		__isl_keep isl_map *map);
+	isl_bool isl_union_map_plain_is_injective(
 		__isl_keep isl_union_map *umap);
-	int isl_union_map_is_injective(
+	isl_bool isl_union_map_is_injective(
 		__isl_keep isl_union_map *umap);
 
 =item * Bijectivity
 
-	int isl_map_is_bijective(__isl_keep isl_map *map);
-	int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
+	isl_bool isl_map_is_bijective(
+		__isl_keep isl_map *map);
+	isl_bool isl_union_map_is_bijective(
+		__isl_keep isl_union_map *umap);
+
+=item * Identity
+
+The following functions test whether the given relation
+only maps elements to themselves.
+
+	#include <isl/map.h>
+	isl_bool isl_map_is_identity(
+		__isl_keep isl_map *map);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_is_identity(
+		__isl_keep isl_union_map *umap);
 
 =item * Position
 
@@ -2053,6 +4750,9 @@
 	__isl_give isl_val *isl_set_plain_get_val_if_fixed(
 		__isl_keep isl_set *set,
 		enum isl_dim_type type, unsigned pos);
+	__isl_give isl_multi_val *
+	isl_set_get_plain_multi_val_if_fixed(
+		__isl_keep isl_set *set);
 	__isl_give isl_val *isl_map_plain_get_val_if_fixed(
 		__isl_keep isl_map *map,
 		enum isl_dim_type type, unsigned pos);
@@ -2060,10 +4760,12 @@
 If the set or relation obviously lies on a hyperplane where the given dimension
 has a fixed value, then return that value.
 Otherwise return NaN.
+C<isl_set_get_plain_multi_val_if_fixed> collects the results over
+all set dimensions.
 
 =item * Stride
 
-	int isl_set_dim_residue_class_val(
+	isl_stat isl_set_dim_residue_class_val(
 		__isl_keep isl_set *set,
 		int pos, __isl_give isl_val **modulo,
 		__isl_give isl_val **residue);
@@ -2076,48 +4778,222 @@
 If the dimension does not attain only a single value and if no modulo
 can be found then assign C<1> to C<*modulo> and C<1> to C<*residue>.
 
+	#include <isl/set.h>
+	__isl_give isl_stride_info *isl_set_get_stride_info(
+		__isl_keep isl_set *set, int pos);
+	__isl_give isl_val *isl_set_get_stride(
+		__isl_keep isl_set *set, int pos);
+
+	#include <isl/map.h>
+	__isl_give isl_stride_info *
+	isl_map_get_range_stride_info(
+		__isl_keep isl_map *map, int pos);
+
+Check if the values of the given set dimension are equal to
+some affine expression of the other dimensions (the offset)
+modulo some integer stride or
+check if the values of the given output dimensions are equal to
+some affine expression of the input dimensions (the offset)
+modulo some integer stride.
+If no more specific information can be found, then the stride
+is taken to be one and the offset is taken to be the zero expression.
+The function C<isl_set_get_stride> performs the same
+computation as C<isl_set_get_stride_info> but only returns the stride.
+For the other functions,
+the stride and offset can be extracted from the returned object
+using the following functions.
+
+	#include <isl/stride_info.h>
+	__isl_give isl_val *isl_stride_info_get_stride(
+		__isl_keep isl_stride_info *si);
+	__isl_give isl_aff *isl_stride_info_get_offset(
+		__isl_keep isl_stride_info *si);
+
+The stride info object can be copied and released using the following
+functions.
+
+	#include <isl/stride_info.h>
+	__isl_give isl_stride_info *isl_stride_info_copy(
+		__isl_keep isl_stride_info *si);
+	__isl_null isl_stride_info *isl_stride_info_free(
+		__isl_take isl_stride_info *si);
+
+=item * Dependence
+
+To check whether a function involves any local variables,
+i.e., integer divisions,
+the following functions can be used.
+
+	#include <isl/set.h>
+	isl_bool isl_set_involves_locals(
+		__isl_keep isl_set *set);
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_involves_locals(
+		__isl_keep isl_aff *aff);
+	isl_bool isl_multi_aff_involves_locals(
+		__isl_keep isl_multi_aff *ma);
+	isl_bool isl_pw_multi_aff_involves_locals(
+		__isl_keep isl_pw_multi_aff *pma);
+	isl_bool isl_union_pw_multi_aff_involves_locals(
+		__isl_keep isl_union_pw_multi_aff *upma);
+
+To check whether the description of a set, relation or function depends
+on a parameter or one or more given dimensions,
+the following functions can be used.
+
+	#include <isl/constraint.h>
+	isl_bool isl_constraint_involves_dims(
+		__isl_keep isl_constraint *constraint,
+		enum isl_dim_type type, unsigned first, unsigned n);
+
+	#include <isl/set.h>
+	isl_bool isl_basic_set_involves_dims(
+		__isl_keep isl_basic_set *bset,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned first, unsigned n);
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_involves_dims(
+		__isl_keep isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
+		enum isl_dim_type type, unsigned first, unsigned n);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_involves_dims(
+		__isl_keep isl_union_map *umap,
+		enum isl_dim_type type, unsigned first, unsigned n);
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_pw_aff_involves_param_id(
+		__isl_keep isl_pw_aff *pa,
+		__isl_keep isl_id *id);
+	isl_bool isl_pw_aff_involves_dims(
+		__isl_keep isl_pw_aff *pwaff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_multi_aff_involves_dims(
+		__isl_keep isl_multi_aff *ma,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_pw_multi_aff_involves_param_id(
+		__isl_keep isl_pw_multi_aff *pma,
+		__isl_keep isl_id *id);
+	isl_bool isl_pw_multi_aff_involves_dims(
+		__isl_keep isl_pw_multi_aff *pma,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_multi_pw_aff_involves_dims(
+		__isl_keep isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_multi_pw_aff_involves_param_id(
+		__isl_keep isl_multi_pw_aff *mpa,
+		__isl_keep isl_id *id);
+	isl_bool isl_multi_pw_aff_involves_param_id_list(
+		__isl_keep isl_multi_pw_aff *mpa,
+		__isl_keep isl_id_list *list);
+
+	#include <isl/polynomial.h>
+	isl_bool isl_qpolynomial_involves_dims(
+		__isl_keep isl_qpolynomial *qp,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	isl_bool isl_pw_qpolynomial_involves_param_id(
+		__isl_keep isl_pw_qpolynomial *pwqp,
+		__isl_keep isl_id *id);
+	isl_bool isl_pw_qpolynomial_fold_involves_param_id(
+		__isl_keep isl_pw_qpolynomial_fold *pwf,
+		__isl_keep isl_id *id);
+
+Similarly, the following functions can be used to check whether
+a given dimension is involved in any lower or upper bound.
+
+	#include <isl/set.h>
+	isl_bool isl_set_dim_has_any_lower_bound(
+		__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_set_dim_has_any_upper_bound(
+		__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+
+Note that these functions return true even if there is a bound on
+the dimension on only some of the basic sets of C<set>.
+To check if they have a bound for all of the basic sets in C<set>,
+use the following functions instead.
+
+	#include <isl/set.h>
+	isl_bool isl_set_dim_has_lower_bound(
+		__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+	isl_bool isl_set_dim_has_upper_bound(
+		__isl_keep isl_set *set,
+		enum isl_dim_type type, unsigned pos);
+
 =item * Space
 
 To check whether a set is a parameter domain, use this function:
 
-	int isl_set_is_params(__isl_keep isl_set *set);
-	int isl_union_set_is_params(
+	isl_bool isl_set_is_params(__isl_keep isl_set *set);
+	isl_bool isl_union_set_is_params(
 		__isl_keep isl_union_set *uset);
 
 =item * Wrapping
 
 The following functions check whether the space of the given
-(basic) set or relation range is a wrapped relation.
+(basic) set or relation domain and/or range is a wrapped relation.
 
 	#include <isl/space.h>
-	int isl_space_is_wrapping(
+	isl_bool isl_space_is_wrapping(
 		__isl_keep isl_space *space);
-	int isl_space_domain_is_wrapping(
+	isl_bool isl_space_domain_is_wrapping(
 		__isl_keep isl_space *space);
-	int isl_space_range_is_wrapping(
+	isl_bool isl_space_range_is_wrapping(
+		__isl_keep isl_space *space);
+	isl_bool isl_space_is_product(
 		__isl_keep isl_space *space);
 
 	#include <isl/set.h>
-	int isl_basic_set_is_wrapping(
+	isl_bool isl_basic_set_is_wrapping(
 		__isl_keep isl_basic_set *bset);
-	int isl_set_is_wrapping(__isl_keep isl_set *set);
+	isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
 
 	#include <isl/map.h>
-	int isl_map_domain_is_wrapping(
+	isl_bool isl_map_domain_is_wrapping(
 		__isl_keep isl_map *map);
-	int isl_map_range_is_wrapping(
+	isl_bool isl_map_range_is_wrapping(
 		__isl_keep isl_map *map);
+	isl_bool isl_map_is_product(__isl_keep isl_map *map);
+
+	#include <isl/id.h>
+	isl_bool isl_multi_id_range_is_wrapping(
+		__isl_keep isl_multi_id *mi);
+
+	#include <isl/val.h>
+	isl_bool isl_multi_val_range_is_wrapping(
+		__isl_keep isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	isl_bool isl_multi_aff_range_is_wrapping(
+		__isl_keep isl_multi_aff *ma);
+	isl_bool isl_multi_pw_aff_range_is_wrapping(
+		__isl_keep isl_multi_pw_aff *mpa);
+	isl_bool isl_multi_union_pw_aff_range_is_wrapping(
+		__isl_keep isl_multi_union_pw_aff *mupa);
 
 The input to C<isl_space_is_wrapping> should
 be the space of a set, while that of
 C<isl_space_domain_is_wrapping> and
 C<isl_space_range_is_wrapping> should be the space of a relation.
+The input to C<isl_space_is_product> can be either the space
+of a set or that of a binary relation.
+In case the input is the space of a binary relation, it checks
+whether both domain and range are wrapping.
 
 =item * Internal Product
 
-	int isl_basic_map_can_zip(
+	isl_bool isl_basic_map_can_zip(
 		__isl_keep isl_basic_map *bmap);
-	int isl_map_can_zip(__isl_keep isl_map *map);
+	isl_bool isl_map_can_zip(__isl_keep isl_map *map);
 
 Check whether the product of domain and range of the given relation
 can be computed,
@@ -2125,18 +5001,98 @@
 
 =item * Currying
 
-	int isl_basic_map_can_curry(
+	#include <isl/space.h>
+	isl_bool isl_space_can_curry(
+		__isl_keep isl_space *space);
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_can_curry(
 		__isl_keep isl_basic_map *bmap);
-	int isl_map_can_curry(__isl_keep isl_map *map);
+	isl_bool isl_map_can_curry(__isl_keep isl_map *map);
 
 Check whether the domain of the (basic) relation is a wrapped relation.
 
-	int isl_basic_map_can_uncurry(
+	#include <isl/space.h>
+	isl_bool isl_space_can_uncurry(
+		__isl_keep isl_space *space);
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_can_uncurry(
 		__isl_keep isl_basic_map *bmap);
-	int isl_map_can_uncurry(__isl_keep isl_map *map);
+	isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);
 
 Check whether the range of the (basic) relation is a wrapped relation.
 
+	#include <isl/space.h>
+	isl_bool isl_space_can_range_curry(
+		__isl_keep isl_space *space);
+
+	#include <isl/map.h>
+	isl_bool isl_map_can_range_curry(
+		__isl_keep isl_map *map);
+
+Check whether the domain of the relation wrapped in the range of
+the input is itself a wrapped relation.
+
+=item * Special Values
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
+	isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
+	isl_bool isl_multi_pw_aff_is_cst(
+		__isl_keep isl_multi_pw_aff *mpa);
+
+Check whether the given expression is a constant.
+
+	#include <isl/val.h>
+	isl_bool isl_multi_val_involves_nan(
+		__isl_keep isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
+	isl_bool isl_multi_aff_involves_nan(
+		__isl_keep isl_multi_aff *ma);
+	isl_bool isl_pw_aff_involves_nan(
+		__isl_keep isl_pw_aff *pa);
+	isl_bool isl_pw_multi_aff_involves_nan(
+		__isl_keep isl_pw_multi_aff *pma);
+	isl_bool isl_multi_pw_aff_involves_nan(
+		__isl_keep isl_multi_pw_aff *mpa);
+	isl_bool isl_union_pw_aff_involves_nan(
+		__isl_keep isl_union_pw_aff *upa);
+	isl_bool isl_union_pw_multi_aff_involves_nan(
+		__isl_keep isl_union_pw_multi_aff *upma);
+	isl_bool isl_multi_union_pw_aff_involves_nan(
+		__isl_keep isl_multi_union_pw_aff *mupa);
+
+	#include <isl/polynomial.h>
+	isl_bool isl_qpolynomial_is_nan(
+		__isl_keep isl_qpolynomial *qp);
+	isl_bool isl_qpolynomial_fold_is_nan(
+		__isl_keep isl_qpolynomial_fold *fold);
+	isl_bool isl_pw_qpolynomial_involves_nan(
+		__isl_keep isl_pw_qpolynomial *pwqp);
+	isl_bool isl_pw_qpolynomial_fold_involves_nan(
+		__isl_keep isl_pw_qpolynomial_fold *pwf);
+	isl_bool isl_union_pw_qpolynomial_involves_nan(
+		__isl_keep isl_union_pw_qpolynomial *upwqp);
+	isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+
+Check whether the given expression is equal to or involves NaN.
+
+	#include <isl/val.h>
+	isl_bool isl_multi_val_is_zero(
+		__isl_keep isl_multi_val *mv);
+
+Check whether the multiple value is zero.
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_plain_is_zero(
+		__isl_keep isl_aff *aff);
+
+Check whether the affine expression is obviously zero.
+
 =back
 
 =head3 Binary Properties
@@ -2145,74 +5101,160 @@
 
 =item * Equality
 
-	int isl_basic_set_plain_is_equal(
+The following functions check whether two objects
+represent the same set, relation or function.
+The C<plain> variants only return true if the objects
+are obviously the same.  That is, they may return false
+even if the objects are the same, but they will never
+return true if the objects are not the same.
+
+	#include <isl/set.h>
+	isl_bool isl_basic_set_plain_is_equal(
+		__isl_keep isl_basic_set *bset1,
+		__isl_keep isl_basic_set *bset2);
+	isl_bool isl_basic_set_is_equal(
 		__isl_keep isl_basic_set *bset1,
 		__isl_keep isl_basic_set *bset2);
-	int isl_set_plain_is_equal(__isl_keep isl_set *set1,
+	isl_bool isl_set_plain_is_equal(
+		__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_set_is_equal(__isl_keep isl_set *set1,
+	isl_bool isl_set_is_equal(__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_union_set_is_equal(
-		__isl_keep isl_union_set *uset1,
-		__isl_keep isl_union_set *uset2);
-	int isl_basic_map_is_equal(
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_is_equal(
 		__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
-	int isl_map_is_equal(__isl_keep isl_map *map1,
+	isl_bool isl_map_is_equal(__isl_keep isl_map *map1,
 		__isl_keep isl_map *map2);
-	int isl_map_plain_is_equal(__isl_keep isl_map *map1,
+	isl_bool isl_map_plain_is_equal(
+		__isl_keep isl_map *map1,
 		__isl_keep isl_map *map2);
-	int isl_union_map_is_equal(
+
+	#include <isl/union_set.h>
+	isl_bool isl_union_set_is_equal(
+		__isl_keep isl_union_set *uset1,
+		__isl_keep isl_union_set *uset2);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_is_equal(
 		__isl_keep isl_union_map *umap1,
 		__isl_keep isl_union_map *umap2);
 
+	#include <isl/id.h>
+	isl_bool isl_multi_id_plain_is_equal(
+		__isl_keep isl_multi_id *mi1,
+		__isl_keep isl_multi_id *mi2);
+
+	#include <isl/val.h>
+	isl_bool isl_multi_val_plain_is_equal(
+		__isl_keep isl_multi_val *mv1,
+		__isl_keep isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	isl_bool isl_aff_plain_is_equal(
+		__isl_keep isl_aff *aff1,
+		__isl_keep isl_aff *aff2);
+	isl_bool isl_multi_aff_plain_is_equal(
+		__isl_keep isl_multi_aff *maff1,
+		__isl_keep isl_multi_aff *maff2);
+	isl_bool isl_pw_aff_plain_is_equal(
+		__isl_keep isl_pw_aff *pwaff1,
+		__isl_keep isl_pw_aff *pwaff2);
+	isl_bool isl_pw_aff_is_equal(
+		__isl_keep isl_pw_aff *pa1,
+		__isl_keep isl_pw_aff *pa2);
+	isl_bool isl_pw_multi_aff_plain_is_equal(
+		__isl_keep isl_pw_multi_aff *pma1,
+		__isl_keep isl_pw_multi_aff *pma2);
+	isl_bool isl_pw_multi_aff_is_equal(
+		__isl_keep isl_pw_multi_aff *pma1,
+		__isl_keep isl_pw_multi_aff *pma2);
+	isl_bool isl_multi_pw_aff_plain_is_equal(
+		__isl_keep isl_multi_pw_aff *mpa1,
+		__isl_keep isl_multi_pw_aff *mpa2);
+	isl_bool isl_multi_pw_aff_is_equal(
+		__isl_keep isl_multi_pw_aff *mpa1,
+		__isl_keep isl_multi_pw_aff *mpa2);
+	isl_bool isl_union_pw_aff_plain_is_equal(
+		__isl_keep isl_union_pw_aff *upa1,
+		__isl_keep isl_union_pw_aff *upa2);
+	isl_bool isl_union_pw_multi_aff_plain_is_equal(
+		__isl_keep isl_union_pw_multi_aff *upma1,
+		__isl_keep isl_union_pw_multi_aff *upma2);
+	isl_bool isl_multi_union_pw_aff_plain_is_equal(
+		__isl_keep isl_multi_union_pw_aff *mupa1,
+		__isl_keep isl_multi_union_pw_aff *mupa2);
+
+	#include <isl/polynomial.h>
+	isl_bool isl_union_pw_qpolynomial_plain_is_equal(
+		__isl_keep isl_union_pw_qpolynomial *upwqp1,
+		__isl_keep isl_union_pw_qpolynomial *upwqp2);
+	isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf1,
+		__isl_keep isl_union_pw_qpolynomial_fold *upwf2);
+
 =item * Disjointness
 
-	int isl_basic_set_is_disjoint(
+	#include <isl/set.h>
+	isl_bool isl_basic_set_is_disjoint(
 		__isl_keep isl_basic_set *bset1,
 		__isl_keep isl_basic_set *bset2);
-	int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
+	isl_bool isl_set_plain_is_disjoint(
+		__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_set_is_disjoint(__isl_keep isl_set *set1,
+	isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_basic_map_is_disjoint(
+
+	#include <isl/map.h>
+	isl_bool isl_basic_map_is_disjoint(
 		__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
-	int isl_map_is_disjoint(__isl_keep isl_map *map1,
+	isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
 		__isl_keep isl_map *map2);
 
+	#include <isl/union_set.h>
+	isl_bool isl_union_set_is_disjoint(
+		__isl_keep isl_union_set *uset1,
+		__isl_keep isl_union_set *uset2);
+
+	#include <isl/union_map.h>
+	isl_bool isl_union_map_is_disjoint(
+		__isl_keep isl_union_map *umap1,
+		__isl_keep isl_union_map *umap2);
+
 =item * Subset
 
-	int isl_basic_set_is_subset(
+	isl_bool isl_basic_set_is_subset(
 		__isl_keep isl_basic_set *bset1,
 		__isl_keep isl_basic_set *bset2);
-	int isl_set_is_subset(__isl_keep isl_set *set1,
+	isl_bool isl_set_is_subset(__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_set_is_strict_subset(
+	isl_bool isl_set_is_strict_subset(
 		__isl_keep isl_set *set1,
 		__isl_keep isl_set *set2);
-	int isl_union_set_is_subset(
+	isl_bool isl_union_set_is_subset(
 		__isl_keep isl_union_set *uset1,
 		__isl_keep isl_union_set *uset2);
-	int isl_union_set_is_strict_subset(
+	isl_bool isl_union_set_is_strict_subset(
 		__isl_keep isl_union_set *uset1,
 		__isl_keep isl_union_set *uset2);
-	int isl_basic_map_is_subset(
+	isl_bool isl_basic_map_is_subset(
 		__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
-	int isl_basic_map_is_strict_subset(
+	isl_bool isl_basic_map_is_strict_subset(
 		__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
-	int isl_map_is_subset(
+	isl_bool isl_map_is_subset(
 		__isl_keep isl_map *map1,
 		__isl_keep isl_map *map2);
-	int isl_map_is_strict_subset(
+	isl_bool isl_map_is_strict_subset(
 		__isl_keep isl_map *map1,
 		__isl_keep isl_map *map2);
-	int isl_union_map_is_subset(
+	isl_bool isl_union_map_is_subset(
 		__isl_keep isl_union_map *umap1,
 		__isl_keep isl_union_map *umap2);
-	int isl_union_map_is_strict_subset(
+	isl_bool isl_union_map_is_strict_subset(
 		__isl_keep isl_union_map *umap1,
 		__isl_keep isl_union_map *umap2);
 
@@ -2258,6 +5300,19 @@
 the internal representation of the inputs has not changed), but may
 change over different versions of C<isl>.
 
+	#include <isl/aff.h>
+	int isl_multi_aff_plain_cmp(
+		__isl_keep isl_multi_aff *ma1,
+		__isl_keep isl_multi_aff *ma2);
+	int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
+		__isl_keep isl_pw_aff *pa2);
+
+The functions C<isl_multi_aff_plain_cmp> and
+C<isl_pw_aff_plain_cmp> can be used to sort C<isl_multi_aff>s and
+C<isl_pw_aff>s.  The order is not strictly defined.
+The current order sorts expressions that only involve
+earlier dimensions before those that involve later dimensions.
+
 =back
 
 =head2 Unary Operations
@@ -2273,15 +5328,131 @@
 
 =item * Inverse map
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_reverse(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_range_reverse(
+		__isl_take isl_space *space);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_reverse(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_map *isl_map_reverse(
 		__isl_take isl_map *map);
+	__isl_give isl_map *isl_map_range_reverse(
+		__isl_take isl_map *map);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_reverse(
 		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *isl_union_map_range_reverse(
+		__isl_take isl_union_map *umap);
+
+The function C<isl_space_range_reverse> reverses the relation
+that is embedded in the range of the input map space.
+The identifier of the range, if any, is only preserved
+if this embedded relation has identical input and output tuples.
+
+=item * Tuple binding
+
+The following function binds
+a tuple to a sequence of parameter identifiers, equating
+the tuple dimensions to the parameters with those identifiers and
+subsequently projecting out the tuple.
+If the original object did not reference any such parameters,
+then this means that the tuple dimensions are reinterpreted
+as parameters.
+The space of C<tuple> needs to match that of the bound tuple.
+
+	#include <isl/set.h>
+	__isl_give isl_set *isl_set_bind(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_id *tuple);
+
+	#include <isl/map.h>
+	__isl_give isl_set *isl_map_bind_domain(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_set *isl_map_bind_range(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_id *tuple);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_set *isl_union_map_bind_range(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_id *tuple);
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_bind_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_multi_aff *isl_multi_aff_bind_domain(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_bind_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_bind_domain(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_pw_aff *
+	isl_pw_aff_bind_domain_wrapped_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_bind_domain_wrapped_domain(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_bind_domain_wrapped_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_bind_domain_wrapped_domain(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_basic_set *isl_aff_bind_id(
+		__isl_take isl_aff *aff,
+		__isl_take isl_id *id);
+	__isl_give isl_set *isl_pw_aff_bind_id(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_id *id);
+	__isl_give isl_basic_set *isl_multi_aff_bind(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_set *isl_multi_pw_aff_bind(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_id *tuple);
+	__isl_give isl_union_set *isl_union_pw_aff_bind_id(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_id *id);
+	__isl_give isl_union_set *
+	isl_multi_union_pw_aff_bind(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_multi_id *tuple);
+
+Projecting out the domain of the wrapped relation in the domain
+of a function leaves the range of that wrapped relation
+in the domain of the resulting function.
+In the case of C<isl_aff_bind_id>, C<isl_pw_aff_bind_id>,
+C<isl_multi_aff_bind>, C<isl_multi_pw_aff_bind>,
+C<isl_union_pw_aff_bind_id> and
+C<isl_multi_union_pw_aff_bind>, the parameters
+are bound to the function values and the result lives
+in the domain of the input function.
 
 =item * Projection
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_range(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_params(
+		__isl_take isl_space *space);
+
 	#include <isl/local_space.h>
 	__isl_give isl_local_space *isl_local_space_domain(
 		__isl_take isl_local_space *ls);
@@ -2292,18 +5463,36 @@
 	__isl_give isl_basic_set *isl_basic_set_project_out(
 		__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_set *isl_set_project_out_param_id(
+		__isl_take isl_set *set,
+		__isl_take isl_id *id);
+	__isl_give isl_set *
+	isl_set_project_out_param_id_list(
+		__isl_take isl_set *set,
+		__isl_take isl_id_list *list);
 	__isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_set *isl_set_project_out_all_params(
+		__isl_take isl_set *set);
+	__isl_give isl_map *isl_set_project_onto_map(
+		__isl_take isl_set *set,
+		enum isl_dim_type type, unsigned first,
+		unsigned n);
 	__isl_give isl_basic_set *isl_basic_set_params(
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_set *isl_set_params(__isl_take isl_set *set);
 
+The function C<isl_set_project_onto_map> returns a relation
+that projects the input set onto the given set dimensions.
+
 	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_project_out(
 		__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned first, unsigned n);
 	__isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_map *isl_map_project_out_all_params(
+		__isl_take isl_map *map);
 	__isl_give isl_basic_set *isl_basic_map_domain(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_basic_set *isl_basic_map_range(
@@ -2315,13 +5504,26 @@
 		__isl_take isl_map *map);
 
 	#include <isl/union_set.h>
+	__isl_give isl_union_set *isl_union_set_project_out(
+		__isl_take isl_union_set *uset,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+	__isl_give isl_union_set *
+	isl_union_set_project_out_all_params(
+		__isl_take isl_union_set *uset);
 	__isl_give isl_set *isl_union_set_params(
 		__isl_take isl_union_set *uset);
 
+The function C<isl_union_set_project_out> can only project out
+parameters.
+
 	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_project_out(
 		__isl_take isl_union_map *umap,
 		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_union_map *
+	isl_union_map_project_out_all_params(
+		__isl_take isl_union_map *umap);
 	__isl_give isl_set *isl_union_map_params(
 		__isl_take isl_union_map *umap);
 	__isl_give isl_union_set *isl_union_map_domain(
@@ -2332,7 +5534,67 @@
 The function C<isl_union_map_project_out> can only project out
 parameters.
 
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_project_domain_on_params(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_project_domain_on_params(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *
+	isl_pw_aff_project_domain_on_params(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_project_domain_on_params(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_project_domain_on_params(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_set *isl_pw_aff_domain(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_set *isl_pw_multi_aff_domain(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_set *isl_multi_pw_aff_domain(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_union_set *isl_union_pw_aff_domain(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_set *isl_union_pw_multi_aff_domain(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_union_set *
+	isl_multi_union_pw_aff_domain(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_set *isl_pw_aff_params(
+		__isl_take isl_pw_aff *pwa);
+
+If no explicit domain was set on a zero-dimensional input to
+C<isl_multi_union_pw_aff_domain>, then this function will
+return a parameter set.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *
+	isl_qpolynomial_project_domain_on_params(
+		__isl_take isl_qpolynomial *qp);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_project_domain_on_params(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_project_domain_on_params(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_set *isl_pw_qpolynomial_domain(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf);
+	__isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
+		__isl_take isl_union_pw_qpolynomial *upwqp);
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_domain_map(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_range_map(
+		__isl_take isl_space *space);
+
 	#include <isl/map.h>
+	__isl_give isl_map *isl_set_wrapped_domain_map(
+		__isl_take isl_set *set);
 	__isl_give isl_basic_map *isl_basic_map_domain_map(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_basic_map *isl_basic_map_range_map(
@@ -2343,11 +5605,19 @@
 	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_domain_map(
 		__isl_take isl_union_map *umap);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_map_domain_map_union_pw_multi_aff(
+		__isl_take isl_union_map *umap);
 	__isl_give isl_union_map *isl_union_map_range_map(
 		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *
+	isl_union_set_wrapped_domain_map(
+		__isl_take isl_union_set *uset);
 
 The functions above construct a (basic, regular or union) relation
 that maps (a wrapped version of) the input relation to its domain or range.
+C<isl_set_wrapped_domain_map> maps the input set to the domain
+of its wrapped relation.
 
 =item * Elimination
 
@@ -2369,24 +5639,183 @@
 Eliminate the coefficients for the given dimensions from the constraints,
 without removing the dimensions.
 
-=item * Constructing a relation from a set
+=item * Constructing a set from a parameter domain
+
+A set space of a given dimension and with an optional name
+can be created from a parameter space using the following functions.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_add_unnamed_tuple_ui(
+		__isl_take isl_space *space, unsigned dim);
+	__isl_give isl_space *
+	isl_space_add_named_tuple_id_ui(
+		__isl_take isl_space *space,
+		__isl_take isl_id *tuple_id, unsigned dim);
+
+A set with a given tuple can be created from a parameter domain
+using the following function.
+
+	#include <isl/set.h>
+	__isl_give isl_set *isl_set_unbind_params(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_id *tuple);
+
+Any parameters with identifiers in C<tuple> are reinterpreted
+as the corresponding set dimensions.
+
+A zero-dimensional (local) space or (basic) set can be constructed
+on a given parameter domain using the following functions.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_set_from_params(
+		__isl_take isl_space *space);
+
+	#include <isl/local_space.h>
+	__isl_give isl_local_space *
+	isl_local_space_set_from_params(
+		__isl_take isl_local_space *ls);
+
+	#include <isl/set.h>
+	__isl_give isl_basic_set *isl_basic_set_from_params(
+		__isl_take isl_basic_set *bset);
+	__isl_give isl_set *isl_set_from_params(
+		__isl_take isl_set *set);
+
+=item * Constructing a relation from one or two sets
+
+A map space with a range of a given dimension and with an optional name
+can be created from a domain space using the functions
+C<isl_space_add_unnamed_tuple_ui> and C<isl_space_add_named_tuple_id_ui>
+described above.
+
+A relation with a given domain tuple can be created from a set
+that will become the range of the relation
+using the following function.
+
+	#include <isl/set.h>
+	__isl_give isl_map *
+	isl_set_unbind_params_insert_domain(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_id *domain);
+
+Any parameters with identifiers in C<domain> are reinterpreted
+as the corresponding input dimensions.
+
+Similarly, a function defined over a parameter domain can
+be converted into one defined over a set domain
+using the following functions.
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *
+	isl_aff_unbind_params_insert_domain(
+		__isl_take isl_aff *aff,
+		__isl_take isl_multi_id *domain);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_unbind_params_insert_domain(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_id *domain);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_unbind_params_insert_domain(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_id *domain);
+
+Again,
+any parameters with identifiers in C<domain> are reinterpreted
+as the corresponding input dimensions.
+
+Create a relation with the given set(s) as domain and/or range.
+If only the domain or the range is specified, then
+the range or domain of the created relation is a zero-dimensional
+flat anonymous space.
+If the case of C<isl_space_map_from_set>, the input space
+specifies both the domain and the range of the result.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_from_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_from_range(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_map_from_set(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_map_from_domain_and_range(
+		__isl_take isl_space *domain,
+		__isl_take isl_space *range);
 
 	#include <isl/local_space.h>
 	__isl_give isl_local_space *isl_local_space_from_domain(
 		__isl_take isl_local_space *ls);
 
 	#include <isl/map.h>
+	__isl_give isl_map *isl_set_insert_domain(
+		__isl_take isl_set *set,
+		__isl_take isl_space *domain);
 	__isl_give isl_map *isl_map_from_domain(
 		__isl_take isl_set *set);
 	__isl_give isl_map *isl_map_from_range(
 		__isl_take isl_set *set);
 
-Create a relation with the given set as domain or range.
-The range or domain of the created relation is a zero-dimensional
-flat anonymous space.
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_from_domain(
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_map *isl_union_map_from_range(
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_map *
+	isl_union_map_from_domain_and_range(
+		__isl_take isl_union_set *domain,
+		__isl_take isl_union_set *range);
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_from_range(
+		__isl_take isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_from_range(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *
+	isl_multi_aff_insert_domain(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_space *domain);
+	__isl_give isl_pw_aff *isl_pw_aff_insert_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_space *domain);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_insert_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_space *domain);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_insert_domain(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_space *domain);
+	__isl_give isl_aff *isl_aff_from_range(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_aff *isl_multi_aff_from_range(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_from_range(
+		__isl_take isl_pw_aff *pwa);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_range(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_domain(
+		__isl_take isl_union_set *uset);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_from_range(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_from_range(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
 
 =item * Slicing
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_fix_si(
 		__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned pos, int value);
@@ -2400,6 +5829,8 @@
 		__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos,
 		__isl_take isl_val *v);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_fix_si(
 		__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned pos, int value);
@@ -2414,15 +5845,37 @@
 		enum isl_dim_type type, unsigned pos,
 		__isl_take isl_val *v);
 
-Intersect the set or relation with the hyperplane where the given
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
+		__isl_take isl_pw_multi_aff *pma,
+		enum isl_dim_type type, unsigned pos, int value);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		enum isl_dim_type type, unsigned n,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_fix_val(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		enum isl_dim_type type, unsigned n,
+		__isl_take isl_val *v);
+
+Intersect the set, relation or function domain
+with the hyperplane where the given
 dimension has the fixed given value.
 
-	__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos, int value);
-	__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type, unsigned pos, int value);
+	#include <isl/set.h>
+	__isl_give isl_basic_set *
+	isl_basic_set_lower_bound_val(
+		__isl_take isl_basic_set *bset,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_val *value);
+	__isl_give isl_basic_set *
+	isl_basic_set_upper_bound_val(
+		__isl_take isl_basic_set *bset,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_val *value);
 	__isl_give isl_set *isl_set_lower_bound_si(
 		__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value);
@@ -2430,9 +5883,6 @@
 		__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos,
 		__isl_take isl_val *value);
-	__isl_give isl_map *isl_map_lower_bound_si(
-		__isl_take isl_map *map,
-		enum isl_dim_type type, unsigned pos, int value);
 	__isl_give isl_set *isl_set_upper_bound_si(
 		__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value);
@@ -2440,12 +5890,56 @@
 		__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos,
 		__isl_take isl_val *value);
+	__isl_give isl_set *isl_set_lower_bound_multi_val(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_val *lower);
+	__isl_give isl_set *isl_set_upper_bound_multi_val(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_val *upper);
+	__isl_give isl_set *isl_set_lower_bound_multi_pw_aff(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_pw_aff *lower);
+	__isl_give isl_set *isl_set_upper_bound_multi_pw_aff(
+		__isl_take isl_set *set,
+		__isl_take isl_multi_pw_aff *upper);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_lower_bound_si(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned pos, int value);
+	__isl_give isl_basic_map *isl_basic_map_upper_bound_si(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned pos, int value);
+	__isl_give isl_map *isl_map_lower_bound_si(
+		__isl_take isl_map *map,
+		enum isl_dim_type type, unsigned pos, int value);
 	__isl_give isl_map *isl_map_upper_bound_si(
 		__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned pos, int value);
+	__isl_give isl_map *isl_map_lower_bound_val(
+		__isl_take isl_map *map,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_val *value);
+	__isl_give isl_map *isl_map_upper_bound_val(
+		__isl_take isl_map *map,
+		enum isl_dim_type type, unsigned pos,
+		__isl_take isl_val *value);
+	__isl_give isl_map *isl_map_lower_bound_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *lower);
+	__isl_give isl_map *isl_map_upper_bound_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *upper);
 
 Intersect the set or relation with the half-space where the given
-dimension has a value bounded by the fixed given integer value.
+dimension has a value bounded by the given fixed integer value or
+symbolic constant expression.
+For functions taking a multi expression,
+this applies to all set dimensions.
+Those that bound a map, bound the range of that map.
+If the multi expression is zero-dimensional but has an explicit domain,
+then the (parameter) domain of the set or map is intersected
+with this explicit domain.
 
 	__isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
 		enum isl_dim_type type1, int pos1,
@@ -2494,15 +5988,117 @@
 Intersect the relation with the half-space where the given
 dimensions satisfy the given ordering.
 
+	#include <isl/union_set.h>
+	__isl_give isl_union_map *isl_union_map_remove_map_if(
+		__isl_take isl_union_map *umap,
+		isl_bool (*fn)(__isl_keep isl_map *map,
+			void *user), void *user);
+
+This function calls the callback function once for each
+pair of spaces for which there are elements in the input.
+If the callback returns C<isl_bool_true>, then all those elements
+are removed from the result.  The only remaining elements in the output
+are then those for which the callback returns C<isl_bool_false>.
+
+=item * Locus
+
+	#include <isl/aff.h>
+	__isl_give isl_basic_set *isl_aff_zero_basic_set(
+		__isl_take isl_aff *aff);
+	__isl_give isl_basic_set *isl_aff_neg_basic_set(
+		__isl_take isl_aff *aff);
+	__isl_give isl_set *isl_pw_aff_pos_set(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_set *isl_pw_aff_nonneg_set(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_set *isl_pw_aff_zero_set(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_set *isl_pw_aff_non_zero_set(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_union_set *
+	isl_union_pw_aff_zero_union_set(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_set *
+	isl_multi_union_pw_aff_zero_union_set(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+The function C<isl_aff_neg_basic_set> returns a basic set
+containing those elements in the domain space
+of C<aff> where C<aff> is negative.
+The function C<isl_pw_aff_nonneg_set> returns a set
+containing those elements in the domain
+of C<pwaff> where C<pwaff> is non-negative.
+The function C<isl_multi_union_pw_aff_zero_union_set>
+returns a union set containing those elements
+in the domains of its elements where they are all zero.
+
 =item * Identity
 
 	__isl_give isl_map *isl_set_identity(
 		__isl_take isl_set *set);
 	__isl_give isl_union_map *isl_union_set_identity(
 		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_set_identity_union_pw_multi_aff(
+		__isl_take isl_union_set *uset);
 
 Construct an identity relation on the given (union) set.
 
+=item * Function Extraction
+
+A piecewise quasi affine expression that is equal to 1 on a set
+and 0 outside the set can be created using the following function.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_set_indicator_function(
+		__isl_take isl_set *set);
+
+A piecewise multiple quasi affine expression can be extracted
+from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
+and the C<isl_map> is single-valued.
+In case of a conversion from an C<isl_union_map>
+to an C<isl_union_pw_multi_aff>, these properties need to hold
+in each domain space.
+A conversion to a C<isl_multi_union_pw_aff> additionally
+requires that the input is non-empty and involves only a single
+range space.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(
+		__isl_take isl_map *map);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
+		__isl_take isl_map *map);
+
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_union_set(
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_map_as_union_pw_multi_aff(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_from_union_map(
+		__isl_take isl_union_map *umap);
+
+	__isl_give isl_multi_union_pw_aff *
+	isl_union_map_as_multi_union_pw_aff(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_from_union_map(
+		__isl_take isl_union_map *umap);
+
+C<isl_map_as_pw_multi_aff> and C<isl_pw_multi_aff_from_map> perform
+the same operation.
+Similarly for C<isl_set_as_pw_multi_aff> and
+C<isl_pw_multi_aff_from_set>,
+for C<isl_union_map_as_union_pw_multi_aff> and
+C<isl_union_pw_multi_aff_from_union_map> and
+for C<isl_union_map_as_multi_union_pw_aff> and
+C<isl_multi_union_pw_aff_from_union_map>.
+
 =item * Deltas
 
 	__isl_give isl_basic_set *isl_basic_map_deltas(
@@ -2524,30 +6120,85 @@
 The functions above construct a (basic, regular or union) relation
 that maps (a wrapped version of) the input relation to its delta set.
 
+=item * Translation
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_set_translation(
+		__isl_take isl_set *deltas);
+
+This function performs essentially the opposite operation
+of C<isl_map_deltas>.  In particular, it returns pairs
+of elements in the same space that have a difference in C<deltas>.
+
 =item * Coalescing
 
-Simplify the representation of a set or relation by trying
+Simplify the representation of a set, relation or functions by trying
 to combine pairs of basic sets or relations into a single
 basic set or relation.
 
+	#include <isl/set.h>
 	__isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
+
+	#include <isl/map.h>
 	__isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
+
+	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_coalesce(
 		__isl_take isl_union_set *uset);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_coalesce(
 		__isl_take isl_union_map *umap);
 
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_coalesce(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_coalesce(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_coalesce(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_coalesce(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_coalesce(
+		__isl_take isl_union_pw_qpolynomial *upwqp);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_coalesce(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf);
+
 One of the methods for combining pairs of basic sets or relations
 can result in coefficients that are much larger than those that appear
 in the constraints of the input.  By default, the coefficients are
 not allowed to grow larger, but this can be changed by unsetting
 the following option.
 
-	int isl_options_set_coalesce_bounded_wrapping(
+	isl_stat isl_options_set_coalesce_bounded_wrapping(
 		isl_ctx *ctx, int val);
 	int isl_options_get_coalesce_bounded_wrapping(
 		isl_ctx *ctx);
 
+One of the other methods tries to combine pairs of basic sets
+with different local variables, treating them as existentially
+quantified variables even if they have known (but different)
+integer division expressions.  The result may then also have
+existentially quantified variables.  Turning on the following
+option prevents this from happening.
+
+	isl_stat isl_options_set_coalesce_preserve_locals(
+		isl_ctx *ctx, int val);
+	int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);
+
 =item * Detecting equalities
 
 	__isl_give isl_basic_set *isl_basic_set_detect_equalities(
@@ -2568,15 +6219,28 @@
 
 =item * Removing redundant constraints
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_remove_redundancies(
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_set *isl_set_remove_redundancies(
 		__isl_take isl_set *set);
+
+	#include <isl/union_set.h>
+	__isl_give isl_union_set *
+	isl_union_set_remove_redundancies(
+		__isl_take isl_union_set *uset);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_remove_redundancies(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_map *isl_map_remove_redundancies(
 		__isl_take isl_map *map);
 
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *
+	isl_union_map_remove_redundancies(
+		__isl_take isl_union_map *umap);
+
 =item * Convex hull
 
 	__isl_give isl_basic_set *isl_set_convex_hull(
@@ -2596,6 +6260,9 @@
 	__isl_give isl_basic_set *isl_set_simple_hull(
 		__isl_take isl_set *set);
 	__isl_give isl_basic_set *
+	isl_set_plain_unshifted_simple_hull(
+		__isl_take isl_set *set);
+	__isl_give isl_basic_set *
 	isl_set_unshifted_simple_hull_from_set_list(
 		__isl_take isl_set *set,
 		__isl_take isl_set_list *list);
@@ -2606,6 +6273,13 @@
 		__isl_take isl_map *map);
 	__isl_give isl_basic_map *isl_map_simple_hull(
 		__isl_take isl_map *map);
+	__isl_give isl_basic_map *
+	isl_map_plain_unshifted_simple_hull(
+		__isl_take isl_map *map);
+		__isl_give isl_basic_map *
+	isl_map_unshifted_simple_hull_from_map_list(
+		__isl_take isl_map *map,
+		__isl_take isl_map_list *list);
 
 	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_simple_hull(
@@ -2617,7 +6291,12 @@
 of the constraints describing the basic sets or relations in the input.
 In case of C<isl_set_unshifted_simple_hull>, only the original
 constraints are used, without any translation.
-In case of C<isl_set_unshifted_simple_hull_from_set_list>, the
+In case of C<isl_set_plain_unshifted_simple_hull> and
+C<isl_map_plain_unshifted_simple_hull>, the result is described
+by original constraints that are obviously satisfied
+by the entire input set or relation.
+In case of C<isl_set_unshifted_simple_hull_from_set_list> and
+C<isl_map_unshifted_simple_hull_from_map_list>, the
 constraints are taken from the elements of the second argument.
 
 =begin latex
@@ -2661,18 +6340,70 @@
 In case of union sets and relations, the polyhedral hull is computed
 per space.
 
+=item * Box hull
+
+	#include <isl/set.h>
+	__isl_give isl_fixed_box *
+	isl_set_get_simple_fixed_box_hull(
+		__isl_keep isl_set *set)
+
+	#include <isl/map.h>
+	__isl_give isl_fixed_box *
+	isl_map_get_range_simple_fixed_box_hull(
+		__isl_keep isl_map *map);
+
+These functions try to approximate the set or
+the range of the map by a box of fixed size.
+The box is described in terms of an offset living in the same space as
+the input and a size living in the set or range space.  For any element
+in the input map, the range value is greater than or equal to
+the offset applied to the domain value and the difference with
+this offset is strictly smaller than the size.
+The same holds for the elements of the input set, where
+the offset is a parametric constant value.
+If no fixed-size approximation can be found,
+an I<invalid> box is returned, i.e., one for which
+C<isl_fixed_box_is_valid> below returns false.
+
+The validity, the offset and the size of the box can be obtained using
+the following functions.
+
+	#include <isl/fixed_box.h>
+	isl_bool isl_fixed_box_is_valid(
+		__isl_keep isl_fixed_box *box);
+	__isl_give isl_multi_aff *isl_fixed_box_get_offset(
+		__isl_keep isl_fixed_box *box);
+	__isl_give isl_multi_val *isl_fixed_box_get_size(
+		__isl_keep isl_fixed_box *box);
+
+The box can be copied and freed using the following functions.
+
+	#include <isl/fixed_box.h>
+	__isl_give isl_fixed_box *isl_fixed_box_copy(
+		__isl_keep isl_fixed_box *box);
+	__isl_null isl_fixed_box *isl_fixed_box_free(
+		__isl_take isl_fixed_box *box);
+
+A representation of the information contained in an object
+of type C<isl_fixed_box> can be obtained using
+
+	#include <isl/fixed_box.h>
+	__isl_give isl_printer *isl_printer_print_fixed_box(
+		__isl_take isl_printer *p,
+		__isl_keep isl_fixed_box *box);
+	__isl_give char *isl_fixed_box_to_str(
+		__isl_keep isl_fixed_box *box);
+
+C<isl_fixed_box_to_str> prints the information in flow format.
+
 =item * Other approximations
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *
 	isl_basic_set_drop_constraints_involving_dims(
 		__isl_take isl_basic_set *bset,
 		enum isl_dim_type type,
 		unsigned first, unsigned n);
-	__isl_give isl_basic_map *
-	isl_basic_map_drop_constraints_involving_dims(
-		__isl_take isl_basic_map *bmap,
-		enum isl_dim_type type,
-		unsigned first, unsigned n);
 	__isl_give isl_basic_set *
 	isl_basic_set_drop_constraints_not_involving_dims(
 		__isl_take isl_basic_set *bset,
@@ -2683,15 +6414,49 @@
 		__isl_take isl_set *set,
 		enum isl_dim_type type,
 		unsigned first, unsigned n);
+	__isl_give isl_set *
+	isl_set_drop_constraints_not_involving_dims(
+		__isl_take isl_set *set,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *
+	isl_basic_map_drop_constraints_involving_dims(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+	__isl_give isl_basic_map *
+	isl_basic_map_drop_constraints_not_involving_dims(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
 	__isl_give isl_map *
 	isl_map_drop_constraints_involving_dims(
 		__isl_take isl_map *map,
 		enum isl_dim_type type,
 		unsigned first, unsigned n);
+	__isl_give isl_map *
+	isl_map_drop_constraints_not_involving_dims(
+		__isl_take isl_map *map,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
 
 These functions drop any constraints (not) involving the specified dimensions.
 Note that the result depends on the representation of the input.
 
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
+		__isl_take isl_pw_qpolynomial *pwqp, int sign);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_to_polynomial(
+		__isl_take isl_union_pw_qpolynomial *upwqp, int sign);
+
+Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
+the polynomial will be an overapproximation.  If C<sign> is negative,
+it will be an underapproximation.  If C<sign> is zero, the approximation
+will lie somewhere in between.
+
 =item * Feasibility
 
 	__isl_give isl_basic_set *isl_basic_set_sample(
@@ -2718,23 +6483,85 @@
 	__isl_give isl_val *isl_set_max_val(
 		__isl_keep isl_set *set,
 		__isl_keep isl_aff *obj);
+	__isl_give isl_multi_val *
+	isl_union_set_min_multi_union_pw_aff(
+		__isl_keep isl_union_set *uset,
+		__isl_keep isl_multi_union_pw_aff *obj);
 
 Compute the minimum or maximum of the integer affine expression C<obj>
-over the points in C<set>, returning the result in C<opt>.
+over the points in C<set>.
 The result is C<NULL> in case of an error, the optimal value in case
 there is one, negative infinity or infinity if the problem is unbounded and
 NaN if the problem is empty.
 
+	#include <isl/ilp.h>
+	__isl_give isl_multi_val *
+	isl_pw_multi_aff_min_multi_val(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_val *
+	isl_pw_multi_aff_max_multi_val(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_val *
+	isl_multi_pw_aff_min_multi_val(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_val *
+	isl_multi_pw_aff_max_multi_val(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_val *isl_union_pw_aff_min_val(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_val *isl_union_pw_aff_max_val(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_multi_val *
+	isl_multi_union_pw_aff_min_multi_val(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_multi_val *
+	isl_multi_union_pw_aff_max_multi_val(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+Compute the minimum or maximum of the integer affine expression
+over its definition domain.
+The result is C<NULL> in case of an error, the optimal value in case
+there is one, negative infinity or infinity if the problem is unbounded and
+NaN if the problem is empty.
+
+	#include <isl/ilp.h>
+	__isl_give isl_val *isl_basic_set_dim_max_val(
+		__isl_take isl_basic_set *bset, int pos);
+	__isl_give isl_val *isl_set_dim_min_val(
+		__isl_take isl_set *set, int pos);
+	__isl_give isl_val *isl_set_dim_max_val(
+		__isl_take isl_set *set, int pos);
+
+Return the minimal or maximal value attained by the given set dimension,
+independently of the parameter values and of any other dimensions.
+The result is C<NULL> in case of an error, the optimal value in case
+there is one, (negative) infinity if the problem is unbounded and
+NaN if the input is empty.
+
 =item * Parametric optimization
 
 	__isl_give isl_pw_aff *isl_set_dim_min(
 		__isl_take isl_set *set, int pos);
 	__isl_give isl_pw_aff *isl_set_dim_max(
 		__isl_take isl_set *set, int pos);
+	__isl_give isl_pw_aff *isl_map_dim_min(
+		__isl_take isl_map *map, int pos);
 	__isl_give isl_pw_aff *isl_map_dim_max(
 		__isl_take isl_map *map, int pos);
+	__isl_give isl_multi_pw_aff *
+	isl_set_min_multi_pw_aff(
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *
+	isl_set_max_multi_pw_aff(
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *
+	isl_map_min_multi_pw_aff(
+		__isl_take isl_map *map);
+	__isl_give isl_multi_pw_aff *
+	isl_map_max_multi_pw_aff(
+		__isl_take isl_map *map);
 
-Compute the minimum or maximum of the given set or output dimension
+Compute the minimum or maximum of the (given) set or output dimension(s)
 as a function of the parameters (and input dimensions), but independently
 of the other set or output dimensions.
 For lexicographic optimization, see L<"Lexicographic Optimization">.
@@ -2752,8 +6579,12 @@
 in future.  In particular, future implementations may use different
 dualization algorithms or skip the elimination step.
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_coefficients(
 		__isl_take isl_basic_set *bset);
+	__isl_give isl_basic_set_list *
+	isl_basic_set_list_coefficients(
+		__isl_take isl_basic_set_list *list);
 	__isl_give isl_basic_set *isl_set_coefficients(
 		__isl_take isl_set *set);
 	__isl_give isl_union_set *isl_union_set_coefficients(
@@ -2780,9 +6611,9 @@
 of C<map> is computed.
 
 	__isl_give isl_map *isl_map_power(__isl_take isl_map *map,
-		int *exact);
+		isl_bool *exact);
 	__isl_give isl_union_map *isl_union_map_power(
-		__isl_take isl_union_map *umap, int *exact);
+		__isl_take isl_union_map *umap, isl_bool *exact);
 
 Compute a parametric representation for all positive powers I<k> of C<map>.
 The result maps I<k> to a nested relation corresponding to the
@@ -2793,9 +6624,9 @@
 =item * Transitive closure
 
 	__isl_give isl_map *isl_map_transitive_closure(
-		__isl_take isl_map *map, int *exact);
+		__isl_take isl_map *map, isl_bool *exact);
 	__isl_give isl_union_map *isl_union_map_transitive_closure(
-		__isl_take isl_union_map *umap, int *exact);
+		__isl_take isl_union_map *umap, isl_bool *exact);
 
 Compute the transitive closure of C<map>.
 The result may be an overapproximation.  If the result is known to be exact,
@@ -2804,7 +6635,7 @@
 =item * Reaching path lengths
 
 	__isl_give isl_map *isl_map_reaching_path_lengths(
-		__isl_take isl_map *map, int *exact);
+		__isl_take isl_map *map, isl_bool *exact);
 
 Compute a relation that maps each element in the range of C<map>
 to the lengths of all paths composed of edges in C<map> that
@@ -2828,6 +6659,10 @@
 	__isl_give isl_space *isl_space_unwrap(
 		__isl_take isl_space *space);
 
+	#include <isl/local_space.h>
+	__isl_give isl_local_space *isl_local_space_wrap(
+		__isl_take isl_local_space *ls);
+
 	#include <isl/set.h>
 	__isl_give isl_basic_map *isl_basic_set_unwrap(
 		__isl_take isl_basic_set *bset);
@@ -2860,6 +6695,12 @@
 set or relation.  If there is any such internal structure in the input,
 then the name of the space is also removed.
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_flatten_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_flatten_range(
+		__isl_take isl_space *space);
+
 	#include <isl/local_space.h>
 	__isl_give isl_local_space *
 	isl_local_space_flatten_domain(
@@ -2888,6 +6729,26 @@
 	__isl_give isl_map *isl_map_flatten(
 		__isl_take isl_map *map);
 
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_flatten_range(
+		__isl_take isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_flatten_range(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_aff *isl_multi_aff_flatten_range(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_flatten_range(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_flatten_range(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
 	#include <isl/map.h>
 	__isl_give isl_map *isl_set_flatten_map(
 		__isl_take isl_set *set);
@@ -2903,6 +6764,7 @@
 is the original space and the range corresponds to the original
 existentially quantified variables.
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_lift(
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_set *isl_set_lift(
@@ -2919,12 +6781,28 @@
 	__isl_give isl_basic_map *isl_local_space_lifting(
 		__isl_take isl_local_space *ls);
 
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_lift(
+		__isl_take isl_multi_aff *maff,
+		__isl_give isl_local_space **ls);
+
+If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
+then it is assigned the local space that lies at the basis of
+the lifting applied.
+
 =item * Internal Product
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_zip(
+		__isl_take isl_space *space);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_zip(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_map *isl_map_zip(
 		__isl_take isl_map *map);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_zip(
 		__isl_take isl_union_map *umap);
 
@@ -2933,6 +6811,13 @@
 
 =item * Currying
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_curry(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_uncurry(
+		__isl_take isl_space *space);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_curry(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_basic_map *isl_basic_map_uncurry(
@@ -2941,6 +6826,8 @@
 		__isl_take isl_map *map);
 	__isl_give isl_map *isl_map_uncurry(
 		__isl_take isl_map *map);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_curry(
 		__isl_take isl_union_map *umap);
 	__isl_give isl_union_map *isl_union_map_uncurry(
@@ -2953,14 +6840,43 @@
 with the original range as range of this nested relation.
 The C<uncurry> functions perform the inverse operation.
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_range_curry(
+		__isl_take isl_space *space);
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_range_curry(
+		__isl_take isl_map *map);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_range_curry(
+		__isl_take isl_union_map *umap);
+
+These functions apply the currying to the relation that
+is nested inside the range of the input.
+
 =item * Aligning parameters
 
+Change the order of the parameters of the given set, relation
+or function
+such that the first parameters match those of C<model>.
+This may involve the introduction of extra parameters.
+All parameters need to be named.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_align_params(
+		__isl_take isl_space *space1,
+		__isl_take isl_space *space2)
+
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_align_params(
 		__isl_take isl_basic_set *bset,
 		__isl_take isl_space *model);
 	__isl_give isl_set *isl_set_align_params(
 		__isl_take isl_set *set,
 		__isl_take isl_space *model);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_align_params(
 		__isl_take isl_basic_map *bmap,
 		__isl_take isl_space *model);
@@ -2968,13 +6884,213 @@
 		__isl_take isl_map *map,
 		__isl_take isl_space *model);
 
-Change the order of the parameters of the given set or relation
-such that the first parameters match those of C<model>.
-This may involve the introduction of extra parameters.
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_align_params(
+		__isl_take isl_multi_id *mi,
+		__isl_take isl_space *model);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_align_params(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_space *model);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_align_params(
+		__isl_take isl_aff *aff,
+		__isl_take isl_space *model);
+	__isl_give isl_multi_aff *isl_multi_aff_align_params(
+		__isl_take isl_multi_aff *multi,
+		__isl_take isl_space *model);
+	__isl_give isl_pw_aff *isl_pw_aff_align_params(
+		__isl_take isl_pw_aff *pwaff,
+		__isl_take isl_space *model);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_space *model);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_align_params(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_space *model);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_align_params(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_space *model);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_align_params(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_space *model);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_align_params(
+		__isl_take isl_qpolynomial *qp,
+		__isl_take isl_space *model);
+
+=item * Drop unused parameters
+
+Drop parameters that are not referenced by the isl object.
 All parameters need to be named.
 
+	#include <isl/set.h>
+	__isl_give isl_basic_set *
+	isl_basic_set_drop_unused_params(
+		__isl_take isl_basic_set *bset);
+	__isl_give isl_set *isl_set_drop_unused_params(
+		__isl_take isl_set *set);
+
+	#include <isl/map.h>
+	__isl_give isl_basic_map *
+	isl_basic_map_drop_unused_params(
+		__isl_take isl_basic_map *bmap);
+	__isl_give isl_map *isl_map_drop_unused_params(
+		__isl_take isl_map *map);
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_drop_unused_params(
+		__isl_take isl_pw_multi_aff *pma);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_drop_unused_params(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_drop_unused_params(
+		__isl_take isl_pw_qpolynomial_fold *pwf);
+
+=item * Unary Arithmetic Operations
+
+	#include <isl/set.h>
+	__isl_give isl_set *isl_set_neg(
+		__isl_take isl_set *set);
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_neg(
+		__isl_take isl_map *map);
+
+C<isl_set_neg> constructs a set containing the opposites of
+the elements in its argument.
+The domain of the result of C<isl_map_neg> is the same
+as the domain of its argument.  The corresponding range
+elements are the opposites of the corresponding range
+elements in the argument.
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_neg(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_neg(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_aff *isl_multi_aff_neg(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_neg(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_neg(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_neg(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_neg(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_aff *isl_aff_ceil(
+		__isl_take isl_aff *aff);
+	__isl_give isl_pw_aff *isl_pw_aff_ceil(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_aff *isl_aff_floor(
+		__isl_take isl_aff *aff);
+	__isl_give isl_multi_aff *isl_multi_aff_floor(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_floor(
+		__isl_take isl_pw_aff *pwaff);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
+		__isl_take isl_union_pw_aff *upa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_floor(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_list_min(
+		__isl_take isl_pw_aff_list *list);
+	__isl_give isl_pw_aff *isl_pw_aff_list_max(
+		__isl_take isl_pw_aff_list *list);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_neg(
+		__isl_take isl_qpolynomial *qp);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
+		__isl_take isl_pw_qpolynomial *pwqp);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_neg(
+		__isl_take isl_union_pw_qpolynomial *upwqp);
+	__isl_give isl_qpolynomial *isl_qpolynomial_pow(
+		__isl_take isl_qpolynomial *qp,
+		unsigned exponent);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		unsigned exponent);
+
+=item * Evaluation
+
+The following functions evaluate a function in a point.
+
+	#include <isl/aff.h>
+	__isl_give isl_val *isl_aff_eval(
+		__isl_take isl_aff *aff,
+		__isl_take isl_point *pnt);
+	__isl_give isl_val *isl_pw_aff_eval(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_point *pnt);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_val *isl_pw_qpolynomial_eval(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		__isl_take isl_point *pnt);
+	__isl_give isl_val *isl_pw_qpolynomial_fold_eval(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_point *pnt);
+	__isl_give isl_val *isl_union_pw_qpolynomial_eval(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_point *pnt);
+	__isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_point *pnt);
+
+These functions return NaN when evaluated at a void point.
+Note that C<isl_pw_aff_eval> returns NaN when the function is evaluated outside
+its definition domain, while C<isl_pw_qpolynomial_eval> returns zero
+when the function is evaluated outside its explicit domain.
+
 =item * Dimension manipulation
 
+It is usually not advisable to directly change the (input or output)
+space of a set or a relation as this removes the name and the internal
+structure of the space.  However, the functions below can be useful
+to add new parameters, assuming
+C<isl_set_align_params> and C<isl_map_align_params>
+are not sufficient.
+
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_add_dims(
+		__isl_take isl_space *space,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_space *isl_space_insert_dims(
+		__isl_take isl_space *space,
+		enum isl_dim_type type, unsigned pos, unsigned n);
+	__isl_give isl_space *isl_space_drop_dims(
+		__isl_take isl_space *space,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_space *isl_space_move_dims(
+		__isl_take isl_space *space,
+		enum isl_dim_type dst_type, unsigned dst_pos,
+		enum isl_dim_type src_type, unsigned src_pos,
+		unsigned n);
+
 	#include <isl/local_space.h>
 	__isl_give isl_local_space *isl_local_space_add_dims(
 		__isl_take isl_local_space *ls,
@@ -3012,6 +7128,9 @@
 		unsigned n);
 
 	#include <isl/map.h>
+	__isl_give isl_basic_map *isl_basic_map_add_dims(
+		__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned n);
 	__isl_give isl_map *isl_map_add_dims(
 		__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned n);
@@ -3033,12 +7152,101 @@
 		enum isl_dim_type src_type, unsigned src_pos,
 		unsigned n);
 
-It is usually not advisable to directly change the (input or output)
-space of a set or a relation as this removes the name and the internal
-structure of the space.  However, the above functions can be useful
-to add new parameters, assuming
-C<isl_set_align_params> and C<isl_map_align_params>
-are not sufficient.
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_insert_dims(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_multi_val *isl_multi_val_add_dims(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_multi_val *isl_multi_val_drop_dims(
+		__isl_take isl_multi_val *mv,
+		enum isl_dim_type type, unsigned first, unsigned n);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_insert_dims(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_multi_aff *isl_multi_aff_insert_dims(
+		__isl_take isl_multi_aff *ma,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_pw_aff *isl_pw_aff_insert_dims(
+		__isl_take isl_pw_aff *pwaff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_aff *isl_aff_add_dims(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_multi_aff *isl_multi_aff_add_dims(
+		__isl_take isl_multi_aff *ma,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_pw_aff *isl_pw_aff_add_dims(
+		__isl_take isl_pw_aff *pwaff,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
+		__isl_take isl_multi_pw_aff *mpa,
+		enum isl_dim_type type, unsigned n);
+	__isl_give isl_aff *isl_aff_drop_dims(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_multi_aff *isl_multi_aff_drop_dims(
+		__isl_take isl_multi_aff *maff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_pw_aff *isl_pw_aff_drop_dims(
+		__isl_take isl_pw_aff *pwaff,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
+		__isl_take isl_pw_multi_aff *pma,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
+		__isl_take isl_union_pw_aff *upa,
+		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_union_pw_multi_aff *
+		isl_union_pw_multi_aff_drop_dims(
+		__isl_take isl_union_pw_multi_aff *upma,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_drop_dims(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		enum isl_dim_type type, unsigned first,
+		unsigned n);
+	__isl_give isl_aff *isl_aff_move_dims(
+		__isl_take isl_aff *aff,
+		enum isl_dim_type dst_type, unsigned dst_pos,
+		enum isl_dim_type src_type, unsigned src_pos,
+		unsigned n);
+	__isl_give isl_multi_aff *isl_multi_aff_move_dims(
+		__isl_take isl_multi_aff *ma,
+		enum isl_dim_type dst_type, unsigned dst_pos,
+		enum isl_dim_type src_type, unsigned src_pos,
+		unsigned n);
+	__isl_give isl_pw_aff *isl_pw_aff_move_dims(
+		__isl_take isl_pw_aff *pa,
+		enum isl_dim_type dst_type, unsigned dst_pos,
+		enum isl_dim_type src_type, unsigned src_pos,
+		unsigned n);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
+		__isl_take isl_multi_pw_aff *pma,
+		enum isl_dim_type dst_type, unsigned dst_pos,
+		enum isl_dim_type src_type, unsigned src_pos,
+		unsigned n);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_drop_dims(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+	__isl_give isl_union_pw_qpolynomial_fold *
+		isl_union_pw_qpolynomial_fold_drop_dims(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		enum isl_dim_type type,
+		unsigned first, unsigned n);
+
+The operations on union expressions can only manipulate parameters.
 
 =back
 
@@ -3074,6 +7282,12 @@
 	__isl_give isl_set *isl_set_intersect(
 		__isl_take isl_set *set1,
 		__isl_take isl_set *set2);
+	__isl_give isl_set *isl_set_intersect_factor_domain(
+		__isl_take isl_set *set,
+		__isl_take isl_set *domain);
+	__isl_give isl_set *isl_set_intersect_factor_range(
+		__isl_take isl_set *set,
+		__isl_take isl_set *range);
 
 	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_intersect_domain(
@@ -3085,6 +7299,8 @@
 	__isl_give isl_basic_map *isl_basic_map_intersect(
 		__isl_take isl_basic_map *bmap1,
 		__isl_take isl_basic_map *bmap2);
+	__isl_give isl_basic_map *isl_basic_map_list_intersect(
+		__isl_take isl_basic_map_list *list);
 	__isl_give isl_map *isl_map_intersect_params(
 		__isl_take isl_map *map,
 		__isl_take isl_set *params);
@@ -3097,6 +7313,22 @@
 	__isl_give isl_map *isl_map_intersect(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
+	__isl_give isl_map *
+	isl_map_intersect_domain_factor_domain(
+		__isl_take isl_map *map,
+		__isl_take isl_map *factor);
+	__isl_give isl_map *
+	isl_map_intersect_domain_factor_range(
+		__isl_take isl_map *map,
+		__isl_take isl_map *factor);
+	__isl_give isl_map *
+	isl_map_intersect_range_factor_domain(
+		__isl_take isl_map *map,
+		__isl_take isl_map *factor);
+	__isl_give isl_map *
+	isl_map_intersect_range_factor_range(
+		__isl_take isl_map *map,
+		__isl_take isl_map *factor);
 
 	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_intersect_params(
@@ -3110,15 +7342,222 @@
 	__isl_give isl_union_map *isl_union_map_intersect_params(
 		__isl_take isl_union_map *umap,
 		__isl_take isl_set *set);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_domain_union_set(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_domain_space(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_space *space);
 	__isl_give isl_union_map *isl_union_map_intersect_domain(
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_set *uset);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_range_union_set(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_range_space(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_space *space);
 	__isl_give isl_union_map *isl_union_map_intersect_range(
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_set *uset);
 	__isl_give isl_union_map *isl_union_map_intersect(
 		__isl_take isl_union_map *umap1,
 		__isl_take isl_union_map *umap2);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_domain_factor_domain(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_map *factor);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_domain_factor_range(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_map *factor);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_range_factor_domain(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_map *factor);
+	__isl_give isl_union_map *
+	isl_union_map_intersect_range_factor_range(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_map *factor);
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_intersect_domain(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_set *domain);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_intersect_domain_space(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_intersect_domain_union_set(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_domain_space(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_domain_union_set(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_domain(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_intersect_domain(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_aff *
+	isl_pw_aff_intersect_domain_wrapped_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_intersect_domain_wrapped_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_intersect_domain_wrapped_domain(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_domain_wrapped_domain(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_aff *
+	isl_pw_aff_intersect_domain_wrapped_range(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_intersect_domain_wrapped_range(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_domain_wrapped_range(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_intersect_domain_wrapped_range(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_aff *isl_pw_aff_intersect_params(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_intersect_params(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_intersect_params(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_intersect_params(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_set *set);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_intersect_params(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_set *params);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_intersect_range(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_set *set);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_intersect_domain(
+		__isl_take isl_pw_qpolynomial *pwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_domain_space(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_domain_union_set(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_domain(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_domain_space(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_domain_union_set(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_domain(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_intersect_domain_wrapped_domain(
+		__isl_take isl_pw_qpolynomial *pwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_intersect_domain_wrapped_range(
+		__isl_take isl_pw_qpolynomial *pwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_domain_wrapped_range(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_range(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_intersect_params(
+		__isl_take isl_pw_qpolynomial *pwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_intersect_params(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_intersect_params(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_intersect_params(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_set *set);
 
 The second argument to the C<_params> functions needs to be
 a parametric (basic) set.  For the other functions, a parametric set
@@ -3126,33 +7565,56 @@
 a parametric set as well.
 The list passed to C<isl_basic_set_list_intersect> needs to have
 at least one element and all elements need to live in the same space.
+The function C<isl_multi_union_pw_aff_intersect_range>
+restricts the input function to those shared domain elements
+that map to the specified range.
+C<isl_union_map_intersect_domain> is an alternative name for
+C<isl_union_map_intersect_domain_union_set>.
+Similarly for the other pairs of functions.
 
 =item * Union
 
+	#include <isl/set.h>
 	__isl_give isl_set *isl_basic_set_union(
 		__isl_take isl_basic_set *bset1,
 		__isl_take isl_basic_set *bset2);
-	__isl_give isl_map *isl_basic_map_union(
-		__isl_take isl_basic_map *bmap1,
-		__isl_take isl_basic_map *bmap2);
 	__isl_give isl_set *isl_set_union(
 		__isl_take isl_set *set1,
 		__isl_take isl_set *set2);
+	__isl_give isl_set *isl_set_list_union(
+		__isl_take isl_set_list *list);
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_basic_map_union(
+		__isl_take isl_basic_map *bmap1,
+		__isl_take isl_basic_map *bmap2);
 	__isl_give isl_map *isl_map_union(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
+
+	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_union(
 		__isl_take isl_union_set *uset1,
 		__isl_take isl_union_set *uset2);
+	__isl_give isl_union_set *isl_union_set_list_union(
+		__isl_take isl_union_set_list *list);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_union(
 		__isl_take isl_union_map *umap1,
 		__isl_take isl_union_map *umap2);
 
+The list passed to C<isl_set_list_union> needs to have
+at least one element and all elements need to live in the same space.
+
 =item * Set difference
 
+	#include <isl/set.h>
 	__isl_give isl_set *isl_set_subtract(
 		__isl_take isl_set *set1,
 		__isl_take isl_set *set2);
+
+	#include <isl/map.h>
 	__isl_give isl_map *isl_map_subtract(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
@@ -3162,9 +7624,13 @@
 	__isl_give isl_map *isl_map_subtract_range(
 		__isl_take isl_map *map,
 		__isl_take isl_set *dom);
+
+	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_subtract(
 		__isl_take isl_union_set *uset1,
 		__isl_take isl_union_set *uset2);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_subtract(
 		__isl_take isl_union_map *umap1,
 		__isl_take isl_union_map *umap2);
@@ -3175,17 +7641,98 @@
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_set *dom);
 
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_subtract_domain(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_subtract_domain(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_subtract_domain_union_set(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_subtract_domain_space(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_subtract_domain(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_subtract_domain_union_set(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_subtract_domain_space(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_subtract_domain(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_subtract_domain(
+		__isl_take isl_pw_qpolynomial *pwpq,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_subtract_domain(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_subtract_domain_union_set(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_subtract_domain_space(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_subtract_domain(
+		__isl_take isl_union_pw_qpolynomial *upwpq,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_subtract_domain_union_set(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_subtract_domain_space(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_space *space);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_subtract_domain(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *uset);
+
+C<isl_union_pw_aff_subtract_domain> is an alternative name for
+C<isl_union_pw_aff_subtract_domain_union_set>.
+Similarly for the other pairs of functions.
+
 =item * Application
 
+	#include <isl/space.h>
+	__isl_give isl_space *isl_space_join(
+		__isl_take isl_space *left,
+		__isl_take isl_space *right);
+
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_apply(
 		__isl_take isl_basic_set *bset,
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_set *isl_set_apply(
 		__isl_take isl_set *set,
 		__isl_take isl_map *map);
+
+	#include <isl/union_set.h>
 	__isl_give isl_union_set *isl_union_set_apply(
 		__isl_take isl_union_set *uset,
 		__isl_take isl_union_map *umap);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_apply_domain(
 		__isl_take isl_basic_map *bmap1,
 		__isl_take isl_basic_map *bmap2);
@@ -3195,16 +7742,81 @@
 	__isl_give isl_map *isl_map_apply_domain(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
-	__isl_give isl_union_map *isl_union_map_apply_domain(
-		__isl_take isl_union_map *umap1,
-		__isl_take isl_union_map *umap2);
 	__isl_give isl_map *isl_map_apply_range(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_apply_domain(
+		__isl_take isl_union_map *umap1,
+		__isl_take isl_union_map *umap2);
 	__isl_give isl_union_map *isl_union_map_apply_range(
 		__isl_take isl_union_map *umap1,
 		__isl_take isl_union_map *umap2);
 
+	#include <isl/aff.h>
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_apply_union_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_union_pw_aff *
+	isl_multi_union_pw_aff_apply_aff(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_aff *aff);
+	__isl_give isl_union_pw_aff *
+	isl_multi_union_pw_aff_apply_pw_aff(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_pw_aff *pa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_apply_multi_aff(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_apply_pw_multi_aff(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_pw_multi_aff *pma);
+
+The result of C<isl_multi_union_pw_aff_apply_aff> is defined
+over the shared domain of the elements of the input.  The dimension is
+required to be greater than zero.
+The C<isl_multi_union_pw_aff> argument of
+C<isl_multi_union_pw_aff_apply_multi_aff> is allowed to be zero-dimensional,
+but only if the range of the C<isl_multi_aff> argument
+is also zero-dimensional.
+Similarly for C<isl_multi_union_pw_aff_apply_pw_multi_aff>.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_set_apply_pw_qpolynomial_fold(
+		__isl_take isl_set *set,
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		isl_bool *tight);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_map_apply_pw_qpolynomial_fold(
+		__isl_take isl_map *map,
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		isl_bool *tight);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_set_apply_union_pw_qpolynomial_fold(
+		__isl_take isl_union_set *uset,
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		isl_bool *tight);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_map_apply_union_pw_qpolynomial_fold(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		isl_bool *tight);
+
+The functions taking a map
+compose the given map with the given piecewise quasipolynomial reduction.
+That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
+over all elements in the intersection of the range of the map
+and the domain of the piecewise quasipolynomial reduction
+as a function of an element in the domain of the map.
+The functions taking a set compute a bound over all elements in the
+intersection of the set and the domain of the
+piecewise quasipolynomial reduction.
+
 =item * Preimage
 
 	#include <isl/set.h>
@@ -3290,11 +7902,256 @@
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_pw_multi_aff *upma);
 
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+
 These functions compute the preimage of the given set or map domain/range under
 the given function.  In other words, the expression is plugged
-into the set description or into the domain/range of the map.
-Objects of types C<isl_multi_aff> and C<isl_pw_multi_aff> are described in
-L</"Piecewise Multiple Quasi Affine Expressions">.
+into the set description or into the domain/range of the map or function.
+
+=item * Pullback
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_pullback_aff(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_aff *isl_aff_pullback_multi_aff(
+		__isl_take isl_aff *aff,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_pullback_multi_aff(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_pullback_multi_aff(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_pullback_pw_multi_aff(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_pullback_pw_multi_aff(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_pullback_multi_pw_aff(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_union_pw_aff *
+	isl_union_pw_aff_pullback_union_pw_multi_aff(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_union_pw_multi_aff *upma);
+
+These functions precompose the first expression by the second function.
+In other words, the second function is plugged
+into the first expression.
+
+=item * Locus
+
+	#include <isl/aff.h>
+	__isl_give isl_basic_set *isl_aff_eq_basic_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_eq_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_ne_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_basic_set *isl_aff_le_basic_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_le_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_basic_set *isl_aff_lt_basic_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_lt_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_basic_set *isl_aff_ge_basic_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_ge_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_basic_set *isl_aff_gt_basic_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_aff_gt_set(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_set *isl_pw_aff_eq_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_set *isl_pw_aff_ne_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_set *isl_pw_aff_le_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_set *isl_pw_aff_lt_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_set *isl_pw_aff_ge_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_set *isl_pw_aff_gt_set(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+
+	__isl_give isl_set *isl_multi_aff_lex_le_set(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_set *isl_multi_aff_lex_lt_set(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_set *isl_multi_aff_lex_ge_set(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_set *isl_multi_aff_lex_gt_set(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+
+	__isl_give isl_set *isl_pw_aff_list_eq_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+	__isl_give isl_set *isl_pw_aff_list_ne_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+	__isl_give isl_set *isl_pw_aff_list_le_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+	__isl_give isl_set *isl_pw_aff_list_lt_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+	__isl_give isl_set *isl_pw_aff_list_ge_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+	__isl_give isl_set *isl_pw_aff_list_gt_set(
+		__isl_take isl_pw_aff_list *list1,
+		__isl_take isl_pw_aff_list *list2);
+
+The function C<isl_aff_ge_basic_set> returns a basic set
+containing those elements in the shared space
+of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
+The function C<isl_pw_aff_ge_set> returns a set
+containing those elements in the shared domain
+of C<pwaff1> and C<pwaff2> where C<pwaff1> is
+greater than or equal to C<pwaff2>.
+The function C<isl_multi_aff_lex_le_set> returns a set
+containing those elements in the shared domain space
+where C<ma1> is lexicographically smaller than or
+equal to C<ma2>.
+The functions operating on C<isl_pw_aff_list> apply the corresponding
+C<isl_pw_aff> function to each pair of elements in the two lists.
+
+	#include <isl/aff.h>
+	__isl_give isl_map *isl_pw_aff_eq_map(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_map *isl_pw_aff_le_map(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_map *isl_pw_aff_lt_map(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_map *isl_pw_aff_ge_map(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_map *isl_pw_aff_gt_map(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+
+	__isl_give isl_map *isl_multi_pw_aff_eq_map(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_map *isl_multi_pw_aff_lex_le_map(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_map *isl_multi_pw_aff_lex_ge_map(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+
+These functions return a map between domain elements of the arguments
+where the function values satisfy the given relation.
+
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_eq_at_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_map *isl_map_lex_lt_at_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_map *isl_map_lex_le_at_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_map *isl_map_lex_gt_at_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_map *isl_map_lex_ge_at_multi_pw_aff(
+		__isl_take isl_map *map,
+		__isl_take isl_multi_pw_aff *mpa);
+
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *
+	isl_union_map_eq_at_multi_union_pw_aff(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_union_map *
+	isl_union_map_lex_lt_at_multi_union_pw_aff(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_union_map *
+	isl_union_map_lex_le_at_multi_union_pw_aff(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_union_map *
+	isl_union_map_lex_gt_at_multi_union_pw_aff(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_union_map *
+	isl_union_map_lex_ge_at_multi_union_pw_aff(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+These functions select the subset of elements in the union map
+that have an equal or lexicographically smaller or greater function value.
 
 =item * Cartesian Product
 
@@ -3362,18 +8219,64 @@
 		__isl_take isl_union_map *umap1,
 		__isl_take isl_union_map *umap2);
 
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_range_product(
+		__isl_take isl_multi_id *mi1,
+		__isl_take isl_multi_id *mi2);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_range_product(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *isl_multi_val_product(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_range_product(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_multi_aff *isl_multi_aff_product(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_range_product(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_range_product(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_range_product(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_range_product(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+
 The above functions compute the cross product of the given
-sets or relations.  The domains and ranges of the results
+sets, relations or functions.  The domains and ranges of the results
 are wrapped maps between domains and ranges of the inputs.
 To obtain a ``flat'' product, use the following functions
 instead.
 
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_flat_product(
 		__isl_take isl_basic_set *bset1,
 		__isl_take isl_basic_set *bset2);
 	__isl_give isl_set *isl_set_flat_product(
 		__isl_take isl_set *set1,
 		__isl_take isl_set *set2);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_flat_range_product(
 		__isl_take isl_basic_map *bmap1,
 		__isl_take isl_basic_map *bmap2);
@@ -3383,9 +8286,6 @@
 	__isl_give isl_map *isl_map_flat_range_product(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
-	__isl_give isl_union_map *isl_union_map_flat_range_product(
-		__isl_take isl_union_map *umap1,
-		__isl_take isl_union_map *umap2);
 	__isl_give isl_basic_map *isl_basic_map_flat_product(
 		__isl_take isl_basic_map *bmap1,
 		__isl_take isl_basic_map *bmap2);
@@ -3393,9 +8293,57 @@
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
 
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *
+	isl_union_map_flat_domain_product(
+		__isl_take isl_union_map *umap1,
+		__isl_take isl_union_map *umap2);
+	__isl_give isl_union_map *
+	isl_union_map_flat_range_product(
+		__isl_take isl_union_map *umap1,
+		__isl_take isl_union_map *umap2);
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *
+	isl_multi_id_flat_range_product(
+		__isl_take isl_multi_id *mi1,
+		__isl_take isl_multi_id *mi2);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_flat_range_product(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_flat_range_product(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_flat_range_product(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_flat_range_product(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_flat_range_product(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+
 	#include <isl/space.h>
+	__isl_give isl_space *isl_space_factor_domain(
+		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_factor_range(
+		__isl_take isl_space *space);
 	__isl_give isl_space *isl_space_domain_factor_domain(
 		__isl_take isl_space *space);
+	__isl_give isl_space *isl_space_domain_factor_range(
+		__isl_take isl_space *space);
 	__isl_give isl_space *isl_space_range_factor_domain(
 		__isl_take isl_space *space);
 	__isl_give isl_space *isl_space_range_factor_range(
@@ -3405,17 +8353,160 @@
 C<isl_space_range_factor_range> extract the two arguments from
 the result of a call to C<isl_space_range_product>.
 
-The arguments of a call to C<isl_map_range_product> can be extracted
-from the result using the following two functions.
+The arguments of a call to a product can be extracted
+from the result using the following functions.
 
 	#include <isl/map.h>
+	__isl_give isl_map *isl_map_factor_domain(
+		__isl_take isl_map *map);
+	__isl_give isl_map *isl_map_factor_range(
+		__isl_take isl_map *map);
+	__isl_give isl_map *isl_map_domain_factor_domain(
+		__isl_take isl_map *map);
+	__isl_give isl_map *isl_map_domain_factor_range(
+		__isl_take isl_map *map);
 	__isl_give isl_map *isl_map_range_factor_domain(
 		__isl_take isl_map *map);
 	__isl_give isl_map *isl_map_range_factor_range(
 		__isl_take isl_map *map);
 
+	#include <isl/union_map.h>
+	__isl_give isl_union_map *isl_union_map_factor_domain(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *isl_union_map_factor_range(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *
+	isl_union_map_domain_factor_domain(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *
+	isl_union_map_domain_factor_range(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *
+	isl_union_map_range_factor_domain(
+		__isl_take isl_union_map *umap);
+	__isl_give isl_union_map *
+	isl_union_map_range_factor_range(
+		__isl_take isl_union_map *umap);
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_factor_range(
+		__isl_take isl_multi_id *mi);
+	__isl_give isl_multi_id *
+	isl_multi_id_range_factor_domain(
+		__isl_take isl_multi_id *mi);
+	__isl_give isl_multi_id *
+	isl_multi_id_range_factor_range(
+		__isl_take isl_multi_id *mi);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_factor_range(
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_val *
+	isl_multi_val_range_factor_domain(
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_val *
+	isl_multi_val_range_factor_range(
+		__isl_take isl_multi_val *mv);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_factor_range(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_range_factor_domain(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_range_factor_range(
+		__isl_take isl_multi_aff *ma);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_factor_range(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_range_factor_domain(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_range_factor_range(
+		__isl_take isl_multi_pw_aff *mpa);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_range_factor_domain(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_range_factor_range(
+		__isl_take isl_pw_multi_aff *pma);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_range_factor_domain(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_range_factor_range(
+		__isl_take isl_union_pw_multi_aff *upma);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_factor_range(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_range_factor_domain(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_range_factor_range(
+		__isl_take isl_multi_union_pw_aff *mupa);
+
+The splice functions are a generalization of the flat product functions,
+where the second argument may be inserted at any position inside
+the first argument rather than being placed at the end.
+The functions C<isl_multi_val_factor_range>,
+C<isl_multi_aff_factor_range>,
+C<isl_multi_pw_aff_factor_range> and
+C<isl_multi_union_pw_aff_factor_range>
+take functions that live in a set space.
+
+	#include <isl/id.h>
+	__isl_give isl_multi_id *isl_multi_id_range_splice(
+		__isl_take isl_multi_id *mi1, unsigned pos,
+		__isl_take isl_multi_id *mi2);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_range_splice(
+		__isl_take isl_multi_val *mv1, unsigned pos,
+		__isl_take isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_range_splice(
+		__isl_take isl_multi_aff *ma1, unsigned pos,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_multi_aff *isl_multi_aff_splice(
+		__isl_take isl_multi_aff *ma1,
+		unsigned in_pos, unsigned out_pos,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_range_splice(
+		__isl_take isl_multi_pw_aff *mpa1, unsigned pos,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
+		__isl_take isl_multi_pw_aff *mpa1,
+		unsigned in_pos, unsigned out_pos,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_range_splice(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		unsigned pos,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+
 =item * Simplification
 
+When applied to a set or relation,
+the gist operation returns a set or relation that has the
+same intersection with the context as the input set or relation.
+Any implicit equality in the intersection is made explicit in the result,
+while all inequalities that are redundant with respect to the intersection
+are removed.
+In case of union sets and relations, the gist operation is performed
+per space.
+
+When applied to a function,
+the gist operation applies the set gist operation to each of
+the cells in the domain of the input piecewise expression.
+The context is also exploited
+to simplify the expression associated to each cell.
+
+	#include <isl/set.h>
 	__isl_give isl_basic_set *isl_basic_set_gist(
 		__isl_take isl_basic_set *bset,
 		__isl_take isl_basic_set *context);
@@ -3424,15 +8515,14 @@
 	__isl_give isl_set *isl_set_gist_params(
 		__isl_take isl_set *set,
 		__isl_take isl_set *context);
-	__isl_give isl_union_set *isl_union_set_gist(
-		__isl_take isl_union_set *uset,
-		__isl_take isl_union_set *context);
-	__isl_give isl_union_set *isl_union_set_gist_params(
-		__isl_take isl_union_set *uset,
-		__isl_take isl_set *set);
+
+	#include <isl/map.h>
 	__isl_give isl_basic_map *isl_basic_map_gist(
 		__isl_take isl_basic_map *bmap,
 		__isl_take isl_basic_map *context);
+	__isl_give isl_basic_map *isl_basic_map_gist_domain(
+		__isl_take isl_basic_map *bmap,
+		__isl_take isl_basic_set *context);
 	__isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
 		__isl_take isl_map *context);
 	__isl_give isl_map *isl_map_gist_params(
@@ -3444,6 +8534,16 @@
 	__isl_give isl_map *isl_map_gist_range(
 		__isl_take isl_map *map,
 		__isl_take isl_set *context);
+
+	#include <isl/union_set.h>
+	__isl_give isl_union_set *isl_union_set_gist(
+		__isl_take isl_union_set *uset,
+		__isl_take isl_union_set *context);
+	__isl_give isl_union_set *isl_union_set_gist_params(
+		__isl_take isl_union_set *uset,
+		__isl_take isl_set *set);
+
+	#include <isl/union_map.h>
 	__isl_give isl_union_map *isl_union_map_gist(
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_map *context);
@@ -3457,13 +8557,519 @@
 		__isl_take isl_union_map *umap,
 		__isl_take isl_union_set *uset);
 
-The gist operation returns a set or relation that has the
-same intersection with the context as the input set or relation.
-Any implicit equality in the intersection is made explicit in the result,
-while all inequalities that are redundant with respect to the intersection
-are removed.
-In case of union sets and relations, the gist operation is performed
-per space.
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_gist_params(
+		__isl_take isl_aff *aff,
+		__isl_take isl_set *context);
+	__isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
+		__isl_take isl_set *context);
+	__isl_give isl_multi_aff *isl_multi_aff_gist_params(
+		__isl_take isl_multi_aff *maff,
+		__isl_take isl_set *context);
+	__isl_give isl_multi_aff *isl_multi_aff_gist(
+		__isl_take isl_multi_aff *maff,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_aff *isl_pw_aff_gist_params(
+		__isl_take isl_pw_aff *pwaff,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_aff *isl_pw_aff_gist(
+		__isl_take isl_pw_aff *pwaff,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_set *set);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_set *set);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_union_set *context);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_set *context);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_gist_params(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_set *context);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_gist(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *context);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_gist_params(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_set *context);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_gist(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_union_set *context);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
+		__isl_take isl_qpolynomial *qp,
+		__isl_take isl_set *context);
+	__isl_give isl_qpolynomial *isl_qpolynomial_gist(
+		__isl_take isl_qpolynomial *qp,
+		__isl_take isl_set *context);
+	__isl_give isl_qpolynomial_fold *
+	isl_qpolynomial_fold_gist_params(
+		__isl_take isl_qpolynomial_fold *fold,
+		__isl_take isl_set *context);
+	__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
+		__isl_take isl_qpolynomial_fold *fold,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_gist(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *context);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_gist_params(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_set *context);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_gist_params(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_set *context);
+	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_union_set *context);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_gist(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_union_set *context);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_gist_params(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_set *context);
+
+=item * Binary Arithmetic Operations
+
+	#include <isl/set.h>
+	__isl_give isl_set *isl_set_sum(
+		__isl_take isl_set *set1,
+		__isl_take isl_set *set2);
+	#include <isl/map.h>
+	__isl_give isl_map *isl_map_sum(
+		__isl_take isl_map *map1,
+		__isl_take isl_map *map2);
+
+C<isl_set_sum> computes the Minkowski sum of its two arguments,
+i.e., the set containing the sums of pairs of elements from
+C<set1> and C<set2>.
+The domain of the result of C<isl_map_sum> is the intersection
+of the domains of its two arguments.  The corresponding range
+elements are the sums of the corresponding range elements
+in the two arguments.
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_add(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *isl_multi_val_sub(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *isl_multi_val_min(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *isl_multi_val_max(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_add(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_multi_aff *isl_multi_aff_add(
+		__isl_take isl_multi_aff *maff1,
+		__isl_take isl_multi_aff *maff2);
+	__isl_give isl_pw_aff *isl_pw_aff_add(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_add(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_add(
+		__isl_take isl_union_pw_aff *upa1,
+		__isl_take isl_union_pw_aff *upa2);
+	__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_add(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+	__isl_give isl_pw_aff *isl_pw_aff_add_constant_val(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_add_constant_val(
+		__isl_take isl_multi_aff *pa,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_add_constant_val(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_add_constant_multi_val(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_add_constant_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_add_constant_multi_val(
+		__isl_take isl_multi_aff *pa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_add_constant_multi_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_pw_aff *isl_pw_aff_min(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_pw_aff *isl_pw_aff_max(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_min(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_max(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_aff *isl_aff_sub(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_multi_aff *isl_multi_aff_sub(
+		__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	__isl_give isl_pw_aff *isl_pw_aff_sub(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_sub(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
+		__isl_take isl_union_pw_aff *upa1,
+		__isl_take isl_union_pw_aff *upa2);
+	__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_sub(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+
+C<isl_aff_sub> subtracts the second argument from the first.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_add(
+		__isl_take isl_qpolynomial *qp1,
+		__isl_take isl_qpolynomial *qp2);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
+		__isl_take isl_pw_qpolynomial *pwqp1,
+		__isl_take isl_pw_qpolynomial *pwqp2);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
+		__isl_take isl_pw_qpolynomial *pwqp1,
+		__isl_take isl_pw_qpolynomial *pwqp2);
+	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
+		__isl_take isl_pw_qpolynomial_fold *pwf1,
+		__isl_take isl_pw_qpolynomial_fold *pwf2);
+	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
+		__isl_take isl_union_pw_qpolynomial *upwqp1,
+		__isl_take isl_union_pw_qpolynomial *upwqp2);
+	__isl_give isl_qpolynomial *isl_qpolynomial_sub(
+		__isl_take isl_qpolynomial *qp1,
+		__isl_take isl_qpolynomial *qp2);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
+		__isl_take isl_pw_qpolynomial *pwqp1,
+		__isl_take isl_pw_qpolynomial *pwqp2);
+	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
+		__isl_take isl_union_pw_qpolynomial *upwqp1,
+		__isl_take isl_union_pw_qpolynomial *upwqp2);
+	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
+		__isl_take isl_pw_qpolynomial_fold *pwf1,
+		__isl_take isl_pw_qpolynomial_fold *pwf2);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_fold(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf1,
+		__isl_take isl_union_pw_qpolynomial_fold *upwf2);
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_union_add(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_union_add(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
+		__isl_take isl_union_pw_aff *upa1,
+		__isl_take isl_union_pw_aff *upa2);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_union_add(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_union_add(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+	__isl_give isl_pw_aff *isl_pw_aff_union_min(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_pw_aff *isl_pw_aff_union_max(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+
+The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
+expression with a domain that is the union of those of C<pwaff1> and
+C<pwaff2> and such that on each cell, the quasi-affine expression is
+the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
+C<pwaff1> or C<pwaff2> is defined on a given cell, then the
+associated expression is the defined one.
+This in contrast to the C<isl_pw_aff_max> function, which is
+only defined on the shared definition domain of the arguments.
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_add_val(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_val *isl_multi_val_mod_val(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_val *isl_multi_val_scale_val(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_val *isl_multi_val_scale_down_val(
+		__isl_take isl_multi_val *mv,
+		__isl_take isl_val *v);
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
+		__isl_take isl_val *mod);
+	__isl_give isl_pw_aff *isl_pw_aff_mod_val(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_val *mod);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_val *f);
+	__isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
+		__isl_take isl_val *v);
+	__isl_give isl_multi_aff *isl_multi_aff_scale_val(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_aff *isl_pw_aff_scale_val(
+		__isl_take isl_pw_aff *pa, __isl_take isl_val *v);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_val *f);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_scale_val(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_val *val);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_scale_val(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_val *v);
+	__isl_give isl_aff *isl_aff_scale_down_ui(
+		__isl_take isl_aff *aff, unsigned f);
+	__isl_give isl_aff *isl_aff_scale_down_val(
+		__isl_take isl_aff *aff, __isl_take isl_val *v);
+	__isl_give isl_multi_aff *isl_multi_aff_scale_down_val(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
+		__isl_take isl_pw_aff *pa,
+		__isl_take isl_val *f);
+	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_down_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
+		__isl_take isl_union_pw_aff *upa,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_scale_down_val(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_val *val);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_scale_down_val(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_val *v);
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
+		__isl_take isl_qpolynomial *qp,
+		__isl_take isl_val *v);
+	__isl_give isl_qpolynomial_fold *
+	isl_qpolynomial_fold_scale_val(
+		__isl_take isl_qpolynomial_fold *fold,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_scale_val(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_scale_val(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_scale_val(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_scale_val(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_val *v);
+	__isl_give isl_qpolynomial *
+	isl_qpolynomial_scale_down_val(
+		__isl_take isl_qpolynomial *qp,
+		__isl_take isl_val *v);
+	__isl_give isl_qpolynomial_fold *
+	isl_qpolynomial_fold_scale_down_val(
+		__isl_take isl_qpolynomial_fold *fold,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_qpolynomial *
+	isl_pw_qpolynomial_scale_down_val(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		__isl_take isl_val *v);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_fold_scale_down_val(
+		__isl_take isl_pw_qpolynomial_fold *pwf,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_qpolynomial *
+	isl_union_pw_qpolynomial_scale_down_val(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		__isl_take isl_val *v);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_scale_down_val(
+		__isl_take isl_union_pw_qpolynomial_fold *upwf,
+		__isl_take isl_val *v);
+
+	#include <isl/val.h>
+	__isl_give isl_multi_val *isl_multi_val_mod_multi_val(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *isl_multi_val_scale_multi_val(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+	__isl_give isl_multi_val *
+	isl_multi_val_scale_down_multi_val(
+		__isl_take isl_multi_val *mv1,
+		__isl_take isl_multi_val *mv2);
+
+	#include <isl/aff.h>
+	__isl_give isl_multi_aff *isl_multi_aff_mod_multi_val(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_mod_multi_val(
+		__isl_take isl_multi_union_pw_aff *upma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_mod_multi_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_pw_multi_aff *
+	isl_pw_multi_aff_scale_multi_val(
+		__isl_take isl_pw_multi_aff *pma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_scale_multi_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_scale_multi_val(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_union_pw_multi_aff *
+	isl_union_pw_multi_aff_scale_multi_val(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_aff *
+	isl_multi_aff_scale_down_multi_val(
+		__isl_take isl_multi_aff *ma,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_pw_aff *
+	isl_multi_pw_aff_scale_down_multi_val(
+		__isl_take isl_multi_pw_aff *mpa,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_multi_union_pw_aff *
+	isl_multi_union_pw_aff_scale_down_multi_val(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_multi_val *mv);
+
+C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
+by the corresponding elements of C<mv>.
+
+	#include <isl/aff.h>
+	__isl_give isl_aff *isl_aff_mul(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_aff *isl_aff_div(
+		__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2);
+	__isl_give isl_pw_aff *isl_pw_aff_mul(
+		__isl_take isl_pw_aff *pwaff1,
+		__isl_take isl_pw_aff *pwaff2);
+	__isl_give isl_pw_aff *isl_pw_aff_div(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+	__isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
+		__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2);
+
+When multiplying two affine expressions, at least one of the two needs
+to be a constant.  Similarly, when dividing an affine expression by another,
+the second expression needs to be a constant.
+C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
+rounding towards zero.  C<isl_pw_aff_tdiv_r> computes the corresponding
+remainder.
+
+	#include <isl/polynomial.h>
+	__isl_give isl_qpolynomial *isl_qpolynomial_mul(
+		__isl_take isl_qpolynomial *qp1,
+		__isl_take isl_qpolynomial *qp2);
+	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
+		__isl_take isl_pw_qpolynomial *pwqp1,
+		__isl_take isl_pw_qpolynomial *pwqp2);
+	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
+		__isl_take isl_union_pw_qpolynomial *upwqp1,
+		__isl_take isl_union_pw_qpolynomial *upwqp2);
 
 =back
 
@@ -3481,6 +9087,7 @@
 for which the result is non-empty and of C<*empty>
 is equal to C<dom>.
 
+	#include <isl/set.h>
 	__isl_give isl_set *isl_basic_set_partial_lexmin(
 		__isl_take isl_basic_set *bset,
 		__isl_take isl_basic_set *dom,
@@ -3501,6 +9108,7 @@
 of the elements in C<set> (or C<bset>).
 In case of union sets, the optimum is computed per space.
 
+	#include <isl/set.h>
 	__isl_give isl_set *isl_basic_set_lexmin(
 		__isl_take isl_basic_set *bset);
 	__isl_give isl_set *isl_basic_set_lexmax(
@@ -3526,6 +9134,7 @@
 In other words, the union of the domain of the result and of C<*empty>
 is equal to C<dom>.
 
+	#include <isl/map.h>
 	__isl_give isl_map *isl_basic_map_partial_lexmax(
 		__isl_take isl_basic_map *bmap,
 		__isl_take isl_basic_set *dom,
@@ -3547,6 +9156,7 @@
 of all elements associated to that element.
 In case of union relations, the optimum is computed per space.
 
+	#include <isl/map.h>
 	__isl_give isl_map *isl_basic_map_lexmin(
 		__isl_take isl_basic_map *bmap);
 	__isl_give isl_map *isl_basic_map_lexmax(
@@ -3561,14 +9171,11 @@
 		__isl_take isl_union_map *umap);
 
 The following functions return their result in the form of
-a piecewise multi-affine expression
-(See L<"Piecewise Multiple Quasi Affine Expressions">),
+a piecewise multi-affine expression,
 but are otherwise equivalent to the corresponding functions
 returning a basic set or relation.
 
-	__isl_give isl_pw_multi_aff *
-	isl_basic_map_lexmin_pw_multi_aff(
-		__isl_take isl_basic_map *bmap);
+	#include <isl/set.h>
 	__isl_give isl_pw_multi_aff *
 	isl_basic_set_partial_lexmin_pw_multi_aff(
 		__isl_take isl_basic_set *bset,
@@ -3579,6 +9186,15 @@
 		__isl_take isl_basic_set *bset,
 		__isl_take isl_basic_set *dom,
 		__isl_give isl_set **empty);
+	__isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
+		__isl_take isl_set *set);
+	__isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
+		__isl_take isl_set *set);
+
+	#include <isl/map.h>
+	__isl_give isl_pw_multi_aff *
+	isl_basic_map_lexmin_pw_multi_aff(
+		__isl_take isl_basic_map *bmap);
 	__isl_give isl_pw_multi_aff *
 	isl_basic_map_partial_lexmin_pw_multi_aff(
 		__isl_take isl_basic_map *bmap,
@@ -3589,24 +9205,78 @@
 		__isl_take isl_basic_map *bmap,
 		__isl_take isl_basic_set *dom,
 		__isl_give isl_set **empty);
-	__isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
-		__isl_take isl_set *set);
-	__isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
-		__isl_take isl_set *set);
 	__isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
 		__isl_take isl_map *map);
 	__isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
 		__isl_take isl_map *map);
 
+The following functions return the lexicographic minimum or maximum
+on the shared domain of the inputs and the single defined function
+on those parts of the domain where only a single function is defined.
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2);
+
+If the input to a lexicographic optimization problem has
+multiple constraints with the same coefficients for the optimized
+variables, then, by default, this symmetry is exploited by
+replacing those constraints by a single constraint with
+an abstract bound, which is in turn bounded by the corresponding terms
+in the original constraints.
+Without this optimization, the solver would typically consider
+all possible orderings of those original bounds, resulting in a needless
+decomposition of the domain.
+However, the optimization can also result in slowdowns since
+an extra parameter is introduced that may get used in additional
+integer divisions.
+The following option determines whether symmetry detection is applied
+during lexicographic optimization.
+
+	#include <isl/options.h>
+	isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx,
+		int val);
+	int isl_options_get_pip_symmetry(isl_ctx *ctx);
+
+=begin latex
+
+See also \autoref{s:offline}.
+
+=end latex
+
+=head2 Ternary Operations
+
+	#include <isl/aff.h>
+	__isl_give isl_pw_aff *isl_pw_aff_cond(
+		__isl_take isl_pw_aff *cond,
+		__isl_take isl_pw_aff *pwaff_true,
+		__isl_take isl_pw_aff *pwaff_false);
+
+The function C<isl_pw_aff_cond> performs a conditional operator
+and returns an expression that is equal to C<pwaff_true>
+for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
+where C<cond> is zero.
+
 =head2 Lists
 
 Lists are defined over several element types, including
-C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_constraint>,
-C<isl_basic_set>, C<isl_set>, C<isl_ast_expr> and C<isl_ast_node>.
+C<isl_val>, C<isl_id>, C<isl_aff>, C<isl_pw_aff>, C<isl_pw_multi_aff>,
+C<isl_union_pw_aff>,
+C<isl_union_pw_multi_aff>,
+C<isl_qpolynomial>, C<isl_pw_qpolynomial>, C<isl_pw_qpolynomial_fold>,
+C<isl_constraint>,
+C<isl_basic_set>, C<isl_set>, C<isl_basic_map>, C<isl_map>, C<isl_union_set>,
+C<isl_union_map>, C<isl_ast_expr> and C<isl_ast_node>.
 Here we take lists of C<isl_set>s as an example.
 Lists can be created, copied, modified and freed using the following functions.
 
 	#include <isl/set.h>
+	__isl_give isl_set_list *isl_set_to_list(
+		__isl_take isl_set *el);
 	__isl_give isl_set_list *isl_set_list_from_set(
 		__isl_take isl_set *el);
 	__isl_give isl_set_list *isl_set_list_alloc(
@@ -3622,12 +9292,24 @@
 	__isl_give isl_set_list *isl_set_list_drop(
 		__isl_take isl_set_list *list,
 		unsigned first, unsigned n);
+	__isl_give isl_set_list *isl_set_list_clear(
+		__isl_take isl_set_list *list);
+	__isl_give isl_set_list *isl_set_list_swap(
+		__isl_take isl_set_list *list,
+		unsigned pos1, unsigned pos2);
+	__isl_give isl_set_list *isl_set_list_reverse(
+		__isl_take isl_set_list *list);
 	__isl_give isl_set_list *isl_set_list_set_set(
 		__isl_take isl_set_list *list, int index,
 		__isl_take isl_set *set);
 	__isl_give isl_set_list *isl_set_list_concat(
 		__isl_take isl_set_list *list1,
 		__isl_take isl_set_list *list2);
+	__isl_give isl_set_list *isl_set_list_map(
+		__isl_take isl_set_list *list,
+		__isl_give isl_set *(*fn)(__isl_take isl_set *el,
+			void *user),
+		void *user);
 	__isl_give isl_set_list *isl_set_list_sort(
 		__isl_take isl_set_list *list,
 		int (*cmp)(__isl_keep isl_set *a,
@@ -3636,32 +9318,47 @@
 	__isl_null isl_set_list *isl_set_list_free(
 		__isl_take isl_set_list *list);
 
-C<isl_set_list_alloc> creates an empty list with a capacity for
-C<n> elements.  C<isl_set_list_from_set> creates a list with a single
-element.
+C<isl_set_list_alloc> creates an empty list with an initial capacity
+for C<n> elements.  C<isl_set_list_insert> and C<isl_set_list_add>
+add elements to a list, increasing its capacity as needed.
+C<isl_set_to_list> creates a list with a single element.
+C<isl_set_list_from_set> performs the same operation.
+C<isl_set_list_clear> removes all elements from a list.
+C<isl_set_list_swap> swaps the elements at the specified locations.
+C<isl_set_list_reverse> reverses the elements in the list.
 
 Lists can be inspected using the following functions.
 
 	#include <isl/set.h>
-	isl_ctx *isl_set_list_get_ctx(__isl_keep isl_set_list *list);
-	int isl_set_list_n_set(__isl_keep isl_set_list *list);
+	isl_size isl_set_list_size(__isl_keep isl_set_list *list);
+	isl_size isl_set_list_n_set(__isl_keep isl_set_list *list);
+	__isl_give isl_set *isl_set_list_get_at(
+		__isl_keep isl_set_list *list, int index);
 	__isl_give isl_set *isl_set_list_get_set(
 		__isl_keep isl_set_list *list, int index);
-	int isl_set_list_foreach(__isl_keep isl_set_list *list,
-		int (*fn)(__isl_take isl_set *el, void *user),
+	isl_stat isl_set_list_foreach(__isl_keep isl_set_list *list,
+		isl_stat (*fn)(__isl_take isl_set *el, void *user),
+		void *user);
+	isl_bool isl_set_list_every(__isl_keep isl_set_list *list,
+		isl_bool (*test)(__isl_take isl_set *el,
+			void *user),
 		void *user);
-	int isl_set_list_foreach_scc(__isl_keep isl_set_list *list,
-		int (*follows)(__isl_keep isl_set *a,
+	isl_stat isl_set_list_foreach_scc(
+		__isl_keep isl_set_list *list,
+		isl_bool (*follows)(__isl_keep isl_set *a,
 			__isl_keep isl_set *b, void *user),
-		void *follows_user
-		int (*fn)(__isl_take isl_set *el, void *user),
+		void *follows_user,
+		isl_stat (*fn)(__isl_take isl_set *el, void *user),
 		void *fn_user);
 
+C<isl_set_list_n_set> is an alternative name for C<isl_set_list_size>.
+Similarly,
+C<isl_set_list_get_set> is an alternative name for C<isl_set_list_get_at>.
 The function C<isl_set_list_foreach_scc> calls C<fn> on each of the
 strongly connected components of the graph with as vertices the elements
 of C<list> and a directed edge from vertex C<b> to vertex C<a>
-iff C<follows(a, b)> returns C<1>.  The callbacks C<follows> and C<fn>
-should return C<-1> on error.
+iff C<follows(a, b)> returns C<isl_bool_true>.  The callbacks C<follows> and
+C<fn> should return C<isl_bool_error> or C<isl_stat_error> on error.
 
 Lists can be printed using
 
@@ -3670,12 +9367,21 @@
 		__isl_take isl_printer *p,
 		__isl_keep isl_set_list *list);
 
+Alternatively, a string representation can be obtained
+directly using the following function, which always prints
+in isl format.
+
+	#include <isl/set.h>
+	__isl_give char *isl_set_list_to_str(
+		__isl_keep isl_set_list *list);
+
 =head2 Associative arrays
 
 Associative arrays map isl objects of a specific type to isl objects
 of some (other) specific type.  They are defined for several pairs
 of types, including (C<isl_map>, C<isl_basic_set>),
-(C<isl_id>, C<isl_ast_expr>) and.
+(C<isl_id>, C<isl_ast_expr>),
+(C<isl_id>, C<isl_id>) and
 (C<isl_id>, C<isl_pw_aff>).
 Here, we take associative arrays that map C<isl_id>s to C<isl_ast_expr>s
 as an example.
@@ -3684,12 +9390,12 @@
 the following functions.
 
 	#include <isl/id_to_ast_expr.h>
-	__isl_give id_to_ast_expr *isl_id_to_ast_expr_alloc(
+	__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_alloc(
 		isl_ctx *ctx, int min_size);
-	__isl_give id_to_ast_expr *isl_id_to_ast_expr_copy(
-		__isl_keep id_to_ast_expr *id2expr);
-	__isl_null id_to_ast_expr *isl_id_to_ast_expr_free(
-		__isl_take id_to_ast_expr *id2expr);
+	__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_copy(
+		__isl_keep isl_id_to_ast_expr *id2expr);
+	__isl_null isl_id_to_ast_expr *isl_id_to_ast_expr_free(
+		__isl_take isl_id_to_ast_expr *id2expr);
 
 The C<min_size> argument to C<isl_id_to_ast_expr_alloc> can be used
 to specify the expected size of the associative array.
@@ -3698,29 +9404,42 @@
 Associative arrays can be inspected using the following functions.
 
 	#include <isl/id_to_ast_expr.h>
-	isl_ctx *isl_id_to_ast_expr_get_ctx(
-		__isl_keep id_to_ast_expr *id2expr);
-	int isl_id_to_ast_expr_has(
-		__isl_keep id_to_ast_expr *id2expr,
+	__isl_give isl_maybe_isl_ast_expr
+	isl_id_to_ast_expr_try_get(
+		__isl_keep isl_id_to_ast_expr *id2expr,
+		__isl_keep isl_id *key);
+	isl_bool isl_id_to_ast_expr_has(
+		__isl_keep isl_id_to_ast_expr *id2expr,
 		__isl_keep isl_id *key);
 	__isl_give isl_ast_expr *isl_id_to_ast_expr_get(
-		__isl_keep id_to_ast_expr *id2expr,
+		__isl_keep isl_id_to_ast_expr *id2expr,
 		__isl_take isl_id *key);
-	int isl_id_to_ast_expr_foreach(
-		__isl_keep id_to_ast_expr *id2expr,
-		int (*fn)(__isl_take isl_id *key,
+	isl_stat isl_id_to_ast_expr_foreach(
+		__isl_keep isl_id_to_ast_expr *id2expr,
+		isl_stat (*fn)(__isl_take isl_id *key,
 			__isl_take isl_ast_expr *val, void *user),
 		void *user);
 
-They can be modified using the following function.
+The function C<isl_id_to_ast_expr_try_get> returns a structure
+containing two elements, C<valid> and C<value>.
+If there is a value associated to the key, then C<valid>
+is set to C<isl_bool_true> and C<value> contains a copy of
+the associated value.  Otherwise C<value> is C<NULL> and
+C<valid> may be C<isl_bool_error> or C<isl_bool_false> depending
+on whether some error has occurred or there simply is no associated value.
+The function C<isl_id_to_ast_expr_has> returns the C<valid> field
+in the structure and
+the function C<isl_id_to_ast_expr_get> returns the C<value> field.
+
+Associative arrays can be modified using the following functions.
 
 	#include <isl/id_to_ast_expr.h>
-	__isl_give id_to_ast_expr *isl_id_to_ast_expr_set(
-		__isl_take id_to_ast_expr *id2expr,
+	__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_set(
+		__isl_take isl_id_to_ast_expr *id2expr,
 		__isl_take isl_id *key,
 		__isl_take isl_ast_expr *val);
-	__isl_give id_to_ast_expr *isl_id_to_ast_expr_drop(
-		__isl_take id_to_ast_expr *id2expr,
+	__isl_give isl_id_to_ast_expr *isl_id_to_ast_expr_drop(
+		__isl_take isl_id_to_ast_expr *id2expr,
 		__isl_take isl_id *key);
 
 Associative arrays can be printed using the following function.
@@ -3728,145 +9447,7 @@
 	#include <isl/id_to_ast_expr.h>
 	__isl_give isl_printer *isl_printer_print_id_to_ast_expr(
 		__isl_take isl_printer *p,
-		__isl_keep id_to_ast_expr *id2expr);
-
-=head2 Multiple Values
-
-An C<isl_multi_val> object represents a sequence of zero or more values,
-living in a set space.
-
-An C<isl_multi_val> can be constructed from an C<isl_val_list>
-using the following function
-
-	#include <isl/val.h>
-	__isl_give isl_multi_val *isl_multi_val_from_val_list(
-		__isl_take isl_space *space,
-		__isl_take isl_val_list *list);
-
-The zero multiple value (with value zero for each set dimension)
-can be created using the following function.
-
-	#include <isl/val.h>
-	__isl_give isl_multi_val *isl_multi_val_zero(
-		__isl_take isl_space *space);
-
-Multiple values can be copied and freed using
-
-	#include <isl/val.h>
-	__isl_give isl_multi_val *isl_multi_val_copy(
-		__isl_keep isl_multi_val *mv);
-	__isl_null isl_multi_val *isl_multi_val_free(
-		__isl_take isl_multi_val *mv);
-
-They can be inspected using
-
-	#include <isl/val.h>
-	isl_ctx *isl_multi_val_get_ctx(
-		__isl_keep isl_multi_val *mv);
-	unsigned isl_multi_val_dim(__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type);
-	__isl_give isl_val *isl_multi_val_get_val(
-		__isl_keep isl_multi_val *mv, int pos);
-	int isl_multi_val_find_dim_by_id(
-		__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type, __isl_keep isl_id *id);
-	__isl_give isl_id *isl_multi_val_get_dim_id(
-		__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_multi_val_get_tuple_name(
-		__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type);
-	int isl_multi_val_has_tuple_id(__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_multi_val_get_tuple_id(
-		__isl_keep isl_multi_val *mv,
-		enum isl_dim_type type);
-	int isl_multi_val_range_is_wrapping(
-		__isl_keep isl_multi_val *mv);
-
-They can be modified using
-
-	#include <isl/val.h>
-	__isl_give isl_multi_val *isl_multi_val_set_val(
-		__isl_take isl_multi_val *mv, int pos,
-		__isl_take isl_val *val);
-	__isl_give isl_multi_val *isl_multi_val_set_dim_name(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, unsigned pos, const char *s);
-	__isl_give isl_multi_val *isl_multi_val_set_dim_id(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, unsigned pos,
-		__isl_take isl_id *id);
-	__isl_give isl_multi_val *isl_multi_val_set_tuple_name(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, const char *s);
-	__isl_give isl_multi_val *isl_multi_val_set_tuple_id(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_multi_val *isl_multi_val_reset_tuple_id(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type);
-	__isl_give isl_multi_val *isl_multi_val_reset_user(
-		__isl_take isl_multi_val *mv);
-
-	__isl_give isl_multi_val *isl_multi_val_insert_dims(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_multi_val *isl_multi_val_add_dims(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_multi_val *isl_multi_val_drop_dims(
-		__isl_take isl_multi_val *mv,
-		enum isl_dim_type type, unsigned first, unsigned n);
-
-Operations include
-
-	#include <isl/val.h>
-	__isl_give isl_multi_val *isl_multi_val_align_params(
-		__isl_take isl_multi_val *mv,
-		__isl_take isl_space *model);
-	__isl_give isl_multi_val *isl_multi_val_from_range(
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_val *isl_multi_val_range_splice(
-		__isl_take isl_multi_val *mv1, unsigned pos,
-		__isl_take isl_multi_val *mv2);
-	__isl_give isl_multi_val *isl_multi_val_range_product(
-		__isl_take isl_multi_val *mv1,
-		__isl_take isl_multi_val *mv2);
-	__isl_give isl_multi_val *
-	isl_multi_val_range_factor_domain(
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_val *
-	isl_multi_val_range_factor_range(
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_val *isl_multi_val_flat_range_product(
-		__isl_take isl_multi_val *mv1,
-		__isl_take isl_multi_aff *mv2);
-	__isl_give isl_multi_val *isl_multi_val_product(
-		__isl_take isl_multi_val *mv1,
-		__isl_take isl_multi_val *mv2);
-	__isl_give isl_multi_val *isl_multi_val_add_val(
-		__isl_take isl_multi_val *mv,
-		__isl_take isl_val *v);
-	__isl_give isl_multi_val *isl_multi_val_mod_val(
-		__isl_take isl_multi_val *mv,
-		__isl_take isl_val *v);
-	__isl_give isl_multi_val *isl_multi_val_scale_val(
-		__isl_take isl_multi_val *mv,
-		__isl_take isl_val *v);
-	__isl_give isl_multi_val *isl_multi_val_scale_multi_val(
-		__isl_take isl_multi_val *mv1,
-		__isl_take isl_multi_val *mv2);
-	__isl_give isl_multi_val *
-	isl_multi_val_scale_down_multi_val(
-		__isl_take isl_multi_val *mv1,
-		__isl_take isl_multi_val *mv2);
-
-A multiple value can be printed using
-
-	__isl_give isl_printer *isl_printer_print_multi_val(
-		__isl_take isl_printer *p,
-		__isl_keep isl_multi_val *mv);
+		__isl_keep isl_id_to_ast_expr *id2expr);
 
 =head2 Vectors
 
@@ -3875,14 +9456,17 @@
 	#include <isl/vec.h>
 	__isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx,
 		unsigned size);
+	__isl_give isl_vec *isl_vec_zero(isl_ctx *ctx,
+		unsigned size);
 	__isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
 	__isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
 
-Note that the elements of a newly created vector may have arbitrary values.
+Note that the elements of a vector created by C<isl_vec_alloc>
+may have arbitrary values.
+A vector created by C<isl_vec_zero> has elements with value zero.
 The elements can be changed and inspected using the following functions.
 
-	isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
-	int isl_vec_size(__isl_keep isl_vec *vec);
+	isl_size isl_vec_size(__isl_keep isl_vec *vec);
 	__isl_give isl_val *isl_vec_get_element_val(
 		__isl_keep isl_vec *vec, int pos);
 	__isl_give isl_vec *isl_vec_set_element_si(
@@ -3918,9 +9502,8 @@
 Note that the elements of a newly created matrix may have arbitrary values.
 The elements can be changed and inspected using the following functions.
 
-	isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat);
-	int isl_mat_rows(__isl_keep isl_mat *mat);
-	int isl_mat_cols(__isl_keep isl_mat *mat);
+	isl_size isl_mat_rows(__isl_keep isl_mat *mat);
+	isl_size isl_mat_cols(__isl_keep isl_mat *mat);
 	__isl_give isl_val *isl_mat_get_element_val(
 		__isl_keep isl_mat *mat, int row, int col);
 	__isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
@@ -3929,8 +9512,11 @@
 		__isl_take isl_mat *mat, int row, int col,
 		__isl_take isl_val *v);
 
-C<isl_mat_get_element> will return a negative value if anything went wrong.
-In that case, the value of C<*v> is undefined.
+The following function computes the rank of a matrix.
+The return value may be -1 if some error occurred.
+
+	#include <isl/mat.h>
+	isl_size isl_mat_rank(__isl_keep isl_mat *mat);
 
 The following function can be used to compute the (right) inverse
 of a matrix, i.e., a matrix such that the product of the original
@@ -3945,1872 +9531,1286 @@
 
 	__isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
 
-=head2 Piecewise Quasi Affine Expressions
+The following function computes a basis for the space spanned
+by the rows of a matrix.
 
-The zero quasi affine expression or the quasi affine expression
-that is equal to a given value or
-a specified dimension on a given domain can be created using
-
-	__isl_give isl_aff *isl_aff_zero_on_domain(
-		__isl_take isl_local_space *ls);
-	__isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
-		__isl_take isl_local_space *ls);
-	__isl_give isl_aff *isl_aff_val_on_domain(
-		__isl_take isl_local_space *ls,
-		__isl_take isl_val *val);
-	__isl_give isl_aff *isl_aff_var_on_domain(
-		__isl_take isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_pw_aff *isl_pw_aff_var_on_domain(
-		__isl_take isl_local_space *ls,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_aff *isl_aff_nan_on_domain(
-		__isl_take isl_local_space *ls);
-	__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(
-		__isl_take isl_local_space *ls);
+	__isl_give isl_mat *isl_mat_row_basis(
+		__isl_take isl_mat *mat);
 
-Note that the space in which the resulting objects live is a map space
-with the given space as domain and a one-dimensional range.
+The following function computes rows that extend a basis of C<mat1>
+to a basis that also covers C<mat2>.
 
-An empty piecewise quasi affine expression (one with no cells)
-or a piecewise quasi affine expression with a single cell can
-be created using the following functions.
+	__isl_give isl_mat *isl_mat_row_basis_extension(
+		__isl_take isl_mat *mat1,
+		__isl_take isl_mat *mat2);
+
+The following function checks whether there is no linear dependence
+among the combined rows of "mat1" and "mat2" that is not already present
+in "mat1" or "mat2" individually.
+If "mat1" and "mat2" have linearly independent rows by themselves,
+then this means that there is no linear dependence among all rows together.
+
+	isl_bool isl_mat_has_linearly_independent_rows(
+		__isl_keep isl_mat *mat1,
+		__isl_keep isl_mat *mat2);
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_aff *isl_pw_aff_empty(
-		__isl_take isl_space *space);
-	__isl_give isl_pw_aff *isl_pw_aff_alloc(
-		__isl_take isl_set *set, __isl_take isl_aff *aff);
-	__isl_give isl_pw_aff *isl_pw_aff_from_aff(
-		__isl_take isl_aff *aff);
-
-A piecewise quasi affine expression that is equal to 1 on a set
-and 0 outside the set can be created using the following function.
-
-	#include <isl/aff.h>
-	__isl_give isl_pw_aff *isl_set_indicator_function(
-		__isl_take isl_set *set);
-
-Quasi affine expressions can be copied and freed using
-
-	#include <isl/aff.h>
-	__isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
-	__isl_null isl_aff *isl_aff_free(__isl_take isl_aff *aff);
-
-	__isl_give isl_pw_aff *isl_pw_aff_copy(
-		__isl_keep isl_pw_aff *pwaff);
-	__isl_null isl_pw_aff *isl_pw_aff_free(
-		__isl_take isl_pw_aff *pwaff);
-
-A (rational) bound on a dimension can be extracted from an C<isl_constraint>
-using the following function.  The constraint is required to have
-a non-zero coefficient for the specified dimension.
-
-	#include <isl/constraint.h>
-	__isl_give isl_aff *isl_constraint_get_bound(
-		__isl_keep isl_constraint *constraint,
-		enum isl_dim_type type, int pos);
-
-The entire affine expression of the constraint can also be extracted
-using the following function.
-
-	#include <isl/constraint.h>
-	__isl_give isl_aff *isl_constraint_get_aff(
-		__isl_keep isl_constraint *constraint);
-
-Conversely, an equality constraint equating
-the affine expression to zero or an inequality constraint enforcing
-the affine expression to be non-negative, can be constructed using
-
-	__isl_give isl_constraint *isl_equality_from_aff(
-		__isl_take isl_aff *aff);
-	__isl_give isl_constraint *isl_inequality_from_aff(
-		__isl_take isl_aff *aff);
-
-The expression can be inspected using
-
-	#include <isl/aff.h>
-	isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
-	int isl_aff_dim(__isl_keep isl_aff *aff,
-		enum isl_dim_type type);
-	__isl_give isl_local_space *isl_aff_get_domain_local_space(
-		__isl_keep isl_aff *aff);
-	__isl_give isl_local_space *isl_aff_get_local_space(
-		__isl_keep isl_aff *aff);
-	const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_pw_aff_get_dim_name(
-		__isl_keep isl_pw_aff *pa,
-		enum isl_dim_type type, unsigned pos);
-	int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_pw_aff_get_dim_id(
-		__isl_keep isl_pw_aff *pa,
-		enum isl_dim_type type, unsigned pos);
-	int isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_pw_aff_get_tuple_id(
-		__isl_keep isl_pw_aff *pa,
-		enum isl_dim_type type);
-	__isl_give isl_val *isl_aff_get_constant_val(
-		__isl_keep isl_aff *aff);
-	__isl_give isl_val *isl_aff_get_coefficient_val(
-		__isl_keep isl_aff *aff,
-		enum isl_dim_type type, int pos);
-	__isl_give isl_val *isl_aff_get_denominator_val(
-		__isl_keep isl_aff *aff);
-	__isl_give isl_aff *isl_aff_get_div(
-		__isl_keep isl_aff *aff, int pos);
-
-	int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
-	int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
-		int (*fn)(__isl_take isl_set *set,
-			  __isl_take isl_aff *aff,
-			  void *user), void *user);
-
-	int isl_aff_is_cst(__isl_keep isl_aff *aff);
-	int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
-
-	int isl_aff_is_nan(__isl_keep isl_aff *aff);
-	int isl_pw_aff_involves_nan(__isl_keep isl_pw_aff *pa);
-
-	int isl_aff_involves_dims(__isl_keep isl_aff *aff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-
-	isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
-	unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff,
-		enum isl_dim_type type);
-	int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
-
-It can be modified using
-
-	#include <isl/aff.h>
-	__isl_give isl_aff *isl_aff_set_tuple_id(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(
-		__isl_take isl_pw_aff *pwaff,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(
-		__isl_take isl_pw_aff *pa,
-		enum isl_dim_type type);
-	__isl_give isl_aff *isl_aff_set_dim_name(
-		__isl_take isl_aff *aff, enum isl_dim_type type,
-		unsigned pos, const char *s);
-	__isl_give isl_aff *isl_aff_set_dim_id(
-		__isl_take isl_aff *aff, enum isl_dim_type type,
-		unsigned pos, __isl_take isl_id *id);
-	__isl_give isl_pw_aff *isl_pw_aff_set_dim_id(
-		__isl_take isl_pw_aff *pma,
-		enum isl_dim_type type, unsigned pos,
-		__isl_take isl_id *id);
-	__isl_give isl_aff *isl_aff_set_constant_si(
-		__isl_take isl_aff *aff, int v);
-	__isl_give isl_aff *isl_aff_set_constant_val(
-		__isl_take isl_aff *aff, __isl_take isl_val *v);
-	__isl_give isl_aff *isl_aff_set_coefficient_si(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, int pos, int v);
-	__isl_give isl_aff *isl_aff_set_coefficient_val(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, int pos,
-		__isl_take isl_val *v);
-
-	__isl_give isl_aff *isl_aff_add_constant_si(
-		__isl_take isl_aff *aff, int v);
-	__isl_give isl_aff *isl_aff_add_constant_val(
-		__isl_take isl_aff *aff, __isl_take isl_val *v);
-	__isl_give isl_aff *isl_aff_add_constant_num_si(
-		__isl_take isl_aff *aff, int v);
-	__isl_give isl_aff *isl_aff_add_coefficient_si(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, int pos, int v);
-	__isl_give isl_aff *isl_aff_add_coefficient_val(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, int pos,
-		__isl_take isl_val *v);
-
-	__isl_give isl_aff *isl_aff_insert_dims(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_pw_aff *isl_pw_aff_insert_dims(
-		__isl_take isl_pw_aff *pwaff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_aff *isl_aff_add_dims(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_pw_aff *isl_pw_aff_add_dims(
-		__isl_take isl_pw_aff *pwaff,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_aff *isl_aff_drop_dims(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_pw_aff *isl_pw_aff_drop_dims(
-		__isl_take isl_pw_aff *pwaff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_aff *isl_aff_move_dims(
-		__isl_take isl_aff *aff,
-		enum isl_dim_type dst_type, unsigned dst_pos,
-		enum isl_dim_type src_type, unsigned src_pos,
-		unsigned n);
-	__isl_give isl_pw_aff *isl_pw_aff_move_dims(
-		__isl_take isl_pw_aff *pa,
-		enum isl_dim_type dst_type, unsigned dst_pos,
-		enum isl_dim_type src_type, unsigned src_pos,
-		unsigned n);
-
-Note that C<isl_aff_set_constant_si> and C<isl_aff_set_coefficient_si>
-set the I<numerator> of the constant or coefficient, while
-C<isl_aff_set_constant_val> and C<isl_aff_set_coefficient_val> set
-the constant or coefficient as a whole.
-The C<add_constant> and C<add_coefficient> functions add an integer
-or rational value to
-the possibly rational constant or coefficient.
-The C<add_constant_num> functions add an integer value to
-the numerator.
-
-To check whether an affine expressions is obviously zero
-or (obviously) equal to some other affine expression, use
-
-	#include <isl/aff.h>
-	int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
-	int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
-		__isl_keep isl_aff *aff2);
-	int isl_pw_aff_plain_is_equal(
-		__isl_keep isl_pw_aff *pwaff1,
-		__isl_keep isl_pw_aff *pwaff2);
-	int isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1,
-		__isl_keep isl_pw_aff *pa2);
-	int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
-		__isl_keep isl_pw_aff *pa2);
-
-The function C<isl_pw_aff_plain_cmp> can be used to sort
-C<isl_pw_aff>s.  The order is not strictly defined.
-The current order sorts expressions that only involve
-earlier dimensions before those that involve later dimensions.
+=head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
 
-Operations include
+The following functions determine
+an upper or lower bound on a quasipolynomial over its domain.
 
-	#include <isl/aff.h>
-	__isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
-		__isl_take isl_aff *aff2);
-	__isl_give isl_pw_aff *isl_pw_aff_add(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_pw_aff *isl_pw_aff_min(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_pw_aff *isl_pw_aff_max(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
-		__isl_take isl_aff *aff2);
-	__isl_give isl_pw_aff *isl_pw_aff_sub(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
-	__isl_give isl_pw_aff *isl_pw_aff_neg(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
-	__isl_give isl_pw_aff *isl_pw_aff_ceil(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
-	__isl_give isl_pw_aff *isl_pw_aff_floor(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
-		__isl_take isl_val *mod);
-	__isl_give isl_pw_aff *isl_pw_aff_mod_val(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_val *mod);
-	__isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
-		__isl_take isl_val *v);
-	__isl_give isl_pw_aff *isl_pw_aff_scale_val(
-		__isl_take isl_pw_aff *pa, __isl_take isl_val *v);
-	__isl_give isl_aff *isl_aff_scale_down_ui(
-		__isl_take isl_aff *aff, unsigned f);
-	__isl_give isl_aff *isl_aff_scale_down_val(
-		__isl_take isl_aff *aff, __isl_take isl_val *v);
-	__isl_give isl_pw_aff *isl_pw_aff_scale_down_val(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_val *f);
-
-	__isl_give isl_pw_aff *isl_pw_aff_list_min(
-		__isl_take isl_pw_aff_list *list);
-	__isl_give isl_pw_aff *isl_pw_aff_list_max(
-		__isl_take isl_pw_aff_list *list);
-
-	__isl_give isl_pw_aff *isl_pw_aff_coalesce(
-		__isl_take isl_pw_aff *pwqp);
+	__isl_give isl_pw_qpolynomial_fold *
+	isl_pw_qpolynomial_bound(
+		__isl_take isl_pw_qpolynomial *pwqp,
+		enum isl_fold type, isl_bool *tight);
 
-	__isl_give isl_aff *isl_aff_align_params(
-		__isl_take isl_aff *aff,
-		__isl_take isl_space *model);
-	__isl_give isl_pw_aff *isl_pw_aff_align_params(
-		__isl_take isl_pw_aff *pwaff,
-		__isl_take isl_space *model);
+	__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_bound(
+		__isl_take isl_union_pw_qpolynomial *upwqp,
+		enum isl_fold type, isl_bool *tight);
 
-	__isl_give isl_aff *isl_aff_project_domain_on_params(
-		__isl_take isl_aff *aff);
-	__isl_give isl_pw_aff *isl_pw_aff_from_range(
-		__isl_take isl_pw_aff *pwa);
+The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
+If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
+is the returned bound is known be tight, i.e., for each value
+of the parameters there is at least
+one element in the domain that reaches the bound.
+If the domain of C<pwqp> is not wrapping, then the bound is computed
+over all elements in that domain and the result has a purely parametric
+domain.  If the domain of C<pwqp> is wrapping, then the bound is
+computed over the range of the wrapped relation.  The domain of the
+wrapped relation becomes the domain of the result.
 
-	__isl_give isl_aff *isl_aff_gist_params(
-		__isl_take isl_aff *aff,
-		__isl_take isl_set *context);
-	__isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
-		__isl_take isl_set *context);
-	__isl_give isl_pw_aff *isl_pw_aff_gist_params(
-		__isl_take isl_pw_aff *pwaff,
-		__isl_take isl_set *context);
-	__isl_give isl_pw_aff *isl_pw_aff_gist(
-		__isl_take isl_pw_aff *pwaff,
-		__isl_take isl_set *context);
+=head2 Parametric Vertex Enumeration
 
-	__isl_give isl_set *isl_pw_aff_domain(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_set *isl_pw_aff_params(
-		__isl_take isl_pw_aff *pwa);
-	__isl_give isl_pw_aff *isl_pw_aff_intersect_domain(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_set *set);
-	__isl_give isl_pw_aff *isl_pw_aff_intersect_params(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_set *set);
+The parametric vertex enumeration described in this section
+is mainly intended to be used internally and by the C<barvinok>
+library.
 
-	__isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
-		__isl_take isl_aff *aff2);
-	__isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
-		__isl_take isl_aff *aff2);
-	__isl_give isl_pw_aff *isl_pw_aff_mul(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_pw_aff *isl_pw_aff_div(
-		__isl_take isl_pw_aff *pa1,
-		__isl_take isl_pw_aff *pa2);
-	__isl_give isl_pw_aff *isl_pw_aff_tdiv_q(
-		__isl_take isl_pw_aff *pa1,
-		__isl_take isl_pw_aff *pa2);
-	__isl_give isl_pw_aff *isl_pw_aff_tdiv_r(
-		__isl_take isl_pw_aff *pa1,
-		__isl_take isl_pw_aff *pa2);
+	#include <isl/vertices.h>
+	__isl_give isl_vertices *isl_basic_set_compute_vertices(
+		__isl_keep isl_basic_set *bset);
 
-When multiplying two affine expressions, at least one of the two needs
-to be a constant.  Similarly, when dividing an affine expression by another,
-the second expression needs to be a constant.
-C<isl_pw_aff_tdiv_q> computes the quotient of an integer division with
-rounding towards zero.  C<isl_pw_aff_tdiv_r> computes the corresponding
-remainder.
+The function C<isl_basic_set_compute_vertices> performs the
+actual computation of the parametric vertices and the chamber
+decomposition and stores the result in an C<isl_vertices> object.
+This information can be queried by either iterating over all
+the vertices or iterating over all the chambers or cells
+and then iterating over all vertices that are active on the chamber.
 
-	#include <isl/aff.h>
-	__isl_give isl_aff *isl_aff_pullback_aff(
-		__isl_take isl_aff *aff1,
-		__isl_take isl_aff *aff2);
-	__isl_give isl_aff *isl_aff_pullback_multi_aff(
-		__isl_take isl_aff *aff,
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
-		__isl_take isl_pw_aff *pa,
-		__isl_take isl_multi_pw_aff *mpa);
+	isl_stat isl_vertices_foreach_vertex(
+		__isl_keep isl_vertices *vertices,
+		isl_stat (*fn)(__isl_take isl_vertex *vertex,
+			void *user), void *user);
 
-These functions precompose the input expression by the given
-C<isl_aff>, C<isl_multi_aff> or C<isl_pw_multi_aff>.  In other words,
-the C<isl_aff>, C<isl_multi_aff> or C<isl_pw_multi_aff> is plugged
-into the (piecewise) affine expression.
-Objects of type C<isl_multi_aff> are described in
-L</"Piecewise Multiple Quasi Affine Expressions">.
+	isl_stat isl_vertices_foreach_cell(
+		__isl_keep isl_vertices *vertices,
+		isl_stat (*fn)(__isl_take isl_cell *cell,
+			void *user), void *user);
+	isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
+		isl_stat (*fn)(__isl_take isl_vertex *vertex,
+			void *user), void *user);
 
-	#include <isl/aff.h>
-	__isl_give isl_basic_set *isl_aff_zero_basic_set(
-		__isl_take isl_aff *aff);
-	__isl_give isl_basic_set *isl_aff_neg_basic_set(
-		__isl_take isl_aff *aff);
-	__isl_give isl_basic_set *isl_aff_le_basic_set(
-		__isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
-	__isl_give isl_basic_set *isl_aff_ge_basic_set(
-		__isl_take isl_aff *aff1, __isl_take isl_aff *aff2);
-	__isl_give isl_set *isl_pw_aff_eq_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_set *isl_pw_aff_ne_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_set *isl_pw_aff_le_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_set *isl_pw_aff_lt_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_set *isl_pw_aff_ge_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_set *isl_pw_aff_gt_set(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
+Other operations that can be performed on an C<isl_vertices> object are
+the following.
 
-	__isl_give isl_set *isl_pw_aff_list_eq_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
-	__isl_give isl_set *isl_pw_aff_list_ne_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
-	__isl_give isl_set *isl_pw_aff_list_le_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
-	__isl_give isl_set *isl_pw_aff_list_lt_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
-	__isl_give isl_set *isl_pw_aff_list_ge_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
-	__isl_give isl_set *isl_pw_aff_list_gt_set(
-		__isl_take isl_pw_aff_list *list1,
-		__isl_take isl_pw_aff_list *list2);
+	isl_size isl_vertices_get_n_vertices(
+		__isl_keep isl_vertices *vertices);
+	__isl_null isl_vertices *isl_vertices_free(
+		__isl_take isl_vertices *vertices);
 
-The function C<isl_aff_neg_basic_set> returns a basic set
-containing those elements in the domain space
-of C<aff> where C<aff> is negative.
-The function C<isl_aff_ge_basic_set> returns a basic set
-containing those elements in the shared space
-of C<aff1> and C<aff2> where C<aff1> is greater than or equal to C<aff2>.
-The function C<isl_pw_aff_ge_set> returns a set
-containing those elements in the shared domain
-of C<pwaff1> and C<pwaff2> where C<pwaff1> is greater than or equal to C<pwaff2>.
-The functions operating on C<isl_pw_aff_list> apply the corresponding
-C<isl_pw_aff> function to each pair of elements in the two lists.
+Vertices can be inspected and destroyed using the following functions.
 
-	#include <isl/aff.h>
-	__isl_give isl_set *isl_pw_aff_nonneg_set(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_set *isl_pw_aff_zero_set(
-		__isl_take isl_pw_aff *pwaff);
-	__isl_give isl_set *isl_pw_aff_non_zero_set(
-		__isl_take isl_pw_aff *pwaff);
+	isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);
+	__isl_give isl_basic_set *isl_vertex_get_domain(
+		__isl_keep isl_vertex *vertex);
+	__isl_give isl_multi_aff *isl_vertex_get_expr(
+		__isl_keep isl_vertex *vertex);
+	__isl_null isl_vertex *isl_vertex_free(
+		__isl_take isl_vertex *vertex);
 
-The function C<isl_pw_aff_nonneg_set> returns a set
-containing those elements in the domain
-of C<pwaff> where C<pwaff> is non-negative.
+C<isl_vertex_get_expr> returns a multiple quasi-affine expression
+describing the vertex in terms of the parameters,
+while C<isl_vertex_get_domain> returns the activity domain
+of the vertex.
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_aff *isl_pw_aff_cond(
-		__isl_take isl_pw_aff *cond,
-		__isl_take isl_pw_aff *pwaff_true,
-		__isl_take isl_pw_aff *pwaff_false);
+Chambers can be inspected and destroyed using the following functions.
 
-The function C<isl_pw_aff_cond> performs a conditional operator
-and returns an expression that is equal to C<pwaff_true>
-for elements where C<cond> is non-zero and equal to C<pwaff_false> for elements
-where C<cond> is zero.
+	__isl_give isl_basic_set *isl_cell_get_domain(
+		__isl_keep isl_cell *cell);
+	__isl_null isl_cell *isl_cell_free(
+		__isl_take isl_cell *cell);
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_aff *isl_pw_aff_union_min(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_pw_aff *isl_pw_aff_union_max(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
-	__isl_give isl_pw_aff *isl_pw_aff_union_add(
-		__isl_take isl_pw_aff *pwaff1,
-		__isl_take isl_pw_aff *pwaff2);
+=head1 Polyhedral Compilation Library
 
-The function C<isl_pw_aff_union_max> computes a piecewise quasi-affine
-expression with a domain that is the union of those of C<pwaff1> and
-C<pwaff2> and such that on each cell, the quasi-affine expression is
-the maximum of those of C<pwaff1> and C<pwaff2>.  If only one of
-C<pwaff1> or C<pwaff2> is defined on a given cell, then the
-associated expression is the defined one.
+This section collects functionality in C<isl> that has been specifically
+designed for use during polyhedral compilation.
 
-An expression can be read from input using
+=head2 Schedule Trees
 
-	#include <isl/aff.h>
-	__isl_give isl_aff *isl_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_pw_aff *isl_pw_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
+A schedule tree is a structured representation of a schedule,
+assigning a relative order to a set of domain elements.
+The relative order expressed by the schedule tree is
+defined recursively.  In particular, the order between
+two domain elements is determined by the node that is closest
+to the root that refers to both elements and that orders them apart.
+Each node in the tree is of one of several types.
+The root node is always of type C<isl_schedule_node_domain>
+(or C<isl_schedule_node_extension>)
+and it describes the (extra) domain elements to which the schedule applies.
+The other types of nodes are as follows.
 
-An expression can be printed using
+=over
 
-	#include <isl/aff.h>
-	__isl_give isl_printer *isl_printer_print_aff(
-		__isl_take isl_printer *p, __isl_keep isl_aff *aff);
+=item C<isl_schedule_node_band>
 
-	__isl_give isl_printer *isl_printer_print_pw_aff(
-		__isl_take isl_printer *p,
-		__isl_keep isl_pw_aff *pwaff);
+A band of schedule dimensions.  Each schedule dimension is represented
+by a union piecewise quasi-affine expression.  If this expression
+assigns a different value to two domain elements, while all previous
+schedule dimensions in the same band assign them the same value,
+then the two domain elements are ordered according to these two
+different values.
+Each expression is required to be total in the domain elements
+that reach the band node.
+
+=item C<isl_schedule_node_expansion>
+
+An expansion node maps each of the domain elements that reach the node
+to one or more domain elements.  The image of this mapping forms
+the set of domain elements that reach the child of the expansion node.
+The function that maps each of the expanded domain elements
+to the original domain element from which it was expanded
+is called the contraction.
+
+=item C<isl_schedule_node_filter>
+
+A filter node does not impose any ordering, but rather intersects
+the set of domain elements that the current subtree refers to
+with a given union set.  The subtree of the filter node only
+refers to domain elements in the intersection.
+A filter node is typically only used as a child of a sequence or
+set node.
+
+=item C<isl_schedule_node_leaf>
+
+A leaf of the schedule tree.  Leaf nodes do not impose any ordering.
+
+=item C<isl_schedule_node_mark>
+
+A mark node can be used to attach any kind of information to a subtree
+of the schedule tree.
+
+=item C<isl_schedule_node_sequence>
+
+A sequence node has one or more children, each of which is a filter node.
+The filters on these filter nodes form a partition of
+the domain elements that the current subtree refers to.
+If two domain elements appear in distinct filters then the sequence
+node orders them according to the child positions of the corresponding
+filter nodes.
+
+=item C<isl_schedule_node_set>
+
+A set node is similar to a sequence node, except that
+it expresses that domain elements appearing in distinct filters
+may have any order.  The order of the children of a set node
+is therefore also immaterial.
 
-=head2 Piecewise Multiple Quasi Affine Expressions
+=back
 
-An C<isl_multi_aff> object represents a sequence of
-zero or more affine expressions, all defined on the same domain space.
-Similarly, an C<isl_multi_pw_aff> object represents a sequence of
-zero or more piecewise affine expressions.
-
-An C<isl_multi_aff> can be constructed from a single
-C<isl_aff> or an C<isl_aff_list> using the
-following functions.  Similarly for C<isl_multi_pw_aff>
-and C<isl_pw_multi_aff>.
+The following node types are only supported by the AST generator.
 
-	#include <isl/aff.h>
-	__isl_give isl_multi_aff *isl_multi_aff_from_aff(
-		__isl_take isl_aff *aff);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_from_multi_aff(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
-		__isl_take isl_pw_aff *pa);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
-		__isl_take isl_pw_aff *pa);
-	__isl_give isl_multi_aff *isl_multi_aff_from_aff_list(
-		__isl_take isl_space *space,
-		__isl_take isl_aff_list *list);
+=over
 
-An C<isl_multi_pw_aff> can be converted to an C<isl_pw_multi_aff>
-using the function C<isl_pw_multi_aff_from_multi_pw_aff> below.
-Note however that the domain
-of the result is the intersection of the domains of the input.
-The reverse conversion is exact.
+=item C<isl_schedule_node_context>
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_from_multi_pw_aff(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_from_pw_multi_aff(
-		__isl_take isl_pw_multi_aff *pma);
+The context describes constraints on the parameters and
+the schedule dimensions of outer
+bands that the AST generator may assume to hold.  It is also the only
+kind of node that may introduce additional parameters.
+The space of the context is that of the flat product of the outer
+band nodes.  In particular, if there are no outer band nodes, then
+this space is the unnamed zero-dimensional space.
+Since a context node references the outer band nodes, any tree
+containing a context node is considered to be anchored.
+
+=item C<isl_schedule_node_extension>
+
+An extension node instructs the AST generator to add additional
+domain elements that need to be scheduled.
+The additional domain elements are described by the range of
+the extension map in terms of the outer schedule dimensions,
+i.e., the flat product of the outer band nodes.
+Note that domain elements are added whenever the AST generator
+reaches the extension node, meaning that there are still some
+active domain elements for which an AST needs to be generated.
+The conditions under which some domain elements are still active
+may however not be completely described by the outer AST nodes
+generated at that point.
+Since an extension node references the outer band nodes, any tree
+containing an extension node is considered to be anchored.
+
+An extension node may also appear as the root of a schedule tree,
+when it is intended to be inserted into another tree
+using C<isl_schedule_node_graft_before> or C<isl_schedule_node_graft_after>.
+In this case, the domain of the extension node should
+correspond to the flat product of the outer band nodes
+in this other schedule tree at the point where the extension tree
+will be inserted.
+
+=item C<isl_schedule_node_guard>
+
+The guard describes constraints on the parameters and
+the schedule dimensions of outer
+bands that need to be enforced by the outer nodes
+in the generated AST.
+That is, the part of the AST that is generated from descendants
+of the guard node can assume that these constraints are satisfied.
+The space of the guard is that of the flat product of the outer
+band nodes.  In particular, if there are no outer band nodes, then
+this space is the unnamed zero-dimensional space.
+Since a guard node references the outer band nodes, any tree
+containing a guard node is considered to be anchored.
 
-An empty piecewise multiple quasi affine expression (one with no cells),
-the zero piecewise multiple quasi affine expression (with value zero
-for each output dimension),
-a piecewise multiple quasi affine expression with a single cell (with
-either a universe or a specified domain) or
-a zero-dimensional piecewise multiple quasi affine expression
-on a given domain
-can be created using the following functions.
+=back
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_aff *isl_multi_aff_zero(
-		__isl_take isl_space *space);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_zero(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_aff *isl_multi_aff_identity(
-		__isl_take isl_space *space);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_aff *isl_multi_aff_domain_map(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_aff *isl_multi_aff_range_map(
-		__isl_take isl_space *space);
-	__isl_give isl_multi_aff *isl_multi_aff_project_out_map(
-		__isl_take isl_space *space,
-		enum isl_dim_type type,
-		unsigned first, unsigned n);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_project_out_map(
-		__isl_take isl_space *space,
-		enum isl_dim_type type,
-		unsigned first, unsigned n);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_from_multi_aff(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(
-		__isl_take isl_set *set,
-		__isl_take isl_multi_aff *maff);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
-		__isl_take isl_set *set);
+Except for the C<isl_schedule_node_context> nodes,
+none of the nodes may introduce any parameters that were not
+already present in the root domain node.
+
+A schedule tree is encapsulated in an C<isl_schedule> object.
+The simplest such objects, those with a tree consisting of single domain node,
+can be created using the following functions with either an empty
+domain or a given domain.
 
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_empty(
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_empty(
 		__isl_take isl_space *space);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_add_pw_multi_aff(
-		__isl_take isl_union_pw_multi_aff *upma,
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_from_domain(
-		__isl_take isl_union_set *uset);
-
-A piecewise multiple quasi affine expression can also be initialized
-from an C<isl_set> or C<isl_map>, provided the C<isl_set> is a singleton
-and the C<isl_map> is single-valued.
-In case of a conversion from an C<isl_union_set> or an C<isl_union_map>
-to an C<isl_union_pw_multi_aff>, these properties need to hold in each space.
-
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(
-		__isl_take isl_set *set);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(
-		__isl_take isl_map *map);
-
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_from_union_set(
-		__isl_take isl_union_set *uset);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_from_union_map(
-		__isl_take isl_union_map *umap);
-
-Multiple quasi affine expressions can be copied and freed using
-
-	#include <isl/aff.h>
-	__isl_give isl_multi_aff *isl_multi_aff_copy(
-		__isl_keep isl_multi_aff *maff);
-	__isl_null isl_multi_aff *isl_multi_aff_free(
-		__isl_take isl_multi_aff *maff);
-
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_copy(
-		__isl_keep isl_pw_multi_aff *pma);
-	__isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
-		__isl_take isl_pw_multi_aff *pma);
-
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_copy(
-		__isl_keep isl_union_pw_multi_aff *upma);
-	__isl_null isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_free(
-		__isl_take isl_union_pw_multi_aff *upma);
-
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_copy(
-		__isl_keep isl_multi_pw_aff *mpa);
-	__isl_null isl_multi_pw_aff *isl_multi_pw_aff_free(
-		__isl_take isl_multi_pw_aff *mpa);
-
-The expression can be inspected using
-
-	#include <isl/aff.h>
-	isl_ctx *isl_multi_aff_get_ctx(
-		__isl_keep isl_multi_aff *maff);
-	isl_ctx *isl_pw_multi_aff_get_ctx(
-		__isl_keep isl_pw_multi_aff *pma);
-	isl_ctx *isl_union_pw_multi_aff_get_ctx(
-		__isl_keep isl_union_pw_multi_aff *upma);
-	isl_ctx *isl_multi_pw_aff_get_ctx(
-		__isl_keep isl_multi_pw_aff *mpa);
-
-	int isl_multi_aff_involves_dims(
-		__isl_keep isl_multi_aff *ma,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	int isl_multi_pw_aff_involves_dims(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned first, unsigned n);
+	__isl_give isl_schedule *isl_schedule_from_domain(
+		__isl_take isl_union_set *domain);
 
-	unsigned isl_multi_aff_dim(__isl_keep isl_multi_aff *maff,
-		enum isl_dim_type type);
-	unsigned isl_pw_multi_aff_dim(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type);
-	unsigned isl_multi_pw_aff_dim(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type);
-	__isl_give isl_aff *isl_multi_aff_get_aff(
-		__isl_keep isl_multi_aff *multi, int pos);
-	__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
-		__isl_keep isl_pw_multi_aff *pma, int pos);
-	__isl_give isl_pw_aff *isl_multi_pw_aff_get_pw_aff(
-		__isl_keep isl_multi_pw_aff *mpa, int pos);
-	int isl_multi_aff_find_dim_by_id(
-		__isl_keep isl_multi_aff *ma,
-		enum isl_dim_type type, __isl_keep isl_id *id);
-	int isl_multi_pw_aff_find_dim_by_id(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, __isl_keep isl_id *id);
-	const char *isl_pw_multi_aff_get_dim_name(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_multi_aff_get_dim_id(
-		__isl_keep isl_multi_aff *ma,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_pw_multi_aff_get_dim_id(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_id *isl_multi_pw_aff_get_dim_id(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned pos);
-	const char *isl_multi_aff_get_tuple_name(
-		__isl_keep isl_multi_aff *multi,
-		enum isl_dim_type type);
-	int isl_pw_multi_aff_has_tuple_name(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type);
-	const char *isl_pw_multi_aff_get_tuple_name(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type);
-	int isl_multi_aff_has_tuple_id(__isl_keep isl_multi_aff *ma,
-		enum isl_dim_type type);
-	int isl_pw_multi_aff_has_tuple_id(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type);
-	int isl_multi_pw_aff_has_tuple_id(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_multi_aff_get_tuple_id(
-		__isl_keep isl_multi_aff *ma,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
-		__isl_keep isl_pw_multi_aff *pma,
-		enum isl_dim_type type);
-	__isl_give isl_id *isl_multi_pw_aff_get_tuple_id(
-		__isl_keep isl_multi_pw_aff *mpa,
-		enum isl_dim_type type);
-	int isl_multi_aff_range_is_wrapping(
-		__isl_keep isl_multi_aff *ma);
-	int isl_multi_pw_aff_range_is_wrapping(
-		__isl_keep isl_multi_pw_aff *mpa);
+The function C<isl_schedule_constraints_compute_schedule> described
+in L</"Scheduling"> can also be used to construct schedules.
 
-	int isl_pw_multi_aff_foreach_piece(
-		__isl_keep isl_pw_multi_aff *pma,
-		int (*fn)(__isl_take isl_set *set,
-			    __isl_take isl_multi_aff *maff,
-			    void *user), void *user);
+C<isl_schedule> objects may be copied and freed using the following functions.
 
-	int isl_union_pw_multi_aff_foreach_pw_multi_aff(
-		__isl_keep isl_union_pw_multi_aff *upma,
-		int (*fn)(__isl_take isl_pw_multi_aff *pma,
-			    void *user), void *user);
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_copy(
+		__isl_keep isl_schedule *sched);
+	__isl_null isl_schedule *isl_schedule_free(
+		__isl_take isl_schedule *sched);
 
-It can be modified using
+The following functions checks whether two C<isl_schedule> objects
+are obviously the same.
 
-	#include <isl/aff.h>
-	__isl_give isl_multi_aff *isl_multi_aff_set_aff(
-		__isl_take isl_multi_aff *multi, int pos,
-		__isl_take isl_aff *aff);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
-		__isl_take isl_pw_multi_aff *pma, unsigned pos,
-		__isl_take isl_pw_aff *pa);
-	__isl_give isl_multi_aff *isl_multi_aff_set_dim_name(
-		__isl_take isl_multi_aff *maff,
-		enum isl_dim_type type, unsigned pos, const char *s);
-	__isl_give isl_multi_aff *isl_multi_aff_set_dim_id(
-		__isl_take isl_multi_aff *maff,
-		enum isl_dim_type type, unsigned pos,
-		__isl_take isl_id *id);
-	__isl_give isl_multi_aff *isl_multi_aff_set_tuple_name(
-		__isl_take isl_multi_aff *maff,
-		enum isl_dim_type type, const char *s);
-	__isl_give isl_multi_aff *isl_multi_aff_set_tuple_id(
-		__isl_take isl_multi_aff *maff,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
-		__isl_take isl_pw_multi_aff *pma,
-		enum isl_dim_type type, __isl_take isl_id *id);
-	__isl_give isl_multi_aff *isl_multi_aff_reset_tuple_id(
-		__isl_take isl_multi_aff *ma,
-		enum isl_dim_type type);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_reset_tuple_id(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type);
-	__isl_give isl_multi_aff *isl_multi_aff_reset_user(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_reset_user(
-		__isl_take isl_multi_pw_aff *mpa);
+	#include <isl/schedule.h>
+	isl_bool isl_schedule_plain_is_equal(
+		__isl_keep isl_schedule *schedule1,
+		__isl_keep isl_schedule *schedule2);
 
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_set_dim_name(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned pos, const char *s);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_set_dim_id(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned pos,
-		__isl_take isl_id *id);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_set_tuple_name(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, const char *s);
+The domain of the schedule, i.e., the domain described by the root node,
+can be obtained using the following function.
 
-	__isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
-		__isl_take isl_multi_aff *ma);
+	#include <isl/schedule.h>
+	__isl_give isl_union_set *isl_schedule_get_domain(
+		__isl_keep isl_schedule *schedule);
 
-	__isl_give isl_multi_aff *isl_multi_aff_insert_dims(
-		__isl_take isl_multi_aff *ma,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_multi_aff *isl_multi_aff_add_dims(
-		__isl_take isl_multi_aff *ma,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_multi_aff *isl_multi_aff_drop_dims(
-		__isl_take isl_multi_aff *maff,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
-		__isl_take isl_pw_multi_aff *pma,
-		enum isl_dim_type type, unsigned first, unsigned n);
+An extra top-level band node (right underneath the domain node) can
+be introduced into the schedule using the following function.
+The schedule tree is assumed not to have any anchored nodes.
 
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_insert_dims(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned first, unsigned n);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_add_dims(
-		__isl_take isl_multi_pw_aff *mpa,
-		enum isl_dim_type type, unsigned n);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
-		__isl_take isl_multi_pw_aff *pma,
-		enum isl_dim_type dst_type, unsigned dst_pos,
-		enum isl_dim_type src_type, unsigned src_pos,
-		unsigned n);
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *
+	isl_schedule_insert_partial_schedule(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_multi_union_pw_aff *partial);
 
-To check whether two multiple affine expressions are
-(obviously) equal to each other, use
+A top-level context node (right underneath the domain node) can
+be introduced into the schedule using the following function.
 
-	int isl_multi_aff_plain_is_equal(__isl_keep isl_multi_aff *maff1,
-		__isl_keep isl_multi_aff *maff2);
-	int isl_pw_multi_aff_plain_is_equal(
-		__isl_keep isl_pw_multi_aff *pma1,
-		__isl_keep isl_pw_multi_aff *pma2);
-	int isl_multi_pw_aff_plain_is_equal(
-		__isl_keep isl_multi_pw_aff *mpa1,
-		__isl_keep isl_multi_pw_aff *mpa2);
-	int isl_multi_pw_aff_is_equal(
-		__isl_keep isl_multi_pw_aff *mpa1,
-		__isl_keep isl_multi_pw_aff *mpa2);
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_insert_context(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_set *context)
 
-Operations include
+A top-level guard node (right underneath the domain node) can
+be introduced into the schedule using the following function.
 
-	#include <isl/aff.h>
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmin(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_lexmax(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_multi_aff *isl_multi_aff_floor(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_aff *isl_multi_aff_add(
-		__isl_take isl_multi_aff *maff1,
-		__isl_take isl_multi_aff *maff2);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
-		__isl_take isl_union_pw_multi_aff *upma1,
-		__isl_take isl_union_pw_multi_aff *upma2);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_multi_aff *isl_multi_aff_sub(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
-		__isl_take isl_union_pw_multi_aff *upma1,
-		__isl_take isl_union_pw_multi_aff *upma2);
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_insert_guard(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_set *guard)
+
+A schedule that combines two schedules either in the given
+order or in an arbitrary order, i.e., with an C<isl_schedule_node_sequence>
+or an C<isl_schedule_node_set> node,
+can be created using the following functions.
 
-C<isl_multi_aff_sub> subtracts the second argument from the first.
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_sequence(
+		__isl_take isl_schedule *schedule1,
+		__isl_take isl_schedule *schedule2);
+	__isl_give isl_schedule *isl_schedule_set(
+		__isl_take isl_schedule *schedule1,
+		__isl_take isl_schedule *schedule2);
+
+The domains of the two input schedules need to be disjoint.
+
+The following function can be used to restrict the domain
+of a schedule with a domain node as root to be a subset of the given union set.
+This operation may remove nodes in the tree that have become
+redundant.
 
-	__isl_give isl_multi_aff *isl_multi_aff_scale_val(
-		__isl_take isl_multi_aff *ma,
-		__isl_take isl_val *v);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_val *v);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_scale_val(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_val *v);
-	__isl_give isl_multi_aff *isl_multi_aff_scale_multi_val(
-		__isl_take isl_multi_aff *ma,
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_scale_multi_val(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_scale_multi_val(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_scale_multi_val(
-		__isl_take isl_union_pw_multi_aff *upma,
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_aff *
-	isl_multi_aff_scale_down_multi_val(
-		__isl_take isl_multi_aff *ma,
-		__isl_take isl_multi_val *mv);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_scale_down_multi_val(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_multi_val *mv);
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_intersect_domain(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_union_set *domain);
 
-C<isl_multi_aff_scale_multi_val> scales the elements of C<ma>
-by the corresponding elements of C<mv>.
+The following function can be used to simplify the domain
+of a schedule with a domain node as root with respect to the given
+parameter domain.
 
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
-		__isl_take isl_pw_multi_aff *pma,
-		enum isl_dim_type type, unsigned pos, int value);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_set *set);
-	__isl_give isl_set *isl_multi_pw_aff_domain(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_intersect_params(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_set *set);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_set *set);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_intersect_domain(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_set *domain);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_intersect_domain(
-		__isl_take isl_union_pw_multi_aff *upma,
-		__isl_take isl_union_set *uset);
-	__isl_give isl_multi_aff *isl_multi_aff_lift(
-		__isl_take isl_multi_aff *maff,
-		__isl_give isl_local_space **ls);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_multi_aff *isl_multi_aff_align_params(
-		__isl_take isl_multi_aff *multi,
-		__isl_take isl_space *model);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_space *model);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_align_params(
-		__isl_take isl_union_pw_multi_aff *upma,
-		__isl_take isl_space *model);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_project_domain_on_params(
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_multi_aff *isl_multi_aff_gist_params(
-		__isl_take isl_multi_aff *maff,
-		__isl_take isl_set *context);
-	__isl_give isl_multi_aff *isl_multi_aff_gist(
-		__isl_take isl_multi_aff *maff,
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_gist_domain_params(
+		__isl_take isl_schedule *schedule,
 		__isl_take isl_set *context);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_set *set);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_set *set);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_set *set);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_set *set);
-	__isl_give isl_multi_aff *isl_multi_aff_from_range(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_range(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_set *isl_pw_multi_aff_domain(
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_union_set *isl_union_pw_multi_aff_domain(
-		__isl_take isl_union_pw_multi_aff *upma);
-	__isl_give isl_multi_aff *isl_multi_aff_range_splice(
-		__isl_take isl_multi_aff *ma1, unsigned pos,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_multi_aff *isl_multi_aff_splice(
-		__isl_take isl_multi_aff *ma1,
-		unsigned in_pos, unsigned out_pos,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_multi_aff *isl_multi_aff_range_product(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_multi_aff *
-	isl_multi_aff_range_factor_domain(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_aff *
-	isl_multi_aff_range_factor_range(
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_aff *isl_multi_aff_flat_range_product(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_multi_aff *isl_multi_aff_product(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_product(
-		__isl_take isl_multi_pw_aff *mpa1,
-		__isl_take isl_multi_pw_aff *mpa2);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_range_product(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_range_factor_domain(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_range_factor_range(
-		__isl_take isl_multi_pw_aff *mpa);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_flat_range_product(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_flat_range_product(
-		__isl_take isl_union_pw_multi_aff *upma1,
-		__isl_take isl_union_pw_multi_aff *upma2);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_range_splice(
-		__isl_take isl_multi_pw_aff *mpa1, unsigned pos,
-		__isl_take isl_multi_pw_aff *mpa2);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_splice(
-		__isl_take isl_multi_pw_aff *mpa1,
-		unsigned in_pos, unsigned out_pos,
-		__isl_take isl_multi_pw_aff *mpa2);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_range_product(
-		__isl_take isl_multi_pw_aff *mpa1,
-		__isl_take isl_multi_pw_aff *mpa2);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_flat_range_product(
-		__isl_take isl_multi_pw_aff *mpa1,
-		__isl_take isl_multi_pw_aff *mpa2);
-
-If the C<ls> argument of C<isl_multi_aff_lift> is not C<NULL>,
-then it is assigned the local space that lies at the basis of
-the lifting applied.
-
-	#include <isl/aff.h>
-	__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_pullback_multi_aff(
-		__isl_take isl_pw_multi_aff *pma,
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_pullback_multi_aff(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_multi_aff *ma);
-	__isl_give isl_pw_multi_aff *
-	isl_pw_multi_aff_pullback_pw_multi_aff(
-		__isl_take isl_pw_multi_aff *pma1,
-		__isl_take isl_pw_multi_aff *pma2);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_pullback_pw_multi_aff(
-		__isl_take isl_multi_pw_aff *mpa,
-		__isl_take isl_pw_multi_aff *pma);
-	__isl_give isl_multi_pw_aff *
-	isl_multi_pw_aff_pullback_multi_pw_aff(
-		__isl_take isl_multi_pw_aff *mpa1,
-		__isl_take isl_multi_pw_aff *mpa2);
-
-The function C<isl_multi_aff_pullback_multi_aff> precomposes C<ma1> by C<ma2>.
-In other words, C<ma2> is plugged
-into C<ma1>.
-
-	__isl_give isl_set *isl_multi_aff_lex_le_set(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-	__isl_give isl_set *isl_multi_aff_lex_ge_set(
-		__isl_take isl_multi_aff *ma1,
-		__isl_take isl_multi_aff *ma2);
-
-The function C<isl_multi_aff_lex_le_set> returns a set
-containing those elements in the shared domain space
-where C<ma1> is lexicographically smaller than or
-equal to C<ma2>.
-
-An expression can be read from input using
-
-	#include <isl/aff.h>
-	__isl_give isl_multi_aff *isl_multi_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
-	__isl_give isl_union_pw_multi_aff *
-	isl_union_pw_multi_aff_read_from_str(
-		isl_ctx *ctx, const char *str);
-
-An expression can be printed using
-
-	#include <isl/aff.h>
-	__isl_give isl_printer *isl_printer_print_multi_aff(
-		__isl_take isl_printer *p,
-		__isl_keep isl_multi_aff *maff);
-	__isl_give isl_printer *isl_printer_print_pw_multi_aff(
-		__isl_take isl_printer *p,
-		__isl_keep isl_pw_multi_aff *pma);
-	__isl_give isl_printer *isl_printer_print_union_pw_multi_aff(
-		__isl_take isl_printer *p,
-		__isl_keep isl_union_pw_multi_aff *upma);
-	__isl_give isl_printer *isl_printer_print_multi_pw_aff(
-		__isl_take isl_printer *p,
-		__isl_keep isl_multi_pw_aff *mpa);
-
-=head2 Points
-
-Points are elements of a set.  They can be used to construct
-simple sets (boxes) or they can be used to represent the
-individual elements of a set.
-The zero point (the origin) can be created using
 
-	__isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
-
-The coordinates of a point can be inspected, set and changed
-using
+The following function resets the user pointers on all parameter
+and tuple identifiers referenced by the nodes of the given schedule.
 
-	__isl_give isl_val *isl_point_get_coordinate_val(
-		__isl_keep isl_point *pnt,
-		enum isl_dim_type type, int pos);
-	__isl_give isl_point *isl_point_set_coordinate_val(
-		__isl_take isl_point *pnt,
-		enum isl_dim_type type, int pos,
-		__isl_take isl_val *v);
-
-	__isl_give isl_point *isl_point_add_ui(
-		__isl_take isl_point *pnt,
-		enum isl_dim_type type, int pos, unsigned val);
-	__isl_give isl_point *isl_point_sub_ui(
-		__isl_take isl_point *pnt,
-		enum isl_dim_type type, int pos, unsigned val);
-
-Other properties can be obtained using
-
-	isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
-
-Points can be copied or freed using
-
-	__isl_give isl_point *isl_point_copy(
-		__isl_keep isl_point *pnt);
-	void isl_point_free(__isl_take isl_point *pnt);
-
-A singleton set can be created from a point using
-
-	__isl_give isl_basic_set *isl_basic_set_from_point(
-		__isl_take isl_point *pnt);
-	__isl_give isl_set *isl_set_from_point(
-		__isl_take isl_point *pnt);
-
-and a box can be created from two opposite extremal points using
-
-	__isl_give isl_basic_set *isl_basic_set_box_from_points(
-		__isl_take isl_point *pnt1,
-		__isl_take isl_point *pnt2);
-	__isl_give isl_set *isl_set_box_from_points(
-		__isl_take isl_point *pnt1,
-		__isl_take isl_point *pnt2);
-
-All elements of a B<bounded> (union) set can be enumerated using
-the following functions.
-
-	int isl_set_foreach_point(__isl_keep isl_set *set,
-		int (*fn)(__isl_take isl_point *pnt, void *user),
-		void *user);
-	int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
-		int (*fn)(__isl_take isl_point *pnt, void *user),
-		void *user);
-
-The function C<fn> is called for each integer point in
-C<set> with as second argument the last argument of
-the C<isl_set_foreach_point> call.  The function C<fn>
-should return C<0> on success and C<-1> on failure.
-In the latter case, C<isl_set_foreach_point> will stop
-enumerating and return C<-1> as well.
-If the enumeration is performed successfully and to completion,
-then C<isl_set_foreach_point> returns C<0>.
-
-To obtain a single point of a (basic) set, use
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_reset_user(
+		__isl_take isl_schedule *schedule);
 
-	__isl_give isl_point *isl_basic_set_sample_point(
-		__isl_take isl_basic_set *bset);
-	__isl_give isl_point *isl_set_sample_point(
-		__isl_take isl_set *set);
+The following function aligns the parameters of all nodes
+in the given schedule to the given space.
 
-If C<set> does not contain any (integer) points, then the
-resulting point will be ``void'', a property that can be
-tested using
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_align_params(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_space *space);
 
-	int isl_point_is_void(__isl_keep isl_point *pnt);
+The following function allows the user to plug in a given function
+in the iteration domains.  The input schedule is not allowed to contain
+any expansion nodes.
 
-=head2 Piecewise Quasipolynomials
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *
+	isl_schedule_pullback_union_pw_multi_aff(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_union_pw_multi_aff *upma);
 
-A piecewise quasipolynomial is a particular kind of function that maps
-a parametric point to a rational value.
-More specifically, a quasipolynomial is a polynomial expression in greatest
-integer parts of affine expressions of parameters and variables.
-A piecewise quasipolynomial is a subdivision of a given parametric
-domain into disjoint cells with a quasipolynomial associated to
-each cell.  The value of the piecewise quasipolynomial at a given
-point is the value of the quasipolynomial associated to the cell
-that contains the point.  Outside of the union of cells,
-the value is assumed to be zero.
-For example, the piecewise quasipolynomial
+The following function can be used to plug in the schedule C<expansion>
+in the leaves of C<schedule>, where C<contraction> describes how
+the domain elements of C<expansion> map to the domain elements
+at the original leaves of C<schedule>.
+The resulting schedule will contain expansion nodes, unless
+C<contraction> is an identity function.
 
-	n -> { x -> ((1 + n) - x) : x <= n and x >= 0 }
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_expand(
+		__isl_take isl_schedule *schedule,
+		__isl_take isl_union_pw_multi_aff *contraction,
+		__isl_take isl_schedule *expansion);
 
-maps C<x> to C<1 + n - x> for values of C<x> between C<0> and C<n>.
-A given piecewise quasipolynomial has a fixed domain dimension.
-Union piecewise quasipolynomials are used to contain piecewise quasipolynomials
-defined over different domains.
-Piecewise quasipolynomials are mainly used by the C<barvinok>
-library for representing the number of elements in a parametric set or map.
-For example, the piecewise quasipolynomial above represents
-the number of points in the map
+An C<isl_union_map> representation of the schedule can be obtained
+from an C<isl_schedule> using the following function.
 
-	n -> { x -> y : x,y >= 0 and 0 <= x + y <= n }
+	#include <isl/schedule.h>
+	__isl_give isl_union_map *isl_schedule_get_map(
+		__isl_keep isl_schedule *sched);
 
-=head3 Input and Output
+The resulting relation encodes the same relative ordering as
+the schedule by mapping the domain elements to a common schedule space.
+If the schedule_separate_components option is set, then the order
+of the children of a set node is explicitly encoded in the result.
+If the tree contains any expansion nodes, then the relation
+is formulated in terms of the expanded domain elements.
 
-Piecewise quasipolynomials can be read from input using
+Schedules can be read from input using the following functions.
 
-	__isl_give isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_read_from_str(
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *isl_schedule_read_from_file(
+		isl_ctx *ctx, FILE *input);
+	__isl_give isl_schedule *isl_schedule_read_from_str(
 		isl_ctx *ctx, const char *str);
 
-Quasipolynomials and piecewise quasipolynomials can be printed
-using the following functions.
-
-	__isl_give isl_printer *isl_printer_print_qpolynomial(
-		__isl_take isl_printer *p,
-		__isl_keep isl_qpolynomial *qp);
-
-	__isl_give isl_printer *isl_printer_print_pw_qpolynomial(
-		__isl_take isl_printer *p,
-		__isl_keep isl_pw_qpolynomial *pwqp);
+A representation of the schedule can be printed using
 
-	__isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
+	#include <isl/schedule.h>
+	__isl_give isl_printer *isl_printer_print_schedule(
 		__isl_take isl_printer *p,
-		__isl_keep isl_union_pw_qpolynomial *upwqp);
-
-The output format of the printer
-needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
-For C<isl_printer_print_union_pw_qpolynomial>, only C<ISL_FORMAT_ISL>
-is supported.
-In case of printing in C<ISL_FORMAT_C>, the user may want
-to set the names of all dimensions
-
-	__isl_give isl_qpolynomial *isl_qpolynomial_set_dim_name(
-		__isl_take isl_qpolynomial *qp,
-		enum isl_dim_type type, unsigned pos,
-		const char *s);
-	__isl_give isl_pw_qpolynomial *
-	isl_pw_qpolynomial_set_dim_name(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		enum isl_dim_type type, unsigned pos,
-		const char *s);
-
-=head3 Creating New (Piecewise) Quasipolynomials
-
-Some simple quasipolynomials can be created using the following functions.
-More complicated quasipolynomials can be created by applying
-operations such as addition and multiplication
-on the resulting quasipolynomials
-
-	__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
-		__isl_take isl_space *domain);
-	__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
-		__isl_take isl_space *domain);
-	__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
-		__isl_take isl_space *domain);
-	__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
-		__isl_take isl_space *domain);
-	__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
-		__isl_take isl_space *domain);
-	__isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
-		__isl_take isl_space *domain,
-		__isl_take isl_val *val);
-	__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
-		__isl_take isl_space *domain,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_qpolynomial *isl_qpolynomial_from_aff(
-		__isl_take isl_aff *aff);
-
-Note that the space in which a quasipolynomial lives is a map space
-with a one-dimensional range.  The C<domain> argument in some of
-the functions above corresponds to the domain of this map space.
-
-The zero piecewise quasipolynomial or a piecewise quasipolynomial
-with a single cell can be created using the following functions.
-Multiple of these single cell piecewise quasipolynomials can
-be combined to create more complicated piecewise quasipolynomials.
-
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
-		__isl_take isl_space *space);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(
-		__isl_take isl_set *set,
-		__isl_take isl_qpolynomial *qp);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
-		__isl_take isl_qpolynomial *qp);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
-		__isl_take isl_pw_aff *pwaff);
-
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
-		__isl_take isl_space *space);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(
-		__isl_take isl_pw_qpolynomial *pwqp);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
-		__isl_take isl_pw_qpolynomial *pwqp);
-
-Quasipolynomials can be copied and freed again using the following
-functions.
-
-	__isl_give isl_qpolynomial *isl_qpolynomial_copy(
-		__isl_keep isl_qpolynomial *qp);
-	__isl_null isl_qpolynomial *isl_qpolynomial_free(
-		__isl_take isl_qpolynomial *qp);
-
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_copy(
-		__isl_keep isl_pw_qpolynomial *pwqp);
-	__isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
-		__isl_take isl_pw_qpolynomial *pwqp);
-
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_copy(
-		__isl_keep isl_union_pw_qpolynomial *upwqp);
-	__isl_null isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_free(
-		__isl_take isl_union_pw_qpolynomial *upwqp);
+		__isl_keep isl_schedule *schedule);
+	__isl_give char *isl_schedule_to_str(
+		__isl_keep isl_schedule *schedule);
 
-=head3 Inspecting (Piecewise) Quasipolynomials
+C<isl_schedule_to_str> prints the schedule in flow format.
 
-To iterate over all piecewise quasipolynomials in a union
-piecewise quasipolynomial, use the following function
+The schedule tree can be traversed through the use of
+C<isl_schedule_node> objects that point to a particular
+position in the schedule tree.  Whenever a C<isl_schedule_node>
+is used to modify a node in the schedule tree, the original schedule
+tree is left untouched and the modifications are performed to a copy
+of the tree.  The returned C<isl_schedule_node> then points to
+this modified copy of the tree.
 
-	int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
-		__isl_keep isl_union_pw_qpolynomial *upwqp,
-		int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
-		void *user);
+The root of the schedule tree can be obtained using the following function.
 
-To extract the piecewise quasipolynomial in a given space from a union, use
-
-	__isl_give isl_pw_qpolynomial *
-	isl_union_pw_qpolynomial_extract_pw_qpolynomial(
-		__isl_keep isl_union_pw_qpolynomial *upwqp,
-		__isl_take isl_space *space);
-
-To iterate over the cells in a piecewise quasipolynomial,
-use either of the following two functions
-
-	int isl_pw_qpolynomial_foreach_piece(
-		__isl_keep isl_pw_qpolynomial *pwqp,
-		int (*fn)(__isl_take isl_set *set,
-			  __isl_take isl_qpolynomial *qp,
-			  void *user), void *user);
-	int isl_pw_qpolynomial_foreach_lifted_piece(
-		__isl_keep isl_pw_qpolynomial *pwqp,
-		int (*fn)(__isl_take isl_set *set,
-			  __isl_take isl_qpolynomial *qp,
-			  void *user), void *user);
-
-As usual, the function C<fn> should return C<0> on success
-and C<-1> on failure.  The difference between
-C<isl_pw_qpolynomial_foreach_piece> and
-C<isl_pw_qpolynomial_foreach_lifted_piece> is that
-C<isl_pw_qpolynomial_foreach_lifted_piece> will first
-compute unique representations for all existentially quantified
-variables and then turn these existentially quantified variables
-into extra set variables, adapting the associated quasipolynomial
-accordingly.  This means that the C<set> passed to C<fn>
-will not have any existentially quantified variables, but that
-the dimensions of the sets may be different for different
-invocations of C<fn>.
+	#include <isl/schedule.h>
+	__isl_give isl_schedule_node *isl_schedule_get_root(
+		__isl_keep isl_schedule *schedule);
 
-The constant term of a quasipolynomial can be extracted using
+A pointer to a newly created schedule tree with a single domain
+node can be created using the following functions.
 
-	__isl_give isl_val *isl_qpolynomial_get_constant_val(
-		__isl_keep isl_qpolynomial *qp);
-
-To iterate over all terms in a quasipolynomial,
-use
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_from_domain(
+		__isl_take isl_union_set *domain);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_from_extension(
+		__isl_take isl_union_map *extension);
+
+C<isl_schedule_node_from_extension> creates a tree with an extension
+node as root.
+
+Schedule nodes can be copied and freed using the following functions.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_copy(
+		__isl_keep isl_schedule_node *node);
+	__isl_null isl_schedule_node *isl_schedule_node_free(
+		__isl_take isl_schedule_node *node);
+
+The following functions can be used to check if two schedule
+nodes point to the same position in the same schedule.
+
+	#include <isl/schedule_node.h>
+	isl_bool isl_schedule_node_is_equal(
+		__isl_keep isl_schedule_node *node1,
+		__isl_keep isl_schedule_node *node2);
+
+The following properties can be obtained from a schedule node.
+
+	#include <isl/schedule_node.h>
+	enum isl_schedule_node_type isl_schedule_node_get_type(
+		__isl_keep isl_schedule_node *node);
+	enum isl_schedule_node_type
+	isl_schedule_node_get_parent_type(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule *isl_schedule_node_get_schedule(
+		__isl_keep isl_schedule_node *node);
+
+The function C<isl_schedule_node_get_type> returns the type of
+the node, while C<isl_schedule_node_get_parent_type> returns
+type of the parent of the node, which is required to exist.
+The function C<isl_schedule_node_get_schedule> returns a copy
+to the schedule to which the node belongs.
+
+The following functions can be used to move the schedule node
+to a different position in the tree or to check if such a position
+exists.
+
+	#include <isl/schedule_node.h>
+	isl_bool isl_schedule_node_has_parent(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *isl_schedule_node_parent(
+		__isl_take isl_schedule_node *node);
+	__isl_give isl_schedule_node *isl_schedule_node_root(
+		__isl_take isl_schedule_node *node);
+	__isl_give isl_schedule_node *isl_schedule_node_ancestor(
+		__isl_take isl_schedule_node *node,
+		int generation);
+	isl_size isl_schedule_node_n_children(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *isl_schedule_node_child(
+		__isl_take isl_schedule_node *node, int pos);
+	isl_bool isl_schedule_node_has_children(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *isl_schedule_node_first_child(
+		__isl_take isl_schedule_node *node);
+	isl_bool isl_schedule_node_has_previous_sibling(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_previous_sibling(
+		__isl_take isl_schedule_node *node);
+	isl_bool isl_schedule_node_has_next_sibling(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_next_sibling(
+		__isl_take isl_schedule_node *node);
+
+For C<isl_schedule_node_ancestor>, the ancestor of generation 0
+is the node itself, the ancestor of generation 1 is its parent and so on.
+
+It is also possible to query the number of ancestors of a node,
+the position of the current node
+within the children of its parent, the position of the subtree
+containing a node within the children of an ancestor
+or to obtain a copy of a given
+child without destroying the current node.
+Given two nodes that point to the same schedule, their closest
+shared ancestor can be obtained using
+C<isl_schedule_node_get_shared_ancestor>.
+
+	#include <isl/schedule_node.h>
+	isl_size isl_schedule_node_get_tree_depth(
+		__isl_keep isl_schedule_node *node);
+	isl_size isl_schedule_node_get_child_position(
+		__isl_keep isl_schedule_node *node);
+	isl_size isl_schedule_node_get_ancestor_child_position(
+		__isl_keep isl_schedule_node *node,
+		__isl_keep isl_schedule_node *ancestor);
+	__isl_give isl_schedule_node *isl_schedule_node_get_child(
+		__isl_keep isl_schedule_node *node, int pos);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_get_shared_ancestor(
+		__isl_keep isl_schedule_node *node1,
+		__isl_keep isl_schedule_node *node2);
+
+All nodes in a schedule tree or
+all descendants of a specific node (including the node) can be visited
+in depth-first pre-order using the following functions.
 
-	int isl_qpolynomial_foreach_term(
-		__isl_keep isl_qpolynomial *qp,
-		int (*fn)(__isl_take isl_term *term,
-			  void *user), void *user);
+	#include <isl/schedule.h>
+	isl_stat isl_schedule_foreach_schedule_node_top_down(
+		__isl_keep isl_schedule *sched,
+		isl_bool (*fn)(__isl_keep isl_schedule_node *node,
+			void *user), void *user);
 
-The terms themselves can be inspected and freed using
-these functions
+	#include <isl/schedule_node.h>
+	isl_stat isl_schedule_node_foreach_descendant_top_down(
+		__isl_keep isl_schedule_node *node,
+		isl_bool (*fn)(__isl_keep isl_schedule_node *node,
+			void *user), void *user);
 
-	unsigned isl_term_dim(__isl_keep isl_term *term,
-		enum isl_dim_type type);
-	__isl_give isl_val *isl_term_get_coefficient_val(
-		__isl_keep isl_term *term);
-	int isl_term_get_exp(__isl_keep isl_term *term,
-		enum isl_dim_type type, unsigned pos);
-	__isl_give isl_aff *isl_term_get_div(
-		__isl_keep isl_term *term, unsigned pos);
-	void isl_term_free(__isl_take isl_term *term);
+The callback function is slightly different from the usual
+callbacks in that it not only indicates success (non-negative result)
+or failure (negative result), but also indicates whether the children
+of the given node should be visited.  In particular, if the callback
+returns a positive value, then the children are visited, but if
+the callback returns zero, then the children are not visited.
+
+The following functions checks whether
+all descendants of a specific node (including the node itself)
+satisfy a user-specified test.
+
+	#include <isl/schedule_node.h>
+	isl_bool isl_schedule_node_every_descendant(
+		__isl_keep isl_schedule_node *node,
+		isl_bool (*test)(__isl_keep isl_schedule_node *node,
+			void *user), void *user)
+
+The ancestors of a node in a schedule tree can be visited from
+the root down to and including the parent of the node using
+the following function.
+
+	#include <isl/schedule_node.h>
+	isl_stat isl_schedule_node_foreach_ancestor_top_down(
+		__isl_keep isl_schedule_node *node,
+		isl_stat (*fn)(__isl_keep isl_schedule_node *node,
+			void *user), void *user);
 
-Each term is a product of parameters, set variables and
-integer divisions.  The function C<isl_term_get_exp>
-returns the exponent of a given dimensions in the given term.
+The following functions allows for a depth-first post-order
+traversal of the nodes in a schedule tree or
+of the descendants of a specific node (including the node
+itself), where the user callback is allowed to modify the
+visited node.
 
-=head3 Properties of (Piecewise) Quasipolynomials
+	#include <isl/schedule.h>
+	__isl_give isl_schedule *
+	isl_schedule_map_schedule_node_bottom_up(
+		__isl_take isl_schedule *schedule,
+		__isl_give isl_schedule_node *(*fn)(
+			__isl_take isl_schedule_node *node,
+			void *user), void *user);
 
-To check whether two union piecewise quasipolynomials are
-obviously equal, use
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_map_descendant_bottom_up(
+		__isl_take isl_schedule_node *node,
+		__isl_give isl_schedule_node *(*fn)(
+			__isl_take isl_schedule_node *node,
+			void *user), void *user);
 
-	int isl_union_pw_qpolynomial_plain_is_equal(
-		__isl_keep isl_union_pw_qpolynomial *upwqp1,
-		__isl_keep isl_union_pw_qpolynomial *upwqp2);
+The traversal continues from the node returned by the callback function.
+It is the responsibility of the user to ensure that this does not
+lead to an infinite loop.  It is safest to always return a pointer
+to the same position (same ancestors and child positions) as the input node.
+
+The following function removes a node (along with its descendants)
+from a schedule tree and returns a pointer to the leaf at the
+same position in the updated tree.
+It is not allowed to remove the root of a schedule tree or
+a child of a set or sequence node.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_cut(
+		__isl_take isl_schedule_node *node);
+
+The following function removes a single node
+from a schedule tree and returns a pointer to the child
+of the node, now located at the position of the original node
+or to a leaf node at that position if there was no child.
+It is not allowed to remove the root of a schedule tree,
+a set or sequence node, a child of a set or sequence node or
+a band node with an anchored subtree.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_delete(
+		__isl_take isl_schedule_node *node);
+
+Most nodes in a schedule tree only contain local information.
+In some cases, however, a node may also refer to the schedule dimensions
+of its outer band nodes.
+This means that the position of the node within the tree should
+not be changed, or at least that no changes are performed to the
+outer band nodes.  The following function can be used to test
+whether the subtree rooted at a given node contains any such nodes.
+
+	#include <isl/schedule_node.h>
+	isl_bool isl_schedule_node_is_subtree_anchored(
+		__isl_keep isl_schedule_node *node);
+
+The following function resets the user pointers on all parameter
+and tuple identifiers referenced by the given schedule node.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_reset_user(
+		__isl_take isl_schedule_node *node);
+
+The following function aligns the parameters of the given schedule
+node to the given space.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_align_params(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_space *space);
+
+Several node types have their own functions for querying
+(and in some cases setting) some node type specific properties.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_space *isl_schedule_node_band_get_space(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_multi_union_pw_aff *
+	isl_schedule_node_band_get_partial_schedule(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_map *
+	isl_schedule_node_band_get_partial_schedule_union_map(
+		__isl_keep isl_schedule_node *node);
+	isl_size isl_schedule_node_band_n_member(
+		__isl_keep isl_schedule_node *node);
+	isl_bool isl_schedule_node_band_member_get_coincident(
+		__isl_keep isl_schedule_node *node, int pos);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_member_set_coincident(
+		__isl_take isl_schedule_node *node, int pos,
+		int coincident);
+	isl_bool isl_schedule_node_band_get_permutable(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_set_permutable(
+		__isl_take isl_schedule_node *node, int permutable);
+	enum isl_ast_loop_type
+	isl_schedule_node_band_member_get_ast_loop_type(
+		__isl_keep isl_schedule_node *node, int pos);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_member_set_ast_loop_type(
+		__isl_take isl_schedule_node *node, int pos,
+		enum isl_ast_loop_type type);
+	enum isl_ast_loop_type
+	isl_schedule_node_band_member_get_isolate_ast_loop_type(
+		__isl_keep isl_schedule_node *node, int pos);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_member_set_isolate_ast_loop_type(
+		__isl_take isl_schedule_node *node, int pos,
+		enum isl_ast_loop_type type);
+	__isl_give isl_union_set *
+	isl_schedule_node_band_get_ast_build_options(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_set_ast_build_options(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set *options);
+	__isl_give isl_set *
+	isl_schedule_node_band_get_ast_isolate_option(
+		__isl_keep isl_schedule_node *node);
 
-=head3 Operations on (Piecewise) Quasipolynomials
+The function C<isl_schedule_node_band_get_space> returns the space
+of the partial schedule of the band.
+The function C<isl_schedule_node_band_get_partial_schedule_union_map>
+returns a representation of the partial schedule of the band node
+in the form of an C<isl_union_map>.
+The coincident and permutable properties are set by
+C<isl_schedule_constraints_compute_schedule> on the schedule tree
+it produces.
+A scheduling dimension is considered to be ``coincident''
+if it satisfies the coincidence constraints within its band.
+That is, if the dependence distances of the coincidence
+constraints are all zero in that direction (for fixed
+iterations of outer bands).
+A band is marked permutable if it was produced using the Pluto-like scheduler.
+Note that the scheduler may have to resort to a Feautrier style scheduling
+step even if the default scheduler is used.
+An C<isl_ast_loop_type> is one of C<isl_ast_loop_default>,
+C<isl_ast_loop_atomic>, C<isl_ast_loop_unroll> or C<isl_ast_loop_separate>.
+For the meaning of these loop AST generation types and the difference
+between the regular loop AST generation type and the isolate
+loop AST generation type, see L</"AST Generation Options (Schedule Tree)">.
+The functions C<isl_schedule_node_band_member_get_ast_loop_type>
+and C<isl_schedule_node_band_member_get_isolate_ast_loop_type>
+may return C<isl_ast_loop_error> if an error occurs.
+The AST build options govern how an AST is generated for
+the individual schedule dimensions during AST generation.
+See L</"AST Generation Options (Schedule Tree)">.
+The isolate option for the given node can be extracted from these
+AST build options using the function
+C<isl_schedule_node_band_get_ast_isolate_option>.
 
-	__isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
-		__isl_take isl_qpolynomial *qp,
-		__isl_take isl_val *v);
-	__isl_give isl_qpolynomial *isl_qpolynomial_neg(
-		__isl_take isl_qpolynomial *qp);
-	__isl_give isl_qpolynomial *isl_qpolynomial_add(
-		__isl_take isl_qpolynomial *qp1,
-		__isl_take isl_qpolynomial *qp2);
-	__isl_give isl_qpolynomial *isl_qpolynomial_sub(
-		__isl_take isl_qpolynomial *qp1,
-		__isl_take isl_qpolynomial *qp2);
-	__isl_give isl_qpolynomial *isl_qpolynomial_mul(
-		__isl_take isl_qpolynomial *qp1,
-		__isl_take isl_qpolynomial *qp2);
-	__isl_give isl_qpolynomial *isl_qpolynomial_pow(
-		__isl_take isl_qpolynomial *qp, unsigned exponent);
+	#include <isl/schedule_node.h>
+	__isl_give isl_set *
+	isl_schedule_node_context_get_context(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_fix_val(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		enum isl_dim_type type, unsigned n,
-		__isl_take isl_val *v);
-	__isl_give isl_pw_qpolynomial *
-	isl_pw_qpolynomial_scale_val(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		__isl_take isl_val *v);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
-		__isl_take isl_pw_qpolynomial *pwqp1,
-		__isl_take isl_pw_qpolynomial *pwqp2);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_sub(
-		__isl_take isl_pw_qpolynomial *pwqp1,
-		__isl_take isl_pw_qpolynomial *pwqp2);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_disjoint(
-		__isl_take isl_pw_qpolynomial *pwqp1,
-		__isl_take isl_pw_qpolynomial *pwqp2);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_neg(
-		__isl_take isl_pw_qpolynomial *pwqp);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul(
-		__isl_take isl_pw_qpolynomial *pwqp1,
-		__isl_take isl_pw_qpolynomial *pwqp2);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
-		__isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_set *
+	isl_schedule_node_domain_get_domain(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_scale_val(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
-		__isl_take isl_val *v);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
-		__isl_take isl_union_pw_qpolynomial *upwqp1,
-		__isl_take isl_union_pw_qpolynomial *upwqp2);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_sub(
-		__isl_take isl_union_pw_qpolynomial *upwqp1,
-		__isl_take isl_union_pw_qpolynomial *upwqp2);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
-		__isl_take isl_union_pw_qpolynomial *upwqp1,
-		__isl_take isl_union_pw_qpolynomial *upwqp2);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_map *
+	isl_schedule_node_expansion_get_expansion(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_pw_multi_aff *
+	isl_schedule_node_expansion_get_contraction(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_val *isl_pw_qpolynomial_eval(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		__isl_take isl_point *pnt);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_map *
+	isl_schedule_node_extension_get_extension(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_val *isl_union_pw_qpolynomial_eval(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
-		__isl_take isl_point *pnt);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_set *
+	isl_schedule_node_filter_get_filter(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_set *isl_pw_qpolynomial_domain(
-		__isl_take isl_pw_qpolynomial *pwqp);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
-		__isl_take isl_pw_qpolynomial *pwpq,
-		__isl_take isl_set *set);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
-		__isl_take isl_pw_qpolynomial *pwpq,
-		__isl_take isl_set *set);
+	#include <isl/schedule_node.h>
+	__isl_give isl_set *isl_schedule_node_guard_get_guard(
+		__isl_keep isl_schedule_node *node);
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_id *isl_schedule_node_mark_get_id(
+		__isl_keep isl_schedule_node *node);
+
+The following functions can be used to obtain an C<isl_multi_union_pw_aff>,
+an C<isl_union_pw_multi_aff> or C<isl_union_map> representation of
+partial schedules related to the node.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_multi_union_pw_aff *
+	isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_pw_multi_aff *
+	isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_map *
+	isl_schedule_node_get_prefix_schedule_union_map(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_map *
+	isl_schedule_node_get_prefix_schedule_relation(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_map *
+	isl_schedule_node_get_subtree_schedule_union_map(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
-		__isl_take isl_union_pw_qpolynomial *upwqp);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
-		__isl_take isl_union_pw_qpolynomial *upwpq,
-		__isl_take isl_union_set *uset);
-	__isl_give isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_intersect_params(
-		__isl_take isl_union_pw_qpolynomial *upwpq,
-		__isl_take isl_set *set);
+In particular, the functions
+C<isl_schedule_node_get_prefix_schedule_multi_union_pw_aff>,
+C<isl_schedule_node_get_prefix_schedule_union_pw_multi_aff>
+and C<isl_schedule_node_get_prefix_schedule_union_map>
+return a relative ordering on the domain elements that reach the given
+node determined by its ancestors.
+The function C<isl_schedule_node_get_prefix_schedule_relation>
+additionally includes the domain constraints in the result.
+The function C<isl_schedule_node_get_subtree_schedule_union_map>
+returns a representation of the partial schedule defined by the
+subtree rooted at the given node.
+If the tree contains any expansion nodes, then the subtree schedule
+is formulated in terms of the expanded domain elements.
+The tree passed to functions returning a prefix schedule
+may only contain extension nodes if these would not affect
+the result of these functions.  That is, if one of the ancestors
+is an extension node, then all of the domain elements that were
+added by the extension node need to have been filtered out
+by filter nodes between the extension node and the input node.
+The tree passed to C<isl_schedule_node_get_subtree_schedule_union_map>
+may not contain in extension nodes in the selected subtree.
+
+The expansion/contraction defined by an entire subtree, combining
+the expansions/contractions
+on the expansion nodes in the subtree, can be obtained using
+the following functions.
 
-	__isl_give isl_qpolynomial *isl_qpolynomial_align_params(
-		__isl_take isl_qpolynomial *qp,
-		__isl_take isl_space *model);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_map *
+	isl_schedule_node_get_subtree_expansion(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_pw_multi_aff *
+	isl_schedule_node_get_subtree_contraction(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_qpolynomial *isl_qpolynomial_project_domain_on_params(
-		__isl_take isl_qpolynomial *qp);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
-		__isl_take isl_pw_qpolynomial *pwqp);
+The total number of outer band members of given node, i.e.,
+the shared output dimension of the maps in the result
+of C<isl_schedule_node_get_prefix_schedule_union_map> can be obtained
+using the following function.
 
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_coalesce(
-		__isl_take isl_union_pw_qpolynomial *upwqp);
+	#include <isl/schedule_node.h>
+	isl_size isl_schedule_node_get_schedule_depth(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
-		__isl_take isl_qpolynomial *qp,
-		__isl_take isl_set *context);
-	__isl_give isl_qpolynomial *isl_qpolynomial_gist(
-		__isl_take isl_qpolynomial *qp,
-		__isl_take isl_set *context);
+The following functions return the elements that reach the given node
+or the union of universes in the spaces that contain these elements.
 
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist_params(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		__isl_take isl_set *context);
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_gist(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		__isl_take isl_set *context);
+	#include <isl/schedule_node.h>
+	__isl_give isl_union_set *
+	isl_schedule_node_get_domain(
+		__isl_keep isl_schedule_node *node);
+	__isl_give isl_union_set *
+	isl_schedule_node_get_universe_domain(
+		__isl_keep isl_schedule_node *node);
 
-	__isl_give isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_gist_params(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
+The input tree of C<isl_schedule_node_get_domain>
+may only contain extension nodes if these would not affect
+the result of this function.  That is, if one of the ancestors
+is an extension node, then all of the domain elements that were
+added by the extension node need to have been filtered out
+by filter nodes between the extension node and the input node.
+
+The following functions can be used to introduce additional nodes
+in the schedule tree.  The new node is introduced at the point
+in the tree where the C<isl_schedule_node> points to and
+the results points to the new node.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_partial_schedule(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_union_pw_aff *schedule);
+
+This function inserts a new band node with (the greatest integer
+part of) the given partial schedule.
+The subtree rooted at the given node is assumed not to have
+any anchored nodes.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_context(
+		__isl_take isl_schedule_node *node,
 		__isl_take isl_set *context);
-	__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_gist(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
-		__isl_take isl_union_set *context);
 
-The gist operation applies the gist operation to each of
-the cells in the domain of the input piecewise quasipolynomial.
-The context is also exploited
-to simplify the quasipolynomials associated to each cell.
+This function inserts a new context node with the given context constraints.
 
-	__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
-		__isl_take isl_pw_qpolynomial *pwqp, int sign);
-	__isl_give isl_union_pw_qpolynomial *
-	isl_union_pw_qpolynomial_to_polynomial(
-		__isl_take isl_union_pw_qpolynomial *upwqp, int sign);
-
-Approximate each quasipolynomial by a polynomial.  If C<sign> is positive,
-the polynomial will be an overapproximation.  If C<sign> is negative,
-it will be an underapproximation.  If C<sign> is zero, the approximation
-will lie somewhere in between.
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_filter(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set *filter);
+
+This function inserts a new filter node with the given filter.
+If the original node already pointed to a filter node, then the
+two filter nodes are merged into one.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_guard(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_set *guard);
+
+This function inserts a new guard node with the given guard constraints.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_mark(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_id *mark);
+
+This function inserts a new mark node with the give mark identifier.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_sequence(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set_list *filters);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_insert_set(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set_list *filters);
+
+These functions insert a new sequence or set node with the given
+filters as children.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_group(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_id *group_id);
+
+This function introduces an expansion node in between the current
+node and its parent that expands instances of a space with tuple
+identifier C<group_id> to the original domain elements that reach
+the node.  The group instances are identified by the prefix schedule
+of those domain elements.  The ancestors of the node are adjusted
+to refer to the group instances instead of the original domain
+elements.  The return value points to the same node in the updated
+schedule tree as the input node, i.e., to the child of the newly
+introduced expansion node.  Grouping instances of different statements
+ensures that they will be treated as a single statement by the
+AST generator up to the point of the expansion node.
+
+The following function can be used to flatten a nested
+sequence.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_sequence_splice_child(
+		__isl_take isl_schedule_node *node, int pos);
+
+That is, given a sequence node C<node> that has another sequence node
+in its child at position C<pos> (in particular, the child of that filter
+node is a sequence node), attach the children of that other sequence
+node as children of C<node>, replacing the original child at position
+C<pos>.
 
-=head2 Bounds on Piecewise Quasipolynomials and Piecewise Quasipolynomial Reductions
-
-A piecewise quasipolynomial reduction is a piecewise
-reduction (or fold) of quasipolynomials.
-In particular, the reduction can be maximum or a minimum.
-The objects are mainly used to represent the result of
-an upper or lower bound on a quasipolynomial over its domain,
-i.e., as the result of the following function.
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
-		__isl_take isl_pw_qpolynomial *pwqp,
-		enum isl_fold type, int *tight);
-
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
-		__isl_take isl_union_pw_qpolynomial *upwqp,
-		enum isl_fold type, int *tight);
+The partial schedule of a band node can be scaled (down) or reduced using
+the following functions.
 
-The C<type> argument may be either C<isl_fold_min> or C<isl_fold_max>.
-If C<tight> is not C<NULL>, then C<*tight> is set to C<1>
-is the returned bound is known be tight, i.e., for each value
-of the parameters there is at least
-one element in the domain that reaches the bound.
-If the domain of C<pwqp> is not wrapping, then the bound is computed
-over all elements in that domain and the result has a purely parametric
-domain.  If the domain of C<pwqp> is wrapping, then the bound is
-computed over the range of the wrapped relation.  The domain of the
-wrapped relation becomes the domain of the result.
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_scale(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_scale_down(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_val *mv);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_mod(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_val *mv);
 
-A (piecewise) quasipolynomial reduction can be copied or freed using the
-following functions.
+The spaces of the two arguments need to match.
+After scaling, the partial schedule is replaced by its greatest
+integer part to ensure that the schedule remains integral.
+
+The partial schedule of a band node can be shifted by an
+C<isl_multi_union_pw_aff> with a domain that is a superset
+of the domain of the partial schedule using
+the following function.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_band_shift(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_union_pw_aff *shift);
+
+A band node can be tiled using the following function.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_band_tile(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_multi_val *sizes);
 
-	__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
-		__isl_keep isl_qpolynomial_fold *fold);
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
-		__isl_keep isl_pw_qpolynomial_fold *pwf);
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_copy(
-		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
-	void isl_qpolynomial_fold_free(
-		__isl_take isl_qpolynomial_fold *fold);
-	__isl_null isl_pw_qpolynomial_fold *
-	isl_pw_qpolynomial_fold_free(
-		__isl_take isl_pw_qpolynomial_fold *pwf);
-	__isl_null isl_union_pw_qpolynomial_fold *
-	isl_union_pw_qpolynomial_fold_free(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf);
+	isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
+		int val);
+	int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
+	isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
+		int val);
+	int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
 
-=head3 Printing Piecewise Quasipolynomial Reductions
+The C<isl_schedule_node_band_tile> function tiles
+the band using the given tile sizes inside its schedule.
+A new child band node is created to represent the point loops and it is
+inserted between the modified band and its children.
+The subtree rooted at the given node is assumed not to have
+any anchored nodes.
+The C<tile_scale_tile_loops> option specifies whether the tile
+loops iterators should be scaled by the tile sizes.
+If the C<tile_shift_point_loops> option is set, then the point loops
+are shifted to start at zero.
 
-Piecewise quasipolynomial reductions can be printed
+A band node can be split into two nested band nodes
 using the following function.
 
-	__isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
-		__isl_take isl_printer *p,
-		__isl_keep isl_pw_qpolynomial_fold *pwf);
-	__isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
-		__isl_take isl_printer *p,
-		__isl_keep isl_union_pw_qpolynomial_fold *upwf);
-
-For C<isl_printer_print_pw_qpolynomial_fold>,
-output format of the printer
-needs to be set to either C<ISL_FORMAT_ISL> or C<ISL_FORMAT_C>.
-For C<isl_printer_print_union_pw_qpolynomial_fold>,
-output format of the printer
-needs to be set to C<ISL_FORMAT_ISL>.
-In case of printing in C<ISL_FORMAT_C>, the user may want
-to set the names of all dimensions
-
-	__isl_give isl_pw_qpolynomial_fold *
-	isl_pw_qpolynomial_fold_set_dim_name(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		enum isl_dim_type type, unsigned pos,
-		const char *s);
-
-=head3 Inspecting (Piecewise) Quasipolynomial Reductions
-
-To iterate over all piecewise quasipolynomial reductions in a union
-piecewise quasipolynomial reduction, use the following function
-
-	int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
-		__isl_keep isl_union_pw_qpolynomial_fold *upwf,
-		int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
-			    void *user), void *user);
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_band_split(
+		__isl_take isl_schedule_node *node, int pos);
+
+The resulting outer band node contains the first C<pos> dimensions of
+the schedule of C<node> while the inner band contains the remaining dimensions.
+The schedules of the two band nodes live in anonymous spaces.
+The loop AST generation type options and the isolate option
+are split over the two band nodes.
+
+A band node can be moved down to the leaves of the subtree rooted
+at the band node using the following function.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *isl_schedule_node_band_sink(
+		__isl_take isl_schedule_node *node);
+
+The subtree rooted at the given node is assumed not to have
+any anchored nodes.
+The result points to the node in the resulting tree that is in the same
+position as the node pointed to by C<node> in the original tree.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_order_before(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set *filter);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_order_after(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_union_set *filter);
+
+These functions split the domain elements that reach C<node>
+into those that satisfy C<filter> and those that do not and
+arranges for the elements that do satisfy the filter to be
+executed before (in case of C<isl_schedule_node_order_before>)
+or after (in case of C<isl_schedule_node_order_after>)
+those that do not.  The order is imposed by
+a sequence node, possibly reusing the grandparent of C<node>
+on two copies of the subtree attached to the original C<node>.
+Both copies are simplified with respect to their filter.
+
+Return a pointer to the copy of the subtree that does not
+satisfy C<filter>.  If there is no such copy (because all
+reaching domain elements satisfy the filter), then return
+the original pointer.
+
+	#include <isl/schedule_node.h>
+	__isl_give isl_schedule_node *
+	isl_schedule_node_graft_before(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_schedule_node *graft);
+	__isl_give isl_schedule_node *
+	isl_schedule_node_graft_after(
+		__isl_take isl_schedule_node *node,
+		__isl_take isl_schedule_node *graft);
+
+This function inserts the C<graft> tree into the tree containing C<node>
+such that it is executed before (in case of C<isl_schedule_node_graft_before>)
+or after (in case of C<isl_schedule_node_graft_after>) C<node>.
+The root node of C<graft>
+should be an extension node where the domain of the extension
+is the flat product of all outer band nodes of C<node>.
+The root node may also be a domain node.
+The elements of the domain or the range of the extension may not
+intersect with the domain elements that reach "node".
+The schedule tree of C<graft> may not be anchored.
+
+The schedule tree of C<node> is modified to include an extension node
+corresponding to the root node of C<graft> as a child of the original
+parent of C<node>.  The original node that C<node> points to and the
+child of the root node of C<graft> are attached to this extension node
+through a sequence, with appropriate filters and with the child
+of C<graft> appearing before or after the original C<node>.
+
+If C<node> already appears inside a sequence that is the child of
+an extension node and if the spaces of the new domain elements
+do not overlap with those of the original domain elements,
+then that extension node is extended with the new extension
+rather than introducing a new segment of extension and sequence nodes.
 
-To iterate over the cells in a piecewise quasipolynomial reduction,
-use either of the following two functions
+Return a pointer to the same node in the modified tree that
+C<node> pointed to in the original tree.
 
-	int isl_pw_qpolynomial_fold_foreach_piece(
-		__isl_keep isl_pw_qpolynomial_fold *pwf,
-		int (*fn)(__isl_take isl_set *set,
-			  __isl_take isl_qpolynomial_fold *fold,
-			  void *user), void *user);
-	int isl_pw_qpolynomial_fold_foreach_lifted_piece(
-		__isl_keep isl_pw_qpolynomial_fold *pwf,
-		int (*fn)(__isl_take isl_set *set,
-			  __isl_take isl_qpolynomial_fold *fold,
-			  void *user), void *user);
+A representation of the schedule node can be printed using
 
-See L<Inspecting (Piecewise) Quasipolynomials> for an explanation
-of the difference between these two functions.
-
-To iterate over all quasipolynomials in a reduction, use
-
-	int isl_qpolynomial_fold_foreach_qpolynomial(
-		__isl_keep isl_qpolynomial_fold *fold,
-		int (*fn)(__isl_take isl_qpolynomial *qp,
-			  void *user), void *user);
-
-=head3 Properties of Piecewise Quasipolynomial Reductions
-
-To check whether two union piecewise quasipolynomial reductions are
-obviously equal, use
-
-	int isl_union_pw_qpolynomial_fold_plain_is_equal(
-		__isl_keep isl_union_pw_qpolynomial_fold *upwf1,
-		__isl_keep isl_union_pw_qpolynomial_fold *upwf2);
-
-=head3 Operations on Piecewise Quasipolynomial Reductions
-
-	__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
-		__isl_take isl_qpolynomial_fold *fold,
-		__isl_take isl_val *v);
-	__isl_give isl_pw_qpolynomial_fold *
-	isl_pw_qpolynomial_fold_scale_val(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		__isl_take isl_val *v);
-	__isl_give isl_union_pw_qpolynomial_fold *
-	isl_union_pw_qpolynomial_fold_scale_val(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_val *v);
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
-		__isl_take isl_pw_qpolynomial_fold *pwf1,
-		__isl_take isl_pw_qpolynomial_fold *pwf2);
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fold(
-		__isl_take isl_pw_qpolynomial_fold *pwf1,
-		__isl_take isl_pw_qpolynomial_fold *pwf2);
-
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf1,
-		__isl_take isl_union_pw_qpolynomial_fold *upwf2);
-
-	__isl_give isl_val *isl_pw_qpolynomial_fold_eval(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		__isl_take isl_point *pnt);
-
-	__isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_point *pnt);
-
-	__isl_give isl_pw_qpolynomial_fold *
-	isl_pw_qpolynomial_fold_intersect_params(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		__isl_take isl_set *set);
-
-	__isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf);
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_union_set *uset);
-	__isl_give isl_union_pw_qpolynomial_fold *
-	isl_union_pw_qpolynomial_fold_intersect_params(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_set *set);
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
-		__isl_take isl_pw_qpolynomial_fold *pwf);
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_coalesce(
-		__isl_take isl_pw_qpolynomial_fold *pwf);
-
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_coalesce(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf);
-
-	__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
-		__isl_take isl_qpolynomial_fold *fold,
-		__isl_take isl_set *context);
-	__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
-		__isl_take isl_qpolynomial_fold *fold,
-		__isl_take isl_set *context);
-
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		__isl_take isl_set *context);
-	__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_gist_params(
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		__isl_take isl_set *context);
-
-	__isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_gist(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_union_set *context);
-	__isl_give isl_union_pw_qpolynomial_fold *
-	isl_union_pw_qpolynomial_fold_gist_params(
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		__isl_take isl_set *context);
+	#include <isl/schedule_node.h>
+	__isl_give isl_printer *isl_printer_print_schedule_node(
+		__isl_take isl_printer *p,
+		__isl_keep isl_schedule_node *node);
+	__isl_give char *isl_schedule_node_to_str(
+		__isl_keep isl_schedule_node *node);
 
-The gist operation applies the gist operation to each of
-the cells in the domain of the input piecewise quasipolynomial reduction.
-In future, the operation will also exploit the context
-to simplify the quasipolynomial reductions associated to each cell.
+C<isl_schedule_node_to_str> prints the schedule node in block format.
 
-	__isl_give isl_pw_qpolynomial_fold *
-	isl_set_apply_pw_qpolynomial_fold(
-		__isl_take isl_set *set,
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		int *tight);
-	__isl_give isl_pw_qpolynomial_fold *
-	isl_map_apply_pw_qpolynomial_fold(
-		__isl_take isl_map *map,
-		__isl_take isl_pw_qpolynomial_fold *pwf,
-		int *tight);
-	__isl_give isl_union_pw_qpolynomial_fold *
-	isl_union_set_apply_union_pw_qpolynomial_fold(
-		__isl_take isl_union_set *uset,
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		int *tight);
-	__isl_give isl_union_pw_qpolynomial_fold *
-	isl_union_map_apply_union_pw_qpolynomial_fold(
-		__isl_take isl_union_map *umap,
-		__isl_take isl_union_pw_qpolynomial_fold *upwf,
-		int *tight);
+=head2 Dependence Analysis
 
-The functions taking a map
-compose the given map with the given piecewise quasipolynomial reduction.
-That is, compute a bound (of the same type as C<pwf> or C<upwf> itself)
-over all elements in the intersection of the range of the map
-and the domain of the piecewise quasipolynomial reduction
-as a function of an element in the domain of the map.
-The functions taking a set compute a bound over all elements in the
-intersection of the set and the domain of the
-piecewise quasipolynomial reduction.
+C<isl> contains specialized functionality for performing
+array dataflow analysis.  That is, given a I<sink> access relation,
+a collection of possible I<source> accesses and
+a collection of I<kill> accesses,
+C<isl> can compute relations that describe
+for each iteration of the sink access, which iterations
+of which of the source access relations may have
+accessed the same data element before the given iteration
+of the sink access without any intermediate kill of that data element.
+The resulting dependence relations map source iterations
+to either the corresponding sink iterations or
+pairs of corresponding sink iterations and accessed data elements.
+To compute standard flow dependences, the sink should be
+a read, while the sources should be writes.
+If no kills are specified,
+then memory based dependence analysis is performed.
+If, on the other hand, all sources are also kills,
+then value based dependence analysis is performed.
+If any of the source accesses are marked as being I<must>
+accesses, then they are also treated as kills.
+Furthermore, the specification of must-sources results
+in the computation of must-dependences.
+Only dependences originating in a must access not coscheduled
+with any other access to the same element and without
+any may accesses between the must access and the sink access
+are considered to be must dependences.
 
-=head2 Parametric Vertex Enumeration
+=head3 High-level Interface
 
-The parametric vertex enumeration described in this section
-is mainly intended to be used internally and by the C<barvinok>
-library.
+A high-level interface to dependence analysis is provided
+by the following function.
 
-	#include <isl/vertices.h>
-	__isl_give isl_vertices *isl_basic_set_compute_vertices(
-		__isl_keep isl_basic_set *bset);
+	#include <isl/flow.h>
+	__isl_give isl_union_flow *
+	isl_union_access_info_compute_flow(
+		__isl_take isl_union_access_info *access);
+
+The input C<isl_union_access_info> object describes the sink
+access relations, the source access relations and a schedule,
+while the output C<isl_union_flow> object describes
+the resulting dependence relations and the subsets of the
+sink relations for which no source was found.
 
-The function C<isl_basic_set_compute_vertices> performs the
-actual computation of the parametric vertices and the chamber
-decomposition and store the result in an C<isl_vertices> object.
-This information can be queried by either iterating over all
-the vertices or iterating over all the chambers or cells
-and then iterating over all vertices that are active on the chamber.
+An C<isl_union_access_info> is created, modified, copied and freed using
+the following functions.
 
-	int isl_vertices_foreach_vertex(
-		__isl_keep isl_vertices *vertices,
-		int (*fn)(__isl_take isl_vertex *vertex, void *user),
-		void *user);
+	#include <isl/flow.h>
+	__isl_give isl_union_access_info *
+	isl_union_access_info_from_sink(
+		__isl_take isl_union_map *sink);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_set_kill(
+		__isl_take isl_union_access_info *access,
+		__isl_take isl_union_map *kill);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_set_may_source(
+		__isl_take isl_union_access_info *access,
+		__isl_take isl_union_map *may_source);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_set_must_source(
+		__isl_take isl_union_access_info *access,
+		__isl_take isl_union_map *must_source);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_set_schedule(
+		__isl_take isl_union_access_info *access,
+		__isl_take isl_schedule *schedule);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_set_schedule_map(
+		__isl_take isl_union_access_info *access,
+		__isl_take isl_union_map *schedule_map);
+	__isl_give isl_union_access_info *
+	isl_union_access_info_copy(
+		__isl_keep isl_union_access_info *access);
+	__isl_null isl_union_access_info *
+	isl_union_access_info_free(
+		__isl_take isl_union_access_info *access);
+
+The may sources set by C<isl_union_access_info_set_may_source>
+do not need to include the must sources set by
+C<isl_union_access_info_set_must_source> as a subset.
+The kills set by C<isl_union_access_info_set_kill> may overlap
+with the may-sources and/or must-sources.
+The user is free not to call one (or more) of these functions,
+in which case the corresponding set is kept to its empty default.
+Similarly, the default schedule initialized by
+C<isl_union_access_info_from_sink> is empty.
+The current schedule is determined by the last call to either
+C<isl_union_access_info_set_schedule> or
+C<isl_union_access_info_set_schedule_map>.
+The domain of the schedule corresponds to the domains of
+the access relations.  In particular, the domains of the access
+relations are effectively intersected with the domain of the schedule
+and only the resulting accesses are considered by the dependence analysis.
 
-	int isl_vertices_foreach_cell(
-		__isl_keep isl_vertices *vertices,
-		int (*fn)(__isl_take isl_cell *cell, void *user),
-		void *user);
-	int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
-		int (*fn)(__isl_take isl_vertex *vertex, void *user),
-		void *user);
+An C<isl_union_access_info> object can be read from input
+using the following function.
 
-Other operations that can be performed on an C<isl_vertices> object are
-the following.
+	#include <isl/flow.h>
+	__isl_give isl_union_access_info *
+	isl_union_access_info_read_from_file(isl_ctx *ctx,
+		FILE *input);
 
-	isl_ctx *isl_vertices_get_ctx(
-		__isl_keep isl_vertices *vertices);
-	int isl_vertices_get_n_vertices(
-		__isl_keep isl_vertices *vertices);
-	void isl_vertices_free(__isl_take isl_vertices *vertices);
+A representation of the information contained in an object
+of type C<isl_union_access_info> can be obtained using
 
-Vertices can be inspected and destroyed using the following functions.
+	#include <isl/flow.h>
+	__isl_give isl_printer *
+	isl_printer_print_union_access_info(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_access_info *access);
+	__isl_give char *isl_union_access_info_to_str(
+		__isl_keep isl_union_access_info *access);
 
-	isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
-	int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
-	__isl_give isl_basic_set *isl_vertex_get_domain(
-		__isl_keep isl_vertex *vertex);
-	__isl_give isl_multi_aff *isl_vertex_get_expr(
-		__isl_keep isl_vertex *vertex);
-	void isl_vertex_free(__isl_take isl_vertex *vertex);
+C<isl_union_access_info_to_str> prints the information in flow format.
 
-C<isl_vertex_get_expr> returns a multiple quasi-affine expression
-describing the vertex in terms of the parameters,
-while C<isl_vertex_get_domain> returns the activity domain
-of the vertex.
+The output of C<isl_union_access_info_compute_flow> can be examined,
+copied, and freed using the following functions.
 
-Chambers can be inspected and destroyed using the following functions.
+	#include <isl/flow.h>
+	__isl_give isl_union_map *isl_union_flow_get_must_dependence(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_map *isl_union_flow_get_may_dependence(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_map *
+	isl_union_flow_get_full_must_dependence(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_map *
+	isl_union_flow_get_full_may_dependence(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_map *isl_union_flow_get_must_no_source(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_map *isl_union_flow_get_may_no_source(
+		__isl_keep isl_union_flow *flow);
+	__isl_give isl_union_flow *isl_union_flow_copy(
+		__isl_keep isl_union_flow *flow);
+	__isl_null isl_union_flow *isl_union_flow_free(
+		__isl_take isl_union_flow *flow);
+
+The relation returned by C<isl_union_flow_get_must_dependence>
+relates domain elements of must sources to domain elements of the sink.
+The relation returned by C<isl_union_flow_get_may_dependence>
+relates domain elements of must or may sources to domain elements of the sink
+and includes the previous relation as a subset.
+The relation returned by C<isl_union_flow_get_full_must_dependence>
+relates domain elements of must sources to pairs of domain elements of the sink
+and accessed data elements.
+The relation returned by C<isl_union_flow_get_full_may_dependence>
+relates domain elements of must or may sources to pairs of
+domain elements of the sink and accessed data elements.
+This relation includes the previous relation as a subset.
+The relation returned by C<isl_union_flow_get_must_no_source> is the subset
+of the sink relation for which no dependences have been found.
+The relation returned by C<isl_union_flow_get_may_no_source> is the subset
+of the sink relation for which no definite dependences have been found.
+That is, it contains those sink access that do not contribute to any
+of the elements in the relation returned
+by C<isl_union_flow_get_must_dependence>.
 
-	isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
-	__isl_give isl_basic_set *isl_cell_get_domain(
-		__isl_keep isl_cell *cell);
-	void isl_cell_free(__isl_take isl_cell *cell);
+A representation of the information contained in an object
+of type C<isl_union_flow> can be obtained using
 
-=head1 Polyhedral Compilation Library
+	#include <isl/flow.h>
+	__isl_give isl_printer *isl_printer_print_union_flow(
+		__isl_take isl_printer *p,
+		__isl_keep isl_union_flow *flow);
+	__isl_give char *isl_union_flow_to_str(
+		__isl_keep isl_union_flow *flow);
 
-This section collects functionality in C<isl> that has been specifically
-designed for use during polyhedral compilation.
+C<isl_union_flow_to_str> prints the information in flow format.
 
-=head2 Dependence Analysis
+=head3 Low-level Interface
 
-C<isl> contains specialized functionality for performing
-array dataflow analysis.  That is, given a I<sink> access relation
-and a collection of possible I<source> access relations,
-C<isl> can compute relations that describe
-for each iteration of the sink access, which iteration
-of which of the source access relations was the last
-to access the same data element before the given iteration
-of the sink access.
-The resulting dependence relations map source iterations
-to the corresponding sink iterations.
-To compute standard flow dependences, the sink should be
-a read, while the sources should be writes.
-If any of the source accesses are marked as being I<may>
-accesses, then there will be a dependence from the last
-I<must> access B<and> from any I<may> access that follows
-this last I<must> access.
-In particular, if I<all> sources are I<may> accesses,
-then memory based dependence analysis is performed.
-If, on the other hand, all sources are I<must> accesses,
-then value based dependence analysis is performed.
+A lower-level interface is provided by the following functions.
 
 	#include <isl/flow.h>
 
@@ -5830,13 +10830,14 @@
 	__isl_give isl_flow *isl_access_info_compute_flow(
 		__isl_take isl_access_info *acc);
 
-	int isl_flow_foreach(__isl_keep isl_flow *deps,
-		int (*fn)(__isl_take isl_map *dep, int must,
+	isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
+		isl_stat (*fn)(__isl_take isl_map *dep, int must,
 			  void *dep_user, void *user),
 		void *user);
 	__isl_give isl_map *isl_flow_get_no_source(
 		__isl_keep isl_flow *deps, int must);
-	void isl_flow_free(__isl_take isl_flow *deps);
+	__isl_null isl_flow *isl_flow_free(
+		__isl_take isl_flow *deps);
 
 The function C<isl_access_info_compute_flow> performs the actual
 dependence analysis.  The other functions are used to construct
@@ -5849,6 +10850,7 @@
 access to the user, a callback function for specifying the
 relative order of source and sink accesses, and the number
 of source access relations that will be added.
+
 The callback function has type C<int (*)(void *first, void *second)>.
 The function is called with two user supplied tokens identifying
 either a source or the sink and it should return the shared nesting
@@ -5857,7 +10859,12 @@
 the two accesses.  If C<first> precedes C<second> textually,
 then the function should return I<2 * n + 1>; otherwise,
 it should return I<2 * n>.
-The sources can be added to the C<isl_access_info> by performing
+The low-level interface assumes that no sources are coscheduled.
+If the information returned by the callback does not allow
+the relative order to be determined, then one of the sources
+is arbitrarily taken to be executed after the other(s).
+
+The sources can be added to the C<isl_access_info> object by performing
 (at most) C<max_source> calls to C<isl_access_info_add_source>.
 C<must> indicates whether the source is a I<must> access
 or a I<may> access.  Note that a multi-valued access relation
@@ -5868,7 +10875,7 @@
 C<source> should have the same dimension as the range
 of the sink access relation.
 The C<isl_access_info_free> function should usually not be
-called explicitly, because it is called implicitly by
+called explicitly, because it is already called implicitly by
 C<isl_access_info_compute_flow>.
 
 The result of the dependence analysis is collected in an
@@ -5897,31 +10904,7 @@
 After finishing with an C<isl_flow>, the user should call
 C<isl_flow_free> to free all associated memory.
 
-A higher-level interface to dependence analysis is provided
-by the following function.
-
-	#include <isl/flow.h>
-
-	int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
-		__isl_take isl_union_map *must_source,
-		__isl_take isl_union_map *may_source,
-		__isl_take isl_union_map *schedule,
-		__isl_give isl_union_map **must_dep,
-		__isl_give isl_union_map **may_dep,
-		__isl_give isl_union_map **must_no_source,
-		__isl_give isl_union_map **may_no_source);
-
-The arrays are identified by the tuple names of the ranges
-of the accesses.  The iteration domains by the tuple names
-of the domains of the accesses and of the schedule.
-The relative order of the iteration domains is given by the
-schedule.  The relations returned through C<must_no_source>
-and C<may_no_source> are subsets of C<sink>.
-Any of C<must_dep>, C<may_dep>, C<must_no_source>
-or C<may_no_source> may be C<NULL>, but a C<NULL> value for
-any of the other arguments is treated as an error.
-
-=head3 Interaction with Dependence Analysis
+=head3 Interaction with the Low-level Interface
 
 During the dependence analysis, we frequently need to perform
 the following operation.  Given a relation between sink iterations
@@ -5981,8 +10964,6 @@
 		__isl_take isl_map *source_map);
 	__isl_null isl_restriction *isl_restriction_free(
 		__isl_take isl_restriction *restr);
-	isl_ctx *isl_restriction_get_ctx(
-		__isl_keep isl_restriction *restr);
 
 C<isl_restriction_none> and C<isl_restriction_empty> are special
 cases of C<isl_restriction_input>.  C<isl_restriction_none>
@@ -6002,15 +10983,10 @@
 
 =head2 Scheduling
 
-B<The functionality described in this section is fairly new
-and may be subject to change.>
-
 	#include <isl/schedule.h>
 	__isl_give isl_schedule *
 	isl_schedule_constraints_compute_schedule(
 		__isl_take isl_schedule_constraints *sc);
-	__isl_null isl_schedule *isl_schedule_free(
-		__isl_take isl_schedule *sched);
 
 The function C<isl_schedule_constraints_compute_schedule> can be
 used to compute a schedule that satisfies the given schedule constraints.
@@ -6025,12 +11001,24 @@
 The generated schedule respects all validity dependences.
 That is, all dependence distances over these dependences in the
 scheduled space are lexicographically positive.
+
 The default algorithm tries to ensure that the dependence distances
 over coincidence constraints are zero and to minimize the
 dependence distances over proximity dependences.
 Moreover, it tries to obtain sequences (bands) of schedule dimensions
 for groups of domains where the dependence distances over validity
 dependences have only non-negative values.
+Note that when minimizing the maximal dependence distance
+over proximity dependences, a single affine expression in the parameters
+is constructed that bounds all dependence distances.  If no such expression
+exists, then the algorithm will fail and resort to an alternative
+scheduling algorithm.  In particular, this means that adding proximity
+dependences may eliminate valid solutions.  A typical example where this
+phenomenon may occur is when some subset of the proximity dependences
+has no restriction on some parameter, forcing the coefficient of that
+parameter to be zero, while some other subset forces the dependence
+distance to depend on that parameter, requiring the same coefficient
+to be non-zero.
 When using Feautrier's algorithm, the coincidence and proximity constraints
 are only taken into account during the extension to a
 full-dimensional schedule.
@@ -6045,8 +11033,10 @@
 	__isl_give isl_schedule_constraints *
 	isl_schedule_constraints_on_domain(
 		__isl_take isl_union_set *domain);
-	isl_ctx *isl_schedule_constraints_get_ctx(
-		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_schedule_constraints *
+	isl_schedule_constraints_set_context(
+		__isl_take isl_schedule_constraints *sc,
+		__isl_take isl_set *context);
 	__isl_give isl_schedule_constraints *
 	isl_schedule_constraints_set_validity(
 		__isl_take isl_schedule_constraints *sc,
@@ -6064,6 +11054,10 @@
 		__isl_take isl_schedule_constraints *sc,
 		__isl_take isl_union_map *condition,
 		__isl_take isl_union_map *validity);
+	__isl_give isl_schedule_constraints *
+	isl_schedule_constraints_apply(
+		__isl_take isl_schedule_constraints *sc,
+		__isl_take isl_union_map *umap);
 	__isl_null isl_schedule_constraints *
 	isl_schedule_constraints_free(
 		__isl_take isl_schedule_constraints *sc);
@@ -6071,6 +11065,9 @@
 The initial C<isl_schedule_constraints> object created by
 C<isl_schedule_constraints_on_domain> does not impose any constraints.
 That is, it has an empty set of dependences.
+The function C<isl_schedule_constraints_set_context> allows the user
+to specify additional constraints on the parameters that may
+be assumed to hold during the construction of the schedule.
 The function C<isl_schedule_constraints_set_validity> replaces the
 validity dependences, mapping domain elements I<i> to domain
 elements that should be scheduled after I<i>.
@@ -6106,6 +11103,58 @@
 In particular, a relation with a tag will never be considered adjacent
 to a relation without a tag.
 
+The function C<isl_schedule_constraints_apply> takes
+schedule constraints that are defined on some set of domain elements
+and transforms them to schedule constraints on the elements
+to which these domain elements are mapped by the given transformation.
+
+An C<isl_schedule_constraints> object can be inspected
+using the following functions.
+
+	#include <isl/schedule.h>
+	__isl_give isl_union_set *
+	isl_schedule_constraints_get_domain(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_set *isl_schedule_constraints_get_context(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_union_map *
+	isl_schedule_constraints_get_validity(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_union_map *
+	isl_schedule_constraints_get_coincidence(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_union_map *
+	isl_schedule_constraints_get_proximity(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_union_map *
+	isl_schedule_constraints_get_conditional_validity(
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give isl_union_map *
+	isl_schedule_constraints_get_conditional_validity_condition(
+		__isl_keep isl_schedule_constraints *sc);
+
+An C<isl_schedule_constraints> object can be read from input
+using the following functions.
+
+	#include <isl/schedule.h>
+	__isl_give isl_schedule_constraints *
+	isl_schedule_constraints_read_from_str(isl_ctx *ctx,
+		const char *str);
+	__isl_give isl_schedule_constraints *
+	isl_schedule_constraints_read_from_file(isl_ctx *ctx,
+		FILE *input);
+
+The contents of an C<isl_schedule_constraints> object can be printed
+using the following functions.
+
+	#include <isl/schedule.h>
+	__isl_give isl_printer *
+	isl_printer_print_schedule_constraints(
+		__isl_take isl_printer *p,
+		__isl_keep isl_schedule_constraints *sc);
+	__isl_give char *isl_schedule_constraints_to_str(
+		__isl_keep isl_schedule_constraints *sc);
+
 The following function computes a schedule directly from
 an iteration domain and validity and proximity dependences
 and is implemented in terms of the functions described above.
@@ -6117,154 +11166,57 @@
 		__isl_take isl_union_map *validity,
 		__isl_take isl_union_map *proximity);
 
-A mapping from the domains to the scheduled space can be obtained
-from an C<isl_schedule> using the following function.
-
-	__isl_give isl_union_map *isl_schedule_get_map(
-		__isl_keep isl_schedule *sched);
-
-A representation of the schedule can be printed using
-	 
-	__isl_give isl_printer *isl_printer_print_schedule(
-		__isl_take isl_printer *p,
-		__isl_keep isl_schedule *schedule);
-
-A representation of the schedule as a forest of bands can be obtained
-using the following function.
-
-	__isl_give isl_band_list *isl_schedule_get_band_forest(
-		__isl_keep isl_schedule *schedule);
-
-The individual bands can be visited in depth-first post-order
-using the following function.
-
-	#include <isl/schedule.h>
-	int isl_schedule_foreach_band(
-		__isl_keep isl_schedule *sched,
-		int (*fn)(__isl_keep isl_band *band, void *user),
-		void *user);
-
-The list can be manipulated as explained in L<"Lists">.
-The bands inside the list can be copied and freed using the following
-functions.
-
-	#include <isl/band.h>
-	__isl_give isl_band *isl_band_copy(
-		__isl_keep isl_band *band);
-	__isl_null isl_band *isl_band_free(
-		__isl_take isl_band *band);
-
-Each band contains zero or more scheduling dimensions.
-These are referred to as the members of the band.
-The section of the schedule that corresponds to the band is
-referred to as the partial schedule of the band.
-For those nodes that participate in a band, the outer scheduling
-dimensions form the prefix schedule, while the inner scheduling
-dimensions form the suffix schedule.
-That is, if we take a cut of the band forest, then the union of
-the concatenations of the prefix, partial and suffix schedules of
-each band in the cut is equal to the entire schedule (modulo
-some possible padding at the end with zero scheduling dimensions).
-The properties of a band can be inspected using the following functions.
-
-	#include <isl/band.h>
-	isl_ctx *isl_band_get_ctx(__isl_keep isl_band *band);
-
-	int isl_band_has_children(__isl_keep isl_band *band);
-	__isl_give isl_band_list *isl_band_get_children(
-		__isl_keep isl_band *band);
-
-	__isl_give isl_union_map *isl_band_get_prefix_schedule(
-		__isl_keep isl_band *band);
-	__isl_give isl_union_map *isl_band_get_partial_schedule(
-		__isl_keep isl_band *band);
-	__isl_give isl_union_map *isl_band_get_suffix_schedule(
-		__isl_keep isl_band *band);
-
-	int isl_band_n_member(__isl_keep isl_band *band);
-	int isl_band_member_is_coincident(
-		__isl_keep isl_band *band, int pos);
-
-	int isl_band_list_foreach_band(
-		__isl_keep isl_band_list *list,
-		int (*fn)(__isl_keep isl_band *band, void *user),
-		void *user);
-
-Note that a scheduling dimension is considered to be ``coincident''
-if it satisfies the coincidence constraints within its band.
-That is, if the dependence distances of the coincidence
-constraints are all zero in that direction (for fixed
-iterations of outer bands).
-Like C<isl_schedule_foreach_band>,
-the function C<isl_band_list_foreach_band> calls C<fn> on the bands
-in depth-first post-order.
-
-A band can be tiled using the following function.
-
-	#include <isl/band.h>
-	int isl_band_tile(__isl_keep isl_band *band,
-		__isl_take isl_vec *sizes);
-
-	int isl_options_set_tile_scale_tile_loops(isl_ctx *ctx,
-		int val);
-	int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
-	int isl_options_set_tile_shift_point_loops(isl_ctx *ctx,
-		int val);
-	int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
-
-The C<isl_band_tile> function tiles the band using the given tile sizes
-inside its schedule.
-A new child band is created to represent the point loops and it is
-inserted between the modified band and its children.
-The C<tile_scale_tile_loops> option specifies whether the tile
-loops iterators should be scaled by the tile sizes.
-If the C<tile_shift_point_loops> option is set, then the point loops
-are shifted to start at zero.
-
-A band can be split into two nested bands using the following function.
-
-	int isl_band_split(__isl_keep isl_band *band, int pos);
-
-The resulting outer band contains the first C<pos> dimensions of C<band>
-while the inner band contains the remaining dimensions.
-
-A representation of the band can be printed using
-
-	#include <isl/band.h>
-	__isl_give isl_printer *isl_printer_print_band(
-		__isl_take isl_printer *p,
-		__isl_keep isl_band *band);
+The generated schedule represents a schedule tree.
+For more information on schedule trees, see
+L</"Schedule Trees">.
 
 =head3 Options
 
 	#include <isl/schedule.h>
-	int isl_options_set_schedule_max_coefficient(
+	isl_stat isl_options_set_schedule_max_coefficient(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_max_coefficient(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_max_constant_term(
+	isl_stat isl_options_set_schedule_max_constant_term(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_max_constant_term(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
-	int isl_options_get_schedule_fuse(isl_ctx *ctx);
-	int isl_options_set_schedule_maximize_band_depth(
+	isl_stat isl_options_set_schedule_serialize_sccs(
+		isl_ctx *ctx, int val);
+	int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
+	isl_stat isl_options_set_schedule_whole_component(
+		isl_ctx *ctx, int val);
+	int isl_options_get_schedule_whole_component(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_schedule_maximize_band_depth(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_maximize_band_depth(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_outer_coincidence(
+	isl_stat isl_options_set_schedule_maximize_coincidence(
+		isl_ctx *ctx, int val);
+	int isl_options_get_schedule_maximize_coincidence(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_schedule_outer_coincidence(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_outer_coincidence(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_split_scaled(
+	isl_stat isl_options_set_schedule_split_scaled(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_split_scaled(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_algorithm(
+	isl_stat isl_options_set_schedule_treat_coalescing(
+		isl_ctx *ctx, int val);
+	int isl_options_get_schedule_treat_coalescing(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_schedule_algorithm(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_algorithm(
 		isl_ctx *ctx);
-	int isl_options_set_schedule_separate_components(
+	isl_stat isl_options_set_schedule_carry_self_first(
+		isl_ctx *ctx, int val);
+	int isl_options_get_schedule_carry_self_first(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_schedule_separate_components(
 		isl_ctx *ctx, int val);
 	int isl_options_get_schedule_separate_components(
 		isl_ctx *ctx);
@@ -6279,6 +11231,7 @@
 and may also prevent fusing of unrelated dimensions. A value of -1 means that
 this option does not introduce bounds on the variable or parameter
 coefficients.
+This option has no effect on the Feautrier style scheduler.
 
 =item * schedule_max_constant_term
 
@@ -6288,24 +11241,44 @@
 unrelated dimensions. A value of -1 means that this option does not introduce
 bounds on the constant coefficients.
 
-=item * schedule_fuse
+=item * schedule_serialize_sccs
 
-This option controls the level of fusion.
-If this option is set to C<ISL_SCHEDULE_FUSE_MIN>, then loops in the
-resulting schedule will be distributed as much as possible.
-If this option is set to C<ISL_SCHEDULE_FUSE_MAX>, then C<isl> will
-try to fuse loops in the resulting schedule.
+If this option is set, then all strongly connected components
+in the dependence graph are serialized as soon as they are detected.
+This means in particular that instances of statements will only
+appear in the same band node if these statements belong
+to the same strongly connected component at the point where
+the band node is constructed.
+
+=item * schedule_whole_component
+
+If this option is set, then entire (weakly) connected
+components in the dependence graph are scheduled together
+as a whole.
+Otherwise, each strongly connected component within
+such a weakly connected component is first scheduled separately
+and then combined with other strongly connected components.
+This option has no effect if C<schedule_serialize_sccs> is set.
 
 =item * schedule_maximize_band_depth
 
-If this option is set, we do not split bands at the point
-where we detect splitting is necessary. Instead, we
-backtrack and split bands as early as possible. This
-reduces the number of splits and maximizes the width of
-the bands. Wider bands give more possibilities for tiling.
-Note that if the C<schedule_fuse> option is set to C<ISL_SCHEDULE_FUSE_MIN>,
-then bands will be split as early as possible, even if there is no need.
-The C<schedule_maximize_band_depth> option therefore has no effect in this case.
+If this option is set, then the scheduler tries to maximize
+the width of the bands.  Wider bands give more possibilities for tiling.
+In particular, if the C<schedule_whole_component> option is set,
+then bands are split if this might result in wider bands.
+Otherwise, the effect of this option is to only allow
+strongly connected components to be combined if this does
+not reduce the width of the bands.
+Note that if the C<schedule_serialize_sccs> options is set, then
+the C<schedule_maximize_band_depth> option therefore has no effect.
+
+=item * schedule_maximize_coincidence
+
+This option is only effective if the C<schedule_whole_component>
+option is turned off.
+If the C<schedule_maximize_coincidence> option is set, then (clusters of)
+strongly connected components are only combined with each other
+if this does not reduce the number of coincident band members.
 
 =item * schedule_outer_coincidence
 
@@ -6313,29 +11286,44 @@
 where the outermost scheduling dimension in each band
 satisfies the coincidence constraints.
 
+=item * schedule_algorithm
+
+Selects the scheduling algorithm to be used.
+Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
+and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
+
 =item * schedule_split_scaled
 
 If this option is set, then we try to construct schedules in which the
 constant term is split off from the linear part if the linear parts of
-the scheduling rows for all nodes in the graphs have a common non-trivial
+the scheduling rows for all nodes in the graph have a common non-trivial
 divisor.
-The constant term is then placed in a separate band and the linear
+The constant term is then dropped and the linear
 part is reduced.
-
-=item * schedule_algorithm
-
-Selects the scheduling algorithm to be used.
-Available scheduling algorithms are C<ISL_SCHEDULE_ALGORITHM_ISL>
-and C<ISL_SCHEDULE_ALGORITHM_FEAUTRIER>.
+This option is only effective when the Feautrier style scheduler is
+being used, either as the main scheduler or as a fallback for the
+Pluto-like scheduler.
+
+=item * schedule_treat_coalescing
+
+If this option is set, then the scheduler will try and avoid
+producing schedules that perform loop coalescing.
+In particular, for the Pluto-like scheduler, this option places
+bounds on the schedule coefficients based on the sizes of the instance sets.
+For the Feautrier style scheduler, this option detects potentially
+coalescing schedules and then tries to adjust the schedule to avoid
+the coalescing.
+
+=item * schedule_carry_self_first
+
+If this option is set, then the Feautrier style scheduler
+(when used as a fallback for the Pluto-like scheduler) will
+first try to only carry self-dependences.
 
 =item * schedule_separate_components
 
-If at any point the dependence graph contains any (weakly connected) components,
-then these components are scheduled separately.
-If this option is not set, then some iterations of the domains
-in these components may be scheduled together.
-If this option is set, then the components are given consecutive
-schedules.
+If this option is set then the function C<isl_schedule_get_map>
+will treat set nodes in the same way as sequence nodes.
 
 =back
 
@@ -6343,40 +11331,51 @@
 
 This section describes the C<isl> functionality for generating
 ASTs that visit all the elements
-in a domain in an order specified by a schedule.
-In particular, given a C<isl_union_map>, an AST is generated
+in a domain in an order specified by a schedule tree or
+a schedule map.
+In case the schedule given as a C<isl_union_map>, an AST is generated
 that visits all the elements in the domain of the C<isl_union_map>
 according to the lexicographic order of the corresponding image
 element(s).  If the range of the C<isl_union_map> consists of
 elements in more than one space, then each of these spaces is handled
 separately in an arbitrary order.
-It should be noted that the image elements only specify the I<order>
+It should be noted that the schedule tree or the image elements
+in a schedule map only specify the I<order>
 in which the corresponding domain elements should be visited.
-No direct relation between the image elements and the loop iterators
-in the generated AST should be assumed.
+No direct relation between the partial schedule values
+or the image elements on the one hand and the loop iterators
+in the generated AST on the other hand should be assumed.
 
 Each AST is generated within a build.  The initial build
 simply specifies the constraints on the parameters (if any)
 and can be created, inspected, copied and freed using the following functions.
 
 	#include <isl/ast_build.h>
+	__isl_give isl_ast_build *isl_ast_build_alloc(
+		isl_ctx *ctx);
 	__isl_give isl_ast_build *isl_ast_build_from_context(
 		__isl_take isl_set *set);
-	isl_ctx *isl_ast_build_get_ctx(
-		__isl_keep isl_ast_build *build);
 	__isl_give isl_ast_build *isl_ast_build_copy(
 		__isl_keep isl_ast_build *build);
 	__isl_null isl_ast_build *isl_ast_build_free(
 		__isl_take isl_ast_build *build);
 
 The C<set> argument is usually a parameter set with zero or more parameters.
+In fact, when creating an AST using C<isl_ast_build_node_from_schedule>,
+this set is required to be a parameter set.
+An C<isl_ast_build> created using C<isl_ast_build_alloc> does not
+specify any parameter constraints.
 More C<isl_ast_build> functions are described in L</"Nested AST Generation">
 and L</"Fine-grained Control over AST Generation">.
-Finally, the AST itself can be constructed using the following
-function.
+Finally, the AST itself can be constructed using one of the following
+functions.
 
 	#include <isl/ast_build.h>
-	__isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
+	__isl_give isl_ast_node *isl_ast_build_node_from_schedule(
+		__isl_keep isl_ast_build *build,
+		__isl_take isl_schedule *schedule);
+	__isl_give isl_ast_node *
+	isl_ast_build_node_from_schedule_map(
 		__isl_keep isl_ast_build *build,
 		__isl_take isl_union_map *schedule);
 
@@ -6385,19 +11384,19 @@
 The basic properties of an AST node can be obtained as follows.
 
 	#include <isl/ast.h>
-	isl_ctx *isl_ast_node_get_ctx(
-		__isl_keep isl_ast_node *node);
 	enum isl_ast_node_type isl_ast_node_get_type(
 		__isl_keep isl_ast_node *node);
 
 The type of an AST node is one of
 C<isl_ast_node_for>,
 C<isl_ast_node_if>,
-C<isl_ast_node_block> or
+C<isl_ast_node_block>,
+C<isl_ast_node_mark> or
 C<isl_ast_node_user>.
 An C<isl_ast_node_for> represents a for node.
 An C<isl_ast_node_if> represents an if node.
 An C<isl_ast_node_block> represents a compound node.
+An C<isl_ast_node_mark> introduces a mark in the AST.
 An C<isl_ast_node_user> represents an expression statement.
 An expression statement typically corresponds to a domain element, i.e.,
 one of the elements that is visited by the AST.
@@ -6415,7 +11414,7 @@
 		__isl_keep isl_ast_node *node);
 	__isl_give isl_ast_node *isl_ast_node_for_get_body(
 		__isl_keep isl_ast_node *node);
-	int isl_ast_node_for_is_degenerate(
+	isl_bool isl_ast_node_for_is_degenerate(
 		__isl_keep isl_ast_node *node);
 
 An C<isl_ast_for> is considered degenerate if it is known to execute
@@ -6424,26 +11423,62 @@
 	#include <isl/ast.h>
 	__isl_give isl_ast_expr *isl_ast_node_if_get_cond(
 		__isl_keep isl_ast_node *node);
+	__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
+		__isl_keep isl_ast_node *node);
 	__isl_give isl_ast_node *isl_ast_node_if_get_then(
 		__isl_keep isl_ast_node *node);
-	int isl_ast_node_if_has_else(
+	isl_bool isl_ast_node_if_has_else_node(
+		__isl_keep isl_ast_node *node);
+	isl_bool isl_ast_node_if_has_else(
+		__isl_keep isl_ast_node *node);
+	__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
 		__isl_keep isl_ast_node *node);
 	__isl_give isl_ast_node *isl_ast_node_if_get_else(
 		__isl_keep isl_ast_node *node);
 
+C<isl_ast_node_if_get_then>,
+C<isl_ast_node_if_has_else> and
+C<isl_ast_node_if_get_else>
+are alternative names for
+C<isl_ast_node_if_get_then_node>,
+C<isl_ast_node_if_has_else_node> and
+C<isl_ast_node_if_get_else_node>, respectively.
+
 	__isl_give isl_ast_node_list *
 	isl_ast_node_block_get_children(
 		__isl_keep isl_ast_node *node);
 
+	__isl_give isl_id *isl_ast_node_mark_get_id(
+		__isl_keep isl_ast_node *node);
+	__isl_give isl_ast_node *isl_ast_node_mark_get_node(
+		__isl_keep isl_ast_node *node);
+
+C<isl_ast_node_mark_get_id> returns the identifier of the mark.
+C<isl_ast_node_mark_get_node> returns the child node that is being marked.
+
+	#include <isl/ast.h>
 	__isl_give isl_ast_expr *isl_ast_node_user_get_expr(
 		__isl_keep isl_ast_node *node);
 
+All descendants of a specific node in the AST (including the node itself)
+can be visited
+in depth-first pre-order using the following function.
+
+	#include <isl/ast.h>
+	isl_stat isl_ast_node_foreach_descendant_top_down(
+		__isl_keep isl_ast_node *node,
+		isl_bool (*fn)(__isl_keep isl_ast_node *node,
+			void *user), void *user);
+
+The callback function should return C<isl_bool_true> if the children
+of the given node should be visited and C<isl_bool_false> if they should not.
+It should return C<isl_bool_error> in case of failure, in which case
+the entire traversal is aborted.
+
 Each of the returned C<isl_ast_expr>s can in turn be inspected using
 the following functions.
 
 	#include <isl/ast.h>
-	isl_ctx *isl_ast_expr_get_ctx(
-		__isl_keep isl_ast_expr *expr);
 	enum isl_ast_expr_type isl_ast_expr_get_type(
 		__isl_keep isl_ast_expr *expr);
 
@@ -6458,88 +11493,127 @@
 Each type of expression has its own additional properties.
 
 	#include <isl/ast.h>
-	enum isl_ast_op_type isl_ast_expr_get_op_type(
+	enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
+		__isl_keep isl_ast_expr *expr);
+	enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
 		__isl_keep isl_ast_expr *expr);
-	int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
+	isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);
+	isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
+	__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(
+		__isl_keep isl_ast_expr *expr, int pos);
 	__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(
 		__isl_keep isl_ast_expr *expr, int pos);
-	int isl_ast_node_foreach_ast_op_type(
+	isl_stat isl_ast_expr_foreach_ast_expr_op_type(
+		__isl_keep isl_ast_expr *expr,
+		isl_stat (*fn)(enum isl_ast_expr_op_type type,
+			void *user), void *user);
+	isl_stat isl_ast_expr_foreach_ast_op_type(
+		__isl_keep isl_ast_expr *expr,
+		isl_stat (*fn)(enum isl_ast_expr_op_type type,
+			void *user), void *user);
+	isl_stat isl_ast_node_foreach_ast_expr_op_type(
 		__isl_keep isl_ast_node *node,
-		int (*fn)(enum isl_ast_op_type type, void *user),
-		void *user);
+		isl_stat (*fn)(enum isl_ast_expr_op_type type,
+			void *user), void *user);
+	isl_stat isl_ast_node_foreach_ast_op_type(
+		__isl_keep isl_ast_node *node,
+		isl_stat (*fn)(enum isl_ast_expr_op_type type,
+			void *user), void *user);
 
-C<isl_ast_expr_get_op_type> returns the type of the operation
-performed.  C<isl_ast_expr_get_op_n_arg> returns the number of
+C<isl_ast_expr_op_get_type> returns the type of the operation
+performed.  C<isl_ast_expr_op_get_n_arg> returns the number of
 arguments.  C<isl_ast_expr_get_op_arg> returns the specified
 argument.
-C<isl_ast_node_foreach_ast_op_type> calls C<fn> for each distinct
-C<isl_ast_op_type> that appears in C<node>.
+C<isl_ast_expr_get_op_type> is an alternative name for
+C<isl_ast_expr_op_get_type>.
+Similarly,
+C<isl_ast_expr_get_op_n_arg> is an alternative name for
+C<isl_ast_expr_op_get_n_arg> and
+C<isl_ast_expr_get_op_arg> is an alternative name for
+C<isl_ast_expr_op_get_arg>.
+
+C<isl_ast_expr_foreach_ast_expr_op_type> calls C<fn> for each distinct
+C<isl_ast_expr_op_type> that appears in C<expr>.
+C<isl_ast_expr_foreach_ast_op_type> is an alternative name for
+C<isl_ast_expr_foreach_ast_expr_op_type>.
+C<isl_ast_node_foreach_ast_expr_op_type> does the same for each distinct
+C<isl_ast_expr_op_type> that appears in C<node>.
+C<isl_ast_node_foreach_ast_op_type> is an alternative name for
+C<isl_ast_node_foreach_ast_expr_op_type>.
 The operation type is one of the following.
 
 =over
 
-=item C<isl_ast_op_and>
+=item C<isl_ast_expr_op_and>
 
 Logical I<and> of two arguments.
 Both arguments can be evaluated.
 
-=item C<isl_ast_op_and_then>
+=item C<isl_ast_expr_op_and_then>
 
 Logical I<and> of two arguments.
 The second argument can only be evaluated if the first evaluates to true.
 
-=item C<isl_ast_op_or>
+=item C<isl_ast_expr_op_or>
 
 Logical I<or> of two arguments.
 Both arguments can be evaluated.
 
-=item C<isl_ast_op_or_else>
+=item C<isl_ast_expr_op_or_else>
 
 Logical I<or> of two arguments.
 The second argument can only be evaluated if the first evaluates to false.
 
-=item C<isl_ast_op_max>
+=item C<isl_ast_expr_op_max>
 
 Maximum of two or more arguments.
 
-=item C<isl_ast_op_min>
+=item C<isl_ast_expr_op_min>
 
 Minimum of two or more arguments.
 
-=item C<isl_ast_op_minus>
+=item C<isl_ast_expr_op_minus>
 
 Change sign.
 
-=item C<isl_ast_op_add>
+=item C<isl_ast_expr_op_add>
 
 Sum of two arguments.
 
-=item C<isl_ast_op_sub>
+=item C<isl_ast_expr_op_sub>
 
 Difference of two arguments.
 
-=item C<isl_ast_op_mul>
+=item C<isl_ast_expr_op_mul>
 
 Product of two arguments.
 
-=item C<isl_ast_op_div>
+=item C<isl_ast_expr_op_div>
 
 Exact division.  That is, the result is known to be an integer.
 
-=item C<isl_ast_op_fdiv_q>
+=item C<isl_ast_expr_op_fdiv_q>
 
 Result of integer division, rounded towards negative
 infinity.
+The divisor is known to be positive.
 
-=item C<isl_ast_op_pdiv_q>
+=item C<isl_ast_expr_op_pdiv_q>
 
 Result of integer division, where dividend is known to be non-negative.
+The divisor is known to be positive.
 
-=item C<isl_ast_op_pdiv_r>
+=item C<isl_ast_expr_op_pdiv_r>
 
 Remainder of integer division, where dividend is known to be non-negative.
+The divisor is known to be positive.
 
-=item C<isl_ast_op_cond>
+=item C<isl_ast_expr_op_zdiv_r>
+
+Equal to zero iff the remainder on integer division is zero.
+The divisor is known to be positive.
+
+=item C<isl_ast_expr_op_cond>
 
 Conditional operator defined on three arguments.
 If the first argument evaluates to true, then the result
@@ -6549,7 +11623,7 @@
 the first argument evaluates to true and false, respectively.
 Corresponds to C<a ? b : c> in C.
 
-=item C<isl_ast_op_select>
+=item C<isl_ast_expr_op_select>
 
 Conditional operator defined on three arguments.
 If the first argument evaluates to true, then the result
@@ -6559,41 +11633,41 @@
 of the value of the first argument.
 Corresponds to C<a * b + (1 - a) * c> in C.
 
-=item C<isl_ast_op_eq>
+=item C<isl_ast_expr_op_eq>
 
 Equality relation.
 
-=item C<isl_ast_op_le>
+=item C<isl_ast_expr_op_le>
 
 Less than or equal relation.
 
-=item C<isl_ast_op_lt>
+=item C<isl_ast_expr_op_lt>
 
 Less than relation.
 
-=item C<isl_ast_op_ge>
+=item C<isl_ast_expr_op_ge>
 
 Greater than or equal relation.
 
-=item C<isl_ast_op_gt>
+=item C<isl_ast_expr_op_gt>
 
 Greater than relation.
 
-=item C<isl_ast_op_call>
+=item C<isl_ast_expr_op_call>
 
 A function call.
 The number of arguments of the C<isl_ast_expr> is one more than
 the number of arguments in the function call, the first argument
 representing the function being called.
 
-=item C<isl_ast_op_access>
+=item C<isl_ast_expr_op_access>
 
 An array access.
 The number of arguments of the C<isl_ast_expr> is one more than
 the number of index expressions in the array access, the first argument
 representing the array being accessed.
 
-=item C<isl_ast_op_member>
+=item C<isl_ast_expr_op_member>
 
 A member access.
 This operation has two arguments, a structure and the name of
@@ -6602,21 +11676,30 @@
 =back
 
 	#include <isl/ast.h>
+	__isl_give isl_id *isl_ast_expr_id_get_id(
+		__isl_keep isl_ast_expr *expr);
 	__isl_give isl_id *isl_ast_expr_get_id(
 		__isl_keep isl_ast_expr *expr);
 
 Return the identifier represented by the AST expression.
+C<isl_ast_expr_get_id> is an alternative name for
+C<isl_ast_expr_id_get_id>.
 
 	#include <isl/ast.h>
+	__isl_give isl_val *isl_ast_expr_int_get_val(
+		__isl_keep isl_ast_expr *expr);
 	__isl_give isl_val *isl_ast_expr_get_val(
 		__isl_keep isl_ast_expr *expr);
 
 Return the integer represented by the AST expression.
+C<isl_ast_expr_get_val> is an alternative name for
+C<isl_ast_expr_int_get_val>.
 
 =head3 Properties of ASTs
 
 	#include <isl/ast.h>
-	int isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
+	isl_bool isl_ast_expr_is_equal(
+		__isl_keep isl_ast_expr *expr1,
 		__isl_keep isl_ast_expr *expr2);
 
 Check if two C<isl_ast_expr>s are equal to each other.
@@ -6663,12 +11746,24 @@
 	__isl_give isl_ast_expr *isl_ast_expr_div(
 		__isl_take isl_ast_expr *expr1,
 		__isl_take isl_ast_expr *expr2);
+	__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(
+		__isl_take isl_ast_expr *expr1,
+		__isl_take isl_ast_expr *expr2);
+	__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(
+		__isl_take isl_ast_expr *expr1,
+		__isl_take isl_ast_expr *expr2);
 	__isl_give isl_ast_expr *isl_ast_expr_and(
 		__isl_take isl_ast_expr *expr1,
 		__isl_take isl_ast_expr *expr2)
+	__isl_give isl_ast_expr *isl_ast_expr_and_then(
+		__isl_take isl_ast_expr *expr1,
+		__isl_take isl_ast_expr *expr2)
 	__isl_give isl_ast_expr *isl_ast_expr_or(
 		__isl_take isl_ast_expr *expr1,
 		__isl_take isl_ast_expr *expr2)
+	__isl_give isl_ast_expr *isl_ast_expr_or_else(
+		__isl_take isl_ast_expr *expr1,
+		__isl_take isl_ast_expr *expr2)
 	__isl_give isl_ast_expr *isl_ast_expr_eq(
 		__isl_take isl_ast_expr *expr1,
 		__isl_take isl_ast_expr *expr2);
@@ -6687,12 +11782,23 @@
 	__isl_give isl_ast_expr *isl_ast_expr_access(
 		__isl_take isl_ast_expr *array,
 		__isl_take isl_ast_expr_list *indices);
+	__isl_give isl_ast_expr *isl_ast_expr_call(
+		__isl_take isl_ast_expr *function,
+		__isl_take isl_ast_expr_list *arguments);
 
 The function C<isl_ast_expr_address_of> can be applied to an
-C<isl_ast_expr> of type C<isl_ast_op_access> only. It is meant
+C<isl_ast_expr> of type C<isl_ast_expr_op_access> only. It is meant
 to represent the address of the C<isl_ast_expr_access>.
+The second argument of the functions C<isl_ast_expr_pdiv_q> and
+C<isl_ast_expr_pdiv_r> should always evaluate to a positive number.
+The function
+C<isl_ast_expr_and_then> as well as C<isl_ast_expr_or_else> are short-circuit
+versions of C<isl_ast_expr_and> and C<isl_ast_expr_or>, respectively.
 
 	#include <isl/ast_build.h>
+	__isl_give isl_ast_expr *isl_ast_build_expr_from_set(
+		__isl_keep isl_ast_build *build,
+		__isl_take isl_set *set);
 	__isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
 		__isl_keep isl_ast_build *build,
 		__isl_take isl_pw_aff *pa);
@@ -6713,7 +11819,8 @@
 		__isl_keep isl_ast_build *build,
 		__isl_take isl_multi_pw_aff *mpa);
 
-The domains of C<pa>, C<mpa> and C<pma> should correspond
+The set C<set> and
+the domains of C<pa>, C<mpa> and C<pma> should correspond
 to the schedule space of C<build>.
 The tuple id of C<mpa> or C<pma> is used as the array being accessed or
 the function being called.
@@ -6760,12 +11867,42 @@
 	__isl_give isl_printer *isl_printer_print_ast_node(
 		__isl_take isl_printer *p,
 		__isl_keep isl_ast_node *node);
+	__isl_give char *isl_ast_expr_to_str(
+		__isl_keep isl_ast_expr *expr);
+	__isl_give char *isl_ast_node_to_str(
+		__isl_keep isl_ast_node *node);
+	__isl_give char *isl_ast_expr_to_C_str(
+		__isl_keep isl_ast_expr *expr);
+	__isl_give char *isl_ast_node_to_C_str(
+		__isl_keep isl_ast_node *node);
+
+The functions C<isl_ast_expr_to_C_str> and
+C<isl_ast_node_to_C_str> are convenience functions
+that return a string representation of the input in C format.
 
 More advanced printing can be performed using the following functions.
 
 	#include <isl/ast.h>
+	__isl_give isl_printer *
+	isl_ast_expr_op_type_set_print_name(
+		__isl_take isl_printer *p,
+		enum isl_ast_expr_op_type type,
+		__isl_keep const char *name);
+	__isl_give isl_printer *isl_ast_op_type_set_print_name(
+		__isl_take isl_printer *p,
+		enum isl_ast_expr_op_type type,
+		__isl_keep const char *name);
+	isl_stat isl_options_set_ast_print_macro_once(
+		isl_ctx *ctx, int val);
+	int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
+	__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
+		enum isl_ast_expr_op_type type,
+		__isl_take isl_printer *p);
 	__isl_give isl_printer *isl_ast_op_type_print_macro(
-		enum isl_ast_op_type type,
+		enum isl_ast_expr_op_type type,
+		__isl_take isl_printer *p);
+	__isl_give isl_printer *isl_ast_expr_print_macros(
+		__isl_keep isl_ast_expr *expr,
 		__isl_take isl_printer *p);
 	__isl_give isl_printer *isl_ast_node_print_macros(
 		__isl_keep isl_ast_node *node,
@@ -6786,14 +11923,26 @@
 While printing an C<isl_ast_node> in C<ISL_FORMAT_C>,
 C<isl> may print out an AST that makes use of macros such
 as C<floord>, C<min> and C<max>.
-C<isl_ast_op_type_print_macro> prints out the macro
-corresponding to a specific C<isl_ast_op_type>.
-C<isl_ast_node_print_macros> scans the C<isl_ast_node>
-for expressions where these macros would be used and prints
+The names of these macros may be modified by a call
+to C<isl_ast_expr_op_type_set_print_name>.  The user-specified
+names are associated to the printer object.
+C<isl_ast_op_type_set_print_name> is an alternative name for
+C<isl_ast_expr_op_type_set_print_name>.
+C<isl_ast_expr_op_type_print_macro> prints out the macro
+corresponding to a specific C<isl_ast_expr_op_type>.
+If the print-macro-once option is set, then a given macro definition
+is only printed once to any given printer object.
+C<isl_ast_op_type_print_macro> is an alternative name for
+C<isl_ast_expr_op_type_print_macro>.
+C<isl_ast_expr_print_macros> scans the C<isl_ast_expr>
+for subexpressions where these macros would be used and prints
 out the required macro definitions.
-Essentially, C<isl_ast_node_print_macros> calls
-C<isl_ast_node_foreach_ast_op_type> with C<isl_ast_op_type_print_macro>
+Essentially, C<isl_ast_expr_print_macros> calls
+C<isl_ast_expr_foreach_ast_expr_op_type> with
+C<isl_ast_expr_op_type_print_macro>
 as function argument.
+C<isl_ast_node_print_macros> does the same
+for expressions in its C<isl_ast_node> argument.
 C<isl_ast_node_print>, C<isl_ast_node_for_print> and
 C<isl_ast_node_if_print> print an C<isl_ast_node>
 in C<ISL_FORMAT_C>, but allow for some extra control
@@ -6843,47 +11992,65 @@
 The following option determines the type to be used for iterators
 while printing the AST.
 
-	int isl_options_set_ast_iterator_type(
+	isl_stat isl_options_set_ast_iterator_type(
 		isl_ctx *ctx, const char *val);
 	const char *isl_options_get_ast_iterator_type(
 		isl_ctx *ctx);
 
-The AST printer only prints body nodes as blocks if these
+The AST printer only prints body nodes of C<if> and C<for> nodes
+as blocks if these
 blocks cannot be safely omitted.
 For example, a C<for> node with one body node will not be
 surrounded with braces in C<ISL_FORMAT_C>.
 A block will always be printed by setting the following option.
 
-	int isl_options_set_ast_always_print_block(isl_ctx *ctx,
+	isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx,
 		int val);
 	int isl_options_get_ast_always_print_block(isl_ctx *ctx);
 
+Explicit block nodes that appear inside the AST are always printed as blocks.
+If the block node appears as the outermost node,
+then it is only printed if the following option is set.
+
+	isl_stat isl_options_set_ast_print_outermost_block(
+		isl_ctx *ctx, int val);
+	int isl_options_get_ast_print_outermost_block(
+		isl_ctx *ctx);
+
 =head3 Options
 
 	#include <isl/ast_build.h>
-	int isl_options_set_ast_build_atomic_upper_bound(
+	isl_stat isl_options_set_ast_build_atomic_upper_bound(
 		isl_ctx *ctx, int val);
 	int isl_options_get_ast_build_atomic_upper_bound(
 		isl_ctx *ctx);
-	int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
+	isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx,
 		int val);
 	int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
-	int isl_options_set_ast_build_exploit_nested_bounds(
+	isl_stat isl_options_set_ast_build_detect_min_max(
+		isl_ctx *ctx, int val);
+	int isl_options_get_ast_build_detect_min_max(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_ast_build_exploit_nested_bounds(
 		isl_ctx *ctx, int val);
 	int isl_options_get_ast_build_exploit_nested_bounds(
 		isl_ctx *ctx);
-	int isl_options_set_ast_build_group_coscheduled(
+	isl_stat isl_options_set_ast_build_group_coscheduled(
 		isl_ctx *ctx, int val);
 	int isl_options_get_ast_build_group_coscheduled(
 		isl_ctx *ctx);
-	int isl_options_set_ast_build_scale_strides(
+	isl_stat isl_options_set_ast_build_separation_bounds(
+		isl_ctx *ctx, int val);
+	int isl_options_get_ast_build_separation_bounds(
+		isl_ctx *ctx);
+	isl_stat isl_options_set_ast_build_scale_strides(
 		isl_ctx *ctx, int val);
 	int isl_options_get_ast_build_scale_strides(
 		isl_ctx *ctx);
-	int isl_options_set_ast_build_allow_else(isl_ctx *ctx,
+	isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx,
 		int val);
 	int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
-	int isl_options_set_ast_build_allow_or(isl_ctx *ctx,
+	isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx,
 		int val);
 	int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
 
@@ -6913,12 +12080,18 @@
 =item * ast_build_prefer_pdiv
 
 If this option is turned off, then the AST generation will
-produce ASTs that may only contain C<isl_ast_op_fdiv_q>
-operators, but no C<isl_ast_op_pdiv_q> or
-C<isl_ast_op_pdiv_r> operators.
-If this options is turned on, then C<isl> will try to convert
-some of the C<isl_ast_op_fdiv_q> operators to (expressions containing)
-C<isl_ast_op_pdiv_q> or C<isl_ast_op_pdiv_r> operators.
+produce ASTs that may only contain C<isl_ast_expr_op_fdiv_q>
+operators, but no C<isl_ast_expr_op_pdiv_q> or
+C<isl_ast_expr_op_pdiv_r> operators.
+If this option is turned on, then C<isl> will try to convert
+some of the C<isl_ast_expr_op_fdiv_q> operators to (expressions containing)
+C<isl_ast_expr_op_pdiv_q> or C<isl_ast_expr_op_pdiv_r> operators.
+
+=item * ast_build_detect_min_max
+
+If this option is turned on, then C<isl> will try and detect
+min or max-expressions when building AST expressions from
+piecewise affine expressions.
 
 =item * ast_build_exploit_nested_bounds
 
@@ -6991,23 +12164,235 @@
 
 =back
 
-=head3 Fine-grained Control over AST Generation
+=head3 AST Generation Options (Schedule Tree)
 
-Besides specifying the constraints on the parameters,
-an C<isl_ast_build> object can be used to control
-various aspects of the AST generation process.
-The most prominent way of control is through ``options'',
-which can be set using the following function.
+In case of AST construction from a schedule tree, the options
+that control how an AST is created from the individual schedule
+dimensions are stored in the band nodes of the tree
+(see L</"Schedule Trees">).
+
+In particular, a schedule dimension can be handled in four
+different ways, atomic, separate, unroll or the default.
+This loop AST generation type can be set using
+C<isl_schedule_node_band_member_set_ast_loop_type>.
+Alternatively,
+the first three can be selected by including a one-dimensional
+element with as value the position of the schedule dimension
+within the band and as name one of C<atomic>, C<separate>
+or C<unroll> in the options
+set by C<isl_schedule_node_band_set_ast_build_options>.
+Only one of these three may be specified for
+any given schedule dimension within a band node.
+If none of these is specified, then the default
+is used.  The meaning of the options is as follows.
+
+=over
+
+=item C<atomic>
+
+When this option is specified, the AST generator will make
+sure that a given domain space only appears in a single
+loop at the specified level.
+
+For example, for the schedule tree
+
+	domain: "{ ai : 0 <= i < 10; bi : 0 <= i < 10 }"
+	child:
+	  schedule: "{ ai -> i; bi -> i+1 }"
+	  options: "{ atomicx }"
+
+the following AST will be generated
+
+	for (int c0 = 0; c0 <= 10; c0 += 1) {
+	  if (c0 >= 1)
+	    b(c0 - 1);
+	  if (c0 <= 9)
+	    a(c0);
+	}
+
+On the other hand, for the schedule tree
+
+	domain: "{ ai : 0 <= i < 10; bi : 0 <= i < 10 }"
+	child:
+	  schedule: "{ ai -> i; bi -> i+1 }"
+	  options: "{ separatex }"
+
+the following AST will be generated
+
+	{
+	  a(0);
+	  for (int c0 = 1; c0 <= 9; c0 += 1) {
+	    b(c0 - 1);
+	    a(c0);
+	  }
+	  b(9);
+	}
+
+If neither C<atomic> nor C<separate> is specified, then the AST generator
+may produce either of these two results or some intermediate form.
+
+=item C<separate>
+
+When this option is specified, the AST generator will
+split the domain of the specified schedule dimension
+into pieces with a fixed set of statements for which
+instances need to be executed by the iterations in
+the schedule domain part.  This option tends to avoid
+the generation of guards inside the corresponding loops.
+See also the C<atomic> option.
+
+=item C<unroll>
+
+When this option is specified, the AST generator will
+I<completely> unroll the corresponding schedule dimension.
+It is the responsibility of the user to ensure that such
+unrolling is possible.
+To obtain a partial unrolling, the user should apply an additional
+strip-mining to the schedule and fully unroll the inner schedule
+dimension.
+
+=back
+
+The C<isolate> option is a bit more involved.  It allows the user
+to isolate a range of schedule dimension values from smaller and
+greater values.  Additionally, the user may specify a different
+atomic/separate/unroll choice for the isolated part and the remaining
+parts.  The typical use case of the C<isolate> option is to isolate
+full tiles from partial tiles.
+The part that needs to be isolated may depend on outer schedule dimensions.
+The option therefore needs to be able to reference those outer schedule
+dimensions.  In particular, the space of the C<isolate> option is that
+of a wrapped map with as domain the flat product of all outer band nodes
+and as range the space of the current band node.
+The atomic/separate/unroll choice for the isolated part is determined
+by an option that lives in an unnamed wrapped space with as domain
+a zero-dimensional C<isolate> space and as range the regular
+C<atomic>, C<separate> or C<unroll> space.
+This option may also be set directly using
+C<isl_schedule_node_band_member_set_isolate_ast_loop_type>.
+The atomic/separate/unroll choice for the remaining part is determined
+by the regular C<atomic>, C<separate> or C<unroll> option.
+Since the C<isolate> option references outer schedule dimensions,
+its use in a band node causes any tree containing the node
+to be considered anchored.
+
+As an example, consider the isolation of full tiles from partial tiles
+in a tiling of a triangular domain.  The original schedule is as follows.
+
+	domain: "{ Ai,j : 0 <= i,j and i + j <= 100 }"
+	child:
+	  schedule: "{ Ai,j -> floor(i/10) }, \
+		{ Ai,j -> floor(j/10) }, \
+		{ Ai,j -> i }, { Ai,j -> j }"
+
+The output is
+
+	for (int c0 = 0; c0 <= 10; c0 += 1)
+	  for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
+	    for (int c2 = 10 * c0;
+                 c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+	      for (int c3 = 10 * c1;
+                   c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+		A(c2, c3);
+
+Isolating the full tiles, we have the following input
+
+	domain: "{ Ai,j : 0 <= i,j and i + j <= 100 }"
+	child:
+	  schedule: "{ Ai,j -> floor(i/10) }, \
+		{ Ai,j -> floor(j/10) }, \
+		{ Ai,j -> i }, { Ai,j -> j }"
+	  options: "{ isolate -> a,b,c,d : 0 <= 10a,10b and \
+		10a+9+10b+9 <= 100 }"
+
+and output
+
+	{
+	  for (int c0 = 0; c0 <= 8; c0 += 1) {
+	    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
+	      for (int c2 = 10 * c0;
+		   c2 <= 10 * c0 + 9; c2 += 1)
+		for (int c3 = 10 * c1;
+		     c3 <= 10 * c1 + 9; c3 += 1)
+		  A(c2, c3);
+	    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
+	      for (int c2 = 10 * c0;
+                   c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+		for (int c3 = 10 * c1;
+                     c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+		  A(c2, c3);
+	  }
+	  for (int c0 = 9; c0 <= 10; c0 += 1)
+	    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
+	      for (int c2 = 10 * c0;
+                   c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+		for (int c3 = 10 * c1;
+                     c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+		  A(c2, c3);
+	}
+
+We may then additionally unroll the innermost loop of the isolated part
+
+	domain: "{ Ai,j : 0 <= i,j and i + j <= 100 }"
+	child:
+	  schedule: "{ Ai,j -> floor(i/10) }, \
+		{ Ai,j -> floor(j/10) }, \
+		{ Ai,j -> i }, { Ai,j -> j }"
+	  options: "{ isolate -> a,b,c,d : 0 <= 10a,10b and \
+		10a+9+10b+9 <= 100; isolate -> unroll3 }"
+
+to obtain
+
+	{
+	  for (int c0 = 0; c0 <= 8; c0 += 1) {
+	    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
+	      for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1) {
+		A(c2, 10 * c1);
+		A(c2, 10 * c1 + 1);
+		A(c2, 10 * c1 + 2);
+		A(c2, 10 * c1 + 3);
+		A(c2, 10 * c1 + 4);
+		A(c2, 10 * c1 + 5);
+		A(c2, 10 * c1 + 6);
+		A(c2, 10 * c1 + 7);
+		A(c2, 10 * c1 + 8);
+		A(c2, 10 * c1 + 9);
+	      }
+	    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
+	      for (int c2 = 10 * c0;
+                   c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+		for (int c3 = 10 * c1;
+		     c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+		  A(c2, c3);
+	  }
+	  for (int c0 = 9; c0 <= 10; c0 += 1)
+	    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
+	      for (int c2 = 10 * c0;
+		   c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+		for (int c3 = 10 * c1;
+		     c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+		  A(c2, c3);
+	}
+
+
+=head3 AST Generation Options (Schedule Map)
+
+In case of AST construction using
+C<isl_ast_build_node_from_schedule_map>, the options
+that control how an AST is created from the individual schedule
+dimensions are stored in the C<isl_ast_build>.
+They can be set using the following function.
 
 	#include <isl/ast_build.h>
 	__isl_give isl_ast_build *
 	isl_ast_build_set_options(
-		__isl_take isl_ast_build *control,
+		__isl_take isl_ast_build *build,
 		__isl_take isl_union_map *options);
 
 The options are encoded in an C<isl_union_map>.
 The domain of this union relation refers to the schedule domain,
-i.e., the range of the schedule passed to C<isl_ast_build_ast_from_schedule>.
+i.e., the range of the schedule passed
+to C<isl_ast_build_node_from_schedule_map>.
 In the case of nested AST generation (see L</"Nested AST Generation">),
 the domain of C<options> should refer to the extra piece of the schedule.
 That is, it should be equal to the range of the wrapped relation in the
@@ -7015,7 +12400,8 @@
 The range of the options can consist of elements in one or more spaces,
 the names of which determine the effect of the option.
 The values of the range typically also refer to the schedule dimension
-to which the option applies.  In case of nested AST generation
+to which the option applies, with value C<0> representing
+the outermost schedule dimension.  In case of nested AST generation
 (see L</"Nested AST Generation">), these values refer to the position
 of the schedule dimension within the innermost AST generation.
 The constraints on the domain elements of
@@ -7026,6 +12412,9 @@
 
 =item C<separation_class>
 
+B<This option has been deprecated.  Use the isolate option on
+schedule trees instead.>
+
 This space is a wrapped relation between two one dimensional spaces.
 The input space represents the schedule dimension to which the option
 applies and the output space represents the separation class.
@@ -7173,12 +12562,22 @@
 
 =back
 
+=head3 Fine-grained Control over AST Generation
+
+Besides specifying the constraints on the parameters,
+an C<isl_ast_build> object can be used to control
+various aspects of the AST generation process.
+In case of AST construction using
+C<isl_ast_build_node_from_schedule_map>,
+the most prominent way of control is through ``options'',
+as explained above.
+
 Additional control is available through the following functions.
 
 	#include <isl/ast_build.h>
 	__isl_give isl_ast_build *
 	isl_ast_build_set_iterators(
-		__isl_take isl_ast_build *control,
+		__isl_take isl_ast_build *build,
 		__isl_take isl_id_list *iterators);
 
 The function C<isl_ast_build_set_iterators> allows the user to
@@ -7196,7 +12595,7 @@
 	#include <isl/ast_build.h>
 	__isl_give isl_ast_build *
 	isl_ast_build_set_create_leaf(
-		__isl_take isl_ast_build *control,
+		__isl_take isl_ast_build *build,
 		__isl_give isl_ast_node *(*fn)(
 			__isl_take isl_ast_build *build,
 			void *user), void *user);
@@ -7244,6 +12643,19 @@
 			__isl_take isl_ast_node *node,
 			__isl_keep isl_ast_build *build,
 			void *user), void *user);
+	__isl_give isl_ast_build *
+	isl_ast_build_set_before_each_mark(
+		__isl_take isl_ast_build *build,
+		isl_stat (*fn)(__isl_keep isl_id *mark,
+			__isl_keep isl_ast_build *build,
+			void *user), void *user);
+	__isl_give isl_ast_build *
+	isl_ast_build_set_after_each_mark(
+		__isl_take isl_ast_build *build,
+		__isl_give isl_ast_node *(*fn)(
+			__isl_take isl_ast_node *node,
+			__isl_keep isl_ast_build *build,
+			void *user), void *user);
 
 The callback set by C<isl_ast_build_set_at_each_domain> will
 be called for each domain AST node.
@@ -7258,7 +12670,15 @@
 In particular, if the user has also specified an C<after_each_for>
 callback, then the annotation can be retrieved from the node passed to
 that callback using C<isl_ast_node_get_annotation>.
-All callbacks should C<NULL> on failure.
+The callbacks set by C<isl_ast_build_set_before_each_mark>
+and C<isl_ast_build_set_after_each_mark> will be called for each
+mark AST node that is created, i.e., for each mark schedule node
+in the input schedule tree.  The first will be called in depth-first
+pre-order, while the second will be called in depth-first post-order.
+Since the callback set by C<isl_ast_build_set_before_each_mark>
+is called before the mark AST node is actually constructed, it is passed
+the identifier of the mark node.
+All callbacks should C<NULL> (or C<isl_stat_error>) on failure.
 The given C<isl_ast_build> can be used to create new
 C<isl_ast_expr> objects using C<isl_ast_build_expr_from_pw_aff>
 or C<isl_ast_build_call_from_pw_multi_aff>.
@@ -7267,8 +12687,8 @@
 
 C<isl> allows the user to create an AST within the context
 of another AST.  These nested ASTs are created using the
-same C<isl_ast_build_ast_from_schedule> function that is used to create the
-outer AST.  The C<build> argument should be an C<isl_ast_build>
+same C<isl_ast_build_node_from_schedule_map> function that is used to create
+the outer AST.  The C<build> argument should be an C<isl_ast_build>
 passed to a callback set by
 C<isl_ast_build_set_create_leaf>.
 The space of the range of the C<schedule> argument should refer
@@ -7315,7 +12735,8 @@
 Although C<isl> is mainly meant to be used as a library,
 it also contains some basic applications that use some
 of the functionality of C<isl>.
-The input may be specified in either the L<isl format>
+For applications that take one or more polytopes or polyhedra
+as input, this input may be specified in either the L<isl format>
 or the L<PolyLib format>.
 
 =head2 C<isl_polyhedron_sample>
@@ -7350,9 +12771,22 @@
 Given a polytope, C<isl_polytope_scan> prints
 all integer points in the polytope.
 
+=head2 C<isl_flow>
+
+Given an C<isl_union_access_info> object as input,
+C<isl_flow> prints out the corresponding dependences,
+as computed by C<isl_union_access_info_compute_flow>.
+
 =head2 C<isl_codegen>
 
-Given a schedule, a context set and an options relation,
+Given either a schedule tree or a sequence consisting of
+a schedule map, a context set and an options relation,
 C<isl_codegen> prints out an AST that scans the domain elements
 of the schedule in the order of their image(s) taking into account
 the constraints in the context set.
+
+=head2 C<isl_schedule>
+
+Given an C<isl_schedule_constraints> object as input,
+C<isl_schedule> prints out a schedule that satisfies the given
+constraints.

_service:tar_scm:isl-0.24.tar.gz/extract_key.c Added

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <string.h>
+
+/* Extract a mapping key from the token "tok".
+ * Return KEY_ERROR on error, i.e., if "tok" does not
+ * correspond to any known key.
+ */
+static KEY extract_key(__isl_keep isl_stream *s, struct isl_token *tok)
+{
+	int type;
+	char *name;
+	KEY key;
+	isl_ctx *ctx;
+
+	if (!tok)
+		return KEY_ERROR;
+	type = isl_token_get_type(tok);
+	if (type != ISL_TOKEN_IDENT && type != ISL_TOKEN_STRING) {
+		isl_stream_error(s, tok, "expecting key");
+		return KEY_ERROR;
+	}
+
+	ctx = isl_stream_get_ctx(s);
+	name = isl_token_get_str(ctx, tok);
+	if (!name)
+		return KEY_ERROR;
+
+	for (key = 0; key < KEY_END; ++key) {
+		if (!strcmp(name, key_strkey))
+			break;
+	}
+	free(name);
+
+	if (key >= KEY_END)
+		isl_die(ctx, isl_error_invalid, "unknown key",
+			return KEY_ERROR);
+	return key;
+}
+
+/* Read a key from "s" and return the corresponding enum.
+ * Return KEY_ERROR on error, i.e., if the first token
+ * on the stream does not correspond to any known key.
+ */
+static KEY get_key(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	KEY key;
+
+	tok = isl_stream_next_token(s);
+	key = extract_key(s, tok);
+	isl_token_free(tok);
+
+	return key;
+}

_service:tar_scm:isl-0.24.tar.gz/flow.c Added

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* This program takes an isl_union_access_info object as input and
+ * prints the corresponding dependences.
+ */
+
+#include <isl/options.h>
+#include <isl/printer.h>
+#include <isl/union_map.h>
+#include <isl/flow.h>
+#include <isl/schedule.h>
+
+int main(int argc, char **argv)
+{
+	isl_ctx *ctx;
+	isl_printer *p;
+	isl_union_access_info *access;
+	isl_union_flow *flow;
+	struct isl_options *options;
+
+	options = isl_options_new_with_defaults();
+	argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
+	ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
+
+	access = isl_union_access_info_read_from_file(ctx, stdin);
+	flow = isl_union_access_info_compute_flow(access);
+
+	p = isl_printer_to_file(ctx, stdout);
+	p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
+	p = isl_printer_print_union_flow(p, flow);
+	isl_printer_free(p);
+
+	isl_union_flow_free(flow);
+
+	isl_ctx_free(ctx);
+
+	return 0;
+}

_service:tar_scm:isl-0.24.tar.gz/flow_cmp.c Added

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <stdlib.h>
+
+#include <isl/arg.h>
+#include <isl/options.h>
+#include <isl/union_map.h>
+#include <isl/stream.h>
+
+struct options {
+	struct isl_options *isl;
+	char *flow1;
+	char *flow2;
+};
+
+ISL_ARGS_START(struct options, options_args)
+ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
+ISL_ARG_ARG(struct options, flow1, "flow1", NULL)
+ISL_ARG_ARG(struct options, flow2, "flow2", NULL)
+ISL_ARGS_END
+
+ISL_ARG_DEF(options, struct options, options_args)
+
+static void die(const char *msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(EXIT_FAILURE);
+}
+
+static FILE *open_or_die(const char *filename)
+{
+	FILE *file;
+
+	file = fopen(filename, "r");
+	if (!file) {
+		fprintf(stderr, "Unable to open %s\n", filename);
+		exit(EXIT_FAILURE);
+	}
+	return file;
+}
+
+#undef BASE
+#define BASE union_map
+#include "read_in_string_templ.c"
+
+/* Given two YAML descriptions of isl_union_flow objects, check whether
+ * they are equivalent.
+ * Return EXIT_SUCCESS if they are and EXIT_FAILURE if they are not
+ * or if anything else went wrong.
+ *
+ * The descriptions are checked field by field, meaning that the fields
+ * are expected to appear in the same order in both inputs.
+ */
+int main(int argc, char **argv)
+{
+	int more;
+	isl_ctx *ctx;
+	struct options *options;
+	FILE *input1, *input2;
+	isl_stream *s1, *s2;
+
+	options = options_new_with_defaults();
+	if (!options)
+		return EXIT_FAILURE;
+
+	ctx = isl_ctx_alloc_with_options(&options_args, options);
+	argc = options_parse(options, argc, argv, ISL_ARG_ALL);
+
+	input1 = open_or_die(options->flow1);
+	input2 = open_or_die(options->flow2);
+	s1 = isl_stream_new_file(ctx, input1);
+	s2 = isl_stream_new_file(ctx, input2);
+
+	if (isl_stream_yaml_read_start_mapping(s1))
+		isl_die(ctx, isl_error_unknown, "arg1 not a YAML mapping",
+			return EXIT_FAILURE);
+	if (isl_stream_yaml_read_start_mapping(s2))
+		isl_die(ctx, isl_error_unknown, "arg2 not a YAML mapping",
+			return EXIT_FAILURE);
+
+	while ((more = isl_stream_yaml_next(s1)) > 0) {
+		int more2;
+		isl_bool equal;
+		isl_union_map *umap1, *umap2;
+
+		more2 = isl_stream_yaml_next(s2);
+		if (more2 < 0)
+			return EXIT_FAILURE;
+		if (!more2)
+			isl_die(ctx, isl_error_unknown, "arg2 shorter",
+				return EXIT_FAILURE);
+		if (isl_stream_eat(s1, ISL_TOKEN_IDENT) < 0)
+			return EXIT_FAILURE;
+		if (isl_stream_eat(s2, ISL_TOKEN_IDENT) < 0)
+			return EXIT_FAILURE;
+		more = isl_stream_yaml_next(s1);
+		more2 = isl_stream_yaml_next(s2);
+		if (more < 0 || more2 < 0)
+			return EXIT_FAILURE;
+		if (!more || !more2)
+			isl_die(ctx, isl_error_unknown, "missing value",
+				return EXIT_FAILURE);
+
+		umap1 = read_union_map(s1);
+		umap2 = read_union_map(s2);
+		equal = isl_union_map_is_equal(umap1, umap2);
+		isl_union_map_free(umap1);
+		isl_union_map_free(umap2);
+		if (equal < 0)
+			return EXIT_FAILURE;
+		if (!equal)
+			die("field not equal");
+	}
+	if (more < 0)
+		return EXIT_FAILURE;
+
+
+	if (isl_stream_yaml_read_end_mapping(s1) < 0) {
+		isl_stream_error(s1, NULL, "unexpected extra elements");
+		return EXIT_FAILURE;
+	}
+	if (isl_stream_yaml_read_end_mapping(s2) < 0) {
+		isl_stream_error(s2, NULL, "unexpected extra elements");
+		return EXIT_FAILURE;
+	}
+
+	isl_stream_free(s1);
+	isl_stream_free(s2);
+	fclose(input1);
+	fclose(input2);
+	isl_ctx_free(ctx);
+
+	return EXIT_SUCCESS;
+}

_service:tar_scm:isl-0.24.tar.gz/flow_test.sh.in Added

_service:tar_scm:isl-0.24.tar.gz/has_single_reference_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/imath/gmp_compat.c -> _service:tar_scm:isl-0.24.tar.gz/imath/gmp_compat.c Changed

@@ -24,51 +24,55 @@
   SOFTWARE.
  */
 #include "gmp_compat.h"
-#include <stdlib.h>
 #include <assert.h>
 #include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
 #include <string.h>
 
-#ifdef  NDEBUG
+#if defined(_MSC_VER)
+#include <BaseTsd.h>
+typedef SSIZE_T ssize_t;
+#else
+#include <sys/types.h>
+#endif
+
+#ifdef NDEBUG
 #define CHECK(res) (res)
 #else
 #define CHECK(res) assert(((res) == MP_OK) && "expected MP_OK")
 #endif
 
+/* *(signed char *)&endian_test will thus either be:
+ *     0b00000001 =  1 on big-endian
+ *     0b11111111 = -1 on little-endian */
+static const uint16_t endian_test = 0x1FF;
+#define HOST_ENDIAN (*(signed char *)&endian_test)
+
 /*************************************************************************
  *
  * Functions with direct translations
  *
  *************************************************************************/
 /* gmp: mpq_clear */
-void GMPQAPI(clear)(mp_rat x) {
-  mp_rat_clear(x);
-}
+void GMPQAPI(clear)(mp_rat x) { mp_rat_clear(x); }
 
 /* gmp: mpq_cmp */
-int GMPQAPI(cmp)(mp_rat op1, mp_rat op2) {
-  return mp_rat_compare(op1, op2);
-}
+int GMPQAPI(cmp)(mp_rat op1, mp_rat op2) { return mp_rat_compare(op1, op2); }
 
 /* gmp: mpq_init */
-void GMPQAPI(init)(mp_rat x) {
-  CHECK(mp_rat_init(x));
-}
+void GMPQAPI(init)(mp_rat x) { CHECK(mp_rat_init(x)); }
 
 /* gmp: mpq_mul */
 void GMPQAPI(mul)(mp_rat product, mp_rat multiplier, mp_rat multiplicand) {
   CHECK(mp_rat_mul(multiplier, multiplicand, product));
 }
 
-/* gmp: mpq_set*/
-void GMPQAPI(set)(mp_rat rop, mp_rat op) {
-  CHECK(mp_rat_copy(op, rop));
-}
+/* gmp: mpq_set */
+void GMPQAPI(set)(mp_rat rop, mp_rat op) { CHECK(mp_rat_copy(op, rop)); }
 
 /* gmp: mpz_abs */
-void GMPZAPI(abs)(mp_int rop, mp_int op) {
-  CHECK(mp_int_abs(op, rop));
-}
+void GMPZAPI(abs)(mp_int rop, mp_int op) { CHECK(mp_int_abs(op, rop)); }
 
 /* gmp: mpz_add */
 void GMPZAPI(add)(mp_int rop, mp_int op1, mp_int op2) {
@@ -76,9 +80,7 @@
 }
 
 /* gmp: mpz_clear */
-void GMPZAPI(clear)(mp_int x) {
-  mp_int_clear(x);
-}
+void GMPZAPI(clear)(mp_int x) { mp_int_clear(x); }
 
 /* gmp: mpz_cmp_si */
 int GMPZAPI(cmp_si)(mp_int op1, long op2) {
@@ -91,14 +93,10 @@
 }
 
 /* gmp: mpz_cmp */
-int GMPZAPI(cmp)(mp_int op1, mp_int op2) {
-  return mp_int_compare(op1, op2);
-}
+int GMPZAPI(cmp)(mp_int op1, mp_int op2) { return mp_int_compare(op1, op2); }
 
 /* gmp: mpz_init */
-void GMPZAPI(init)(mp_int x) {
-  CHECK(mp_int_init(x));
-}
+void GMPZAPI(init)(mp_int x) { CHECK(mp_int_init(x)); }
 
 /* gmp: mpz_mul */
 void GMPZAPI(mul)(mp_int rop, mp_int op1, mp_int op2) {
@@ -106,19 +104,13 @@
 }
 
 /* gmp: mpz_neg */
-void GMPZAPI(neg)(mp_int rop, mp_int op) {
-  CHECK(mp_int_neg(op, rop));
-}
+void GMPZAPI(neg)(mp_int rop, mp_int op) { CHECK(mp_int_neg(op, rop)); }
 
 /* gmp: mpz_set_si */
-void GMPZAPI(set_si)(mp_int rop, long op) {
-  CHECK(mp_int_set_value(rop, op));
-}
+void GMPZAPI(set_si)(mp_int rop, long op) { CHECK(mp_int_set_value(rop, op)); }
 
 /* gmp: mpz_set */
-void GMPZAPI(set)(mp_int rop, mp_int op) {
-  CHECK(mp_int_copy(op, rop));
-}
+void GMPZAPI(set)(mp_int rop, mp_int op) { CHECK(mp_int_copy(op, rop)); }
 
 /* gmp: mpz_sub */
 void GMPZAPI(sub)(mp_int rop, mp_int op1, mp_int op2) {
@@ -126,19 +118,13 @@
 }
 
 /* gmp: mpz_swap */
-void GMPZAPI(swap)(mp_int rop1, mp_int rop2) {
-  mp_int_swap(rop1, rop2);
-}
+void GMPZAPI(swap)(mp_int rop1, mp_int rop2) { mp_int_swap(rop1, rop2); }
 
 /* gmp: mpq_sgn */
-int GMPQAPI(sgn)(mp_rat op) {
-  return mp_rat_compare_zero(op);
-}
+int GMPQAPI(sgn)(mp_rat op) { return mp_rat_compare_zero(op); }
 
 /* gmp: mpz_sgn */
-int GMPZAPI(sgn)(mp_int op) {
-  return mp_int_compare_zero(op);
-}
+int GMPZAPI(sgn)(mp_int op) { return mp_int_compare_zero(op); }
 
 /* gmp: mpq_set_ui */
 void GMPQAPI(set_ui)(mp_rat rop, unsigned long op1, unsigned long op2) {
@@ -151,25 +137,18 @@
 }
 
 /* gmp: mpq_den_ref */
-mp_int GMPQAPI(denref)(mp_rat op) {
-  return mp_rat_denom_ref(op);
-}
+mp_int GMPQAPI(denref)(mp_rat op) { return mp_rat_denom_ref(op); }
 
 /* gmp: mpq_num_ref */
-mp_int GMPQAPI(numref)(mp_rat op) {
-  return mp_rat_numer_ref(op);
-}
+mp_int GMPQAPI(numref)(mp_rat op) { return mp_rat_numer_ref(op); }
 
 /* gmp: mpq_canonicalize */
-void GMPQAPI(canonicalize)(mp_rat op) {
-  CHECK(mp_rat_reduce(op));
-}
+void GMPQAPI(canonicalize)(mp_rat op) { CHECK(mp_rat_reduce(op)); }
 
-/*************************************************************************
- *
+/*
  * Functions that can be implemented as a combination of imath functions
- *
- *************************************************************************/
+ */
+
 /* gmp: mpz_addmul */
 /* gmp: rop = rop + (op1 * op2) */
 void GMPZAPI(addmul)(mp_int rop, mp_int op1, mp_int op2) {
@@ -190,18 +169,17 @@
 
 /* gmp: mpz_divisible_p */
 /* gmp: return 1 if d divides n, 0 otherwise */
-/* gmp: 0 is considered to divide 0*/
+/* gmp: 0 is considered to divide only 0 */
 int GMPZAPI(divisible_p)(mp_int n, mp_int d) {
   /* variables to hold remainder */
   mpz_t rz;
   mp_int r = &rz;
   int r_is_zero;
 
-  /* check for n = 0, d = 0 */
+  /* check for d = 0 */
   int n_is_zero = mp_int_compare_zero(n) == 0;
   int d_is_zero = mp_int_compare_zero(d) == 0;
-  if (n_is_zero && d_is_zero)
-    return 1;
+  if (d_is_zero) return n_is_zero;
 
   /* return true if remainder is 0 */
   CHECK(mp_int_init(r));
@@ -308,13 +286,12 @@
 }
 
 /* gmp: mpz_get_str */
-char* GMPZAPI(get_str)(char *str, int radix, mp_int op) {
+char *GMPZAPI(get_str)(char *str, int radix, mp_int op) {
   int i, r, len;
 
   /* Support negative radix like gmp */
   r = radix;
-  if (r < 0)
-    r = -r;
+  if (r < 0) r = -r;
 
   /* Compute the length of the string needed to hold the int */
   len = mp_int_string_len(op, r);
@@ -326,16 +303,18 @@
   CHECK(mp_int_to_string(op, r, str, len));
 
   /* Change case to match gmp */
-  for (i = 0; i < len; i++)
-    if (radix < 0)
+  for (i = 0; i < len - 1; i++) {
+    if (radix < 0) {
       stri = toupper(stri);
-    else
+    } else {
       stri = tolower(stri);
+    }
+  }
   return str;
 }
 
 /* gmp: mpq_get_str */
-char* GMPQAPI(get_str)(char *str, int radix, mp_rat op) {
+char *GMPQAPI(get_str)(char *str, int radix, mp_rat op) {
   int i, r, len;
 
   /* Only print numerator if it is a whole number */
@@ -344,8 +323,7 @@
 
   /* Support negative radix like gmp */
   r = radix;
-  if (r < 0)
-    r = -r;
+  if (r < 0) r = -r;
 
   /* Compute the length of the string needed to hold the int */
   len = mp_rat_string_len(op, r);
@@ -357,11 +335,13 @@
   CHECK(mp_rat_to_string(op, r, str, len));
 
   /* Change case to match gmp */
-  for (i = 0; i < len; i++)
-    if (radix < 0)
+  for (i = 0; i < len; i++) {
+    if (radix < 0) {
       stri = toupper(stri);
-    else
+    } else {
       stri = tolower(stri);
+    }
+  }
 
   return str;
 }
@@ -381,26 +361,27 @@
   int res = 0;
 
   /* Copy string to temporary storage so we can modify it below */
-  str = malloc(strlen(s)+1);
+  str = malloc(strlen(s) + 1);
   strcpy(str, s);
 
   /* Properly format the string as an int by terminating at the / */
   slash = strchr(str, '/');
-  if (slash)
-    *slash = '\0';
+  if (slash) *slash = '\0';
 
   /* Parse numerator */
   resN = mp_int_read_string(mp_rat_numer_ref(rop), base, str);
 
-  /* Parse denomenator if given or set to 1 if not */
-  if (slash)
-    resD = mp_int_read_string(mp_rat_denom_ref(rop), base, slash+1);
-  else
+  /* Parse denominator if given or set to 1 if not */
+  if (slash) {
+    resD = mp_int_read_string(mp_rat_denom_ref(rop), base, slash + 1);
+  } else {
     resD = mp_int_set_uvalue(mp_rat_denom_ref(rop), 1);
+  }
 
   /* Return failure if either parse failed */
-  if (resN != MP_OK || resD != MP_OK)
+  if (resN != MP_OK || resD != MP_OK) {
     res = -1;
+  }
 
   free(str);
   return res;
@@ -411,18 +392,24 @@
    * the least significant digits that will fit into the long.  Read the digits
    * into the long starting at the most significant digit that fits into a
    * long. The long is shifted over by MP_DIGIT_BIT before each digit is added.
-   * The shift is decomposed into two steps to follow the patten used in the
-   * rest of the imath library. The two step shift is used to accomedate
-   * architectures that don't deal well with 32-bit shifts. */
-  mp_size num_digits_in_long = sizeof(unsigned long) / sizeof(mp_digit);
+   *
+   * The shift is decomposed into two steps (following the pattern used in the
+   * rest of the imath library) to accommodate architectures that don't deal
+   * well with 32-bit shifts.
+   */
+  mp_size digits_to_copy =
+      (sizeof(unsigned long) + sizeof(mp_digit) - 1) / sizeof(mp_digit);
+  if (digits_to_copy > MP_USED(op)) {
+    digits_to_copy = MP_USED(op);
+  }
+
   mp_digit *digits = MP_DIGITS(op);
   unsigned long out = 0;
-  int i;
 
-  for (i = num_digits_in_long - 1; i >= 0; i--) {
-    out <<= (MP_DIGIT_BIT/2);
-    out <<= (MP_DIGIT_BIT/2);
-    out  |= digitsi;
+  for (int i = digits_to_copy - 1; i >= 0; i--) {
+    out <<= (MP_DIGIT_BIT / 2);
+    out <<= (MP_DIGIT_BIT / 2);
+    out |= digitsi;
   }
 
   return out;
@@ -434,14 +421,12 @@
 
   /* Try a standard conversion that fits into an unsigned long */
   mp_result res = mp_int_to_uint(op, &out);
-  if (res == MP_OK)
-    return out;
+  if (res == MP_OK) return out;
 
   /* Abort the try if we don't have a range error in the conversion.
    * The range error indicates that the value cannot fit into a long. */
   CHECK(res == MP_RANGE ? MP_OK : MP_RANGE);
-  if (res != MP_RANGE)
-    return 0;
+  if (res != MP_RANGE) return 0;
 
   return get_long_bits(op);
 }
@@ -454,14 +439,12 @@
 
   /* Try a standard conversion that fits into a long */
   mp_result res = mp_int_to_int(op, &out);
-  if (res == MP_OK)
-    return out;
+  if (res == MP_OK) return out;
 
   /* Abort the try if we don't have a range error in the conversion.
    * The range error indicates that the value cannot fit into a long. */
   CHECK(res == MP_RANGE ? MP_OK : MP_RANGE);
-  if (res != MP_RANGE)
-    return 0;
+  if (res != MP_RANGE) return 0;
 
   /* get least significant bits into an unsigned long */
   uout = get_long_bits(op);
@@ -471,10 +454,11 @@
   uout &= (~(1UL << long_msb));
 
   /* convert to negative if needed based on sign of op */
-  if (MP_SIGN(op) == MP_NEG)
+  if (MP_SIGN(op) == MP_NEG) {
     uout = 0 - uout;
+  }
 
-  out = (long) uout;
+  out = (long)uout;
   return out;
 }
 
@@ -501,11 +485,9 @@
     CHECK(mp_int_mul_pow2(op1, op2, rop));
 }
 
-/*************************************************************************
- *
+/*
  * Functions needing expanded functionality
- *
- *************************************************************************/
+ */
 /* NoteOverview of division implementation
 
     All division operations (N / D) compute q and r such that
@@ -566,9 +548,8 @@
     if (rsign != 0) { /* r != 0 */
       CHECK(mp_int_add_value(q, 1, q));
     }
-  }
-  else if (qsign == 0) { /* q == 0 */
-    if (rsign != 0) {    /* r != 0 */
+  } else if (qsign == 0) { /* q == 0 */
+    if (rsign != 0) {      /* r != 0 */
       if ((nsign > 0 && dsign > 0) || (nsign < 0 && dsign < 0)) {
         CHECK(mp_int_set_value(q, 1));
       }
@@ -598,9 +579,8 @@
     if (rsign != 0) { /* r != 0 */
       CHECK(mp_int_sub_value(q, 1, q));
     }
-  }
-  else if (qsign == 0) { /* q == 0 */
-    if (rsign != 0) {    /* r != 0 */
+  } else if (qsign == 0) { /* q == 0 */
+    if (rsign != 0) {      /* r != 0 */
       if ((nsign < 0 && dsign > 0) || (nsign > 0 && dsign < 0)) {
         CHECK(mp_int_set_value(q, -1));
       }
@@ -672,34 +652,32 @@
 }
 
 /* gmp: mpz_export */
-void* GMPZAPI(export)(void *rop, size_t *countp, int order, size_t size, int endian, size_t nails, mp_int op) {
-  int i;
-  int num_used_bytes;
+void *GMPZAPI(export)(void *rop, size_t *countp, int order, size_t size,
+                      int endian, size_t nails, mp_int op) {
+  size_t i, j;
+  size_t num_used_bytes;
   size_t num_words, num_missing_bytes;
-  unsigned char* dst;
-  unsigned char* src;
+  ssize_t word_offset;
+  unsigned char *dst;
+  mp_digit *src;
+  int src_bits;
 
   /* We do not have a complete implementation. Assert to ensure our
-   * restrictions are in place, We do not support big endian output, but do not
-   * check that native endian is little endian. */
-  assert(nails  == 0 && "Do not support non-full words");
-  assert((endian == 0 || endian == -1) && "Do not support big endian");
-
-  /* The gmp API requires that order must be -1 or 1.
-     Not sure how gmp behaves when order is not 1 or -1, so force all non-one
-     values to -1 for now. */
-  if (order != 1) order = -1;
+   * restrictions are in place.
+   */
+  assert(nails == 0 && "Do not support non-full words");
+  assert(endian == 1 || endian == 0 || endian == -1);
+  assert(order == 1 || order == -1);
 
   /* Test for zero */
   if (mp_int_compare_zero(op) == 0) {
-    if (countp)
-      *countp = 0;
+    if (countp) *countp = 0;
     return rop;
   }
 
   /* Calculate how many words we need */
-  num_used_bytes  = mp_int_unsigned_len(op);
-  num_words       = (num_used_bytes + (size-1)) / size; /* ceil division */
+  num_used_bytes = mp_int_unsigned_len(op);
+  num_words = (num_used_bytes + (size - 1)) / size; /* ceil division */
   assert(num_used_bytes > 0);
 
   /* Check to see if we will have missing bytes in the last word.
@@ -711,7 +689,7 @@
      pad the word with extra zeros. Otherwise, the missing bytes can be filled
      directly from the zeros in the last digit in the number.
    */
-  num_missing_bytes   = (size * num_words) - num_used_bytes;
+  num_missing_bytes = (size * num_words) - num_used_bytes;
   assert(num_missing_bytes < size);
 
   /* Allocate space for the result if needed */
@@ -719,71 +697,62 @@
     rop = malloc(num_words * size);
   }
 
+  if (endian == 0) {
+    endian = HOST_ENDIAN;
+  }
+
   /* Initialize dst and src pointers */
-  dst = (unsigned char *)rop;
-  src = (unsigned char *)MP_DIGITS(op);
-
-  /* Most significant word first */
-  if (order == 1) {
-    size_t words_written = 0;
-    src += (num_words-1) * size;
-
-    /* Handle write of first word specially */
-    for (i = 0; i < size - num_missing_bytes; i++)
-      dsti = srci;
-    for (; i < size; i++)
-      dsti = 0;
-    dst += size;
-    src -= size;
-    words_written++;
-
-    for (; words_written < num_words; words_written++) {
-      for (i = 0; i < size; i++)
-        dsti = srci;
-      dst += size;
-      src -= size;
+  dst = (unsigned char *)rop + (order >= 0 ? (num_words - 1) * size : 0) +
+        (endian >= 0 ? size - 1 : 0);
+  src = MP_DIGITS(op);
+  src_bits = MP_DIGIT_BIT;
+
+  word_offset = (endian >= 0 ? size : -size) + (order < 0 ? size : -size);
+
+  for (i = 0; i < num_words; i++) {
+    for (j = 0; j < size && i * size + j < num_used_bytes; j++) {
+      if (src_bits == 0) {
+        ++src;
+        src_bits = MP_DIGIT_BIT;
+      }
+      *dst = (*src >> (MP_DIGIT_BIT - src_bits)) & 0xFF;
+      src_bits -= 8;
+      dst -= endian;
     }
-  }
-  /* Least significant word first */
-  else {
-    size_t words_written = 0;
-    for (; words_written < num_words - 1; words_written++) {
-      for (i = 0; i < size; i++)
-        dsti = srci;
-      dst += size;
-      src += size;
+    for (; j < size; j++) {
+      *dst = 0;
+      dst -= endian;
     }
-
-    /* Handle write of last word specially */
-    for (i = 0; i < size - num_missing_bytes; i++)
-      dsti = srci;
-
-    for (; i < size; i++)
-      dsti = 0;
+    dst += word_offset;
   }
 
-  if (countp)
-    *countp = num_words;
+  if (countp) *countp = num_words;
   return rop;
 }
 
 /* gmp: mpz_import */
-void GMPZAPI(import)(mp_int rop, size_t count, int order, size_t size, int endian, size_t nails, const void* op) {
+void GMPZAPI(import)(mp_int rop, size_t count, int order, size_t size,
+                     int endian, size_t nails, const void *op) {
   mpz_t tmpz;
   mp_int tmp = &tmpz;
   size_t total_size;
   size_t num_digits;
-  const char *src;
-  char *dst;
-  int i;
-  if (count == 0 || op == NULL)
-    return;
+  ssize_t word_offset;
+  const unsigned char *src;
+  mp_digit *dst;
+  int dst_bits;
+  size_t i, j;
+  if (count == 0 || op == NULL) return;
 
   /* We do not have a complete implementation. Assert to ensure our
-   * restrictions are in place, We do not support big endian output, but do not
-   * check that native endian is little endian. */
-  assert(nails  == 0 && "Do not support non-full words");
-  assert((endian == 0 || endian == -1) && "Do not support big endian");
+   * restrictions are in place. */
+  assert(nails == 0 && "Do not support non-full words");
+  assert(endian == 1 || endian == 0 || endian == -1);
+  assert(order == 1 || order == -1);
+
+  if (endian == 0) {
+    endian = HOST_ENDIAN;
+  }
 
   /* Compute number of needed digits by ceil division */
   total_size = count * size;
@@ -791,47 +760,42 @@
 
   /* Init temporary */
   mp_int_init_size(tmp, num_digits);
-  for (i = 0; i < num_digits; i++)
-    tmp->digitsi = 0;
+  for (i = 0; i < num_digits; i++) tmp->digitsi = 0;
 
   /* Copy bytes */
-  src = (const char *) op;
-  dst = (char *)MP_DIGITS(tmp);
-
-  /* Most significant word is first */
-  if (order == 1) {
-    size_t word;
-    dst += (count - 1) * size;
-    for (word = 0; word < count; word++) {
-      for (i = 0; i < size; i++)
-        dsti = srci;
-      dst -= size;
-      src += size;
-    }
-  }
-  /* Least significant word is first */
-  else {
-    size_t word;
-    for (word = 0; word < count; word++) {
-      for (i = 0; i < size; i++)
-        dsti = srci;
-      dst += size;
-      src += size;
+  src = (const unsigned char *)op + (order >= 0 ? (count - 1) * size : 0) +
+        (endian >= 0 ? size - 1 : 0);
+  dst = MP_DIGITS(tmp);
+  dst_bits = 0;
+
+  word_offset = (endian >= 0 ? size : -size) + (order < 0 ? size : -size);
+
+  for (i = 0; i < count; i++) {
+    for (j = 0; j < size; j++) {
+      if (dst_bits == MP_DIGIT_BIT) {
+        ++dst;
+        dst_bits = 0;
+      }
+      *dst |= ((mp_digit)*src) << dst_bits;
+      dst_bits += 8;
+      src -= endian;
     }
+    src += word_offset;
   }
-  MP_USED(tmp) = num_digits;
+
+  tmp->used = num_digits;
 
   /* Remove leading zeros from number */
   {
-    mp_size uz_   = MP_USED(tmp);
-    mp_digit *dz_ = MP_DIGITS(tmp) + uz_ -1;
-    while (uz_ > 1 && (*dz_-- == 0))
-      --uz_;
-    MP_USED(tmp) = uz_;
+    mp_size uz_ = tmp->used;
+    mp_digit *dz_ = MP_DIGITS(tmp) + uz_ - 1;
+    while (uz_ > 1 && (*dz_-- == 0)) --uz_;
+    tmp->used = uz_;
   }
 
   /* Copy to destination */
   mp_int_copy(tmp, rop);
+  mp_int_clear(tmp);
 }
 
 /* gmp: mpz_sizeinbase */
@@ -840,8 +804,7 @@
   size_t size;
 
   /* If op == 0, return 1 */
-  if (mp_int_compare_zero(op) == 0)
-    return 1;
+  if (mp_int_compare_zero(op) == 0) return 1;
 
   /* Compute string length in base */
   res = mp_int_string_len(op, base);
@@ -854,8 +817,7 @@
   size -= 1;
 
   /* subtract one for the negative sign */
-  if (mp_int_compare_zero(op) < 0)
-    size -= 1;
+  if (mp_int_compare_zero(op) < 0) size -= 1;
 
   return size;
 }

_service:tar_scm:isl-0.14.tar.xz/imath/imath.c -> _service:tar_scm:isl-0.24.tar.gz/imath/imath.c Changed

@@ -1,7 +1,7 @@
 /*
   Name:     imath.c
   Purpose:  Arbitrary precision integer arithmetic routines.
-  Author:   M. J. Fromberger <http://spinning-yarns.org/michael/>
+  Author:   M. J. Fromberger
 
   Copyright (C) 2002-2007 Michael J. Fromberger, All Rights Reserved.
 
@@ -26,57 +26,29 @@
 
 #include "imath.h"
 
-#if DEBUG
-#include <stdio.h>
-#endif
-
+#include <assert.h>
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-
-#include <assert.h>
-
-#if DEBUG
-#define STATIC /* public */
-#else
-#define STATIC static
-#endif
 
-/* {{{ Constants */
-
-const mp_result MP_OK     = 0;  /* no error, all is well  */
-const mp_result MP_FALSE  = 0;  /* boolean false          */
-const mp_result MP_TRUE   = -1; /* boolean true           */
+const mp_result MP_OK = 0;      /* no error, all is well  */
+const mp_result MP_FALSE = 0;   /* boolean false          */
+const mp_result MP_TRUE = -1;   /* boolean true           */
 const mp_result MP_MEMORY = -2; /* out of memory          */
-const mp_result MP_RANGE  = -3; /* argument out of range  */
-const mp_result MP_UNDEF  = -4; /* result undefined       */
-const mp_result MP_TRUNC  = -5; /* output truncated       */
+const mp_result MP_RANGE = -3;  /* argument out of range  */
+const mp_result MP_UNDEF = -4;  /* result undefined       */
+const mp_result MP_TRUNC = -5;  /* output truncated       */
 const mp_result MP_BADARG = -6; /* invalid null argument  */
 const mp_result MP_MINERR = -6;
 
-const mp_sign   MP_NEG  = 1;    /* value is strictly negative */
-const mp_sign   MP_ZPOS = 0;    /* value is non-negative      */
-
-STATIC const char *s_unknown_err = "unknown result code";
-STATIC const char *s_error_msg = {
-  "error code 0",
-  "boolean true",
-  "out of memory",
-  "argument out of range",
-  "result undefined",
-  "output truncated",
-  "invalid argument",
-  NULL
-};
-
-/* }}} */
+const mp_sign MP_NEG = 1;  /* value is strictly negative */
+const mp_sign MP_ZPOS = 0; /* value is non-negative      */
 
-/* Argument checking macros
-   Use CHECK() where a return value is required; NRCHECK() elsewhere */
-#define CHECK(TEST)   assert(TEST)
-#define NRCHECK(TEST) assert(TEST)
-
-/* {{{ Logarithm table for computing output sizes */
+static const char *s_unknown_err = "unknown result code";
+static const char *s_error_msg = {"error code 0",     "boolean true",
+                                    "out of memory",    "argument out of range",
+                                    "result undefined", "output truncated",
+                                    "invalid argument", NULL};
 
 /* The ith entry of this table gives the value of log_i(2).
 
@@ -89,618 +61,538 @@
 
    If MP_MAX_RADIX is increased, this table should be expanded too.
  */
-STATIC const double s_log2 = {
-   0.000000000, 0.000000000, 1.000000000, 0.630929754, 	/* (D)(D) 2  3 */
-   0.500000000, 0.430676558, 0.386852807, 0.356207187, 	/*  4  5  6  7 */
-   0.333333333, 0.315464877, 0.301029996, 0.289064826, 	/*  8  9 10 11 */
-   0.278942946, 0.270238154, 0.262649535, 0.255958025, 	/* 12 13 14 15 */
-   0.250000000, 0.244650542, 0.239812467, 0.235408913, 	/* 16 17 18 19 */
-   0.231378213, 0.227670249, 0.224243824, 0.221064729, 	/* 20 21 22 23 */
-   0.218104292, 0.215338279, 0.212746054, 0.210309918, 	/* 24 25 26 27 */
-   0.208014598, 0.205846832, 0.203795047, 0.201849087, 	/* 28 29 30 31 */
-   0.200000000, 0.198239863, 0.196561632, 0.194959022, 	/* 32 33 34 35 */
-   0.193426404,                                         /* 36          */
+static const double s_log2 = {
+    0.000000000, 0.000000000, 1.000000000, 0.630929754, /* (D)(D) 2  3 */
+    0.500000000, 0.430676558, 0.386852807, 0.356207187, /*  4  5  6  7 */
+    0.333333333, 0.315464877, 0.301029996, 0.289064826, /*  8  9 10 11 */
+    0.278942946, 0.270238154, 0.262649535, 0.255958025, /* 12 13 14 15 */
+    0.250000000, 0.244650542, 0.239812467, 0.235408913, /* 16 17 18 19 */
+    0.231378213, 0.227670249, 0.224243824, 0.221064729, /* 20 21 22 23 */
+    0.218104292, 0.215338279, 0.212746054, 0.210309918, /* 24 25 26 27 */
+    0.208014598, 0.205846832, 0.203795047, 0.201849087, /* 28 29 30 31 */
+    0.200000000, 0.198239863, 0.196561632, 0.194959022, /* 32 33 34 35 */
+    0.193426404,                                        /* 36          */
 };
 
-/* }}} */
-/* {{{ Various macros */
-
 /* Return the number of digits needed to represent a static value */
 #define MP_VALUE_DIGITS(V) \
-((sizeof(V)+(sizeof(mp_digit)-1))/sizeof(mp_digit))
+  ((sizeof(V) + (sizeof(mp_digit) - 1)) / sizeof(mp_digit))
 
 /* Round precision P to nearest word boundary */
-#define ROUND_PREC(P) ((mp_size)(2*(((P)+1)/2)))
+static inline mp_size s_round_prec(mp_size P) { return 2 * ((P + 1) / 2); }
 
 /* Set array P of S digits to zero */
-#define ZERO(P, S) \
-do{ \
-  mp_size i__ = (S) * sizeof(mp_digit); \
-  mp_digit *p__ = (P); \
-  memset(p__, 0, i__); \
-} while(0)
+static inline void ZERO(mp_digit *P, mp_size S) {
+  mp_size i__ = S * sizeof(mp_digit);
+  mp_digit *p__ = P;
+  memset(p__, 0, i__);
+}
 
 /* Copy S digits from array P to array Q */
-#define COPY(P, Q, S) \
-do{ \
-  mp_size i__ = (S) * sizeof(mp_digit); \
-  mp_digit *p__ = (P), *q__ = (Q); \
-  memcpy(q__, p__, i__); \
-} while(0)
-
-/* Reverse N elements of type T in array A */
-#define REV(T, A, N) \
-do{ \
-  T *u_ = (A), *v_ = u_ + (N) - 1; \
-  while (u_ < v_) { \
-    T xch = *u_; \
-    *u_++ = *v_; \
-    *v_-- = xch; \
-  } \
-} while(0)
-
-#define CLAMP(Z) \
-do{ \
-  mp_int z_ = (Z); \
-  mp_size uz_ = MP_USED(z_); \
-  mp_digit *dz_ = MP_DIGITS(z_) + uz_ -1; \
-  while (uz_ > 1 && (*dz_-- == 0)) \
-    --uz_; \
-  MP_USED(z_) = uz_; \
-} while(0)
-
-/* Select min/max.  Do not provide expressions for which multiple
-   evaluation would be problematic, e.g. x++ */
-#define MIN(A, B) ((B)<(A)?(B):(A))
-#define MAX(A, B) ((B)>(A)?(B):(A))
+static inline void COPY(mp_digit *P, mp_digit *Q, mp_size S) {
+  mp_size i__ = S * sizeof(mp_digit);
+  mp_digit *p__ = P;
+  mp_digit *q__ = Q;
+  memcpy(q__, p__, i__);
+}
+
+/* Reverse N elements of unsigned char in A. */
+static inline void REV(unsigned char *A, int N) {
+  unsigned char *u_ = A;
+  unsigned char *v_ = u_ + N - 1;
+  while (u_ < v_) {
+    unsigned char xch = *u_;
+    *u_++ = *v_;
+    *v_-- = xch;
+  }
+}
+
+/* Strip leading zeroes from z_ in-place. */
+static inline void CLAMP(mp_int z_) {
+  mp_size uz_ = MP_USED(z_);
+  mp_digit *dz_ = MP_DIGITS(z_) + uz_ - 1;
+  while (uz_ > 1 && (*dz_-- == 0)) --uz_;
+  z_->used = uz_;
+}
+
+/* Select min/max. */
+static inline int MIN(int A, int B) { return (B < A ? B : A); }
+static inline mp_size MAX(mp_size A, mp_size B) { return (B > A ? B : A); }
 
 /* Exchange lvalues A and B of type T, e.g.
    SWAP(int, x, y) where x and y are variables of type int. */
 #define SWAP(T, A, B) \
-do{ \
-  T t_ = (A); \
-  A = (B); \
-  B = t_; \
-} while(0)
-
-/* Used to set up and access simple temp stacks within functions. */
-#define DECLARE_TEMP(N) \
-  mpz_t temp(N); \
-  int last__ = 0
-#define CLEANUP_TEMP() \
- CLEANUP: \
-  while (--last__ >= 0) \
-    mp_int_clear(TEMP(last__))
-#define TEMP(K) (temp + (K))
-#define LAST_TEMP() TEMP(last__)
-#define SETUP(E) \
-do{ \
-  if ((res = (E)) != MP_OK) \
-    goto CLEANUP; \
-  ++(last__); \
-} while(0)
+  do {                \
+    T t_ = (A);       \
+    A = (B);          \
+    B = t_;           \
+  } while (0)
+
+/* Declare a block of N temporary mpz_t values.
+   These values are initialized to zero.
+   You must add CLEANUP_TEMP() at the end of the function.
+   Use TEMP(i) to access a pointer to the ith value.
+ */
+#define DECLARE_TEMP(N)                   \
+  struct {                                \
+    mpz_t value(N);                     \
+    int len;                              \
+    mp_result err;                        \
+  } temp_ = {                             \
+      .len = (N),                         \
+      .err = MP_OK,                       \
+  };                                      \
+  do {                                    \
+    for (int i = 0; i < temp_.len; i++) { \
+      mp_int_init(TEMP(i));               \
+    }                                     \
+  } while (0)
+
+/* Clear all allocated temp values. */
+#define CLEANUP_TEMP()                    \
+  CLEANUP:                                \
+  do {                                    \
+    for (int i = 0; i < temp_.len; i++) { \
+      mp_int_clear(TEMP(i));              \
+    }                                     \
+    if (temp_.err != MP_OK) {             \
+      return temp_.err;                   \
+    }                                     \
+  } while (0)
+
+/* A pointer to the kth temp value. */
+#define TEMP(K) (temp_.value + (K))
+
+/* Evaluate E, an expression of type mp_result expected to return MP_OK.  If
+   the value is not MP_OK, the error is cached and control resumes at the
+   cleanup handler, which returns it.
+*/
+#define REQUIRE(E)                        \
+  do {                                    \
+    temp_.err = (E);                      \
+    if (temp_.err != MP_OK) goto CLEANUP; \
+  } while (0)
 
 /* Compare value to zero. */
-#define CMPZ(Z) \
-(((Z)->used==1&&(Z)->digits0==0)?0:((Z)->sign==MP_NEG)?-1:1)
-
-/* Multiply X by Y into Z, ignoring signs.  Requires that Z have
-   enough storage preallocated to hold the result. */
-#define UMUL(X, Y, Z) \
-do{ \
-  mp_size ua_ = MP_USED(X), ub_ = MP_USED(Y); \
-  mp_size o_ = ua_ + ub_; \
-  ZERO(MP_DIGITS(Z), o_); \
-  (void) s_kmul(MP_DIGITS(X), MP_DIGITS(Y), MP_DIGITS(Z), ua_, ub_); \
-  MP_USED(Z) = o_; \
-  CLAMP(Z); \
-} while(0)
-
-/* Square X into Z.  Requires that Z have enough storage to hold the
-   result. */
-#define USQR(X, Z) \
-do{ \
-  mp_size ua_ = MP_USED(X), o_ = ua_ + ua_; \
-  ZERO(MP_DIGITS(Z), o_); \
-  (void) s_ksqr(MP_DIGITS(X), MP_DIGITS(Z), ua_); \
-  MP_USED(Z) = o_; \
-  CLAMP(Z); \
-} while(0)
-
-#define UPPER_HALF(W)           ((mp_word)((W) >> MP_DIGIT_BIT))
-#define LOWER_HALF(W)           ((mp_digit)(W))
-#define HIGH_BIT_SET(W)         ((W) >> (MP_WORD_BIT - 1))
-#define ADD_WILL_OVERFLOW(W, V) ((MP_WORD_MAX - (V)) < (W))
-
-/* }}} */
-/* {{{ Default configuration settings */
+static inline int CMPZ(mp_int Z) {
+  if (Z->used == 1 && Z->digits0 == 0) return 0;
+  return (Z->sign == MP_NEG) ? -1 : 1;
+}
+
+static inline mp_word UPPER_HALF(mp_word W) { return (W >> MP_DIGIT_BIT); }
+static inline mp_digit LOWER_HALF(mp_word W) { return (mp_digit)(W); }
+
+/* Report whether the highest-order bit of W is 1. */
+static inline bool HIGH_BIT_SET(mp_word W) {
+  return (W >> (MP_WORD_BIT - 1)) != 0;
+}
+
+/* Report whether adding W + V will carry out. */
+static inline bool ADD_WILL_OVERFLOW(mp_word W, mp_word V) {
+  return ((MP_WORD_MAX - V) < W);
+}
 
 /* Default number of digits allocated to a new mp_int */
-#if IMATH_TEST
-mp_size default_precision = MP_DEFAULT_PREC;
-#else
-STATIC const mp_size default_precision = MP_DEFAULT_PREC;
-#endif
+static mp_size default_precision = 8;
+
+void mp_int_default_precision(mp_size size) {
+  assert(size > 0);
+  default_precision = size;
+}
 
 /* Minimum number of digits to invoke recursive multiply */
-#if IMATH_TEST
-mp_size multiply_threshold = MP_MULT_THRESH;
-#else
-STATIC const mp_size multiply_threshold = MP_MULT_THRESH;
-#endif
+static mp_size multiply_threshold = 32;
 
-/* }}} */
+void mp_int_multiply_threshold(mp_size thresh) {
+  assert(thresh >= sizeof(mp_word));
+  multiply_threshold = thresh;
+}
 
 /* Allocate a buffer of (at least) num digits, or return
    NULL if that couldn't be done.  */
-STATIC mp_digit *s_alloc(mp_size num);
+static mp_digit *s_alloc(mp_size num);
 
 /* Release a buffer of digits allocated by s_alloc(). */
-STATIC void s_free(void *ptr);
+static void s_free(void *ptr);
 
 /* Insure that z has at least min digits allocated, resizing if
    necessary.  Returns true if successful, false if out of memory. */
-STATIC int  s_pad(mp_int z, mp_size min);
+static bool s_pad(mp_int z, mp_size min);
+
+/* Ensure Z has at least N digits allocated. */
+static inline mp_result GROW(mp_int Z, mp_size N) {
+  return s_pad(Z, N) ? MP_OK : MP_MEMORY;
+}
 
 /* Fill in a "fake" mp_int on the stack with a given value */
-STATIC void      s_fake(mp_int z, mp_small value, mp_digit vbuf);
-STATIC void      s_ufake(mp_int z, mp_usmall value, mp_digit vbuf);
+static void s_fake(mp_int z, mp_small value, mp_digit vbuf);
+static void s_ufake(mp_int z, mp_usmall value, mp_digit vbuf);
 
 /* Compare two runs of digits of given length, returns <0, 0, >0 */
-STATIC int       s_cdig(mp_digit *da, mp_digit *db, mp_size len);
+static int s_cdig(mp_digit *da, mp_digit *db, mp_size len);
 
 /* Pack the unsigned digits of v into array t */
-STATIC int       s_uvpack(mp_usmall v, mp_digit t);
+static int s_uvpack(mp_usmall v, mp_digit t);
 
 /* Compare magnitudes of a and b, returns <0, 0, >0 */
-STATIC int       s_ucmp(mp_int a, mp_int b);
+static int s_ucmp(mp_int a, mp_int b);
 
 /* Compare magnitudes of a and v, returns <0, 0, >0 */
-STATIC int       s_vcmp(mp_int a, mp_small v);
-STATIC int       s_uvcmp(mp_int a, mp_usmall uv);
+static int s_vcmp(mp_int a, mp_small v);
+static int s_uvcmp(mp_int a, mp_usmall uv);
 
 /* Unsigned magnitude addition; assumes dc is big enough.
    Carry out is returned (no memory allocated). */
-STATIC mp_digit  s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
-		        mp_size size_a, mp_size size_b);
+static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                       mp_size size_b);
 
 /* Unsigned magnitude subtraction.  Assumes dc is big enough. */
-STATIC void      s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
-		        mp_size size_a, mp_size size_b);
+static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                   mp_size size_b);
 
 /* Unsigned recursive multiplication.  Assumes dc is big enough. */
-STATIC int       s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
-			mp_size size_a, mp_size size_b);
+static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                  mp_size size_b);
 
 /* Unsigned magnitude multiplication.  Assumes dc is big enough. */
-STATIC void      s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
-			mp_size size_a, mp_size size_b);
+static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                   mp_size size_b);
 
 /* Unsigned recursive squaring.  Assumes dc is big enough. */
-STATIC int       s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a);
+static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a);
 
 /* Unsigned magnitude squaring.  Assumes dc is big enough. */
-STATIC void      s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a);
+static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a);
 
 /* Single digit addition.  Assumes a is big enough. */
-STATIC void      s_dadd(mp_int a, mp_digit b);
+static void s_dadd(mp_int a, mp_digit b);
 
 /* Single digit multiplication.  Assumes a is big enough. */
-STATIC void      s_dmul(mp_int a, mp_digit b);
+static void s_dmul(mp_int a, mp_digit b);
 
 /* Single digit multiplication on buffers; assumes dc is big enough. */
-STATIC void      s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc,
-			 mp_size size_a);
+static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a);
 
 /* Single digit division.  Replaces a with the quotient,
    returns the remainder.  */
-STATIC mp_digit  s_ddiv(mp_int a, mp_digit b);
+static mp_digit s_ddiv(mp_int a, mp_digit b);
 
 /* Quick division by a power of 2, replaces z (no allocation) */
-STATIC void      s_qdiv(mp_int z, mp_size p2);
+static void s_qdiv(mp_int z, mp_size p2);
 
 /* Quick remainder by a power of 2, replaces z (no allocation) */
-STATIC void      s_qmod(mp_int z, mp_size p2);
+static void s_qmod(mp_int z, mp_size p2);
 
 /* Quick multiplication by a power of 2, replaces z.
    Allocates if necessary; returns false in case this fails. */
-STATIC int       s_qmul(mp_int z, mp_size p2);
+static int s_qmul(mp_int z, mp_size p2);
 
 /* Quick subtraction from a power of 2, replaces z.
    Allocates if necessary; returns false in case this fails. */
-STATIC int       s_qsub(mp_int z, mp_size p2);
+static int s_qsub(mp_int z, mp_size p2);
 
 /* Return maximum k such that 2^k divides z. */
-STATIC int       s_dp2k(mp_int z);
+static int s_dp2k(mp_int z);
 
 /* Return k >= 0 such that z = 2^k, or -1 if there is no such k. */
-STATIC int       s_isp2(mp_int z);
+static int s_isp2(mp_int z);
 
 /* Set z to 2^k.  May allocate; returns false in case this fails. */
-STATIC int       s_2expt(mp_int z, mp_small k);
+static int s_2expt(mp_int z, mp_small k);
 
 /* Normalize a and b for division, returns normalization constant */
-STATIC int       s_norm(mp_int a, mp_int b);
+static int s_norm(mp_int a, mp_int b);
 
 /* Compute constant mu for Barrett reduction, given modulus m, result
    replaces z, m is untouched. */
-STATIC mp_result s_brmu(mp_int z, mp_int m);
+static mp_result s_brmu(mp_int z, mp_int m);
 
 /* Reduce a modulo m, using Barrett's algorithm. */
-STATIC int       s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2);
+static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2);
 
 /* Modular exponentiation, using Barrett reduction */
-STATIC mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c);
+static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c);
 
 /* Unsigned magnitude division.  Assumes |a| > |b|.  Allocates temporaries;
    overwrites a with quotient, b with remainder. */
-STATIC mp_result s_udiv_knuth(mp_int a, mp_int b);
+static mp_result s_udiv_knuth(mp_int a, mp_int b);
 
 /* Compute the number of digits in radix r required to represent the given
    value.  Does not account for sign flags, terminators, etc. */
-STATIC int       s_outlen(mp_int z, mp_size r);
+static int s_outlen(mp_int z, mp_size r);
 
 /* Guess how many digits of precision will be needed to represent a radix r
    value of the specified number of digits.  Returns a value guaranteed to be
    no smaller than the actual number required. */
-STATIC mp_size   s_inlen(int len, mp_size r);
+static mp_size s_inlen(int len, mp_size r);
 
 /* Convert a character to a digit value in radix r, or
    -1 if out of range */
-STATIC int       s_ch2val(char c, int r);
+static int s_ch2val(char c, int r);
 
 /* Convert a digit value to a character */
-STATIC char      s_val2ch(int v, int caps);
+static char s_val2ch(int v, int caps);
 
 /* Take 2's complement of a buffer in place */
-STATIC void      s_2comp(unsigned char *buf, int len);
+static void s_2comp(unsigned char *buf, int len);
 
 /* Convert a value to binary, ignoring sign.  On input, *limpos is the bound on
    how many bytes should be written to buf; on output, *limpos is set to the
    number of bytes actually written. */
-STATIC mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad);
+static mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad);
 
-#if DEBUG
-/* Dump a representation of the mp_int to standard output */
-void      s_print(char *tag, mp_int z);
-void      s_print_buf(char *tag, mp_digit *buf, mp_size num);
-#endif
+/* Multiply X by Y into Z, ignoring signs.  Requires that Z have enough storage
+   preallocated to hold the result. */
+static inline void UMUL(mp_int X, mp_int Y, mp_int Z) {
+  mp_size ua_ = MP_USED(X);
+  mp_size ub_ = MP_USED(Y);
+  mp_size o_ = ua_ + ub_;
+  ZERO(MP_DIGITS(Z), o_);
+  (void)s_kmul(MP_DIGITS(X), MP_DIGITS(Y), MP_DIGITS(Z), ua_, ub_);
+  Z->used = o_;
+  CLAMP(Z);
+}
 
-/* {{{ mp_int_init(z) */
+/* Square X into Z.  Requires that Z have enough storage to hold the result. */
+static inline void USQR(mp_int X, mp_int Z) {
+  mp_size ua_ = MP_USED(X);
+  mp_size o_ = ua_ + ua_;
+  ZERO(MP_DIGITS(Z), o_);
+  (void)s_ksqr(MP_DIGITS(X), MP_DIGITS(Z), ua_);
+  Z->used = o_;
+  CLAMP(Z);
+}
 
-mp_result mp_int_init(mp_int z)
-{
-  if (z == NULL)
-    return MP_BADARG;
+mp_result mp_int_init(mp_int z) {
+  if (z == NULL) return MP_BADARG;
 
   z->single = 0;
   z->digits = &(z->single);
-  z->alloc  = 1;
-  z->used   = 1;
-  z->sign   = MP_ZPOS;
+  z->alloc = 1;
+  z->used = 1;
+  z->sign = MP_ZPOS;
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_alloc() */
-
-mp_int    mp_int_alloc(void)
-{
+mp_int mp_int_alloc(void) {
   mp_int out = malloc(sizeof(mpz_t));
 
-  if (out != NULL)
-    mp_int_init(out);
+  if (out != NULL) mp_int_init(out);
 
   return out;
 }
 
-/* }}} */
-
-/* {{{ mp_int_init_size(z, prec) */
-
-mp_result mp_int_init_size(mp_int z, mp_size prec)
-{
-  CHECK(z != NULL);
+mp_result mp_int_init_size(mp_int z, mp_size prec) {
+  assert(z != NULL);
 
-  if (prec == 0)
+  if (prec == 0) {
     prec = default_precision;
-  else if (prec == 1)
+  } else if (prec == 1) {
     return mp_int_init(z);
-  else
-    prec = (mp_size) ROUND_PREC(prec);
+  } else {
+    prec = s_round_prec(prec);
+  }
 
-  if ((MP_DIGITS(z) = s_alloc(prec)) == NULL)
-    return MP_MEMORY;
+  z->digits = s_alloc(prec);
+  if (MP_DIGITS(z) == NULL) return MP_MEMORY;
 
   z->digits0 = 0;
-  MP_USED(z) = 1;
-  MP_ALLOC(z) = prec;
-  MP_SIGN(z) = MP_ZPOS;
+  z->used = 1;
+  z->alloc = prec;
+  z->sign = MP_ZPOS;
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_init_copy(z, old) */
-
-mp_result mp_int_init_copy(mp_int z, mp_int old)
-{
-  mp_result res;
-  mp_size uold;
-
-  CHECK(z != NULL && old != NULL);
+mp_result mp_int_init_copy(mp_int z, mp_int old) {
+  assert(z != NULL && old != NULL);
 
-  uold = MP_USED(old);
+  mp_size uold = MP_USED(old);
   if (uold == 1) {
     mp_int_init(z);
-  }
-  else {
+  } else {
     mp_size target = MAX(uold, default_precision);
-
-    if ((res = mp_int_init_size(z, target)) != MP_OK)
-      return res;
+    mp_result res = mp_int_init_size(z, target);
+    if (res != MP_OK) return res;
   }
 
-  MP_USED(z) = uold;
-  MP_SIGN(z) = MP_SIGN(old);
+  z->used = uold;
+  z->sign = old->sign;
   COPY(MP_DIGITS(old), MP_DIGITS(z), uold);
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_init_value(z, value) */
-
-mp_result mp_int_init_value(mp_int z, mp_small value)
-{
-  mpz_t    vtmp;
+mp_result mp_int_init_value(mp_int z, mp_small value) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
   s_fake(&vtmp, value, vbuf);
   return mp_int_init_copy(z, &vtmp);
 }
 
-/* }}} */
-
-/* {{{ mp_int_init_uvalue(z, uvalue) */
-
-mp_result mp_int_init_uvalue(mp_int z, mp_usmall uvalue)
-{
-  mpz_t    vtmp;
+mp_result mp_int_init_uvalue(mp_int z, mp_usmall uvalue) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(uvalue);
 
   s_ufake(&vtmp, uvalue, vbuf);
   return mp_int_init_copy(z, &vtmp);
 }
 
-/* }}} */
-
-/* {{{ mp_int_set_value(z, value) */
-
-mp_result  mp_int_set_value(mp_int z, mp_small value)
-{
-  mpz_t    vtmp;
+mp_result mp_int_set_value(mp_int z, mp_small value) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
   s_fake(&vtmp, value, vbuf);
   return mp_int_copy(&vtmp, z);
 }
 
-/* }}} */
-
-/* {{{ mp_int_set_uvalue(z, value) */
-
-mp_result  mp_int_set_uvalue(mp_int z, mp_usmall uvalue)
-{
-  mpz_t    vtmp;
+mp_result mp_int_set_uvalue(mp_int z, mp_usmall uvalue) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(uvalue);
 
   s_ufake(&vtmp, uvalue, vbuf);
   return mp_int_copy(&vtmp, z);
 }
 
-/* }}} */
-
-/* {{{ mp_int_clear(z) */
-
-void      mp_int_clear(mp_int z)
-{
-  if (z == NULL)
-    return;
+void mp_int_clear(mp_int z) {
+  if (z == NULL) return;
 
   if (MP_DIGITS(z) != NULL) {
-    if (MP_DIGITS(z) != &(z->single))
-      s_free(MP_DIGITS(z));
+    if (MP_DIGITS(z) != &(z->single)) s_free(MP_DIGITS(z));
 
-    MP_DIGITS(z) = NULL;
+    z->digits = NULL;
   }
 }
 
-/* }}} */
-
-/* {{{ mp_int_free(z) */
-
-void      mp_int_free(mp_int z)
-{
-  NRCHECK(z != NULL);
+void mp_int_free(mp_int z) {
+  assert(z != NULL);
 
   mp_int_clear(z);
   free(z); /* note: NOT s_free() */
 }
 
-/* }}} */
-
-/* {{{ mp_int_copy(a, c) */
-
-mp_result mp_int_copy(mp_int a, mp_int c)
-{
-  CHECK(a != NULL && c != NULL);
+mp_result mp_int_copy(mp_int a, mp_int c) {
+  assert(a != NULL && c != NULL);
 
   if (a != c) {
     mp_size ua = MP_USED(a);
     mp_digit *da, *dc;
 
-    if (!s_pad(c, ua))
-      return MP_MEMORY;
+    if (!s_pad(c, ua)) return MP_MEMORY;
 
-    da = MP_DIGITS(a); dc = MP_DIGITS(c);
+    da = MP_DIGITS(a);
+    dc = MP_DIGITS(c);
     COPY(da, dc, ua);
 
-    MP_USED(c) = ua;
-    MP_SIGN(c) = MP_SIGN(a);
+    c->used = ua;
+    c->sign = a->sign;
   }
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_swap(a, c) */
-
-void      mp_int_swap(mp_int a, mp_int c)
-{
+void mp_int_swap(mp_int a, mp_int c) {
   if (a != c) {
     mpz_t tmp = *a;
 
     *a = *c;
     *c = tmp;
 
-    if (MP_DIGITS(a) == &(c->single))
-      MP_DIGITS(a) = &(a->single);
-    if (MP_DIGITS(c) == &(a->single))
-      MP_DIGITS(c) = &(c->single);
+    if (MP_DIGITS(a) == &(c->single)) a->digits = &(a->single);
+    if (MP_DIGITS(c) == &(a->single)) c->digits = &(c->single);
   }
 }
 
-/* }}} */
-
-/* {{{ mp_int_zero(z) */
-
-void      mp_int_zero(mp_int z)
-{
-  NRCHECK(z != NULL);
+void mp_int_zero(mp_int z) {
+  assert(z != NULL);
 
   z->digits0 = 0;
-  MP_USED(z) = 1;
-  MP_SIGN(z) = MP_ZPOS;
+  z->used = 1;
+  z->sign = MP_ZPOS;
 }
 
-/* }}} */
-
-/* {{{ mp_int_abs(a, c) */
+mp_result mp_int_abs(mp_int a, mp_int c) {
+  assert(a != NULL && c != NULL);
 
-mp_result mp_int_abs(mp_int a, mp_int c)
-{
   mp_result res;
+  if ((res = mp_int_copy(a, c)) != MP_OK) return res;
 
-  CHECK(a != NULL && c != NULL);
-
-  if ((res = mp_int_copy(a, c)) != MP_OK)
-    return res;
-
-  MP_SIGN(c) = MP_ZPOS;
+  c->sign = MP_ZPOS;
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_neg(a, c) */
+mp_result mp_int_neg(mp_int a, mp_int c) {
+  assert(a != NULL && c != NULL);
 
-mp_result mp_int_neg(mp_int a, mp_int c)
-{
   mp_result res;
+  if ((res = mp_int_copy(a, c)) != MP_OK) return res;
 
-  CHECK(a != NULL && c != NULL);
-
-  if ((res = mp_int_copy(a, c)) != MP_OK)
-    return res;
-
-  if (CMPZ(c) != 0)
-    MP_SIGN(c) = 1 - MP_SIGN(a);
+  if (CMPZ(c) != 0) c->sign = 1 - MP_SIGN(a);
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_add(a, b, c) */
-
-mp_result mp_int_add(mp_int a, mp_int b, mp_int c)
-{
-  mp_size ua, ub, uc, max;
+mp_result mp_int_add(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
 
-  CHECK(a != NULL && b != NULL && c != NULL);
-
-  ua = MP_USED(a); ub = MP_USED(b); uc = MP_USED(c);
-  max = MAX(ua, ub);
+  mp_size ua = MP_USED(a);
+  mp_size ub = MP_USED(b);
+  mp_size max = MAX(ua, ub);
 
   if (MP_SIGN(a) == MP_SIGN(b)) {
     /* Same sign -- add magnitudes, preserve sign of addends */
-    mp_digit carry;
+    if (!s_pad(c, max)) return MP_MEMORY;
 
-    if (!s_pad(c, max))
-      return MP_MEMORY;
-
-    carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub);
-    uc = max;
+    mp_digit carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub);
+    mp_size uc = max;
 
     if (carry) {
-      if (!s_pad(c, max + 1))
-	return MP_MEMORY;
+      if (!s_pad(c, max + 1)) return MP_MEMORY;
 
       c->digitsmax = carry;
       ++uc;
     }
 
-    MP_USED(c) = uc;
-    MP_SIGN(c) = MP_SIGN(a);
+    c->used = uc;
+    c->sign = a->sign;
 
-  }
-  else {
+  } else {
     /* Different signs -- subtract magnitudes, preserve sign of greater */
-    mp_int  x, y;
-    int     cmp = s_ucmp(a, b); /* magnitude comparision, sign ignored */
+    int cmp = s_ucmp(a, b); /* magnitude comparison, sign ignored */
 
     /* Set x to max(a, b), y to min(a, b) to simplify later code.
        A special case yields zero for equal magnitudes.
     */
+    mp_int x, y;
     if (cmp == 0) {
       mp_int_zero(c);
       return MP_OK;
-    }
-    else if (cmp < 0) {
-      x = b; y = a;
-    }
-    else {
-      x = a; y = b;
+    } else if (cmp < 0) {
+      x = b;
+      y = a;
+    } else {
+      x = a;
+      y = b;
     }
 
-    if (!s_pad(c, MP_USED(x)))
-      return MP_MEMORY;
+    if (!s_pad(c, MP_USED(x))) return MP_MEMORY;
 
     /* Subtract smaller from larger */
     s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y));
-    MP_USED(c) = MP_USED(x);
+    c->used = x->used;
     CLAMP(c);
 
     /* Give result the sign of the larger */
-    MP_SIGN(c) = MP_SIGN(x);
+    c->sign = x->sign;
   }
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_add_value(a, value, c) */
-
-mp_result mp_int_add_value(mp_int a, mp_small value, mp_int c)
-{
-  mpz_t    vtmp;
+mp_result mp_int_add_value(mp_int a, mp_small value, mp_int c) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
   s_fake(&vtmp, value, vbuf);
@@ -708,77 +600,61 @@
   return mp_int_add(a, &vtmp, c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_sub(a, b, c) */
+mp_result mp_int_sub(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
 
-mp_result mp_int_sub(mp_int a, mp_int b, mp_int c)
-{
-  mp_size ua, ub, uc, max;
-
-  CHECK(a != NULL && b != NULL && c != NULL);
-
-  ua = MP_USED(a); ub = MP_USED(b); uc = MP_USED(c);
-  max = MAX(ua, ub);
+  mp_size ua = MP_USED(a);
+  mp_size ub = MP_USED(b);
+  mp_size max = MAX(ua, ub);
 
   if (MP_SIGN(a) != MP_SIGN(b)) {
     /* Different signs -- add magnitudes and keep sign of a */
-    mp_digit carry;
+    if (!s_pad(c, max)) return MP_MEMORY;
 
-    if (!s_pad(c, max))
-      return MP_MEMORY;
-
-    carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub);
-    uc = max;
+    mp_digit carry = s_uadd(MP_DIGITS(a), MP_DIGITS(b), MP_DIGITS(c), ua, ub);
+    mp_size uc = max;
 
     if (carry) {
-      if (!s_pad(c, max + 1))
-	return MP_MEMORY;
+      if (!s_pad(c, max + 1)) return MP_MEMORY;
 
       c->digitsmax = carry;
       ++uc;
     }
 
-    MP_USED(c) = uc;
-    MP_SIGN(c) = MP_SIGN(a);
+    c->used = uc;
+    c->sign = a->sign;
 
-  }
-  else {
+  } else {
     /* Same signs -- subtract magnitudes */
-    mp_int  x, y;
+    if (!s_pad(c, max)) return MP_MEMORY;
+    mp_int x, y;
     mp_sign osign;
-    int     cmp = s_ucmp(a, b);
-
-    if (!s_pad(c, max))
-      return MP_MEMORY;
 
+    int cmp = s_ucmp(a, b);
     if (cmp >= 0) {
-      x = a; y = b; osign = MP_ZPOS;
-    }
-    else {
-      x = b; y = a; osign = MP_NEG;
+      x = a;
+      y = b;
+      osign = MP_ZPOS;
+    } else {
+      x = b;
+      y = a;
+      osign = MP_NEG;
     }
 
-    if (MP_SIGN(a) == MP_NEG && cmp != 0)
-      osign = 1 - osign;
+    if (MP_SIGN(a) == MP_NEG && cmp != 0) osign = 1 - osign;
 
     s_usub(MP_DIGITS(x), MP_DIGITS(y), MP_DIGITS(c), MP_USED(x), MP_USED(y));
-    MP_USED(c) = MP_USED(x);
+    c->used = x->used;
     CLAMP(c);
 
-    MP_SIGN(c) = osign;
+    c->sign = osign;
   }
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_sub_value(a, value, c) */
-
-mp_result mp_int_sub_value(mp_int a, mp_small value, mp_int c)
-{
-  mpz_t    vtmp;
+mp_result mp_int_sub_value(mp_int a, mp_small value, mp_int c) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
   s_fake(&vtmp, value, vbuf);
@@ -786,17 +662,8 @@
   return mp_int_sub(a, &vtmp, c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_mul(a, b, c) */
-
-mp_result mp_int_mul(mp_int a, mp_int b, mp_int c)
-{
-  mp_digit *out;
-  mp_size   osize, ua, ub, p = 0;
-  mp_sign   osign;
-
-  CHECK(a != NULL && b != NULL && c != NULL);
+mp_result mp_int_mul(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
 
   /* If either input is zero, we can shortcut multiplication */
   if (mp_int_compare_zero(a) == 0 || mp_int_compare_zero(b) == 0) {
@@ -805,56 +672,48 @@
   }
 
   /* Output is positive if inputs have same sign, otherwise negative */
-  osign = (MP_SIGN(a) == MP_SIGN(b)) ? MP_ZPOS : MP_NEG;
+  mp_sign osign = (MP_SIGN(a) == MP_SIGN(b)) ? MP_ZPOS : MP_NEG;
 
   /* If the output is not identical to any of the inputs, we'll write the
      results directly; otherwise, allocate a temporary space. */
-  ua = MP_USED(a); ub = MP_USED(b);
-  osize = MAX(ua, ub);
+  mp_size ua = MP_USED(a);
+  mp_size ub = MP_USED(b);
+  mp_size osize = MAX(ua, ub);
   osize = 4 * ((osize + 1) / 2);
 
+  mp_digit *out;
+  mp_size p = 0;
   if (c == a || c == b) {
-    p = ROUND_PREC(osize);
-    p = MAX(p, default_precision);
+    p = MAX(s_round_prec(osize), default_precision);
 
-    if ((out = s_alloc(p)) == NULL)
-      return MP_MEMORY;
-  }
-  else {
-    if (!s_pad(c, osize))
-      return MP_MEMORY;
+    if ((out = s_alloc(p)) == NULL) return MP_MEMORY;
+  } else {
+    if (!s_pad(c, osize)) return MP_MEMORY;
 
     out = MP_DIGITS(c);
   }
   ZERO(out, osize);
 
-  if (!s_kmul(MP_DIGITS(a), MP_DIGITS(b), out, ua, ub))
-    return MP_MEMORY;
+  if (!s_kmul(MP_DIGITS(a), MP_DIGITS(b), out, ua, ub)) return MP_MEMORY;
 
   /* If we allocated a new buffer, get rid of whatever memory c was already
      using, and fix up its fields to reflect that.
    */
   if (out != MP_DIGITS(c)) {
-    if ((void *) MP_DIGITS(c) != (void *) c)
-      s_free(MP_DIGITS(c));
-    MP_DIGITS(c) = out;
-    MP_ALLOC(c) = p;
+    if ((void *)MP_DIGITS(c) != (void *)c) s_free(MP_DIGITS(c));
+    c->digits = out;
+    c->alloc = p;
   }
 
-  MP_USED(c) = osize; /* might not be true, but we'll fix it ... */
-  CLAMP(c);           /* ... right here */
-  MP_SIGN(c) = osign;
+  c->used = osize; /* might not be true, but we'll fix it ... */
+  CLAMP(c);        /* ... right here */
+  c->sign = osign;
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_mul_value(a, value, c) */
-
-mp_result mp_int_mul_value(mp_int a, mp_small value, mp_int c)
-{
-  mpz_t    vtmp;
+mp_result mp_int_mul_value(mp_int a, mp_small value, mp_int c) {
+  mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
   s_fake(&vtmp, value, vbuf);
@@ -862,47 +721,33 @@
   return mp_int_mul(a, &vtmp, c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_mul_pow2(a, p2, c) */
+mp_result mp_int_mul_pow2(mp_int a, mp_small p2, mp_int c) {
+  assert(a != NULL && c != NULL && p2 >= 0);
 
-mp_result mp_int_mul_pow2(mp_int a, mp_small p2, mp_int c)
-{
-  mp_result res;
-  CHECK(a != NULL && c != NULL && p2 >= 0);
+  mp_result res = mp_int_copy(a, c);
+  if (res != MP_OK) return res;
 
-  if ((res = mp_int_copy(a, c)) != MP_OK)
-    return res;
-
-  if (s_qmul(c, (mp_size) p2))
+  if (s_qmul(c, (mp_size)p2)) {
     return MP_OK;
-  else
+  } else {
     return MP_MEMORY;
+  }
 }
 
-/* }}} */
-
-/* {{{ mp_int_sqr(a, c) */
-
-mp_result mp_int_sqr(mp_int a, mp_int c)
-{
-  mp_digit *out;
-  mp_size   osize, p = 0;
-
-  CHECK(a != NULL && c != NULL);
+mp_result mp_int_sqr(mp_int a, mp_int c) {
+  assert(a != NULL && c != NULL);
 
   /* Get a temporary buffer big enough to hold the result */
-  osize = (mp_size) 4 * ((MP_USED(a) + 1) / 2);
+  mp_size osize = (mp_size)4 * ((MP_USED(a) + 1) / 2);
+  mp_size p = 0;
+  mp_digit *out;
   if (a == c) {
-    p = ROUND_PREC(osize);
+    p = s_round_prec(osize);
     p = MAX(p, default_precision);
 
-    if ((out = s_alloc(p)) == NULL)
-      return MP_MEMORY;
-  }
-  else {
-    if (!s_pad(c, osize))
-      return MP_MEMORY;
+    if ((out = s_alloc(p)) == NULL) return MP_MEMORY;
+  } else {
+    if (!s_pad(c, osize)) return MP_MEMORY;
 
     out = MP_DIGITS(c);
   }
@@ -914,60 +759,48 @@
      reflect the new digit array it's using
    */
   if (out != MP_DIGITS(c)) {
-    if ((void *) MP_DIGITS(c) != (void *) c)
-      s_free(MP_DIGITS(c));
-    MP_DIGITS(c) = out;
-    MP_ALLOC(c) = p;
+    if ((void *)MP_DIGITS(c) != (void *)c) s_free(MP_DIGITS(c));
+    c->digits = out;
+    c->alloc = p;
   }
 
-  MP_USED(c) = osize; /* might not be true, but we'll fix it ... */
-  CLAMP(c);           /* ... right here */
-  MP_SIGN(c) = MP_ZPOS;
+  c->used = osize; /* might not be true, but we'll fix it ... */
+  CLAMP(c);        /* ... right here */
+  c->sign = MP_ZPOS;
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_div(a, b, q, r) */
+mp_result mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r) {
+  assert(a != NULL && b != NULL && q != r);
 
-mp_result mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r)
-{
-  int cmp, lg;
+  int cmp;
   mp_result res = MP_OK;
   mp_int qout, rout;
-  mp_sign sa = MP_SIGN(a), sb = MP_SIGN(b);
-  DECLARE_TEMP(2);
-
-  CHECK(a != NULL && b != NULL && q != r);
-
-  if (CMPZ(b) == 0)
+  mp_sign sa = MP_SIGN(a);
+  mp_sign sb = MP_SIGN(b);
+  if (CMPZ(b) == 0) {
     return MP_UNDEF;
-  else if ((cmp = s_ucmp(a, b)) < 0) {
+  } else if ((cmp = s_ucmp(a, b)) < 0) {
     /* If |a| < |b|, no division is required:
        q = 0, r = a
      */
-    if (r && (res = mp_int_copy(a, r)) != MP_OK)
-      return res;
+    if (r && (res = mp_int_copy(a, r)) != MP_OK) return res;
 
-    if (q)
-      mp_int_zero(q);
+    if (q) mp_int_zero(q);
 
     return MP_OK;
-  }
-  else if (cmp == 0) {
+  } else if (cmp == 0) {
     /* If |a| = |b|, no division is required:
        q = 1 or -1, r = 0
      */
-    if (r)
-      mp_int_zero(r);
+    if (r) mp_int_zero(r);
 
     if (q) {
       mp_int_zero(q);
       q->digits0 = 1;
 
-      if (sa != sb)
-	MP_SIGN(q) = MP_NEG;
+      if (sa != sb) q->sign = MP_NEG;
     }
 
     return MP_OK;
@@ -977,388 +810,260 @@
      quotient and remainder, but q and r are allowed to be NULL or to overlap
      with the inputs.
    */
+  DECLARE_TEMP(2);
+  int lg;
   if ((lg = s_isp2(b)) < 0) {
     if (q && b != q) {
-      if ((res = mp_int_copy(a, q)) != MP_OK)
-	goto CLEANUP;
-      else
-	qout = q;
-    }
-    else {
-      qout = LAST_TEMP();
-      SETUP(mp_int_init_copy(LAST_TEMP(), a));
+      REQUIRE(mp_int_copy(a, q));
+      qout = q;
+    } else {
+      REQUIRE(mp_int_copy(a, TEMP(0)));
+      qout = TEMP(0);
     }
 
     if (r && a != r) {
-      if ((res = mp_int_copy(b, r)) != MP_OK)
-	goto CLEANUP;
-      else
-	rout = r;
-    }
-    else {
-      rout = LAST_TEMP();
-      SETUP(mp_int_init_copy(LAST_TEMP(), b));
+      REQUIRE(mp_int_copy(b, r));
+      rout = r;
+    } else {
+      REQUIRE(mp_int_copy(b, TEMP(1)));
+      rout = TEMP(1);
     }
 
-    if ((res = s_udiv_knuth(qout, rout)) != MP_OK) goto CLEANUP;
-  }
-  else {
-    if (q && (res = mp_int_copy(a, q)) != MP_OK) goto CLEANUP;
-    if (r && (res = mp_int_copy(a, r)) != MP_OK) goto CLEANUP;
+    REQUIRE(s_udiv_knuth(qout, rout));
+  } else {
+    if (q) REQUIRE(mp_int_copy(a, q));
+    if (r) REQUIRE(mp_int_copy(a, r));
 
-    if (q) s_qdiv(q, (mp_size) lg); qout = q;
-    if (r) s_qmod(r, (mp_size) lg); rout = r;
+    if (q) s_qdiv(q, (mp_size)lg);
+    qout = q;
+    if (r) s_qmod(r, (mp_size)lg);
+    rout = r;
   }
 
   /* Recompute signs for output */
   if (rout) {
-    MP_SIGN(rout) = sa;
-    if (CMPZ(rout) == 0)
-      MP_SIGN(rout) = MP_ZPOS;
+    rout->sign = sa;
+    if (CMPZ(rout) == 0) rout->sign = MP_ZPOS;
   }
   if (qout) {
-    MP_SIGN(qout) = (sa == sb) ? MP_ZPOS : MP_NEG;
-    if (CMPZ(qout) == 0)
-      MP_SIGN(qout) = MP_ZPOS;
+    qout->sign = (sa == sb) ? MP_ZPOS : MP_NEG;
+    if (CMPZ(qout) == 0) qout->sign = MP_ZPOS;
   }
 
-  if (q && (res = mp_int_copy(qout, q)) != MP_OK) goto CLEANUP;
-  if (r && (res = mp_int_copy(rout, r)) != MP_OK) goto CLEANUP;
-
+  if (q) REQUIRE(mp_int_copy(qout, q));
+  if (r) REQUIRE(mp_int_copy(rout, r));
   CLEANUP_TEMP();
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_int_mod(a, m, c) */
-
-mp_result mp_int_mod(mp_int a, mp_int m, mp_int c)
-{
-  mp_result res;
-  mpz_t     tmp;
-  mp_int    out;
-
-  if (m == c) {
-    mp_int_init(&tmp);
-    out = &tmp;
-  }
-  else {
-    out = c;
+mp_result mp_int_mod(mp_int a, mp_int m, mp_int c) {
+  DECLARE_TEMP(1);
+  mp_int out = (m == c) ? TEMP(0) : c;
+  REQUIRE(mp_int_div(a, m, NULL, out));
+  if (CMPZ(out) < 0) {
+    REQUIRE(mp_int_add(out, m, c));
+  } else {
+    REQUIRE(mp_int_copy(out, c));
   }
-
-  if ((res = mp_int_div(a, m, NULL, out)) != MP_OK)
-    goto CLEANUP;
-
-  if (CMPZ(out) < 0)
-    res = mp_int_add(out, m, c);
-  else
-    res = mp_int_copy(out, c);
-
- CLEANUP:
-  if (out != c)
-    mp_int_clear(&tmp);
-
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_div_value(a, value, q, r) */
-
-mp_result mp_int_div_value(mp_int a, mp_small value, mp_int q, mp_small *r)
-{
-  mpz_t     vtmp, rtmp;
-  mp_digit  vbufMP_VALUE_DIGITS(value);
-  mp_result res;
-
-  mp_int_init(&rtmp);
+mp_result mp_int_div_value(mp_int a, mp_small value, mp_int q, mp_small *r) {
+  mpz_t vtmp;
+  mp_digit vbufMP_VALUE_DIGITS(value);
   s_fake(&vtmp, value, vbuf);
 
-  if ((res = mp_int_div(a, &vtmp, q, &rtmp)) != MP_OK)
-    goto CLEANUP;
+  DECLARE_TEMP(1);
+  REQUIRE(mp_int_div(a, &vtmp, q, TEMP(0)));
 
-  if (r)
-    (void) mp_int_to_int(&rtmp, r); /* can't fail */
+  if (r) (void)mp_int_to_int(TEMP(0), r); /* can't fail */
 
- CLEANUP:
-  mp_int_clear(&rtmp);
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
+mp_result mp_int_div_pow2(mp_int a, mp_small p2, mp_int q, mp_int r) {
+  assert(a != NULL && p2 >= 0 && q != r);
 
-/* {{{ mp_int_div_pow2(a, p2, q, r) */
-
-mp_result mp_int_div_pow2(mp_int a, mp_small p2, mp_int q, mp_int r)
-{
   mp_result res = MP_OK;
+  if (q != NULL && (res = mp_int_copy(a, q)) == MP_OK) {
+    s_qdiv(q, (mp_size)p2);
+  }
 
-  CHECK(a != NULL && p2 >= 0 && q != r);
-
-  if (q != NULL && (res = mp_int_copy(a, q)) == MP_OK)
-    s_qdiv(q, (mp_size) p2);
-
-  if (res == MP_OK && r != NULL && (res = mp_int_copy(a, r)) == MP_OK)
-    s_qmod(r, (mp_size) p2);
+  if (res == MP_OK && r != NULL && (res = mp_int_copy(a, r)) == MP_OK) {
+    s_qmod(r, (mp_size)p2);
+  }
 
   return res;
 }
 
-/* }}} */
+mp_result mp_int_expt(mp_int a, mp_small b, mp_int c) {
+  assert(c != NULL);
+  if (b < 0) return MP_RANGE;
 
-/* {{{ mp_int_expt(a, b, c) */
+  DECLARE_TEMP(1);
+  REQUIRE(mp_int_copy(a, TEMP(0)));
 
-mp_result mp_int_expt(mp_int a, mp_small b, mp_int c)
-{
-  mpz_t t;
-  mp_result res;
-  unsigned int v = abs(b);
-
-  CHECK(c != NULL);
-  if (b < 0)
-    return MP_RANGE;
-
-  if ((res = mp_int_init_copy(&t, a)) != MP_OK)
-    return res;
-
-  (void) mp_int_set_value(c, 1);
+  (void)mp_int_set_value(c, 1);
+  unsigned int v = labs(b);
   while (v != 0) {
     if (v & 1) {
-      if ((res = mp_int_mul(c, &t, c)) != MP_OK)
-	goto CLEANUP;
+      REQUIRE(mp_int_mul(c, TEMP(0), c));
     }
 
     v >>= 1;
     if (v == 0) break;
 
-    if ((res = mp_int_sqr(&t, &t)) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_sqr(TEMP(0), TEMP(0)));
   }
 
- CLEANUP:
-  mp_int_clear(&t);
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_expt_value(a, b, c) */
-
-mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c)
-{
-  mpz_t     t;
-  mp_result res;
-  unsigned int v = abs(b);
-
-  CHECK(c != NULL);
-  if (b < 0)
-    return MP_RANGE;
+mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c) {
+  assert(c != NULL);
+  if (b < 0) return MP_RANGE;
 
-  if ((res = mp_int_init_value(&t, a)) != MP_OK)
-    return res;
+  DECLARE_TEMP(1);
+  REQUIRE(mp_int_set_value(TEMP(0), a));
 
-  (void) mp_int_set_value(c, 1);
+  (void)mp_int_set_value(c, 1);
+  unsigned int v = labs(b);
   while (v != 0) {
     if (v & 1) {
-      if ((res = mp_int_mul(c, &t, c)) != MP_OK)
-	goto CLEANUP;
+      REQUIRE(mp_int_mul(c, TEMP(0), c));
     }
 
     v >>= 1;
     if (v == 0) break;
 
-    if ((res = mp_int_sqr(&t, &t)) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_sqr(TEMP(0), TEMP(0)));
   }
 
- CLEANUP:
-  mp_int_clear(&t);
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_expt_full(a, b, c) */
-
-mp_result mp_int_expt_full(mp_int a, mp_int b, mp_int c)
-{
-  mpz_t t;
-  mp_result res;
-  unsigned ix, jx;
-
-  CHECK(a != NULL && b != NULL && c != NULL);
-  if (MP_SIGN(b) == MP_NEG)
-    return MP_RANGE;
+mp_result mp_int_expt_full(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
+  if (MP_SIGN(b) == MP_NEG) return MP_RANGE;
 
-  if ((res = mp_int_init_copy(&t, a)) != MP_OK)
-    return res;
+  DECLARE_TEMP(1);
+  REQUIRE(mp_int_copy(a, TEMP(0)));
 
-  (void) mp_int_set_value(c, 1);
-  for (ix = 0; ix < MP_USED(b); ++ix) {
+  (void)mp_int_set_value(c, 1);
+  for (unsigned ix = 0; ix < MP_USED(b); ++ix) {
     mp_digit d = b->digitsix;
 
-    for (jx = 0; jx < MP_DIGIT_BIT; ++jx) {
+    for (unsigned jx = 0; jx < MP_DIGIT_BIT; ++jx) {
       if (d & 1) {
-	if ((res = mp_int_mul(c, &t, c)) != MP_OK)
-	  goto CLEANUP;
+        REQUIRE(mp_int_mul(c, TEMP(0), c));
       }
 
       d >>= 1;
-      if (d == 0 && ix + 1 == MP_USED(b))
-	break;
-      if ((res = mp_int_sqr(&t, &t)) != MP_OK)
-	goto CLEANUP;
+      if (d == 0 && ix + 1 == MP_USED(b)) break;
+      REQUIRE(mp_int_sqr(TEMP(0), TEMP(0)));
     }
   }
 
- CLEANUP:
-  mp_int_clear(&t);
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
+int mp_int_compare(mp_int a, mp_int b) {
+  assert(a != NULL && b != NULL);
 
-/* {{{ mp_int_compare(a, b) */
-
-int       mp_int_compare(mp_int a, mp_int b)
-{
-  mp_sign sa;
-
-  CHECK(a != NULL && b != NULL);
-
-  sa = MP_SIGN(a);
+  mp_sign sa = MP_SIGN(a);
   if (sa == MP_SIGN(b)) {
     int cmp = s_ucmp(a, b);
 
     /* If they're both zero or positive, the normal comparison applies; if both
        negative, the sense is reversed. */
-    if (sa == MP_ZPOS)
+    if (sa == MP_ZPOS) {
       return cmp;
-    else
+    } else {
       return -cmp;
-
-  }
-  else {
-    if (sa == MP_ZPOS)
-      return 1;
-    else
-      return -1;
+    }
+  } else if (sa == MP_ZPOS) {
+    return 1;
+  } else {
+    return -1;
   }
 }
 
-/* }}} */
-
-/* {{{ mp_int_compare_unsigned(a, b) */
-
-int       mp_int_compare_unsigned(mp_int a, mp_int b)
-{
-  NRCHECK(a != NULL && b != NULL);
+int mp_int_compare_unsigned(mp_int a, mp_int b) {
+  assert(a != NULL && b != NULL);
 
   return s_ucmp(a, b);
 }
 
-/* }}} */
-
-/* {{{ mp_int_compare_zero(z) */
-
-int       mp_int_compare_zero(mp_int z)
-{
-  NRCHECK(z != NULL);
+int mp_int_compare_zero(mp_int z) {
+  assert(z != NULL);
 
-  if (MP_USED(z) == 1 && z->digits0 == 0)
+  if (MP_USED(z) == 1 && z->digits0 == 0) {
     return 0;
-  else if (MP_SIGN(z) == MP_ZPOS)
+  } else if (MP_SIGN(z) == MP_ZPOS) {
     return 1;
-  else
+  } else {
     return -1;
+  }
 }
 
-/* }}} */
-
-/* {{{ mp_int_compare_value(z, value) */
+int mp_int_compare_value(mp_int z, mp_small value) {
+  assert(z != NULL);
 
-int       mp_int_compare_value(mp_int z, mp_small value)
-{
   mp_sign vsign = (value < 0) ? MP_NEG : MP_ZPOS;
-  int cmp;
-
-  CHECK(z != NULL);
-
   if (vsign == MP_SIGN(z)) {
-    cmp = s_vcmp(z, value);
+    int cmp = s_vcmp(z, value);
 
     return (vsign == MP_ZPOS) ? cmp : -cmp;
-  }
-  else {
+  } else {
     return (value < 0) ? 1 : -1;
   }
 }
 
-/* }}} */
-
-/* {{{ mp_int_compare_uvalue(z, uv) */
+int mp_int_compare_uvalue(mp_int z, mp_usmall uv) {
+  assert(z != NULL);
 
-int       mp_int_compare_uvalue(mp_int z, mp_usmall uv)
-{
-  CHECK(z != NULL);
-
-  if (MP_SIGN(z) == MP_NEG)
+  if (MP_SIGN(z) == MP_NEG) {
     return -1;
-  else
+  } else {
     return s_uvcmp(z, uv);
+  }
 }
 
-/* }}} */
-
-/* {{{ mp_int_exptmod(a, b, m, c) */
-
-mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c)
-{
-  mp_result res;
-  mp_size um;
-  mp_int s;
-  DECLARE_TEMP(3);
-
-  CHECK(a != NULL && b != NULL && c != NULL && m != NULL);
+mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL && m != NULL);
 
   /* Zero moduli and negative exponents are not considered. */
-  if (CMPZ(m) == 0)
-    return MP_UNDEF;
-  if (CMPZ(b) < 0)
-    return MP_RANGE;
+  if (CMPZ(m) == 0) return MP_UNDEF;
+  if (CMPZ(b) < 0) return MP_RANGE;
 
-  um = MP_USED(m);
-  SETUP(mp_int_init_size(TEMP(0), 2 * um));
-  SETUP(mp_int_init_size(TEMP(1), 2 * um));
+  mp_size um = MP_USED(m);
+  DECLARE_TEMP(3);
+  REQUIRE(GROW(TEMP(0), 2 * um));
+  REQUIRE(GROW(TEMP(1), 2 * um));
 
+  mp_int s;
   if (c == b || c == m) {
-    SETUP(mp_int_init_size(TEMP(2), 2 * um));
+    REQUIRE(GROW(TEMP(2), 2 * um));
     s = TEMP(2);
-  }
-  else {
+  } else {
     s = c;
   }
 
-  if ((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) goto CLEANUP;
-
-  if ((res = s_brmu(TEMP(1), m)) != MP_OK) goto CLEANUP;
-
-  if ((res = s_embar(TEMP(0), b, m, TEMP(1), s)) != MP_OK)
-    goto CLEANUP;
-
-  res = mp_int_copy(s, c);
+  REQUIRE(mp_int_mod(a, m, TEMP(0)));
+  REQUIRE(s_brmu(TEMP(1), m));
+  REQUIRE(s_embar(TEMP(0), b, m, TEMP(1), s));
+  REQUIRE(mp_int_copy(s, c));
 
   CLEANUP_TEMP();
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_exptmod_evalue(a, value, m, c) */
-
-mp_result mp_int_exptmod_evalue(mp_int a, mp_small value, mp_int m, mp_int c)
-{
+mp_result mp_int_exptmod_evalue(mp_int a, mp_small value, mp_int m, mp_int c) {
   mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
@@ -1367,13 +1072,7 @@
   return mp_int_exptmod(a, &vtmp, m, c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_exptmod_bvalue(v, b, m, c) */
-
-mp_result mp_int_exptmod_bvalue(mp_small value, mp_int b,
-				mp_int m, mp_int c)
-{
+mp_result mp_int_exptmod_bvalue(mp_small value, mp_int b, mp_int m, mp_int c) {
   mpz_t vtmp;
   mp_digit vbufMP_VALUE_DIGITS(value);
 
@@ -1382,248 +1081,184 @@
   return mp_int_exptmod(&vtmp, b, m, c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_exptmod_known(a, b, m, mu, c) */
-
-mp_result mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c)
-{
-  mp_result res;
-  mp_size um;
-  mp_int s;
-  DECLARE_TEMP(2);
-
-  CHECK(a && b && m && c);
+mp_result mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu,
+                               mp_int c) {
+  assert(a && b && m && c);
 
   /* Zero moduli and negative exponents are not considered. */
-  if (CMPZ(m) == 0)
-    return MP_UNDEF;
-  if (CMPZ(b) < 0)
-    return MP_RANGE;
+  if (CMPZ(m) == 0) return MP_UNDEF;
+  if (CMPZ(b) < 0) return MP_RANGE;
 
-  um = MP_USED(m);
-  SETUP(mp_int_init_size(TEMP(0), 2 * um));
+  DECLARE_TEMP(2);
+  mp_size um = MP_USED(m);
+  REQUIRE(GROW(TEMP(0), 2 * um));
 
+  mp_int s;
   if (c == b || c == m) {
-    SETUP(mp_int_init_size(TEMP(1), 2 * um));
+    REQUIRE(GROW(TEMP(1), 2 * um));
     s = TEMP(1);
-  }
-  else {
+  } else {
     s = c;
   }
 
-  if ((res = mp_int_mod(a, m, TEMP(0))) != MP_OK) goto CLEANUP;
-
-  if ((res = s_embar(TEMP(0), b, m, mu, s)) != MP_OK)
-    goto CLEANUP;
-
-  res = mp_int_copy(s, c);
+  REQUIRE(mp_int_mod(a, m, TEMP(0)));
+  REQUIRE(s_embar(TEMP(0), b, m, mu, s));
+  REQUIRE(mp_int_copy(s, c));
 
   CLEANUP_TEMP();
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_redux_const(m, c) */
-
-mp_result mp_int_redux_const(mp_int m, mp_int c)
-{
-  CHECK(m != NULL && c != NULL && m != c);
+mp_result mp_int_redux_const(mp_int m, mp_int c) {
+  assert(m != NULL && c != NULL && m != c);
 
   return s_brmu(c, m);
 }
 
-/* }}} */
+mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c) {
+  assert(a != NULL && m != NULL && c != NULL);
 
-/* {{{ mp_int_invmod(a, m, c) */
+  if (CMPZ(a) == 0 || CMPZ(m) <= 0) return MP_RANGE;
 
-mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c)
-{
-  mp_result res;
-  mp_sign sa;
   DECLARE_TEMP(2);
 
-  CHECK(a != NULL && m != NULL && c != NULL);
-
-  if (CMPZ(a) == 0 || CMPZ(m) <= 0)
-    return MP_RANGE;
-
-  sa = MP_SIGN(a); /* need this for the result later */
-
-  for (last__ = 0; last__ < 2; ++last__)
-    mp_int_init(LAST_TEMP());
-
-  if ((res = mp_int_egcd(a, m, TEMP(0), TEMP(1), NULL)) != MP_OK)
-    goto CLEANUP;
+  REQUIRE(mp_int_egcd(a, m, TEMP(0), TEMP(1), NULL));
 
   if (mp_int_compare_value(TEMP(0), 1) != 0) {
-    res = MP_UNDEF;
-    goto CLEANUP;
+    REQUIRE(MP_UNDEF);
   }
 
   /* It is first necessary to constrain the value to the proper range */
-  if ((res = mp_int_mod(TEMP(1), m, TEMP(1))) != MP_OK)
-    goto CLEANUP;
+  REQUIRE(mp_int_mod(TEMP(1), m, TEMP(1)));
 
   /* Now, if 'a' was originally negative, the value we have is actually the
      magnitude of the negative representative; to get the positive value we
      have to subtract from the modulus.  Otherwise, the value is okay as it
      stands.
    */
-  if (sa == MP_NEG)
-    res = mp_int_sub(m, TEMP(1), c);
-  else
-    res = mp_int_copy(TEMP(1), c);
+  if (MP_SIGN(a) == MP_NEG) {
+    REQUIRE(mp_int_sub(m, TEMP(1), c));
+  } else {
+    REQUIRE(mp_int_copy(TEMP(1), c));
+  }
 
   CLEANUP_TEMP();
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_gcd(a, b, c) */
-
 /* Binary GCD algorithm due to Josef Stein, 1961 */
-mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c)
-{
-  int ca, cb, k = 0;
-  mpz_t u, v, t;
-  mp_result res;
-
-  CHECK(a != NULL && b != NULL && c != NULL);
+mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
 
-  ca = CMPZ(a);
-  cb = CMPZ(b);
-  if (ca == 0 && cb == 0)
+  int ca = CMPZ(a);
+  int cb = CMPZ(b);
+  if (ca == 0 && cb == 0) {
     return MP_UNDEF;
-  else if (ca == 0)
+  } else if (ca == 0) {
     return mp_int_abs(b, c);
-  else if (cb == 0)
+  } else if (cb == 0) {
     return mp_int_abs(a, c);
+  }
 
-  mp_int_init(&t);
-  if ((res = mp_int_init_copy(&u, a)) != MP_OK)
-    goto U;
-  if ((res = mp_int_init_copy(&v, b)) != MP_OK)
-    goto V;
+  DECLARE_TEMP(3);
+  REQUIRE(mp_int_copy(a, TEMP(0)));
+  REQUIRE(mp_int_copy(b, TEMP(1)));
 
-  MP_SIGN(&u) = MP_ZPOS; MP_SIGN(&v) = MP_ZPOS;
+  TEMP(0)->sign = MP_ZPOS;
+  TEMP(1)->sign = MP_ZPOS;
 
+  int k = 0;
   { /* Divide out common factors of 2 from u and v */
-    int div2_u = s_dp2k(&u), div2_v = s_dp2k(&v);
+    int div2_u = s_dp2k(TEMP(0));
+    int div2_v = s_dp2k(TEMP(1));
 
     k = MIN(div2_u, div2_v);
-    s_qdiv(&u, (mp_size) k);
-    s_qdiv(&v, (mp_size) k);
+    s_qdiv(TEMP(0), (mp_size)k);
+    s_qdiv(TEMP(1), (mp_size)k);
   }
 
-  if (mp_int_is_odd(&u)) {
-    if ((res = mp_int_neg(&v, &t)) != MP_OK)
-      goto CLEANUP;
-  }
-  else {
-    if ((res = mp_int_copy(&u, &t)) != MP_OK)
-      goto CLEANUP;
+  if (mp_int_is_odd(TEMP(0))) {
+    REQUIRE(mp_int_neg(TEMP(1), TEMP(2)));
+  } else {
+    REQUIRE(mp_int_copy(TEMP(0), TEMP(2)));
   }
 
   for (;;) {
-    s_qdiv(&t, s_dp2k(&t));
+    s_qdiv(TEMP(2), s_dp2k(TEMP(2)));
 
-    if (CMPZ(&t) > 0) {
-      if ((res = mp_int_copy(&t, &u)) != MP_OK)
-	goto CLEANUP;
-    }
-    else {
-      if ((res = mp_int_neg(&t, &v)) != MP_OK)
-	goto CLEANUP;
+    if (CMPZ(TEMP(2)) > 0) {
+      REQUIRE(mp_int_copy(TEMP(2), TEMP(0)));
+    } else {
+      REQUIRE(mp_int_neg(TEMP(2), TEMP(1)));
     }
 
-    if ((res = mp_int_sub(&u, &v, &t)) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_sub(TEMP(0), TEMP(1), TEMP(2)));
 
-    if (CMPZ(&t) == 0)
-      break;
+    if (CMPZ(TEMP(2)) == 0) break;
   }
 
-  if ((res = mp_int_abs(&u, c)) != MP_OK)
-    goto CLEANUP;
-  if (!s_qmul(c, (mp_size) k))
-    res = MP_MEMORY;
+  REQUIRE(mp_int_abs(TEMP(0), c));
+  if (!s_qmul(c, (mp_size)k)) REQUIRE(MP_MEMORY);
 
- CLEANUP:
-  mp_int_clear(&v);
- V: mp_int_clear(&u);
- U: mp_int_clear(&t);
-
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_egcd(a, b, c, x, y) */
-
 /* This is the binary GCD algorithm again, but this time we keep track of the
    elementary matrix operations as we go, so we can get values x and y
    satisfying c = ax + by.
  */
-mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c,
-		      mp_int x, mp_int y)
-{
-  int k, ca, cb;
-  mp_result res;
-  DECLARE_TEMP(8);
-
-  CHECK(a != NULL && b != NULL && c != NULL &&
-	(x != NULL || y != NULL));
+mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, mp_int x, mp_int y) {
+  assert(a != NULL && b != NULL && c != NULL && (x != NULL || y != NULL));
 
-  ca = CMPZ(a);
-  cb = CMPZ(b);
-  if (ca == 0 && cb == 0)
+  mp_result res = MP_OK;
+  int ca = CMPZ(a);
+  int cb = CMPZ(b);
+  if (ca == 0 && cb == 0) {
     return MP_UNDEF;
-  else if (ca == 0) {
+  } else if (ca == 0) {
     if ((res = mp_int_abs(b, c)) != MP_OK) return res;
-    mp_int_zero(x); (void) mp_int_set_value(y, 1); return MP_OK;
-  }
-  else if (cb == 0) {
+    mp_int_zero(x);
+    (void)mp_int_set_value(y, 1);
+    return MP_OK;
+  } else if (cb == 0) {
     if ((res = mp_int_abs(a, c)) != MP_OK) return res;
-    (void) mp_int_set_value(x, 1); mp_int_zero(y); return MP_OK;
+    (void)mp_int_set_value(x, 1);
+    mp_int_zero(y);
+    return MP_OK;
   }
 
   /* Initialize temporaries:
      A:0, B:1, C:2, D:3, u:4, v:5, ou:6, ov:7 */
-  for (last__ = 0; last__ < 4; ++last__)
-    mp_int_init(LAST_TEMP());
-  TEMP(0)->digits0 = 1;
-  TEMP(3)->digits0 = 1;
-
-  SETUP(mp_int_init_copy(TEMP(4), a));
-  SETUP(mp_int_init_copy(TEMP(5), b));
+  DECLARE_TEMP(8);
+  REQUIRE(mp_int_set_value(TEMP(0), 1));
+  REQUIRE(mp_int_set_value(TEMP(3), 1));
+  REQUIRE(mp_int_copy(a, TEMP(4)));
+  REQUIRE(mp_int_copy(b, TEMP(5)));
 
   /* We will work with absolute values here */
-  MP_SIGN(TEMP(4)) = MP_ZPOS;
-  MP_SIGN(TEMP(5)) = MP_ZPOS;
+  TEMP(4)->sign = MP_ZPOS;
+  TEMP(5)->sign = MP_ZPOS;
 
+  int k = 0;
   { /* Divide out common factors of 2 from u and v */
-    int  div2_u = s_dp2k(TEMP(4)), div2_v = s_dp2k(TEMP(5));
+    int div2_u = s_dp2k(TEMP(4)), div2_v = s_dp2k(TEMP(5));
 
     k = MIN(div2_u, div2_v);
     s_qdiv(TEMP(4), k);
     s_qdiv(TEMP(5), k);
   }
 
-  SETUP(mp_int_init_copy(TEMP(6), TEMP(4)));
-  SETUP(mp_int_init_copy(TEMP(7), TEMP(5)));
+  REQUIRE(mp_int_copy(TEMP(4), TEMP(6)));
+  REQUIRE(mp_int_copy(TEMP(5), TEMP(7)));
 
   for (;;) {
     while (mp_int_is_even(TEMP(4))) {
       s_qdiv(TEMP(4), 1);
 
       if (mp_int_is_odd(TEMP(0)) || mp_int_is_odd(TEMP(1))) {
-	if ((res = mp_int_add(TEMP(0), TEMP(7), TEMP(0))) != MP_OK)
-	  goto CLEANUP;
-	if ((res = mp_int_sub(TEMP(1), TEMP(6), TEMP(1))) != MP_OK)
-	  goto CLEANUP;
+        REQUIRE(mp_int_add(TEMP(0), TEMP(7), TEMP(0)));
+        REQUIRE(mp_int_sub(TEMP(1), TEMP(6), TEMP(1)));
       }
 
       s_qdiv(TEMP(0), 1);
@@ -1634,10 +1269,8 @@
       s_qdiv(TEMP(5), 1);
 
       if (mp_int_is_odd(TEMP(2)) || mp_int_is_odd(TEMP(3))) {
-	if ((res = mp_int_add(TEMP(2), TEMP(7), TEMP(2))) != MP_OK)
-	  goto CLEANUP;
-	if ((res = mp_int_sub(TEMP(3), TEMP(6), TEMP(3))) != MP_OK)
-	  goto CLEANUP;
+        REQUIRE(mp_int_add(TEMP(2), TEMP(7), TEMP(2)));
+        REQUIRE(mp_int_sub(TEMP(3), TEMP(6), TEMP(3)));
       }
 
       s_qdiv(TEMP(2), 1);
@@ -1645,26 +1278,23 @@
     }
 
     if (mp_int_compare(TEMP(4), TEMP(5)) >= 0) {
-      if ((res = mp_int_sub(TEMP(4), TEMP(5), TEMP(4))) != MP_OK) goto CLEANUP;
-      if ((res = mp_int_sub(TEMP(0), TEMP(2), TEMP(0))) != MP_OK) goto CLEANUP;
-      if ((res = mp_int_sub(TEMP(1), TEMP(3), TEMP(1))) != MP_OK) goto CLEANUP;
-    }
-    else {
-      if ((res = mp_int_sub(TEMP(5), TEMP(4), TEMP(5))) != MP_OK) goto CLEANUP;
-      if ((res = mp_int_sub(TEMP(2), TEMP(0), TEMP(2))) != MP_OK) goto CLEANUP;
-      if ((res = mp_int_sub(TEMP(3), TEMP(1), TEMP(3))) != MP_OK) goto CLEANUP;
+      REQUIRE(mp_int_sub(TEMP(4), TEMP(5), TEMP(4)));
+      REQUIRE(mp_int_sub(TEMP(0), TEMP(2), TEMP(0)));
+      REQUIRE(mp_int_sub(TEMP(1), TEMP(3), TEMP(1)));
+    } else {
+      REQUIRE(mp_int_sub(TEMP(5), TEMP(4), TEMP(5)));
+      REQUIRE(mp_int_sub(TEMP(2), TEMP(0), TEMP(2)));
+      REQUIRE(mp_int_sub(TEMP(3), TEMP(1), TEMP(3)));
     }
 
     if (CMPZ(TEMP(4)) == 0) {
-      if (x && (res = mp_int_copy(TEMP(2), x)) != MP_OK) goto CLEANUP;
-      if (y && (res = mp_int_copy(TEMP(3), y)) != MP_OK) goto CLEANUP;
+      if (x) REQUIRE(mp_int_copy(TEMP(2), x));
+      if (y) REQUIRE(mp_int_copy(TEMP(3), y));
       if (c) {
-	if (!s_qmul(TEMP(5), k)) {
-	  res = MP_MEMORY;
-	  goto CLEANUP;
-	}
-
-	res = mp_int_copy(TEMP(5), c);
+        if (!s_qmul(TEMP(5), k)) {
+          REQUIRE(MP_MEMORY);
+        }
+        REQUIRE(mp_int_copy(TEMP(5), c));
       }
 
       break;
@@ -1672,19 +1302,11 @@
   }
 
   CLEANUP_TEMP();
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_lcm(a, b, c) */
-
-mp_result mp_int_lcm(mp_int a, mp_int b, mp_int c)
-{
-  mpz_t lcm;
-  mp_result res;
-
-  CHECK(a != NULL && b != NULL && c != NULL);
+mp_result mp_int_lcm(mp_int a, mp_int b, mp_int c) {
+  assert(a != NULL && b != NULL && c != NULL);
 
   /* Since a * b = gcd(a, b) * lcm(a, b), we can compute
      lcm(a, b) = (a / gcd(a, b)) * b.
@@ -1692,211 +1314,143 @@
      This formulation insures everything works even if the input
      variables share space.
    */
-  if ((res = mp_int_init(&lcm)) != MP_OK)
-    return res;
-  if ((res = mp_int_gcd(a, b, &lcm)) != MP_OK)
-    goto CLEANUP;
-  if ((res = mp_int_div(a, &lcm, &lcm, NULL)) != MP_OK)
-    goto CLEANUP;
-  if ((res = mp_int_mul(&lcm, b, &lcm)) != MP_OK)
-    goto CLEANUP;
+  DECLARE_TEMP(1);
+  REQUIRE(mp_int_gcd(a, b, TEMP(0)));
+  REQUIRE(mp_int_div(a, TEMP(0), TEMP(0), NULL));
+  REQUIRE(mp_int_mul(TEMP(0), b, TEMP(0)));
+  REQUIRE(mp_int_copy(TEMP(0), c));
 
-  res = mp_int_copy(&lcm, c);
-
-  CLEANUP:
-    mp_int_clear(&lcm);
-
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_divisible_value(a, v) */
-
-int       mp_int_divisible_value(mp_int a, mp_small v)
-{
+bool mp_int_divisible_value(mp_int a, mp_small v) {
   mp_small rem = 0;
 
-  if (mp_int_div_value(a, v, NULL, &rem) != MP_OK)
-    return 0;
-
+  if (mp_int_div_value(a, v, NULL, &rem) != MP_OK) {
+    return false;
+  }
   return rem == 0;
 }
 
-/* }}} */
-
-/* {{{ mp_int_is_pow2(z) */
-
-int       mp_int_is_pow2(mp_int z)
-{
-  CHECK(z != NULL);
+int mp_int_is_pow2(mp_int z) {
+  assert(z != NULL);
 
   return s_isp2(z);
 }
 
-/* }}} */
-
-/* {{{ mp_int_root(a, b, c) */
-
 /* Implementation of Newton's root finding method, based loosely on a patch
    contributed by Hal Finkel <half@halssoftware.com>
    modified by M. J. Fromberger.
  */
-mp_result mp_int_root(mp_int a, mp_small b, mp_int c)
-{
-  mp_result res = MP_OK;
-  int flips = 0;
-  DECLARE_TEMP(5);
-
-  CHECK(a != NULL && c != NULL && b > 0);
+mp_result mp_int_root(mp_int a, mp_small b, mp_int c) {
+  assert(a != NULL && c != NULL && b > 0);
 
   if (b == 1) {
     return mp_int_copy(a, c);
   }
+  bool flips = false;
   if (MP_SIGN(a) == MP_NEG) {
-    if (b % 2 == 0)
+    if (b % 2 == 0) {
       return MP_UNDEF; /* root does not exist for negative a with even b */
-    else
-      flips = 1;
+    } else {
+      flips = true;
+    }
   }
 
-  SETUP(mp_int_init_copy(LAST_TEMP(), a));
-  SETUP(mp_int_init_copy(LAST_TEMP(), a));
-  SETUP(mp_int_init(LAST_TEMP()));
-  SETUP(mp_int_init(LAST_TEMP()));
-  SETUP(mp_int_init(LAST_TEMP()));
-
-  (void) mp_int_abs(TEMP(0), TEMP(0));
-  (void) mp_int_abs(TEMP(1), TEMP(1));
+  DECLARE_TEMP(5);
+  REQUIRE(mp_int_copy(a, TEMP(0)));
+  REQUIRE(mp_int_copy(a, TEMP(1)));
+  TEMP(0)->sign = MP_ZPOS;
+  TEMP(1)->sign = MP_ZPOS;
 
   for (;;) {
-    if ((res = mp_int_expt(TEMP(1), b, TEMP(2))) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_expt(TEMP(1), b, TEMP(2)));
 
-    if (mp_int_compare_unsigned(TEMP(2), TEMP(0)) <= 0)
-      break;
+    if (mp_int_compare_unsigned(TEMP(2), TEMP(0)) <= 0) break;
 
-    if ((res = mp_int_sub(TEMP(2), TEMP(0), TEMP(2))) != MP_OK)
-      goto CLEANUP;
-    if ((res = mp_int_expt(TEMP(1), b - 1, TEMP(3))) != MP_OK)
-      goto CLEANUP;
-    if ((res = mp_int_mul_value(TEMP(3), b, TEMP(3))) != MP_OK)
-      goto CLEANUP;
-    if ((res = mp_int_div(TEMP(2), TEMP(3), TEMP(4), NULL)) != MP_OK)
-      goto CLEANUP;
-    if ((res = mp_int_sub(TEMP(1), TEMP(4), TEMP(4))) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_sub(TEMP(2), TEMP(0), TEMP(2)));
+    REQUIRE(mp_int_expt(TEMP(1), b - 1, TEMP(3)));
+    REQUIRE(mp_int_mul_value(TEMP(3), b, TEMP(3)));
+    REQUIRE(mp_int_div(TEMP(2), TEMP(3), TEMP(4), NULL));
+    REQUIRE(mp_int_sub(TEMP(1), TEMP(4), TEMP(4)));
 
     if (mp_int_compare_unsigned(TEMP(1), TEMP(4)) == 0) {
-      if ((res = mp_int_sub_value(TEMP(4), 1, TEMP(4))) != MP_OK)
-	goto CLEANUP;
+      REQUIRE(mp_int_sub_value(TEMP(4), 1, TEMP(4)));
     }
-    if ((res = mp_int_copy(TEMP(4), TEMP(1))) != MP_OK)
-      goto CLEANUP;
+    REQUIRE(mp_int_copy(TEMP(4), TEMP(1)));
   }
 
-  if ((res = mp_int_copy(TEMP(1), c)) != MP_OK)
-    goto CLEANUP;
+  REQUIRE(mp_int_copy(TEMP(1), c));
 
   /* If the original value of a was negative, flip the output sign. */
-  if (flips)
-    (void) mp_int_neg(c, c); /* cannot fail */
+  if (flips) (void)mp_int_neg(c, c); /* cannot fail */
 
   CLEANUP_TEMP();
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_to_int(z, *out) */
-
-mp_result mp_int_to_int(mp_int z, mp_small *out)
-{
-  mp_usmall uv = 0;
-  mp_size   uz;
-  mp_digit *dz;
-  mp_sign   sz;
-
-  CHECK(z != NULL);
+mp_result mp_int_to_int(mp_int z, mp_small *out) {
+  assert(z != NULL);
 
   /* Make sure the value is representable as a small integer */
-  sz = MP_SIGN(z);
+  mp_sign sz = MP_SIGN(z);
   if ((sz == MP_ZPOS && mp_int_compare_value(z, MP_SMALL_MAX) > 0) ||
-      mp_int_compare_value(z, MP_SMALL_MIN) < 0)
+      mp_int_compare_value(z, MP_SMALL_MIN) < 0) {
     return MP_RANGE;
+  }
 
-  uz = MP_USED(z);
-  dz = MP_DIGITS(z) + uz - 1;
-
+  mp_usmall uz = MP_USED(z);
+  mp_digit *dz = MP_DIGITS(z) + uz - 1;
+  mp_small uv = 0;
   while (uz > 0) {
-    uv <<= MP_DIGIT_BIT/2;
-    uv = (uv << (MP_DIGIT_BIT/2)) | *dz--;
+    uv <<= MP_DIGIT_BIT / 2;
+    uv = (uv << (MP_DIGIT_BIT / 2)) | *dz--;
     --uz;
   }
 
-  if (out)
-    *out = (sz == MP_NEG) ? -(mp_small)uv : (mp_small)uv;
+  if (out) *out = (mp_small)((sz == MP_NEG) ? -uv : uv);
 
   return MP_OK;
 }
 
-/* }}} */
+mp_result mp_int_to_uint(mp_int z, mp_usmall *out) {
+  assert(z != NULL);
 
-/* {{{ mp_int_to_uint(z, *out) */
+  /* Make sure the value is representable as an unsigned small integer */
+  mp_size sz = MP_SIGN(z);
+  if (sz == MP_NEG || mp_int_compare_uvalue(z, MP_USMALL_MAX) > 0) {
+    return MP_RANGE;
+  }
 
-mp_result mp_int_to_uint(mp_int z, mp_usmall *out)
-{
+  mp_size uz = MP_USED(z);
+  mp_digit *dz = MP_DIGITS(z) + uz - 1;
   mp_usmall uv = 0;
-  mp_size   uz;
-  mp_digit *dz;
-  mp_sign   sz;
-  
-  CHECK(z != NULL);
 
-  /* Make sure the value is representable as an unsigned small integer */
-  sz = MP_SIGN(z);
-  if (sz == MP_NEG || mp_int_compare_uvalue(z, MP_USMALL_MAX) > 0)
-    return MP_RANGE;
-     
-  uz = MP_USED(z);
-  dz = MP_DIGITS(z) + uz - 1;
-  
   while (uz > 0) {
-    uv <<= MP_DIGIT_BIT/2;
-    uv = (uv << (MP_DIGIT_BIT/2)) | *dz--;
+    uv <<= MP_DIGIT_BIT / 2;
+    uv = (uv << (MP_DIGIT_BIT / 2)) | *dz--;
     --uz;
   }
-  
-  if (out)
-    *out = uv;
-  
-  return MP_OK;
-}
 
-/* }}} */
+  if (out) *out = uv;
 
-/* {{{ mp_int_to_string(z, radix, str, limit) */
-
-mp_result mp_int_to_string(mp_int z, mp_size radix,
-			   char *str, int limit)
-{
-  mp_result res;
-  int       cmp = 0;
-
-  CHECK(z != NULL && str != NULL && limit >= 2);
+  return MP_OK;
+}
 
-  if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX)
-    return MP_RANGE;
+mp_result mp_int_to_string(mp_int z, mp_size radix, char *str, int limit) {
+  assert(z != NULL && str != NULL && limit >= 2);
+  assert(radix >= MP_MIN_RADIX && radix <= MP_MAX_RADIX);
 
+  int cmp = 0;
   if (CMPZ(z) == 0) {
     *str++ = s_val2ch(0, 1);
-  }
-  else {
+  } else {
+    mp_result res;
     mpz_t tmp;
-    char  *h, *t;
+    char *h, *t;
 
-    if ((res = mp_int_init_copy(&tmp, z)) != MP_OK)
-      return res;
+    if ((res = mp_int_init_copy(&tmp, z)) != MP_OK) return res;
 
     if (MP_SIGN(z) == MP_NEG) {
       *str++ = '-';
@@ -1908,8 +1462,7 @@
     for (/* */; limit > 0; --limit) {
       mp_digit d;
 
-      if ((cmp = CMPZ(&tmp)) == 0)
-	break;
+      if ((cmp = CMPZ(&tmp)) == 0) break;
 
       d = s_ddiv(&tmp, (mp_digit)radix);
       *str++ = s_val2ch(d, 1);
@@ -1927,83 +1480,60 @@
   }
 
   *str = '\0';
-  if (cmp == 0)
+  if (cmp == 0) {
     return MP_OK;
-  else
+  } else {
     return MP_TRUNC;
+  }
 }
 
-/* }}} */
-
-/* {{{ mp_int_string_len(z, radix) */
-
-mp_result mp_int_string_len(mp_int z, mp_size radix)
-{
-  int  len;
+mp_result mp_int_string_len(mp_int z, mp_size radix) {
+  assert(z != NULL);
+  assert(radix >= MP_MIN_RADIX && radix <= MP_MAX_RADIX);
 
-  CHECK(z != NULL);
-
-  if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX)
-    return MP_RANGE;
-
-  len = s_outlen(z, radix) + 1; /* for terminator */
+  int len = s_outlen(z, radix) + 1; /* for terminator */
 
   /* Allow for sign marker on negatives */
-  if (MP_SIGN(z) == MP_NEG)
-    len += 1;
+  if (MP_SIGN(z) == MP_NEG) len += 1;
 
   return len;
 }
 
-/* }}} */
-
-/* {{{ mp_int_read_string(z, radix, *str) */
-
 /* Read zero-terminated string into z */
-mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str)
-{
+mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str) {
   return mp_int_read_cstring(z, radix, str, NULL);
 }
 
-/* }}} */
-
-/* {{{ mp_int_read_cstring(z, radix, *str, **end) */
-
-mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str, char **end)
-{
-  int ch;
-
-  CHECK(z != NULL && str != NULL);
-
-  if (radix < MP_MIN_RADIX || radix > MP_MAX_RADIX)
-    return MP_RANGE;
+mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str,
+                              char **end) {
+  assert(z != NULL && str != NULL);
+  assert(radix >= MP_MIN_RADIX && radix <= MP_MAX_RADIX);
 
   /* Skip leading whitespace */
-  while (isspace((int)*str))
-    ++str;
+  while (isspace((unsigned char)*str)) ++str;
 
   /* Handle leading sign tag (+/-, positive default) */
   switch (*str) {
-  case '-':
-    MP_SIGN(z) = MP_NEG;
-    ++str;
-    break;
-  case '+':
-    ++str; /* fallthrough */
-  default:
-    MP_SIGN(z) = MP_ZPOS;
-    break;
+    case '-':
+      z->sign = MP_NEG;
+      ++str;
+      break;
+    case '+':
+      ++str; /* fallthrough */
+    default:
+      z->sign = MP_ZPOS;
+      break;
   }
 
   /* Skip leading zeroes */
-  while ((ch = s_ch2val(*str, radix)) == 0)
-    ++str;
+  int ch;
+  while ((ch = s_ch2val(*str, radix)) == 0) ++str;
 
   /* Make sure there is enough space for the value */
-  if (!s_pad(z, s_inlen(strlen(str), radix)))
-    return MP_MEMORY;
+  if (!s_pad(z, s_inlen(strlen(str), radix))) return MP_MEMORY;
 
-  MP_USED(z) = 1; z->digits0 = 0;
+  z->used = 1;
+  z->digits0 = 0;
 
   while (*str != '\0' && ((ch = s_ch2val(*str, radix)) >= 0)) {
     s_dmul(z, (mp_digit)radix);
@@ -2014,38 +1544,28 @@
   CLAMP(z);
 
   /* Override sign for zero, even if negative specified. */
-  if (CMPZ(z) == 0)
-    MP_SIGN(z) = MP_ZPOS;
+  if (CMPZ(z) == 0) z->sign = MP_ZPOS;
 
-  if (end != NULL)
-    *end = (char *)str;
+  if (end != NULL) *end = (char *)str;
 
   /* Return a truncation error if the string has unprocessed characters
      remaining, so the caller can tell if the whole string was done */
-  if (*str != '\0')
+  if (*str != '\0') {
     return MP_TRUNC;
-  else
+  } else {
     return MP_OK;
+  }
 }
 
-/* }}} */
+mp_result mp_int_count_bits(mp_int z) {
+  assert(z != NULL);
 
-/* {{{ mp_int_count_bits(z) */
-
-mp_result mp_int_count_bits(mp_int z)
-{
-  mp_size  nbits = 0, uz;
-  mp_digit d;
-
-  CHECK(z != NULL);
-
-  uz = MP_USED(z);
-  if (uz == 1 && z->digits0 == 0)
-    return 1;
+  mp_size uz = MP_USED(z);
+  if (uz == 1 && z->digits0 == 0) return 1;
 
   --uz;
-  nbits = uz * MP_DIGIT_BIT;
-  d = z->digitsuz;
+  mp_size nbits = uz * MP_DIGIT_BIT;
+  mp_digit d = z->digitsuz;
 
   while (d != 0) {
     d >>= 1;
@@ -2055,267 +1575,173 @@
   return nbits;
 }
 
-/* }}} */
-
-/* {{{ mp_int_to_binary(z, buf, limit) */
-
-mp_result mp_int_to_binary(mp_int z, unsigned char *buf, int limit)
-{
+mp_result mp_int_to_binary(mp_int z, unsigned char *buf, int limit) {
   static const int PAD_FOR_2C = 1;
 
-  mp_result res;
-  int limpos = limit;
+  assert(z != NULL && buf != NULL);
 
-  CHECK(z != NULL && buf != NULL);
-
-  res = s_tobin(z, buf, &limpos, PAD_FOR_2C);
+  int limpos = limit;
+  mp_result res = s_tobin(z, buf, &limpos, PAD_FOR_2C);
 
-  if (MP_SIGN(z) == MP_NEG)
-    s_2comp(buf, limpos);
+  if (MP_SIGN(z) == MP_NEG) s_2comp(buf, limpos);
 
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_int_read_binary(z, buf, len) */
-
-mp_result mp_int_read_binary(mp_int z, unsigned char *buf, int len)
-{
-  mp_size need, i;
-  unsigned char *tmp;
-  mp_digit *dz;
-
-  CHECK(z != NULL && buf != NULL && len > 0);
+mp_result mp_int_read_binary(mp_int z, unsigned char *buf, int len) {
+  assert(z != NULL && buf != NULL && len > 0);
 
   /* Figure out how many digits are needed to represent this value */
-  need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT;
-  if (!s_pad(z, need))
-    return MP_MEMORY;
+  mp_size need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT;
+  if (!s_pad(z, need)) return MP_MEMORY;
 
   mp_int_zero(z);
 
   /* If the high-order bit is set, take the 2's complement before reading the
      value (it will be restored afterward) */
   if (buf0 >> (CHAR_BIT - 1)) {
-    MP_SIGN(z) = MP_NEG;
+    z->sign = MP_NEG;
     s_2comp(buf, len);
   }
 
-  dz = MP_DIGITS(z);
-  for (tmp = buf, i = len; i > 0; --i, ++tmp) {
-    s_qmul(z, (mp_size) CHAR_BIT);
+  mp_digit *dz = MP_DIGITS(z);
+  unsigned char *tmp = buf;
+  for (int i = len; i > 0; --i, ++tmp) {
+    s_qmul(z, (mp_size)CHAR_BIT);
     *dz |= *tmp;
   }
 
   /* Restore 2's complement if we took it before */
-  if (MP_SIGN(z) == MP_NEG)
-    s_2comp(buf, len);
+  if (MP_SIGN(z) == MP_NEG) s_2comp(buf, len);
 
   return MP_OK;
 }
 
-/* }}} */
+mp_result mp_int_binary_len(mp_int z) {
+  mp_result res = mp_int_count_bits(z);
+  if (res <= 0) return res;
 
-/* {{{ mp_int_binary_len(z) */
-
-mp_result mp_int_binary_len(mp_int z)
-{
-  mp_result  res = mp_int_count_bits(z);
-  int        bytes = mp_int_unsigned_len(z);
-
-  if (res <= 0)
-    return res;
-
-  bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT;
+  int bytes = mp_int_unsigned_len(z);
 
   /* If the highest-order bit falls exactly on a byte boundary, we need to pad
      with an extra byte so that the sign will be read correctly when reading it
      back in. */
-  if (bytes * CHAR_BIT == res)
-    ++bytes;
+  if (bytes * CHAR_BIT == res) ++bytes;
 
   return bytes;
 }
 
-/* }}} */
-
-/* {{{ mp_int_to_unsigned(z, buf, limit) */
-
-mp_result mp_int_to_unsigned(mp_int z, unsigned char *buf, int limit)
-{
+mp_result mp_int_to_unsigned(mp_int z, unsigned char *buf, int limit) {
   static const int NO_PADDING = 0;
 
-  CHECK(z != NULL && buf != NULL);
+  assert(z != NULL && buf != NULL);
 
   return s_tobin(z, buf, &limit, NO_PADDING);
 }
 
-/* }}} */
-
-/* {{{ mp_int_read_unsigned(z, buf, len) */
-
-mp_result mp_int_read_unsigned(mp_int z, unsigned char *buf, int len)
-{
-  mp_size need, i;
-  unsigned char *tmp;
-
-  CHECK(z != NULL && buf != NULL && len > 0);
+mp_result mp_int_read_unsigned(mp_int z, unsigned char *buf, int len) {
+  assert(z != NULL && buf != NULL && len > 0);
 
   /* Figure out how many digits are needed to represent this value */
-  need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT;
-  if (!s_pad(z, need))
-    return MP_MEMORY;
+  mp_size need = ((len * CHAR_BIT) + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT;
+  if (!s_pad(z, need)) return MP_MEMORY;
 
   mp_int_zero(z);
 
-  for (tmp = buf, i = len; i > 0; --i, ++tmp) {
-    (void) s_qmul(z, CHAR_BIT);
+  unsigned char *tmp = buf;
+  for (int i = len; i > 0; --i, ++tmp) {
+    (void)s_qmul(z, CHAR_BIT);
     *MP_DIGITS(z) |= *tmp;
   }
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_int_unsigned_len(z) */
-
-mp_result mp_int_unsigned_len(mp_int z)
-{
-  mp_result  res = mp_int_count_bits(z);
-  int        bytes;
-
-  if (res <= 0)
-    return res;
-
-  bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT;
+mp_result mp_int_unsigned_len(mp_int z) {
+  mp_result res = mp_int_count_bits(z);
+  if (res <= 0) return res;
 
+  int bytes = (res + (CHAR_BIT - 1)) / CHAR_BIT;
   return bytes;
 }
 
-/* }}} */
-
-/* {{{ mp_error_string(res) */
-
-const char *mp_error_string(mp_result res)
-{
-  int ix;
-  if (res > 0)
-    return s_unknown_err;
+const char *mp_error_string(mp_result res) {
+  if (res > 0) return s_unknown_err;
 
   res = -res;
+  int ix;
   for (ix = 0; ix < res && s_error_msgix != NULL; ++ix)
     ;
 
-  if (s_error_msgix != NULL)
+  if (s_error_msgix != NULL) {
     return s_error_msgix;
-  else
+  } else {
     return s_unknown_err;
+  }
 }
 
-/* }}} */
-
 /*------------------------------------------------------------------------*/
 /* Private functions for internal use.  These make assumptions.           */
 
-/* {{{ s_alloc(num) */
+#if DEBUG
+static const mp_digit fill = (mp_digit)0xdeadbeefabad1dea;
+#endif
 
-STATIC mp_digit *s_alloc(mp_size num)
-{
+static mp_digit *s_alloc(mp_size num) {
   mp_digit *out = malloc(num * sizeof(mp_digit));
+  assert(out != NULL);
 
-  assert(out != NULL); /* for debugging */
-#if DEBUG > 1
-  {
-    mp_digit v = (mp_digit) 0xdeadbeef;
-    int      ix;
-
-    for (ix = 0; ix < num; ++ix)
-      outix = v;
-  }
+#if DEBUG
+  for (mp_size ix = 0; ix < num; ++ix) outix = fill;
 #endif
-
   return out;
 }
 
-/* }}} */
-
-/* {{{ s_realloc(old, osize, nsize) */
-
-STATIC mp_digit *s_realloc(mp_digit *old, mp_size osize, mp_size nsize)
-{
-#if DEBUG > 1
+static mp_digit *s_realloc(mp_digit *old, mp_size osize, mp_size nsize) {
+#if DEBUG
   mp_digit *new = s_alloc(nsize);
-  int       ix;
-
-  for (ix = 0; ix < nsize; ++ix)
-    newix = (mp_digit) 0xdeadbeef;
+  assert(new != NULL);
 
+  for (mp_size ix = 0; ix < nsize; ++ix) newix = fill;
   memcpy(new, old, osize * sizeof(mp_digit));
 #else
   mp_digit *new = realloc(old, nsize * sizeof(mp_digit));
-
-  assert(new != NULL); /* for debugging */
+  assert(new != NULL);
 #endif
-  return new;
-}
-
-/* }}} */
-
-/* {{{ s_free(ptr) */
 
-STATIC void s_free(void *ptr)
-{
-  free(ptr);
+  return new;
 }
 
-/* }}} */
-
-/* {{{ s_pad(z, min) */
+static void s_free(void *ptr) { free(ptr); }
 
-STATIC int      s_pad(mp_int z, mp_size min)
-{
+static bool s_pad(mp_int z, mp_size min) {
   if (MP_ALLOC(z) < min) {
-    mp_size nsize = ROUND_PREC(min);
+    mp_size nsize = s_round_prec(min);
     mp_digit *tmp;
 
-    if ((void *)z->digits == (void *)z) {
-      if ((tmp = s_alloc(nsize)) == NULL)
-        return 0;
-
-      COPY(MP_DIGITS(z), tmp, MP_USED(z));
+    if (z->digits == &(z->single)) {
+      if ((tmp = s_alloc(nsize)) == NULL) return false;
+      tmp0 = z->single;
+    } else if ((tmp = s_realloc(MP_DIGITS(z), MP_ALLOC(z), nsize)) == NULL) {
+      return false;
     }
-    else if ((tmp = s_realloc(MP_DIGITS(z), MP_ALLOC(z), nsize)) == NULL)
-      return 0;
 
-    MP_DIGITS(z) = tmp;
-    MP_ALLOC(z) = nsize;
+    z->digits = tmp;
+    z->alloc = nsize;
   }
 
-  return 1;
+  return true;
 }
 
-/* }}} */
-
-/* {{{ s_fake(z, value, vbuf) */
-
 /* Note: This will not work correctly when value == MP_SMALL_MIN */
-STATIC void      s_fake(mp_int z, mp_small value, mp_digit vbuf)
-{
-  mp_usmall uv = (mp_usmall) (value < 0) ? -value : value;
+static void s_fake(mp_int z, mp_small value, mp_digit vbuf) {
+  mp_usmall uv = (mp_usmall)(value < 0) ? -value : value;
   s_ufake(z, uv, vbuf);
-  if (value < 0)
-    z->sign = MP_NEG;
+  if (value < 0) z->sign = MP_NEG;
 }
 
-/* }}} */
-
-/* {{{ s_ufake(z, value, vbuf) */
-
-STATIC void      s_ufake(mp_int z, mp_usmall value, mp_digit vbuf)
-{
-  mp_size ndig = (mp_size) s_uvpack(value, vbuf);
+static void s_ufake(mp_int z, mp_usmall value, mp_digit vbuf) {
+  mp_size ndig = (mp_size)s_uvpack(value, vbuf);
 
   z->used = ndig;
   z->alloc = MP_VALUE_DIGITS(value);
@@ -2323,77 +1749,54 @@
   z->digits = vbuf;
 }
 
-/* }}} */
-
-/* {{{ s_cdig(da, db, len) */
-
-STATIC int      s_cdig(mp_digit *da, mp_digit *db, mp_size len)
-{
+static int s_cdig(mp_digit *da, mp_digit *db, mp_size len) {
   mp_digit *dat = da + len - 1, *dbt = db + len - 1;
 
   for (/* */; len != 0; --len, --dat, --dbt) {
-    if (*dat > *dbt)
+    if (*dat > *dbt) {
       return 1;
-    else if (*dat < *dbt)
+    } else if (*dat < *dbt) {
       return -1;
+    }
   }
 
   return 0;
 }
 
-/* }}} */
-
-/* {{{ s_uvpack(uv, t) */
-
-STATIC int       s_uvpack(mp_usmall uv, mp_digit t)
-{
+static int s_uvpack(mp_usmall uv, mp_digit t) {
   int ndig = 0;
 
   if (uv == 0)
     tndig++ = 0;
   else {
     while (uv != 0) {
-      tndig++ = (mp_digit) uv;
-      uv >>= MP_DIGIT_BIT/2;
-      uv >>= MP_DIGIT_BIT/2;
+      tndig++ = (mp_digit)uv;
+      uv >>= MP_DIGIT_BIT / 2;
+      uv >>= MP_DIGIT_BIT / 2;
     }
   }
 
   return ndig;
 }
 
-/* }}} */
-
-/* {{{ s_ucmp(a, b) */
-
-STATIC int      s_ucmp(mp_int a, mp_int b)
-{
-  mp_size  ua = MP_USED(a), ub = MP_USED(b);
+static int s_ucmp(mp_int a, mp_int b) {
+  mp_size ua = MP_USED(a), ub = MP_USED(b);
 
-  if (ua > ub)
+  if (ua > ub) {
     return 1;
-  else if (ub > ua)
+  } else if (ub > ua) {
     return -1;
-  else
+  } else {
     return s_cdig(MP_DIGITS(a), MP_DIGITS(b), ua);
+  }
 }
 
-/* }}} */
-
-/* {{{ s_vcmp(a, v) */
-
-STATIC int      s_vcmp(mp_int a, mp_small v)
-{
-  mp_usmall uv = (mp_usmall) (v < 0) ? -v : v;
+static int s_vcmp(mp_int a, mp_small v) {
+  mp_usmall uv = (v < 0) ? -(mp_usmall)v : (mp_usmall)v;
   return s_uvcmp(a, uv);
 }
 
-/* }}} */
-
-/* {{{ s_uvcmp(a, v) */
-
-STATIC int      s_uvcmp(mp_int a, mp_usmall uv)
-{
+static int s_uvcmp(mp_int a, mp_usmall uv) {
   mpz_t vtmp;
   mp_digit vdigMP_VALUE_DIGITS(uv);
 
@@ -2401,13 +1804,8 @@
   return s_ucmp(a, &vtmp);
 }
 
-/* }}} */
-
-/* {{{ s_uadd(da, db, dc, size_a, size_b) */
-
-STATIC mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc,
-		       mp_size size_a, mp_size size_b)
-{
+static mp_digit s_uadd(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                       mp_size size_b) {
   mp_size pos;
   mp_word w = 0;
 
@@ -2419,7 +1817,7 @@
 
   /* Add corresponding digits until the shorter number runs out */
   for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) {
-    w = w + (mp_word) *da + (mp_word) *db;
+    w = w + (mp_word)*da + (mp_word)*db;
     *dc = LOWER_HALF(w);
     w = UPPER_HALF(w);
   }
@@ -2436,13 +1834,8 @@
   return (mp_digit)w;
 }
 
-/* }}} */
-
-/* {{{ s_usub(da, db, dc, size_a, size_b) */
-
-STATIC void     s_usub(mp_digit *da, mp_digit *db, mp_digit *dc,
-		       mp_size size_a, mp_size size_b)
-{
+static void s_usub(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                   mp_size size_b) {
   mp_size pos;
   mp_word w = 0;
 
@@ -2451,8 +1844,9 @@
 
   /* Subtract corresponding digits and propagate borrow */
   for (pos = 0; pos < size_b; ++pos, ++da, ++db, ++dc) {
-    w = ((mp_word)MP_DIGIT_MAX + 1 +  /* MP_RADIX */
-	 (mp_word)*da) - w - (mp_word)*db;
+    w = ((mp_word)MP_DIGIT_MAX + 1 + /* MP_RADIX */
+         (mp_word)*da) -
+        w - (mp_word)*db;
 
     *dc = LOWER_HALF(w);
     w = (UPPER_HALF(w) == 0);
@@ -2460,8 +1854,9 @@
 
   /* Finish the subtraction for remaining upper digits of da */
   for (/* */; pos < size_a; ++pos, ++da, ++dc) {
-    w = ((mp_word)MP_DIGIT_MAX + 1 +  /* MP_RADIX */
-	 (mp_word)*da) - w;
+    w = ((mp_word)MP_DIGIT_MAX + 1 + /* MP_RADIX */
+         (mp_word)*da) -
+        w;
 
     *dc = LOWER_HALF(w);
     w = (UPPER_HALF(w) == 0);
@@ -2471,14 +1866,9 @@
   assert(w == 0);
 }
 
-/* }}} */
-
-/* {{{ s_kmul(da, db, dc, size_a, size_b) */
-
-STATIC int       s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc,
-			mp_size size_a, mp_size size_b)
-{
-  mp_size  bot_size;
+static int s_kmul(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                  mp_size size_b) {
+  mp_size bot_size;
 
   /* Make sure b is the smaller of the two input values */
   if (size_b > size_a) {
@@ -2495,18 +1885,15 @@
      algorithm to compute the product; otherwise use the normal multiplication
      algorithm
    */
-  if (multiply_threshold &&
-      size_a >= multiply_threshold &&
-      size_b > bot_size) {
-
+  if (multiply_threshold && size_a >= multiply_threshold && size_b > bot_size) {
     mp_digit *t1, *t2, *t3, carry;
 
     mp_digit *a_top = da + bot_size;
     mp_digit *b_top = db + bot_size;
 
-    mp_size  at_size = size_a - bot_size;
-    mp_size  bt_size = size_b - bot_size;
-    mp_size  buf_size = 2 * bot_size;
+    mp_size at_size = size_a - bot_size;
+    mp_size bt_size = size_b - bot_size;
+    mp_size buf_size = 2 * bot_size;
 
     /* Do a single allocation for all three temporary buffers needed; each
        buffer must be big enough to hold the product of two bottom halves, and
@@ -2521,21 +1908,21 @@
     /* t1 and t2 are initially used as temporaries to compute the inner product
        (a1 + a0)(b1 + b0) = a1b1 + a1b0 + a0b1 + a0b0
      */
-    carry = s_uadd(da, a_top, t1, bot_size, at_size);      /* t1 = a1 + a0 */
+    carry = s_uadd(da, a_top, t1, bot_size, at_size); /* t1 = a1 + a0 */
     t1bot_size = carry;
 
-    carry = s_uadd(db, b_top, t2, bot_size, bt_size);      /* t2 = b1 + b0 */
+    carry = s_uadd(db, b_top, t2, bot_size, bt_size); /* t2 = b1 + b0 */
     t2bot_size = carry;
 
-    (void) s_kmul(t1, t2, t3, bot_size + 1, bot_size + 1); /* t3 = t1 * t2 */
+    (void)s_kmul(t1, t2, t3, bot_size + 1, bot_size + 1); /* t3 = t1 * t2 */
 
     /* Now we'll get t1 = a0b0 and t2 = a1b1, and subtract them out so that
        we're left with only the pieces we want:  t3 = a1b0 + a0b1
      */
     ZERO(t1, buf_size);
     ZERO(t2, buf_size);
-    (void) s_kmul(da, db, t1, bot_size, bot_size);     /* t1 = a0 * b0 */
-    (void) s_kmul(a_top, b_top, t2, at_size, bt_size); /* t2 = a1 * b1 */
+    (void)s_kmul(da, db, t1, bot_size, bot_size);     /* t1 = a0 * b0 */
+    (void)s_kmul(a_top, b_top, t2, at_size, bt_size); /* t2 = a1 * b1 */
 
     /* Subtract out t1 and t2 to get the inner product */
     s_usub(t3, t1, t3, buf_size + 2, buf_size);
@@ -2543,30 +1930,23 @@
 
     /* Assemble the output value */
     COPY(t1, dc, buf_size);
-    carry = s_uadd(t3, dc + bot_size, dc + bot_size,
-		   buf_size + 1, buf_size);
+    carry = s_uadd(t3, dc + bot_size, dc + bot_size, buf_size + 1, buf_size);
     assert(carry == 0);
 
-    carry = s_uadd(t2, dc + 2*bot_size, dc + 2*bot_size,
-		   buf_size, buf_size);
+    carry =
+        s_uadd(t2, dc + 2 * bot_size, dc + 2 * bot_size, buf_size, buf_size);
     assert(carry == 0);
 
     s_free(t1); /* note t2 and t3 are just internal pointers to t1 */
-  }
-  else {
+  } else {
     s_umul(da, db, dc, size_a, size_b);
   }
 
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_umul(da, db, dc, size_a, size_b) */
-
-STATIC void     s_umul(mp_digit *da, mp_digit *db, mp_digit *dc,
-		       mp_size size_a, mp_size size_b)
-{
+static void s_umul(mp_digit *da, mp_digit *db, mp_digit *dc, mp_size size_a,
+                   mp_size size_b) {
   mp_size a, b;
   mp_word w;
 
@@ -2574,8 +1954,7 @@
     mp_digit *dct = dc;
     mp_digit *dbt = db;
 
-    if (*da == 0)
-      continue;
+    if (*da == 0) continue;
 
     w = 0;
     for (b = 0; b < size_b; ++b, ++dbt, ++dct) {
@@ -2589,28 +1968,23 @@
   }
 }
 
-/* }}} */
-
-/* {{{ s_ksqr(da, dc, size_a) */
-
-STATIC int       s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a)
-{
+static int s_ksqr(mp_digit *da, mp_digit *dc, mp_size size_a) {
   if (multiply_threshold && size_a > multiply_threshold) {
-    mp_size  bot_size = (size_a + 1) / 2;
+    mp_size bot_size = (size_a + 1) / 2;
     mp_digit *a_top = da + bot_size;
     mp_digit *t1, *t2, *t3, carry;
-    mp_size  at_size = size_a - bot_size;
-    mp_size  buf_size = 2 * bot_size;
+    mp_size at_size = size_a - bot_size;
+    mp_size buf_size = 2 * bot_size;
 
     if ((t1 = s_alloc(4 * buf_size)) == NULL) return 0;
     t2 = t1 + buf_size;
     t3 = t2 + buf_size;
     ZERO(t1, 4 * buf_size);
 
-    (void) s_ksqr(da, t1, bot_size);    /* t1 = a0 ^ 2 */
-    (void) s_ksqr(a_top, t2, at_size);  /* t2 = a1 ^ 2 */
+    (void)s_ksqr(da, t1, bot_size);   /* t1 = a0 ^ 2 */
+    (void)s_ksqr(a_top, t2, at_size); /* t2 = a1 ^ 2 */
 
-    (void) s_kmul(da, a_top, t3, bot_size, at_size);  /* t3 = a0 * a1 */
+    (void)s_kmul(da, a_top, t3, bot_size, at_size); /* t3 = a0 * a1 */
 
     /* Quick multiply t3 by 2, shifting left (can't overflow) */
     {
@@ -2618,83 +1992,75 @@
       mp_word w, save = 0;
 
       for (i = 0; i < top; ++i) {
-	w = t3i;
-	w = (w << 1) | save;
-	t3i = LOWER_HALF(w);
-	save = UPPER_HALF(w);
+        w = t3i;
+        w = (w << 1) | save;
+        t3i = LOWER_HALF(w);
+        save = UPPER_HALF(w);
       }
       t3i = LOWER_HALF(save);
     }
 
     /* Assemble the output value */
     COPY(t1, dc, 2 * bot_size);
-    carry = s_uadd(t3, dc + bot_size, dc + bot_size,
-		   buf_size + 1, buf_size);
+    carry = s_uadd(t3, dc + bot_size, dc + bot_size, buf_size + 1, buf_size);
     assert(carry == 0);
 
-    carry = s_uadd(t2, dc + 2*bot_size, dc + 2*bot_size,
-		   buf_size, buf_size);
+    carry =
+        s_uadd(t2, dc + 2 * bot_size, dc + 2 * bot_size, buf_size, buf_size);
     assert(carry == 0);
 
     s_free(t1); /* note that t2 and t2 are internal pointers only */
 
-  } 
-  else {
+  } else {
     s_usqr(da, dc, size_a);
   }
 
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_usqr(da, dc, size_a) */
-
-STATIC void      s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a)
-{
+static void s_usqr(mp_digit *da, mp_digit *dc, mp_size size_a) {
   mp_size i, j;
   mp_word w;
 
   for (i = 0; i < size_a; ++i, dc += 2, ++da) {
-    mp_digit  *dct = dc, *dat = da;
+    mp_digit *dct = dc, *dat = da;
 
-    if (*da == 0)
-      continue;
+    if (*da == 0) continue;
 
     /* Take care of the first digit, no rollover */
     w = (mp_word)*dat * (mp_word)*dat + (mp_word)*dct;
     *dct = LOWER_HALF(w);
     w = UPPER_HALF(w);
-    ++dat; ++dct;
+    ++dat;
+    ++dct;
 
     for (j = i + 1; j < size_a; ++j, ++dat, ++dct) {
-      mp_word  t = (mp_word)*da * (mp_word)*dat;
-      mp_word  u = w + (mp_word)*dct, ov = 0;
+      mp_word t = (mp_word)*da * (mp_word)*dat;
+      mp_word u = w + (mp_word)*dct, ov = 0;
 
       /* Check if doubling t will overflow a word */
-      if (HIGH_BIT_SET(t))
-	ov = 1;
+      if (HIGH_BIT_SET(t)) ov = 1;
 
       w = t + t;
 
       /* Check if adding u to w will overflow a word */
-      if (ADD_WILL_OVERFLOW(w, u))
-	ov = 1;
+      if (ADD_WILL_OVERFLOW(w, u)) ov = 1;
 
       w += u;
 
       *dct = LOWER_HALF(w);
       w = UPPER_HALF(w);
       if (ov) {
-	w += MP_DIGIT_MAX; /* MP_RADIX */
-	++w;
+        w += MP_DIGIT_MAX; /* MP_RADIX */
+        ++w;
       }
     }
 
     w = w + *dct;
     *dct = (mp_digit)w;
     while ((w = UPPER_HALF(w)) != 0) {
-      ++dct; w = w + *dct;
+      ++dct;
+      w = w + *dct;
       *dct = LOWER_HALF(w);
     }
 
@@ -2702,12 +2068,7 @@
   }
 }
 
-/* }}} */
-
-/* {{{ s_dadd(a, b) */
-
-STATIC void      s_dadd(mp_int a, mp_digit b)
-{
+static void s_dadd(mp_int a, mp_digit b) {
   mp_word w = 0;
   mp_digit *da = MP_DIGITS(a);
   mp_size ua = MP_USED(a);
@@ -2725,16 +2086,11 @@
 
   if (w) {
     *da = (mp_digit)w;
-    MP_USED(a) += 1;
+    a->used += 1;
   }
 }
 
-/* }}} */
-
-/* {{{ s_dmul(a, b) */
-
-STATIC void      s_dmul(mp_int a, mp_digit b)
-{
+static void s_dmul(mp_int a, mp_digit b) {
   mp_word w = 0;
   mp_digit *da = MP_DIGITS(a);
   mp_size ua = MP_USED(a);
@@ -2748,17 +2104,12 @@
 
   if (w) {
     *da = (mp_digit)w;
-    MP_USED(a) += 1;
+    a->used += 1;
   }
 }
 
-/* }}} */
-
-/* {{{ s_dbmul(da, b, dc, size_a) */
-
-STATIC void      s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a)
-{
-  mp_word  w = 0;
+static void s_dbmul(mp_digit *da, mp_digit b, mp_digit *dc, mp_size size_a) {
+  mp_word w = 0;
 
   while (size_a > 0) {
     w = (mp_word)*da++ * (mp_word)b + w;
@@ -2768,16 +2119,10 @@
     --size_a;
   }
 
-  if (w)
-    *dc = LOWER_HALF(w);
+  if (w) *dc = LOWER_HALF(w);
 }
 
-/* }}} */
-
-/* {{{ s_ddiv(da, d, dc, size_a) */
-
-STATIC mp_digit  s_ddiv(mp_int a, mp_digit b)
-{
+static mp_digit s_ddiv(mp_int a, mp_digit b) {
   mp_word w = 0, qdigit;
   mp_size ua = MP_USED(a);
   mp_digit *da = MP_DIGITS(a) + ua - 1;
@@ -2788,8 +2133,7 @@
     if (w >= b) {
       qdigit = w / b;
       w = w % b;
-    }
-    else {
+    } else {
       qdigit = 0;
     }
 
@@ -2800,17 +2144,12 @@
   return (mp_digit)w;
 }
 
-/* }}} */
-
-/* {{{ s_qdiv(z, p2) */
-
-STATIC void     s_qdiv(mp_int z, mp_size p2)
-{
+static void s_qdiv(mp_int z, mp_size p2) {
   mp_size ndig = p2 / MP_DIGIT_BIT, nbits = p2 % MP_DIGIT_BIT;
   mp_size uz = MP_USED(z);
 
   if (ndig) {
-    mp_size  mark;
+    mp_size mark;
     mp_digit *to, *from;
 
     if (ndig >= uz) {
@@ -2818,17 +2157,19 @@
       return;
     }
 
-    to = MP_DIGITS(z); from = to + ndig;
+    to = MP_DIGITS(z);
+    from = to + ndig;
 
-    for (mark = ndig; mark < uz; ++mark)
+    for (mark = ndig; mark < uz; ++mark) {
       *to++ = *from++;
+    }
 
-    MP_USED(z) = uz - ndig;
+    z->used = uz - ndig;
   }
 
   if (nbits) {
     mp_digit d = 0, *dz, save;
-    mp_size  up = MP_DIGIT_BIT - nbits;
+    mp_size up = MP_DIGIT_BIT - nbits;
 
     uz = MP_USED(z);
     dz = MP_DIGITS(z) + uz - 1;
@@ -2843,41 +2184,30 @@
     CLAMP(z);
   }
 
-  if (MP_USED(z) == 1 && z->digits0 == 0)
-    MP_SIGN(z) = MP_ZPOS;
+  if (MP_USED(z) == 1 && z->digits0 == 0) z->sign = MP_ZPOS;
 }
 
-/* }}} */
-
-/* {{{ s_qmod(z, p2) */
-
-STATIC void     s_qmod(mp_int z, mp_size p2)
-{
+static void s_qmod(mp_int z, mp_size p2) {
   mp_size start = p2 / MP_DIGIT_BIT + 1, rest = p2 % MP_DIGIT_BIT;
   mp_size uz = MP_USED(z);
-  mp_digit mask = (1 << rest) - 1;
+  mp_digit mask = (1u << rest) - 1;
 
   if (start <= uz) {
-    MP_USED(z) = start;
+    z->used = start;
     z->digitsstart - 1 &= mask;
     CLAMP(z);
   }
 }
 
-/* }}} */
-
-/* {{{ s_qmul(z, p2) */
-
-STATIC int      s_qmul(mp_int z, mp_size p2)
-{
-  mp_size   uz, need, rest, extra, i;
+static int s_qmul(mp_int z, mp_size p2) {
+  mp_size uz, need, rest, extra, i;
   mp_digit *from, *to, d;
 
-  if (p2 == 0)
-    return 1;
+  if (p2 == 0) return 1;
 
-  uz = MP_USED(z); 
-  need = p2 / MP_DIGIT_BIT; rest = p2 % MP_DIGIT_BIT;
+  uz = MP_USED(z);
+  need = p2 / MP_DIGIT_BIT;
+  rest = p2 % MP_DIGIT_BIT;
 
   /* Figure out if we need an extra digit at the top end; this occurs if the
      topmost `rest' bits of the high-order digit of z are not zero, meaning
@@ -2886,12 +2216,10 @@
   if (rest != 0) {
     mp_digit *dz = MP_DIGITS(z) + uz - 1;
 
-    if ((*dz >> (MP_DIGIT_BIT - rest)) != 0)
-      extra = 1;
+    if ((*dz >> (MP_DIGIT_BIT - rest)) != 0) extra = 1;
   }
 
-  if (!s_pad(z, uz + need + extra))
-    return 0;
+  if (!s_pad(z, uz + need + extra)) return 0;
 
   /* If we need to shift by whole digits, do that in one pass, then
      to back and shift by partial digits.
@@ -2900,8 +2228,7 @@
     from = MP_DIGITS(z) + uz - 1;
     to = from + need;
 
-    for (i = 0; i < uz; ++i)
-      *to-- = *from--;
+    for (i = 0; i < uz; ++i) *to-- = *from--;
 
     ZERO(MP_DIGITS(z), need);
     uz += need;
@@ -2911,7 +2238,7 @@
     d = 0;
     for (i = need, from = MP_DIGITS(z) + need; i < uz; ++i, ++from) {
       mp_digit save = *from;
-      
+
       *from = (*from << rest) | (d >> (MP_DIGIT_BIT - rest));
       d = save;
     }
@@ -2923,57 +2250,45 @@
     }
   }
 
-  MP_USED(z) = uz;
+  z->used = uz;
   CLAMP(z);
 
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_qsub(z, p2) */
-
 /* Compute z = 2^p2 - |z|; requires that 2^p2 >= |z|
    The sign of the result is always zero/positive.
  */
-STATIC int       s_qsub(mp_int z, mp_size p2)
-{
-  mp_digit hi = (1 << (p2 % MP_DIGIT_BIT)), *zp;
-  mp_size  tdig = (p2 / MP_DIGIT_BIT), pos;
-  mp_word  w = 0;
+static int s_qsub(mp_int z, mp_size p2) {
+  mp_digit hi = (1u << (p2 % MP_DIGIT_BIT)), *zp;
+  mp_size tdig = (p2 / MP_DIGIT_BIT), pos;
+  mp_word w = 0;
 
-  if (!s_pad(z, tdig + 1))
-    return 0;
+  if (!s_pad(z, tdig + 1)) return 0;
 
   for (pos = 0, zp = MP_DIGITS(z); pos < tdig; ++pos, ++zp) {
-    w = ((mp_word) MP_DIGIT_MAX + 1) - w - (mp_word)*zp;
+    w = ((mp_word)MP_DIGIT_MAX + 1) - w - (mp_word)*zp;
 
     *zp = LOWER_HALF(w);
     w = UPPER_HALF(w) ? 0 : 1;
   }
 
-  w = ((mp_word) MP_DIGIT_MAX + 1 + hi) - w - (mp_word)*zp;
+  w = ((mp_word)MP_DIGIT_MAX + 1 + hi) - w - (mp_word)*zp;
   *zp = LOWER_HALF(w);
 
   assert(UPPER_HALF(w) != 0); /* no borrow out should be possible */
 
-  MP_SIGN(z) = MP_ZPOS;
+  z->sign = MP_ZPOS;
   CLAMP(z);
 
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_dp2k(z) */
-
-STATIC int      s_dp2k(mp_int z)
-{
-  int       k = 0;
+static int s_dp2k(mp_int z) {
+  int k = 0;
   mp_digit *dp = MP_DIGITS(z), d;
 
-  if (MP_USED(z) == 1 && *dp == 0)
-    return 1;
+  if (MP_USED(z) == 1 && *dp == 0) return 1;
 
   while (*dp == 0) {
     k += MP_DIGIT_BIT;
@@ -2989,106 +2304,77 @@
   return k;
 }
 
-/* }}} */
-
-/* {{{ s_isp2(z) */
-
-STATIC int       s_isp2(mp_int z)
-{
+static int s_isp2(mp_int z) {
   mp_size uz = MP_USED(z), k = 0;
   mp_digit *dz = MP_DIGITS(z), d;
 
   while (uz > 1) {
-    if (*dz++ != 0)
-      return -1;
+    if (*dz++ != 0) return -1;
     k += MP_DIGIT_BIT;
     --uz;
   }
 
   d = *dz;
   while (d > 1) {
-    if (d & 1)
-      return -1;
-    ++k; d >>= 1;
+    if (d & 1) return -1;
+    ++k;
+    d >>= 1;
   }
 
-  return (int) k;
+  return (int)k;
 }
 
-/* }}} */
-
-/* {{{ s_2expt(z, k) */
-
-STATIC int       s_2expt(mp_int z, mp_small k)
-{
-  mp_size  ndig, rest;
+static int s_2expt(mp_int z, mp_small k) {
+  mp_size ndig, rest;
   mp_digit *dz;
 
   ndig = (k + MP_DIGIT_BIT) / MP_DIGIT_BIT;
   rest = k % MP_DIGIT_BIT;
 
-  if (!s_pad(z, ndig))
-    return 0;
+  if (!s_pad(z, ndig)) return 0;
 
   dz = MP_DIGITS(z);
   ZERO(dz, ndig);
-  *(dz + ndig - 1) = (1 << rest);
-  MP_USED(z) = ndig;
+  *(dz + ndig - 1) = (1u << rest);
+  z->used = ndig;
 
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_norm(a, b) */
-
-STATIC int      s_norm(mp_int a, mp_int b)
-{
+static int s_norm(mp_int a, mp_int b) {
   mp_digit d = b->digitsMP_USED(b) - 1;
   int k = 0;
 
-  while (d < (mp_digit) (1 << (MP_DIGIT_BIT - 1))) { /* d < (MP_RADIX / 2) */
+  while (d < (1u << (mp_digit)(MP_DIGIT_BIT - 1))) { /* d < (MP_RADIX / 2) */
     d <<= 1;
     ++k;
   }
 
   /* These multiplications can't fail */
   if (k != 0) {
-    (void) s_qmul(a, (mp_size) k);
-    (void) s_qmul(b, (mp_size) k);
+    (void)s_qmul(a, (mp_size)k);
+    (void)s_qmul(b, (mp_size)k);
   }
 
   return k;
 }
 
-/* }}} */
-
-/* {{{ s_brmu(z, m) */
-
-STATIC mp_result s_brmu(mp_int z, mp_int m)
-{
+static mp_result s_brmu(mp_int z, mp_int m) {
   mp_size um = MP_USED(m) * 2;
 
-  if (!s_pad(z, um))
-    return MP_MEMORY;
+  if (!s_pad(z, um)) return MP_MEMORY;
 
   s_2expt(z, MP_DIGIT_BIT * um);
   return mp_int_div(z, m, z, NULL);
 }
 
-/* }}} */
-
-/* {{{ s_reduce(x, m, mu, q1, q2) */
-
-STATIC int       s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2)
-{
-  mp_size   um = MP_USED(m), umb_p1, umb_m1;
+static int s_reduce(mp_int x, mp_int m, mp_int mu, mp_int q1, mp_int q2) {
+  mp_size um = MP_USED(m), umb_p1, umb_m1;
 
   umb_p1 = (um + 1) * MP_DIGIT_BIT;
   umb_m1 = (um - 1) * MP_DIGIT_BIT;
 
-  if (mp_int_copy(x, q1) != MP_OK)
-    return 0;
+  if (mp_int_copy(x, q1) != MP_OK) return 0;
 
   /* Compute q2 = floor((floor(x / b^(k-1)) * mu) / b^(k+1)) */
   s_qdiv(q1, umb_m1);
@@ -3104,65 +2390,60 @@
    */
   UMUL(q2, m, q1);
   s_qmod(q1, umb_p1);
-  (void) mp_int_sub(x, q1, x); /* can't fail */
+  (void)mp_int_sub(x, q1, x); /* can't fail */
 
   /* The result may be < 0; if it is, add b^(k+1) to pin it in the proper
      range. */
-  if ((CMPZ(x) < 0) && !s_qsub(x, umb_p1))
-    return 0;
+  if ((CMPZ(x) < 0) && !s_qsub(x, umb_p1)) return 0;
 
   /* If x > m, we need to back it off until it is in range.  This will be
      required at most twice.  */
   if (mp_int_compare(x, m) >= 0) {
-    (void) mp_int_sub(x, m, x);
-    if (mp_int_compare(x, m) >= 0)
-      (void) mp_int_sub(x, m, x);
+    (void)mp_int_sub(x, m, x);
+    if (mp_int_compare(x, m) >= 0) {
+      (void)mp_int_sub(x, m, x);
+    }
   }
 
   /* At this point, x has been properly reduced. */
   return 1;
 }
 
-/* }}} */
-
-/* {{{ s_embar(a, b, m, mu, c) */
-
 /* Perform modular exponentiation using Barrett's method, where mu is the
    reduction constant for m.  Assumes a < m, b > 0. */
-STATIC mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c)
-{
-  mp_digit  *db, *dbt, umu, d;
-  mp_result res;
-  DECLARE_TEMP(3);
-
-  umu = MP_USED(mu); db = MP_DIGITS(b); dbt = db + MP_USED(b) - 1;
+static mp_result s_embar(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c) {
+  mp_digit umu = MP_USED(mu);
+  mp_digit *db = MP_DIGITS(b);
+  mp_digit *dbt = db + MP_USED(b) - 1;
 
-  while (last__ < 3) {
-    SETUP(mp_int_init_size(LAST_TEMP(), 4 * umu));
-    ZERO(MP_DIGITS(TEMP(last__ - 1)), MP_ALLOC(TEMP(last__ - 1)));
-  }
+  DECLARE_TEMP(3);
+  REQUIRE(GROW(TEMP(0), 4 * umu));
+  REQUIRE(GROW(TEMP(1), 4 * umu));
+  REQUIRE(GROW(TEMP(2), 4 * umu));
+  ZERO(TEMP(0)->digits, TEMP(0)->alloc);
+  ZERO(TEMP(1)->digits, TEMP(1)->alloc);
+  ZERO(TEMP(2)->digits, TEMP(2)->alloc);
 
-  (void) mp_int_set_value(c, 1);
+  (void)mp_int_set_value(c, 1);
 
   /* Take care of low-order digits */
   while (db < dbt) {
-    int      i;
+    mp_digit d = *db;
 
-    for (d = *db, i = MP_DIGIT_BIT; i > 0; --i, d >>= 1) {
+    for (int i = MP_DIGIT_BIT; i > 0; --i, d >>= 1) {
       if (d & 1) {
-	/* The use of a second temporary avoids allocation */
-	UMUL(c, a, TEMP(0));
-	if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) {
-	  res = MP_MEMORY; goto CLEANUP;
-	}
-	mp_int_copy(TEMP(0), c);
+        /* The use of a second temporary avoids allocation */
+        UMUL(c, a, TEMP(0));
+        if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) {
+          REQUIRE(MP_MEMORY);
+        }
+        mp_int_copy(TEMP(0), c);
       }
 
-
       USQR(a, TEMP(0));
       assert(MP_SIGN(TEMP(0)) == MP_ZPOS);
       if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) {
-	res = MP_MEMORY; goto CLEANUP;
+        REQUIRE(MP_MEMORY);
       }
       assert(MP_SIGN(TEMP(0)) == MP_ZPOS);
       mp_int_copy(TEMP(0), a);
@@ -3172,12 +2453,12 @@
   }
 
   /* Take care of highest-order digit */
-  d = *dbt;
+  mp_digit d = *dbt;
   for (;;) {
     if (d & 1) {
       UMUL(c, a, TEMP(0));
       if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) {
-	res = MP_MEMORY; goto CLEANUP;
+        REQUIRE(MP_MEMORY);
       }
       mp_int_copy(TEMP(0), c);
     }
@@ -3187,120 +2468,15 @@
 
     USQR(a, TEMP(0));
     if (!s_reduce(TEMP(0), m, mu, TEMP(1), TEMP(2))) {
-      res = MP_MEMORY; goto CLEANUP;
+      REQUIRE(MP_MEMORY);
     }
-    (void) mp_int_copy(TEMP(0), a);
+    (void)mp_int_copy(TEMP(0), a);
   }
 
   CLEANUP_TEMP();
-  return res;
-}
-
-/* }}} */
-
-#if 0
-/* {{{ s_udiv(a, b) */
-/* The s_udiv function produces incorrect results. For example, with test
-     div:11141460315522012760862883825:48318382095:0,230584300062375935
-   commenting out the function for now and using s_udiv_knuth instead.
-   STATIC mp_result s_udiv(mp_int a, mp_int b);
-*/
-
-/* Precondition:  a >= b and b > 0
-   Postcondition: a' = a / b, b' = a % b
- */
-STATIC mp_result s_udiv(mp_int a, mp_int b)
-{
-  mpz_t q, r, t;
-  mp_size ua, ub, qpos = 0;
-  mp_digit *da, btop;
-  mp_result res = MP_OK;
-  int k, skip = 0;
-
-  /* Force signs to positive */
-  MP_SIGN(a) = MP_ZPOS;
-  MP_SIGN(b) = MP_ZPOS;
-
-  /* Normalize, per Knuth */
-  k = s_norm(a, b);
-
-  ua = MP_USED(a); ub = MP_USED(b); btop = b->digitsub - 1;
-  if ((res = mp_int_init_size(&q, ua)) != MP_OK) return res;
-  if ((res = mp_int_init_size(&t, ua + 1)) != MP_OK) goto CLEANUP;
-
-  da = MP_DIGITS(a);
-  r.digits = da + ua - 1;  /* The contents of r are shared with a */
-  r.used   = 1;
-  r.sign   = MP_ZPOS;
-  r.alloc  = MP_ALLOC(a);
-  ZERO(t.digits, t.alloc);
-
-  /* Solve for quotient digits, store in q.digits in reverse order */
-  while (r.digits >= da) {
-    assert(qpos <= q.alloc);
-
-    if (s_ucmp(b, &r) > 0) {
-      r.digits -= 1;
-      r.used += 1;
-
-      if (++skip > 1 && qpos > 0)
-	q.digitsqpos++ = 0;
-
-      CLAMP(&r);
-    }
-    else {
-      mp_word  pfx = r.digitsr.used - 1;
-      mp_word  qdigit;
-
-      if (r.used > 1 && pfx < btop) {
-	pfx <<= MP_DIGIT_BIT / 2;
-	pfx <<= MP_DIGIT_BIT / 2;
-	pfx |= r.digitsr.used - 2;
-      }
-
-      qdigit = pfx / btop;
-      if (qdigit > MP_DIGIT_MAX) {
-	qdigit = MP_DIGIT_MAX;
-      }
-
-      s_dbmul(MP_DIGITS(b), (mp_digit) qdigit, t.digits, ub);
-      t.used = ub + 1; CLAMP(&t);
-      while (s_ucmp(&t, &r) > 0) {
-	--qdigit;
-	(void) mp_int_sub(&t, b, &t); /* cannot fail */
-      }
-
-      s_usub(r.digits, t.digits, r.digits, r.used, t.used);
-      CLAMP(&r);
-
-      q.digitsqpos++ = (mp_digit) qdigit;
-      ZERO(t.digits, t.used);
-      skip = 0;
-    }
-  }
-
-  /* Put quotient digits in the correct order, and discard extra zeroes */
-  q.used = qpos;
-  REV(mp_digit, q.digits, qpos);
-  CLAMP(&q);
-
-  /* Denormalize the remainder */
-  CLAMP(a);
-  if (k != 0)
-    s_qdiv(a, k);
-
-  mp_int_copy(a, b);  /* ok:  0 <= r < b */
-  mp_int_copy(&q, a); /* ok:  q <= a     */
-
-  mp_int_clear(&t);
- CLEANUP:
-  mp_int_clear(&q);
-  return res;
+  return MP_OK;
 }
 
-/* }}} */
-#endif
-
 /* Division of nonnegative integers
 
    This function implements division algorithm for unsigned multi-precision
@@ -3321,39 +2497,32 @@
   outputs: u / v stored in u
            u % v stored in v
  */
-STATIC mp_result s_udiv_knuth(mp_int u, mp_int v) {
-  mpz_t q, r, t;
-  mp_result
-  res = MP_OK;
-  int k,j;
-  mp_size m,n;
-
+static mp_result s_udiv_knuth(mp_int u, mp_int v) {
   /* Force signs to positive */
-  MP_SIGN(u) = MP_ZPOS;
-  MP_SIGN(v) = MP_ZPOS;
+  u->sign = MP_ZPOS;
+  v->sign = MP_ZPOS;
 
   /* Use simple division algorithm when v is only one digit long */
   if (MP_USED(v) == 1) {
     mp_digit d, rem;
-    d   = v->digits0;
+    d = v->digits0;
     rem = s_ddiv(u, d);
     mp_int_set_value(v, rem);
     return MP_OK;
   }
 
-  /************************************************************/
-  /* Algorithm D */
-  /************************************************************/
-  /* The n and m variables are defined as used by Knuth.
+  /* Algorithm D
+
+     The n and m variables are defined as used by Knuth.
      u is an n digit number with digits u_{n-1}..u_0.
      v is an n+m digit number with digits from v_{m+n-1}..v_0.
-     We require that n > 1 and m >= 0 */
-  n = MP_USED(v);
-  m = MP_USED(u) - n;
-  assert(n >  1);
-  assert(m >= 0);
+     We require that n > 1 and m >= 0
+   */
+  mp_size n = MP_USED(v);
+  mp_size m = MP_USED(u) - n;
+  assert(n > 1);
+  /* assert(m >= 0) follows because m is unsigned. */
 
-  /************************************************************/
   /* D1: Normalize.
      The normalization step provides the necessary condition for Theorem B,
      which states that the quotient estimate for q_j, call it qhat
@@ -3365,8 +2534,9 @@
       qhat - 2 <= q_j <= qhat.
 
      That is, qhat is always greater than the actual quotient digit q,
-     and it is never more than two larger than the actual quotient digit.  */
-  k = s_norm(u, v);
+     and it is never more than two larger than the actual quotient digit.
+   */
+  int k = s_norm(u, v);
 
   /* Extend size of u by one if needed.
 
@@ -3376,54 +2546,54 @@
      a leading zero here.
    */
   if (k == 0 || MP_USED(u) != m + n + 1) {
-    if (!s_pad(u, m+n+1))
-      return MP_MEMORY;
-    u->digitsm+n = 0;
-    u->used = m+n+1;
+    if (!s_pad(u, m + n + 1)) return MP_MEMORY;
+    u->digitsm + n = 0;
+    u->used = m + n + 1;
   }
 
   /* Add a leading 0 to v.
 
      The multiplication in step D4 multiplies qhat * 0v_{n-1}..v_0.  We need to
      add the leading zero to v here to ensure that the multiplication will
-     produce the full n+1 digit result.  */
-  if (!s_pad(v, n+1)) return MP_MEMORY; v->digitsn = 0;
+     produce the full n+1 digit result.
+   */
+  if (!s_pad(v, n + 1)) return MP_MEMORY;
+  v->digitsn = 0;
 
   /* Initialize temporary variables q and t.
      q allocates space for m+1 digits to store the quotient digits
-     t allocates space for n+1 digits to hold the result of q_j*v */
-  if ((res = mp_int_init_size(&q, m + 1)) != MP_OK) return res;
-  if ((res = mp_int_init_size(&t, n + 1)) != MP_OK) goto CLEANUP;
+     t allocates space for n+1 digits to hold the result of q_j*v
+   */
+  DECLARE_TEMP(2);
+  REQUIRE(GROW(TEMP(0), m + 1));
+  REQUIRE(GROW(TEMP(1), n + 1));
 
-  /************************************************************/
   /* D2: Initialize j */
-  j = m;
-  r.digits = MP_DIGITS(u) + j;  /* The contents of r are shared with u */
-  r.used   = n + 1;
-  r.sign   = MP_ZPOS;
-  r.alloc  = MP_ALLOC(u);
-  ZERO(t.digits, t.alloc);
+  int j = m;
+  mpz_t r;
+  r.digits = MP_DIGITS(u) + j; /* The contents of r are shared with u */
+  r.used = n + 1;
+  r.sign = MP_ZPOS;
+  r.alloc = MP_ALLOC(u);
+  ZERO(TEMP(1)->digits, TEMP(1)->alloc);
 
   /* Calculate the m+1 digits of the quotient result */
   for (; j >= 0; j--) {
-    /************************************************************/
     /* D3: Calculate q' */
     /* r->digits is aligned to position j of the number u */
     mp_word pfx, qhat;
-    pfx   = r.digitsn;
+    pfx = r.digitsn;
     pfx <<= MP_DIGIT_BIT / 2;
     pfx <<= MP_DIGIT_BIT / 2;
-    pfx |= r.digitsn-1; /* pfx = u_{j+n}{j+n-1} */
+    pfx |= r.digitsn - 1; /* pfx = u_{j+n}{j+n-1} */
 
-    qhat = pfx / v->digitsn-1;
+    qhat = pfx / v->digitsn - 1;
     /* Check to see if qhat > b, and decrease qhat if so.
        Theorem B guarantess that qhat is at most 2 larger than the
        actual value, so it is possible that qhat is greater than
        the maximum value that will fit in a digit */
-    if (qhat > MP_DIGIT_MAX)
-      qhat = MP_DIGIT_MAX;
+    if (qhat > MP_DIGIT_MAX) qhat = MP_DIGIT_MAX;
 
-    /************************************************************/
     /* D4,D5,D6: Multiply qhat * v and test for a correct value of q
 
        We proceed a bit different than the way described by Knuth. This way is
@@ -3433,146 +2603,128 @@
        decrease qhat by one and try again. We may need to decrease qhat one
        more time before we get a value that is smaller than r.
 
-       This way is less efficent than Knuth becuase we do more multiplies, but
-       we do not need to worry about underflow this way.  */
+       This way is less efficent than Knuth because we do more multiplies, but
+       we do not need to worry about underflow this way.
+     */
     /* t = qhat * v */
-    s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1); t.used = n + 1;
-    CLAMP(&t);
+    s_dbmul(MP_DIGITS(v), (mp_digit)qhat, TEMP(1)->digits, n + 1);
+    TEMP(1)->used = n + 1;
+    CLAMP(TEMP(1));
 
     /* Clamp r for the comparison. Comparisons do not like leading zeros. */
     CLAMP(&r);
-    if (s_ucmp(&t, &r) > 0) {   /* would the remainder be negative? */
-      qhat -= 1;   /* try a smaller q */
-      s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1);
-      t.used = n + 1; CLAMP(&t);
-      if (s_ucmp(&t, &r) > 0) { /* would the remainder be negative? */
+    if (s_ucmp(TEMP(1), &r) > 0) { /* would the remainder be negative? */
+      qhat -= 1;                   /* try a smaller q */
+      s_dbmul(MP_DIGITS(v), (mp_digit)qhat, TEMP(1)->digits, n + 1);
+      TEMP(1)->used = n + 1;
+      CLAMP(TEMP(1));
+      if (s_ucmp(TEMP(1), &r) > 0) { /* would the remainder be negative? */
         assert(qhat > 0);
         qhat -= 1; /* try a smaller q */
-        s_dbmul(MP_DIGITS(v), (mp_digit) qhat, t.digits, n+1);
-        t.used = n + 1; CLAMP(&t);
+        s_dbmul(MP_DIGITS(v), (mp_digit)qhat, TEMP(1)->digits, n + 1);
+        TEMP(1)->used = n + 1;
+        CLAMP(TEMP(1));
       }
-      assert(s_ucmp(&t, &r) <=  0 && "The mathematics failed us.");
+      assert(s_ucmp(TEMP(1), &r) <= 0 && "The mathematics failed us.");
     }
     /* Unclamp r. The D algorithm expects r = u_{j+n}..u_j to always be n+1
        digits long. */
     r.used = n + 1;
 
-    /************************************************************/
-    /* D4: Multiply and subtract */
-    /* note: The multiply was completed above so we only need to subtract here.
-     **/
-    s_usub(r.digits, t.digits, r.digits, r.used, t.used);
+    /* D4: Multiply and subtract
+
+       Note: The multiply was completed above so we only need to subtract here.
+     */
+    s_usub(r.digits, TEMP(1)->digits, r.digits, r.used, TEMP(1)->used);
+
+    /* D5: Test remainder
 
-    /************************************************************/
-    /* D5: Test remainder */
-    /* note: Not needed because we always check that qhat is the correct value
-     *       before performing the subtract. */
-    q.digitsj = qhat;
+       Note: Not needed because we always check that qhat is the correct value
+             before performing the subtract.  Value cast to mp_digit to prevent
+             warning, qhat has been clamped to MP_DIGIT_MAX
+     */
+    TEMP(0)->digitsj = (mp_digit)qhat;
 
-    /************************************************************/
-    /* D6: Add back */
-    /* note: Not needed because we always check that qhat is the correct value
-     *       before performing the subtract. */
+    /* D6: Add back
+       Note: Not needed because we always check that qhat is the correct value
+             before performing the subtract.
+     */
 
-    /************************************************************/
     /* D7: Loop on j */
     r.digits--;
-    ZERO(t.digits, t.alloc);
+    ZERO(TEMP(1)->digits, TEMP(1)->alloc);
   }
 
   /* Get rid of leading zeros in q */
-  q.used = m + 1;
-  CLAMP(&q);
+  TEMP(0)->used = m + 1;
+  CLAMP(TEMP(0));
 
   /* Denormalize the remainder */
   CLAMP(u); /* use u here because the r.digits pointer is off-by-one */
-  if (k != 0)
-    s_qdiv(u, k);
+  if (k != 0) s_qdiv(u, k);
 
-  mp_int_copy(u, v);  /* ok:  0 <= r < v */
-  mp_int_copy(&q, u); /* ok:  q <= u     */
+  mp_int_copy(u, v);       /* ok:  0 <= r < v */
+  mp_int_copy(TEMP(0), u); /* ok:  q <= u     */
 
-  mp_int_clear(&t);
- CLEANUP:
-  mp_int_clear(&q);
-  return res;
+  CLEANUP_TEMP();
+  return MP_OK;
 }
 
-/* {{{ s_outlen(z, r) */
-
-STATIC int       s_outlen(mp_int z, mp_size r)
-{
-  mp_result bits;
-  double raw;
-
+static int s_outlen(mp_int z, mp_size r) {
   assert(r >= MP_MIN_RADIX && r <= MP_MAX_RADIX);
 
-  bits = mp_int_count_bits(z);
-  raw = (double)bits * s_log2r;
+  mp_result bits = mp_int_count_bits(z);
+  double raw = (double)bits * s_log2r;
 
   return (int)(raw + 0.999999);
 }
 
-/* }}} */
-
-/* {{{ s_inlen(len, r) */
-
-STATIC mp_size   s_inlen(int len, mp_size r)
-{
-  double  raw = (double)len / s_log2r;
+static mp_size s_inlen(int len, mp_size r) {
+  double raw = (double)len / s_log2r;
   mp_size bits = (mp_size)(raw + 0.5);
 
   return (mp_size)((bits + (MP_DIGIT_BIT - 1)) / MP_DIGIT_BIT) + 1;
 }
 
-/* }}} */
-
-/* {{{ s_ch2val(c, r) */
-
-STATIC int       s_ch2val(char c, int r)
-{
+static int s_ch2val(char c, int r) {
   int out;
 
-  if (isdigit((unsigned char) c))
+  /*
+   * In some locales, isalpha() accepts characters outside the range A-Z,
+   * producing out<0 or out>=36.  The "out >= r" check will always catch
+   * out>=36.  Though nothing explicitly catches out<0, our caller reacts the
+   * same way to every negative return value.
+   */
+  if (isdigit((unsigned char)c))
     out = c - '0';
-  else if (r > 10 && isalpha((unsigned char) c))
-    out = toupper(c) - 'A' + 10;
+  else if (r > 10 && isalpha((unsigned char)c))
+    out = toupper((unsigned char)c) - 'A' + 10;
   else
     return -1;
 
   return (out >= r) ? -1 : out;
 }
 
-/* }}} */
-
-/* {{{ s_val2ch(v, caps) */
-
-STATIC char      s_val2ch(int v, int caps)
-{
+static char s_val2ch(int v, int caps) {
   assert(v >= 0);
 
-  if (v < 10)
+  if (v < 10) {
     return v + '0';
-  else {
+  } else {
     char out = (v - 10) + 'a';
 
-    if (caps)
-      return toupper(out);
-    else
+    if (caps) {
+      return toupper((unsigned char)out);
+    } else {
       return out;
+    }
   }
 }
 
-/* }}} */
-
-/* {{{ s_2comp(buf, len) */
-
-STATIC void      s_2comp(unsigned char *buf, int len)
-{
-  int i;
+static void s_2comp(unsigned char *buf, int len) {
   unsigned short s = 1;
 
-  for (i = len - 1; i >= 0; --i) {
+  for (int i = len - 1; i >= 0; --i) {
     unsigned char c = ~bufi;
 
     s = c + s;
@@ -3585,17 +2737,11 @@
   /* last carry out is ignored */
 }
 
-/* }}} */
-
-/* {{{ s_tobin(z, buf, *limpos) */
-
-STATIC mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad)
-{
-  mp_size uz;
-  mp_digit *dz;
+static mp_result s_tobin(mp_int z, unsigned char *buf, int *limpos, int pad) {
   int pos = 0, limit = *limpos;
+  mp_size uz = MP_USED(z);
+  mp_digit *dz = MP_DIGITS(z);
 
-  uz = MP_USED(z); dz = MP_DIGITS(z);
   while (uz > 0 && pos < limit) {
     mp_digit d = *dz++;
     int i;
@@ -3605,8 +2751,7 @@
       d >>= CHAR_BIT;
 
       /* Don't write leading zeroes */
-      if (d == 0 && uz == 1)
-	i = 0; /* exit loop without signaling truncation */
+      if (d == 0 && uz == 1) i = 0; /* exit loop without signaling truncation */
     }
 
     /* Detect truncation (loop exited with pos >= limit) */
@@ -3616,14 +2761,15 @@
   }
 
   if (pad != 0 && (bufpos - 1 >> (CHAR_BIT - 1))) {
-    if (pos < limit)
+    if (pos < limit) {
       bufpos++ = 0;
-    else
+    } else {
       uz = 1;
+    }
   }
 
   /* Digits are in reverse order, fix that */
-  REV(unsigned char, buf, pos);
+  REV(buf, pos);
 
   /* Return the number of bytes actually written */
   *limpos = pos;
@@ -3631,38 +2777,4 @@
   return (uz == 0) ? MP_OK : MP_TRUNC;
 }
 
-/* }}} */
-
-/* {{{ s_print(tag, z) */
-
-#if DEBUG
-void      s_print(char *tag, mp_int z)
-{
-  int  i;
-
-  fprintf(stderr, "%s: %c ", tag,
-	  (MP_SIGN(z) == MP_NEG) ? '-' : '+');
-
-  for (i = MP_USED(z) - 1; i >= 0; --i)
-    fprintf(stderr, "%0*X", (int)(MP_DIGIT_BIT / 4), z->digitsi);
-
-  fputc('\n', stderr);
-
-}
-
-void      s_print_buf(char *tag, mp_digit *buf, mp_size num)
-{
-  int i;
-
-  fprintf(stderr, "%s: ", tag);
-
-  for (i = num - 1; i >= 0; --i)
-    fprintf(stderr, "%0*X", (int)(MP_DIGIT_BIT / 4), bufi);
-
-  fputc('\n', stderr);
-}
-#endif
-
-/* }}} */
-
 /* Here there be dragons */

_service:tar_scm:isl-0.14.tar.xz/imath/imath.h -> _service:tar_scm:isl-0.24.tar.gz/imath/imath.h Changed

@@ -1,7 +1,7 @@
 /*
   Name:     imath.h
   Purpose:  Arbitrary precision integer arithmetic routines.
-  Author:   M. J. Fromberger <http://spinning-yarns.org/michael/>
+  Author:   M. J. Fromberger
 
   Copyright (C) 2002-2007 Michael J. Fromberger, All Rights Reserved.
 
@@ -27,44 +27,46 @@
 #ifndef IMATH_H_
 #define IMATH_H_
 
-#include <stdint.h>
 #include <limits.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef unsigned char      mp_sign;
-typedef unsigned int       mp_size;
-typedef int                mp_result;
-typedef long               mp_small;  /* must be a signed type */
-typedef unsigned long      mp_usmall; /* must be an unsigned type */
+typedef unsigned char  mp_sign;
+typedef unsigned int   mp_size;
+typedef int            mp_result;
+typedef long           mp_small;  /* must be a signed type */
+typedef unsigned long  mp_usmall; /* must be an unsigned type */
 
-/* Force building with uint64_t so that the library builds consistently
- * whether we build from the makefile or by embedding imath in another project.
- */
-#undef  USE_64BIT_WORDS
-#define USE_64BIT_WORDS
-#ifdef  USE_64BIT_WORDS
-typedef uint32_t           mp_digit;
-typedef uint64_t           mp_word;
+
+/* Build with words as uint64_t by default. */
+#ifdef USE_32BIT_WORDS
+typedef uint16_t        mp_digit;
+typedef uint32_t        mp_word;
+#  define MP_DIGIT_MAX  (UINT16_MAX * 1UL)
+#  define MP_WORD_MAX   (UINT32_MAX * 1UL)
 #else
-typedef uint16_t           mp_digit;
-typedef uint32_t           mp_word;
+typedef uint32_t        mp_digit;
+typedef uint64_t        mp_word;
+#  define MP_DIGIT_MAX  (UINT32_MAX * UINT64_C(1))
+#  define MP_WORD_MAX   (UINT64_MAX)
 #endif
 
-typedef struct mpz {
-  mp_digit    single;
-  mp_digit   *digits;
-  mp_size     alloc;
-  mp_size     used;
-  mp_sign     sign;
+typedef struct {
+  mp_digit  single;
+  mp_digit* digits;
+  mp_size   alloc;
+  mp_size   used;
+  mp_sign   sign;
 } mpz_t, *mp_int;
 
-#define MP_DIGITS(Z) ((Z)->digits)
-#define MP_ALLOC(Z)  ((Z)->alloc)
-#define MP_USED(Z)   ((Z)->used)
-#define MP_SIGN(Z)   ((Z)->sign)
+static inline mp_digit* MP_DIGITS(mp_int Z) { return Z->digits; }
+static inline mp_size   MP_ALLOC(mp_int Z)  { return Z->alloc; }
+static inline mp_size   MP_USED(mp_int Z)   { return Z->used; }
+static inline mp_sign   MP_SIGN(mp_int Z)   { return Z->sign; }
 
 extern const mp_result MP_OK;
 extern const mp_result MP_FALSE;
@@ -76,156 +78,343 @@
 extern const mp_result MP_BADARG;
 extern const mp_result MP_MINERR;
 
-#define MP_DIGIT_BIT    (sizeof(mp_digit) * CHAR_BIT)
-#define MP_WORD_BIT     (sizeof(mp_word) * CHAR_BIT)
-#define MP_SMALL_MIN    LONG_MIN
-#define MP_SMALL_MAX    LONG_MAX
-#define MP_USMALL_MIN   ULONG_MIN
-#define MP_USMALL_MAX   ULONG_MAX
+#define MP_DIGIT_BIT   (sizeof(mp_digit) * CHAR_BIT)
+#define MP_WORD_BIT    (sizeof(mp_word) * CHAR_BIT)
+#define MP_SMALL_MIN   LONG_MIN
+#define MP_SMALL_MAX   LONG_MAX
+#define MP_USMALL_MAX  ULONG_MAX
 
-#ifdef USE_64BIT_WORDS
-#  define MP_DIGIT_MAX   (UINT32_MAX * UINT64_C(1))
-#  define MP_WORD_MAX    (UINT64_MAX)
-#else
-#  define MP_DIGIT_MAX   (UINT16_MAX * 1UL)
-#  define MP_WORD_MAX    (UINT32_MAX * 1UL)
-#endif
+#define MP_MIN_RADIX   2
+#define MP_MAX_RADIX   36
 
-#define MP_MIN_RADIX    2
-#define MP_MAX_RADIX    36
+/** Sets the default number of digits allocated to an `mp_int` constructed by
+    `mp_int_init_size()` with `prec == 0`. Allocations are rounded up to
+    multiples of this value. `MP_DEFAULT_PREC` is the default value. Requires
+    `ndigits > 0`. */
+void mp_int_default_precision(mp_size ndigits);
 
-/* Values with fewer than this many significant digits use the standard
-   multiplication algorithm; otherwise, a recursive algorithm is used.  
-   Choose a value to suit your platform.
- */
-#define MP_MULT_THRESH  22
+/** Sets the number of digits below which multiplication will use the standard
+    quadratic "schoolbook" multiplication algorithm rather than Karatsuba-Ofman.
+    Requires `ndigits >= sizeof(mp_word)`. */
+void mp_int_multiply_threshold(mp_size ndigits);
+
+/** A sign indicating a (strictly) negative value. */
+extern const mp_sign MP_NEG;
 
-#define MP_DEFAULT_PREC 8   /* default memory allocation, in digits */
+/** A sign indicating a zero or positive value. */
+extern const mp_sign MP_ZPOS;
 
-extern const mp_sign   MP_NEG;
-extern const mp_sign   MP_ZPOS;
+/** Reports whether `z` is odd, having remainder 1 when divided by 2. */
+static inline bool mp_int_is_odd(mp_int z) { return (z->digits0 & 1) != 0; }
 
-#define mp_int_is_odd(Z)  ((Z)->digits0 & 1)
-#define mp_int_is_even(Z) !((Z)->digits0 & 1)
+/** Reports whether `z` is even, having remainder 0 when divided by 2. */
+static inline bool mp_int_is_even(mp_int z) { return (z->digits0 & 1) == 0; }
 
+/** Initializes `z` with 1-digit precision and sets it to zero.  This function
+    cannot fail unless `z == NULL`. */
 mp_result mp_int_init(mp_int z);
-mp_int    mp_int_alloc(void);
+
+/** Allocates a fresh zero-valued `mpz_t` on the heap, returning NULL in case
+    of error. The only possible error is out-of-memory. */
+mp_int mp_int_alloc(void);
+
+/** Initializes `z` with at least `prec` digits of storage, and sets it to
+    zero. If `prec` is zero, the default precision is used. In either case the
+    size is rounded up to the nearest multiple of the word size. */
 mp_result mp_int_init_size(mp_int z, mp_size prec);
+
+/** Initializes `z` to be a copy of an already-initialized value in `old`. The
+    new copy does not share storage with the original. */
 mp_result mp_int_init_copy(mp_int z, mp_int old);
+
+/** Initializes `z` to the specified signed `value` at default precision. */
 mp_result mp_int_init_value(mp_int z, mp_small value);
+
+/** Initializes `z` to the specified unsigned `value` at default precision. */
 mp_result mp_int_init_uvalue(mp_int z, mp_usmall uvalue);
+
+/** Sets `z` to the value of the specified signed `value`. */
 mp_result mp_int_set_value(mp_int z, mp_small value);
+
+/** Sets `z` to the value of the specified unsigned `value`. */
 mp_result mp_int_set_uvalue(mp_int z, mp_usmall uvalue);
-void      mp_int_clear(mp_int z);
-void      mp_int_free(mp_int z);
-
-mp_result mp_int_copy(mp_int a, mp_int c);           /* c = a     */
-void      mp_int_swap(mp_int a, mp_int c);           /* swap a, c */
-void      mp_int_zero(mp_int z);                     /* z = 0     */
-mp_result mp_int_abs(mp_int a, mp_int c);            /* c = |a|   */
-mp_result mp_int_neg(mp_int a, mp_int c);            /* c = -a    */
-mp_result mp_int_add(mp_int a, mp_int b, mp_int c);  /* c = a + b */
+
+/** Releases the storage used by `z`. */
+void mp_int_clear(mp_int z);
+
+/** Releases the storage used by `z` and also `z` itself.
+    This should only be used for `z` allocated by `mp_int_alloc()`. */
+void mp_int_free(mp_int z);
+
+/** Replaces the value of `c` with a copy of the value of `a`. No new memory is
+    allocated unless `a` has more significant digits than `c` has allocated. */
+mp_result mp_int_copy(mp_int a, mp_int c);
+
+/** Swaps the values and storage between `a` and `c`. */
+void mp_int_swap(mp_int a, mp_int c);
+
+/** Sets `z` to zero. The allocated storage of `z` is not changed. */
+void mp_int_zero(mp_int z);
+
+/** Sets `c` to the absolute value of `a`. */
+mp_result mp_int_abs(mp_int a, mp_int c);
+
+/** Sets `c` to the additive inverse (negation) of `a`. */
+mp_result mp_int_neg(mp_int a, mp_int c);
+
+/** Sets `c` to the sum of `a` and `b`. */
+mp_result mp_int_add(mp_int a, mp_int b, mp_int c);
+
+/** Sets `c` to the sum of `a` and `value`. */
 mp_result mp_int_add_value(mp_int a, mp_small value, mp_int c);
-mp_result mp_int_sub(mp_int a, mp_int b, mp_int c);  /* c = a - b */
+
+/** Sets `c` to the difference of `a` less `b`. */
+mp_result mp_int_sub(mp_int a, mp_int b, mp_int c);
+
+/** Sets `c` to the difference of `a` less `value`. */
 mp_result mp_int_sub_value(mp_int a, mp_small value, mp_int c);
-mp_result mp_int_mul(mp_int a, mp_int b, mp_int c);  /* c = a * b */
+
+/** Sets `c` to the product of `a` and `b`. */
+mp_result mp_int_mul(mp_int a, mp_int b, mp_int c);
+
+/** Sets `c` to the product of `a` and `value`. */
 mp_result mp_int_mul_value(mp_int a, mp_small value, mp_int c);
+
+/** Sets `c` to the product of `a` and `2^p2`. Requires `p2 >= 0`. */
 mp_result mp_int_mul_pow2(mp_int a, mp_small p2, mp_int c);
-mp_result mp_int_sqr(mp_int a, mp_int c);            /* c = a * a */
-mp_result mp_int_div(mp_int a, mp_int b,             /* q = a / b */
-		     mp_int q, mp_int r);            /* r = a % b */
-mp_result mp_int_div_value(mp_int a, mp_small value, /* q = a / value */
-			   mp_int q, mp_small *r);   /* r = a % value */
-mp_result mp_int_div_pow2(mp_int a, mp_small p2,     /* q = a / 2^p2  */
-			  mp_int q, mp_int r);       /* r = q % 2^p2  */
-mp_result mp_int_mod(mp_int a, mp_int m, mp_int c);  /* c = a % m */
-#define   mp_int_mod_value(A, V, R) mp_int_div_value((A), (V), 0, (R))
-mp_result mp_int_expt(mp_int a, mp_small b, mp_int c);         /* c = a^b */
-mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c); /* c = a^b */
-mp_result mp_int_expt_full(mp_int a, mp_int b, mp_int c);      /* c = a^b */
-
-int       mp_int_compare(mp_int a, mp_int b);          /* a <=> b     */
-int       mp_int_compare_unsigned(mp_int a, mp_int b); /* |a| <=> |b| */
-int       mp_int_compare_zero(mp_int z);                 /* a <=> 0  */
-int       mp_int_compare_value(mp_int z, mp_small v);    /* a <=> v  */
-int       mp_int_compare_uvalue(mp_int z, mp_usmall uv); /* a <=> uv */
-
-/* Returns true if v|a, false otherwise (including errors) */
-int       mp_int_divisible_value(mp_int a, mp_small v);
-
-/* Returns k >= 0 such that z = 2^k, if one exists; otherwise < 0 */
-int       mp_int_is_pow2(mp_int z);
-
-mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m,
-			 mp_int c);                    /* c = a^b (mod m) */
-mp_result mp_int_exptmod_evalue(mp_int a, mp_small value,
-				mp_int m, mp_int c);   /* c = a^v (mod m) */
-mp_result mp_int_exptmod_bvalue(mp_small value, mp_int b,
-				mp_int m, mp_int c);   /* c = v^b (mod m) */
-mp_result mp_int_exptmod_known(mp_int a, mp_int b,
-			       mp_int m, mp_int mu,
-			       mp_int c);              /* c = a^b (mod m) */
+
+/** Sets `c` to the square of `a`. */
+mp_result mp_int_sqr(mp_int a, mp_int c);
+
+/** Sets `q` and `r` to the quotent and remainder of `a / b`. Division by
+    powers of 2 is detected and handled efficiently.  The remainder is pinned
+    to `0 <= r < b`.
+
+    Either of `q` or `r` may be NULL, but not both, and `q` and `r` may not
+    point to the same value. */
+mp_result mp_int_div(mp_int a, mp_int b, mp_int q, mp_int r);
+
+/** Sets `q` and `*r` to the quotent and remainder of `a / value`. Division by
+    powers of 2 is detected and handled efficiently. The remainder is pinned to
+    `0 <= *r < b`. Either of `q` or `r` may be NULL. */
+mp_result mp_int_div_value(mp_int a, mp_small value, mp_int q, mp_small *r);
+
+/** Sets `q` and `r` to the quotient and remainder of `a / 2^p2`. This is a
+    special case for division by powers of two that is more efficient than
+    using ordinary division. Note that `mp_int_div()` will automatically handle
+    this case, this function is for cases where you have only the exponent. */
+mp_result mp_int_div_pow2(mp_int a, mp_small p2, mp_int q, mp_int r);
+
+/** Sets `c` to the remainder of `a / m`.
+    The remainder is pinned to `0 <= c < m`. */
+mp_result mp_int_mod(mp_int a, mp_int m, mp_int c);
+
+/** Sets `c` to the value of `a` raised to the `b` power.
+    It returns `MP_RANGE` if `b < 0`. */
+mp_result mp_int_expt(mp_int a, mp_small b, mp_int c);
+
+/** Sets `c` to the value of `a` raised to the `b` power.
+    It returns `MP_RANGE` if `b < 0`. */
+mp_result mp_int_expt_value(mp_small a, mp_small b, mp_int c);
+
+/** Sets `c` to the value of `a` raised to the `b` power.
+    It returns `MP_RANGE`) if `b < 0`. */
+mp_result mp_int_expt_full(mp_int a, mp_int b, mp_int c);
+
+/** Sets `*r` to the remainder of `a / value`.
+    The remainder is pinned to `0 <= r < value`. */
+static inline
+mp_result mp_int_mod_value(mp_int a, mp_small value, mp_small* r) {
+  return mp_int_div_value(a, value, 0, r);
+}
+
+/** Returns the comparator of `a` and `b`. */
+int mp_int_compare(mp_int a, mp_int b);
+
+/** Returns the comparator of the magnitudes of `a` and `b`, disregarding their
+    signs. Neither `a` nor `b` is modified by the comparison. */
+int mp_int_compare_unsigned(mp_int a, mp_int b);
+
+/** Returns the comparator of `z` and zero. */
+int mp_int_compare_zero(mp_int z);
+
+/** Returns the comparator of `z` and the signed value `v`. */
+int mp_int_compare_value(mp_int z, mp_small v);
+
+/** Returns the comparator of `z` and the unsigned value `uv`. */
+int mp_int_compare_uvalue(mp_int z, mp_usmall uv);
+
+/** Reports whether `a` is divisible by `v`. */
+bool mp_int_divisible_value(mp_int a, mp_small v);
+
+/** Returns `k >= 0` such that `z` is `2^k`, if such a `k` exists. If no such
+    `k` exists, the function returns -1. */
+int mp_int_is_pow2(mp_int z);
+
+/** Sets `c` to the value of `a` raised to the `b` power, reduced modulo `m`.
+    It returns `MP_RANGE` if `b < 0` or `MP_UNDEF` if `m == 0`. */
+mp_result mp_int_exptmod(mp_int a, mp_int b, mp_int m, mp_int c);
+
+/** Sets `c` to the value of `a` raised to the `value` power, modulo `m`.
+    It returns `MP_RANGE` if `value < 0` or `MP_UNDEF` if `m == 0`. */
+mp_result mp_int_exptmod_evalue(mp_int a, mp_small value, mp_int m, mp_int c);
+
+/** Sets `c` to the value of `value` raised to the `b` power, modulo `m`.
+    It returns `MP_RANGE` if `b < 0` or `MP_UNDEF` if `m == 0`. */
+mp_result mp_int_exptmod_bvalue(mp_small value, mp_int b, mp_int m, mp_int c);
+
+/** Sets `c` to the value of `a` raised to the `b` power, reduced modulo `m`,
+    given a precomputed reduction constant `mu` defined for Barrett's modular
+    reduction algorithm.
+
+    It returns `MP_RANGE` if `b < 0` or `MP_UNDEF` if `m == 0`. */
+mp_result mp_int_exptmod_known(mp_int a, mp_int b, mp_int m, mp_int mu, mp_int c);
+
+/** Sets `c` to the reduction constant for Barrett reduction by modulus `m`.
+    Requires that `c` and `m` point to distinct locations. */
 mp_result mp_int_redux_const(mp_int m, mp_int c);
 
-mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c); /* c = 1/a (mod m) */
+/** Sets `c` to the multiplicative inverse of `a` modulo `m`, if it exists.
+    The least non-negative representative of the congruence class is computed.
+
+    It returns `MP_UNDEF` if the inverse does not exist, or `MP_RANGE` if `a ==
+    0` or `m <= 0`. */
+mp_result mp_int_invmod(mp_int a, mp_int m, mp_int c);
+
+/** Sets `c` to the greatest common divisor of `a` and `b`.
+
+    It returns `MP_UNDEF` if the GCD is undefined, such as for example if `a`
+    and `b` are both zero. */
+mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c);
+
+/** Sets `c` to the greatest common divisor of `a` and `b`, and sets `x` and
+    `y` to values satisfying Bezout's identity `gcd(a, b) = ax + by`.
 
-mp_result mp_int_gcd(mp_int a, mp_int b, mp_int c);    /* c = gcd(a, b)   */
+    It returns `MP_UNDEF` if the GCD is undefined, such as for example if `a`
+    and `b` are both zero. */
+mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c, mp_int x, mp_int y);
 
-mp_result mp_int_egcd(mp_int a, mp_int b, mp_int c,    /* c = gcd(a, b)   */
-		      mp_int x, mp_int y);             /* c = ax + by     */
+/** Sets `c` to the least common multiple of `a` and `b`.
 
-mp_result mp_int_lcm(mp_int a, mp_int b, mp_int c);    /* c = lcm(a, b)   */
+    It returns `MP_UNDEF` if the LCM is undefined, such as for example if `a`
+    and `b` are both zero. */
+mp_result mp_int_lcm(mp_int a, mp_int b, mp_int c);
 
-mp_result mp_int_root(mp_int a, mp_small b, mp_int c); /* c = floor(a^{1/b}) */
-#define   mp_int_sqrt(a, c) mp_int_root(a, 2, c)       /* c = floor(sqrt(a)) */
+/** Sets `c` to the greatest integer not less than the `b`th root of `a`,
+    using Newton's root-finding algorithm.
+    It returns `MP_UNDEF` if `a < 0` and `b` is even. */
+mp_result mp_int_root(mp_int a, mp_small b, mp_int c);
 
-/* Convert to a small int, if representable; else MP_RANGE */
+/** Sets `c` to the greatest integer not less than the square root of `a`.
+    This is a special case of `mp_int_root()`. */
+static inline
+mp_result mp_int_sqrt(mp_int a, mp_int c) { return mp_int_root(a, 2, c); }
+
+/** Returns `MP_OK` if `z` is representable as `mp_small`, else `MP_RANGE`.
+    If `out` is not NULL, `*out` is set to the value of `z` when `MP_OK`. */
 mp_result mp_int_to_int(mp_int z, mp_small *out);
+
+/** Returns `MP_OK` if `z` is representable as `mp_usmall`, or `MP_RANGE`.
+    If `out` is not NULL, `*out` is set to the value of `z` when `MP_OK`. */
 mp_result mp_int_to_uint(mp_int z, mp_usmall *out);
 
-/* Convert to nul-terminated string with the specified radix, writing at
-   most limit characters including the nul terminator  */
-mp_result mp_int_to_string(mp_int z, mp_size radix,
-			   char *str, int limit);
+/** Converts `z` to a zero-terminated string of characters in the specified
+    `radix`, writing at most `limit` characters to `str` including the
+    terminating NUL value. A leading `-` is used to indicate a negative value.
 
-/* Return the number of characters required to represent
-   z in the given radix.  May over-estimate. */
+    Returns `MP_TRUNC` if `limit` was to small to write all of `z`.
+    Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
+mp_result mp_int_to_string(mp_int z, mp_size radix, char *str, int limit);
+
+/** Reports the minimum number of characters required to represent `z` as a
+    zero-terminated string in the given `radix`.
+    Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
 mp_result mp_int_string_len(mp_int z, mp_size radix);
 
-/* Read zero-terminated string into z */
+/** Reads a string of ASCII digits in the specified `radix` from the zero
+    terminated `str` provided into `z`. For values of `radix > 10`, the letters
+    `A`..`Z` or `a`..`z` are accepted. Letters are interpreted without respect
+    to case.
+
+    Leading whitespace is ignored, and a leading `+` or `-` is interpreted as a
+    sign flag. Processing stops when a NUL or any other character out of range
+    for a digit in the given radix is encountered.
+
+    If the whole string was consumed, `MP_OK` is returned; otherwise
+    `MP_TRUNC`. is returned.
+
+    Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
 mp_result mp_int_read_string(mp_int z, mp_size radix, const char *str);
-mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str,
-			      char **end);
 
-/* Return the number of significant bits in z */
+/** Reads a string of ASCII digits in the specified `radix` from the zero
+    terminated `str` provided into `z`. For values of `radix > 10`, the letters
+    `A`..`Z` or `a`..`z` are accepted. Letters are interpreted without respect
+    to case.
+
+    Leading whitespace is ignored, and a leading `+` or `-` is interpreted as a
+    sign flag. Processing stops when a NUL or any other character out of range
+    for a digit in the given radix is encountered.
+
+    If the whole string was consumed, `MP_OK` is returned; otherwise
+    `MP_TRUNC`. is returned. If `end` is not NULL, `*end` is set to point to
+    the first unconsumed byte of the input string (the NUL byte if the whole
+    string was consumed). This emulates the behavior of the standard C
+    `strtol()` function.
+
+    Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
+mp_result mp_int_read_cstring(mp_int z, mp_size radix, const char *str, char **end);
+
+/** Returns the number of significant bits in `z`. */
 mp_result mp_int_count_bits(mp_int z);
 
-/* Convert z to two's complement binary, writing at most limit bytes */
+/** Converts `z` to 2's complement binary, writing at most `limit` bytes into
+    the given `buf`.  Returns `MP_TRUNC` if the buffer limit was too small to
+    contain the whole value.  If this occurs, the contents of buf will be
+    effectively garbage, as the function uses the buffer as scratch space.
+
+    The binary representation of `z` is in base-256 with digits ordered from
+    most significant to least significant (network byte ordering).  The
+    high-order bit of the first byte is set for negative values, clear for
+    non-negative values.
+
+    As a result, non-negative values will be padded with a leading zero byte if
+    the high-order byte of the base-256 magnitude is set.  This extra byte is
+    accounted for by the `mp_int_binary_len()` function. */
 mp_result mp_int_to_binary(mp_int z, unsigned char *buf, int limit);
 
-/* Read a two's complement binary value into z from the given buffer */
+/** Reads a 2's complement binary value from `buf` into `z`, where `len` is the
+    length of the buffer.  The contents of `buf` may be overwritten during
+    processing, although they will be restored when the function returns. */
 mp_result mp_int_read_binary(mp_int z, unsigned char *buf, int len);
 
-/* Return the number of bytes required to represent z in binary. */
+/** Returns the number of bytes to represent `z` in 2's complement binary. */
 mp_result mp_int_binary_len(mp_int z);
 
-/* Convert z to unsigned binary, writing at most limit bytes */
+/** Converts the magnitude of `z` to unsigned binary, writing at most `limit`
+    bytes into the given `buf`.  The sign of `z` is ignored, but `z` is not
+    modified.  Returns `MP_TRUNC` if the buffer limit was too small to contain
+    the whole value.  If this occurs, the contents of `buf` will be effectively
+    garbage, as the function uses the buffer as scratch space during
+    conversion.
+
+    The binary representation of `z` is in base-256 with digits ordered from
+    most significant to least significant (network byte ordering). */
 mp_result mp_int_to_unsigned(mp_int z, unsigned char *buf, int limit);
 
-/* Read an unsigned binary value into z from the given buffer */
+/** Reads an unsigned binary value from `buf` into `z`, where `len` is the
+    length of the buffer. The contents of `buf` are not modified during
+    processing. */
 mp_result mp_int_read_unsigned(mp_int z, unsigned char *buf, int len);
 
-/* Return the number of bytes required to represent z as unsigned output */
+/** Returns the number of bytes required to represent `z` as an unsigned binary
+    value in base 256. */
 mp_result mp_int_unsigned_len(mp_int z);
 
-/* Return a statically allocated string describing error code res */
+/** Returns a pointer to a brief, human-readable, zero-terminated string
+    describing `res`. The returned string is statically allocated and must not
+    be freed by the caller. */
 const char *mp_error_string(mp_result res);
 
-#if DEBUG
-void      s_print(char *tag, mp_int z);
-void      s_print_buf(char *tag, mp_digit *buf, mp_size num);
-#endif
-
 #ifdef __cplusplus
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/imath/imrat.c -> _service:tar_scm:isl-0.24.tar.gz/imath/imrat.c Changed

@@ -1,7 +1,7 @@
 /*
   Name:     imrat.c
   Purpose:  Arbitrary precision rational arithmetic routines.
-  Author:   M. J. Fromberger <http://spinning-yarns.org/michael/>
+  Author:   M. J. Fromberger
 
   Copyright (C) 2002-2007 Michael J. Fromberger, All Rights Reserved.
 
@@ -25,23 +25,20 @@
  */
 
 #include "imrat.h"
+#include <assert.h>
+#include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
-#include <ctype.h>
-#include <assert.h>
 
-/* {{{ Useful macros */
+#define MP_NUMER_SIGN(Q) (MP_NUMER_P(Q)->sign)
+#define MP_DENOM_SIGN(Q) (MP_DENOM_P(Q)->sign)
 
 #define TEMP(K) (temp + (K))
-#define SETUP(E, C) \
-do{if((res = (E)) != MP_OK) goto CLEANUP; ++(C);}while(0)
-
-/* Argument checking:
-   Use CHECK() where a return value is required; NRCHECK() elsewhere */
-#define CHECK(TEST)   assert(TEST)
-#define NRCHECK(TEST) assert(TEST)
-
-/* }}} */
+#define SETUP(E, C)                         \
+  do {                                      \
+    if ((res = (E)) != MP_OK) goto CLEANUP; \
+    ++(C);                                  \
+  } while (0)
 
 /* Reduce the given rational, in place, to lowest terms and canonical form.
    Zero is represented as 0/1, one as 1/1.  Signs are adjusted so that the sign
@@ -50,16 +47,12 @@
 
 /* Common code for addition and subtraction operations on rationals. */
 static mp_result s_rat_combine(mp_rat a, mp_rat b, mp_rat c,
-			       mp_result (*comb_f)(mp_int, mp_int, mp_int));
-
-/* {{{ mp_rat_init(r) */
+                               mp_result (*comb_f)(mp_int, mp_int, mp_int));
 
-mp_result mp_rat_init(mp_rat r)
-{
+mp_result mp_rat_init(mp_rat r) {
   mp_result res;
 
-  if ((res = mp_int_init(MP_NUMER_P(r))) != MP_OK)
-    return res;
+  if ((res = mp_int_init(MP_NUMER_P(r))) != MP_OK) return res;
   if ((res = mp_int_init(MP_DENOM_P(r))) != MP_OK) {
     mp_int_clear(MP_NUMER_P(r));
     return res;
@@ -68,12 +61,7 @@
   return mp_int_set_value(MP_DENOM_P(r), 1);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_alloc() */
-
-mp_rat mp_rat_alloc(void)
-{
+mp_rat mp_rat_alloc(void) {
   mp_rat out = malloc(sizeof(*out));
 
   if (out != NULL) {
@@ -86,591 +74,429 @@
   return out;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_reduce(r) */
-
-mp_result mp_rat_reduce(mp_rat r) {
-  return s_rat_reduce(r);
-}
-
-/* }}} */
+mp_result mp_rat_reduce(mp_rat r) { return s_rat_reduce(r); }
 
-/* {{{ mp_rat_init_size(r, n_prec, d_prec) */
-
-mp_result mp_rat_init_size(mp_rat r, mp_size n_prec, mp_size d_prec)
-{
+mp_result mp_rat_init_size(mp_rat r, mp_size n_prec, mp_size d_prec) {
   mp_result res;
 
-  if ((res = mp_int_init_size(MP_NUMER_P(r), n_prec)) != MP_OK)
+  if ((res = mp_int_init_size(MP_NUMER_P(r), n_prec)) != MP_OK) {
     return res;
+  }
   if ((res = mp_int_init_size(MP_DENOM_P(r), d_prec)) != MP_OK) {
     mp_int_clear(MP_NUMER_P(r));
     return res;
   }
-  
+
   return mp_int_set_value(MP_DENOM_P(r), 1);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_init_copy(r, old) */
-
-mp_result mp_rat_init_copy(mp_rat r, mp_rat old)
-{
+mp_result mp_rat_init_copy(mp_rat r, mp_rat old) {
   mp_result res;
 
-  if ((res = mp_int_init_copy(MP_NUMER_P(r), MP_NUMER_P(old))) != MP_OK)
+  if ((res = mp_int_init_copy(MP_NUMER_P(r), MP_NUMER_P(old))) != MP_OK) {
     return res;
-  if ((res = mp_int_init_copy(MP_DENOM_P(r), MP_DENOM_P(old))) != MP_OK) 
+  }
+  if ((res = mp_int_init_copy(MP_DENOM_P(r), MP_DENOM_P(old))) != MP_OK)
     mp_int_clear(MP_NUMER_P(r));
-  
+
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_set_value(r, numer, denom) */
-
-mp_result mp_rat_set_value(mp_rat r, mp_small numer, mp_small denom)
-{
+mp_result mp_rat_set_value(mp_rat r, mp_small numer, mp_small denom) {
   mp_result res;
 
-  if (denom == 0)
-    return MP_UNDEF;
+  if (denom == 0) return MP_UNDEF;
 
-  if ((res = mp_int_set_value(MP_NUMER_P(r), numer)) != MP_OK)
+  if ((res = mp_int_set_value(MP_NUMER_P(r), numer)) != MP_OK) {
     return res;
-  if ((res = mp_int_set_value(MP_DENOM_P(r), denom)) != MP_OK)
+  }
+  if ((res = mp_int_set_value(MP_DENOM_P(r), denom)) != MP_OK) {
     return res;
+  }
 
   return s_rat_reduce(r);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_set_uvalue(r, numer, denom) */
-
-mp_result mp_rat_set_uvalue(mp_rat r, mp_usmall numer, mp_usmall denom)
-{
+mp_result mp_rat_set_uvalue(mp_rat r, mp_usmall numer, mp_usmall denom) {
   mp_result res;
 
-  if (denom == 0)
-    return MP_UNDEF;
+  if (denom == 0) return MP_UNDEF;
 
-  if ((res = mp_int_set_uvalue(MP_NUMER_P(r), numer)) != MP_OK)
+  if ((res = mp_int_set_uvalue(MP_NUMER_P(r), numer)) != MP_OK) {
     return res;
-  if ((res = mp_int_set_uvalue(MP_DENOM_P(r), denom)) != MP_OK)
+  }
+  if ((res = mp_int_set_uvalue(MP_DENOM_P(r), denom)) != MP_OK) {
     return res;
+  }
 
   return s_rat_reduce(r);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_clear(r) */
-
-void      mp_rat_clear(mp_rat r)
-{
+void mp_rat_clear(mp_rat r) {
   mp_int_clear(MP_NUMER_P(r));
   mp_int_clear(MP_DENOM_P(r));
-
 }
 
-/* }}} */
+void mp_rat_free(mp_rat r) {
+  assert(r != NULL);
 
-/* {{{ mp_rat_free(r) */
-
-void      mp_rat_free(mp_rat r)
-{
-  NRCHECK(r != NULL);
-  
-  if (r->num.digits != NULL)
-    mp_rat_clear(r);
+  if (r->num.digits != NULL) mp_rat_clear(r);
 
   free(r);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_numer(r, z) */
-
-mp_result mp_rat_numer(mp_rat r, mp_int z)
-{
+mp_result mp_rat_numer(mp_rat r, mp_int z) {
   return mp_int_copy(MP_NUMER_P(r), z);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_numer_ref(r) */
-
-mp_int mp_rat_numer_ref(mp_rat r)
-{
-  return MP_NUMER_P(r);
-}
-
-/* }}} */
-
+mp_int mp_rat_numer_ref(mp_rat r) { return MP_NUMER_P(r); }
 
-/* {{{ mp_rat_denom(r, z) */
-
-mp_result mp_rat_denom(mp_rat r, mp_int z)
-{
+mp_result mp_rat_denom(mp_rat r, mp_int z) {
   return mp_int_copy(MP_DENOM_P(r), z);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_denom_ref(r) */
-
-mp_int    mp_rat_denom_ref(mp_rat r)
-{
-  return MP_DENOM_P(r);
-}
-
-/* }}} */
-
-/* {{{ mp_rat_sign(r) */
-
-mp_sign   mp_rat_sign(mp_rat r)
-{
-  return MP_SIGN(MP_NUMER_P(r));
-}
-
-/* }}} */
+mp_int mp_rat_denom_ref(mp_rat r) { return MP_DENOM_P(r); }
 
-/* {{{ mp_rat_copy(a, c) */
+mp_sign mp_rat_sign(mp_rat r) { return MP_NUMER_SIGN(r); }
 
-mp_result mp_rat_copy(mp_rat a, mp_rat c)
-{
+mp_result mp_rat_copy(mp_rat a, mp_rat c) {
   mp_result res;
 
-  if ((res = mp_int_copy(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK)
+  if ((res = mp_int_copy(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK) {
     return res;
-  
+  }
+
   res = mp_int_copy(MP_DENOM_P(a), MP_DENOM_P(c));
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_zero(r) */
-
-void      mp_rat_zero(mp_rat r)
-{
+void mp_rat_zero(mp_rat r) {
   mp_int_zero(MP_NUMER_P(r));
   mp_int_set_value(MP_DENOM_P(r), 1);
-  
 }
 
-/* }}} */
-
-/* {{{ mp_rat_abs(a, c) */
-
-mp_result mp_rat_abs(mp_rat a, mp_rat c)
-{
+mp_result mp_rat_abs(mp_rat a, mp_rat c) {
   mp_result res;
 
-  if ((res = mp_int_abs(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK)
+  if ((res = mp_int_abs(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK) {
     return res;
-  
+  }
+
   res = mp_int_abs(MP_DENOM_P(a), MP_DENOM_P(c));
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_neg(a, c) */
-
-mp_result mp_rat_neg(mp_rat a, mp_rat c)
-{
+mp_result mp_rat_neg(mp_rat a, mp_rat c) {
   mp_result res;
 
-  if ((res = mp_int_neg(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK)
+  if ((res = mp_int_neg(MP_NUMER_P(a), MP_NUMER_P(c))) != MP_OK) {
     return res;
+  }
 
   res = mp_int_copy(MP_DENOM_P(a), MP_DENOM_P(c));
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_recip(a, c) */
-
-mp_result mp_rat_recip(mp_rat a, mp_rat c)
-{
+mp_result mp_rat_recip(mp_rat a, mp_rat c) {
   mp_result res;
 
-  if (mp_rat_compare_zero(a) == 0)
-    return MP_UNDEF;
+  if (mp_rat_compare_zero(a) == 0) return MP_UNDEF;
 
-  if ((res = mp_rat_copy(a, c)) != MP_OK)
-    return res;
+  if ((res = mp_rat_copy(a, c)) != MP_OK) return res;
 
   mp_int_swap(MP_NUMER_P(c), MP_DENOM_P(c));
 
   /* Restore the signs of the swapped elements */
   {
-    mp_sign tmp = MP_SIGN(MP_NUMER_P(c));
+    mp_sign tmp = MP_NUMER_SIGN(c);
 
-    MP_SIGN(MP_NUMER_P(c)) = MP_SIGN(MP_DENOM_P(c));
-    MP_SIGN(MP_DENOM_P(c)) = tmp;
+    MP_NUMER_SIGN(c) = MP_DENOM_SIGN(c);
+    MP_DENOM_SIGN(c) = tmp;
   }
 
   return MP_OK;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_add(a, b, c) */
-
-mp_result mp_rat_add(mp_rat a, mp_rat b, mp_rat c)
-{
+mp_result mp_rat_add(mp_rat a, mp_rat b, mp_rat c) {
   return s_rat_combine(a, b, c, mp_int_add);
-
 }
 
-/* }}} */
-
-/* {{{ mp_rat_sub(a, b, c) */
-
-mp_result mp_rat_sub(mp_rat a, mp_rat b, mp_rat c)
-{
+mp_result mp_rat_sub(mp_rat a, mp_rat b, mp_rat c) {
   return s_rat_combine(a, b, c, mp_int_sub);
-
 }
 
-/* }}} */
-
-/* {{{ mp_rat_mul(a, b, c) */
-
-mp_result mp_rat_mul(mp_rat a, mp_rat b, mp_rat c)
-{
+mp_result mp_rat_mul(mp_rat a, mp_rat b, mp_rat c) {
   mp_result res;
 
   if ((res = mp_int_mul(MP_NUMER_P(a), MP_NUMER_P(b), MP_NUMER_P(c))) != MP_OK)
     return res;
 
   if (mp_int_compare_zero(MP_NUMER_P(c)) != 0) {
-    if ((res = mp_int_mul(MP_DENOM_P(a), MP_DENOM_P(b), MP_DENOM_P(c))) != MP_OK)
+    res = mp_int_mul(MP_DENOM_P(a), MP_DENOM_P(b), MP_DENOM_P(c));
+    if (res != MP_OK) {
       return res;
+    }
   }
 
   return s_rat_reduce(c);
 }
 
-/* }}} */
-
-/* {{{ mp_int_div(a, b, c) */
-
-mp_result mp_rat_div(mp_rat a, mp_rat b, mp_rat c)
-{
+mp_result mp_rat_div(mp_rat a, mp_rat b, mp_rat c) {
   mp_result res = MP_OK;
 
-  if (mp_rat_compare_zero(b) == 0)
-    return MP_UNDEF;
+  if (mp_rat_compare_zero(b) == 0) return MP_UNDEF;
 
   if (c == a || c == b) {
     mpz_t tmp;
 
     if ((res = mp_int_init(&tmp)) != MP_OK) return res;
-    if ((res = mp_int_mul(MP_NUMER_P(a), MP_DENOM_P(b), &tmp)) != MP_OK) 
+    if ((res = mp_int_mul(MP_NUMER_P(a), MP_DENOM_P(b), &tmp)) != MP_OK) {
       goto CLEANUP;
-    if ((res = mp_int_mul(MP_DENOM_P(a), MP_NUMER_P(b), MP_DENOM_P(c))) != MP_OK)
+    }
+    if ((res = mp_int_mul(MP_DENOM_P(a), MP_NUMER_P(b), MP_DENOM_P(c))) !=
+        MP_OK) {
       goto CLEANUP;
+    }
     res = mp_int_copy(&tmp, MP_NUMER_P(c));
 
   CLEANUP:
     mp_int_clear(&tmp);
-  }
-  else {
-    if ((res = mp_int_mul(MP_NUMER_P(a), MP_DENOM_P(b), MP_NUMER_P(c))) != MP_OK)
+  } else {
+    if ((res = mp_int_mul(MP_NUMER_P(a), MP_DENOM_P(b), MP_NUMER_P(c))) !=
+        MP_OK) {
       return res;
-    if ((res = mp_int_mul(MP_DENOM_P(a), MP_NUMER_P(b), MP_DENOM_P(c))) != MP_OK)
+    }
+    if ((res = mp_int_mul(MP_DENOM_P(a), MP_NUMER_P(b), MP_DENOM_P(c))) !=
+        MP_OK) {
       return res;
+    }
   }
 
-  if (res != MP_OK)
+  if (res != MP_OK) {
     return res;
-  else
+  } else {
     return s_rat_reduce(c);
+  }
 }
 
-/* }}} */
-
-/* {{{ mp_rat_add_int(a, b, c) */
-
-mp_result mp_rat_add_int(mp_rat a, mp_int b, mp_rat c)
-{
+mp_result mp_rat_add_int(mp_rat a, mp_int b, mp_rat c) {
   mpz_t tmp;
   mp_result res;
 
-  if ((res = mp_int_init_copy(&tmp, b)) != MP_OK)
+  if ((res = mp_int_init_copy(&tmp, b)) != MP_OK) {
     return res;
-
-  if ((res = mp_int_mul(&tmp, MP_DENOM_P(a), &tmp)) != MP_OK)
+  }
+  if ((res = mp_int_mul(&tmp, MP_DENOM_P(a), &tmp)) != MP_OK) {
     goto CLEANUP;
-
-  if ((res = mp_rat_copy(a, c)) != MP_OK)
+  }
+  if ((res = mp_rat_copy(a, c)) != MP_OK) {
     goto CLEANUP;
-
-  if ((res = mp_int_add(MP_NUMER_P(c), &tmp, MP_NUMER_P(c))) != MP_OK)
+  }
+  if ((res = mp_int_add(MP_NUMER_P(c), &tmp, MP_NUMER_P(c))) != MP_OK) {
     goto CLEANUP;
+  }
 
   res = s_rat_reduce(c);
 
- CLEANUP:
+CLEANUP:
   mp_int_clear(&tmp);
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_sub_int(a, b, c) */
-
-mp_result mp_rat_sub_int(mp_rat a, mp_int b, mp_rat c)
-{
+mp_result mp_rat_sub_int(mp_rat a, mp_int b, mp_rat c) {
   mpz_t tmp;
   mp_result res;
 
-  if ((res = mp_int_init_copy(&tmp, b)) != MP_OK)
+  if ((res = mp_int_init_copy(&tmp, b)) != MP_OK) {
     return res;
-
-  if ((res = mp_int_mul(&tmp, MP_DENOM_P(a), &tmp)) != MP_OK)
+  }
+  if ((res = mp_int_mul(&tmp, MP_DENOM_P(a), &tmp)) != MP_OK) {
     goto CLEANUP;
-
-  if ((res = mp_rat_copy(a, c)) != MP_OK)
+  }
+  if ((res = mp_rat_copy(a, c)) != MP_OK) {
     goto CLEANUP;
-
-  if ((res = mp_int_sub(MP_NUMER_P(c), &tmp, MP_NUMER_P(c))) != MP_OK)
+  }
+  if ((res = mp_int_sub(MP_NUMER_P(c), &tmp, MP_NUMER_P(c))) != MP_OK) {
     goto CLEANUP;
+  }
 
   res = s_rat_reduce(c);
 
- CLEANUP:
+CLEANUP:
   mp_int_clear(&tmp);
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_mul_int(a, b, c) */
-
-mp_result mp_rat_mul_int(mp_rat a, mp_int b, mp_rat c)
-{
+mp_result mp_rat_mul_int(mp_rat a, mp_int b, mp_rat c) {
   mp_result res;
 
-  if ((res = mp_rat_copy(a, c)) != MP_OK)
+  if ((res = mp_rat_copy(a, c)) != MP_OK) {
     return res;
-
-  if ((res = mp_int_mul(MP_NUMER_P(c), b, MP_NUMER_P(c))) != MP_OK)
+  }
+  if ((res = mp_int_mul(MP_NUMER_P(c), b, MP_NUMER_P(c))) != MP_OK) {
     return res;
+  }
 
   return s_rat_reduce(c);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_div_int(a, b, c) */
-
-mp_result mp_rat_div_int(mp_rat a, mp_int b, mp_rat c)
-{
+mp_result mp_rat_div_int(mp_rat a, mp_int b, mp_rat c) {
   mp_result res;
 
-  if (mp_int_compare_zero(b) == 0)
+  if (mp_int_compare_zero(b) == 0) {
     return MP_UNDEF;
-
-  if ((res = mp_rat_copy(a, c)) != MP_OK)
+  }
+  if ((res = mp_rat_copy(a, c)) != MP_OK) {
     return res;
-
-  if ((res = mp_int_mul(MP_DENOM_P(c), b, MP_DENOM_P(c))) != MP_OK)
+  }
+  if ((res = mp_int_mul(MP_DENOM_P(c), b, MP_DENOM_P(c))) != MP_OK) {
     return res;
+  }
 
   return s_rat_reduce(c);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_expt(a, b, c) */
-
-mp_result mp_rat_expt(mp_rat a, mp_small b, mp_rat c)
-{
-  mp_result  res;
+mp_result mp_rat_expt(mp_rat a, mp_small b, mp_rat c) {
+  mp_result res;
 
   /* Special cases for easy powers. */
-  if (b == 0)
+  if (b == 0) {
     return mp_rat_set_value(c, 1, 1);
-  else if(b == 1)
+  } else if (b == 1) {
     return mp_rat_copy(a, c);
+  }
 
   /* Since rationals are always stored in lowest terms, it is not necessary to
      reduce again when raising to an integer power. */
-  if ((res = mp_int_expt(MP_NUMER_P(a), b, MP_NUMER_P(c))) != MP_OK)
+  if ((res = mp_int_expt(MP_NUMER_P(a), b, MP_NUMER_P(c))) != MP_OK) {
     return res;
+  }
 
   return mp_int_expt(MP_DENOM_P(a), b, MP_DENOM_P(c));
 }
 
-/* }}} */
-
-/* {{{ mp_rat_compare(a, b) */
-
-int       mp_rat_compare(mp_rat a, mp_rat b)
-{
+int mp_rat_compare(mp_rat a, mp_rat b) {
   /* Quick check for opposite signs.  Works because the sign of the numerator
      is always definitive. */
-  if (MP_SIGN(MP_NUMER_P(a)) != MP_SIGN(MP_NUMER_P(b))) {
-    if (MP_SIGN(MP_NUMER_P(a)) == MP_ZPOS)
+  if (MP_NUMER_SIGN(a) != MP_NUMER_SIGN(b)) {
+    if (MP_NUMER_SIGN(a) == MP_ZPOS) {
       return 1;
-    else
+    } else {
       return -1;
-  }
-  else {
+    }
+  } else {
     /* Compare absolute magnitudes; if both are positive, the answer stands,
        otherwise it needs to be reflected about zero. */
     int cmp = mp_rat_compare_unsigned(a, b);
 
-    if (MP_SIGN(MP_NUMER_P(a)) == MP_ZPOS)
+    if (MP_NUMER_SIGN(a) == MP_ZPOS) {
       return cmp;
-    else
+    } else {
       return -cmp;
+    }
   }
 }
 
-/* }}} */
-
-/* {{{ mp_rat_compare_unsigned(a, b) */
-
-int       mp_rat_compare_unsigned(mp_rat a, mp_rat b)
-{
+int mp_rat_compare_unsigned(mp_rat a, mp_rat b) {
   /* If the denominators are equal, we can quickly compare numerators without
      multiplying.  Otherwise, we actually have to do some work. */
-  if (mp_int_compare_unsigned(MP_DENOM_P(a), MP_DENOM_P(b)) == 0)
+  if (mp_int_compare_unsigned(MP_DENOM_P(a), MP_DENOM_P(b)) == 0) {
     return mp_int_compare_unsigned(MP_NUMER_P(a), MP_NUMER_P(b));
+  }
 
   else {
-    mpz_t  temp2;
+    mpz_t temp2;
     mp_result res;
-    int  cmp = INT_MAX, last = 0;
+    int cmp = INT_MAX, last = 0;
 
     /* t0 = num(a) * den(b), t1 = num(b) * den(a) */
     SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(a)), last);
     SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(b)), last);
 
     if ((res = mp_int_mul(TEMP(0), MP_DENOM_P(b), TEMP(0))) != MP_OK ||
-	(res = mp_int_mul(TEMP(1), MP_DENOM_P(a), TEMP(1))) != MP_OK)
+        (res = mp_int_mul(TEMP(1), MP_DENOM_P(a), TEMP(1))) != MP_OK) {
       goto CLEANUP;
-    
+    }
+
     cmp = mp_int_compare_unsigned(TEMP(0), TEMP(1));
-    
+
   CLEANUP:
-    while (--last >= 0)
+    while (--last >= 0) {
       mp_int_clear(TEMP(last));
+    }
 
     return cmp;
   }
 }
 
-/* }}} */
-
-/* {{{ mp_rat_compare_zero(r) */
-
-int       mp_rat_compare_zero(mp_rat r)
-{
-  return mp_int_compare_zero(MP_NUMER_P(r));
-}
-
-/* }}} */
+int mp_rat_compare_zero(mp_rat r) { return mp_int_compare_zero(MP_NUMER_P(r)); }
 
-/* {{{ mp_rat_compare_value(r, n, d) */
-
-int       mp_rat_compare_value(mp_rat r, mp_small n, mp_small d)
-{
+int mp_rat_compare_value(mp_rat r, mp_small n, mp_small d) {
   mpq_t tmp;
   mp_result res;
-  int  out = INT_MAX;
+  int out = INT_MAX;
 
-  if ((res = mp_rat_init(&tmp)) != MP_OK)
+  if ((res = mp_rat_init(&tmp)) != MP_OK) {
     return out;
-  if ((res = mp_rat_set_value(&tmp, n, d)) != MP_OK)
+  }
+  if ((res = mp_rat_set_value(&tmp, n, d)) != MP_OK) {
     goto CLEANUP;
-  
+  }
+
   out = mp_rat_compare(r, &tmp);
-  
- CLEANUP:
+
+CLEANUP:
   mp_rat_clear(&tmp);
   return out;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_is_integer(r) */
-
-int       mp_rat_is_integer(mp_rat r)
-{
+bool mp_rat_is_integer(mp_rat r) {
   return (mp_int_compare_value(MP_DENOM_P(r), 1) == 0);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_to_ints(r, *num, *den) */
-
-mp_result mp_rat_to_ints(mp_rat r, mp_small *num, mp_small *den)
-{
+mp_result mp_rat_to_ints(mp_rat r, mp_small *num, mp_small *den) {
   mp_result res;
 
-  if ((res = mp_int_to_int(MP_NUMER_P(r), num)) != MP_OK)
+  if ((res = mp_int_to_int(MP_NUMER_P(r), num)) != MP_OK) {
     return res;
+  }
 
   res = mp_int_to_int(MP_DENOM_P(r), den);
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_to_string(r, radix, *str, limit) */
-
-mp_result mp_rat_to_string(mp_rat r, mp_size radix, char *str, int limit)
-{
-  char *start;
-  int   len;
-  mp_result res;
-
+mp_result mp_rat_to_string(mp_rat r, mp_size radix, char *str, int limit) {
   /* Write the numerator.  The sign of the rational number is written by the
      underlying integer implementation. */
-  if ((res = mp_int_to_string(MP_NUMER_P(r), radix, str, limit)) != MP_OK)
+  mp_result res;
+  if ((res = mp_int_to_string(MP_NUMER_P(r), radix, str, limit)) != MP_OK) {
     return res;
+  }
 
   /* If the value is zero, don't bother writing any denominator */
-  if (mp_int_compare_zero(MP_NUMER_P(r)) == 0)
+  if (mp_int_compare_zero(MP_NUMER_P(r)) == 0) {
     return MP_OK;
-  
+  }
+
   /* Locate the end of the numerator, and make sure we are not going to exceed
      the limit by writing a slash. */
-  len = strlen(str);
-  start = str + len;
+  int len = strlen(str);
+  char *start = str + len;
   limit -= len;
-  if(limit == 0)
-    return MP_TRUNC;
+  if (limit == 0) return MP_TRUNC;
 
   *start++ = '/';
   limit -= 1;
-  
-  res = mp_int_to_string(MP_DENOM_P(r), radix, start, limit);
-  return res;
-}
 
-/* }}} */
+  return mp_int_to_string(MP_DENOM_P(r), radix, start, limit);
+}
 
-/* {{{ mp_rat_to_decimal(r, radix, prec, *str, limit) */
 mp_result mp_rat_to_decimal(mp_rat r, mp_size radix, mp_size prec,
-                            mp_round_mode round, char *str, int limit)
-{
+                            mp_round_mode round, char *str, int limit) {
   mpz_t temp3;
   mp_result res;
-  char *start = str;
-  int len, lead_0, left = limit, last = 0;
-    
+  int last = 0;
+
   SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(r)), last);
   SETUP(mp_int_init(TEMP(last)), last);
   SETUP(mp_int_init(TEMP(last)), last);
@@ -678,32 +504,39 @@
   /* Get the unsigned integer part by dividing denominator into the absolute
      value of the numerator. */
   mp_int_abs(TEMP(0), TEMP(0));
-  if ((res = mp_int_div(TEMP(0), MP_DENOM_P(r), TEMP(0), TEMP(1))) != MP_OK)
+  if ((res = mp_int_div(TEMP(0), MP_DENOM_P(r), TEMP(0), TEMP(1))) != MP_OK) {
     goto CLEANUP;
+  }
 
   /* Now:  T0 = integer portion, unsigned;
            T1 = remainder, from which fractional part is computed. */
 
   /* Count up leading zeroes after the radix point. */
-  for (lead_0 = 0; lead_0 < prec && mp_int_compare(TEMP(1), MP_DENOM_P(r)) < 0; 
-      ++lead_0) {
-    if ((res = mp_int_mul_value(TEMP(1), radix, TEMP(1))) != MP_OK)
+  int zprec = (int)prec;
+  int lead_0;
+  for (lead_0 = 0; lead_0 < zprec && mp_int_compare(TEMP(1), MP_DENOM_P(r)) < 0;
+       ++lead_0) {
+    if ((res = mp_int_mul_value(TEMP(1), radix, TEMP(1))) != MP_OK) {
       goto CLEANUP;
+    }
   }
 
   /* Multiply remainder by a power of the radix sufficient to get the right
      number of significant figures. */
-  if (prec > lead_0) {
-    if ((res = mp_int_expt_value(radix, prec - lead_0, TEMP(2))) != MP_OK)
+  if (zprec > lead_0) {
+    if ((res = mp_int_expt_value(radix, zprec - lead_0, TEMP(2))) != MP_OK) {
       goto CLEANUP;
-    if ((res = mp_int_mul(TEMP(1), TEMP(2), TEMP(1))) != MP_OK)
+    }
+    if ((res = mp_int_mul(TEMP(1), TEMP(2), TEMP(1))) != MP_OK) {
       goto CLEANUP;
+    }
   }
-  if ((res = mp_int_div(TEMP(1), MP_DENOM_P(r), TEMP(1), TEMP(2))) != MP_OK)
+  if ((res = mp_int_div(TEMP(1), MP_DENOM_P(r), TEMP(1), TEMP(2))) != MP_OK) {
     goto CLEANUP;
+  }
 
   /* Now:  T1 = significant digits of fractional part;
-           T2 = leftovers, to use for rounding. 
+           T2 = leftovers, to use for rounding.
 
      At this point, what we do depends on the rounding mode.  The default is
      MP_ROUND_DOWN, for which everything is as it should be already.
@@ -711,64 +544,70 @@
   switch (round) {
     int cmp;
 
-  case MP_ROUND_UP:
-    if (mp_int_compare_zero(TEMP(2)) != 0) {
-      if (prec == 0)
-	res = mp_int_add_value(TEMP(0), 1, TEMP(0));
-      else
-	res = mp_int_add_value(TEMP(1), 1, TEMP(1));
-    }
-    break;
-
-  case MP_ROUND_HALF_UP:
-  case MP_ROUND_HALF_DOWN:
-    if ((res = mp_int_mul_pow2(TEMP(2), 1, TEMP(2))) != MP_OK)
-      goto CLEANUP;
-
-    cmp = mp_int_compare(TEMP(2), MP_DENOM_P(r));    
-
-    if (round == MP_ROUND_HALF_UP)
-      cmp += 1;
-
-    if (cmp > 0) {
-      if (prec == 0)
-	res = mp_int_add_value(TEMP(0), 1, TEMP(0));
-      else
-	res = mp_int_add_value(TEMP(1), 1, TEMP(1));
-    }
-    break;
-    
-  case MP_ROUND_DOWN:
-    break;  /* No action required */
-
-  default: 
-    return MP_BADARG; /* Invalid rounding specifier */
+    case MP_ROUND_UP:
+      if (mp_int_compare_zero(TEMP(2)) != 0) {
+        if (prec == 0) {
+          res = mp_int_add_value(TEMP(0), 1, TEMP(0));
+        } else {
+          res = mp_int_add_value(TEMP(1), 1, TEMP(1));
+        }
+      }
+      break;
+
+    case MP_ROUND_HALF_UP:
+    case MP_ROUND_HALF_DOWN:
+      if ((res = mp_int_mul_pow2(TEMP(2), 1, TEMP(2))) != MP_OK) {
+        goto CLEANUP;
+      }
+
+      cmp = mp_int_compare(TEMP(2), MP_DENOM_P(r));
+
+      if (round == MP_ROUND_HALF_UP) cmp += 1;
+
+      if (cmp > 0) {
+        if (prec == 0) {
+          res = mp_int_add_value(TEMP(0), 1, TEMP(0));
+        } else {
+          res = mp_int_add_value(TEMP(1), 1, TEMP(1));
+        }
+      }
+      break;
+
+    case MP_ROUND_DOWN:
+      break; /* No action required */
+
+    default:
+      return MP_BADARG; /* Invalid rounding specifier */
+  }
+  if (res != MP_OK) {
+    goto CLEANUP;
   }
 
   /* The sign of the output should be the sign of the numerator, but if all the
      displayed digits will be zero due to the precision, a negative shouldn't
      be shown. */
-  if (MP_SIGN(MP_NUMER_P(r)) == MP_NEG &&
-      (mp_int_compare_zero(TEMP(0)) != 0 ||
-       mp_int_compare_zero(TEMP(1)) != 0)) {
+  char *start = str;
+  int left = limit;
+  if (MP_NUMER_SIGN(r) == MP_NEG && (mp_int_compare_zero(TEMP(0)) != 0 ||
+                                     mp_int_compare_zero(TEMP(1)) != 0)) {
     *start++ = '-';
     left -= 1;
   }
 
-  if ((res = mp_int_to_string(TEMP(0), radix, start, left)) != MP_OK)
+  if ((res = mp_int_to_string(TEMP(0), radix, start, left)) != MP_OK) {
     goto CLEANUP;
-  
-  len = strlen(start);
+  }
+
+  int len = strlen(start);
   start += len;
   left -= len;
-  
-  if (prec == 0) 
-    goto CLEANUP;
-  
+
+  if (prec == 0) goto CLEANUP;
+
   *start++ = '.';
   left -= 1;
-  
-  if (left < prec + 1) {
+
+  if (left < zprec + 1) {
     res = MP_TRUNC;
     goto CLEANUP;
   }
@@ -779,25 +618,19 @@
 
   res = mp_int_to_string(TEMP(1), radix, start, left);
 
- CLEANUP:
-  while (--last >= 0)
-    mp_int_clear(TEMP(last));
-  
+CLEANUP:
+  while (--last >= 0) mp_int_clear(TEMP(last));
+
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_string_len(r, radix) */
-
-mp_result mp_rat_string_len(mp_rat r, mp_size radix)
-{
-  mp_result n_len, d_len = 0;
+mp_result mp_rat_string_len(mp_rat r, mp_size radix) {
+  mp_result d_len = 0;
+  mp_result n_len = mp_int_string_len(MP_NUMER_P(r), radix);
 
-  n_len = mp_int_string_len(MP_NUMER_P(r), radix);
-
-  if (mp_int_compare_zero(MP_NUMER_P(r)) != 0)
+  if (mp_int_compare_zero(MP_NUMER_P(r)) != 0) {
     d_len = mp_int_string_len(MP_DENOM_P(r), radix);
+  }
 
   /* Though simplistic, this formula is correct.  Space for the sign flag is
      included in n_len, and the space for the NUL that is counted in n_len
@@ -805,148 +638,111 @@
      counts for the final terminator here. */
 
   return n_len + d_len;
-
 }
 
-/* }}} */
-
-/* {{{ mp_rat_decimal_len(r, radix, prec) */
+mp_result mp_rat_decimal_len(mp_rat r, mp_size radix, mp_size prec) {
+  int f_len;
+  int z_len = mp_int_string_len(MP_NUMER_P(r), radix);
 
-mp_result mp_rat_decimal_len(mp_rat r, mp_size radix, mp_size prec)
-{
-  int  z_len, f_len;
-
-  z_len = mp_int_string_len(MP_NUMER_P(r), radix);
-  
-  if (prec == 0)
+  if (prec == 0) {
     f_len = 1; /* terminator only */
-  else
+  } else {
     f_len = 1 + prec + 1; /* decimal point, digits, terminator */
-  
+  }
+
   return z_len + f_len;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_read_string(r, radix, *str) */
-
-mp_result mp_rat_read_string(mp_rat r, mp_size radix, const char *str)
-{
+mp_result mp_rat_read_string(mp_rat r, mp_size radix, const char *str) {
   return mp_rat_read_cstring(r, radix, str, NULL);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_read_cstring(r, radix, *str, **end) */
-
-mp_result mp_rat_read_cstring(mp_rat r, mp_size radix, const char *str, 
-			      char **end)
-{
+mp_result mp_rat_read_cstring(mp_rat r, mp_size radix, const char *str,
+                              char **end) {
   mp_result res;
   char *endp;
 
   if ((res = mp_int_read_cstring(MP_NUMER_P(r), radix, str, &endp)) != MP_OK &&
-      (res != MP_TRUNC))
+      (res != MP_TRUNC)) {
     return res;
+  }
 
   /* Skip whitespace between numerator and (possible) separator */
-  while (isspace((unsigned char) *endp))
+  while (isspace((unsigned char)*endp)) {
     ++endp;
-  
+  }
+
   /* If there is no separator, we will stop reading at this point. */
   if (*endp != '/') {
     mp_int_set_value(MP_DENOM_P(r), 1);
-    if (end != NULL)
-      *end = endp;
+    if (end != NULL) *end = endp;
     return res;
   }
-  
+
   ++endp; /* skip separator */
-  if ((res = mp_int_read_cstring(MP_DENOM_P(r), radix, endp, end)) != MP_OK)
+  if ((res = mp_int_read_cstring(MP_DENOM_P(r), radix, endp, end)) != MP_OK) {
     return res;
-  
+  }
+
   /* Make sure the value is well-defined */
-  if (mp_int_compare_zero(MP_DENOM_P(r)) == 0)
+  if (mp_int_compare_zero(MP_DENOM_P(r)) == 0) {
     return MP_UNDEF;
+  }
 
   /* Reduce to lowest terms */
   return s_rat_reduce(r);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_read_ustring(r, radix, *str, **end) */
-
 /* Read a string and figure out what format it's in.  The radix may be supplied
    as zero to use "default" behaviour.
 
    This function will accept either a/b notation or decimal notation.
  */
-mp_result mp_rat_read_ustring(mp_rat r, mp_size radix, const char *str, 
-			      char **end)
-{
-  char      *endp;
-  mp_result  res;
-
-  if (radix == 0)
-    radix = 10;  /* default to decimal input */
-
-  if ((res = mp_rat_read_cstring(r, radix, str, &endp)) != MP_OK) {
-    if (res == MP_TRUNC) {
-      if (*endp == '.')
-	res = mp_rat_read_cdecimal(r, radix, str, &endp);
-    }
-    else
-      return res;
-  }
+mp_result mp_rat_read_ustring(mp_rat r, mp_size radix, const char *str,
+                              char **end) {
+  char *endp = "";
+  mp_result res;
 
-  if (end != NULL)
-    *end = endp;
+  if (radix == 0) radix = 10; /* default to decimal input */
 
+  res = mp_rat_read_cstring(r, radix, str, &endp);
+  if (res == MP_TRUNC && *endp == '.') {
+    res = mp_rat_read_cdecimal(r, radix, str, &endp);
+  }
+  if (end != NULL) *end = endp;
   return res;
 }
 
-/* }}} */
-
-/* {{{ mp_rat_read_decimal(r, radix, *str) */
-
-mp_result mp_rat_read_decimal(mp_rat r, mp_size radix, const char *str)
-{
+mp_result mp_rat_read_decimal(mp_rat r, mp_size radix, const char *str) {
   return mp_rat_read_cdecimal(r, radix, str, NULL);
 }
 
-/* }}} */
-
-/* {{{ mp_rat_read_cdecimal(r, radix, *str, **end) */
-
-mp_result mp_rat_read_cdecimal(mp_rat r, mp_size radix, const char *str, 
-			       char **end)
-{
+mp_result mp_rat_read_cdecimal(mp_rat r, mp_size radix, const char *str,
+                               char **end) {
   mp_result res;
-  mp_sign   osign;
+  mp_sign osign;
   char *endp;
 
-  while (isspace((unsigned char) *str))
-    ++str;
-  
+  while (isspace((unsigned char)*str)) ++str;
+
   switch (*str) {
-  case '-':
-    osign = MP_NEG;
-    break;
-  default:
-    osign = MP_ZPOS;
+    case '-':
+      osign = MP_NEG;
+      break;
+    default:
+      osign = MP_ZPOS;
   }
-  
+
   if ((res = mp_int_read_cstring(MP_NUMER_P(r), radix, str, &endp)) != MP_OK &&
-     (res != MP_TRUNC))
+      (res != MP_TRUNC)) {
     return res;
+  }
 
   /* This needs to be here. */
-  (void) mp_int_set_value(MP_DENOM_P(r), 1);
+  (void)mp_int_set_value(MP_DENOM_P(r), 1);
 
   if (*endp != '.') {
-    if (end != NULL)
-      *end = endp;
+    if (end != NULL) *end = endp;
     return res;
   }
 
@@ -961,55 +757,60 @@
   */
   ++endp;
   if (*endp == '\0') {
-    if (end != NULL)
-      *end = endp;
+    if (end != NULL) *end = endp;
     return MP_OK;
-  }
-  else if(isspace((unsigned char) *endp) || *endp == '-' || *endp == '+') {
+  } else if (isspace((unsigned char)*endp) || *endp == '-' || *endp == '+') {
     return MP_TRUNC;
-  }
-  else {
-    mpz_t  frac;
+  } else {
+    mpz_t frac;
     mp_result save_res;
-    char  *save = endp;
-    int    num_lz = 0;
+    char *save = endp;
+    int num_lz = 0;
 
     /* Make a temporary to hold the part after the decimal point. */
-    if ((res = mp_int_init(&frac)) != MP_OK)
+    if ((res = mp_int_init(&frac)) != MP_OK) {
       return res;
-    
+    }
+
     if ((res = mp_int_read_cstring(&frac, radix, endp, &endp)) != MP_OK &&
-       (res != MP_TRUNC))
+        (res != MP_TRUNC)) {
       goto CLEANUP;
+    }
 
     /* Save this response for later. */
     save_res = res;
 
-    if (mp_int_compare_zero(&frac) == 0)
-      goto FINISHED;
+    if (mp_int_compare_zero(&frac) == 0) goto FINISHED;
 
     /* Discard trailing zeroes (somewhat inefficiently) */
-    while (mp_int_divisible_value(&frac, radix))
-      if ((res = mp_int_div_value(&frac, radix, &frac, NULL)) != MP_OK)
-	goto CLEANUP;
-    
+    while (mp_int_divisible_value(&frac, radix)) {
+      if ((res = mp_int_div_value(&frac, radix, &frac, NULL)) != MP_OK) {
+        goto CLEANUP;
+      }
+    }
+
     /* Count leading zeros after the decimal point */
-    while (savenum_lz == '0')
+    while (savenum_lz == '0') {
       ++num_lz;
+    }
 
     /* Find the least power of the radix that is at least as large as the
        significant value of the fractional part, ignoring leading zeroes.  */
-    (void) mp_int_set_value(MP_DENOM_P(r), radix); 
-    
+    (void)mp_int_set_value(MP_DENOM_P(r), radix);
+
     while (mp_int_compare(MP_DENOM_P(r), &frac) < 0) {
-      if ((res = mp_int_mul_value(MP_DENOM_P(r), radix, MP_DENOM_P(r))) != MP_OK)
-	goto CLEANUP;
+      if ((res = mp_int_mul_value(MP_DENOM_P(r), radix, MP_DENOM_P(r))) !=
+          MP_OK) {
+        goto CLEANUP;
+      }
     }
-    
+
     /* Also shift by enough to account for leading zeroes */
     while (num_lz > 0) {
-      if ((res = mp_int_mul_value(MP_DENOM_P(r), radix, MP_DENOM_P(r))) != MP_OK)
-	goto CLEANUP;
+      if ((res = mp_int_mul_value(MP_DENOM_P(r), radix, MP_DENOM_P(r))) !=
+          MP_OK) {
+        goto CLEANUP;
+      }
 
       --num_lz;
     }
@@ -1017,26 +818,27 @@
     /* Having found this power, shift the numerator leftward that many, digits,
        and add the nonzero significant digits of the fractional part to get the
        result. */
-    if ((res = mp_int_mul(MP_NUMER_P(r), MP_DENOM_P(r), MP_NUMER_P(r))) != MP_OK)
+    if ((res = mp_int_mul(MP_NUMER_P(r), MP_DENOM_P(r), MP_NUMER_P(r))) !=
+        MP_OK) {
       goto CLEANUP;
-    
+    }
+
     { /* This addition needs to be unsigned. */
-      MP_SIGN(MP_NUMER_P(r)) = MP_ZPOS;
-      if ((res = mp_int_add(MP_NUMER_P(r), &frac, MP_NUMER_P(r))) != MP_OK)
-	goto CLEANUP;
+      MP_NUMER_SIGN(r) = MP_ZPOS;
+      if ((res = mp_int_add(MP_NUMER_P(r), &frac, MP_NUMER_P(r))) != MP_OK) {
+        goto CLEANUP;
+      }
 
-      MP_SIGN(MP_NUMER_P(r)) = osign;
+      MP_NUMER_SIGN(r) = osign;
     }
-    if ((res = s_rat_reduce(r)) != MP_OK)
-      goto CLEANUP;
+    if ((res = s_rat_reduce(r)) != MP_OK) goto CLEANUP;
 
     /* At this point, what we return depends on whether reading the fractional
        part was truncated or not.  That information is saved from when we
        called mp_int_read_string() above. */
   FINISHED:
     res = save_res;
-    if (end != NULL)
-      *end = endp;
+    if (end != NULL) *end = endp;
 
   CLEANUP:
     mp_int_clear(&frac);
@@ -1045,15 +847,10 @@
   }
 }
 
-/* }}} */
-
 /* Private functions for internal use.  Make unchecked assumptions about format
    and validity of inputs. */
 
-/* {{{ s_rat_reduce(r) */
-
-static mp_result s_rat_reduce(mp_rat r)
-{
+static mp_result s_rat_reduce(mp_rat r) {
   mpz_t gcd;
   mp_result res = MP_OK;
 
@@ -1064,78 +861,80 @@
 
   /* If the greatest common divisor of the numerator and denominator is greater
      than 1, divide it out. */
-  if ((res = mp_int_init(&gcd)) != MP_OK)
-    return res;
+  if ((res = mp_int_init(&gcd)) != MP_OK) return res;
 
-  if ((res = mp_int_gcd(MP_NUMER_P(r), MP_DENOM_P(r), &gcd)) != MP_OK)
+  if ((res = mp_int_gcd(MP_NUMER_P(r), MP_DENOM_P(r), &gcd)) != MP_OK) {
     goto CLEANUP;
+  }
 
   if (mp_int_compare_value(&gcd, 1) != 0) {
-    if ((res = mp_int_div(MP_NUMER_P(r), &gcd, MP_NUMER_P(r), NULL)) != MP_OK)
+    if ((res = mp_int_div(MP_NUMER_P(r), &gcd, MP_NUMER_P(r), NULL)) != MP_OK) {
       goto CLEANUP;
-    if ((res = mp_int_div(MP_DENOM_P(r), &gcd, MP_DENOM_P(r), NULL)) != MP_OK)
+    }
+    if ((res = mp_int_div(MP_DENOM_P(r), &gcd, MP_DENOM_P(r), NULL)) != MP_OK) {
       goto CLEANUP;
+    }
   }
 
   /* Fix up the signs of numerator and denominator */
-  if (MP_SIGN(MP_NUMER_P(r)) == MP_SIGN(MP_DENOM_P(r)))
-    MP_SIGN(MP_NUMER_P(r)) = MP_SIGN(MP_DENOM_P(r)) = MP_ZPOS;
-  else {
-    MP_SIGN(MP_NUMER_P(r)) = MP_NEG;
-    MP_SIGN(MP_DENOM_P(r)) = MP_ZPOS;
+  if (MP_NUMER_SIGN(r) == MP_DENOM_SIGN(r)) {
+    MP_NUMER_SIGN(r) = MP_DENOM_SIGN(r) = MP_ZPOS;
+  } else {
+    MP_NUMER_SIGN(r) = MP_NEG;
+    MP_DENOM_SIGN(r) = MP_ZPOS;
   }
 
- CLEANUP:
+CLEANUP:
   mp_int_clear(&gcd);
 
   return res;
 }
 
-/* }}} */
-
-/* {{{ s_rat_combine(a, b, c, comb_f) */
-
-static mp_result s_rat_combine(mp_rat a, mp_rat b, mp_rat c, 
-			       mp_result (*comb_f)(mp_int, mp_int, mp_int))
-{
+static mp_result s_rat_combine(mp_rat a, mp_rat b, mp_rat c,
+                               mp_result (*comb_f)(mp_int, mp_int, mp_int)) {
   mp_result res;
 
   /* Shortcut when denominators are already common */
   if (mp_int_compare(MP_DENOM_P(a), MP_DENOM_P(b)) == 0) {
-    if ((res = (comb_f)(MP_NUMER_P(a), MP_NUMER_P(b), MP_NUMER_P(c))) != MP_OK)
+    if ((res = (comb_f)(MP_NUMER_P(a), MP_NUMER_P(b), MP_NUMER_P(c))) !=
+        MP_OK) {
       return res;
-    if ((res = mp_int_copy(MP_DENOM_P(a), MP_DENOM_P(c))) != MP_OK)
+    }
+    if ((res = mp_int_copy(MP_DENOM_P(a), MP_DENOM_P(c))) != MP_OK) {
       return res;
-    
+    }
+
     return s_rat_reduce(c);
-  }
-  else {
-    mpz_t  temp2;
-    int    last = 0;
+  } else {
+    mpz_t temp2;
+    int last = 0;
 
     SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(a)), last);
     SETUP(mp_int_init_copy(TEMP(last), MP_NUMER_P(b)), last);
-    
-    if ((res = mp_int_mul(TEMP(0), MP_DENOM_P(b), TEMP(0))) != MP_OK)
+
+    if ((res = mp_int_mul(TEMP(0), MP_DENOM_P(b), TEMP(0))) != MP_OK) {
       goto CLEANUP;
-    if ((res = mp_int_mul(TEMP(1), MP_DENOM_P(a), TEMP(1))) != MP_OK)
+    }
+    if ((res = mp_int_mul(TEMP(1), MP_DENOM_P(a), TEMP(1))) != MP_OK) {
       goto CLEANUP;
-    if ((res = (comb_f)(TEMP(0), TEMP(1), MP_NUMER_P(c))) != MP_OK)
+    }
+    if ((res = (comb_f)(TEMP(0), TEMP(1), MP_NUMER_P(c))) != MP_OK) {
       goto CLEANUP;
+    }
 
     res = mp_int_mul(MP_DENOM_P(a), MP_DENOM_P(b), MP_DENOM_P(c));
 
   CLEANUP:
-    while (--last >= 0) 
+    while (--last >= 0) {
       mp_int_clear(TEMP(last));
+    }
 
-    if (res == MP_OK)
+    if (res == MP_OK) {
       return s_rat_reduce(c);
-    else
+    } else {
       return res;
+    }
   }
 }
 
-/* }}} */
-
 /* Here there be dragons */

_service:tar_scm:isl-0.14.tar.xz/imath/imrat.h -> _service:tar_scm:isl-0.24.tar.gz/imath/imrat.h Changed

@@ -1,7 +1,7 @@
 /*
   Name:     imrat.h
   Purpose:  Arbitrary precision rational arithmetic routines.
-  Author:   M. J. Fromberger <http://spinning-yarns.org/michael/>
+  Author:   M. J. Fromberger
 
   Copyright (C) 2002-2007 Michael J. Fromberger, All Rights Reserved.
 
@@ -27,19 +27,24 @@
 #ifndef IMRAT_H_
 #define IMRAT_H_
 
+#include <stdbool.h>
+
 #include "imath.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-typedef struct mpq {
+typedef struct {
   mpz_t   num;    /* Numerator         */
   mpz_t   den;    /* Denominator, <> 0 */
 } mpq_t, *mp_rat;
 
-#define MP_NUMER_P(Q)  (&((Q)->num)) /* Pointer to numerator   */
-#define MP_DENOM_P(Q)  (&((Q)->den)) /* Pointer to denominator */
+/* Return a pointer to the numerator. */
+static inline mp_int MP_NUMER_P(mp_rat Q) { return &(Q->num); }
+
+/* Return a pointer to the denominator. */
+static inline mp_int MP_DENOM_P(mp_rat Q) { return &(Q->den); }
 
 /* Rounding constants */
 typedef enum {
@@ -49,72 +54,213 @@
   MP_ROUND_HALF_DOWN
 } mp_round_mode;
 
+/** Initializes `r` with 1-digit precision and sets it to zero. This function
+    cannot fail unless `r` is NULL. */
 mp_result mp_rat_init(mp_rat r);
-mp_rat    mp_rat_alloc(void);
+
+/** Allocates a fresh zero-valued `mpq_t` on the heap, returning NULL in case
+    of error. The only possible error is out-of-memory. */
+mp_rat mp_rat_alloc(void);
+
+/** Reduces `r` in-place to lowest terms and canonical form.
+
+    Zero is represented as 0/1, one as 1/1, and signs are adjusted so that the
+    sign of the value is carried by the numerator. */
 mp_result mp_rat_reduce(mp_rat r);
+
+/** Initializes `r` with at least `n_prec` digits of storage for the numerator
+    and `d_prec` digits of storage for the denominator, and value zero.
+
+    If either precision is zero, the default precision is used, rounded up to
+    the nearest word size. */
 mp_result mp_rat_init_size(mp_rat r, mp_size n_prec, mp_size d_prec);
+
+/** Initializes `r` to be a copy of an already-initialized value in `old`. The
+    new copy does not share storage with the original. */
 mp_result mp_rat_init_copy(mp_rat r, mp_rat old);
+
+/** Sets the value of `r` to the ratio of signed `numer` to signed `denom`.  It
+    returns `MP_UNDEF` if `denom` is zero. */
 mp_result mp_rat_set_value(mp_rat r, mp_small numer, mp_small denom);
+
+/** Sets the value of `r` to the ratio of unsigned `numer` to unsigned
+    `denom`. It returns `MP_UNDEF` if `denom` is zero. */
 mp_result mp_rat_set_uvalue(mp_rat r, mp_usmall numer, mp_usmall denom);
-void      mp_rat_clear(mp_rat r);
-void      mp_rat_free(mp_rat r);
-mp_result mp_rat_numer(mp_rat r, mp_int z);             /* z = num(r)  */
-mp_int    mp_rat_numer_ref(mp_rat r);                   /* &num(r)     */
-mp_result mp_rat_denom(mp_rat r, mp_int z);             /* z = den(r)  */
-mp_int    mp_rat_denom_ref(mp_rat r);                   /* &den(r)     */
-mp_sign   mp_rat_sign(mp_rat r);
-
-mp_result mp_rat_copy(mp_rat a, mp_rat c);              /* c = a       */
-void      mp_rat_zero(mp_rat r);                        /* r = 0       */
-mp_result mp_rat_abs(mp_rat a, mp_rat c);               /* c = |a|     */
-mp_result mp_rat_neg(mp_rat a, mp_rat c);               /* c = -a      */
-mp_result mp_rat_recip(mp_rat a, mp_rat c);             /* c = 1 / a   */
-mp_result mp_rat_add(mp_rat a, mp_rat b, mp_rat c);     /* c = a + b   */
-mp_result mp_rat_sub(mp_rat a, mp_rat b, mp_rat c);     /* c = a - b   */
-mp_result mp_rat_mul(mp_rat a, mp_rat b, mp_rat c);     /* c = a * b   */
-mp_result mp_rat_div(mp_rat a, mp_rat b, mp_rat c);     /* c = a / b   */
-
-mp_result mp_rat_add_int(mp_rat a, mp_int b, mp_rat c); /* c = a + b   */
-mp_result mp_rat_sub_int(mp_rat a, mp_int b, mp_rat c); /* c = a - b   */
-mp_result mp_rat_mul_int(mp_rat a, mp_int b, mp_rat c); /* c = a * b   */
-mp_result mp_rat_div_int(mp_rat a, mp_int b, mp_rat c); /* c = a / b   */
-mp_result mp_rat_expt(mp_rat a, mp_small b, mp_rat c);  /* c = a ^ b   */
-
-int       mp_rat_compare(mp_rat a, mp_rat b);           /* a <=> b     */
-int       mp_rat_compare_unsigned(mp_rat a, mp_rat b);  /* |a| <=> |b| */
-int       mp_rat_compare_zero(mp_rat r);                /* r <=> 0     */
-int       mp_rat_compare_value(mp_rat r, mp_small n, mp_small d); /* r <=> n/d */
-int       mp_rat_is_integer(mp_rat r);
-
-/* Convert to integers, if representable (returns MP_RANGE if not). */
+
+/** Releases the storage used by `r`. */
+void mp_rat_clear(mp_rat r);
+
+/** Releases the storage used by `r` and also `r` itself.
+    This should only be used for `r` allocated by `mp_rat_alloc()`. */
+void mp_rat_free(mp_rat r);
+
+/** Sets `z` to a copy of the numerator of `r`. */
+mp_result mp_rat_numer(mp_rat r, mp_int z);
+
+/** Returns a pointer to the numerator of `r`. */
+mp_int mp_rat_numer_ref(mp_rat r);
+
+/** Sets `z` to a copy of the denominator of `r`. */
+mp_result mp_rat_denom(mp_rat r, mp_int z);
+
+/** Returns a pointer to the denominator of `r`. */
+mp_int mp_rat_denom_ref(mp_rat r);
+
+/** Reports the sign of `r`. */
+mp_sign mp_rat_sign(mp_rat r);
+
+/** Sets `c` to a copy of the value of `a`. No new memory is allocated unless a
+    term of `a` has more significant digits than the corresponding term of `c`
+    has allocated. */
+mp_result mp_rat_copy(mp_rat a, mp_rat c);
+
+/** Sets `r` to zero. The allocated storage of `r` is not changed. */
+void mp_rat_zero(mp_rat r);
+
+/** Sets `c` to the absolute value of `a`. */
+mp_result mp_rat_abs(mp_rat a, mp_rat c);
+
+/** Sets `c` to the absolute value of `a`. */
+mp_result mp_rat_neg(mp_rat a, mp_rat c);
+
+/** Sets `c` to the reciprocal of `a` if the reciprocal is defined.
+    It returns `MP_UNDEF` if `a` is zero. */
+mp_result mp_rat_recip(mp_rat a, mp_rat c);
+
+/** Sets `c` to the sum of `a` and `b`. */
+mp_result mp_rat_add(mp_rat a, mp_rat b, mp_rat c);
+
+/** Sets `c` to the difference of `a` less `b`. */
+mp_result mp_rat_sub(mp_rat a, mp_rat b, mp_rat c);
+
+/** Sets `c` to the product of `a` and `b`. */
+mp_result mp_rat_mul(mp_rat a, mp_rat b, mp_rat c);
+
+/** Sets `c` to the ratio `a / b` if that ratio is defined.
+    It returns `MP_UNDEF` if `b` is zero. */
+mp_result mp_rat_div(mp_rat a, mp_rat b, mp_rat c);
+
+/** Sets `c` to the sum of `a` and integer `b`. */
+mp_result mp_rat_add_int(mp_rat a, mp_int b, mp_rat c);
+
+/** Sets `c` to the difference of `a` less integer `b`. */
+mp_result mp_rat_sub_int(mp_rat a, mp_int b, mp_rat c);
+
+/** Sets `c` to the product of `a` and integer `b`. */
+mp_result mp_rat_mul_int(mp_rat a, mp_int b, mp_rat c);
+
+/** Sets `c` to the ratio `a / b` if that ratio is defined.
+    It returns `MP_UNDEF` if `b` is zero. */
+mp_result mp_rat_div_int(mp_rat a, mp_int b, mp_rat c);
+
+/** Sets `c` to the value of `a` raised to the `b` power.
+    It returns `MP_RANGE` if `b < 0`. */
+mp_result mp_rat_expt(mp_rat a, mp_small b, mp_rat c);
+
+/** Returns the comparator of `a` and `b`. */
+int mp_rat_compare(mp_rat a, mp_rat b);
+
+/** Returns the comparator of the magnitudes of `a` and `b`, disregarding their
+    signs. Neither `a` nor `b` is modified by the comparison. */
+int mp_rat_compare_unsigned(mp_rat a, mp_rat b);
+
+/** Returns the comparator of `r` and zero. */
+int mp_rat_compare_zero(mp_rat r);
+
+/** Returns the comparator of `r` and the signed ratio `n / d`.
+    It returns `MP_UNDEF` if `d` is zero. */
+int mp_rat_compare_value(mp_rat r, mp_small n, mp_small d);
+
+/** Reports whether `r` is an integer, having canonical denominator 1. */
+bool mp_rat_is_integer(mp_rat r);
+
+/** Reports whether the numerator and denominator of `r` can be represented as
+    small signed integers, and if so stores the corresponding values to `num`
+    and `den`. It returns `MP_RANGE` if either cannot be so represented. */
 mp_result mp_rat_to_ints(mp_rat r, mp_small *num, mp_small *den);
 
-/* Convert to nul-terminated string with the specified radix, writing
-   at most limit characters including the nul terminator. */
+/** Converts `r` to a zero-terminated string of the format `"n/d"` with `n` and
+    `d` in the specified radix and writing no more than `limit` bytes to the
+    given output buffer `str`. The output of the numerator includes a sign flag
+    if `r` is negative.  Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
 mp_result mp_rat_to_string(mp_rat r, mp_size radix, char *str, int limit);
 
-/* Convert to decimal format in the specified radix and precision,
-   writing at most limit characters including a nul terminator. */
+/** Converts the value of `r` to a string in decimal-point notation with the
+    specified radix, writing no more than `limit` bytes of data to the given
+    output buffer.  It generates `prec` digits of precision, and requires
+    `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`.
+
+    Ratios usually must be rounded when they are being converted for output as
+    a decimal value.  There are four rounding modes currently supported:
+
+      MP_ROUND_DOWN
+        Truncates the value toward zero.
+        Example:  12.009 to 2dp becomes 12.00
+
+      MP_ROUND_UP
+        Rounds the value away from zero:
+        Example:  12.001 to 2dp becomes 12.01, but
+                  12.000 to 2dp remains 12.00
+
+      MP_ROUND_HALF_DOWN
+         Rounds the value to nearest digit, half goes toward zero.
+         Example:  12.005 to 2dp becomes 12.00, but
+                   12.006 to 2dp becomes 12.01
+
+      MP_ROUND_HALF_UP
+         Rounds the value to nearest digit, half rounds upward.
+         Example:  12.005 to 2dp becomes 12.01, but
+                   12.004 to 2dp becomes 12.00
+*/
 mp_result mp_rat_to_decimal(mp_rat r, mp_size radix, mp_size prec,
                             mp_round_mode round, char *str, int limit);
 
-/* Return the number of characters required to represent r in the given
-   radix.  May over-estimate. */
+/** Reports the minimum number of characters required to represent `r` as a
+    zero-terminated string in the given `radix`.
+    Requires `MP_MIN_RADIX <= radix <= MP_MAX_RADIX`. */
 mp_result mp_rat_string_len(mp_rat r, mp_size radix);
 
-/* Return the number of characters required to represent r in decimal
-   format with the given radix and precision.  May over-estimate. */
+/** Reports the length in bytes of the buffer needed to convert `r` using the
+    `mp_rat_to_decimal()` function with the specified `radix` and `prec`. The
+    buffer size estimate may slightly exceed the actual required capacity. */
 mp_result mp_rat_decimal_len(mp_rat r, mp_size radix, mp_size prec);
 
-/* Read zero-terminated string into r */
+/** Sets `r` to the value represented by a zero-terminated string `str` in the
+    format `"n/d"` including a sign flag. It returns `MP_UNDEF` if the encoded
+    denominator has value zero. */
 mp_result mp_rat_read_string(mp_rat r, mp_size radix, const char *str);
+
+/** Sets `r` to the value represented by a zero-terminated string `str` in the
+    format `"n/d"` including a sign flag. It returns `MP_UNDEF` if the encoded
+    denominator has value zero. If `end` is not NULL then `*end` is set to
+    point to the first unconsumed character in the string, after parsing.
+*/
 mp_result mp_rat_read_cstring(mp_rat r, mp_size radix, const char *str,
 			      char **end);
+
+/** Sets `r` to the value represented by a zero-terminated string `str` having
+    one of the following formats, each with an optional leading sign flag:
+
+       n         : integer format, e.g. "123"
+       n/d       : ratio format, e.g., "-12/5"
+       z.ffff    : decimal format, e.g., "1.627"
+
+    It returns `MP_UNDEF` if the effective denominator is zero. If `end` is not
+    NULL then `*end` is set to point to the first unconsumed character in the
+    string, after parsing.
+*/
 mp_result mp_rat_read_ustring(mp_rat r, mp_size radix, const char *str,
 			      char **end);
 
-/* Read zero-terminated string in decimal format into r */
+/** Sets `r` to the value represented by a zero-terminated string `str` in the
+    format `"z.ffff"` including a sign flag. It returns `MP_UNDEF` if the
+    effective denominator. */
 mp_result mp_rat_read_decimal(mp_rat r, mp_size radix, const char *str);
+
+/** Sets `r` to the value represented by a zero-terminated string `str` in the
+    format `"z.ffff"` including a sign flag. It returns `MP_UNDEF` if the
+    effective denominator. If `end` is not NULL then `*end` is set to point to
+    the first unconsumed character in the string, after parsing. */
 mp_result mp_rat_read_cdecimal(mp_rat r, mp_size radix, const char *str,
 			       char **end);

_service:tar_scm:isl-0.14.tar.xz/imath_wrap/wrap.h -> _service:tar_scm:isl-0.24.tar.gz/imath_wrap/wrap.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/aff.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/aff.h Changed

@@ -1,33 +1,48 @@
 #ifndef ISL_AFF_H
 #define ISL_AFF_H
 
+#include <isl/stdint.h>
 #include <isl/local_space.h>
 #include <isl/printer.h>
+#include <isl/id_type.h>
 #include <isl/set_type.h>
 #include <isl/aff_type.h>
 #include <isl/list.h>
 #include <isl/multi.h>
 #include <isl/union_set_type.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
+#include <isl/point.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
+__isl_overload
+__isl_give isl_aff *isl_aff_zero_on_domain_space(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_aff *isl_space_zero_aff_on_domain(__isl_take isl_space *space);
 __isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls);
+__isl_give isl_aff *isl_aff_val_on_domain_space(__isl_take isl_space *space,
+	__isl_take isl_val *val);
 __isl_give isl_aff *isl_aff_val_on_domain(__isl_take isl_local_space *ls,
 	__isl_take isl_val *val);
 __isl_give isl_aff *isl_aff_var_on_domain(__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
+__isl_give isl_aff *isl_aff_nan_on_domain_space(__isl_take isl_space *space);
 __isl_give isl_aff *isl_aff_nan_on_domain(__isl_take isl_local_space *ls);
+__isl_give isl_aff *isl_aff_param_on_domain_space_id(
+	__isl_take isl_space *space, __isl_take isl_id *id);
 
 __isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff);
 __isl_null isl_aff *isl_aff_free(__isl_take isl_aff *aff);
 
 isl_ctx *isl_aff_get_ctx(__isl_keep isl_aff *aff);
+uint32_t isl_aff_get_hash(__isl_keep isl_aff *aff);
+
+isl_bool isl_aff_involves_locals(__isl_keep isl_aff *aff);
 
-int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type);
-int isl_aff_involves_dims(__isl_keep isl_aff *aff,
+isl_size isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type);
+isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
 __isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff);
@@ -38,9 +53,12 @@
 
 const char *isl_aff_get_dim_name(__isl_keep isl_aff *aff,
 	enum isl_dim_type type, unsigned pos);
+__isl_export
 __isl_give isl_val *isl_aff_get_constant_val(__isl_keep isl_aff *aff);
 __isl_give isl_val *isl_aff_get_coefficient_val(__isl_keep isl_aff *aff,
 	enum isl_dim_type type, int pos);
+int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff,
+	enum isl_dim_type type, int pos);
 __isl_give isl_val *isl_aff_get_denominator_val(__isl_keep isl_aff *aff);
 __isl_give isl_aff *isl_aff_set_constant_si(__isl_take isl_aff *aff, int v);
 __isl_give isl_aff *isl_aff_set_constant_val(__isl_take isl_aff *aff,
@@ -50,6 +68,7 @@
 __isl_give isl_aff *isl_aff_set_coefficient_val(__isl_take isl_aff *aff,
 	enum isl_dim_type type, int pos, __isl_take isl_val *v);
 __isl_give isl_aff *isl_aff_add_constant_si(__isl_take isl_aff *aff, int v);
+__isl_overload
 __isl_give isl_aff *isl_aff_add_constant_val(__isl_take isl_aff *aff,
 	__isl_take isl_val *v);
 __isl_give isl_aff *isl_aff_add_constant_num_si(__isl_take isl_aff *aff, int v);
@@ -58,7 +77,8 @@
 __isl_give isl_aff *isl_aff_add_coefficient_val(__isl_take isl_aff *aff,
 	enum isl_dim_type type, int pos, __isl_take isl_val *v);
 
-int isl_aff_is_cst(__isl_keep isl_aff *aff);
+__isl_export
+isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff);
 
 __isl_give isl_aff *isl_aff_set_tuple_id(__isl_take isl_aff *aff,
 	enum isl_dim_type type, __isl_take isl_id *id);
@@ -67,30 +87,46 @@
 __isl_give isl_aff *isl_aff_set_dim_id(__isl_take isl_aff *aff,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
 
-int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1, __isl_keep isl_aff *aff2);
-int isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
-int isl_aff_is_nan(__isl_keep isl_aff *aff);
+int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff, enum isl_dim_type type,
+	const char *name);
+
+isl_bool isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
+	__isl_keep isl_aff *aff2);
+isl_bool isl_aff_plain_is_zero(__isl_keep isl_aff *aff);
+isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff);
 
 __isl_give isl_aff *isl_aff_get_div(__isl_keep isl_aff *aff, int pos);
 
+__isl_give isl_aff *isl_aff_from_range(__isl_take isl_aff *aff);
+
+__isl_export
 __isl_give isl_aff *isl_aff_neg(__isl_take isl_aff *aff);
+__isl_export
 __isl_give isl_aff *isl_aff_ceil(__isl_take isl_aff *aff);
+__isl_export
 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff);
+__isl_overload
 __isl_give isl_aff *isl_aff_mod_val(__isl_take isl_aff *aff,
 	__isl_take isl_val *mod);
 
+__isl_export
 __isl_give isl_aff *isl_aff_mul(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_export
 __isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_export
 __isl_give isl_aff *isl_aff_add(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_export
 __isl_give isl_aff *isl_aff_sub(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
 
+__isl_overload
 __isl_give isl_aff *isl_aff_scale_val(__isl_take isl_aff *aff,
 	__isl_take isl_val *v);
 __isl_give isl_aff *isl_aff_scale_down_ui(__isl_take isl_aff *aff, unsigned f);
+__isl_overload
 __isl_give isl_aff *isl_aff_scale_down_val(__isl_take isl_aff *aff,
 	__isl_take isl_val *v);
 
@@ -104,129 +140,223 @@
 __isl_give isl_aff *isl_aff_drop_dims(__isl_take isl_aff *aff,
 	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_aff *isl_aff_project_domain_on_params(__isl_take isl_aff *aff);
+__isl_export
+__isl_give isl_aff *isl_aff_unbind_params_insert_domain(
+	__isl_take isl_aff *aff, __isl_take isl_multi_id *domain);
 
 __isl_give isl_aff *isl_aff_align_params(__isl_take isl_aff *aff,
 	__isl_take isl_space *model);
 
+__isl_export
 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
 	__isl_take isl_set *context);
 __isl_give isl_aff *isl_aff_gist_params(__isl_take isl_aff *aff,
 	__isl_take isl_set *context);
 
+__isl_export
+__isl_give isl_val *isl_aff_eval(__isl_take isl_aff *aff,
+	__isl_take isl_point *pnt);
+
 __isl_give isl_aff *isl_aff_pullback_aff(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_overload
 __isl_give isl_aff *isl_aff_pullback_multi_aff(__isl_take isl_aff *aff,
 	__isl_take isl_multi_aff *ma);
 
 __isl_give isl_basic_set *isl_aff_zero_basic_set(__isl_take isl_aff *aff);
 __isl_give isl_basic_set *isl_aff_neg_basic_set(__isl_take isl_aff *aff);
 
+__isl_give isl_basic_set *isl_aff_eq_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_eq_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_ne_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
 __isl_give isl_basic_set *isl_aff_le_basic_set(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_le_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_give isl_basic_set *isl_aff_lt_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_lt_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
 __isl_give isl_basic_set *isl_aff_ge_basic_set(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_ge_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_give isl_basic_set *isl_aff_gt_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
+__isl_export
+__isl_give isl_set *isl_aff_gt_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2);
 
+__isl_overload
+__isl_give isl_basic_set *isl_aff_bind_id(__isl_take isl_aff *aff,
+	__isl_take isl_id *id);
+
+__isl_constructor
 __isl_give isl_aff *isl_aff_read_from_str(isl_ctx *ctx, const char *str);
+__isl_give char *isl_aff_to_str(__isl_keep isl_aff *aff);
 __isl_give isl_printer *isl_printer_print_aff(__isl_take isl_printer *p,
 	__isl_keep isl_aff *aff);
 void isl_aff_dump(__isl_keep isl_aff *aff);
 
 isl_ctx *isl_pw_aff_get_ctx(__isl_keep isl_pw_aff *pwaff);
+uint32_t isl_pw_aff_get_hash(__isl_keep isl_pw_aff *pa);
 __isl_give isl_space *isl_pw_aff_get_domain_space(__isl_keep isl_pw_aff *pwaff);
 __isl_give isl_space *isl_pw_aff_get_space(__isl_keep isl_pw_aff *pwaff);
 
+__isl_constructor
 __isl_give isl_pw_aff *isl_pw_aff_from_aff(__isl_take isl_aff *aff);
-__isl_give isl_pw_aff *isl_pw_aff_empty(__isl_take isl_space *dim);
+__isl_give isl_pw_aff *isl_pw_aff_empty(__isl_take isl_space *space);
 __isl_give isl_pw_aff *isl_pw_aff_alloc(__isl_take isl_set *set,
 	__isl_take isl_aff *aff);
 __isl_give isl_pw_aff *isl_pw_aff_zero_on_domain(
 	__isl_take isl_local_space *ls);
 __isl_give isl_pw_aff *isl_pw_aff_var_on_domain(__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
+__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
+	__isl_take isl_space *space);
 __isl_give isl_pw_aff *isl_pw_aff_nan_on_domain(__isl_take isl_local_space *ls);
+__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(__isl_take isl_set *domain,
+	__isl_take isl_val *v);
+__isl_overload
+__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
+	__isl_take isl_set *domain, __isl_take isl_id *id);
 
+__isl_export
 __isl_give isl_pw_aff *isl_set_indicator_function(__isl_take isl_set *set);
 
 const char *isl_pw_aff_get_dim_name(__isl_keep isl_pw_aff *pa,
 	enum isl_dim_type type, unsigned pos);
-int isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
+isl_bool isl_pw_aff_has_dim_id(__isl_keep isl_pw_aff *pa,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_id *isl_pw_aff_get_dim_id(__isl_keep isl_pw_aff *pa,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_pw_aff *isl_pw_aff_set_dim_id(__isl_take isl_pw_aff *pma,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
 
-int isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
-int isl_pw_aff_involves_nan(__isl_keep isl_pw_aff *pa);
+int isl_pw_aff_find_dim_by_name(__isl_keep isl_pw_aff *pa,
+	enum isl_dim_type type, const char *name);
+
+isl_bool isl_pw_aff_is_empty(__isl_keep isl_pw_aff *pwaff);
+isl_bool isl_pw_aff_involves_nan(__isl_keep isl_pw_aff *pa);
 int isl_pw_aff_plain_cmp(__isl_keep isl_pw_aff *pa1,
 	__isl_keep isl_pw_aff *pa2);
-int isl_pw_aff_plain_is_equal(__isl_keep isl_pw_aff *pwaff1,
+isl_bool isl_pw_aff_plain_is_equal(__isl_keep isl_pw_aff *pwaff1,
 	__isl_keep isl_pw_aff *pwaff2);
-int isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1, __isl_keep isl_pw_aff *pa2);
+isl_bool isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1,
+	__isl_keep isl_pw_aff *pa2);
 
 __isl_give isl_pw_aff *isl_pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
 __isl_give isl_pw_aff *isl_pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_union_add(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
 
 __isl_give isl_pw_aff *isl_pw_aff_copy(__isl_keep isl_pw_aff *pwaff);
 __isl_null isl_pw_aff *isl_pw_aff_free(__isl_take isl_pw_aff *pwaff);
 
-unsigned isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff, enum isl_dim_type type);
-int isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
+isl_size isl_pw_aff_dim(__isl_keep isl_pw_aff *pwaff, enum isl_dim_type type);
+isl_bool isl_pw_aff_involves_param_id(__isl_keep isl_pw_aff *pa,
+	__isl_keep isl_id *id);
+isl_bool isl_pw_aff_involves_dims(__isl_keep isl_pw_aff *pwaff,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
-int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
+isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff);
+
+__isl_export
+__isl_give isl_pw_aff *isl_pw_aff_insert_domain(__isl_take isl_pw_aff *pa,
+	__isl_take isl_space *domain);
+__isl_give isl_pw_aff *isl_pw_aff_project_domain_on_params(
+	__isl_take isl_pw_aff *pa);
 
 __isl_give isl_pw_aff *isl_pw_aff_align_params(__isl_take isl_pw_aff *pwaff,
 	__isl_take isl_space *model);
+__isl_give isl_pw_aff *isl_pw_aff_drop_unused_params(
+	__isl_take isl_pw_aff *pa);
 
-int isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa, enum isl_dim_type type);
+isl_bool isl_pw_aff_has_tuple_id(__isl_keep isl_pw_aff *pa,
+	enum isl_dim_type type);
 __isl_give isl_id *isl_pw_aff_get_tuple_id(__isl_keep isl_pw_aff *pa,
 	enum isl_dim_type type);
 __isl_give isl_pw_aff *isl_pw_aff_set_tuple_id(__isl_take isl_pw_aff *pwaff,
 	enum isl_dim_type type, __isl_take isl_id *id);
 __isl_give isl_pw_aff *isl_pw_aff_reset_tuple_id(__isl_take isl_pw_aff *pa,
 	enum isl_dim_type type);
+__isl_give isl_pw_aff *isl_pw_aff_reset_user(__isl_take isl_pw_aff *pa);
 
 __isl_give isl_set *isl_pw_aff_params(__isl_take isl_pw_aff *pwa);
+__isl_export
 __isl_give isl_set *isl_pw_aff_domain(__isl_take isl_pw_aff *pwaff);
 __isl_give isl_pw_aff *isl_pw_aff_from_range(__isl_take isl_pw_aff *pwa);
 
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_min(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_max(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_div(__isl_take isl_pw_aff *pa1,
 	__isl_take isl_pw_aff *pa2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_add(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_sub(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_neg(__isl_take isl_pw_aff *pwaff);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_ceil(__isl_take isl_pw_aff *pwaff);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_floor(__isl_take isl_pw_aff *pwaff);
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_mod_val(__isl_take isl_pw_aff *pa,
 	__isl_take isl_val *mod);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_tdiv_q(__isl_take isl_pw_aff *pa1,
 	__isl_take isl_pw_aff *pa2);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_tdiv_r(__isl_take isl_pw_aff *pa1,
 	__isl_take isl_pw_aff *pa2);
 
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_intersect_params(__isl_take isl_pw_aff *pa,
 	__isl_take isl_set *set);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_intersect_domain(__isl_take isl_pw_aff *pa,
 	__isl_take isl_set *set);
+__isl_give isl_pw_aff *isl_pw_aff_intersect_domain_wrapped_domain(
+	__isl_take isl_pw_aff *pa, __isl_take isl_set *set);
+__isl_give isl_pw_aff *isl_pw_aff_intersect_domain_wrapped_range(
+	__isl_take isl_pw_aff *pa, __isl_take isl_set *set);
+__isl_export
+__isl_give isl_pw_aff *isl_pw_aff_subtract_domain(__isl_take isl_pw_aff *pa,
+	__isl_take isl_set *set);
 
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_cond(__isl_take isl_pw_aff *cond,
 	__isl_take isl_pw_aff *pwaff_true, __isl_take isl_pw_aff *pwaff_false);
 
+__isl_overload
+__isl_give isl_pw_aff *isl_pw_aff_add_constant_val(__isl_take isl_pw_aff *pa,
+	__isl_take isl_val *v);
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_scale_val(__isl_take isl_pw_aff *pa,
 	__isl_take isl_val *v);
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_scale_down_val(__isl_take isl_pw_aff *pa,
 	__isl_take isl_val *f);
 
@@ -240,45 +370,93 @@
 __isl_give isl_pw_aff *isl_pw_aff_drop_dims(__isl_take isl_pw_aff *pwaff,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
-__isl_give isl_pw_aff *isl_pw_aff_coalesce(__isl_take isl_pw_aff *pwqp);
+__isl_export
+__isl_give isl_pw_aff *isl_pw_aff_coalesce(__isl_take isl_pw_aff *pa);
+__isl_export
 __isl_give isl_pw_aff *isl_pw_aff_gist(__isl_take isl_pw_aff *pwaff,
 	__isl_take isl_set *context);
 __isl_give isl_pw_aff *isl_pw_aff_gist_params(__isl_take isl_pw_aff *pwaff,
 	__isl_take isl_set *context);
 
+__isl_export
+__isl_give isl_val *isl_pw_aff_eval(__isl_take isl_pw_aff *pa,
+	__isl_take isl_point *pnt);
+
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_aff(
 	__isl_take isl_pw_aff *pa, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_pullback_pw_multi_aff(
 	__isl_take isl_pw_aff *pa, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_pw_aff *isl_pw_aff_pullback_multi_pw_aff(
 	__isl_take isl_pw_aff *pa, __isl_take isl_multi_pw_aff *mpa);
 
-int isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
-int isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_aff *aff,
+isl_size isl_pw_aff_n_piece(__isl_keep isl_pw_aff *pwaff);
+isl_stat isl_pw_aff_foreach_piece(__isl_keep isl_pw_aff *pwaff,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take isl_aff *aff,
 		    void *user), void *user);
-
+isl_bool isl_pw_aff_every_piece(__isl_keep isl_pw_aff *pa,
+	isl_bool (*test)(__isl_keep isl_set *set, __isl_keep isl_aff *aff,
+		void *user), void *user);
+__isl_export
+isl_bool isl_pw_aff_isa_aff(__isl_keep isl_pw_aff *pa);
+__isl_export
+__isl_give isl_aff *isl_pw_aff_as_aff(__isl_take isl_pw_aff *pa);
+
+__isl_export
+__isl_give isl_map *isl_pw_aff_as_map(__isl_take isl_pw_aff *pa);
 __isl_give isl_set *isl_set_from_pw_aff(__isl_take isl_pw_aff *pwaff);
 __isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff);
 
+__isl_give isl_set *isl_pw_aff_pos_set(__isl_take isl_pw_aff *pa);
 __isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff);
 __isl_give isl_set *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff);
 __isl_give isl_set *isl_pw_aff_non_zero_set(__isl_take isl_pw_aff *pwaff);
 
+__isl_export
 __isl_give isl_set *isl_pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_set *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_set *isl_pw_aff_le_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_set *isl_pw_aff_lt_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_set *isl_pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
+__isl_export
 __isl_give isl_set *isl_pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2);
 
+__isl_give isl_map *isl_pw_aff_eq_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2);
+__isl_give isl_map *isl_pw_aff_le_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2);
+__isl_give isl_map *isl_pw_aff_lt_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2);
+__isl_give isl_map *isl_pw_aff_ge_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2);
+__isl_give isl_map *isl_pw_aff_gt_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2);
+
+__isl_export
+__isl_give isl_pw_aff *isl_pw_aff_bind_domain(__isl_take isl_pw_aff *pa,
+	__isl_take isl_multi_id *tuple);
+__isl_export
+__isl_give isl_pw_aff *isl_pw_aff_bind_domain_wrapped_domain(
+	__isl_take isl_pw_aff *pa, __isl_take isl_multi_id *tuple);
+__isl_overload
+__isl_give isl_set *isl_pw_aff_bind_id(__isl_take isl_pw_aff *pa,
+	__isl_take isl_id *id);
+
+__isl_constructor
 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(isl_ctx *ctx, const char *str);
+__isl_give char *isl_pw_aff_to_str(__isl_keep isl_pw_aff *pa);
 __isl_give isl_printer *isl_printer_print_pw_aff(__isl_take isl_printer *p,
 	__isl_keep isl_pw_aff *pwaff);
 void isl_pw_aff_dump(__isl_keep isl_pw_aff *pwaff);
@@ -300,58 +478,140 @@
 	__isl_take isl_pw_aff_list *list2);
 
 ISL_DECLARE_MULTI(aff)
-
+ISL_DECLARE_MULTI_IDENTITY(aff)
+ISL_DECLARE_MULTI_CMP(aff)
+ISL_DECLARE_MULTI_ARITH(aff)
+ISL_DECLARE_MULTI_ADD_CONSTANT(aff)
+ISL_DECLARE_MULTI_ZERO(aff)
+ISL_DECLARE_MULTI_NAN(aff)
+ISL_DECLARE_MULTI_DIMS(aff)
+ISL_DECLARE_MULTI_INSERT_DOMAIN(aff)
+ISL_DECLARE_MULTI_LOCALS(aff)
+ISL_DECLARE_MULTI_DIM_ID(aff)
+ISL_DECLARE_MULTI_TUPLE_ID(aff)
+ISL_DECLARE_MULTI_WITH_DOMAIN(aff)
+ISL_DECLARE_MULTI_BIND_DOMAIN(aff)
+ISL_DECLARE_MULTI_UNBIND_PARAMS(aff)
+
+__isl_constructor
 __isl_give isl_multi_aff *isl_multi_aff_from_aff(__isl_take isl_aff *aff);
-__isl_give isl_multi_aff *isl_multi_aff_identity(__isl_take isl_space *space);
+__isl_export
 __isl_give isl_multi_aff *isl_multi_aff_domain_map(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
+	__isl_take isl_space *space);
+__isl_export
 __isl_give isl_multi_aff *isl_multi_aff_range_map(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
+	__isl_take isl_space *space);
 __isl_give isl_multi_aff *isl_multi_aff_project_out_map(
 	__isl_take isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n);
 
-__isl_give isl_multi_aff *isl_multi_aff_floor(__isl_take isl_multi_aff *ma);
+__isl_overload
+__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_domain_space(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv);
+__isl_overload
+__isl_give isl_multi_aff *isl_space_multi_aff_on_domain_multi_val(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv);
+__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_space(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv);
 
-__isl_give isl_multi_aff *isl_multi_aff_add(__isl_take isl_multi_aff *maff1,
-	__isl_take isl_multi_aff *maff2);
-__isl_give isl_multi_aff *isl_multi_aff_sub(__isl_take isl_multi_aff *ma1,
-	__isl_take isl_multi_aff *ma2);
+__isl_export
+__isl_give isl_multi_val *isl_multi_aff_get_constant_multi_val(
+	__isl_keep isl_multi_aff *ma);
 
-__isl_give isl_multi_aff *isl_multi_aff_product(
-	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2);
+__isl_export
+__isl_give isl_multi_aff *isl_multi_aff_floor(__isl_take isl_multi_aff *ma);
 
 __isl_give isl_multi_aff *isl_multi_aff_gist_params(
 	__isl_take isl_multi_aff *maff, __isl_take isl_set *context);
+__isl_export
 __isl_give isl_multi_aff *isl_multi_aff_gist(__isl_take isl_multi_aff *maff,
 	__isl_take isl_set *context);
 
 __isl_give isl_multi_aff *isl_multi_aff_lift(__isl_take isl_multi_aff *maff,
 	__isl_give isl_local_space **ls);
 
+__isl_overload
 __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
 	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2);
 
+__isl_give isl_multi_aff *isl_multi_aff_move_dims(__isl_take isl_multi_aff *ma,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
+
+__isl_give isl_set *isl_multi_aff_lex_lt_set(__isl_take isl_multi_aff *ma1,
+	__isl_take isl_multi_aff *ma2);
 __isl_give isl_set *isl_multi_aff_lex_le_set(__isl_take isl_multi_aff *ma1,
 	__isl_take isl_multi_aff *ma2);
+__isl_give isl_set *isl_multi_aff_lex_gt_set(__isl_take isl_multi_aff *ma1,
+	__isl_take isl_multi_aff *ma2);
 __isl_give isl_set *isl_multi_aff_lex_ge_set(__isl_take isl_multi_aff *ma1,
 	__isl_take isl_multi_aff *ma2);
 
+__isl_export
+__isl_give isl_basic_set *isl_multi_aff_bind(__isl_take isl_multi_aff *ma,
+	__isl_take isl_multi_id *tuple);
+
+__isl_give char *isl_multi_aff_to_str(__isl_keep isl_multi_aff *ma);
 __isl_give isl_printer *isl_printer_print_multi_aff(__isl_take isl_printer *p,
 	__isl_keep isl_multi_aff *maff);
 
+__isl_constructor
 __isl_give isl_multi_aff *isl_multi_aff_read_from_str(isl_ctx *ctx,
 		const char *str);
 void isl_multi_aff_dump(__isl_keep isl_multi_aff *maff);
 
 ISL_DECLARE_MULTI(pw_aff)
-
+ISL_DECLARE_MULTI_IDENTITY(pw_aff)
+ISL_DECLARE_MULTI_ARITH(pw_aff)
+ISL_DECLARE_MULTI_MIN_MAX(pw_aff)
+ISL_DECLARE_MULTI_ADD_CONSTANT(pw_aff)
+ISL_DECLARE_MULTI_ZERO(pw_aff)
+ISL_DECLARE_MULTI_NAN(pw_aff)
+ISL_DECLARE_MULTI_DIMS(pw_aff)
+ISL_DECLARE_MULTI_DIM_ID(pw_aff)
+ISL_DECLARE_MULTI_INSERT_DOMAIN(pw_aff)
+ISL_DECLARE_MULTI_TUPLE_ID(pw_aff)
+ISL_DECLARE_MULTI_WITH_DOMAIN(pw_aff)
+ISL_DECLARE_MULTI_BIND_DOMAIN(pw_aff)
+ISL_DECLARE_MULTI_PARAM(pw_aff)
+ISL_DECLARE_MULTI_UNBIND_PARAMS(pw_aff)
+
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_zero(__isl_take isl_space *space);
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity_on_domain_space(
+	__isl_take isl_space *space);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_space_identity_pw_multi_aff_on_domain(
+	__isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity(
 	__isl_take isl_space *space);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
+	__isl_take isl_space *space);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_space_domain_map_pw_multi_aff(
+	__isl_take isl_space *space);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
+	__isl_take isl_space *space);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_space_range_map_pw_multi_aff(
+	__isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_project_out_map(
 	__isl_take isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_multi_aff_to_pw_multi_aff(
+	__isl_take isl_multi_aff *ma);
+__isl_constructor
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_aff(
 	__isl_take isl_multi_aff *ma);
+__isl_constructor
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_pw_aff(
 	__isl_take isl_pw_aff *pa);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_alloc(__isl_take isl_set *set,
@@ -361,8 +621,17 @@
 __isl_null isl_pw_multi_aff *isl_pw_multi_aff_free(
 	__isl_take isl_pw_multi_aff *pma);
 
-unsigned isl_pw_multi_aff_dim(__isl_keep isl_pw_multi_aff *pma,
+isl_size isl_pw_multi_aff_dim(__isl_keep isl_pw_multi_aff *pma,
 	enum isl_dim_type type);
+__isl_export
+isl_bool isl_pw_multi_aff_involves_locals(__isl_keep isl_pw_multi_aff *pma);
+isl_bool isl_pw_multi_aff_involves_param_id(__isl_keep isl_pw_multi_aff *pma,
+	__isl_keep isl_id *id);
+isl_bool isl_pw_multi_aff_involves_dims(__isl_keep isl_pw_multi_aff *pma,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_export
+__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
+	__isl_keep isl_pw_multi_aff *pma, int pos);
 __isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
 	__isl_keep isl_pw_multi_aff *pma, int pos);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_pw_aff(
@@ -372,30 +641,54 @@
 isl_ctx *isl_pw_multi_aff_get_ctx(__isl_keep isl_pw_multi_aff *pma);
 __isl_give isl_space *isl_pw_multi_aff_get_domain_space(
 	__isl_keep isl_pw_multi_aff *pma);
+__isl_export
 __isl_give isl_space *isl_pw_multi_aff_get_space(
 	__isl_keep isl_pw_multi_aff *pma);
-int isl_pw_multi_aff_has_tuple_name(__isl_keep isl_pw_multi_aff *pma,
+isl_bool isl_pw_multi_aff_has_tuple_name(__isl_keep isl_pw_multi_aff *pma,
 	enum isl_dim_type type);
 const char *isl_pw_multi_aff_get_tuple_name(__isl_keep isl_pw_multi_aff *pma,
 	enum isl_dim_type type);
+__isl_export
+__isl_give isl_id *isl_pw_multi_aff_get_range_tuple_id(
+	__isl_keep isl_pw_multi_aff *pma);
 __isl_give isl_id *isl_pw_multi_aff_get_tuple_id(
 	__isl_keep isl_pw_multi_aff *pma, enum isl_dim_type type);
-int isl_pw_multi_aff_has_tuple_id(__isl_keep isl_pw_multi_aff *pma,
+__isl_export
+isl_bool isl_pw_multi_aff_has_range_tuple_id(__isl_keep isl_pw_multi_aff *pma);
+isl_bool isl_pw_multi_aff_has_tuple_id(__isl_keep isl_pw_multi_aff *pma,
 	enum isl_dim_type type);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_tuple_id(
 	__isl_take isl_pw_multi_aff *pma,
 	enum isl_dim_type type, __isl_take isl_id *id);
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_set_range_tuple_id(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_id *id);
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_tuple_id(
+	__isl_take isl_pw_multi_aff *pma, enum isl_dim_type type);
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_user(
+	__isl_take isl_pw_multi_aff *pma);
+
+int isl_pw_multi_aff_find_dim_by_name(__isl_keep isl_pw_multi_aff *pma,
+	enum isl_dim_type type, const char *name);
 
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_dims(
 	__isl_take isl_pw_multi_aff *pma,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
+__isl_export
 __isl_give isl_set *isl_pw_multi_aff_domain(__isl_take isl_pw_multi_aff *pma);
 
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_empty(__isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_domain(
 	__isl_take isl_set *set);
 
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_multi_val_on_domain(
+	__isl_take isl_set *domain, __isl_take isl_multi_val *mv);
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_set_pw_multi_aff_on_domain_multi_val(
+	__isl_take isl_set *domain, __isl_take isl_multi_val *mv);
+
 const char *isl_pw_multi_aff_get_dim_name(__isl_keep isl_pw_multi_aff *pma,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_id *isl_pw_multi_aff_get_dim_id(
@@ -405,23 +698,42 @@
 	__isl_take isl_pw_multi_aff *pma,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
 
-int isl_pw_multi_aff_plain_is_equal(__isl_keep isl_pw_multi_aff *pma1,
+isl_bool isl_pw_multi_aff_involves_nan(__isl_keep isl_pw_multi_aff *pma);
+isl_bool isl_pw_multi_aff_plain_is_equal(__isl_keep isl_pw_multi_aff *pma1,
+	__isl_keep isl_pw_multi_aff *pma2);
+isl_bool isl_pw_multi_aff_is_equal(__isl_keep isl_pw_multi_aff *pma1,
 	__isl_keep isl_pw_multi_aff *pma2);
 
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_fix_si(
 	__isl_take isl_pw_multi_aff *pma, enum isl_dim_type type,
 	unsigned pos, int value);
 
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
 
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_neg(
+	__isl_take isl_pw_multi_aff *pma);
+
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
 
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add_constant_val(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_val *v);
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add_constant_multi_val(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv);
+__isl_overload
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_val(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_val *v);
+__isl_overload
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_down_val(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_val *v);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_scale_multi_val(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv);
 
@@ -435,100 +747,321 @@
 __isl_give isl_multi_aff *isl_multi_aff_flatten_domain(
 	__isl_take isl_multi_aff *ma);
 
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_flat_range_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_domain(
+	__isl_take isl_pw_multi_aff *pma);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_range(
+	__isl_take isl_pw_multi_aff *pma);
 
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_params(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain_wrapped_domain(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_intersect_domain_wrapped_range(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_subtract_domain(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
 
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_insert_domain(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_space *domain);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_project_domain_on_params(
 	__isl_take isl_pw_multi_aff *pma);
 
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_align_params(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_space *model);
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_drop_unused_params(
+	__isl_take isl_pw_multi_aff *pma);
 
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_coalesce(
 	__isl_take isl_pw_multi_aff *pma);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist_params(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_gist(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_set *set);
 
+__isl_overload
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_pullback_multi_aff(
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_pullback_pw_multi_aff(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
+__isl_overload
+__isl_give isl_pw_multi_aff *
+isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
+	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2);
 
-int isl_pw_multi_aff_foreach_piece(__isl_keep isl_pw_multi_aff *pma,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_multi_aff *maff,
+__isl_export
+isl_size isl_pw_multi_aff_n_piece(__isl_keep isl_pw_multi_aff *pma);
+__isl_export
+isl_stat isl_pw_multi_aff_foreach_piece(__isl_keep isl_pw_multi_aff *pma,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take isl_multi_aff *maff,
 		    void *user), void *user);
+isl_bool isl_pw_multi_aff_every_piece(__isl_keep isl_pw_multi_aff *pma,
+	isl_bool (*test)(__isl_keep isl_set *set, __isl_keep isl_multi_aff *ma,
+		void *user), void *user);
+__isl_export
+isl_bool isl_pw_multi_aff_isa_multi_aff(__isl_keep isl_pw_multi_aff *pma);
+__isl_export
+__isl_give isl_multi_aff *isl_pw_multi_aff_as_multi_aff(
+	__isl_take isl_pw_multi_aff *pma);
 
+__isl_export
+__isl_give isl_map *isl_pw_multi_aff_as_map(__isl_take isl_pw_multi_aff *pma);
 __isl_give isl_map *isl_map_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma);
+__isl_export
+__isl_give isl_set *isl_pw_multi_aff_as_set(__isl_take isl_pw_multi_aff *pma);
 __isl_give isl_set *isl_set_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma);
 
+__isl_give char *isl_pw_multi_aff_to_str(__isl_keep isl_pw_multi_aff *pma);
 __isl_give isl_printer *isl_printer_print_pw_multi_aff(__isl_take isl_printer *p,
 	__isl_keep isl_pw_multi_aff *pma);
 
+__isl_export
+__isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(__isl_take isl_set *set);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(__isl_take isl_set *set);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(__isl_take isl_map *map);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(__isl_take isl_map *map);
 
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_bind_domain(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_id *tuple);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_bind_domain_wrapped_domain(
+	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_id *tuple);
+
+__isl_constructor
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(isl_ctx *ctx,
 	const char *str);
 void isl_pw_multi_aff_dump(__isl_keep isl_pw_multi_aff *pma);
 
 
+__isl_overload
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_empty_ctx(
+	isl_ctx *ctx);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_empty_space(
+	__isl_take isl_space *space);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_empty(
 	__isl_take isl_space *space);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_aff(
+	__isl_take isl_aff *aff);
+__isl_constructor
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_multi_aff(
+	__isl_take isl_multi_aff *ma);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_pw_multi_aff_to_union_pw_multi_aff(
+	__isl_take isl_pw_multi_aff *pma);
+__isl_constructor
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_pw_multi_aff(
+	__isl_take isl_pw_multi_aff *pma);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_domain(
 	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_multi_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_param_on_domain_id(
+	__isl_take isl_union_set *domain, __isl_take isl_id *id);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_copy(
 	__isl_keep isl_union_pw_multi_aff *upma);
 __isl_null isl_union_pw_multi_aff *isl_union_pw_multi_aff_free(
 	__isl_take isl_union_pw_multi_aff *upma);
 
+__isl_give isl_union_pw_multi_aff *isl_union_set_identity_union_pw_multi_aff(
+	__isl_take isl_union_set *uset);
+
+__isl_give isl_union_pw_aff *isl_union_pw_multi_aff_get_union_pw_aff(
+	__isl_keep isl_union_pw_multi_aff *upma, int pos);
+
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add_pw_multi_aff(
 	__isl_take isl_union_pw_multi_aff *upma,
 	__isl_take isl_pw_multi_aff *pma);
 
 isl_ctx *isl_union_pw_multi_aff_get_ctx(
 	__isl_keep isl_union_pw_multi_aff *upma);
+__isl_export
 __isl_give isl_space *isl_union_pw_multi_aff_get_space(
 	__isl_keep isl_union_pw_multi_aff *upma);
+__isl_give isl_pw_multi_aff_list *isl_union_pw_multi_aff_get_pw_multi_aff_list(
+	__isl_keep isl_union_pw_multi_aff *upma);
+
+isl_size isl_union_pw_multi_aff_dim(__isl_keep isl_union_pw_multi_aff *upma,
+	enum isl_dim_type type);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_set_dim_name(
+	__isl_take isl_union_pw_multi_aff *upma,
+	enum isl_dim_type type, unsigned pos, const char *s);
+
+int isl_union_pw_multi_aff_find_dim_by_name(
+	__isl_keep isl_union_pw_multi_aff *upma, enum isl_dim_type type,
+	const char *name);
+
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_drop_dims(
+	__isl_take isl_union_pw_multi_aff *upma,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_reset_user(
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_coalesce(
+	__isl_take isl_union_pw_multi_aff *upma);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_gist_params(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_set *context);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_gist(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *context);
+
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_apply_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2);
 
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_align_params(
 	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_space *model);
 
-int isl_union_pw_multi_aff_foreach_pw_multi_aff(
+isl_size isl_union_pw_multi_aff_n_pw_multi_aff(
+	__isl_keep isl_union_pw_multi_aff *upma);
+
+isl_stat isl_union_pw_multi_aff_foreach_pw_multi_aff(
+	__isl_keep isl_union_pw_multi_aff *upma,
+	isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma, void *user),
+	void *user);
+isl_bool isl_union_pw_multi_aff_every_pw_multi_aff(
 	__isl_keep isl_union_pw_multi_aff *upma,
-	int (*fn)(__isl_take isl_pw_multi_aff *pma, void *user), void *user);
+	isl_bool (*test)(__isl_keep isl_pw_multi_aff *pma, void *user),
+	void *user);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_union_pw_multi_aff_extract_pw_multi_aff(
+	__isl_keep isl_union_pw_multi_aff *upma, __isl_take isl_space *space);
+__isl_export
+isl_bool isl_union_pw_multi_aff_isa_pw_multi_aff(
+	__isl_keep isl_union_pw_multi_aff *upma);
+__isl_export
+__isl_give isl_pw_multi_aff *isl_union_pw_multi_aff_as_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma);
 
+__isl_export
+isl_bool isl_union_pw_multi_aff_plain_is_empty(
+	__isl_keep isl_union_pw_multi_aff *upma);
+__isl_export
+isl_bool isl_union_pw_multi_aff_involves_locals(
+	__isl_keep isl_union_pw_multi_aff *upma);
+isl_bool isl_union_pw_multi_aff_involves_nan(
+	__isl_keep isl_union_pw_multi_aff *upma);
+isl_bool isl_union_pw_multi_aff_plain_is_equal(
+	__isl_keep isl_union_pw_multi_aff *upma1,
+	__isl_keep isl_union_pw_multi_aff *upma2);
+
+__isl_export
 __isl_give isl_union_set *isl_union_pw_multi_aff_domain(
 	__isl_take isl_union_pw_multi_aff *upma);
 
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_neg(
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_export
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_add(
 	__isl_take isl_union_pw_multi_aff *upma1,
 	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_union_add(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_export
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_sub(
 	__isl_take isl_union_pw_multi_aff *upma1,
 	__isl_take isl_union_pw_multi_aff *upma2);
 
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_val(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_val *val);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_down_val(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_val *val);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_multi_val(
 	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_multi_val *mv);
 
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_product(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_export
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_flat_range_product(
 	__isl_take isl_union_pw_multi_aff *upma1,
 	__isl_take isl_union_pw_multi_aff *upma2);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_domain(
+	__isl_take isl_union_pw_multi_aff *upma);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_range(
+	__isl_take isl_union_pw_multi_aff *upma);
 
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_intersect_params(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_set *set);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_intersect_domain_union_set(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *uset);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_intersect_domain(
 	__isl_take isl_union_pw_multi_aff *upma,
 	__isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_intersect_domain_space(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_space *space);
+__isl_export
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_intersect_domain_wrapped_domain(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_intersect_domain_wrapped_range(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_subtract_domain_union_set(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_subtract_domain_space(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_space *space);
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_subtract_domain(
+	__isl_take isl_union_pw_multi_aff *upma,
+	__isl_take isl_union_set *uset);
 
+__isl_export
+__isl_give isl_union_map *isl_union_pw_multi_aff_as_union_map(
+	__isl_take isl_union_pw_multi_aff *upma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_from_union_pw_multi_aff(
 	__isl_take isl_union_pw_multi_aff *upma);
 
@@ -537,66 +1070,392 @@
 
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_set(
 	__isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_map_as_union_pw_multi_aff(
+	__isl_take isl_union_map *umap);
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_map(
 	__isl_take isl_union_map *umap);
 
+__isl_constructor
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_read_from_str(
 	isl_ctx *ctx, const char *str);
 void isl_union_pw_multi_aff_dump(__isl_keep isl_union_pw_multi_aff *upma);
 __isl_give char *isl_union_pw_multi_aff_to_str(
 	__isl_keep isl_union_pw_multi_aff *upma);
 
-__isl_give isl_multi_pw_aff *isl_multi_pw_aff_identity(
-	__isl_take isl_space *space);
+uint32_t isl_multi_pw_aff_get_hash(__isl_keep isl_multi_pw_aff *mpa);
+
+__isl_constructor
+__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(__isl_take isl_aff *aff);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_multi_aff_to_multi_pw_aff(
+	__isl_take isl_multi_aff *ma);
+__isl_constructor
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_multi_aff(
 	__isl_take isl_multi_aff *ma);
+__isl_constructor
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_aff(
 	__isl_take isl_pw_aff *pa);
+__isl_export
 __isl_give isl_set *isl_multi_pw_aff_domain(__isl_take isl_multi_pw_aff *mpa);
+__isl_export
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_intersect_params(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_set *set);
+__isl_export
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_intersect_domain(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_set *domain);
 
+__isl_export
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
 	__isl_take isl_multi_pw_aff *mpa);
+__isl_export
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_set *set);
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_gist_params(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_set *set);
 
-int isl_multi_pw_aff_is_equal(__isl_keep isl_multi_pw_aff *mpa1,
+isl_bool isl_multi_pw_aff_is_cst(__isl_keep isl_multi_pw_aff *mpa);
+isl_bool isl_multi_pw_aff_is_equal(__isl_keep isl_multi_pw_aff *mpa1,
 	__isl_keep isl_multi_pw_aff *mpa2);
 
+__isl_overload
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_pw_multi_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_pw_aff(
 	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
 
+__isl_export
+__isl_give isl_multi_pw_aff *isl_multi_pw_aff_union_add(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
+
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_dims(
 	__isl_take isl_multi_pw_aff *pma,
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
 
+__isl_export
+__isl_give isl_set *isl_multi_pw_aff_as_set(__isl_take isl_multi_pw_aff *mpa);
 __isl_give isl_set *isl_set_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa);
+__isl_export
+__isl_give isl_map *isl_multi_pw_aff_as_map(__isl_take isl_multi_pw_aff *mpa);
 __isl_give isl_map *isl_map_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_pw_aff(
 	__isl_take isl_multi_pw_aff *mpa);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_pw_multi_aff_to_multi_pw_aff(
+	__isl_take isl_pw_multi_aff *pma);
+__isl_constructor
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_multi_aff(
 	__isl_take isl_pw_multi_aff *pma);
 
+__isl_give isl_map *isl_multi_pw_aff_eq_map(__isl_take isl_multi_pw_aff *mpa1,
+	__isl_take isl_multi_pw_aff *mpa2);
+__isl_give isl_map *isl_multi_pw_aff_lex_le_map(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
+__isl_give isl_map *isl_multi_pw_aff_lex_lt_map(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
+__isl_give isl_map *isl_multi_pw_aff_lex_ge_map(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
+__isl_give isl_map *isl_multi_pw_aff_lex_gt_map(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2);
+
+__isl_export
+__isl_give isl_set *isl_multi_pw_aff_bind(__isl_take isl_multi_pw_aff *mpa,
+	__isl_take isl_multi_id *tuple);
+
+__isl_constructor
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_read_from_str(isl_ctx *ctx,
 	const char *str);
+__isl_give char *isl_multi_pw_aff_to_str(__isl_keep isl_multi_pw_aff *mpa);
 __isl_give isl_printer *isl_printer_print_multi_pw_aff(
 	__isl_take isl_printer *p, __isl_keep isl_multi_pw_aff *mpa);
 void isl_multi_pw_aff_dump(__isl_keep isl_multi_pw_aff *mpa);
 
+__isl_give isl_union_pw_aff *isl_union_pw_aff_copy(
+	__isl_keep isl_union_pw_aff *upa);
+__isl_null isl_union_pw_aff *isl_union_pw_aff_free(
+	__isl_take isl_union_pw_aff *upa);
+
+isl_ctx *isl_union_pw_aff_get_ctx(__isl_keep isl_union_pw_aff *upa);
+__isl_export
+__isl_give isl_space *isl_union_pw_aff_get_space(
+	__isl_keep isl_union_pw_aff *upa);
+__isl_give isl_pw_aff_list *isl_union_pw_aff_get_pw_aff_list(
+	__isl_keep isl_union_pw_aff *upa);
+
+isl_size isl_union_pw_aff_dim(__isl_keep isl_union_pw_aff *upa,
+	enum isl_dim_type type);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_set_dim_name(
+	__isl_take isl_union_pw_aff *upa, enum isl_dim_type type,
+	unsigned pos, const char *s);
+
+int isl_union_pw_aff_find_dim_by_name(__isl_keep isl_union_pw_aff *upa,
+	enum isl_dim_type type, const char *name);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_drop_dims(
+	__isl_take isl_union_pw_aff *upa,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_reset_user(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_empty_ctx(isl_ctx *ctx);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_empty_space(
+	__isl_take isl_space *space);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_empty(
+	__isl_take isl_space *space);
+__isl_constructor
+__isl_give isl_union_pw_aff *isl_union_pw_aff_from_aff(__isl_take isl_aff *aff);
+__isl_export
+__isl_give isl_union_pw_aff *isl_pw_aff_to_union_pw_aff(
+	__isl_take isl_pw_aff *pa);
+__isl_constructor
+__isl_give isl_union_pw_aff *isl_union_pw_aff_from_pw_aff(
+	__isl_take isl_pw_aff *pa);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_val *v);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_aff *aff);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_pw_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_pw_aff *pa);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_add_pw_aff(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_pw_aff *pa);
+
+__isl_constructor
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_pw_aff(
+	__isl_take isl_union_pw_aff *upa);
+
+isl_size isl_union_pw_aff_n_pw_aff(__isl_keep isl_union_pw_aff *upa);
+
+isl_stat isl_union_pw_aff_foreach_pw_aff(__isl_keep isl_union_pw_aff *upa,
+	isl_stat (*fn)(__isl_take isl_pw_aff *pa, void *user), void *user);
+isl_bool isl_union_pw_aff_every_pw_aff(__isl_keep isl_union_pw_aff *upa,
+	isl_bool (*test)(__isl_keep isl_pw_aff *pa, void *user), void *user);
+__isl_give isl_pw_aff *isl_union_pw_aff_extract_pw_aff(
+	__isl_keep isl_union_pw_aff *upa, __isl_take isl_space *space);
+
+isl_bool isl_union_pw_aff_involves_nan(__isl_keep isl_union_pw_aff *upa);
+isl_bool isl_union_pw_aff_plain_is_equal(__isl_keep isl_union_pw_aff *upa1,
+	__isl_keep isl_union_pw_aff *upa2);
+
+__isl_export
+__isl_give isl_union_set *isl_union_pw_aff_domain(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_neg(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_add(
+	__isl_take isl_union_pw_aff *upa1, __isl_take isl_union_pw_aff *upa2);
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
+	__isl_take isl_union_pw_aff *upa1, __isl_take isl_union_pw_aff *upa2);
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_sub(
+	__isl_take isl_union_pw_aff *upa1, __isl_take isl_union_pw_aff *upa2);
+
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_coalesce(
+	__isl_take isl_union_pw_aff *upa);
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_gist(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *context);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_gist_params(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_set *context);
+
+__isl_overload
+__isl_give isl_union_pw_aff *isl_union_pw_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_union_pw_aff *upa,
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_val(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_val *v);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_scale_down_val(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_val *v);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_val *f);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_align_params(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_space *model);
+
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_params(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_set *set);
+__isl_overload
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain_space(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_space *space);
+__isl_overload
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain_union_set(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain_wrapped_domain(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_union_pw_aff *isl_union_pw_aff_intersect_domain_wrapped_range(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_pw_aff *isl_union_pw_aff_subtract_domain_union_set(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_pw_aff *isl_union_pw_aff_subtract_domain_space(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_space *space);
+__isl_give isl_union_pw_aff *isl_union_pw_aff_subtract_domain(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_union_set *uset);
+
+__isl_give isl_union_pw_aff *isl_union_pw_aff_set_dim_name(
+	__isl_take isl_union_pw_aff *upa,
+	enum isl_dim_type type, unsigned pos, const char *s);
+
+__isl_give isl_union_set *isl_union_pw_aff_zero_union_set(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_give isl_union_map *isl_union_map_from_union_pw_aff(
+	__isl_take isl_union_pw_aff *upa);
+
+__isl_overload
+__isl_give isl_union_set *isl_union_pw_aff_bind_id(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_id *id);
+
+__isl_constructor
+__isl_give isl_union_pw_aff *isl_union_pw_aff_read_from_str(isl_ctx *ctx,
+	const char *str);
+__isl_give char *isl_union_pw_aff_to_str(__isl_keep isl_union_pw_aff *upa);
+__isl_give isl_printer *isl_printer_print_union_pw_aff(
+	__isl_take isl_printer *p, __isl_keep isl_union_pw_aff *upa);
+void isl_union_pw_aff_dump(__isl_keep isl_union_pw_aff *upa);
+
+ISL_DECLARE_MULTI(union_pw_aff)
+ISL_DECLARE_MULTI_ARITH(union_pw_aff)
+ISL_DECLARE_MULTI_ZERO(union_pw_aff)
+ISL_DECLARE_MULTI_NAN(union_pw_aff)
+ISL_DECLARE_MULTI_DROP_DIMS(union_pw_aff)
+ISL_DECLARE_MULTI_DIM_ID(union_pw_aff)
+ISL_DECLARE_MULTI_TUPLE_ID(union_pw_aff)
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_aff_to_multi_union_pw_aff(
+        __isl_take isl_multi_aff *ma);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_aff(
+	__isl_take isl_multi_aff *ma);
+__isl_constructor
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_union_pw_aff(
+	__isl_take isl_union_pw_aff *upa);
+__isl_constructor
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_pw_aff(
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_aff *ma);
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_pw_multi_aff_on_domain(__isl_take isl_union_set *domain,
+	__isl_take isl_pw_multi_aff *pma);
+
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_floor(
+	__isl_take isl_multi_union_pw_aff *mupa);
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_intersect_domain(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_intersect_params(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *params);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_intersect_range(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *set);
+
+__isl_export
+__isl_give isl_union_set *isl_multi_union_pw_aff_domain(
+	__isl_take isl_multi_union_pw_aff *mupa);
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_coalesce(
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_gist(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_union_set *context);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_gist_params(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *context);
+
+__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma);
+__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_pw_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_pw_multi_aff *pma);
+
+__isl_overload
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa);
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_union_add(
+	__isl_take isl_multi_union_pw_aff *mupa1,
+	__isl_take isl_multi_union_pw_aff *mupa2);
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *
+isl_union_pw_multi_aff_as_multi_union_pw_aff(
+	__isl_take isl_union_pw_multi_aff *upma);
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_from_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_union_map_as_multi_union_pw_aff(
+	__isl_take isl_union_map *umap);
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_union_map(
+	__isl_take isl_union_map *umap);
+__isl_overload
+__isl_give isl_union_map *isl_union_map_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa);
+
+__isl_give isl_union_set *isl_multi_union_pw_aff_zero_union_set(
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_export
+__isl_give isl_union_set *isl_multi_union_pw_aff_bind(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_multi_id *tuple);
+
+__isl_give isl_multi_pw_aff *isl_multi_union_pw_aff_extract_multi_pw_aff(
+	__isl_keep isl_multi_union_pw_aff *mupa, __isl_take isl_space *space);
+
+__isl_constructor
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_read_from_str(
+	isl_ctx *ctx, const char *str);
+__isl_give char *isl_multi_union_pw_aff_to_str(
+	__isl_keep isl_multi_union_pw_aff *mupa);
+__isl_give isl_printer *isl_printer_print_multi_union_pw_aff(
+	__isl_take isl_printer *p, __isl_keep isl_multi_union_pw_aff *mupa);
+void isl_multi_union_pw_aff_dump(__isl_keep isl_multi_union_pw_aff *mupa);
+
+ISL_DECLARE_EXPORTED_LIST_FN(aff)
+ISL_DECLARE_EXPORTED_LIST_FN(pw_aff)
+ISL_DECLARE_EXPORTED_LIST_FN(pw_multi_aff)
+ISL_DECLARE_EXPORTED_LIST_FN(union_pw_aff)
+ISL_DECLARE_LIST_FN(union_pw_multi_aff)
+
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/aff_type.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/aff_type.h Changed

@@ -7,28 +7,44 @@
 extern "C" {
 #endif
 
-struct isl_aff;
+struct __isl_subclass(isl_multi_aff) __isl_subclass(isl_pw_aff) isl_aff;
 typedef struct isl_aff isl_aff;
 
-ISL_DECLARE_LIST(aff)
+ISL_DECLARE_EXPORTED_LIST_TYPE(aff)
 
-struct isl_pw_aff;
+struct __isl_subclass(isl_multi_pw_aff) __isl_subclass(isl_pw_multi_aff)
+	__isl_subclass(isl_union_pw_aff) isl_pw_aff;
 typedef struct isl_pw_aff isl_pw_aff;
 
-ISL_DECLARE_LIST(pw_aff)
+ISL_DECLARE_EXPORTED_LIST_TYPE(pw_aff)
 
-struct isl_multi_aff;
+struct __isl_subclass(isl_multi_union_pw_aff)
+	__isl_subclass(isl_union_pw_multi_aff) isl_union_pw_aff;
+typedef struct isl_union_pw_aff isl_union_pw_aff;
+
+ISL_DECLARE_EXPORTED_LIST_TYPE(union_pw_aff)
+
+struct __isl_subclass(isl_multi_pw_aff) __isl_subclass(isl_pw_multi_aff)
+	isl_multi_aff;
 typedef struct isl_multi_aff isl_multi_aff;
 
-struct isl_pw_multi_aff;
+struct __isl_subclass(isl_multi_pw_aff) __isl_subclass(isl_union_pw_multi_aff)
+	isl_pw_multi_aff;
 typedef struct isl_pw_multi_aff isl_pw_multi_aff;
 
-struct isl_union_pw_multi_aff;
+ISL_DECLARE_EXPORTED_LIST_TYPE(pw_multi_aff)
+
+struct __isl_export isl_union_pw_multi_aff;
 typedef struct isl_union_pw_multi_aff isl_union_pw_multi_aff;
 
-struct isl_multi_pw_aff;
+ISL_DECLARE_LIST_TYPE(union_pw_multi_aff)
+
+struct __isl_subclass(isl_multi_union_pw_aff) isl_multi_pw_aff;
 typedef struct isl_multi_pw_aff isl_multi_pw_aff;
 
+struct __isl_export isl_multi_union_pw_aff;
+typedef struct isl_multi_union_pw_aff isl_multi_union_pw_aff;
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/arg.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/arg.h Changed

@@ -53,6 +53,7 @@
 	char			 short_name;
 	const char		*long_name;
 	const char		*argument_name;
+#define ISL_ARG_OFFSET_NONE	((size_t) -1)
 	size_t			 offset;
 	const char		*help_msg;
 #define ISL_ARG_SINGLE_DASH	(1 << 0)
@@ -148,6 +149,16 @@
 	.u = { .choice = { .choice = c, .default_value = d,		\
 			    .default_selected = ds, .set = NULL } }	\
 },
+#define ISL_ARG_PHANTOM_USER_CHOICE_F(s,l,c,setter,d,h,fl)	{	\
+	.type = isl_arg_choice,						\
+	.short_name = s,						\
+	.long_name = l,							\
+	.offset = ISL_ARG_OFFSET_NONE,					\
+	.help_msg = h,							\
+	.flags = fl,							\
+	.u = { .choice = { .choice = c, .default_value = d,		\
+			    .default_selected = d, .set = setter } }	\
+},
 #define ISL_ARG_USER_OPT_CHOICE(st,f,s,l,c,setter,d,ds,h)	{	\
 	.type = isl_arg_choice,						\
 	.short_name = s,						\
@@ -171,7 +182,7 @@
 #define ISL_ARG_BOOL(st,f,s,l,d,h)					\
 	ISL_ARG_BOOL_F(st,f,s,l,d,h,0)
 #define ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,fl)				\
-	_ISL_ARG_BOOL_F(-1,s,l,setter,0,h,fl)
+	_ISL_ARG_BOOL_F(ISL_ARG_OFFSET_NONE,s,l,setter,0,h,fl)
 #define ISL_ARG_PHANTOM_BOOL(s,l,setter,h)				\
 	ISL_ARG_PHANTOM_BOOL_F(s,l,setter,h,0)
 #define ISL_ARG_INT_F(st,f,s,l,a,d,h,fl)	{			\
@@ -182,7 +193,7 @@
 	.offset = offsetof(st, f),					\
 	.help_msg = h,							\
 	.flags = fl,							\
-	.u = { .ul = { .default_value = d } }				\
+	.u = { .i = { .default_value = d } }				\
 },
 #define ISL_ARG_INT(st,f,s,l,a,d,h)					\
 	ISL_ARG_INT_F(st,f,s,l,a,d,h,0)
@@ -253,7 +264,7 @@
 #define ISL_ARG_CHILD(st,f,l,c,h)					\
 	_ISL_ARG_CHILD(offsetof(st, f),l,c,h,0)
 #define ISL_ARG_GROUP_F(l,c,h,fl)					\
-	_ISL_ARG_CHILD(-1,l,c,h,fl)
+	_ISL_ARG_CHILD(ISL_ARG_OFFSET_NONE,l,c,h,fl)
 #define ISL_ARG_GROUP(l,c,h)						\
 	ISL_ARG_GROUP_F(l,c,h,0)
 #define ISL_ARG_FLAGS(st,f,s,l,c,d,h)	{				\

_service:tar_scm:isl-0.14.tar.xz/include/isl/ast.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/ast.h Changed

@@ -3,9 +3,9 @@
 
 #include <isl/ctx.h>
 #include <isl/ast_type.h>
-#include <isl/id.h>
+#include <isl/id_type.h>
 #include <isl/id_to_ast_expr.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 #include <isl/list.h>
 #include <isl/printer.h>
 
@@ -13,12 +13,15 @@
 extern "C" {
 #endif
 
-int isl_options_set_ast_iterator_type(isl_ctx *ctx, const char *val);
+isl_stat isl_options_set_ast_iterator_type(isl_ctx *ctx, const char *val);
 const char *isl_options_get_ast_iterator_type(isl_ctx *ctx);
 
-int isl_options_set_ast_always_print_block(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_always_print_block(isl_ctx *ctx, int val);
 int isl_options_get_ast_always_print_block(isl_ctx *ctx);
 
+isl_stat isl_options_set_ast_print_outermost_block(isl_ctx *ctx, int val);
+int isl_options_get_ast_print_outermost_block(isl_ctx *ctx);
+
 __isl_give isl_ast_expr *isl_ast_expr_from_val(__isl_take isl_val *v);
 __isl_give isl_ast_expr *isl_ast_expr_from_id(__isl_take isl_id *id);
 __isl_give isl_ast_expr *isl_ast_expr_neg(__isl_take isl_ast_expr *expr);
@@ -30,10 +33,18 @@
 	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_div(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2);
+__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2);
+__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_and(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2);
+__isl_give isl_ast_expr *isl_ast_expr_and_then(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_or(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2);
+__isl_give isl_ast_expr *isl_ast_expr_or_else(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_le(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_lt(__isl_take isl_ast_expr *expr1,
@@ -46,24 +57,40 @@
 	__isl_take isl_ast_expr *expr2);
 __isl_give isl_ast_expr *isl_ast_expr_access(__isl_take isl_ast_expr *array,
 	__isl_take isl_ast_expr_list *indices);
+__isl_give isl_ast_expr *isl_ast_expr_call(__isl_take isl_ast_expr *function,
+	__isl_take isl_ast_expr_list *arguments);
 __isl_give isl_ast_expr *isl_ast_expr_address_of(__isl_take isl_ast_expr *expr);
 
 __isl_give isl_ast_expr *isl_ast_expr_copy(__isl_keep isl_ast_expr *expr);
 __isl_null isl_ast_expr *isl_ast_expr_free(__isl_take isl_ast_expr *expr);
 
 isl_ctx *isl_ast_expr_get_ctx(__isl_keep isl_ast_expr *expr);
+__isl_subclass(isl_ast_expr)
 enum isl_ast_expr_type isl_ast_expr_get_type(__isl_keep isl_ast_expr *expr);
+__isl_export
+__isl_give isl_val *isl_ast_expr_int_get_val(__isl_keep isl_ast_expr *expr);
 __isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr);
+__isl_export
+__isl_give isl_id *isl_ast_expr_id_get_id(__isl_keep isl_ast_expr *expr);
 __isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr);
 
-enum isl_ast_op_type isl_ast_expr_get_op_type(__isl_keep isl_ast_expr *expr);
-int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
+__isl_subclass(isl_ast_expr_op)
+enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
+	__isl_keep isl_ast_expr *expr);
+enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
+	__isl_keep isl_ast_expr *expr);
+__isl_export
+isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr);
+isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr);
+__isl_export
+__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(__isl_keep isl_ast_expr *expr,
+	int pos);
 __isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr,
 	int pos);
 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(__isl_take isl_ast_expr *expr,
 	int pos, __isl_take isl_ast_expr *arg);
 
-int isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
+isl_bool isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
 	__isl_keep isl_ast_expr *expr2);
 
 __isl_give isl_ast_expr *isl_ast_expr_substitute_ids(
@@ -73,47 +100,78 @@
 	__isl_keep isl_ast_expr *expr);
 void isl_ast_expr_dump(__isl_keep isl_ast_expr *expr);
 __isl_give char *isl_ast_expr_to_str(__isl_keep isl_ast_expr *expr);
+__isl_export
+__isl_give char *isl_ast_expr_to_C_str(__isl_keep isl_ast_expr *expr);
 
 __isl_give isl_ast_node *isl_ast_node_alloc_user(__isl_take isl_ast_expr *expr);
 __isl_give isl_ast_node *isl_ast_node_copy(__isl_keep isl_ast_node *node);
 __isl_null isl_ast_node *isl_ast_node_free(__isl_take isl_ast_node *node);
 
 isl_ctx *isl_ast_node_get_ctx(__isl_keep isl_ast_node *node);
+__isl_subclass(isl_ast_node)
 enum isl_ast_node_type isl_ast_node_get_type(__isl_keep isl_ast_node *node);
 
 __isl_give isl_ast_node *isl_ast_node_set_annotation(
 	__isl_take isl_ast_node *node, __isl_take isl_id *annotation);
 __isl_give isl_id *isl_ast_node_get_annotation(__isl_keep isl_ast_node *node);
 
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
 	__isl_keep isl_ast_node *node);
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_for_get_init(
 	__isl_keep isl_ast_node *node);
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_for_get_cond(
 	__isl_keep isl_ast_node *node);
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_for_get_inc(
 	__isl_keep isl_ast_node *node);
+__isl_export
 __isl_give isl_ast_node *isl_ast_node_for_get_body(
 	__isl_keep isl_ast_node *node);
-int isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node);
+__isl_export
+isl_bool isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node);
 
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
 	__isl_keep isl_ast_node *node);
+__isl_export
+__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
+	__isl_keep isl_ast_node *node);
 __isl_give isl_ast_node *isl_ast_node_if_get_then(
 	__isl_keep isl_ast_node *node);
-int isl_ast_node_if_has_else(__isl_keep isl_ast_node *node);
+__isl_export
+isl_bool isl_ast_node_if_has_else_node(__isl_keep isl_ast_node *node);
+isl_bool isl_ast_node_if_has_else(__isl_keep isl_ast_node *node);
+__isl_export
+__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
+	__isl_keep isl_ast_node *node);
 __isl_give isl_ast_node *isl_ast_node_if_get_else(
 	__isl_keep isl_ast_node *node);
 
+__isl_export
 __isl_give isl_ast_node_list *isl_ast_node_block_get_children(
 	__isl_keep isl_ast_node *node);
 
+__isl_export
+__isl_give isl_id *isl_ast_node_mark_get_id(__isl_keep isl_ast_node *node);
+__isl_export
+__isl_give isl_ast_node *isl_ast_node_mark_get_node(
+	__isl_keep isl_ast_node *node);
+
+__isl_export
 __isl_give isl_ast_expr *isl_ast_node_user_get_expr(
 	__isl_keep isl_ast_node *node);
 
+isl_stat isl_ast_node_foreach_descendant_top_down(
+	__isl_keep isl_ast_node *node,
+	isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user), void *user);
+
 __isl_give isl_printer *isl_printer_print_ast_node(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node);
 void isl_ast_node_dump(__isl_keep isl_ast_node *node);
+__isl_give char *isl_ast_node_to_str(__isl_keep isl_ast_node *node);
 
 __isl_give isl_ast_print_options *isl_ast_print_options_alloc(isl_ctx *ctx);
 __isl_give isl_ast_print_options *isl_ast_print_options_copy(
@@ -136,10 +194,29 @@
 		__isl_keep isl_ast_node *node, void *user),
 	void *user);
 
-int isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node,
-	int (*fn)(enum isl_ast_op_type type, void *user), void *user);
+isl_stat isl_options_set_ast_print_macro_once(isl_ctx *ctx, int val);
+int isl_options_get_ast_print_macro_once(isl_ctx *ctx);
+
+isl_stat isl_ast_expr_foreach_ast_expr_op_type(__isl_keep isl_ast_expr *expr,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user);
+isl_stat isl_ast_expr_foreach_ast_op_type(__isl_keep isl_ast_expr *expr,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user);
+isl_stat isl_ast_node_foreach_ast_expr_op_type(__isl_keep isl_ast_node *node,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user);
+isl_stat isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user);
+__isl_give isl_printer *isl_ast_expr_op_type_set_print_name(
+	__isl_take isl_printer *p, enum isl_ast_expr_op_type type,
+	__isl_keep const char *name);
+__isl_give isl_printer *isl_ast_op_type_set_print_name(
+	__isl_take isl_printer *p, enum isl_ast_expr_op_type type,
+	__isl_keep const char *name);
+__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
+	enum isl_ast_expr_op_type type, __isl_take isl_printer *p);
 __isl_give isl_printer *isl_ast_op_type_print_macro(
-	enum isl_ast_op_type type, __isl_take isl_printer *p);
+	enum isl_ast_expr_op_type type, __isl_take isl_printer *p);
+__isl_give isl_printer *isl_ast_expr_print_macros(
+	__isl_keep isl_ast_expr *expr, __isl_take isl_printer *p);
 __isl_give isl_printer *isl_ast_node_print_macros(
 	__isl_keep isl_ast_node *node, __isl_take isl_printer *p);
 __isl_give isl_printer *isl_ast_node_print(__isl_keep isl_ast_node *node,
@@ -152,6 +229,12 @@
 	__isl_take isl_printer *p,
 	__isl_take isl_ast_print_options *options);
 
+__isl_export
+__isl_give char *isl_ast_node_to_C_str(__isl_keep isl_ast_node *node);
+
+ISL_DECLARE_LIST_FN(ast_expr)
+ISL_DECLARE_EXPORTED_LIST_FN(ast_node)
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/ast_build.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/ast_build.h Changed

@@ -1,50 +1,58 @@
-#ifndef ISL_AST_CONTEXT_H
-#define ISL_AST_CONTEXT_H
+#ifndef ISL_AST_BUILD_H
+#define ISL_AST_BUILD_H
 
 #include <isl/ctx.h>
 #include <isl/set.h>
 #include <isl/ast.h>
+#include <isl/schedule.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_ast_build;
+struct __isl_export isl_ast_build;
 typedef struct isl_ast_build isl_ast_build;
 
 
-int isl_options_set_ast_build_atomic_upper_bound(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_atomic_upper_bound(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_atomic_upper_bound(isl_ctx *ctx);
 
-int isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_prefer_pdiv(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_prefer_pdiv(isl_ctx *ctx);
 
-int isl_options_set_ast_build_exploit_nested_bounds(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_detect_min_max(isl_ctx *ctx, int val);
+int isl_options_get_ast_build_detect_min_max(isl_ctx *ctx);
+
+isl_stat isl_options_set_ast_build_exploit_nested_bounds(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_exploit_nested_bounds(isl_ctx *ctx);
 
-int isl_options_set_ast_build_group_coscheduled(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_group_coscheduled(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_group_coscheduled(isl_ctx *ctx);
 
 #define ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT		0
 #define ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT		1
-int isl_options_set_ast_build_separation_bounds(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_separation_bounds(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_separation_bounds(isl_ctx *ctx);
 
-int isl_options_set_ast_build_scale_strides(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_scale_strides(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_scale_strides(isl_ctx *ctx);
 
-int isl_options_set_ast_build_allow_else(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_allow_else(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_allow_else(isl_ctx *ctx);
 
-int isl_options_set_ast_build_allow_or(isl_ctx *ctx, int val);
+isl_stat isl_options_set_ast_build_allow_or(isl_ctx *ctx, int val);
 int isl_options_get_ast_build_allow_or(isl_ctx *ctx);
 
 isl_ctx *isl_ast_build_get_ctx(__isl_keep isl_ast_build *build);
 
+__isl_constructor
+__isl_give isl_ast_build *isl_ast_build_alloc(isl_ctx *ctx);
+__isl_export
 __isl_give isl_ast_build *isl_ast_build_from_context(__isl_take isl_set *set);
 
 __isl_give isl_space *isl_ast_build_get_schedule_space(
 	__isl_keep isl_ast_build *build);
+__isl_export
 __isl_give isl_union_map *isl_ast_build_get_schedule(
 	__isl_keep isl_ast_build *build);
 
@@ -62,6 +70,7 @@
 __isl_give isl_ast_build *isl_ast_build_set_iterators(
 	__isl_take isl_ast_build *build,
 	__isl_take isl_id_list *iterators);
+__isl_export
 __isl_give isl_ast_build *isl_ast_build_set_at_each_domain(
 	__isl_take isl_ast_build *build,
 	__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
@@ -74,22 +83,44 @@
 	__isl_take isl_ast_build *build,
 	__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
 		__isl_keep isl_ast_build *build, void *user), void *user);
+__isl_give isl_ast_build *isl_ast_build_set_before_each_mark(
+	__isl_take isl_ast_build *build,
+	isl_stat (*fn)(__isl_keep isl_id *mark, __isl_keep isl_ast_build *build,
+		void *user), void *user);
+__isl_give isl_ast_build *isl_ast_build_set_after_each_mark(
+	__isl_take isl_ast_build *build,
+	__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
+		__isl_keep isl_ast_build *build, void *user), void *user);
 __isl_give isl_ast_build *isl_ast_build_set_create_leaf(
 	__isl_take isl_ast_build *build,
 	__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_build *build,
 		void *user), void *user);
 
+__isl_overload
+__isl_give isl_ast_expr *isl_ast_build_expr_from_set(
+	__isl_keep isl_ast_build *build, __isl_take isl_set *set);
+__isl_overload
 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_aff *pa);
+__isl_overload
 __isl_give isl_ast_expr *isl_ast_build_access_from_pw_multi_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_ast_expr *isl_ast_build_access_from_multi_pw_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_multi_pw_aff *mpa);
+__isl_overload
 __isl_give isl_ast_expr *isl_ast_build_call_from_pw_multi_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_ast_expr *isl_ast_build_call_from_multi_pw_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_multi_pw_aff *mpa);
 
+__isl_overload
+__isl_give isl_ast_node *isl_ast_build_node_from_schedule(
+	__isl_keep isl_ast_build *build, __isl_take isl_schedule *schedule);
+__isl_export
+__isl_give isl_ast_node *isl_ast_build_node_from_schedule_map(
+	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule);
 __isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
 	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule);

_service:tar_scm:isl-0.14.tar.xz/include/isl/ast_type.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/ast_type.h Changed

@@ -7,41 +7,71 @@
 extern "C" {
 #endif
 
-struct isl_ast_expr;
+struct __isl_export isl_ast_expr;
 typedef struct isl_ast_expr isl_ast_expr;
 
-struct isl_ast_node;
+struct __isl_export isl_ast_node;
 typedef struct isl_ast_node isl_ast_node;
 
-enum isl_ast_op_type {
-	isl_ast_op_error = -1,
-	isl_ast_op_and,
-	isl_ast_op_and_then,
-	isl_ast_op_or,
-	isl_ast_op_or_else,
-	isl_ast_op_max,
-	isl_ast_op_min,
-	isl_ast_op_minus,
-	isl_ast_op_add,
-	isl_ast_op_sub,
-	isl_ast_op_mul,
-	isl_ast_op_div,
-	isl_ast_op_fdiv_q,	/* Round towards -infty */
-	isl_ast_op_pdiv_q,	/* Dividend is non-negative */
-	isl_ast_op_pdiv_r,	/* Dividend is non-negative */
-	isl_ast_op_cond,
-	isl_ast_op_select,
-	isl_ast_op_eq,
-	isl_ast_op_le,
-	isl_ast_op_lt,
-	isl_ast_op_ge,
-	isl_ast_op_gt,
-	isl_ast_op_call,
-	isl_ast_op_access,
-	isl_ast_op_member,
-	isl_ast_op_address_of
+enum isl_ast_expr_op_type {
+	isl_ast_expr_op_error = -1,
+	isl_ast_expr_op_and,
+	isl_ast_expr_op_and_then,
+	isl_ast_expr_op_or,
+	isl_ast_expr_op_or_else,
+	isl_ast_expr_op_max,
+	isl_ast_expr_op_min,
+	isl_ast_expr_op_minus,
+	isl_ast_expr_op_add,
+	isl_ast_expr_op_sub,
+	isl_ast_expr_op_mul,
+	isl_ast_expr_op_div,
+	isl_ast_expr_op_fdiv_q,	/* Round towards -infty */
+	isl_ast_expr_op_pdiv_q,	/* Dividend is non-negative */
+	isl_ast_expr_op_pdiv_r,	/* Dividend is non-negative */
+	isl_ast_expr_op_zdiv_r,	/* Result only compared against zero */
+	isl_ast_expr_op_cond,
+	isl_ast_expr_op_select,
+	isl_ast_expr_op_eq,
+	isl_ast_expr_op_le,
+	isl_ast_expr_op_lt,
+	isl_ast_expr_op_ge,
+	isl_ast_expr_op_gt,
+	isl_ast_expr_op_call,
+	isl_ast_expr_op_access,
+	isl_ast_expr_op_member,
+	isl_ast_expr_op_address_of
 };
 
+#define isl_ast_op_type		isl_ast_expr_op_type
+#define isl_ast_op_error	isl_ast_expr_op_error
+#define isl_ast_op_and		isl_ast_expr_op_and
+#define isl_ast_op_and_then	isl_ast_expr_op_and_then
+#define isl_ast_op_or		isl_ast_expr_op_or
+#define isl_ast_op_or_else	isl_ast_expr_op_or_else
+#define isl_ast_op_max		isl_ast_expr_op_max
+#define isl_ast_op_min		isl_ast_expr_op_min
+#define isl_ast_op_minus	isl_ast_expr_op_minus
+#define isl_ast_op_add		isl_ast_expr_op_add
+#define isl_ast_op_sub		isl_ast_expr_op_sub
+#define isl_ast_op_mul		isl_ast_expr_op_mul
+#define isl_ast_op_div		isl_ast_expr_op_div
+#define isl_ast_op_fdiv_q	isl_ast_expr_op_fdiv_q
+#define isl_ast_op_pdiv_q	isl_ast_expr_op_pdiv_q
+#define isl_ast_op_pdiv_r	isl_ast_expr_op_pdiv_r
+#define isl_ast_op_zdiv_r	isl_ast_expr_op_zdiv_r
+#define isl_ast_op_cond		isl_ast_expr_op_cond
+#define isl_ast_op_select	isl_ast_expr_op_select
+#define isl_ast_op_eq		isl_ast_expr_op_eq
+#define isl_ast_op_le		isl_ast_expr_op_le
+#define isl_ast_op_lt		isl_ast_expr_op_lt
+#define isl_ast_op_ge		isl_ast_expr_op_ge
+#define isl_ast_op_gt		isl_ast_expr_op_gt
+#define isl_ast_op_call		isl_ast_expr_op_call
+#define isl_ast_op_access	isl_ast_expr_op_access
+#define isl_ast_op_member	isl_ast_expr_op_member
+#define isl_ast_op_address_of	isl_ast_expr_op_address_of
+
 enum isl_ast_expr_type {
 	isl_ast_expr_error = -1,
 	isl_ast_expr_op,
@@ -54,14 +84,23 @@
 	isl_ast_node_for = 1,
 	isl_ast_node_if,
 	isl_ast_node_block,
+	isl_ast_node_mark,
 	isl_ast_node_user
 };
 
+enum isl_ast_loop_type {
+	isl_ast_loop_error = -1,
+	isl_ast_loop_default = 0,
+	isl_ast_loop_atomic,
+	isl_ast_loop_unroll,
+	isl_ast_loop_separate
+};
+
 struct isl_ast_print_options;
 typedef struct isl_ast_print_options isl_ast_print_options;
 
-ISL_DECLARE_LIST(ast_expr)
-ISL_DECLARE_LIST(ast_node)
+ISL_DECLARE_LIST_TYPE(ast_expr)
+ISL_DECLARE_EXPORTED_LIST_TYPE(ast_node)
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.14.tar.xz/include/isl/constraint.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/constraint.h Changed

@@ -11,11 +11,11 @@
 #define ISL_CONSTRAINT_H
 
 #include <isl/local_space.h>
-#include <isl/space.h>
+#include <isl/space_type.h>
 #include <isl/aff_type.h>
 #include <isl/set_type.h>
 #include <isl/list.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 #include <isl/printer.h>
 
 #if defined(__cplusplus)
@@ -29,29 +29,32 @@
 
 isl_ctx *isl_constraint_get_ctx(__isl_keep isl_constraint *c);
 
+__isl_give isl_constraint *isl_constraint_alloc_equality(
+	__isl_take isl_local_space *ls);
+__isl_give isl_constraint *isl_constraint_alloc_inequality(
+	__isl_take isl_local_space *ls);
 __isl_give isl_constraint *isl_equality_alloc(__isl_take isl_local_space *ls);
 __isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_local_space *ls);
 
-struct isl_constraint *isl_constraint_cow(struct isl_constraint *c);
-struct isl_constraint *isl_constraint_copy(struct isl_constraint *c);
+__isl_give isl_constraint *isl_constraint_copy(__isl_keep isl_constraint *c);
 __isl_null isl_constraint *isl_constraint_free(__isl_take isl_constraint *c);
 
-int isl_basic_map_n_constraint(__isl_keep isl_basic_map *bmap);
-int isl_basic_set_n_constraint(__isl_keep isl_basic_set *bset);
-int isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap,
-	int (*fn)(__isl_take isl_constraint *c, void *user), void *user);
-int isl_basic_set_foreach_constraint(__isl_keep isl_basic_set *bset,
-	int (*fn)(__isl_take isl_constraint *c, void *user), void *user);
+isl_size isl_basic_map_n_constraint(__isl_keep isl_basic_map *bmap);
+isl_size isl_basic_set_n_constraint(__isl_keep isl_basic_set *bset);
+isl_stat isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap,
+	isl_stat (*fn)(__isl_take isl_constraint *c, void *user), void *user);
+isl_stat isl_basic_set_foreach_constraint(__isl_keep isl_basic_set *bset,
+	isl_stat (*fn)(__isl_take isl_constraint *c, void *user), void *user);
 __isl_give isl_constraint_list *isl_basic_map_get_constraint_list(
 	__isl_keep isl_basic_map *bmap);
 __isl_give isl_constraint_list *isl_basic_set_get_constraint_list(
 	__isl_keep isl_basic_set *bset);
-int isl_constraint_is_equal(struct isl_constraint *constraint1,
-			    struct isl_constraint *constraint2);
+int isl_constraint_is_equal(__isl_keep isl_constraint *constraint1,
+			    __isl_keep isl_constraint *constraint2);
 
-int isl_basic_set_foreach_bound_pair(__isl_keep isl_basic_set *bset,
+isl_stat isl_basic_set_foreach_bound_pair(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos,
-	int (*fn)(__isl_take isl_constraint *lower,
+	isl_stat (*fn)(__isl_take isl_constraint *lower,
 		  __isl_take isl_constraint *upper,
 		  __isl_take isl_basic_set *bset, void *user), void *user);
 
@@ -64,13 +67,13 @@
 __isl_give isl_set *isl_set_add_constraint(__isl_take isl_set *set,
 	__isl_take isl_constraint *constraint);
 
-int isl_basic_map_has_defining_equality(
+isl_bool isl_basic_map_has_defining_equality(
 	__isl_keep isl_basic_map *bmap, enum isl_dim_type type, int pos,
 	__isl_give isl_constraint **c);
-int isl_basic_set_has_defining_equality(
+isl_bool isl_basic_set_has_defining_equality(
 	struct isl_basic_set *bset, enum isl_dim_type type, int pos,
 	struct isl_constraint **constraint);
-int isl_basic_set_has_defining_inequalities(
+isl_bool isl_basic_set_has_defining_inequalities(
 	struct isl_basic_set *bset, enum isl_dim_type type, int pos,
 	struct isl_constraint **lower,
 	struct isl_constraint **upper);
@@ -79,10 +82,10 @@
 	__isl_keep isl_constraint *constraint);
 __isl_give isl_local_space *isl_constraint_get_local_space(
 	__isl_keep isl_constraint *constraint);
-int isl_constraint_dim(struct isl_constraint *constraint,
+isl_size isl_constraint_dim(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type);
 
-int isl_constraint_involves_dims(__isl_keep isl_constraint *constraint,
+isl_bool isl_constraint_involves_dims(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
 const char *isl_constraint_get_dim_name(__isl_keep isl_constraint *constraint,
@@ -105,20 +108,22 @@
 __isl_give isl_aff *isl_constraint_get_div(__isl_keep isl_constraint *constraint,
 	int pos);
 
-struct isl_constraint *isl_constraint_negate(struct isl_constraint *constraint);
+__isl_give isl_constraint *isl_constraint_negate(
+	__isl_take isl_constraint *constraint);
 
-int isl_constraint_is_equality(__isl_keep isl_constraint *constraint);
-int isl_constraint_is_div_constraint(__isl_keep isl_constraint *constraint);
+isl_bool isl_constraint_is_equality(__isl_keep isl_constraint *constraint);
+isl_bool isl_constraint_is_div_constraint(
+	__isl_keep isl_constraint *constraint);
 
-int isl_constraint_is_lower_bound(__isl_keep isl_constraint *constraint,
+isl_bool isl_constraint_is_lower_bound(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned pos);
-int isl_constraint_is_upper_bound(__isl_keep isl_constraint *constraint,
+isl_bool isl_constraint_is_upper_bound(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned pos);
 
 __isl_give isl_basic_map *isl_basic_map_from_constraint(
 	__isl_take isl_constraint *constraint);
-struct isl_basic_set *isl_basic_set_from_constraint(
-	struct isl_constraint *constraint);
+__isl_give isl_basic_set *isl_basic_set_from_constraint(
+	__isl_take isl_constraint *constraint);
 
 __isl_give isl_aff *isl_constraint_get_bound(
 	__isl_keep isl_constraint *constraint, enum isl_dim_type type, int pos);
@@ -127,9 +132,6 @@
 __isl_give isl_constraint *isl_equality_from_aff(__isl_take isl_aff *aff);
 __isl_give isl_constraint *isl_inequality_from_aff(__isl_take isl_aff *aff);
 
-__isl_give isl_basic_set *isl_basic_set_drop_constraint(
-	__isl_take isl_basic_set *bset, __isl_take isl_constraint *constraint);
-
 int isl_constraint_plain_cmp(__isl_keep isl_constraint *c1,
 	__isl_keep isl_constraint *c2);
 int isl_constraint_cmp_last_non_zero(__isl_keep isl_constraint *c1,
@@ -143,6 +145,4 @@
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.24.tar.gz/include/isl/cpp-checked-conversion.h Added

@@ -0,0 +1,675 @@
+/// These are automatically generated conversions between
+/// the default and the 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.
+
+#ifndef ISL_CPP_CHECKED_CONVERSION
+#define ISL_CPP_CHECKED_CONVERSION
+
+#include <isl/cpp.h>
+#include <isl/cpp-checked.h>
+
+namespace isl {
+
+checked::aff check(aff obj) {
+	return checked::manage(obj.copy());
+}
+
+aff uncheck(checked::aff obj) {
+	return manage(obj.copy());
+}
+
+checked::aff_list check(aff_list obj) {
+	return checked::manage(obj.copy());
+}
+
+aff_list uncheck(checked::aff_list obj) {
+	return manage(obj.copy());
+}
+
+checked::ast_build check(ast_build obj) {
+	return checked::manage(obj.copy());
+}
+
+ast_build uncheck(checked::ast_build obj) {
+	return manage(obj.copy());
+}
+
+checked::ast_expr check(ast_expr obj) {
+	return checked::manage(obj.copy());
+}
+
+ast_expr uncheck(checked::ast_expr obj) {
+	return manage(obj.copy());
+}
+
+checked::ast_expr_id check(ast_expr_id obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_id>();
+}
+
+ast_expr_id uncheck(checked::ast_expr_id obj) {
+	return manage(obj.copy()).as<ast_expr_id>();
+}
+
+checked::ast_expr_int check(ast_expr_int obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_int>();
+}
+
+ast_expr_int uncheck(checked::ast_expr_int obj) {
+	return manage(obj.copy()).as<ast_expr_int>();
+}
+
+checked::ast_expr_op check(ast_expr_op obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>();
+}
+
+ast_expr_op uncheck(checked::ast_expr_op obj) {
+	return manage(obj.copy()).as<ast_expr_op>();
+}
+
+checked::ast_expr_op_access check(ast_expr_op_access obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_access>();
+}
+
+ast_expr_op_access uncheck(checked::ast_expr_op_access obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_access>();
+}
+
+checked::ast_expr_op_add check(ast_expr_op_add obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_add>();
+}
+
+ast_expr_op_add uncheck(checked::ast_expr_op_add obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_add>();
+}
+
+checked::ast_expr_op_address_of check(ast_expr_op_address_of obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_address_of>();
+}
+
+ast_expr_op_address_of uncheck(checked::ast_expr_op_address_of obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_address_of>();
+}
+
+checked::ast_expr_op_and check(ast_expr_op_and obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_and>();
+}
+
+ast_expr_op_and uncheck(checked::ast_expr_op_and obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_and>();
+}
+
+checked::ast_expr_op_and_then check(ast_expr_op_and_then obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_and_then>();
+}
+
+ast_expr_op_and_then uncheck(checked::ast_expr_op_and_then obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_and_then>();
+}
+
+checked::ast_expr_op_call check(ast_expr_op_call obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_call>();
+}
+
+ast_expr_op_call uncheck(checked::ast_expr_op_call obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_call>();
+}
+
+checked::ast_expr_op_cond check(ast_expr_op_cond obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_cond>();
+}
+
+ast_expr_op_cond uncheck(checked::ast_expr_op_cond obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_cond>();
+}
+
+checked::ast_expr_op_div check(ast_expr_op_div obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_div>();
+}
+
+ast_expr_op_div uncheck(checked::ast_expr_op_div obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_div>();
+}
+
+checked::ast_expr_op_eq check(ast_expr_op_eq obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_eq>();
+}
+
+ast_expr_op_eq uncheck(checked::ast_expr_op_eq obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_eq>();
+}
+
+checked::ast_expr_op_fdiv_q check(ast_expr_op_fdiv_q obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_fdiv_q>();
+}
+
+ast_expr_op_fdiv_q uncheck(checked::ast_expr_op_fdiv_q obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_fdiv_q>();
+}
+
+checked::ast_expr_op_ge check(ast_expr_op_ge obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_ge>();
+}
+
+ast_expr_op_ge uncheck(checked::ast_expr_op_ge obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_ge>();
+}
+
+checked::ast_expr_op_gt check(ast_expr_op_gt obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_gt>();
+}
+
+ast_expr_op_gt uncheck(checked::ast_expr_op_gt obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_gt>();
+}
+
+checked::ast_expr_op_le check(ast_expr_op_le obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_le>();
+}
+
+ast_expr_op_le uncheck(checked::ast_expr_op_le obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_le>();
+}
+
+checked::ast_expr_op_lt check(ast_expr_op_lt obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_lt>();
+}
+
+ast_expr_op_lt uncheck(checked::ast_expr_op_lt obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_lt>();
+}
+
+checked::ast_expr_op_max check(ast_expr_op_max obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_max>();
+}
+
+ast_expr_op_max uncheck(checked::ast_expr_op_max obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_max>();
+}
+
+checked::ast_expr_op_member check(ast_expr_op_member obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_member>();
+}
+
+ast_expr_op_member uncheck(checked::ast_expr_op_member obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_member>();
+}
+
+checked::ast_expr_op_min check(ast_expr_op_min obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_min>();
+}
+
+ast_expr_op_min uncheck(checked::ast_expr_op_min obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_min>();
+}
+
+checked::ast_expr_op_minus check(ast_expr_op_minus obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_minus>();
+}
+
+ast_expr_op_minus uncheck(checked::ast_expr_op_minus obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_minus>();
+}
+
+checked::ast_expr_op_mul check(ast_expr_op_mul obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_mul>();
+}
+
+ast_expr_op_mul uncheck(checked::ast_expr_op_mul obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_mul>();
+}
+
+checked::ast_expr_op_or check(ast_expr_op_or obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_or>();
+}
+
+ast_expr_op_or uncheck(checked::ast_expr_op_or obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_or>();
+}
+
+checked::ast_expr_op_or_else check(ast_expr_op_or_else obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_or_else>();
+}
+
+ast_expr_op_or_else uncheck(checked::ast_expr_op_or_else obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_or_else>();
+}
+
+checked::ast_expr_op_pdiv_q check(ast_expr_op_pdiv_q obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_pdiv_q>();
+}
+
+ast_expr_op_pdiv_q uncheck(checked::ast_expr_op_pdiv_q obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_pdiv_q>();
+}
+
+checked::ast_expr_op_pdiv_r check(ast_expr_op_pdiv_r obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_pdiv_r>();
+}
+
+ast_expr_op_pdiv_r uncheck(checked::ast_expr_op_pdiv_r obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_pdiv_r>();
+}
+
+checked::ast_expr_op_select check(ast_expr_op_select obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_select>();
+}
+
+ast_expr_op_select uncheck(checked::ast_expr_op_select obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_select>();
+}
+
+checked::ast_expr_op_sub check(ast_expr_op_sub obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_sub>();
+}
+
+ast_expr_op_sub uncheck(checked::ast_expr_op_sub obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_sub>();
+}
+
+checked::ast_expr_op_zdiv_r check(ast_expr_op_zdiv_r obj) {
+	return checked::manage(obj.copy()).as<checked::ast_expr_op>().as<checked::ast_expr_op_zdiv_r>();
+}
+
+ast_expr_op_zdiv_r uncheck(checked::ast_expr_op_zdiv_r obj) {
+	return manage(obj.copy()).as<ast_expr_op>().as<ast_expr_op_zdiv_r>();
+}
+
+checked::ast_node check(ast_node obj) {
+	return checked::manage(obj.copy());
+}
+
+ast_node uncheck(checked::ast_node obj) {
+	return manage(obj.copy());
+}
+
+checked::ast_node_block check(ast_node_block obj) {
+	return checked::manage(obj.copy()).as<checked::ast_node_block>();
+}
+
+ast_node_block uncheck(checked::ast_node_block obj) {
+	return manage(obj.copy()).as<ast_node_block>();
+}
+
+checked::ast_node_for check(ast_node_for obj) {
+	return checked::manage(obj.copy()).as<checked::ast_node_for>();
+}
+
+ast_node_for uncheck(checked::ast_node_for obj) {
+	return manage(obj.copy()).as<ast_node_for>();
+}
+
+checked::ast_node_if check(ast_node_if obj) {
+	return checked::manage(obj.copy()).as<checked::ast_node_if>();
+}
+
+ast_node_if uncheck(checked::ast_node_if obj) {
+	return manage(obj.copy()).as<ast_node_if>();
+}
+
+checked::ast_node_list check(ast_node_list obj) {
+	return checked::manage(obj.copy());
+}
+
+ast_node_list uncheck(checked::ast_node_list obj) {
+	return manage(obj.copy());
+}
+
+checked::ast_node_mark check(ast_node_mark obj) {
+	return checked::manage(obj.copy()).as<checked::ast_node_mark>();
+}
+
+ast_node_mark uncheck(checked::ast_node_mark obj) {
+	return manage(obj.copy()).as<ast_node_mark>();
+}
+
+checked::ast_node_user check(ast_node_user obj) {
+	return checked::manage(obj.copy()).as<checked::ast_node_user>();
+}
+
+ast_node_user uncheck(checked::ast_node_user obj) {
+	return manage(obj.copy()).as<ast_node_user>();
+}
+
+checked::basic_map check(basic_map obj) {
+	return checked::manage(obj.copy());
+}
+
+basic_map uncheck(checked::basic_map obj) {
+	return manage(obj.copy());
+}
+
+checked::basic_set check(basic_set obj) {
+	return checked::manage(obj.copy());
+}
+
+basic_set uncheck(checked::basic_set obj) {
+	return manage(obj.copy());
+}
+
+checked::fixed_box check(fixed_box obj) {
+	return checked::manage(obj.copy());
+}
+
+fixed_box uncheck(checked::fixed_box obj) {
+	return manage(obj.copy());
+}
+
+checked::id check(id obj) {
+	return checked::manage(obj.copy());
+}
+
+id uncheck(checked::id obj) {
+	return manage(obj.copy());
+}
+
+checked::id_list check(id_list obj) {
+	return checked::manage(obj.copy());
+}
+
+id_list uncheck(checked::id_list obj) {
+	return manage(obj.copy());
+}
+
+checked::map check(map obj) {
+	return checked::manage(obj.copy());
+}
+
+map uncheck(checked::map obj) {
+	return manage(obj.copy());
+}
+
+checked::multi_aff check(multi_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+multi_aff uncheck(checked::multi_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::multi_id check(multi_id obj) {
+	return checked::manage(obj.copy());
+}
+
+multi_id uncheck(checked::multi_id obj) {
+	return manage(obj.copy());
+}
+
+checked::multi_pw_aff check(multi_pw_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+multi_pw_aff uncheck(checked::multi_pw_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::multi_union_pw_aff check(multi_union_pw_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+multi_union_pw_aff uncheck(checked::multi_union_pw_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::multi_val check(multi_val obj) {
+	return checked::manage(obj.copy());
+}
+
+multi_val uncheck(checked::multi_val obj) {
+	return manage(obj.copy());
+}
+
+checked::point check(point obj) {
+	return checked::manage(obj.copy());
+}
+
+point uncheck(checked::point obj) {
+	return manage(obj.copy());
+}
+
+checked::pw_aff check(pw_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+pw_aff uncheck(checked::pw_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::pw_aff_list check(pw_aff_list obj) {
+	return checked::manage(obj.copy());
+}
+
+pw_aff_list uncheck(checked::pw_aff_list obj) {
+	return manage(obj.copy());
+}
+
+checked::pw_multi_aff check(pw_multi_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+pw_multi_aff uncheck(checked::pw_multi_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::pw_multi_aff_list check(pw_multi_aff_list obj) {
+	return checked::manage(obj.copy());
+}
+
+pw_multi_aff_list uncheck(checked::pw_multi_aff_list obj) {
+	return manage(obj.copy());
+}
+
+checked::schedule check(schedule obj) {
+	return checked::manage(obj.copy());
+}
+
+schedule uncheck(checked::schedule obj) {
+	return manage(obj.copy());
+}
+
+checked::schedule_constraints check(schedule_constraints obj) {
+	return checked::manage(obj.copy());
+}
+
+schedule_constraints uncheck(checked::schedule_constraints obj) {
+	return manage(obj.copy());
+}
+
+checked::schedule_node check(schedule_node obj) {
+	return checked::manage(obj.copy());
+}
+
+schedule_node uncheck(checked::schedule_node obj) {
+	return manage(obj.copy());
+}
+
+checked::schedule_node_band check(schedule_node_band obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_band>();
+}
+
+schedule_node_band uncheck(checked::schedule_node_band obj) {
+	return manage(obj.copy()).as<schedule_node_band>();
+}
+
+checked::schedule_node_context check(schedule_node_context obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_context>();
+}
+
+schedule_node_context uncheck(checked::schedule_node_context obj) {
+	return manage(obj.copy()).as<schedule_node_context>();
+}
+
+checked::schedule_node_domain check(schedule_node_domain obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_domain>();
+}
+
+schedule_node_domain uncheck(checked::schedule_node_domain obj) {
+	return manage(obj.copy()).as<schedule_node_domain>();
+}
+
+checked::schedule_node_expansion check(schedule_node_expansion obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_expansion>();
+}
+
+schedule_node_expansion uncheck(checked::schedule_node_expansion obj) {
+	return manage(obj.copy()).as<schedule_node_expansion>();
+}
+
+checked::schedule_node_extension check(schedule_node_extension obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_extension>();
+}
+
+schedule_node_extension uncheck(checked::schedule_node_extension obj) {
+	return manage(obj.copy()).as<schedule_node_extension>();
+}
+
+checked::schedule_node_filter check(schedule_node_filter obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_filter>();
+}
+
+schedule_node_filter uncheck(checked::schedule_node_filter obj) {
+	return manage(obj.copy()).as<schedule_node_filter>();
+}
+
+checked::schedule_node_guard check(schedule_node_guard obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_guard>();
+}
+
+schedule_node_guard uncheck(checked::schedule_node_guard obj) {
+	return manage(obj.copy()).as<schedule_node_guard>();
+}
+
+checked::schedule_node_leaf check(schedule_node_leaf obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_leaf>();
+}
+
+schedule_node_leaf uncheck(checked::schedule_node_leaf obj) {
+	return manage(obj.copy()).as<schedule_node_leaf>();
+}
+
+checked::schedule_node_mark check(schedule_node_mark obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_mark>();
+}
+
+schedule_node_mark uncheck(checked::schedule_node_mark obj) {
+	return manage(obj.copy()).as<schedule_node_mark>();
+}
+
+checked::schedule_node_sequence check(schedule_node_sequence obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_sequence>();
+}
+
+schedule_node_sequence uncheck(checked::schedule_node_sequence obj) {
+	return manage(obj.copy()).as<schedule_node_sequence>();
+}
+
+checked::schedule_node_set check(schedule_node_set obj) {
+	return checked::manage(obj.copy()).as<checked::schedule_node_set>();
+}
+
+schedule_node_set uncheck(checked::schedule_node_set obj) {
+	return manage(obj.copy()).as<schedule_node_set>();
+}
+
+checked::set check(set obj) {
+	return checked::manage(obj.copy());
+}
+
+set uncheck(checked::set obj) {
+	return manage(obj.copy());
+}
+
+checked::space check(space obj) {
+	return checked::manage(obj.copy());
+}
+
+space uncheck(checked::space obj) {
+	return manage(obj.copy());
+}
+
+checked::union_access_info check(union_access_info obj) {
+	return checked::manage(obj.copy());
+}
+
+union_access_info uncheck(checked::union_access_info obj) {
+	return manage(obj.copy());
+}
+
+checked::union_flow check(union_flow obj) {
+	return checked::manage(obj.copy());
+}
+
+union_flow uncheck(checked::union_flow obj) {
+	return manage(obj.copy());
+}
+
+checked::union_map check(union_map obj) {
+	return checked::manage(obj.copy());
+}
+
+union_map uncheck(checked::union_map obj) {
+	return manage(obj.copy());
+}
+
+checked::union_pw_aff check(union_pw_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+union_pw_aff uncheck(checked::union_pw_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::union_pw_aff_list check(union_pw_aff_list obj) {
+	return checked::manage(obj.copy());
+}
+
+union_pw_aff_list uncheck(checked::union_pw_aff_list obj) {
+	return manage(obj.copy());
+}
+
+checked::union_pw_multi_aff check(union_pw_multi_aff obj) {
+	return checked::manage(obj.copy());
+}
+
+union_pw_multi_aff uncheck(checked::union_pw_multi_aff obj) {
+	return manage(obj.copy());
+}
+
+checked::union_set check(union_set obj) {
+	return checked::manage(obj.copy());
+}
+
+union_set uncheck(checked::union_set obj) {
+	return manage(obj.copy());
+}
+
+checked::union_set_list check(union_set_list obj) {
+	return checked::manage(obj.copy());
+}
+
+union_set_list uncheck(checked::union_set_list obj) {
+	return manage(obj.copy());
+}
+
+checked::val check(val obj) {
+	return checked::manage(obj.copy());
+}
+
+val uncheck(checked::val obj) {
+	return manage(obj.copy());
+}
+
+checked::val_list check(val_list obj) {
+	return checked::manage(obj.copy());
+}
+
+val_list uncheck(checked::val_list obj) {
+	return manage(obj.copy());
+}
+
+} // namespace isl
+
+#endif /* ISL_CPP_CHECKED_CONVERSION */

_service:tar_scm:isl-0.24.tar.gz/include/isl/cpp-checked.h Added

@@ -0,0 +1,19142 @@
+/// 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.
+
+#ifndef ISL_CPP_CHECKED
+#define ISL_CPP_CHECKED
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+namespace isl {
+namespace checked {
+
+#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 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) {}
+
+  /* implicit */ boolean(bool val)
+      : val(val ? isl_bool_true : isl_bool_false) {}
+
+  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; }
+
+  explicit operator bool() const {
+    ISLPP_ASSERT(check->checked, "IMPLEMENTATION ERROR: Unchecked error state");
+    ISLPP_ASSERT(!is_error(), "IMPLEMENTATION ERROR: Unhandled error state");
+    return is_true();
+  }
+
+  boolean negate() {
+    if (val == isl_bool_true)
+      val = isl_bool_false;
+    else if (val == isl_bool_false)
+      val = isl_bool_true;
+    return *this;
+  }
+
+  boolean operator!() const {
+    return boolean(*this).negate();
+  }
+};
+
+inline boolean manage(isl_bool val) {
+  return boolean(val);
+}
+
+class ctx {
+  isl_ctx *ptr;
+public:
+  /* implicit */ ctx(isl_ctx *ctx)
+      : ptr(ctx) {}
+  isl_ctx *release() {
+    auto tmp = ptr;
+    ptr = nullptr;
+    return tmp;
+  }
+  isl_ctx *get() {
+    return ptr;
+  }
+};
+
+/* Class encapsulating an isl_stat value.
+ */
+class stat {
+private:
+	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:
+	static stat ok() {
+		return stat(isl_stat_ok);
+	}
+	static stat error() {
+		return stat(isl_stat_error);
+	}
+	stat() : val(isl_stat_error) {}
+
+	isl_stat release() {
+		check->checked = true;
+		return val;
+	}
+
+	bool is_error() const {
+		check->checked = true;
+		return val == isl_stat_error;
+	}
+	bool is_ok() const {
+		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);
+}
+
+}
+} // 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/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>
+
+namespace isl {
+
+namespace checked {
+
+// forward declarations
+class aff;
+class aff_list;
+class ast_build;
+class ast_expr;
+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_set;
+class fixed_box;
+class id;
+class id_list;
+class map;
+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 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 space;
+class union_access_info;
+class union_flow;
+class union_map;
+class union_pw_aff;
+class union_pw_aff_list;
+class union_pw_multi_aff;
+class union_set;
+class union_set_list;
+class val;
+class val_list;
+
+// 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::checked::ctx ctx, const std::string &str);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::aff add(isl::checked::aff aff2) const;
+  inline isl::checked::multi_aff add(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_aff add(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::pw_multi_aff add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff add(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::aff add_constant(isl::checked::val v) const;
+  inline isl::checked::aff add_constant(long v) const;
+  inline isl::checked::multi_aff add_constant(const isl::checked::multi_val &mv) const;
+  inline isl::checked::union_pw_multi_aff apply(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::aff as_aff() const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_aff as_multi_aff() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::aff at(int pos) const;
+  inline isl::checked::basic_set bind(isl::checked::id id) const;
+  inline isl::checked::basic_set bind(const std::string &id) const;
+  inline isl::checked::basic_set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::pw_aff bind_domain(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::pw_aff bind_domain_wrapped_domain(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::aff ceil() const;
+  inline isl::checked::pw_aff coalesce() const;
+  inline isl::checked::pw_aff cond(const isl::checked::pw_aff &pwaff_true, const isl::checked::pw_aff &pwaff_false) const;
+  inline isl::checked::multi_val constant_multi_val() const;
+  inline isl::checked::val constant_val() const;
+  inline isl::checked::val get_constant_val() const;
+  inline isl::checked::aff div(isl::checked::aff aff2) const;
+  inline isl::checked::pw_aff div(const isl::checked::pw_aff &pa2) const;
+  inline isl::checked::set domain() const;
+  inline isl::checked::set eq_set(isl::checked::aff aff2) const;
+  inline isl::checked::set eq_set(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::val eval(isl::checked::point pnt) const;
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(const isl::checked::space &space) const;
+  inline isl::checked::multi_aff flat_range_product(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::aff floor() const;
+  inline stat foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const;
+  inline isl::checked::set ge_set(isl::checked::aff aff2) const;
+  inline isl::checked::set ge_set(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::aff gist(isl::checked::set context) const;
+  inline isl::checked::union_pw_aff gist(const isl::checked::union_set &context) const;
+  inline isl::checked::aff gist(const isl::checked::basic_set &context) const;
+  inline isl::checked::aff gist(const isl::checked::point &context) const;
+  inline isl::checked::set gt_set(isl::checked::aff aff2) const;
+  inline isl::checked::set gt_set(const isl::checked::pw_aff &pwaff2) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_aff identity() const;
+  inline isl::checked::pw_aff insert_domain(const isl::checked::space &domain) const;
+  inline isl::checked::pw_aff intersect_domain(const isl::checked::set &set) const;
+  inline isl::checked::union_pw_aff intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_aff intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_aff intersect_params(const isl::checked::set &set) const;
+  inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::checked::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::checked::id_list &list) const;
+  inline boolean is_cst() const;
+  inline boolean isa_aff() const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::checked::set le_set(isl::checked::aff aff2) const;
+  inline isl::checked::set le_set(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::aff_list list() const;
+  inline isl::checked::set lt_set(isl::checked::aff aff2) const;
+  inline isl::checked::set lt_set(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::multi_pw_aff max(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_aff max(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::multi_val max_multi_val() const;
+  inline isl::checked::multi_pw_aff min(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_aff min(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::multi_val min_multi_val() const;
+  inline isl::checked::aff mod(isl::checked::val mod) const;
+  inline isl::checked::aff mod(long mod) const;
+  inline isl::checked::aff mul(isl::checked::aff aff2) const;
+  inline isl::checked::pw_aff mul(const isl::checked::pw_aff &pwaff2) const;
+  inline class size n_piece() const;
+  inline isl::checked::set ne_set(isl::checked::aff aff2) const;
+  inline isl::checked::set ne_set(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::checked::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff product(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::aff pullback(isl::checked::multi_aff ma) const;
+  inline isl::checked::pw_aff pullback(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::pw_aff pullback(const isl::checked::pw_multi_aff &pma) const;
+  inline isl::checked::union_pw_aff pullback(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::aff pullback(const isl::checked::aff &ma) const;
+  inline isl::checked::pw_multi_aff range_factor_domain() const;
+  inline isl::checked::pw_multi_aff range_factor_range() const;
+  inline isl::checked::multi_aff range_product(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::multi_aff reset_range_tuple_id() const;
+  inline isl::checked::aff scale(isl::checked::val v) const;
+  inline isl::checked::aff scale(long v) const;
+  inline isl::checked::multi_aff scale(const isl::checked::multi_val &mv) const;
+  inline isl::checked::aff scale_down(isl::checked::val v) const;
+  inline isl::checked::aff scale_down(long v) const;
+  inline isl::checked::multi_aff scale_down(const isl::checked::multi_val &mv) const;
+  inline isl::checked::multi_aff set_at(int pos, const isl::checked::aff &el) const;
+  inline isl::checked::multi_pw_aff set_at(int pos, const isl::checked::pw_aff &el) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::multi_aff set_range_tuple(const isl::checked::id &id) const;
+  inline isl::checked::multi_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::aff sub(isl::checked::aff aff2) const;
+  inline isl::checked::multi_aff sub(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_aff sub(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::pw_multi_aff sub(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff sub(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff sub(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_aff subtract_domain(const isl::checked::set &set) const;
+  inline isl::checked::union_pw_aff subtract_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_aff subtract_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_aff tdiv_q(const isl::checked::pw_aff &pa2) const;
+  inline isl::checked::pw_aff tdiv_r(const isl::checked::pw_aff &pa2) const;
+  inline isl::checked::aff_list to_list() const;
+  inline isl::checked::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::checked::multi_union_pw_aff to_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff to_pw_multi_aff() const;
+  inline isl::checked::union_pw_aff to_union_pw_aff() const;
+  inline isl::checked::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::checked::aff unbind_params_insert_domain(isl::checked::multi_id domain) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::pw_aff union_add(const isl::checked::pw_aff &pwaff2) const;
+  inline isl::checked::pw_multi_aff union_add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff union_add(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff union_add(const isl::checked::union_pw_multi_aff &upma2) const;
+  static inline isl::checked::aff zero_on_domain(isl::checked::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::checked::ctx ctx, int n);
+  inline explicit aff_list(isl::checked::aff el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::aff_list add(isl::checked::aff el) const;
+  inline isl::checked::aff at(int index) const;
+  inline isl::checked::aff get_at(int index) const;
+  inline isl::checked::aff_list clear() const;
+  inline isl::checked::aff_list concat(isl::checked::aff_list list2) const;
+  inline isl::checked::aff_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::aff)> &fn) const;
+  inline isl::checked::aff_list insert(unsigned int pos, isl::checked::aff el) 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::checked::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::checked::ctx ctx() const;
+
+private:
+  inline ast_build &copy_callbacks(const ast_build &obj);
+  struct at_each_domain_data {
+    std::function<isl::checked::ast_node(isl::checked::ast_node, isl::checked::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::checked::ast_node(isl::checked::ast_node, isl::checked::ast_build)> &fn);
+public:
+  inline isl::checked::ast_build set_at_each_domain(const std::function<isl::checked::ast_node(isl::checked::ast_node, isl::checked::ast_build)> &fn) const;
+  inline isl::checked::ast_expr access_from(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::ast_expr access_from(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::ast_expr call_from(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::ast_expr call_from(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::ast_expr expr_from(isl::checked::pw_aff pa) const;
+  inline isl::checked::ast_expr expr_from(isl::checked::set set) const;
+  static inline isl::checked::ast_build from_context(isl::checked::set set);
+  inline isl::checked::ast_node node_from(isl::checked::schedule schedule) const;
+  inline isl::checked::ast_node node_from_schedule_map(isl::checked::union_map schedule) const;
+  inline isl::checked::union_map schedule() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline std::string to_C_str() 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::checked::ctx ctx() const;
+
+  inline isl::checked::id id() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::val val() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_expr arg(int pos) const;
+  inline isl::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::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::checked::ctx ctx() 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::checked::ctx ctx() const;
+
+  inline std::string to_C_str() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_node_list children() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_node body() const;
+  inline isl::checked::ast_node get_body() const;
+  inline isl::checked::ast_expr cond() const;
+  inline isl::checked::ast_expr get_cond() const;
+  inline isl::checked::ast_expr inc() const;
+  inline isl::checked::ast_expr get_inc() const;
+  inline isl::checked::ast_expr init() const;
+  inline isl::checked::ast_expr get_init() const;
+  inline boolean is_degenerate() const;
+  inline isl::checked::ast_expr iterator() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_expr cond() const;
+  inline isl::checked::ast_expr get_cond() const;
+  inline isl::checked::ast_node else_node() const;
+  inline isl::checked::ast_node get_else_node() const;
+  inline boolean has_else_node() const;
+  inline isl::checked::ast_node then_node() const;
+  inline isl::checked::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::checked::ctx ctx, int n);
+  inline explicit ast_node_list(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_node_list add(isl::checked::ast_node el) const;
+  inline isl::checked::ast_node at(int index) const;
+  inline isl::checked::ast_node get_at(int index) const;
+  inline isl::checked::ast_node_list clear() const;
+  inline isl::checked::ast_node_list concat(isl::checked::ast_node_list list2) const;
+  inline isl::checked::ast_node_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::ast_node)> &fn) const;
+  inline isl::checked::ast_node_list insert(unsigned int pos, isl::checked::ast_node el) 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::checked::ctx ctx() const;
+
+  inline isl::checked::id id() const;
+  inline isl::checked::id get_id() const;
+  inline isl::checked::ast_node node() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::ast_expr expr() const;
+  inline isl::checked::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::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::basic_map affine_hull() const;
+  inline isl::checked::basic_map apply_domain(isl::checked::basic_map bmap2) const;
+  inline isl::checked::map apply_domain(const isl::checked::map &map2) const;
+  inline isl::checked::union_map apply_domain(const isl::checked::union_map &umap2) const;
+  inline isl::checked::basic_map apply_range(isl::checked::basic_map bmap2) const;
+  inline isl::checked::map apply_range(const isl::checked::map &map2) const;
+  inline isl::checked::union_map apply_range(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::union_pw_multi_aff as_union_pw_multi_aff() const;
+  inline isl::checked::set bind_domain(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::set bind_range(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::map coalesce() const;
+  inline isl::checked::map complement() const;
+  inline isl::checked::union_map compute_divs() const;
+  inline isl::checked::map curry() const;
+  inline isl::checked::basic_set deltas() const;
+  inline isl::checked::basic_map detect_equalities() const;
+  inline isl::checked::set domain() const;
+  inline isl::checked::map domain_factor_domain() const;
+  inline isl::checked::map domain_factor_range() const;
+  inline isl::checked::union_map domain_map() const;
+  inline isl::checked::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
+  inline isl::checked::map domain_product(const isl::checked::map &map2) const;
+  inline isl::checked::union_map domain_product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::id domain_tuple_id() const;
+  inline isl::checked::map eq_at(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::union_map eq_at(const isl::checked::multi_union_pw_aff &mupa) const;
+  inline boolean every_map(const std::function<boolean(isl::checked::map)> &test) const;
+  inline isl::checked::map extract_map(const isl::checked::space &space) const;
+  inline isl::checked::map factor_domain() const;
+  inline isl::checked::map factor_range() const;
+  inline isl::checked::union_map fixed_power(const isl::checked::val &exp) const;
+  inline isl::checked::union_map fixed_power(long exp) const;
+  inline isl::checked::basic_map flatten() const;
+  inline isl::checked::basic_map flatten_domain() const;
+  inline isl::checked::basic_map flatten_range() const;
+  inline stat foreach_basic_map(const std::function<stat(isl::checked::basic_map)> &fn) const;
+  inline stat foreach_map(const std::function<stat(isl::checked::map)> &fn) const;
+  inline isl::checked::basic_map gist(isl::checked::basic_map context) const;
+  inline isl::checked::map gist(const isl::checked::map &context) const;
+  inline isl::checked::union_map gist(const isl::checked::union_map &context) const;
+  inline isl::checked::map gist_domain(const isl::checked::set &context) const;
+  inline isl::checked::union_map gist_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_map gist_params(const isl::checked::set &set) const;
+  inline isl::checked::union_map gist_range(const isl::checked::union_set &uset) const;
+  inline boolean has_domain_tuple_id() const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::basic_map intersect(isl::checked::basic_map bmap2) const;
+  inline isl::checked::map intersect(const isl::checked::map &map2) const;
+  inline isl::checked::union_map intersect(const isl::checked::union_map &umap2) const;
+  inline isl::checked::basic_map intersect_domain(isl::checked::basic_set bset) const;
+  inline isl::checked::map intersect_domain(const isl::checked::set &set) const;
+  inline isl::checked::union_map intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_map intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::basic_map intersect_domain(const isl::checked::point &bset) const;
+  inline isl::checked::map intersect_domain_factor_domain(const isl::checked::map &factor) const;
+  inline isl::checked::union_map intersect_domain_factor_domain(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_domain_factor_range(const isl::checked::map &factor) const;
+  inline isl::checked::union_map intersect_domain_factor_range(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_params(const isl::checked::set &params) const;
+  inline isl::checked::basic_map intersect_range(isl::checked::basic_set bset) const;
+  inline isl::checked::map intersect_range(const isl::checked::set &set) const;
+  inline isl::checked::union_map intersect_range(const isl::checked::space &space) const;
+  inline isl::checked::union_map intersect_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::basic_map intersect_range(const isl::checked::point &bset) const;
+  inline isl::checked::map intersect_range_factor_domain(const isl::checked::map &factor) const;
+  inline isl::checked::union_map intersect_range_factor_domain(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_range_factor_range(const isl::checked::map &factor) const;
+  inline isl::checked::union_map intersect_range_factor_range(const isl::checked::union_map &factor) const;
+  inline boolean is_bijective() const;
+  inline boolean is_disjoint(const isl::checked::map &map2) const;
+  inline boolean is_disjoint(const isl::checked::union_map &umap2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::basic_map &bmap2) const;
+  inline boolean is_equal(const isl::checked::map &map2) const;
+  inline boolean is_equal(const isl::checked::union_map &umap2) const;
+  inline boolean is_injective() const;
+  inline boolean is_single_valued() const;
+  inline boolean is_strict_subset(const isl::checked::map &map2) const;
+  inline boolean is_strict_subset(const isl::checked::union_map &umap2) const;
+  inline boolean is_subset(const isl::checked::basic_map &bmap2) const;
+  inline boolean is_subset(const isl::checked::map &map2) const;
+  inline boolean is_subset(const isl::checked::union_map &umap2) const;
+  inline boolean isa_map() const;
+  inline isl::checked::map lex_ge_at(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::map lex_gt_at(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::map lex_le_at(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::map lex_lt_at(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::map lexmax() const;
+  inline isl::checked::pw_multi_aff lexmax_pw_multi_aff() const;
+  inline isl::checked::map lexmin() const;
+  inline isl::checked::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::checked::map lower_bound(const isl::checked::multi_pw_aff &lower) const;
+  inline isl::checked::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::checked::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::checked::basic_map polyhedral_hull() const;
+  inline isl::checked::map preimage_domain(const isl::checked::multi_aff &ma) const;
+  inline isl::checked::map preimage_domain(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::map preimage_domain(const isl::checked::pw_multi_aff &pma) const;
+  inline isl::checked::union_map preimage_domain(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::map preimage_range(const isl::checked::multi_aff &ma) const;
+  inline isl::checked::map preimage_range(const isl::checked::pw_multi_aff &pma) const;
+  inline isl::checked::union_map preimage_range(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::map product(const isl::checked::map &map2) const;
+  inline isl::checked::union_map product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map project_out_all_params() const;
+  inline isl::checked::set range() const;
+  inline isl::checked::map range_factor_domain() const;
+  inline isl::checked::map range_factor_range() const;
+  inline isl::checked::union_map range_map() const;
+  inline isl::checked::map range_product(const isl::checked::map &map2) const;
+  inline isl::checked::union_map range_product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map range_reverse() const;
+  inline isl::checked::fixed_box range_simple_fixed_box_hull() const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::basic_map reverse() const;
+  inline isl::checked::basic_map sample() const;
+  inline isl::checked::map set_domain_tuple(const isl::checked::id &id) const;
+  inline isl::checked::map set_domain_tuple(const std::string &id) const;
+  inline isl::checked::map set_range_tuple(const isl::checked::id &id) const;
+  inline isl::checked::map set_range_tuple(const std::string &id) const;
+  inline isl::checked::space space() const;
+  inline isl::checked::map subtract(const isl::checked::map &map2) const;
+  inline isl::checked::union_map subtract(const isl::checked::union_map &umap2) const;
+  inline isl::checked::union_map subtract_domain(const isl::checked::union_set &dom) const;
+  inline isl::checked::union_map subtract_range(const isl::checked::union_set &dom) const;
+  inline isl::checked::union_map to_union_map() const;
+  inline isl::checked::map uncurry() const;
+  inline isl::checked::map unite(isl::checked::basic_map bmap2) const;
+  inline isl::checked::map unite(const isl::checked::map &map2) const;
+  inline isl::checked::union_map unite(const isl::checked::union_map &umap2) const;
+  inline isl::checked::basic_map unshifted_simple_hull() const;
+  inline isl::checked::map upper_bound(const isl::checked::multi_pw_aff &upper) const;
+  inline isl::checked::set wrap() const;
+  inline isl::checked::map zip() 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::checked::point pnt);
+  inline explicit basic_set(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::basic_set affine_hull() const;
+  inline isl::checked::basic_set apply(isl::checked::basic_map bmap) const;
+  inline isl::checked::set apply(const isl::checked::map &map) const;
+  inline isl::checked::union_set apply(const isl::checked::union_map &umap) const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::set coalesce() const;
+  inline isl::checked::set complement() const;
+  inline isl::checked::union_set compute_divs() const;
+  inline isl::checked::basic_set detect_equalities() const;
+  inline isl::checked::val dim_max_val(int pos) const;
+  inline isl::checked::val dim_min_val(int pos) const;
+  inline boolean every_set(const std::function<boolean(isl::checked::set)> &test) const;
+  inline isl::checked::set extract_set(const isl::checked::space &space) const;
+  inline isl::checked::basic_set flatten() const;
+  inline stat foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::checked::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::checked::set)> &fn) const;
+  inline isl::checked::basic_set gist(isl::checked::basic_set context) const;
+  inline isl::checked::set gist(const isl::checked::set &context) const;
+  inline isl::checked::union_set gist(const isl::checked::union_set &context) const;
+  inline isl::checked::basic_set gist(const isl::checked::point &context) const;
+  inline isl::checked::union_set gist_params(const isl::checked::set &set) const;
+  inline isl::checked::map identity() const;
+  inline isl::checked::pw_aff indicator_function() const;
+  inline isl::checked::map insert_domain(const isl::checked::space &domain) const;
+  inline isl::checked::basic_set intersect(isl::checked::basic_set bset2) const;
+  inline isl::checked::set intersect(const isl::checked::set &set2) const;
+  inline isl::checked::union_set intersect(const isl::checked::union_set &uset2) const;
+  inline isl::checked::basic_set intersect(const isl::checked::point &bset2) const;
+  inline isl::checked::basic_set intersect_params(isl::checked::basic_set bset2) const;
+  inline isl::checked::set intersect_params(const isl::checked::set &params) const;
+  inline isl::checked::basic_set intersect_params(const isl::checked::point &bset2) const;
+  inline boolean involves_locals() const;
+  inline boolean is_disjoint(const isl::checked::set &set2) const;
+  inline boolean is_disjoint(const isl::checked::union_set &uset2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::basic_set &bset2) const;
+  inline boolean is_equal(const isl::checked::set &set2) const;
+  inline boolean is_equal(const isl::checked::union_set &uset2) const;
+  inline boolean is_equal(const isl::checked::point &bset2) const;
+  inline boolean is_singleton() const;
+  inline boolean is_strict_subset(const isl::checked::set &set2) const;
+  inline boolean is_strict_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_subset(const isl::checked::basic_set &bset2) const;
+  inline boolean is_subset(const isl::checked::set &set2) const;
+  inline boolean is_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_subset(const isl::checked::point &bset2) const;
+  inline boolean is_wrapping() const;
+  inline boolean isa_set() const;
+  inline isl::checked::set lexmax() const;
+  inline isl::checked::pw_multi_aff lexmax_pw_multi_aff() const;
+  inline isl::checked::set lexmin() const;
+  inline isl::checked::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::checked::set lower_bound(const isl::checked::multi_pw_aff &lower) const;
+  inline isl::checked::set lower_bound(const isl::checked::multi_val &lower) const;
+  inline isl::checked::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::checked::val max_val(const isl::checked::aff &obj) const;
+  inline isl::checked::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::checked::val min_val(const isl::checked::aff &obj) const;
+  inline isl::checked::basic_set params() const;
+  inline isl::checked::multi_val plain_multi_val_if_fixed() const;
+  inline isl::checked::basic_set polyhedral_hull() const;
+  inline isl::checked::set preimage(const isl::checked::multi_aff &ma) const;
+  inline isl::checked::set preimage(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::set preimage(const isl::checked::pw_multi_aff &pma) const;
+  inline isl::checked::union_set preimage(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::set product(const isl::checked::set &set2) const;
+  inline isl::checked::set project_out_all_params() const;
+  inline isl::checked::set project_out_param(const isl::checked::id &id) const;
+  inline isl::checked::set project_out_param(const std::string &id) const;
+  inline isl::checked::set project_out_param(const isl::checked::id_list &list) const;
+  inline isl::checked::pw_multi_aff pw_multi_aff_on_domain(const isl::checked::multi_val &mv) const;
+  inline isl::checked::basic_set sample() const;
+  inline isl::checked::point sample_point() const;
+  inline isl::checked::fixed_box simple_fixed_box_hull() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::val stride(int pos) const;
+  inline isl::checked::set subtract(const isl::checked::set &set2) const;
+  inline isl::checked::union_set subtract(const isl::checked::union_set &uset2) const;
+  inline isl::checked::union_set_list to_list() const;
+  inline isl::checked::set to_set() const;
+  inline isl::checked::union_set to_union_set() const;
+  inline isl::checked::map translation() const;
+  inline isl::checked::set unbind_params(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::map unbind_params_insert_domain(const isl::checked::multi_id &domain) const;
+  inline isl::checked::set unite(isl::checked::basic_set bset2) const;
+  inline isl::checked::set unite(const isl::checked::set &set2) const;
+  inline isl::checked::union_set unite(const isl::checked::union_set &uset2) const;
+  inline isl::checked::set unite(const isl::checked::point &bset2) const;
+  inline isl::checked::basic_set unshifted_simple_hull() const;
+  inline isl::checked::map unwrap() const;
+  inline isl::checked::set upper_bound(const isl::checked::multi_pw_aff &upper) const;
+  inline isl::checked::set upper_bound(const isl::checked::multi_val &upper) 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::checked::ctx ctx() const;
+
+  inline boolean is_valid() const;
+  inline isl::checked::multi_aff offset() const;
+  inline isl::checked::multi_aff get_offset() const;
+  inline isl::checked::multi_val size() const;
+  inline isl::checked::multi_val get_size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() 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::checked::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::checked::ctx ctx() const;
+
+  inline std::string name() const;
+  inline std::string get_name() const;
+  inline isl::checked::id_list to_list() 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::checked::ctx ctx, int n);
+  inline explicit id_list(isl::checked::id el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::id_list add(isl::checked::id el) const;
+  inline isl::checked::id_list add(const std::string &el) const;
+  inline isl::checked::id at(int index) const;
+  inline isl::checked::id get_at(int index) const;
+  inline isl::checked::id_list clear() const;
+  inline isl::checked::id_list concat(isl::checked::id_list list2) const;
+  inline isl::checked::id_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::id)> &fn) const;
+  inline isl::checked::id_list insert(unsigned int pos, isl::checked::id el) const;
+  inline isl::checked::id_list insert(unsigned int pos, const std::string &el) const;
+  inline class size size() 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::checked::basic_map bmap);
+  inline explicit map(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::basic_map affine_hull() const;
+  inline isl::checked::map apply_domain(isl::checked::map map2) const;
+  inline isl::checked::union_map apply_domain(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map apply_domain(const isl::checked::basic_map &map2) const;
+  inline isl::checked::map apply_range(isl::checked::map map2) const;
+  inline isl::checked::union_map apply_range(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map apply_range(const isl::checked::basic_map &map2) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::union_pw_multi_aff as_union_pw_multi_aff() const;
+  inline isl::checked::set bind_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::set bind_range(isl::checked::multi_id tuple) const;
+  inline isl::checked::map coalesce() const;
+  inline isl::checked::map complement() const;
+  inline isl::checked::union_map compute_divs() const;
+  inline isl::checked::map curry() const;
+  inline isl::checked::set deltas() const;
+  inline isl::checked::map detect_equalities() const;
+  inline isl::checked::set domain() const;
+  inline isl::checked::map domain_factor_domain() const;
+  inline isl::checked::map domain_factor_range() const;
+  inline isl::checked::union_map domain_map() const;
+  inline isl::checked::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
+  inline isl::checked::map domain_product(isl::checked::map map2) const;
+  inline isl::checked::union_map domain_product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map domain_product(const isl::checked::basic_map &map2) const;
+  inline isl::checked::id domain_tuple_id() const;
+  inline isl::checked::id get_domain_tuple_id() const;
+  static inline isl::checked::map empty(isl::checked::space space);
+  inline isl::checked::map eq_at(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::union_map eq_at(const isl::checked::multi_union_pw_aff &mupa) const;
+  inline isl::checked::map eq_at(const isl::checked::aff &mpa) const;
+  inline isl::checked::map eq_at(const isl::checked::multi_aff &mpa) const;
+  inline isl::checked::map eq_at(const isl::checked::pw_aff &mpa) const;
+  inline isl::checked::map eq_at(const isl::checked::pw_multi_aff &mpa) const;
+  inline boolean every_map(const std::function<boolean(isl::checked::map)> &test) const;
+  inline isl::checked::map extract_map(const isl::checked::space &space) const;
+  inline isl::checked::map factor_domain() const;
+  inline isl::checked::map factor_range() const;
+  inline isl::checked::union_map fixed_power(const isl::checked::val &exp) const;
+  inline isl::checked::union_map fixed_power(long exp) const;
+  inline isl::checked::map flatten() const;
+  inline isl::checked::map flatten_domain() const;
+  inline isl::checked::map flatten_range() const;
+  inline stat foreach_basic_map(const std::function<stat(isl::checked::basic_map)> &fn) const;
+  inline stat foreach_map(const std::function<stat(isl::checked::map)> &fn) const;
+  inline isl::checked::map gist(isl::checked::map context) const;
+  inline isl::checked::union_map gist(const isl::checked::union_map &context) const;
+  inline isl::checked::map gist(const isl::checked::basic_map &context) const;
+  inline isl::checked::map gist_domain(isl::checked::set context) const;
+  inline isl::checked::union_map gist_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::map gist_domain(const isl::checked::basic_set &context) const;
+  inline isl::checked::map gist_domain(const isl::checked::point &context) const;
+  inline isl::checked::union_map gist_params(const isl::checked::set &set) const;
+  inline isl::checked::union_map gist_range(const isl::checked::union_set &uset) const;
+  inline boolean has_domain_tuple_id() const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::map intersect(isl::checked::map map2) const;
+  inline isl::checked::union_map intersect(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map intersect(const isl::checked::basic_map &map2) const;
+  inline isl::checked::map intersect_domain(isl::checked::set set) const;
+  inline isl::checked::union_map intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_map intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::map intersect_domain(const isl::checked::basic_set &set) const;
+  inline isl::checked::map intersect_domain(const isl::checked::point &set) const;
+  inline isl::checked::map intersect_domain_factor_domain(isl::checked::map factor) const;
+  inline isl::checked::union_map intersect_domain_factor_domain(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_domain_factor_domain(const isl::checked::basic_map &factor) const;
+  inline isl::checked::map intersect_domain_factor_range(isl::checked::map factor) const;
+  inline isl::checked::union_map intersect_domain_factor_range(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_domain_factor_range(const isl::checked::basic_map &factor) const;
+  inline isl::checked::map intersect_params(isl::checked::set params) const;
+  inline isl::checked::map intersect_range(isl::checked::set set) const;
+  inline isl::checked::union_map intersect_range(const isl::checked::space &space) const;
+  inline isl::checked::union_map intersect_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::map intersect_range(const isl::checked::basic_set &set) const;
+  inline isl::checked::map intersect_range(const isl::checked::point &set) const;
+  inline isl::checked::map intersect_range_factor_domain(isl::checked::map factor) const;
+  inline isl::checked::union_map intersect_range_factor_domain(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_range_factor_domain(const isl::checked::basic_map &factor) const;
+  inline isl::checked::map intersect_range_factor_range(isl::checked::map factor) const;
+  inline isl::checked::union_map intersect_range_factor_range(const isl::checked::union_map &factor) const;
+  inline isl::checked::map intersect_range_factor_range(const isl::checked::basic_map &factor) const;
+  inline boolean is_bijective() const;
+  inline boolean is_disjoint(const isl::checked::map &map2) const;
+  inline boolean is_disjoint(const isl::checked::union_map &umap2) const;
+  inline boolean is_disjoint(const isl::checked::basic_map &map2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::map &map2) const;
+  inline boolean is_equal(const isl::checked::union_map &umap2) const;
+  inline boolean is_equal(const isl::checked::basic_map &map2) const;
+  inline boolean is_injective() const;
+  inline boolean is_single_valued() const;
+  inline boolean is_strict_subset(const isl::checked::map &map2) const;
+  inline boolean is_strict_subset(const isl::checked::union_map &umap2) const;
+  inline boolean is_strict_subset(const isl::checked::basic_map &map2) const;
+  inline boolean is_subset(const isl::checked::map &map2) const;
+  inline boolean is_subset(const isl::checked::union_map &umap2) const;
+  inline boolean is_subset(const isl::checked::basic_map &map2) const;
+  inline boolean isa_map() const;
+  inline isl::checked::map lex_ge_at(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::map lex_gt_at(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::map lex_le_at(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::map lex_lt_at(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::map lexmax() const;
+  inline isl::checked::pw_multi_aff lexmax_pw_multi_aff() const;
+  inline isl::checked::map lexmin() const;
+  inline isl::checked::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::checked::map lower_bound(isl::checked::multi_pw_aff lower) const;
+  inline isl::checked::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::checked::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::checked::basic_map polyhedral_hull() const;
+  inline isl::checked::map preimage_domain(isl::checked::multi_aff ma) const;
+  inline isl::checked::map preimage_domain(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::map preimage_domain(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_map preimage_domain(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::map preimage_range(isl::checked::multi_aff ma) const;
+  inline isl::checked::map preimage_range(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_map preimage_range(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::map product(isl::checked::map map2) const;
+  inline isl::checked::union_map product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map product(const isl::checked::basic_map &map2) const;
+  inline isl::checked::map project_out_all_params() const;
+  inline isl::checked::set range() const;
+  inline isl::checked::map range_factor_domain() const;
+  inline isl::checked::map range_factor_range() const;
+  inline isl::checked::union_map range_map() const;
+  inline isl::checked::map range_product(isl::checked::map map2) const;
+  inline isl::checked::union_map range_product(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map range_product(const isl::checked::basic_map &map2) const;
+  inline isl::checked::map range_reverse() const;
+  inline isl::checked::fixed_box range_simple_fixed_box_hull() const;
+  inline isl::checked::fixed_box get_range_simple_fixed_box_hull() const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::map reverse() const;
+  inline isl::checked::basic_map sample() const;
+  inline isl::checked::map set_domain_tuple(isl::checked::id id) const;
+  inline isl::checked::map set_domain_tuple(const std::string &id) const;
+  inline isl::checked::map set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::map set_range_tuple(const std::string &id) const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::map subtract(isl::checked::map map2) const;
+  inline isl::checked::union_map subtract(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map subtract(const isl::checked::basic_map &map2) const;
+  inline isl::checked::union_map subtract_domain(const isl::checked::union_set &dom) const;
+  inline isl::checked::union_map subtract_range(const isl::checked::union_set &dom) const;
+  inline isl::checked::union_map to_union_map() const;
+  inline isl::checked::map uncurry() const;
+  inline isl::checked::map unite(isl::checked::map map2) const;
+  inline isl::checked::union_map unite(const isl::checked::union_map &umap2) const;
+  inline isl::checked::map unite(const isl::checked::basic_map &map2) const;
+  static inline isl::checked::map universe(isl::checked::space space);
+  inline isl::checked::basic_map unshifted_simple_hull() const;
+  inline isl::checked::map upper_bound(isl::checked::multi_pw_aff upper) const;
+  inline isl::checked::set wrap() const;
+  inline isl::checked::map zip() 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::checked::aff aff);
+  inline explicit multi_aff(isl::checked::space space, isl::checked::aff_list list);
+  inline explicit multi_aff(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_aff add(isl::checked::multi_aff multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff add(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_aff add_constant(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_aff add_constant(isl::checked::val v) const;
+  inline isl::checked::multi_aff add_constant(long v) const;
+  inline isl::checked::union_pw_multi_aff apply(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_aff as_multi_aff() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::aff at(int pos) const;
+  inline isl::checked::aff get_at(int pos) const;
+  inline isl::checked::basic_set bind(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_aff bind_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_aff bind_domain_wrapped_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::pw_multi_aff coalesce() const;
+  inline isl::checked::multi_val constant_multi_val() const;
+  inline isl::checked::multi_val get_constant_multi_val() const;
+  inline isl::checked::set domain() const;
+  static inline isl::checked::multi_aff domain_map(isl::checked::space space);
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(const isl::checked::space &space) const;
+  inline isl::checked::multi_aff flat_range_product(isl::checked::multi_aff multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff flat_range_product(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_aff floor() const;
+  inline stat foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const;
+  inline isl::checked::multi_aff gist(isl::checked::set context) const;
+  inline isl::checked::union_pw_multi_aff gist(const isl::checked::union_set &context) const;
+  inline isl::checked::multi_aff gist(const isl::checked::basic_set &context) const;
+  inline isl::checked::multi_aff gist(const isl::checked::point &context) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_aff identity() const;
+  static inline isl::checked::multi_aff identity_on_domain(isl::checked::space space);
+  inline isl::checked::multi_aff insert_domain(isl::checked::space domain) const;
+  inline isl::checked::pw_multi_aff intersect_domain(const isl::checked::set &set) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_multi_aff intersect_params(const isl::checked::set &set) const;
+  inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::checked::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::checked::id_list &list) const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::checked::aff_list list() const;
+  inline isl::checked::aff_list get_list() const;
+  inline isl::checked::multi_pw_aff max(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_val max_multi_val() const;
+  inline isl::checked::multi_pw_aff min(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_val min_multi_val() const;
+  static inline isl::checked::multi_aff multi_val_on_domain(isl::checked::space space, isl::checked::multi_val mv);
+  inline class size n_piece() const;
+  inline isl::checked::multi_aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::checked::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::aff &multi2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff product(isl::checked::multi_aff multi2) const;
+  inline isl::checked::multi_pw_aff product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::multi_aff product(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_aff pullback(isl::checked::multi_aff ma2) const;
+  inline isl::checked::multi_pw_aff pullback(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::pw_multi_aff pullback(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff pullback(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff pullback(const isl::checked::aff &ma2) const;
+  inline isl::checked::pw_multi_aff range_factor_domain() const;
+  inline isl::checked::pw_multi_aff range_factor_range() const;
+  static inline isl::checked::multi_aff range_map(isl::checked::space space);
+  inline isl::checked::multi_aff range_product(isl::checked::multi_aff multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff range_product(const isl::checked::aff &multi2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::multi_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_aff scale(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_aff scale(isl::checked::val v) const;
+  inline isl::checked::multi_aff scale(long v) const;
+  inline isl::checked::multi_aff scale_down(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_aff scale_down(isl::checked::val v) const;
+  inline isl::checked::multi_aff scale_down(long v) const;
+  inline isl::checked::multi_aff set_at(int pos, isl::checked::aff el) const;
+  inline isl::checked::multi_pw_aff set_at(int pos, const isl::checked::pw_aff &el) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::multi_aff set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::multi_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_aff sub(isl::checked::multi_aff multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff sub(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff sub(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_aff sub(const isl::checked::aff &multi2) const;
+  inline isl::checked::pw_multi_aff subtract_domain(const isl::checked::set &set) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_multi_aff_list to_list() const;
+  inline isl::checked::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::checked::multi_union_pw_aff to_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff to_pw_multi_aff() const;
+  inline isl::checked::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::checked::multi_aff unbind_params_insert_domain(isl::checked::multi_id domain) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::pw_multi_aff union_add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff union_add(const isl::checked::union_pw_multi_aff &upma2) const;
+  static inline isl::checked::multi_aff zero(isl::checked::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::checked::space space, isl::checked::id_list list);
+  inline explicit multi_id(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::id at(int pos) const;
+  inline isl::checked::id get_at(int pos) const;
+  inline isl::checked::multi_id flat_range_product(isl::checked::multi_id multi2) const;
+  inline isl::checked::id_list list() const;
+  inline isl::checked::id_list get_list() const;
+  inline boolean plain_is_equal(const isl::checked::multi_id &multi2) const;
+  inline isl::checked::multi_id range_product(isl::checked::multi_id multi2) const;
+  inline isl::checked::multi_id set_at(int pos, isl::checked::id el) const;
+  inline isl::checked::multi_id set_at(int pos, const std::string &el) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::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::checked::aff aff);
+  inline /* implicit */ multi_pw_aff(isl::checked::multi_aff ma);
+  inline /* implicit */ multi_pw_aff(isl::checked::pw_aff pa);
+  inline explicit multi_pw_aff(isl::checked::space space, isl::checked::pw_aff_list list);
+  inline /* implicit */ multi_pw_aff(isl::checked::pw_multi_aff pma);
+  inline explicit multi_pw_aff(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_pw_aff add(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff add(const isl::checked::pw_multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff add_constant(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_pw_aff add_constant(isl::checked::val v) const;
+  inline isl::checked::multi_pw_aff add_constant(long v) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::pw_aff at(int pos) const;
+  inline isl::checked::pw_aff get_at(int pos) const;
+  inline isl::checked::set bind(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_pw_aff bind_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_pw_aff bind_domain_wrapped_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_pw_aff coalesce() const;
+  inline isl::checked::set domain() const;
+  inline isl::checked::multi_pw_aff flat_range_product(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::pw_multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff gist(isl::checked::set set) const;
+  inline isl::checked::multi_union_pw_aff gist(const isl::checked::union_set &context) const;
+  inline isl::checked::multi_pw_aff gist(const isl::checked::basic_set &set) const;
+  inline isl::checked::multi_pw_aff gist(const isl::checked::point &set) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff identity() const;
+  static inline isl::checked::multi_pw_aff identity_on_domain(isl::checked::space space);
+  inline isl::checked::multi_pw_aff insert_domain(isl::checked::space domain) const;
+  inline isl::checked::multi_pw_aff intersect_domain(isl::checked::set domain) const;
+  inline isl::checked::multi_union_pw_aff intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::multi_pw_aff intersect_domain(const isl::checked::basic_set &domain) const;
+  inline isl::checked::multi_pw_aff intersect_domain(const isl::checked::point &domain) const;
+  inline isl::checked::multi_pw_aff intersect_params(isl::checked::set set) const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::checked::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::checked::id_list &list) const;
+  inline isl::checked::pw_aff_list list() const;
+  inline isl::checked::pw_aff_list get_list() const;
+  inline isl::checked::multi_pw_aff max(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_val max_multi_val() const;
+  inline isl::checked::multi_pw_aff min(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_val min_multi_val() const;
+  inline isl::checked::multi_pw_aff neg() const;
+  inline boolean plain_is_equal(const isl::checked::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::pw_multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff product(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_pw_aff pullback(isl::checked::multi_aff ma) const;
+  inline isl::checked::multi_pw_aff pullback(isl::checked::multi_pw_aff mpa2) const;
+  inline isl::checked::multi_pw_aff pullback(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::multi_union_pw_aff pullback(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::multi_pw_aff range_product(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::pw_multi_aff &multi2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff scale(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_pw_aff scale(isl::checked::val v) const;
+  inline isl::checked::multi_pw_aff scale(long v) const;
+  inline isl::checked::multi_pw_aff scale_down(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_pw_aff scale_down(isl::checked::val v) const;
+  inline isl::checked::multi_pw_aff scale_down(long v) const;
+  inline isl::checked::multi_pw_aff set_at(int pos, isl::checked::pw_aff el) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::multi_pw_aff set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::multi_pw_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_pw_aff sub(isl::checked::multi_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::aff &multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::pw_aff &multi2) const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::pw_multi_aff &multi2) const;
+  inline isl::checked::multi_pw_aff unbind_params_insert_domain(isl::checked::multi_id domain) const;
+  inline isl::checked::multi_pw_aff union_add(isl::checked::multi_pw_aff mpa2) const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::aff &mpa2) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::multi_aff &mpa2) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::pw_aff &mpa2) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::pw_multi_aff &mpa2) const;
+  static inline isl::checked::multi_pw_aff zero(isl::checked::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::checked::multi_pw_aff mpa);
+  inline /* implicit */ multi_union_pw_aff(isl::checked::union_pw_aff upa);
+  inline explicit multi_union_pw_aff(isl::checked::space space, isl::checked::union_pw_aff_list list);
+  inline explicit multi_union_pw_aff(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_union_pw_aff add(isl::checked::multi_union_pw_aff multi2) const;
+  inline isl::checked::union_pw_aff at(int pos) const;
+  inline isl::checked::union_pw_aff get_at(int pos) const;
+  inline isl::checked::union_set bind(isl::checked::multi_id tuple) const;
+  inline isl::checked::multi_union_pw_aff coalesce() const;
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(isl::checked::multi_union_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff gist(isl::checked::union_set context) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_union_pw_aff intersect_domain(isl::checked::union_set uset) const;
+  inline isl::checked::multi_union_pw_aff intersect_params(isl::checked::set params) const;
+  inline boolean involves_nan() const;
+  inline isl::checked::union_pw_aff_list list() const;
+  inline isl::checked::union_pw_aff_list get_list() const;
+  inline isl::checked::multi_union_pw_aff neg() const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff pullback(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::multi_union_pw_aff range_product(isl::checked::multi_union_pw_aff multi2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::multi_union_pw_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_union_pw_aff scale(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_union_pw_aff scale(isl::checked::val v) const;
+  inline isl::checked::multi_union_pw_aff scale(long v) const;
+  inline isl::checked::multi_union_pw_aff scale_down(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_union_pw_aff scale_down(isl::checked::val v) const;
+  inline isl::checked::multi_union_pw_aff scale_down(long v) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, isl::checked::union_pw_aff el) const;
+  inline isl::checked::multi_union_pw_aff set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::multi_union_pw_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_union_pw_aff sub(isl::checked::multi_union_pw_aff multi2) const;
+  inline isl::checked::multi_union_pw_aff union_add(isl::checked::multi_union_pw_aff mupa2) const;
+  static inline isl::checked::multi_union_pw_aff zero(isl::checked::space space);
+};
+
+// 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::checked::space space, isl::checked::val_list list);
+  inline explicit multi_val(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_val add(isl::checked::multi_val multi2) const;
+  inline isl::checked::multi_val add(isl::checked::val v) const;
+  inline isl::checked::multi_val add(long v) const;
+  inline isl::checked::val at(int pos) const;
+  inline isl::checked::val get_at(int pos) const;
+  inline isl::checked::multi_val flat_range_product(isl::checked::multi_val multi2) const;
+  inline boolean has_range_tuple_id() const;
+  inline boolean involves_nan() const;
+  inline isl::checked::val_list list() const;
+  inline isl::checked::val_list get_list() const;
+  inline isl::checked::multi_val max(isl::checked::multi_val multi2) const;
+  inline isl::checked::multi_val min(isl::checked::multi_val multi2) const;
+  inline isl::checked::multi_val neg() const;
+  inline boolean plain_is_equal(const isl::checked::multi_val &multi2) const;
+  inline isl::checked::multi_val product(isl::checked::multi_val multi2) const;
+  inline isl::checked::multi_val range_product(isl::checked::multi_val multi2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::multi_val reset_range_tuple_id() const;
+  inline isl::checked::multi_val scale(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_val scale(isl::checked::val v) const;
+  inline isl::checked::multi_val scale(long v) const;
+  inline isl::checked::multi_val scale_down(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_val scale_down(isl::checked::val v) const;
+  inline isl::checked::multi_val scale_down(long v) const;
+  inline isl::checked::multi_val set_at(int pos, isl::checked::val el) const;
+  inline isl::checked::multi_val set_at(int pos, long el) const;
+  inline isl::checked::multi_val set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::multi_val set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_val sub(isl::checked::multi_val multi2) const;
+  static inline isl::checked::multi_val zero(isl::checked::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 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::checked::ctx ctx() const;
+
+  inline isl::checked::basic_set affine_hull() const;
+  inline isl::checked::basic_set apply(const isl::checked::basic_map &bmap) const;
+  inline isl::checked::set apply(const isl::checked::map &map) const;
+  inline isl::checked::union_set apply(const isl::checked::union_map &umap) const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::set coalesce() const;
+  inline isl::checked::set complement() const;
+  inline isl::checked::union_set compute_divs() const;
+  inline isl::checked::basic_set detect_equalities() const;
+  inline isl::checked::val dim_max_val(int pos) const;
+  inline isl::checked::val dim_min_val(int pos) const;
+  inline boolean every_set(const std::function<boolean(isl::checked::set)> &test) const;
+  inline isl::checked::set extract_set(const isl::checked::space &space) const;
+  inline isl::checked::basic_set flatten() const;
+  inline stat foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::checked::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::checked::set)> &fn) const;
+  inline isl::checked::basic_set gist(const isl::checked::basic_set &context) const;
+  inline isl::checked::set gist(const isl::checked::set &context) const;
+  inline isl::checked::union_set gist(const isl::checked::union_set &context) const;
+  inline isl::checked::union_set gist_params(const isl::checked::set &set) const;
+  inline isl::checked::map identity() const;
+  inline isl::checked::pw_aff indicator_function() const;
+  inline isl::checked::map insert_domain(const isl::checked::space &domain) const;
+  inline isl::checked::basic_set intersect(const isl::checked::basic_set &bset2) const;
+  inline isl::checked::set intersect(const isl::checked::set &set2) const;
+  inline isl::checked::union_set intersect(const isl::checked::union_set &uset2) const;
+  inline isl::checked::basic_set intersect_params(const isl::checked::basic_set &bset2) const;
+  inline isl::checked::set intersect_params(const isl::checked::set &params) const;
+  inline boolean involves_locals() const;
+  inline boolean is_disjoint(const isl::checked::set &set2) const;
+  inline boolean is_disjoint(const isl::checked::union_set &uset2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::basic_set &bset2) const;
+  inline boolean is_equal(const isl::checked::set &set2) const;
+  inline boolean is_equal(const isl::checked::union_set &uset2) const;
+  inline boolean is_singleton() const;
+  inline boolean is_strict_subset(const isl::checked::set &set2) const;
+  inline boolean is_strict_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_subset(const isl::checked::basic_set &bset2) const;
+  inline boolean is_subset(const isl::checked::set &set2) const;
+  inline boolean is_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_wrapping() const;
+  inline boolean isa_set() const;
+  inline isl::checked::set lexmax() const;
+  inline isl::checked::pw_multi_aff lexmax_pw_multi_aff() const;
+  inline isl::checked::set lexmin() const;
+  inline isl::checked::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::checked::set lower_bound(const isl::checked::multi_pw_aff &lower) const;
+  inline isl::checked::set lower_bound(const isl::checked::multi_val &lower) const;
+  inline isl::checked::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::checked::val max_val(const isl::checked::aff &obj) const;
+  inline isl::checked::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::checked::val min_val(const isl::checked::aff &obj) const;
+  inline isl::checked::multi_val multi_val() const;
+  inline isl::checked::multi_val get_multi_val() const;
+  inline isl::checked::basic_set params() const;
+  inline isl::checked::multi_val plain_multi_val_if_fixed() const;
+  inline isl::checked::basic_set polyhedral_hull() const;
+  inline isl::checked::set preimage(const isl::checked::multi_aff &ma) const;
+  inline isl::checked::set preimage(const isl::checked::multi_pw_aff &mpa) const;
+  inline isl::checked::set preimage(const isl::checked::pw_multi_aff &pma) const;
+  inline isl::checked::union_set preimage(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::set product(const isl::checked::set &set2) const;
+  inline isl::checked::set project_out_all_params() const;
+  inline isl::checked::set project_out_param(const isl::checked::id &id) const;
+  inline isl::checked::set project_out_param(const std::string &id) const;
+  inline isl::checked::set project_out_param(const isl::checked::id_list &list) const;
+  inline isl::checked::pw_multi_aff pw_multi_aff_on_domain(const isl::checked::multi_val &mv) const;
+  inline isl::checked::basic_set sample() const;
+  inline isl::checked::point sample_point() const;
+  inline isl::checked::fixed_box simple_fixed_box_hull() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::val stride(int pos) const;
+  inline isl::checked::set subtract(const isl::checked::set &set2) const;
+  inline isl::checked::union_set subtract(const isl::checked::union_set &uset2) const;
+  inline isl::checked::union_set_list to_list() const;
+  inline isl::checked::set to_set() const;
+  inline isl::checked::union_set to_union_set() const;
+  inline isl::checked::map translation() const;
+  inline isl::checked::set unbind_params(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::map unbind_params_insert_domain(const isl::checked::multi_id &domain) const;
+  inline isl::checked::set unite(const isl::checked::basic_set &bset2) const;
+  inline isl::checked::set unite(const isl::checked::set &set2) const;
+  inline isl::checked::union_set unite(const isl::checked::union_set &uset2) const;
+  inline isl::checked::basic_set unshifted_simple_hull() const;
+  inline isl::checked::map unwrap() const;
+  inline isl::checked::set upper_bound(const isl::checked::multi_pw_aff &upper) const;
+  inline isl::checked::set upper_bound(const isl::checked::multi_val &upper) 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::checked::aff aff);
+  inline explicit pw_aff(isl::checked::ctx ctx, const std::string &str);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_pw_aff add(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_aff add(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_multi_aff add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff add(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_aff add(const isl::checked::aff &pwaff2) const;
+  inline isl::checked::pw_aff add_constant(isl::checked::val v) const;
+  inline isl::checked::pw_aff add_constant(long v) const;
+  inline isl::checked::pw_multi_aff add_constant(const isl::checked::multi_val &mv) const;
+  inline isl::checked::union_pw_multi_aff apply(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::aff as_aff() const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_aff as_multi_aff() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::pw_aff at(int pos) const;
+  inline isl::checked::set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::set bind(isl::checked::id id) const;
+  inline isl::checked::set bind(const std::string &id) const;
+  inline isl::checked::pw_aff bind_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::pw_aff bind_domain_wrapped_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::pw_aff ceil() const;
+  inline isl::checked::pw_aff coalesce() const;
+  inline isl::checked::pw_aff cond(isl::checked::pw_aff pwaff_true, isl::checked::pw_aff pwaff_false) const;
+  inline isl::checked::pw_aff div(isl::checked::pw_aff pa2) const;
+  inline isl::checked::set domain() const;
+  inline isl::checked::set eq_set(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::val eval(isl::checked::point pnt) const;
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(const isl::checked::space &space) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_aff floor() const;
+  inline stat foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const;
+  inline isl::checked::set ge_set(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_aff gist(isl::checked::set context) const;
+  inline isl::checked::union_pw_aff gist(const isl::checked::union_set &context) const;
+  inline isl::checked::pw_aff gist(const isl::checked::basic_set &context) const;
+  inline isl::checked::pw_aff gist(const isl::checked::point &context) const;
+  inline isl::checked::set gt_set(isl::checked::pw_aff pwaff2) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff identity() const;
+  inline isl::checked::pw_aff insert_domain(isl::checked::space domain) const;
+  inline isl::checked::pw_aff intersect_domain(isl::checked::set set) const;
+  inline isl::checked::union_pw_aff intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_aff intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_aff intersect_domain(const isl::checked::basic_set &set) const;
+  inline isl::checked::pw_aff intersect_domain(const isl::checked::point &set) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_aff intersect_params(isl::checked::set set) const;
+  inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::checked::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::checked::id_list &list) const;
+  inline boolean isa_aff() const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::checked::set le_set(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_aff_list list() const;
+  inline isl::checked::set lt_set(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::multi_pw_aff max(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_aff max(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_aff max(const isl::checked::aff &pwaff2) const;
+  inline isl::checked::multi_val max_multi_val() const;
+  inline isl::checked::multi_pw_aff min(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_aff min(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_aff min(const isl::checked::aff &pwaff2) const;
+  inline isl::checked::multi_val min_multi_val() const;
+  inline isl::checked::pw_aff mod(isl::checked::val mod) const;
+  inline isl::checked::pw_aff mod(long mod) const;
+  inline isl::checked::pw_aff mul(isl::checked::pw_aff pwaff2) const;
+  inline class size n_piece() const;
+  inline isl::checked::set ne_set(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_aff neg() const;
+  static inline isl::checked::pw_aff param_on_domain(isl::checked::set domain, isl::checked::id id);
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::checked::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_pw_aff product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::pw_aff pullback(isl::checked::multi_aff ma) const;
+  inline isl::checked::pw_aff pullback(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::pw_aff pullback(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_pw_aff pullback(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::pw_multi_aff range_factor_domain() const;
+  inline isl::checked::pw_multi_aff range_factor_range() const;
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff range_product(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_multi_aff range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::multi_pw_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff scale(const isl::checked::multi_val &mv) const;
+  inline isl::checked::pw_aff scale(isl::checked::val v) const;
+  inline isl::checked::pw_aff scale(long v) const;
+  inline isl::checked::multi_pw_aff scale_down(const isl::checked::multi_val &mv) const;
+  inline isl::checked::pw_aff scale_down(isl::checked::val f) const;
+  inline isl::checked::pw_aff scale_down(long f) const;
+  inline isl::checked::multi_pw_aff set_at(int pos, const isl::checked::pw_aff &el) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::pw_multi_aff set_range_tuple(const isl::checked::id &id) const;
+  inline isl::checked::pw_multi_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_aff sub(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_multi_aff sub(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff sub(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff sub(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_aff sub(const isl::checked::aff &pwaff2) const;
+  inline isl::checked::pw_aff subtract_domain(isl::checked::set set) const;
+  inline isl::checked::union_pw_aff subtract_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_aff subtract_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_aff subtract_domain(const isl::checked::basic_set &set) const;
+  inline isl::checked::pw_aff subtract_domain(const isl::checked::point &set) const;
+  inline isl::checked::pw_aff tdiv_q(isl::checked::pw_aff pa2) const;
+  inline isl::checked::pw_aff tdiv_r(isl::checked::pw_aff pa2) const;
+  inline isl::checked::pw_aff_list to_list() const;
+  inline isl::checked::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::checked::union_pw_aff to_union_pw_aff() const;
+  inline isl::checked::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::checked::multi_pw_aff unbind_params_insert_domain(const isl::checked::multi_id &domain) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::pw_aff union_add(isl::checked::pw_aff pwaff2) const;
+  inline isl::checked::pw_multi_aff union_add(const isl::checked::pw_multi_aff &pma2) const;
+  inline isl::checked::union_pw_aff union_add(const isl::checked::union_pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff union_add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_aff union_add(const isl::checked::aff &pwaff2) 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::checked::ctx ctx, int n);
+  inline explicit pw_aff_list(isl::checked::pw_aff el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::pw_aff_list add(isl::checked::pw_aff el) const;
+  inline isl::checked::pw_aff at(int index) const;
+  inline isl::checked::pw_aff get_at(int index) const;
+  inline isl::checked::pw_aff_list clear() const;
+  inline isl::checked::pw_aff_list concat(isl::checked::pw_aff_list list2) const;
+  inline isl::checked::pw_aff_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::pw_aff)> &fn) const;
+  inline isl::checked::pw_aff_list insert(unsigned int pos, isl::checked::pw_aff el) 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::checked::multi_aff ma);
+  inline /* implicit */ pw_multi_aff(isl::checked::pw_aff pa);
+  inline explicit pw_multi_aff(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_pw_aff add(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff add(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff add(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff add(const isl::checked::pw_aff &pma2) const;
+  inline isl::checked::pw_multi_aff add_constant(isl::checked::multi_val mv) const;
+  inline isl::checked::pw_multi_aff add_constant(isl::checked::val v) const;
+  inline isl::checked::pw_multi_aff add_constant(long v) const;
+  inline isl::checked::union_pw_multi_aff apply(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_aff as_multi_aff() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::pw_aff at(int pos) const;
+  inline isl::checked::pw_aff get_at(int pos) const;
+  inline isl::checked::set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::pw_multi_aff bind_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::pw_multi_aff bind_domain_wrapped_domain(isl::checked::multi_id tuple) const;
+  inline isl::checked::pw_multi_aff coalesce() const;
+  inline isl::checked::set domain() const;
+  static inline isl::checked::pw_multi_aff domain_map(isl::checked::space space);
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(const isl::checked::space &space) const;
+  inline isl::checked::multi_pw_aff flat_range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff flat_range_product(const isl::checked::pw_aff &pma2) const;
+  inline stat foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const;
+  inline isl::checked::pw_multi_aff gist(isl::checked::set set) const;
+  inline isl::checked::union_pw_multi_aff gist(const isl::checked::union_set &context) const;
+  inline isl::checked::pw_multi_aff gist(const isl::checked::basic_set &set) const;
+  inline isl::checked::pw_multi_aff gist(const isl::checked::point &set) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff identity() const;
+  static inline isl::checked::pw_multi_aff identity_on_domain(isl::checked::space space);
+  inline isl::checked::pw_multi_aff insert_domain(isl::checked::space domain) const;
+  inline isl::checked::pw_multi_aff intersect_domain(isl::checked::set set) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_multi_aff intersect_domain(const isl::checked::basic_set &set) const;
+  inline isl::checked::pw_multi_aff intersect_domain(const isl::checked::point &set) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_range(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_multi_aff intersect_params(isl::checked::set set) const;
+  inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean involves_param(const isl::checked::id &id) const;
+  inline boolean involves_param(const std::string &id) const;
+  inline boolean involves_param(const isl::checked::id_list &list) const;
+  inline boolean isa_multi_aff() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::checked::pw_aff_list list() const;
+  inline isl::checked::multi_pw_aff max(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_val max_multi_val() const;
+  inline isl::checked::multi_pw_aff min(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_val min_multi_val() const;
+  static inline isl::checked::pw_multi_aff multi_val_on_domain(isl::checked::set domain, isl::checked::multi_val mv);
+  inline class size n_piece() const;
+  inline isl::checked::multi_pw_aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::checked::multi_pw_aff &multi2) const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::pw_aff &pma2) const;
+  inline isl::checked::multi_pw_aff product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff product(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::pw_multi_aff product(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff product(const isl::checked::pw_aff &pma2) const;
+  inline isl::checked::multi_pw_aff pullback(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::pw_multi_aff pullback(isl::checked::multi_aff ma) const;
+  inline isl::checked::pw_multi_aff pullback(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff pullback(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff range_factor_domain() const;
+  inline isl::checked::pw_multi_aff range_factor_range() const;
+  static inline isl::checked::pw_multi_aff range_map(isl::checked::space space);
+  inline isl::checked::multi_pw_aff range_product(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff range_product(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff range_product(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff range_product(const isl::checked::pw_aff &pma2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_pw_aff scale(const isl::checked::multi_val &mv) const;
+  inline isl::checked::pw_multi_aff scale(isl::checked::val v) const;
+  inline isl::checked::pw_multi_aff scale(long v) const;
+  inline isl::checked::multi_pw_aff scale_down(const isl::checked::multi_val &mv) const;
+  inline isl::checked::pw_multi_aff scale_down(isl::checked::val v) const;
+  inline isl::checked::pw_multi_aff scale_down(long v) const;
+  inline isl::checked::multi_pw_aff set_at(int pos, const isl::checked::pw_aff &el) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::pw_multi_aff set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::pw_multi_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_pw_aff sub(const isl::checked::multi_pw_aff &multi2) const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::pw_multi_aff sub(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff sub(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff sub(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff sub(const isl::checked::pw_aff &pma2) const;
+  inline isl::checked::pw_multi_aff subtract_domain(isl::checked::set set) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(const isl::checked::space &space) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(const isl::checked::union_set &uset) const;
+  inline isl::checked::pw_multi_aff subtract_domain(const isl::checked::basic_set &set) const;
+  inline isl::checked::pw_multi_aff subtract_domain(const isl::checked::point &set) const;
+  inline isl::checked::pw_multi_aff_list to_list() const;
+  inline isl::checked::multi_pw_aff to_multi_pw_aff() const;
+  inline isl::checked::union_pw_multi_aff to_union_pw_multi_aff() const;
+  inline isl::checked::multi_pw_aff unbind_params_insert_domain(const isl::checked::multi_id &domain) const;
+  inline isl::checked::multi_pw_aff union_add(const isl::checked::multi_pw_aff &mpa2) const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::pw_multi_aff union_add(isl::checked::pw_multi_aff pma2) const;
+  inline isl::checked::union_pw_multi_aff union_add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::pw_multi_aff union_add(const isl::checked::multi_aff &pma2) const;
+  inline isl::checked::pw_multi_aff union_add(const isl::checked::pw_aff &pma2) const;
+  static inline isl::checked::pw_multi_aff zero(isl::checked::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::checked::ctx ctx, int n);
+  inline explicit pw_multi_aff_list(isl::checked::pw_multi_aff el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::pw_multi_aff_list add(isl::checked::pw_multi_aff el) const;
+  inline isl::checked::pw_multi_aff at(int index) const;
+  inline isl::checked::pw_multi_aff get_at(int index) const;
+  inline isl::checked::pw_multi_aff_list clear() const;
+  inline isl::checked::pw_multi_aff_list concat(isl::checked::pw_multi_aff_list list2) const;
+  inline isl::checked::pw_multi_aff_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::pw_multi_aff)> &fn) const;
+  inline isl::checked::pw_multi_aff_list insert(unsigned int pos, isl::checked::pw_multi_aff el) 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::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::union_set get_domain() const;
+  static inline isl::checked::schedule from_domain(isl::checked::union_set domain);
+  inline isl::checked::union_map map() const;
+  inline isl::checked::union_map get_map() const;
+  inline isl::checked::schedule pullback(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::schedule_node root() const;
+  inline isl::checked::schedule_node get_root() 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::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_map coincidence() const;
+  inline isl::checked::union_map get_coincidence() const;
+  inline isl::checked::schedule compute_schedule() const;
+  inline isl::checked::union_map conditional_validity() const;
+  inline isl::checked::union_map get_conditional_validity() const;
+  inline isl::checked::union_map conditional_validity_condition() const;
+  inline isl::checked::union_map get_conditional_validity_condition() const;
+  inline isl::checked::set context() const;
+  inline isl::checked::set get_context() const;
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::union_set get_domain() const;
+  static inline isl::checked::schedule_constraints on_domain(isl::checked::union_set domain);
+  inline isl::checked::union_map proximity() const;
+  inline isl::checked::union_map get_proximity() const;
+  inline isl::checked::schedule_constraints set_coincidence(isl::checked::union_map coincidence) const;
+  inline isl::checked::schedule_constraints set_conditional_validity(isl::checked::union_map condition, isl::checked::union_map validity) const;
+  inline isl::checked::schedule_constraints set_context(isl::checked::set context) const;
+  inline isl::checked::schedule_constraints set_proximity(isl::checked::union_map proximity) const;
+  inline isl::checked::schedule_constraints set_validity(isl::checked::union_map validity) const;
+  inline isl::checked::union_map validity() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::schedule_node ancestor(int generation) const;
+  inline class size ancestor_child_position(const isl::checked::schedule_node &ancestor) const;
+  inline class size get_ancestor_child_position(const isl::checked::schedule_node &ancestor) const;
+  inline isl::checked::schedule_node child(int pos) const;
+  inline class size child_position() const;
+  inline class size get_child_position() const;
+  inline boolean every_descendant(const std::function<boolean(isl::checked::schedule_node)> &test) const;
+  inline isl::checked::schedule_node first_child() const;
+  inline stat foreach_ancestor_top_down(const std::function<stat(isl::checked::schedule_node)> &fn) const;
+  inline stat foreach_descendant_top_down(const std::function<boolean(isl::checked::schedule_node)> &fn) const;
+  static inline isl::checked::schedule_node from_domain(isl::checked::union_set domain);
+  static inline isl::checked::schedule_node from_extension(isl::checked::union_map extension);
+  inline isl::checked::schedule_node graft_after(isl::checked::schedule_node graft) const;
+  inline isl::checked::schedule_node graft_before(isl::checked::schedule_node graft) 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::checked::schedule_node insert_context(isl::checked::set context) const;
+  inline isl::checked::schedule_node insert_filter(isl::checked::union_set filter) const;
+  inline isl::checked::schedule_node insert_guard(isl::checked::set context) const;
+  inline isl::checked::schedule_node insert_mark(isl::checked::id mark) const;
+  inline isl::checked::schedule_node insert_mark(const std::string &mark) const;
+  inline isl::checked::schedule_node insert_partial_schedule(isl::checked::multi_union_pw_aff schedule) const;
+  inline isl::checked::schedule_node insert_sequence(isl::checked::union_set_list filters) const;
+  inline isl::checked::schedule_node insert_set(isl::checked::union_set_list filters) const;
+  inline boolean is_equal(const isl::checked::schedule_node &node2) const;
+  inline boolean is_subtree_anchored() const;
+  inline isl::checked::schedule_node map_descendant_bottom_up(const std::function<isl::checked::schedule_node(isl::checked::schedule_node)> &fn) const;
+  inline class size n_children() const;
+  inline isl::checked::schedule_node next_sibling() const;
+  inline isl::checked::schedule_node order_after(isl::checked::union_set filter) const;
+  inline isl::checked::schedule_node order_before(isl::checked::union_set filter) const;
+  inline isl::checked::schedule_node parent() const;
+  inline isl::checked::multi_union_pw_aff prefix_schedule_multi_union_pw_aff() const;
+  inline isl::checked::multi_union_pw_aff get_prefix_schedule_multi_union_pw_aff() const;
+  inline isl::checked::union_map prefix_schedule_union_map() const;
+  inline isl::checked::union_map get_prefix_schedule_union_map() const;
+  inline isl::checked::union_pw_multi_aff prefix_schedule_union_pw_multi_aff() const;
+  inline isl::checked::union_pw_multi_aff get_prefix_schedule_union_pw_multi_aff() const;
+  inline isl::checked::schedule_node previous_sibling() const;
+  inline isl::checked::schedule_node root() const;
+  inline isl::checked::schedule schedule() const;
+  inline isl::checked::schedule get_schedule() const;
+  inline isl::checked::schedule_node shared_ancestor(const isl::checked::schedule_node &node2) const;
+  inline isl::checked::schedule_node get_shared_ancestor(const isl::checked::schedule_node &node2) const;
+  inline class size tree_depth() const;
+  inline class size get_tree_depth() 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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set ast_build_options() const;
+  inline isl::checked::union_set get_ast_build_options() const;
+  inline isl::checked::set ast_isolate_option() const;
+  inline isl::checked::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::checked::multi_val mv) const;
+  inline class size n_member() const;
+  inline isl::checked::multi_union_pw_aff partial_schedule() const;
+  inline isl::checked::multi_union_pw_aff get_partial_schedule() const;
+  inline boolean permutable() const;
+  inline boolean get_permutable() const;
+  inline schedule_node_band scale(isl::checked::multi_val mv) const;
+  inline schedule_node_band scale_down(isl::checked::multi_val mv) const;
+  inline schedule_node_band set_ast_build_options(isl::checked::union_set options) const;
+  inline schedule_node_band set_permutable(int permutable) const;
+  inline schedule_node_band shift(isl::checked::multi_union_pw_aff shift) const;
+  inline schedule_node_band split(int pos) const;
+  inline schedule_node_band tile(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::set context() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_pw_multi_aff contraction() const;
+  inline isl::checked::union_pw_multi_aff get_contraction() const;
+  inline isl::checked::union_map expansion() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_map extension() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set filter() const;
+  inline isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::set guard() const;
+  inline isl::checked::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::checked::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::checked::ctx ctx() 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::checked::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::checked::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::checked::basic_set bset);
+  inline /* implicit */ set(isl::checked::point pnt);
+  inline explicit set(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::basic_set affine_hull() const;
+  inline isl::checked::set apply(isl::checked::map map) const;
+  inline isl::checked::union_set apply(const isl::checked::union_map &umap) const;
+  inline isl::checked::set apply(const isl::checked::basic_map &map) const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::set bind(isl::checked::multi_id tuple) const;
+  inline isl::checked::set coalesce() const;
+  inline isl::checked::set complement() const;
+  inline isl::checked::union_set compute_divs() const;
+  inline isl::checked::set detect_equalities() const;
+  inline isl::checked::val dim_max_val(int pos) const;
+  inline isl::checked::val dim_min_val(int pos) const;
+  static inline isl::checked::set empty(isl::checked::space space);
+  inline boolean every_set(const std::function<boolean(isl::checked::set)> &test) const;
+  inline isl::checked::set extract_set(const isl::checked::space &space) const;
+  inline isl::checked::set flatten() const;
+  inline stat foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const;
+  inline stat foreach_point(const std::function<stat(isl::checked::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::checked::set)> &fn) const;
+  inline isl::checked::set gist(isl::checked::set context) const;
+  inline isl::checked::union_set gist(const isl::checked::union_set &context) const;
+  inline isl::checked::set gist(const isl::checked::basic_set &context) const;
+  inline isl::checked::set gist(const isl::checked::point &context) const;
+  inline isl::checked::union_set gist_params(const isl::checked::set &set) const;
+  inline isl::checked::map identity() const;
+  inline isl::checked::pw_aff indicator_function() const;
+  inline isl::checked::map insert_domain(isl::checked::space domain) const;
+  inline isl::checked::set intersect(isl::checked::set set2) const;
+  inline isl::checked::union_set intersect(const isl::checked::union_set &uset2) const;
+  inline isl::checked::set intersect(const isl::checked::basic_set &set2) const;
+  inline isl::checked::set intersect(const isl::checked::point &set2) const;
+  inline isl::checked::set intersect_params(isl::checked::set params) const;
+  inline boolean involves_locals() const;
+  inline boolean is_disjoint(const isl::checked::set &set2) const;
+  inline boolean is_disjoint(const isl::checked::union_set &uset2) const;
+  inline boolean is_disjoint(const isl::checked::basic_set &set2) const;
+  inline boolean is_disjoint(const isl::checked::point &set2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::set &set2) const;
+  inline boolean is_equal(const isl::checked::union_set &uset2) const;
+  inline boolean is_equal(const isl::checked::basic_set &set2) const;
+  inline boolean is_equal(const isl::checked::point &set2) const;
+  inline boolean is_singleton() const;
+  inline boolean is_strict_subset(const isl::checked::set &set2) const;
+  inline boolean is_strict_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_strict_subset(const isl::checked::basic_set &set2) const;
+  inline boolean is_strict_subset(const isl::checked::point &set2) const;
+  inline boolean is_subset(const isl::checked::set &set2) const;
+  inline boolean is_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_subset(const isl::checked::basic_set &set2) const;
+  inline boolean is_subset(const isl::checked::point &set2) const;
+  inline boolean is_wrapping() const;
+  inline boolean isa_set() const;
+  inline isl::checked::set lexmax() const;
+  inline isl::checked::pw_multi_aff lexmax_pw_multi_aff() const;
+  inline isl::checked::set lexmin() const;
+  inline isl::checked::pw_multi_aff lexmin_pw_multi_aff() const;
+  inline isl::checked::set lower_bound(isl::checked::multi_pw_aff lower) const;
+  inline isl::checked::set lower_bound(isl::checked::multi_val lower) const;
+  inline isl::checked::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::checked::val max_val(const isl::checked::aff &obj) const;
+  inline isl::checked::multi_pw_aff min_multi_pw_aff() const;
+  inline isl::checked::val min_val(const isl::checked::aff &obj) const;
+  inline isl::checked::set params() const;
+  inline isl::checked::multi_val plain_multi_val_if_fixed() const;
+  inline isl::checked::multi_val get_plain_multi_val_if_fixed() const;
+  inline isl::checked::basic_set polyhedral_hull() const;
+  inline isl::checked::set preimage(isl::checked::multi_aff ma) const;
+  inline isl::checked::set preimage(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::set preimage(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_set preimage(const isl::checked::union_pw_multi_aff &upma) const;
+  inline isl::checked::set product(isl::checked::set set2) const;
+  inline isl::checked::set project_out_all_params() const;
+  inline isl::checked::set project_out_param(isl::checked::id id) const;
+  inline isl::checked::set project_out_param(const std::string &id) const;
+  inline isl::checked::set project_out_param(isl::checked::id_list list) const;
+  inline isl::checked::pw_multi_aff pw_multi_aff_on_domain(isl::checked::multi_val mv) const;
+  inline isl::checked::basic_set sample() const;
+  inline isl::checked::point sample_point() const;
+  inline isl::checked::fixed_box simple_fixed_box_hull() const;
+  inline isl::checked::fixed_box get_simple_fixed_box_hull() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::val stride(int pos) const;
+  inline isl::checked::val get_stride(int pos) const;
+  inline isl::checked::set subtract(isl::checked::set set2) const;
+  inline isl::checked::union_set subtract(const isl::checked::union_set &uset2) const;
+  inline isl::checked::set subtract(const isl::checked::basic_set &set2) const;
+  inline isl::checked::set subtract(const isl::checked::point &set2) const;
+  inline isl::checked::union_set_list to_list() const;
+  inline isl::checked::union_set to_union_set() const;
+  inline isl::checked::map translation() const;
+  inline isl::checked::set unbind_params(isl::checked::multi_id tuple) const;
+  inline isl::checked::map unbind_params_insert_domain(isl::checked::multi_id domain) const;
+  inline isl::checked::set unite(isl::checked::set set2) const;
+  inline isl::checked::union_set unite(const isl::checked::union_set &uset2) const;
+  inline isl::checked::set unite(const isl::checked::basic_set &set2) const;
+  inline isl::checked::set unite(const isl::checked::point &set2) const;
+  static inline isl::checked::set universe(isl::checked::space space);
+  inline isl::checked::basic_set unshifted_simple_hull() const;
+  inline isl::checked::map unwrap() const;
+  inline isl::checked::set upper_bound(isl::checked::multi_pw_aff upper) const;
+  inline isl::checked::set upper_bound(isl::checked::multi_val upper) 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 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::checked::ctx ctx() const;
+
+  inline isl::checked::space add_named_tuple(isl::checked::id tuple_id, unsigned int dim) const;
+  inline isl::checked::space add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  inline isl::checked::space add_unnamed_tuple(unsigned int dim) const;
+  inline isl::checked::space curry() const;
+  inline isl::checked::space domain() const;
+  inline isl::checked::multi_aff domain_map_multi_aff() const;
+  inline isl::checked::pw_multi_aff domain_map_pw_multi_aff() const;
+  inline isl::checked::id domain_tuple_id() const;
+  inline isl::checked::id get_domain_tuple_id() const;
+  inline isl::checked::space flatten_domain() const;
+  inline isl::checked::space flatten_range() const;
+  inline boolean has_domain_tuple_id() const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::multi_aff identity_multi_aff_on_domain() const;
+  inline isl::checked::multi_pw_aff identity_multi_pw_aff_on_domain() const;
+  inline isl::checked::pw_multi_aff identity_pw_multi_aff_on_domain() const;
+  inline boolean is_equal(const isl::checked::space &space2) const;
+  inline boolean is_wrapping() const;
+  inline isl::checked::space map_from_set() const;
+  inline isl::checked::multi_aff multi_aff(isl::checked::aff_list list) const;
+  inline isl::checked::multi_aff multi_aff_on_domain(isl::checked::multi_val mv) const;
+  inline isl::checked::multi_id multi_id(isl::checked::id_list list) const;
+  inline isl::checked::multi_pw_aff multi_pw_aff(isl::checked::pw_aff_list list) const;
+  inline isl::checked::multi_union_pw_aff multi_union_pw_aff(isl::checked::union_pw_aff_list list) const;
+  inline isl::checked::multi_val multi_val(isl::checked::val_list list) const;
+  inline isl::checked::space params() const;
+  inline isl::checked::space product(isl::checked::space right) const;
+  inline isl::checked::space range() const;
+  inline isl::checked::multi_aff range_map_multi_aff() const;
+  inline isl::checked::pw_multi_aff range_map_pw_multi_aff() const;
+  inline isl::checked::space range_reverse() const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::id get_range_tuple_id() const;
+  inline isl::checked::space reverse() const;
+  inline isl::checked::space set_domain_tuple(isl::checked::id id) const;
+  inline isl::checked::space set_domain_tuple(const std::string &id) const;
+  inline isl::checked::space set_range_tuple(isl::checked::id id) const;
+  inline isl::checked::space set_range_tuple(const std::string &id) const;
+  inline isl::checked::space uncurry() const;
+  static inline isl::checked::space unit(isl::checked::ctx ctx);
+  inline isl::checked::map universe_map() const;
+  inline isl::checked::set universe_set() const;
+  inline isl::checked::space unwrap() const;
+  inline isl::checked::space wrap() const;
+  inline isl::checked::aff zero_aff_on_domain() const;
+  inline isl::checked::multi_aff zero_multi_aff() const;
+  inline isl::checked::multi_pw_aff zero_multi_pw_aff() const;
+  inline isl::checked::multi_union_pw_aff zero_multi_union_pw_aff() const;
+  inline isl::checked::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::checked::union_map sink);
+  inline union_access_info &operator=(union_access_info obj);
+  inline ~union_access_info();
+  inline __isl_give isl_union_access_info *copy() const &;
+  inline __isl_give isl_union_access_info *copy() && = delete;
+  inline __isl_keep isl_union_access_info *get() const;
+  inline __isl_give isl_union_access_info *release();
+  inline bool is_null() const;
+  inline isl::checked::ctx ctx() const;
+
+  inline isl::checked::union_flow compute_flow() const;
+  inline isl::checked::union_access_info set_kill(isl::checked::union_map kill) const;
+  inline isl::checked::union_access_info set_may_source(isl::checked::union_map may_source) const;
+  inline isl::checked::union_access_info set_must_source(isl::checked::union_map must_source) const;
+  inline isl::checked::union_access_info set_schedule(isl::checked::schedule schedule) const;
+  inline isl::checked::union_access_info set_schedule_map(isl::checked::union_map schedule_map) const;
+};
+
+// 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::checked::ctx ctx() const;
+
+  inline isl::checked::union_map full_may_dependence() const;
+  inline isl::checked::union_map get_full_may_dependence() const;
+  inline isl::checked::union_map full_must_dependence() const;
+  inline isl::checked::union_map get_full_must_dependence() const;
+  inline isl::checked::union_map may_dependence() const;
+  inline isl::checked::union_map get_may_dependence() const;
+  inline isl::checked::union_map may_no_source() const;
+  inline isl::checked::union_map get_may_no_source() const;
+  inline isl::checked::union_map must_dependence() const;
+  inline isl::checked::union_map get_must_dependence() const;
+  inline isl::checked::union_map must_no_source() const;
+  inline isl::checked::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::checked::basic_map bmap);
+  inline /* implicit */ union_map(isl::checked::map map);
+  inline explicit union_map(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_map affine_hull() const;
+  inline isl::checked::union_map apply_domain(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map apply_range(isl::checked::union_map umap2) const;
+  inline isl::checked::map as_map() const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::union_pw_multi_aff as_union_pw_multi_aff() const;
+  inline isl::checked::union_set bind_range(isl::checked::multi_id tuple) const;
+  inline isl::checked::union_map coalesce() const;
+  inline isl::checked::union_map compute_divs() const;
+  inline isl::checked::union_map curry() const;
+  inline isl::checked::union_set deltas() const;
+  inline isl::checked::union_map detect_equalities() const;
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::union_map domain_factor_domain() const;
+  inline isl::checked::union_map domain_factor_range() const;
+  inline isl::checked::union_map domain_map() const;
+  inline isl::checked::union_pw_multi_aff domain_map_union_pw_multi_aff() const;
+  inline isl::checked::union_map domain_product(isl::checked::union_map umap2) const;
+  static inline isl::checked::union_map empty(isl::checked::ctx ctx);
+  inline isl::checked::union_map eq_at(isl::checked::multi_union_pw_aff mupa) const;
+  inline boolean every_map(const std::function<boolean(isl::checked::map)> &test) const;
+  inline isl::checked::map extract_map(isl::checked::space space) const;
+  inline isl::checked::union_map factor_domain() const;
+  inline isl::checked::union_map factor_range() const;
+  inline isl::checked::union_map fixed_power(isl::checked::val exp) const;
+  inline isl::checked::union_map fixed_power(long exp) const;
+  inline stat foreach_map(const std::function<stat(isl::checked::map)> &fn) const;
+  static inline isl::checked::union_map from(isl::checked::multi_union_pw_aff mupa);
+  static inline isl::checked::union_map from(isl::checked::union_pw_multi_aff upma);
+  static inline isl::checked::union_map from_domain(isl::checked::union_set uset);
+  static inline isl::checked::union_map from_domain_and_range(isl::checked::union_set domain, isl::checked::union_set range);
+  static inline isl::checked::union_map from_range(isl::checked::union_set uset);
+  inline isl::checked::union_map gist(isl::checked::union_map context) const;
+  inline isl::checked::union_map gist_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_map gist_params(isl::checked::set set) const;
+  inline isl::checked::union_map gist_range(isl::checked::union_set uset) const;
+  inline isl::checked::union_map intersect(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map intersect_domain(isl::checked::space space) const;
+  inline isl::checked::union_map intersect_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_map intersect_domain_factor_domain(isl::checked::union_map factor) const;
+  inline isl::checked::union_map intersect_domain_factor_range(isl::checked::union_map factor) const;
+  inline isl::checked::union_map intersect_params(isl::checked::set set) const;
+  inline isl::checked::union_map intersect_range(isl::checked::space space) const;
+  inline isl::checked::union_map intersect_range(isl::checked::union_set uset) const;
+  inline isl::checked::union_map intersect_range_factor_domain(isl::checked::union_map factor) const;
+  inline isl::checked::union_map intersect_range_factor_range(isl::checked::union_map factor) const;
+  inline boolean is_bijective() const;
+  inline boolean is_disjoint(const isl::checked::union_map &umap2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::union_map &umap2) const;
+  inline boolean is_injective() const;
+  inline boolean is_single_valued() const;
+  inline boolean is_strict_subset(const isl::checked::union_map &umap2) const;
+  inline boolean is_subset(const isl::checked::union_map &umap2) const;
+  inline boolean isa_map() const;
+  inline isl::checked::union_map lexmax() const;
+  inline isl::checked::union_map lexmin() const;
+  inline isl::checked::union_map polyhedral_hull() const;
+  inline isl::checked::union_map preimage_domain(isl::checked::multi_aff ma) const;
+  inline isl::checked::union_map preimage_domain(isl::checked::multi_pw_aff mpa) const;
+  inline isl::checked::union_map preimage_domain(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_map preimage_domain(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::union_map preimage_range(isl::checked::multi_aff ma) const;
+  inline isl::checked::union_map preimage_range(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_map preimage_range(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::union_map product(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map project_out_all_params() const;
+  inline isl::checked::union_set range() const;
+  inline isl::checked::union_map range_factor_domain() const;
+  inline isl::checked::union_map range_factor_range() const;
+  inline isl::checked::union_map range_map() const;
+  inline isl::checked::union_map range_product(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map range_reverse() const;
+  inline isl::checked::union_map reverse() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::union_map subtract(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map subtract_domain(isl::checked::union_set dom) const;
+  inline isl::checked::union_map subtract_range(isl::checked::union_set dom) const;
+  inline isl::checked::union_map uncurry() const;
+  inline isl::checked::union_map unite(isl::checked::union_map umap2) const;
+  inline isl::checked::union_map universe() const;
+  inline isl::checked::union_set wrap() const;
+  inline isl::checked::union_map zip() 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::checked::aff aff);
+  inline /* implicit */ union_pw_aff(isl::checked::pw_aff pa);
+  inline explicit union_pw_aff(isl::checked::ctx ctx, const std::string &str);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::multi_union_pw_aff add(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::union_pw_aff add(isl::checked::union_pw_aff upa2) const;
+  inline isl::checked::union_pw_multi_aff add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::union_pw_aff add(const isl::checked::aff &upa2) const;
+  inline isl::checked::union_pw_aff add(const isl::checked::pw_aff &upa2) const;
+  inline isl::checked::union_pw_multi_aff apply(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::union_pw_aff at(int pos) const;
+  inline isl::checked::union_set bind(const isl::checked::multi_id &tuple) const;
+  inline isl::checked::union_set bind(isl::checked::id id) const;
+  inline isl::checked::union_set bind(const std::string &id) const;
+  inline isl::checked::union_pw_aff coalesce() const;
+  inline isl::checked::union_set domain() const;
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(const isl::checked::space &space) const;
+  inline isl::checked::multi_union_pw_aff flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::union_pw_aff gist(isl::checked::union_set context) const;
+  inline boolean has_range_tuple_id() const;
+  inline isl::checked::union_pw_aff intersect_domain(isl::checked::space space) const;
+  inline isl::checked::union_pw_aff intersect_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_aff intersect_domain_wrapped_range(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_aff intersect_params(isl::checked::set set) const;
+  inline boolean involves_locals() const;
+  inline boolean involves_nan() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline isl::checked::union_pw_aff_list list() const;
+  inline isl::checked::multi_union_pw_aff neg() const;
+  inline boolean plain_is_empty() const;
+  inline boolean plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::union_pw_aff pullback(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::union_pw_multi_aff range_factor_domain() const;
+  inline isl::checked::union_pw_multi_aff range_factor_range() const;
+  inline isl::checked::multi_union_pw_aff range_product(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::union_pw_multi_aff range_product(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::id range_tuple_id() const;
+  inline isl::checked::multi_union_pw_aff reset_range_tuple_id() const;
+  inline isl::checked::multi_union_pw_aff scale(const isl::checked::multi_val &mv) const;
+  inline isl::checked::multi_union_pw_aff scale(const isl::checked::val &v) const;
+  inline isl::checked::multi_union_pw_aff scale(long v) const;
+  inline isl::checked::multi_union_pw_aff scale_down(const isl::checked::multi_val &mv) const;
+  inline isl::checked::multi_union_pw_aff scale_down(const isl::checked::val &v) const;
+  inline isl::checked::multi_union_pw_aff scale_down(long v) const;
+  inline isl::checked::multi_union_pw_aff set_at(int pos, const isl::checked::union_pw_aff &el) const;
+  inline isl::checked::multi_union_pw_aff set_range_tuple(const isl::checked::id &id) const;
+  inline isl::checked::multi_union_pw_aff set_range_tuple(const std::string &id) const;
+  inline class size size() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::multi_union_pw_aff sub(const isl::checked::multi_union_pw_aff &multi2) const;
+  inline isl::checked::union_pw_aff sub(isl::checked::union_pw_aff upa2) const;
+  inline isl::checked::union_pw_multi_aff sub(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::union_pw_aff sub(const isl::checked::aff &upa2) const;
+  inline isl::checked::union_pw_aff sub(const isl::checked::pw_aff &upa2) const;
+  inline isl::checked::union_pw_aff subtract_domain(isl::checked::space space) const;
+  inline isl::checked::union_pw_aff subtract_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_aff_list to_list() const;
+  inline isl::checked::multi_union_pw_aff union_add(const isl::checked::multi_union_pw_aff &mupa2) const;
+  inline isl::checked::union_pw_aff union_add(isl::checked::union_pw_aff upa2) const;
+  inline isl::checked::union_pw_multi_aff union_add(const isl::checked::union_pw_multi_aff &upma2) const;
+  inline isl::checked::union_pw_aff union_add(const isl::checked::aff &upa2) const;
+  inline isl::checked::union_pw_aff union_add(const isl::checked::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::checked::ctx ctx, int n);
+  inline explicit union_pw_aff_list(isl::checked::union_pw_aff el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::union_pw_aff_list add(isl::checked::union_pw_aff el) const;
+  inline isl::checked::union_pw_aff at(int index) const;
+  inline isl::checked::union_pw_aff get_at(int index) const;
+  inline isl::checked::union_pw_aff_list clear() const;
+  inline isl::checked::union_pw_aff_list concat(isl::checked::union_pw_aff_list list2) const;
+  inline isl::checked::union_pw_aff_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::union_pw_aff)> &fn) const;
+  inline isl::checked::union_pw_aff_list insert(unsigned int pos, isl::checked::union_pw_aff el) 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::checked::multi_aff ma);
+  inline /* implicit */ union_pw_multi_aff(isl::checked::pw_multi_aff pma);
+  inline /* implicit */ union_pw_multi_aff(isl::checked::union_pw_aff upa);
+  inline explicit union_pw_multi_aff(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_pw_multi_aff add(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::union_pw_multi_aff apply(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::multi_union_pw_aff as_multi_union_pw_aff() const;
+  inline isl::checked::pw_multi_aff as_pw_multi_aff() const;
+  inline isl::checked::union_map as_union_map() const;
+  inline isl::checked::union_pw_multi_aff coalesce() const;
+  inline isl::checked::union_set domain() const;
+  static inline isl::checked::union_pw_multi_aff empty(isl::checked::ctx ctx);
+  inline isl::checked::pw_multi_aff extract_pw_multi_aff(isl::checked::space space) const;
+  inline isl::checked::union_pw_multi_aff flat_range_product(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::union_pw_multi_aff gist(isl::checked::union_set context) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(isl::checked::space space) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_domain_wrapped_range(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_multi_aff intersect_params(isl::checked::set set) const;
+  inline boolean involves_locals() const;
+  inline boolean isa_pw_multi_aff() const;
+  inline boolean plain_is_empty() const;
+  inline isl::checked::union_pw_multi_aff preimage_domain_wrapped_domain(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::union_pw_multi_aff pullback(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::union_pw_multi_aff range_factor_domain() const;
+  inline isl::checked::union_pw_multi_aff range_factor_range() const;
+  inline isl::checked::union_pw_multi_aff range_product(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::union_pw_multi_aff sub(isl::checked::union_pw_multi_aff upma2) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(isl::checked::space space) const;
+  inline isl::checked::union_pw_multi_aff subtract_domain(isl::checked::union_set uset) const;
+  inline isl::checked::union_pw_multi_aff union_add(isl::checked::union_pw_multi_aff upma2) const;
+};
+
+// 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::checked::basic_set bset);
+  inline /* implicit */ union_set(isl::checked::point pnt);
+  inline /* implicit */ union_set(isl::checked::set set);
+  inline explicit union_set(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set affine_hull() const;
+  inline isl::checked::union_set apply(isl::checked::union_map umap) const;
+  inline isl::checked::set as_set() const;
+  inline isl::checked::union_set coalesce() const;
+  inline isl::checked::union_set compute_divs() const;
+  inline isl::checked::union_set detect_equalities() const;
+  static inline isl::checked::union_set empty(isl::checked::ctx ctx);
+  inline boolean every_set(const std::function<boolean(isl::checked::set)> &test) const;
+  inline isl::checked::set extract_set(isl::checked::space space) const;
+  inline stat foreach_point(const std::function<stat(isl::checked::point)> &fn) const;
+  inline stat foreach_set(const std::function<stat(isl::checked::set)> &fn) const;
+  inline isl::checked::union_set gist(isl::checked::union_set context) const;
+  inline isl::checked::union_set gist_params(isl::checked::set set) const;
+  inline isl::checked::union_map identity() const;
+  inline isl::checked::union_set intersect(isl::checked::union_set uset2) const;
+  inline isl::checked::union_set intersect_params(isl::checked::set set) const;
+  inline boolean is_disjoint(const isl::checked::union_set &uset2) const;
+  inline boolean is_empty() const;
+  inline boolean is_equal(const isl::checked::union_set &uset2) const;
+  inline boolean is_strict_subset(const isl::checked::union_set &uset2) const;
+  inline boolean is_subset(const isl::checked::union_set &uset2) const;
+  inline boolean isa_set() const;
+  inline isl::checked::union_set lexmax() const;
+  inline isl::checked::union_set lexmin() const;
+  inline isl::checked::union_set polyhedral_hull() const;
+  inline isl::checked::union_set preimage(isl::checked::multi_aff ma) const;
+  inline isl::checked::union_set preimage(isl::checked::pw_multi_aff pma) const;
+  inline isl::checked::union_set preimage(isl::checked::union_pw_multi_aff upma) const;
+  inline isl::checked::point sample_point() const;
+  inline isl::checked::space space() const;
+  inline isl::checked::space get_space() const;
+  inline isl::checked::union_set subtract(isl::checked::union_set uset2) const;
+  inline isl::checked::union_set_list to_list() const;
+  inline isl::checked::union_set unite(isl::checked::union_set uset2) const;
+  inline isl::checked::union_set universe() const;
+  inline isl::checked::union_map unwrap() 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::checked::ctx ctx, int n);
+  inline explicit union_set_list(isl::checked::union_set el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::union_set_list add(isl::checked::union_set el) const;
+  inline isl::checked::union_set at(int index) const;
+  inline isl::checked::union_set get_at(int index) const;
+  inline isl::checked::union_set_list clear() const;
+  inline isl::checked::union_set_list concat(isl::checked::union_set_list list2) const;
+  inline isl::checked::union_set_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::union_set)> &fn) const;
+  inline isl::checked::union_set_list insert(unsigned int pos, isl::checked::union_set el) 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::checked::ctx ctx, long i);
+  inline explicit val(isl::checked::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::checked::ctx ctx() const;
+
+  inline isl::checked::val abs() const;
+  inline boolean abs_eq(const isl::checked::val &v2) const;
+  inline boolean abs_eq(long v2) const;
+  inline isl::checked::val add(isl::checked::val v2) const;
+  inline isl::checked::val add(long v2) const;
+  inline isl::checked::val ceil() const;
+  inline int cmp_si(long i) const;
+  inline long den_si() const;
+  inline long get_den_si() const;
+  inline isl::checked::val div(isl::checked::val v2) const;
+  inline isl::checked::val div(long v2) const;
+  inline boolean eq(const isl::checked::val &v2) const;
+  inline boolean eq(long v2) const;
+  inline isl::checked::val floor() const;
+  inline isl::checked::val gcd(isl::checked::val v2) const;
+  inline isl::checked::val gcd(long v2) const;
+  inline boolean ge(const isl::checked::val &v2) const;
+  inline boolean ge(long v2) const;
+  inline boolean gt(const isl::checked::val &v2) const;
+  inline boolean gt(long v2) const;
+  static inline isl::checked::val infty(isl::checked::ctx ctx);
+  inline isl::checked::val inv() const;
+  inline boolean is_divisible_by(const isl::checked::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::checked::val &v2) const;
+  inline boolean le(long v2) const;
+  inline boolean lt(const isl::checked::val &v2) const;
+  inline boolean lt(long v2) const;
+  inline isl::checked::val max(isl::checked::val v2) const;
+  inline isl::checked::val max(long v2) const;
+  inline isl::checked::val min(isl::checked::val v2) const;
+  inline isl::checked::val min(long v2) const;
+  inline isl::checked::val mod(isl::checked::val v2) const;
+  inline isl::checked::val mod(long v2) const;
+  inline isl::checked::val mul(isl::checked::val v2) const;
+  inline isl::checked::val mul(long v2) const;
+  static inline isl::checked::val nan(isl::checked::ctx ctx);
+  inline boolean ne(const isl::checked::val &v2) const;
+  inline boolean ne(long v2) const;
+  inline isl::checked::val neg() const;
+  static inline isl::checked::val neginfty(isl::checked::ctx ctx);
+  static inline isl::checked::val negone(isl::checked::ctx ctx);
+  inline long num_si() const;
+  inline long get_num_si() const;
+  static inline isl::checked::val one(isl::checked::ctx ctx);
+  inline isl::checked::val pow2() const;
+  inline int sgn() const;
+  inline isl::checked::val sub(isl::checked::val v2) const;
+  inline isl::checked::val sub(long v2) const;
+  inline isl::checked::val_list to_list() const;
+  inline isl::checked::val trunc() const;
+  static inline isl::checked::val zero(isl::checked::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::checked::ctx ctx, int n);
+  inline explicit val_list(isl::checked::val el);
+  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::checked::ctx ctx() const;
+
+  inline isl::checked::val_list add(isl::checked::val el) const;
+  inline isl::checked::val_list add(long el) const;
+  inline isl::checked::val at(int index) const;
+  inline isl::checked::val get_at(int index) const;
+  inline isl::checked::val_list clear() const;
+  inline isl::checked::val_list concat(isl::checked::val_list list2) const;
+  inline isl::checked::val_list drop(unsigned int first, unsigned int n) const;
+  inline stat foreach(const std::function<stat(isl::checked::val)> &fn) const;
+  inline isl::checked::val_list insert(unsigned int pos, isl::checked::val el) const;
+  inline isl::checked::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::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+aff &aff::operator=(aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+aff::~aff() {
+  if (ptr)
+    isl_aff_free(ptr);
+}
+
+__isl_give isl_aff *aff::copy() const & {
+  return isl_aff_copy(ptr);
+}
+
+__isl_keep isl_aff *aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_aff *aff::release() {
+  isl_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx aff::ctx() const {
+  return isl::checked::ctx(isl_aff_get_ctx(ptr));
+}
+
+isl::checked::aff aff::add(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_add(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff aff::add(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).add(multi2);
+}
+
+isl::checked::multi_pw_aff aff::add(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).add(multi2);
+}
+
+isl::checked::multi_union_pw_aff aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).add(multi2);
+}
+
+isl::checked::pw_aff aff::add(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).add(pwaff2);
+}
+
+isl::checked::pw_multi_aff aff::add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).add(pma2);
+}
+
+isl::checked::union_pw_aff aff::add(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::pw_aff(*this).add(upa2);
+}
+
+isl::checked::union_pw_multi_aff aff::add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).add(upma2);
+}
+
+isl::checked::aff aff::add_constant(isl::checked::val v) const
+{
+  auto res = isl_aff_add_constant_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::aff aff::add_constant(long v) const
+{
+  return this->add_constant(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_aff aff::add_constant(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_aff(*this).add_constant(mv);
+}
+
+isl::checked::union_pw_multi_aff aff::apply(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).apply(upma2);
+}
+
+isl::checked::aff aff::as_aff() const
+{
+  return isl::checked::pw_aff(*this).as_aff();
+}
+
+isl::checked::map aff::as_map() const
+{
+  return isl::checked::pw_aff(*this).as_map();
+}
+
+isl::checked::multi_aff aff::as_multi_aff() const
+{
+  return isl::checked::pw_aff(*this).as_multi_aff();
+}
+
+isl::checked::multi_union_pw_aff aff::as_multi_union_pw_aff() const
+{
+  return isl::checked::pw_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff aff::as_pw_multi_aff() const
+{
+  return isl::checked::pw_aff(*this).as_pw_multi_aff();
+}
+
+isl::checked::set aff::as_set() const
+{
+  return isl::checked::multi_aff(*this).as_set();
+}
+
+isl::checked::union_map aff::as_union_map() const
+{
+  return isl::checked::pw_aff(*this).as_union_map();
+}
+
+isl::checked::aff aff::at(int pos) const
+{
+  return isl::checked::multi_aff(*this).at(pos);
+}
+
+isl::checked::basic_set aff::bind(isl::checked::id id) const
+{
+  auto res = isl_aff_bind_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::basic_set aff::bind(const std::string &id) const
+{
+  return this->bind(isl::checked::id(ctx(), id));
+}
+
+isl::checked::basic_set aff::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::multi_aff(*this).bind(tuple);
+}
+
+isl::checked::pw_aff aff::bind_domain(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::pw_aff(*this).bind_domain(tuple);
+}
+
+isl::checked::pw_aff aff::bind_domain_wrapped_domain(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::pw_aff(*this).bind_domain_wrapped_domain(tuple);
+}
+
+isl::checked::aff aff::ceil() const
+{
+  auto res = isl_aff_ceil(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff aff::coalesce() const
+{
+  return isl::checked::pw_aff(*this).coalesce();
+}
+
+isl::checked::pw_aff aff::cond(const isl::checked::pw_aff &pwaff_true, const isl::checked::pw_aff &pwaff_false) const
+{
+  return isl::checked::pw_aff(*this).cond(pwaff_true, pwaff_false);
+}
+
+isl::checked::multi_val aff::constant_multi_val() const
+{
+  return isl::checked::multi_aff(*this).constant_multi_val();
+}
+
+isl::checked::val aff::constant_val() const
+{
+  auto res = isl_aff_get_constant_val(get());
+  return manage(res);
+}
+
+isl::checked::val aff::get_constant_val() const
+{
+  return constant_val();
+}
+
+isl::checked::aff aff::div(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_div(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff aff::div(const isl::checked::pw_aff &pa2) const
+{
+  return isl::checked::pw_aff(*this).div(pa2);
+}
+
+isl::checked::set aff::domain() const
+{
+  return isl::checked::pw_aff(*this).domain();
+}
+
+isl::checked::set aff::eq_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_eq_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::eq_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).eq_set(pwaff2);
+}
+
+isl::checked::val aff::eval(isl::checked::point pnt) const
+{
+  auto res = isl_aff_eval(copy(), pnt.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff aff::extract_pw_multi_aff(const isl::checked::space &space) const
+{
+  return isl::checked::pw_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::checked::multi_aff aff::flat_range_product(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_pw_aff aff::flat_range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::pw_multi_aff aff::flat_range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).flat_range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff aff::flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).flat_range_product(upma2);
+}
+
+isl::checked::aff aff::floor() const
+{
+  auto res = isl_aff_floor(copy());
+  return manage(res);
+}
+
+stat aff::foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const
+{
+  return isl::checked::pw_aff(*this).foreach_piece(fn);
+}
+
+isl::checked::set aff::ge_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_ge_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::ge_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).ge_set(pwaff2);
+}
+
+isl::checked::aff aff::gist(isl::checked::set context) const
+{
+  auto res = isl_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff aff::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::pw_aff(*this).gist(context);
+}
+
+isl::checked::aff aff::gist(const isl::checked::basic_set &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::aff aff::gist(const isl::checked::point &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::set aff::gt_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_gt_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::gt_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).gt_set(pwaff2);
+}
+
+boolean aff::has_range_tuple_id() const
+{
+  return isl::checked::multi_aff(*this).has_range_tuple_id();
+}
+
+isl::checked::multi_aff aff::identity() const
+{
+  return isl::checked::multi_aff(*this).identity();
+}
+
+isl::checked::pw_aff aff::insert_domain(const isl::checked::space &domain) const
+{
+  return isl::checked::pw_aff(*this).insert_domain(domain);
+}
+
+isl::checked::pw_aff aff::intersect_domain(const isl::checked::set &set) const
+{
+  return isl::checked::pw_aff(*this).intersect_domain(set);
+}
+
+isl::checked::union_pw_aff aff::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::pw_aff(*this).intersect_domain(space);
+}
+
+isl::checked::union_pw_aff aff::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_aff(*this).intersect_domain(uset);
+}
+
+isl::checked::union_pw_aff aff::intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::checked::union_pw_aff aff::intersect_domain_wrapped_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::checked::pw_aff aff::intersect_params(const isl::checked::set &set) const
+{
+  return isl::checked::pw_aff(*this).intersect_params(set);
+}
+
+boolean aff::involves_locals() const
+{
+  return isl::checked::multi_aff(*this).involves_locals();
+}
+
+boolean aff::involves_nan() const
+{
+  return isl::checked::multi_aff(*this).involves_nan();
+}
+
+boolean aff::involves_param(const isl::checked::id &id) const
+{
+  return isl::checked::pw_aff(*this).involves_param(id);
+}
+
+boolean aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::checked::id(ctx(), id));
+}
+
+boolean aff::involves_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::pw_aff(*this).involves_param(list);
+}
+
+boolean aff::is_cst() const
+{
+  auto res = isl_aff_is_cst(get());
+  return manage(res);
+}
+
+boolean aff::isa_aff() const
+{
+  return isl::checked::pw_aff(*this).isa_aff();
+}
+
+boolean aff::isa_multi_aff() const
+{
+  return isl::checked::pw_aff(*this).isa_multi_aff();
+}
+
+boolean aff::isa_pw_multi_aff() const
+{
+  return isl::checked::pw_aff(*this).isa_pw_multi_aff();
+}
+
+isl::checked::set aff::le_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_le_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::le_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).le_set(pwaff2);
+}
+
+isl::checked::aff_list aff::list() const
+{
+  return isl::checked::multi_aff(*this).list();
+}
+
+isl::checked::set aff::lt_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_lt_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::lt_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).lt_set(pwaff2);
+}
+
+isl::checked::multi_pw_aff aff::max(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).max(multi2);
+}
+
+isl::checked::pw_aff aff::max(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).max(pwaff2);
+}
+
+isl::checked::multi_val aff::max_multi_val() const
+{
+  return isl::checked::pw_aff(*this).max_multi_val();
+}
+
+isl::checked::multi_pw_aff aff::min(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).min(multi2);
+}
+
+isl::checked::pw_aff aff::min(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).min(pwaff2);
+}
+
+isl::checked::multi_val aff::min_multi_val() const
+{
+  return isl::checked::pw_aff(*this).min_multi_val();
+}
+
+isl::checked::aff aff::mod(isl::checked::val mod) const
+{
+  auto res = isl_aff_mod_val(copy(), mod.release());
+  return manage(res);
+}
+
+isl::checked::aff aff::mod(long mod) const
+{
+  return this->mod(isl::checked::val(ctx(), mod));
+}
+
+isl::checked::aff aff::mul(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_mul(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff aff::mul(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).mul(pwaff2);
+}
+
+class size aff::n_piece() const
+{
+  return isl::checked::pw_aff(*this).n_piece();
+}
+
+isl::checked::set aff::ne_set(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_ne_set(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::set aff::ne_set(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).ne_set(pwaff2);
+}
+
+isl::checked::aff aff::neg() const
+{
+  auto res = isl_aff_neg(copy());
+  return manage(res);
+}
+
+boolean aff::plain_is_empty() const
+{
+  return isl::checked::pw_aff(*this).plain_is_empty();
+}
+
+boolean aff::plain_is_equal(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).plain_is_equal(multi2);
+}
+
+boolean aff::plain_is_equal(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).plain_is_equal(multi2);
+}
+
+boolean aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::checked::pw_multi_aff aff::preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::checked::union_pw_multi_aff aff::preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::checked::multi_aff aff::product(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).product(multi2);
+}
+
+isl::checked::multi_pw_aff aff::product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).product(multi2);
+}
+
+isl::checked::pw_multi_aff aff::product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).product(pma2);
+}
+
+isl::checked::aff aff::pullback(isl::checked::multi_aff ma) const
+{
+  auto res = isl_aff_pullback_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff aff::pullback(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::pw_aff(*this).pullback(mpa);
+}
+
+isl::checked::pw_aff aff::pullback(const isl::checked::pw_multi_aff &pma) const
+{
+  return isl::checked::pw_aff(*this).pullback(pma);
+}
+
+isl::checked::union_pw_aff aff::pullback(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::pw_aff(*this).pullback(upma);
+}
+
+isl::checked::aff aff::pullback(const isl::checked::aff &ma) const
+{
+  return this->pullback(isl::checked::multi_aff(ma));
+}
+
+isl::checked::pw_multi_aff aff::range_factor_domain() const
+{
+  return isl::checked::pw_aff(*this).range_factor_domain();
+}
+
+isl::checked::pw_multi_aff aff::range_factor_range() const
+{
+  return isl::checked::pw_aff(*this).range_factor_range();
+}
+
+isl::checked::multi_aff aff::range_product(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_pw_aff aff::range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::pw_multi_aff aff::range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff aff::range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).range_product(upma2);
+}
+
+isl::checked::id aff::range_tuple_id() const
+{
+  return isl::checked::multi_aff(*this).range_tuple_id();
+}
+
+isl::checked::multi_aff aff::reset_range_tuple_id() const
+{
+  return isl::checked::multi_aff(*this).reset_range_tuple_id();
+}
+
+isl::checked::aff aff::scale(isl::checked::val v) const
+{
+  auto res = isl_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::aff aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_aff aff::scale(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_aff(*this).scale(mv);
+}
+
+isl::checked::aff aff::scale_down(isl::checked::val v) const
+{
+  auto res = isl_aff_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::aff aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_aff aff::scale_down(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_aff(*this).scale_down(mv);
+}
+
+isl::checked::multi_aff aff::set_at(int pos, const isl::checked::aff &el) const
+{
+  return isl::checked::multi_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_pw_aff aff::set_at(int pos, const isl::checked::pw_aff &el) const
+{
+  return isl::checked::pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_union_pw_aff aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_aff aff::set_range_tuple(const isl::checked::id &id) const
+{
+  return isl::checked::multi_aff(*this).set_range_tuple(id);
+}
+
+isl::checked::multi_aff aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size aff::size() const
+{
+  return isl::checked::multi_aff(*this).size();
+}
+
+isl::checked::space aff::space() const
+{
+  return isl::checked::multi_aff(*this).space();
+}
+
+isl::checked::aff aff::sub(isl::checked::aff aff2) const
+{
+  auto res = isl_aff_sub(copy(), aff2.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff aff::sub(const isl::checked::multi_aff &multi2) const
+{
+  return isl::checked::multi_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_pw_aff aff::sub(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_union_pw_aff aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_aff(*this).sub(multi2);
+}
+
+isl::checked::pw_aff aff::sub(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).sub(pwaff2);
+}
+
+isl::checked::pw_multi_aff aff::sub(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).sub(pma2);
+}
+
+isl::checked::union_pw_aff aff::sub(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::pw_aff(*this).sub(upa2);
+}
+
+isl::checked::union_pw_multi_aff aff::sub(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).sub(upma2);
+}
+
+isl::checked::pw_aff aff::subtract_domain(const isl::checked::set &set) const
+{
+  return isl::checked::pw_aff(*this).subtract_domain(set);
+}
+
+isl::checked::union_pw_aff aff::subtract_domain(const isl::checked::space &space) const
+{
+  return isl::checked::pw_aff(*this).subtract_domain(space);
+}
+
+isl::checked::union_pw_aff aff::subtract_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_aff(*this).subtract_domain(uset);
+}
+
+isl::checked::pw_aff aff::tdiv_q(const isl::checked::pw_aff &pa2) const
+{
+  return isl::checked::pw_aff(*this).tdiv_q(pa2);
+}
+
+isl::checked::pw_aff aff::tdiv_r(const isl::checked::pw_aff &pa2) const
+{
+  return isl::checked::pw_aff(*this).tdiv_r(pa2);
+}
+
+isl::checked::aff_list aff::to_list() const
+{
+  auto res = isl_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff aff::to_multi_pw_aff() const
+{
+  return isl::checked::multi_aff(*this).to_multi_pw_aff();
+}
+
+isl::checked::multi_union_pw_aff aff::to_multi_union_pw_aff() const
+{
+  return isl::checked::multi_aff(*this).to_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff aff::to_pw_multi_aff() const
+{
+  return isl::checked::multi_aff(*this).to_pw_multi_aff();
+}
+
+isl::checked::union_pw_aff aff::to_union_pw_aff() const
+{
+  return isl::checked::pw_aff(*this).to_union_pw_aff();
+}
+
+isl::checked::union_pw_multi_aff aff::to_union_pw_multi_aff() const
+{
+  return isl::checked::pw_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::checked::aff aff::unbind_params_insert_domain(isl::checked::multi_id domain) const
+{
+  auto res = isl_aff_unbind_params_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff aff::union_add(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::pw_aff(*this).union_add(mpa2);
+}
+
+isl::checked::multi_union_pw_aff aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::pw_aff(*this).union_add(mupa2);
+}
+
+isl::checked::pw_aff aff::union_add(const isl::checked::pw_aff &pwaff2) const
+{
+  return isl::checked::pw_aff(*this).union_add(pwaff2);
+}
+
+isl::checked::pw_multi_aff aff::union_add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_aff(*this).union_add(pma2);
+}
+
+isl::checked::union_pw_aff aff::union_add(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::pw_aff(*this).union_add(upa2);
+}
+
+isl::checked::union_pw_multi_aff aff::union_add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_aff(*this).union_add(upma2);
+}
+
+isl::checked::aff aff::zero_on_domain(isl::checked::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::checked::ctx ctx, int n)
+{
+  auto res = isl_aff_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+aff_list::aff_list(isl::checked::aff el)
+{
+  auto res = isl_aff_list_from_aff(el.release());
+  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_aff_list_free(ptr);
+}
+
+__isl_give isl_aff_list *aff_list::copy() const & {
+  return isl_aff_list_copy(ptr);
+}
+
+__isl_keep isl_aff_list *aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_aff_list *aff_list::release() {
+  isl_aff_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx aff_list::ctx() const {
+  return isl::checked::ctx(isl_aff_list_get_ctx(ptr));
+}
+
+isl::checked::aff_list aff_list::add(isl::checked::aff el) const
+{
+  auto res = isl_aff_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::aff aff_list::at(int index) const
+{
+  auto res = isl_aff_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::aff aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::aff_list aff_list::clear() const
+{
+  auto res = isl_aff_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::aff_list aff_list::concat(isl::checked::aff_list list2) const
+{
+  auto res = isl_aff_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::aff_list aff_list::insert(unsigned int pos, isl::checked::aff el) const
+{
+  auto res = isl_aff_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size aff_list::size() const
+{
+  auto res = isl_aff_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const aff_list &obj)
+{
+  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::checked::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::checked::ctx ast_build::ctx() const {
+  return isl::checked::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::checked::ast_node(isl::checked::ast_node, isl::checked::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::checked::ast_build ast_build::set_at_each_domain(const std::function<isl::checked::ast_node(isl::checked::ast_node, isl::checked::ast_build)> &fn) const
+{
+  auto copy = *this;
+  copy.set_at_each_domain_data(fn);
+  return copy;
+}
+
+isl::checked::ast_expr ast_build::access_from(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_ast_build_access_from_multi_pw_aff(get(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_build::access_from(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_ast_build_access_from_pw_multi_aff(get(), pma.release());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_build::call_from(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_ast_build_call_from_multi_pw_aff(get(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_build::call_from(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_ast_build_call_from_pw_multi_aff(get(), pma.release());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_build::expr_from(isl::checked::pw_aff pa) const
+{
+  auto res = isl_ast_build_expr_from_pw_aff(get(), pa.release());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_build::expr_from(isl::checked::set set) const
+{
+  auto res = isl_ast_build_expr_from_set(get(), set.release());
+  return manage(res);
+}
+
+isl::checked::ast_build ast_build::from_context(isl::checked::set set)
+{
+  auto res = isl_ast_build_from_context(set.release());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_build::node_from(isl::checked::schedule schedule) const
+{
+  auto res = isl_ast_build_node_from_schedule(get(), schedule.release());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_build::node_from_schedule_map(isl::checked::union_map schedule) const
+{
+  auto res = isl_ast_build_node_from_schedule_map(get(), schedule.release());
+  return manage(res);
+}
+
+isl::checked::union_map ast_build::schedule() const
+{
+  auto res = isl_ast_build_get_schedule(get());
+  return manage(res);
+}
+
+isl::checked::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::copy() const & {
+  return isl_ast_expr_copy(ptr);
+}
+
+__isl_keep isl_ast_expr *ast_expr::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_expr *ast_expr::release() {
+  isl_ast_expr *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool ast_expr::is_null() const {
+  return ptr == nullptr;
+}
+
+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;
+}
+template <class T>
+boolean ast_expr::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T ast_expr::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::checked::ctx ast_expr::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+std::string ast_expr::to_C_str() const
+{
+  auto res = isl_ast_expr_to_C_str(get());
+  std::string tmp(res);
+  free(res);
+  return tmp;
+}
+
+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::checked::ctx ast_expr_id::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+isl::checked::id ast_expr_id::id() const
+{
+  auto res = isl_ast_expr_id_get_id(get());
+  return manage(res);
+}
+
+isl::checked::id ast_expr_id::get_id() const
+{
+  return id();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_id &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_int
+ast_expr_int::ast_expr_int()
+    : ast_expr() {}
+
+ast_expr_int::ast_expr_int(const ast_expr_int &obj)
+    : ast_expr(obj)
+{
+}
+
+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::checked::ctx ast_expr_int::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+isl::checked::val ast_expr_int::val() const
+{
+  auto res = isl_ast_expr_int_get_val(get());
+  return manage(res);
+}
+
+isl::checked::val ast_expr_int::get_val() const
+{
+  return val();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_int &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
+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::checked::ctx ast_expr_op::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+isl::checked::ast_expr ast_expr_op::arg(int pos) const
+{
+  auto res = isl_ast_expr_op_get_arg(get(), pos);
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_expr_op::get_arg(int pos) const
+{
+  return arg(pos);
+}
+
+class size ast_expr_op::n_arg() const
+{
+  auto res = isl_ast_expr_op_get_n_arg(get());
+  return manage(res);
+}
+
+class size ast_expr_op::get_n_arg() const
+{
+  return n_arg();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op &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_access
+ast_expr_op_access::ast_expr_op_access()
+    : ast_expr_op() {}
+
+ast_expr_op_access::ast_expr_op_access(const ast_expr_op_access &obj)
+    : ast_expr_op(obj)
+{
+}
+
+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::checked::ctx ast_expr_op_access::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_access &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_add::ctx() const {
+  return isl::checked::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;
+  }
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_address_of
+ast_expr_op_address_of::ast_expr_op_address_of()
+    : ast_expr_op() {}
+
+ast_expr_op_address_of::ast_expr_op_address_of(const ast_expr_op_address_of &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_address_of::ast_expr_op_address_of(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(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::checked::ctx ast_expr_op_address_of::ctx() const {
+  return isl::checked::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_op_and &ast_expr_op_and::operator=(ast_expr_op_and obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::checked::ctx ast_expr_op_and::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(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;
+}
+
+// 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)
+{
+}
+
+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;
+}
+
+isl::checked::ctx ast_expr_op_and_then::ctx() const {
+  return isl::checked::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() {}
+
+ast_expr_op_call::ast_expr_op_call(const ast_expr_op_call &obj)
+    : ast_expr_op(obj)
+{
+}
+
+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::checked::ctx ast_expr_op_call::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_call &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_cond::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_cond &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_div::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_div &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_eq::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_eq &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_fdiv_q::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_fdiv_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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_ge::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_ge &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_gt::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_gt &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_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)
+{
+}
+
+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::checked::ctx ast_expr_op_le::ctx() const {
+  return isl::checked::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_le &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_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::checked::ctx ast_expr_op_lt::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_max::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_member::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_min::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_minus::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_mul::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_or::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_or_else::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_pdiv_q::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_pdiv_r::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_select::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_sub::ctx() const {
+  return isl::checked::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::checked::ctx ast_expr_op_zdiv_r::ctx() const {
+  return isl::checked::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::copy() const & {
+  return isl_ast_node_copy(ptr);
+}
+
+__isl_keep isl_ast_node *ast_node::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_node *ast_node::release() {
+  isl_ast_node *tmp = ptr;
+  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::checked::ctx ast_node::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+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::checked::ast_node_list ast_node::to_list() const
+{
+  auto res = isl_ast_node_to_list(copy());
+  return manage(res);
+}
+
+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::checked::ctx ast_node_block::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::checked::ast_node_list ast_node_block::children() const
+{
+  auto res = isl_ast_node_block_get_children(get());
+  return manage(res);
+}
+
+isl::checked::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::checked::ctx ast_node_for::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::checked::ast_node ast_node_for::body() const
+{
+  auto res = isl_ast_node_for_get_body(get());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_for::get_body() const
+{
+  return body();
+}
+
+isl::checked::ast_expr ast_node_for::cond() const
+{
+  auto res = isl_ast_node_for_get_cond(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_for::get_cond() const
+{
+  return cond();
+}
+
+isl::checked::ast_expr ast_node_for::inc() const
+{
+  auto res = isl_ast_node_for_get_inc(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_for::get_inc() const
+{
+  return inc();
+}
+
+isl::checked::ast_expr ast_node_for::init() const
+{
+  auto res = isl_ast_node_for_get_init(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_for::get_init() const
+{
+  return init();
+}
+
+boolean ast_node_for::is_degenerate() const
+{
+  auto res = isl_ast_node_for_is_degenerate(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_for::iterator() const
+{
+  auto res = isl_ast_node_for_get_iterator(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_for::get_iterator() const
+{
+  return iterator();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_for &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_if
+ast_node_if::ast_node_if()
+    : ast_node() {}
+
+ast_node_if::ast_node_if(const ast_node_if &obj)
+    : ast_node(obj)
+{
+}
+
+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::checked::ctx ast_node_if::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::checked::ast_expr ast_node_if::cond() const
+{
+  auto res = isl_ast_node_if_get_cond(get());
+  return manage(res);
+}
+
+isl::checked::ast_expr ast_node_if::get_cond() const
+{
+  return cond();
+}
+
+isl::checked::ast_node ast_node_if::else_node() const
+{
+  auto res = isl_ast_node_if_get_else_node(get());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_if::get_else_node() const
+{
+  return else_node();
+}
+
+boolean ast_node_if::has_else_node() const
+{
+  auto res = isl_ast_node_if_has_else_node(get());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_if::then_node() const
+{
+  auto res = isl_ast_node_if_get_then_node(get());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_if::get_then_node() const
+{
+  return then_node();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_if &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_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::checked::ctx ctx, int n)
+{
+  auto res = isl_ast_node_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+ast_node_list::ast_node_list(isl::checked::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_ast_node_list_free(ptr);
+}
+
+__isl_give isl_ast_node_list *ast_node_list::copy() const & {
+  return isl_ast_node_list_copy(ptr);
+}
+
+__isl_keep isl_ast_node_list *ast_node_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_node_list *ast_node_list::release() {
+  isl_ast_node_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool ast_node_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx ast_node_list::ctx() const {
+  return isl::checked::ctx(isl_ast_node_list_get_ctx(ptr));
+}
+
+isl::checked::ast_node_list ast_node_list::add(isl::checked::ast_node el) const
+{
+  auto res = isl_ast_node_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_list::at(int index) const
+{
+  auto res = isl_ast_node_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::ast_node_list ast_node_list::clear() const
+{
+  auto res = isl_ast_node_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::ast_node_list ast_node_list::concat(isl::checked::ast_node_list list2) const
+{
+  auto res = isl_ast_node_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::ast_node)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::ast_node_list ast_node_list::insert(unsigned int pos, isl::checked::ast_node el) const
+{
+  auto res = isl_ast_node_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size ast_node_list::size() const
+{
+  auto res = isl_ast_node_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_list &obj)
+{
+  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;
+}
+
+// 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)
+{
+}
+
+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::checked::ctx ast_node_mark::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::checked::id ast_node_mark::id() const
+{
+  auto res = isl_ast_node_mark_get_id(get());
+  return manage(res);
+}
+
+isl::checked::id ast_node_mark::get_id() const
+{
+  return id();
+}
+
+isl::checked::ast_node ast_node_mark::node() const
+{
+  auto res = isl_ast_node_mark_get_node(get());
+  return manage(res);
+}
+
+isl::checked::ast_node ast_node_mark::get_node() const
+{
+  return node();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_mark &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_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::checked::ctx ast_node_user::ctx() const {
+  return isl::checked::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+isl::checked::ast_expr ast_node_user::expr() const
+{
+  auto res = isl_ast_node_user_get_expr(get());
+  return manage(res);
+}
+
+isl::checked::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::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_basic_map_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+basic_map &basic_map::operator=(basic_map obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+basic_map::~basic_map() {
+  if (ptr)
+    isl_basic_map_free(ptr);
+}
+
+__isl_give isl_basic_map *basic_map::copy() const & {
+  return isl_basic_map_copy(ptr);
+}
+
+__isl_keep isl_basic_map *basic_map::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_map *basic_map::release() {
+  isl_basic_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool basic_map::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx basic_map::ctx() const {
+  return isl::checked::ctx(isl_basic_map_get_ctx(ptr));
+}
+
+isl::checked::basic_map basic_map::affine_hull() const
+{
+  auto res = isl_basic_map_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map basic_map::apply_domain(isl::checked::basic_map bmap2) const
+{
+  auto res = isl_basic_map_apply_domain(copy(), bmap2.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::apply_domain(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).apply_domain(map2);
+}
+
+isl::checked::union_map basic_map::apply_domain(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).apply_domain(umap2);
+}
+
+isl::checked::basic_map basic_map::apply_range(isl::checked::basic_map bmap2) const
+{
+  auto res = isl_basic_map_apply_range(copy(), bmap2.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::apply_range(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).apply_range(map2);
+}
+
+isl::checked::union_map basic_map::apply_range(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).apply_range(umap2);
+}
+
+isl::checked::map basic_map::as_map() const
+{
+  return isl::checked::map(*this).as_map();
+}
+
+isl::checked::multi_union_pw_aff basic_map::as_multi_union_pw_aff() const
+{
+  return isl::checked::map(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff basic_map::as_pw_multi_aff() const
+{
+  return isl::checked::map(*this).as_pw_multi_aff();
+}
+
+isl::checked::union_pw_multi_aff basic_map::as_union_pw_multi_aff() const
+{
+  return isl::checked::map(*this).as_union_pw_multi_aff();
+}
+
+isl::checked::set basic_map::bind_domain(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::map(*this).bind_domain(tuple);
+}
+
+isl::checked::set basic_map::bind_range(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::map(*this).bind_range(tuple);
+}
+
+isl::checked::map basic_map::coalesce() const
+{
+  return isl::checked::map(*this).coalesce();
+}
+
+isl::checked::map basic_map::complement() const
+{
+  return isl::checked::map(*this).complement();
+}
+
+isl::checked::union_map basic_map::compute_divs() const
+{
+  return isl::checked::map(*this).compute_divs();
+}
+
+isl::checked::map basic_map::curry() const
+{
+  return isl::checked::map(*this).curry();
+}
+
+isl::checked::basic_set basic_map::deltas() const
+{
+  auto res = isl_basic_map_deltas(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map basic_map::detect_equalities() const
+{
+  auto res = isl_basic_map_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::set basic_map::domain() const
+{
+  return isl::checked::map(*this).domain();
+}
+
+isl::checked::map basic_map::domain_factor_domain() const
+{
+  return isl::checked::map(*this).domain_factor_domain();
+}
+
+isl::checked::map basic_map::domain_factor_range() const
+{
+  return isl::checked::map(*this).domain_factor_range();
+}
+
+isl::checked::union_map basic_map::domain_map() const
+{
+  return isl::checked::map(*this).domain_map();
+}
+
+isl::checked::union_pw_multi_aff basic_map::domain_map_union_pw_multi_aff() const
+{
+  return isl::checked::map(*this).domain_map_union_pw_multi_aff();
+}
+
+isl::checked::map basic_map::domain_product(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).domain_product(map2);
+}
+
+isl::checked::union_map basic_map::domain_product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).domain_product(umap2);
+}
+
+isl::checked::id basic_map::domain_tuple_id() const
+{
+  return isl::checked::map(*this).domain_tuple_id();
+}
+
+isl::checked::map basic_map::eq_at(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).eq_at(mpa);
+}
+
+isl::checked::union_map basic_map::eq_at(const isl::checked::multi_union_pw_aff &mupa) const
+{
+  return isl::checked::map(*this).eq_at(mupa);
+}
+
+boolean basic_map::every_map(const std::function<boolean(isl::checked::map)> &test) const
+{
+  return isl::checked::map(*this).every_map(test);
+}
+
+isl::checked::map basic_map::extract_map(const isl::checked::space &space) const
+{
+  return isl::checked::map(*this).extract_map(space);
+}
+
+isl::checked::map basic_map::factor_domain() const
+{
+  return isl::checked::map(*this).factor_domain();
+}
+
+isl::checked::map basic_map::factor_range() const
+{
+  return isl::checked::map(*this).factor_range();
+}
+
+isl::checked::union_map basic_map::fixed_power(const isl::checked::val &exp) const
+{
+  return isl::checked::map(*this).fixed_power(exp);
+}
+
+isl::checked::union_map basic_map::fixed_power(long exp) const
+{
+  return this->fixed_power(isl::checked::val(ctx(), exp));
+}
+
+isl::checked::basic_map basic_map::flatten() const
+{
+  auto res = isl_basic_map_flatten(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map basic_map::flatten_domain() const
+{
+  auto res = isl_basic_map_flatten_domain(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map basic_map::flatten_range() const
+{
+  auto res = isl_basic_map_flatten_range(copy());
+  return manage(res);
+}
+
+stat basic_map::foreach_basic_map(const std::function<stat(isl::checked::basic_map)> &fn) const
+{
+  return isl::checked::map(*this).foreach_basic_map(fn);
+}
+
+stat basic_map::foreach_map(const std::function<stat(isl::checked::map)> &fn) const
+{
+  return isl::checked::map(*this).foreach_map(fn);
+}
+
+isl::checked::basic_map basic_map::gist(isl::checked::basic_map context) const
+{
+  auto res = isl_basic_map_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::gist(const isl::checked::map &context) const
+{
+  return isl::checked::map(*this).gist(context);
+}
+
+isl::checked::union_map basic_map::gist(const isl::checked::union_map &context) const
+{
+  return isl::checked::map(*this).gist(context);
+}
+
+isl::checked::map basic_map::gist_domain(const isl::checked::set &context) const
+{
+  return isl::checked::map(*this).gist_domain(context);
+}
+
+isl::checked::union_map basic_map::gist_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::map(*this).gist_domain(uset);
+}
+
+isl::checked::union_map basic_map::gist_params(const isl::checked::set &set) const
+{
+  return isl::checked::map(*this).gist_params(set);
+}
+
+isl::checked::union_map basic_map::gist_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::map(*this).gist_range(uset);
+}
+
+boolean basic_map::has_domain_tuple_id() const
+{
+  return isl::checked::map(*this).has_domain_tuple_id();
+}
+
+boolean basic_map::has_range_tuple_id() const
+{
+  return isl::checked::map(*this).has_range_tuple_id();
+}
+
+isl::checked::basic_map basic_map::intersect(isl::checked::basic_map bmap2) const
+{
+  auto res = isl_basic_map_intersect(copy(), bmap2.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::intersect(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).intersect(map2);
+}
+
+isl::checked::union_map basic_map::intersect(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).intersect(umap2);
+}
+
+isl::checked::basic_map basic_map::intersect_domain(isl::checked::basic_set bset) const
+{
+  auto res = isl_basic_map_intersect_domain(copy(), bset.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::intersect_domain(const isl::checked::set &set) const
+{
+  return isl::checked::map(*this).intersect_domain(set);
+}
+
+isl::checked::union_map basic_map::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::map(*this).intersect_domain(space);
+}
+
+isl::checked::union_map basic_map::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::map(*this).intersect_domain(uset);
+}
+
+isl::checked::basic_map basic_map::intersect_domain(const isl::checked::point &bset) const
+{
+  return this->intersect_domain(isl::checked::basic_set(bset));
+}
+
+isl::checked::map basic_map::intersect_domain_factor_domain(const isl::checked::map &factor) const
+{
+  return isl::checked::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::checked::union_map basic_map::intersect_domain_factor_domain(const isl::checked::union_map &factor) const
+{
+  return isl::checked::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::checked::map basic_map::intersect_domain_factor_range(const isl::checked::map &factor) const
+{
+  return isl::checked::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::checked::union_map basic_map::intersect_domain_factor_range(const isl::checked::union_map &factor) const
+{
+  return isl::checked::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::checked::map basic_map::intersect_params(const isl::checked::set &params) const
+{
+  return isl::checked::map(*this).intersect_params(params);
+}
+
+isl::checked::basic_map basic_map::intersect_range(isl::checked::basic_set bset) const
+{
+  auto res = isl_basic_map_intersect_range(copy(), bset.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::intersect_range(const isl::checked::set &set) const
+{
+  return isl::checked::map(*this).intersect_range(set);
+}
+
+isl::checked::union_map basic_map::intersect_range(const isl::checked::space &space) const
+{
+  return isl::checked::map(*this).intersect_range(space);
+}
+
+isl::checked::union_map basic_map::intersect_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::map(*this).intersect_range(uset);
+}
+
+isl::checked::basic_map basic_map::intersect_range(const isl::checked::point &bset) const
+{
+  return this->intersect_range(isl::checked::basic_set(bset));
+}
+
+isl::checked::map basic_map::intersect_range_factor_domain(const isl::checked::map &factor) const
+{
+  return isl::checked::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::checked::union_map basic_map::intersect_range_factor_domain(const isl::checked::union_map &factor) const
+{
+  return isl::checked::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::checked::map basic_map::intersect_range_factor_range(const isl::checked::map &factor) const
+{
+  return isl::checked::map(*this).intersect_range_factor_range(factor);
+}
+
+isl::checked::union_map basic_map::intersect_range_factor_range(const isl::checked::union_map &factor) const
+{
+  return isl::checked::map(*this).intersect_range_factor_range(factor);
+}
+
+boolean basic_map::is_bijective() const
+{
+  return isl::checked::map(*this).is_bijective();
+}
+
+boolean basic_map::is_disjoint(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).is_disjoint(map2);
+}
+
+boolean basic_map::is_disjoint(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::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::checked::basic_map &bmap2) const
+{
+  auto res = isl_basic_map_is_equal(get(), bmap2.get());
+  return manage(res);
+}
+
+boolean basic_map::is_equal(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).is_equal(map2);
+}
+
+boolean basic_map::is_equal(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).is_equal(umap2);
+}
+
+boolean basic_map::is_injective() const
+{
+  return isl::checked::map(*this).is_injective();
+}
+
+boolean basic_map::is_single_valued() const
+{
+  return isl::checked::map(*this).is_single_valued();
+}
+
+boolean basic_map::is_strict_subset(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).is_strict_subset(map2);
+}
+
+boolean basic_map::is_strict_subset(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).is_strict_subset(umap2);
+}
+
+boolean basic_map::is_subset(const isl::checked::basic_map &bmap2) const
+{
+  auto res = isl_basic_map_is_subset(get(), bmap2.get());
+  return manage(res);
+}
+
+boolean basic_map::is_subset(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).is_subset(map2);
+}
+
+boolean basic_map::is_subset(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).is_subset(umap2);
+}
+
+boolean basic_map::isa_map() const
+{
+  return isl::checked::map(*this).isa_map();
+}
+
+isl::checked::map basic_map::lex_ge_at(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).lex_ge_at(mpa);
+}
+
+isl::checked::map basic_map::lex_gt_at(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).lex_gt_at(mpa);
+}
+
+isl::checked::map basic_map::lex_le_at(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).lex_le_at(mpa);
+}
+
+isl::checked::map basic_map::lex_lt_at(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).lex_lt_at(mpa);
+}
+
+isl::checked::map basic_map::lexmax() const
+{
+  auto res = isl_basic_map_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff basic_map::lexmax_pw_multi_aff() const
+{
+  return isl::checked::map(*this).lexmax_pw_multi_aff();
+}
+
+isl::checked::map basic_map::lexmin() const
+{
+  auto res = isl_basic_map_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff basic_map::lexmin_pw_multi_aff() const
+{
+  return isl::checked::map(*this).lexmin_pw_multi_aff();
+}
+
+isl::checked::map basic_map::lower_bound(const isl::checked::multi_pw_aff &lower) const
+{
+  return isl::checked::map(*this).lower_bound(lower);
+}
+
+isl::checked::multi_pw_aff basic_map::max_multi_pw_aff() const
+{
+  return isl::checked::map(*this).max_multi_pw_aff();
+}
+
+isl::checked::multi_pw_aff basic_map::min_multi_pw_aff() const
+{
+  return isl::checked::map(*this).min_multi_pw_aff();
+}
+
+isl::checked::basic_map basic_map::polyhedral_hull() const
+{
+  return isl::checked::map(*this).polyhedral_hull();
+}
+
+isl::checked::map basic_map::preimage_domain(const isl::checked::multi_aff &ma) const
+{
+  return isl::checked::map(*this).preimage_domain(ma);
+}
+
+isl::checked::map basic_map::preimage_domain(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::map(*this).preimage_domain(mpa);
+}
+
+isl::checked::map basic_map::preimage_domain(const isl::checked::pw_multi_aff &pma) const
+{
+  return isl::checked::map(*this).preimage_domain(pma);
+}
+
+isl::checked::union_map basic_map::preimage_domain(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::map(*this).preimage_domain(upma);
+}
+
+isl::checked::map basic_map::preimage_range(const isl::checked::multi_aff &ma) const
+{
+  return isl::checked::map(*this).preimage_range(ma);
+}
+
+isl::checked::map basic_map::preimage_range(const isl::checked::pw_multi_aff &pma) const
+{
+  return isl::checked::map(*this).preimage_range(pma);
+}
+
+isl::checked::union_map basic_map::preimage_range(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::map(*this).preimage_range(upma);
+}
+
+isl::checked::map basic_map::product(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).product(map2);
+}
+
+isl::checked::union_map basic_map::product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).product(umap2);
+}
+
+isl::checked::map basic_map::project_out_all_params() const
+{
+  return isl::checked::map(*this).project_out_all_params();
+}
+
+isl::checked::set basic_map::range() const
+{
+  return isl::checked::map(*this).range();
+}
+
+isl::checked::map basic_map::range_factor_domain() const
+{
+  return isl::checked::map(*this).range_factor_domain();
+}
+
+isl::checked::map basic_map::range_factor_range() const
+{
+  return isl::checked::map(*this).range_factor_range();
+}
+
+isl::checked::union_map basic_map::range_map() const
+{
+  return isl::checked::map(*this).range_map();
+}
+
+isl::checked::map basic_map::range_product(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).range_product(map2);
+}
+
+isl::checked::union_map basic_map::range_product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).range_product(umap2);
+}
+
+isl::checked::map basic_map::range_reverse() const
+{
+  return isl::checked::map(*this).range_reverse();
+}
+
+isl::checked::fixed_box basic_map::range_simple_fixed_box_hull() const
+{
+  return isl::checked::map(*this).range_simple_fixed_box_hull();
+}
+
+isl::checked::id basic_map::range_tuple_id() const
+{
+  return isl::checked::map(*this).range_tuple_id();
+}
+
+isl::checked::basic_map basic_map::reverse() const
+{
+  auto res = isl_basic_map_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map basic_map::sample() const
+{
+  auto res = isl_basic_map_sample(copy());
+  return manage(res);
+}
+
+isl::checked::map basic_map::set_domain_tuple(const isl::checked::id &id) const
+{
+  return isl::checked::map(*this).set_domain_tuple(id);
+}
+
+isl::checked::map basic_map::set_domain_tuple(const std::string &id) const
+{
+  return this->set_domain_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::map basic_map::set_range_tuple(const isl::checked::id &id) const
+{
+  return isl::checked::map(*this).set_range_tuple(id);
+}
+
+isl::checked::map basic_map::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::space basic_map::space() const
+{
+  return isl::checked::map(*this).space();
+}
+
+isl::checked::map basic_map::subtract(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).subtract(map2);
+}
+
+isl::checked::union_map basic_map::subtract(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).subtract(umap2);
+}
+
+isl::checked::union_map basic_map::subtract_domain(const isl::checked::union_set &dom) const
+{
+  return isl::checked::map(*this).subtract_domain(dom);
+}
+
+isl::checked::union_map basic_map::subtract_range(const isl::checked::union_set &dom) const
+{
+  return isl::checked::map(*this).subtract_range(dom);
+}
+
+isl::checked::union_map basic_map::to_union_map() const
+{
+  return isl::checked::map(*this).to_union_map();
+}
+
+isl::checked::map basic_map::uncurry() const
+{
+  return isl::checked::map(*this).uncurry();
+}
+
+isl::checked::map basic_map::unite(isl::checked::basic_map bmap2) const
+{
+  auto res = isl_basic_map_union(copy(), bmap2.release());
+  return manage(res);
+}
+
+isl::checked::map basic_map::unite(const isl::checked::map &map2) const
+{
+  return isl::checked::map(*this).unite(map2);
+}
+
+isl::checked::union_map basic_map::unite(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::map(*this).unite(umap2);
+}
+
+isl::checked::basic_map basic_map::unshifted_simple_hull() const
+{
+  return isl::checked::map(*this).unshifted_simple_hull();
+}
+
+isl::checked::map basic_map::upper_bound(const isl::checked::multi_pw_aff &upper) const
+{
+  return isl::checked::map(*this).upper_bound(upper);
+}
+
+isl::checked::set basic_map::wrap() const
+{
+  return isl::checked::map(*this).wrap();
+}
+
+isl::checked::map basic_map::zip() const
+{
+  return isl::checked::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_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::checked::point pnt)
+{
+  auto res = isl_basic_set_from_point(pnt.release());
+  ptr = res;
+}
+
+basic_set::basic_set(isl::checked::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);
+  return *this;
+}
+
+basic_set::~basic_set() {
+  if (ptr)
+    isl_basic_set_free(ptr);
+}
+
+__isl_give isl_basic_set *basic_set::copy() const & {
+  return isl_basic_set_copy(ptr);
+}
+
+__isl_keep isl_basic_set *basic_set::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_set *basic_set::release() {
+  isl_basic_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool basic_set::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx basic_set::ctx() const {
+  return isl::checked::ctx(isl_basic_set_get_ctx(ptr));
+}
+
+isl::checked::basic_set basic_set::affine_hull() const
+{
+  auto res = isl_basic_set_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::basic_set basic_set::apply(isl::checked::basic_map bmap) const
+{
+  auto res = isl_basic_set_apply(copy(), bmap.release());
+  return manage(res);
+}
+
+isl::checked::set basic_set::apply(const isl::checked::map &map) const
+{
+  return isl::checked::set(*this).apply(map);
+}
+
+isl::checked::union_set basic_set::apply(const isl::checked::union_map &umap) const
+{
+  return isl::checked::set(*this).apply(umap);
+}
+
+isl::checked::pw_multi_aff basic_set::as_pw_multi_aff() const
+{
+  return isl::checked::set(*this).as_pw_multi_aff();
+}
+
+isl::checked::set basic_set::as_set() const
+{
+  return isl::checked::set(*this).as_set();
+}
+
+isl::checked::set basic_set::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::set(*this).bind(tuple);
+}
+
+isl::checked::set basic_set::coalesce() const
+{
+  return isl::checked::set(*this).coalesce();
+}
+
+isl::checked::set basic_set::complement() const
+{
+  return isl::checked::set(*this).complement();
+}
+
+isl::checked::union_set basic_set::compute_divs() const
+{
+  return isl::checked::set(*this).compute_divs();
+}
+
+isl::checked::basic_set basic_set::detect_equalities() const
+{
+  auto res = isl_basic_set_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::val basic_set::dim_max_val(int pos) const
+{
+  auto res = isl_basic_set_dim_max_val(copy(), pos);
+  return manage(res);
+}
+
+isl::checked::val basic_set::dim_min_val(int pos) const
+{
+  return isl::checked::set(*this).dim_min_val(pos);
+}
+
+boolean basic_set::every_set(const std::function<boolean(isl::checked::set)> &test) const
+{
+  return isl::checked::set(*this).every_set(test);
+}
+
+isl::checked::set basic_set::extract_set(const isl::checked::space &space) const
+{
+  return isl::checked::set(*this).extract_set(space);
+}
+
+isl::checked::basic_set basic_set::flatten() const
+{
+  auto res = isl_basic_set_flatten(copy());
+  return manage(res);
+}
+
+stat basic_set::foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const
+{
+  return isl::checked::set(*this).foreach_basic_set(fn);
+}
+
+stat basic_set::foreach_point(const std::function<stat(isl::checked::point)> &fn) const
+{
+  return isl::checked::set(*this).foreach_point(fn);
+}
+
+stat basic_set::foreach_set(const std::function<stat(isl::checked::set)> &fn) const
+{
+  return isl::checked::set(*this).foreach_set(fn);
+}
+
+isl::checked::basic_set basic_set::gist(isl::checked::basic_set context) const
+{
+  auto res = isl_basic_set_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::set basic_set::gist(const isl::checked::set &context) const
+{
+  return isl::checked::set(*this).gist(context);
+}
+
+isl::checked::union_set basic_set::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::set(*this).gist(context);
+}
+
+isl::checked::basic_set basic_set::gist(const isl::checked::point &context) const
+{
+  return this->gist(isl::checked::basic_set(context));
+}
+
+isl::checked::union_set basic_set::gist_params(const isl::checked::set &set) const
+{
+  return isl::checked::set(*this).gist_params(set);
+}
+
+isl::checked::map basic_set::identity() const
+{
+  return isl::checked::set(*this).identity();
+}
+
+isl::checked::pw_aff basic_set::indicator_function() const
+{
+  return isl::checked::set(*this).indicator_function();
+}
+
+isl::checked::map basic_set::insert_domain(const isl::checked::space &domain) const
+{
+  return isl::checked::set(*this).insert_domain(domain);
+}
+
+isl::checked::basic_set basic_set::intersect(isl::checked::basic_set bset2) const
+{
+  auto res = isl_basic_set_intersect(copy(), bset2.release());
+  return manage(res);
+}
+
+isl::checked::set basic_set::intersect(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).intersect(set2);
+}
+
+isl::checked::union_set basic_set::intersect(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).intersect(uset2);
+}
+
+isl::checked::basic_set basic_set::intersect(const isl::checked::point &bset2) const
+{
+  return this->intersect(isl::checked::basic_set(bset2));
+}
+
+isl::checked::basic_set basic_set::intersect_params(isl::checked::basic_set bset2) const
+{
+  auto res = isl_basic_set_intersect_params(copy(), bset2.release());
+  return manage(res);
+}
+
+isl::checked::set basic_set::intersect_params(const isl::checked::set &params) const
+{
+  return isl::checked::set(*this).intersect_params(params);
+}
+
+isl::checked::basic_set basic_set::intersect_params(const isl::checked::point &bset2) const
+{
+  return this->intersect_params(isl::checked::basic_set(bset2));
+}
+
+boolean basic_set::involves_locals() const
+{
+  return isl::checked::set(*this).involves_locals();
+}
+
+boolean basic_set::is_disjoint(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).is_disjoint(set2);
+}
+
+boolean basic_set::is_disjoint(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).is_disjoint(uset2);
+}
+
+boolean basic_set::is_empty() const
+{
+  auto res = isl_basic_set_is_empty(get());
+  return manage(res);
+}
+
+boolean basic_set::is_equal(const isl::checked::basic_set &bset2) const
+{
+  auto res = isl_basic_set_is_equal(get(), bset2.get());
+  return manage(res);
+}
+
+boolean basic_set::is_equal(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).is_equal(set2);
+}
+
+boolean basic_set::is_equal(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).is_equal(uset2);
+}
+
+boolean basic_set::is_equal(const isl::checked::point &bset2) const
+{
+  return this->is_equal(isl::checked::basic_set(bset2));
+}
+
+boolean basic_set::is_singleton() const
+{
+  return isl::checked::set(*this).is_singleton();
+}
+
+boolean basic_set::is_strict_subset(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).is_strict_subset(set2);
+}
+
+boolean basic_set::is_strict_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).is_strict_subset(uset2);
+}
+
+boolean basic_set::is_subset(const isl::checked::basic_set &bset2) const
+{
+  auto res = isl_basic_set_is_subset(get(), bset2.get());
+  return manage(res);
+}
+
+boolean basic_set::is_subset(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).is_subset(set2);
+}
+
+boolean basic_set::is_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).is_subset(uset2);
+}
+
+boolean basic_set::is_subset(const isl::checked::point &bset2) const
+{
+  return this->is_subset(isl::checked::basic_set(bset2));
+}
+
+boolean basic_set::is_wrapping() const
+{
+  auto res = isl_basic_set_is_wrapping(get());
+  return manage(res);
+}
+
+boolean basic_set::isa_set() const
+{
+  return isl::checked::set(*this).isa_set();
+}
+
+isl::checked::set basic_set::lexmax() const
+{
+  auto res = isl_basic_set_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff basic_set::lexmax_pw_multi_aff() const
+{
+  return isl::checked::set(*this).lexmax_pw_multi_aff();
+}
+
+isl::checked::set basic_set::lexmin() const
+{
+  auto res = isl_basic_set_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff basic_set::lexmin_pw_multi_aff() const
+{
+  return isl::checked::set(*this).lexmin_pw_multi_aff();
+}
+
+isl::checked::set basic_set::lower_bound(const isl::checked::multi_pw_aff &lower) const
+{
+  return isl::checked::set(*this).lower_bound(lower);
+}
+
+isl::checked::set basic_set::lower_bound(const isl::checked::multi_val &lower) const
+{
+  return isl::checked::set(*this).lower_bound(lower);
+}
+
+isl::checked::multi_pw_aff basic_set::max_multi_pw_aff() const
+{
+  return isl::checked::set(*this).max_multi_pw_aff();
+}
+
+isl::checked::val basic_set::max_val(const isl::checked::aff &obj) const
+{
+  return isl::checked::set(*this).max_val(obj);
+}
+
+isl::checked::multi_pw_aff basic_set::min_multi_pw_aff() const
+{
+  return isl::checked::set(*this).min_multi_pw_aff();
+}
+
+isl::checked::val basic_set::min_val(const isl::checked::aff &obj) const
+{
+  return isl::checked::set(*this).min_val(obj);
+}
+
+isl::checked::basic_set basic_set::params() const
+{
+  auto res = isl_basic_set_params(copy());
+  return manage(res);
+}
+
+isl::checked::multi_val basic_set::plain_multi_val_if_fixed() const
+{
+  return isl::checked::set(*this).plain_multi_val_if_fixed();
+}
+
+isl::checked::basic_set basic_set::polyhedral_hull() const
+{
+  return isl::checked::set(*this).polyhedral_hull();
+}
+
+isl::checked::set basic_set::preimage(const isl::checked::multi_aff &ma) const
+{
+  return isl::checked::set(*this).preimage(ma);
+}
+
+isl::checked::set basic_set::preimage(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::set(*this).preimage(mpa);
+}
+
+isl::checked::set basic_set::preimage(const isl::checked::pw_multi_aff &pma) const
+{
+  return isl::checked::set(*this).preimage(pma);
+}
+
+isl::checked::union_set basic_set::preimage(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::set(*this).preimage(upma);
+}
+
+isl::checked::set basic_set::product(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).product(set2);
+}
+
+isl::checked::set basic_set::project_out_all_params() const
+{
+  return isl::checked::set(*this).project_out_all_params();
+}
+
+isl::checked::set basic_set::project_out_param(const isl::checked::id &id) const
+{
+  return isl::checked::set(*this).project_out_param(id);
+}
+
+isl::checked::set basic_set::project_out_param(const std::string &id) const
+{
+  return this->project_out_param(isl::checked::id(ctx(), id));
+}
+
+isl::checked::set basic_set::project_out_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::set(*this).project_out_param(list);
+}
+
+isl::checked::pw_multi_aff basic_set::pw_multi_aff_on_domain(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::set(*this).pw_multi_aff_on_domain(mv);
+}
+
+isl::checked::basic_set basic_set::sample() const
+{
+  auto res = isl_basic_set_sample(copy());
+  return manage(res);
+}
+
+isl::checked::point basic_set::sample_point() const
+{
+  auto res = isl_basic_set_sample_point(copy());
+  return manage(res);
+}
+
+isl::checked::fixed_box basic_set::simple_fixed_box_hull() const
+{
+  return isl::checked::set(*this).simple_fixed_box_hull();
+}
+
+isl::checked::space basic_set::space() const
+{
+  return isl::checked::set(*this).space();
+}
+
+isl::checked::val basic_set::stride(int pos) const
+{
+  return isl::checked::set(*this).stride(pos);
+}
+
+isl::checked::set basic_set::subtract(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).subtract(set2);
+}
+
+isl::checked::union_set basic_set::subtract(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).subtract(uset2);
+}
+
+isl::checked::union_set_list basic_set::to_list() const
+{
+  return isl::checked::set(*this).to_list();
+}
+
+isl::checked::set basic_set::to_set() const
+{
+  auto res = isl_basic_set_to_set(copy());
+  return manage(res);
+}
+
+isl::checked::union_set basic_set::to_union_set() const
+{
+  return isl::checked::set(*this).to_union_set();
+}
+
+isl::checked::map basic_set::translation() const
+{
+  return isl::checked::set(*this).translation();
+}
+
+isl::checked::set basic_set::unbind_params(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::set(*this).unbind_params(tuple);
+}
+
+isl::checked::map basic_set::unbind_params_insert_domain(const isl::checked::multi_id &domain) const
+{
+  return isl::checked::set(*this).unbind_params_insert_domain(domain);
+}
+
+isl::checked::set basic_set::unite(isl::checked::basic_set bset2) const
+{
+  auto res = isl_basic_set_union(copy(), bset2.release());
+  return manage(res);
+}
+
+isl::checked::set basic_set::unite(const isl::checked::set &set2) const
+{
+  return isl::checked::set(*this).unite(set2);
+}
+
+isl::checked::union_set basic_set::unite(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::set(*this).unite(uset2);
+}
+
+isl::checked::set basic_set::unite(const isl::checked::point &bset2) const
+{
+  return this->unite(isl::checked::basic_set(bset2));
+}
+
+isl::checked::basic_set basic_set::unshifted_simple_hull() const
+{
+  return isl::checked::set(*this).unshifted_simple_hull();
+}
+
+isl::checked::map basic_set::unwrap() const
+{
+  return isl::checked::set(*this).unwrap();
+}
+
+isl::checked::set basic_set::upper_bound(const isl::checked::multi_pw_aff &upper) const
+{
+  return isl::checked::set(*this).upper_bound(upper);
+}
+
+isl::checked::set basic_set::upper_bound(const isl::checked::multi_val &upper) const
+{
+  return isl::checked::set(*this).upper_bound(upper);
+}
+
+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::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::copy() const & {
+  return isl_fixed_box_copy(ptr);
+}
+
+__isl_keep isl_fixed_box *fixed_box::get() const {
+  return ptr;
+}
+
+__isl_give isl_fixed_box *fixed_box::release() {
+  isl_fixed_box *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool fixed_box::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx fixed_box::ctx() const {
+  return isl::checked::ctx(isl_fixed_box_get_ctx(ptr));
+}
+
+boolean fixed_box::is_valid() const
+{
+  auto res = isl_fixed_box_is_valid(get());
+  return manage(res);
+}
+
+isl::checked::multi_aff fixed_box::offset() const
+{
+  auto res = isl_fixed_box_get_offset(get());
+  return manage(res);
+}
+
+isl::checked::multi_aff fixed_box::get_offset() const
+{
+  return offset();
+}
+
+isl::checked::multi_val fixed_box::size() const
+{
+  auto res = isl_fixed_box_get_size(get());
+  return manage(res);
+}
+
+isl::checked::multi_val fixed_box::get_size() const
+{
+  return size();
+}
+
+isl::checked::space fixed_box::space() const
+{
+  auto res = isl_fixed_box_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space fixed_box::get_space() const
+{
+  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::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_id_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+id &id::operator=(id obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+id::~id() {
+  if (ptr)
+    isl_id_free(ptr);
+}
+
+__isl_give isl_id *id::copy() const & {
+  return isl_id_copy(ptr);
+}
+
+__isl_keep isl_id *id::get() const {
+  return ptr;
+}
+
+__isl_give isl_id *id::release() {
+  isl_id *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool id::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx id::ctx() const {
+  return isl::checked::ctx(isl_id_get_ctx(ptr));
+}
+
+std::string id::name() const
+{
+  auto res = isl_id_get_name(get());
+  std::string tmp(res);
+  return tmp;
+}
+
+std::string id::get_name() const
+{
+  return name();
+}
+
+isl::checked::id_list id::to_list() const
+{
+  auto res = isl_id_to_list(copy());
+  return manage(res);
+}
+
+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::checked::ctx ctx, int n)
+{
+  auto res = isl_id_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+id_list::id_list(isl::checked::id el)
+{
+  auto res = isl_id_list_from_id(el.release());
+  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_id_list_free(ptr);
+}
+
+__isl_give isl_id_list *id_list::copy() const & {
+  return isl_id_list_copy(ptr);
+}
+
+__isl_keep isl_id_list *id_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_id_list *id_list::release() {
+  isl_id_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool id_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx id_list::ctx() const {
+  return isl::checked::ctx(isl_id_list_get_ctx(ptr));
+}
+
+isl::checked::id_list id_list::add(isl::checked::id el) const
+{
+  auto res = isl_id_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::id_list id_list::add(const std::string &el) const
+{
+  return this->add(isl::checked::id(ctx(), el));
+}
+
+isl::checked::id id_list::at(int index) const
+{
+  auto res = isl_id_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::id id_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::id_list id_list::clear() const
+{
+  auto res = isl_id_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::id_list id_list::concat(isl::checked::id_list list2) const
+{
+  auto res = isl_id_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::id)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::id_list id_list::insert(unsigned int pos, isl::checked::id el) const
+{
+  auto res = isl_id_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::id_list id_list::insert(unsigned int pos, const std::string &el) const
+{
+  return this->insert(pos, isl::checked::id(ctx(), el));
+}
+
+class size id_list::size() const
+{
+  auto res = isl_id_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const id_list &obj)
+{
+  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::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::checked::basic_map bmap)
+{
+  auto res = isl_map_from_basic_map(bmap.release());
+  ptr = res;
+}
+
+map::map(isl::checked::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);
+  return *this;
+}
+
+map::~map() {
+  if (ptr)
+    isl_map_free(ptr);
+}
+
+__isl_give isl_map *map::copy() const & {
+  return isl_map_copy(ptr);
+}
+
+__isl_keep isl_map *map::get() const {
+  return ptr;
+}
+
+__isl_give isl_map *map::release() {
+  isl_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool map::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx map::ctx() const {
+  return isl::checked::ctx(isl_map_get_ctx(ptr));
+}
+
+isl::checked::basic_map map::affine_hull() const
+{
+  auto res = isl_map_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::map map::apply_domain(isl::checked::map map2) const
+{
+  auto res = isl_map_apply_domain(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::apply_domain(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).apply_domain(umap2);
+}
+
+isl::checked::map map::apply_domain(const isl::checked::basic_map &map2) const
+{
+  return this->apply_domain(isl::checked::map(map2));
+}
+
+isl::checked::map map::apply_range(isl::checked::map map2) const
+{
+  auto res = isl_map_apply_range(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::apply_range(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).apply_range(umap2);
+}
+
+isl::checked::map map::apply_range(const isl::checked::basic_map &map2) const
+{
+  return this->apply_range(isl::checked::map(map2));
+}
+
+isl::checked::map map::as_map() const
+{
+  return isl::checked::union_map(*this).as_map();
+}
+
+isl::checked::multi_union_pw_aff map::as_multi_union_pw_aff() const
+{
+  return isl::checked::union_map(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff map::as_pw_multi_aff() const
+{
+  auto res = isl_map_as_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff map::as_union_pw_multi_aff() const
+{
+  return isl::checked::union_map(*this).as_union_pw_multi_aff();
+}
+
+isl::checked::set map::bind_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_map_bind_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::set map::bind_range(isl::checked::multi_id tuple) const
+{
+  auto res = isl_map_bind_range(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::map map::coalesce() const
+{
+  auto res = isl_map_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::map map::complement() const
+{
+  auto res = isl_map_complement(copy());
+  return manage(res);
+}
+
+isl::checked::union_map map::compute_divs() const
+{
+  return isl::checked::union_map(*this).compute_divs();
+}
+
+isl::checked::map map::curry() const
+{
+  auto res = isl_map_curry(copy());
+  return manage(res);
+}
+
+isl::checked::set map::deltas() const
+{
+  auto res = isl_map_deltas(copy());
+  return manage(res);
+}
+
+isl::checked::map map::detect_equalities() const
+{
+  auto res = isl_map_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::set map::domain() const
+{
+  auto res = isl_map_domain(copy());
+  return manage(res);
+}
+
+isl::checked::map map::domain_factor_domain() const
+{
+  auto res = isl_map_domain_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::map map::domain_factor_range() const
+{
+  auto res = isl_map_domain_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map map::domain_map() const
+{
+  return isl::checked::union_map(*this).domain_map();
+}
+
+isl::checked::union_pw_multi_aff map::domain_map_union_pw_multi_aff() const
+{
+  return isl::checked::union_map(*this).domain_map_union_pw_multi_aff();
+}
+
+isl::checked::map map::domain_product(isl::checked::map map2) const
+{
+  auto res = isl_map_domain_product(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::domain_product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).domain_product(umap2);
+}
+
+isl::checked::map map::domain_product(const isl::checked::basic_map &map2) const
+{
+  return this->domain_product(isl::checked::map(map2));
+}
+
+isl::checked::id map::domain_tuple_id() const
+{
+  auto res = isl_map_get_domain_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id map::get_domain_tuple_id() const
+{
+  return domain_tuple_id();
+}
+
+isl::checked::map map::empty(isl::checked::space space)
+{
+  auto res = isl_map_empty(space.release());
+  return manage(res);
+}
+
+isl::checked::map map::eq_at(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_eq_at_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::eq_at(const isl::checked::multi_union_pw_aff &mupa) const
+{
+  return isl::checked::union_map(*this).eq_at(mupa);
+}
+
+isl::checked::map map::eq_at(const isl::checked::aff &mpa) const
+{
+  return this->eq_at(isl::checked::multi_pw_aff(mpa));
+}
+
+isl::checked::map map::eq_at(const isl::checked::multi_aff &mpa) const
+{
+  return this->eq_at(isl::checked::multi_pw_aff(mpa));
+}
+
+isl::checked::map map::eq_at(const isl::checked::pw_aff &mpa) const
+{
+  return this->eq_at(isl::checked::multi_pw_aff(mpa));
+}
+
+isl::checked::map map::eq_at(const isl::checked::pw_multi_aff &mpa) const
+{
+  return this->eq_at(isl::checked::multi_pw_aff(mpa));
+}
+
+boolean map::every_map(const std::function<boolean(isl::checked::map)> &test) const
+{
+  return isl::checked::union_map(*this).every_map(test);
+}
+
+isl::checked::map map::extract_map(const isl::checked::space &space) const
+{
+  return isl::checked::union_map(*this).extract_map(space);
+}
+
+isl::checked::map map::factor_domain() const
+{
+  auto res = isl_map_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::map map::factor_range() const
+{
+  auto res = isl_map_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map map::fixed_power(const isl::checked::val &exp) const
+{
+  return isl::checked::union_map(*this).fixed_power(exp);
+}
+
+isl::checked::union_map map::fixed_power(long exp) const
+{
+  return this->fixed_power(isl::checked::val(ctx(), exp));
+}
+
+isl::checked::map map::flatten() const
+{
+  auto res = isl_map_flatten(copy());
+  return manage(res);
+}
+
+isl::checked::map map::flatten_domain() const
+{
+  auto res = isl_map_flatten_domain(copy());
+  return manage(res);
+}
+
+isl::checked::map map::flatten_range() const
+{
+  auto res = isl_map_flatten_range(copy());
+  return manage(res);
+}
+
+stat map::foreach_basic_map(const std::function<stat(isl::checked::basic_map)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::map)> &fn) const
+{
+  return isl::checked::union_map(*this).foreach_map(fn);
+}
+
+isl::checked::map map::gist(isl::checked::map context) const
+{
+  auto res = isl_map_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::gist(const isl::checked::union_map &context) const
+{
+  return isl::checked::union_map(*this).gist(context);
+}
+
+isl::checked::map map::gist(const isl::checked::basic_map &context) const
+{
+  return this->gist(isl::checked::map(context));
+}
+
+isl::checked::map map::gist_domain(isl::checked::set context) const
+{
+  auto res = isl_map_gist_domain(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::gist_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_map(*this).gist_domain(uset);
+}
+
+isl::checked::map map::gist_domain(const isl::checked::basic_set &context) const
+{
+  return this->gist_domain(isl::checked::set(context));
+}
+
+isl::checked::map map::gist_domain(const isl::checked::point &context) const
+{
+  return this->gist_domain(isl::checked::set(context));
+}
+
+isl::checked::union_map map::gist_params(const isl::checked::set &set) const
+{
+  return isl::checked::union_map(*this).gist_params(set);
+}
+
+isl::checked::union_map map::gist_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_map(*this).gist_range(uset);
+}
+
+boolean map::has_domain_tuple_id() const
+{
+  auto res = isl_map_has_domain_tuple_id(get());
+  return manage(res);
+}
+
+boolean map::has_range_tuple_id() const
+{
+  auto res = isl_map_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::map map::intersect(isl::checked::map map2) const
+{
+  auto res = isl_map_intersect(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).intersect(umap2);
+}
+
+isl::checked::map map::intersect(const isl::checked::basic_map &map2) const
+{
+  return this->intersect(isl::checked::map(map2));
+}
+
+isl::checked::map map::intersect_domain(isl::checked::set set) const
+{
+  auto res = isl_map_intersect_domain(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::union_map(*this).intersect_domain(space);
+}
+
+isl::checked::union_map map::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_map(*this).intersect_domain(uset);
+}
+
+isl::checked::map map::intersect_domain(const isl::checked::basic_set &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::map map::intersect_domain(const isl::checked::point &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::map map::intersect_domain_factor_domain(isl::checked::map factor) const
+{
+  auto res = isl_map_intersect_domain_factor_domain(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_domain_factor_domain(const isl::checked::union_map &factor) const
+{
+  return isl::checked::union_map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::checked::map map::intersect_domain_factor_domain(const isl::checked::basic_map &factor) const
+{
+  return this->intersect_domain_factor_domain(isl::checked::map(factor));
+}
+
+isl::checked::map map::intersect_domain_factor_range(isl::checked::map factor) const
+{
+  auto res = isl_map_intersect_domain_factor_range(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_domain_factor_range(const isl::checked::union_map &factor) const
+{
+  return isl::checked::union_map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::checked::map map::intersect_domain_factor_range(const isl::checked::basic_map &factor) const
+{
+  return this->intersect_domain_factor_range(isl::checked::map(factor));
+}
+
+isl::checked::map map::intersect_params(isl::checked::set params) const
+{
+  auto res = isl_map_intersect_params(copy(), params.release());
+  return manage(res);
+}
+
+isl::checked::map map::intersect_range(isl::checked::set set) const
+{
+  auto res = isl_map_intersect_range(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_range(const isl::checked::space &space) const
+{
+  return isl::checked::union_map(*this).intersect_range(space);
+}
+
+isl::checked::union_map map::intersect_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_map(*this).intersect_range(uset);
+}
+
+isl::checked::map map::intersect_range(const isl::checked::basic_set &set) const
+{
+  return this->intersect_range(isl::checked::set(set));
+}
+
+isl::checked::map map::intersect_range(const isl::checked::point &set) const
+{
+  return this->intersect_range(isl::checked::set(set));
+}
+
+isl::checked::map map::intersect_range_factor_domain(isl::checked::map factor) const
+{
+  auto res = isl_map_intersect_range_factor_domain(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_range_factor_domain(const isl::checked::union_map &factor) const
+{
+  return isl::checked::union_map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::checked::map map::intersect_range_factor_domain(const isl::checked::basic_map &factor) const
+{
+  return this->intersect_range_factor_domain(isl::checked::map(factor));
+}
+
+isl::checked::map map::intersect_range_factor_range(isl::checked::map factor) const
+{
+  auto res = isl_map_intersect_range_factor_range(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::intersect_range_factor_range(const isl::checked::union_map &factor) const
+{
+  return isl::checked::union_map(*this).intersect_range_factor_range(factor);
+}
+
+isl::checked::map map::intersect_range_factor_range(const isl::checked::basic_map &factor) const
+{
+  return this->intersect_range_factor_range(isl::checked::map(factor));
+}
+
+boolean map::is_bijective() const
+{
+  auto res = isl_map_is_bijective(get());
+  return manage(res);
+}
+
+boolean map::is_disjoint(const isl::checked::map &map2) const
+{
+  auto res = isl_map_is_disjoint(get(), map2.get());
+  return manage(res);
+}
+
+boolean map::is_disjoint(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).is_disjoint(umap2);
+}
+
+boolean map::is_disjoint(const isl::checked::basic_map &map2) const
+{
+  return this->is_disjoint(isl::checked::map(map2));
+}
+
+boolean map::is_empty() const
+{
+  auto res = isl_map_is_empty(get());
+  return manage(res);
+}
+
+boolean map::is_equal(const isl::checked::map &map2) const
+{
+  auto res = isl_map_is_equal(get(), map2.get());
+  return manage(res);
+}
+
+boolean map::is_equal(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).is_equal(umap2);
+}
+
+boolean map::is_equal(const isl::checked::basic_map &map2) const
+{
+  return this->is_equal(isl::checked::map(map2));
+}
+
+boolean map::is_injective() const
+{
+  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::checked::map &map2) const
+{
+  auto res = isl_map_is_strict_subset(get(), map2.get());
+  return manage(res);
+}
+
+boolean map::is_strict_subset(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).is_strict_subset(umap2);
+}
+
+boolean map::is_strict_subset(const isl::checked::basic_map &map2) const
+{
+  return this->is_strict_subset(isl::checked::map(map2));
+}
+
+boolean map::is_subset(const isl::checked::map &map2) const
+{
+  auto res = isl_map_is_subset(get(), map2.get());
+  return manage(res);
+}
+
+boolean map::is_subset(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).is_subset(umap2);
+}
+
+boolean map::is_subset(const isl::checked::basic_map &map2) const
+{
+  return this->is_subset(isl::checked::map(map2));
+}
+
+boolean map::isa_map() const
+{
+  return isl::checked::union_map(*this).isa_map();
+}
+
+isl::checked::map map::lex_ge_at(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_lex_ge_at_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::map map::lex_gt_at(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_lex_gt_at_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::map map::lex_le_at(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_lex_le_at_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::map map::lex_lt_at(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_lex_lt_at_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::map map::lexmax() const
+{
+  auto res = isl_map_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff map::lexmax_pw_multi_aff() const
+{
+  auto res = isl_map_lexmax_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::map map::lexmin() const
+{
+  auto res = isl_map_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff map::lexmin_pw_multi_aff() const
+{
+  auto res = isl_map_lexmin_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::map map::lower_bound(isl::checked::multi_pw_aff lower) const
+{
+  auto res = isl_map_lower_bound_multi_pw_aff(copy(), lower.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff map::max_multi_pw_aff() const
+{
+  auto res = isl_map_max_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff map::min_multi_pw_aff() const
+{
+  auto res = isl_map_min_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map map::polyhedral_hull() const
+{
+  auto res = isl_map_polyhedral_hull(copy());
+  return manage(res);
+}
+
+isl::checked::map map::preimage_domain(isl::checked::multi_aff ma) const
+{
+  auto res = isl_map_preimage_domain_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::map map::preimage_domain(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::map map::preimage_domain(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_map_preimage_domain_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::preimage_domain(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::union_map(*this).preimage_domain(upma);
+}
+
+isl::checked::map map::preimage_range(isl::checked::multi_aff ma) const
+{
+  auto res = isl_map_preimage_range_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::map map::preimage_range(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_map_preimage_range_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::preimage_range(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::union_map(*this).preimage_range(upma);
+}
+
+isl::checked::map map::product(isl::checked::map map2) const
+{
+  auto res = isl_map_product(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).product(umap2);
+}
+
+isl::checked::map map::product(const isl::checked::basic_map &map2) const
+{
+  return this->product(isl::checked::map(map2));
+}
+
+isl::checked::map map::project_out_all_params() const
+{
+  auto res = isl_map_project_out_all_params(copy());
+  return manage(res);
+}
+
+isl::checked::set map::range() const
+{
+  auto res = isl_map_range(copy());
+  return manage(res);
+}
+
+isl::checked::map map::range_factor_domain() const
+{
+  auto res = isl_map_range_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::map map::range_factor_range() const
+{
+  auto res = isl_map_range_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map map::range_map() const
+{
+  return isl::checked::union_map(*this).range_map();
+}
+
+isl::checked::map map::range_product(isl::checked::map map2) const
+{
+  auto res = isl_map_range_product(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::range_product(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).range_product(umap2);
+}
+
+isl::checked::map map::range_product(const isl::checked::basic_map &map2) const
+{
+  return this->range_product(isl::checked::map(map2));
+}
+
+isl::checked::map map::range_reverse() const
+{
+  auto res = isl_map_range_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::fixed_box map::range_simple_fixed_box_hull() const
+{
+  auto res = isl_map_get_range_simple_fixed_box_hull(get());
+  return manage(res);
+}
+
+isl::checked::fixed_box map::get_range_simple_fixed_box_hull() const
+{
+  return range_simple_fixed_box_hull();
+}
+
+isl::checked::id map::range_tuple_id() const
+{
+  auto res = isl_map_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id map::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::map map::reverse() const
+{
+  auto res = isl_map_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::basic_map map::sample() const
+{
+  auto res = isl_map_sample(copy());
+  return manage(res);
+}
+
+isl::checked::map map::set_domain_tuple(isl::checked::id id) const
+{
+  auto res = isl_map_set_domain_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::map map::set_domain_tuple(const std::string &id) const
+{
+  return this->set_domain_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::map map::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_map_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::map map::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::space map::space() const
+{
+  auto res = isl_map_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space map::get_space() const
+{
+  return space();
+}
+
+isl::checked::map map::subtract(isl::checked::map map2) const
+{
+  auto res = isl_map_subtract(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::subtract(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).subtract(umap2);
+}
+
+isl::checked::map map::subtract(const isl::checked::basic_map &map2) const
+{
+  return this->subtract(isl::checked::map(map2));
+}
+
+isl::checked::union_map map::subtract_domain(const isl::checked::union_set &dom) const
+{
+  return isl::checked::union_map(*this).subtract_domain(dom);
+}
+
+isl::checked::union_map map::subtract_range(const isl::checked::union_set &dom) const
+{
+  return isl::checked::union_map(*this).subtract_range(dom);
+}
+
+isl::checked::union_map map::to_union_map() const
+{
+  auto res = isl_map_to_union_map(copy());
+  return manage(res);
+}
+
+isl::checked::map map::uncurry() const
+{
+  auto res = isl_map_uncurry(copy());
+  return manage(res);
+}
+
+isl::checked::map map::unite(isl::checked::map map2) const
+{
+  auto res = isl_map_union(copy(), map2.release());
+  return manage(res);
+}
+
+isl::checked::union_map map::unite(const isl::checked::union_map &umap2) const
+{
+  return isl::checked::union_map(*this).unite(umap2);
+}
+
+isl::checked::map map::unite(const isl::checked::basic_map &map2) const
+{
+  return this->unite(isl::checked::map(map2));
+}
+
+isl::checked::map map::universe(isl::checked::space space)
+{
+  auto res = isl_map_universe(space.release());
+  return manage(res);
+}
+
+isl::checked::basic_map map::unshifted_simple_hull() const
+{
+  auto res = isl_map_unshifted_simple_hull(copy());
+  return manage(res);
+}
+
+isl::checked::map map::upper_bound(isl::checked::multi_pw_aff upper) const
+{
+  auto res = isl_map_upper_bound_multi_pw_aff(copy(), upper.release());
+  return manage(res);
+}
+
+isl::checked::set map::wrap() const
+{
+  auto res = isl_map_wrap(copy());
+  return manage(res);
+}
+
+isl::checked::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::multi_aff
+multi_aff manage(__isl_take isl_multi_aff *ptr) {
+  return multi_aff(ptr);
+}
+multi_aff manage_copy(__isl_keep isl_multi_aff *ptr) {
+  ptr = isl_multi_aff_copy(ptr);
+  return multi_aff(ptr);
+}
+
+multi_aff::multi_aff()
+    : ptr(nullptr) {}
+
+multi_aff::multi_aff(const multi_aff &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
+    : ptr(ptr) {}
+
+multi_aff::multi_aff(isl::checked::aff aff)
+{
+  auto res = isl_multi_aff_from_aff(aff.release());
+  ptr = res;
+}
+
+multi_aff::multi_aff(isl::checked::space space, isl::checked::aff_list list)
+{
+  auto res = isl_multi_aff_from_aff_list(space.release(), list.release());
+  ptr = res;
+}
+
+multi_aff::multi_aff(isl::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_multi_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+multi_aff &multi_aff::operator=(multi_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_aff::~multi_aff() {
+  if (ptr)
+    isl_multi_aff_free(ptr);
+}
+
+__isl_give isl_multi_aff *multi_aff::copy() const & {
+  return isl_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_aff *multi_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_aff *multi_aff::release() {
+  isl_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool multi_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx multi_aff::ctx() const {
+  return isl::checked::ctx(isl_multi_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_aff multi_aff::add(isl::checked::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_add(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::add(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(multi2);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(multi2);
+}
+
+isl::checked::pw_multi_aff multi_aff::add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(upma2);
+}
+
+isl::checked::multi_aff multi_aff::add(const isl::checked::aff &multi2) const
+{
+  return this->add(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::multi_aff multi_aff::add_constant(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_aff_add_constant_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::add_constant(isl::checked::val v) const
+{
+  auto res = isl_multi_aff_add_constant_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::add_constant(long v) const
+{
+  return this->add_constant(isl::checked::val(ctx(), v));
+}
+
+isl::checked::union_pw_multi_aff multi_aff::apply(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).apply(upma2);
+}
+
+isl::checked::map multi_aff::as_map() const
+{
+  auto res = isl_multi_aff_as_map(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::as_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).as_multi_aff();
+}
+
+isl::checked::multi_union_pw_aff multi_aff::as_multi_union_pw_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff multi_aff::as_pw_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::checked::set multi_aff::as_set() const
+{
+  auto res = isl_multi_aff_as_set(copy());
+  return manage(res);
+}
+
+isl::checked::union_map multi_aff::as_union_map() const
+{
+  return isl::checked::pw_multi_aff(*this).as_union_map();
+}
+
+isl::checked::aff multi_aff::at(int pos) const
+{
+  auto res = isl_multi_aff_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::aff multi_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::basic_set multi_aff::bind(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_aff_bind(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::bind_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_aff_bind_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::bind_domain_wrapped_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff multi_aff::coalesce() const
+{
+  return isl::checked::pw_multi_aff(*this).coalesce();
+}
+
+isl::checked::multi_val multi_aff::constant_multi_val() const
+{
+  auto res = isl_multi_aff_get_constant_multi_val(get());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_aff::get_constant_multi_val() const
+{
+  return constant_multi_val();
+}
+
+isl::checked::set multi_aff::domain() const
+{
+  return isl::checked::pw_multi_aff(*this).domain();
+}
+
+isl::checked::multi_aff multi_aff::domain_map(isl::checked::space space)
+{
+  auto res = isl_multi_aff_domain_map(space.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff multi_aff::extract_pw_multi_aff(const isl::checked::space &space) const
+{
+  return isl::checked::pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::checked::multi_aff multi_aff::flat_range_product(isl::checked::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_flat_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::flat_range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::pw_multi_aff multi_aff::flat_range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::checked::multi_aff multi_aff::flat_range_product(const isl::checked::aff &multi2) const
+{
+  return this->flat_range_product(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::multi_aff multi_aff::floor() const
+{
+  auto res = isl_multi_aff_floor(copy());
+  return manage(res);
+}
+
+stat multi_aff::foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const
+{
+  return isl::checked::pw_multi_aff(*this).foreach_piece(fn);
+}
+
+isl::checked::multi_aff multi_aff::gist(isl::checked::set context) const
+{
+  auto res = isl_multi_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::pw_multi_aff(*this).gist(context);
+}
+
+isl::checked::multi_aff multi_aff::gist(const isl::checked::basic_set &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::multi_aff multi_aff::gist(const isl::checked::point &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+boolean multi_aff::has_range_tuple_id() const
+{
+  auto res = isl_multi_aff_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::identity() const
+{
+  auto res = isl_multi_aff_identity_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::identity_on_domain(isl::checked::space space)
+{
+  auto res = isl_multi_aff_identity_on_domain_space(space.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::insert_domain(isl::checked::space domain) const
+{
+  auto res = isl_multi_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff multi_aff::intersect_domain(const isl::checked::set &set) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_domain(set);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_domain(space);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_domain(uset);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::intersect_domain_wrapped_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::checked::pw_multi_aff multi_aff::intersect_params(const isl::checked::set &set) const
+{
+  return isl::checked::pw_multi_aff(*this).intersect_params(set);
+}
+
+boolean multi_aff::involves_locals() const
+{
+  auto res = isl_multi_aff_involves_locals(get());
+  return manage(res);
+}
+
+boolean multi_aff::involves_nan() const
+{
+  auto res = isl_multi_aff_involves_nan(get());
+  return manage(res);
+}
+
+boolean multi_aff::involves_param(const isl::checked::id &id) const
+{
+  return isl::checked::pw_multi_aff(*this).involves_param(id);
+}
+
+boolean multi_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::checked::id(ctx(), id));
+}
+
+boolean multi_aff::involves_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::pw_multi_aff(*this).involves_param(list);
+}
+
+boolean multi_aff::isa_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).isa_multi_aff();
+}
+
+boolean multi_aff::isa_pw_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::checked::aff_list multi_aff::list() const
+{
+  auto res = isl_multi_aff_get_list(get());
+  return manage(res);
+}
+
+isl::checked::aff_list multi_aff::get_list() const
+{
+  return list();
+}
+
+isl::checked::multi_pw_aff multi_aff::max(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).max(multi2);
+}
+
+isl::checked::multi_val multi_aff::max_multi_val() const
+{
+  return isl::checked::pw_multi_aff(*this).max_multi_val();
+}
+
+isl::checked::multi_pw_aff multi_aff::min(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).min(multi2);
+}
+
+isl::checked::multi_val multi_aff::min_multi_val() const
+{
+  return isl::checked::pw_multi_aff(*this).min_multi_val();
+}
+
+isl::checked::multi_aff multi_aff::multi_val_on_domain(isl::checked::space space, isl::checked::multi_val mv)
+{
+  auto res = isl_multi_aff_multi_val_on_domain_space(space.release(), mv.release());
+  return manage(res);
+}
+
+class size multi_aff::n_piece() const
+{
+  return isl::checked::pw_multi_aff(*this).n_piece();
+}
+
+isl::checked::multi_aff multi_aff::neg() const
+{
+  auto res = isl_multi_aff_neg(copy());
+  return manage(res);
+}
+
+boolean multi_aff::plain_is_empty() const
+{
+  return isl::checked::pw_multi_aff(*this).plain_is_empty();
+}
+
+boolean multi_aff::plain_is_equal(const isl::checked::multi_aff &multi2) const
+{
+  auto res = isl_multi_aff_plain_is_equal(get(), multi2.get());
+  return manage(res);
+}
+
+boolean multi_aff::plain_is_equal(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+boolean multi_aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+boolean multi_aff::plain_is_equal(const isl::checked::aff &multi2) const
+{
+  return this->plain_is_equal(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::checked::multi_aff multi_aff::product(isl::checked::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).product(multi2);
+}
+
+isl::checked::pw_multi_aff multi_aff::product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).product(pma2);
+}
+
+isl::checked::multi_aff multi_aff::product(const isl::checked::aff &multi2) const
+{
+  return this->product(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::multi_aff multi_aff::pullback(isl::checked::multi_aff ma2) const
+{
+  auto res = isl_multi_aff_pullback_multi_aff(copy(), ma2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::pullback(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::pw_multi_aff(*this).pullback(mpa2);
+}
+
+isl::checked::pw_multi_aff multi_aff::pullback(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).pullback(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::pullback(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).pullback(upma2);
+}
+
+isl::checked::multi_aff multi_aff::pullback(const isl::checked::aff &ma2) const
+{
+  return this->pullback(isl::checked::multi_aff(ma2));
+}
+
+isl::checked::pw_multi_aff multi_aff::range_factor_domain() const
+{
+  return isl::checked::pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::checked::pw_multi_aff multi_aff::range_factor_range() const
+{
+  return isl::checked::pw_multi_aff(*this).range_factor_range();
+}
+
+isl::checked::multi_aff multi_aff::range_map(isl::checked::space space)
+{
+  auto res = isl_multi_aff_range_map(space.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::range_product(isl::checked::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::checked::pw_multi_aff multi_aff::range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::checked::multi_aff multi_aff::range_product(const isl::checked::aff &multi2) const
+{
+  return this->range_product(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::id multi_aff::range_tuple_id() const
+{
+  auto res = isl_multi_aff_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id multi_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::multi_aff multi_aff::reset_range_tuple_id() const
+{
+  auto res = isl_multi_aff_reset_range_tuple_id(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::scale(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_aff_scale_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::scale(isl::checked::val v) const
+{
+  auto res = isl_multi_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_aff multi_aff::scale_down(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_aff_scale_down_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::scale_down(isl::checked::val v) const
+{
+  auto res = isl_multi_aff_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_aff multi_aff::set_at(int pos, isl::checked::aff el) const
+{
+  auto res = isl_multi_aff_set_at(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::set_at(int pos, const isl::checked::pw_aff &el) const
+{
+  return isl::checked::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_aff multi_aff::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_multi_aff_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff multi_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size multi_aff::size() const
+{
+  auto res = isl_multi_aff_size(get());
+  return manage(res);
+}
+
+isl::checked::space multi_aff::space() const
+{
+  auto res = isl_multi_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_aff multi_aff::sub(isl::checked::multi_aff multi2) const
+{
+  auto res = isl_multi_aff_sub(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::sub(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::checked::pw_multi_aff multi_aff::sub(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::sub(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(upma2);
+}
+
+isl::checked::multi_aff multi_aff::sub(const isl::checked::aff &multi2) const
+{
+  return this->sub(isl::checked::multi_aff(multi2));
+}
+
+isl::checked::pw_multi_aff multi_aff::subtract_domain(const isl::checked::set &set) const
+{
+  return isl::checked::pw_multi_aff(*this).subtract_domain(set);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::subtract_domain(const isl::checked::space &space) const
+{
+  return isl::checked::pw_multi_aff(*this).subtract_domain(space);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::subtract_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::pw_multi_aff(*this).subtract_domain(uset);
+}
+
+isl::checked::pw_multi_aff_list multi_aff::to_list() const
+{
+  return isl::checked::pw_multi_aff(*this).to_list();
+}
+
+isl::checked::multi_pw_aff multi_aff::to_multi_pw_aff() const
+{
+  auto res = isl_multi_aff_to_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::to_multi_union_pw_aff() const
+{
+  auto res = isl_multi_aff_to_multi_union_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff multi_aff::to_pw_multi_aff() const
+{
+  auto res = isl_multi_aff_to_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::to_union_pw_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::checked::multi_aff multi_aff::unbind_params_insert_domain(isl::checked::multi_id domain) const
+{
+  auto res = isl_multi_aff_unbind_params_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_aff::union_add(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(mpa2);
+}
+
+isl::checked::multi_union_pw_aff multi_aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(mupa2);
+}
+
+isl::checked::pw_multi_aff multi_aff::union_add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(pma2);
+}
+
+isl::checked::union_pw_multi_aff multi_aff::union_add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::checked::multi_aff multi_aff::zero(isl::checked::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::checked::space space, isl::checked::id_list list)
+{
+  auto res = isl_multi_id_from_id_list(space.release(), list.release());
+  ptr = res;
+}
+
+multi_id::multi_id(isl::checked::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);
+  return *this;
+}
+
+multi_id::~multi_id() {
+  if (ptr)
+    isl_multi_id_free(ptr);
+}
+
+__isl_give isl_multi_id *multi_id::copy() const & {
+  return isl_multi_id_copy(ptr);
+}
+
+__isl_keep isl_multi_id *multi_id::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_id *multi_id::release() {
+  isl_multi_id *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool multi_id::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx multi_id::ctx() const {
+  return isl::checked::ctx(isl_multi_id_get_ctx(ptr));
+}
+
+isl::checked::id multi_id::at(int pos) const
+{
+  auto res = isl_multi_id_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::id multi_id::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::multi_id multi_id::flat_range_product(isl::checked::multi_id multi2) const
+{
+  auto res = isl_multi_id_flat_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::id_list multi_id::list() const
+{
+  auto res = isl_multi_id_get_list(get());
+  return manage(res);
+}
+
+isl::checked::id_list multi_id::get_list() const
+{
+  return list();
+}
+
+boolean multi_id::plain_is_equal(const isl::checked::multi_id &multi2) const
+{
+  auto res = isl_multi_id_plain_is_equal(get(), multi2.get());
+  return manage(res);
+}
+
+isl::checked::multi_id multi_id::range_product(isl::checked::multi_id multi2) const
+{
+  auto res = isl_multi_id_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_id multi_id::set_at(int pos, isl::checked::id el) const
+{
+  auto res = isl_multi_id_set_at(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::multi_id multi_id::set_at(int pos, const std::string &el) const
+{
+  return this->set_at(pos, isl::checked::id(ctx(), el));
+}
+
+class size multi_id::size() const
+{
+  auto res = isl_multi_id_size(get());
+  return manage(res);
+}
+
+isl::checked::space multi_id::space() const
+{
+  auto res = isl_multi_id_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space multi_id::get_space() const
+{
+  return space();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_id &obj)
+{
+  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::checked::aff aff)
+{
+  auto res = isl_multi_pw_aff_from_aff(aff.release());
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::checked::multi_aff ma)
+{
+  auto res = isl_multi_pw_aff_from_multi_aff(ma.release());
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::checked::pw_aff pa)
+{
+  auto res = isl_multi_pw_aff_from_pw_aff(pa.release());
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::checked::space space, isl::checked::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::checked::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::checked::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);
+  return *this;
+}
+
+multi_pw_aff::~multi_pw_aff() {
+  if (ptr)
+    isl_multi_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_pw_aff *multi_pw_aff::copy() const & {
+  return isl_multi_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_pw_aff *multi_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_pw_aff *multi_pw_aff::release() {
+  isl_multi_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool multi_pw_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx multi_pw_aff::ctx() const {
+  return isl::checked::ctx(isl_multi_pw_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_add(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).add(multi2);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add(const isl::checked::aff &multi2) const
+{
+  return this->add(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add(const isl::checked::multi_aff &multi2) const
+{
+  return this->add(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add(const isl::checked::pw_aff &multi2) const
+{
+  return this->add(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add(const isl::checked::pw_multi_aff &multi2) const
+{
+  return this->add(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add_constant(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_pw_aff_add_constant_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add_constant(isl::checked::val v) const
+{
+  auto res = isl_multi_pw_aff_add_constant_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::add_constant(long v) const
+{
+  return this->add_constant(isl::checked::val(ctx(), v));
+}
+
+isl::checked::map multi_pw_aff::as_map() const
+{
+  auto res = isl_multi_pw_aff_as_map(copy());
+  return manage(res);
+}
+
+isl::checked::set multi_pw_aff::as_set() const
+{
+  auto res = isl_multi_pw_aff_as_set(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff multi_pw_aff::at(int pos) const
+{
+  auto res = isl_multi_pw_aff_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::pw_aff multi_pw_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::set multi_pw_aff::bind(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_pw_aff_bind(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::bind_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_pw_aff_bind_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::bind_domain_wrapped_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::coalesce() const
+{
+  auto res = isl_multi_pw_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::set multi_pw_aff::domain() const
+{
+  auto res = isl_multi_pw_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::flat_range_product(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_flat_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::flat_range_product(const isl::checked::aff &multi2) const
+{
+  return this->flat_range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::flat_range_product(const isl::checked::multi_aff &multi2) const
+{
+  return this->flat_range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::flat_range_product(const isl::checked::pw_aff &multi2) const
+{
+  return this->flat_range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::flat_range_product(const isl::checked::pw_multi_aff &multi2) const
+{
+  return this->flat_range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::gist(isl::checked::set set) const
+{
+  auto res = isl_multi_pw_aff_gist(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::multi_union_pw_aff(*this).gist(context);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::gist(const isl::checked::basic_set &set) const
+{
+  return this->gist(isl::checked::set(set));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::gist(const isl::checked::point &set) const
+{
+  return this->gist(isl::checked::set(set));
+}
+
+boolean multi_pw_aff::has_range_tuple_id() const
+{
+  auto res = isl_multi_pw_aff_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::identity() const
+{
+  auto res = isl_multi_pw_aff_identity_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::identity_on_domain(isl::checked::space space)
+{
+  auto res = isl_multi_pw_aff_identity_on_domain_space(space.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::insert_domain(isl::checked::space domain) const
+{
+  auto res = isl_multi_pw_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::intersect_domain(isl::checked::set domain) const
+{
+  auto res = isl_multi_pw_aff_intersect_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::multi_union_pw_aff(*this).intersect_domain(uset);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::intersect_domain(const isl::checked::basic_set &domain) const
+{
+  return this->intersect_domain(isl::checked::set(domain));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::intersect_domain(const isl::checked::point &domain) const
+{
+  return this->intersect_domain(isl::checked::set(domain));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_multi_pw_aff_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+boolean multi_pw_aff::involves_nan() const
+{
+  auto res = isl_multi_pw_aff_involves_nan(get());
+  return manage(res);
+}
+
+boolean multi_pw_aff::involves_param(const isl::checked::id &id) const
+{
+  auto res = isl_multi_pw_aff_involves_param_id(get(), id.get());
+  return manage(res);
+}
+
+boolean multi_pw_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::checked::id(ctx(), id));
+}
+
+boolean multi_pw_aff::involves_param(const isl::checked::id_list &list) const
+{
+  auto res = isl_multi_pw_aff_involves_param_id_list(get(), list.get());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list multi_pw_aff::list() const
+{
+  auto res = isl_multi_pw_aff_get_list(get());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list multi_pw_aff::get_list() const
+{
+  return list();
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::max(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_max(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_pw_aff::max_multi_val() const
+{
+  auto res = isl_multi_pw_aff_max_multi_val(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::min(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_min(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_pw_aff::min_multi_val() const
+{
+  auto res = isl_multi_pw_aff_min_multi_val(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::neg() const
+{
+  auto res = isl_multi_pw_aff_neg(copy());
+  return manage(res);
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::multi_pw_aff &multi2) const
+{
+  auto res = isl_multi_pw_aff_plain_is_equal(get(), multi2.get());
+  return manage(res);
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::aff &multi2) const
+{
+  return this->plain_is_equal(isl::checked::multi_pw_aff(multi2));
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::multi_aff &multi2) const
+{
+  return this->plain_is_equal(isl::checked::multi_pw_aff(multi2));
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::pw_aff &multi2) const
+{
+  return this->plain_is_equal(isl::checked::multi_pw_aff(multi2));
+}
+
+boolean multi_pw_aff::plain_is_equal(const isl::checked::pw_multi_aff &multi2) const
+{
+  return this->plain_is_equal(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::product(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::pullback(isl::checked::multi_aff ma) const
+{
+  auto res = isl_multi_pw_aff_pullback_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::pullback(isl::checked::multi_pw_aff mpa2) const
+{
+  auto res = isl_multi_pw_aff_pullback_multi_pw_aff(copy(), mpa2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::pullback(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_multi_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::pullback(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::multi_union_pw_aff(*this).pullback(upma);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::range_product(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::range_product(const isl::checked::aff &multi2) const
+{
+  return this->range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::range_product(const isl::checked::multi_aff &multi2) const
+{
+  return this->range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::range_product(const isl::checked::pw_aff &multi2) const
+{
+  return this->range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::range_product(const isl::checked::pw_multi_aff &multi2) const
+{
+  return this->range_product(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::id multi_pw_aff::range_tuple_id() const
+{
+  auto res = isl_multi_pw_aff_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id multi_pw_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::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::checked::multi_pw_aff multi_pw_aff::scale(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_pw_aff_scale_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::scale(isl::checked::val v) const
+{
+  auto res = isl_multi_pw_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::scale_down(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_pw_aff_scale_down_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::scale_down(isl::checked::val v) const
+{
+  auto res = isl_multi_pw_aff_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::set_at(int pos, isl::checked::pw_aff el) const
+{
+  auto res = isl_multi_pw_aff_set_at(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::multi_union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_multi_pw_aff_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size multi_pw_aff::size() const
+{
+  auto res = isl_multi_pw_aff_size(get());
+  return manage(res);
+}
+
+isl::checked::space multi_pw_aff::space() const
+{
+  auto res = isl_multi_pw_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space multi_pw_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::sub(isl::checked::multi_pw_aff multi2) const
+{
+  auto res = isl_multi_pw_aff_sub(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::sub(const isl::checked::aff &multi2) const
+{
+  return this->sub(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::sub(const isl::checked::multi_aff &multi2) const
+{
+  return this->sub(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::sub(const isl::checked::pw_aff &multi2) const
+{
+  return this->sub(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::sub(const isl::checked::pw_multi_aff &multi2) const
+{
+  return this->sub(isl::checked::multi_pw_aff(multi2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::unbind_params_insert_domain(isl::checked::multi_id domain) const
+{
+  auto res = isl_multi_pw_aff_unbind_params_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::union_add(isl::checked::multi_pw_aff mpa2) const
+{
+  auto res = isl_multi_pw_aff_union_add(copy(), mpa2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_pw_aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::union_add(const isl::checked::aff &mpa2) const
+{
+  return this->union_add(isl::checked::multi_pw_aff(mpa2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::union_add(const isl::checked::multi_aff &mpa2) const
+{
+  return this->union_add(isl::checked::multi_pw_aff(mpa2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::union_add(const isl::checked::pw_aff &mpa2) const
+{
+  return this->union_add(isl::checked::multi_pw_aff(mpa2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::union_add(const isl::checked::pw_multi_aff &mpa2) const
+{
+  return this->union_add(isl::checked::multi_pw_aff(mpa2));
+}
+
+isl::checked::multi_pw_aff multi_pw_aff::zero(isl::checked::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::checked::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::checked::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::checked::space space, isl::checked::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::checked::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);
+  return *this;
+}
+
+multi_union_pw_aff::~multi_union_pw_aff() {
+  if (ptr)
+    isl_multi_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::copy() const & {
+  return isl_multi_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_union_pw_aff *multi_union_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::release() {
+  isl_multi_union_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool multi_union_pw_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx multi_union_pw_aff::ctx() const {
+  return isl::checked::ctx(isl_multi_union_pw_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::add(isl::checked::multi_union_pw_aff multi2) const
+{
+  auto res = isl_multi_union_pw_aff_add(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff multi_union_pw_aff::at(int pos) const
+{
+  auto res = isl_multi_union_pw_aff_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::union_pw_aff multi_union_pw_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::union_set multi_union_pw_aff::bind(isl::checked::multi_id tuple) const
+{
+  auto res = isl_multi_union_pw_aff_bind(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::coalesce() const
+{
+  auto res = isl_multi_union_pw_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::union_set multi_union_pw_aff::domain() const
+{
+  auto res = isl_multi_union_pw_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::flat_range_product(isl::checked::multi_union_pw_aff multi2) const
+{
+  auto res = isl_multi_union_pw_aff_flat_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::gist(isl::checked::union_set context) const
+{
+  auto res = isl_multi_union_pw_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+boolean multi_union_pw_aff::has_range_tuple_id() const
+{
+  auto res = isl_multi_union_pw_aff_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::intersect_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_multi_union_pw_aff_intersect_domain(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::intersect_params(isl::checked::set params) const
+{
+  auto res = isl_multi_union_pw_aff_intersect_params(copy(), params.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::checked::union_pw_aff_list multi_union_pw_aff::list() const
+{
+  auto res = isl_multi_union_pw_aff_get_list(get());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff_list multi_union_pw_aff::get_list() const
+{
+  return list();
+}
+
+isl::checked::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::checked::multi_union_pw_aff &multi2) const
+{
+  auto res = isl_multi_union_pw_aff_plain_is_equal(get(), multi2.get());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::pullback(isl::checked::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::checked::multi_union_pw_aff multi_union_pw_aff::range_product(isl::checked::multi_union_pw_aff multi2) const
+{
+  auto res = isl_multi_union_pw_aff_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::id multi_union_pw_aff::range_tuple_id() const
+{
+  auto res = isl_multi_union_pw_aff_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id multi_union_pw_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::reset_range_tuple_id() const
+{
+  auto res = isl_multi_union_pw_aff_reset_range_tuple_id(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_union_pw_aff_scale_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale(isl::checked::val v) const
+{
+  auto res = isl_multi_union_pw_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_union_pw_aff_scale_down_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::checked::val v) const
+{
+  auto res = isl_multi_union_pw_aff_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::set_at(int pos, isl::checked::union_pw_aff el) const
+{
+  auto res = isl_multi_union_pw_aff_set_at(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_multi_union_pw_aff_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size multi_union_pw_aff::size() const
+{
+  auto res = isl_multi_union_pw_aff_size(get());
+  return manage(res);
+}
+
+isl::checked::space multi_union_pw_aff::space() const
+{
+  auto res = isl_multi_union_pw_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space multi_union_pw_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::sub(isl::checked::multi_union_pw_aff multi2) const
+{
+  auto res = isl_multi_union_pw_aff_sub(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::union_add(isl::checked::multi_union_pw_aff mupa2) const
+{
+  auto res = isl_multi_union_pw_aff_union_add(copy(), mupa2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff multi_union_pw_aff::zero(isl::checked::space space)
+{
+  auto res = isl_multi_union_pw_aff_zero(space.release());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_union_pw_aff &obj)
+{
+  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::checked::space space, isl::checked::val_list list)
+{
+  auto res = isl_multi_val_from_val_list(space.release(), list.release());
+  ptr = res;
+}
+
+multi_val::multi_val(isl::checked::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);
+  return *this;
+}
+
+multi_val::~multi_val() {
+  if (ptr)
+    isl_multi_val_free(ptr);
+}
+
+__isl_give isl_multi_val *multi_val::copy() const & {
+  return isl_multi_val_copy(ptr);
+}
+
+__isl_keep isl_multi_val *multi_val::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_val *multi_val::release() {
+  isl_multi_val *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool multi_val::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx multi_val::ctx() const {
+  return isl::checked::ctx(isl_multi_val_get_ctx(ptr));
+}
+
+isl::checked::multi_val multi_val::add(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_add(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::add(isl::checked::val v) const
+{
+  auto res = isl_multi_val_add_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::add(long v) const
+{
+  return this->add(isl::checked::val(ctx(), v));
+}
+
+isl::checked::val multi_val::at(int pos) const
+{
+  auto res = isl_multi_val_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::val multi_val::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::multi_val multi_val::flat_range_product(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_flat_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+boolean multi_val::has_range_tuple_id() const
+{
+  auto res = isl_multi_val_has_range_tuple_id(get());
+  return manage(res);
+}
+
+boolean multi_val::involves_nan() const
+{
+  auto res = isl_multi_val_involves_nan(get());
+  return manage(res);
+}
+
+isl::checked::val_list multi_val::list() const
+{
+  auto res = isl_multi_val_get_list(get());
+  return manage(res);
+}
+
+isl::checked::val_list multi_val::get_list() const
+{
+  return list();
+}
+
+isl::checked::multi_val multi_val::max(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_max(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::min(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_min(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::neg() const
+{
+  auto res = isl_multi_val_neg(copy());
+  return manage(res);
+}
+
+boolean multi_val::plain_is_equal(const isl::checked::multi_val &multi2) const
+{
+  auto res = isl_multi_val_plain_is_equal(get(), multi2.get());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::product(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::range_product(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_range_product(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::id multi_val::range_tuple_id() const
+{
+  auto res = isl_multi_val_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id multi_val::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::multi_val multi_val::reset_range_tuple_id() const
+{
+  auto res = isl_multi_val_reset_range_tuple_id(copy());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::scale(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_val_scale_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::scale(isl::checked::val v) const
+{
+  auto res = isl_multi_val_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_val multi_val::scale_down(isl::checked::multi_val mv) const
+{
+  auto res = isl_multi_val_scale_down_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::scale_down(isl::checked::val v) const
+{
+  auto res = isl_multi_val_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_val multi_val::set_at(int pos, isl::checked::val el) const
+{
+  auto res = isl_multi_val_set_at(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::set_at(int pos, long el) const
+{
+  return this->set_at(pos, isl::checked::val(ctx(), el));
+}
+
+isl::checked::multi_val multi_val::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_multi_val_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size multi_val::size() const
+{
+  auto res = isl_multi_val_size(get());
+  return manage(res);
+}
+
+isl::checked::space multi_val::space() const
+{
+  auto res = isl_multi_val_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space multi_val::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_val multi_val::sub(isl::checked::multi_val multi2) const
+{
+  auto res = isl_multi_val_sub(copy(), multi2.release());
+  return manage(res);
+}
+
+isl::checked::multi_val multi_val::zero(isl::checked::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::operator=(point obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+point::~point() {
+  if (ptr)
+    isl_point_free(ptr);
+}
+
+__isl_give isl_point *point::copy() const & {
+  return isl_point_copy(ptr);
+}
+
+__isl_keep isl_point *point::get() const {
+  return ptr;
+}
+
+__isl_give isl_point *point::release() {
+  isl_point *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool point::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx point::ctx() const {
+  return isl::checked::ctx(isl_point_get_ctx(ptr));
+}
+
+isl::checked::basic_set point::affine_hull() const
+{
+  return isl::checked::basic_set(*this).affine_hull();
+}
+
+isl::checked::basic_set point::apply(const isl::checked::basic_map &bmap) const
+{
+  return isl::checked::basic_set(*this).apply(bmap);
+}
+
+isl::checked::set point::apply(const isl::checked::map &map) const
+{
+  return isl::checked::basic_set(*this).apply(map);
+}
+
+isl::checked::union_set point::apply(const isl::checked::union_map &umap) const
+{
+  return isl::checked::basic_set(*this).apply(umap);
+}
+
+isl::checked::pw_multi_aff point::as_pw_multi_aff() const
+{
+  return isl::checked::basic_set(*this).as_pw_multi_aff();
+}
+
+isl::checked::set point::as_set() const
+{
+  return isl::checked::basic_set(*this).as_set();
+}
+
+isl::checked::set point::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::basic_set(*this).bind(tuple);
+}
+
+isl::checked::set point::coalesce() const
+{
+  return isl::checked::basic_set(*this).coalesce();
+}
+
+isl::checked::set point::complement() const
+{
+  return isl::checked::basic_set(*this).complement();
+}
+
+isl::checked::union_set point::compute_divs() const
+{
+  return isl::checked::basic_set(*this).compute_divs();
+}
+
+isl::checked::basic_set point::detect_equalities() const
+{
+  return isl::checked::basic_set(*this).detect_equalities();
+}
+
+isl::checked::val point::dim_max_val(int pos) const
+{
+  return isl::checked::basic_set(*this).dim_max_val(pos);
+}
+
+isl::checked::val point::dim_min_val(int pos) const
+{
+  return isl::checked::basic_set(*this).dim_min_val(pos);
+}
+
+boolean point::every_set(const std::function<boolean(isl::checked::set)> &test) const
+{
+  return isl::checked::basic_set(*this).every_set(test);
+}
+
+isl::checked::set point::extract_set(const isl::checked::space &space) const
+{
+  return isl::checked::basic_set(*this).extract_set(space);
+}
+
+isl::checked::basic_set point::flatten() const
+{
+  return isl::checked::basic_set(*this).flatten();
+}
+
+stat point::foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const
+{
+  return isl::checked::basic_set(*this).foreach_basic_set(fn);
+}
+
+stat point::foreach_point(const std::function<stat(isl::checked::point)> &fn) const
+{
+  return isl::checked::basic_set(*this).foreach_point(fn);
+}
+
+stat point::foreach_set(const std::function<stat(isl::checked::set)> &fn) const
+{
+  return isl::checked::basic_set(*this).foreach_set(fn);
+}
+
+isl::checked::basic_set point::gist(const isl::checked::basic_set &context) const
+{
+  return isl::checked::basic_set(*this).gist(context);
+}
+
+isl::checked::set point::gist(const isl::checked::set &context) const
+{
+  return isl::checked::basic_set(*this).gist(context);
+}
+
+isl::checked::union_set point::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::basic_set(*this).gist(context);
+}
+
+isl::checked::union_set point::gist_params(const isl::checked::set &set) const
+{
+  return isl::checked::basic_set(*this).gist_params(set);
+}
+
+isl::checked::map point::identity() const
+{
+  return isl::checked::basic_set(*this).identity();
+}
+
+isl::checked::pw_aff point::indicator_function() const
+{
+  return isl::checked::basic_set(*this).indicator_function();
+}
+
+isl::checked::map point::insert_domain(const isl::checked::space &domain) const
+{
+  return isl::checked::basic_set(*this).insert_domain(domain);
+}
+
+isl::checked::basic_set point::intersect(const isl::checked::basic_set &bset2) const
+{
+  return isl::checked::basic_set(*this).intersect(bset2);
+}
+
+isl::checked::set point::intersect(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).intersect(set2);
+}
+
+isl::checked::union_set point::intersect(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).intersect(uset2);
+}
+
+isl::checked::basic_set point::intersect_params(const isl::checked::basic_set &bset2) const
+{
+  return isl::checked::basic_set(*this).intersect_params(bset2);
+}
+
+isl::checked::set point::intersect_params(const isl::checked::set &params) const
+{
+  return isl::checked::basic_set(*this).intersect_params(params);
+}
+
+boolean point::involves_locals() const
+{
+  return isl::checked::basic_set(*this).involves_locals();
+}
+
+boolean point::is_disjoint(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).is_disjoint(set2);
+}
+
+boolean point::is_disjoint(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).is_disjoint(uset2);
+}
+
+boolean point::is_empty() const
+{
+  return isl::checked::basic_set(*this).is_empty();
+}
+
+boolean point::is_equal(const isl::checked::basic_set &bset2) const
+{
+  return isl::checked::basic_set(*this).is_equal(bset2);
+}
+
+boolean point::is_equal(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).is_equal(set2);
+}
+
+boolean point::is_equal(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).is_equal(uset2);
+}
+
+boolean point::is_singleton() const
+{
+  return isl::checked::basic_set(*this).is_singleton();
+}
+
+boolean point::is_strict_subset(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).is_strict_subset(set2);
+}
+
+boolean point::is_strict_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).is_strict_subset(uset2);
+}
+
+boolean point::is_subset(const isl::checked::basic_set &bset2) const
+{
+  return isl::checked::basic_set(*this).is_subset(bset2);
+}
+
+boolean point::is_subset(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).is_subset(set2);
+}
+
+boolean point::is_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).is_subset(uset2);
+}
+
+boolean point::is_wrapping() const
+{
+  return isl::checked::basic_set(*this).is_wrapping();
+}
+
+boolean point::isa_set() const
+{
+  return isl::checked::basic_set(*this).isa_set();
+}
+
+isl::checked::set point::lexmax() const
+{
+  return isl::checked::basic_set(*this).lexmax();
+}
+
+isl::checked::pw_multi_aff point::lexmax_pw_multi_aff() const
+{
+  return isl::checked::basic_set(*this).lexmax_pw_multi_aff();
+}
+
+isl::checked::set point::lexmin() const
+{
+  return isl::checked::basic_set(*this).lexmin();
+}
+
+isl::checked::pw_multi_aff point::lexmin_pw_multi_aff() const
+{
+  return isl::checked::basic_set(*this).lexmin_pw_multi_aff();
+}
+
+isl::checked::set point::lower_bound(const isl::checked::multi_pw_aff &lower) const
+{
+  return isl::checked::basic_set(*this).lower_bound(lower);
+}
+
+isl::checked::set point::lower_bound(const isl::checked::multi_val &lower) const
+{
+  return isl::checked::basic_set(*this).lower_bound(lower);
+}
+
+isl::checked::multi_pw_aff point::max_multi_pw_aff() const
+{
+  return isl::checked::basic_set(*this).max_multi_pw_aff();
+}
+
+isl::checked::val point::max_val(const isl::checked::aff &obj) const
+{
+  return isl::checked::basic_set(*this).max_val(obj);
+}
+
+isl::checked::multi_pw_aff point::min_multi_pw_aff() const
+{
+  return isl::checked::basic_set(*this).min_multi_pw_aff();
+}
+
+isl::checked::val point::min_val(const isl::checked::aff &obj) const
+{
+  return isl::checked::basic_set(*this).min_val(obj);
+}
+
+isl::checked::multi_val point::multi_val() const
+{
+  auto res = isl_point_get_multi_val(get());
+  return manage(res);
+}
+
+isl::checked::multi_val point::get_multi_val() const
+{
+  return multi_val();
+}
+
+isl::checked::basic_set point::params() const
+{
+  return isl::checked::basic_set(*this).params();
+}
+
+isl::checked::multi_val point::plain_multi_val_if_fixed() const
+{
+  return isl::checked::basic_set(*this).plain_multi_val_if_fixed();
+}
+
+isl::checked::basic_set point::polyhedral_hull() const
+{
+  return isl::checked::basic_set(*this).polyhedral_hull();
+}
+
+isl::checked::set point::preimage(const isl::checked::multi_aff &ma) const
+{
+  return isl::checked::basic_set(*this).preimage(ma);
+}
+
+isl::checked::set point::preimage(const isl::checked::multi_pw_aff &mpa) const
+{
+  return isl::checked::basic_set(*this).preimage(mpa);
+}
+
+isl::checked::set point::preimage(const isl::checked::pw_multi_aff &pma) const
+{
+  return isl::checked::basic_set(*this).preimage(pma);
+}
+
+isl::checked::union_set point::preimage(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::basic_set(*this).preimage(upma);
+}
+
+isl::checked::set point::product(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).product(set2);
+}
+
+isl::checked::set point::project_out_all_params() const
+{
+  return isl::checked::basic_set(*this).project_out_all_params();
+}
+
+isl::checked::set point::project_out_param(const isl::checked::id &id) const
+{
+  return isl::checked::basic_set(*this).project_out_param(id);
+}
+
+isl::checked::set point::project_out_param(const std::string &id) const
+{
+  return this->project_out_param(isl::checked::id(ctx(), id));
+}
+
+isl::checked::set point::project_out_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::basic_set(*this).project_out_param(list);
+}
+
+isl::checked::pw_multi_aff point::pw_multi_aff_on_domain(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::basic_set(*this).pw_multi_aff_on_domain(mv);
+}
+
+isl::checked::basic_set point::sample() const
+{
+  return isl::checked::basic_set(*this).sample();
+}
+
+isl::checked::point point::sample_point() const
+{
+  return isl::checked::basic_set(*this).sample_point();
+}
+
+isl::checked::fixed_box point::simple_fixed_box_hull() const
+{
+  return isl::checked::basic_set(*this).simple_fixed_box_hull();
+}
+
+isl::checked::space point::space() const
+{
+  return isl::checked::basic_set(*this).space();
+}
+
+isl::checked::val point::stride(int pos) const
+{
+  return isl::checked::basic_set(*this).stride(pos);
+}
+
+isl::checked::set point::subtract(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).subtract(set2);
+}
+
+isl::checked::union_set point::subtract(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).subtract(uset2);
+}
+
+isl::checked::union_set_list point::to_list() const
+{
+  return isl::checked::basic_set(*this).to_list();
+}
+
+isl::checked::set point::to_set() const
+{
+  auto res = isl_point_to_set(copy());
+  return manage(res);
+}
+
+isl::checked::union_set point::to_union_set() const
+{
+  return isl::checked::basic_set(*this).to_union_set();
+}
+
+isl::checked::map point::translation() const
+{
+  return isl::checked::basic_set(*this).translation();
+}
+
+isl::checked::set point::unbind_params(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::basic_set(*this).unbind_params(tuple);
+}
+
+isl::checked::map point::unbind_params_insert_domain(const isl::checked::multi_id &domain) const
+{
+  return isl::checked::basic_set(*this).unbind_params_insert_domain(domain);
+}
+
+isl::checked::set point::unite(const isl::checked::basic_set &bset2) const
+{
+  return isl::checked::basic_set(*this).unite(bset2);
+}
+
+isl::checked::set point::unite(const isl::checked::set &set2) const
+{
+  return isl::checked::basic_set(*this).unite(set2);
+}
+
+isl::checked::union_set point::unite(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::basic_set(*this).unite(uset2);
+}
+
+isl::checked::basic_set point::unshifted_simple_hull() const
+{
+  return isl::checked::basic_set(*this).unshifted_simple_hull();
+}
+
+isl::checked::map point::unwrap() const
+{
+  return isl::checked::basic_set(*this).unwrap();
+}
+
+isl::checked::set point::upper_bound(const isl::checked::multi_pw_aff &upper) const
+{
+  return isl::checked::basic_set(*this).upper_bound(upper);
+}
+
+isl::checked::set point::upper_bound(const isl::checked::multi_val &upper) const
+{
+  return isl::checked::basic_set(*this).upper_bound(upper);
+}
+
+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::pw_aff(const pw_aff &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
+    : ptr(ptr) {}
+
+pw_aff::pw_aff(isl::checked::aff aff)
+{
+  auto res = isl_pw_aff_from_aff(aff.release());
+  ptr = res;
+}
+
+pw_aff::pw_aff(isl::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_pw_aff_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+pw_aff &pw_aff::operator=(pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_aff::~pw_aff() {
+  if (ptr)
+    isl_pw_aff_free(ptr);
+}
+
+__isl_give isl_pw_aff *pw_aff::copy() const & {
+  return isl_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_pw_aff *pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_aff *pw_aff::release() {
+  isl_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool pw_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx pw_aff::ctx() const {
+  return isl::checked::ctx(isl_pw_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_pw_aff pw_aff::add(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::union_pw_aff(*this).add(multi2);
+}
+
+isl::checked::pw_aff pw_aff::add(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_add(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_aff::add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).add(pma2);
+}
+
+isl::checked::union_pw_aff pw_aff::add(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::union_pw_aff(*this).add(upa2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).add(upma2);
+}
+
+isl::checked::pw_aff pw_aff::add(const isl::checked::aff &pwaff2) const
+{
+  return this->add(isl::checked::pw_aff(pwaff2));
+}
+
+isl::checked::pw_aff pw_aff::add_constant(isl::checked::val v) const
+{
+  auto res = isl_pw_aff_add_constant_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::add_constant(long v) const
+{
+  return this->add_constant(isl::checked::val(ctx(), v));
+}
+
+isl::checked::pw_multi_aff pw_aff::add_constant(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::pw_multi_aff(*this).add_constant(mv);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::apply(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).apply(upma2);
+}
+
+isl::checked::aff pw_aff::as_aff() const
+{
+  auto res = isl_pw_aff_as_aff(copy());
+  return manage(res);
+}
+
+isl::checked::map pw_aff::as_map() const
+{
+  auto res = isl_pw_aff_as_map(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff pw_aff::as_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).as_multi_aff();
+}
+
+isl::checked::multi_union_pw_aff pw_aff::as_multi_union_pw_aff() const
+{
+  return isl::checked::union_pw_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff pw_aff::as_pw_multi_aff() const
+{
+  return isl::checked::union_pw_aff(*this).as_pw_multi_aff();
+}
+
+isl::checked::set pw_aff::as_set() const
+{
+  return isl::checked::pw_multi_aff(*this).as_set();
+}
+
+isl::checked::union_map pw_aff::as_union_map() const
+{
+  return isl::checked::union_pw_aff(*this).as_union_map();
+}
+
+isl::checked::pw_aff pw_aff::at(int pos) const
+{
+  return isl::checked::pw_multi_aff(*this).at(pos);
+}
+
+isl::checked::set pw_aff::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::multi_pw_aff(*this).bind(tuple);
+}
+
+isl::checked::set pw_aff::bind(isl::checked::id id) const
+{
+  auto res = isl_pw_aff_bind_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::set pw_aff::bind(const std::string &id) const
+{
+  return this->bind(isl::checked::id(ctx(), id));
+}
+
+isl::checked::pw_aff pw_aff::bind_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_pw_aff_bind_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::bind_domain_wrapped_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::ceil() const
+{
+  auto res = isl_pw_aff_ceil(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::coalesce() const
+{
+  auto res = isl_pw_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::cond(isl::checked::pw_aff pwaff_true, isl::checked::pw_aff pwaff_false) const
+{
+  auto res = isl_pw_aff_cond(copy(), pwaff_true.release(), pwaff_false.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::div(isl::checked::pw_aff pa2) const
+{
+  auto res = isl_pw_aff_div(copy(), pa2.release());
+  return manage(res);
+}
+
+isl::checked::set pw_aff::domain() const
+{
+  auto res = isl_pw_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::set pw_aff::eq_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_eq_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::val pw_aff::eval(isl::checked::point pnt) const
+{
+  auto res = isl_pw_aff_eval(copy(), pnt.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_aff::extract_pw_multi_aff(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::checked::multi_pw_aff pw_aff::flat_range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_aff::flat_range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).flat_range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).flat_range_product(upma2);
+}
+
+isl::checked::pw_aff pw_aff::floor() const
+{
+  auto res = isl_pw_aff_floor(copy());
+  return manage(res);
+}
+
+stat pw_aff::foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const
+{
+  return isl::checked::pw_multi_aff(*this).foreach_piece(fn);
+}
+
+isl::checked::set pw_aff::ge_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_ge_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::gist(isl::checked::set context) const
+{
+  auto res = isl_pw_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff pw_aff::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::union_pw_aff(*this).gist(context);
+}
+
+isl::checked::pw_aff pw_aff::gist(const isl::checked::basic_set &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::pw_aff pw_aff::gist(const isl::checked::point &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::set pw_aff::gt_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_gt_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+boolean pw_aff::has_range_tuple_id() const
+{
+  return isl::checked::pw_multi_aff(*this).has_range_tuple_id();
+}
+
+isl::checked::multi_pw_aff pw_aff::identity() const
+{
+  return isl::checked::pw_multi_aff(*this).identity();
+}
+
+isl::checked::pw_aff pw_aff::insert_domain(isl::checked::space domain) const
+{
+  auto res = isl_pw_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::intersect_domain(isl::checked::set set) const
+{
+  auto res = isl_pw_aff_intersect_domain(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff pw_aff::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_aff(*this).intersect_domain(space);
+}
+
+isl::checked::union_pw_aff pw_aff::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_aff(*this).intersect_domain(uset);
+}
+
+isl::checked::pw_aff pw_aff::intersect_domain(const isl::checked::basic_set &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_aff pw_aff::intersect_domain(const isl::checked::point &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::union_pw_aff pw_aff::intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::checked::union_pw_aff pw_aff::intersect_domain_wrapped_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::checked::pw_aff pw_aff::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_pw_aff_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+boolean pw_aff::involves_locals() const
+{
+  return isl::checked::pw_multi_aff(*this).involves_locals();
+}
+
+boolean pw_aff::involves_nan() const
+{
+  return isl::checked::multi_pw_aff(*this).involves_nan();
+}
+
+boolean pw_aff::involves_param(const isl::checked::id &id) const
+{
+  return isl::checked::pw_multi_aff(*this).involves_param(id);
+}
+
+boolean pw_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::checked::id(ctx(), id));
+}
+
+boolean pw_aff::involves_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::pw_multi_aff(*this).involves_param(list);
+}
+
+boolean pw_aff::isa_aff() const
+{
+  auto res = isl_pw_aff_isa_aff(get());
+  return manage(res);
+}
+
+boolean pw_aff::isa_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).isa_multi_aff();
+}
+
+boolean pw_aff::isa_pw_multi_aff() const
+{
+  return isl::checked::union_pw_aff(*this).isa_pw_multi_aff();
+}
+
+isl::checked::set pw_aff::le_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_le_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list pw_aff::list() const
+{
+  return isl::checked::multi_pw_aff(*this).list();
+}
+
+isl::checked::set pw_aff::lt_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_lt_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_aff::max(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).max(multi2);
+}
+
+isl::checked::pw_aff pw_aff::max(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_max(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::max(const isl::checked::aff &pwaff2) const
+{
+  return this->max(isl::checked::pw_aff(pwaff2));
+}
+
+isl::checked::multi_val pw_aff::max_multi_val() const
+{
+  return isl::checked::pw_multi_aff(*this).max_multi_val();
+}
+
+isl::checked::multi_pw_aff pw_aff::min(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).min(multi2);
+}
+
+isl::checked::pw_aff pw_aff::min(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_min(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::min(const isl::checked::aff &pwaff2) const
+{
+  return this->min(isl::checked::pw_aff(pwaff2));
+}
+
+isl::checked::multi_val pw_aff::min_multi_val() const
+{
+  return isl::checked::pw_multi_aff(*this).min_multi_val();
+}
+
+isl::checked::pw_aff pw_aff::mod(isl::checked::val mod) const
+{
+  auto res = isl_pw_aff_mod_val(copy(), mod.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::mod(long mod) const
+{
+  return this->mod(isl::checked::val(ctx(), mod));
+}
+
+isl::checked::pw_aff pw_aff::mul(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_mul(copy(), pwaff2.release());
+  return manage(res);
+}
+
+class size pw_aff::n_piece() const
+{
+  return isl::checked::pw_multi_aff(*this).n_piece();
+}
+
+isl::checked::set pw_aff::ne_set(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_ne_set(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::neg() const
+{
+  auto res = isl_pw_aff_neg(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::param_on_domain(isl::checked::set domain, isl::checked::id id)
+{
+  auto res = isl_pw_aff_param_on_domain_id(domain.release(), id.release());
+  return manage(res);
+}
+
+boolean pw_aff::plain_is_empty() const
+{
+  return isl::checked::union_pw_aff(*this).plain_is_empty();
+}
+
+boolean pw_aff::plain_is_equal(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+boolean pw_aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::checked::pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::checked::multi_pw_aff pw_aff::product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_aff::product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).product(pma2);
+}
+
+isl::checked::pw_aff pw_aff::pullback(isl::checked::multi_aff ma) const
+{
+  auto res = isl_pw_aff_pullback_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::pullback(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_pw_aff_pullback_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::pullback(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff pw_aff::pullback(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::union_pw_aff(*this).pullback(upma);
+}
+
+isl::checked::pw_multi_aff pw_aff::range_factor_domain() const
+{
+  return isl::checked::pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::checked::pw_multi_aff pw_aff::range_factor_range() const
+{
+  return isl::checked::pw_multi_aff(*this).range_factor_range();
+}
+
+isl::checked::multi_pw_aff pw_aff::range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::union_pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_aff::range_product(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).range_product(pma2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).range_product(upma2);
+}
+
+isl::checked::id pw_aff::range_tuple_id() const
+{
+  return isl::checked::pw_multi_aff(*this).range_tuple_id();
+}
+
+isl::checked::multi_pw_aff pw_aff::reset_range_tuple_id() const
+{
+  return isl::checked::multi_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::checked::multi_pw_aff pw_aff::scale(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_pw_aff(*this).scale(mv);
+}
+
+isl::checked::pw_aff pw_aff::scale(isl::checked::val v) const
+{
+  auto res = isl_pw_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_pw_aff pw_aff::scale_down(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_pw_aff(*this).scale_down(mv);
+}
+
+isl::checked::pw_aff pw_aff::scale_down(isl::checked::val f) const
+{
+  auto res = isl_pw_aff_scale_down_val(copy(), f.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::scale_down(long f) const
+{
+  return this->scale_down(isl::checked::val(ctx(), f));
+}
+
+isl::checked::multi_pw_aff pw_aff::set_at(int pos, const isl::checked::pw_aff &el) const
+{
+  return isl::checked::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::pw_multi_aff pw_aff::set_range_tuple(const isl::checked::id &id) const
+{
+  return isl::checked::pw_multi_aff(*this).set_range_tuple(id);
+}
+
+isl::checked::pw_multi_aff pw_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size pw_aff::size() const
+{
+  return isl::checked::multi_pw_aff(*this).size();
+}
+
+isl::checked::space pw_aff::space() const
+{
+  return isl::checked::union_pw_aff(*this).space();
+}
+
+isl::checked::multi_pw_aff pw_aff::sub(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::union_pw_aff(*this).sub(multi2);
+}
+
+isl::checked::pw_aff pw_aff::sub(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_sub(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_aff::sub(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).sub(pma2);
+}
+
+isl::checked::union_pw_aff pw_aff::sub(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::union_pw_aff(*this).sub(upa2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::sub(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).sub(upma2);
+}
+
+isl::checked::pw_aff pw_aff::sub(const isl::checked::aff &pwaff2) const
+{
+  return this->sub(isl::checked::pw_aff(pwaff2));
+}
+
+isl::checked::pw_aff pw_aff::subtract_domain(isl::checked::set set) const
+{
+  auto res = isl_pw_aff_subtract_domain(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff pw_aff::subtract_domain(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_aff(*this).subtract_domain(space);
+}
+
+isl::checked::union_pw_aff pw_aff::subtract_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_aff(*this).subtract_domain(uset);
+}
+
+isl::checked::pw_aff pw_aff::subtract_domain(const isl::checked::basic_set &set) const
+{
+  return this->subtract_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_aff pw_aff::subtract_domain(const isl::checked::point &set) const
+{
+  return this->subtract_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_aff pw_aff::tdiv_q(isl::checked::pw_aff pa2) const
+{
+  auto res = isl_pw_aff_tdiv_q(copy(), pa2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff::tdiv_r(isl::checked::pw_aff pa2) const
+{
+  auto res = isl_pw_aff_tdiv_r(copy(), pa2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list pw_aff::to_list() const
+{
+  auto res = isl_pw_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_aff::to_multi_pw_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).to_multi_pw_aff();
+}
+
+isl::checked::union_pw_aff pw_aff::to_union_pw_aff() const
+{
+  auto res = isl_pw_aff_to_union_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::to_union_pw_multi_aff() const
+{
+  return isl::checked::pw_multi_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::checked::multi_pw_aff pw_aff::unbind_params_insert_domain(const isl::checked::multi_id &domain) const
+{
+  return isl::checked::pw_multi_aff(*this).unbind_params_insert_domain(domain);
+}
+
+isl::checked::multi_pw_aff pw_aff::union_add(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(mpa2);
+}
+
+isl::checked::multi_union_pw_aff pw_aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::checked::pw_aff pw_aff::union_add(isl::checked::pw_aff pwaff2) const
+{
+  auto res = isl_pw_aff_union_add(copy(), pwaff2.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_aff::union_add(const isl::checked::pw_multi_aff &pma2) const
+{
+  return isl::checked::pw_multi_aff(*this).union_add(pma2);
+}
+
+isl::checked::union_pw_aff pw_aff::union_add(const isl::checked::union_pw_aff &upa2) const
+{
+  return isl::checked::union_pw_aff(*this).union_add(upa2);
+}
+
+isl::checked::union_pw_multi_aff pw_aff::union_add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_aff(*this).union_add(upma2);
+}
+
+isl::checked::pw_aff pw_aff::union_add(const isl::checked::aff &pwaff2) const
+{
+  return this->union_add(isl::checked::pw_aff(pwaff2));
+}
+
+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;
+}
+
+// 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_aff_list::pw_aff_list()
+    : ptr(nullptr) {}
+
+pw_aff_list::pw_aff_list(const pw_aff_list &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
+    : ptr(ptr) {}
+
+pw_aff_list::pw_aff_list(isl::checked::ctx ctx, int n)
+{
+  auto res = isl_pw_aff_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+pw_aff_list::pw_aff_list(isl::checked::pw_aff el)
+{
+  auto res = isl_pw_aff_list_from_pw_aff(el.release());
+  ptr = res;
+}
+
+pw_aff_list &pw_aff_list::operator=(pw_aff_list obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_aff_list::~pw_aff_list() {
+  if (ptr)
+    isl_pw_aff_list_free(ptr);
+}
+
+__isl_give isl_pw_aff_list *pw_aff_list::copy() const & {
+  return isl_pw_aff_list_copy(ptr);
+}
+
+__isl_keep isl_pw_aff_list *pw_aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_aff_list *pw_aff_list::release() {
+  isl_pw_aff_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool pw_aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx pw_aff_list::ctx() const {
+  return isl::checked::ctx(isl_pw_aff_list_get_ctx(ptr));
+}
+
+isl::checked::pw_aff_list pw_aff_list::add(isl::checked::pw_aff el) const
+{
+  auto res = isl_pw_aff_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff_list::at(int index) const
+{
+  auto res = isl_pw_aff_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::pw_aff_list pw_aff_list::clear() const
+{
+  auto res = isl_pw_aff_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list pw_aff_list::concat(isl::checked::pw_aff_list list2) const
+{
+  auto res = isl_pw_aff_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::pw_aff_list pw_aff_list::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl_pw_aff_list_drop(copy(), first, n);
+  return manage(res);
+}
+
+stat pw_aff_list::foreach(const std::function<stat(isl::checked::pw_aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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::checked::pw_aff_list pw_aff_list::insert(unsigned int pos, isl::checked::pw_aff el) const
+{
+  auto res = isl_pw_aff_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size pw_aff_list::size() const
+{
+  auto res = isl_pw_aff_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_aff_list &obj)
+{
+  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);
+}
+
+pw_multi_aff::pw_multi_aff()
+    : ptr(nullptr) {}
+
+pw_multi_aff::pw_multi_aff(const pw_multi_aff &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+pw_multi_aff::pw_multi_aff(__isl_take isl_pw_multi_aff *ptr)
+    : ptr(ptr) {}
+
+pw_multi_aff::pw_multi_aff(isl::checked::multi_aff ma)
+{
+  auto res = isl_pw_multi_aff_from_multi_aff(ma.release());
+  ptr = res;
+}
+
+pw_multi_aff::pw_multi_aff(isl::checked::pw_aff pa)
+{
+  auto res = isl_pw_multi_aff_from_pw_aff(pa.release());
+  ptr = res;
+}
+
+pw_multi_aff::pw_multi_aff(isl::checked::ctx ctx, const std::string &str)
+{
+  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_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::checked::ctx pw_multi_aff::ctx() const {
+  return isl::checked::ctx(isl_pw_multi_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::add(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).add(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).add(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_add(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).add(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add(const isl::checked::multi_aff &pma2) const
+{
+  return this->add(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add(const isl::checked::pw_aff &pma2) const
+{
+  return this->add(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add_constant(isl::checked::multi_val mv) const
+{
+  auto res = isl_pw_multi_aff_add_constant_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add_constant(isl::checked::val v) const
+{
+  auto res = isl_pw_multi_aff_add_constant_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::add_constant(long v) const
+{
+  return this->add_constant(isl::checked::val(ctx(), v));
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::apply(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).apply(upma2);
+}
+
+isl::checked::map pw_multi_aff::as_map() const
+{
+  auto res = isl_pw_multi_aff_as_map(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff pw_multi_aff::as_multi_aff() const
+{
+  auto res = isl_pw_multi_aff_as_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::as_multi_union_pw_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::as_pw_multi_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::checked::set pw_multi_aff::as_set() const
+{
+  auto res = isl_pw_multi_aff_as_set(copy());
+  return manage(res);
+}
+
+isl::checked::union_map pw_multi_aff::as_union_map() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_union_map();
+}
+
+isl::checked::pw_aff pw_multi_aff::at(int pos) const
+{
+  auto res = isl_pw_multi_aff_get_at(get(), pos);
+  return manage(res);
+}
+
+isl::checked::pw_aff pw_multi_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::checked::set pw_multi_aff::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::multi_pw_aff(*this).bind(tuple);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::bind_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_pw_multi_aff_bind_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::bind_domain_wrapped_domain(isl::checked::multi_id tuple) const
+{
+  auto res = isl_pw_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::coalesce() const
+{
+  auto res = isl_pw_multi_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::set pw_multi_aff::domain() const
+{
+  auto res = isl_pw_multi_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::domain_map(isl::checked::space space)
+{
+  auto res = isl_pw_multi_aff_domain_map(space.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::extract_pw_multi_aff(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::flat_range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::flat_range_product(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_flat_range_product(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::flat_range_product(const isl::checked::multi_aff &pma2) const
+{
+  return this->flat_range_product(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::flat_range_product(const isl::checked::pw_aff &pma2) const
+{
+  return this->flat_range_product(isl::checked::pw_multi_aff(pma2));
+}
+
+stat pw_multi_aff::foreach_piece(const std::function<stat(isl::checked::set, isl::checked::multi_aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::set, isl::checked::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::checked::pw_multi_aff pw_multi_aff::gist(isl::checked::set set) const
+{
+  auto res = isl_pw_multi_aff_gist(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::union_pw_multi_aff(*this).gist(context);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::gist(const isl::checked::basic_set &set) const
+{
+  return this->gist(isl::checked::set(set));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::gist(const isl::checked::point &set) const
+{
+  return this->gist(isl::checked::set(set));
+}
+
+boolean pw_multi_aff::has_range_tuple_id() const
+{
+  auto res = isl_pw_multi_aff_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::identity() const
+{
+  return isl::checked::multi_pw_aff(*this).identity();
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::identity_on_domain(isl::checked::space space)
+{
+  auto res = isl_pw_multi_aff_identity_on_domain_space(space.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::insert_domain(isl::checked::space domain) const
+{
+  auto res = isl_pw_multi_aff_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::intersect_domain(isl::checked::set set) const
+{
+  auto res = isl_pw_multi_aff_intersect_domain(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_multi_aff(*this).intersect_domain(space);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_multi_aff(*this).intersect_domain(uset);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::intersect_domain(const isl::checked::basic_set &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::intersect_domain(const isl::checked::point &set) const
+{
+  return this->intersect_domain(isl::checked::set(set));
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::intersect_domain_wrapped_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_multi_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::intersect_domain_wrapped_range(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_pw_multi_aff_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+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::checked::multi_pw_aff(*this).involves_nan();
+}
+
+boolean pw_multi_aff::involves_param(const isl::checked::id &id) const
+{
+  return isl::checked::multi_pw_aff(*this).involves_param(id);
+}
+
+boolean pw_multi_aff::involves_param(const std::string &id) const
+{
+  return this->involves_param(isl::checked::id(ctx(), id));
+}
+
+boolean pw_multi_aff::involves_param(const isl::checked::id_list &list) const
+{
+  return isl::checked::multi_pw_aff(*this).involves_param(list);
+}
+
+boolean pw_multi_aff::isa_multi_aff() const
+{
+  auto res = isl_pw_multi_aff_isa_multi_aff(get());
+  return manage(res);
+}
+
+boolean pw_multi_aff::isa_pw_multi_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::checked::pw_aff_list pw_multi_aff::list() const
+{
+  return isl::checked::multi_pw_aff(*this).list();
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::max(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).max(multi2);
+}
+
+isl::checked::multi_val pw_multi_aff::max_multi_val() const
+{
+  auto res = isl_pw_multi_aff_max_multi_val(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::min(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).min(multi2);
+}
+
+isl::checked::multi_val pw_multi_aff::min_multi_val() const
+{
+  auto res = isl_pw_multi_aff_min_multi_val(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::multi_val_on_domain(isl::checked::set domain, isl::checked::multi_val mv)
+{
+  auto res = isl_pw_multi_aff_multi_val_on_domain(domain.release(), mv.release());
+  return manage(res);
+}
+
+class size pw_multi_aff::n_piece() const
+{
+  auto res = isl_pw_multi_aff_n_piece(get());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::neg() const
+{
+  return isl::checked::multi_pw_aff(*this).neg();
+}
+
+boolean pw_multi_aff::plain_is_empty() const
+{
+  return isl::checked::union_pw_multi_aff(*this).plain_is_empty();
+}
+
+boolean pw_multi_aff::plain_is_equal(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).plain_is_equal(multi2);
+}
+
+boolean pw_multi_aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(isl::checked::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::checked::union_pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::checked::multi_aff &pma2) const
+{
+  return this->preimage_domain_wrapped_domain(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::checked::pw_aff &pma2) const
+{
+  return this->preimage_domain_wrapped_domain(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::product(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_product(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::product(const isl::checked::multi_aff &pma2) const
+{
+  return this->product(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::product(const isl::checked::pw_aff &pma2) const
+{
+  return this->product(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::pullback(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::multi_pw_aff(*this).pullback(mpa2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::pullback(isl::checked::multi_aff ma) const
+{
+  auto res = isl_pw_multi_aff_pullback_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::pullback(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_pullback_pw_multi_aff(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::pullback(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).pullback(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_factor_domain() const
+{
+  auto res = isl_pw_multi_aff_range_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_factor_range() const
+{
+  auto res = isl_pw_multi_aff_range_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_map(isl::checked::space space)
+{
+  auto res = isl_pw_multi_aff_range_map(space.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::range_product(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_product(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_range_product(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_product(const isl::checked::multi_aff &pma2) const
+{
+  return this->range_product(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::range_product(const isl::checked::pw_aff &pma2) const
+{
+  return this->range_product(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::id pw_multi_aff::range_tuple_id() const
+{
+  auto res = isl_pw_multi_aff_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id pw_multi_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::reset_range_tuple_id() const
+{
+  return isl::checked::multi_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::scale(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_pw_aff(*this).scale(mv);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::scale(isl::checked::val v) const
+{
+  auto res = isl_pw_multi_aff_scale_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::scale_down(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_pw_aff(*this).scale_down(mv);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::scale_down(isl::checked::val v) const
+{
+  auto res = isl_pw_multi_aff_scale_down_val(copy(), v.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::set_at(int pos, const isl::checked::pw_aff &el) const
+{
+  return isl::checked::multi_pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::multi_pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_pw_multi_aff_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size pw_multi_aff::size() const
+{
+  return isl::checked::multi_pw_aff(*this).size();
+}
+
+isl::checked::space pw_multi_aff::space() const
+{
+  auto res = isl_pw_multi_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space pw_multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::sub(const isl::checked::multi_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).sub(multi2);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_pw_aff(*this).sub(multi2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::sub(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_sub(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::sub(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).sub(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::sub(const isl::checked::multi_aff &pma2) const
+{
+  return this->sub(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::sub(const isl::checked::pw_aff &pma2) const
+{
+  return this->sub(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::subtract_domain(isl::checked::set set) const
+{
+  auto res = isl_pw_multi_aff_subtract_domain(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_multi_aff(*this).subtract_domain(space);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::checked::union_set &uset) const
+{
+  return isl::checked::union_pw_multi_aff(*this).subtract_domain(uset);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::subtract_domain(const isl::checked::basic_set &set) const
+{
+  return this->subtract_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::subtract_domain(const isl::checked::point &set) const
+{
+  return this->subtract_domain(isl::checked::set(set));
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff::to_list() const
+{
+  auto res = isl_pw_multi_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::to_multi_pw_aff() const
+{
+  auto res = isl_pw_multi_aff_to_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::to_union_pw_multi_aff() const
+{
+  auto res = isl_pw_multi_aff_to_union_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::unbind_params_insert_domain(const isl::checked::multi_id &domain) const
+{
+  return isl::checked::multi_pw_aff(*this).unbind_params_insert_domain(domain);
+}
+
+isl::checked::multi_pw_aff pw_multi_aff::union_add(const isl::checked::multi_pw_aff &mpa2) const
+{
+  return isl::checked::multi_pw_aff(*this).union_add(mpa2);
+}
+
+isl::checked::multi_union_pw_aff pw_multi_aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::multi_pw_aff(*this).union_add(mupa2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::union_add(isl::checked::pw_multi_aff pma2) const
+{
+  auto res = isl_pw_multi_aff_union_add(copy(), pma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff pw_multi_aff::union_add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::union_add(const isl::checked::multi_aff &pma2) const
+{
+  return this->union_add(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::union_add(const isl::checked::pw_aff &pma2) const
+{
+  return this->union_add(isl::checked::pw_multi_aff(pma2));
+}
+
+isl::checked::pw_multi_aff pw_multi_aff::zero(isl::checked::space space)
+{
+  auto res = isl_pw_multi_aff_zero(space.release());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff &obj)
+{
+  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::pw_multi_aff_list
+pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr) {
+  return pw_multi_aff_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);
+}
+
+pw_multi_aff_list::pw_multi_aff_list()
+    : ptr(nullptr) {}
+
+pw_multi_aff_list::pw_multi_aff_list(const pw_multi_aff_list &obj)
+    : ptr(nullptr)
+{
+  ptr = obj.copy();
+}
+
+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::checked::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::checked::pw_multi_aff el)
+{
+  auto res = isl_pw_multi_aff_list_from_pw_multi_aff(el.release());
+  ptr = res;
+}
+
+pw_multi_aff_list &pw_multi_aff_list::operator=(pw_multi_aff_list obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_multi_aff_list::~pw_multi_aff_list() {
+  if (ptr)
+    isl_pw_multi_aff_list_free(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_pw_multi_aff_list *pw_multi_aff_list::get() const {
+  return 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 pw_multi_aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx pw_multi_aff_list::ctx() const {
+  return isl::checked::ctx(isl_pw_multi_aff_list_get_ctx(ptr));
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff_list::add(isl::checked::pw_multi_aff el) const
+{
+  auto res = isl_pw_multi_aff_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff_list::at(int index) const
+{
+  auto res = isl_pw_multi_aff_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff pw_multi_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff_list::clear() const
+{
+  auto res = isl_pw_multi_aff_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff_list::concat(isl::checked::pw_multi_aff_list list2) const
+{
+  auto res = isl_pw_multi_aff_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff_list::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl_pw_multi_aff_list_drop(copy(), first, n);
+  return manage(res);
+}
+
+stat pw_multi_aff_list::foreach(const std::function<stat(isl::checked::pw_multi_aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    auto ret = (data->func)(manage(arg_0));
+    return ret.release();
+  };
+  auto res = isl_pw_multi_aff_list_foreach(get(), fn_lambda, &fn_data);
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff_list pw_multi_aff_list::insert(unsigned int pos, isl::checked::pw_multi_aff el) const
+{
+  auto res = isl_pw_multi_aff_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size pw_multi_aff_list::size() const
+{
+  auto res = isl_pw_multi_aff_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff_list &obj)
+{
+  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::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_schedule_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+schedule &schedule::operator=(schedule obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+schedule::~schedule() {
+  if (ptr)
+    isl_schedule_free(ptr);
+}
+
+__isl_give isl_schedule *schedule::copy() const & {
+  return isl_schedule_copy(ptr);
+}
+
+__isl_keep isl_schedule *schedule::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule *schedule::release() {
+  isl_schedule *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool schedule::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx schedule::ctx() const {
+  return isl::checked::ctx(isl_schedule_get_ctx(ptr));
+}
+
+isl::checked::union_set schedule::domain() const
+{
+  auto res = isl_schedule_get_domain(get());
+  return manage(res);
+}
+
+isl::checked::union_set schedule::get_domain() const
+{
+  return domain();
+}
+
+isl::checked::schedule schedule::from_domain(isl::checked::union_set domain)
+{
+  auto res = isl_schedule_from_domain(domain.release());
+  return manage(res);
+}
+
+isl::checked::union_map schedule::map() const
+{
+  auto res = isl_schedule_get_map(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule::get_map() const
+{
+  return map();
+}
+
+isl::checked::schedule schedule::pullback(isl::checked::union_pw_multi_aff upma) const
+{
+  auto res = isl_schedule_pullback_union_pw_multi_aff(copy(), upma.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule::root() const
+{
+  auto res = isl_schedule_get_root(get());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule::get_root() const
+{
+  return root();
+}
+
+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::checked::ctx ctx, const std::string &str)
+{
+  auto res = isl_schedule_constraints_read_from_str(ctx.release(), str.c_str());
+  ptr = res;
+}
+
+schedule_constraints &schedule_constraints::operator=(schedule_constraints obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+schedule_constraints::~schedule_constraints() {
+  if (ptr)
+    isl_schedule_constraints_free(ptr);
+}
+
+__isl_give isl_schedule_constraints *schedule_constraints::copy() const & {
+  return isl_schedule_constraints_copy(ptr);
+}
+
+__isl_keep isl_schedule_constraints *schedule_constraints::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_constraints *schedule_constraints::release() {
+  isl_schedule_constraints *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool schedule_constraints::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx schedule_constraints::ctx() const {
+  return isl::checked::ctx(isl_schedule_constraints_get_ctx(ptr));
+}
+
+isl::checked::union_map schedule_constraints::coincidence() const
+{
+  auto res = isl_schedule_constraints_get_coincidence(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::get_coincidence() const
+{
+  return coincidence();
+}
+
+isl::checked::schedule schedule_constraints::compute_schedule() const
+{
+  auto res = isl_schedule_constraints_compute_schedule(copy());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::conditional_validity() const
+{
+  auto res = isl_schedule_constraints_get_conditional_validity(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::get_conditional_validity() const
+{
+  return conditional_validity();
+}
+
+isl::checked::union_map schedule_constraints::conditional_validity_condition() const
+{
+  auto res = isl_schedule_constraints_get_conditional_validity_condition(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::get_conditional_validity_condition() const
+{
+  return conditional_validity_condition();
+}
+
+isl::checked::set schedule_constraints::context() const
+{
+  auto res = isl_schedule_constraints_get_context(get());
+  return manage(res);
+}
+
+isl::checked::set schedule_constraints::get_context() const
+{
+  return context();
+}
+
+isl::checked::union_set schedule_constraints::domain() const
+{
+  auto res = isl_schedule_constraints_get_domain(get());
+  return manage(res);
+}
+
+isl::checked::union_set schedule_constraints::get_domain() const
+{
+  return domain();
+}
+
+isl::checked::schedule_constraints schedule_constraints::on_domain(isl::checked::union_set domain)
+{
+  auto res = isl_schedule_constraints_on_domain(domain.release());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::proximity() const
+{
+  auto res = isl_schedule_constraints_get_proximity(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::get_proximity() const
+{
+  return proximity();
+}
+
+isl::checked::schedule_constraints schedule_constraints::set_coincidence(isl::checked::union_map coincidence) const
+{
+  auto res = isl_schedule_constraints_set_coincidence(copy(), coincidence.release());
+  return manage(res);
+}
+
+isl::checked::schedule_constraints schedule_constraints::set_conditional_validity(isl::checked::union_map condition, isl::checked::union_map validity) const
+{
+  auto res = isl_schedule_constraints_set_conditional_validity(copy(), condition.release(), validity.release());
+  return manage(res);
+}
+
+isl::checked::schedule_constraints schedule_constraints::set_context(isl::checked::set context) const
+{
+  auto res = isl_schedule_constraints_set_context(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::schedule_constraints schedule_constraints::set_proximity(isl::checked::union_map proximity) const
+{
+  auto res = isl_schedule_constraints_set_proximity(copy(), proximity.release());
+  return manage(res);
+}
+
+isl::checked::schedule_constraints schedule_constraints::set_validity(isl::checked::union_map validity) const
+{
+  auto res = isl_schedule_constraints_set_validity(copy(), validity.release());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_constraints::validity() const
+{
+  auto res = isl_schedule_constraints_get_validity(get());
+  return manage(res);
+}
+
+isl::checked::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::copy() const & {
+  return isl_schedule_node_copy(ptr);
+}
+
+__isl_keep isl_schedule_node *schedule_node::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_node *schedule_node::release() {
+  isl_schedule_node *tmp = ptr;
+  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::checked::ctx schedule_node::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::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::checked::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::checked::schedule_node &ancestor) const
+{
+  return ancestor_child_position(ancestor);
+}
+
+isl::checked::schedule_node schedule_node::child(int pos) const
+{
+  auto res = isl_schedule_node_child(copy(), pos);
+  return manage(res);
+}
+
+class size schedule_node::child_position() const
+{
+  auto res = isl_schedule_node_get_child_position(get());
+  return manage(res);
+}
+
+class size schedule_node::get_child_position() const
+{
+  return child_position();
+}
+
+boolean schedule_node::every_descendant(const std::function<boolean(isl::checked::schedule_node)> &test) const
+{
+  struct test_data {
+    std::function<boolean(isl::checked::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::checked::schedule_node schedule_node::first_child() const
+{
+  auto res = isl_schedule_node_first_child(copy());
+  return manage(res);
+}
+
+stat schedule_node::foreach_ancestor_top_down(const std::function<stat(isl::checked::schedule_node)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+}
+
+stat schedule_node::foreach_descendant_top_down(const std::function<boolean(isl::checked::schedule_node)> &fn) const
+{
+  struct fn_data {
+    std::function<boolean(isl::checked::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::checked::schedule_node schedule_node::from_domain(isl::checked::union_set domain)
+{
+  auto res = isl_schedule_node_from_domain(domain.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::from_extension(isl::checked::union_map extension)
+{
+  auto res = isl_schedule_node_from_extension(extension.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::graft_after(isl::checked::schedule_node graft) const
+{
+  auto res = isl_schedule_node_graft_after(copy(), graft.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::graft_before(isl::checked::schedule_node graft) const
+{
+  auto res = isl_schedule_node_graft_before(copy(), graft.release());
+  return manage(res);
+}
+
+boolean schedule_node::has_children() const
+{
+  auto res = isl_schedule_node_has_children(get());
+  return manage(res);
+}
+
+boolean schedule_node::has_next_sibling() const
+{
+  auto res = isl_schedule_node_has_next_sibling(get());
+  return manage(res);
+}
+
+boolean schedule_node::has_parent() const
+{
+  auto res = isl_schedule_node_has_parent(get());
+  return manage(res);
+}
+
+boolean schedule_node::has_previous_sibling() const
+{
+  auto res = isl_schedule_node_has_previous_sibling(get());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_context(isl::checked::set context) const
+{
+  auto res = isl_schedule_node_insert_context(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_filter(isl::checked::union_set filter) const
+{
+  auto res = isl_schedule_node_insert_filter(copy(), filter.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_guard(isl::checked::set context) const
+{
+  auto res = isl_schedule_node_insert_guard(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_mark(isl::checked::id mark) const
+{
+  auto res = isl_schedule_node_insert_mark(copy(), mark.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_mark(const std::string &mark) const
+{
+  return this->insert_mark(isl::checked::id(ctx(), mark));
+}
+
+isl::checked::schedule_node schedule_node::insert_partial_schedule(isl::checked::multi_union_pw_aff schedule) const
+{
+  auto res = isl_schedule_node_insert_partial_schedule(copy(), schedule.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_sequence(isl::checked::union_set_list filters) const
+{
+  auto res = isl_schedule_node_insert_sequence(copy(), filters.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::insert_set(isl::checked::union_set_list filters) const
+{
+  auto res = isl_schedule_node_insert_set(copy(), filters.release());
+  return manage(res);
+}
+
+boolean schedule_node::is_equal(const isl::checked::schedule_node &node2) const
+{
+  auto res = isl_schedule_node_is_equal(get(), node2.get());
+  return manage(res);
+}
+
+boolean schedule_node::is_subtree_anchored() const
+{
+  auto res = isl_schedule_node_is_subtree_anchored(get());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::map_descendant_bottom_up(const std::function<isl::checked::schedule_node(isl::checked::schedule_node)> &fn) const
+{
+  struct fn_data {
+    std::function<isl::checked::schedule_node(isl::checked::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);
+}
+
+class size schedule_node::n_children() const
+{
+  auto res = isl_schedule_node_n_children(get());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::next_sibling() const
+{
+  auto res = isl_schedule_node_next_sibling(copy());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::order_after(isl::checked::union_set filter) const
+{
+  auto res = isl_schedule_node_order_after(copy(), filter.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::order_before(isl::checked::union_set filter) const
+{
+  auto res = isl_schedule_node_order_before(copy(), filter.release());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::parent() const
+{
+  auto res = isl_schedule_node_parent(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff schedule_node::prefix_schedule_multi_union_pw_aff() const
+{
+  auto res = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(get());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff schedule_node::get_prefix_schedule_multi_union_pw_aff() const
+{
+  return prefix_schedule_multi_union_pw_aff();
+}
+
+isl::checked::union_map schedule_node::prefix_schedule_union_map() const
+{
+  auto res = isl_schedule_node_get_prefix_schedule_union_map(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_node::get_prefix_schedule_union_map() const
+{
+  return prefix_schedule_union_map();
+}
+
+isl::checked::union_pw_multi_aff schedule_node::prefix_schedule_union_pw_multi_aff() const
+{
+  auto res = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(get());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff schedule_node::get_prefix_schedule_union_pw_multi_aff() const
+{
+  return prefix_schedule_union_pw_multi_aff();
+}
+
+isl::checked::schedule_node schedule_node::previous_sibling() const
+{
+  auto res = isl_schedule_node_previous_sibling(copy());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::root() const
+{
+  auto res = isl_schedule_node_root(copy());
+  return manage(res);
+}
+
+isl::checked::schedule schedule_node::schedule() const
+{
+  auto res = isl_schedule_node_get_schedule(get());
+  return manage(res);
+}
+
+isl::checked::schedule schedule_node::get_schedule() const
+{
+  return schedule();
+}
+
+isl::checked::schedule_node schedule_node::shared_ancestor(const isl::checked::schedule_node &node2) const
+{
+  auto res = isl_schedule_node_get_shared_ancestor(get(), node2.get());
+  return manage(res);
+}
+
+isl::checked::schedule_node schedule_node::get_shared_ancestor(const isl::checked::schedule_node &node2) const
+{
+  return shared_ancestor(node2);
+}
+
+class size schedule_node::tree_depth() const
+{
+  auto res = isl_schedule_node_get_tree_depth(get());
+  return manage(res);
+}
+
+class size schedule_node::get_tree_depth() const
+{
+  return tree_depth();
+}
+
+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::checked::ctx schedule_node_band::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::union_set schedule_node_band::ast_build_options() const
+{
+  auto res = isl_schedule_node_band_get_ast_build_options(get());
+  return manage(res);
+}
+
+isl::checked::union_set schedule_node_band::get_ast_build_options() const
+{
+  return ast_build_options();
+}
+
+isl::checked::set schedule_node_band::ast_isolate_option() const
+{
+  auto res = isl_schedule_node_band_get_ast_isolate_option(get());
+  return manage(res);
+}
+
+isl::checked::set schedule_node_band::get_ast_isolate_option() const
+{
+  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);
+}
+
+schedule_node_band schedule_node_band::member_set_coincident(int pos, int coincident) const
+{
+  auto res = isl_schedule_node_band_member_set_coincident(copy(), pos, coincident);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::mod(isl::checked::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);
+}
+
+isl::checked::multi_union_pw_aff schedule_node_band::partial_schedule() const
+{
+  auto res = isl_schedule_node_band_get_partial_schedule(get());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff schedule_node_band::get_partial_schedule() const
+{
+  return partial_schedule();
+}
+
+boolean schedule_node_band::permutable() const
+{
+  auto res = isl_schedule_node_band_get_permutable(get());
+  return manage(res);
+}
+
+boolean schedule_node_band::get_permutable() const
+{
+  return permutable();
+}
+
+schedule_node_band schedule_node_band::scale(isl::checked::multi_val mv) const
+{
+  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::checked::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::checked::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::checked::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::checked::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::checked::ctx schedule_node_context::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::set schedule_node_context::context() const
+{
+  auto res = isl_schedule_node_context_get_context(get());
+  return manage(res);
+}
+
+isl::checked::set schedule_node_context::get_context() const
+{
+  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::checked::ctx schedule_node_domain::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::union_set schedule_node_domain::domain() const
+{
+  auto res = isl_schedule_node_domain_get_domain(get());
+  return manage(res);
+}
+
+isl::checked::union_set schedule_node_domain::get_domain() const
+{
+  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::checked::ctx schedule_node_expansion::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::union_pw_multi_aff schedule_node_expansion::contraction() const
+{
+  auto res = isl_schedule_node_expansion_get_contraction(get());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff schedule_node_expansion::get_contraction() const
+{
+  return contraction();
+}
+
+isl::checked::union_map schedule_node_expansion::expansion() const
+{
+  auto res = isl_schedule_node_expansion_get_expansion(get());
+  return manage(res);
+}
+
+isl::checked::union_map schedule_node_expansion::get_expansion() const
+{
+  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::checked::ctx schedule_node_extension::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::union_map schedule_node_extension::extension() const
+{
+  auto res = isl_schedule_node_extension_get_extension(get());
+  return manage(res);
+}
+
+isl::checked::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::checked::ctx schedule_node_filter::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::union_set schedule_node_filter::filter() const
+{
+  auto res = isl_schedule_node_filter_get_filter(get());
+  return manage(res);
+}
+
+isl::checked::union_set schedule_node_filter::get_filter() const
+{
+  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::checked::ctx schedule_node_guard::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::checked::set schedule_node_guard::guard() const
+{
+  auto res = isl_schedule_node_guard_get_guard(get());
+  return manage(res);
+}
+
+isl::checked::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::checked::ctx schedule_node_leaf::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_leaf &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_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::checked::ctx schedule_node_mark::ctx() const {
+  return isl::checked::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+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::checked::ctx schedule_node_sequence::ctx() const {
+  return isl::checked::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::checked::ctx schedule_node_set::ctx() const {
+  return isl::checked::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::checked::basic_set bset)
+{
+  auto res = isl_set_from_basic_set(bset.release());
+  ptr = res;
+}
+
+set::set(isl::checked::point pnt)
+{
+  auto res = isl_set_from_point(pnt.release());
+  ptr = res;
+}
+
+set::set(isl::checked::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);
+  return *this;
+}
+
+set::~set() {
+  if (ptr)
+    isl_set_free(ptr);
+}
+
+__isl_give isl_set *set::copy() const & {
+  return isl_set_copy(ptr);
+}
+
+__isl_keep isl_set *set::get() const {
+  return ptr;
+}
+
+__isl_give isl_set *set::release() {
+  isl_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool set::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx set::ctx() const {
+  return isl::checked::ctx(isl_set_get_ctx(ptr));
+}
+
+isl::checked::basic_set set::affine_hull() const
+{
+  auto res = isl_set_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::set set::apply(isl::checked::map map) const
+{
+  auto res = isl_set_apply(copy(), map.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::apply(const isl::checked::union_map &umap) const
+{
+  return isl::checked::union_set(*this).apply(umap);
+}
+
+isl::checked::set set::apply(const isl::checked::basic_map &map) const
+{
+  return this->apply(isl::checked::map(map));
+}
+
+isl::checked::pw_multi_aff set::as_pw_multi_aff() const
+{
+  auto res = isl_set_as_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::set set::as_set() const
+{
+  return isl::checked::union_set(*this).as_set();
+}
+
+isl::checked::set set::bind(isl::checked::multi_id tuple) const
+{
+  auto res = isl_set_bind(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::set set::coalesce() const
+{
+  auto res = isl_set_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::set set::complement() const
+{
+  auto res = isl_set_complement(copy());
+  return manage(res);
+}
+
+isl::checked::union_set set::compute_divs() const
+{
+  return isl::checked::union_set(*this).compute_divs();
+}
+
+isl::checked::set set::detect_equalities() const
+{
+  auto res = isl_set_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::val set::dim_max_val(int pos) const
+{
+  auto res = isl_set_dim_max_val(copy(), pos);
+  return manage(res);
+}
+
+isl::checked::val set::dim_min_val(int pos) const
+{
+  auto res = isl_set_dim_min_val(copy(), pos);
+  return manage(res);
+}
+
+isl::checked::set set::empty(isl::checked::space space)
+{
+  auto res = isl_set_empty(space.release());
+  return manage(res);
+}
+
+boolean set::every_set(const std::function<boolean(isl::checked::set)> &test) const
+{
+  return isl::checked::union_set(*this).every_set(test);
+}
+
+isl::checked::set set::extract_set(const isl::checked::space &space) const
+{
+  return isl::checked::union_set(*this).extract_set(space);
+}
+
+isl::checked::set set::flatten() const
+{
+  auto res = isl_set_flatten(copy());
+  return manage(res);
+}
+
+stat set::foreach_basic_set(const std::function<stat(isl::checked::basic_set)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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(isl::checked::point)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    auto ret = (data->func)(manage(arg_0));
+    return ret.release();
+  };
+  auto res = isl_set_foreach_point(get(), fn_lambda, &fn_data);
+  return manage(res);
+}
+
+stat set::foreach_set(const std::function<stat(isl::checked::set)> &fn) const
+{
+  return isl::checked::union_set(*this).foreach_set(fn);
+}
+
+isl::checked::set set::gist(isl::checked::set context) const
+{
+  auto res = isl_set_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::gist(const isl::checked::union_set &context) const
+{
+  return isl::checked::union_set(*this).gist(context);
+}
+
+isl::checked::set set::gist(const isl::checked::basic_set &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::set set::gist(const isl::checked::point &context) const
+{
+  return this->gist(isl::checked::set(context));
+}
+
+isl::checked::union_set set::gist_params(const isl::checked::set &set) const
+{
+  return isl::checked::union_set(*this).gist_params(set);
+}
+
+isl::checked::map set::identity() const
+{
+  auto res = isl_set_identity(copy());
+  return manage(res);
+}
+
+isl::checked::pw_aff set::indicator_function() const
+{
+  auto res = isl_set_indicator_function(copy());
+  return manage(res);
+}
+
+isl::checked::map set::insert_domain(isl::checked::space domain) const
+{
+  auto res = isl_set_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::set set::intersect(isl::checked::set set2) const
+{
+  auto res = isl_set_intersect(copy(), set2.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::intersect(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).intersect(uset2);
+}
+
+isl::checked::set set::intersect(const isl::checked::basic_set &set2) const
+{
+  return this->intersect(isl::checked::set(set2));
+}
+
+isl::checked::set set::intersect(const isl::checked::point &set2) const
+{
+  return this->intersect(isl::checked::set(set2));
+}
+
+isl::checked::set set::intersect_params(isl::checked::set params) const
+{
+  auto res = isl_set_intersect_params(copy(), params.release());
+  return manage(res);
+}
+
+boolean set::involves_locals() const
+{
+  auto res = isl_set_involves_locals(get());
+  return manage(res);
+}
+
+boolean set::is_disjoint(const isl::checked::set &set2) const
+{
+  auto res = isl_set_is_disjoint(get(), set2.get());
+  return manage(res);
+}
+
+boolean set::is_disjoint(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).is_disjoint(uset2);
+}
+
+boolean set::is_disjoint(const isl::checked::basic_set &set2) const
+{
+  return this->is_disjoint(isl::checked::set(set2));
+}
+
+boolean set::is_disjoint(const isl::checked::point &set2) const
+{
+  return this->is_disjoint(isl::checked::set(set2));
+}
+
+boolean set::is_empty() const
+{
+  auto res = isl_set_is_empty(get());
+  return manage(res);
+}
+
+boolean set::is_equal(const isl::checked::set &set2) const
+{
+  auto res = isl_set_is_equal(get(), set2.get());
+  return manage(res);
+}
+
+boolean set::is_equal(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).is_equal(uset2);
+}
+
+boolean set::is_equal(const isl::checked::basic_set &set2) const
+{
+  return this->is_equal(isl::checked::set(set2));
+}
+
+boolean set::is_equal(const isl::checked::point &set2) const
+{
+  return this->is_equal(isl::checked::set(set2));
+}
+
+boolean set::is_singleton() const
+{
+  auto res = isl_set_is_singleton(get());
+  return manage(res);
+}
+
+boolean set::is_strict_subset(const isl::checked::set &set2) const
+{
+  auto res = isl_set_is_strict_subset(get(), set2.get());
+  return manage(res);
+}
+
+boolean set::is_strict_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).is_strict_subset(uset2);
+}
+
+boolean set::is_strict_subset(const isl::checked::basic_set &set2) const
+{
+  return this->is_strict_subset(isl::checked::set(set2));
+}
+
+boolean set::is_strict_subset(const isl::checked::point &set2) const
+{
+  return this->is_strict_subset(isl::checked::set(set2));
+}
+
+boolean set::is_subset(const isl::checked::set &set2) const
+{
+  auto res = isl_set_is_subset(get(), set2.get());
+  return manage(res);
+}
+
+boolean set::is_subset(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).is_subset(uset2);
+}
+
+boolean set::is_subset(const isl::checked::basic_set &set2) const
+{
+  return this->is_subset(isl::checked::set(set2));
+}
+
+boolean set::is_subset(const isl::checked::point &set2) const
+{
+  return this->is_subset(isl::checked::set(set2));
+}
+
+boolean set::is_wrapping() const
+{
+  auto res = isl_set_is_wrapping(get());
+  return manage(res);
+}
+
+boolean set::isa_set() const
+{
+  return isl::checked::union_set(*this).isa_set();
+}
+
+isl::checked::set set::lexmax() const
+{
+  auto res = isl_set_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff set::lexmax_pw_multi_aff() const
+{
+  auto res = isl_set_lexmax_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::set set::lexmin() const
+{
+  auto res = isl_set_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff set::lexmin_pw_multi_aff() const
+{
+  auto res = isl_set_lexmin_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::set set::lower_bound(isl::checked::multi_pw_aff lower) const
+{
+  auto res = isl_set_lower_bound_multi_pw_aff(copy(), lower.release());
+  return manage(res);
+}
+
+isl::checked::set set::lower_bound(isl::checked::multi_val lower) const
+{
+  auto res = isl_set_lower_bound_multi_val(copy(), lower.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff set::max_multi_pw_aff() const
+{
+  auto res = isl_set_max_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::val set::max_val(const isl::checked::aff &obj) const
+{
+  auto res = isl_set_max_val(get(), obj.get());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff set::min_multi_pw_aff() const
+{
+  auto res = isl_set_min_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::val set::min_val(const isl::checked::aff &obj) const
+{
+  auto res = isl_set_min_val(get(), obj.get());
+  return manage(res);
+}
+
+isl::checked::set set::params() const
+{
+  auto res = isl_set_params(copy());
+  return manage(res);
+}
+
+isl::checked::multi_val set::plain_multi_val_if_fixed() const
+{
+  auto res = isl_set_get_plain_multi_val_if_fixed(get());
+  return manage(res);
+}
+
+isl::checked::multi_val set::get_plain_multi_val_if_fixed() const
+{
+  return plain_multi_val_if_fixed();
+}
+
+isl::checked::basic_set set::polyhedral_hull() const
+{
+  auto res = isl_set_polyhedral_hull(copy());
+  return manage(res);
+}
+
+isl::checked::set set::preimage(isl::checked::multi_aff ma) const
+{
+  auto res = isl_set_preimage_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::set set::preimage(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_set_preimage_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::set set::preimage(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_set_preimage_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::preimage(const isl::checked::union_pw_multi_aff &upma) const
+{
+  return isl::checked::union_set(*this).preimage(upma);
+}
+
+isl::checked::set set::product(isl::checked::set set2) const
+{
+  auto res = isl_set_product(copy(), set2.release());
+  return manage(res);
+}
+
+isl::checked::set set::project_out_all_params() const
+{
+  auto res = isl_set_project_out_all_params(copy());
+  return manage(res);
+}
+
+isl::checked::set set::project_out_param(isl::checked::id id) const
+{
+  auto res = isl_set_project_out_param_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::set set::project_out_param(const std::string &id) const
+{
+  return this->project_out_param(isl::checked::id(ctx(), id));
+}
+
+isl::checked::set set::project_out_param(isl::checked::id_list list) const
+{
+  auto res = isl_set_project_out_param_id_list(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff set::pw_multi_aff_on_domain(isl::checked::multi_val mv) const
+{
+  auto res = isl_set_pw_multi_aff_on_domain_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::basic_set set::sample() const
+{
+  auto res = isl_set_sample(copy());
+  return manage(res);
+}
+
+isl::checked::point set::sample_point() const
+{
+  auto res = isl_set_sample_point(copy());
+  return manage(res);
+}
+
+isl::checked::fixed_box set::simple_fixed_box_hull() const
+{
+  auto res = isl_set_get_simple_fixed_box_hull(get());
+  return manage(res);
+}
+
+isl::checked::fixed_box set::get_simple_fixed_box_hull() const
+{
+  return simple_fixed_box_hull();
+}
+
+isl::checked::space set::space() const
+{
+  auto res = isl_set_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space set::get_space() const
+{
+  return space();
+}
+
+isl::checked::val set::stride(int pos) const
+{
+  auto res = isl_set_get_stride(get(), pos);
+  return manage(res);
+}
+
+isl::checked::val set::get_stride(int pos) const
+{
+  return stride(pos);
+}
+
+isl::checked::set set::subtract(isl::checked::set set2) const
+{
+  auto res = isl_set_subtract(copy(), set2.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::subtract(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).subtract(uset2);
+}
+
+isl::checked::set set::subtract(const isl::checked::basic_set &set2) const
+{
+  return this->subtract(isl::checked::set(set2));
+}
+
+isl::checked::set set::subtract(const isl::checked::point &set2) const
+{
+  return this->subtract(isl::checked::set(set2));
+}
+
+isl::checked::union_set_list set::to_list() const
+{
+  return isl::checked::union_set(*this).to_list();
+}
+
+isl::checked::union_set set::to_union_set() const
+{
+  auto res = isl_set_to_union_set(copy());
+  return manage(res);
+}
+
+isl::checked::map set::translation() const
+{
+  auto res = isl_set_translation(copy());
+  return manage(res);
+}
+
+isl::checked::set set::unbind_params(isl::checked::multi_id tuple) const
+{
+  auto res = isl_set_unbind_params(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::map set::unbind_params_insert_domain(isl::checked::multi_id domain) const
+{
+  auto res = isl_set_unbind_params_insert_domain(copy(), domain.release());
+  return manage(res);
+}
+
+isl::checked::set set::unite(isl::checked::set set2) const
+{
+  auto res = isl_set_union(copy(), set2.release());
+  return manage(res);
+}
+
+isl::checked::union_set set::unite(const isl::checked::union_set &uset2) const
+{
+  return isl::checked::union_set(*this).unite(uset2);
+}
+
+isl::checked::set set::unite(const isl::checked::basic_set &set2) const
+{
+  return this->unite(isl::checked::set(set2));
+}
+
+isl::checked::set set::unite(const isl::checked::point &set2) const
+{
+  return this->unite(isl::checked::set(set2));
+}
+
+isl::checked::set set::universe(isl::checked::space space)
+{
+  auto res = isl_set_universe(space.release());
+  return manage(res);
+}
+
+isl::checked::basic_set set::unshifted_simple_hull() const
+{
+  auto res = isl_set_unshifted_simple_hull(copy());
+  return manage(res);
+}
+
+isl::checked::map set::unwrap() const
+{
+  auto res = isl_set_unwrap(copy());
+  return manage(res);
+}
+
+isl::checked::set set::upper_bound(isl::checked::multi_pw_aff upper) const
+{
+  auto res = isl_set_upper_bound_multi_pw_aff(copy(), upper.release());
+  return manage(res);
+}
+
+isl::checked::set set::upper_bound(isl::checked::multi_val upper) const
+{
+  auto res = isl_set_upper_bound_multi_val(copy(), upper.release());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const set &obj)
+{
+  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::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::operator=(space obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+space::~space() {
+  if (ptr)
+    isl_space_free(ptr);
+}
+
+__isl_give isl_space *space::copy() const & {
+  return isl_space_copy(ptr);
+}
+
+__isl_keep isl_space *space::get() const {
+  return ptr;
+}
+
+__isl_give isl_space *space::release() {
+  isl_space *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool space::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx space::ctx() const {
+  return isl::checked::ctx(isl_space_get_ctx(ptr));
+}
+
+isl::checked::space space::add_named_tuple(isl::checked::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::checked::space space::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
+{
+  return this->add_named_tuple(isl::checked::id(ctx(), tuple_id), dim);
+}
+
+isl::checked::space space::add_unnamed_tuple(unsigned int dim) const
+{
+  auto res = isl_space_add_unnamed_tuple_ui(copy(), dim);
+  return manage(res);
+}
+
+isl::checked::space space::curry() const
+{
+  auto res = isl_space_curry(copy());
+  return manage(res);
+}
+
+isl::checked::space space::domain() const
+{
+  auto res = isl_space_domain(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::domain_map_multi_aff() const
+{
+  auto res = isl_space_domain_map_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff space::domain_map_pw_multi_aff() const
+{
+  auto res = isl_space_domain_map_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::id space::domain_tuple_id() const
+{
+  auto res = isl_space_get_domain_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id space::get_domain_tuple_id() const
+{
+  return domain_tuple_id();
+}
+
+isl::checked::space space::flatten_domain() const
+{
+  auto res = isl_space_flatten_domain(copy());
+  return manage(res);
+}
+
+isl::checked::space space::flatten_range() const
+{
+  auto res = isl_space_flatten_range(copy());
+  return manage(res);
+}
+
+boolean space::has_domain_tuple_id() const
+{
+  auto res = isl_space_has_domain_tuple_id(get());
+  return manage(res);
+}
+
+boolean space::has_range_tuple_id() const
+{
+  auto res = isl_space_has_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::identity_multi_aff_on_domain() const
+{
+  auto res = isl_space_identity_multi_aff_on_domain(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff space::identity_multi_pw_aff_on_domain() const
+{
+  auto res = isl_space_identity_multi_pw_aff_on_domain(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff space::identity_pw_multi_aff_on_domain() const
+{
+  auto res = isl_space_identity_pw_multi_aff_on_domain(copy());
+  return manage(res);
+}
+
+boolean space::is_equal(const isl::checked::space &space2) const
+{
+  auto res = isl_space_is_equal(get(), space2.get());
+  return manage(res);
+}
+
+boolean space::is_wrapping() const
+{
+  auto res = isl_space_is_wrapping(get());
+  return manage(res);
+}
+
+isl::checked::space space::map_from_set() const
+{
+  auto res = isl_space_map_from_set(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::multi_aff(isl::checked::aff_list list) const
+{
+  auto res = isl_space_multi_aff(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::multi_aff_on_domain(isl::checked::multi_val mv) const
+{
+  auto res = isl_space_multi_aff_on_domain_multi_val(copy(), mv.release());
+  return manage(res);
+}
+
+isl::checked::multi_id space::multi_id(isl::checked::id_list list) const
+{
+  auto res = isl_space_multi_id(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff space::multi_pw_aff(isl::checked::pw_aff_list list) const
+{
+  auto res = isl_space_multi_pw_aff(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff space::multi_union_pw_aff(isl::checked::union_pw_aff_list list) const
+{
+  auto res = isl_space_multi_union_pw_aff(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::multi_val space::multi_val(isl::checked::val_list list) const
+{
+  auto res = isl_space_multi_val(copy(), list.release());
+  return manage(res);
+}
+
+isl::checked::space space::params() const
+{
+  auto res = isl_space_params(copy());
+  return manage(res);
+}
+
+isl::checked::space space::product(isl::checked::space right) const
+{
+  auto res = isl_space_product(copy(), right.release());
+  return manage(res);
+}
+
+isl::checked::space space::range() const
+{
+  auto res = isl_space_range(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::range_map_multi_aff() const
+{
+  auto res = isl_space_range_map_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff space::range_map_pw_multi_aff() const
+{
+  auto res = isl_space_range_map_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::space space::range_reverse() const
+{
+  auto res = isl_space_range_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::id space::range_tuple_id() const
+{
+  auto res = isl_space_get_range_tuple_id(get());
+  return manage(res);
+}
+
+isl::checked::id space::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::checked::space space::reverse() const
+{
+  auto res = isl_space_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::space space::set_domain_tuple(isl::checked::id id) const
+{
+  auto res = isl_space_set_domain_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::space space::set_domain_tuple(const std::string &id) const
+{
+  return this->set_domain_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::space space::set_range_tuple(isl::checked::id id) const
+{
+  auto res = isl_space_set_range_tuple_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::space space::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+isl::checked::space space::uncurry() const
+{
+  auto res = isl_space_uncurry(copy());
+  return manage(res);
+}
+
+isl::checked::space space::unit(isl::checked::ctx ctx)
+{
+  auto res = isl_space_unit(ctx.release());
+  return manage(res);
+}
+
+isl::checked::map space::universe_map() const
+{
+  auto res = isl_space_universe_map(copy());
+  return manage(res);
+}
+
+isl::checked::set space::universe_set() const
+{
+  auto res = isl_space_universe_set(copy());
+  return manage(res);
+}
+
+isl::checked::space space::unwrap() const
+{
+  auto res = isl_space_unwrap(copy());
+  return manage(res);
+}
+
+isl::checked::space space::wrap() const
+{
+  auto res = isl_space_wrap(copy());
+  return manage(res);
+}
+
+isl::checked::aff space::zero_aff_on_domain() const
+{
+  auto res = isl_space_zero_aff_on_domain(copy());
+  return manage(res);
+}
+
+isl::checked::multi_aff space::zero_multi_aff() const
+{
+  auto res = isl_space_zero_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_pw_aff space::zero_multi_pw_aff() const
+{
+  auto res = isl_space_zero_multi_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff space::zero_multi_union_pw_aff() const
+{
+  auto res = isl_space_zero_multi_union_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::multi_val space::zero_multi_val() const
+{
+  auto res = isl_space_zero_multi_val(copy());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const space &obj)
+{
+  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::checked::union_map sink)
+{
+  auto res = isl_union_access_info_from_sink(sink.release());
+  ptr = res;
+}
+
+union_access_info &union_access_info::operator=(union_access_info obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_access_info::~union_access_info() {
+  if (ptr)
+    isl_union_access_info_free(ptr);
+}
+
+__isl_give isl_union_access_info *union_access_info::copy() const & {
+  return isl_union_access_info_copy(ptr);
+}
+
+__isl_keep isl_union_access_info *union_access_info::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_access_info *union_access_info::release() {
+  isl_union_access_info *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_access_info::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_access_info::ctx() const {
+  return isl::checked::ctx(isl_union_access_info_get_ctx(ptr));
+}
+
+isl::checked::union_flow union_access_info::compute_flow() const
+{
+  auto res = isl_union_access_info_compute_flow(copy());
+  return manage(res);
+}
+
+isl::checked::union_access_info union_access_info::set_kill(isl::checked::union_map kill) const
+{
+  auto res = isl_union_access_info_set_kill(copy(), kill.release());
+  return manage(res);
+}
+
+isl::checked::union_access_info union_access_info::set_may_source(isl::checked::union_map may_source) const
+{
+  auto res = isl_union_access_info_set_may_source(copy(), may_source.release());
+  return manage(res);
+}
+
+isl::checked::union_access_info union_access_info::set_must_source(isl::checked::union_map must_source) const
+{
+  auto res = isl_union_access_info_set_must_source(copy(), must_source.release());
+  return manage(res);
+}
+
+isl::checked::union_access_info union_access_info::set_schedule(isl::checked::schedule schedule) const
+{
+  auto res = isl_union_access_info_set_schedule(copy(), schedule.release());
+  return manage(res);
+}
+
+isl::checked::union_access_info union_access_info::set_schedule_map(isl::checked::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::copy() const & {
+  return isl_union_flow_copy(ptr);
+}
+
+__isl_keep isl_union_flow *union_flow::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_flow *union_flow::release() {
+  isl_union_flow *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_flow::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_flow::ctx() const {
+  return isl::checked::ctx(isl_union_flow_get_ctx(ptr));
+}
+
+isl::checked::union_map union_flow::full_may_dependence() const
+{
+  auto res = isl_union_flow_get_full_may_dependence(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_flow::get_full_may_dependence() const
+{
+  return full_may_dependence();
+}
+
+isl::checked::union_map union_flow::full_must_dependence() const
+{
+  auto res = isl_union_flow_get_full_must_dependence(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_flow::get_full_must_dependence() const
+{
+  return full_must_dependence();
+}
+
+isl::checked::union_map union_flow::may_dependence() const
+{
+  auto res = isl_union_flow_get_may_dependence(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_flow::get_may_dependence() const
+{
+  return may_dependence();
+}
+
+isl::checked::union_map union_flow::may_no_source() const
+{
+  auto res = isl_union_flow_get_may_no_source(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_flow::get_may_no_source() const
+{
+  return may_no_source();
+}
+
+isl::checked::union_map union_flow::must_dependence() const
+{
+  auto res = isl_union_flow_get_must_dependence(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_flow::get_must_dependence() const
+{
+  return must_dependence();
+}
+
+isl::checked::union_map union_flow::must_no_source() const
+{
+  auto res = isl_union_flow_get_must_no_source(get());
+  return manage(res);
+}
+
+isl::checked::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::checked::basic_map bmap)
+{
+  auto res = isl_union_map_from_basic_map(bmap.release());
+  ptr = res;
+}
+
+union_map::union_map(isl::checked::map map)
+{
+  auto res = isl_union_map_from_map(map.release());
+  ptr = res;
+}
+
+union_map::union_map(isl::checked::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);
+  return *this;
+}
+
+union_map::~union_map() {
+  if (ptr)
+    isl_union_map_free(ptr);
+}
+
+__isl_give isl_union_map *union_map::copy() const & {
+  return isl_union_map_copy(ptr);
+}
+
+__isl_keep isl_union_map *union_map::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_map *union_map::release() {
+  isl_union_map *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_map::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_map::ctx() const {
+  return isl::checked::ctx(isl_union_map_get_ctx(ptr));
+}
+
+isl::checked::union_map union_map::affine_hull() const
+{
+  auto res = isl_union_map_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::apply_domain(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_apply_domain(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::apply_range(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_apply_range(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::map union_map::as_map() const
+{
+  auto res = isl_union_map_as_map(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff union_map::as_multi_union_pw_aff() const
+{
+  auto res = isl_union_map_as_multi_union_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_map::as_union_pw_multi_aff() const
+{
+  auto res = isl_union_map_as_union_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_map::bind_range(isl::checked::multi_id tuple) const
+{
+  auto res = isl_union_map_bind_range(copy(), tuple.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::coalesce() const
+{
+  auto res = isl_union_map_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::compute_divs() const
+{
+  auto res = isl_union_map_compute_divs(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::curry() const
+{
+  auto res = isl_union_map_curry(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_map::deltas() const
+{
+  auto res = isl_union_map_deltas(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::detect_equalities() const
+{
+  auto res = isl_union_map_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_map::domain() const
+{
+  auto res = isl_union_map_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::domain_factor_domain() const
+{
+  auto res = isl_union_map_domain_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::domain_factor_range() const
+{
+  auto res = isl_union_map_domain_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::domain_map() const
+{
+  auto res = isl_union_map_domain_map(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_map::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl_union_map_domain_map_union_pw_multi_aff(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::domain_product(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_domain_product(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::empty(isl::checked::ctx ctx)
+{
+  auto res = isl_union_map_empty_ctx(ctx.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::eq_at(isl::checked::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::checked::map)> &test) const
+{
+  struct test_data {
+    std::function<boolean(isl::checked::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::checked::map union_map::extract_map(isl::checked::space space) const
+{
+  auto res = isl_union_map_extract_map(get(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::factor_domain() const
+{
+  auto res = isl_union_map_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::factor_range() const
+{
+  auto res = isl_union_map_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::fixed_power(isl::checked::val exp) const
+{
+  auto res = isl_union_map_fixed_power_val(copy(), exp.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::fixed_power(long exp) const
+{
+  return this->fixed_power(isl::checked::val(ctx(), exp));
+}
+
+stat union_map::foreach_map(const std::function<stat(isl::checked::map)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::union_map union_map::from(isl::checked::multi_union_pw_aff mupa)
+{
+  auto res = isl_union_map_from_multi_union_pw_aff(mupa.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::from(isl::checked::union_pw_multi_aff upma)
+{
+  auto res = isl_union_map_from_union_pw_multi_aff(upma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::from_domain(isl::checked::union_set uset)
+{
+  auto res = isl_union_map_from_domain(uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::from_domain_and_range(isl::checked::union_set domain, isl::checked::union_set range)
+{
+  auto res = isl_union_map_from_domain_and_range(domain.release(), range.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::from_range(isl::checked::union_set uset)
+{
+  auto res = isl_union_map_from_range(uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::gist(isl::checked::union_map context) const
+{
+  auto res = isl_union_map_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::gist_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_map_gist_domain(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::gist_params(isl::checked::set set) const
+{
+  auto res = isl_union_map_gist_params(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::gist_range(isl::checked::union_set uset) const
+{
+  auto res = isl_union_map_gist_range(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_intersect(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_domain(isl::checked::space space) const
+{
+  auto res = isl_union_map_intersect_domain_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_map_intersect_domain_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_domain_factor_domain(isl::checked::union_map factor) const
+{
+  auto res = isl_union_map_intersect_domain_factor_domain(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_domain_factor_range(isl::checked::union_map factor) const
+{
+  auto res = isl_union_map_intersect_domain_factor_range(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_union_map_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_range(isl::checked::space space) const
+{
+  auto res = isl_union_map_intersect_range_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_range(isl::checked::union_set uset) const
+{
+  auto res = isl_union_map_intersect_range_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_range_factor_domain(isl::checked::union_map factor) const
+{
+  auto res = isl_union_map_intersect_range_factor_domain(copy(), factor.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::intersect_range_factor_range(isl::checked::union_map factor) const
+{
+  auto res = isl_union_map_intersect_range_factor_range(copy(), factor.release());
+  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::checked::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::checked::union_map &umap2) const
+{
+  auto res = isl_union_map_is_equal(get(), umap2.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
+{
+  auto res = isl_union_map_is_single_valued(get());
+  return manage(res);
+}
+
+boolean union_map::is_strict_subset(const isl::checked::union_map &umap2) const
+{
+  auto res = isl_union_map_is_strict_subset(get(), umap2.get());
+  return manage(res);
+}
+
+boolean union_map::is_subset(const isl::checked::union_map &umap2) const
+{
+  auto res = isl_union_map_is_subset(get(), umap2.get());
+  return manage(res);
+}
+
+boolean union_map::isa_map() const
+{
+  auto res = isl_union_map_isa_map(get());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::lexmax() const
+{
+  auto res = isl_union_map_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::lexmin() const
+{
+  auto res = isl_union_map_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::polyhedral_hull() const
+{
+  auto res = isl_union_map_polyhedral_hull(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_domain(isl::checked::multi_aff ma) const
+{
+  auto res = isl_union_map_preimage_domain_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_domain(isl::checked::multi_pw_aff mpa) const
+{
+  auto res = isl_union_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_domain(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_union_map_preimage_domain_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_domain(isl::checked::union_pw_multi_aff upma) const
+{
+  auto res = isl_union_map_preimage_domain_union_pw_multi_aff(copy(), upma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_range(isl::checked::multi_aff ma) const
+{
+  auto res = isl_union_map_preimage_range_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_range(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_union_map_preimage_range_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::preimage_range(isl::checked::union_pw_multi_aff upma) const
+{
+  auto res = isl_union_map_preimage_range_union_pw_multi_aff(copy(), upma.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::product(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_product(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::project_out_all_params() const
+{
+  auto res = isl_union_map_project_out_all_params(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_map::range() const
+{
+  auto res = isl_union_map_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::range_factor_domain() const
+{
+  auto res = isl_union_map_range_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::range_factor_range() const
+{
+  auto res = isl_union_map_range_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::range_map() const
+{
+  auto res = isl_union_map_range_map(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::range_product(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_range_product(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::range_reverse() const
+{
+  auto res = isl_union_map_range_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::reverse() const
+{
+  auto res = isl_union_map_reverse(copy());
+  return manage(res);
+}
+
+isl::checked::space union_map::space() const
+{
+  auto res = isl_union_map_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space union_map::get_space() const
+{
+  return space();
+}
+
+isl::checked::union_map union_map::subtract(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_subtract(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::subtract_domain(isl::checked::union_set dom) const
+{
+  auto res = isl_union_map_subtract_domain(copy(), dom.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::subtract_range(isl::checked::union_set dom) const
+{
+  auto res = isl_union_map_subtract_range(copy(), dom.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::uncurry() const
+{
+  auto res = isl_union_map_uncurry(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::unite(isl::checked::union_map umap2) const
+{
+  auto res = isl_union_map_union(copy(), umap2.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::universe() const
+{
+  auto res = isl_union_map_universe(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_map::wrap() const
+{
+  auto res = isl_union_map_wrap(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_map::zip() const
+{
+  auto res = isl_union_map_zip(copy());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_map &obj)
+{
+  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::checked::aff aff)
+{
+  auto res = isl_union_pw_aff_from_aff(aff.release());
+  ptr = res;
+}
+
+union_pw_aff::union_pw_aff(isl::checked::pw_aff pa)
+{
+  auto res = isl_union_pw_aff_from_pw_aff(pa.release());
+  ptr = res;
+}
+
+union_pw_aff::union_pw_aff(isl::checked::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::operator=(union_pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_pw_aff::~union_pw_aff() {
+  if (ptr)
+    isl_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_aff *union_pw_aff::copy() const & {
+  return isl_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_aff *union_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_aff *union_pw_aff::release() {
+  isl_union_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_pw_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_pw_aff::ctx() const {
+  return isl::checked::ctx(isl_union_pw_aff_get_ctx(ptr));
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::add(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).add(multi2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::add(isl::checked::union_pw_aff upa2) const
+{
+  auto res = isl_union_pw_aff_add(copy(), upa2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).add(upma2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::add(const isl::checked::aff &upa2) const
+{
+  return this->add(isl::checked::union_pw_aff(upa2));
+}
+
+isl::checked::union_pw_aff union_pw_aff::add(const isl::checked::pw_aff &upa2) const
+{
+  return this->add(isl::checked::union_pw_aff(upa2));
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::apply(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).apply(upma2);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::as_multi_union_pw_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::checked::pw_multi_aff union_pw_aff::as_pw_multi_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::checked::union_map union_pw_aff::as_union_map() const
+{
+  return isl::checked::union_pw_multi_aff(*this).as_union_map();
+}
+
+isl::checked::union_pw_aff union_pw_aff::at(int pos) const
+{
+  return isl::checked::multi_union_pw_aff(*this).at(pos);
+}
+
+isl::checked::union_set union_pw_aff::bind(const isl::checked::multi_id &tuple) const
+{
+  return isl::checked::multi_union_pw_aff(*this).bind(tuple);
+}
+
+isl::checked::union_set union_pw_aff::bind(isl::checked::id id) const
+{
+  auto res = isl_union_pw_aff_bind_id(copy(), id.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_pw_aff::bind(const std::string &id) const
+{
+  return this->bind(isl::checked::id(ctx(), id));
+}
+
+isl::checked::union_pw_aff union_pw_aff::coalesce() const
+{
+  auto res = isl_union_pw_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_pw_aff::domain() const
+{
+  auto res = isl_union_pw_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff union_pw_aff::extract_pw_multi_aff(const isl::checked::space &space) const
+{
+  return isl::checked::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::flat_range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::flat_range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::gist(isl::checked::union_set context) const
+{
+  auto res = isl_union_pw_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+boolean union_pw_aff::has_range_tuple_id() const
+{
+  return isl::checked::multi_union_pw_aff(*this).has_range_tuple_id();
+}
+
+isl::checked::union_pw_aff union_pw_aff::intersect_domain(isl::checked::space space) const
+{
+  auto res = isl_union_pw_aff_intersect_domain_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff::intersect_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_aff_intersect_domain_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff::intersect_domain_wrapped_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_aff_intersect_domain_wrapped_domain(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff::intersect_domain_wrapped_range(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_aff_intersect_domain_wrapped_range(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_union_pw_aff_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+boolean union_pw_aff::involves_locals() const
+{
+  return isl::checked::union_pw_multi_aff(*this).involves_locals();
+}
+
+boolean union_pw_aff::involves_nan() const
+{
+  return isl::checked::multi_union_pw_aff(*this).involves_nan();
+}
+
+boolean union_pw_aff::isa_pw_multi_aff() const
+{
+  return isl::checked::union_pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::checked::union_pw_aff_list union_pw_aff::list() const
+{
+  return isl::checked::multi_union_pw_aff(*this).list();
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::neg() const
+{
+  return isl::checked::multi_union_pw_aff(*this).neg();
+}
+
+boolean union_pw_aff::plain_is_empty() const
+{
+  return isl::checked::union_pw_multi_aff(*this).plain_is_empty();
+}
+
+boolean union_pw_aff::plain_is_equal(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::preimage_domain_wrapped_domain(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::pullback(isl::checked::union_pw_multi_aff upma) const
+{
+  auto res = isl_union_pw_aff_pullback_union_pw_multi_aff(copy(), upma.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::range_factor_domain() const
+{
+  return isl::checked::union_pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::range_factor_range() const
+{
+  return isl::checked::union_pw_multi_aff(*this).range_factor_range();
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::range_product(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).range_product(multi2);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::range_product(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::checked::id union_pw_aff::range_tuple_id() const
+{
+  return isl::checked::multi_union_pw_aff(*this).range_tuple_id();
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::reset_range_tuple_id() const
+{
+  return isl::checked::multi_union_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_union_pw_aff(*this).scale(mv);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale(const isl::checked::val &v) const
+{
+  return isl::checked::multi_union_pw_aff(*this).scale(v);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale(long v) const
+{
+  return this->scale(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale_down(const isl::checked::multi_val &mv) const
+{
+  return isl::checked::multi_union_pw_aff(*this).scale_down(mv);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale_down(const isl::checked::val &v) const
+{
+  return isl::checked::multi_union_pw_aff(*this).scale_down(v);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::scale_down(long v) const
+{
+  return this->scale_down(isl::checked::val(ctx(), v));
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::set_at(int pos, const isl::checked::union_pw_aff &el) const
+{
+  return isl::checked::multi_union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::set_range_tuple(const isl::checked::id &id) const
+{
+  return isl::checked::multi_union_pw_aff(*this).set_range_tuple(id);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::set_range_tuple(const std::string &id) const
+{
+  return this->set_range_tuple(isl::checked::id(ctx(), id));
+}
+
+class size union_pw_aff::size() const
+{
+  return isl::checked::multi_union_pw_aff(*this).size();
+}
+
+isl::checked::space union_pw_aff::space() const
+{
+  auto res = isl_union_pw_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space union_pw_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::sub(const isl::checked::multi_union_pw_aff &multi2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).sub(multi2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::sub(isl::checked::union_pw_aff upa2) const
+{
+  auto res = isl_union_pw_aff_sub(copy(), upa2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::sub(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).sub(upma2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::sub(const isl::checked::aff &upa2) const
+{
+  return this->sub(isl::checked::union_pw_aff(upa2));
+}
+
+isl::checked::union_pw_aff union_pw_aff::sub(const isl::checked::pw_aff &upa2) const
+{
+  return this->sub(isl::checked::union_pw_aff(upa2));
+}
+
+isl::checked::union_pw_aff union_pw_aff::subtract_domain(isl::checked::space space) const
+{
+  auto res = isl_union_pw_aff_subtract_domain_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff::subtract_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_aff_subtract_domain_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff_list union_pw_aff::to_list() const
+{
+  auto res = isl_union_pw_aff_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff union_pw_aff::union_add(const isl::checked::multi_union_pw_aff &mupa2) const
+{
+  return isl::checked::multi_union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::union_add(isl::checked::union_pw_aff upa2) const
+{
+  auto res = isl_union_pw_aff_union_add(copy(), upa2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_aff::union_add(const isl::checked::union_pw_multi_aff &upma2) const
+{
+  return isl::checked::union_pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::checked::union_pw_aff union_pw_aff::union_add(const isl::checked::aff &upa2) const
+{
+  return this->union_add(isl::checked::union_pw_aff(upa2));
+}
+
+isl::checked::union_pw_aff union_pw_aff::union_add(const isl::checked::pw_aff &upa2) const
+{
+  return this->union_add(isl::checked::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::checked::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::checked::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::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_union_pw_aff_list_free(ptr);
+}
+
+__isl_give isl_union_pw_aff_list *union_pw_aff_list::copy() const & {
+  return isl_union_pw_aff_list_copy(ptr);
+}
+
+__isl_keep isl_union_pw_aff_list *union_pw_aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_aff_list *union_pw_aff_list::release() {
+  isl_union_pw_aff_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_pw_aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_pw_aff_list::ctx() const {
+  return isl::checked::ctx(isl_union_pw_aff_list_get_ctx(ptr));
+}
+
+isl::checked::union_pw_aff_list union_pw_aff_list::add(isl::checked::union_pw_aff el) const
+{
+  auto res = isl_union_pw_aff_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff_list::at(int index) const
+{
+  auto res = isl_union_pw_aff_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::union_pw_aff union_pw_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::union_pw_aff_list union_pw_aff_list::clear() const
+{
+  auto res = isl_union_pw_aff_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_aff_list union_pw_aff_list::concat(isl::checked::union_pw_aff_list list2) const
+{
+  auto res = isl_union_pw_aff_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::union_pw_aff)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::union_pw_aff_list union_pw_aff_list::insert(unsigned int pos, isl::checked::union_pw_aff el) const
+{
+  auto res = isl_union_pw_aff_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size union_pw_aff_list::size() const
+{
+  auto res = isl_union_pw_aff_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_aff_list &obj)
+{
+  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::checked::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::checked::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::checked::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::checked::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);
+  return *this;
+}
+
+union_pw_multi_aff::~union_pw_multi_aff() {
+  if (ptr)
+    isl_union_pw_multi_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::copy() const & {
+  return isl_union_pw_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_multi_aff *union_pw_multi_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::release() {
+  isl_union_pw_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_pw_multi_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_pw_multi_aff::ctx() const {
+  return isl::checked::ctx(isl_union_pw_multi_aff_get_ctx(ptr));
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::add(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_add(copy(), upma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::apply(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_apply_union_pw_multi_aff(copy(), upma2.release());
+  return manage(res);
+}
+
+isl::checked::multi_union_pw_aff union_pw_multi_aff::as_multi_union_pw_aff() const
+{
+  auto res = isl_union_pw_multi_aff_as_multi_union_pw_aff(copy());
+  return manage(res);
+}
+
+isl::checked::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::checked::union_map union_pw_multi_aff::as_union_map() const
+{
+  auto res = isl_union_pw_multi_aff_as_union_map(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::coalesce() const
+{
+  auto res = isl_union_pw_multi_aff_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_pw_multi_aff::domain() const
+{
+  auto res = isl_union_pw_multi_aff_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::empty(isl::checked::ctx ctx)
+{
+  auto res = isl_union_pw_multi_aff_empty_ctx(ctx.release());
+  return manage(res);
+}
+
+isl::checked::pw_multi_aff union_pw_multi_aff::extract_pw_multi_aff(isl::checked::space space) const
+{
+  auto res = isl_union_pw_multi_aff_extract_pw_multi_aff(get(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::flat_range_product(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_flat_range_product(copy(), upma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::gist(isl::checked::union_set context) const
+{
+  auto res = isl_union_pw_multi_aff_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::checked::space space) const
+{
+  auto res = isl_union_pw_multi_aff_intersect_domain_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_multi_aff_intersect_domain_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::intersect_domain_wrapped_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_multi_aff_intersect_domain_wrapped_domain(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::intersect_domain_wrapped_range(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_multi_aff_intersect_domain_wrapped_range(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_union_pw_multi_aff_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+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::isa_pw_multi_aff() const
+{
+  auto res = isl_union_pw_multi_aff_isa_pw_multi_aff(get());
+  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);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::preimage_domain_wrapped_domain(isl::checked::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::checked::union_pw_multi_aff union_pw_multi_aff::pullback(isl::checked::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::checked::union_pw_multi_aff union_pw_multi_aff::range_factor_domain() const
+{
+  auto res = isl_union_pw_multi_aff_range_factor_domain(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::range_factor_range() const
+{
+  auto res = isl_union_pw_multi_aff_range_factor_range(copy());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::range_product(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_range_product(copy(), upma2.release());
+  return manage(res);
+}
+
+isl::checked::space union_pw_multi_aff::space() const
+{
+  auto res = isl_union_pw_multi_aff_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space union_pw_multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::sub(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_sub(copy(), upma2.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::subtract_domain(isl::checked::space space) const
+{
+  auto res = isl_union_pw_multi_aff_subtract_domain_space(copy(), space.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::subtract_domain(isl::checked::union_set uset) const
+{
+  auto res = isl_union_pw_multi_aff_subtract_domain_union_set(copy(), uset.release());
+  return manage(res);
+}
+
+isl::checked::union_pw_multi_aff union_pw_multi_aff::union_add(isl::checked::union_pw_multi_aff upma2) const
+{
+  auto res = isl_union_pw_multi_aff_union_add(copy(), upma2.release());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_multi_aff &obj)
+{
+  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::checked::basic_set bset)
+{
+  auto res = isl_union_set_from_basic_set(bset.release());
+  ptr = res;
+}
+
+union_set::union_set(isl::checked::point pnt)
+{
+  auto res = isl_union_set_from_point(pnt.release());
+  ptr = res;
+}
+
+union_set::union_set(isl::checked::set set)
+{
+  auto res = isl_union_set_from_set(set.release());
+  ptr = res;
+}
+
+union_set::union_set(isl::checked::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);
+  return *this;
+}
+
+union_set::~union_set() {
+  if (ptr)
+    isl_union_set_free(ptr);
+}
+
+__isl_give isl_union_set *union_set::copy() const & {
+  return isl_union_set_copy(ptr);
+}
+
+__isl_keep isl_union_set *union_set::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_set *union_set::release() {
+  isl_union_set *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_set::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_set::ctx() const {
+  return isl::checked::ctx(isl_union_set_get_ctx(ptr));
+}
+
+isl::checked::union_set union_set::affine_hull() const
+{
+  auto res = isl_union_set_affine_hull(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::apply(isl::checked::union_map umap) const
+{
+  auto res = isl_union_set_apply(copy(), umap.release());
+  return manage(res);
+}
+
+isl::checked::set union_set::as_set() const
+{
+  auto res = isl_union_set_as_set(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::coalesce() const
+{
+  auto res = isl_union_set_coalesce(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::compute_divs() const
+{
+  auto res = isl_union_set_compute_divs(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::detect_equalities() const
+{
+  auto res = isl_union_set_detect_equalities(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::empty(isl::checked::ctx ctx)
+{
+  auto res = isl_union_set_empty_ctx(ctx.release());
+  return manage(res);
+}
+
+boolean union_set::every_set(const std::function<boolean(isl::checked::set)> &test) const
+{
+  struct test_data {
+    std::function<boolean(isl::checked::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::checked::set union_set::extract_set(isl::checked::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(isl::checked::point)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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(isl::checked::set)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::union_set union_set::gist(isl::checked::union_set context) const
+{
+  auto res = isl_union_set_gist(copy(), context.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::gist_params(isl::checked::set set) const
+{
+  auto res = isl_union_set_gist_params(copy(), set.release());
+  return manage(res);
+}
+
+isl::checked::union_map union_set::identity() const
+{
+  auto res = isl_union_set_identity(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::intersect(isl::checked::union_set uset2) const
+{
+  auto res = isl_union_set_intersect(copy(), uset2.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::intersect_params(isl::checked::set set) const
+{
+  auto res = isl_union_set_intersect_params(copy(), set.release());
+  return manage(res);
+}
+
+boolean union_set::is_disjoint(const isl::checked::union_set &uset2) const
+{
+  auto res = isl_union_set_is_disjoint(get(), uset2.get());
+  return manage(res);
+}
+
+boolean union_set::is_empty() const
+{
+  auto res = isl_union_set_is_empty(get());
+  return manage(res);
+}
+
+boolean union_set::is_equal(const isl::checked::union_set &uset2) const
+{
+  auto res = isl_union_set_is_equal(get(), uset2.get());
+  return manage(res);
+}
+
+boolean union_set::is_strict_subset(const isl::checked::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::checked::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::checked::union_set union_set::lexmax() const
+{
+  auto res = isl_union_set_lexmax(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::lexmin() const
+{
+  auto res = isl_union_set_lexmin(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::polyhedral_hull() const
+{
+  auto res = isl_union_set_polyhedral_hull(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::preimage(isl::checked::multi_aff ma) const
+{
+  auto res = isl_union_set_preimage_multi_aff(copy(), ma.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::preimage(isl::checked::pw_multi_aff pma) const
+{
+  auto res = isl_union_set_preimage_pw_multi_aff(copy(), pma.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::preimage(isl::checked::union_pw_multi_aff upma) const
+{
+  auto res = isl_union_set_preimage_union_pw_multi_aff(copy(), upma.release());
+  return manage(res);
+}
+
+isl::checked::point union_set::sample_point() const
+{
+  auto res = isl_union_set_sample_point(copy());
+  return manage(res);
+}
+
+isl::checked::space union_set::space() const
+{
+  auto res = isl_union_set_get_space(get());
+  return manage(res);
+}
+
+isl::checked::space union_set::get_space() const
+{
+  return space();
+}
+
+isl::checked::union_set union_set::subtract(isl::checked::union_set uset2) const
+{
+  auto res = isl_union_set_subtract(copy(), uset2.release());
+  return manage(res);
+}
+
+isl::checked::union_set_list union_set::to_list() const
+{
+  auto res = isl_union_set_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::unite(isl::checked::union_set uset2) const
+{
+  auto res = isl_union_set_union(copy(), uset2.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set::universe() const
+{
+  auto res = isl_union_set_universe(copy());
+  return manage(res);
+}
+
+isl::checked::union_map union_set::unwrap() const
+{
+  auto res = isl_union_set_unwrap(copy());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_set &obj)
+{
+  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::checked::ctx ctx, int n)
+{
+  auto res = isl_union_set_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+union_set_list::union_set_list(isl::checked::union_set el)
+{
+  auto res = isl_union_set_list_from_union_set(el.release());
+  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_union_set_list_free(ptr);
+}
+
+__isl_give isl_union_set_list *union_set_list::copy() const & {
+  return isl_union_set_list_copy(ptr);
+}
+
+__isl_keep isl_union_set_list *union_set_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_set_list *union_set_list::release() {
+  isl_union_set_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool union_set_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx union_set_list::ctx() const {
+  return isl::checked::ctx(isl_union_set_list_get_ctx(ptr));
+}
+
+isl::checked::union_set_list union_set_list::add(isl::checked::union_set el) const
+{
+  auto res = isl_union_set_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::union_set union_set_list::at(int index) const
+{
+  auto res = isl_union_set_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::union_set union_set_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::union_set_list union_set_list::clear() const
+{
+  auto res = isl_union_set_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::union_set_list union_set_list::concat(isl::checked::union_set_list list2) const
+{
+  auto res = isl_union_set_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::union_set)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::union_set_list union_set_list::insert(unsigned int pos, isl::checked::union_set el) const
+{
+  auto res = isl_union_set_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+class size union_set_list::size() const
+{
+  auto res = isl_union_set_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_set_list &obj)
+{
+  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::checked::ctx ctx, long i)
+{
+  auto res = isl_val_int_from_si(ctx.release(), i);
+  ptr = res;
+}
+
+val::val(isl::checked::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);
+  return *this;
+}
+
+val::~val() {
+  if (ptr)
+    isl_val_free(ptr);
+}
+
+__isl_give isl_val *val::copy() const & {
+  return isl_val_copy(ptr);
+}
+
+__isl_keep isl_val *val::get() const {
+  return ptr;
+}
+
+__isl_give isl_val *val::release() {
+  isl_val *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool val::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx val::ctx() const {
+  return isl::checked::ctx(isl_val_get_ctx(ptr));
+}
+
+isl::checked::val val::abs() const
+{
+  auto res = isl_val_abs(copy());
+  return manage(res);
+}
+
+boolean val::abs_eq(const isl::checked::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::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::add(isl::checked::val v2) const
+{
+  auto res = isl_val_add(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::add(long v2) const
+{
+  return this->add(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::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::checked::val val::div(isl::checked::val v2) const
+{
+  auto res = isl_val_div(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::div(long v2) const
+{
+  return this->div(isl::checked::val(ctx(), v2));
+}
+
+boolean val::eq(const isl::checked::val &v2) const
+{
+  auto res = isl_val_eq(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::eq(long v2) const
+{
+  return this->eq(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::floor() const
+{
+  auto res = isl_val_floor(copy());
+  return manage(res);
+}
+
+isl::checked::val val::gcd(isl::checked::val v2) const
+{
+  auto res = isl_val_gcd(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::gcd(long v2) const
+{
+  return this->gcd(isl::checked::val(ctx(), v2));
+}
+
+boolean val::ge(const isl::checked::val &v2) const
+{
+  auto res = isl_val_ge(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::ge(long v2) const
+{
+  return this->ge(isl::checked::val(ctx(), v2));
+}
+
+boolean val::gt(const isl::checked::val &v2) const
+{
+  auto res = isl_val_gt(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::gt(long v2) const
+{
+  return this->gt(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::infty(isl::checked::ctx ctx)
+{
+  auto res = isl_val_infty(ctx.release());
+  return manage(res);
+}
+
+isl::checked::val val::inv() const
+{
+  auto res = isl_val_inv(copy());
+  return manage(res);
+}
+
+boolean val::is_divisible_by(const isl::checked::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::checked::val(ctx(), v2));
+}
+
+boolean val::is_infty() const
+{
+  auto res = isl_val_is_infty(get());
+  return manage(res);
+}
+
+boolean val::is_int() const
+{
+  auto res = isl_val_is_int(get());
+  return manage(res);
+}
+
+boolean val::is_nan() const
+{
+  auto res = isl_val_is_nan(get());
+  return manage(res);
+}
+
+boolean val::is_neg() const
+{
+  auto res = isl_val_is_neg(get());
+  return manage(res);
+}
+
+boolean val::is_neginfty() const
+{
+  auto res = isl_val_is_neginfty(get());
+  return manage(res);
+}
+
+boolean val::is_negone() const
+{
+  auto res = isl_val_is_negone(get());
+  return manage(res);
+}
+
+boolean val::is_nonneg() const
+{
+  auto res = isl_val_is_nonneg(get());
+  return manage(res);
+}
+
+boolean val::is_nonpos() const
+{
+  auto res = isl_val_is_nonpos(get());
+  return manage(res);
+}
+
+boolean val::is_one() const
+{
+  auto res = isl_val_is_one(get());
+  return manage(res);
+}
+
+boolean val::is_pos() const
+{
+  auto res = isl_val_is_pos(get());
+  return manage(res);
+}
+
+boolean val::is_rat() const
+{
+  auto res = isl_val_is_rat(get());
+  return manage(res);
+}
+
+boolean val::is_zero() const
+{
+  auto res = isl_val_is_zero(get());
+  return manage(res);
+}
+
+boolean val::le(const isl::checked::val &v2) const
+{
+  auto res = isl_val_le(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::le(long v2) const
+{
+  return this->le(isl::checked::val(ctx(), v2));
+}
+
+boolean val::lt(const isl::checked::val &v2) const
+{
+  auto res = isl_val_lt(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::lt(long v2) const
+{
+  return this->lt(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::max(isl::checked::val v2) const
+{
+  auto res = isl_val_max(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::max(long v2) const
+{
+  return this->max(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::min(isl::checked::val v2) const
+{
+  auto res = isl_val_min(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::min(long v2) const
+{
+  return this->min(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::mod(isl::checked::val v2) const
+{
+  auto res = isl_val_mod(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::mod(long v2) const
+{
+  return this->mod(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::mul(isl::checked::val v2) const
+{
+  auto res = isl_val_mul(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::mul(long v2) const
+{
+  return this->mul(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::nan(isl::checked::ctx ctx)
+{
+  auto res = isl_val_nan(ctx.release());
+  return manage(res);
+}
+
+boolean val::ne(const isl::checked::val &v2) const
+{
+  auto res = isl_val_ne(get(), v2.get());
+  return manage(res);
+}
+
+boolean val::ne(long v2) const
+{
+  return this->ne(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val val::neg() const
+{
+  auto res = isl_val_neg(copy());
+  return manage(res);
+}
+
+isl::checked::val val::neginfty(isl::checked::ctx ctx)
+{
+  auto res = isl_val_neginfty(ctx.release());
+  return manage(res);
+}
+
+isl::checked::val val::negone(isl::checked::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::checked::val val::one(isl::checked::ctx ctx)
+{
+  auto res = isl_val_one(ctx.release());
+  return manage(res);
+}
+
+isl::checked::val val::pow2() const
+{
+  auto res = isl_val_pow2(copy());
+  return manage(res);
+}
+
+int val::sgn() const
+{
+  auto res = isl_val_sgn(get());
+  return res;
+}
+
+isl::checked::val val::sub(isl::checked::val v2) const
+{
+  auto res = isl_val_sub(copy(), v2.release());
+  return manage(res);
+}
+
+isl::checked::val val::sub(long v2) const
+{
+  return this->sub(isl::checked::val(ctx(), v2));
+}
+
+isl::checked::val_list val::to_list() const
+{
+  auto res = isl_val_to_list(copy());
+  return manage(res);
+}
+
+isl::checked::val val::trunc() const
+{
+  auto res = isl_val_trunc(copy());
+  return manage(res);
+}
+
+isl::checked::val val::zero(isl::checked::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::checked::ctx ctx, int n)
+{
+  auto res = isl_val_list_alloc(ctx.release(), n);
+  ptr = res;
+}
+
+val_list::val_list(isl::checked::val el)
+{
+  auto res = isl_val_list_from_val(el.release());
+  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_val_list_free(ptr);
+}
+
+__isl_give isl_val_list *val_list::copy() const & {
+  return isl_val_list_copy(ptr);
+}
+
+__isl_keep isl_val_list *val_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_val_list *val_list::release() {
+  isl_val_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool val_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::checked::ctx val_list::ctx() const {
+  return isl::checked::ctx(isl_val_list_get_ctx(ptr));
+}
+
+isl::checked::val_list val_list::add(isl::checked::val el) const
+{
+  auto res = isl_val_list_add(copy(), el.release());
+  return manage(res);
+}
+
+isl::checked::val_list val_list::add(long el) const
+{
+  return this->add(isl::checked::val(ctx(), el));
+}
+
+isl::checked::val val_list::at(int index) const
+{
+  auto res = isl_val_list_get_at(get(), index);
+  return manage(res);
+}
+
+isl::checked::val val_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::checked::val_list val_list::clear() const
+{
+  auto res = isl_val_list_clear(copy());
+  return manage(res);
+}
+
+isl::checked::val_list val_list::concat(isl::checked::val_list list2) const
+{
+  auto res = isl_val_list_concat(copy(), list2.release());
+  return manage(res);
+}
+
+isl::checked::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(isl::checked::val)> &fn) const
+{
+  struct fn_data {
+    std::function<stat(isl::checked::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);
+    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::checked::val_list val_list::insert(unsigned int pos, isl::checked::val el) const
+{
+  auto res = isl_val_list_insert(copy(), pos, el.release());
+  return manage(res);
+}
+
+isl::checked::val_list val_list::insert(unsigned int pos, long el) const
+{
+  return this->insert(pos, isl::checked::val(ctx(), el));
+}
+
+class size val_list::size() const
+{
+  auto res = isl_val_list_size(get());
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const val_list &obj)
+{
+  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 checked
+} // namespace isl
+
+#endif /* ISL_CPP_CHECKED */

_service:tar_scm:isl-0.24.tar.gz/include/isl/cpp.h Added

@@ -0,0 +1,27646 @@
+/// These are automatically generated 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.
+
+#ifndef ISL_CPP
+#define ISL_CPP
+
+#include <isl/ctx.h>
+#include <isl/options.h>
+
+#include <functional>
+#include <memory>
+#include <ostream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+
+/* ISL_USE_EXCEPTIONS should be defined to 1 if exceptions are available.
+ * gcc and clang define __cpp_exceptions; MSVC and xlC define _CPPUNWIND.
+ * Older versions of gcc (e.g., 4.9) only define __EXCEPTIONS.
+ * If exceptions are not available, any error condition will result
+ * in an abort.
+ */
+#ifndef ISL_USE_EXCEPTIONS
+#if defined(__cpp_exceptions) || defined(_CPPUNWIND) || defined(__EXCEPTIONS)
+#define ISL_USE_EXCEPTIONS	1
+#else
+#define ISL_USE_EXCEPTIONS	0
+#endif
+#endif
+
+namespace isl {
+
+class ctx {
+	isl_ctx *ptr;
+public:
+	/* implicit */ ctx(isl_ctx *ctx) : ptr(ctx) {}
+	isl_ctx *release() {
+		auto tmp = ptr;
+		ptr = nullptr;
+		return tmp;
+	}
+	isl_ctx *get() {
+		return ptr;
+	}
+};
+
+/* Macros hiding try/catch.
+ * If exceptions are not available, then no exceptions will be thrown and
+ * there is nothing to catch.
+ */
+#if ISL_USE_EXCEPTIONS
+#define ISL_CPP_TRY		try
+#define ISL_CPP_CATCH_ALL	catch (...)
+#else
+#define ISL_CPP_TRY		if (1)
+#define ISL_CPP_CATCH_ALL	if (0)
+#endif
+
+#if ISL_USE_EXCEPTIONS
+
+/* Class capturing isl errors.
+ *
+ * The what() return value is stored in a reference counted string
+ * to ensure that the copy constructor and the assignment operator
+ * do not throw any exceptions.
+ */
+class exception : public std::exception {
+	std::shared_ptr<std::string> what_str;
+
+protected:
+	inline exception(const char *what_arg, const char *msg,
+		const char *file, int line);
+public:
+	exception() {}
+	exception(const char *what_arg) {
+		what_str = std::make_shared<std::string>(what_arg);
+	}
+	static inline void throw_error(enum isl_error error, const char *msg,
+		const char *file, int line);
+	virtual const char *what() const noexcept {
+		return what_str->c_str();
+	}
+
+	/* Default behavior on error conditions that occur inside isl calls
+	 * performed from inside the bindings.
+	 * In the case exceptions are available, isl should continue
+	 * without printing a warning since the warning message
+	 * will be included in the exception thrown from inside the bindings.
+	 */
+	static constexpr auto on_error = ISL_ON_ERROR_CONTINUE;
+	/* Wrapper for throwing an exception with the given message.
+	 */
+	static void throw_invalid(const char *msg, const char *file, int line) {
+		throw_error(isl_error_invalid, msg, file, line);
+	}
+	static inline void throw_last_error(ctx ctx);
+};
+
+/* Create an exception of a type described by "what_arg", with
+ * error message "msg" in line "line" of file "file".
+ *
+ * Create a string holding the what() return value that
+ * corresponds to what isl would have printed.
+ * If no error message or no error file was set, then use "what_arg" instead.
+ */
+exception::exception(const char *what_arg, const char *msg, const char *file,
+	int line)
+{
+	if (!msg || !file)
+		what_str = std::make_shared<std::string>(what_arg);
+	else
+		what_str = std::make_shared<std::string>(std::string(file) +
+				    ":" + std::to_string(line) + ": " + msg);
+}
+
+class exception_abort : public exception {
+	friend exception;
+	exception_abort(const char *msg, const char *file, int line) :
+		exception("execution aborted", msg, file, line) {}
+};
+
+class exception_alloc : public exception {
+	friend exception;
+	exception_alloc(const char *msg, const char *file, int line) :
+		exception("memory allocation failure", msg, file, line) {}
+};
+
+class exception_unknown : public exception {
+	friend exception;
+	exception_unknown(const char *msg, const char *file, int line) :
+		exception("unknown failure", msg, file, line) {}
+};
+
+class exception_internal : public exception {
+	friend exception;
+	exception_internal(const char *msg, const char *file, int line) :
+		exception("internal error", msg, file, line) {}
+};
+
+class exception_invalid : public exception {
+	friend exception;
+	exception_invalid(const char *msg, const char *file, int line) :
+		exception("invalid argument", msg, file, line) {}
+};
+
+class exception_quota : public exception {
+	friend exception;
+	exception_quota(const char *msg, const char *file, int line) :
+		exception("quota exceeded", msg, file, line) {}
+};
+
+class exception_unsupported : public exception {
+	friend exception;
+	exception_unsupported(const char *msg, const char *file, int line) :
+		exception("unsupported operation", msg, file, line) {}
+};
+
+/* Throw an exception of the class that corresponds to "error", with
+ * error message "msg" in line "line" of file "file".
+ *
+ * isl_error_none is treated as an invalid error type.
+ */
+void exception::throw_error(enum isl_error error, const char *msg,
+	const char *file, int line)
+{
+	switch (error) {
+	case isl_error_none:
+		break;
+	case isl_error_abort: throw exception_abort(msg, file, line);
+	case isl_error_alloc: throw exception_alloc(msg, file, line);
+	case isl_error_unknown: throw exception_unknown(msg, file, line);
+	case isl_error_internal: throw exception_internal(msg, file, line);
+	case isl_error_invalid: throw exception_invalid(msg, file, line);
+	case isl_error_quota: throw exception_quota(msg, file, line);
+	case isl_error_unsupported:
+				throw exception_unsupported(msg, file, line);
+	}
+
+	throw exception_invalid("invalid error type", file, line);
+}
+
+/* Throw an exception corresponding to the last error on "ctx" and
+ * reset the error.
+ *
+ * If "ctx" is NULL or if it is not in an error state at the start,
+ * then an invalid argument exception is thrown.
+ */
+void exception::throw_last_error(ctx ctx)
+{
+	enum isl_error error;
+	const char *msg, *file;
+	int line;
+
+	error = isl_ctx_last_error(ctx.get());
+	msg = isl_ctx_last_error_msg(ctx.get());
+	file = isl_ctx_last_error_file(ctx.get());
+	line = isl_ctx_last_error_line(ctx.get());
+	isl_ctx_reset_error(ctx.get());
+
+	throw_error(error, msg, file, line);
+}
+
+#else
+
+#include <stdio.h>
+#include <stdlib.h>
+
+class exception {
+public:
+	/* Default behavior on error conditions that occur inside isl calls
+	 * performed from inside the bindings.
+	 * In the case exceptions are not available, isl should abort.
+	 */
+	static constexpr auto on_error = ISL_ON_ERROR_ABORT;
+	/* Wrapper for throwing an exception with the given message.
+	 * In the case exceptions are not available, print an error and abort.
+	 */
+	static void throw_invalid(const char *msg, const char *file, int line) {
+		fprintf(stderr, "%s:%d: %s\n", file, line, msg);
+		abort();
+	}
+	/* Throw an exception corresponding to the last
+	 * error on "ctx".
+	 * isl should already abort when an error condition occurs,
+	 * so this function should never be called.
+	 */
+	static void throw_last_error(ctx ctx) {
+		abort();
+	}
+};
+
+#endif
+
+/* Helper class for setting the on_error and resetting the option
+ * to the original value when leaving the scope.
+ */
+class options_scoped_set_on_error {
+	isl_ctx *ctx;
+	int saved_on_error;
+public:
+	options_scoped_set_on_error(class ctx ctx, int on_error) {
+		this->ctx = ctx.get();
+		saved_on_error = isl_options_get_on_error(this->ctx);
+		isl_options_set_on_error(this->ctx, on_error);
+	}
+	~options_scoped_set_on_error() {
+		isl_options_set_on_error(ctx, saved_on_error);
+	}
+};
+
+} // 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/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>
+
+namespace isl {
+
+// forward declarations
+class aff;
+class aff_list;
+class ast_build;
+class ast_expr;
+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_set;
+class fixed_box;
+class id;
+class id_list;
+class map;
+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 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 space;
+class union_access_info;
+class union_flow;
+class union_map;
+class union_pw_aff;
+class union_pw_aff_list;
+class union_pw_multi_aff;
+class union_set;
+class union_set_list;
+class val;
+class val_list;
+
+// 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 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 isl::aff add(isl::aff aff2) 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(long v) const;
+  inline isl::multi_aff add_constant(const isl::multi_val &mv) 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 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::aff div(isl::aff aff2) const;
+  inline isl::pw_aff div(const isl::pw_aff &pa2) const;
+  inline isl::set domain() 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 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 void foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const;
+  inline isl::set ge_set(isl::aff aff2) const;
+  inline isl::set ge_set(const isl::pw_aff &pwaff2) const;
+  inline isl::aff gist(isl::set context) 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::set gt_set(const isl::pw_aff &pwaff2) const;
+  inline bool 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 bool involves_locals() const;
+  inline bool involves_nan() const;
+  inline bool involves_param(const isl::id &id) const;
+  inline bool involves_param(const std::string &id) const;
+  inline bool involves_param(const isl::id_list &list) const;
+  inline bool is_cst() const;
+  inline bool isa_aff() const;
+  inline bool isa_multi_aff() const;
+  inline bool isa_pw_multi_aff() const;
+  inline isl::set le_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 mod(long mod) const;
+  inline isl::aff mul(isl::aff aff2) const;
+  inline isl::pw_aff mul(const isl::pw_aff &pwaff2) const;
+  inline unsigned 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 bool plain_is_empty() const;
+  inline bool plain_is_equal(const isl::multi_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool 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::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 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::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(long v) const;
+  inline isl::multi_aff scale_down(const isl::multi_val &mv) 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::multi_aff set_range_tuple(const isl::id &id) const;
+  inline isl::multi_aff set_range_tuple(const std::string &id) const;
+  inline unsigned 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::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_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 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 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 isl::aff_list add(isl::aff el) const;
+  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 void foreach(const std::function<void(isl::aff)> &fn) const;
+  inline isl::aff_list insert(unsigned int pos, isl::aff el) const;
+  inline unsigned 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::exception_ptr eptr;
+  };
+  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_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::ast_node node_from(isl::schedule schedule) const;
+  inline isl::ast_node node_from_schedule_map(isl::union_map schedule) 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 bool isa_type(T subtype) const;
+public:
+  template <class T> inline bool isa() const;
+  template <class T> inline T as() const;
+  inline isl::ctx ctx() const;
+
+  inline std::string to_C_str() const;
+};
+
+// declarations for isl::ast_expr_id
+
+class ast_expr_id : public ast_expr {
+  template <class T>
+  friend bool 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 bool 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 bool 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 bool isa_type(T subtype) const;
+public:
+  template <class T> inline bool 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 unsigned n_arg() const;
+  inline unsigned get_n_arg() const;
+};
+
+// declarations for isl::ast_expr_op_access
+
+class ast_expr_op_access : public ast_expr_op {
+  template <class T>
+  friend bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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;
+
+};
+
+// 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 bool isa_type(T subtype) const;
+public:
+  template <class T> inline bool isa() const;
+  template <class T> inline T as() const;
+  inline isl::ctx ctx() const;
+
+  inline std::string to_C_str() 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 bool 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 bool 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 bool 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 bool 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 bool 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 isl::ast_node_list add(isl::ast_node el) const;
+  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 void foreach(const std::function<void(isl::ast_node)> &fn) const;
+  inline isl::ast_node_list insert(unsigned int pos, isl::ast_node el) const;
+  inline unsigned size() const;
+};
+
+// declarations for isl::ast_node_mark
+
+class ast_node_mark : public ast_node {
+  template <class T>
+  friend bool 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 bool 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 isl::basic_map affine_hull() 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::set bind_domain(const isl::multi_id &tuple) const;
+  inline isl::set bind_range(const isl::multi_id &tuple) 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 detect_equalities() const;
+  inline isl::set domain() const;
+  inline isl::map domain_factor_domain() const;
+  inline isl::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::map domain_product(const isl::map &map2) const;
+  inline isl::union_map domain_product(const isl::union_map &umap2) 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;
+  inline bool every_map(const std::function<bool(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::union_map fixed_power(const isl::val &exp) const;
+  inline isl::union_map fixed_power(long exp) const;
+  inline isl::basic_map flatten() const;
+  inline isl::basic_map flatten_domain() const;
+  inline isl::basic_map flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const;
+  inline void foreach_map(const std::function<void(isl::map)> &fn) const;
+  inline isl::basic_map gist(isl::basic_map context) 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::union_map gist_params(const isl::set &set) const;
+  inline isl::union_map gist_range(const isl::union_set &uset) const;
+  inline bool has_domain_tuple_id() const;
+  inline bool has_range_tuple_id() 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 bool is_bijective() const;
+  inline bool is_disjoint(const isl::map &map2) const;
+  inline bool is_disjoint(const isl::union_map &umap2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::basic_map &bmap2) const;
+  inline bool is_equal(const isl::map &map2) const;
+  inline bool is_equal(const isl::union_map &umap2) const;
+  inline bool is_injective() const;
+  inline bool is_single_valued() const;
+  inline bool is_strict_subset(const isl::map &map2) const;
+  inline bool is_strict_subset(const isl::union_map &umap2) const;
+  inline bool is_subset(const isl::basic_map &bmap2) const;
+  inline bool is_subset(const isl::map &map2) const;
+  inline bool is_subset(const isl::union_map &umap2) const;
+  inline bool 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::map lower_bound(const isl::multi_pw_aff &lower) const;
+  inline isl::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::multi_pw_aff min_multi_pw_aff() 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_all_params() const;
+  inline isl::set range() const;
+  inline isl::map range_factor_domain() const;
+  inline isl::map range_factor_range() const;
+  inline isl::union_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 isl::id range_tuple_id() const;
+  inline isl::basic_map reverse() const;
+  inline isl::basic_map sample() 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::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::union_map to_union_map() 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;
+  inline isl::basic_map unshifted_simple_hull() const;
+  inline isl::map upper_bound(const isl::multi_pw_aff &upper) const;
+  inline isl::set wrap() const;
+  inline isl::map zip() 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 isl::basic_set affine_hull() const;
+  inline isl::basic_set apply(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::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 isl::basic_set detect_equalities() const;
+  inline isl::val dim_max_val(int pos) const;
+  inline isl::val dim_min_val(int pos) const;
+  inline bool every_set(const std::function<bool(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) const;
+  inline isl::basic_set flatten() const;
+  inline void foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
+  inline void foreach_set(const std::function<void(isl::set)> &fn) const;
+  inline isl::basic_set gist(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::basic_set gist(const isl::point &context) const;
+  inline isl::union_set gist_params(const isl::set &set) const;
+  inline isl::map identity() const;
+  inline isl::pw_aff indicator_function() 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 bool involves_locals() const;
+  inline bool is_disjoint(const isl::set &set2) const;
+  inline bool is_disjoint(const isl::union_set &uset2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::basic_set &bset2) const;
+  inline bool is_equal(const isl::set &set2) const;
+  inline bool is_equal(const isl::union_set &uset2) const;
+  inline bool is_equal(const isl::point &bset2) const;
+  inline bool is_singleton() const;
+  inline bool is_strict_subset(const isl::set &set2) const;
+  inline bool is_strict_subset(const isl::union_set &uset2) const;
+  inline bool is_subset(const isl::basic_set &bset2) const;
+  inline bool is_subset(const isl::set &set2) const;
+  inline bool is_subset(const isl::union_set &uset2) const;
+  inline bool is_subset(const isl::point &bset2) const;
+  inline bool is_wrapping() const;
+  inline bool 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::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::basic_set params() 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::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::basic_set sample() const;
+  inline isl::point sample_point() const;
+  inline isl::fixed_box simple_fixed_box_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::union_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 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;
+  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;
+};
+
+// 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 bool 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;
+};
+
+// 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 std::string name() const;
+  inline std::string get_name() const;
+  inline isl::id_list to_list() 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 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 isl::id_list add(isl::id el) const;
+  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 void foreach(const std::function<void(isl::id)> &fn) const;
+  inline isl::id_list insert(unsigned int pos, isl::id el) const;
+  inline isl::id_list insert(unsigned int pos, const std::string &el) const;
+  inline unsigned size() 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 isl::basic_map affine_hull() 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::set bind_domain(isl::multi_id tuple) const;
+  inline isl::set bind_range(isl::multi_id tuple) 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::set deltas() const;
+  inline isl::map detect_equalities() const;
+  inline isl::set domain() const;
+  inline isl::map domain_factor_domain() const;
+  inline isl::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::map domain_product(isl::map map2) 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 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 bool every_map(const std::function<bool(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::union_map fixed_power(const isl::val &exp) const;
+  inline isl::union_map fixed_power(long exp) const;
+  inline isl::map flatten() const;
+  inline isl::map flatten_domain() const;
+  inline isl::map flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const;
+  inline void foreach_map(const std::function<void(isl::map)> &fn) const;
+  inline isl::map gist(isl::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::union_map gist_params(const isl::set &set) const;
+  inline isl::union_map gist_range(const isl::union_set &uset) const;
+  inline bool has_domain_tuple_id() const;
+  inline bool has_range_tuple_id() 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 bool is_bijective() const;
+  inline bool is_disjoint(const isl::map &map2) const;
+  inline bool is_disjoint(const isl::union_map &umap2) const;
+  inline bool is_disjoint(const isl::basic_map &map2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::map &map2) const;
+  inline bool is_equal(const isl::union_map &umap2) const;
+  inline bool is_equal(const isl::basic_map &map2) const;
+  inline bool is_injective() const;
+  inline bool is_single_valued() const;
+  inline bool is_strict_subset(const isl::map &map2) const;
+  inline bool is_strict_subset(const isl::union_map &umap2) const;
+  inline bool is_strict_subset(const isl::basic_map &map2) const;
+  inline bool is_subset(const isl::map &map2) const;
+  inline bool is_subset(const isl::union_map &umap2) const;
+  inline bool is_subset(const isl::basic_map &map2) const;
+  inline bool isa_map() const;
+  inline isl::map lex_ge_at(isl::multi_pw_aff mpa) const;
+  inline isl::map lex_gt_at(isl::multi_pw_aff mpa) const;
+  inline isl::map lex_le_at(isl::multi_pw_aff mpa) const;
+  inline isl::map lex_lt_at(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::map lower_bound(isl::multi_pw_aff lower) const;
+  inline isl::multi_pw_aff max_multi_pw_aff() const;
+  inline isl::multi_pw_aff min_multi_pw_aff() 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_all_params() const;
+  inline isl::set range() const;
+  inline isl::map range_factor_domain() const;
+  inline isl::map range_factor_range() const;
+  inline isl::union_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::fixed_box range_simple_fixed_box_hull() const;
+  inline isl::fixed_box get_range_simple_fixed_box_hull() 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_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::space space() const;
+  inline isl::space get_space() const;
+  inline isl::map subtract(isl::map map2) 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::union_map to_union_map() 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::map upper_bound(isl::multi_pw_aff upper) const;
+  inline isl::set wrap() const;
+  inline isl::map zip() 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 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_constant(long v) 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::pw_multi_aff coalesce() const;
+  inline isl::multi_val constant_multi_val() const;
+  inline isl::multi_val get_constant_multi_val() const;
+  inline isl::set domain() const;
+  static inline isl::multi_aff domain_map(isl::space space);
+  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_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 void foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const;
+  inline isl::multi_aff gist(isl::set context) 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 bool has_range_tuple_id() const;
+  inline isl::multi_aff identity() const;
+  static inline isl::multi_aff identity_on_domain(isl::space space);
+  inline isl::multi_aff insert_domain(isl::space domain) 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 bool involves_locals() const;
+  inline bool involves_nan() const;
+  inline bool involves_param(const isl::id &id) const;
+  inline bool involves_param(const std::string &id) const;
+  inline bool involves_param(const isl::id_list &list) const;
+  inline bool isa_multi_aff() const;
+  inline bool 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 unsigned n_piece() const;
+  inline isl::multi_aff neg() const;
+  inline bool plain_is_empty() const;
+  inline bool plain_is_equal(const isl::multi_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline bool 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_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_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 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_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 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_at(int pos, 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::multi_aff set_range_tuple(isl::id id) const;
+  inline isl::multi_aff set_range_tuple(const std::string &id) const;
+  inline unsigned 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::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 isl::id at(int pos) const;
+  inline isl::id get_at(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 bool plain_is_equal(const isl::multi_id &multi2) const;
+  inline isl::multi_id range_product(isl::multi_id multi2) 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 unsigned 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 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_constant(long v) const;
+  inline isl::map as_map() 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::set domain() const;
+  inline isl::multi_pw_aff flat_range_product(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::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_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 bool has_range_tuple_id() const;
+  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_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 bool involves_nan() const;
+  inline bool involves_param(const isl::id &id) const;
+  inline bool involves_param(const std::string &id) const;
+  inline bool involves_param(const isl::id_list &list) 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 neg() const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_union_pw_aff &multi2) const;
+  inline bool plain_is_equal(const isl::aff &multi2) const;
+  inline bool plain_is_equal(const isl::multi_aff &multi2) const;
+  inline bool plain_is_equal(const isl::pw_aff &multi2) const;
+  inline bool 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 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_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_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 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_union_pw_aff set_at(int pos, const isl::union_pw_aff &el) 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 unsigned 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::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 isl::multi_union_pw_aff add(isl::multi_union_pw_aff multi2) 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::union_set domain() const;
+  inline isl::multi_union_pw_aff flat_range_product(isl::multi_union_pw_aff multi2) const;
+  inline isl::multi_union_pw_aff gist(isl::union_set context) const;
+  inline bool 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 bool involves_nan() const;
+  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 bool 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;
+  inline isl::multi_union_pw_aff range_product(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 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_range_tuple(isl::id id) const;
+  inline isl::multi_union_pw_aff set_range_tuple(const std::string &id) const;
+  inline unsigned 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);
+};
+
+// 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 isl::multi_val add(isl::multi_val multi2) const;
+  inline isl::multi_val add(isl::val v) 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::multi_val flat_range_product(isl::multi_val multi2) const;
+  inline bool has_range_tuple_id() const;
+  inline bool involves_nan() 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 neg() const;
+  inline bool plain_is_equal(const isl::multi_val &multi2) const;
+  inline isl::multi_val product(isl::multi_val multi2) const;
+  inline isl::multi_val range_product(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 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_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 unsigned 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 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 isl::basic_set affine_hull() 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::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 isl::basic_set detect_equalities() const;
+  inline isl::val dim_max_val(int pos) const;
+  inline isl::val dim_min_val(int pos) const;
+  inline bool every_set(const std::function<bool(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) const;
+  inline isl::basic_set flatten() const;
+  inline void foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
+  inline void foreach_set(const std::function<void(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::union_set gist_params(const isl::set &set) const;
+  inline isl::map identity() const;
+  inline isl::pw_aff indicator_function() 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 bool involves_locals() const;
+  inline bool is_disjoint(const isl::set &set2) const;
+  inline bool is_disjoint(const isl::union_set &uset2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::basic_set &bset2) const;
+  inline bool is_equal(const isl::set &set2) const;
+  inline bool is_equal(const isl::union_set &uset2) const;
+  inline bool is_singleton() const;
+  inline bool is_strict_subset(const isl::set &set2) const;
+  inline bool is_strict_subset(const isl::union_set &uset2) const;
+  inline bool is_subset(const isl::basic_set &bset2) const;
+  inline bool is_subset(const isl::set &set2) const;
+  inline bool is_subset(const isl::union_set &uset2) const;
+  inline bool is_wrapping() const;
+  inline bool 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::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::basic_set params() 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::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::basic_set sample() const;
+  inline isl::point sample_point() const;
+  inline isl::fixed_box simple_fixed_box_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::union_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 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;
+};
+
+// 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 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 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::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::pw_aff div(isl::pw_aff pa2) const;
+  inline isl::set domain() const;
+  inline isl::set eq_set(isl::pw_aff pwaff2) const;
+  inline isl::val eval(isl::point pnt) 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 void foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const;
+  inline isl::set ge_set(isl::pw_aff pwaff2) const;
+  inline isl::pw_aff gist(isl::set context) 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 bool 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::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 bool involves_locals() const;
+  inline bool involves_nan() const;
+  inline bool involves_param(const isl::id &id) const;
+  inline bool involves_param(const std::string &id) const;
+  inline bool involves_param(const isl::id_list &list) const;
+  inline bool isa_aff() const;
+  inline bool isa_multi_aff() const;
+  inline bool isa_pw_multi_aff() const;
+  inline isl::set le_set(isl::pw_aff pwaff2) 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 mod(long mod) const;
+  inline isl::pw_aff mul(isl::pw_aff pwaff2) const;
+  inline unsigned n_piece() const;
+  inline isl::set ne_set(isl::pw_aff pwaff2) const;
+  inline isl::pw_aff neg() const;
+  static inline isl::pw_aff param_on_domain(isl::set domain, isl::id id);
+  inline bool plain_is_empty() const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool 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::union_pw_aff pullback(const isl::union_pw_multi_aff &upma) 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 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 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::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 unsigned size() const;
+  inline isl::space 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::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_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;
+};
+
+// 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 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 isl::pw_aff_list add(isl::pw_aff el) const;
+  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 void foreach(const std::function<void(isl::pw_aff)> &fn) const;
+  inline isl::pw_aff_list insert(unsigned int pos, isl::pw_aff el) const;
+  inline unsigned 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 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 add_constant(long v) 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::set domain() const;
+  static inline isl::pw_multi_aff domain_map(isl::space space);
+  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 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 void foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const;
+  inline isl::pw_multi_aff gist(isl::set set) const;
+  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 bool 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::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 bool involves_locals() const;
+  inline bool involves_nan() const;
+  inline bool involves_param(const isl::id &id) const;
+  inline bool involves_param(const std::string &id) const;
+  inline bool involves_param(const isl::id_list &list) const;
+  inline bool isa_multi_aff() const;
+  inline bool 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 unsigned n_piece() const;
+  inline isl::multi_pw_aff neg() const;
+  inline bool plain_is_empty() const;
+  inline bool plain_is_equal(const isl::multi_pw_aff &multi2) const;
+  inline bool 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 product(const isl::multi_aff &pma2) const;
+  inline isl::pw_multi_aff product(const isl::pw_aff &pma2) const;
+  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 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::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 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_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::pw_multi_aff set_range_tuple(isl::id id) const;
+  inline isl::pw_multi_aff set_range_tuple(const std::string &id) const;
+  inline unsigned 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::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::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 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 isl::pw_multi_aff_list add(isl::pw_multi_aff el) const;
+  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 void foreach(const std::function<void(isl::pw_multi_aff)> &fn) const;
+  inline isl::pw_multi_aff_list insert(unsigned int pos, isl::pw_multi_aff el) const;
+  inline unsigned 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 isl::union_set domain() const;
+  inline isl::union_set get_domain() const;
+  static inline isl::schedule from_domain(isl::union_set domain);
+  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_node root() const;
+  inline isl::schedule_node get_root() 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 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;
+  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 bool isa_type(T subtype) const;
+public:
+  template <class T> inline bool isa() const;
+  template <class T> inline T as() const;
+  inline isl::ctx ctx() const;
+
+  inline isl::schedule_node ancestor(int generation) const;
+  inline unsigned ancestor_child_position(const isl::schedule_node &ancestor) const;
+  inline unsigned get_ancestor_child_position(const isl::schedule_node &ancestor) const;
+  inline isl::schedule_node child(int pos) const;
+  inline unsigned child_position() const;
+  inline unsigned get_child_position() const;
+  inline bool every_descendant(const std::function<bool(isl::schedule_node)> &test) const;
+  inline isl::schedule_node first_child() const;
+  inline void foreach_ancestor_top_down(const std::function<void(isl::schedule_node)> &fn) const;
+  inline void foreach_descendant_top_down(const std::function<bool(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::schedule_node graft_after(isl::schedule_node graft) const;
+  inline isl::schedule_node graft_before(isl::schedule_node graft) const;
+  inline bool has_children() const;
+  inline bool has_next_sibling() const;
+  inline bool has_parent() const;
+  inline bool 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 bool is_equal(const isl::schedule_node &node2) const;
+  inline bool is_subtree_anchored() const;
+  inline isl::schedule_node map_descendant_bottom_up(const std::function<isl::schedule_node(isl::schedule_node)> &fn) const;
+  inline unsigned 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_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 root() const;
+  inline isl::schedule schedule() const;
+  inline isl::schedule get_schedule() 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 unsigned tree_depth() const;
+  inline unsigned get_tree_depth() const;
+};
+
+// declarations for isl::schedule_node_band
+
+class schedule_node_band : public schedule_node {
+  template <class T>
+  friend bool 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 bool 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 unsigned n_member() const;
+  inline isl::multi_union_pw_aff partial_schedule() const;
+  inline isl::multi_union_pw_aff get_partial_schedule() const;
+  inline bool permutable() const;
+  inline bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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 bool 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;
+
+};
+
+// declarations for isl::schedule_node_sequence
+
+class schedule_node_sequence : public schedule_node {
+  template <class T>
+  friend bool 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 bool 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::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 isl::basic_set affine_hull() 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::set bind(isl::multi_id tuple) const;
+  inline isl::set coalesce() const;
+  inline isl::set complement() const;
+  inline isl::union_set compute_divs() const;
+  inline isl::set detect_equalities() const;
+  inline isl::val dim_max_val(int pos) const;
+  inline isl::val dim_min_val(int pos) const;
+  static inline isl::set empty(isl::space space);
+  inline bool every_set(const std::function<bool(isl::set)> &test) const;
+  inline isl::set extract_set(const isl::space &space) const;
+  inline isl::set flatten() const;
+  inline void foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
+  inline void foreach_set(const std::function<void(isl::set)> &fn) const;
+  inline isl::set gist(isl::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::union_set gist_params(const isl::set &set) const;
+  inline isl::map identity() const;
+  inline isl::pw_aff indicator_function() const;
+  inline isl::map insert_domain(isl::space domain) const;
+  inline isl::set intersect(isl::set set2) 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 bool involves_locals() const;
+  inline bool is_disjoint(const isl::set &set2) const;
+  inline bool is_disjoint(const isl::union_set &uset2) const;
+  inline bool is_disjoint(const isl::basic_set &set2) const;
+  inline bool is_disjoint(const isl::point &set2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::set &set2) const;
+  inline bool is_equal(const isl::union_set &uset2) const;
+  inline bool is_equal(const isl::basic_set &set2) const;
+  inline bool is_equal(const isl::point &set2) const;
+  inline bool is_singleton() const;
+  inline bool is_strict_subset(const isl::set &set2) const;
+  inline bool is_strict_subset(const isl::union_set &uset2) const;
+  inline bool is_strict_subset(const isl::basic_set &set2) const;
+  inline bool is_strict_subset(const isl::point &set2) const;
+  inline bool is_subset(const isl::set &set2) const;
+  inline bool is_subset(const isl::union_set &uset2) const;
+  inline bool is_subset(const isl::basic_set &set2) const;
+  inline bool is_subset(const isl::point &set2) const;
+  inline bool is_wrapping() const;
+  inline bool 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::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 params() 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::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::basic_set sample() const;
+  inline isl::point sample_point() const;
+  inline isl::fixed_box simple_fixed_box_hull() const;
+  inline isl::fixed_box get_simple_fixed_box_hull() 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::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::union_set_list to_list() const;
+  inline isl::union_set to_union_set() const;
+  inline isl::map translation() 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::map unwrap() const;
+  inline isl::set upper_bound(isl::multi_pw_aff upper) const;
+  inline isl::set upper_bound(isl::multi_val upper) 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 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 isl::space add_named_tuple(isl::id tuple_id, unsigned int dim) const;
+  inline isl::space add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  inline isl::space add_unnamed_tuple(unsigned int dim) const;
+  inline isl::space curry() const;
+  inline isl::space domain() 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 flatten_domain() const;
+  inline isl::space flatten_range() const;
+  inline bool has_domain_tuple_id() const;
+  inline bool has_range_tuple_id() 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 bool is_equal(const isl::space &space2) const;
+  inline bool is_wrapping() const;
+  inline isl::space map_from_set() 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::space params() const;
+  inline isl::space product(isl::space right) const;
+  inline isl::space range() 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::id range_tuple_id() const;
+  inline isl::id get_range_tuple_id() const;
+  inline isl::space reverse() 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_range_tuple(isl::id id) const;
+  inline isl::space set_range_tuple(const std::string &id) 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::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);
+  inline union_access_info &operator=(union_access_info obj);
+  inline ~union_access_info();
+  inline __isl_give isl_union_access_info *copy() const &;
+  inline __isl_give isl_union_access_info *copy() && = delete;
+  inline __isl_keep isl_union_access_info *get() const;
+  inline __isl_give isl_union_access_info *release();
+  inline bool is_null() const;
+  inline isl::ctx ctx() const;
+
+  inline isl::union_flow compute_flow() const;
+  inline isl::union_access_info set_kill(isl::union_map kill) const;
+  inline isl::union_access_info set_may_source(isl::union_map may_source) const;
+  inline isl::union_access_info set_must_source(isl::union_map must_source) const;
+  inline isl::union_access_info set_schedule(isl::schedule schedule) const;
+  inline isl::union_access_info set_schedule_map(isl::union_map schedule_map) const;
+};
+
+// 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::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 isl::union_map affine_hull() 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 isl::union_map compute_divs() const;
+  inline isl::union_map curry() const;
+  inline isl::union_set deltas() const;
+  inline isl::union_map detect_equalities() 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 bool every_map(const std::function<bool(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 isl::union_map fixed_power(isl::val exp) const;
+  inline isl::union_map fixed_power(long exp) const;
+  inline void foreach_map(const std::function<void(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);
+  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 bool is_bijective() const;
+  inline bool is_disjoint(const isl::union_map &umap2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::union_map &umap2) const;
+  inline bool is_injective() const;
+  inline bool is_single_valued() const;
+  inline bool is_strict_subset(const isl::union_map &umap2) const;
+  inline bool is_subset(const isl::union_map &umap2) const;
+  inline bool isa_map() const;
+  inline isl::union_map lexmax() const;
+  inline isl::union_map lexmin() 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_all_params() const;
+  inline isl::union_set range() 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 reverse() 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_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 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 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_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 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::union_set domain() 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 isl::union_pw_aff gist(isl::union_set context) const;
+  inline bool 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 bool involves_locals() const;
+  inline bool involves_nan() const;
+  inline bool isa_pw_multi_aff() const;
+  inline isl::union_pw_aff_list list() const;
+  inline isl::multi_union_pw_aff neg() const;
+  inline bool plain_is_empty() const;
+  inline bool 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;
+  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 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 unsigned 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_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 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 isl::union_pw_aff_list add(isl::union_pw_aff el) const;
+  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 void foreach(const std::function<void(isl::union_pw_aff)> &fn) const;
+  inline isl::union_pw_aff_list insert(unsigned int pos, isl::union_pw_aff el) const;
+  inline unsigned 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::multi_aff ma);
+  inline /* implicit */ union_pw_multi_aff(isl::pw_multi_aff pma);
+  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 isl::union_pw_multi_aff add(isl::union_pw_multi_aff upma2) 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::union_set domain() const;
+  static inline isl::union_pw_multi_aff empty(isl::ctx ctx);
+  inline isl::pw_multi_aff extract_pw_multi_aff(isl::space space) const;
+  inline isl::union_pw_multi_aff flat_range_product(isl::union_pw_multi_aff upma2) const;
+  inline isl::union_pw_multi_aff gist(isl::union_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 bool involves_locals() const;
+  inline bool isa_pw_multi_aff() const;
+  inline bool plain_is_empty() 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::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::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_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 isl::union_set affine_hull() 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 compute_divs() const;
+  inline isl::union_set detect_equalities() const;
+  static inline isl::union_set empty(isl::ctx ctx);
+  inline bool every_set(const std::function<bool(isl::set)> &test) const;
+  inline isl::set extract_set(isl::space space) const;
+  inline void foreach_point(const std::function<void(isl::point)> &fn) const;
+  inline void foreach_set(const std::function<void(isl::set)> &fn) const;
+  inline isl::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_set intersect(isl::union_set uset2) const;
+  inline isl::union_set intersect_params(isl::set set) const;
+  inline bool is_disjoint(const isl::union_set &uset2) const;
+  inline bool is_empty() const;
+  inline bool is_equal(const isl::union_set &uset2) const;
+  inline bool is_strict_subset(const isl::union_set &uset2) const;
+  inline bool is_subset(const isl::union_set &uset2) const;
+  inline bool isa_set() const;
+  inline isl::union_set lexmax() const;
+  inline isl::union_set lexmin() 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::point sample_point() 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;
+};
+
+// 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 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 isl::union_set_list add(isl::union_set el) const;
+  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 void foreach(const std::function<void(isl::union_set)> &fn) const;
+  inline isl::union_set_list insert(unsigned int pos, isl::union_set el) const;
+  inline unsigned 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 isl::val abs() const;
+  inline bool abs_eq(const isl::val &v2) const;
+  inline bool abs_eq(long v2) const;
+  inline isl::val add(isl::val 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(long v2) const;
+  inline bool eq(const isl::val &v2) const;
+  inline bool 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 bool ge(const isl::val &v2) const;
+  inline bool ge(long v2) const;
+  inline bool gt(const isl::val &v2) const;
+  inline bool gt(long v2) const;
+  static inline isl::val infty(isl::ctx ctx);
+  inline isl::val inv() const;
+  inline bool is_divisible_by(const isl::val &v2) const;
+  inline bool is_divisible_by(long v2) const;
+  inline bool is_infty() const;
+  inline bool is_int() const;
+  inline bool is_nan() const;
+  inline bool is_neg() const;
+  inline bool is_neginfty() const;
+  inline bool is_negone() const;
+  inline bool is_nonneg() const;
+  inline bool is_nonpos() const;
+  inline bool is_one() const;
+  inline bool is_pos() const;
+  inline bool is_rat() const;
+  inline bool is_zero() const;
+  inline bool le(const isl::val &v2) const;
+  inline bool le(long v2) const;
+  inline bool lt(const isl::val &v2) const;
+  inline bool 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(long v2) const;
+  static inline isl::val nan(isl::ctx ctx);
+  inline bool ne(const isl::val &v2) const;
+  inline bool 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 int sgn() const;
+  inline isl::val sub(isl::val v2) const;
+  inline isl::val sub(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 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 isl::val_list add(isl::val el) const;
+  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 void foreach(const std::function<void(isl::val)> &fn) const;
+  inline isl::val_list insert(unsigned int pos, isl::val el) const;
+  inline isl::val_list insert(unsigned int pos, long el) const;
+  inline unsigned size() const;
+};
+
+// implementations for isl::aff
+aff manage(__isl_take isl_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return aff(ptr);
+}
+aff manage_copy(__isl_keep isl_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return aff(ptr);
+}
+
+aff::aff()
+    : ptr(nullptr) {}
+
+aff::aff(const aff &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+aff::aff(__isl_take isl_aff *ptr)
+    : ptr(ptr) {}
+
+aff::aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+aff &aff::operator=(aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+aff::~aff() {
+  if (ptr)
+    isl_aff_free(ptr);
+}
+
+__isl_give isl_aff *aff::copy() const & {
+  return isl_aff_copy(ptr);
+}
+
+__isl_keep isl_aff *aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_aff *aff::release() {
+  isl_aff *tmp = ptr;
+  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));
+}
+
+isl::aff aff::add(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_add(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff aff::add(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).add(multi2);
+}
+
+isl::multi_pw_aff aff::add(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(multi2);
+}
+
+isl::multi_union_pw_aff aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(multi2);
+}
+
+isl::pw_aff aff::add(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(pwaff2);
+}
+
+isl::pw_multi_aff aff::add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(pma2);
+}
+
+isl::union_pw_aff aff::add(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(upa2);
+}
+
+isl::union_pw_multi_aff aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).add(upma2);
+}
+
+isl::aff aff::add_constant(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_add_constant_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff::add_constant(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::multi_aff aff::add_constant(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).add_constant(mv);
+}
+
+isl::union_pw_multi_aff aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).apply(upma2);
+}
+
+isl::aff aff::as_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_aff();
+}
+
+isl::map aff::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_map();
+}
+
+isl::multi_aff aff::as_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_multi_aff();
+}
+
+isl::multi_union_pw_aff aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_pw_multi_aff();
+}
+
+isl::set aff::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).as_set();
+}
+
+isl::union_map aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).as_union_map();
+}
+
+isl::aff aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).at(pos);
+}
+
+isl::basic_set aff::bind(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_bind_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_set aff::bind(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->bind(isl::id(ctx(), id));
+}
+
+isl::basic_set aff::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).bind(tuple);
+}
+
+isl::pw_aff aff::bind_domain(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).bind_domain(tuple);
+}
+
+isl::pw_aff aff::bind_domain_wrapped_domain(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).bind_domain_wrapped_domain(tuple);
+}
+
+isl::aff aff::ceil() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_ceil(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).coalesce();
+}
+
+isl::pw_aff aff::cond(const isl::pw_aff &pwaff_true, const isl::pw_aff &pwaff_false) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).cond(pwaff_true, pwaff_false);
+}
+
+isl::multi_val aff::constant_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).constant_multi_val();
+}
+
+isl::val aff::constant_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_get_constant_val(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val aff::get_constant_val() const
+{
+  return constant_val();
+}
+
+isl::aff aff::div(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_div(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff aff::div(const isl::pw_aff &pa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).div(pa2);
+}
+
+isl::set aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).domain();
+}
+
+isl::set aff::eq_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_eq_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::eq_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).eq_set(pwaff2);
+}
+
+isl::val aff::eval(isl::point pnt) const
+{
+  if (!ptr || pnt.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_eval(copy(), pnt.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::multi_aff aff::flat_range_product(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_pw_aff aff::flat_range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::pw_multi_aff aff::flat_range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).flat_range_product(upma2);
+}
+
+isl::aff aff::floor() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_floor(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void aff::foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).foreach_piece(fn);
+}
+
+isl::set aff::ge_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_ge_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::ge_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).ge_set(pwaff2);
+}
+
+isl::aff aff::gist(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff aff::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).gist(context);
+}
+
+isl::aff aff::gist(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::aff aff::gist(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::set aff::gt_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_gt_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::gt_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).gt_set(pwaff2);
+}
+
+bool aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).has_range_tuple_id();
+}
+
+isl::multi_aff aff::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).identity();
+}
+
+isl::pw_aff aff::insert_domain(const isl::space &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).insert_domain(domain);
+}
+
+isl::pw_aff aff::intersect_domain(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_domain(set);
+}
+
+isl::union_pw_aff aff::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_domain(space);
+}
+
+isl::union_pw_aff aff::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_domain(uset);
+}
+
+isl::union_pw_aff aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::union_pw_aff aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::pw_aff aff::intersect_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).intersect_params(set);
+}
+
+bool aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).involves_locals();
+}
+
+bool aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).involves_nan();
+}
+
+bool aff::involves_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).involves_param(id);
+}
+
+bool aff::involves_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+bool aff::involves_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).involves_param(list);
+}
+
+bool aff::is_cst() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_is_cst(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool aff::isa_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).isa_aff();
+}
+
+bool aff::isa_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).isa_multi_aff();
+}
+
+bool aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).isa_pw_multi_aff();
+}
+
+isl::set aff::le_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_le_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::le_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).le_set(pwaff2);
+}
+
+isl::aff_list aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).list();
+}
+
+isl::set aff::lt_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_lt_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::lt_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).lt_set(pwaff2);
+}
+
+isl::multi_pw_aff aff::max(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).max(multi2);
+}
+
+isl::pw_aff aff::max(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).max(pwaff2);
+}
+
+isl::multi_val aff::max_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).max_multi_val();
+}
+
+isl::multi_pw_aff aff::min(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).min(multi2);
+}
+
+isl::pw_aff aff::min(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).min(pwaff2);
+}
+
+isl::multi_val aff::min_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).min_multi_val();
+}
+
+isl::aff aff::mod(isl::val mod) const
+{
+  if (!ptr || mod.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_mod_val(copy(), mod.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff::mod(long mod) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->mod(isl::val(ctx(), mod));
+}
+
+isl::aff aff::mul(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_mul(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff aff::mul(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).mul(pwaff2);
+}
+
+unsigned aff::n_piece() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).n_piece();
+}
+
+isl::set aff::ne_set(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_ne_set(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set aff::ne_set(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).ne_set(pwaff2);
+}
+
+isl::aff aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).plain_is_empty();
+}
+
+bool aff::plain_is_equal(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).plain_is_equal(multi2);
+}
+
+bool aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).plain_is_equal(multi2);
+}
+
+bool aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::pw_multi_aff aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::multi_aff aff::product(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).product(multi2);
+}
+
+isl::multi_pw_aff aff::product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).product(multi2);
+}
+
+isl::pw_multi_aff aff::product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).product(pma2);
+}
+
+isl::aff aff::pullback(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_pullback_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff aff::pullback(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).pullback(mpa);
+}
+
+isl::pw_aff aff::pullback(const isl::pw_multi_aff &pma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).pullback(pma);
+}
+
+isl::union_pw_aff aff::pullback(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).pullback(upma);
+}
+
+isl::aff aff::pullback(const isl::aff &ma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->pullback(isl::multi_aff(ma));
+}
+
+isl::pw_multi_aff aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_factor_domain();
+}
+
+isl::pw_multi_aff aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_factor_range();
+}
+
+isl::multi_aff aff::range_product(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).range_product(multi2);
+}
+
+isl::multi_pw_aff aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_product(multi2);
+}
+
+isl::multi_union_pw_aff aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_product(multi2);
+}
+
+isl::pw_multi_aff aff::range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_product(pma2);
+}
+
+isl::union_pw_multi_aff aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).range_product(upma2);
+}
+
+isl::id aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).range_tuple_id();
+}
+
+isl::multi_aff aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).reset_range_tuple_id();
+}
+
+isl::aff aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_aff aff::scale(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).scale(mv);
+}
+
+isl::aff aff::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_aff aff::scale_down(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).scale_down(mv);
+}
+
+isl::multi_aff aff::set_at(int pos, const isl::aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).set_at(pos, el);
+}
+
+isl::multi_pw_aff aff::set_at(int pos, const isl::pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).set_at(pos, el);
+}
+
+isl::multi_aff aff::set_range_tuple(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).set_range_tuple(id);
+}
+
+isl::multi_aff aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).size();
+}
+
+isl::space aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).space();
+}
+
+isl::aff aff::sub(isl::aff aff2) const
+{
+  if (!ptr || aff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_sub(copy(), aff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff aff::sub(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).sub(multi2);
+}
+
+isl::multi_pw_aff aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(multi2);
+}
+
+isl::multi_union_pw_aff aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(multi2);
+}
+
+isl::pw_aff aff::sub(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(pwaff2);
+}
+
+isl::pw_multi_aff aff::sub(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(pma2);
+}
+
+isl::union_pw_aff aff::sub(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(upa2);
+}
+
+isl::union_pw_multi_aff aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).sub(upma2);
+}
+
+isl::pw_aff aff::subtract_domain(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).subtract_domain(set);
+}
+
+isl::union_pw_aff aff::subtract_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).subtract_domain(space);
+}
+
+isl::union_pw_aff aff::subtract_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).subtract_domain(uset);
+}
+
+isl::pw_aff aff::tdiv_q(const isl::pw_aff &pa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).tdiv_q(pa2);
+}
+
+isl::pw_aff aff::tdiv_r(const isl::pw_aff &pa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).tdiv_r(pa2);
+}
+
+isl::aff_list aff::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff aff::to_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).to_multi_pw_aff();
+}
+
+isl::multi_union_pw_aff aff::to_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).to_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff aff::to_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_aff(*this).to_pw_multi_aff();
+}
+
+isl::union_pw_aff aff::to_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).to_union_pw_aff();
+}
+
+isl::union_pw_multi_aff aff::to_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::aff aff::unbind_params_insert_domain(isl::multi_id domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_unbind_params_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff aff::union_add(const isl::multi_pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(mpa2);
+}
+
+isl::multi_union_pw_aff aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(mupa2);
+}
+
+isl::pw_aff aff::union_add(const isl::pw_aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(pwaff2);
+}
+
+isl::pw_multi_aff aff::union_add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(pma2);
+}
+
+isl::union_pw_aff aff::union_add(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(upa2);
+}
+
+isl::union_pw_multi_aff aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_aff(*this).union_add(upma2);
+}
+
+isl::aff aff::zero_on_domain(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_zero_on_domain_space(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::aff_list
+aff_list manage(__isl_take isl_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return aff_list(ptr);
+}
+aff_list manage_copy(__isl_keep isl_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_aff_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return aff_list(ptr);
+}
+
+aff_list::aff_list()
+    : ptr(nullptr) {}
+
+aff_list::aff_list(const aff_list &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+aff_list::aff_list(__isl_take isl_aff_list *ptr)
+    : ptr(ptr) {}
+
+aff_list::aff_list(isl::ctx ctx, int n)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+aff_list::aff_list(isl::aff el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_from_aff(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_aff_list_free(ptr);
+}
+
+__isl_give isl_aff_list *aff_list::copy() const & {
+  return isl_aff_list_copy(ptr);
+}
+
+__isl_keep isl_aff_list *aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_aff_list *aff_list::release() {
+  isl_aff_list *tmp = ptr;
+  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));
+}
+
+isl::aff_list aff_list::add(isl::aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::aff_list aff_list::clear() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff_list aff_list::concat(isl::aff_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff_list aff_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void aff_list::foreach(const std::function<void(isl::aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::aff)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_aff *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_aff_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::aff_list aff_list::insert(unsigned int pos, isl::aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned aff_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_aff_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const aff_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_aff_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_aff_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_build
+ast_build manage(__isl_take isl_ast_build *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return ast_build(ptr);
+}
+ast_build manage_copy(__isl_keep isl_ast_build *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_build_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_ast_build_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return ast_build(ptr);
+}
+
+ast_build::ast_build()
+    : ptr(nullptr) {}
+
+ast_build::ast_build(const ast_build &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_build_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  copy_callbacks(obj);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+ast_build::ast_build(__isl_take isl_ast_build *ptr)
+    : ptr(ptr) {}
+
+ast_build::ast_build(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_alloc(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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)
+    exception::throw_invalid("cannot release object with persistent callbacks", __FILE__, __LINE__);
+  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);
+  ISL_CPP_TRY {
+    auto ret = (data->func)(manage(arg_0), manage_copy(arg_1));
+    return ret.release();
+  } ISL_CPP_CATCH_ALL {
+    data->eptr = std::current_exception();
+    return NULL;
+  }
+}
+
+void ast_build::set_at_each_domain_data(const std::function<isl::ast_node(isl::ast_node, isl::ast_build)> &fn)
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_build_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  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());
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_access_from_multi_pw_aff(get(), mpa.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_build::access_from(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_access_from_pw_multi_aff(get(), pma.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_build::call_from(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_call_from_multi_pw_aff(get(), mpa.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_build::call_from(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_call_from_pw_multi_aff(get(), pma.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_build::expr_from(isl::pw_aff pa) const
+{
+  if (!ptr || pa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_expr_from_pw_aff(get(), pa.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_build::expr_from(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_expr_from_set(get(), set.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_build ast_build::from_context(isl::set set)
+{
+  if (set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = set.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_from_context(set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_build::node_from(isl::schedule schedule) const
+{
+  if (!ptr || schedule.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_node_from_schedule(get(), schedule.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_build::node_from_schedule_map(isl::union_map schedule) const
+{
+  if (!ptr || schedule.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_node_from_schedule_map(get(), schedule.release());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map ast_build::schedule() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_build_get_schedule(get());
+  if (at_each_domain_data && at_each_domain_data->eptr) {
+    std::exception_ptr eptr = at_each_domain_data->eptr;
+    at_each_domain_data->eptr = nullptr;
+    std::rethrow_exception(eptr);
+  }
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return ast_expr(ptr);
+}
+ast_expr manage_copy(__isl_keep isl_ast_expr *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_ast_expr_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return ast_expr(ptr);
+}
+
+ast_expr::ast_expr()
+    : ptr(nullptr) {}
+
+ast_expr::ast_expr(const ast_expr &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::copy() const & {
+  return isl_ast_expr_copy(ptr);
+}
+
+__isl_keep isl_ast_expr *ast_expr::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_expr *ast_expr::release() {
+  isl_ast_expr *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool ast_expr::is_null() const {
+  return ptr == nullptr;
+}
+
+template <typename T, typename>
+bool ast_expr::isa_type(T subtype) const
+{
+  if (is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl_ast_expr_get_type(get()) == subtype;
+}
+template <class T>
+bool ast_expr::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T ast_expr::as() const
+{
+ if (!isa<T>())
+    exception::throw_invalid("not an object of the requested subtype", __FILE__, __LINE__);
+  return T(copy());
+}
+
+isl::ctx ast_expr::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+std::string ast_expr::to_C_str() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_expr_to_C_str(get());
+  std::string tmp(res);
+  free(res);
+  return tmp;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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::id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_expr_id_get_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id ast_expr_id::get_id() const
+{
+  return id();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_id &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_expr_int_get_val(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val ast_expr_int::get_val() const
+{
+  return val();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_int &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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>
+bool ast_expr_op::isa_type(T subtype) const
+{
+  if (is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl_ast_expr_op_get_type(get()) == subtype;
+}
+template <class T>
+bool 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>())
+    exception::throw_invalid("not an object of the requested subtype", __FILE__, __LINE__);
+  return T(copy());
+}
+
+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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_expr_op_get_arg(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_expr_op::get_arg(int pos) const
+{
+  return arg(pos);
+}
+
+unsigned ast_expr_op::n_arg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_expr_op_get_n_arg(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+unsigned ast_expr_op::get_n_arg() const
+{
+  return n_arg();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_access
+ast_expr_op_access::ast_expr_op_access()
+    : ast_expr_op() {}
+
+ast_expr_op_access::ast_expr_op_access(const ast_expr_op_access &obj)
+    : ast_expr_op(obj)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_address_of
+ast_expr_op_address_of::ast_expr_op_address_of()
+    : ast_expr_op() {}
+
+ast_expr_op_address_of::ast_expr_op_address_of(const ast_expr_op_address_of &obj)
+    : ast_expr_op(obj)
+{
+}
+
+ast_expr_op_address_of::ast_expr_op_address_of(__isl_take isl_ast_expr *ptr)
+    : ast_expr_op(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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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_op_and &ast_expr_op_and::operator=(ast_expr_op_and obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+isl::ctx ast_expr_op_and::ctx() const {
+  return isl::ctx(isl_ast_expr_get_ctx(ptr));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_and &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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;
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_expr_op_call
+ast_expr_op_call::ast_expr_op_call()
+    : ast_expr_op() {}
+
+ast_expr_op_call::ast_expr_op_call(const ast_expr_op_call &obj)
+    : ast_expr_op(obj)
+{
+}
+
+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));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_expr_op_call &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_expr_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_expr_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_node
+ast_node manage(__isl_take isl_ast_node *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return ast_node(ptr);
+}
+ast_node manage_copy(__isl_keep isl_ast_node *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_ast_node_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return ast_node(ptr);
+}
+
+ast_node::ast_node()
+    : ptr(nullptr) {}
+
+ast_node::ast_node(const ast_node &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::copy() const & {
+  return isl_ast_node_copy(ptr);
+}
+
+__isl_keep isl_ast_node *ast_node::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_node *ast_node::release() {
+  isl_ast_node *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool ast_node::is_null() const {
+  return ptr == nullptr;
+}
+
+template <typename T, typename>
+bool ast_node::isa_type(T subtype) const
+{
+  if (is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl_ast_node_get_type(get()) == subtype;
+}
+template <class T>
+bool ast_node::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T ast_node::as() const
+{
+ if (!isa<T>())
+    exception::throw_invalid("not an object of the requested subtype", __FILE__, __LINE__);
+  return T(copy());
+}
+
+isl::ctx ast_node::ctx() const {
+  return isl::ctx(isl_ast_node_get_ctx(ptr));
+}
+
+std::string ast_node::to_C_str() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_to_C_str(get());
+  std::string tmp(res);
+  free(res);
+  return tmp;
+}
+
+isl::ast_node_list ast_node::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_block_get_children(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node_list ast_node_block::get_children() const
+{
+  return children();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_block &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_get_body(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_node_for::get_body() const
+{
+  return body();
+}
+
+isl::ast_expr ast_node_for::cond() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_get_cond(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_node_for::get_cond() const
+{
+  return cond();
+}
+
+isl::ast_expr ast_node_for::inc() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_get_inc(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_node_for::get_inc() const
+{
+  return inc();
+}
+
+isl::ast_expr ast_node_for::init() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_get_init(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_node_for::get_init() const
+{
+  return init();
+}
+
+bool ast_node_for::is_degenerate() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_is_degenerate(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::ast_expr ast_node_for::iterator() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_for_get_iterator(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_node_for::get_iterator() const
+{
+  return iterator();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_for &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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_expr ast_node_if::cond() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_if_get_cond(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_expr ast_node_if::get_cond() const
+{
+  return cond();
+}
+
+isl::ast_node ast_node_if::else_node() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_if_get_else_node(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_node_if::get_else_node() const
+{
+  return else_node();
+}
+
+bool ast_node_if::has_else_node() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_if_has_else_node(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::ast_node ast_node_if::then_node() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_if_get_then_node(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_node_if::get_then_node() const
+{
+  return then_node();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_if &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::ast_node_list
+ast_node_list manage(__isl_take isl_ast_node_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return ast_node_list(ptr);
+}
+ast_node_list manage_copy(__isl_keep isl_ast_node_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_ast_node_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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 saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+ast_node_list::ast_node_list(isl::ast_node el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_from_ast_node(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_ast_node_list_free(ptr);
+}
+
+__isl_give isl_ast_node_list *ast_node_list::copy() const & {
+  return isl_ast_node_list_copy(ptr);
+}
+
+__isl_keep isl_ast_node_list *ast_node_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_ast_node_list *ast_node_list::release() {
+  isl_ast_node_list *tmp = ptr;
+  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));
+}
+
+isl::ast_node_list ast_node_list::add(isl::ast_node el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_node_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node_list ast_node_list::concat(isl::ast_node_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node_list ast_node_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void ast_node_list::foreach(const std::function<void(isl::ast_node)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::ast_node)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_ast_node_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::ast_node_list ast_node_list::insert(unsigned int pos, isl::ast_node el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned ast_node_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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)
+{
+}
+
+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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_mark_get_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id ast_node_mark::get_id() const
+{
+  return id();
+}
+
+isl::ast_node ast_node_mark::node() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_mark_get_node(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::ast_node ast_node_mark::get_node() const
+{
+  return node();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const ast_node_mark &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// 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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_ast_node_user_get_expr(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_ast_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_ast_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::basic_map
+basic_map manage(__isl_take isl_basic_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return basic_map(ptr);
+}
+basic_map manage_copy(__isl_keep isl_basic_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_map_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_basic_map_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return basic_map(ptr);
+}
+
+basic_map::basic_map()
+    : ptr(nullptr) {}
+
+basic_map::basic_map(const basic_map &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_map_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+basic_map::basic_map(__isl_take isl_basic_map *ptr)
+    : ptr(ptr) {}
+
+basic_map::basic_map(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+basic_map &basic_map::operator=(basic_map obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+basic_map::~basic_map() {
+  if (ptr)
+    isl_basic_map_free(ptr);
+}
+
+__isl_give isl_basic_map *basic_map::copy() const & {
+  return isl_basic_map_copy(ptr);
+}
+
+__isl_keep isl_basic_map *basic_map::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_map *basic_map::release() {
+  isl_basic_map *tmp = ptr;
+  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));
+}
+
+isl::basic_map basic_map::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map basic_map::apply_domain(isl::basic_map bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_apply_domain(copy(), bmap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::apply_domain(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).apply_domain(map2);
+}
+
+isl::union_map basic_map::apply_domain(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).apply_domain(umap2);
+}
+
+isl::basic_map basic_map::apply_range(isl::basic_map bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_apply_range(copy(), bmap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::apply_range(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).apply_range(map2);
+}
+
+isl::union_map basic_map::apply_range(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).apply_range(umap2);
+}
+
+isl::map basic_map::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).as_map();
+}
+
+isl::multi_union_pw_aff basic_map::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff basic_map::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).as_pw_multi_aff();
+}
+
+isl::union_pw_multi_aff basic_map::as_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).as_union_pw_multi_aff();
+}
+
+isl::set basic_map::bind_domain(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).bind_domain(tuple);
+}
+
+isl::set basic_map::bind_range(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).bind_range(tuple);
+}
+
+isl::map basic_map::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).coalesce();
+}
+
+isl::map basic_map::complement() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).complement();
+}
+
+isl::union_map basic_map::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).compute_divs();
+}
+
+isl::map basic_map::curry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).curry();
+}
+
+isl::basic_set basic_map::deltas() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_deltas(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map basic_map::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_map::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain();
+}
+
+isl::map basic_map::domain_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_factor_domain();
+}
+
+isl::map basic_map::domain_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_factor_range();
+}
+
+isl::union_map basic_map::domain_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_map();
+}
+
+isl::union_pw_multi_aff basic_map::domain_map_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_map_union_pw_multi_aff();
+}
+
+isl::map basic_map::domain_product(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_product(map2);
+}
+
+isl::union_map basic_map::domain_product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_product(umap2);
+}
+
+isl::id basic_map::domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).domain_tuple_id();
+}
+
+isl::map basic_map::eq_at(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).eq_at(mpa);
+}
+
+isl::union_map basic_map::eq_at(const isl::multi_union_pw_aff &mupa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).eq_at(mupa);
+}
+
+bool basic_map::every_map(const std::function<bool(isl::map)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).every_map(test);
+}
+
+isl::map basic_map::extract_map(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).extract_map(space);
+}
+
+isl::map basic_map::factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).factor_domain();
+}
+
+isl::map basic_map::factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).factor_range();
+}
+
+isl::union_map basic_map::fixed_power(const isl::val &exp) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).fixed_power(exp);
+}
+
+isl::union_map basic_map::fixed_power(long exp) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->fixed_power(isl::val(ctx(), exp));
+}
+
+isl::basic_map basic_map::flatten() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_flatten(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map basic_map::flatten_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_flatten_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map basic_map::flatten_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_flatten_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void basic_map::foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).foreach_basic_map(fn);
+}
+
+void basic_map::foreach_map(const std::function<void(isl::map)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).foreach_map(fn);
+}
+
+isl::basic_map basic_map::gist(isl::basic_map context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::gist(const isl::map &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist(context);
+}
+
+isl::union_map basic_map::gist(const isl::union_map &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist(context);
+}
+
+isl::map basic_map::gist_domain(const isl::set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist_domain(context);
+}
+
+isl::union_map basic_map::gist_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist_domain(uset);
+}
+
+isl::union_map basic_map::gist_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist_params(set);
+}
+
+isl::union_map basic_map::gist_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).gist_range(uset);
+}
+
+bool basic_map::has_domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).has_domain_tuple_id();
+}
+
+bool basic_map::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).has_range_tuple_id();
+}
+
+isl::basic_map basic_map::intersect(isl::basic_map bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_intersect(copy(), bmap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::intersect(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect(map2);
+}
+
+isl::union_map basic_map::intersect(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect(umap2);
+}
+
+isl::basic_map basic_map::intersect_domain(isl::basic_set bset) const
+{
+  if (!ptr || bset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_intersect_domain(copy(), bset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::intersect_domain(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain(set);
+}
+
+isl::union_map basic_map::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain(space);
+}
+
+isl::union_map basic_map::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain(uset);
+}
+
+isl::basic_map basic_map::intersect_domain(const isl::point &bset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::basic_set(bset));
+}
+
+isl::map basic_map::intersect_domain_factor_domain(const isl::map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::union_map basic_map::intersect_domain_factor_domain(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::map basic_map::intersect_domain_factor_range(const isl::map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::union_map basic_map::intersect_domain_factor_range(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::map basic_map::intersect_params(const isl::set &params) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_params(params);
+}
+
+isl::basic_map basic_map::intersect_range(isl::basic_set bset) const
+{
+  if (!ptr || bset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_intersect_range(copy(), bset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::intersect_range(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range(set);
+}
+
+isl::union_map basic_map::intersect_range(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range(space);
+}
+
+isl::union_map basic_map::intersect_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range(uset);
+}
+
+isl::basic_map basic_map::intersect_range(const isl::point &bset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_range(isl::basic_set(bset));
+}
+
+isl::map basic_map::intersect_range_factor_domain(const isl::map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::union_map basic_map::intersect_range_factor_domain(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::map basic_map::intersect_range_factor_range(const isl::map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range_factor_range(factor);
+}
+
+isl::union_map basic_map::intersect_range_factor_range(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).intersect_range_factor_range(factor);
+}
+
+bool basic_map::is_bijective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_bijective();
+}
+
+bool basic_map::is_disjoint(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_disjoint(map2);
+}
+
+bool basic_map::is_disjoint(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_disjoint(umap2);
+}
+
+bool basic_map::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_map::is_equal(const isl::basic_map &bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_is_equal(get(), bmap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_map::is_equal(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_equal(map2);
+}
+
+bool basic_map::is_equal(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_equal(umap2);
+}
+
+bool basic_map::is_injective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_injective();
+}
+
+bool basic_map::is_single_valued() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_single_valued();
+}
+
+bool basic_map::is_strict_subset(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_strict_subset(map2);
+}
+
+bool basic_map::is_strict_subset(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_strict_subset(umap2);
+}
+
+bool basic_map::is_subset(const isl::basic_map &bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_is_subset(get(), bmap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_map::is_subset(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_subset(map2);
+}
+
+bool basic_map::is_subset(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).is_subset(umap2);
+}
+
+bool basic_map::isa_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).isa_map();
+}
+
+isl::map basic_map::lex_ge_at(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lex_ge_at(mpa);
+}
+
+isl::map basic_map::lex_gt_at(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lex_gt_at(mpa);
+}
+
+isl::map basic_map::lex_le_at(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lex_le_at(mpa);
+}
+
+isl::map basic_map::lex_lt_at(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lex_lt_at(mpa);
+}
+
+isl::map basic_map::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff basic_map::lexmax_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lexmax_pw_multi_aff();
+}
+
+isl::map basic_map::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff basic_map::lexmin_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lexmin_pw_multi_aff();
+}
+
+isl::map basic_map::lower_bound(const isl::multi_pw_aff &lower) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).lower_bound(lower);
+}
+
+isl::multi_pw_aff basic_map::max_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).max_multi_pw_aff();
+}
+
+isl::multi_pw_aff basic_map::min_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).min_multi_pw_aff();
+}
+
+isl::basic_map basic_map::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).polyhedral_hull();
+}
+
+isl::map basic_map::preimage_domain(const isl::multi_aff &ma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_domain(ma);
+}
+
+isl::map basic_map::preimage_domain(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_domain(mpa);
+}
+
+isl::map basic_map::preimage_domain(const isl::pw_multi_aff &pma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_domain(pma);
+}
+
+isl::union_map basic_map::preimage_domain(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_domain(upma);
+}
+
+isl::map basic_map::preimage_range(const isl::multi_aff &ma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_range(ma);
+}
+
+isl::map basic_map::preimage_range(const isl::pw_multi_aff &pma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_range(pma);
+}
+
+isl::union_map basic_map::preimage_range(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).preimage_range(upma);
+}
+
+isl::map basic_map::product(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).product(map2);
+}
+
+isl::union_map basic_map::product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).product(umap2);
+}
+
+isl::map basic_map::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).project_out_all_params();
+}
+
+isl::set basic_map::range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range();
+}
+
+isl::map basic_map::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_factor_domain();
+}
+
+isl::map basic_map::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_factor_range();
+}
+
+isl::union_map basic_map::range_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_map();
+}
+
+isl::map basic_map::range_product(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_product(map2);
+}
+
+isl::union_map basic_map::range_product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_product(umap2);
+}
+
+isl::map basic_map::range_reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_reverse();
+}
+
+isl::fixed_box basic_map::range_simple_fixed_box_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_simple_fixed_box_hull();
+}
+
+isl::id basic_map::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).range_tuple_id();
+}
+
+isl::basic_map basic_map::reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map basic_map::sample() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_sample(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::set_domain_tuple(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).set_domain_tuple(id);
+}
+
+isl::map basic_map::set_domain_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_domain_tuple(isl::id(ctx(), id));
+}
+
+isl::map basic_map::set_range_tuple(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).set_range_tuple(id);
+}
+
+isl::map basic_map::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::space basic_map::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).space();
+}
+
+isl::map basic_map::subtract(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).subtract(map2);
+}
+
+isl::union_map basic_map::subtract(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).subtract(umap2);
+}
+
+isl::union_map basic_map::subtract_domain(const isl::union_set &dom) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).subtract_domain(dom);
+}
+
+isl::union_map basic_map::subtract_range(const isl::union_set &dom) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).subtract_range(dom);
+}
+
+isl::union_map basic_map::to_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).to_union_map();
+}
+
+isl::map basic_map::uncurry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).uncurry();
+}
+
+isl::map basic_map::unite(isl::basic_map bmap2) const
+{
+  if (!ptr || bmap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_map_union(copy(), bmap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map basic_map::unite(const isl::map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).unite(map2);
+}
+
+isl::union_map basic_map::unite(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).unite(umap2);
+}
+
+isl::basic_map basic_map::unshifted_simple_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).unshifted_simple_hull();
+}
+
+isl::map basic_map::upper_bound(const isl::multi_pw_aff &upper) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).upper_bound(upper);
+}
+
+isl::set basic_map::wrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).wrap();
+}
+
+isl::map basic_map::zip() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::map(*this).zip();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const basic_map &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_map_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_basic_map_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::basic_set
+basic_set manage(__isl_take isl_basic_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return basic_set(ptr);
+}
+basic_set manage_copy(__isl_keep isl_basic_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_set_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_basic_set_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return basic_set(ptr);
+}
+
+basic_set::basic_set()
+    : ptr(nullptr) {}
+
+basic_set::basic_set(const basic_set &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_set_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+basic_set::basic_set(__isl_take isl_basic_set *ptr)
+    : ptr(ptr) {}
+
+basic_set::basic_set(isl::point pnt)
+{
+  if (pnt.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pnt.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_from_point(pnt.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+basic_set::basic_set(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+basic_set &basic_set::operator=(basic_set obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+basic_set::~basic_set() {
+  if (ptr)
+    isl_basic_set_free(ptr);
+}
+
+__isl_give isl_basic_set *basic_set::copy() const & {
+  return isl_basic_set_copy(ptr);
+}
+
+__isl_keep isl_basic_set *basic_set::get() const {
+  return ptr;
+}
+
+__isl_give isl_basic_set *basic_set::release() {
+  isl_basic_set *tmp = ptr;
+  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));
+}
+
+isl::basic_set basic_set::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_set basic_set::apply(isl::basic_map bmap) const
+{
+  if (!ptr || bmap.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_apply(copy(), bmap.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_set::apply(const isl::map &map) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).apply(map);
+}
+
+isl::union_set basic_set::apply(const isl::union_map &umap) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).apply(umap);
+}
+
+isl::pw_multi_aff basic_set::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).as_pw_multi_aff();
+}
+
+isl::set basic_set::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).as_set();
+}
+
+isl::set basic_set::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).bind(tuple);
+}
+
+isl::set basic_set::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).coalesce();
+}
+
+isl::set basic_set::complement() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).complement();
+}
+
+isl::union_set basic_set::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).compute_divs();
+}
+
+isl::basic_set basic_set::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val basic_set::dim_max_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_dim_max_val(copy(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val basic_set::dim_min_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).dim_min_val(pos);
+}
+
+bool basic_set::every_set(const std::function<bool(isl::set)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).every_set(test);
+}
+
+isl::set basic_set::extract_set(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).extract_set(space);
+}
+
+isl::basic_set basic_set::flatten() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_flatten(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void basic_set::foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).foreach_basic_set(fn);
+}
+
+void basic_set::foreach_point(const std::function<void(isl::point)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).foreach_point(fn);
+}
+
+void basic_set::foreach_set(const std::function<void(isl::set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).foreach_set(fn);
+}
+
+isl::basic_set basic_set::gist(isl::basic_set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_set::gist(const isl::set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).gist(context);
+}
+
+isl::union_set basic_set::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).gist(context);
+}
+
+isl::basic_set basic_set::gist(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::basic_set(context));
+}
+
+isl::union_set basic_set::gist_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).gist_params(set);
+}
+
+isl::map basic_set::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).identity();
+}
+
+isl::pw_aff basic_set::indicator_function() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).indicator_function();
+}
+
+isl::map basic_set::insert_domain(const isl::space &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).insert_domain(domain);
+}
+
+isl::basic_set basic_set::intersect(isl::basic_set bset2) const
+{
+  if (!ptr || bset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_intersect(copy(), bset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_set::intersect(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).intersect(set2);
+}
+
+isl::union_set basic_set::intersect(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).intersect(uset2);
+}
+
+isl::basic_set basic_set::intersect(const isl::point &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect(isl::basic_set(bset2));
+}
+
+isl::basic_set basic_set::intersect_params(isl::basic_set bset2) const
+{
+  if (!ptr || bset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_intersect_params(copy(), bset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_set::intersect_params(const isl::set &params) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).intersect_params(params);
+}
+
+isl::basic_set basic_set::intersect_params(const isl::point &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_params(isl::basic_set(bset2));
+}
+
+bool basic_set::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).involves_locals();
+}
+
+bool basic_set::is_disjoint(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_disjoint(set2);
+}
+
+bool basic_set::is_disjoint(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_disjoint(uset2);
+}
+
+bool basic_set::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_set::is_equal(const isl::basic_set &bset2) const
+{
+  if (!ptr || bset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_is_equal(get(), bset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_set::is_equal(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_equal(set2);
+}
+
+bool basic_set::is_equal(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_equal(uset2);
+}
+
+bool basic_set::is_equal(const isl::point &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_equal(isl::basic_set(bset2));
+}
+
+bool basic_set::is_singleton() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_singleton();
+}
+
+bool basic_set::is_strict_subset(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_strict_subset(set2);
+}
+
+bool basic_set::is_strict_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_strict_subset(uset2);
+}
+
+bool basic_set::is_subset(const isl::basic_set &bset2) const
+{
+  if (!ptr || bset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_is_subset(get(), bset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_set::is_subset(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_subset(set2);
+}
+
+bool basic_set::is_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).is_subset(uset2);
+}
+
+bool basic_set::is_subset(const isl::point &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_subset(isl::basic_set(bset2));
+}
+
+bool basic_set::is_wrapping() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_is_wrapping(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool basic_set::isa_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).isa_set();
+}
+
+isl::set basic_set::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff basic_set::lexmax_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).lexmax_pw_multi_aff();
+}
+
+isl::set basic_set::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff basic_set::lexmin_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).lexmin_pw_multi_aff();
+}
+
+isl::set basic_set::lower_bound(const isl::multi_pw_aff &lower) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).lower_bound(lower);
+}
+
+isl::set basic_set::lower_bound(const isl::multi_val &lower) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).lower_bound(lower);
+}
+
+isl::multi_pw_aff basic_set::max_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).max_multi_pw_aff();
+}
+
+isl::val basic_set::max_val(const isl::aff &obj) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).max_val(obj);
+}
+
+isl::multi_pw_aff basic_set::min_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).min_multi_pw_aff();
+}
+
+isl::val basic_set::min_val(const isl::aff &obj) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).min_val(obj);
+}
+
+isl::basic_set basic_set::params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val basic_set::plain_multi_val_if_fixed() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).plain_multi_val_if_fixed();
+}
+
+isl::basic_set basic_set::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).polyhedral_hull();
+}
+
+isl::set basic_set::preimage(const isl::multi_aff &ma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).preimage(ma);
+}
+
+isl::set basic_set::preimage(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).preimage(mpa);
+}
+
+isl::set basic_set::preimage(const isl::pw_multi_aff &pma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).preimage(pma);
+}
+
+isl::union_set basic_set::preimage(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).preimage(upma);
+}
+
+isl::set basic_set::product(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).product(set2);
+}
+
+isl::set basic_set::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).project_out_all_params();
+}
+
+isl::set basic_set::project_out_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).project_out_param(id);
+}
+
+isl::set basic_set::project_out_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->project_out_param(isl::id(ctx(), id));
+}
+
+isl::set basic_set::project_out_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).project_out_param(list);
+}
+
+isl::pw_multi_aff basic_set::pw_multi_aff_on_domain(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).pw_multi_aff_on_domain(mv);
+}
+
+isl::basic_set basic_set::sample() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_sample(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::point basic_set::sample_point() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_sample_point(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::fixed_box basic_set::simple_fixed_box_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).simple_fixed_box_hull();
+}
+
+isl::space basic_set::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).space();
+}
+
+isl::val basic_set::stride(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).stride(pos);
+}
+
+isl::set basic_set::subtract(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).subtract(set2);
+}
+
+isl::union_set basic_set::subtract(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).subtract(uset2);
+}
+
+isl::union_set_list basic_set::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).to_list();
+}
+
+isl::set basic_set::to_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_to_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set basic_set::to_union_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).to_union_set();
+}
+
+isl::map basic_set::translation() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).translation();
+}
+
+isl::set basic_set::unbind_params(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unbind_params(tuple);
+}
+
+isl::map basic_set::unbind_params_insert_domain(const isl::multi_id &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unbind_params_insert_domain(domain);
+}
+
+isl::set basic_set::unite(isl::basic_set bset2) const
+{
+  if (!ptr || bset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_basic_set_union(copy(), bset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set basic_set::unite(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unite(set2);
+}
+
+isl::union_set basic_set::unite(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unite(uset2);
+}
+
+isl::set basic_set::unite(const isl::point &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->unite(isl::basic_set(bset2));
+}
+
+isl::basic_set basic_set::unshifted_simple_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unshifted_simple_hull();
+}
+
+isl::map basic_set::unwrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).unwrap();
+}
+
+isl::set basic_set::upper_bound(const isl::multi_pw_aff &upper) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).upper_bound(upper);
+}
+
+isl::set basic_set::upper_bound(const isl::multi_val &upper) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::set(*this).upper_bound(upper);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const basic_set &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_basic_set_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_basic_set_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::fixed_box
+fixed_box manage(__isl_take isl_fixed_box *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return fixed_box(ptr);
+}
+fixed_box manage_copy(__isl_keep isl_fixed_box *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_fixed_box_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_fixed_box_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return fixed_box(ptr);
+}
+
+fixed_box::fixed_box()
+    : ptr(nullptr) {}
+
+fixed_box::fixed_box(const fixed_box &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_fixed_box_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::copy() const & {
+  return isl_fixed_box_copy(ptr);
+}
+
+__isl_keep isl_fixed_box *fixed_box::get() const {
+  return ptr;
+}
+
+__isl_give isl_fixed_box *fixed_box::release() {
+  isl_fixed_box *tmp = ptr;
+  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));
+}
+
+bool fixed_box::is_valid() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_fixed_box_is_valid(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_aff fixed_box::offset() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_fixed_box_get_offset(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff fixed_box::get_offset() const
+{
+  return offset();
+}
+
+isl::multi_val fixed_box::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_fixed_box_get_size(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val fixed_box::get_size() const
+{
+  return size();
+}
+
+isl::space fixed_box::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_fixed_box_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space fixed_box::get_space() const
+{
+  return space();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const fixed_box &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_fixed_box_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_fixed_box_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::id
+id manage(__isl_take isl_id *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return id(ptr);
+}
+id manage_copy(__isl_keep isl_id *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_id_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return id(ptr);
+}
+
+id::id()
+    : ptr(nullptr) {}
+
+id::id(const id &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+id::id(__isl_take isl_id *ptr)
+    : ptr(ptr) {}
+
+id::id(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+id &id::operator=(id obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+id::~id() {
+  if (ptr)
+    isl_id_free(ptr);
+}
+
+__isl_give isl_id *id::copy() const & {
+  return isl_id_copy(ptr);
+}
+
+__isl_keep isl_id *id::get() const {
+  return ptr;
+}
+
+__isl_give isl_id *id::release() {
+  isl_id *tmp = ptr;
+  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));
+}
+
+std::string id::name() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_get_name(get());
+  std::string tmp(res);
+  return tmp;
+}
+
+std::string id::get_name() const
+{
+  return name();
+}
+
+isl::id_list id::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const id &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_id_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::id_list
+id_list manage(__isl_take isl_id_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return id_list(ptr);
+}
+id_list manage_copy(__isl_keep isl_id_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_id_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return id_list(ptr);
+}
+
+id_list::id_list()
+    : ptr(nullptr) {}
+
+id_list::id_list(const id_list &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+id_list::id_list(__isl_take isl_id_list *ptr)
+    : ptr(ptr) {}
+
+id_list::id_list(isl::ctx ctx, int n)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+id_list::id_list(isl::id el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_from_id(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_id_list_free(ptr);
+}
+
+__isl_give isl_id_list *id_list::copy() const & {
+  return isl_id_list_copy(ptr);
+}
+
+__isl_keep isl_id_list *id_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_id_list *id_list::release() {
+  isl_id_list *tmp = ptr;
+  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));
+}
+
+isl::id_list id_list::add(isl::id el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list id_list::add(const std::string &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::id(ctx(), el));
+}
+
+isl::id id_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id id_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::id_list id_list::clear() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list id_list::concat(isl::id_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list id_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void id_list::foreach(const std::function<void(isl::id)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::id)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_id *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_id_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::id_list id_list::insert(unsigned int pos, isl::id el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list id_list::insert(unsigned int pos, const std::string &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->insert(pos, isl::id(ctx(), el));
+}
+
+unsigned id_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_id_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const id_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_id_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_id_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::map
+map manage(__isl_take isl_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return map(ptr);
+}
+map manage_copy(__isl_keep isl_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_map_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_map_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return map(ptr);
+}
+
+map::map()
+    : ptr(nullptr) {}
+
+map::map(const map &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_map_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+map::map(__isl_take isl_map *ptr)
+    : ptr(ptr) {}
+
+map::map(isl::basic_map bmap)
+{
+  if (bmap.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = bmap.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_from_basic_map(bmap.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+map::map(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+map &map::operator=(map obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+map::~map() {
+  if (ptr)
+    isl_map_free(ptr);
+}
+
+__isl_give isl_map *map::copy() const & {
+  return isl_map_copy(ptr);
+}
+
+__isl_keep isl_map *map::get() const {
+  return ptr;
+}
+
+__isl_give isl_map *map::release() {
+  isl_map *tmp = ptr;
+  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));
+}
+
+isl::basic_map map::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::apply_domain(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_apply_domain(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::apply_domain(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).apply_domain(umap2);
+}
+
+isl::map map::apply_domain(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->apply_domain(isl::map(map2));
+}
+
+isl::map map::apply_range(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_apply_range(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::apply_range(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).apply_range(umap2);
+}
+
+isl::map map::apply_range(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->apply_range(isl::map(map2));
+}
+
+isl::map map::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).as_map();
+}
+
+isl::multi_union_pw_aff map::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff map::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_as_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff map::as_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).as_union_pw_multi_aff();
+}
+
+isl::set map::bind_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_bind_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set map::bind_range(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_bind_range(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::complement() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_complement(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).compute_divs();
+}
+
+isl::map map::curry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_curry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set map::deltas() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_deltas(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set map::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::domain_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_domain_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::domain_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_domain_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::domain_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).domain_map();
+}
+
+isl::union_pw_multi_aff map::domain_map_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).domain_map_union_pw_multi_aff();
+}
+
+isl::map map::domain_product(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_domain_product(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::domain_product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).domain_product(umap2);
+}
+
+isl::map map::domain_product(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->domain_product(isl::map(map2));
+}
+
+isl::id map::domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_get_domain_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id map::get_domain_tuple_id() const
+{
+  return domain_tuple_id();
+}
+
+isl::map map::empty(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_empty(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::eq_at(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_eq_at_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::eq_at(const isl::multi_union_pw_aff &mupa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).eq_at(mupa);
+}
+
+isl::map map::eq_at(const isl::aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->eq_at(isl::multi_pw_aff(mpa));
+}
+
+isl::map map::eq_at(const isl::multi_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->eq_at(isl::multi_pw_aff(mpa));
+}
+
+isl::map map::eq_at(const isl::pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->eq_at(isl::multi_pw_aff(mpa));
+}
+
+isl::map map::eq_at(const isl::pw_multi_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->eq_at(isl::multi_pw_aff(mpa));
+}
+
+bool map::every_map(const std::function<bool(isl::map)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).every_map(test);
+}
+
+isl::map map::extract_map(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).extract_map(space);
+}
+
+isl::map map::factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::fixed_power(const isl::val &exp) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).fixed_power(exp);
+}
+
+isl::union_map map::fixed_power(long exp) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->fixed_power(isl::val(ctx(), exp));
+}
+
+isl::map map::flatten() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_flatten(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::flatten_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_flatten_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::flatten_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_flatten_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void map::foreach_basic_map(const std::function<void(isl::basic_map)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::basic_map)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_map_foreach_basic_map(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+void map::foreach_map(const std::function<void(isl::map)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).foreach_map(fn);
+}
+
+isl::map map::gist(isl::map context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::gist(const isl::union_map &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).gist(context);
+}
+
+isl::map map::gist(const isl::basic_map &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::map(context));
+}
+
+isl::map map::gist_domain(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_gist_domain(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::gist_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).gist_domain(uset);
+}
+
+isl::map map::gist_domain(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist_domain(isl::set(context));
+}
+
+isl::map map::gist_domain(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist_domain(isl::set(context));
+}
+
+isl::union_map map::gist_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).gist_params(set);
+}
+
+isl::union_map map::gist_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).gist_range(uset);
+}
+
+bool map::has_domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_has_domain_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::map map::intersect(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect(umap2);
+}
+
+isl::map map::intersect(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect(isl::map(map2));
+}
+
+isl::map map::intersect_domain(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_domain(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_domain(space);
+}
+
+isl::union_map map::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_domain(uset);
+}
+
+isl::map map::intersect_domain(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::map map::intersect_domain(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::map map::intersect_domain_factor_domain(isl::map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_domain_factor_domain(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_domain_factor_domain(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_domain_factor_domain(factor);
+}
+
+isl::map map::intersect_domain_factor_domain(const isl::basic_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain_factor_domain(isl::map(factor));
+}
+
+isl::map map::intersect_domain_factor_range(isl::map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_domain_factor_range(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_domain_factor_range(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_domain_factor_range(factor);
+}
+
+isl::map map::intersect_domain_factor_range(const isl::basic_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain_factor_range(isl::map(factor));
+}
+
+isl::map map::intersect_params(isl::set params) const
+{
+  if (!ptr || params.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_params(copy(), params.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::intersect_range(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_range(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_range(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_range(space);
+}
+
+isl::union_map map::intersect_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_range(uset);
+}
+
+isl::map map::intersect_range(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_range(isl::set(set));
+}
+
+isl::map map::intersect_range(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_range(isl::set(set));
+}
+
+isl::map map::intersect_range_factor_domain(isl::map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_range_factor_domain(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_range_factor_domain(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_range_factor_domain(factor);
+}
+
+isl::map map::intersect_range_factor_domain(const isl::basic_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_range_factor_domain(isl::map(factor));
+}
+
+isl::map map::intersect_range_factor_range(isl::map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_intersect_range_factor_range(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::intersect_range_factor_range(const isl::union_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).intersect_range_factor_range(factor);
+}
+
+isl::map map::intersect_range_factor_range(const isl::basic_map &factor) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_range_factor_range(isl::map(factor));
+}
+
+bool map::is_bijective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_bijective(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_disjoint(const isl::map &map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_disjoint(get(), map2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_disjoint(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).is_disjoint(umap2);
+}
+
+bool map::is_disjoint(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_disjoint(isl::map(map2));
+}
+
+bool map::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_equal(const isl::map &map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_equal(get(), map2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_equal(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).is_equal(umap2);
+}
+
+bool map::is_equal(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_equal(isl::map(map2));
+}
+
+bool map::is_injective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_injective(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_single_valued() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_single_valued(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_strict_subset(const isl::map &map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_strict_subset(get(), map2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_strict_subset(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).is_strict_subset(umap2);
+}
+
+bool map::is_strict_subset(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_strict_subset(isl::map(map2));
+}
+
+bool map::is_subset(const isl::map &map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_is_subset(get(), map2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool map::is_subset(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).is_subset(umap2);
+}
+
+bool map::is_subset(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_subset(isl::map(map2));
+}
+
+bool map::isa_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).isa_map();
+}
+
+isl::map map::lex_ge_at(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lex_ge_at_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lex_gt_at(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lex_gt_at_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lex_le_at(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lex_le_at_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lex_lt_at(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lex_lt_at_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff map::lexmax_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lexmax_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff map::lexmin_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lexmin_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::lower_bound(isl::multi_pw_aff lower) const
+{
+  if (!ptr || lower.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_lower_bound_multi_pw_aff(copy(), lower.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff map::max_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_max_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff map::min_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_min_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map map::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_polyhedral_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::preimage_domain(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_preimage_domain_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::preimage_domain(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::preimage_domain(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_preimage_domain_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::preimage_domain(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).preimage_domain(upma);
+}
+
+isl::map map::preimage_range(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_preimage_range_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::preimage_range(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_preimage_range_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::preimage_range(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).preimage_range(upma);
+}
+
+isl::map map::product(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_product(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).product(umap2);
+}
+
+isl::map map::product(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->product(isl::map(map2));
+}
+
+isl::map map::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_project_out_all_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set map::range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_range_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_range_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::range_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).range_map();
+}
+
+isl::map map::range_product(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_range_product(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::range_product(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).range_product(umap2);
+}
+
+isl::map map::range_product(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::map(map2));
+}
+
+isl::map map::range_reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_range_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::fixed_box map::range_simple_fixed_box_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_get_range_simple_fixed_box_hull(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::fixed_box map::get_range_simple_fixed_box_hull() const
+{
+  return range_simple_fixed_box_hull();
+}
+
+isl::id map::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id map::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::map map::reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map map::sample() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_sample(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::set_domain_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_set_domain_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::set_domain_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_domain_tuple(isl::id(ctx(), id));
+}
+
+isl::map map::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::space map::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space map::get_space() const
+{
+  return space();
+}
+
+isl::map map::subtract(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_subtract(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::subtract(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).subtract(umap2);
+}
+
+isl::map map::subtract(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract(isl::map(map2));
+}
+
+isl::union_map map::subtract_domain(const isl::union_set &dom) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).subtract_domain(dom);
+}
+
+isl::union_map map::subtract_range(const isl::union_set &dom) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).subtract_range(dom);
+}
+
+isl::union_map map::to_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_to_union_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::uncurry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_uncurry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::unite(isl::map map2) const
+{
+  if (!ptr || map2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_union(copy(), map2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map map::unite(const isl::union_map &umap2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_map(*this).unite(umap2);
+}
+
+isl::map map::unite(const isl::basic_map &map2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->unite(isl::map(map2));
+}
+
+isl::map map::universe(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_universe(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_map map::unshifted_simple_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_unshifted_simple_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::upper_bound(isl::multi_pw_aff upper) const
+{
+  if (!ptr || upper.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_upper_bound_multi_pw_aff(copy(), upper.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set map::wrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_wrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map map::zip() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_map_zip(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const map &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_map_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_map_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::multi_aff
+multi_aff manage(__isl_take isl_multi_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return multi_aff(ptr);
+}
+multi_aff manage_copy(__isl_keep isl_multi_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_multi_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return multi_aff(ptr);
+}
+
+multi_aff::multi_aff()
+    : ptr(nullptr) {}
+
+multi_aff::multi_aff(const multi_aff &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+multi_aff::multi_aff(__isl_take isl_multi_aff *ptr)
+    : ptr(ptr) {}
+
+multi_aff::multi_aff(isl::aff aff)
+{
+  if (aff.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = aff.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_from_aff(aff.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_aff::multi_aff(isl::space space, isl::aff_list list)
+{
+  if (space.is_null() || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_from_aff_list(space.release(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_aff::multi_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_aff &multi_aff::operator=(multi_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_aff::~multi_aff() {
+  if (ptr)
+    isl_multi_aff_free(ptr);
+}
+
+__isl_give isl_multi_aff *multi_aff::copy() const & {
+  return isl_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_aff *multi_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_aff *multi_aff::release() {
+  isl_multi_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+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::multi_aff multi_aff::add(isl::multi_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_add(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::add(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(multi2);
+}
+
+isl::multi_union_pw_aff multi_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(multi2);
+}
+
+isl::pw_multi_aff multi_aff::add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(upma2);
+}
+
+isl::multi_aff multi_aff::add(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::multi_aff(multi2));
+}
+
+isl::multi_aff multi_aff::add_constant(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_add_constant_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::add_constant(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_add_constant_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::add_constant(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::union_pw_multi_aff multi_aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).apply(upma2);
+}
+
+isl::map multi_aff::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_as_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::as_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_multi_aff();
+}
+
+isl::multi_union_pw_aff multi_aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff multi_aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::set multi_aff::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_as_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map multi_aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_union_map();
+}
+
+isl::aff multi_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff multi_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::basic_set multi_aff::bind(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_bind(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::bind_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_bind_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff multi_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).coalesce();
+}
+
+isl::multi_val multi_aff::constant_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_get_constant_multi_val(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_aff::get_constant_multi_val() const
+{
+  return constant_multi_val();
+}
+
+isl::set multi_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).domain();
+}
+
+isl::multi_aff multi_aff::domain_map(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_domain_map(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff multi_aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::multi_aff multi_aff::flat_range_product(isl::multi_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_flat_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::flat_range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_union_pw_aff multi_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::pw_multi_aff multi_aff::flat_range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).flat_range_product(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::multi_aff multi_aff::flat_range_product(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::multi_aff(multi2));
+}
+
+isl::multi_aff multi_aff::floor() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_floor(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void multi_aff::foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).foreach_piece(fn);
+}
+
+isl::multi_aff multi_aff::gist(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff multi_aff::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).gist(context);
+}
+
+isl::multi_aff multi_aff::gist(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::multi_aff multi_aff::gist(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+bool multi_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_aff multi_aff::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_identity_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::identity_on_domain(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_identity_on_domain_space(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::insert_domain(isl::space domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff multi_aff::intersect_domain(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_domain(set);
+}
+
+isl::union_pw_multi_aff multi_aff::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_domain(space);
+}
+
+isl::union_pw_multi_aff multi_aff::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_domain(uset);
+}
+
+isl::union_pw_multi_aff multi_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::union_pw_multi_aff multi_aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::pw_multi_aff multi_aff::intersect_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).intersect_params(set);
+}
+
+bool multi_aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_involves_locals(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_involves_nan(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_aff::involves_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).involves_param(id);
+}
+
+bool multi_aff::involves_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+bool multi_aff::involves_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).involves_param(list);
+}
+
+bool multi_aff::isa_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).isa_multi_aff();
+}
+
+bool multi_aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::aff_list multi_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_get_list(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff_list multi_aff::get_list() const
+{
+  return list();
+}
+
+isl::multi_pw_aff multi_aff::max(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).max(multi2);
+}
+
+isl::multi_val multi_aff::max_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).max_multi_val();
+}
+
+isl::multi_pw_aff multi_aff::min(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).min(multi2);
+}
+
+isl::multi_val multi_aff::min_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).min_multi_val();
+}
+
+isl::multi_aff multi_aff::multi_val_on_domain(isl::space space, isl::multi_val mv)
+{
+  if (space.is_null() || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_multi_val_on_domain_space(space.release(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned multi_aff::n_piece() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).n_piece();
+}
+
+isl::multi_aff multi_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).plain_is_empty();
+}
+
+bool multi_aff::plain_is_equal(const isl::multi_aff &multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_plain_is_equal(get(), multi2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+bool multi_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+bool multi_aff::plain_is_equal(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->plain_is_equal(isl::multi_aff(multi2));
+}
+
+isl::pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::multi_aff multi_aff::product(isl::multi_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).product(multi2);
+}
+
+isl::pw_multi_aff multi_aff::product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).product(pma2);
+}
+
+isl::multi_aff multi_aff::product(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->product(isl::multi_aff(multi2));
+}
+
+isl::multi_aff multi_aff::pullback(isl::multi_aff ma2) const
+{
+  if (!ptr || ma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_pullback_multi_aff(copy(), ma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::pullback(const isl::multi_pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).pullback(mpa2);
+}
+
+isl::pw_multi_aff multi_aff::pullback(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).pullback(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::pullback(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).pullback(upma2);
+}
+
+isl::multi_aff multi_aff::pullback(const isl::aff &ma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->pullback(isl::multi_aff(ma2));
+}
+
+isl::pw_multi_aff multi_aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::pw_multi_aff multi_aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_factor_range();
+}
+
+isl::multi_aff multi_aff::range_map(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_range_map(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::range_product(isl::multi_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::multi_union_pw_aff multi_aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::pw_multi_aff multi_aff::range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::multi_aff multi_aff::range_product(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::multi_aff(multi2));
+}
+
+isl::id multi_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::multi_aff multi_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_reset_range_tuple_id(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::scale(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_scale_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_aff multi_aff::scale_down(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_scale_down_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_aff multi_aff::set_at(int pos, isl::aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_set_at(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::set_at(int pos, const isl::pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::multi_union_pw_aff multi_aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::multi_aff multi_aff::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff multi_aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned multi_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space multi_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::multi_aff multi_aff::sub(isl::multi_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_sub(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::multi_union_pw_aff multi_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::pw_multi_aff multi_aff::sub(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(upma2);
+}
+
+isl::multi_aff multi_aff::sub(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::multi_aff(multi2));
+}
+
+isl::pw_multi_aff multi_aff::subtract_domain(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).subtract_domain(set);
+}
+
+isl::union_pw_multi_aff multi_aff::subtract_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).subtract_domain(space);
+}
+
+isl::union_pw_multi_aff multi_aff::subtract_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).subtract_domain(uset);
+}
+
+isl::pw_multi_aff_list multi_aff::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).to_list();
+}
+
+isl::multi_pw_aff multi_aff::to_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_to_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_aff::to_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_to_multi_union_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff multi_aff::to_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_to_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff multi_aff::to_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::multi_aff multi_aff::unbind_params_insert_domain(isl::multi_id domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_unbind_params_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_aff::union_add(const isl::multi_pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).union_add(mpa2);
+}
+
+isl::multi_union_pw_aff multi_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).union_add(mupa2);
+}
+
+isl::pw_multi_aff multi_aff::union_add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).union_add(pma2);
+}
+
+isl::union_pw_multi_aff multi_aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::multi_aff multi_aff::zero(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_aff_zero(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_multi_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::multi_id
+multi_id manage(__isl_take isl_multi_id *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return multi_id(ptr);
+}
+multi_id manage_copy(__isl_keep isl_multi_id *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_id_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_multi_id_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return multi_id(ptr);
+}
+
+multi_id::multi_id()
+    : ptr(nullptr) {}
+
+multi_id::multi_id(const multi_id &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_id_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+multi_id::multi_id(__isl_take isl_multi_id *ptr)
+    : ptr(ptr) {}
+
+multi_id::multi_id(isl::space space, isl::id_list list)
+{
+  if (space.is_null() || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_from_id_list(space.release(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_id::multi_id(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_id &multi_id::operator=(multi_id obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_id::~multi_id() {
+  if (ptr)
+    isl_multi_id_free(ptr);
+}
+
+__isl_give isl_multi_id *multi_id::copy() const & {
+  return isl_multi_id_copy(ptr);
+}
+
+__isl_keep isl_multi_id *multi_id::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_id *multi_id::release() {
+  isl_multi_id *tmp = ptr;
+  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));
+}
+
+isl::id multi_id::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_id::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::multi_id multi_id::flat_range_product(isl::multi_id multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_flat_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list multi_id::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_get_list(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id_list multi_id::get_list() const
+{
+  return list();
+}
+
+bool multi_id::plain_is_equal(const isl::multi_id &multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_plain_is_equal(get(), multi2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_id multi_id::range_product(isl::multi_id multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_id multi_id::set_at(int pos, isl::id el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_set_at(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_id multi_id::set_at(int pos, const std::string &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_at(pos, isl::id(ctx(), el));
+}
+
+unsigned multi_id::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space multi_id::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_id_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space multi_id::get_space() const
+{
+  return space();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_id &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_id_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_multi_id_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::multi_pw_aff
+multi_pw_aff manage(__isl_take isl_multi_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return multi_pw_aff(ptr);
+}
+multi_pw_aff manage_copy(__isl_keep isl_multi_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_pw_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_multi_pw_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_pw_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+multi_pw_aff::multi_pw_aff(__isl_take isl_multi_pw_aff *ptr)
+    : ptr(ptr) {}
+
+multi_pw_aff::multi_pw_aff(isl::aff aff)
+{
+  if (aff.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = aff.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_from_aff(aff.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::multi_aff ma)
+{
+  if (ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_from_multi_aff(ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::pw_aff pa)
+{
+  if (pa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_from_pw_aff(pa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::space space, isl::pw_aff_list list)
+{
+  if (space.is_null() || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_from_pw_aff_list(space.release(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::pw_multi_aff pma)
+{
+  if (pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_from_pw_multi_aff(pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff::multi_pw_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_pw_aff &multi_pw_aff::operator=(multi_pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_pw_aff::~multi_pw_aff() {
+  if (ptr)
+    isl_multi_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_pw_aff *multi_pw_aff::copy() const & {
+  return isl_multi_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_pw_aff *multi_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_pw_aff *multi_pw_aff::release() {
+  isl_multi_pw_aff *tmp = ptr;
+  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));
+}
+
+isl::multi_pw_aff multi_pw_aff::add(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_add(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).add(multi2);
+}
+
+isl::multi_pw_aff multi_pw_aff::add(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::add(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::add(const isl::pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::add(const isl::pw_multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::add_constant(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_add_constant_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::add_constant(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_add_constant_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::add_constant(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::map multi_pw_aff::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_as_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set multi_pw_aff::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_as_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff multi_pw_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff multi_pw_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::set multi_pw_aff::bind(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_bind(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::bind_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_bind_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set multi_pw_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::flat_range_product(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_flat_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::flat_range_product(const isl::pw_multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::gist(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_gist(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).gist(context);
+}
+
+isl::multi_pw_aff multi_pw_aff::gist(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(set));
+}
+
+isl::multi_pw_aff multi_pw_aff::gist(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(set));
+}
+
+bool multi_pw_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_pw_aff multi_pw_aff::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_identity_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::identity_on_domain(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_identity_on_domain_space(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::insert_domain(isl::space domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::intersect_domain(isl::set domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_intersect_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).intersect_domain(uset);
+}
+
+isl::multi_pw_aff multi_pw_aff::intersect_domain(const isl::basic_set &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(domain));
+}
+
+isl::multi_pw_aff multi_pw_aff::intersect_domain(const isl::point &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(domain));
+}
+
+isl::multi_pw_aff multi_pw_aff::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_pw_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_involves_nan(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_pw_aff::involves_param(const isl::id &id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_involves_param_id(get(), id.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_pw_aff::involves_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+bool multi_pw_aff::involves_param(const isl::id_list &list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_involves_param_id_list(get(), list.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::pw_aff_list multi_pw_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_get_list(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff_list multi_pw_aff::get_list() const
+{
+  return list();
+}
+
+isl::multi_pw_aff multi_pw_aff::max(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_max(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_pw_aff::max_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_max_multi_val(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::min(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_min(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_pw_aff::min_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_min_multi_val(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_plain_is_equal(get(), multi2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+bool multi_pw_aff::plain_is_equal(const isl::pw_multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->plain_is_equal(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::product(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::pullback(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_pullback_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::pullback(isl::multi_pw_aff mpa2) const
+{
+  if (!ptr || mpa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_pullback_multi_pw_aff(copy(), mpa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::pullback(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::pullback(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).pullback(upma);
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(isl::multi_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).range_product(multi2);
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::range_product(const isl::pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::multi_pw_aff(multi2));
+}
+
+isl::id multi_pw_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_pw_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::multi_pw_aff multi_pw_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_reset_range_tuple_id(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::scale(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_scale_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_pw_aff multi_pw_aff::scale_down(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_scale_down_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_pw_aff multi_pw_aff::set_at(int pos, isl::pw_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_set_at(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::multi_pw_aff multi_pw_aff::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned multi_pw_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space multi_pw_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_sub(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).sub(multi2);
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::sub(const isl::pw_multi_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::multi_pw_aff(multi2));
+}
+
+isl::multi_pw_aff multi_pw_aff::unbind_params_insert_domain(isl::multi_id domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_unbind_params_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(isl::multi_pw_aff mpa2) const
+{
+  if (!ptr || mpa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_union_add(copy(), mpa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_pw_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::multi_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::union_add(const isl::pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::multi_pw_aff(mpa2));
+}
+
+isl::multi_pw_aff multi_pw_aff::zero(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_pw_aff_zero(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_pw_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_pw_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_multi_pw_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return multi_union_pw_aff(ptr);
+}
+multi_union_pw_aff manage_copy(__isl_keep isl_multi_union_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_union_pw_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_multi_union_pw_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_union_pw_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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)
+{
+  if (mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = mpa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_from_multi_pw_aff(mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_union_pw_aff::multi_union_pw_aff(isl::union_pw_aff upa)
+{
+  if (upa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = upa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_from_union_pw_aff(upa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_union_pw_aff::multi_union_pw_aff(isl::space space, isl::union_pw_aff_list list)
+{
+  if (space.is_null() || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_from_union_pw_aff_list(space.release(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_union_pw_aff::multi_union_pw_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_union_pw_aff &multi_union_pw_aff::operator=(multi_union_pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_union_pw_aff::~multi_union_pw_aff() {
+  if (ptr)
+    isl_multi_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::copy() const & {
+  return isl_multi_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_multi_union_pw_aff *multi_union_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_union_pw_aff *multi_union_pw_aff::release() {
+  isl_multi_union_pw_aff *tmp = ptr;
+  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));
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::add(isl::multi_union_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_add(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff multi_union_pw_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff multi_union_pw_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::union_set multi_union_pw_aff::bind(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_bind(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set multi_union_pw_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::flat_range_product(isl::multi_union_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_flat_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::gist(isl::union_set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_union_pw_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::intersect_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_intersect_domain(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::intersect_params(isl::set params) const
+{
+  if (!ptr || params.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_intersect_params(copy(), params.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_union_pw_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_involves_nan(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::union_pw_aff_list multi_union_pw_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_get_list(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff_list multi_union_pw_aff::get_list() const
+{
+  return list();
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_plain_is_equal(get(), multi2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::pullback(isl::union_pw_multi_aff upma) const
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_pullback_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::range_product(isl::multi_union_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_union_pw_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_union_pw_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_reset_range_tuple_id(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_scale_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_scale_down_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_set_at(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned multi_union_pw_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space multi_union_pw_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space multi_union_pw_aff::get_space() const
+{
+  return space();
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::sub(isl::multi_union_pw_aff multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_sub(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::union_add(isl::multi_union_pw_aff mupa2) const
+{
+  if (!ptr || mupa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_union_add(copy(), mupa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff multi_union_pw_aff::zero(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_union_pw_aff_zero(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_union_pw_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_union_pw_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_multi_union_pw_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::multi_val
+multi_val manage(__isl_take isl_multi_val *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return multi_val(ptr);
+}
+multi_val manage_copy(__isl_keep isl_multi_val *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_val_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_multi_val_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return multi_val(ptr);
+}
+
+multi_val::multi_val()
+    : ptr(nullptr) {}
+
+multi_val::multi_val(const multi_val &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_val_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+multi_val::multi_val(__isl_take isl_multi_val *ptr)
+    : ptr(ptr) {}
+
+multi_val::multi_val(isl::space space, isl::val_list list)
+{
+  if (space.is_null() || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_from_val_list(space.release(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_val::multi_val(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+multi_val &multi_val::operator=(multi_val obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+multi_val::~multi_val() {
+  if (ptr)
+    isl_multi_val_free(ptr);
+}
+
+__isl_give isl_multi_val *multi_val::copy() const & {
+  return isl_multi_val_copy(ptr);
+}
+
+__isl_keep isl_multi_val *multi_val::get() const {
+  return ptr;
+}
+
+__isl_give isl_multi_val *multi_val::release() {
+  isl_multi_val *tmp = ptr;
+  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));
+}
+
+isl::multi_val multi_val::add(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_add(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::add(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_add_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::add(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::val(ctx(), v));
+}
+
+isl::val multi_val::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val multi_val::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::multi_val multi_val::flat_range_product(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_flat_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_val::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool multi_val::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_involves_nan(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::val_list multi_val::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_get_list(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val_list multi_val::get_list() const
+{
+  return list();
+}
+
+isl::multi_val multi_val::max(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_max(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::min(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_min(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool multi_val::plain_is_equal(const isl::multi_val &multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_plain_is_equal(get(), multi2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_val multi_val::product(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::range_product(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_range_product(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_val::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id multi_val::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::multi_val multi_val::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_reset_range_tuple_id(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::scale(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_scale_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_val multi_val::scale_down(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_scale_down_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_val multi_val::set_at(int pos, isl::val el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_set_at(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::set_at(int pos, long el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_at(pos, isl::val(ctx(), el));
+}
+
+isl::multi_val multi_val::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned multi_val::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space multi_val::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space multi_val::get_space() const
+{
+  return space();
+}
+
+isl::multi_val multi_val::sub(isl::multi_val multi2) const
+{
+  if (!ptr || multi2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_sub(copy(), multi2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val multi_val::zero(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_multi_val_zero(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const multi_val &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_multi_val_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_multi_val_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::point
+point manage(__isl_take isl_point *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return point(ptr);
+}
+point manage_copy(__isl_keep isl_point *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_point_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_point_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return point(ptr);
+}
+
+point::point()
+    : ptr(nullptr) {}
+
+point::point(const point &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_point_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+point::point(__isl_take isl_point *ptr)
+    : ptr(ptr) {}
+
+point &point::operator=(point obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+point::~point() {
+  if (ptr)
+    isl_point_free(ptr);
+}
+
+__isl_give isl_point *point::copy() const & {
+  return isl_point_copy(ptr);
+}
+
+__isl_keep isl_point *point::get() const {
+  return ptr;
+}
+
+__isl_give isl_point *point::release() {
+  isl_point *tmp = ptr;
+  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));
+}
+
+isl::basic_set point::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).affine_hull();
+}
+
+isl::basic_set point::apply(const isl::basic_map &bmap) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).apply(bmap);
+}
+
+isl::set point::apply(const isl::map &map) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).apply(map);
+}
+
+isl::union_set point::apply(const isl::union_map &umap) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).apply(umap);
+}
+
+isl::pw_multi_aff point::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).as_pw_multi_aff();
+}
+
+isl::set point::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).as_set();
+}
+
+isl::set point::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).bind(tuple);
+}
+
+isl::set point::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).coalesce();
+}
+
+isl::set point::complement() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).complement();
+}
+
+isl::union_set point::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).compute_divs();
+}
+
+isl::basic_set point::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).detect_equalities();
+}
+
+isl::val point::dim_max_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).dim_max_val(pos);
+}
+
+isl::val point::dim_min_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).dim_min_val(pos);
+}
+
+bool point::every_set(const std::function<bool(isl::set)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).every_set(test);
+}
+
+isl::set point::extract_set(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).extract_set(space);
+}
+
+isl::basic_set point::flatten() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).flatten();
+}
+
+void point::foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).foreach_basic_set(fn);
+}
+
+void point::foreach_point(const std::function<void(isl::point)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).foreach_point(fn);
+}
+
+void point::foreach_set(const std::function<void(isl::set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).foreach_set(fn);
+}
+
+isl::basic_set point::gist(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).gist(context);
+}
+
+isl::set point::gist(const isl::set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).gist(context);
+}
+
+isl::union_set point::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).gist(context);
+}
+
+isl::union_set point::gist_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).gist_params(set);
+}
+
+isl::map point::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).identity();
+}
+
+isl::pw_aff point::indicator_function() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).indicator_function();
+}
+
+isl::map point::insert_domain(const isl::space &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).insert_domain(domain);
+}
+
+isl::basic_set point::intersect(const isl::basic_set &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).intersect(bset2);
+}
+
+isl::set point::intersect(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).intersect(set2);
+}
+
+isl::union_set point::intersect(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).intersect(uset2);
+}
+
+isl::basic_set point::intersect_params(const isl::basic_set &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).intersect_params(bset2);
+}
+
+isl::set point::intersect_params(const isl::set &params) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).intersect_params(params);
+}
+
+bool point::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).involves_locals();
+}
+
+bool point::is_disjoint(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_disjoint(set2);
+}
+
+bool point::is_disjoint(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_disjoint(uset2);
+}
+
+bool point::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_empty();
+}
+
+bool point::is_equal(const isl::basic_set &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_equal(bset2);
+}
+
+bool point::is_equal(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_equal(set2);
+}
+
+bool point::is_equal(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_equal(uset2);
+}
+
+bool point::is_singleton() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_singleton();
+}
+
+bool point::is_strict_subset(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_strict_subset(set2);
+}
+
+bool point::is_strict_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_strict_subset(uset2);
+}
+
+bool point::is_subset(const isl::basic_set &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_subset(bset2);
+}
+
+bool point::is_subset(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_subset(set2);
+}
+
+bool point::is_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_subset(uset2);
+}
+
+bool point::is_wrapping() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).is_wrapping();
+}
+
+bool point::isa_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).isa_set();
+}
+
+isl::set point::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lexmax();
+}
+
+isl::pw_multi_aff point::lexmax_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lexmax_pw_multi_aff();
+}
+
+isl::set point::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lexmin();
+}
+
+isl::pw_multi_aff point::lexmin_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lexmin_pw_multi_aff();
+}
+
+isl::set point::lower_bound(const isl::multi_pw_aff &lower) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lower_bound(lower);
+}
+
+isl::set point::lower_bound(const isl::multi_val &lower) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).lower_bound(lower);
+}
+
+isl::multi_pw_aff point::max_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).max_multi_pw_aff();
+}
+
+isl::val point::max_val(const isl::aff &obj) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).max_val(obj);
+}
+
+isl::multi_pw_aff point::min_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).min_multi_pw_aff();
+}
+
+isl::val point::min_val(const isl::aff &obj) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).min_val(obj);
+}
+
+isl::multi_val point::multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_point_get_multi_val(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val point::get_multi_val() const
+{
+  return multi_val();
+}
+
+isl::basic_set point::params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).params();
+}
+
+isl::multi_val point::plain_multi_val_if_fixed() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).plain_multi_val_if_fixed();
+}
+
+isl::basic_set point::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).polyhedral_hull();
+}
+
+isl::set point::preimage(const isl::multi_aff &ma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).preimage(ma);
+}
+
+isl::set point::preimage(const isl::multi_pw_aff &mpa) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).preimage(mpa);
+}
+
+isl::set point::preimage(const isl::pw_multi_aff &pma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).preimage(pma);
+}
+
+isl::union_set point::preimage(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).preimage(upma);
+}
+
+isl::set point::product(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).product(set2);
+}
+
+isl::set point::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).project_out_all_params();
+}
+
+isl::set point::project_out_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).project_out_param(id);
+}
+
+isl::set point::project_out_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->project_out_param(isl::id(ctx(), id));
+}
+
+isl::set point::project_out_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).project_out_param(list);
+}
+
+isl::pw_multi_aff point::pw_multi_aff_on_domain(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).pw_multi_aff_on_domain(mv);
+}
+
+isl::basic_set point::sample() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).sample();
+}
+
+isl::point point::sample_point() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).sample_point();
+}
+
+isl::fixed_box point::simple_fixed_box_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).simple_fixed_box_hull();
+}
+
+isl::space point::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).space();
+}
+
+isl::val point::stride(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).stride(pos);
+}
+
+isl::set point::subtract(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).subtract(set2);
+}
+
+isl::union_set point::subtract(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).subtract(uset2);
+}
+
+isl::union_set_list point::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).to_list();
+}
+
+isl::set point::to_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_point_to_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set point::to_union_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).to_union_set();
+}
+
+isl::map point::translation() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).translation();
+}
+
+isl::set point::unbind_params(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unbind_params(tuple);
+}
+
+isl::map point::unbind_params_insert_domain(const isl::multi_id &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unbind_params_insert_domain(domain);
+}
+
+isl::set point::unite(const isl::basic_set &bset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unite(bset2);
+}
+
+isl::set point::unite(const isl::set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unite(set2);
+}
+
+isl::union_set point::unite(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unite(uset2);
+}
+
+isl::basic_set point::unshifted_simple_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unshifted_simple_hull();
+}
+
+isl::map point::unwrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).unwrap();
+}
+
+isl::set point::upper_bound(const isl::multi_pw_aff &upper) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).upper_bound(upper);
+}
+
+isl::set point::upper_bound(const isl::multi_val &upper) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::basic_set(*this).upper_bound(upper);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const point &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_point_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_point_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_aff
+pw_aff manage(__isl_take isl_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return pw_aff(ptr);
+}
+pw_aff manage_copy(__isl_keep isl_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_pw_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return pw_aff(ptr);
+}
+
+pw_aff::pw_aff()
+    : ptr(nullptr) {}
+
+pw_aff::pw_aff(const pw_aff &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+pw_aff::pw_aff(__isl_take isl_pw_aff *ptr)
+    : ptr(ptr) {}
+
+pw_aff::pw_aff(isl::aff aff)
+{
+  if (aff.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = aff.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_from_aff(aff.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_aff::pw_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_aff &pw_aff::operator=(pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_aff::~pw_aff() {
+  if (ptr)
+    isl_pw_aff_free(ptr);
+}
+
+__isl_give isl_pw_aff *pw_aff::copy() const & {
+  return isl_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_pw_aff *pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_aff *pw_aff::release() {
+  isl_pw_aff *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool pw_aff::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::ctx pw_aff::ctx() const {
+  return isl::ctx(isl_pw_aff_get_ctx(ptr));
+}
+
+isl::multi_pw_aff pw_aff::add(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(multi2);
+}
+
+isl::multi_union_pw_aff pw_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).add(multi2);
+}
+
+isl::pw_aff pw_aff::add(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_add(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_aff::add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add(pma2);
+}
+
+isl::union_pw_aff pw_aff::add(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).add(upa2);
+}
+
+isl::union_pw_multi_aff pw_aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).add(upma2);
+}
+
+isl::pw_aff pw_aff::add(const isl::aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::pw_aff(pwaff2));
+}
+
+isl::pw_aff pw_aff::add_constant(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_add_constant_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::add_constant(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::pw_multi_aff pw_aff::add_constant(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).add_constant(mv);
+}
+
+isl::union_pw_multi_aff pw_aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).apply(upma2);
+}
+
+isl::aff pw_aff::as_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_as_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map pw_aff::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_as_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff pw_aff::as_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_multi_aff();
+}
+
+isl::multi_union_pw_aff pw_aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff pw_aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).as_pw_multi_aff();
+}
+
+isl::set pw_aff::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).as_set();
+}
+
+isl::union_map pw_aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).as_union_map();
+}
+
+isl::pw_aff pw_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).at(pos);
+}
+
+isl::set pw_aff::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).bind(tuple);
+}
+
+isl::set pw_aff::bind(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_bind_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set pw_aff::bind(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->bind(isl::id(ctx(), id));
+}
+
+isl::pw_aff pw_aff::bind_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_bind_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::ceil() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_ceil(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::cond(isl::pw_aff pwaff_true, isl::pw_aff pwaff_false) const
+{
+  if (!ptr || pwaff_true.is_null() || pwaff_false.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_cond(copy(), pwaff_true.release(), pwaff_false.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::div(isl::pw_aff pa2) const
+{
+  if (!ptr || pa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_div(copy(), pa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set pw_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set pw_aff::eq_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_eq_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val pw_aff::eval(isl::point pnt) const
+{
+  if (!ptr || pnt.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_eval(copy(), pnt.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_union_pw_aff pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::pw_multi_aff pw_aff::flat_range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).flat_range_product(upma2);
+}
+
+isl::pw_aff pw_aff::floor() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_floor(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void pw_aff::foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).foreach_piece(fn);
+}
+
+isl::set pw_aff::ge_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_ge_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::gist(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff pw_aff::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).gist(context);
+}
+
+isl::pw_aff pw_aff::gist(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::pw_aff pw_aff::gist(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::set pw_aff::gt_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_gt_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool pw_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).has_range_tuple_id();
+}
+
+isl::multi_pw_aff pw_aff::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).identity();
+}
+
+isl::pw_aff pw_aff::insert_domain(isl::space domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::intersect_domain(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_intersect_domain(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff pw_aff::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).intersect_domain(space);
+}
+
+isl::union_pw_aff pw_aff::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).intersect_domain(uset);
+}
+
+isl::pw_aff pw_aff::intersect_domain(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::pw_aff pw_aff::intersect_domain(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::union_pw_aff pw_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).intersect_domain_wrapped_domain(uset);
+}
+
+isl::union_pw_aff pw_aff::intersect_domain_wrapped_range(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::pw_aff pw_aff::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool pw_aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).involves_locals();
+}
+
+bool pw_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).involves_nan();
+}
+
+bool pw_aff::involves_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).involves_param(id);
+}
+
+bool pw_aff::involves_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+bool pw_aff::involves_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).involves_param(list);
+}
+
+bool pw_aff::isa_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_isa_aff(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool pw_aff::isa_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).isa_multi_aff();
+}
+
+bool pw_aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).isa_pw_multi_aff();
+}
+
+isl::set pw_aff::le_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_le_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff_list pw_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).list();
+}
+
+isl::set pw_aff::lt_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_lt_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_aff::max(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).max(multi2);
+}
+
+isl::pw_aff pw_aff::max(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_max(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::max(const isl::aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->max(isl::pw_aff(pwaff2));
+}
+
+isl::multi_val pw_aff::max_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).max_multi_val();
+}
+
+isl::multi_pw_aff pw_aff::min(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).min(multi2);
+}
+
+isl::pw_aff pw_aff::min(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_min(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::min(const isl::aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->min(isl::pw_aff(pwaff2));
+}
+
+isl::multi_val pw_aff::min_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).min_multi_val();
+}
+
+isl::pw_aff pw_aff::mod(isl::val mod) const
+{
+  if (!ptr || mod.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_mod_val(copy(), mod.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::mod(long mod) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->mod(isl::val(ctx(), mod));
+}
+
+isl::pw_aff pw_aff::mul(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_mul(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned pw_aff::n_piece() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).n_piece();
+}
+
+isl::set pw_aff::ne_set(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_ne_set(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::param_on_domain(isl::set domain, isl::id id)
+{
+  if (domain.is_null() || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_param_on_domain_id(domain.release(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool pw_aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).plain_is_empty();
+}
+
+bool pw_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).plain_is_equal(multi2);
+}
+
+bool pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).preimage_domain_wrapped_domain(pma2);
+}
+
+isl::union_pw_multi_aff pw_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::multi_pw_aff pw_aff::product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).product(multi2);
+}
+
+isl::pw_multi_aff pw_aff::product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).product(pma2);
+}
+
+isl::pw_aff pw_aff::pullback(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_pullback_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::pullback(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_pullback_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::pullback(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_pullback_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff pw_aff::pullback(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).pullback(upma);
+}
+
+isl::pw_multi_aff pw_aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::pw_multi_aff pw_aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_factor_range();
+}
+
+isl::multi_pw_aff pw_aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(multi2);
+}
+
+isl::multi_union_pw_aff pw_aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).range_product(multi2);
+}
+
+isl::pw_multi_aff pw_aff::range_product(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_product(pma2);
+}
+
+isl::union_pw_multi_aff pw_aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).range_product(upma2);
+}
+
+isl::id pw_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).range_tuple_id();
+}
+
+isl::multi_pw_aff pw_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::multi_pw_aff pw_aff::scale(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).scale(mv);
+}
+
+isl::pw_aff pw_aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_pw_aff pw_aff::scale_down(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).scale_down(mv);
+}
+
+isl::pw_aff pw_aff::scale_down(isl::val f) const
+{
+  if (!ptr || f.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_scale_down_val(copy(), f.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::scale_down(long f) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), f));
+}
+
+isl::multi_pw_aff pw_aff::set_at(int pos, const isl::pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).set_at(pos, el);
+}
+
+isl::multi_union_pw_aff pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).set_at(pos, el);
+}
+
+isl::pw_multi_aff pw_aff::set_range_tuple(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).set_range_tuple(id);
+}
+
+isl::pw_multi_aff pw_aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned pw_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).size();
+}
+
+isl::space pw_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).space();
+}
+
+isl::multi_pw_aff pw_aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(multi2);
+}
+
+isl::multi_union_pw_aff pw_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).sub(multi2);
+}
+
+isl::pw_aff pw_aff::sub(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_sub(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_aff::sub(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).sub(pma2);
+}
+
+isl::union_pw_aff pw_aff::sub(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).sub(upa2);
+}
+
+isl::union_pw_multi_aff pw_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).sub(upma2);
+}
+
+isl::pw_aff pw_aff::sub(const isl::aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::pw_aff(pwaff2));
+}
+
+isl::pw_aff pw_aff::subtract_domain(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_subtract_domain(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff pw_aff::subtract_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).subtract_domain(space);
+}
+
+isl::union_pw_aff pw_aff::subtract_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).subtract_domain(uset);
+}
+
+isl::pw_aff pw_aff::subtract_domain(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract_domain(isl::set(set));
+}
+
+isl::pw_aff pw_aff::subtract_domain(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract_domain(isl::set(set));
+}
+
+isl::pw_aff pw_aff::tdiv_q(isl::pw_aff pa2) const
+{
+  if (!ptr || pa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_tdiv_q(copy(), pa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff::tdiv_r(isl::pw_aff pa2) const
+{
+  if (!ptr || pa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_tdiv_r(copy(), pa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff_list pw_aff::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_aff::to_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).to_multi_pw_aff();
+}
+
+isl::union_pw_aff pw_aff::to_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_to_union_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_aff::to_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).to_union_pw_multi_aff();
+}
+
+isl::multi_pw_aff pw_aff::unbind_params_insert_domain(const isl::multi_id &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).union_add(mupa2);
+}
+
+isl::pw_aff pw_aff::union_add(isl::pw_aff pwaff2) const
+{
+  if (!ptr || pwaff2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_union_add(copy(), pwaff2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_aff::union_add(const isl::pw_multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::pw_multi_aff(*this).union_add(pma2);
+}
+
+isl::union_pw_aff pw_aff::union_add(const isl::union_pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_aff(*this).union_add(upma2);
+}
+
+isl::pw_aff pw_aff::union_add(const isl::aff &pwaff2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::pw_aff(pwaff2));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_pw_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_aff_list
+pw_aff_list manage(__isl_take isl_pw_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return pw_aff_list(ptr);
+}
+pw_aff_list manage_copy(__isl_keep isl_pw_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_pw_aff_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return pw_aff_list(ptr);
+}
+
+pw_aff_list::pw_aff_list()
+    : ptr(nullptr) {}
+
+pw_aff_list::pw_aff_list(const pw_aff_list &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+pw_aff_list::pw_aff_list(__isl_take isl_pw_aff_list *ptr)
+    : ptr(ptr) {}
+
+pw_aff_list::pw_aff_list(isl::ctx ctx, int n)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_aff_list::pw_aff_list(isl::pw_aff el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_from_pw_aff(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_aff_list &pw_aff_list::operator=(pw_aff_list obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_aff_list::~pw_aff_list() {
+  if (ptr)
+    isl_pw_aff_list_free(ptr);
+}
+
+__isl_give isl_pw_aff_list *pw_aff_list::copy() const & {
+  return isl_pw_aff_list_copy(ptr);
+}
+
+__isl_keep isl_pw_aff_list *pw_aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_pw_aff_list *pw_aff_list::release() {
+  isl_pw_aff_list *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool pw_aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::ctx pw_aff_list::ctx() const {
+  return isl::ctx(isl_pw_aff_list_get_ctx(ptr));
+}
+
+isl::pw_aff_list pw_aff_list::add(isl::pw_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::pw_aff_list pw_aff_list::clear() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff_list pw_aff_list::concat(isl::pw_aff_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff_list pw_aff_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void pw_aff_list::foreach(const std::function<void(isl::pw_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::pw_aff)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_pw_aff_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::pw_aff_list pw_aff_list::insert(unsigned int pos, isl::pw_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned pw_aff_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_aff_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_aff_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_aff_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_pw_aff_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_multi_aff
+pw_multi_aff manage(__isl_take isl_pw_multi_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return pw_multi_aff(ptr);
+}
+pw_multi_aff manage_copy(__isl_keep isl_pw_multi_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_pw_multi_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return pw_multi_aff(ptr);
+}
+
+pw_multi_aff::pw_multi_aff()
+    : ptr(nullptr) {}
+
+pw_multi_aff::pw_multi_aff(const pw_multi_aff &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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)
+{
+  if (ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_from_multi_aff(ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_multi_aff::pw_multi_aff(isl::pw_aff pa)
+{
+  if (pa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_from_pw_aff(pa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_multi_aff::pw_multi_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).add(multi2);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).add(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::add(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_add(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).add(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::add(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::add(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::add_constant(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_add_constant_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::add_constant(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_add_constant_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::add_constant(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_constant(isl::val(ctx(), v));
+}
+
+isl::union_pw_multi_aff pw_multi_aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).apply(upma2);
+}
+
+isl::map pw_multi_aff::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_as_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff pw_multi_aff::as_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_as_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff pw_multi_aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::set pw_multi_aff::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_as_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map pw_multi_aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_union_map();
+}
+
+isl::pw_aff pw_multi_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_get_at(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff pw_multi_aff::get_at(int pos) const
+{
+  return at(pos);
+}
+
+isl::set pw_multi_aff::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).bind(tuple);
+}
+
+isl::pw_multi_aff pw_multi_aff::bind_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_bind_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::bind_domain_wrapped_domain(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_bind_domain_wrapped_domain(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set pw_multi_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::domain_map(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_domain_map(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::multi_pw_aff pw_multi_aff::flat_range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).flat_range_product(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::flat_range_product(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_flat_range_product(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::flat_range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::flat_range_product(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::flat_range_product(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->flat_range_product(isl::pw_multi_aff(pma2));
+}
+
+void pw_multi_aff::foreach_piece(const std::function<void(isl::set, isl::multi_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::set, isl::multi_aff)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0), manage(arg_1));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_pw_multi_aff_foreach_piece(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::pw_multi_aff pw_multi_aff::gist(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_gist(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).gist(context);
+}
+
+isl::pw_multi_aff pw_multi_aff::gist(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(set));
+}
+
+isl::pw_multi_aff pw_multi_aff::gist(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(set));
+}
+
+bool pw_multi_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_pw_aff pw_multi_aff::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).identity();
+}
+
+isl::pw_multi_aff pw_multi_aff::identity_on_domain(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_identity_on_domain_space(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::insert_domain(isl::space domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::intersect_domain(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_intersect_domain(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).intersect_domain(space);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).intersect_domain(uset);
+}
+
+isl::pw_multi_aff pw_multi_aff::intersect_domain(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::pw_multi_aff pw_multi_aff::intersect_domain(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect_domain(isl::set(set));
+}
+
+isl::union_pw_multi_aff pw_multi_aff::intersect_domain_wrapped_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).intersect_domain_wrapped_range(uset);
+}
+
+isl::pw_multi_aff pw_multi_aff::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool pw_multi_aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_involves_locals(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool pw_multi_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).involves_nan();
+}
+
+bool pw_multi_aff::involves_param(const isl::id &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).involves_param(id);
+}
+
+bool pw_multi_aff::involves_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->involves_param(isl::id(ctx(), id));
+}
+
+bool pw_multi_aff::involves_param(const isl::id_list &list) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).involves_param(list);
+}
+
+bool pw_multi_aff::isa_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_isa_multi_aff(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool pw_multi_aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::pw_aff_list pw_multi_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).list();
+}
+
+isl::multi_pw_aff pw_multi_aff::max(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).max(multi2);
+}
+
+isl::multi_val pw_multi_aff::max_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_max_multi_val(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_multi_aff::min(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).min(multi2);
+}
+
+isl::multi_val pw_multi_aff::min_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_min_multi_val(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::multi_val_on_domain(isl::set domain, isl::multi_val mv)
+{
+  if (domain.is_null() || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_multi_val_on_domain(domain.release(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned pw_multi_aff::n_piece() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_n_piece(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_pw_aff pw_multi_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).neg();
+}
+
+bool pw_multi_aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).plain_is_empty();
+}
+
+bool pw_multi_aff::plain_is_equal(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).plain_is_equal(multi2);
+}
+
+bool pw_multi_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).preimage_domain_wrapped_domain(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->preimage_domain_wrapped_domain(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::preimage_domain_wrapped_domain(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->preimage_domain_wrapped_domain(isl::pw_multi_aff(pma2));
+}
+
+isl::multi_pw_aff pw_multi_aff::product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).product(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::product(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_product(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::product(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->product(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::product(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->product(isl::pw_multi_aff(pma2));
+}
+
+isl::multi_pw_aff pw_multi_aff::pullback(const isl::multi_pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).pullback(mpa2);
+}
+
+isl::pw_multi_aff pw_multi_aff::pullback(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_pullback_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::pullback(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_pullback_pw_multi_aff(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::pullback(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).pullback(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_range_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_range_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::range_map(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_range_map(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_multi_aff::range_product(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).range_product(multi2);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).range_product(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::range_product(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_range_product(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::range_product(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::range_product(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::range_product(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->range_product(isl::pw_multi_aff(pma2));
+}
+
+isl::id pw_multi_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id pw_multi_aff::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::multi_pw_aff pw_multi_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::multi_pw_aff pw_multi_aff::scale(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).scale(mv);
+}
+
+isl::pw_multi_aff pw_multi_aff::scale(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_scale_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_pw_aff pw_multi_aff::scale_down(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).scale_down(mv);
+}
+
+isl::pw_multi_aff pw_multi_aff::scale_down(isl::val v) const
+{
+  if (!ptr || v.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_scale_down_val(copy(), v.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_pw_aff pw_multi_aff::set_at(int pos, const isl::pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).set_at(pos, el);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).set_at(pos, el);
+}
+
+isl::pw_multi_aff pw_multi_aff::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned pw_multi_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).size();
+}
+
+isl::space pw_multi_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space pw_multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::multi_pw_aff pw_multi_aff::sub(const isl::multi_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).sub(multi2);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::sub(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).sub(multi2);
+}
+
+isl::pw_multi_aff pw_multi_aff::sub(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_sub(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).sub(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::sub(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::sub(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::subtract_domain(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_subtract_domain(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).subtract_domain(space);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::subtract_domain(const isl::union_set &uset) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).subtract_domain(uset);
+}
+
+isl::pw_multi_aff pw_multi_aff::subtract_domain(const isl::basic_set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract_domain(isl::set(set));
+}
+
+isl::pw_multi_aff pw_multi_aff::subtract_domain(const isl::point &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract_domain(isl::set(set));
+}
+
+isl::pw_multi_aff_list pw_multi_aff::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_multi_aff::to_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_to_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::to_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_to_union_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff pw_multi_aff::unbind_params_insert_domain(const isl::multi_id &domain) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).unbind_params_insert_domain(domain);
+}
+
+isl::multi_pw_aff pw_multi_aff::union_add(const isl::multi_pw_aff &mpa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).union_add(mpa2);
+}
+
+isl::multi_union_pw_aff pw_multi_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_pw_aff(*this).union_add(mupa2);
+}
+
+isl::pw_multi_aff pw_multi_aff::union_add(isl::pw_multi_aff pma2) const
+{
+  if (!ptr || pma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_union_add(copy(), pma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff pw_multi_aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::pw_multi_aff pw_multi_aff::union_add(const isl::multi_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::union_add(const isl::pw_aff &pma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::pw_multi_aff(pma2));
+}
+
+isl::pw_multi_aff pw_multi_aff::zero(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_zero(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_pw_multi_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::pw_multi_aff_list
+pw_multi_aff_list manage(__isl_take isl_pw_multi_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return pw_multi_aff_list(ptr);
+}
+pw_multi_aff_list manage_copy(__isl_keep isl_pw_multi_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_pw_multi_aff_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return pw_multi_aff_list(ptr);
+}
+
+pw_multi_aff_list::pw_multi_aff_list()
+    : ptr(nullptr) {}
+
+pw_multi_aff_list::pw_multi_aff_list(const pw_multi_aff_list &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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 saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_multi_aff_list::pw_multi_aff_list(isl::pw_multi_aff el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_from_pw_multi_aff(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+pw_multi_aff_list &pw_multi_aff_list::operator=(pw_multi_aff_list obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+pw_multi_aff_list::~pw_multi_aff_list() {
+  if (ptr)
+    isl_pw_multi_aff_list_free(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_pw_multi_aff_list *pw_multi_aff_list::get() const {
+  return 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 pw_multi_aff_list::is_null() const {
+  return ptr == nullptr;
+}
+
+isl::ctx pw_multi_aff_list::ctx() const {
+  return isl::ctx(isl_pw_multi_aff_list_get_ctx(ptr));
+}
+
+isl::pw_multi_aff_list pw_multi_aff_list::add(isl::pw_multi_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff pw_multi_aff_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::pw_multi_aff_list pw_multi_aff_list::clear() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff_list pw_multi_aff_list::concat(isl::pw_multi_aff_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff_list pw_multi_aff_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void pw_multi_aff_list::foreach(const std::function<void(isl::pw_multi_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::pw_multi_aff)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_pw_multi_aff_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::pw_multi_aff_list pw_multi_aff_list::insert(unsigned int pos, isl::pw_multi_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned pw_multi_aff_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_pw_multi_aff_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const pw_multi_aff_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_pw_multi_aff_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_pw_multi_aff_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule
+schedule manage(__isl_take isl_schedule *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return schedule(ptr);
+}
+schedule manage_copy(__isl_keep isl_schedule *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_schedule_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return schedule(ptr);
+}
+
+schedule::schedule()
+    : ptr(nullptr) {}
+
+schedule::schedule(const schedule &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+schedule::schedule(__isl_take isl_schedule *ptr)
+    : ptr(ptr) {}
+
+schedule::schedule(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+schedule &schedule::operator=(schedule obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+schedule::~schedule() {
+  if (ptr)
+    isl_schedule_free(ptr);
+}
+
+__isl_give isl_schedule *schedule::copy() const & {
+  return isl_schedule_copy(ptr);
+}
+
+__isl_keep isl_schedule *schedule::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule *schedule::release() {
+  isl_schedule *tmp = ptr;
+  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));
+}
+
+isl::union_set schedule::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_get_domain(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set schedule::get_domain() const
+{
+  return domain();
+}
+
+isl::schedule schedule::from_domain(isl::union_set domain)
+{
+  if (domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_from_domain(domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule::map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_get_map(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule::get_map() const
+{
+  return map();
+}
+
+isl::schedule schedule::pullback(isl::union_pw_multi_aff upma) const
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_pullback_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule::root() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_get_root(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule::get_root() const
+{
+  return root();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_constraints
+schedule_constraints manage(__isl_take isl_schedule_constraints *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return schedule_constraints(ptr);
+}
+schedule_constraints manage_copy(__isl_keep isl_schedule_constraints *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_constraints_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_schedule_constraints_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return schedule_constraints(ptr);
+}
+
+schedule_constraints::schedule_constraints()
+    : ptr(nullptr) {}
+
+schedule_constraints::schedule_constraints(const schedule_constraints &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_constraints_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+schedule_constraints::schedule_constraints(__isl_take isl_schedule_constraints *ptr)
+    : ptr(ptr) {}
+
+schedule_constraints::schedule_constraints(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+schedule_constraints &schedule_constraints::operator=(schedule_constraints obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+schedule_constraints::~schedule_constraints() {
+  if (ptr)
+    isl_schedule_constraints_free(ptr);
+}
+
+__isl_give isl_schedule_constraints *schedule_constraints::copy() const & {
+  return isl_schedule_constraints_copy(ptr);
+}
+
+__isl_keep isl_schedule_constraints *schedule_constraints::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_constraints *schedule_constraints::release() {
+  isl_schedule_constraints *tmp = ptr;
+  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));
+}
+
+isl::union_map schedule_constraints::coincidence() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_coincidence(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_coincidence() const
+{
+  return coincidence();
+}
+
+isl::schedule schedule_constraints::compute_schedule() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_compute_schedule(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::conditional_validity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_conditional_validity(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_conditional_validity() const
+{
+  return conditional_validity();
+}
+
+isl::union_map schedule_constraints::conditional_validity_condition() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_conditional_validity_condition(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_conditional_validity_condition() const
+{
+  return conditional_validity_condition();
+}
+
+isl::set schedule_constraints::context() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_context(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set schedule_constraints::get_context() const
+{
+  return context();
+}
+
+isl::union_set schedule_constraints::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_domain(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set schedule_constraints::get_domain() const
+{
+  return domain();
+}
+
+isl::schedule_constraints schedule_constraints::on_domain(isl::union_set domain)
+{
+  if (domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_on_domain(domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::proximity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_proximity(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr || coincidence.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_set_coincidence(copy(), coincidence.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_constraints schedule_constraints::set_conditional_validity(isl::union_map condition, isl::union_map validity) const
+{
+  if (!ptr || condition.is_null() || validity.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_set_conditional_validity(copy(), condition.release(), validity.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_constraints schedule_constraints::set_context(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_set_context(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_constraints schedule_constraints::set_proximity(isl::union_map proximity) const
+{
+  if (!ptr || proximity.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_set_proximity(copy(), proximity.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_constraints schedule_constraints::set_validity(isl::union_map validity) const
+{
+  if (!ptr || validity.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_set_validity(copy(), validity.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::validity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_constraints_get_validity(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_constraints::get_validity() const
+{
+  return validity();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_constraints &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_constraints_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_constraints_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::schedule_node
+schedule_node manage(__isl_take isl_schedule_node *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return schedule_node(ptr);
+}
+schedule_node manage_copy(__isl_keep isl_schedule_node *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_schedule_node_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return schedule_node(ptr);
+}
+
+schedule_node::schedule_node()
+    : ptr(nullptr) {}
+
+schedule_node::schedule_node(const schedule_node &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::copy() const & {
+  return isl_schedule_node_copy(ptr);
+}
+
+__isl_keep isl_schedule_node *schedule_node::get() const {
+  return ptr;
+}
+
+__isl_give isl_schedule_node *schedule_node::release() {
+  isl_schedule_node *tmp = ptr;
+  ptr = nullptr;
+  return tmp;
+}
+
+bool schedule_node::is_null() const {
+  return ptr == nullptr;
+}
+
+template <typename T, typename>
+bool schedule_node::isa_type(T subtype) const
+{
+  if (is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl_schedule_node_get_type(get()) == subtype;
+}
+template <class T>
+bool schedule_node::isa() const
+{
+  return isa_type<decltype(T::type)>(T::type);
+}
+template <class T>
+T schedule_node::as() const
+{
+ if (!isa<T>())
+    exception::throw_invalid("not an object of the requested subtype", __FILE__, __LINE__);
+  return T(copy());
+}
+
+isl::ctx schedule_node::ctx() const {
+  return isl::ctx(isl_schedule_node_get_ctx(ptr));
+}
+
+isl::schedule_node schedule_node::ancestor(int generation) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_ancestor(copy(), generation);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned schedule_node::ancestor_child_position(const isl::schedule_node &ancestor) const
+{
+  if (!ptr || ancestor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_ancestor_child_position(get(), ancestor.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+unsigned schedule_node::get_ancestor_child_position(const isl::schedule_node &ancestor) const
+{
+  return ancestor_child_position(ancestor);
+}
+
+isl::schedule_node schedule_node::child(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_child(copy(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned schedule_node::child_position() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_child_position(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+unsigned schedule_node::get_child_position() const
+{
+  return child_position();
+}
+
+bool schedule_node::every_descendant(const std::function<bool(isl::schedule_node)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct test_data {
+    std::function<bool(isl::schedule_node)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      auto ret = (data->func)(manage_copy(arg_0));
+      return ret ? isl_bool_true : isl_bool_false;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_bool_error;
+    }
+  };
+  auto res = isl_schedule_node_every_descendant(get(), test_lambda, &test_data);
+  if (test_data.eptr)
+    std::rethrow_exception(test_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::schedule_node schedule_node::first_child() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_first_child(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void schedule_node::foreach_ancestor_top_down(const std::function<void(isl::schedule_node)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::schedule_node)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage_copy(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_schedule_node_foreach_ancestor_top_down(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+void schedule_node::foreach_descendant_top_down(const std::function<bool(isl::schedule_node)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<bool(isl::schedule_node)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      auto ret = (data->func)(manage_copy(arg_0));
+      return ret ? isl_bool_true : isl_bool_false;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_bool_error;
+    }
+  };
+  auto res = isl_schedule_node_foreach_descendant_top_down(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::schedule_node schedule_node::from_domain(isl::union_set domain)
+{
+  if (domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_from_domain(domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::from_extension(isl::union_map extension)
+{
+  if (extension.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = extension.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_from_extension(extension.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::graft_after(isl::schedule_node graft) const
+{
+  if (!ptr || graft.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_graft_after(copy(), graft.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::graft_before(isl::schedule_node graft) const
+{
+  if (!ptr || graft.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_graft_before(copy(), graft.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool schedule_node::has_children() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_has_children(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool schedule_node::has_next_sibling() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_has_next_sibling(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool schedule_node::has_parent() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_has_parent(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool schedule_node::has_previous_sibling() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_has_previous_sibling(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::schedule_node schedule_node::insert_context(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_context(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_filter(isl::union_set filter) const
+{
+  if (!ptr || filter.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_filter(copy(), filter.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_guard(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_guard(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_mark(isl::id mark) const
+{
+  if (!ptr || mark.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_mark(copy(), mark.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_mark(const std::string &mark) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->insert_mark(isl::id(ctx(), mark));
+}
+
+isl::schedule_node schedule_node::insert_partial_schedule(isl::multi_union_pw_aff schedule) const
+{
+  if (!ptr || schedule.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_partial_schedule(copy(), schedule.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_sequence(isl::union_set_list filters) const
+{
+  if (!ptr || filters.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_sequence(copy(), filters.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::insert_set(isl::union_set_list filters) const
+{
+  if (!ptr || filters.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_insert_set(copy(), filters.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool schedule_node::is_equal(const isl::schedule_node &node2) const
+{
+  if (!ptr || node2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_is_equal(get(), node2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool schedule_node::is_subtree_anchored() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_is_subtree_anchored(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::schedule_node schedule_node::map_descendant_bottom_up(const std::function<isl::schedule_node(isl::schedule_node)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<isl::schedule_node(isl::schedule_node)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      auto ret = (data->func)(manage(arg_0));
+      return ret.release();
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return NULL;
+    }
+  };
+  auto res = isl_schedule_node_map_descendant_bottom_up(copy(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned schedule_node::n_children() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_n_children(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::schedule_node schedule_node::next_sibling() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_next_sibling(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::order_after(isl::union_set filter) const
+{
+  if (!ptr || filter.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_order_after(copy(), filter.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::order_before(isl::union_set filter) const
+{
+  if (!ptr || filter.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_order_before(copy(), filter.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::parent() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_parent(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff schedule_node::prefix_schedule_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff schedule_node::get_prefix_schedule_multi_union_pw_aff() const
+{
+  return prefix_schedule_multi_union_pw_aff();
+}
+
+isl::union_map schedule_node::prefix_schedule_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_prefix_schedule_union_map(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_node::get_prefix_schedule_union_map() const
+{
+  return prefix_schedule_union_map();
+}
+
+isl::union_pw_multi_aff schedule_node::prefix_schedule_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff schedule_node::get_prefix_schedule_union_pw_multi_aff() const
+{
+  return prefix_schedule_union_pw_multi_aff();
+}
+
+isl::schedule_node schedule_node::previous_sibling() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_previous_sibling(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::root() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_root(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule schedule_node::schedule() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_schedule(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule schedule_node::get_schedule() const
+{
+  return schedule();
+}
+
+isl::schedule_node schedule_node::shared_ancestor(const isl::schedule_node &node2) const
+{
+  if (!ptr || node2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_shared_ancestor(get(), node2.get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::schedule_node schedule_node::get_shared_ancestor(const isl::schedule_node &node2) const
+{
+  return shared_ancestor(node2);
+}
+
+unsigned schedule_node::tree_depth() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_get_tree_depth(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+unsigned schedule_node::get_tree_depth() const
+{
+  return tree_depth();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_get_ast_build_options(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set schedule_node_band::get_ast_build_options() const
+{
+  return ast_build_options();
+}
+
+isl::set schedule_node_band::ast_isolate_option() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_get_ast_isolate_option(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set schedule_node_band::get_ast_isolate_option() const
+{
+  return ast_isolate_option();
+}
+
+bool schedule_node_band::member_get_coincident(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_get_coincident(get(), pos);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+schedule_node_band schedule_node_band::member_set_coincident(int pos, int coincident) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_set_coincident(copy(), pos, coincident);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::mod(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_mod(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+unsigned schedule_node_band::n_member() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_n_member(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_union_pw_aff schedule_node_band::partial_schedule() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_get_partial_schedule(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff schedule_node_band::get_partial_schedule() const
+{
+  return partial_schedule();
+}
+
+bool schedule_node_band::permutable() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_get_permutable(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool schedule_node_band::get_permutable() const
+{
+  return permutable();
+}
+
+schedule_node_band schedule_node_band::scale(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_scale(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::scale_down(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_scale_down(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::set_ast_build_options(isl::union_set options) const
+{
+  if (!ptr || options.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_set_ast_build_options(copy(), options.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::set_permutable(int permutable) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_set_permutable(copy(), permutable);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::shift(isl::multi_union_pw_aff shift) const
+{
+  if (!ptr || shift.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_shift(copy(), shift.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::split(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_split(copy(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::tile(isl::multi_val sizes) const
+{
+  if (!ptr || sizes.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_tile(copy(), sizes.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_default(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_default);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_atomic(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_atomic);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_unroll(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_unroll);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+schedule_node_band schedule_node_band::member_set_ast_loop_separate(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_band_member_set_ast_loop_type(copy(), pos, isl_ast_loop_separate);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res).as<schedule_node_band>();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_band &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_context_get_context(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set schedule_node_context::get_context() const
+{
+  return context();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_context &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_domain_get_domain(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set schedule_node_domain::get_domain() const
+{
+  return domain();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_domain &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_expansion_get_contraction(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff schedule_node_expansion::get_contraction() const
+{
+  return contraction();
+}
+
+isl::union_map schedule_node_expansion::expansion() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_expansion_get_expansion(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_node_expansion::get_expansion() const
+{
+  return expansion();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_expansion &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_extension_get_extension(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map schedule_node_extension::get_extension() const
+{
+  return extension();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_extension &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_filter_get_filter(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set schedule_node_filter::get_filter() const
+{
+  return filter();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_filter &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_schedule_node_guard_get_guard(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set schedule_node_guard::get_guard() const
+{
+  return guard();
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_guard &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const schedule_node_mark &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_schedule_node_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_schedule_node_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::set
+set manage(__isl_take isl_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return set(ptr);
+}
+set manage_copy(__isl_keep isl_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_set_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_set_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return set(ptr);
+}
+
+set::set()
+    : ptr(nullptr) {}
+
+set::set(const set &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_set_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+set::set(__isl_take isl_set *ptr)
+    : ptr(ptr) {}
+
+set::set(isl::basic_set bset)
+{
+  if (bset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = bset.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_from_basic_set(bset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+set::set(isl::point pnt)
+{
+  if (pnt.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pnt.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_from_point(pnt.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+set::set(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+set &set::operator=(set obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+set::~set() {
+  if (ptr)
+    isl_set_free(ptr);
+}
+
+__isl_give isl_set *set::copy() const & {
+  return isl_set_copy(ptr);
+}
+
+__isl_keep isl_set *set::get() const {
+  return ptr;
+}
+
+__isl_give isl_set *set::release() {
+  isl_set *tmp = ptr;
+  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));
+}
+
+isl::basic_set set::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::apply(isl::map map) const
+{
+  if (!ptr || map.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_apply(copy(), map.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::apply(const isl::union_map &umap) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).apply(umap);
+}
+
+isl::set set::apply(const isl::basic_map &map) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->apply(isl::map(map));
+}
+
+isl::pw_multi_aff set::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_as_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).as_set();
+}
+
+isl::set set::bind(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_bind(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::complement() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_complement(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).compute_divs();
+}
+
+isl::set set::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val set::dim_max_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_dim_max_val(copy(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val set::dim_min_val(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_dim_min_val(copy(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::empty(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_empty(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool set::every_set(const std::function<bool(isl::set)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).every_set(test);
+}
+
+isl::set set::extract_set(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).extract_set(space);
+}
+
+isl::set set::flatten() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_flatten(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void set::foreach_basic_set(const std::function<void(isl::basic_set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::basic_set)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_set_foreach_basic_set(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+void set::foreach_point(const std::function<void(isl::point)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::point)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_point *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_set_foreach_point(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+void set::foreach_set(const std::function<void(isl::set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).foreach_set(fn);
+}
+
+isl::set set::gist(isl::set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::gist(const isl::union_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).gist(context);
+}
+
+isl::set set::gist(const isl::basic_set &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::set set::gist(const isl::point &context) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gist(isl::set(context));
+}
+
+isl::union_set set::gist_params(const isl::set &set) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).gist_params(set);
+}
+
+isl::map set::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_identity(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_aff set::indicator_function() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_indicator_function(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map set::insert_domain(isl::space domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::intersect(isl::set set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_intersect(copy(), set2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::intersect(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).intersect(uset2);
+}
+
+isl::set set::intersect(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect(isl::set(set2));
+}
+
+isl::set set::intersect(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->intersect(isl::set(set2));
+}
+
+isl::set set::intersect_params(isl::set params) const
+{
+  if (!ptr || params.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_intersect_params(copy(), params.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool set::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_involves_locals(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_disjoint(const isl::set &set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_disjoint(get(), set2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_disjoint(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).is_disjoint(uset2);
+}
+
+bool set::is_disjoint(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_disjoint(isl::set(set2));
+}
+
+bool set::is_disjoint(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_disjoint(isl::set(set2));
+}
+
+bool set::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_equal(const isl::set &set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_equal(get(), set2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_equal(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).is_equal(uset2);
+}
+
+bool set::is_equal(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_equal(isl::set(set2));
+}
+
+bool set::is_equal(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_equal(isl::set(set2));
+}
+
+bool set::is_singleton() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_singleton(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_strict_subset(const isl::set &set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_strict_subset(get(), set2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_strict_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).is_strict_subset(uset2);
+}
+
+bool set::is_strict_subset(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_strict_subset(isl::set(set2));
+}
+
+bool set::is_strict_subset(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_strict_subset(isl::set(set2));
+}
+
+bool set::is_subset(const isl::set &set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_subset(get(), set2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::is_subset(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).is_subset(uset2);
+}
+
+bool set::is_subset(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_subset(isl::set(set2));
+}
+
+bool set::is_subset(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_subset(isl::set(set2));
+}
+
+bool set::is_wrapping() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_is_wrapping(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool set::isa_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).isa_set();
+}
+
+isl::set set::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff set::lexmax_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lexmax_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff set::lexmin_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lexmin_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::lower_bound(isl::multi_pw_aff lower) const
+{
+  if (!ptr || lower.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lower_bound_multi_pw_aff(copy(), lower.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::lower_bound(isl::multi_val lower) const
+{
+  if (!ptr || lower.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_lower_bound_multi_val(copy(), lower.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff set::max_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_max_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val set::max_val(const isl::aff &obj) const
+{
+  if (!ptr || obj.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_max_val(get(), obj.get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff set::min_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_min_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val set::min_val(const isl::aff &obj) const
+{
+  if (!ptr || obj.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_min_val(get(), obj.get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val set::plain_multi_val_if_fixed() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_get_plain_multi_val_if_fixed(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val set::get_plain_multi_val_if_fixed() const
+{
+  return plain_multi_val_if_fixed();
+}
+
+isl::basic_set set::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_polyhedral_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::preimage(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_preimage_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::preimage(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_preimage_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::preimage(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_preimage_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::preimage(const isl::union_pw_multi_aff &upma) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).preimage(upma);
+}
+
+isl::set set::product(isl::set set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_product(copy(), set2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_project_out_all_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::project_out_param(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_project_out_param_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::project_out_param(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->project_out_param(isl::id(ctx(), id));
+}
+
+isl::set set::project_out_param(isl::id_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_project_out_param_id_list(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff set::pw_multi_aff_on_domain(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_pw_multi_aff_on_domain_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_set set::sample() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_sample(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::point set::sample_point() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_sample_point(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::fixed_box set::simple_fixed_box_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_get_simple_fixed_box_hull(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::fixed_box set::get_simple_fixed_box_hull() const
+{
+  return simple_fixed_box_hull();
+}
+
+isl::space set::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space set::get_space() const
+{
+  return space();
+}
+
+isl::val set::stride(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_get_stride(get(), pos);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val set::get_stride(int pos) const
+{
+  return stride(pos);
+}
+
+isl::set set::subtract(isl::set set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_subtract(copy(), set2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::subtract(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).subtract(uset2);
+}
+
+isl::set set::subtract(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract(isl::set(set2));
+}
+
+isl::set set::subtract(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->subtract(isl::set(set2));
+}
+
+isl::union_set_list set::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).to_list();
+}
+
+isl::union_set set::to_union_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_to_union_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map set::translation() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_translation(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::unbind_params(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_unbind_params(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map set::unbind_params_insert_domain(isl::multi_id domain) const
+{
+  if (!ptr || domain.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_unbind_params_insert_domain(copy(), domain.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::unite(isl::set set2) const
+{
+  if (!ptr || set2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_union(copy(), set2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set set::unite(const isl::union_set &uset2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_set(*this).unite(uset2);
+}
+
+isl::set set::unite(const isl::basic_set &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->unite(isl::set(set2));
+}
+
+isl::set set::unite(const isl::point &set2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->unite(isl::set(set2));
+}
+
+isl::set set::universe(isl::space space)
+{
+  if (space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = space.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_universe(space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::basic_set set::unshifted_simple_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_unshifted_simple_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map set::unwrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_unwrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::upper_bound(isl::multi_pw_aff upper) const
+{
+  if (!ptr || upper.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_upper_bound_multi_pw_aff(copy(), upper.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set set::upper_bound(isl::multi_val upper) const
+{
+  if (!ptr || upper.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_set_upper_bound_multi_val(copy(), upper.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const set &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_set_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_set_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::space
+space manage(__isl_take isl_space *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return space(ptr);
+}
+space manage_copy(__isl_keep isl_space *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_space_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_space_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return space(ptr);
+}
+
+space::space()
+    : ptr(nullptr) {}
+
+space::space(const space &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_space_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+space::space(__isl_take isl_space *ptr)
+    : ptr(ptr) {}
+
+space &space::operator=(space obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+space::~space() {
+  if (ptr)
+    isl_space_free(ptr);
+}
+
+__isl_give isl_space *space::copy() const & {
+  return isl_space_copy(ptr);
+}
+
+__isl_keep isl_space *space::get() const {
+  return ptr;
+}
+
+__isl_give isl_space *space::release() {
+  isl_space *tmp = ptr;
+  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));
+}
+
+isl::space space::add_named_tuple(isl::id tuple_id, unsigned int dim) const
+{
+  if (!ptr || tuple_id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_add_named_tuple_id_ui(copy(), tuple_id.release(), dim);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add_named_tuple(isl::id(ctx(), tuple_id), dim);
+}
+
+isl::space space::add_unnamed_tuple(unsigned int dim) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_add_unnamed_tuple_ui(copy(), dim);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::curry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_curry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff space::domain_map_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_domain_map_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff space::domain_map_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_domain_map_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id space::domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_get_domain_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id space::get_domain_tuple_id() const
+{
+  return domain_tuple_id();
+}
+
+isl::space space::flatten_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_flatten_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::flatten_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_flatten_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool space::has_domain_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_has_domain_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool space::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_has_range_tuple_id(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::multi_aff space::identity_multi_aff_on_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_identity_multi_aff_on_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff space::identity_multi_pw_aff_on_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_identity_multi_pw_aff_on_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff space::identity_pw_multi_aff_on_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_identity_pw_multi_aff_on_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool space::is_equal(const isl::space &space2) const
+{
+  if (!ptr || space2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_is_equal(get(), space2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool space::is_wrapping() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_is_wrapping(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::space space::map_from_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_map_from_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff space::multi_aff(isl::aff_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_aff(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff space::multi_aff_on_domain(isl::multi_val mv) const
+{
+  if (!ptr || mv.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_aff_on_domain_multi_val(copy(), mv.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_id space::multi_id(isl::id_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_id(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff space::multi_pw_aff(isl::pw_aff_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_pw_aff(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff space::multi_union_pw_aff(isl::union_pw_aff_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_union_pw_aff(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val space::multi_val(isl::val_list list) const
+{
+  if (!ptr || list.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_multi_val(copy(), list.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::product(isl::space right) const
+{
+  if (!ptr || right.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_product(copy(), right.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff space::range_map_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_range_map_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff space::range_map_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_range_map_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::range_reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_range_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id space::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_get_range_tuple_id(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::id space::get_range_tuple_id() const
+{
+  return range_tuple_id();
+}
+
+isl::space space::reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::set_domain_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_set_domain_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::set_domain_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_domain_tuple(isl::id(ctx(), id));
+}
+
+isl::space space::set_range_tuple(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_set_range_tuple_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::set_range_tuple(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+isl::space space::uncurry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_uncurry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::unit(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_unit(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map space::universe_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_universe_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set space::universe_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_universe_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::unwrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_unwrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space space::wrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_wrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::aff space::zero_aff_on_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_zero_aff_on_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_aff space::zero_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_zero_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_pw_aff space::zero_multi_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_zero_multi_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff space::zero_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_zero_multi_union_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_val space::zero_multi_val() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_space_zero_multi_val(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const space &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_space_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_space_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_access_info
+union_access_info manage(__isl_take isl_union_access_info *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_access_info(ptr);
+}
+union_access_info manage_copy(__isl_keep isl_union_access_info *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_access_info_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_access_info_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_access_info_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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)
+{
+  if (sink.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = sink.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_from_sink(sink.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_access_info &union_access_info::operator=(union_access_info obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_access_info::~union_access_info() {
+  if (ptr)
+    isl_union_access_info_free(ptr);
+}
+
+__isl_give isl_union_access_info *union_access_info::copy() const & {
+  return isl_union_access_info_copy(ptr);
+}
+
+__isl_keep isl_union_access_info *union_access_info::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_access_info *union_access_info::release() {
+  isl_union_access_info *tmp = ptr;
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_compute_flow(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_access_info union_access_info::set_kill(isl::union_map kill) const
+{
+  if (!ptr || kill.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_set_kill(copy(), kill.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_access_info union_access_info::set_may_source(isl::union_map may_source) const
+{
+  if (!ptr || may_source.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_set_may_source(copy(), may_source.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_access_info union_access_info::set_must_source(isl::union_map must_source) const
+{
+  if (!ptr || must_source.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_set_must_source(copy(), must_source.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_access_info union_access_info::set_schedule(isl::schedule schedule) const
+{
+  if (!ptr || schedule.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_set_schedule(copy(), schedule.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_access_info union_access_info::set_schedule_map(isl::union_map schedule_map) const
+{
+  if (!ptr || schedule_map.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_access_info_set_schedule_map(copy(), schedule_map.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_access_info &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_access_info_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_access_info_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_flow
+union_flow manage(__isl_take isl_union_flow *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_flow(ptr);
+}
+union_flow manage_copy(__isl_keep isl_union_flow *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_flow_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_flow_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return union_flow(ptr);
+}
+
+union_flow::union_flow()
+    : ptr(nullptr) {}
+
+union_flow::union_flow(const union_flow &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_flow_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::copy() const & {
+  return isl_union_flow_copy(ptr);
+}
+
+__isl_keep isl_union_flow *union_flow::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_flow *union_flow::release() {
+  isl_union_flow *tmp = ptr;
+  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::full_may_dependence() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_full_may_dependence(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_flow::get_full_may_dependence() const
+{
+  return full_may_dependence();
+}
+
+isl::union_map union_flow::full_must_dependence() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_full_must_dependence(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_flow::get_full_must_dependence() const
+{
+  return full_must_dependence();
+}
+
+isl::union_map union_flow::may_dependence() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_may_dependence(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_flow::get_may_dependence() const
+{
+  return may_dependence();
+}
+
+isl::union_map union_flow::may_no_source() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_may_no_source(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_flow::get_may_no_source() const
+{
+  return may_no_source();
+}
+
+isl::union_map union_flow::must_dependence() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_must_dependence(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_flow::get_must_dependence() const
+{
+  return must_dependence();
+}
+
+isl::union_map union_flow::must_no_source() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_flow_get_must_no_source(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_flow_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_flow_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_map
+union_map manage(__isl_take isl_union_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_map(ptr);
+}
+union_map manage_copy(__isl_keep isl_union_map *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_map_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_map_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return union_map(ptr);
+}
+
+union_map::union_map()
+    : ptr(nullptr) {}
+
+union_map::union_map(const union_map &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_map_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+union_map::union_map(__isl_take isl_union_map *ptr)
+    : ptr(ptr) {}
+
+union_map::union_map(isl::basic_map bmap)
+{
+  if (bmap.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = bmap.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_basic_map(bmap.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_map::union_map(isl::map map)
+{
+  if (map.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = map.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_map(map.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_map::union_map(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_map &union_map::operator=(union_map obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_map::~union_map() {
+  if (ptr)
+    isl_union_map_free(ptr);
+}
+
+__isl_give isl_union_map *union_map::copy() const & {
+  return isl_union_map_copy(ptr);
+}
+
+__isl_keep isl_union_map *union_map::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_map *union_map::release() {
+  isl_union_map *tmp = ptr;
+  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));
+}
+
+isl::union_map union_map::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::apply_domain(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_apply_domain(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::apply_range(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_apply_range(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::map union_map::as_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_as_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff union_map::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_as_multi_union_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_map::as_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_as_union_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_map::bind_range(isl::multi_id tuple) const
+{
+  if (!ptr || tuple.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_bind_range(copy(), tuple.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_compute_divs(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::curry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_curry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_map::deltas() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_deltas(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_map::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::domain_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::domain_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::domain_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_map::domain_map_union_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain_map_union_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::domain_product(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_domain_product(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::empty(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_empty_ctx(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::eq_at(isl::multi_union_pw_aff mupa) const
+{
+  if (!ptr || mupa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_eq_at_multi_union_pw_aff(copy(), mupa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_map::every_map(const std::function<bool(isl::map)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct test_data {
+    std::function<bool(isl::map)> func;
+    std::exception_ptr eptr;
+  } test_data = { test };
+  auto test_lambda = (isl_map *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct test_data *>(arg_1);
+    ISL_CPP_TRY {
+      auto ret = (data->func)(manage_copy(arg_0));
+      return ret ? isl_bool_true : isl_bool_false;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_bool_error;
+    }
+  };
+  auto res = isl_union_map_every_map(get(), test_lambda, &test_data);
+  if (test_data.eptr)
+    std::rethrow_exception(test_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::map union_map::extract_map(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_extract_map(get(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::fixed_power(isl::val exp) const
+{
+  if (!ptr || exp.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_fixed_power_val(copy(), exp.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::fixed_power(long exp) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->fixed_power(isl::val(ctx(), exp));
+}
+
+void union_map::foreach_map(const std::function<void(isl::map)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::map)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_map *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_union_map_foreach_map(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::union_map union_map::from(isl::multi_union_pw_aff mupa)
+{
+  if (mupa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = mupa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_multi_union_pw_aff(mupa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::from(isl::union_pw_multi_aff upma)
+{
+  if (upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = upma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_union_pw_multi_aff(upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::from_domain(isl::union_set uset)
+{
+  if (uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = uset.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_domain(uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::from_domain_and_range(isl::union_set domain, isl::union_set range)
+{
+  if (domain.is_null() || range.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = domain.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_domain_and_range(domain.release(), range.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::from_range(isl::union_set uset)
+{
+  if (uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = uset.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_from_range(uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::gist(isl::union_map context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::gist_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_gist_domain(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::gist_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_gist_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::gist_range(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_gist_range(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_domain(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_domain_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_domain_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_domain_factor_domain(isl::union_map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_domain_factor_domain(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_domain_factor_range(isl::union_map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_domain_factor_range(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_range(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_range_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_range(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_range_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_range_factor_domain(isl::union_map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_range_factor_domain(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::intersect_range_factor_range(isl::union_map factor) const
+{
+  if (!ptr || factor.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_intersect_range_factor_range(copy(), factor.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_map::is_bijective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_bijective(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_disjoint(const isl::union_map &umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_disjoint(get(), umap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_equal(const isl::union_map &umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_equal(get(), umap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_injective() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_injective(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_single_valued() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_single_valued(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_strict_subset(const isl::union_map &umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_strict_subset(get(), umap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::is_subset(const isl::union_map &umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_is_subset(get(), umap2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_map::isa_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_isa_map(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::union_map union_map::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_polyhedral_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_domain(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_domain_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_domain(isl::multi_pw_aff mpa) const
+{
+  if (!ptr || mpa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_domain_multi_pw_aff(copy(), mpa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_domain(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_domain_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_domain(isl::union_pw_multi_aff upma) const
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_domain_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_range(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_range_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_range(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_range_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::preimage_range(isl::union_pw_multi_aff upma) const
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_preimage_range_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::product(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_product(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::project_out_all_params() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_project_out_all_params(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_map::range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::range_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::range_product(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range_product(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::range_reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_range_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::reverse() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_reverse(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_map::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_map::get_space() const
+{
+  return space();
+}
+
+isl::union_map union_map::subtract(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_subtract(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::subtract_domain(isl::union_set dom) const
+{
+  if (!ptr || dom.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_subtract_domain(copy(), dom.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::subtract_range(isl::union_set dom) const
+{
+  if (!ptr || dom.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_subtract_range(copy(), dom.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::uncurry() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_uncurry(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::unite(isl::union_map umap2) const
+{
+  if (!ptr || umap2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_union(copy(), umap2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::universe() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_universe(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_map::wrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_wrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_map::zip() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_map_zip(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_map &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_map_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_map_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_pw_aff
+union_pw_aff manage(__isl_take isl_union_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_pw_aff(ptr);
+}
+union_pw_aff manage_copy(__isl_keep isl_union_pw_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_pw_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+union_pw_aff::union_pw_aff(__isl_take isl_union_pw_aff *ptr)
+    : ptr(ptr) {}
+
+union_pw_aff::union_pw_aff(isl::aff aff)
+{
+  if (aff.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = aff.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_from_aff(aff.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_aff::union_pw_aff(isl::pw_aff pa)
+{
+  if (pa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_from_pw_aff(pa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_aff::union_pw_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_aff &union_pw_aff::operator=(union_pw_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_pw_aff::~union_pw_aff() {
+  if (ptr)
+    isl_union_pw_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_aff *union_pw_aff::copy() const & {
+  return isl_union_pw_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_aff *union_pw_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_aff *union_pw_aff::release() {
+  isl_union_pw_aff *tmp = ptr;
+  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));
+}
+
+isl::multi_union_pw_aff union_pw_aff::add(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).add(multi2);
+}
+
+isl::union_pw_aff union_pw_aff::add(isl::union_pw_aff upa2) const
+{
+  if (!ptr || upa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_add(copy(), upa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_aff::add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).add(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::add(const isl::aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::add(const isl::pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_multi_aff union_pw_aff::apply(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).apply(upma2);
+}
+
+isl::multi_union_pw_aff union_pw_aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_multi_union_pw_aff();
+}
+
+isl::pw_multi_aff union_pw_aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_pw_multi_aff();
+}
+
+isl::union_map union_pw_aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).as_union_map();
+}
+
+isl::union_pw_aff union_pw_aff::at(int pos) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).at(pos);
+}
+
+isl::union_set union_pw_aff::bind(const isl::multi_id &tuple) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).bind(tuple);
+}
+
+isl::union_set union_pw_aff::bind(isl::id id) const
+{
+  if (!ptr || id.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_bind_id(copy(), id.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_pw_aff::bind(const std::string &id) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->bind(isl::id(ctx(), id));
+}
+
+isl::union_pw_aff union_pw_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_pw_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff union_pw_aff::extract_pw_multi_aff(const isl::space &space) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).extract_pw_multi_aff(space);
+}
+
+isl::multi_union_pw_aff union_pw_aff::flat_range_product(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).flat_range_product(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::gist(isl::union_set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_pw_aff::has_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).has_range_tuple_id();
+}
+
+isl::union_pw_aff union_pw_aff::intersect_domain(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_intersect_domain_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff::intersect_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_intersect_domain_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff::intersect_domain_wrapped_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_intersect_domain_wrapped_domain(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff::intersect_domain_wrapped_range(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_intersect_domain_wrapped_range(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_pw_aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).involves_locals();
+}
+
+bool union_pw_aff::involves_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).involves_nan();
+}
+
+bool union_pw_aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).isa_pw_multi_aff();
+}
+
+isl::union_pw_aff_list union_pw_aff::list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).list();
+}
+
+isl::multi_union_pw_aff union_pw_aff::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).neg();
+}
+
+bool union_pw_aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).plain_is_empty();
+}
+
+bool union_pw_aff::plain_is_equal(const isl::multi_union_pw_aff &multi2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).plain_is_equal(multi2);
+}
+
+isl::union_pw_multi_aff union_pw_aff::preimage_domain_wrapped_domain(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_pullback_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).range_factor_domain();
+}
+
+isl::union_pw_multi_aff union_pw_aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).range_product(upma2);
+}
+
+isl::id union_pw_aff::range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).range_tuple_id();
+}
+
+isl::multi_union_pw_aff union_pw_aff::reset_range_tuple_id() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).reset_range_tuple_id();
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).scale(mv);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(const isl::val &v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).scale(v);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale(isl::val(ctx(), v));
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale_down(const isl::multi_val &mv) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).scale_down(v);
+}
+
+isl::multi_union_pw_aff union_pw_aff::scale_down(long v) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->scale_down(isl::val(ctx(), v));
+}
+
+isl::multi_union_pw_aff union_pw_aff::set_at(int pos, const isl::union_pw_aff &el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->set_range_tuple(isl::id(ctx(), id));
+}
+
+unsigned union_pw_aff::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).size();
+}
+
+isl::space union_pw_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::multi_union_pw_aff(*this).sub(multi2);
+}
+
+isl::union_pw_aff union_pw_aff::sub(isl::union_pw_aff upa2) const
+{
+  if (!ptr || upa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_sub(copy(), upa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_aff::sub(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).sub(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::sub(const isl::aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::sub(const isl::pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::subtract_domain(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_subtract_domain_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff::subtract_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_subtract_domain_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff_list union_pw_aff::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff union_pw_aff::union_add(const isl::multi_union_pw_aff &mupa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  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
+{
+  if (!ptr || upa2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_union_add(copy(), upa2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_aff::union_add(const isl::union_pw_multi_aff &upma2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return isl::union_pw_multi_aff(*this).union_add(upma2);
+}
+
+isl::union_pw_aff union_pw_aff::union_add(const isl::aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::union_pw_aff(upa2));
+}
+
+isl::union_pw_aff union_pw_aff::union_add(const isl::pw_aff &upa2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->union_add(isl::union_pw_aff(upa2));
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_pw_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_pw_aff_list(ptr);
+}
+union_pw_aff_list manage_copy(__isl_keep isl_union_pw_aff_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_pw_aff_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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 saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_aff_list::union_pw_aff_list(isl::union_pw_aff el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_from_union_pw_aff(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_union_pw_aff_list_free(ptr);
+}
+
+__isl_give isl_union_pw_aff_list *union_pw_aff_list::copy() const & {
+  return isl_union_pw_aff_list_copy(ptr);
+}
+
+__isl_keep isl_union_pw_aff_list *union_pw_aff_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_aff_list *union_pw_aff_list::release() {
+  isl_union_pw_aff_list *tmp = ptr;
+  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));
+}
+
+isl::union_pw_aff_list union_pw_aff_list::add(isl::union_pw_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff union_pw_aff_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff_list union_pw_aff_list::concat(isl::union_pw_aff_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_aff_list union_pw_aff_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void union_pw_aff_list::foreach(const std::function<void(isl::union_pw_aff)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::union_pw_aff)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_union_pw_aff_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::union_pw_aff_list union_pw_aff_list::insert(unsigned int pos, isl::union_pw_aff el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned union_pw_aff_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_aff_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_aff_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_aff_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_pw_aff_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  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) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_pw_multi_aff(ptr);
+}
+union_pw_multi_aff manage_copy(__isl_keep isl_union_pw_multi_aff *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_multi_aff_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_pw_multi_aff_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_multi_aff_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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::multi_aff ma)
+{
+  if (ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_from_multi_aff(ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_multi_aff::union_pw_multi_aff(isl::pw_multi_aff pma)
+{
+  if (pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pma.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_from_pw_multi_aff(pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_multi_aff::union_pw_multi_aff(isl::union_pw_aff upa)
+{
+  if (upa.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = upa.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_from_union_pw_aff(upa.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_multi_aff::union_pw_multi_aff(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_pw_multi_aff &union_pw_multi_aff::operator=(union_pw_multi_aff obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_pw_multi_aff::~union_pw_multi_aff() {
+  if (ptr)
+    isl_union_pw_multi_aff_free(ptr);
+}
+
+__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::copy() const & {
+  return isl_union_pw_multi_aff_copy(ptr);
+}
+
+__isl_keep isl_union_pw_multi_aff *union_pw_multi_aff::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_pw_multi_aff *union_pw_multi_aff::release() {
+  isl_union_pw_multi_aff *tmp = ptr;
+  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));
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::add(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_add(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::apply(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_apply_union_pw_multi_aff(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::multi_union_pw_aff union_pw_multi_aff::as_multi_union_pw_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_as_multi_union_pw_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff union_pw_multi_aff::as_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_as_pw_multi_aff(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_pw_multi_aff::as_union_map() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_as_union_map(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_pw_multi_aff::domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::empty(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_empty_ctx(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::pw_multi_aff union_pw_multi_aff::extract_pw_multi_aff(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_extract_pw_multi_aff(get(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::flat_range_product(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_flat_range_product(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::gist(isl::union_set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_intersect_domain_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_intersect_domain_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain_wrapped_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_intersect_domain_wrapped_domain(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::intersect_domain_wrapped_range(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_intersect_domain_wrapped_range(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_pw_multi_aff::involves_locals() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_involves_locals(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_pw_multi_aff::isa_pw_multi_aff() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_isa_pw_multi_aff(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_pw_multi_aff::plain_is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_plain_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::preimage_domain_wrapped_domain(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::pullback(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_pullback_union_pw_multi_aff(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::range_factor_domain() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_range_factor_domain(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::range_factor_range() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_range_factor_range(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::range_product(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_range_product(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_pw_multi_aff::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_pw_multi_aff::get_space() const
+{
+  return space();
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::sub(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_sub(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::subtract_domain(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_subtract_domain_space(copy(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::subtract_domain(isl::union_set uset) const
+{
+  if (!ptr || uset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_subtract_domain_union_set(copy(), uset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_pw_multi_aff union_pw_multi_aff::union_add(isl::union_pw_multi_aff upma2) const
+{
+  if (!ptr || upma2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_pw_multi_aff_union_add(copy(), upma2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_pw_multi_aff &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_pw_multi_aff_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_pw_multi_aff_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_set
+union_set manage(__isl_take isl_union_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_set(ptr);
+}
+union_set manage_copy(__isl_keep isl_union_set *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_set_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return union_set(ptr);
+}
+
+union_set::union_set()
+    : ptr(nullptr) {}
+
+union_set::union_set(const union_set &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+union_set::union_set(__isl_take isl_union_set *ptr)
+    : ptr(ptr) {}
+
+union_set::union_set(isl::basic_set bset)
+{
+  if (bset.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = bset.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_from_basic_set(bset.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_set::union_set(isl::point pnt)
+{
+  if (pnt.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = pnt.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_from_point(pnt.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_set::union_set(isl::set set)
+{
+  if (set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = set.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_from_set(set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_set::union_set(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_set &union_set::operator=(union_set obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+union_set::~union_set() {
+  if (ptr)
+    isl_union_set_free(ptr);
+}
+
+__isl_give isl_union_set *union_set::copy() const & {
+  return isl_union_set_copy(ptr);
+}
+
+__isl_keep isl_union_set *union_set::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_set *union_set::release() {
+  isl_union_set *tmp = ptr;
+  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));
+}
+
+isl::union_set union_set::affine_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_affine_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::apply(isl::union_map umap) const
+{
+  if (!ptr || umap.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_apply(copy(), umap.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::set union_set::as_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_as_set(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::coalesce() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_coalesce(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::compute_divs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_compute_divs(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::detect_equalities() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_detect_equalities(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::empty(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_empty_ctx(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_set::every_set(const std::function<bool(isl::set)> &test) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct test_data {
+    std::function<bool(isl::set)> func;
+    std::exception_ptr eptr;
+  } test_data = { test };
+  auto test_lambda = (isl_set *arg_0, void *arg_1) -> isl_bool {
+    auto *data = static_cast<struct test_data *>(arg_1);
+    ISL_CPP_TRY {
+      auto ret = (data->func)(manage_copy(arg_0));
+      return ret ? isl_bool_true : isl_bool_false;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_bool_error;
+    }
+  };
+  auto res = isl_union_set_every_set(get(), test_lambda, &test_data);
+  if (test_data.eptr)
+    std::rethrow_exception(test_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::set union_set::extract_set(isl::space space) const
+{
+  if (!ptr || space.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_extract_set(get(), space.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void union_set::foreach_point(const std::function<void(isl::point)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::point)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_point *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_union_set_foreach_point(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+void union_set::foreach_set(const std::function<void(isl::set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::set)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_set *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_union_set_foreach_set(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::union_set union_set::gist(isl::union_set context) const
+{
+  if (!ptr || context.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_gist(copy(), context.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::gist_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_gist_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_set::identity() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_identity(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::intersect(isl::union_set uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_intersect(copy(), uset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::intersect_params(isl::set set) const
+{
+  if (!ptr || set.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_intersect_params(copy(), set.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool union_set::is_disjoint(const isl::union_set &uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_is_disjoint(get(), uset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_set::is_empty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_is_empty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_set::is_equal(const isl::union_set &uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_is_equal(get(), uset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_set::is_strict_subset(const isl::union_set &uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_is_strict_subset(get(), uset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_set::is_subset(const isl::union_set &uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_is_subset(get(), uset2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool union_set::isa_set() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_isa_set(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+isl::union_set union_set::lexmax() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_lexmax(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::lexmin() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_lexmin(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::polyhedral_hull() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_polyhedral_hull(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::preimage(isl::multi_aff ma) const
+{
+  if (!ptr || ma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_preimage_multi_aff(copy(), ma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::preimage(isl::pw_multi_aff pma) const
+{
+  if (!ptr || pma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_preimage_pw_multi_aff(copy(), pma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::preimage(isl::union_pw_multi_aff upma) const
+{
+  if (!ptr || upma.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_preimage_union_pw_multi_aff(copy(), upma.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::point union_set::sample_point() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_sample_point(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_set::space() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_get_space(get());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::space union_set::get_space() const
+{
+  return space();
+}
+
+isl::union_set union_set::subtract(isl::union_set uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_subtract(copy(), uset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set_list union_set::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::unite(isl::union_set uset2) const
+{
+  if (!ptr || uset2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_union(copy(), uset2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set::universe() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_universe(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_map union_set::unwrap() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_unwrap(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_set &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_set_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::union_set_list
+union_set_list manage(__isl_take isl_union_set_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return union_set_list(ptr);
+}
+union_set_list manage_copy(__isl_keep isl_union_set_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_union_set_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  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)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+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 saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+union_set_list::union_set_list(isl::union_set el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_from_union_set(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_union_set_list_free(ptr);
+}
+
+__isl_give isl_union_set_list *union_set_list::copy() const & {
+  return isl_union_set_list_copy(ptr);
+}
+
+__isl_keep isl_union_set_list *union_set_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_union_set_list *union_set_list::release() {
+  isl_union_set_list *tmp = ptr;
+  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));
+}
+
+isl::union_set_list union_set_list::add(isl::union_set el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set union_set_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set_list union_set_list::concat(isl::union_set_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::union_set_list union_set_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void union_set_list::foreach(const std::function<void(isl::union_set)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::union_set)> func;
+    std::exception_ptr eptr;
+  } 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);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_union_set_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::union_set_list union_set_list::insert(unsigned int pos, isl::union_set el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+unsigned union_set_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_union_set_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const union_set_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_union_set_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_union_set_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::val
+val manage(__isl_take isl_val *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return val(ptr);
+}
+val manage_copy(__isl_keep isl_val *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_val_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return val(ptr);
+}
+
+val::val()
+    : ptr(nullptr) {}
+
+val::val(const val &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+val::val(__isl_take isl_val *ptr)
+    : ptr(ptr) {}
+
+val::val(isl::ctx ctx, long i)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_int_from_si(ctx.release(), i);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+val::val(isl::ctx ctx, const std::string &str)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_read_from_str(ctx.release(), str.c_str());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+val &val::operator=(val obj) {
+  std::swap(this->ptr, obj.ptr);
+  return *this;
+}
+
+val::~val() {
+  if (ptr)
+    isl_val_free(ptr);
+}
+
+__isl_give isl_val *val::copy() const & {
+  return isl_val_copy(ptr);
+}
+
+__isl_keep isl_val *val::get() const {
+  return ptr;
+}
+
+__isl_give isl_val *val::release() {
+  isl_val *tmp = ptr;
+  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));
+}
+
+isl::val val::abs() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_abs(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool val::abs_eq(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_abs_eq(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::abs_eq(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->abs_eq(isl::val(ctx(), v2));
+}
+
+isl::val val::add(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_add(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::add(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::val(ctx(), v2));
+}
+
+isl::val val::ceil() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_ceil(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+int val::cmp_si(long i) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_cmp_si(get(), i);
+  return res;
+}
+
+long val::den_si() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  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
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_div(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::div(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->div(isl::val(ctx(), v2));
+}
+
+bool val::eq(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_eq(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::eq(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->eq(isl::val(ctx(), v2));
+}
+
+isl::val val::floor() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_floor(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::gcd(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_gcd(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::gcd(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gcd(isl::val(ctx(), v2));
+}
+
+bool val::ge(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_ge(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::ge(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->ge(isl::val(ctx(), v2));
+}
+
+bool val::gt(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_gt(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::gt(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->gt(isl::val(ctx(), v2));
+}
+
+isl::val val::infty(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_infty(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::inv() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_inv(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool val::is_divisible_by(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_divisible_by(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_divisible_by(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->is_divisible_by(isl::val(ctx(), v2));
+}
+
+bool val::is_infty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_infty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_int() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_int(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_nan() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_nan(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_neg(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_neginfty() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_neginfty(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_negone() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_negone(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_nonneg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_nonneg(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_nonpos() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_nonpos(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_one() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_one(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_pos() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_pos(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_rat() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_rat(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::is_zero() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_is_zero(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::le(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_le(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::le(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->le(isl::val(ctx(), v2));
+}
+
+bool val::lt(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_lt(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::lt(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->lt(isl::val(ctx(), v2));
+}
+
+isl::val val::max(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_max(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::max(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->max(isl::val(ctx(), v2));
+}
+
+isl::val val::min(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_min(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::min(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->min(isl::val(ctx(), v2));
+}
+
+isl::val val::mod(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_mod(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::mod(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->mod(isl::val(ctx(), v2));
+}
+
+isl::val val::mul(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_mul(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::mul(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->mul(isl::val(ctx(), v2));
+}
+
+isl::val val::nan(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_nan(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+bool val::ne(const isl::val &v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_ne(get(), v2.get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+bool val::ne(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->ne(isl::val(ctx(), v2));
+}
+
+isl::val val::neg() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_neg(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::neginfty(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_neginfty(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::negone(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_negone(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+long val::num_si() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  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 saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_one(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::pow2() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_pow2(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+int val::sgn() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_sgn(get());
+  return res;
+}
+
+isl::val val::sub(isl::val v2) const
+{
+  if (!ptr || v2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_sub(copy(), v2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::sub(long v2) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->sub(isl::val(ctx(), v2));
+}
+
+isl::val_list val::to_list() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_to_list(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::trunc() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_trunc(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val::zero(isl::ctx ctx)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_zero(ctx.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+inline std::ostream &operator<<(std::ostream &os, const val &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_val_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+
+// implementations for isl::val_list
+val_list manage(__isl_take isl_val_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return val_list(ptr);
+}
+val_list manage_copy(__isl_keep isl_val_list *ptr) {
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_list_get_ctx(ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = isl_val_list_copy(ptr);
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+  return val_list(ptr);
+}
+
+val_list::val_list()
+    : ptr(nullptr) {}
+
+val_list::val_list(const val_list &obj)
+    : ptr(nullptr)
+{
+  if (!obj.ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_list_get_ctx(obj.ptr);
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  ptr = obj.copy();
+  if (!ptr)
+    exception::throw_last_error(saved_ctx);
+}
+
+val_list::val_list(__isl_take isl_val_list *ptr)
+    : ptr(ptr) {}
+
+val_list::val_list(isl::ctx ctx, int n)
+{
+  auto saved_ctx = ctx;
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_alloc(ctx.release(), n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  ptr = res;
+}
+
+val_list::val_list(isl::val el)
+{
+  if (el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = el.ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_from_val(el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  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_val_list_free(ptr);
+}
+
+__isl_give isl_val_list *val_list::copy() const & {
+  return isl_val_list_copy(ptr);
+}
+
+__isl_keep isl_val_list *val_list::get() const {
+  return ptr;
+}
+
+__isl_give isl_val_list *val_list::release() {
+  isl_val_list *tmp = ptr;
+  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));
+}
+
+isl::val_list val_list::add(isl::val el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_add(copy(), el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val_list val_list::add(long el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->add(isl::val(ctx(), el));
+}
+
+isl::val val_list::at(int index) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_get_at(get(), index);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val val_list::get_at(int index) const
+{
+  return at(index);
+}
+
+isl::val_list val_list::clear() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_clear(copy());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val_list val_list::concat(isl::val_list list2) const
+{
+  if (!ptr || list2.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_concat(copy(), list2.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val_list val_list::drop(unsigned int first, unsigned int n) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_drop(copy(), first, n);
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+void val_list::foreach(const std::function<void(isl::val)> &fn) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  struct fn_data {
+    std::function<void(isl::val)> func;
+    std::exception_ptr eptr;
+  } fn_data = { fn };
+  auto fn_lambda = (isl_val *arg_0, void *arg_1) -> isl_stat {
+    auto *data = static_cast<struct fn_data *>(arg_1);
+    ISL_CPP_TRY {
+      (data->func)(manage(arg_0));
+      return isl_stat_ok;
+    } ISL_CPP_CATCH_ALL {
+      data->eptr = std::current_exception();
+      return isl_stat_error;
+    }
+  };
+  auto res = isl_val_list_foreach(get(), fn_lambda, &fn_data);
+  if (fn_data.eptr)
+    std::rethrow_exception(fn_data.eptr);
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return;
+}
+
+isl::val_list val_list::insert(unsigned int pos, isl::val el) const
+{
+  if (!ptr || el.is_null())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_insert(copy(), pos, el.release());
+  if (!res)
+    exception::throw_last_error(saved_ctx);
+  return manage(res);
+}
+
+isl::val_list val_list::insert(unsigned int pos, long el) const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  return this->insert(pos, isl::val(ctx(), el));
+}
+
+unsigned val_list::size() const
+{
+  if (!ptr)
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = ctx();
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  auto res = isl_val_list_size(get());
+  if (res < 0)
+    exception::throw_last_error(saved_ctx);
+  return res;
+}
+
+inline std::ostream &operator<<(std::ostream &os, const val_list &obj)
+{
+  if (!obj.get())
+    exception::throw_invalid("NULL input", __FILE__, __LINE__);
+  auto saved_ctx = isl_val_list_get_ctx(obj.get());
+  options_scoped_set_on_error saved_on_error(saved_ctx, exception::on_error);
+  char *str = isl_val_list_to_str(obj.get());
+  if (!str)
+    exception::throw_last_error(saved_ctx);
+  os << str;
+  free(str);
+  return os;
+}
+} // namespace isl
+
+#endif /* ISL_CPP */

_service:tar_scm:isl-0.14.tar.xz/include/isl/ctx.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/ctx.h Changed

@@ -14,7 +14,6 @@
 #include <stdlib.h>
 
 #include <isl/arg.h>
-#include <isl/hash.h>
 
 #ifndef __isl_give
 #define __isl_give
@@ -31,6 +30,9 @@
 #ifndef __isl_export
 #define __isl_export
 #endif
+#ifndef __isl_overload
+#define __isl_overload
+#endif
 #ifndef __isl_constructor
 #define __isl_constructor
 #endif
@@ -79,6 +81,20 @@
 	isl_error_quota,
 	isl_error_unsupported
 };
+typedef enum {
+	isl_stat_error = -1,
+	isl_stat_ok = 0
+} isl_stat;
+isl_stat isl_stat_non_null(void *obj);
+typedef enum {
+	isl_bool_error = -1,
+	isl_bool_false = 0,
+	isl_bool_true = 1
+} isl_bool;
+isl_bool isl_bool_not(isl_bool b);
+isl_bool isl_bool_ok(int b);
+typedef int	isl_size;
+#define isl_size_error	((int) -1)
 struct isl_ctx;
 typedef struct isl_ctx isl_ctx;
 
@@ -181,16 +197,16 @@
 }
 
 #define ISL_CTX_SET_INT_DEF(prefix,st,args,field)			\
-int prefix ## _set_ ## field(isl_ctx *ctx, int val)			\
+isl_stat prefix ## _set_ ## field(isl_ctx *ctx, int val)		\
 {									\
 	st *options;							\
 	options = isl_ctx_peek_ ## prefix(ctx);				\
 	if (!options)							\
 		isl_die(ctx, isl_error_invalid,				\
 			"isl_ctx does not reference " #prefix,		\
-			return -1);					\
+			return isl_stat_error);				\
 	options->field = val;						\
-	return 0;							\
+	return isl_stat_ok;						\
 }
 
 #define ISL_CTX_GET_STR_DEF(prefix,st,args,field)			\
@@ -206,21 +222,21 @@
 }
 
 #define ISL_CTX_SET_STR_DEF(prefix,st,args,field)			\
-int prefix ## _set_ ## field(isl_ctx *ctx, const char *val)		\
+isl_stat prefix ## _set_ ## field(isl_ctx *ctx, const char *val)	\
 {									\
 	st *options;							\
 	options = isl_ctx_peek_ ## prefix(ctx);				\
 	if (!options)							\
 		isl_die(ctx, isl_error_invalid,				\
 			"isl_ctx does not reference " #prefix,		\
-			return -1);					\
+			return isl_stat_error);				\
 	if (!val)							\
-		return -1;						\
+		return isl_stat_error;					\
 	free(options->field);						\
 	options->field = strdup(val);					\
 	if (!options->field)						\
-		return -1;						\
-	return 0;							\
+		return isl_stat_error;					\
+	return isl_stat_ok;						\
 }
 
 #define ISL_CTX_GET_BOOL_DEF(prefix,st,args,field)			\
@@ -236,6 +252,9 @@
 	ISL_CTX_SET_INT_DEF(prefix,st,args,field)
 
 enum isl_error isl_ctx_last_error(isl_ctx *ctx);
+const char *isl_ctx_last_error_msg(isl_ctx *ctx);
+const char *isl_ctx_last_error_file(isl_ctx *ctx);
+int isl_ctx_last_error_line(isl_ctx *ctx);
 void isl_ctx_reset_error(isl_ctx *ctx);
 void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error);

_service:tar_scm:isl-0.24.tar.gz/include/isl/fixed_box.h Added

@@ -0,0 +1,43 @@
+/*
+ * Use of this software is governed by the MIT license
+ */
+
+#ifndef ISL_FIXED_BOX_H
+#define ISL_FIXED_BOX_H
+
+#include <isl/ctx.h>
+#include <isl/val_type.h>
+#include <isl/space_type.h>
+#include <isl/aff_type.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+struct __isl_export isl_fixed_box;
+typedef struct isl_fixed_box isl_fixed_box;
+
+isl_ctx *isl_fixed_box_get_ctx(__isl_keep isl_fixed_box *box);
+__isl_export
+__isl_give isl_space *isl_fixed_box_get_space(__isl_keep isl_fixed_box *box);
+__isl_export
+isl_bool isl_fixed_box_is_valid(__isl_keep isl_fixed_box *box);
+__isl_export
+__isl_give isl_multi_aff *isl_fixed_box_get_offset(
+	__isl_keep isl_fixed_box *box);
+__isl_export
+__isl_give isl_multi_val *isl_fixed_box_get_size(__isl_keep isl_fixed_box *box);
+
+__isl_give isl_fixed_box *isl_fixed_box_copy(__isl_keep isl_fixed_box *box);
+__isl_null isl_fixed_box *isl_fixed_box_free(__isl_take isl_fixed_box *box);
+
+__isl_give isl_printer *isl_printer_print_fixed_box(
+	__isl_take isl_printer *p, __isl_keep isl_fixed_box *box);
+__isl_give char *isl_fixed_box_to_str(__isl_keep isl_fixed_box *box);
+void isl_fixed_box_dump(__isl_keep isl_fixed_box *box);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/flow.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/flow.h Changed

@@ -1,10 +1,14 @@
 #ifndef ISL_FLOW_H
 #define ISL_FLOW_H
 
+#include <stdio.h>
+
 #include <isl/set_type.h>
 #include <isl/map_type.h>
 #include <isl/union_set_type.h>
 #include <isl/union_map_type.h>
+#include <isl/schedule.h>
+#include <isl/printer.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -54,14 +58,89 @@
 isl_ctx *isl_access_info_get_ctx(__isl_keep isl_access_info *acc);
 
 __isl_give isl_flow *isl_access_info_compute_flow(__isl_take isl_access_info *acc);
-int isl_flow_foreach(__isl_keep isl_flow *deps,
-	int (*fn)(__isl_take isl_map *dep, int must, void *dep_user, void *user),
+isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
+	isl_stat (*fn)(__isl_take isl_map *dep, int must, void *dep_user,
+		void *user),
 	void *user);
 __isl_give isl_map *isl_flow_get_no_source(__isl_keep isl_flow *deps, int must);
-void isl_flow_free(__isl_take isl_flow *deps);
+__isl_null isl_flow *isl_flow_free(__isl_take isl_flow *deps);
 
 isl_ctx *isl_flow_get_ctx(__isl_keep isl_flow *deps);
 
+struct __isl_export isl_union_access_info;
+typedef struct isl_union_access_info isl_union_access_info;
+struct __isl_export isl_union_flow;
+typedef struct isl_union_flow isl_union_flow;
+
+__isl_constructor
+__isl_give isl_union_access_info *isl_union_access_info_from_sink(
+	__isl_take isl_union_map *sink);
+__isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_must_source(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *must_source);
+__isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_may_source(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *may_source);
+__isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_kill(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *kill);
+__isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_schedule(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_schedule *schedule);
+__isl_export
+__isl_give isl_union_access_info *isl_union_access_info_set_schedule_map(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *schedule_map);
+__isl_give isl_union_access_info *isl_union_access_info_copy(
+	__isl_keep isl_union_access_info *access);
+__isl_null isl_union_access_info *isl_union_access_info_free(
+	__isl_take isl_union_access_info *access);
+
+isl_ctx *isl_union_access_info_get_ctx(
+	__isl_keep isl_union_access_info *access);
+
+__isl_give isl_union_access_info *isl_union_access_info_read_from_file(
+	isl_ctx *ctx, FILE *input);
+__isl_give isl_printer *isl_printer_print_union_access_info(
+	__isl_take isl_printer *p, __isl_keep isl_union_access_info *access);
+__isl_give char *isl_union_access_info_to_str(
+	__isl_keep isl_union_access_info *access);
+
+__isl_export
+__isl_give isl_union_flow *isl_union_access_info_compute_flow(
+	__isl_take isl_union_access_info *access);
+
+isl_ctx *isl_union_flow_get_ctx(__isl_keep isl_union_flow *flow);
+__isl_give isl_union_flow *isl_union_flow_copy(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_must_dependence(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_may_dependence(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_full_must_dependence(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_full_may_dependence(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_must_no_source(
+	__isl_keep isl_union_flow *flow);
+__isl_export
+__isl_give isl_union_map *isl_union_flow_get_may_no_source(
+	__isl_keep isl_union_flow *flow);
+__isl_null isl_union_flow *isl_union_flow_free(__isl_take isl_union_flow *flow);
+
+__isl_give isl_printer *isl_printer_print_union_flow(
+	__isl_take isl_printer *p, __isl_keep isl_union_flow *flow);
+__isl_give char *isl_union_flow_to_str(__isl_keep isl_union_flow *flow);
+
 int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
 	__isl_take isl_union_map *must_source,
 	__isl_take isl_union_map *may_source,

_service:tar_scm:isl-0.14.tar.xz/include/isl/hash.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/hash.h Changed

@@ -12,6 +12,7 @@
 
 #include <stdlib.h>
 #include <isl/stdint.h>
+#include <isl/ctx.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -52,22 +53,20 @@
 	struct isl_hash_table_entry *entries;
 };
 
-struct isl_ctx;
-
 struct isl_hash_table *isl_hash_table_alloc(struct isl_ctx *ctx, int min_size);
 void isl_hash_table_free(struct isl_ctx *ctx, struct isl_hash_table *table);
 
 int isl_hash_table_init(struct isl_ctx *ctx, struct isl_hash_table *table,
 			int min_size);
 void isl_hash_table_clear(struct isl_hash_table *table);
+extern struct isl_hash_table_entry *isl_hash_table_entry_none;
 struct isl_hash_table_entry *isl_hash_table_find(struct isl_ctx *ctx,
-				struct isl_hash_table *table,
-				uint32_t key_hash,
-				int (*eq)(const void *entry, const void *val),
-				const void *val, int reserve);
-int isl_hash_table_foreach(struct isl_ctx *ctx,
 			    struct isl_hash_table *table,
-			    int (*fn)(void **entry, void *user), void *user);
+			    uint32_t key_hash,
+			    isl_bool (*eq)(const void *entry, const void *val),
+			    const void *val, int reserve);
+isl_stat isl_hash_table_foreach(isl_ctx *ctx, struct isl_hash_table *table,
+	isl_stat (*fn)(void **entry, void *user), void *user);
 void isl_hash_table_remove(struct isl_ctx *ctx,
 				struct isl_hash_table *table,
 				struct isl_hash_table_entry *entry);

_service:tar_scm:isl-0.14.tar.xz/include/isl/hmap.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/hmap.h Changed

@@ -1,4 +1,5 @@
 #include <isl/ctx.h>
+#include <isl/maybe.h>
 #include <isl/printer.h>
 
 #if defined(__cplusplus)
@@ -7,14 +8,8 @@
 
 #define ISL_xCAT(A,B) A ## B
 #define ISL_CAT(A,B) ISL_xCAT(A,B)
-#define ISL_KEY ISL_CAT(isl_,ISL_KEY_BASE)
-#define ISL_VAL ISL_CAT(isl_,ISL_VAL_BASE)
 #define ISL_xFN(TYPE,NAME) TYPE ## _ ## NAME
 #define ISL_FN(TYPE,NAME) ISL_xFN(TYPE,NAME)
-#define ISL_xHMAP(KEY,VAL_BASE) KEY ## _to_ ## VAL_BASE
-#define ISL_yHMAP(KEY,VAL_BASE) ISL_xHMAP(KEY,VAL_BASE)
-#define ISL_HMAP ISL_yHMAP(ISL_KEY,ISL_VAL_BASE)
-#define ISL_HMAP_BASE ISL_yHMAP(ISL_KEY_BASE,ISL_VAL_BASE)
 
 struct ISL_HMAP;
 typedef struct ISL_HMAP	ISL_HMAP;
@@ -25,7 +20,10 @@
 
 isl_ctx *ISL_FN(ISL_HMAP,get_ctx)(__isl_keep ISL_HMAP *hmap);
 
-int ISL_FN(ISL_HMAP,has)(__isl_keep ISL_HMAP *hmap, __isl_keep ISL_KEY *key);
+__isl_give ISL_MAYBE(ISL_VAL) ISL_FN(ISL_HMAP,try_get)(
+	__isl_keep ISL_HMAP *hmap, __isl_keep ISL_KEY *key);
+isl_bool ISL_FN(ISL_HMAP,has)(__isl_keep ISL_HMAP *hmap,
+	__isl_keep ISL_KEY *key);
 __isl_give ISL_VAL *ISL_FN(ISL_HMAP,get)(__isl_keep ISL_HMAP *hmap,
 	__isl_take ISL_KEY *key);
 __isl_give ISL_HMAP *ISL_FN(ISL_HMAP,set)(__isl_take ISL_HMAP *hmap,
@@ -33,11 +31,12 @@
 __isl_give ISL_HMAP *ISL_FN(ISL_HMAP,drop)(__isl_take ISL_HMAP *hmap,
 	__isl_take ISL_KEY *key);
 
-int ISL_FN(ISL_HMAP,foreach)(__isl_keep ISL_HMAP *hmap,
-	int (*fn)(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val, void *user),
+isl_stat ISL_FN(ISL_HMAP,foreach)(__isl_keep ISL_HMAP *hmap,
+	isl_stat (*fn)(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val,
+		void *user),
 	void *user);
 
-__isl_give isl_printer *ISL_FN(isl_printer_print,ISL_HMAP_BASE)(
+__isl_give isl_printer *ISL_FN(isl_printer_print,ISL_HMAP_SUFFIX)(
 	__isl_take isl_printer *p, __isl_keep ISL_HMAP *hmap);
 void ISL_FN(ISL_HMAP,dump)(__isl_keep ISL_HMAP *hmap);

_service:tar_scm:isl-0.24.tar.gz/include/isl/hmap_templ.c Added

@@ -0,0 +1,425 @@
+/*
+ * Copyright 2011      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <isl/ctx.h>
+#include <isl/hash.h>
+
+#define ISL_xCAT(A,B) A ## B
+#define ISL_CAT(A,B) ISL_xCAT(A,B)
+#define ISL_xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define ISL_FN(TYPE,NAME) ISL_xFN(TYPE,NAME)
+#define ISL_xS(TYPE1,TYPE2,NAME) struct isl_ ## TYPE1 ## _ ## TYPE2 ## _ ## NAME
+#define ISL_yS(TYPE1,TYPE2,NAME) ISL_xS(TYPE1,TYPE2,NAME)
+#define ISL_S(NAME) ISL_yS(ISL_KEY,ISL_VAL,NAME)
+
+struct ISL_HMAP {
+	int ref;
+	isl_ctx *ctx;
+	struct isl_hash_table table;
+};
+
+ISL_S(pair) {
+	ISL_KEY *key;
+	ISL_VAL *val;
+};
+
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,alloc)(isl_ctx *ctx, int min_size)
+{
+	ISL_HMAP *hmap;
+
+	hmap = isl_calloc_type(ctx, ISL_HMAP);
+	if (!hmap)
+		return NULL;
+
+	hmap->ctx = ctx;
+	isl_ctx_ref(ctx);
+	hmap->ref = 1;
+
+	if (isl_hash_table_init(ctx, &hmap->table, min_size) < 0)
+		return ISL_FN(ISL_HMAP,free)(hmap);
+
+	return hmap;
+}
+
+static isl_stat free_pair(void **entry, void *user)
+{
+	ISL_S(pair) *pair = *entry;
+	ISL_FN(ISL_KEY,free)(pair->key);
+	ISL_FN(ISL_VAL,free)(pair->val);
+	free(pair);
+	*entry = NULL;
+	return isl_stat_ok;
+}
+
+__isl_null ISL_HMAP *ISL_FN(ISL_HMAP,free)(__isl_take ISL_HMAP *hmap)
+{
+	if (!hmap)
+		return NULL;
+	if (--hmap->ref > 0)
+		return NULL;
+	isl_hash_table_foreach(hmap->ctx, &hmap->table, &free_pair, NULL);
+	isl_hash_table_clear(&hmap->table);
+	isl_ctx_deref(hmap->ctx);
+	free(hmap);
+	return NULL;
+}
+
+isl_ctx *ISL_FN(ISL_HMAP,get_ctx)(__isl_keep ISL_HMAP *hmap)
+{
+	return hmap ? hmap->ctx : NULL;
+}
+
+/* Add a mapping from "key" to "val" to the associative array
+ * pointed to by user.
+ */
+static isl_stat add_key_val(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val,
+	void *user)
+{
+	ISL_HMAP **hmap = (ISL_HMAP **) user;
+
+	*hmap = ISL_FN(ISL_HMAP,set)(*hmap, key, val);
+
+	if (!*hmap)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,dup)(__isl_keep ISL_HMAP *hmap)
+{
+	ISL_HMAP *dup;
+
+	if (!hmap)
+		return NULL;
+
+	dup = ISL_FN(ISL_HMAP,alloc)(hmap->ctx, hmap->table.n);
+	if (ISL_FN(ISL_HMAP,foreach)(hmap, &add_key_val, &dup) < 0)
+		return ISL_FN(ISL_HMAP,free)(dup);
+
+	return dup;
+}
+
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,cow)(__isl_take ISL_HMAP *hmap)
+{
+	if (!hmap)
+		return NULL;
+
+	if (hmap->ref == 1)
+		return hmap;
+	hmap->ref--;
+	return ISL_FN(ISL_HMAP,dup)(hmap);
+}
+
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,copy)(__isl_keep ISL_HMAP *hmap)
+{
+	if (!hmap)
+		return NULL;
+
+	hmap->ref++;
+	return hmap;
+}
+
+static isl_bool has_key(const void *entry, const void *c_key)
+{
+	const ISL_S(pair) *pair = entry;
+	ISL_KEY *key = (ISL_KEY *) c_key;
+
+	return ISL_KEY_IS_EQUAL(pair->key, key);
+}
+
+/* If "hmap" contains a value associated to "key", then return
+ * (isl_bool_true, copy of value).
+ * Otherwise, return
+ * (isl_bool_false, NULL).
+ * If an error occurs, then return
+ * (isl_bool_error, NULL).
+ */
+__isl_give ISL_MAYBE(ISL_VAL) ISL_FN(ISL_HMAP,try_get)(
+	__isl_keep ISL_HMAP *hmap, __isl_keep ISL_KEY *key)
+{
+	struct isl_hash_table_entry *entry;
+	ISL_S(pair) *pair;
+	uint32_t hash;
+	ISL_MAYBE(ISL_VAL) res = { isl_bool_false, NULL };
+
+	if (!hmap || !key)
+		goto error;
+
+	hash = ISL_FN(ISL_KEY,get_hash)(key);
+	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
+					&has_key, key, 0);
+
+	if (!entry)
+		goto error;
+	if (entry == isl_hash_table_entry_none)
+		return res;
+
+	pair = entry->data;
+
+	res.valid = isl_bool_true;
+	res.value = ISL_FN(ISL_VAL,copy)(pair->val);
+	if (!res.value)
+		res.valid = isl_bool_error;
+	return res;
+error:
+	res.valid = isl_bool_error;
+	res.value = NULL;
+	return res;
+}
+
+/* If "hmap" contains a value associated to "key", then return
+ * isl_bool_true.  Otherwise, return isl_bool_false.
+ * Return isl_bool_error on error.
+ */
+isl_bool ISL_FN(ISL_HMAP,has)(__isl_keep ISL_HMAP *hmap,
+	__isl_keep ISL_KEY *key)
+{
+	ISL_MAYBE(ISL_VAL) res;
+
+	res = ISL_FN(ISL_HMAP,try_get)(hmap, key);
+	ISL_FN(ISL_VAL,free)(res.value);
+
+	return res.valid;
+}
+
+/* If "hmap" contains a value associated to "key", then return
+ * a copy of that value.  Otherwise, return NULL.
+ * Return NULL on error.
+ */
+__isl_give ISL_VAL *ISL_FN(ISL_HMAP,get)(__isl_keep ISL_HMAP *hmap,
+	__isl_take ISL_KEY *key)
+{
+	ISL_VAL *res;
+
+	res = ISL_FN(ISL_HMAP,try_get)(hmap, key).value;
+	ISL_FN(ISL_KEY,free)(key);
+	return res;
+}
+
+/* Remove the mapping between "key" and its associated value (if any)
+ * from "hmap".
+ *
+ * If "key" is not mapped to anything, then we leave "hmap" untouched"
+ */
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,drop)(__isl_take ISL_HMAP *hmap,
+	__isl_take ISL_KEY *key)
+{
+	struct isl_hash_table_entry *entry;
+	ISL_S(pair) *pair;
+	uint32_t hash;
+
+	if (!hmap || !key)
+		goto error;
+
+	hash = ISL_FN(ISL_KEY,get_hash)(key);
+	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
+					&has_key, key, 0);
+	if (!entry)
+		goto error;
+	if (entry == isl_hash_table_entry_none) {
+		ISL_FN(ISL_KEY,free)(key);
+		return hmap;
+	}
+
+	hmap = ISL_FN(ISL_HMAP,cow)(hmap);
+	if (!hmap)
+		goto error;
+	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
+					&has_key, key, 0);
+	ISL_FN(ISL_KEY,free)(key);
+
+	if (!entry)
+		return ISL_FN(ISL_HMAP,free)(hmap);
+	if (entry == isl_hash_table_entry_none)
+		isl_die(hmap->ctx, isl_error_internal,
+			"missing entry" , return ISL_FN(ISL_HMAP,free)(hmap));
+
+	pair = entry->data;
+	isl_hash_table_remove(hmap->ctx, &hmap->table, entry);
+	ISL_FN(ISL_KEY,free)(pair->key);
+	ISL_FN(ISL_VAL,free)(pair->val);
+	free(pair);
+
+	return hmap;
+error:
+	ISL_FN(ISL_KEY,free)(key);
+	ISL_FN(ISL_HMAP,free)(hmap);
+	return NULL;
+}
+
+/* Add a mapping from "key" to "val" to "hmap".
+ * If "key" was already mapped to something else, then that mapping
+ * is replaced.
+ * If key happened to be mapped to "val" already, then we leave
+ * "hmap" untouched.
+ */
+__isl_give ISL_HMAP *ISL_FN(ISL_HMAP,set)(__isl_take ISL_HMAP *hmap,
+	__isl_take ISL_KEY *key, __isl_take ISL_VAL *val)
+{
+	struct isl_hash_table_entry *entry;
+	ISL_S(pair) *pair;
+	uint32_t hash;
+
+	if (!hmap || !key || !val)
+		goto error;
+
+	hash = ISL_FN(ISL_KEY,get_hash)(key);
+	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
+					&has_key, key, 0);
+	if (!entry)
+		goto error;
+	if (entry != isl_hash_table_entry_none) {
+		isl_bool equal;
+		pair = entry->data;
+		equal = ISL_VAL_IS_EQUAL(pair->val, val);
+		if (equal < 0)
+			goto error;
+		if (equal) {
+			ISL_FN(ISL_KEY,free)(key);
+			ISL_FN(ISL_VAL,free)(val);
+			return hmap;
+		}
+	}
+
+	hmap = ISL_FN(ISL_HMAP,cow)(hmap);
+	if (!hmap)
+		goto error;
+
+	entry = isl_hash_table_find(hmap->ctx, &hmap->table, hash,
+					&has_key, key, 1);
+
+	if (!entry)
+		goto error;
+
+	if (entry->data) {
+		pair = entry->data;
+		ISL_FN(ISL_VAL,free)(pair->val);
+		pair->val = val;
+		ISL_FN(ISL_KEY,free)(key);
+		return hmap;
+	}
+
+	pair = isl_alloc_type(hmap->ctx, ISL_S(pair));
+	if (!pair)
+		goto error;
+
+	entry->data = pair;
+	pair->key = key;
+	pair->val = val;
+	return hmap;
+error:
+	ISL_FN(ISL_KEY,free)(key);
+	ISL_FN(ISL_VAL,free)(val);
+	return ISL_FN(ISL_HMAP,free)(hmap);
+}
+
+/* Internal data structure for isl_map_to_basic_set_foreach.
+ *
+ * fn is the function that should be called on each entry.
+ * user is the user-specified final argument to fn.
+ */
+ISL_S(foreach_data) {
+	isl_stat (*fn)(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val,
+		void *user);
+	void *user;
+};
+
+/* Call data->fn on a copy of the key and value in *entry.
+ */
+static isl_stat call_on_copy(void **entry, void *user)
+{
+	ISL_S(pair) *pair = *entry;
+	ISL_S(foreach_data) *data = (ISL_S(foreach_data) *) user;
+
+	return data->fn(ISL_FN(ISL_KEY,copy)(pair->key),
+			ISL_FN(ISL_VAL,copy)(pair->val), data->user);
+}
+
+/* Call "fn" on each pair of key and value in "hmap".
+ */
+isl_stat ISL_FN(ISL_HMAP,foreach)(__isl_keep ISL_HMAP *hmap,
+	isl_stat (*fn)(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val,
+		void *user),
+	void *user)
+{
+	ISL_S(foreach_data) data = { fn, user };
+
+	if (!hmap)
+		return isl_stat_error;
+
+	return isl_hash_table_foreach(hmap->ctx, &hmap->table,
+				      &call_on_copy, &data);
+}
+
+/* Internal data structure for print_pair.
+ *
+ * p is the printer on which the associative array is being printed.
+ * first is set if the current key-value pair is the first to be printed.
+ */
+ISL_S(print_data) {
+	isl_printer *p;
+	int first;
+};
+
+/* Print the given key-value pair to data->p.
+ */
+static isl_stat print_pair(__isl_take ISL_KEY *key, __isl_take ISL_VAL *val,
+	void *user)
+{
+	ISL_S(print_data) *data = user;
+
+	if (!data->first)
+		data->p = isl_printer_print_str(data->p, ", ");
+	data->p = ISL_KEY_PRINT(data->p, key);
+	data->p = isl_printer_print_str(data->p, ": ");
+	data->p = ISL_VAL_PRINT(data->p, val);
+	data->first = 0;
+
+	ISL_FN(ISL_KEY,free)(key);
+	ISL_FN(ISL_VAL,free)(val);
+	return isl_stat_ok;
+}
+
+/* Print the associative array to "p".
+ */
+__isl_give isl_printer *ISL_FN(isl_printer_print,ISL_HMAP_SUFFIX)(
+	__isl_take isl_printer *p, __isl_keep ISL_HMAP *hmap)
+{
+	ISL_S(print_data) data;
+
+	if (!p || !hmap)
+		return isl_printer_free(p);
+
+	p = isl_printer_print_str(p, "{");
+	data.p = p;
+	data.first = 1;
+	if (ISL_FN(ISL_HMAP,foreach)(hmap, &print_pair, &data) < 0)
+		data.p = isl_printer_free(data.p);
+	p = data.p;
+	p = isl_printer_print_str(p, "}");
+
+	return p;
+}
+
+void ISL_FN(ISL_HMAP,dump)(__isl_keep ISL_HMAP *hmap)
+{
+	isl_printer *printer;
+
+	if (!hmap)
+		return;
+
+	printer = isl_printer_to_file(ISL_FN(ISL_HMAP,get_ctx)(hmap), stderr);
+	printer = ISL_FN(isl_printer_print,ISL_HMAP_SUFFIX)(printer, hmap);
+	printer = isl_printer_end_line(printer);
+
+	isl_printer_free(printer);
+}

_service:tar_scm:isl-0.14.tar.xz/include/isl/id.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/id.h Changed

@@ -2,17 +2,19 @@
 #define ISL_ID_H
 
 #include <isl/ctx.h>
+#include <isl/id_type.h>
 #include <isl/list.h>
-#include <isl/printer.h>
+#include <isl/multi.h>
+#include <isl/printer_type.h>
+#include <isl/stdint.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_id;
-typedef struct isl_id isl_id;
+ISL_DECLARE_EXPORTED_LIST_FN(id)
 
-ISL_DECLARE_LIST(id)
+ISL_DECLARE_MULTI(id)
 
 isl_ctx *isl_id_get_ctx(__isl_keep isl_id *id);
 uint32_t isl_id_get_hash(__isl_keep isl_id *id);
@@ -23,15 +25,27 @@
 __isl_null isl_id *isl_id_free(__isl_take isl_id *id);
 
 void *isl_id_get_user(__isl_keep isl_id *id);
+__isl_export
 __isl_keep const char *isl_id_get_name(__isl_keep isl_id *id);
 
 __isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
-	__isl_give void (*free_user)(void *user));
+	void (*free_user)(void *user));
 
+__isl_constructor
+__isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx, const char *str);
+__isl_give char *isl_id_to_str(__isl_keep isl_id *id);
 __isl_give isl_printer *isl_printer_print_id(__isl_take isl_printer *p,
 	__isl_keep isl_id *id);
 void isl_id_dump(__isl_keep isl_id *id);
 
+__isl_constructor
+__isl_give isl_multi_id *isl_multi_id_read_from_str(isl_ctx *ctx,
+	const char *str);
+__isl_give isl_printer *isl_printer_print_multi_id(__isl_take isl_printer *p,
+	__isl_keep isl_multi_id *mi);
+void isl_multi_id_dump(__isl_keep isl_multi_id *mi);
+__isl_give char *isl_multi_id_to_str(__isl_keep isl_multi_id *mi);
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/id_to_ast_expr.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/id_to_ast_expr.h Changed

_service:tar_scm:isl-0.24.tar.gz/include/isl/id_to_id.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/id_to_pw_aff.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/id_to_pw_aff.h Changed

_service:tar_scm:isl-0.24.tar.gz/include/isl/id_type.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/ilp.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/ilp.h Changed

@@ -12,7 +12,8 @@
 
 #include <isl/aff_type.h>
 #include <isl/set_type.h>
-#include <isl/val.h>
+#include <isl/union_set_type.h>
+#include <isl/val_type.h>
 #include <isl/vec.h>
 
 #if defined(__cplusplus)
@@ -21,10 +22,43 @@
 
 __isl_give isl_val *isl_basic_set_max_val(__isl_keep isl_basic_set *bset,
 	__isl_keep isl_aff *obj);
+__isl_export
 __isl_give isl_val *isl_set_min_val(__isl_keep isl_set *set,
 	__isl_keep isl_aff *obj);
+__isl_export
 __isl_give isl_val *isl_set_max_val(__isl_keep isl_set *set,
 	__isl_keep isl_aff *obj);
+__isl_give isl_multi_val *isl_union_set_min_multi_union_pw_aff(
+	__isl_keep isl_union_set *uset, __isl_keep isl_multi_union_pw_aff *obj);
+
+__isl_export
+__isl_give isl_multi_val *isl_pw_multi_aff_min_multi_val(
+	__isl_take isl_pw_multi_aff *pma);
+__isl_export
+__isl_give isl_multi_val *isl_pw_multi_aff_max_multi_val(
+	__isl_take isl_pw_multi_aff *pma);
+__isl_export
+__isl_give isl_multi_val *isl_multi_pw_aff_min_multi_val(
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_export
+__isl_give isl_multi_val *isl_multi_pw_aff_max_multi_val(
+	__isl_take isl_multi_pw_aff *mpa);
+
+__isl_give isl_val *isl_union_pw_aff_min_val(__isl_take isl_union_pw_aff *upa);
+__isl_give isl_val *isl_union_pw_aff_max_val(__isl_take isl_union_pw_aff *upa);
+
+__isl_give isl_multi_val *isl_multi_union_pw_aff_min_multi_val(
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_multi_val *isl_multi_union_pw_aff_max_multi_val(
+	__isl_take isl_multi_union_pw_aff *mupa);
+
+__isl_export
+__isl_give isl_val *isl_basic_set_dim_max_val(__isl_take isl_basic_set *bset,
+	int pos);
+__isl_export
+__isl_give isl_val *isl_set_dim_min_val(__isl_take isl_set *set, int pos);
+__isl_export
+__isl_give isl_val *isl_set_dim_max_val(__isl_take isl_set *set, int pos);
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.14.tar.xz/include/isl/list.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/list.h Changed

@@ -11,63 +11,106 @@
 #define ISL_LIST_H
 
 #include <isl/ctx.h>
-#include <isl/printer.h>
+#include <isl/printer_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-#define ISL_DECLARE_LIST_TYPE(EL)					\
+#define ISL_DECLARE_LIST_TYPE2(EL,EXPORT)				\
 struct isl_##EL;							\
-struct isl_##EL##_list;							\
+struct EXPORT isl_##EL##_list;						\
 typedef struct isl_##EL##_list isl_##EL##_list;
-#define ISL_DECLARE_LIST_FN(EL)						\
+#define ISL_DECLARE_LIST_TYPE(EL)					\
+	ISL_DECLARE_LIST_TYPE2(EL,)
+#define ISL_DECLARE_EXPORTED_LIST_TYPE(EL)				\
+	ISL_DECLARE_LIST_TYPE2(EL,__isl_export)
+#define ISL_DECLARE_LIST_FN3(EL,CONSTRUCTOR,EXPORT)			\
 isl_ctx *isl_##EL##_list_get_ctx(__isl_keep isl_##EL##_list *list);	\
+EXPORT									\
+__isl_give isl_##EL##_list *isl_##EL##_to_list(__isl_take isl_##EL *el);\
+CONSTRUCTOR								\
 __isl_give isl_##EL##_list *isl_##EL##_list_from_##EL(			\
-	__isl_take struct isl_##EL *el);				\
+	__isl_take isl_##EL *el);					\
+CONSTRUCTOR								\
 __isl_give isl_##EL##_list *isl_##EL##_list_alloc(isl_ctx *ctx, int n);	\
 __isl_give isl_##EL##_list *isl_##EL##_list_copy(			\
 	__isl_keep isl_##EL##_list *list);				\
 __isl_null isl_##EL##_list *isl_##EL##_list_free(			\
 	__isl_take isl_##EL##_list *list);				\
+EXPORT									\
 __isl_give isl_##EL##_list *isl_##EL##_list_add(			\
 	__isl_take isl_##EL##_list *list,				\
-	__isl_take struct isl_##EL *el);				\
+	__isl_take isl_##EL *el);					\
+EXPORT									\
 __isl_give isl_##EL##_list *isl_##EL##_list_insert(			\
 	__isl_take isl_##EL##_list *list, unsigned pos,			\
-	__isl_take struct isl_##EL *el);				\
+	__isl_take isl_##EL *el);					\
+EXPORT									\
 __isl_give isl_##EL##_list *isl_##EL##_list_drop(			\
 	__isl_take isl_##EL##_list *list, unsigned first, unsigned n);	\
+EXPORT									\
+__isl_give isl_##EL##_list *isl_##EL##_list_clear(			\
+	__isl_take isl_##EL##_list *list);				\
+__isl_give isl_##EL##_list *isl_##EL##_list_swap(			\
+	__isl_take isl_##EL##_list *list, unsigned pos1,		\
+	unsigned pos2);							\
+__isl_give isl_##EL##_list *isl_##EL##_list_reverse(			\
+	__isl_take isl_##EL##_list *list);				\
+EXPORT									\
 __isl_give isl_##EL##_list *isl_##EL##_list_concat(			\
 	__isl_take isl_##EL##_list *list1,				\
 	__isl_take isl_##EL##_list *list2);				\
-int isl_##EL##_list_n_##EL(__isl_keep isl_##EL##_list *list);		\
+EXPORT									\
+isl_size isl_##EL##_list_size(__isl_keep isl_##EL##_list *list);	\
+isl_size isl_##EL##_list_n_##EL(__isl_keep isl_##EL##_list *list);	\
+EXPORT									\
+__isl_give isl_##EL *isl_##EL##_list_get_at(				\
+	__isl_keep isl_##EL##_list *list, int index);			\
 __isl_give struct isl_##EL *isl_##EL##_list_get_##EL(			\
 	__isl_keep isl_##EL##_list *list, int index);			\
 __isl_give struct isl_##EL##_list *isl_##EL##_list_set_##EL(		\
 	__isl_take struct isl_##EL##_list *list, int index,		\
 	__isl_take struct isl_##EL *el);				\
-int isl_##EL##_list_foreach(__isl_keep isl_##EL##_list *list,		\
-	int (*fn)(__isl_take struct isl_##EL *el, void *user),		\
+EXPORT									\
+isl_stat isl_##EL##_list_foreach(__isl_keep isl_##EL##_list *list,	\
+	isl_stat (*fn)(__isl_take isl_##EL *el, void *user),		\
+	void *user);							\
+isl_bool isl_##EL##_list_every(__isl_keep isl_##EL##_list *list,	\
+	isl_bool (*test)(__isl_keep isl_##EL *el, void *user),		\
+	void *user);							\
+__isl_give isl_##EL##_list *isl_##EL##_list_map(			\
+	__isl_take isl_##EL##_list *list,				\
+	__isl_give isl_##EL * (*fn)(__isl_take isl_##EL *el,		\
+		void *user),						\
 	void *user);							\
 __isl_give isl_##EL##_list *isl_##EL##_list_sort(			\
 	__isl_take isl_##EL##_list *list,				\
 	int (*cmp)(__isl_keep struct isl_##EL *a,			\
 		__isl_keep struct isl_##EL *b,				\
 		void *user), void *user);				\
-int isl_##EL##_list_foreach_scc(__isl_keep isl_##EL##_list *list,	\
-	int (*follows)(__isl_keep struct isl_##EL *a,			\
+isl_stat isl_##EL##_list_foreach_scc(__isl_keep isl_##EL##_list *list,	\
+	isl_bool (*follows)(__isl_keep struct isl_##EL *a,		\
 			__isl_keep struct isl_##EL *b, void *user),	\
 	void *follows_user,						\
-	int (*fn)(__isl_take isl_##EL##_list *scc, void *user),		\
+	isl_stat (*fn)(__isl_take isl_##EL##_list *scc, void *user),	\
 	void *fn_user);							\
+__isl_give char *isl_##EL##_list_to_str(				\
+	__isl_keep isl_##EL##_list *list);				\
 __isl_give isl_printer *isl_printer_print_##EL##_list(			\
 	__isl_take isl_printer *p, __isl_keep isl_##EL##_list *list);	\
 void isl_##EL##_list_dump(__isl_keep isl_##EL##_list *list);
+#define ISL_DECLARE_LIST_FN(EL)						\
+	ISL_DECLARE_LIST_FN3(EL,,)
+#define ISL_DECLARE_EXPORTED_LIST_FN(EL)				\
+	ISL_DECLARE_LIST_FN3(EL,__isl_constructor,__isl_export)
 
 #define ISL_DECLARE_LIST(EL)						\
 	ISL_DECLARE_LIST_TYPE(EL)					\
 	ISL_DECLARE_LIST_FN(EL)
+#define ISL_DECLARE_EXPORTED_LIST(EL)					\
+	ISL_DECLARE_EXPORTED_LIST_TYPE(EL)				\
+	ISL_DECLARE_EXPORTED_LIST_FN(EL)
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.14.tar.xz/include/isl/local_space.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/local_space.h Changed

@@ -2,7 +2,7 @@
 #define ISL_LOCAL_SPACE_H
 
 #include <isl/aff_type.h>
-#include <isl/space.h>
+#include <isl/space_type.h>
 #include <isl/printer.h>
 #include <isl/map_type.h>
 
@@ -15,29 +15,31 @@
 
 isl_ctx *isl_local_space_get_ctx(__isl_keep isl_local_space *ls);
 
-__isl_give isl_local_space *isl_local_space_from_space(__isl_take isl_space *dim);
+__isl_give isl_local_space *isl_local_space_from_space(
+	__isl_take isl_space *space);
 
 __isl_give isl_local_space *isl_local_space_copy(
 	__isl_keep isl_local_space *ls);
 __isl_null isl_local_space *isl_local_space_free(
 	__isl_take isl_local_space *ls);
 
-int isl_local_space_is_set(__isl_keep isl_local_space *ls);
+isl_bool isl_local_space_is_params(__isl_keep isl_local_space *ls);
+isl_bool isl_local_space_is_set(__isl_keep isl_local_space *ls);
 
 __isl_give isl_local_space *isl_local_space_set_tuple_id(
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, __isl_take isl_id *id);
 
-int isl_local_space_dim(__isl_keep isl_local_space *ls,
+isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type);
-int isl_local_space_has_dim_name(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_has_dim_name(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
 const char *isl_local_space_get_dim_name(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_local_space *isl_local_space_set_dim_name(
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos, const char *s);
-int isl_local_space_has_dim_id(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_has_dim_id(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_id *isl_local_space_get_dim_id(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos);
@@ -48,6 +50,9 @@
 __isl_give isl_aff *isl_local_space_get_div(__isl_keep isl_local_space *ls,
 	int pos);
 
+int isl_local_space_find_dim_by_name(__isl_keep isl_local_space *ls,
+	enum isl_dim_type type, const char *name);
+
 __isl_give isl_local_space *isl_local_space_domain(
 	__isl_take isl_local_space *ls);
 __isl_give isl_local_space *isl_local_space_range(
@@ -62,11 +67,16 @@
 __isl_give isl_local_space *isl_local_space_insert_dims(
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_local_space *isl_local_space_set_from_params(
+	__isl_take isl_local_space *ls);
 
 __isl_give isl_local_space *isl_local_space_intersect(
 	__isl_take isl_local_space *ls1, __isl_take isl_local_space *ls2);
 
-int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
+__isl_give isl_local_space *isl_local_space_wrap(
+	__isl_take isl_local_space *ls);
+
+isl_bool isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
 	__isl_keep isl_local_space *ls2);
 
 __isl_give isl_basic_map *isl_local_space_lifting(

_service:tar_scm:isl-0.14.tar.xz/include/isl/lp.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/lp.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/map.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/map.h Changed

@@ -13,7 +13,7 @@
 #include <stdio.h>
 
 #include <isl/ctx.h>
-#include <isl/space.h>
+#include <isl/space_type.h>
 #include <isl/vec.h>
 #include <isl/mat.h>
 #include <isl/printer.h>
@@ -21,42 +21,25 @@
 #include <isl/aff_type.h>
 #include <isl/list.h>
 #include <isl/map_type.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
+#include <isl/stdint.h>
+#include <isl/stride_info.h>
+#include <isl/fixed_box.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-/* General notes:
- *
- * All structures are reference counted to allow reuse without duplication.
- * A *_copy operation will increase the reference count, while a *_free
- * operation will decrease the reference count and only actually release
- * the structures when the reference count drops to zero.
- *
- * Functions that return an isa structure will in general _destroy_
- * all argument isa structures (the obvious execption begin the _copy
- * functions).  A pointer passed to such a function may therefore
- * never be used after the function call.  If you want to keep a
- * reference to the old structure(s), use the appropriate _copy function.
- */
-
-unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap);
-unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap);
-unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap);
-unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap);
-unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap);
-unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
+isl_size isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap);
+isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
 				enum isl_dim_type type);
 
-unsigned isl_map_n_in(const struct isl_map *map);
-unsigned isl_map_n_out(const struct isl_map *map);
-unsigned isl_map_n_param(const struct isl_map *map);
-unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type);
+isl_size isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type);
 
 isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap);
 isl_ctx *isl_map_get_ctx(__isl_keep isl_map *map);
 __isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap);
+__isl_export
 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map);
 
 __isl_give isl_aff *isl_basic_map_get_div(__isl_keep isl_basic_map *bmap,
@@ -69,14 +52,15 @@
 	__isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s);
 const char *isl_basic_map_get_tuple_name(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type);
-int isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type);
+isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map,
+	enum isl_dim_type type);
 const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
 	enum isl_dim_type type);
 __isl_give isl_map *isl_map_set_tuple_name(__isl_take isl_map *map,
 	enum isl_dim_type type, const char *s);
 const char *isl_basic_map_get_dim_name(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos);
-int isl_map_has_dim_name(__isl_keep isl_map *map,
+isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos);
 const char *isl_map_get_dim_name(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos);
@@ -91,60 +75,68 @@
 	enum isl_dim_type type, __isl_take isl_id *id);
 __isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
-int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos);
-int isl_map_has_dim_id(__isl_keep isl_map *map,
+isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos);
+__isl_overload
+__isl_give isl_map *isl_map_set_domain_tuple_id(__isl_take isl_map *map,
+	__isl_take isl_id *id);
+__isl_overload
+__isl_give isl_map *isl_map_set_range_tuple_id(__isl_take isl_map *map,
+	__isl_take isl_id *id);
 __isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
 	enum isl_dim_type type, __isl_take isl_id *id);
 __isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
 	enum isl_dim_type type);
-int isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type);
+__isl_export
+isl_bool isl_map_has_domain_tuple_id(__isl_keep isl_map *map);
+__isl_export
+isl_bool isl_map_has_range_tuple_id(__isl_keep isl_map *map);
+isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type);
+__isl_export
+__isl_give isl_id *isl_map_get_domain_tuple_id(__isl_keep isl_map *map);
+__isl_export
+__isl_give isl_id *isl_map_get_range_tuple_id(__isl_keep isl_map *map);
 __isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
 	enum isl_dim_type type);
 __isl_give isl_map *isl_map_reset_user(__isl_take isl_map *map);
 
+int isl_basic_map_find_dim_by_name(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type, const char *name);
 int isl_map_find_dim_by_id(__isl_keep isl_map *map, enum isl_dim_type type,
 	__isl_keep isl_id *id);
 int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
 	const char *name);
 
-int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap);
 
-struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned in, unsigned out, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim);
-struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model);
-struct isl_basic_map *isl_basic_map_finalize(struct isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *space);
 __isl_null isl_basic_map *isl_basic_map_free(__isl_take isl_basic_map *bmap);
 __isl_give isl_basic_map *isl_basic_map_copy(__isl_keep isl_basic_map *bmap);
-struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
-		unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-struct isl_basic_map *isl_basic_map_extend_constraints(
-		struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq);
 __isl_give isl_basic_map *isl_basic_map_equal(
-	__isl_take isl_space *dim, unsigned n_equal);
-__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
+	__isl_take isl_space *space, unsigned n_equal);
+__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *space,
 	unsigned pos);
-__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
+__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *space,
 	unsigned pos);
-__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *dim);
-struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model);
-struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model);
-__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *dim);
-__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim);
-__isl_give isl_basic_map *isl_basic_map_universe_like(
-		__isl_keep isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *space);
+__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *space);
+__isl_give isl_basic_map *isl_basic_map_nat_universe(
+	__isl_take isl_space *space);
 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
 	__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_remove_redundancies(__isl_take isl_map *map);
 __isl_give isl_basic_map *isl_map_simple_hull(__isl_take isl_map *map);
+__isl_export
 __isl_give isl_basic_map *isl_map_unshifted_simple_hull(
 	__isl_take isl_map *map);
+__isl_give isl_basic_map *isl_map_plain_unshifted_simple_hull(
+	__isl_take isl_map *map);
+__isl_give isl_basic_map *isl_map_unshifted_simple_hull_from_map_list(
+	__isl_take isl_map *map, __isl_take isl_map_list *list);
 
 __isl_export
 __isl_give isl_basic_map *isl_basic_map_intersect_domain(
@@ -158,6 +150,8 @@
 __isl_give isl_basic_map *isl_basic_map_intersect(
 		__isl_take isl_basic_map *bmap1,
 		__isl_take isl_basic_map *bmap2);
+__isl_give isl_basic_map *isl_basic_map_list_intersect(
+	__isl_take isl_basic_map_list *list);
 __isl_export
 __isl_give isl_map *isl_basic_map_union(
 		__isl_take isl_basic_map *bmap1,
@@ -191,12 +185,8 @@
 __isl_give isl_basic_map *isl_basic_map_eliminate(
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n);
-__isl_give isl_basic_map *isl_basic_map_from_basic_set(
-	__isl_take isl_basic_set *bset, __isl_take isl_space *dim);
-struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap);
 __isl_export
 __isl_give isl_basic_map *isl_basic_map_sample(__isl_take isl_basic_map *bmap);
-struct isl_basic_map *isl_basic_map_simplify(struct isl_basic_map *bmap);
 __isl_export
 __isl_give isl_basic_map *isl_basic_map_detect_equalities(
 						__isl_take isl_basic_map *bmap);
@@ -209,13 +199,11 @@
 __isl_constructor
 __isl_give isl_map *isl_map_read_from_str(isl_ctx *ctx, const char *str);
 void isl_basic_map_dump(__isl_keep isl_basic_map *bmap);
-void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
-	const char *prefix, const char *suffix, unsigned output_format);
 void isl_map_dump(__isl_keep isl_map *map);
-void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
-	unsigned output_format);
+__isl_give char *isl_basic_map_to_str(__isl_keep isl_basic_map *bmap);
 __isl_give isl_printer *isl_printer_print_basic_map(
 	__isl_take isl_printer *printer, __isl_keep isl_basic_map *bmap);
+__isl_give char *isl_map_to_str(__isl_keep isl_map *map);
 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *printer,
 	__isl_keep isl_map *map);
 __isl_give isl_basic_map *isl_basic_map_fix_si(__isl_take isl_basic_map *bmap,
@@ -228,21 +216,27 @@
 __isl_give isl_basic_map *isl_basic_map_upper_bound_si(
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos, int value);
-
-struct isl_basic_map *isl_basic_map_sum(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2);
-struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap);
-
-struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2);
-struct isl_map *isl_map_neg(struct isl_map *map);
+__isl_overload
+__isl_give isl_map *isl_map_lower_bound_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *lower);
+__isl_overload
+__isl_give isl_map *isl_map_upper_bound_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *upper);
+
+__isl_give isl_basic_map *isl_basic_map_sum(__isl_take isl_basic_map *bmap1,
+	__isl_take isl_basic_map *bmap2);
+__isl_give isl_basic_map *isl_basic_map_neg(__isl_take isl_basic_map *bmap);
+
+__isl_give isl_map *isl_map_sum(__isl_take isl_map *map1,
+	__isl_take isl_map *map2);
+__isl_give isl_map *isl_map_neg(__isl_take isl_map *map);
 __isl_give isl_map *isl_map_floordiv_val(__isl_take isl_map *map,
 	__isl_take isl_val *d);
 
 __isl_export
-int isl_basic_map_is_equal(
-		__isl_keep isl_basic_map *bmap1,
-		__isl_keep isl_basic_map *bmap2);
-int isl_basic_map_is_disjoint(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_is_equal(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2);
+isl_bool isl_basic_map_is_disjoint(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2);
 
 __isl_give isl_map *isl_basic_map_partial_lexmax(
@@ -273,70 +267,68 @@
 	__isl_give isl_set **empty);
 __isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff(
 	__isl_take isl_basic_map *bmap);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_map_lexmin_pw_multi_aff(
 	__isl_take isl_map *map);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_map_lexmax_pw_multi_aff(
 	__isl_take isl_map *map);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_map_min_multi_pw_aff(__isl_take isl_map *map);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_map_max_multi_pw_aff(__isl_take isl_map *map);
 
 void isl_basic_map_print_internal(__isl_keep isl_basic_map *bmap,
 	FILE *out, int indent);
 
-struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map);
-__isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
-						__isl_keep isl_basic_map *bmap);
-
 __isl_give isl_val *isl_basic_map_plain_get_val_if_fixed(
 	__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos);
 
-int isl_basic_map_image_is_bounded(__isl_keep isl_basic_map *bmap);
-int isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
-int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
-ISL_DEPRECATED
-int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_image_is_bounded(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_plain_is_universe(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap);
 __isl_export
-int isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap);
 __isl_export
-int isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
-int isl_basic_map_is_strict_subset(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_is_strict_subset(__isl_keep isl_basic_map *bmap1,
 		__isl_keep isl_basic_map *bmap2);
 
-struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned in, unsigned out, int n,
-		unsigned flags);
-__isl_give isl_map *isl_map_universe(__isl_take isl_space *dim);
-__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim);
-__isl_give isl_map *isl_map_empty(__isl_take isl_space *dim);
-struct isl_map *isl_map_empty_like(struct isl_map *model);
-struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model);
-struct isl_map *isl_map_dup(struct isl_map *map);
-__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
-						__isl_take isl_basic_map *bmap);
-__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim);
-struct isl_map *isl_map_identity_like(struct isl_map *model);
-struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model);
-__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n);
-__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n);
-__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim);
-__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim);
-__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n);
-__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n);
-__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim);
-__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim);
-struct isl_map *isl_map_finalize(struct isl_map *map);
+__isl_export
+__isl_give isl_map *isl_map_universe(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_map *isl_space_universe_map(__isl_take isl_space *space);
+__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_map *isl_map_empty(__isl_take isl_space *space);
+__isl_give isl_map *isl_map_identity(__isl_take isl_space *space);
+__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *space,
+	unsigned n);
+__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *space,
+	unsigned n);
+__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_space);
+__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_space);
+__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *space,
+	unsigned n);
+__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *space,
+	unsigned n);
+__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_space);
+__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_space);
 __isl_null isl_map *isl_map_free(__isl_take isl_map *map);
 __isl_give isl_map *isl_map_copy(__isl_keep isl_map *map);
-struct isl_map *isl_map_extend(struct isl_map *base,
-		unsigned nparam, unsigned n_in, unsigned n_out);
 __isl_export
 __isl_give isl_map *isl_map_reverse(__isl_take isl_map *map);
 __isl_export
+__isl_give isl_map *isl_map_range_reverse(__isl_take isl_map *map);
+__isl_export
 __isl_give isl_map *isl_map_union(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
-struct isl_map *isl_map_union_disjoint(
-			struct isl_map *map1, struct isl_map *map2);
+__isl_give isl_map *isl_map_union_disjoint(
+		__isl_take isl_map *map1, __isl_take isl_map *map2);
 __isl_export
 __isl_give isl_map *isl_map_intersect_domain(
 		__isl_take isl_map *map,
@@ -346,6 +338,18 @@
 		__isl_take isl_map *map,
 		__isl_take isl_set *set);
 __isl_export
+__isl_give isl_map *isl_map_intersect_domain_factor_domain(
+	__isl_take isl_map *map, __isl_take isl_map *factor);
+__isl_export
+__isl_give isl_map *isl_map_intersect_domain_factor_range(
+	__isl_take isl_map *map, __isl_take isl_map *factor);
+__isl_export
+__isl_give isl_map *isl_map_intersect_range_factor_domain(
+	__isl_take isl_map *map, __isl_take isl_map *factor);
+__isl_export
+__isl_give isl_map *isl_map_intersect_range_factor_range(
+	__isl_take isl_map *map, __isl_take isl_map *factor);
+__isl_export
 __isl_give isl_map *isl_map_apply_domain(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
@@ -353,26 +357,34 @@
 __isl_give isl_map *isl_map_apply_range(
 		__isl_take isl_map *map1,
 		__isl_take isl_map *map2);
+__isl_overload
 __isl_give isl_map *isl_map_preimage_domain_multi_aff(__isl_take isl_map *map,
 	__isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_map *isl_map_preimage_range_multi_aff(__isl_take isl_map *map,
 	__isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_map *isl_map_preimage_domain_pw_multi_aff(
 	__isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_map *isl_map_preimage_range_pw_multi_aff(
 	__isl_take isl_map *map, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_map *isl_map_preimage_domain_multi_pw_aff(
 	__isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa);
 __isl_give isl_basic_map *isl_basic_map_product(
 	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2);
+__isl_export
 __isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
 __isl_give isl_basic_map *isl_basic_map_domain_product(
 	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2);
 __isl_give isl_basic_map *isl_basic_map_range_product(
 	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2);
+__isl_export
 __isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
+__isl_export
 __isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
 __isl_give isl_basic_map *isl_basic_map_flat_product(
@@ -385,9 +397,20 @@
 	__isl_take isl_map *map2);
 __isl_give isl_map *isl_map_flat_range_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
-int isl_map_domain_is_wrapping(__isl_keep isl_map *map);
-int isl_map_range_is_wrapping(__isl_keep isl_map *map);
+isl_bool isl_map_domain_is_wrapping(__isl_keep isl_map *map);
+isl_bool isl_map_range_is_wrapping(__isl_keep isl_map *map);
+isl_bool isl_map_is_product(__isl_keep isl_map *map);
+__isl_export
+__isl_give isl_map *isl_map_factor_domain(__isl_take isl_map *map);
+__isl_export
+__isl_give isl_map *isl_map_factor_range(__isl_take isl_map *map);
+__isl_export
+__isl_give isl_map *isl_map_domain_factor_domain(__isl_take isl_map *map);
+__isl_export
+__isl_give isl_map *isl_map_domain_factor_range(__isl_take isl_map *map);
+__isl_export
 __isl_give isl_map *isl_map_range_factor_domain(__isl_take isl_map *map);
+__isl_export
 __isl_give isl_map *isl_map_range_factor_range(__isl_take isl_map *map);
 __isl_export
 __isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
@@ -405,7 +428,7 @@
 	__isl_take isl_set *dom);
 __isl_export
 __isl_give isl_map *isl_map_complement(__isl_take isl_map *map);
-struct isl_map *isl_map_fix_input_si(struct isl_map *map,
+__isl_give isl_map *isl_map_fix_input_si(__isl_take isl_map *map,
 		unsigned input, int value);
 __isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned pos, int value);
@@ -413,8 +436,12 @@
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *v);
 __isl_give isl_map *isl_map_lower_bound_si(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_map *isl_map_lower_bound_val(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
 __isl_give isl_map *isl_map_upper_bound_si(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_map *isl_map_upper_bound_val(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
 __isl_export
 __isl_give isl_basic_set *isl_basic_map_deltas(__isl_take isl_basic_map *bmap);
 __isl_export
@@ -429,7 +456,7 @@
 __isl_give isl_basic_map *isl_map_convex_hull(__isl_take isl_map *map);
 __isl_export
 __isl_give isl_basic_map *isl_map_polyhedral_hull(__isl_take isl_map *map);
-__isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap,
+__isl_give isl_basic_map *isl_basic_map_add_dims(__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned n);
 __isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned n);
@@ -450,6 +477,8 @@
 		enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_map *isl_map_project_out(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned first, unsigned n);
+__isl_export
+__isl_give isl_map *isl_map_project_out_all_params(__isl_take isl_map *map);
 __isl_give isl_basic_map *isl_basic_map_remove_divs(
 	__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_remove_unknown_divs(__isl_take isl_map *map);
@@ -463,7 +492,7 @@
 	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_map *isl_map_remove_divs_involving_dims(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n);
-struct isl_map *isl_map_remove_inputs(struct isl_map *map,
+__isl_give isl_map *isl_map_remove_inputs(__isl_take isl_map *map,
 	unsigned first, unsigned n);
 
 __isl_give isl_basic_map *isl_basic_map_equate(__isl_take isl_basic_map *bmap,
@@ -486,15 +515,19 @@
 	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2);
 
 __isl_export
+__isl_give isl_map *isl_set_translation(__isl_take isl_set *deltas);
+__isl_export
 __isl_give isl_map *isl_set_identity(__isl_take isl_set *set);
 
 __isl_export
-int isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset);
 __isl_export
-int isl_set_is_wrapping(__isl_keep isl_set *set);
+isl_bool isl_set_is_wrapping(__isl_keep isl_set *set);
 __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap);
+__isl_export
 __isl_give isl_set *isl_map_wrap(__isl_take isl_map *map);
 __isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset);
+__isl_export
 __isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set);
 __isl_export
 __isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap);
@@ -516,10 +549,16 @@
 __isl_give isl_set *isl_set_flatten(__isl_take isl_set *set);
 __isl_give isl_map *isl_set_flatten_map(__isl_take isl_set *set);
 __isl_give isl_set *isl_map_params(__isl_take isl_map *map);
+__isl_export
 __isl_give isl_set *isl_map_domain(__isl_take isl_map *bmap);
+__isl_export
 __isl_give isl_set *isl_map_range(__isl_take isl_map *map);
+__isl_export
+__isl_give isl_map *isl_set_insert_domain(__isl_take isl_set *set,
+	__isl_take isl_space *domain);
 __isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map);
 __isl_give isl_map *isl_map_range_map(__isl_take isl_map *map);
+__isl_give isl_map *isl_set_wrapped_domain_map(__isl_take isl_set *set);
 __isl_constructor
 __isl_give isl_map *isl_map_from_basic_map(__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_from_domain(__isl_take isl_set *set);
@@ -532,68 +571,87 @@
 	__isl_take isl_basic_set *domain, __isl_take isl_basic_set *range);
 __isl_give isl_map *isl_map_from_domain_and_range(__isl_take isl_set *domain,
 	__isl_take isl_set *range);
-__isl_give isl_map *isl_map_from_set(__isl_take isl_set *set,
-	__isl_take isl_space *dim);
-struct isl_set *isl_set_from_map(struct isl_map *map);
 __isl_export
 __isl_give isl_basic_map *isl_map_sample(__isl_take isl_map *map);
 
-int isl_map_plain_is_empty(__isl_keep isl_map *map);
-ISL_DEPRECATED
-int isl_map_fast_is_empty(__isl_keep isl_map *map);
-int isl_map_plain_is_universe(__isl_keep isl_map *map);
 __isl_export
-int isl_map_is_empty(__isl_keep isl_map *map);
+__isl_give isl_set *isl_map_bind_domain(__isl_take isl_map *map,
+	__isl_take isl_multi_id *tuple);
+__isl_export
+__isl_give isl_set *isl_map_bind_range(__isl_take isl_map *map,
+	__isl_take isl_multi_id *tuple);
+
+isl_bool isl_map_plain_is_empty(__isl_keep isl_map *map);
+isl_bool isl_map_plain_is_universe(__isl_keep isl_map *map);
 __isl_export
-int isl_map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
+isl_bool isl_map_is_empty(__isl_keep isl_map *map);
 __isl_export
-int isl_map_is_strict_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
+isl_bool isl_map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
 __isl_export
-int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
+isl_bool isl_map_is_strict_subset(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
 __isl_export
-int isl_map_is_disjoint(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
-int isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap);
-int isl_map_plain_is_single_valued(__isl_keep isl_map *map);
+isl_bool isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
 __isl_export
-int isl_map_is_single_valued(__isl_keep isl_map *map);
-int isl_map_plain_is_injective(__isl_keep isl_map *map);
+isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
+isl_bool isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap);
+isl_bool isl_map_plain_is_single_valued(__isl_keep isl_map *map);
 __isl_export
-int isl_map_is_injective(__isl_keep isl_map *map);
+isl_bool isl_map_is_single_valued(__isl_keep isl_map *map);
+isl_bool isl_map_plain_is_injective(__isl_keep isl_map *map);
 __isl_export
-int isl_map_is_bijective(__isl_keep isl_map *map);
+isl_bool isl_map_is_injective(__isl_keep isl_map *map);
+__isl_export
+isl_bool isl_map_is_bijective(__isl_keep isl_map *map);
+isl_bool isl_map_is_identity(__isl_keep isl_map *map);
 int isl_map_is_translation(__isl_keep isl_map *map);
-int isl_map_has_equal_space(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
+isl_bool isl_map_has_equal_space(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
 
-int isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap);
-int isl_map_can_zip(__isl_keep isl_map *map);
+isl_bool isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap);
+isl_bool isl_map_can_zip(__isl_keep isl_map *map);
 __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap);
+__isl_export
 __isl_give isl_map *isl_map_zip(__isl_take isl_map *map);
 
-int isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap);
-int isl_map_can_curry(__isl_keep isl_map *map);
+isl_bool isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap);
+isl_bool isl_map_can_curry(__isl_keep isl_map *map);
 __isl_give isl_basic_map *isl_basic_map_curry(__isl_take isl_basic_map *bmap);
+__isl_export
 __isl_give isl_map *isl_map_curry(__isl_take isl_map *map);
 
-int isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap);
-int isl_map_can_uncurry(__isl_keep isl_map *map);
+isl_bool isl_map_can_range_curry(__isl_keep isl_map *map);
+__isl_give isl_map *isl_map_range_curry(__isl_take isl_map *map);
+
+isl_bool isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap);
+isl_bool isl_map_can_uncurry(__isl_keep isl_map *map);
 __isl_give isl_basic_map *isl_basic_map_uncurry(__isl_take isl_basic_map *bmap);
+__isl_export
 __isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map);
 
 __isl_give isl_map *isl_map_make_disjoint(__isl_take isl_map *map);
 __isl_give isl_map *isl_basic_map_compute_divs(__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_compute_divs(__isl_take isl_map *map);
+ISL_DEPRECATED
 __isl_give isl_map *isl_map_align_divs(__isl_take isl_map *map);
 
 __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_map *isl_map_drop_constraints_involving_dims(
 	__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_map *isl_map_drop_constraints_not_involving_dims(
+	__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n);
 
-int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n);
-int isl_map_involves_dims(__isl_keep isl_map *map,
+isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
 void isl_map_print_internal(__isl_keep isl_map *map, FILE *out, int indent);
@@ -601,6 +659,8 @@
 __isl_give isl_val *isl_map_plain_get_val_if_fixed(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos);
 
+__isl_give isl_basic_map *isl_basic_map_gist_domain(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *context);
 __isl_export
 __isl_give isl_basic_map *isl_basic_map_gist(__isl_take isl_basic_map *bmap,
 	__isl_take isl_basic_map *context);
@@ -617,29 +677,34 @@
 __isl_give isl_map *isl_map_gist_basic_map(__isl_take isl_map *map,
 	__isl_take isl_basic_map *context);
 
+__isl_give isl_stride_info *isl_map_get_range_stride_info(
+	__isl_keep isl_map *map, int pos);
+__isl_export
+__isl_give isl_fixed_box *isl_map_get_range_simple_fixed_box_hull(
+	__isl_keep isl_map *map);
+
 __isl_export
 __isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map);
 
-int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
-ISL_DEPRECATED
-int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2);
+isl_bool isl_map_plain_is_equal(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
 
 uint32_t isl_map_get_hash(__isl_keep isl_map *map);
 
-int isl_map_n_basic_map(__isl_keep isl_map *map);
+isl_size isl_map_n_basic_map(__isl_keep isl_map *map);
 __isl_export
-int isl_map_foreach_basic_map(__isl_keep isl_map *map,
-	int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user);
-
-__isl_give isl_map *isl_set_lifting(__isl_take isl_set *set);
+isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
+	isl_stat (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user);
+__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
+	__isl_keep isl_map *map);
 
 __isl_give isl_map *isl_map_fixed_power_val(__isl_take isl_map *map,
 	__isl_take isl_val *exp);
-__isl_give isl_map *isl_map_power(__isl_take isl_map *map, int *exact);
+__isl_give isl_map *isl_map_power(__isl_take isl_map *map, isl_bool *exact);
 __isl_give isl_map *isl_map_reaching_path_lengths(__isl_take isl_map *map,
-	int *exact);
+	isl_bool *exact);
 __isl_give isl_map *isl_map_transitive_closure(__isl_take isl_map *map,
-	int *exact);
+	isl_bool *exact);
 
 __isl_give isl_map *isl_map_lex_le_map(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
@@ -650,10 +715,29 @@
 __isl_give isl_map *isl_map_lex_gt_map(__isl_take isl_map *map1,
 	__isl_take isl_map *map2);
 
+__isl_overload
+__isl_give isl_map *isl_map_eq_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_overload
+__isl_give isl_map *isl_map_lex_lt_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_overload
+__isl_give isl_map *isl_map_lex_le_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_overload
+__isl_give isl_map *isl_map_lex_gt_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa);
+__isl_overload
+__isl_give isl_map *isl_map_lex_ge_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa);
+
 __isl_give isl_basic_map *isl_basic_map_align_params(
 	__isl_take isl_basic_map *bmap, __isl_take isl_space *model);
 __isl_give isl_map *isl_map_align_params(__isl_take isl_map *map,
 	__isl_take isl_space *model);
+__isl_give isl_basic_map *isl_basic_map_drop_unused_params(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_map *isl_map_drop_unused_params(__isl_take isl_map *map);
 
 __isl_give isl_mat *isl_basic_map_equalities_matrix(
 		__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
@@ -664,7 +748,7 @@
 		enum isl_dim_type c2, enum isl_dim_type c3,
 		enum isl_dim_type c4, enum isl_dim_type c5);
 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
-	__isl_take isl_space *dim,
+	__isl_take isl_space *space,
 	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3,
 	enum isl_dim_type c4, enum isl_dim_type c5);
@@ -673,17 +757,21 @@
 __isl_give isl_basic_map *isl_basic_map_from_multi_aff(
 	__isl_take isl_multi_aff *maff);
 __isl_give isl_basic_map *isl_basic_map_from_aff_list(
-	__isl_take isl_space *domain_dim, __isl_take isl_aff_list *list);
+	__isl_take isl_space *domain_space, __isl_take isl_aff_list *list);
 
 __isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff);
+__isl_export
+__isl_give isl_map *isl_multi_aff_as_map(__isl_take isl_multi_aff *ma);
 __isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff);
 
+__isl_give isl_pw_aff *isl_map_dim_min(__isl_take isl_map *map, int pos);
 __isl_give isl_pw_aff *isl_map_dim_max(__isl_take isl_map *map, int pos);
 
+ISL_DECLARE_LIST_FN(basic_map)
+ISL_DECLARE_LIST_FN(map)
+
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/map_to_basic_set.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/map_to_basic_set.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/map_type.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/map_type.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/mat.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/mat.h Changed

@@ -14,7 +14,7 @@
 
 #include <isl/ctx.h>
 #include <isl/vec.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -27,16 +27,14 @@
 
 __isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
 	unsigned n_row, unsigned n_col);
-struct isl_mat *isl_mat_dup(struct isl_mat *mat);
-struct isl_mat *isl_mat_extend(struct isl_mat *mat,
+__isl_give isl_mat *isl_mat_extend(__isl_take isl_mat *mat,
 	unsigned n_row, unsigned n_col);
-struct isl_mat *isl_mat_identity(struct isl_ctx *ctx, unsigned n_row);
+__isl_give isl_mat *isl_mat_identity(isl_ctx *ctx, unsigned n_row);
 __isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat);
-struct isl_mat *isl_mat_cow(struct isl_mat *mat);
 __isl_null isl_mat *isl_mat_free(__isl_take isl_mat *mat);
 
-int isl_mat_rows(__isl_keep isl_mat *mat);
-int isl_mat_cols(__isl_keep isl_mat *mat);
+isl_size isl_mat_rows(__isl_keep isl_mat *mat);
+isl_size isl_mat_cols(__isl_keep isl_mat *mat);
 __isl_give isl_val *isl_mat_get_element_val(__isl_keep isl_mat *mat,
 	int row, int col);
 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
@@ -44,34 +42,38 @@
 __isl_give isl_mat *isl_mat_set_element_val(__isl_take isl_mat *mat,
 	int row, int col, __isl_take isl_val *v);
 
-struct isl_mat *isl_mat_swap_cols(struct isl_mat *mat, unsigned i, unsigned j);
-struct isl_mat *isl_mat_swap_rows(struct isl_mat *mat, unsigned i, unsigned j);
+__isl_give isl_mat *isl_mat_swap_cols(__isl_take isl_mat *mat,
+	unsigned i, unsigned j);
+__isl_give isl_mat *isl_mat_swap_rows(__isl_take isl_mat *mat,
+	unsigned i, unsigned j);
 
-struct isl_vec *isl_mat_vec_product(struct isl_mat *mat, struct isl_vec *vec);
-struct isl_vec *isl_vec_mat_product(struct isl_vec *vec, struct isl_mat *mat);
+__isl_give isl_vec *isl_mat_vec_product(__isl_take isl_mat *mat,
+	__isl_take isl_vec *vec);
+__isl_give isl_vec *isl_vec_mat_product(__isl_take isl_vec *vec,
+	__isl_take isl_mat *mat);
 __isl_give isl_vec *isl_mat_vec_inverse_product(__isl_take isl_mat *mat,
 						__isl_take isl_vec *vec);
-struct isl_mat *isl_mat_aff_direct_sum(struct isl_mat *left,
-					struct isl_mat *right);
+__isl_give isl_mat *isl_mat_aff_direct_sum(__isl_take isl_mat *left,
+	__isl_take isl_mat *right);
 __isl_give isl_mat *isl_mat_diagonal(__isl_take isl_mat *mat1,
 	__isl_take isl_mat *mat2);
-struct isl_mat *isl_mat_left_hermite(struct isl_mat *M,
-	int neg, struct isl_mat **U, struct isl_mat **Q);
-struct isl_mat *isl_mat_lin_to_aff(struct isl_mat *mat);
-struct isl_mat *isl_mat_inverse_product(struct isl_mat *left,
-	struct isl_mat *right);
+__isl_give isl_mat *isl_mat_left_hermite(__isl_take isl_mat *M, int neg,
+	__isl_give isl_mat **U, __isl_give isl_mat **Q);
+__isl_give isl_mat *isl_mat_lin_to_aff(__isl_take isl_mat *mat);
+__isl_give isl_mat *isl_mat_inverse_product(__isl_take isl_mat *left,
+	__isl_take isl_mat *right);
 __isl_give isl_mat *isl_mat_product(__isl_take isl_mat *left,
 	__isl_take isl_mat *right);
-struct isl_mat *isl_mat_transpose(struct isl_mat *mat);
+__isl_give isl_mat *isl_mat_transpose(__isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat);
 
 __isl_give isl_mat *isl_mat_normalize(__isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_normalize_row(__isl_take isl_mat *mat, int row);
 
-struct isl_mat *isl_mat_drop_cols(struct isl_mat *mat,
-				unsigned col, unsigned n);
-struct isl_mat *isl_mat_drop_rows(struct isl_mat *mat,
+__isl_give isl_mat *isl_mat_drop_cols(__isl_take isl_mat *mat,
+	unsigned col, unsigned n);
+__isl_give isl_mat *isl_mat_drop_rows(__isl_take isl_mat *mat,
 				unsigned row, unsigned n);
 __isl_give isl_mat *isl_mat_insert_cols(__isl_take isl_mat *mat,
 				unsigned col, unsigned n);
@@ -89,7 +91,10 @@
 
 void isl_mat_col_add(__isl_keep isl_mat *mat, int dst_col, int src_col);
 
-struct isl_mat *isl_mat_unimodular_complete(struct isl_mat *M, int row);
+__isl_give isl_mat *isl_mat_unimodular_complete(__isl_take isl_mat *M, int row);
+__isl_give isl_mat *isl_mat_row_basis(__isl_take isl_mat *mat);
+__isl_give isl_mat *isl_mat_row_basis_extension(
+	__isl_take isl_mat *mat1, __isl_take isl_mat *mat2);
 
 __isl_give isl_mat *isl_mat_from_row_vec(__isl_take isl_vec *vec);
 __isl_give isl_mat *isl_mat_concat(__isl_take isl_mat *top,
@@ -97,8 +102,11 @@
 __isl_give isl_mat *isl_mat_vec_concat(__isl_take isl_mat *top,
 	__isl_take isl_vec *bot);
 
-int isl_mat_is_equal(__isl_keep isl_mat *mat1, __isl_keep isl_mat *mat2);
+isl_bool isl_mat_is_equal(__isl_keep isl_mat *mat1, __isl_keep isl_mat *mat2);
+isl_bool isl_mat_has_linearly_independent_rows(__isl_keep isl_mat *mat1,
+	__isl_keep isl_mat *mat2);
 
+isl_size isl_mat_rank(__isl_keep isl_mat *mat);
 int isl_mat_initial_non_zero_cols(__isl_keep isl_mat *mat);
 
 void isl_mat_print_internal(__isl_keep isl_mat *mat, FILE *out, int indent);

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe_ast_expr.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe_basic_set.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe_id.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe_pw_aff.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/maybe_templ.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/multi.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/multi.h Changed

@@ -1,7 +1,8 @@
 #ifndef ISL_MULTI_H
 #define ISL_MULTI_H
 
-#include <isl/space.h>
+#include <isl/val_type.h>
+#include <isl/space_type.h>
 #include <isl/list.h>
 #include <isl/set_type.h>
 
@@ -10,105 +11,266 @@
 #endif
 
 #define ISL_DECLARE_MULTI(BASE)						\
-unsigned isl_multi_##BASE##_dim(__isl_keep isl_multi_##BASE *multi,	\
-	enum isl_dim_type type);					\
 isl_ctx *isl_multi_##BASE##_get_ctx(					\
 	__isl_keep isl_multi_##BASE *multi);				\
+__isl_export								\
 __isl_give isl_space *isl_multi_##BASE##_get_space(			\
 	__isl_keep isl_multi_##BASE *multi);				\
 __isl_give isl_space *isl_multi_##BASE##_get_domain_space(		\
 	__isl_keep isl_multi_##BASE *multi);				\
+__isl_export								\
+__isl_give isl_##BASE##_list *isl_multi_##BASE##_get_list(		\
+	__isl_keep isl_multi_##BASE *multi);				\
+__isl_constructor							\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_from_##BASE##_list(	\
 	__isl_take isl_space *space, __isl_take isl_##BASE##_list *list); \
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_zero(			\
-	__isl_take isl_space *space);					\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_space_multi_##BASE(			\
+	__isl_take isl_space *space, __isl_take isl_##BASE##_list *list); \
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_copy(			\
 	__isl_keep isl_multi_##BASE *multi);				\
 __isl_null isl_multi_##BASE *isl_multi_##BASE##_free(			\
 	__isl_take isl_multi_##BASE *multi);				\
-int isl_multi_##BASE##_plain_is_equal(					\
+__isl_export								\
+isl_bool isl_multi_##BASE##_plain_is_equal(				\
 	__isl_keep isl_multi_##BASE *multi1,				\
 	__isl_keep isl_multi_##BASE *multi2);				\
-int isl_multi_##BASE##_find_dim_by_id(					\
-	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type,	\
-	__isl_keep isl_id *id);						\
-__isl_give isl_id *isl_multi_##BASE##_get_dim_id(			\
-	__isl_take isl_multi_##BASE *multi,				\
-	enum isl_dim_type type, unsigned pos);				\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_dim_name(		\
-	__isl_take isl_multi_##BASE *multi,				\
-	enum isl_dim_type type, unsigned pos, const char *s);		\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_dim_id(		\
-	__isl_take isl_multi_##BASE *multi,				\
-	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);	\
-const char *isl_multi_##BASE##_get_tuple_name(				\
-	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type);	\
-int isl_multi_##BASE##_has_tuple_id(__isl_keep isl_multi_##BASE *multi,	\
-	enum isl_dim_type type);					\
-__isl_give isl_id *isl_multi_##BASE##_get_tuple_id(			\
-	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type);	\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_tuple_name(		\
-	__isl_take isl_multi_##BASE *multi,				\
-	enum isl_dim_type type, const char *s);				\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_tuple_id(		\
-	__isl_take isl_multi_##BASE *multi,				\
-	enum isl_dim_type type, __isl_take isl_id *id);			\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_reset_tuple_id(		\
-	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type);	\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_reset_user(		\
 	__isl_take isl_multi_##BASE *multi);				\
-int isl_multi_##BASE##_involves_dims(					\
-	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type,	\
-	unsigned first, unsigned n);					\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_insert_dims(		\
-	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
-	unsigned first, unsigned n);					\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_add_dims(		\
-	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
-	unsigned n);							\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_drop_dims(		\
-	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
-	unsigned first, unsigned n);					\
+__isl_export								\
+isl_size isl_multi_##BASE##_size(__isl_keep isl_multi_##BASE *multi);	\
+__isl_export								\
+__isl_give isl_##BASE *isl_multi_##BASE##_get_at(			\
+	__isl_keep isl_multi_##BASE *multi, int pos);			\
 __isl_give isl_##BASE *isl_multi_##BASE##_get_##BASE(			\
 	__isl_keep isl_multi_##BASE *multi, int pos);			\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_at(			\
+	__isl_take isl_multi_##BASE *multi, int pos,			\
+	__isl_take isl_##BASE *el);					\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_set_##BASE(		\
 	__isl_take isl_multi_##BASE *multi, int pos,			\
 	__isl_take isl_##BASE *el);					\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_range_splice(		\
 	__isl_take isl_multi_##BASE *multi1, unsigned pos,		\
 	__isl_take isl_multi_##BASE *multi2);				\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_splice(			\
-	__isl_take isl_multi_##BASE *multi1, unsigned in_pos,		\
-	unsigned out_pos, __isl_take isl_multi_##BASE *multi2);		\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_flatten_range(		\
+	__isl_take isl_multi_##BASE *multi);				\
+__isl_export								\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_flat_range_product(	\
 	__isl_take isl_multi_##BASE *multi1,				\
 	__isl_take isl_multi_##BASE *multi2);				\
+__isl_export								\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_range_product(		\
 	__isl_take isl_multi_##BASE *multi1,				\
 	__isl_take isl_multi_##BASE *multi2);				\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_product(		\
-	__isl_take isl_multi_##BASE *multi1,				\
-	__isl_take isl_multi_##BASE *multi2);				\
-int isl_multi_##BASE##_range_is_wrapping(				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_factor_range(		\
+	__isl_take isl_multi_##BASE *multi);				\
+isl_bool isl_multi_##BASE##_range_is_wrapping(				\
 	__isl_keep isl_multi_##BASE *multi);				\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_range_factor_domain(	\
 	__isl_take isl_multi_##BASE *multi);				\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_range_factor_range(	\
 	__isl_take isl_multi_##BASE *multi);				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_align_params(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	__isl_take isl_space *model);					\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_from_range(		\
+	__isl_take isl_multi_##BASE *multi);
+
+#define ISL_DECLARE_MULTI_IDENTITY(BASE)				\
+__isl_overload								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_identity_multi_##BASE(	\
+	__isl_take isl_multi_##BASE *multi);				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_identity(		\
+	__isl_take isl_space *space);					\
+__isl_overload								\
+__isl_give isl_multi_##BASE *						\
+isl_multi_##BASE##_identity_on_domain_space(				\
+	__isl_take isl_space *space);					\
+__isl_export								\
+__isl_give isl_multi_##BASE *						\
+isl_space_identity_multi_##BASE##_on_domain(				\
+	__isl_take isl_space *space);
+
+#define ISL_DECLARE_MULTI_CMP(BASE)					\
+int isl_multi_##BASE##_plain_cmp(__isl_keep isl_multi_##BASE *multi1,	\
+	__isl_keep isl_multi_##BASE *multi2);
+
+#define ISL_DECLARE_MULTI_ARITH(BASE)					\
+__isl_overload								\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_scale_val(		\
 	__isl_take isl_multi_##BASE *multi, __isl_take isl_val *v);	\
+__isl_overload								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_scale_down_val(		\
+	__isl_take isl_multi_##BASE *multi, __isl_take isl_val *v);	\
+__isl_overload								\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_scale_multi_val(	\
 	__isl_take isl_multi_##BASE *multi,				\
 	__isl_take isl_multi_val *mv);					\
+__isl_overload								\
 __isl_give isl_multi_##BASE *isl_multi_##BASE##_scale_down_multi_val(	\
 	__isl_take isl_multi_##BASE *multi,				\
 	__isl_take isl_multi_val *mv);					\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_align_params(		\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_mod_multi_val(		\
 	__isl_take isl_multi_##BASE *multi,				\
-	__isl_take isl_space *model);					\
-__isl_give isl_multi_##BASE *isl_multi_##BASE##_from_range(		\
+	__isl_take isl_multi_val *mv);					\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_add(			\
+	__isl_take isl_multi_##BASE *multi1,				\
+	__isl_take isl_multi_##BASE *multi2);				\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_sub(			\
+	__isl_take isl_multi_##BASE *multi1,				\
+	__isl_take isl_multi_##BASE *multi2);				\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_neg(		 	\
 	__isl_take isl_multi_##BASE *multi);
 
+#define ISL_DECLARE_MULTI_MIN_MAX(BASE)					\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_min(			\
+	__isl_take isl_multi_##BASE *multi1,				\
+	__isl_take isl_multi_##BASE *multi2);				\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_max(			\
+	__isl_take isl_multi_##BASE *multi1,				\
+	__isl_take isl_multi_##BASE *multi2);
+
+#define ISL_DECLARE_MULTI_ADD_CONSTANT(BASE)				\
+__isl_overload								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_add_constant_val(	\
+	__isl_take isl_multi_##BASE *mpa, __isl_take isl_val *v);	\
+__isl_overload								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_add_constant_multi_val(	\
+	__isl_take isl_multi_##BASE *mpa, __isl_take isl_multi_val *mv);
+
+#define ISL_DECLARE_MULTI_ZERO(BASE)					\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_zero(			\
+	__isl_take isl_space *space);					\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_space_zero_multi_##BASE(		\
+	__isl_take isl_space *space);
+
+#define ISL_DECLARE_MULTI_NAN(BASE)					\
+__isl_export								\
+isl_bool isl_multi_##BASE##_involves_nan(				\
+	__isl_keep isl_multi_##BASE *multi);
+
+#define ISL_DECLARE_MULTI_DROP_DIMS(BASE)				\
+isl_size isl_multi_##BASE##_dim(__isl_keep isl_multi_##BASE *multi,	\
+	enum isl_dim_type type);					\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_drop_dims(		\
+	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
+	unsigned first, unsigned n);
+#define ISL_DECLARE_MULTI_DIMS(BASE)					\
+ISL_DECLARE_MULTI_DROP_DIMS(BASE)					\
+isl_bool isl_multi_##BASE##_involves_dims(				\
+	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type,	\
+	unsigned first, unsigned n);					\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_insert_dims(		\
+	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
+	unsigned first, unsigned n);					\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_add_dims(		\
+	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type,	\
+	unsigned n);							\
+__isl_give isl_multi_##BASE *						\
+isl_multi_##BASE##_project_domain_on_params(				\
+	__isl_take isl_multi_##BASE *multi);
+
+#define ISL_DECLARE_MULTI_INSERT_DOMAIN(BASE)				\
+__isl_export								\
+__isl_give isl_multi_##BASE *						\
+isl_multi_##BASE##_insert_domain(__isl_take isl_multi_##BASE *multi,	\
+	__isl_take isl_space *domain);
+
+#define ISL_DECLARE_MULTI_LOCALS(BASE)					\
+__isl_export								\
+isl_bool isl_multi_##BASE##_involves_locals(				\
+	__isl_keep isl_multi_##BASE *multi);
+
+#define ISL_DECLARE_MULTI_DIM_ID(BASE)					\
+int isl_multi_##BASE##_find_dim_by_name(				\
+	__isl_keep isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, const char *name);			\
+int isl_multi_##BASE##_find_dim_by_id(					\
+	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type,	\
+	__isl_keep isl_id *id);						\
+__isl_give isl_id *isl_multi_##BASE##_get_dim_id(			\
+	__isl_keep isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, unsigned pos);				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_dim_name(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, unsigned pos, const char *s);		\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_dim_id(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
+
+#define ISL_DECLARE_MULTI_TUPLE_ID(BASE)				\
+const char *isl_multi_##BASE##_get_tuple_name(				\
+	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type);	\
+__isl_export								\
+isl_bool isl_multi_##BASE##_has_range_tuple_id(				\
+	__isl_keep isl_multi_##BASE *multi);				\
+isl_bool isl_multi_##BASE##_has_tuple_id(				\
+	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type);	\
+__isl_export								\
+__isl_give isl_id *isl_multi_##BASE##_get_range_tuple_id(		\
+	__isl_keep isl_multi_##BASE *multi);				\
+__isl_give isl_id *isl_multi_##BASE##_get_tuple_id(			\
+	__isl_keep isl_multi_##BASE *multi, enum isl_dim_type type);	\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_tuple_name(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, const char *s);				\
+__isl_overload								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_range_tuple_id(	\
+	__isl_take isl_multi_##BASE *multi,  __isl_take isl_id *id);	\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_set_tuple_id(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	enum isl_dim_type type, __isl_take isl_id *id);			\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_reset_range_tuple_id(	\
+	__isl_take isl_multi_##BASE *multi);				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_reset_tuple_id(		\
+	__isl_take isl_multi_##BASE *multi, enum isl_dim_type type);
+
+#define ISL_DECLARE_MULTI_WITH_DOMAIN(BASE)				\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_product(		\
+	__isl_take isl_multi_##BASE *multi1,				\
+	__isl_take isl_multi_##BASE *multi2);				\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_splice(			\
+	__isl_take isl_multi_##BASE *multi1, unsigned in_pos,		\
+	unsigned out_pos, __isl_take isl_multi_##BASE *multi2);
+
+#define ISL_DECLARE_MULTI_BIND_DOMAIN(BASE)				\
+__isl_export								\
+__isl_give isl_multi_##BASE *isl_multi_##BASE##_bind_domain(		\
+	__isl_take isl_multi_##BASE *multi,				\
+	__isl_take isl_multi_id *tuple);				\
+__isl_export								\
+__isl_give isl_multi_##BASE *						\
+isl_multi_##BASE##_bind_domain_wrapped_domain(				\
+	__isl_take isl_multi_##BASE *multi,				\
+	__isl_take isl_multi_id *tuple);
+
+#define ISL_DECLARE_MULTI_UNBIND_PARAMS(BASE)				\
+__isl_export								\
+__isl_give isl_multi_##BASE *						\
+isl_multi_##BASE##_unbind_params_insert_domain(				\
+	__isl_take isl_multi_##BASE *multi,				\
+	__isl_take isl_multi_id *domain);
+
+#define ISL_DECLARE_MULTI_PARAM(BASE)					\
+__isl_overload								\
+isl_bool isl_multi_##BASE##_involves_param_id(				\
+	__isl_keep isl_multi_##BASE *multi, __isl_keep isl_id *id);	\
+__isl_overload								\
+isl_bool isl_multi_##BASE##_involves_param_id_list(			\
+	__isl_keep isl_multi_##BASE *multi,				\
+	__isl_keep isl_id_list *list);
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/obj.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/obj.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/options.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/options.h Changed

@@ -23,26 +23,32 @@
 
 #define			ISL_BOUND_BERNSTEIN	0
 #define			ISL_BOUND_RANGE		1
-int isl_options_set_bound(isl_ctx *ctx, int val);
+isl_stat isl_options_set_bound(isl_ctx *ctx, int val);
 int isl_options_get_bound(isl_ctx *ctx);
 
 #define			ISL_ON_ERROR_WARN	0
 #define			ISL_ON_ERROR_CONTINUE	1
 #define			ISL_ON_ERROR_ABORT	2
-int isl_options_set_on_error(isl_ctx *ctx, int val);
+isl_stat isl_options_set_on_error(isl_ctx *ctx, int val);
 int isl_options_get_on_error(isl_ctx *ctx);
 
-int isl_options_set_gbr_only_first(isl_ctx *ctx, int val);
+isl_stat isl_options_set_gbr_only_first(isl_ctx *ctx, int val);
 int isl_options_get_gbr_only_first(isl_ctx *ctx);
 
 #define		ISL_SCHEDULE_ALGORITHM_ISL		0
 #define		ISL_SCHEDULE_ALGORITHM_FEAUTRIER	1
-int isl_options_set_schedule_algorithm(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_algorithm(isl_ctx *ctx, int val);
 int isl_options_get_schedule_algorithm(isl_ctx *ctx);
 
-int isl_options_set_coalesce_bounded_wrapping(isl_ctx *ctx, int val);
+isl_stat isl_options_set_pip_symmetry(isl_ctx *ctx, int val);
+int isl_options_get_pip_symmetry(isl_ctx *ctx);
+
+isl_stat isl_options_set_coalesce_bounded_wrapping(isl_ctx *ctx, int val);
 int isl_options_get_coalesce_bounded_wrapping(isl_ctx *ctx);
 
+isl_stat isl_options_set_coalesce_preserve_locals(isl_ctx *ctx, int val);
+int isl_options_get_coalesce_preserve_locals(isl_ctx *ctx);
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/point.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/point.h Changed

@@ -2,44 +2,45 @@
 #define ISL_POINT_H
 
 #include <stdio.h>
-#include <isl/space.h>
-#include <isl/val.h>
+#include <isl/space_type.h>
+#include <isl/val_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_point;
+struct __isl_subclass(isl_basic_set) isl_point;
 typedef struct isl_point isl_point;
 
 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt);
 __isl_give isl_space *isl_point_get_space(__isl_keep isl_point *pnt);
 
-__isl_give isl_point *isl_point_zero(__isl_take isl_space *dim);
+__isl_give isl_point *isl_point_zero(__isl_take isl_space *space);
 __isl_give isl_point *isl_point_copy(__isl_keep isl_point *pnt);
-void isl_point_free(__isl_take isl_point *pnt);
+__isl_null isl_point *isl_point_free(__isl_take isl_point *pnt);
 
 __isl_give isl_val *isl_point_get_coordinate_val(__isl_keep isl_point *pnt,
 	enum isl_dim_type type, int pos);
 __isl_give isl_point *isl_point_set_coordinate_val(__isl_take isl_point *pnt,
 	enum isl_dim_type type, int pos, __isl_take isl_val *v);
+__isl_export
+__isl_give isl_multi_val *isl_point_get_multi_val(__isl_keep isl_point *pnt);
 
 __isl_give isl_point *isl_point_add_ui(__isl_take isl_point *pnt,
 	enum isl_dim_type type, int pos, unsigned val);
 __isl_give isl_point *isl_point_sub_ui(__isl_take isl_point *pnt,
 	enum isl_dim_type type, int pos, unsigned val);
 
-__isl_give isl_point *isl_point_void(__isl_take isl_space *dim);
-int isl_point_is_void(__isl_keep isl_point *pnt);
+__isl_give isl_point *isl_point_void(__isl_take isl_space *space);
+isl_bool isl_point_is_void(__isl_keep isl_point *pnt);
 
 __isl_give isl_printer *isl_printer_print_point(
 	__isl_take isl_printer *printer, __isl_keep isl_point *pnt);
+__isl_give char *isl_point_to_str(__isl_keep isl_point *pnt);
 void isl_point_dump(__isl_keep isl_point *pnt);
 
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/polynomial.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/polynomial.h Changed

@@ -3,14 +3,14 @@
 
 #include <isl/ctx.h>
 #include <isl/constraint.h>
-#include <isl/space.h>
+#include <isl/space_type.h>
 #include <isl/set_type.h>
 #include <isl/point.h>
 #include <isl/printer.h>
 #include <isl/union_set_type.h>
 #include <isl/aff_type.h>
 #include <isl/polynomial_type.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -20,9 +20,9 @@
 __isl_give isl_space *isl_qpolynomial_get_domain_space(
 	__isl_keep isl_qpolynomial *qp);
 __isl_give isl_space *isl_qpolynomial_get_space(__isl_keep isl_qpolynomial *qp);
-unsigned isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp,
+isl_size isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp,
 	enum isl_dim_type type);
-int isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp,
+isl_bool isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
 __isl_give isl_val *isl_qpolynomial_get_constant_val(
@@ -32,25 +32,31 @@
 	__isl_take isl_qpolynomial *qp,
 	enum isl_dim_type type, unsigned pos, const char *s);
 
-__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(__isl_take isl_space *dim);
-__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(__isl_take isl_space *dim);
-__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(__isl_take isl_space *dim);
-__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(__isl_take isl_space *dim);
-__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(__isl_take isl_space *dim);
+__isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
+	__isl_take isl_space *domain);
+__isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
+	__isl_take isl_space *domain);
+__isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
+	__isl_take isl_space *domain);
+__isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
+	__isl_take isl_space *domain);
+__isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
+	__isl_take isl_space *domain);
 __isl_give isl_qpolynomial *isl_qpolynomial_val_on_domain(
 	__isl_take isl_space *space, __isl_take isl_val *val);
-__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(__isl_take isl_space *dim,
+__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
+	__isl_take isl_space *domain,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_qpolynomial *isl_qpolynomial_copy(__isl_keep isl_qpolynomial *qp);
 __isl_null isl_qpolynomial *isl_qpolynomial_free(
 	__isl_take isl_qpolynomial *qp);
 
-int isl_qpolynomial_plain_is_equal(__isl_keep isl_qpolynomial *qp1,
+isl_bool isl_qpolynomial_plain_is_equal(__isl_keep isl_qpolynomial *qp1,
 	__isl_keep isl_qpolynomial *qp2);
-int isl_qpolynomial_is_zero(__isl_keep isl_qpolynomial *qp);
-int isl_qpolynomial_is_nan(__isl_keep isl_qpolynomial *qp);
-int isl_qpolynomial_is_infty(__isl_keep isl_qpolynomial *qp);
-int isl_qpolynomial_is_neginfty(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_zero(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_nan(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_infty(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_neginfty(__isl_keep isl_qpolynomial *qp);
 int isl_qpolynomial_sgn(__isl_keep isl_qpolynomial *qp);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_neg(__isl_take isl_qpolynomial *qp);
@@ -64,6 +70,8 @@
 	unsigned power);
 __isl_give isl_qpolynomial *isl_qpolynomial_scale_val(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_val *v);
+__isl_give isl_qpolynomial *isl_qpolynomial_scale_down_val(
+	__isl_take isl_qpolynomial *qp, __isl_take isl_val *v);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_insert_dims(
 	__isl_take isl_qpolynomial *qp, enum isl_dim_type type,
@@ -85,9 +93,9 @@
 	enum isl_dim_type type, unsigned first, unsigned n,
 	__isl_keep isl_qpolynomial **subs);
 
-int isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
+isl_stat isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
 	__isl_keep isl_basic_set *bset,
-	int (*fn)(__isl_take isl_basic_set *bset,
+	isl_stat (*fn)(__isl_take isl_basic_set *bset,
 		  __isl_take isl_qpolynomial *poly, void *user), void *user);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_homogenize(
@@ -99,16 +107,16 @@
 isl_ctx *isl_term_get_ctx(__isl_keep isl_term *term);
 
 __isl_give isl_term *isl_term_copy(__isl_keep isl_term *term);
-void isl_term_free(__isl_take isl_term *term);
+__isl_null isl_term *isl_term_free(__isl_take isl_term *term);
 
-unsigned isl_term_dim(__isl_keep isl_term *term, enum isl_dim_type type);
+isl_size isl_term_dim(__isl_keep isl_term *term, enum isl_dim_type type);
 __isl_give isl_val *isl_term_get_coefficient_val(__isl_keep isl_term *term);
-int isl_term_get_exp(__isl_keep isl_term *term,
+isl_size isl_term_get_exp(__isl_keep isl_term *term,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_aff *isl_term_get_div(__isl_keep isl_term *term, unsigned pos);
 
-int isl_qpolynomial_foreach_term(__isl_keep isl_qpolynomial *qp,
-	int (*fn)(__isl_take isl_term *term, void *user), void *user);
+isl_stat isl_qpolynomial_foreach_term(__isl_keep isl_qpolynomial *qp,
+	isl_stat (*fn)(__isl_take isl_term *term, void *user), void *user);
 
 __isl_give isl_val *isl_qpolynomial_eval(__isl_take isl_qpolynomial *qp,
 	__isl_take isl_point *pnt);
@@ -133,10 +141,12 @@
 
 isl_ctx *isl_pw_qpolynomial_get_ctx(__isl_keep isl_pw_qpolynomial *pwqp);
 
-int isl_pw_qpolynomial_plain_is_equal(__isl_keep isl_pw_qpolynomial *pwqp1,
+isl_bool isl_pw_qpolynomial_involves_nan(__isl_keep isl_pw_qpolynomial *pwqp);
+isl_bool isl_pw_qpolynomial_plain_is_equal(__isl_keep isl_pw_qpolynomial *pwqp1,
 	__isl_keep isl_pw_qpolynomial *pwqp2);
 
-__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(__isl_take isl_space *dim);
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_zero(
+	__isl_take isl_space *space);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_alloc(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial *qp);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
@@ -146,33 +156,53 @@
 __isl_null isl_pw_qpolynomial *isl_pw_qpolynomial_free(
 	__isl_take isl_pw_qpolynomial *pwqp);
 
-int isl_pw_qpolynomial_is_zero(__isl_keep isl_pw_qpolynomial *pwqp);
+isl_bool isl_pw_qpolynomial_is_zero(__isl_keep isl_pw_qpolynomial *pwqp);
 
 __isl_give isl_space *isl_pw_qpolynomial_get_domain_space(
 	__isl_keep isl_pw_qpolynomial *pwqp);
 __isl_give isl_space *isl_pw_qpolynomial_get_space(
 	__isl_keep isl_pw_qpolynomial *pwqp);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_reset_domain_space(
-	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_space *dim);
-unsigned isl_pw_qpolynomial_dim(__isl_keep isl_pw_qpolynomial *pwqp,
+	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_space *space);
+isl_size isl_pw_qpolynomial_dim(__isl_keep isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type);
-int isl_pw_qpolynomial_involves_dims(__isl_keep isl_pw_qpolynomial *pwqp,
+isl_bool isl_pw_qpolynomial_involves_param_id(
+	__isl_keep isl_pw_qpolynomial *pwqp, __isl_keep isl_id *id);
+isl_bool isl_pw_qpolynomial_involves_dims(__isl_keep isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type, unsigned first, unsigned n);
-int isl_pw_qpolynomial_has_equal_space(__isl_keep isl_pw_qpolynomial *pwqp1,
+isl_bool isl_pw_qpolynomial_has_equal_space(
+	__isl_keep isl_pw_qpolynomial *pwqp1,
 	__isl_keep isl_pw_qpolynomial *pwqp2);
 
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_set_dim_name(
 	__isl_take isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type, unsigned pos, const char *s);
 
+int isl_pw_qpolynomial_find_dim_by_name(__isl_keep isl_pw_qpolynomial *pwqp,
+	enum isl_dim_type type, const char *name);
+
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_reset_user(
+	__isl_take isl_pw_qpolynomial *pwqp);
+
+__isl_export
 __isl_give isl_set *isl_pw_qpolynomial_domain(__isl_take isl_pw_qpolynomial *pwqp);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_domain(
 	__isl_take isl_pw_qpolynomial *pwpq, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial *
+isl_pw_qpolynomial_intersect_domain_wrapped_domain(
+	__isl_take isl_pw_qpolynomial *pwpq, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial *
+isl_pw_qpolynomial_intersect_domain_wrapped_range(
+	__isl_take isl_pw_qpolynomial *pwpq, __isl_take isl_set *set);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_intersect_params(
 	__isl_take isl_pw_qpolynomial *pwpq, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_subtract_domain(
+	__isl_take isl_pw_qpolynomial *pwpq, __isl_take isl_set *set);
 
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_project_domain_on_params(
 	__isl_take isl_pw_qpolynomial *pwqp);
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_range(
+	__isl_take isl_pw_qpolynomial *pwqp);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_drop_dims(
 	__isl_take isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type, unsigned first, unsigned n);
@@ -180,6 +210,9 @@
 	__isl_take isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_drop_unused_params(
+	__isl_take isl_pw_qpolynomial *pwqp);
+
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add(
 	__isl_take isl_pw_qpolynomial *pwqp1,
 	__isl_take isl_pw_qpolynomial *pwqp2);
@@ -196,6 +229,8 @@
 	__isl_take isl_pw_qpolynomial *pwqp2);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_scale_val(
 	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_val *v);
+__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_scale_down_val(
+	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_val *v);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_pow(
 	__isl_take isl_pw_qpolynomial *pwqp, unsigned exponent);
 
@@ -214,18 +249,28 @@
 	__isl_take isl_pw_qpolynomial *pwqp,
 	enum isl_dim_type type, unsigned n, __isl_take isl_val *v);
 
+__isl_export
 __isl_give isl_val *isl_pw_qpolynomial_eval(
 	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_point *pnt);
 
 __isl_give isl_val *isl_pw_qpolynomial_max(__isl_take isl_pw_qpolynomial *pwqp);
 __isl_give isl_val *isl_pw_qpolynomial_min(__isl_take isl_pw_qpolynomial *pwqp);
 
-int isl_pw_qpolynomial_foreach_piece(__isl_keep isl_pw_qpolynomial *pwqp,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial *qp,
+isl_size isl_pw_qpolynomial_n_piece(__isl_keep isl_pw_qpolynomial *pwqp);
+isl_stat isl_pw_qpolynomial_foreach_piece(__isl_keep isl_pw_qpolynomial *pwqp,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial *qp,
 		    void *user), void *user);
-int isl_pw_qpolynomial_foreach_lifted_piece(__isl_keep isl_pw_qpolynomial *pwqp,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial *qp,
+isl_bool isl_pw_qpolynomial_every_piece(__isl_keep isl_pw_qpolynomial *pwqp,
+	isl_bool (*test)(__isl_keep isl_set *set,
+		__isl_keep isl_qpolynomial *qp, void *user), void *user);
+isl_stat isl_pw_qpolynomial_foreach_lifted_piece(
+	__isl_keep isl_pw_qpolynomial *pwqp,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial *qp,
 		    void *user), void *user);
+isl_bool isl_pw_qpolynomial_isa_qpolynomial(
+	__isl_keep isl_pw_qpolynomial *pwqp);
+__isl_give isl_qpolynomial *isl_pw_qpolynomial_as_qpolynomial(
+	__isl_take isl_pw_qpolynomial *pwqp);
 
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_pw_aff(
 	__isl_take isl_pw_aff *pwaff);
@@ -235,6 +280,7 @@
 		const char *str);
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_read_from_file(isl_ctx *ctx,
 		FILE *input);
+__isl_give char *isl_pw_qpolynomial_to_str(__isl_keep isl_pw_qpolynomial *pwqp);
 __isl_give isl_printer *isl_printer_print_pw_qpolynomial(
 	__isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp);
 void isl_pw_qpolynomial_print(__isl_keep isl_pw_qpolynomial *pwqp, FILE *out,
@@ -259,17 +305,22 @@
 enum isl_fold isl_qpolynomial_fold_get_type(__isl_keep isl_qpolynomial_fold *fold);
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_empty(enum isl_fold type,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_alloc(
 	enum isl_fold type, __isl_take isl_qpolynomial *qp);
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
 	__isl_keep isl_qpolynomial_fold *fold);
-void isl_qpolynomial_fold_free(__isl_take isl_qpolynomial_fold *fold);
+__isl_null isl_qpolynomial_fold *isl_qpolynomial_fold_free(
+	__isl_take isl_qpolynomial_fold *fold);
 
-int isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold);
-int isl_qpolynomial_fold_plain_is_equal(__isl_keep isl_qpolynomial_fold *fold1,
+isl_bool isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold);
+isl_bool isl_qpolynomial_fold_is_nan(__isl_keep isl_qpolynomial_fold *fold);
+isl_bool isl_qpolynomial_fold_plain_is_equal(
+	__isl_keep isl_qpolynomial_fold *fold1,
 	__isl_keep isl_qpolynomial_fold *fold2);
 
+__isl_give isl_space *isl_qpolynomial_fold_get_domain_space(
+	__isl_keep isl_qpolynomial_fold *fold);
 __isl_give isl_space *isl_qpolynomial_fold_get_space(
 	__isl_keep isl_qpolynomial_fold *fold);
 
@@ -279,6 +330,8 @@
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v);
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_down_val(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v);
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_move_dims(
 	__isl_take isl_qpolynomial_fold *fold,
@@ -290,6 +343,10 @@
 	enum isl_dim_type type, unsigned first, unsigned n,
 	__isl_keep isl_qpolynomial **subs);
 
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_fix_val(
+	__isl_take isl_pw_qpolynomial_fold *pwf,
+	enum isl_dim_type type, unsigned n, __isl_take isl_val *v);
+
 __isl_give isl_val *isl_qpolynomial_fold_eval(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_point *pnt);
 
@@ -298,9 +355,9 @@
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context);
 
-int isl_qpolynomial_fold_foreach_qpolynomial(
+isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
 	__isl_keep isl_qpolynomial_fold *fold,
-	int (*fn)(__isl_take isl_qpolynomial *qp, void *user), void *user);
+	isl_stat (*fn)(__isl_take isl_qpolynomial *qp, void *user), void *user);
 
 __isl_give isl_printer *isl_printer_print_qpolynomial_fold(
 	__isl_take isl_printer *p, __isl_keep isl_qpolynomial_fold *fold);
@@ -309,8 +366,12 @@
 void isl_qpolynomial_fold_dump(__isl_keep isl_qpolynomial_fold *fold);
 
 isl_ctx *isl_pw_qpolynomial_fold_get_ctx(__isl_keep isl_pw_qpolynomial_fold *pwf);
+enum isl_fold isl_pw_qpolynomial_fold_get_type(
+	__isl_keep isl_pw_qpolynomial_fold *pwf);
 
-int isl_pw_qpolynomial_fold_plain_is_equal(
+isl_bool isl_pw_qpolynomial_fold_involves_nan(
+	__isl_keep isl_pw_qpolynomial_fold *pwf);
+isl_bool isl_pw_qpolynomial_fold_plain_is_equal(
 	__isl_keep isl_pw_qpolynomial_fold *pwf1,
 	__isl_keep isl_pw_qpolynomial_fold *pwf2);
 
@@ -320,40 +381,61 @@
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_alloc(
 	enum isl_fold type,
 	__isl_take isl_set *set, __isl_take isl_qpolynomial_fold *fold);
+__isl_give isl_pw_qpolynomial_fold *
+isl_pw_qpolynomial_fold_from_qpolynomial_fold(
+	__isl_take isl_qpolynomial_fold *fold);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_copy(
 	__isl_keep isl_pw_qpolynomial_fold *pwf);
 __isl_null isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_free(
 	__isl_take isl_pw_qpolynomial_fold *pwf);
 
-int isl_pw_qpolynomial_fold_is_zero(__isl_keep isl_pw_qpolynomial_fold *pwf);
+isl_bool isl_pw_qpolynomial_fold_is_zero(
+	__isl_keep isl_pw_qpolynomial_fold *pwf);
 
 __isl_give isl_space *isl_pw_qpolynomial_fold_get_domain_space(
 	__isl_keep isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_space *isl_pw_qpolynomial_fold_get_space(
 	__isl_keep isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_reset_space(
-	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_space *dim);
-unsigned isl_pw_qpolynomial_fold_dim(__isl_keep isl_pw_qpolynomial_fold *pwf,
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_space *space);
+isl_size isl_pw_qpolynomial_fold_dim(__isl_keep isl_pw_qpolynomial_fold *pwf,
 	enum isl_dim_type type);
-int isl_pw_qpolynomial_fold_has_equal_space(
+isl_bool isl_pw_qpolynomial_fold_involves_param_id(
+	__isl_keep isl_pw_qpolynomial_fold *pwf, __isl_keep isl_id *id);
+isl_bool isl_pw_qpolynomial_fold_has_equal_space(
 	__isl_keep isl_pw_qpolynomial_fold *pwf1,
 	__isl_keep isl_pw_qpolynomial_fold *pwf2);
 
 size_t isl_pw_qpolynomial_fold_size(__isl_keep isl_pw_qpolynomial_fold *pwf);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_zero(
-	__isl_take isl_space *dim, enum isl_fold type);
+	__isl_take isl_space *space, enum isl_fold type);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_set_dim_name(
 	__isl_take isl_pw_qpolynomial_fold *pwf,
 	enum isl_dim_type type, unsigned pos, const char *s);
 
+int isl_pw_qpolynomial_fold_find_dim_by_name(
+	__isl_keep isl_pw_qpolynomial_fold *pwf,
+	enum isl_dim_type type, const char *name);
+
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_reset_user(
+	__isl_take isl_pw_qpolynomial_fold *pwf);
+
 __isl_give isl_set *isl_pw_qpolynomial_fold_domain(
 	__isl_take isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_intersect_domain(
 	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial_fold *
+isl_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial_fold *
+isl_pw_qpolynomial_fold_intersect_domain_wrapped_range(
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_intersect_params(
 	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set);
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_subtract_domain(
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_set *set);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_add(
 	__isl_take isl_pw_qpolynomial_fold *pwf1,
@@ -366,9 +448,13 @@
 	__isl_take isl_pw_qpolynomial_fold *pwf2);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_scale_val(
 	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_val *v);
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_scale_down_val(
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_val *v);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_project_domain_on_params(
 	__isl_take isl_pw_qpolynomial_fold *pwf);
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_from_range(
+	__isl_take isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_drop_dims(
 	__isl_take isl_pw_qpolynomial_fold *pwf,
 	enum isl_dim_type type, unsigned first, unsigned n);
@@ -377,18 +463,33 @@
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
 
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_drop_unused_params(
+	__isl_take isl_pw_qpolynomial_fold *pwf);
+
 __isl_give isl_val *isl_pw_qpolynomial_fold_eval(
 	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_point *pnt);
 
-int isl_pw_qpolynomial_fold_foreach_piece(
+isl_size isl_pw_qpolynomial_fold_n_piece(
+	__isl_keep isl_pw_qpolynomial_fold *pwf);
+isl_stat isl_pw_qpolynomial_fold_foreach_piece(
 	__isl_keep isl_pw_qpolynomial_fold *pwf,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial_fold *fold,
-		    void *user), void *user);
-int isl_pw_qpolynomial_fold_foreach_lifted_piece(
+	isl_stat (*fn)(__isl_take isl_set *set,
+		__isl_take isl_qpolynomial_fold *fold, void *user), void *user);
+isl_bool isl_pw_qpolynomial_fold_every_piece(
 	__isl_keep isl_pw_qpolynomial_fold *pwf,
-	int (*fn)(__isl_take isl_set *set, __isl_take isl_qpolynomial_fold *fold,
-		    void *user), void *user);
+	isl_bool (*test)(__isl_keep isl_set *set,
+		__isl_keep isl_qpolynomial_fold *fold, void *user), void *user);
+isl_stat isl_pw_qpolynomial_fold_foreach_lifted_piece(
+	__isl_keep isl_pw_qpolynomial_fold *pwf,
+	isl_stat (*fn)(__isl_take isl_set *set,
+		__isl_take isl_qpolynomial_fold *fold, void *user), void *user);
+isl_bool isl_pw_qpolynomial_fold_isa_qpolynomial_fold(
+	__isl_keep isl_pw_qpolynomial_fold *pwf);
+__isl_give isl_qpolynomial_fold *isl_pw_qpolynomial_fold_as_qpolynomial_fold(
+	__isl_take isl_pw_qpolynomial_fold *pwf);
 
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_read_from_str(
+	isl_ctx *ctx, const char *str);
 __isl_give isl_printer *isl_printer_print_pw_qpolynomial_fold(
 	__isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf);
 void isl_pw_qpolynomial_fold_print(__isl_keep isl_pw_qpolynomial_fold *pwf,
@@ -408,15 +509,16 @@
 	__isl_take isl_pw_qpolynomial_fold *pwf);
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
-	__isl_take isl_pw_qpolynomial *pwqp, enum isl_fold type, int *tight);
+	__isl_take isl_pw_qpolynomial *pwqp, enum isl_fold type,
+	isl_bool *tight);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
-	__isl_take isl_pw_qpolynomial_fold *pwf, int *tight);
+	__isl_take isl_pw_qpolynomial_fold *pwf, isl_bool *tight);
 __isl_give isl_pw_qpolynomial_fold *isl_set_apply_pw_qpolynomial_fold(
 	__isl_take isl_set *set, __isl_take isl_pw_qpolynomial_fold *pwf,
-	int *tight);
+	isl_bool *tight);
 __isl_give isl_pw_qpolynomial_fold *isl_map_apply_pw_qpolynomial_fold(
 	__isl_take isl_map *map, __isl_take isl_pw_qpolynomial_fold *pwf,
-	int *tight);
+	isl_bool *tight);
 
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_to_polynomial(
 	__isl_take isl_pw_qpolynomial *pwqp, int sign);
@@ -424,13 +526,24 @@
 isl_ctx *isl_union_pw_qpolynomial_get_ctx(
 	__isl_keep isl_union_pw_qpolynomial *upwqp);
 
-int isl_union_pw_qpolynomial_plain_is_equal(
+isl_size isl_union_pw_qpolynomial_dim(
+	__isl_keep isl_union_pw_qpolynomial *upwqp, enum isl_dim_type type);
+
+isl_bool isl_union_pw_qpolynomial_involves_nan(
+	__isl_keep isl_union_pw_qpolynomial *upwqp);
+isl_bool isl_union_pw_qpolynomial_plain_is_equal(
 	__isl_keep isl_union_pw_qpolynomial *upwqp1,
 	__isl_keep isl_union_pw_qpolynomial *upwqp2);
 
+__isl_give isl_union_pw_qpolynomial *isl_pw_qpolynomial_to_union_pw_qpolynomial(
+	__isl_take isl_pw_qpolynomial *pwqp);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_from_pw_qpolynomial(__isl_take isl_pw_qpolynomial *pwqp);
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero_ctx(
+	isl_ctx *ctx);
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero_space(
+	__isl_take isl_space *space);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_zero(
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add_pw_qpolynomial(
 	__isl_take isl_union_pw_qpolynomial *upwqp,
 	__isl_take isl_pw_qpolynomial *pwqp);
@@ -442,6 +555,11 @@
 __isl_constructor
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_read_from_str(
 	isl_ctx *ctx, const char *str);
+__isl_give char *isl_union_pw_qpolynomial_to_str(
+	__isl_keep isl_union_pw_qpolynomial *upwqp);
+
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_neg(
+	__isl_take isl_union_pw_qpolynomial *upwqp);
 
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_add(
 	__isl_take isl_union_pw_qpolynomial *upwqp1,
@@ -454,19 +572,67 @@
 	__isl_take isl_union_pw_qpolynomial *upwqp2);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_scale_val(
 	__isl_take isl_union_pw_qpolynomial *upwqp, __isl_take isl_val *v);
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_scale_down_val(
+	__isl_take isl_union_pw_qpolynomial *upwqp, __isl_take isl_val *v);
 
+__isl_export
 __isl_give isl_union_set *isl_union_pw_qpolynomial_domain(
 	__isl_take isl_union_pw_qpolynomial *upwqp);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_intersect_domain_space(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_space *space);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_intersect_domain_union_set(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_union_set *uset);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_domain(
 	__isl_take isl_union_pw_qpolynomial *upwpq,
 	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_intersect_domain_wrapped_domain(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_intersect_domain_wrapped_range(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_union_set *uset);
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_intersect_params(
 	__isl_take isl_union_pw_qpolynomial *upwpq,
 	__isl_take isl_set *set);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_subtract_domain_union_set(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial *
+isl_union_pw_qpolynomial_subtract_domain_space(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_space *space);
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_subtract_domain(
+	__isl_take isl_union_pw_qpolynomial *upwpq,
+	__isl_take isl_union_set *uset);
 
 __isl_give isl_space *isl_union_pw_qpolynomial_get_space(
 	__isl_keep isl_union_pw_qpolynomial *upwqp);
+__isl_give isl_pw_qpolynomial_list *
+isl_union_pw_qpolynomial_get_pw_qpolynomial_list(
+	__isl_keep isl_union_pw_qpolynomial *upwqp);
+
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_set_dim_name(
+	__isl_take isl_union_pw_qpolynomial *upwqp,
+	enum isl_dim_type type, unsigned pos, const char *s);
 
+int isl_union_pw_qpolynomial_find_dim_by_name(
+	__isl_keep isl_union_pw_qpolynomial *upwqp,
+	enum isl_dim_type type, const char *name);
+
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_drop_dims(
+	__isl_take isl_union_pw_qpolynomial *upwqp,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_reset_user(
+	__isl_take isl_union_pw_qpolynomial *upwqp);
+
+__isl_export
 __isl_give isl_val *isl_union_pw_qpolynomial_eval(
 	__isl_take isl_union_pw_qpolynomial *upwqp, __isl_take isl_point *pnt);
 
@@ -483,11 +649,19 @@
 	__isl_take isl_union_pw_qpolynomial *upwqp,
 	__isl_take isl_space *model);
 
-int isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
+isl_size isl_union_pw_qpolynomial_n_pw_qpolynomial(
+	__isl_keep isl_union_pw_qpolynomial *upwqp);
+isl_stat isl_union_pw_qpolynomial_foreach_pw_qpolynomial(
+	__isl_keep isl_union_pw_qpolynomial *upwqp,
+	isl_stat (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user),
+	void *user);
+isl_bool isl_union_pw_qpolynomial_every_pw_qpolynomial(
 	__isl_keep isl_union_pw_qpolynomial *upwqp,
-	int (*fn)(__isl_take isl_pw_qpolynomial *pwqp, void *user), void *user);
+	isl_bool (*test)(__isl_keep isl_pw_qpolynomial *pwqp, void *user),
+	void *user);
 __isl_give isl_pw_qpolynomial *isl_union_pw_qpolynomial_extract_pw_qpolynomial(
-	__isl_keep isl_union_pw_qpolynomial *upwqp, __isl_take isl_space *dim);
+	__isl_keep isl_union_pw_qpolynomial *upwqp,
+	__isl_take isl_space *space);
 
 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial(
 	__isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp);
@@ -495,13 +669,26 @@
 isl_ctx *isl_union_pw_qpolynomial_fold_get_ctx(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
 
-int isl_union_pw_qpolynomial_fold_plain_is_equal(
+isl_size isl_union_pw_qpolynomial_fold_dim(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf, enum isl_dim_type type);
+
+isl_bool isl_union_pw_qpolynomial_fold_involves_nan(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+isl_bool isl_union_pw_qpolynomial_fold_plain_is_equal(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf1,
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf2);
 
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_pw_qpolynomial_fold_to_union_pw_qpolynomial_fold(
+	__isl_take isl_pw_qpolynomial_fold *pwf);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_from_pw_qpolynomial_fold(__isl_take isl_pw_qpolynomial_fold *pwf);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_zero_ctx(isl_ctx *ctx, enum isl_fold type);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_zero_space(__isl_take isl_space *space,
+	enum isl_fold type);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_zero(
-	__isl_take isl_space *dim, enum isl_fold type);
+	__isl_take isl_space *space, enum isl_fold type);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(
 	__isl_take isl_union_pw_qpolynomial_fold *upwqp,
 	__isl_take isl_pw_qpolynomial_fold *pwqp);
@@ -519,21 +706,72 @@
 __isl_give isl_union_pw_qpolynomial_fold *
 isl_union_pw_qpolynomial_fold_scale_val(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf, __isl_take isl_val *v);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_scale_down_val(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf, __isl_take isl_val *v);
 
 __isl_give isl_union_set *isl_union_pw_qpolynomial_fold_domain(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_intersect_domain_space(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_space *space);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_intersect_domain_union_set(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_union_set *uset);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_intersect_domain(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf,
 	__isl_take isl_union_set *uset);
 __isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_domain(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_intersect_domain_wrapped_range(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial_fold *
 isl_union_pw_qpolynomial_fold_intersect_params(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf,
 	__isl_take isl_set *set);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_subtract_domain_union_set(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_subtract_domain_space(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_space *space);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_subtract_domain(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_union_set *uset);
 
 enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
 __isl_give isl_space *isl_union_pw_qpolynomial_fold_get_space(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+__isl_give isl_pw_qpolynomial_fold_list *
+isl_union_pw_qpolynomial_fold_get_pw_qpolynomial_fold_list(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_set_dim_name(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	enum isl_dim_type type, unsigned pos, const char *s);
+
+int isl_union_pw_qpolynomial_fold_find_dim_by_name(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+	enum isl_dim_type type, const char *name);
+
+__isl_give isl_union_pw_qpolynomial_fold *
+	isl_union_pw_qpolynomial_fold_drop_dims(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_union_pw_qpolynomial_fold *
+isl_union_pw_qpolynomial_fold_reset_user(
+	__isl_take isl_union_pw_qpolynomial_fold *upwf);
 
 __isl_give isl_val *isl_union_pw_qpolynomial_fold_eval(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf,
@@ -553,12 +791,19 @@
 	__isl_take isl_union_pw_qpolynomial_fold *upwf,
 	__isl_take isl_space *model);
 
-int isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
+isl_size isl_union_pw_qpolynomial_fold_n_pw_qpolynomial_fold(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf);
+isl_stat isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf,
-	int (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
+	isl_stat (*fn)(__isl_take isl_pw_qpolynomial_fold *pwf,
 		    void *user), void *user);
+isl_bool isl_union_pw_qpolynomial_fold_every_pw_qpolynomial_fold(
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+	isl_bool (*test)(__isl_keep isl_pw_qpolynomial_fold *pwf,
+		void *user), void *user);
 __isl_give isl_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_extract_pw_qpolynomial_fold(
-	__isl_keep isl_union_pw_qpolynomial_fold *upwf, __isl_take isl_space *dim);
+	__isl_keep isl_union_pw_qpolynomial_fold *upwf,
+	__isl_take isl_space *space);
 
 __isl_give isl_printer *isl_printer_print_union_pw_qpolynomial_fold(
 	__isl_take isl_printer *p,
@@ -566,21 +811,23 @@
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
 	__isl_take isl_union_pw_qpolynomial *upwqp,
-	enum isl_fold type, int *tight);
+	enum isl_fold type, isl_bool *tight);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_set_apply_union_pw_qpolynomial_fold(
 	__isl_take isl_union_set *uset,
-	__isl_take isl_union_pw_qpolynomial_fold *upwf, int *tight);
+	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight);
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_map_apply_union_pw_qpolynomial_fold(
 	__isl_take isl_union_map *umap,
-	__isl_take isl_union_pw_qpolynomial_fold *upwf, int *tight);
+	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight);
 
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_to_polynomial(
 	__isl_take isl_union_pw_qpolynomial *upwqp, int sign);
 
+ISL_DECLARE_LIST_FN(qpolynomial)
+ISL_DECLARE_LIST_FN(pw_qpolynomial)
+ISL_DECLARE_LIST_FN(pw_qpolynomial_fold)
+
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/polynomial_type.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/polynomial_type.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/printer.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/printer.h Changed

@@ -3,14 +3,13 @@
 
 #include <stdio.h>
 #include <isl/ctx.h>
+#include <isl/printer_type.h>
+#include <isl/id_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_printer;
-typedef struct isl_printer isl_printer;
-
 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx, FILE *file);
 __isl_give isl_printer *isl_printer_to_str(isl_ctx *ctx);
 __isl_null isl_printer *isl_printer_free(__isl_take isl_printer *printer);
@@ -36,6 +35,12 @@
 	int output_format);
 int isl_printer_get_output_format(__isl_keep isl_printer *p);
 
+#define ISL_YAML_STYLE_BLOCK		0
+#define ISL_YAML_STYLE_FLOW		1
+__isl_give isl_printer *isl_printer_set_yaml_style(__isl_take isl_printer *p,
+	int yaml_style);
+int isl_printer_get_yaml_style(__isl_keep isl_printer *p);
+
 __isl_give isl_printer *isl_printer_set_indent_prefix(__isl_take isl_printer *p,
 	const char *prefix);
 __isl_give isl_printer *isl_printer_set_prefix(__isl_take isl_printer *p,
@@ -45,6 +50,13 @@
 __isl_give isl_printer *isl_printer_set_isl_int_width(__isl_take isl_printer *p,
 	int width);
 
+isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
+	__isl_keep isl_id *id);
+__isl_give isl_id *isl_printer_get_note(__isl_keep isl_printer *p,
+	__isl_take isl_id *id);
+__isl_give isl_printer *isl_printer_set_note(__isl_take isl_printer *p,
+	__isl_take isl_id *id, __isl_take isl_id *note);
+
 __isl_give isl_printer *isl_printer_start_line(__isl_take isl_printer *p);
 __isl_give isl_printer *isl_printer_end_line(__isl_take isl_printer *p);
 __isl_give isl_printer *isl_printer_print_double(__isl_take isl_printer *p,
@@ -53,6 +65,16 @@
 __isl_give isl_printer *isl_printer_print_str(__isl_take isl_printer *p,
 	const char *s);
 
+__isl_give isl_printer *isl_printer_yaml_start_mapping(
+	__isl_take isl_printer *p);
+__isl_give isl_printer *isl_printer_yaml_end_mapping(
+	__isl_take isl_printer *p);
+__isl_give isl_printer *isl_printer_yaml_start_sequence(
+	__isl_take isl_printer *p);
+__isl_give isl_printer *isl_printer_yaml_end_sequence(
+	__isl_take isl_printer *p);
+__isl_give isl_printer *isl_printer_yaml_next(__isl_take isl_printer *p);
+
 __isl_give isl_printer *isl_printer_flush(__isl_take isl_printer *p);
 
 #if defined(__cplusplus)

_service:tar_scm:isl-0.24.tar.gz/include/isl/printer_type.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/schedule.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/schedule.h Changed

@@ -3,54 +3,74 @@
 
 #include <isl/union_set_type.h>
 #include <isl/union_map_type.h>
-#include <isl/band.h>
+#include <isl/schedule_type.h>
+#include <isl/aff_type.h>
+#include <isl/space_type.h>
+#include <isl/set_type.h>
 #include <isl/list.h>
+#include <isl/printer_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_schedule_constraints;
+struct __isl_export isl_schedule_constraints;
 typedef struct isl_schedule_constraints isl_schedule_constraints;
-struct isl_schedule;
-typedef struct isl_schedule isl_schedule;
 
-int isl_options_set_schedule_max_coefficient(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_max_coefficient(isl_ctx *ctx, int val);
 int isl_options_get_schedule_max_coefficient(isl_ctx *ctx);
 
-int isl_options_set_schedule_max_constant_term(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_max_constant_term(isl_ctx *ctx, int val);
 int isl_options_get_schedule_max_constant_term(isl_ctx *ctx);
 
-int isl_options_set_schedule_maximize_band_depth(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_maximize_band_depth(isl_ctx *ctx, int val);
 int isl_options_get_schedule_maximize_band_depth(isl_ctx *ctx);
 
-int isl_options_set_schedule_outer_coincidence(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_maximize_coincidence(isl_ctx *ctx, int val);
+int isl_options_get_schedule_maximize_coincidence(isl_ctx *ctx);
+
+isl_stat isl_options_set_schedule_outer_coincidence(isl_ctx *ctx, int val);
 int isl_options_get_schedule_outer_coincidence(isl_ctx *ctx);
 
-int isl_options_set_schedule_split_scaled(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_split_scaled(isl_ctx *ctx, int val);
 int isl_options_get_schedule_split_scaled(isl_ctx *ctx);
 
-int isl_options_set_schedule_separate_components(isl_ctx *ctx, int val);
+isl_stat isl_options_set_schedule_treat_coalescing(isl_ctx *ctx, int val);
+int isl_options_get_schedule_treat_coalescing(isl_ctx *ctx);
+
+isl_stat isl_options_set_schedule_separate_components(isl_ctx *ctx, int val);
 int isl_options_get_schedule_separate_components(isl_ctx *ctx);
 
-#define		ISL_SCHEDULE_FUSE_MAX			0
-#define		ISL_SCHEDULE_FUSE_MIN			1
-int isl_options_set_schedule_fuse(isl_ctx *ctx, int val);
-int isl_options_get_schedule_fuse(isl_ctx *ctx);
+isl_stat isl_options_set_schedule_serialize_sccs(isl_ctx *ctx, int val);
+int isl_options_get_schedule_serialize_sccs(isl_ctx *ctx);
+
+isl_stat isl_options_set_schedule_whole_component(isl_ctx *ctx, int val);
+int isl_options_get_schedule_whole_component(isl_ctx *ctx);
+
+isl_stat isl_options_set_schedule_carry_self_first(isl_ctx *ctx, int val);
+int isl_options_get_schedule_carry_self_first(isl_ctx *ctx);
 
 __isl_give isl_schedule_constraints *isl_schedule_constraints_copy(
 	__isl_keep isl_schedule_constraints *sc);
+__isl_export
 __isl_give isl_schedule_constraints *isl_schedule_constraints_on_domain(
 	__isl_take isl_union_set *domain);
+__isl_export
+__isl_give isl_schedule_constraints *isl_schedule_constraints_set_context(
+	__isl_take isl_schedule_constraints *sc, __isl_take isl_set *context);
+__isl_export
 __isl_give isl_schedule_constraints *isl_schedule_constraints_set_validity(
 	__isl_take isl_schedule_constraints *sc,
 	__isl_take isl_union_map *validity);
+__isl_export
 __isl_give isl_schedule_constraints *isl_schedule_constraints_set_coincidence(
 	__isl_take isl_schedule_constraints *sc,
 	__isl_take isl_union_map *coincidence);
+__isl_export
 __isl_give isl_schedule_constraints *isl_schedule_constraints_set_proximity(
 	__isl_take isl_schedule_constraints *sc,
 	__isl_take isl_union_map *proximity);
+__isl_export
 __isl_give isl_schedule_constraints *
 isl_schedule_constraints_set_conditional_validity(
 	__isl_take isl_schedule_constraints *sc,
@@ -61,9 +81,45 @@
 
 isl_ctx *isl_schedule_constraints_get_ctx(
 	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_set *isl_schedule_constraints_get_domain(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_set *isl_schedule_constraints_get_context(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_map *isl_schedule_constraints_get_validity(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_map *isl_schedule_constraints_get_coincidence(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_map *isl_schedule_constraints_get_proximity(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_map *isl_schedule_constraints_get_conditional_validity(
+	__isl_keep isl_schedule_constraints *sc);
+__isl_export
+__isl_give isl_union_map *
+isl_schedule_constraints_get_conditional_validity_condition(
+	__isl_keep isl_schedule_constraints *sc);
 
+__isl_give isl_schedule_constraints *isl_schedule_constraints_apply(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *umap);
+
+__isl_constructor
+__isl_give isl_schedule_constraints *isl_schedule_constraints_read_from_str(
+	isl_ctx *ctx, const char *str);
+__isl_give isl_schedule_constraints *isl_schedule_constraints_read_from_file(
+	isl_ctx *ctx, FILE *input);
+__isl_give isl_printer *isl_printer_print_schedule_constraints(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_constraints *sc);
 void isl_schedule_constraints_dump(__isl_keep isl_schedule_constraints *sc);
+__isl_give char *isl_schedule_constraints_to_str(
+	__isl_keep isl_schedule_constraints *sc);
 
+__isl_export
 __isl_give isl_schedule *isl_schedule_constraints_compute_schedule(
 	__isl_take isl_schedule_constraints *sc);
 
@@ -71,20 +127,72 @@
 	__isl_take isl_union_set *domain,
 	__isl_take isl_union_map *validity,
 	__isl_take isl_union_map *proximity);
+
+__isl_give isl_schedule *isl_schedule_empty(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_schedule *isl_schedule_from_domain(
+	__isl_take isl_union_set *domain);
+__isl_give isl_schedule *isl_schedule_copy(__isl_keep isl_schedule *sched);
 __isl_null isl_schedule *isl_schedule_free(__isl_take isl_schedule *sched);
+__isl_export
 __isl_give isl_union_map *isl_schedule_get_map(__isl_keep isl_schedule *sched);
 
 isl_ctx *isl_schedule_get_ctx(__isl_keep isl_schedule *sched);
+isl_bool isl_schedule_plain_is_equal(__isl_keep isl_schedule *schedule1,
+	__isl_keep isl_schedule *schedule2);
 
-__isl_give isl_band_list *isl_schedule_get_band_forest(
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_get_root(
+	__isl_keep isl_schedule *schedule);
+__isl_export
+__isl_give isl_union_set *isl_schedule_get_domain(
 	__isl_keep isl_schedule *schedule);
 
+isl_stat isl_schedule_foreach_schedule_node_top_down(
+	__isl_keep isl_schedule *sched,
+	isl_bool (*fn)(__isl_keep isl_schedule_node *node, void *user),
+	void *user);
+__isl_give isl_schedule *isl_schedule_map_schedule_node_bottom_up(
+	__isl_take isl_schedule *schedule,
+	__isl_give isl_schedule_node *(*fn)(
+		__isl_take isl_schedule_node *node, void *user), void *user);
+
+__isl_give isl_schedule *isl_schedule_insert_context(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *context);
+__isl_give isl_schedule *isl_schedule_insert_partial_schedule(
+	__isl_take isl_schedule *schedule,
+	__isl_take isl_multi_union_pw_aff *partial);
+__isl_give isl_schedule *isl_schedule_insert_guard(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *guard);
+__isl_give isl_schedule *isl_schedule_sequence(
+	__isl_take isl_schedule *schedule1, __isl_take isl_schedule *schedule2);
+__isl_give isl_schedule *isl_schedule_set(
+	__isl_take isl_schedule *schedule1, __isl_take isl_schedule *schedule2);
+__isl_give isl_schedule *isl_schedule_intersect_domain(
+	__isl_take isl_schedule *schedule, __isl_take isl_union_set *domain);
+__isl_give isl_schedule *isl_schedule_gist_domain_params(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *context);
+
+__isl_give isl_schedule *isl_schedule_reset_user(
+	__isl_take isl_schedule *schedule);
+__isl_give isl_schedule *isl_schedule_align_params(
+	__isl_take isl_schedule *schedule, __isl_take isl_space *space);
+__isl_overload
+__isl_give isl_schedule *isl_schedule_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule *schedule,
+	__isl_take isl_union_pw_multi_aff *upma);
+__isl_give isl_schedule *isl_schedule_expand(__isl_take isl_schedule *schedule,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_schedule *expansion);
+
+__isl_give isl_schedule *isl_schedule_read_from_file(isl_ctx *ctx, FILE *input);
+__isl_constructor
+__isl_give isl_schedule *isl_schedule_read_from_str(isl_ctx *ctx,
+	const char *str);
 __isl_give isl_printer *isl_printer_print_schedule(__isl_take isl_printer *p,
 	__isl_keep isl_schedule *schedule);
 void isl_schedule_dump(__isl_keep isl_schedule *schedule);
-
-int isl_schedule_foreach_band(__isl_keep isl_schedule *sched,
-	int (*fn)(__isl_keep isl_band *band, void *user), void *user);
+__isl_give char *isl_schedule_to_str(__isl_keep isl_schedule *schedule);
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.24.tar.gz/include/isl/schedule_node.h Added

@@ -0,0 +1,300 @@
+#ifndef ISL_SCHEDULE_NODE_H
+#define ISL_SCHEDULE_NODE_H
+
+#include <isl/schedule_type.h>
+#include <isl/union_set_type.h>
+#include <isl/aff_type.h>
+#include <isl/ast_type.h>
+#include <isl/val_type.h>
+#include <isl/space_type.h>
+#include <isl/id_type.h>
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_from_domain(
+	__isl_take isl_union_set *domain);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_from_extension(
+	__isl_take isl_union_map *extension);
+__isl_give isl_schedule_node *isl_schedule_node_copy(
+	__isl_keep isl_schedule_node *node);
+__isl_null isl_schedule_node *isl_schedule_node_free(
+	__isl_take isl_schedule_node *node);
+
+__isl_export
+isl_bool isl_schedule_node_is_equal(__isl_keep isl_schedule_node *node1,
+	__isl_keep isl_schedule_node *node2);
+
+isl_ctx *isl_schedule_node_get_ctx(__isl_keep isl_schedule_node *node);
+__isl_subclass(isl_schedule_node)
+enum isl_schedule_node_type isl_schedule_node_get_type(
+	__isl_keep isl_schedule_node *node);
+enum isl_schedule_node_type isl_schedule_node_get_parent_type(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule *isl_schedule_node_get_schedule(
+	__isl_keep isl_schedule_node *node);
+
+__isl_export
+isl_stat isl_schedule_node_foreach_descendant_top_down(
+	__isl_keep isl_schedule_node *node,
+	isl_bool (*fn)(__isl_keep isl_schedule_node *node, void *user),
+	void *user);
+__isl_export
+isl_bool isl_schedule_node_every_descendant(__isl_keep isl_schedule_node *node,
+	isl_bool (*test)(__isl_keep isl_schedule_node *node, void *user),
+	void *user);
+__isl_export
+isl_stat isl_schedule_node_foreach_ancestor_top_down(
+	__isl_keep isl_schedule_node *node,
+	isl_stat (*fn)(__isl_keep isl_schedule_node *node, void *user),
+	void *user);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_map_descendant_bottom_up(
+	__isl_take isl_schedule_node *node,
+	__isl_give isl_schedule_node *(*fn)(__isl_take isl_schedule_node *node,
+		void *user), void *user);
+
+__isl_export
+isl_size isl_schedule_node_get_tree_depth(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_bool isl_schedule_node_has_parent(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_bool isl_schedule_node_has_children(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_bool isl_schedule_node_has_previous_sibling(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+isl_bool isl_schedule_node_has_next_sibling(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_size isl_schedule_node_n_children(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_size isl_schedule_node_get_child_position(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+isl_size isl_schedule_node_get_ancestor_child_position(
+	__isl_keep isl_schedule_node *node,
+	__isl_keep isl_schedule_node *ancestor);
+__isl_give isl_schedule_node *isl_schedule_node_get_child(
+	__isl_keep isl_schedule_node *node, int pos);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_get_shared_ancestor(
+	__isl_keep isl_schedule_node *node1,
+	__isl_keep isl_schedule_node *node2);
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_root(
+	__isl_take isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_parent(
+	__isl_take isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_ancestor(
+	__isl_take isl_schedule_node *node, int generation);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_child(
+	__isl_take isl_schedule_node *node, int pos);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_first_child(
+	__isl_take isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_previous_sibling(
+	__isl_take isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_next_sibling(
+	__isl_take isl_schedule_node *node);
+
+__isl_export
+isl_bool isl_schedule_node_is_subtree_anchored(
+	__isl_keep isl_schedule_node *node);
+
+__isl_give isl_schedule_node *isl_schedule_node_group(
+	__isl_take isl_schedule_node *node, __isl_take isl_id *group_id);
+
+__isl_give isl_schedule_node *isl_schedule_node_sequence_splice_child(
+	__isl_take isl_schedule_node *node, int pos);
+
+__isl_give isl_space *isl_schedule_node_band_get_space(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_multi_union_pw_aff *isl_schedule_node_band_get_partial_schedule(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_map *isl_schedule_node_band_get_partial_schedule_union_map(
+	__isl_keep isl_schedule_node *node);
+enum isl_ast_loop_type isl_schedule_node_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_node *node, int pos);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_node *node, int pos,
+	enum isl_ast_loop_type type);
+enum isl_ast_loop_type isl_schedule_node_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_node *node, int pos);
+__isl_give isl_schedule_node *
+isl_schedule_node_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_node *node, int pos,
+	enum isl_ast_loop_type type);
+__isl_export
+__isl_give isl_union_set *isl_schedule_node_band_get_ast_build_options(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_set_ast_build_options(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *options);
+__isl_export
+__isl_give isl_set *isl_schedule_node_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+isl_size isl_schedule_node_band_n_member(__isl_keep isl_schedule_node *node);
+__isl_export
+isl_bool isl_schedule_node_band_member_get_coincident(
+	__isl_keep isl_schedule_node *node, int pos);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_member_set_coincident(
+	__isl_take isl_schedule_node *node, int pos, int coincident);
+__isl_export
+isl_bool isl_schedule_node_band_get_permutable(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_set_permutable(
+	__isl_take isl_schedule_node *node, int permutable);
+
+isl_stat isl_options_set_tile_scale_tile_loops(isl_ctx *ctx, int val);
+int isl_options_get_tile_scale_tile_loops(isl_ctx *ctx);
+isl_stat isl_options_set_tile_shift_point_loops(isl_ctx *ctx, int val);
+int isl_options_get_tile_shift_point_loops(isl_ctx *ctx);
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_scale(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_scale_down(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_mod(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_shift(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_multi_union_pw_aff *shift);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_tile(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *sizes);
+__isl_give isl_schedule_node *isl_schedule_node_band_sink(
+	__isl_take isl_schedule_node *node);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_band_split(
+	__isl_take isl_schedule_node *node, int pos);
+
+__isl_export
+__isl_give isl_set *isl_schedule_node_context_get_context(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_set *isl_schedule_node_domain_get_domain(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_map *isl_schedule_node_expansion_get_expansion(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_schedule_node_expansion_get_contraction(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_map *isl_schedule_node_extension_get_extension(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_set *isl_schedule_node_filter_get_filter(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_set *isl_schedule_node_guard_get_guard(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_id *isl_schedule_node_mark_get_id(
+	__isl_keep isl_schedule_node *node);
+
+isl_size isl_schedule_node_get_schedule_depth(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_set *isl_schedule_node_get_domain(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_set *isl_schedule_node_get_universe_domain(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_multi_union_pw_aff *
+isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_pw_multi_aff *
+isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
+	__isl_keep isl_schedule_node *node);
+__isl_export
+__isl_give isl_union_map *isl_schedule_node_get_prefix_schedule_union_map(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_map *isl_schedule_node_get_prefix_schedule_relation(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_map *isl_schedule_node_get_subtree_schedule_union_map(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_map *isl_schedule_node_get_subtree_expansion(
+	__isl_keep isl_schedule_node *node);
+__isl_give isl_union_pw_multi_aff *isl_schedule_node_get_subtree_contraction(
+	__isl_keep isl_schedule_node *node);
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_context(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *context);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_partial_schedule(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_multi_union_pw_aff *schedule);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_filter(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_guard(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *context);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_mark(
+	__isl_take isl_schedule_node *node, __isl_take isl_id *mark);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_sequence(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_set_list *filters);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_insert_set(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_set_list *filters);
+
+__isl_give isl_schedule_node *isl_schedule_node_cut(
+	__isl_take isl_schedule_node *node);
+__isl_give isl_schedule_node *isl_schedule_node_delete(
+	__isl_take isl_schedule_node *node);
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_order_before(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_order_after(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter);
+
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_graft_before(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_schedule_node *graft);
+__isl_export
+__isl_give isl_schedule_node *isl_schedule_node_graft_after(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_schedule_node *graft);
+
+__isl_give isl_schedule_node *isl_schedule_node_reset_user(
+	__isl_take isl_schedule_node *node);
+__isl_give isl_schedule_node *isl_schedule_node_align_params(
+	__isl_take isl_schedule_node *node, __isl_take isl_space *space);
+
+__isl_give isl_printer *isl_printer_print_schedule_node(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_node *node);
+void isl_schedule_node_dump(__isl_keep isl_schedule_node *node);
+__isl_give char *isl_schedule_node_to_str(__isl_keep isl_schedule_node *node);
+
+#if defined(__cplusplus)
+}
+#endif
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/include/isl/schedule_type.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/set.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/set.h Changed

@@ -10,34 +10,39 @@
 #ifndef ISL_SET_H
 #define ISL_SET_H
 
+#include <isl/id_type.h>
 #include <isl/map_type.h>
 #include <isl/aff_type.h>
 #include <isl/list.h>
 #include <isl/mat.h>
 #include <isl/point.h>
 #include <isl/local_space.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
+#include <isl/stdint.h>
+#include <isl/stride_info.h>
+#include <isl/fixed_box.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-unsigned isl_basic_set_n_dim(__isl_keep isl_basic_set *bset);
-unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset);
-unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset);
-unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
+isl_size isl_basic_set_n_dim(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_set_n_param(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_set_total_dim(__isl_keep const isl_basic_set *bset);
+isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
 				enum isl_dim_type type);
 
-unsigned isl_set_n_dim(__isl_keep isl_set *set);
-unsigned isl_set_n_param(__isl_keep isl_set *set);
-unsigned isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type);
+isl_size isl_set_n_dim(__isl_keep isl_set *set);
+isl_size isl_set_n_param(__isl_keep isl_set *set);
+isl_size isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type);
 
 isl_ctx *isl_basic_set_get_ctx(__isl_keep isl_basic_set *bset);
 isl_ctx *isl_set_get_ctx(__isl_keep isl_set *set);
 __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset);
+__isl_export
 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set);
 __isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 
 __isl_give isl_aff *isl_basic_set_get_div(__isl_keep isl_basic_set *bset,
 	int pos);
@@ -46,7 +51,7 @@
 	__isl_keep isl_basic_set *bset);
 
 const char *isl_basic_set_get_tuple_name(__isl_keep isl_basic_set *bset);
-int isl_set_has_tuple_name(__isl_keep isl_set *set);
+isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set);
 const char *isl_set_get_tuple_name(__isl_keep isl_set *set);
 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
 	__isl_take isl_basic_set *set, const char *s);
@@ -57,7 +62,7 @@
 __isl_give isl_basic_set *isl_basic_set_set_dim_name(
 	__isl_take isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos, const char *s);
-int isl_set_has_dim_name(__isl_keep isl_set *set,
+isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
 const char *isl_set_get_dim_name(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
@@ -70,14 +75,14 @@
 	__isl_take isl_basic_set *bset, __isl_take isl_id *id);
 __isl_give isl_set *isl_set_set_dim_id(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
-int isl_set_has_dim_id(__isl_keep isl_set *set,
+isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_id *isl_set_get_dim_id(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
 __isl_give isl_set *isl_set_set_tuple_id(__isl_take isl_set *set,
 	__isl_take isl_id *id);
 __isl_give isl_set *isl_set_reset_tuple_id(__isl_take isl_set *set);
-int isl_set_has_tuple_id(__isl_keep isl_set *set);
+isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set);
 __isl_give isl_id *isl_set_get_tuple_id(__isl_keep isl_set *set);
 __isl_give isl_set *isl_set_reset_user(__isl_take isl_set *set);
 
@@ -88,25 +93,12 @@
 
 int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset);
 
-struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base,
-		unsigned nparam, unsigned dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-struct isl_basic_set *isl_basic_set_extend_constraints(
-		struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq);
-struct isl_basic_set *isl_basic_set_finalize(struct isl_basic_set *bset);
 __isl_null isl_basic_set *isl_basic_set_free(__isl_take isl_basic_set *bset);
 __isl_give isl_basic_set *isl_basic_set_copy(__isl_keep isl_basic_set *bset);
-struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset);
-__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *dim);
-struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *bset);
-__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *dim);
-__isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_space *dim);
-struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *bset);
-__isl_give isl_basic_set *isl_basic_set_universe_like_set(
-	__isl_keep isl_set *model);
+__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *space);
+__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *space);
+__isl_give isl_basic_set *isl_basic_set_nat_universe(
+	__isl_take isl_space *space);
 __isl_give isl_basic_set *isl_basic_set_positive_orthant(
 	__isl_take isl_space *space);
 void isl_basic_set_print_internal(__isl_keep isl_basic_set *bset,
@@ -132,7 +124,6 @@
 	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_export
 __isl_give isl_basic_set *isl_basic_set_sample(__isl_take isl_basic_set *bset);
-struct isl_basic_set *isl_basic_set_simplify(struct isl_basic_set *bset);
 __isl_export
 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
 						__isl_take isl_basic_set *bset);
@@ -141,8 +132,8 @@
 __isl_give isl_set *isl_set_remove_redundancies(__isl_take isl_set *set);
 __isl_give isl_basic_set *isl_basic_set_list_intersect(
 	__isl_take struct isl_basic_set_list *list);
-__isl_give isl_basic_set *isl_basic_set_list_product(
-	__isl_take struct isl_basic_set_list *list);
+
+__isl_give isl_set *isl_set_list_union(__isl_take isl_set_list *list);
 
 __isl_give isl_basic_set *isl_basic_set_read_from_file(isl_ctx *ctx,
 	FILE *input);
@@ -158,10 +149,6 @@
 	__isl_take isl_printer *printer, __isl_keep isl_basic_set *bset);
 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *printer,
 	__isl_keep isl_set *map);
-void isl_basic_set_print(__isl_keep isl_basic_set *bset, FILE *out, int indent,
-	const char *prefix, const char *suffix, unsigned output_format);
-void isl_set_print(__isl_keep struct isl_set *set, FILE *out, int indent,
-	unsigned output_format);
 __isl_give isl_basic_set *isl_basic_set_fix_si(__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned pos, int value);
 __isl_give isl_basic_set *isl_basic_set_fix_val(__isl_take isl_basic_set *bset,
@@ -170,26 +157,38 @@
 		enum isl_dim_type type, unsigned pos, int value);
 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_basic_set *isl_basic_set_lower_bound_val(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	__isl_take isl_val *value);
 __isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
 __isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, int value);
+__isl_give isl_basic_set *isl_basic_set_upper_bound_val(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	__isl_take isl_val *value);
 __isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value);
+__isl_overload
+__isl_give isl_set *isl_set_lower_bound_multi_val(__isl_take isl_set *set,
+	__isl_take isl_multi_val *lower);
+__isl_overload
+__isl_give isl_set *isl_set_upper_bound_multi_val(__isl_take isl_set *set,
+	__isl_take isl_multi_val *upper);
+__isl_overload
+__isl_give isl_set *isl_set_lower_bound_multi_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_pw_aff *lower);
+__isl_overload
+__isl_give isl_set *isl_set_upper_bound_multi_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_pw_aff *upper);
 
 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
 	enum isl_dim_type type1, int pos1, enum isl_dim_type type2, int pos2);
 
-struct isl_basic_set *isl_basic_set_from_underlying_set(
-	struct isl_basic_set *bset, struct isl_basic_set *like);
-struct isl_set *isl_set_from_underlying_set(
-	struct isl_set *set, struct isl_basic_set *like);
-struct isl_set *isl_set_to_underlying_set(struct isl_set *set);
-
 __isl_export
-int isl_basic_set_is_equal(
-		struct isl_basic_set *bset1, struct isl_basic_set *bset2);
-int isl_basic_set_is_disjoint(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2);
+isl_bool isl_basic_set_is_disjoint(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2);
 
 __isl_give isl_set *isl_basic_set_partial_lexmin(
@@ -218,63 +217,78 @@
 __isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmax_pw_multi_aff(
 	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_set_lexmin_pw_multi_aff(
 	__isl_take isl_set *set);
+__isl_export
 __isl_give isl_pw_multi_aff *isl_set_lexmax_pw_multi_aff(
 	__isl_take isl_set *set);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_set_min_multi_pw_aff(__isl_take isl_set *set);
+__isl_export
+__isl_give isl_multi_pw_aff *isl_set_max_multi_pw_aff(__isl_take isl_set *set);
 
 __isl_export
 __isl_give isl_set *isl_basic_set_union(
 		__isl_take isl_basic_set *bset1,
 		__isl_take isl_basic_set *bset2);
 
-int isl_basic_set_compare_at(struct isl_basic_set *bset1,
-	struct isl_basic_set *bset2, int pos);
+int isl_basic_set_compare_at(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2, int pos);
 int isl_set_follows_at(__isl_keep isl_set *set1,
 	__isl_keep isl_set *set2, int pos);
 
+__isl_export
 __isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset);
 __isl_give isl_basic_set *isl_basic_set_from_params(
 	__isl_take isl_basic_set *bset);
+__isl_export
 __isl_give isl_set *isl_set_params(__isl_take isl_set *set);
 __isl_give isl_set *isl_set_from_params(__isl_take isl_set *set);
 
-int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
+__isl_export
+__isl_give isl_set *isl_set_bind(__isl_take isl_set *set,
+	__isl_take isl_multi_id *tuple);
+__isl_export
+__isl_give isl_set *isl_set_unbind_params(__isl_take isl_set *set,
+	__isl_take isl_multi_id *tuple);
+__isl_export
+__isl_give isl_map *isl_set_unbind_params_insert_domain(
+	__isl_take isl_set *set, __isl_take isl_multi_id *domain);
+
+isl_stat isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos, unsigned n, int *signs);
 
-int isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
-int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
-ISL_DEPRECATED
-int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_plain_is_universe(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_is_universe(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset);
 __isl_export
-int isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
-int isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_is_empty(__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset);
 __isl_export
-int isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2);
-int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2);
 
-struct isl_set *isl_set_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned dim, int n, unsigned flags);
-struct isl_set *isl_set_extend(struct isl_set *base,
-		unsigned nparam, unsigned dim);
-__isl_give isl_set *isl_set_empty(__isl_take isl_space *dim);
-struct isl_set *isl_set_empty_like(struct isl_set *set);
-__isl_give isl_set *isl_set_universe(__isl_take isl_space *dim);
-__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *dim);
-__isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model);
-__isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
-						__isl_take isl_basic_set *bset);
-struct isl_set *isl_set_finalize(struct isl_set *set);
+__isl_export
+__isl_give isl_set *isl_set_empty(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_set *isl_set_universe(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_set *isl_space_universe_set(__isl_take isl_space *space);
+__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *space);
 __isl_give isl_set *isl_set_copy(__isl_keep isl_set *set);
 __isl_null isl_set *isl_set_free(__isl_take isl_set *set);
-struct isl_set *isl_set_dup(struct isl_set *set);
+__isl_export
+__isl_give isl_set *isl_basic_set_to_set(__isl_take isl_basic_set *bset);
 __isl_constructor
 __isl_give isl_set *isl_set_from_basic_set(__isl_take isl_basic_set *bset);
 __isl_export
 __isl_give isl_basic_set *isl_set_sample(__isl_take isl_set *set);
+__isl_export
 __isl_give isl_point *isl_basic_set_sample_point(__isl_take isl_basic_set *bset);
+__isl_export
 __isl_give isl_point *isl_set_sample_point(__isl_take isl_set *set);
 __isl_export
 __isl_give isl_set *isl_set_detect_equalities(__isl_take isl_set *set);
@@ -284,19 +298,22 @@
 __isl_export
 __isl_give isl_basic_set *isl_set_polyhedral_hull(__isl_take isl_set *set);
 __isl_give isl_basic_set *isl_set_simple_hull(__isl_take isl_set *set);
+__isl_export
 __isl_give isl_basic_set *isl_set_unshifted_simple_hull(
 	__isl_take isl_set *set);
+__isl_give isl_basic_set *isl_set_plain_unshifted_simple_hull(
+	__isl_take isl_set *set);
 __isl_give isl_basic_set *isl_set_unshifted_simple_hull_from_set_list(
 	__isl_take isl_set *set, __isl_take isl_set_list *list);
-struct isl_basic_set *isl_set_bounded_simple_hull(struct isl_set *set);
-__isl_give isl_set *isl_set_recession_cone(__isl_take isl_set *set);
+__isl_give isl_basic_set *isl_set_bounded_simple_hull(__isl_take isl_set *set);
 
-struct isl_set *isl_set_union_disjoint(
-			struct isl_set *set1, struct isl_set *set2);
+__isl_give isl_set *isl_set_union_disjoint(
+	__isl_take isl_set *set1, __isl_take isl_set *set2);
 __isl_export
 __isl_give isl_set *isl_set_union(
 		__isl_take isl_set *set1,
 		__isl_take isl_set *set2);
+__isl_export
 __isl_give isl_set *isl_set_product(__isl_take isl_set *set1,
 	__isl_take isl_set *set2);
 __isl_give isl_basic_set *isl_basic_set_flat_product(
@@ -310,6 +327,10 @@
 __isl_export
 __isl_give isl_set *isl_set_intersect_params(__isl_take isl_set *set,
 		__isl_take isl_set *params);
+__isl_give isl_set *isl_set_intersect_factor_domain(__isl_take isl_set *set,
+	__isl_take isl_set *domain);
+__isl_give isl_set *isl_set_intersect_factor_range(__isl_take isl_set *set,
+	__isl_take isl_set *range);
 __isl_export
 __isl_give isl_set *isl_set_subtract(
 		__isl_take isl_set *set1,
@@ -320,15 +341,18 @@
 __isl_give isl_set *isl_set_apply(
 		__isl_take isl_set *set,
 		__isl_take isl_map *map);
+__isl_overload
 __isl_give isl_set *isl_set_preimage_multi_aff(__isl_take isl_set *set,
 	__isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_set *isl_set_preimage_pw_multi_aff(__isl_take isl_set *set,
 	__isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_set *isl_set_preimage_multi_pw_aff(__isl_take isl_set *set,
 	__isl_take isl_multi_pw_aff *mpa);
 __isl_give isl_set *isl_set_fix_val(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *v);
-struct isl_set *isl_set_fix_dim_si(struct isl_set *set,
+__isl_give isl_set *isl_set_fix_dim_si(__isl_take isl_set *set,
 		unsigned dim, int value);
 __isl_give isl_basic_set *isl_basic_set_insert_dims(
 	__isl_take isl_basic_set *bset,
@@ -337,9 +361,6 @@
 		enum isl_dim_type type, unsigned pos, unsigned n);
 __isl_give isl_basic_set *isl_basic_set_add_dims(__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned n);
-/* deprecated */
-__isl_give isl_basic_set *isl_basic_set_add(__isl_take isl_basic_set *bset,
-	enum isl_dim_type type, unsigned n);
 __isl_give isl_set *isl_set_add_dims(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned n);
 __isl_give isl_basic_set *isl_basic_set_move_dims(__isl_take isl_basic_set *bset,
@@ -351,8 +372,18 @@
 __isl_give isl_basic_set *isl_basic_set_project_out(
 		__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned first, unsigned n);
+__isl_overload
+__isl_give isl_set *isl_set_project_out_param_id(__isl_take isl_set *set,
+	__isl_take isl_id *id);
+__isl_overload
+__isl_give isl_set *isl_set_project_out_param_id_list(__isl_take isl_set *set,
+	__isl_take isl_id_list *list);
 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned first, unsigned n);
+__isl_export
+__isl_give isl_set *isl_set_project_out_all_params(__isl_take isl_set *set);
+__isl_give isl_map *isl_set_project_onto_map(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_basic_set *isl_basic_set_remove_divs(
 	__isl_take isl_basic_set *bset);
 __isl_give isl_basic_set *isl_basic_set_eliminate(
@@ -360,7 +391,7 @@
 	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n);
-struct isl_set *isl_set_eliminate_dims(struct isl_set *set,
+__isl_give isl_set *isl_set_eliminate_dims(__isl_take isl_set *set,
 		unsigned first, unsigned n);
 __isl_give isl_set *isl_set_remove_dims(__isl_take isl_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n);
@@ -385,34 +416,40 @@
 __isl_give isl_set *isl_set_drop_constraints_involving_dims(
 	__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_set *isl_set_drop_constraints_not_involving_dims(
+	__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n);
+
+__isl_export
+isl_bool isl_set_involves_locals(__isl_keep isl_set *set);
 
-int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
+isl_bool isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n);
-int isl_set_involves_dims(__isl_keep isl_set *set,
+isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
 void isl_set_print_internal(__isl_keep isl_set *set, FILE *out, int indent);
-int isl_set_plain_is_empty(__isl_keep isl_set *set);
-ISL_DEPRECATED
-int isl_set_fast_is_empty(__isl_keep isl_set *set);
-int isl_set_plain_is_universe(__isl_keep isl_set *set);
-ISL_DEPRECATED
-int isl_set_fast_is_universe(__isl_keep isl_set *set);
-int isl_set_is_params(__isl_keep isl_set *set);
+isl_bool isl_set_plain_is_empty(__isl_keep isl_set *set);
+isl_bool isl_set_plain_is_universe(__isl_keep isl_set *set);
+isl_bool isl_set_is_params(__isl_keep isl_set *set);
 __isl_export
-int isl_set_is_empty(__isl_keep isl_set *set);
-int isl_set_is_bounded(__isl_keep isl_set *set);
+isl_bool isl_set_is_empty(__isl_keep isl_set *set);
+isl_bool isl_set_is_bounded(__isl_keep isl_set *set);
 __isl_export
-int isl_set_is_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
+isl_bool isl_set_is_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
 __isl_export
-int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
+isl_bool isl_set_is_strict_subset(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2);
 __isl_export
-int isl_set_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
+isl_bool isl_set_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
 __isl_export
-int isl_set_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
-int isl_set_is_singleton(__isl_keep isl_set *set);
-int isl_set_is_box(__isl_keep isl_set *set);
-int isl_set_has_equal_space(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
+isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2);
+__isl_export
+isl_bool isl_set_is_singleton(__isl_keep isl_set *set);
+isl_bool isl_set_is_box(__isl_keep isl_set *set);
+isl_bool isl_set_has_equal_space(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2);
 
 __isl_give isl_set *isl_set_sum(__isl_take isl_set *set1,
 	__isl_take isl_set *set2);
@@ -420,25 +457,25 @@
 __isl_give isl_set *isl_set_neg(__isl_take isl_set *set);
 
 __isl_give isl_set *isl_set_make_disjoint(__isl_take isl_set *set);
-struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset);
+__isl_give isl_set *isl_basic_set_compute_divs(__isl_take isl_basic_set *bset);
 __isl_give isl_set *isl_set_compute_divs(__isl_take isl_set *set);
+ISL_DEPRECATED
 __isl_give isl_set *isl_set_align_divs(__isl_take isl_set *set);
 
-struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set);
-struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
-						struct isl_basic_set *bset);
-
+__isl_export
+__isl_give isl_multi_val *isl_set_get_plain_multi_val_if_fixed(
+	__isl_keep isl_set *set);
 __isl_give isl_val *isl_set_plain_get_val_if_fixed(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
-int isl_set_dim_is_bounded(__isl_keep isl_set *set,
+isl_bool isl_set_dim_is_bounded(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
-int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
-int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
-int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
-int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos);
 
 __isl_export
@@ -451,36 +488,45 @@
 	__isl_take isl_set *context);
 __isl_give isl_set *isl_set_gist_params(__isl_take isl_set *set,
 	__isl_take isl_set *context);
-int isl_set_dim_residue_class_val(__isl_keep isl_set *set,
+isl_stat isl_set_dim_residue_class_val(__isl_keep isl_set *set,
 	int pos, __isl_give isl_val **modulo, __isl_give isl_val **residue);
 
+__isl_give isl_stride_info *isl_set_get_stride_info(__isl_keep isl_set *set,
+	int pos);
+__isl_export
+__isl_give isl_val *isl_set_get_stride(__isl_keep isl_set *set, int pos);
+__isl_export
+__isl_give isl_fixed_box *isl_set_get_simple_fixed_box_hull(
+	__isl_keep isl_set *set);
+
 __isl_export
 __isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set);
 
 int isl_set_plain_cmp(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
-int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
-ISL_DEPRECATED
-int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2);
-int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
+isl_bool isl_set_plain_is_equal(__isl_keep isl_set *set1,
 	__isl_keep isl_set *set2);
-ISL_DEPRECATED
-int isl_set_fast_is_disjoint(__isl_keep isl_set *set1,
+isl_bool isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
 	__isl_keep isl_set *set2);
 
-uint32_t isl_set_get_hash(struct isl_set *set);
+uint32_t isl_set_get_hash(__isl_keep isl_set *set);
 
-int isl_set_dim_is_unique(struct isl_set *set, unsigned dim);
-
-int isl_set_n_basic_set(__isl_keep isl_set *set);
+isl_size isl_set_n_basic_set(__isl_keep isl_set *set);
 __isl_export
-int isl_set_foreach_basic_set(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user);
+isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_basic_set *bset, void *user), void *user);
+__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
+	__isl_keep isl_set *set);
 
-int isl_set_foreach_point(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_point *pnt, void *user), void *user);
+__isl_export
+isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user);
 __isl_give isl_val *isl_set_count_val(__isl_keep isl_set *set);
 
+__isl_constructor
 __isl_give isl_basic_set *isl_basic_set_from_point(__isl_take isl_point *pnt);
+__isl_export
+__isl_give isl_set *isl_point_to_set(__isl_take isl_point *pnt);
+__isl_constructor
 __isl_give isl_set *isl_set_from_point(__isl_take isl_point *pnt);
 __isl_give isl_basic_set *isl_basic_set_box_from_points(
 	__isl_take isl_point *pnt1, __isl_take isl_point *pnt2);
@@ -505,6 +551,9 @@
 	__isl_take isl_basic_set *bset, __isl_take isl_space *model);
 __isl_give isl_set *isl_set_align_params(__isl_take isl_set *set,
 	__isl_take isl_space *model);
+__isl_give isl_basic_set *isl_basic_set_drop_unused_params(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_set *isl_set_drop_unused_params(__isl_take isl_set *set);
 
 __isl_give isl_mat *isl_basic_set_equalities_matrix(
 	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
@@ -513,14 +562,23 @@
 	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4);
 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
-	__isl_take isl_space *dim,
+	__isl_take isl_space *space,
 	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4);
 
+__isl_give isl_basic_set *isl_basic_set_from_multi_aff(
+	__isl_take isl_multi_aff *ma);
+
+__isl_export
+__isl_give isl_set *isl_multi_aff_as_set(__isl_take isl_multi_aff *ma);
+__isl_give isl_set *isl_set_from_multi_aff(__isl_take isl_multi_aff *ma);
+
 __isl_give isl_mat *isl_basic_set_reduced_basis(__isl_keep isl_basic_set *bset);
 
 __isl_give isl_basic_set *isl_basic_set_coefficients(
 	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_set_list *isl_basic_set_list_coefficients(
+	__isl_take isl_basic_set_list *list);
 __isl_give isl_basic_set *isl_set_coefficients(__isl_take isl_set *set);
 __isl_give isl_basic_set *isl_basic_set_solutions(
 	__isl_take isl_basic_set *bset);
@@ -529,12 +587,11 @@
 __isl_give isl_pw_aff *isl_set_dim_max(__isl_take isl_set *set, int pos);
 __isl_give isl_pw_aff *isl_set_dim_min(__isl_take isl_set *set, int pos);
 
+__isl_give char *isl_basic_set_to_str(__isl_keep isl_basic_set *bset);
 __isl_give char *isl_set_to_str(__isl_keep isl_set *set);
 
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/space.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/space.h Changed

@@ -11,154 +11,203 @@
 #define ISL_SPACE_H
 
 #include <isl/ctx.h>
-#include <isl/id.h>
+#include <isl/space_type.h>
+#include <isl/id_type.h>
 #include <isl/printer.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_space;
-typedef struct isl_space isl_space;
-
-enum isl_dim_type {
-	isl_dim_cst,
-	isl_dim_param,
-	isl_dim_in,
-	isl_dim_out,
-	isl_dim_set = isl_dim_out,
-	isl_dim_div,
-	isl_dim_all
-};
-
-isl_ctx *isl_space_get_ctx(__isl_keep isl_space *dim);
+isl_ctx *isl_space_get_ctx(__isl_keep isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_unit(isl_ctx *ctx);
 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
 			unsigned nparam, unsigned n_in, unsigned n_out);
 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
 			unsigned nparam, unsigned dim);
 __isl_give isl_space *isl_space_params_alloc(isl_ctx *ctx, unsigned nparam);
-__isl_give isl_space *isl_space_copy(__isl_keep isl_space *dim);
+__isl_give isl_space *isl_space_copy(__isl_keep isl_space *space);
 __isl_null isl_space *isl_space_free(__isl_take isl_space *space);
 
-int isl_space_is_params(__isl_keep isl_space *space);
-int isl_space_is_set(__isl_keep isl_space *space);
-int isl_space_is_map(__isl_keep isl_space *space);
+isl_bool isl_space_is_params(__isl_keep isl_space *space);
+isl_bool isl_space_is_set(__isl_keep isl_space *space);
+isl_bool isl_space_is_map(__isl_keep isl_space *space);
+
+__isl_give isl_space *isl_space_add_param_id(__isl_take isl_space *space,
+	__isl_take isl_id *id);
 
-__isl_give isl_space *isl_space_set_tuple_name(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_tuple_name(__isl_take isl_space *space,
 	enum isl_dim_type type, const char *s);
-int isl_space_has_tuple_name(__isl_keep isl_space *space,
+isl_bool isl_space_has_tuple_name(__isl_keep isl_space *space,
 	enum isl_dim_type type);
-const char *isl_space_get_tuple_name(__isl_keep isl_space *dim,
+__isl_keep const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
 				 enum isl_dim_type type);
-__isl_give isl_space *isl_space_set_tuple_id(__isl_take isl_space *dim,
+__isl_overload
+__isl_give isl_space *isl_space_set_domain_tuple_id(
+	__isl_take isl_space *space, __isl_take isl_id *id);
+__isl_overload
+__isl_give isl_space *isl_space_set_range_tuple_id(
+	__isl_take isl_space *space, __isl_take isl_id *id);
+__isl_give isl_space *isl_space_set_tuple_id(__isl_take isl_space *space,
 	enum isl_dim_type type, __isl_take isl_id *id);
-__isl_give isl_space *isl_space_reset_tuple_id(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_reset_tuple_id(__isl_take isl_space *space,
 	enum isl_dim_type type);
-int isl_space_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type);
-__isl_give isl_id *isl_space_get_tuple_id(__isl_keep isl_space *dim,
+__isl_export
+isl_bool isl_space_has_domain_tuple_id(__isl_keep isl_space *space);
+__isl_export
+isl_bool isl_space_has_range_tuple_id(__isl_keep isl_space *space);
+isl_bool isl_space_has_tuple_id(__isl_keep isl_space *space,
+	enum isl_dim_type type);
+__isl_export
+__isl_give isl_id *isl_space_get_domain_tuple_id(
+	__isl_keep isl_space *space);
+__isl_export
+__isl_give isl_id *isl_space_get_range_tuple_id(
+	__isl_keep isl_space *space);
+__isl_give isl_id *isl_space_get_tuple_id(__isl_keep isl_space *space,
 	enum isl_dim_type type);
 __isl_give isl_space *isl_space_reset_user(__isl_take isl_space *space);
 
-__isl_give isl_space *isl_space_set_dim_id(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_dim_id(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id);
-int isl_space_has_dim_id(__isl_keep isl_space *dim,
+isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos);
-__isl_give isl_id *isl_space_get_dim_id(__isl_keep isl_space *dim,
+__isl_give isl_id *isl_space_get_dim_id(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos);
 
-int isl_space_find_dim_by_id(__isl_keep isl_space *dim, enum isl_dim_type type,
-	__isl_keep isl_id *id);
+int isl_space_find_dim_by_id(__isl_keep isl_space *space,
+	enum isl_dim_type type, __isl_keep isl_id *id);
 int isl_space_find_dim_by_name(__isl_keep isl_space *space,
 	enum isl_dim_type type, const char *name);
 
-int isl_space_has_dim_name(__isl_keep isl_space *space,
+isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos);
-__isl_give isl_space *isl_space_set_dim_name(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_dim_name(__isl_take isl_space *space,
 				 enum isl_dim_type type, unsigned pos,
 				 __isl_keep const char *name);
-__isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *dim,
+__isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *space,
 				 enum isl_dim_type type, unsigned pos);
 
-__isl_give isl_space *isl_space_extend(__isl_take isl_space *dim,
+ISL_DEPRECATED
+__isl_give isl_space *isl_space_extend(__isl_take isl_space *space,
 			unsigned nparam, unsigned n_in, unsigned n_out);
-__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *dim, enum isl_dim_type type,
-		unsigned n);
-__isl_give isl_space *isl_space_move_dims(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
+	enum isl_dim_type type, unsigned n);
+__isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
-__isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned pos, unsigned n);
 __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
 	__isl_take isl_space *right);
+__isl_export
 __isl_give isl_space *isl_space_product(__isl_take isl_space *left,
 	__isl_take isl_space *right);
 __isl_give isl_space *isl_space_domain_product(__isl_take isl_space *left,
 	__isl_take isl_space *right);
 __isl_give isl_space *isl_space_range_product(__isl_take isl_space *left,
 	__isl_take isl_space *right);
+__isl_give isl_space *isl_space_factor_domain(__isl_take isl_space *space);
+__isl_give isl_space *isl_space_factor_range(__isl_take isl_space *space);
 __isl_give isl_space *isl_space_domain_factor_domain(
 	__isl_take isl_space *space);
+__isl_give isl_space *isl_space_domain_factor_range(
+	__isl_take isl_space *space);
 __isl_give isl_space *isl_space_range_factor_domain(
 	__isl_take isl_space *space);
 __isl_give isl_space *isl_space_range_factor_range(
 	__isl_take isl_space *space);
-__isl_give isl_space *isl_space_map_from_set(__isl_take isl_space *dim);
+__isl_export
+__isl_give isl_space *isl_space_map_from_set(__isl_take isl_space *space);
 __isl_give isl_space *isl_space_map_from_domain_and_range(
 	__isl_take isl_space *domain, __isl_take isl_space *range);
-__isl_give isl_space *isl_space_reverse(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *dim,
+__isl_export
+__isl_give isl_space *isl_space_reverse(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_range_reverse(__isl_take isl_space *space);
+__isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned first, unsigned num);
-__isl_give isl_space *isl_space_drop_inputs(__isl_take isl_space *dim,
+ISL_DEPRECATED
+__isl_give isl_space *isl_space_drop_inputs(__isl_take isl_space *space,
 		unsigned first, unsigned n);
-__isl_give isl_space *isl_space_drop_outputs(__isl_take isl_space *dim,
+ISL_DEPRECATED
+__isl_give isl_space *isl_space_drop_outputs(__isl_take isl_space *space,
 		unsigned first, unsigned n);
-__isl_give isl_space *isl_space_domain(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_from_domain(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_range(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_from_range(__isl_take isl_space *dim);
+__isl_give isl_space *isl_space_drop_all_params(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_domain(__isl_take isl_space *space);
+__isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_range(__isl_take isl_space *space);
+__isl_give isl_space *isl_space_from_range(__isl_take isl_space *space);
 __isl_give isl_space *isl_space_domain_map(__isl_take isl_space *space);
 __isl_give isl_space *isl_space_range_map(__isl_take isl_space *space);
+__isl_export
 __isl_give isl_space *isl_space_params(__isl_take isl_space *space);
+__isl_overload
+__isl_give isl_space *isl_space_add_unnamed_tuple_ui(
+	__isl_take isl_space *space, unsigned dim);
+__isl_overload
+__isl_give isl_space *isl_space_add_named_tuple_id_ui(
+	__isl_take isl_space *space, __isl_take isl_id *tuple_id, unsigned dim);
 __isl_give isl_space *isl_space_set_from_params(__isl_take isl_space *space);
 
-__isl_give isl_space *isl_space_align_params(__isl_take isl_space *dim1,
-	__isl_take isl_space *dim2);
+__isl_give isl_space *isl_space_align_params(__isl_take isl_space *space1,
+	__isl_take isl_space *space2);
 
-int isl_space_is_wrapping(__isl_keep isl_space *dim);
-int isl_space_domain_is_wrapping(__isl_keep isl_space *space);
-int isl_space_range_is_wrapping(__isl_keep isl_space *space);
-__isl_give isl_space *isl_space_wrap(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_unwrap(__isl_take isl_space *dim);
+__isl_export
+isl_bool isl_space_is_wrapping(__isl_keep isl_space *space);
+isl_bool isl_space_domain_is_wrapping(__isl_keep isl_space *space);
+isl_bool isl_space_range_is_wrapping(__isl_keep isl_space *space);
+isl_bool isl_space_is_product(__isl_keep isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_wrap(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space);
 
-int isl_space_can_zip(__isl_keep isl_space *dim);
-__isl_give isl_space *isl_space_zip(__isl_take isl_space *dim);
+isl_bool isl_space_can_zip(__isl_keep isl_space *space);
+__isl_give isl_space *isl_space_zip(__isl_take isl_space *space);
 
-int isl_space_can_curry(__isl_keep isl_space *space);
+isl_bool isl_space_can_curry(__isl_keep isl_space *space);
+__isl_export
 __isl_give isl_space *isl_space_curry(__isl_take isl_space *space);
 
-int isl_space_can_uncurry(__isl_keep isl_space *space);
+isl_bool isl_space_can_range_curry(__isl_keep isl_space *space);
+__isl_give isl_space *isl_space_range_curry(__isl_take isl_space *space);
+
+isl_bool isl_space_can_uncurry(__isl_keep isl_space *space);
+__isl_export
 __isl_give isl_space *isl_space_uncurry(__isl_take isl_space *space);
 
-int isl_space_is_domain(__isl_keep isl_space *space1,
+isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_bool isl_space_is_range(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2);
-int isl_space_is_range(__isl_keep isl_space *space1,
+__isl_export
+isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2);
-int isl_space_is_equal(__isl_keep isl_space *space1,
+isl_bool isl_space_has_equal_params(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2);
-int isl_space_tuple_is_equal(__isl_keep isl_space *space1,
+isl_bool isl_space_has_equal_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_bool isl_space_tuple_is_equal(__isl_keep isl_space *space1,
 	enum isl_dim_type type1, __isl_keep isl_space *space2,
 	enum isl_dim_type type2);
-int isl_space_match(__isl_keep isl_space *dim1, enum isl_dim_type dim1_type,
-	__isl_keep isl_space *dim2, enum isl_dim_type dim2_type);
-int isl_space_tuple_match(__isl_keep isl_space *space1, enum isl_dim_type type1,
+ISL_DEPRECATED
+isl_bool isl_space_match(__isl_keep isl_space *space1, enum isl_dim_type type1,
 	__isl_keep isl_space *space2, enum isl_dim_type type2);
-int isl_space_compatible(__isl_keep isl_space *dim1,
-	__isl_keep isl_space *dim2);
-unsigned isl_space_dim(__isl_keep isl_space *dim, enum isl_dim_type type);
+isl_size isl_space_dim(__isl_keep isl_space *space, enum isl_dim_type type);
+
+__isl_export
+__isl_give isl_space *isl_space_flatten_domain(__isl_take isl_space *space);
+__isl_export
+__isl_give isl_space *isl_space_flatten_range(__isl_take isl_space *space);
 
+__isl_give char *isl_space_to_str(__isl_keep isl_space *space);
 __isl_give isl_printer *isl_printer_print_space(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim);
-void isl_space_dump(__isl_keep isl_space *dim);
+	__isl_keep isl_space *space);
+void isl_space_dump(__isl_keep isl_space *space);
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.24.tar.gz/include/isl/space_type.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/stream.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/stream.h Changed

@@ -14,7 +14,8 @@
 #include <isl/hash.h>
 #include <isl/aff_type.h>
 #include <isl/obj.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
+#include <isl/schedule_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
@@ -37,6 +38,7 @@
 			ISL_TOKEN_MAP, ISL_TOKEN_AFF,
 			ISL_TOKEN_CEIL, ISL_TOKEN_FLOOR,
 			ISL_TOKEN_IMPLIES,
+			ISL_TOKEN_INT_DIV,
 			ISL_TOKEN_LAST };
 
 struct isl_token;
@@ -46,55 +48,48 @@
 int isl_token_get_type(struct isl_token *tok);
 void isl_token_free(struct isl_token *tok);
 
-struct isl_stream {
-	struct isl_ctx	*ctx;
-	FILE        	*file;
-	const char  	*str;
-	int	    	line;
-	int	    	col;
-	int	    	eof;
-
-	char	    	*buffer;
-	size_t	    	size;
-	size_t	    	len;
-	int	    	c;
-	int		un5;
-	int		n_un;
-
-	struct isl_token	*tokens5;
-	int	    	n_token;
-
-	struct isl_hash_table	*keywords;
-	enum isl_token_type	 next_type;
-};
-
-struct isl_stream* isl_stream_new_file(struct isl_ctx *ctx, FILE *file);
-struct isl_stream* isl_stream_new_str(struct isl_ctx *ctx, const char *str);
-void isl_stream_free(struct isl_stream *s);
-
-void isl_stream_error(struct isl_stream *s, struct isl_token *tok, char *msg);
-
-struct isl_token *isl_stream_next_token(struct isl_stream *s);
-struct isl_token *isl_stream_next_token_on_same_line(struct isl_stream *s);
-int isl_stream_next_token_is(struct isl_stream *s, int type);
-void isl_stream_push_token(struct isl_stream *s, struct isl_token *tok);
-void isl_stream_flush_tokens(struct isl_stream *s);
-int isl_stream_eat_if_available(struct isl_stream *s, int type);
-char *isl_stream_read_ident_if_available(struct isl_stream *s);
-int isl_stream_eat(struct isl_stream *s, int type);
-int isl_stream_is_empty(struct isl_stream *s);
-int isl_stream_skip_line(struct isl_stream *s);
-
-enum isl_token_type isl_stream_register_keyword(struct isl_stream *s,
+struct isl_stream;
+typedef struct isl_stream isl_stream;
+
+__isl_give isl_stream *isl_stream_new_file(isl_ctx *ctx, FILE *file);
+__isl_give isl_stream *isl_stream_new_str(isl_ctx *ctx, const char *str);
+void isl_stream_free(__isl_take isl_stream *s);
+
+isl_ctx *isl_stream_get_ctx(__isl_keep isl_stream *s);
+
+void isl_stream_error(__isl_keep isl_stream *s, struct isl_token *tok,
+	char *msg);
+
+struct isl_token *isl_stream_next_token(__isl_keep isl_stream *s);
+struct isl_token *isl_stream_next_token_on_same_line(__isl_keep isl_stream *s);
+int isl_stream_next_token_is(__isl_keep isl_stream *s, int type);
+void isl_stream_push_token(__isl_keep isl_stream *s, struct isl_token *tok);
+void isl_stream_flush_tokens(__isl_keep isl_stream *s);
+int isl_stream_eat_if_available(__isl_keep isl_stream *s, int type);
+char *isl_stream_read_ident_if_available(__isl_keep isl_stream *s);
+int isl_stream_eat(__isl_keep isl_stream *s, int type);
+int isl_stream_is_empty(__isl_keep isl_stream *s);
+int isl_stream_skip_line(__isl_keep isl_stream *s);
+
+enum isl_token_type isl_stream_register_keyword(__isl_keep isl_stream *s,
 	const char *name);
 
-struct isl_obj isl_stream_read_obj(struct isl_stream *s);
-__isl_give isl_multi_aff *isl_stream_read_multi_aff(struct isl_stream *s);
-__isl_give isl_map *isl_stream_read_map(struct isl_stream *s);
-__isl_give isl_set *isl_stream_read_set(struct isl_stream *s);
+struct isl_obj isl_stream_read_obj(__isl_keep isl_stream *s);
+__isl_give isl_val *isl_stream_read_val(__isl_keep isl_stream *s);
+__isl_give isl_multi_aff *isl_stream_read_multi_aff(__isl_keep isl_stream *s);
+__isl_give isl_map *isl_stream_read_map(__isl_keep isl_stream *s);
+__isl_give isl_set *isl_stream_read_set(__isl_keep isl_stream *s);
 __isl_give isl_pw_qpolynomial *isl_stream_read_pw_qpolynomial(
-	struct isl_stream *s);
-__isl_give isl_union_map *isl_stream_read_union_map(struct isl_stream *s);
+	__isl_keep isl_stream *s);
+__isl_give isl_union_set *isl_stream_read_union_set(__isl_keep isl_stream *s);
+__isl_give isl_union_map *isl_stream_read_union_map(__isl_keep isl_stream *s);
+__isl_give isl_schedule *isl_stream_read_schedule(isl_stream *s);
+
+int isl_stream_yaml_read_start_mapping(__isl_keep isl_stream *s);
+int isl_stream_yaml_read_end_mapping(__isl_keep isl_stream *s);
+int isl_stream_yaml_read_start_sequence(__isl_keep isl_stream *s);
+int isl_stream_yaml_read_end_sequence(__isl_keep isl_stream *s);
+int isl_stream_yaml_next(__isl_keep isl_stream *s);
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.24.tar.gz/include/isl/stride_info.h Added

_service:tar_scm:isl-0.24.tar.gz/include/isl/typed_cpp.h Added

@@ -0,0 +1,46689 @@
+/// These are automatically generated templated 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.
+
+#ifndef ISL_TYPED_CPP
+#define ISL_TYPED_CPP
+
+#include <type_traits>
+
+#include <isl/cpp.h>
+
+namespace isl {
+namespace typed {
+
+template <typename Domain, typename Range>
+struct pair {};
+
+struct Anonymous;
+
+
+template <typename...>
+struct aff;
+
+template <typename...Ts>
+using aff_on = aff<Ts..., Anonymous>;
+
+template <typename...>
+struct aff_list;
+
+template <typename...Ts>
+using aff_list_on = aff_list<Ts..., Anonymous>;
+
+template <typename...>
+struct basic_map;
+
+template <typename...>
+struct basic_set;
+
+template <typename...>
+struct fixed_box;
+
+template <typename...>
+struct id;
+
+template <typename...>
+struct id_list;
+
+template <typename...>
+struct map;
+
+template <typename...>
+struct multi_aff;
+
+template <typename...>
+struct multi_id;
+
+template <typename...>
+struct multi_pw_aff;
+
+template <typename...>
+struct multi_union_pw_aff;
+
+template <typename...>
+struct multi_val;
+
+template <typename...>
+struct point;
+
+template <typename...>
+struct pw_aff;
+
+template <typename...Ts>
+using pw_aff_on = pw_aff<Ts..., Anonymous>;
+
+template <typename...>
+struct pw_aff_list;
+
+template <typename...Ts>
+using pw_aff_list_on = pw_aff_list<Ts..., Anonymous>;
+
+template <typename...>
+struct pw_multi_aff;
+
+template <typename...>
+struct pw_multi_aff_list;
+
+template <typename...>
+struct set;
+
+template <typename...>
+struct space;
+
+template <typename...>
+struct union_map;
+
+template <typename...>
+struct union_pw_aff;
+
+template <typename...Ts>
+using union_pw_aff_on = union_pw_aff<Ts..., Anonymous>;
+
+template <typename...>
+struct union_pw_aff_list;
+
+template <typename...Ts>
+using union_pw_aff_list_on = union_pw_aff_list<Ts..., Anonymous>;
+
+template <typename...>
+struct union_pw_multi_aff;
+
+template <typename...>
+struct union_set;
+
+template <typename...>
+struct union_set_list;
+
+template <typename...>
+struct val;
+
+template <typename...>
+struct val_list;
+
+template <>
+struct aff<Anonymous> : public isl::aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  aff() = default;
+  aff(const isl::aff &obj) : isl::aff(obj) {}
+  static aff from(const isl::aff &obj) {
+    return aff(obj);
+  }
+  inline explicit aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::aff<Anonymous> add(const typed::aff<Anonymous> &aff2) const;
+  inline typed::multi_aff<Anonymous> add(const typed::multi_aff<Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<Anonymous> add(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Anonymous> add(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> add(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> add(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::aff<Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Anonymous> add_constant(long v) const;
+  inline typed::multi_aff<Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const;
+  inline typed::aff<Anonymous> as_aff() const;
+  inline typed::map<Anonymous> as_map() const = delete;
+  inline typed::multi_aff<Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Anonymous> as_pw_multi_aff() const;
+  inline typed::set<Anonymous> as_set() const;
+  inline typed::union_map<Anonymous> as_union_map() const = delete;
+  inline typed::aff<Anonymous> at(int pos) const;
+  inline typed::basic_set<> bind(const typed::id<Anonymous> &id) const;
+  inline typed::basic_set<> bind(const std::string &id) const;
+  inline typed::basic_set<> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Anonymous> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Anonymous> coalesce() const;
+  inline typed::multi_val<Anonymous> constant_multi_val() const;
+  inline typed::val<Anonymous> get_constant_val() const = delete;
+  inline typed::set<> domain() const;
+  inline typed::aff<Anonymous> floor() const;
+  inline typed::set<Anonymous> ge_set(const typed::aff<> &aff2) const = delete;
+  inline typed::set<Anonymous> ge_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::aff<Anonymous> gist(const typed::set<> &context) const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::union_set<> &context) const;
+  inline typed::aff<Anonymous> gist(const typed::basic_set<> &context) const;
+  inline typed::aff<Anonymous> gist(const typed::point<> &context) const;
+  inline typed::set<Anonymous> gt_set(const typed::aff<> &aff2) const = delete;
+  inline typed::set<Anonymous> gt_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::multi_aff<Anonymous, Anonymous> identity() const;
+  template <typename Domain>
+  inline typed::pw_aff<Domain, Anonymous> insert_domain(const typed::space<Domain> &domain) const;
+  inline typed::pw_aff<Anonymous> intersect_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_aff<Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::set<Anonymous> le_set(const typed::aff<> &aff2) const = delete;
+  inline typed::set<Anonymous> le_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::aff_list<Anonymous> list() const;
+  inline typed::set<Anonymous> lt_set(const typed::aff<> &aff2) const = delete;
+  inline typed::set<Anonymous> lt_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::multi_pw_aff<Anonymous> max(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> max(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<Anonymous> min(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> min(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::aff<Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::aff<Anonymous> mod(long mod) const;
+  inline typed::aff<Anonymous> neg() const;
+  inline typed::pw_multi_aff<Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Range>
+  inline typed::multi_aff<pair<Anonymous, Range>> product(const typed::multi_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Anonymous, Range>> product(const typed::multi_pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Anonymous, Range>> product(const typed::pw_multi_aff<Range> &pma2) const;
+  inline typed::aff<Anonymous> pullback(const typed::multi_aff<> &ma) const = delete;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::aff<Anonymous> pullback(const typed::aff<> &ma) const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_factor_range() const = delete;
+  inline typed::multi_aff<Anonymous> range_product(const typed::multi_aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Anonymous> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_product(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::aff<Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Anonymous> scale(long v) const;
+  inline typed::multi_aff<Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::aff<Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Anonymous> scale_down(long v) const;
+  inline typed::multi_aff<Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_aff<Anonymous> set_at(int pos, const typed::aff<Anonymous> &el) const;
+  inline typed::multi_pw_aff<Anonymous> set_at(int pos, const typed::pw_aff<Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Anonymous> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Anonymous> space() const;
+  inline typed::aff<Anonymous> sub(const typed::aff<Anonymous> &aff2) const;
+  inline typed::multi_aff<Anonymous> sub(const typed::multi_aff<Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<Anonymous> sub(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Anonymous> sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> sub(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> sub(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> sub(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::pw_aff<Anonymous> subtract_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::multi_pw_aff<Anonymous> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Anonymous> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Anonymous> to_pw_multi_aff() const;
+  inline typed::union_pw_aff<Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Anonymous> to_union_pw_multi_aff() const;
+  template <typename Domain>
+  inline typed::aff<Domain, Anonymous> unbind_params_insert_domain(const typed::multi_id<Domain> &domain) const;
+  inline typed::multi_pw_aff<Anonymous> union_add(const typed::multi_pw_aff<Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<Anonymous> union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const;
+  inline typed::pw_aff<Anonymous> union_add(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> union_add(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> union_add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+};
+
+template <typename Domain>
+struct aff<Domain, Anonymous> : public isl::aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  aff(const aff<Arg1, Anonymous> &obj) : isl::aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::aff>{}, bool>::type = true>
+  aff(const base &obj) : isl::aff(obj) {}
+ public:
+  static aff from(const isl::aff &obj) {
+    return aff(obj);
+  }
+  inline explicit aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::aff<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::multi_aff<Domain, Anonymous> add(const typed::multi_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> add(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::aff<Domain, Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Domain, Anonymous> add_constant(long v) const;
+  inline typed::multi_aff<Domain, Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const;
+  inline typed::aff<Domain, Anonymous> as_aff() const;
+  inline typed::map<Domain, Anonymous> as_map() const;
+  inline typed::multi_aff<Domain, Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> as_pw_multi_aff() const;
+  inline typed::set<Domain, Anonymous> as_set() const = delete;
+  inline typed::union_map<Domain, Anonymous> as_union_map() const;
+  inline typed::aff<Domain, Anonymous> at(int pos) const;
+  inline typed::basic_set<Domain> bind(const typed::id<Anonymous> &id) const;
+  inline typed::basic_set<Domain> bind(const std::string &id) const;
+  inline typed::basic_set<Domain> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::pw_aff<Domain, Anonymous> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Domain, Anonymous> coalesce() const;
+  inline typed::multi_val<Anonymous> constant_multi_val() const;
+  inline typed::val<Domain, Anonymous> get_constant_val() const = delete;
+  inline typed::set<Domain> domain() const;
+  inline typed::aff<Domain, Anonymous> floor() const;
+  inline typed::set<Domain> ge_set(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::set<Domain> ge_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::aff<Domain, Anonymous> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::union_set<Domain> &context) const;
+  inline typed::aff<Domain, Anonymous> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::aff<Domain, Anonymous> gist(const typed::point<Domain> &context) const;
+  inline typed::set<Domain> gt_set(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::set<Domain> gt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_aff<Domain, Anonymous> identity() const;
+  inline typed::pw_aff<Domain, Anonymous> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_aff<Domain, Anonymous> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::set<Domain> le_set(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::set<Domain> le_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::aff_list<Domain, Anonymous> list() const;
+  inline typed::set<Domain> lt_set(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::set<Domain> lt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> max(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> max(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Anonymous> min(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> min(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::aff<Domain, Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::aff<Domain, Anonymous> mod(long mod) const;
+  inline typed::aff<Domain, Anonymous> neg() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> product(const typed::multi_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2>
+  inline typed::aff<Domain2, Anonymous> pullback(const typed::multi_aff<Domain2, Domain> &ma) const;
+  inline typed::aff<Anonymous> pullback(const typed::multi_aff<Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::pw_aff<Domain2, Anonymous> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::pw_aff<Domain2, Anonymous> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::aff<Domain2, Anonymous> pullback(const typed::aff<Domain2, Domain> &ma) const;
+  inline typed::aff<Anonymous> pullback(const typed::aff<Domain> &ma) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, Anonymous> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  inline typed::aff<Domain, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Domain, Anonymous> scale(long v) const;
+  inline typed::multi_aff<Domain, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::aff<Domain, Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::aff<Domain, Anonymous> scale_down(long v) const;
+  inline typed::multi_aff<Domain, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_aff<Domain, Anonymous> set_at(int pos, const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Anonymous> space() const;
+  inline typed::aff<Domain, Anonymous> sub(const typed::aff<Domain, Anonymous> &aff2) const;
+  inline typed::multi_aff<Domain, Anonymous> sub(const typed::multi_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> sub(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> sub(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> sub(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::pw_aff<Domain, Anonymous> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> to_pw_multi_aff() const;
+  inline typed::union_pw_aff<Domain, Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> to_union_pw_multi_aff() const;
+  inline typed::aff<Domain, Anonymous> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Anonymous> union_add(const typed::multi_pw_aff<Domain, Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const;
+  inline typed::pw_aff<Domain, Anonymous> union_add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> union_add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+};
+
+template <typename Domain2, typename Range2>
+struct aff<pair<Domain2, Range2>, Anonymous> : public isl::aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain2, Arg1>{} &&
+              std::is_base_of<Range2, Arg2>{},
+            bool>::type = true>
+  aff(const aff<pair<Arg1, Arg2>, Anonymous> &obj) : isl::aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::aff>{}, bool>::type = true>
+  aff(const base &obj) : isl::aff(obj) {}
+ public:
+  static aff from(const isl::aff &obj) {
+    return aff(obj);
+  }
+  inline explicit aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> add(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> add(const typed::multi_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> add_constant(long v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Arg1>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> apply(const typed::union_pw_multi_aff<Anonymous, Arg1> &upma2) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> as_aff() const;
+  inline typed::map<pair<Domain2, Range2>, Anonymous> as_map() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain2, Range2>, Anonymous> as_set() const = delete;
+  inline typed::union_map<pair<Domain2, Range2>, Anonymous> as_union_map() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> at(int pos) const;
+  inline typed::basic_set<pair<Domain2, Range2>> bind(const typed::id<Anonymous> &id) const;
+  inline typed::basic_set<pair<Domain2, Range2>> bind(const std::string &id) const;
+  inline typed::basic_set<pair<Domain2, Range2>> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const;
+  inline typed::pw_aff<Range2, Anonymous> bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> coalesce() const;
+  inline typed::multi_val<Anonymous> constant_multi_val() const;
+  inline typed::val<pair<Domain2, Range2>, Anonymous> get_constant_val() const = delete;
+  inline typed::set<pair<Domain2, Range2>> domain() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> floor() const;
+  inline typed::set<pair<Domain2, Range2>> ge_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::set<pair<Domain2, Range2>> ge_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> gist(const typed::set<pair<Domain2, Range2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> gist(const typed::union_set<pair<Domain2, Range2>> &context) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> gist(const typed::basic_set<pair<Domain2, Range2>> &context) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> gist(const typed::point<pair<Domain2, Range2>> &context) const;
+  inline typed::set<pair<Domain2, Range2>> gt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::set<pair<Domain2, Range2>> gt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> identity() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::set<pair<Domain2, Range2>> le_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::set<pair<Domain2, Range2>> le_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::aff_list<pair<Domain2, Range2>, Anonymous> list() const;
+  inline typed::set<pair<Domain2, Range2>> lt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::set<pair<Domain2, Range2>> lt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> max(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> max(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> min(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> min(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> mod(long mod) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const;
+  template <typename Arg1, typename Arg2>
+  inline typed::multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> product(const typed::multi_aff<Arg1, Arg2> &multi2) const;
+  template <typename Arg1, typename Arg2>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> product(const typed::multi_pw_aff<Arg1, Arg2> &multi2) const;
+  template <typename Arg1, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> product(const typed::pw_multi_aff<Arg1, Arg2> &pma2) const;
+  template <typename Arg1>
+  inline typed::aff<Arg1, Anonymous> pullback(const typed::multi_aff<Arg1, pair<Domain2, Range2>> &ma) const;
+  inline typed::aff<Anonymous> pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const;
+  template <typename Arg1>
+  inline typed::pw_aff<Arg1, Anonymous> pullback(const typed::multi_pw_aff<Arg1, pair<Domain2, Range2>> &mpa) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa) const;
+  template <typename Arg1>
+  inline typed::pw_aff<Arg1, Anonymous> pullback(const typed::pw_multi_aff<Arg1, pair<Domain2, Range2>> &pma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const;
+  template <typename Arg1>
+  inline typed::union_pw_aff<Arg1, Anonymous> pullback(const typed::union_pw_multi_aff<Arg1, pair<Domain2, Range2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const;
+  template <typename Arg1>
+  inline typed::aff<Arg1, Anonymous> pullback(const typed::aff<Arg1, pair<Domain2, Range2>> &ma) const;
+  inline typed::aff<Anonymous> pullback(const typed::aff<pair<Domain2, Range2>> &ma) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> range_factor_range() const = delete;
+  template <typename Arg1>
+  inline typed::multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg1> &multi2) const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const;
+  template <typename Arg1>
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> &pma2) const;
+  template <typename Arg1>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> &upma2) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> scale(long v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> scale_down(long v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> set_at(int pos, const typed::aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  template <typename Arg1>
+  inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg1>
+  inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain2, Range2>, Anonymous> space() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> sub(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::multi_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> to_pw_multi_aff() const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> to_union_pw_multi_aff() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &mupa2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+};
+
+template <>
+struct aff_list<Anonymous> : public isl::aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  aff_list() = default;
+  aff_list(const isl::aff_list &obj) : isl::aff_list(obj) {}
+  static aff_list from(const isl::aff_list &obj) {
+    return aff_list(obj);
+  }
+  inline explicit aff_list(const isl::ctx &ctx, int n);
+  inline explicit aff_list(const typed::aff<Anonymous> &el);
+  inline typed::aff_list<Anonymous> add(const typed::aff<Anonymous> &el) const;
+  inline typed::aff<Anonymous> at(int index) const;
+  inline typed::aff<Anonymous> get_at(int index) const = delete;
+  inline typed::aff_list<Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::aff<Anonymous>)> &fn) const;
+};
+
+template <typename Domain>
+struct aff_list<Domain, Anonymous> : public isl::aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  aff_list() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  aff_list(const aff_list<Arg1, Anonymous> &obj) : isl::aff_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::aff_list>{}, bool>::type = true>
+  aff_list(const base &obj) : isl::aff_list(obj) {}
+ public:
+  static aff_list from(const isl::aff_list &obj) {
+    return aff_list(obj);
+  }
+  inline explicit aff_list(const isl::ctx &ctx, int n);
+  inline explicit aff_list(const typed::aff<Domain, Anonymous> &el);
+  inline typed::aff_list<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::aff<Domain, Anonymous> at(int index) const;
+  inline typed::aff<Domain, Anonymous> get_at(int index) const = delete;
+  inline typed::aff_list<Domain, Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::aff<Domain, Anonymous>)> &fn) const;
+};
+
+template <typename Domain, typename Range>
+struct basic_map<Domain, Range> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  basic_map(const basic_map<Arg1, Arg2> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, Range> apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::basic_map<Domain, Range2> apply_range(const typed::basic_map<Range, Range2> &bmap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::map<Range, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Range, Range2> &umap2) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Range> as_union_pw_multi_aff() const;
+  inline typed::set<Range> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<Range> &tuple) const;
+  inline typed::map<Domain, Range> coalesce() const;
+  inline typed::map<Domain, Range> curry() const = delete;
+  inline typed::basic_set<Domain, Range> deltas() const = delete;
+  inline typed::basic_map<Domain, Range> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, Range> domain_factor_domain() const = delete;
+  inline typed::map<Domain, Range> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Range> domain_product(const typed::map<Domain2, Range> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Range> domain_product(const typed::union_map<Domain2, Range> &umap2) const;
+  inline typed::map<Domain, Range> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<Domain, Range> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const;
+  inline typed::basic_map<Domain, Range> flatten_domain() const = delete;
+  inline typed::basic_map<Domain, Range> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const;
+  inline typed::basic_map<Domain, Range> gist(const typed::basic_map<Domain, Range> &context) const;
+  inline typed::map<Domain, Range> gist(const typed::map<Domain, Range> &context) const;
+  inline typed::union_map<Domain, Range> gist(const typed::union_map<Domain, Range> &context) const;
+  inline typed::map<Domain, Range> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, Range> intersect(const typed::basic_map<Domain, Range> &bmap2) const;
+  inline typed::map<Domain, Range> intersect(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> intersect(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::basic_map<Domain, Range> intersect_domain(const typed::basic_set<Domain> &bset) const;
+  inline typed::map<Domain, Range> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, Range> intersect_domain(const typed::point<Domain> &bset) const;
+  inline typed::map<Domain, Range> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<Domain, Range> intersect_range(const typed::basic_set<Range> &bset) const;
+  inline typed::map<Domain, Range> intersect_range(const typed::set<Range> &set) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::space<Range> &space) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::union_set<Range> &uset) const;
+  inline typed::basic_map<Domain, Range> intersect_range(const typed::point<Range> &bset) const;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lexmax() const;
+  inline typed::pw_multi_aff<Domain, Range> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, Range> lexmin() const;
+  inline typed::pw_multi_aff<Domain, Range> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, Range> lower_bound(const typed::multi_pw_aff<Domain, Range> &lower) const;
+  inline typed::multi_pw_aff<Domain, Range> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, Range> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Range> &ma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  inline typed::map<Domain, Range> project_out_all_params() const;
+  inline typed::set<Range> range() const;
+  inline typed::map<Domain, Range> range_factor_domain() const = delete;
+  inline typed::map<Domain, Range> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range> range_map() const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Range, Range2>> range_product(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Range, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  inline typed::map<Domain, Range> range_reverse() const = delete;
+  inline typed::fixed_box<Domain, Range> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<Range, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> set_domain_tuple(const std::string &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::map<Domain, Range> subtract(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> subtract(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::union_set<Range> &dom) const;
+  inline typed::union_map<Domain, Range> to_union_map() const;
+  inline typed::map<Domain, Range> uncurry() const = delete;
+  inline typed::map<Domain, Range> unite(const typed::basic_map<Domain, Range> &bmap2) const;
+  inline typed::map<Domain, Range> unite(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> unite(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::map<Domain, Range> upper_bound(const typed::multi_pw_aff<Domain, Range> &upper) const;
+  inline typed::set<pair<Domain, Range>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct basic_map<pair<Domain, Range>, Range2> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  basic_map(const basic_map<pair<Arg1, Arg2>, Arg3> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, Range2> apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> apply_domain(const typed::map<pair<Domain, Range>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const;
+  template <typename Arg3>
+  inline typed::basic_map<pair<Domain, Range>, Arg3> apply_range(const typed::basic_map<Range2, Arg3> &bmap2) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> apply_range(const typed::map<Range2, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> apply_range(const typed::union_map<Range2, Arg3> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> as_map() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>, Range2> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Range2> as_union_pw_multi_aff() const;
+  inline typed::set<Range2> bind_domain(const typed::multi_id<pair<Domain, Range>> &tuple) const;
+  inline typed::set<pair<Domain, Range>> bind_range(const typed::multi_id<Range2> &tuple) const;
+  inline typed::map<pair<Domain, Range>, Range2> coalesce() const;
+  inline typed::map<Domain, pair<Range, Range2>> curry() const;
+  inline typed::basic_set<pair<Domain, Range>, Range2> deltas() const = delete;
+  inline typed::basic_map<pair<Domain, Range>, Range2> detect_equalities() const;
+  inline typed::set<pair<Domain, Range>> domain() const;
+  inline typed::map<Domain, Range2> domain_factor_domain() const;
+  inline typed::map<Range, Range2> domain_factor_range() const;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::union_map<Domain2, Range2> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const;
+  inline typed::basic_map<Anonymous, Range2> flatten_domain() const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist(const typed::map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist_domain(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> intersect(const typed::basic_map<pair<Domain, Range>, Range2> &bmap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> intersect_domain(const typed::basic_set<pair<Domain, Range>> &bset) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_domain(const typed::set<pair<Domain, Range>> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::space<pair<Domain, Range>> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> intersect_domain(const typed::point<pair<Domain, Range>> &bset) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> intersect_range(const typed::basic_set<Range2> &bset) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_range(const typed::set<Range2> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::space<Range2> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::union_set<Range2> &uset) const;
+  inline typed::basic_map<pair<Domain, Range>, Range2> intersect_range(const typed::point<Range2> &bset) const;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lexmax() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<Domain, Range>, Range2> lexmin() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::map<Domain2, Arg3> &map2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> project_out_all_params() const;
+  inline typed::set<Range2> range() const;
+  inline typed::map<pair<Domain, Range>, Range2> range_factor_domain() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> range_factor_range() const = delete;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> range_map() const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::map<pair<Domain, Range>, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> range_reverse() const = delete;
+  inline typed::fixed_box<pair<Domain, Range>, Range2> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<Range2, pair<Domain, Range>> reverse() const;
+  inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const std::string &id) const = delete;
+  template <typename Arg2>
+  inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg2>
+  inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain, Range>, Range2> space() const;
+  inline typed::map<pair<Domain, Range>, Range2> subtract(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::union_set<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> to_union_map() const;
+  inline typed::map<pair<Domain, Range>, Range2> uncurry() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> unite(const typed::basic_map<pair<Domain, Range>, Range2> &bmap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> unite(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::set<pair<pair<Domain, Range>, Range2>> wrap() const;
+};
+
+template <typename Domain>
+struct basic_map<Domain, Domain> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  basic_map(const basic_map<Arg1, Arg1> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, Domain> apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::basic_map<Domain, Range2> apply_range(const typed::basic_map<Domain, Range2> &bmap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Domain, Range2> &umap2) const;
+  inline typed::map<Domain, Domain> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Domain> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Domain> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Domain> as_union_pw_multi_aff() const;
+  inline typed::set<Domain> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<Domain> &tuple) const;
+  inline typed::map<Domain, Domain> coalesce() const;
+  inline typed::map<Domain, Domain> curry() const = delete;
+  inline typed::basic_set<Domain> deltas() const;
+  inline typed::basic_map<Domain, Domain> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, Domain> domain_factor_domain() const = delete;
+  inline typed::map<Domain, Domain> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Domain> domain_product(const typed::map<Domain2, Domain> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Domain> domain_product(const typed::union_map<Domain2, Domain> &umap2) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::union_map<Domain, Domain> eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const;
+  inline typed::basic_map<Domain, Domain> flatten_domain() const = delete;
+  inline typed::basic_map<Domain, Domain> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const;
+  inline typed::basic_map<Domain, Domain> gist(const typed::basic_map<Domain, Domain> &context) const;
+  inline typed::map<Domain, Domain> gist(const typed::map<Domain, Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist(const typed::union_map<Domain, Domain> &context) const;
+  inline typed::map<Domain, Domain> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, Domain> intersect(const typed::basic_map<Domain, Domain> &bmap2) const;
+  inline typed::map<Domain, Domain> intersect(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> intersect(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::basic_map<Domain, Domain> intersect_domain(const typed::basic_set<Domain> &bset) const;
+  inline typed::map<Domain, Domain> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, Domain> intersect_domain(const typed::point<Domain> &bset) const;
+  inline typed::map<Domain, Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<Domain, Domain> intersect_range(const typed::basic_set<Domain> &bset) const;
+  inline typed::map<Domain, Domain> intersect_range(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, Domain> intersect_range(const typed::point<Domain> &bset) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  inline typed::map<Domain, Domain> lexmax() const;
+  inline typed::pw_multi_aff<Domain, Domain> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, Domain> lexmin() const;
+  inline typed::pw_multi_aff<Domain, Domain> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::multi_pw_aff<Domain, Domain> &lower) const;
+  inline typed::multi_pw_aff<Domain, Domain> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, Domain> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Domain> &ma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  inline typed::map<Domain, Domain> project_out_all_params() const;
+  inline typed::set<Domain> range() const;
+  inline typed::map<Domain, Domain> range_factor_domain() const = delete;
+  inline typed::map<Domain, Domain> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> range_map() const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Domain, Range2>> range_product(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Domain, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  inline typed::map<Domain, Domain> range_reverse() const = delete;
+  inline typed::fixed_box<Domain, Domain> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<Domain, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> set_domain_tuple(const std::string &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Domain> space() const;
+  inline typed::map<Domain, Domain> subtract(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> subtract(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> to_union_map() const;
+  inline typed::map<Domain, Domain> uncurry() const = delete;
+  inline typed::map<Domain, Domain> unite(const typed::basic_map<Domain, Domain> &bmap2) const;
+  inline typed::map<Domain, Domain> unite(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> unite(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::map<Domain, Domain> upper_bound(const typed::multi_pw_aff<Domain, Domain> &upper) const;
+  inline typed::set<pair<Domain, Domain>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct basic_map<Domain, pair<Range, Range2>> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  basic_map(const basic_map<Arg1, pair<Arg2, Arg3>> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Arg3>
+  inline typed::basic_map<Domain, Arg3> apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &bmap2) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> apply_range(const typed::map<pair<Range, Range2>, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<Range, Range2>> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::map<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::map<Domain, pair<Range, Range2>> curry() const = delete;
+  inline typed::basic_set<Domain, pair<Range, Range2>> deltas() const = delete;
+  inline typed::basic_map<Domain, pair<Range, Range2>> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, pair<Range, Range2>> domain_factor_domain() const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> flatten_domain() const = delete;
+  inline typed::basic_map<Domain, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist(const typed::map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> intersect(const typed::basic_map<Domain, pair<Range, Range2>> &bmap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> intersect_domain(const typed::basic_set<Domain> &bset) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> intersect_domain(const typed::point<Domain> &bset) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> intersect_range(const typed::basic_set<pair<Range, Range2>> &bset) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_range(const typed::set<pair<Range, Range2>> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::basic_map<Domain, pair<Range, Range2>> intersect_range(const typed::point<pair<Range, Range2>> &bset) const;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lexmax() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, pair<Range, Range2>> lexmin() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::map<Domain2, Arg3> &map2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::set<pair<Range, Range2>> range() const;
+  inline typed::map<Domain, Range> range_factor_domain() const;
+  inline typed::map<Domain, Range2> range_factor_range() const;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg3>
+  inline typed::map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::map<Domain, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_map<Domain, Arg3> &umap2) const;
+  inline typed::map<Domain, pair<Range2, Range>> range_reverse() const;
+  inline typed::fixed_box<Domain, pair<Range, Range2>> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<pair<Range, Range2>, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const std::string &id) const;
+  inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> space() const;
+  inline typed::map<Domain, pair<Range, Range2>> subtract(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> to_union_map() const;
+  inline typed::map<pair<Domain, Range>, Range2> uncurry() const;
+  inline typed::map<Domain, pair<Range, Range2>> unite(const typed::basic_map<Domain, pair<Range, Range2>> &bmap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> unite(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::set<pair<Domain, pair<Range, Range2>>> wrap() const;
+};
+
+template <typename T1, typename T2>
+struct basic_map<pair<T1, T2>, pair<T1, T2>> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{},
+            bool>::type = true>
+  basic_map(const basic_map<pair<Arg1, Arg2>, pair<Arg1, Arg2>> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, pair<T1, T2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::basic_map<pair<T1, T2>, Range2> apply_range(const typed::basic_map<pair<T1, T2>, Range2> &bmap2) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> apply_range(const typed::map<pair<T1, T2>, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<T1, T2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::set<pair<T1, T2>> bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> coalesce() const;
+  inline typed::map<T1, pair<T2, pair<T1, T2>>> curry() const;
+  inline typed::basic_set<pair<T1, T2>> deltas() const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> detect_equalities() const;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::map<T1, pair<T1, T2>> domain_factor_domain() const;
+  inline typed::map<T2, pair<T1, T2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::map<Domain2, pair<T1, T2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const;
+  inline typed::basic_map<Anonymous, pair<T1, T2>> flatten_domain() const;
+  inline typed::basic_map<pair<T1, T2>, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::basic_set<pair<T1, T2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::point<pair<T1, T2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::basic_set<pair<T1, T2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::point<pair<T1, T2>> &bset) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lexmax() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lexmin() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> project_out_all_params() const;
+  inline typed::set<pair<T1, T2>> range() const;
+  inline typed::map<pair<T1, T2>, T1> range_factor_domain() const;
+  inline typed::map<pair<T1, T2>, T2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> range_map() const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::map<pair<T1, T2>, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T2, T1>> range_reverse() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<T1, T2>> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<pair<T1, T2>, pair<T1, T2>> reverse() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<T1, T2>> space() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> to_union_map() const;
+  inline typed::map<pair<pair<T1, T2>, T1>, T2> uncurry() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::set<pair<pair<T1, T2>, pair<T1, T2>>> wrap() const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct basic_map<pair<T1, T2>, pair<Range, Range2>> : public isl::basic_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  basic_map(const basic_map<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::basic_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_map>{}, bool>::type = true>
+  basic_map(const base &obj) : isl::basic_map(obj) {}
+ public:
+  static basic_map from(const isl::basic_map &obj) {
+    return basic_map(obj);
+  }
+  inline explicit basic_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::basic_map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &bmap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Arg2>
+  inline typed::basic_map<pair<T1, T2>, Arg2> apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &bmap2) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> apply_range(const typed::map<pair<Range, Range2>, Arg2> &map2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<Range, Range2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::set<pair<T1, T2>> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::map<T1, pair<T2, pair<Range, Range2>>> curry() const;
+  inline typed::basic_set<pair<T1, T2>, pair<Range, Range2>> deltas() const = delete;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> detect_equalities() const;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::map<T1, pair<Range, Range2>> domain_factor_domain() const;
+  inline typed::map<T2, pair<Range, Range2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const;
+  inline typed::basic_map<Anonymous, pair<Range, Range2>> flatten_domain() const;
+  inline typed::basic_map<pair<T1, T2>, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::basic_set<pair<T1, T2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::point<pair<T1, T2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::basic_set<pair<Range, Range2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::set<pair<Range, Range2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::basic_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::point<pair<Range, Range2>> &bset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lexmax() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lexmin() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::map<Domain2, Arg2> &map2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::union_map<Domain2, Arg2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::set<pair<Range, Range2>> range() const;
+  inline typed::map<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::map<pair<T1, T2>, Range2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::map<pair<T1, T2>, Arg2> &map2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range2, Range>> range_reverse() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<Range, Range2>> range_simple_fixed_box_hull() const;
+  inline typed::basic_map<pair<Range, Range2>, pair<T1, T2>> reverse() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> space() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> to_union_map() const;
+  inline typed::map<pair<pair<T1, T2>, Range>, Range2> uncurry() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::set<pair<pair<T1, T2>, pair<Range, Range2>>> wrap() const;
+};
+
+template <>
+struct basic_set<> : public isl::basic_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_set() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_set>{}, bool>::type = true>
+  basic_set(const base &obj) : isl::basic_set(obj) {}
+ public:
+  static basic_set from(const isl::basic_set &obj) {
+    return basic_set(obj);
+  }
+  inline /* implicit */ basic_set(const typed::point<> &pnt);
+  inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
+  inline typed::basic_set<> apply(const typed::basic_map<> &bmap) const = delete;
+  inline typed::set<> apply(const typed::map<> &map) const = delete;
+  inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
+  inline typed::pw_multi_aff<> as_pw_multi_aff() const = delete;
+  inline typed::set<> as_set() const = delete;
+  inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
+  inline typed::set<> coalesce() const;
+  inline typed::basic_set<> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
+  inline typed::basic_set<> gist(const typed::basic_set<> &context) const;
+  inline typed::set<> gist(const typed::set<> &context) const;
+  inline typed::union_set<> gist(const typed::union_set<> &context) const;
+  inline typed::basic_set<> gist(const typed::point<> &context) const;
+  inline typed::map<> identity() const = delete;
+  inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::basic_set<> intersect(const typed::basic_set<> &bset2) const;
+  inline typed::set<> intersect(const typed::set<> &set2) const;
+  inline typed::union_set<> intersect(const typed::union_set<> &uset2) const;
+  inline typed::basic_set<> intersect(const typed::point<> &bset2) const;
+  inline typed::basic_set<> intersect_params(const typed::basic_set<> &bset2) const = delete;
+  inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
+  inline typed::basic_set<> intersect_params(const typed::point<> &bset2) const = delete;
+  inline typed::set<> lexmax() const = delete;
+  inline typed::pw_multi_aff<> lexmax_pw_multi_aff() const = delete;
+  inline typed::set<> lexmin() const = delete;
+  inline typed::pw_multi_aff<> lexmin_pw_multi_aff() const = delete;
+  inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
+  inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
+  inline typed::multi_pw_aff<> max_multi_pw_aff() const = delete;
+  inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<> min_multi_pw_aff() const = delete;
+  inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::basic_set<> params() const = delete;
+  inline typed::multi_val<> plain_multi_val_if_fixed() const = delete;
+  inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
+  inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::set<> product(const typed::set<> &set2) const = delete;
+  inline typed::set<> project_out_all_params() const;
+  inline typed::set<> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<> project_out_param(const std::string &id) const;
+  inline typed::set<> project_out_param(const typed::id_list<Anonymous> &list) const;
+  inline typed::pw_multi_aff<> pw_multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::fixed_box<> simple_fixed_box_hull() const = delete;
+  inline typed::space<> space() const;
+  inline typed::set<> subtract(const typed::set<> &set2) const;
+  inline typed::union_set<> subtract(const typed::union_set<> &uset2) const;
+  inline typed::set<> to_set() const;
+  inline typed::union_set<> to_union_set() const;
+  inline typed::map<> translation() const = delete;
+  template <typename Domain>
+  inline typed::set<Domain> unbind_params(const typed::multi_id<Domain> &tuple) const;
+  inline typed::map<> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::set<> unite(const typed::basic_set<> &bset2) const;
+  inline typed::set<> unite(const typed::set<> &set2) const;
+  inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
+  inline typed::set<> unite(const typed::point<> &bset2) const;
+  inline typed::map<> unwrap() const = delete;
+  inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
+  inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
+};
+
+template <typename Domain>
+struct basic_set<Domain> : public isl::basic_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_set() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  basic_set(const basic_set<Arg1> &obj) : isl::basic_set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_set>{}, bool>::type = true>
+  basic_set(const base &obj) : isl::basic_set(obj) {}
+ public:
+  static basic_set from(const isl::basic_set &obj) {
+    return basic_set(obj);
+  }
+  inline /* implicit */ basic_set(const typed::point<Domain> &pnt);
+  inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
+  template <typename Range>
+  inline typed::basic_set<Range> apply(const typed::basic_map<Domain, Range> &bmap) const;
+  template <typename Range>
+  inline typed::set<Range> apply(const typed::map<Domain, Range> &map) const;
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::union_map<Domain, Range> &umap) const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> coalesce() const;
+  inline typed::basic_set<Domain> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
+  inline typed::basic_set<Domain> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::set<Domain> gist(const typed::set<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::union_set<Domain> &context) const;
+  inline typed::basic_set<Domain> gist(const typed::point<Domain> &context) const;
+  inline typed::map<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::basic_set<Domain> intersect(const typed::basic_set<Domain> &bset2) const;
+  inline typed::set<Domain> intersect(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> intersect(const typed::union_set<Domain> &uset2) const;
+  inline typed::basic_set<Domain> intersect(const typed::point<Domain> &bset2) const;
+  inline typed::basic_set<Domain> intersect_params(const typed::basic_set<> &bset2) const;
+  inline typed::set<Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_set<Domain> intersect_params(const typed::point<> &bset2) const;
+  inline typed::set<Domain> lexmax() const;
+  inline typed::pw_multi_aff<Domain> lexmax_pw_multi_aff() const;
+  inline typed::set<Domain> lexmin() const;
+  inline typed::pw_multi_aff<Domain> lexmin_pw_multi_aff() const;
+  inline typed::set<Domain> lower_bound(const typed::multi_pw_aff<Domain> &lower) const;
+  inline typed::set<Domain> lower_bound(const typed::multi_val<Domain> &lower) const;
+  inline typed::multi_pw_aff<Domain> max_multi_pw_aff() const;
+  inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<Domain> min_multi_pw_aff() const;
+  inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::basic_set<> params() const;
+  inline typed::multi_val<Domain> plain_multi_val_if_fixed() const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range>
+  inline typed::set<pair<Domain, Range>> product(const typed::set<Range> &set2) const;
+  inline typed::set<Domain> project_out_all_params() const;
+  inline typed::set<Domain> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<Domain> project_out_param(const std::string &id) const;
+  inline typed::set<Domain> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<Domain, Range> pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const;
+  inline typed::fixed_box<Domain> simple_fixed_box_hull() const;
+  inline typed::space<Domain> space() const;
+  inline typed::set<Domain> subtract(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> subtract(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> to_set() const;
+  inline typed::union_set<Domain> to_union_set() const;
+  inline typed::map<Domain, Domain> translation() const;
+  inline typed::set<Domain> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::set<Domain> unite(const typed::basic_set<Domain> &bset2) const;
+  inline typed::set<Domain> unite(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> unite(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> unite(const typed::point<Domain> &bset2) const;
+  inline typed::map<Domain> unwrap() const = delete;
+  inline typed::set<Domain> upper_bound(const typed::multi_pw_aff<Domain> &upper) const;
+  inline typed::set<Domain> upper_bound(const typed::multi_val<Domain> &upper) const;
+};
+
+template <typename Domain, typename Range>
+struct basic_set<pair<Domain, Range>> : public isl::basic_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  basic_set() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  basic_set(const basic_set<pair<Arg1, Arg2>> &obj) : isl::basic_set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::basic_set>{}, bool>::type = true>
+  basic_set(const base &obj) : isl::basic_set(obj) {}
+ public:
+  static basic_set from(const isl::basic_set &obj) {
+    return basic_set(obj);
+  }
+  inline /* implicit */ basic_set(const typed::point<pair<Domain, Range>> &pnt);
+  inline explicit basic_set(const isl::ctx &ctx, const std::string &str);
+  template <typename Arg2>
+  inline typed::basic_set<Arg2> apply(const typed::basic_map<pair<Domain, Range>, Arg2> &bmap) const;
+  template <typename Arg2>
+  inline typed::set<Arg2> apply(const typed::map<pair<Domain, Range>, Arg2> &map) const;
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<pair<Domain, Range>> &tuple) const;
+  inline typed::set<pair<Domain, Range>> coalesce() const;
+  inline typed::basic_set<pair<Domain, Range>> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
+  inline typed::basic_set<pair<Domain, Range>> gist(const typed::basic_set<pair<Domain, Range>> &context) const;
+  inline typed::set<pair<Domain, Range>> gist(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::union_set<pair<Domain, Range>> &context) const;
+  inline typed::basic_set<pair<Domain, Range>> gist(const typed::point<pair<Domain, Range>> &context) const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> identity() const;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> insert_domain(const typed::space<Arg2> &domain) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect(const typed::basic_set<pair<Domain, Range>> &bset2) const;
+  inline typed::set<pair<Domain, Range>> intersect(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect(const typed::point<pair<Domain, Range>> &bset2) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect_params(const typed::basic_set<> &bset2) const;
+  inline typed::set<pair<Domain, Range>> intersect_params(const typed::set<> &params) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect_params(const typed::point<> &bset2) const;
+  inline typed::set<pair<Domain, Range>> lexmax() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmax_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lexmin() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmin_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>> max_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<pair<Domain, Range>> min_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::basic_set<> params() const;
+  inline typed::multi_val<pair<Domain, Range>> plain_multi_val_if_fixed() const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg2>
+  inline typed::set<pair<pair<Domain, Range>, Arg2>> product(const typed::set<Arg2> &set2) const;
+  inline typed::set<pair<Domain, Range>> project_out_all_params() const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const std::string &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain, Range>, Arg2> pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const;
+  inline typed::fixed_box<pair<Domain, Range>> simple_fixed_box_hull() const;
+  inline typed::space<pair<Domain, Range>> space() const;
+  inline typed::set<pair<Domain, Range>> subtract(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> to_set() const;
+  inline typed::union_set<pair<Domain, Range>> to_union_set() const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> translation() const;
+  inline typed::set<pair<Domain, Range>> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::basic_set<pair<Domain, Range>> &bset2) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::point<pair<Domain, Range>> &bset2) const;
+  inline typed::map<Domain, Range> unwrap() const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const;
+};
+
+template <typename Domain>
+struct fixed_box<Domain> : public isl::fixed_box {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  fixed_box() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  fixed_box(const fixed_box<Arg1> &obj) : isl::fixed_box(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::fixed_box>{}, bool>::type = true>
+  fixed_box(const base &obj) : isl::fixed_box(obj) {}
+ public:
+  static fixed_box from(const isl::fixed_box &obj) {
+    return fixed_box(obj);
+  }
+  inline typed::multi_aff<Domain> offset() const;
+  inline typed::multi_aff<Domain> get_offset() const = delete;
+  inline typed::multi_val<Domain> size() const;
+  inline typed::multi_val<Domain> get_size() const = delete;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+};
+
+template <typename Domain, typename Range>
+struct fixed_box<Domain, Range> : public isl::fixed_box {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  fixed_box() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  fixed_box(const fixed_box<Arg1, Arg2> &obj) : isl::fixed_box(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::fixed_box>{}, bool>::type = true>
+  fixed_box(const base &obj) : isl::fixed_box(obj) {}
+ public:
+  static fixed_box from(const isl::fixed_box &obj) {
+    return fixed_box(obj);
+  }
+  inline typed::multi_aff<Domain, Range> offset() const;
+  inline typed::multi_aff<Domain, Range> get_offset() const = delete;
+  inline typed::multi_val<Range> size() const;
+  inline typed::multi_val<Domain, Range> get_size() const = delete;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+};
+
+template <>
+struct id<Anonymous> : public isl::id {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  id() = default;
+  id(const isl::id &obj) : isl::id(obj) {}
+  static id from(const isl::id &obj) {
+    return id(obj);
+  }
+  inline explicit id(const isl::ctx &ctx, const std::string &str);
+  inline std::string get_name() const = delete;
+};
+
+template <>
+struct id_list<Anonymous> : public isl::id_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  id_list() = default;
+  id_list(const isl::id_list &obj) : isl::id_list(obj) {}
+  static id_list from(const isl::id_list &obj) {
+    return id_list(obj);
+  }
+  inline explicit id_list(const isl::ctx &ctx, int n);
+  inline explicit id_list(const typed::id<Anonymous> &el);
+  inline typed::id_list<Anonymous> add(const typed::id<Anonymous> &el) const;
+  inline typed::id_list<Anonymous> add(const std::string &el) const;
+  inline typed::id<Anonymous> at(int index) const;
+  inline typed::id<Anonymous> get_at(int index) const = delete;
+  inline typed::id_list<Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::id<Anonymous>)> &fn) const;
+};
+
+template <typename Domain, typename Range>
+struct map<Domain, Range> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  map(const map<Arg1, Arg2> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<Domain, Range> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> apply_domain(const typed::basic_map<Domain, Domain2> &map2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::map<Range, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Range, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::basic_map<Range, Range2> &map2) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Range> as_union_pw_multi_aff() const;
+  inline typed::set<Range> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<Range> &tuple) const;
+  inline typed::map<Domain, Range> coalesce() const;
+  inline typed::map<Domain, Range> curry() const = delete;
+  inline typed::set<Domain, Range> deltas() const = delete;
+  inline typed::map<Domain, Range> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, Range> domain_factor_domain() const = delete;
+  inline typed::map<Domain, Range> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Range> domain_product(const typed::map<Domain2, Range> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Range> domain_product(const typed::union_map<Domain2, Range> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Range> domain_product(const typed::basic_map<Domain2, Range> &map2) const;
+  inline typed::id<Domain, Range> get_domain_tuple_id() const = delete;
+  inline typed::map<Domain, Range> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<Domain, Range> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::map<Domain, Range> eq_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> eq_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> eq_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> eq_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const;
+  inline typed::map<Domain, Range> flatten_domain() const = delete;
+  inline typed::map<Domain, Range> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const;
+  inline typed::map<Domain, Range> gist(const typed::map<Domain, Range> &context) const;
+  inline typed::union_map<Domain, Range> gist(const typed::union_map<Domain, Range> &context) const;
+  inline typed::map<Domain, Range> gist(const typed::basic_map<Domain, Range> &context) const;
+  inline typed::map<Domain, Range> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, Range> gist_domain(const typed::basic_set<Domain> &context) const;
+  inline typed::map<Domain, Range> gist_domain(const typed::point<Domain> &context) const;
+  inline typed::map<Domain, Range> intersect(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> intersect(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::map<Domain, Range> intersect(const typed::basic_map<Domain, Range> &map2) const;
+  inline typed::map<Domain, Range> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, Range> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::map<Domain, Range> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::map<Domain, Range> intersect_params(const typed::set<> &params) const;
+  inline typed::map<Domain, Range> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<Domain, Range> intersect_params(const typed::point<> &params) const;
+  inline typed::map<Domain, Range> intersect_range(const typed::set<Range> &set) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::space<Range> &space) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::union_set<Range> &uset) const;
+  inline typed::map<Domain, Range> intersect_range(const typed::basic_set<Range> &set) const;
+  inline typed::map<Domain, Range> intersect_range(const typed::point<Range> &set) const;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_ge_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_gt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_le_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lex_lt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, Range> lexmax() const;
+  inline typed::pw_multi_aff<Domain, Range> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, Range> lexmin() const;
+  inline typed::pw_multi_aff<Domain, Range> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, Range> lower_bound(const typed::multi_pw_aff<Domain, Range> &lower) const;
+  inline typed::map<Domain, Range> lower_bound(const typed::aff<Domain, Range> &lower) const;
+  inline typed::map<Domain, Range> lower_bound(const typed::multi_aff<Domain, Range> &lower) const;
+  inline typed::map<Domain, Range> lower_bound(const typed::pw_aff<Domain, Range> &lower) const;
+  inline typed::map<Domain, Range> lower_bound(const typed::pw_multi_aff<Domain, Range> &lower) const;
+  inline typed::multi_pw_aff<Domain, Range> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, Range> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Range> &ma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::basic_map<Domain2, Range2> &map2) const;
+  inline typed::map<Domain, Range> project_out_all_params() const;
+  inline typed::set<Range> range() const;
+  inline typed::map<Domain, Range> range_factor_domain() const = delete;
+  inline typed::map<Domain, Range> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range> range_map() const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Range, Range2>> range_product(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Range, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Range, Range2>> range_product(const typed::basic_map<Domain, Range2> &map2) const;
+  inline typed::map<Domain, Range> range_reverse() const = delete;
+  inline typed::fixed_box<Domain, Range> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<Domain, Range> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::map<Range, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range> set_domain_tuple(const std::string &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::map<Domain, Range> subtract(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> subtract(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::map<Domain, Range> subtract(const typed::basic_map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::union_set<Range> &dom) const;
+  inline typed::union_map<Domain, Range> to_union_map() const;
+  inline typed::map<Domain, Range> uncurry() const = delete;
+  inline typed::map<Domain, Range> unite(const typed::map<Domain, Range> &map2) const;
+  inline typed::union_map<Domain, Range> unite(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::map<Domain, Range> unite(const typed::basic_map<Domain, Range> &map2) const;
+  static inline typed::map<Domain, Range> universe(const typed::space<Domain, Range> &space);
+  inline typed::map<Domain, Range> upper_bound(const typed::multi_pw_aff<Domain, Range> &upper) const;
+  inline typed::map<Domain, Range> upper_bound(const typed::aff<Domain, Range> &upper) const;
+  inline typed::map<Domain, Range> upper_bound(const typed::multi_aff<Domain, Range> &upper) const;
+  inline typed::map<Domain, Range> upper_bound(const typed::pw_aff<Domain, Range> &upper) const;
+  inline typed::map<Domain, Range> upper_bound(const typed::pw_multi_aff<Domain, Range> &upper) const;
+  inline typed::set<pair<Domain, Range>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct map<pair<Domain, Range>, Range2> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  map(const map<pair<Arg1, Arg2>, Arg3> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<pair<Domain, Range>, Range2> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> apply_domain(const typed::map<pair<Domain, Range>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &map2) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> apply_range(const typed::map<Range2, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> apply_range(const typed::union_map<Range2, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> apply_range(const typed::basic_map<Range2, Arg3> &map2) const;
+  inline typed::map<pair<Domain, Range>, Range2> as_map() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>, Range2> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Range2> as_union_pw_multi_aff() const;
+  inline typed::set<Range2> bind_domain(const typed::multi_id<pair<Domain, Range>> &tuple) const;
+  inline typed::set<pair<Domain, Range>> bind_range(const typed::multi_id<Range2> &tuple) const;
+  inline typed::map<pair<Domain, Range>, Range2> coalesce() const;
+  inline typed::map<Domain, pair<Range, Range2>> curry() const;
+  inline typed::set<pair<Domain, Range>, Range2> deltas() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> detect_equalities() const;
+  inline typed::set<pair<Domain, Range>> domain() const;
+  inline typed::map<Domain, Range2> domain_factor_domain() const;
+  inline typed::map<Range, Range2> domain_factor_range() const;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::basic_map<Domain2, Range2> &map2) const;
+  inline typed::id<pair<Domain, Range>, Range2> get_domain_tuple_id() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> eq_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const;
+  inline typed::map<Anonymous, Range2> flatten_domain() const;
+  inline typed::map<pair<Domain, Range>, Range2> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist(const typed::map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist_domain(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist_domain(const typed::basic_set<pair<Domain, Range>> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> gist_domain(const typed::point<pair<Domain, Range>> &context) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_domain(const typed::set<pair<Domain, Range>> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::space<pair<Domain, Range>> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_domain(const typed::basic_set<pair<Domain, Range>> &set) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_domain(const typed::point<pair<Domain, Range>> &set) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_params(const typed::set<> &params) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_params(const typed::point<> &params) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_range(const typed::set<Range2> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::space<Range2> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::union_set<Range2> &uset) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_range(const typed::basic_set<Range2> &set) const;
+  inline typed::map<pair<Domain, Range>, Range2> intersect_range(const typed::point<Range2> &set) const;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_ge_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_gt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_le_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lex_lt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> lexmax() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<Domain, Range>, Range2> lexmin() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::multi_aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::pw_aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::map<pair<Domain, Range>, Range2> lower_bound(const typed::pw_multi_aff<pair<Domain, Range>, Range2> &lower) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Range2> preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::map<Domain2, Arg3> &map2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::basic_map<Domain2, Arg3> &map2) const;
+  inline typed::map<pair<Domain, Range>, Range2> project_out_all_params() const;
+  inline typed::set<Range2> range() const;
+  inline typed::map<pair<Domain, Range>, Range2> range_factor_domain() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> range_factor_range() const = delete;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> range_map() const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::map<pair<Domain, Range>, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::basic_map<pair<Domain, Range>, Arg3> &map2) const;
+  inline typed::map<pair<Domain, Range>, Range2> range_reverse() const = delete;
+  inline typed::fixed_box<pair<Domain, Range>, Range2> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<pair<Domain, Range>, Range2> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<pair<Domain, Range>, Range2> get_range_tuple_id() const = delete;
+  inline typed::map<Range2, pair<Domain, Range>> reverse() const;
+  inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> set_domain_tuple(const std::string &id) const = delete;
+  template <typename Arg2>
+  inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg2>
+  inline typed::map<pair<Domain, Range>, Arg2> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain, Range>, Range2> space() const;
+  inline typed::space<pair<Domain, Range>, Range2> get_space() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> subtract(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> subtract(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::union_set<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> to_union_map() const;
+  inline typed::map<pair<Domain, Range>, Range2> uncurry() const = delete;
+  inline typed::map<pair<Domain, Range>, Range2> unite(const typed::map<pair<Domain, Range>, Range2> &map2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> unite(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const;
+  static inline typed::map<pair<Domain, Range>, Range2> universe(const typed::space<pair<Domain, Range>, Range2> &space);
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::multi_aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::pw_aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::map<pair<Domain, Range>, Range2> upper_bound(const typed::pw_multi_aff<pair<Domain, Range>, Range2> &upper) const;
+  inline typed::set<pair<pair<Domain, Range>, Range2>> wrap() const;
+};
+
+template <typename Domain>
+struct map<Domain, Domain> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  map(const map<Arg1, Arg1> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<Domain, Domain> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> apply_domain(const typed::basic_map<Domain, Domain2> &map2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> apply_range(const typed::basic_map<Domain, Range2> &map2) const;
+  inline typed::map<Domain, Domain> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Domain> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Domain> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Domain> as_union_pw_multi_aff() const;
+  inline typed::set<Domain> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<Domain> &tuple) const;
+  inline typed::map<Domain, Domain> coalesce() const;
+  inline typed::map<Domain, Domain> curry() const = delete;
+  inline typed::set<Domain> deltas() const;
+  inline typed::map<Domain, Domain> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, Domain> domain_factor_domain() const = delete;
+  inline typed::map<Domain, Domain> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Domain> domain_product(const typed::map<Domain2, Domain> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Domain> domain_product(const typed::union_map<Domain2, Domain> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, Domain> domain_product(const typed::basic_map<Domain2, Domain> &map2) const;
+  inline typed::id<Domain, Domain> get_domain_tuple_id() const = delete;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::union_map<Domain, Domain> eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> eq_at(const typed::pw_multi_aff<Domain, Range> &mpa) const;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const;
+  inline typed::map<Domain, Domain> flatten_domain() const = delete;
+  inline typed::map<Domain, Domain> flatten_range() const = delete;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const;
+  inline typed::map<Domain, Domain> gist(const typed::map<Domain, Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist(const typed::union_map<Domain, Domain> &context) const;
+  inline typed::map<Domain, Domain> gist(const typed::basic_map<Domain, Domain> &context) const;
+  inline typed::map<Domain, Domain> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, Domain> gist_domain(const typed::basic_set<Domain> &context) const;
+  inline typed::map<Domain, Domain> gist_domain(const typed::point<Domain> &context) const;
+  inline typed::map<Domain, Domain> intersect(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> intersect(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::map<Domain, Domain> intersect(const typed::basic_map<Domain, Domain> &map2) const;
+  inline typed::map<Domain, Domain> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, Domain> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::map<Domain, Domain> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::map<Domain, Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::map<Domain, Domain> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<Domain, Domain> intersect_params(const typed::point<> &params) const;
+  inline typed::map<Domain, Domain> intersect_range(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, Domain> intersect_range(const typed::basic_set<Domain> &set) const;
+  inline typed::map<Domain, Domain> intersect_range(const typed::point<Domain> &set) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_ge_at(const typed::pw_multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_gt_at(const typed::pw_multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_le_at(const typed::pw_multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::multi_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::pw_aff<Domain, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<Domain, Domain> lex_lt_at(const typed::pw_multi_aff<Domain, Range> &mpa) const;
+  inline typed::map<Domain, Domain> lexmax() const;
+  inline typed::pw_multi_aff<Domain, Domain> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, Domain> lexmin() const;
+  inline typed::pw_multi_aff<Domain, Domain> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::multi_pw_aff<Domain, Domain> &lower) const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::aff<Domain, Domain> &lower) const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::multi_aff<Domain, Domain> &lower) const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::pw_aff<Domain, Domain> &lower) const;
+  inline typed::map<Domain, Domain> lower_bound(const typed::pw_multi_aff<Domain, Domain> &lower) const;
+  inline typed::multi_pw_aff<Domain, Domain> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, Domain> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Domain> &ma) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::basic_map<Domain2, Range2> &map2) const;
+  inline typed::map<Domain, Domain> project_out_all_params() const;
+  inline typed::set<Domain> range() const;
+  inline typed::map<Domain, Domain> range_factor_domain() const = delete;
+  inline typed::map<Domain, Domain> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> range_map() const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Domain, Range2>> range_product(const typed::map<Domain, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Domain, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<Domain, pair<Domain, Range2>> range_product(const typed::basic_map<Domain, Range2> &map2) const;
+  inline typed::map<Domain, Domain> range_reverse() const = delete;
+  inline typed::fixed_box<Domain, Domain> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<Domain, Domain> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<Domain, Domain> get_range_tuple_id() const = delete;
+  inline typed::map<Domain, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, Domain> set_domain_tuple(const std::string &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::map<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Domain> space() const;
+  inline typed::space<Domain, Domain> get_space() const = delete;
+  inline typed::map<Domain, Domain> subtract(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> subtract(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::map<Domain, Domain> subtract(const typed::basic_map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> to_union_map() const;
+  inline typed::map<Domain, Domain> uncurry() const = delete;
+  inline typed::map<Domain, Domain> unite(const typed::map<Domain, Domain> &map2) const;
+  inline typed::union_map<Domain, Domain> unite(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::map<Domain, Domain> unite(const typed::basic_map<Domain, Domain> &map2) const;
+  static inline typed::map<Domain, Domain> universe(const typed::space<Domain, Domain> &space);
+  inline typed::map<Domain, Domain> upper_bound(const typed::multi_pw_aff<Domain, Domain> &upper) const;
+  inline typed::map<Domain, Domain> upper_bound(const typed::aff<Domain, Domain> &upper) const;
+  inline typed::map<Domain, Domain> upper_bound(const typed::multi_aff<Domain, Domain> &upper) const;
+  inline typed::map<Domain, Domain> upper_bound(const typed::pw_aff<Domain, Domain> &upper) const;
+  inline typed::map<Domain, Domain> upper_bound(const typed::pw_multi_aff<Domain, Domain> &upper) const;
+  inline typed::set<pair<Domain, Domain>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct map<Domain, pair<Range, Range2>> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  map(const map<Arg1, pair<Arg2, Arg3>> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<Domain, pair<Range, Range2>> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<Domain, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<Domain, Domain2> &map2) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> apply_range(const typed::map<pair<Range, Range2>, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &map2) const;
+  inline typed::map<Domain, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<Range, Range2>> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::map<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::map<Domain, pair<Range, Range2>> curry() const = delete;
+  inline typed::set<Domain, pair<Range, Range2>> deltas() const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> detect_equalities() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::map<Domain, pair<Range, Range2>> domain_factor_domain() const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &map2) const;
+  inline typed::id<Domain, pair<Range, Range2>> get_domain_tuple_id() const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> eq_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const;
+  inline typed::map<Domain, pair<Range, Range2>> flatten_domain() const = delete;
+  inline typed::map<Domain, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist(const typed::map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist_domain(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist_domain(const typed::basic_set<Domain> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> gist_domain(const typed::point<Domain> &context) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &params) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_params(const typed::point<> &params) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_range(const typed::set<pair<Range, Range2>> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_range(const typed::basic_set<pair<Range, Range2>> &set) const;
+  inline typed::map<Domain, pair<Range, Range2>> intersect_range(const typed::point<pair<Range, Range2>> &set) const;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_ge_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_gt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_le_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lex_lt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> lexmax() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> lexmax_pw_multi_aff() const;
+  inline typed::map<Domain, pair<Range, Range2>> lexmin() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> lexmin_pw_multi_aff() const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::multi_aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::pw_aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::map<Domain, pair<Range, Range2>> lower_bound(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &lower) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const;
+  template <typename Arg3>
+  inline typed::map<Domain, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::map<Domain2, Arg3> &map2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::basic_map<Domain2, Arg3> &map2) const;
+  inline typed::map<Domain, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::set<pair<Range, Range2>> range() const;
+  inline typed::map<Domain, Range> range_factor_domain() const;
+  inline typed::map<Domain, Range2> range_factor_range() const;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg3>
+  inline typed::map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::map<Domain, Arg3> &map2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_map<Domain, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::basic_map<Domain, Arg3> &map2) const;
+  inline typed::map<Domain, pair<Range2, Range>> range_reverse() const;
+  inline typed::fixed_box<Domain, pair<Range, Range2>> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<Domain, pair<Range, Range2>> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<Domain, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::map<pair<Range, Range2>, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> set_domain_tuple(const std::string &id) const;
+  inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> space() const;
+  inline typed::space<Domain, pair<Range, Range2>> get_space() const = delete;
+  inline typed::map<Domain, pair<Range, Range2>> subtract(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> subtract(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> to_union_map() const;
+  inline typed::map<pair<Domain, Range>, Range2> uncurry() const;
+  inline typed::map<Domain, pair<Range, Range2>> unite(const typed::map<Domain, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> unite(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const;
+  static inline typed::map<Domain, pair<Range, Range2>> universe(const typed::space<Domain, pair<Range, Range2>> &space);
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::multi_aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::pw_aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::map<Domain, pair<Range, Range2>> upper_bound(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upper) const;
+  inline typed::set<pair<Domain, pair<Range, Range2>>> wrap() const;
+};
+
+template <typename T1, typename T2>
+struct map<pair<T1, T2>, pair<T1, T2>> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{},
+            bool>::type = true>
+  map(const map<pair<Arg1, Arg2>, pair<Arg1, Arg2>> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> apply_range(const typed::map<pair<T1, T2>, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> apply_range(const typed::basic_map<pair<T1, T2>, Range2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<T1, T2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::set<pair<T1, T2>> bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> coalesce() const;
+  inline typed::map<T1, pair<T2, pair<T1, T2>>> curry() const;
+  inline typed::set<pair<T1, T2>> deltas() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> detect_equalities() const;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::map<T1, pair<T1, T2>> domain_factor_domain() const;
+  inline typed::map<T2, pair<T1, T2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::map<Domain2, pair<T1, T2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::basic_map<Domain2, pair<T1, T2>> &map2) const;
+  inline typed::id<pair<T1, T2>, pair<T1, T2>> get_domain_tuple_id() const = delete;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const;
+  inline typed::map<Anonymous, pair<T1, T2>> flatten_domain() const;
+  inline typed::map<pair<T1, T2>, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::basic_set<pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::point<pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::point<pair<T1, T2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::set<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::point<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::point<pair<T1, T2>> &set) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_ge_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_gt_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_le_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const;
+  template <typename Range>
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lex_lt_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lexmax() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lexmin() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::multi_aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> lower_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> &lower) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<T1, T2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, Range2> preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::map<Domain2, Range2> &map2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::basic_map<Domain2, Range2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> project_out_all_params() const;
+  inline typed::set<pair<T1, T2>> range() const;
+  inline typed::map<pair<T1, T2>, T1> range_factor_domain() const;
+  inline typed::map<pair<T1, T2>, T2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> range_map() const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::map<pair<T1, T2>, Range2> &map2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::basic_map<pair<T1, T2>, Range2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<T2, T1>> range_reverse() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<T1, T2>> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<T1, T2>> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<pair<T1, T2>, pair<T1, T2>> get_range_tuple_id() const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> reverse() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<T1, T2>> space() const;
+  inline typed::space<pair<T1, T2>, pair<T1, T2>> get_space() const = delete;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> to_union_map() const;
+  inline typed::map<pair<pair<T1, T2>, T1>, T2> uncurry() const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const;
+  static inline typed::map<pair<T1, T2>, pair<T1, T2>> universe(const typed::space<pair<T1, T2>, pair<T1, T2>> &space);
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::multi_aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> upper_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> &upper) const;
+  inline typed::set<pair<pair<T1, T2>, pair<T1, T2>>> wrap() const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct map<pair<T1, T2>, pair<Range, Range2>> : public isl::map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  map(const map<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::map>{}, bool>::type = true>
+  map(const base &obj) : isl::map(obj) {}
+ public:
+  static map from(const isl::map &obj) {
+    return map(obj);
+  }
+  inline /* implicit */ map(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap);
+  inline explicit map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &map2) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> apply_range(const typed::map<pair<Range, Range2>, Arg2> &map2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::set<pair<Range, Range2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::set<pair<T1, T2>> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::map<T1, pair<T2, pair<Range, Range2>>> curry() const;
+  inline typed::set<pair<T1, T2>, pair<Range, Range2>> deltas() const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> detect_equalities() const;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::map<T1, pair<Range, Range2>> domain_factor_domain() const;
+  inline typed::map<T2, pair<Range, Range2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &map2) const;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_domain_tuple_id() const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const;
+  inline typed::map<Anonymous, pair<Range, Range2>> flatten_domain() const;
+  inline typed::map<pair<T1, T2>, Anonymous> flatten_range() const;
+  inline void foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::basic_set<pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::point<pair<T1, T2>> &context) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::point<pair<T1, T2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::point<> &params) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::set<pair<Range, Range2>> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::basic_set<pair<Range, Range2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::point<pair<Range, Range2>> &set) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_ge_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_gt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_le_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::pw_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lex_lt_at(const typed::pw_multi_aff<> &mpa) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lexmax() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> lexmax_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lexmin() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> lexmin_pw_multi_aff() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> lower_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> max_multi_pw_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> min_multi_pw_aff() const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, Arg2> preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::map<Domain2, Arg2> &map2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::union_map<Domain2, Arg2> &umap2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::basic_map<Domain2, Arg2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::set<pair<Range, Range2>> range() const;
+  inline typed::map<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::map<pair<T1, T2>, Range2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::map<pair<T1, T2>, Arg2> &map2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::basic_map<pair<T1, T2>, Arg2> &map2) const;
+  inline typed::map<pair<T1, T2>, pair<Range2, Range>> range_reverse() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<Range, Range2>> range_simple_fixed_box_hull() const;
+  inline typed::fixed_box<pair<T1, T2>, pair<Range, Range2>> get_range_simple_fixed_box_hull() const = delete;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::map<pair<Range, Range2>, pair<T1, T2>> reverse() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> space() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> get_space() const = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> to_union_map() const;
+  inline typed::map<pair<pair<T1, T2>, Range>, Range2> uncurry() const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const;
+  static inline typed::map<pair<T1, T2>, pair<Range, Range2>> universe(const typed::space<pair<T1, T2>, pair<Range, Range2>> &space);
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> upper_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const;
+  inline typed::set<pair<pair<T1, T2>, pair<Range, Range2>>> wrap() const;
+};
+
+template <typename Domain>
+struct multi_aff<Domain> : public isl::multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  multi_aff(const multi_aff<Arg1> &obj) : isl::multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_aff>{}, bool>::type = true>
+  multi_aff(const base &obj) : isl::multi_aff(obj) {}
+ public:
+  static multi_aff from(const isl::multi_aff &obj) {
+    return multi_aff(obj);
+  }
+  inline /* implicit */ multi_aff(const typed::aff<Domain> &aff);
+  inline explicit multi_aff(const typed::space<Domain> &space, const typed::aff_list<Anonymous> &list);
+  inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_aff<Domain> add(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> add(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::pw_multi_aff<Domain> add(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::multi_aff<Domain> add(const typed::aff<Domain> &multi2) const;
+  inline typed::multi_aff<Domain> add_constant(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_aff<Domain> add_constant(const typed::val<Domain> &v) const;
+  inline typed::multi_aff<Domain> add_constant(long v) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::map<Domain> as_map() const = delete;
+  inline typed::multi_aff<Domain> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::union_map<Domain> as_union_map() const = delete;
+  inline typed::aff<Anonymous> at(int pos) const;
+  inline typed::aff<Domain> get_at(int pos) const = delete;
+  inline typed::basic_set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_aff<Domain> bind_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::multi_aff<Domain> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain> coalesce() const;
+  inline typed::multi_val<Domain> constant_multi_val() const;
+  inline typed::multi_val<Domain> get_constant_multi_val() const = delete;
+  inline typed::set<> domain() const;
+  inline typed::multi_aff<Domain> floor() const;
+  inline typed::multi_aff<Domain> gist(const typed::set<> &context) const;
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::union_set<> &context) const;
+  inline typed::multi_aff<Domain> gist(const typed::basic_set<> &context) const;
+  inline typed::multi_aff<Domain> gist(const typed::point<> &context) const;
+  inline typed::multi_aff<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::multi_aff<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::pw_multi_aff<Domain> intersect_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_multi_aff<Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::aff_list<Anonymous> list() const;
+  inline typed::aff_list<Domain> get_list() const = delete;
+  inline typed::multi_pw_aff<Domain> max(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain> min(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> min_multi_val() const;
+  inline typed::multi_aff<Domain> neg() const;
+  inline typed::pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Range>
+  inline typed::multi_aff<pair<Domain, Range>> product(const typed::multi_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::multi_pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Domain, Range>> product(const typed::pw_multi_aff<Range> &pma2) const;
+  template <typename Range>
+  inline typed::multi_aff<pair<Domain, Range>> product(const typed::aff<Range> &multi2) const;
+  inline typed::multi_aff<Domain> pullback(const typed::multi_aff<> &ma2) const = delete;
+  inline typed::multi_pw_aff<Domain> pullback(const typed::multi_pw_aff<> &mpa2) const = delete;
+  inline typed::pw_multi_aff<Domain> pullback(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::multi_aff<Domain> pullback(const typed::aff<> &ma2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain> range_factor_range() const = delete;
+  inline typed::multi_aff<Domain> range_product(const typed::multi_aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_product(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::multi_aff<Domain> range_product(const typed::aff<> &multi2) const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::multi_aff<Domain> scale(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_aff<Domain> scale(const typed::val<Domain> &v) const;
+  inline typed::multi_aff<Domain> scale(long v) const;
+  inline typed::multi_aff<Domain> scale_down(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_aff<Domain> scale_down(const typed::val<Domain> &v) const;
+  inline typed::multi_aff<Domain> scale_down(long v) const;
+  inline typed::multi_aff<Domain> set_at(int pos, const typed::aff<Anonymous> &el) const;
+  inline typed::multi_pw_aff<Domain> set_at(int pos, const typed::pw_aff<Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::multi_aff<Domain> sub(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> sub(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::pw_multi_aff<Domain> sub(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::multi_aff<Domain> sub(const typed::aff<Domain> &multi2) const;
+  inline typed::pw_multi_aff<Domain> subtract_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::multi_pw_aff<Domain> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain> to_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain> to_union_pw_multi_aff() const;
+  template <typename Arg1>
+  inline typed::multi_aff<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::multi_pw_aff<Domain> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const;
+  inline typed::pw_multi_aff<Domain> union_add(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+};
+
+template <typename Domain, typename Range>
+struct multi_aff<Domain, Range> : public isl::multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  multi_aff(const multi_aff<Arg1, Arg2> &obj) : isl::multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_aff>{}, bool>::type = true>
+  multi_aff(const base &obj) : isl::multi_aff(obj) {}
+ public:
+  static multi_aff from(const isl::multi_aff &obj) {
+    return multi_aff(obj);
+  }
+  inline /* implicit */ multi_aff(const typed::aff<Domain, Range> &aff);
+  inline explicit multi_aff(const typed::space<Domain, Range> &space, const typed::aff_list<Domain, Anonymous> &list);
+  inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_aff<Domain, Range> add(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::pw_multi_aff<Domain, Range> add(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::multi_aff<Domain, Range> add(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::multi_aff<Domain, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<Domain, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::multi_aff<Domain, Range> add_constant(long v) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::multi_aff<Domain, Range> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> as_pw_multi_aff() const;
+  inline typed::set<Domain, Range> as_set() const = delete;
+  inline typed::union_map<Domain, Range> as_union_map() const;
+  inline typed::aff<Domain, Anonymous> at(int pos) const;
+  inline typed::aff<Domain, Range> get_at(int pos) const = delete;
+  inline typed::basic_set<Domain> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::multi_aff<Range> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_aff<Domain, Range> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> coalesce() const;
+  inline typed::multi_val<Range> constant_multi_val() const;
+  inline typed::multi_val<Domain, Range> get_constant_multi_val() const = delete;
+  inline typed::set<Domain> domain() const;
+  inline typed::multi_aff<Domain, Range> floor() const;
+  inline typed::multi_aff<Domain, Range> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::union_set<Domain> &context) const;
+  inline typed::multi_aff<Domain, Range> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::multi_aff<Domain, Range> gist(const typed::point<Domain> &context) const;
+  inline typed::multi_aff<Domain, Range> identity() const;
+  inline typed::multi_aff<Domain, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::aff_list<Domain, Anonymous> list() const;
+  inline typed::aff_list<Domain, Range> get_list() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_aff<Domain, Range> neg() const;
+  inline typed::pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, Range> pullback(const typed::multi_aff<Domain2, Domain> &ma2) const;
+  inline typed::multi_aff<Range> pullback(const typed::multi_aff<Domain> &ma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, Range> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<Domain> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, Range> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::pw_multi_aff<Domain> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, Range> pullback(const typed::aff<Domain2, Domain> &ma2) const;
+  inline typed::multi_aff<Range> pullback(const typed::aff<Domain> &ma2) const;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, pair<Range, Range2>> range_product(const typed::aff<Domain, Range2> &multi2) const;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_aff<Domain, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<Domain, Range> scale(const typed::val<Range> &v) const;
+  inline typed::multi_aff<Domain, Range> scale(long v) const;
+  inline typed::multi_aff<Domain, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<Domain, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::multi_aff<Domain, Range> scale_down(long v) const;
+  inline typed::multi_aff<Domain, Range> set_at(int pos, const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::multi_pw_aff<Domain, Range> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, Range> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::multi_aff<Domain, Range> sub(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::pw_multi_aff<Domain, Range> sub(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::multi_aff<Domain, Range> sub(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::pw_multi_aff<Domain, Range> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_pw_aff<Domain, Range> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Range> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> to_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Range> to_union_pw_multi_aff() const;
+  inline typed::multi_aff<Domain, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const;
+  inline typed::pw_multi_aff<Domain, Range> union_add(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+};
+
+template <typename Domain2, typename Range2, typename Range>
+struct multi_aff<pair<Domain2, Range2>, Range> : public isl::multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain2, Arg1>{} &&
+              std::is_base_of<Range2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{},
+            bool>::type = true>
+  multi_aff(const multi_aff<pair<Arg1, Arg2>, Arg3> &obj) : isl::multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_aff>{}, bool>::type = true>
+  multi_aff(const base &obj) : isl::multi_aff(obj) {}
+ public:
+  static multi_aff from(const isl::multi_aff &obj) {
+    return multi_aff(obj);
+  }
+  inline /* implicit */ multi_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff);
+  inline explicit multi_aff(const typed::space<pair<Domain2, Range2>, Range> &space, const typed::aff_list<pair<Domain2, Range2>, Anonymous> &list);
+  inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> add(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> add(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> add_constant(long v) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> apply(const typed::union_pw_multi_aff<Range, Arg2> &upma2) const;
+  inline typed::map<pair<Domain2, Range2>, Range> as_map() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain2, Range2>, Range> as_set() const = delete;
+  inline typed::union_map<pair<Domain2, Range2>, Range> as_union_map() const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> at(int pos) const;
+  inline typed::aff<pair<Domain2, Range2>, Range> get_at(int pos) const = delete;
+  inline typed::basic_set<pair<Domain2, Range2>> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::multi_aff<Range> bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const;
+  inline typed::multi_aff<Range2, Range> bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> coalesce() const;
+  inline typed::multi_val<Range> constant_multi_val() const;
+  inline typed::multi_val<pair<Domain2, Range2>, Range> get_constant_multi_val() const = delete;
+  inline typed::set<pair<Domain2, Range2>> domain() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> floor() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> gist(const typed::set<pair<Domain2, Range2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> gist(const typed::union_set<pair<Domain2, Range2>> &context) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> gist(const typed::basic_set<pair<Domain2, Range2>> &context) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> gist(const typed::point<pair<Domain2, Range2>> &context) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> identity() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::aff_list<pair<Domain2, Range2>, Anonymous> list() const;
+  inline typed::aff_list<pair<Domain2, Range2>, Range> get_list() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::pw_multi_aff<Arg2, Arg3> &pma2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_aff<Arg2, Range> pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma2) const;
+  inline typed::multi_aff<Range> pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<Arg2, Range> pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<Arg2, Range> pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<Arg2, Range> pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma2) const;
+  template <typename Arg2>
+  inline typed::multi_aff<Arg2, Range> pullback(const typed::aff<Arg2, pair<Domain2, Range2>> &ma2) const;
+  inline typed::multi_aff<Range> pullback(const typed::aff<pair<Domain2, Range2>> &ma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> range_factor_range() const = delete;
+  template <typename Arg2>
+  inline typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  inline typed::id<pair<Domain2, Range2>, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale(const typed::val<Range> &v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale(long v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> scale_down(long v) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  template <typename Arg1>
+  inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg1>
+  inline typed::multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain2, Range2>, Range> space() const;
+  inline typed::space<pair<Domain2, Range2>, Range> get_space() const = delete;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> sub(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> to_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> to_union_pw_multi_aff() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct multi_aff<Domain, pair<Range, Range2>> : public isl::multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  multi_aff(const multi_aff<Arg1, pair<Arg2, Arg3>> &obj) : isl::multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_aff>{}, bool>::type = true>
+  multi_aff(const base &obj) : isl::multi_aff(obj) {}
+ public:
+  static multi_aff from(const isl::multi_aff &obj) {
+    return multi_aff(obj);
+  }
+  inline /* implicit */ multi_aff(const typed::aff<Domain, pair<Range, Range2>> &aff);
+  inline explicit multi_aff(const typed::space<Domain, pair<Range, Range2>> &space, const typed::aff_list<Domain, Anonymous> &list);
+  inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_aff<Domain, pair<Range, Range2>> add(const typed::multi_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> add(const typed::aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> add_constant(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> add_constant(long v) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  inline typed::map<Domain, pair<Range, Range2>> as_map() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::set<Domain, pair<Range, Range2>> as_set() const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> as_union_map() const;
+  inline typed::aff<Domain, Anonymous> at(int pos) const;
+  inline typed::aff<Domain, pair<Range, Range2>> get_at(int pos) const = delete;
+  inline typed::basic_set<Domain> bind(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::multi_aff<pair<Range, Range2>> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::multi_val<pair<Range, Range2>> constant_multi_val() const;
+  inline typed::multi_val<Domain, pair<Range, Range2>> get_constant_multi_val() const = delete;
+  inline typed::set<Domain> domain() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> floor() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::union_set<Domain> &context) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> gist(const typed::point<Domain> &context) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> identity() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::aff_list<Domain, Anonymous> list() const;
+  inline typed::aff_list<Domain, pair<Range, Range2>> get_list() const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> max(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> min(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> min_multi_val() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> neg() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Domain2, typename Arg3>
+  inline typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::multi_aff<Domain2, Arg3> &multi2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::multi_pw_aff<Domain2, Arg3> &multi2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::pw_multi_aff<Domain2, Arg3> &pma2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::aff<Domain2, Arg3> &multi2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, Domain> &ma2) const;
+  inline typed::multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<Domain> &ma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::aff<Domain2, Domain> &ma2) const;
+  inline typed::multi_aff<pair<Range, Range2>> pullback(const typed::aff<Domain> &ma2) const;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_domain() const;
+  inline typed::pw_multi_aff<Domain, Range2> range_factor_range() const;
+  template <typename Arg3>
+  inline typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_aff<Domain, Arg3> &multi2) const;
+  template <typename Arg3>
+  inline typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_pw_aff<Domain, Arg3> &multi2) const;
+  template <typename Arg3>
+  inline typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_union_pw_aff<Domain, Arg3> &multi2) const;
+  template <typename Arg3>
+  inline typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::pw_multi_aff<Domain, Arg3> &pma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::aff<Domain, Arg3> &multi2) const;
+  inline typed::id<Domain, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale(long v) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale_down(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> scale_down(long v) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> set_at(int pos, const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> space() const;
+  inline typed::space<Domain, pair<Range, Range2>> get_space() const = delete;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> sub(const typed::multi_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> sub(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> sub(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> sub(const typed::aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> to_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> to_union_pw_multi_aff() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &mupa2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct multi_aff<pair<T1, T2>, pair<Range, Range2>> : public isl::multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  multi_aff(const multi_aff<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_aff>{}, bool>::type = true>
+  multi_aff(const base &obj) : isl::multi_aff(obj) {}
+ public:
+  static multi_aff from(const isl::multi_aff &obj) {
+    return multi_aff(obj);
+  }
+  inline /* implicit */ multi_aff(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &aff);
+  inline explicit multi_aff(const typed::space<pair<T1, T2>, pair<Range, Range2>> &space, const typed::aff_list<pair<T1, T2>, Anonymous> &list);
+  inline explicit multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(long v) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> as_map() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::set<pair<T1, T2>, pair<Range, Range2>> as_set() const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> as_union_map() const;
+  inline typed::aff<pair<T1, T2>, Anonymous> at(int pos) const;
+  inline typed::aff<pair<T1, T2>, pair<Range, Range2>> get_at(int pos) const = delete;
+  inline typed::basic_set<pair<T1, T2>> bind(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::multi_aff<pair<Range, Range2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::multi_aff<T2, pair<Range, Range2>> bind_domain_wrapped_domain(const typed::multi_id<T1> &tuple) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::multi_val<pair<Range, Range2>> constant_multi_val() const;
+  inline typed::multi_val<pair<T1, T2>, pair<Range, Range2>> get_constant_multi_val() const = delete;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> floor() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_set<pair<T1, T2>> &context) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_set<pair<T1, T2>> &context) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::point<pair<T1, T2>> &context) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> identity() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::aff_list<pair<T1, T2>, Anonymous> list() const;
+  inline typed::aff_list<pair<T1, T2>, pair<Range, Range2>> get_list() const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> max(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> min(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> min_multi_val() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::multi_aff<Domain2, Arg2> &multi2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::multi_pw_aff<Domain2, Arg2> &multi2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::pw_multi_aff<Domain2, Arg2> &pma2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::aff<Domain2, Arg2> &multi2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &ma2) const;
+  inline typed::multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<pair<T1, T2>> &ma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Range, Range2>> pullback(const typed::multi_pw_aff<pair<T1, T2>> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<pair<T1, T2>> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const;
+  template <typename Domain2>
+  inline typed::multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::aff<Domain2, pair<T1, T2>> &ma2) const;
+  inline typed::multi_aff<pair<Range, Range2>> pullback(const typed::aff<pair<T1, T2>> &ma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, Range2> range_factor_range() const;
+  template <typename Arg2>
+  inline typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_pw_aff<pair<T1, T2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_union_pw_aff<pair<T1, T2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::aff<pair<T1, T2>, Arg2> &multi2) const;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale(long v) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(long v) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> set_at(int pos, const typed::aff<pair<T1, T2>, Anonymous> &el) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> set_at(int pos, const typed::pw_aff<pair<T1, T2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> set_at(int pos, const typed::union_pw_aff<pair<T1, T2>, Anonymous> &el) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> space() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> get_space() const = delete;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> to_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> to_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> to_pw_multi_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> to_union_pw_multi_aff() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mupa2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+};
+
+template <typename Domain>
+struct multi_id<Domain> : public isl::multi_id {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_id() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  multi_id(const multi_id<Arg1> &obj) : isl::multi_id(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_id>{}, bool>::type = true>
+  multi_id(const base &obj) : isl::multi_id(obj) {}
+ public:
+  static multi_id from(const isl::multi_id &obj) {
+    return multi_id(obj);
+  }
+  inline explicit multi_id(const typed::space<Domain> &space, const typed::id_list<Anonymous> &list);
+  inline explicit multi_id(const isl::ctx &ctx, const std::string &str);
+  inline typed::id<Anonymous> at(int pos) const;
+  inline typed::id<Domain> get_at(int pos) const = delete;
+  inline typed::id_list<Anonymous> list() const;
+  inline typed::id_list<Domain> get_list() const = delete;
+  inline typed::multi_id<Domain> range_product(const typed::multi_id<> &multi2) const = delete;
+  inline typed::multi_id<Domain> set_at(int pos, const typed::id<Anonymous> &el) const;
+  inline typed::multi_id<Domain> set_at(int pos, const std::string &el) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+};
+
+template <typename Domain>
+struct multi_pw_aff<Domain> : public isl::multi_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_pw_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  multi_pw_aff(const multi_pw_aff<Arg1> &obj) : isl::multi_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
+  multi_pw_aff(const base &obj) : isl::multi_pw_aff(obj) {}
+ public:
+  static multi_pw_aff from(const isl::multi_pw_aff &obj) {
+    return multi_pw_aff(obj);
+  }
+  inline /* implicit */ multi_pw_aff(const typed::aff<Domain> &aff);
+  inline /* implicit */ multi_pw_aff(const typed::multi_aff<Domain> &ma);
+  inline /* implicit */ multi_pw_aff(const typed::pw_aff<Domain> &pa);
+  inline explicit multi_pw_aff(const typed::space<Domain> &space, const typed::pw_aff_list<Anonymous> &list);
+  inline /* implicit */ multi_pw_aff(const typed::pw_multi_aff<Domain> &pma);
+  inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain> add(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> add(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add(const typed::aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add(const typed::pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add(const typed::pw_multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> add_constant(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_pw_aff<Domain> add_constant(const typed::val<Domain> &v) const;
+  inline typed::multi_pw_aff<Domain> add_constant(long v) const;
+  inline typed::map<Domain> as_map() const = delete;
+  inline typed::set<Domain> as_set() const;
+  inline typed::pw_aff<Anonymous> at(int pos) const;
+  inline typed::pw_aff<Domain> get_at(int pos) const = delete;
+  inline typed::set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_pw_aff<Domain> bind_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::multi_pw_aff<Domain> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::multi_pw_aff<Domain> coalesce() const;
+  inline typed::set<> domain() const;
+  inline typed::multi_pw_aff<Domain> gist(const typed::set<> &set) const;
+  inline typed::multi_union_pw_aff<Domain> gist(const typed::union_set<> &context) const;
+  inline typed::multi_pw_aff<Domain> gist(const typed::basic_set<> &set) const;
+  inline typed::multi_pw_aff<Domain> gist(const typed::point<> &set) const;
+  inline typed::multi_pw_aff<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::multi_pw_aff<Domain> intersect_domain(const typed::set<> &domain) const = delete;
+  inline typed::multi_union_pw_aff<Domain> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::multi_pw_aff<Domain> intersect_domain(const typed::basic_set<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain> intersect_domain(const typed::point<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::multi_pw_aff<Domain> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::multi_pw_aff<Domain> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<Anonymous> list() const;
+  inline typed::pw_aff_list<Domain> get_list() const = delete;
+  inline typed::multi_pw_aff<Domain> max(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> max(const typed::aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> max(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> max(const typed::pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> max(const typed::pw_multi_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain> min(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> min(const typed::aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> min(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> min(const typed::pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> min(const typed::pw_multi_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> min_multi_val() const;
+  inline typed::multi_pw_aff<Domain> neg() const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::multi_pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::multi_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::pw_multi_aff<Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain> pullback(const typed::multi_aff<> &ma) const = delete;
+  inline typed::multi_pw_aff<Domain> pullback(const typed::multi_pw_aff<> &mpa2) const = delete;
+  inline typed::multi_pw_aff<Domain> pullback(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::multi_union_pw_aff<Domain> pullback(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::multi_aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::pw_aff<> &multi2) const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::pw_multi_aff<> &multi2) const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<Domain> scale(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_pw_aff<Domain> scale(const typed::val<Domain> &v) const;
+  inline typed::multi_pw_aff<Domain> scale(long v) const;
+  inline typed::multi_pw_aff<Domain> scale_down(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_pw_aff<Domain> scale_down(const typed::val<Domain> &v) const;
+  inline typed::multi_pw_aff<Domain> scale_down(long v) const;
+  inline typed::multi_pw_aff<Domain> set_at(int pos, const typed::pw_aff<Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::multi_pw_aff<Domain> sub(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> sub(const typed::aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> sub(const typed::multi_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> sub(const typed::pw_aff<Domain> &multi2) const;
+  inline typed::multi_pw_aff<Domain> sub(const typed::pw_multi_aff<Domain> &multi2) const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::multi_pw_aff<Domain> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::aff<Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::multi_aff<Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::pw_aff<Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::pw_multi_aff<Domain> &mpa2) const;
+};
+
+template <typename Domain, typename Range>
+struct multi_pw_aff<Domain, Range> : public isl::multi_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_pw_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  multi_pw_aff(const multi_pw_aff<Arg1, Arg2> &obj) : isl::multi_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
+  multi_pw_aff(const base &obj) : isl::multi_pw_aff(obj) {}
+ public:
+  static multi_pw_aff from(const isl::multi_pw_aff &obj) {
+    return multi_pw_aff(obj);
+  }
+  inline /* implicit */ multi_pw_aff(const typed::aff<Domain, Range> &aff);
+  inline /* implicit */ multi_pw_aff(const typed::multi_aff<Domain, Range> &ma);
+  inline /* implicit */ multi_pw_aff(const typed::pw_aff<Domain, Range> &pa);
+  inline explicit multi_pw_aff(const typed::space<Domain, Range> &space, const typed::pw_aff_list<Domain, Anonymous> &list);
+  inline /* implicit */ multi_pw_aff(const typed::pw_multi_aff<Domain, Range> &pma);
+  inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::pw_multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<Domain, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<Domain, Range> add_constant(long v) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::set<Domain, Range> as_set() const = delete;
+  inline typed::pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::pw_aff<Domain, Range> get_at(int pos) const = delete;
+  inline typed::set<Domain> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::multi_pw_aff<Range> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_pw_aff<Domain, Range> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> coalesce() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::multi_pw_aff<Domain, Range> gist(const typed::set<Domain> &set) const;
+  inline typed::multi_union_pw_aff<Domain, Range> gist(const typed::union_set<Domain> &context) const;
+  inline typed::multi_pw_aff<Domain, Range> gist(const typed::basic_set<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> gist(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> identity() const;
+  inline typed::multi_pw_aff<Domain, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> intersect_domain(const typed::set<Domain> &domain) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_pw_aff<Domain, Range> intersect_domain(const typed::basic_set<Domain> &domain) const;
+  inline typed::multi_pw_aff<Domain, Range> intersect_domain(const typed::point<Domain> &domain) const;
+  inline typed::multi_pw_aff<Domain, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::pw_aff_list<Domain, Range> get_list() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::pw_multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::pw_multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Range> neg() const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::pw_multi_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, Range> pullback(const typed::multi_aff<Domain2, Domain> &ma) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_aff<Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, Range> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<Domain> &mpa2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, Range> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::pw_multi_aff<Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2, Range> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::union_pw_multi_aff<Domain> &upma) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &multi2) const;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<Domain, Range> scale(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<Domain, Range> scale(long v) const;
+  inline typed::multi_pw_aff<Domain, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<Domain, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<Domain, Range> scale_down(long v) const;
+  inline typed::multi_pw_aff<Domain, Range> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, Range> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::pw_multi_aff<Domain, Range> &multi2) const;
+  inline typed::multi_pw_aff<Domain, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::aff<Domain, Range> &mpa2) const;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::multi_aff<Domain, Range> &mpa2) const;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::pw_aff<Domain, Range> &mpa2) const;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::pw_multi_aff<Domain, Range> &mpa2) const;
+};
+
+template <typename Domain2, typename Range2, typename Range>
+struct multi_pw_aff<pair<Domain2, Range2>, Range> : public isl::multi_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_pw_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain2, Arg1>{} &&
+              std::is_base_of<Range2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{},
+            bool>::type = true>
+  multi_pw_aff(const multi_pw_aff<pair<Arg1, Arg2>, Arg3> &obj) : isl::multi_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_pw_aff>{}, bool>::type = true>
+  multi_pw_aff(const base &obj) : isl::multi_pw_aff(obj) {}
+ public:
+  static multi_pw_aff from(const isl::multi_pw_aff &obj) {
+    return multi_pw_aff(obj);
+  }
+  inline /* implicit */ multi_pw_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff);
+  inline /* implicit */ multi_pw_aff(const typed::multi_aff<pair<Domain2, Range2>, Range> &ma);
+  inline /* implicit */ multi_pw_aff(const typed::pw_aff<pair<Domain2, Range2>, Range> &pa);
+  inline explicit multi_pw_aff(const typed::space<pair<Domain2, Range2>, Range> &space, const typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> &list);
+  inline /* implicit */ multi_pw_aff(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma);
+  inline explicit multi_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add_constant(long v) const;
+  inline typed::map<pair<Domain2, Range2>, Range> as_map() const;
+  inline typed::set<pair<Domain2, Range2>, Range> as_set() const = delete;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> at(int pos) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Range> get_at(int pos) const = delete;
+  inline typed::set<pair<Domain2, Range2>> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::multi_pw_aff<Range> bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const;
+  inline typed::multi_pw_aff<Range2, Range> bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> coalesce() const;
+  inline typed::set<pair<Domain2, Range2>> domain() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> gist(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> gist(const typed::union_set<pair<Domain2, Range2>> &context) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> gist(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> gist(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> identity() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::set<pair<Domain2, Range2>> &domain) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &domain) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::point<pair<Domain2, Range2>> &domain) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> list() const;
+  inline typed::pw_aff_list<pair<Domain2, Range2>, Range> get_list() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> neg() const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::pw_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::pw_multi_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<Arg2, Range> pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<Arg2, Range> pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<Arg2, Range> pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<Arg2, Range> pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  inline typed::id<pair<Domain2, Range2>, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale(long v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale_down(long v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain2, Range2>, Range> space() const;
+  inline typed::space<pair<Domain2, Range2>, Range> get_space() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::pw_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+};
+
+template <typename Domain>
+struct multi_union_pw_aff<Domain> : public isl::multi_union_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_union_pw_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  multi_union_pw_aff(const multi_union_pw_aff<Arg1> &obj) : isl::multi_union_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_union_pw_aff>{}, bool>::type = true>
+  multi_union_pw_aff(const base &obj) : isl::multi_union_pw_aff(obj) {}
+ public:
+  static multi_union_pw_aff from(const isl::multi_union_pw_aff &obj) {
+    return multi_union_pw_aff(obj);
+  }
+  inline /* implicit */ multi_union_pw_aff(const typed::multi_pw_aff<Domain> &mpa);
+  inline /* implicit */ multi_union_pw_aff(const typed::union_pw_aff<Domain> &upa);
+  inline explicit multi_union_pw_aff(const typed::space<Domain> &space, const typed::union_pw_aff_list<Anonymous> &list);
+  inline explicit multi_union_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_union_pw_aff<Domain> add(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> add(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> add(const typed::union_pw_aff<Domain> &multi2) const;
+  inline typed::union_pw_aff<Anonymous> at(int pos) const;
+  inline typed::union_pw_aff<Domain> get_at(int pos) const = delete;
+  inline typed::union_set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::multi_union_pw_aff<Domain> coalesce() const;
+  inline typed::union_set<> domain() const;
+  inline typed::multi_union_pw_aff<Domain> gist(const typed::union_set<> &context) const;
+  inline typed::multi_union_pw_aff<Domain> gist(const typed::basic_set<> &context) const;
+  inline typed::multi_union_pw_aff<Domain> gist(const typed::point<> &context) const;
+  inline typed::multi_union_pw_aff<Domain> gist(const typed::set<> &context) const;
+  inline typed::multi_union_pw_aff<Domain> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::multi_union_pw_aff<Domain> intersect_domain(const typed::basic_set<> &uset) const = delete;
+  inline typed::multi_union_pw_aff<Domain> intersect_domain(const typed::point<> &uset) const = delete;
+  inline typed::multi_union_pw_aff<Domain> intersect_domain(const typed::set<> &uset) const = delete;
+  inline typed::multi_union_pw_aff<Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::multi_union_pw_aff<Domain> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::multi_union_pw_aff<Domain> intersect_params(const typed::point<> &params) const;
+  inline typed::union_pw_aff_list<Anonymous> list() const;
+  inline typed::union_pw_aff_list<Domain> get_list() const = delete;
+  inline typed::multi_union_pw_aff<Domain> neg() const;
+  inline typed::multi_union_pw_aff<Domain> pullback(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::multi_union_pw_aff<Domain> pullback(const typed::multi_aff<> &upma) const = delete;
+  inline typed::multi_union_pw_aff<Domain> pullback(const typed::pw_multi_aff<> &upma) const = delete;
+  inline typed::multi_union_pw_aff<Domain> pullback(const typed::union_pw_aff<> &upma) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::union_pw_aff<> &multi2) const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::multi_union_pw_aff<Domain> scale(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_union_pw_aff<Domain> scale(const typed::val<Domain> &v) const;
+  inline typed::multi_union_pw_aff<Domain> scale(long v) const;
+  inline typed::multi_union_pw_aff<Domain> scale_down(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_union_pw_aff<Domain> scale_down(const typed::val<Domain> &v) const;
+  inline typed::multi_union_pw_aff<Domain> scale_down(long v) const;
+  inline typed::multi_union_pw_aff<Domain> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::union_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::multi_pw_aff<Domain> &mupa2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::union_pw_aff<Domain> &mupa2) const;
+};
+
+template <typename Domain, typename Range>
+struct multi_union_pw_aff<Domain, Range> : public isl::multi_union_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_union_pw_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  multi_union_pw_aff(const multi_union_pw_aff<Arg1, Arg2> &obj) : isl::multi_union_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_union_pw_aff>{}, bool>::type = true>
+  multi_union_pw_aff(const base &obj) : isl::multi_union_pw_aff(obj) {}
+ public:
+  static multi_union_pw_aff from(const isl::multi_union_pw_aff &obj) {
+    return multi_union_pw_aff(obj);
+  }
+  inline /* implicit */ multi_union_pw_aff(const typed::multi_pw_aff<Domain, Range> &mpa);
+  inline /* implicit */ multi_union_pw_aff(const typed::union_pw_aff<Domain, Range> &upa);
+  inline explicit multi_union_pw_aff(const typed::space<Domain, Range> &space, const typed::union_pw_aff_list<Domain, Anonymous> &list);
+  inline explicit multi_union_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::union_pw_aff<Domain, Range> get_at(int pos) const = delete;
+  inline typed::union_set<Domain> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::multi_union_pw_aff<Domain, Range> coalesce() const;
+  inline typed::union_set<Domain> domain() const;
+  inline typed::multi_union_pw_aff<Domain, Range> gist(const typed::union_set<Domain> &context) const;
+  inline typed::multi_union_pw_aff<Domain, Range> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::multi_union_pw_aff<Domain, Range> gist(const typed::point<Domain> &context) const;
+  inline typed::multi_union_pw_aff<Domain, Range> gist(const typed::set<Domain> &context) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_domain(const typed::basic_set<Domain> &uset) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_domain(const typed::point<Domain> &uset) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_domain(const typed::set<Domain> &uset) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_params(const typed::set<> &params) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::multi_union_pw_aff<Domain, Range> intersect_params(const typed::point<> &params) const;
+  inline typed::union_pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::union_pw_aff_list<Domain, Range> get_list() const = delete;
+  inline typed::multi_union_pw_aff<Domain, Range> neg() const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2, Range> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::union_pw_multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2, Range> pullback(const typed::multi_aff<Domain2, Domain> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2, Range> pullback(const typed::pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::pw_multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2, Range> pullback(const typed::union_pw_aff<Domain2, Domain> &upma) const;
+  inline typed::multi_union_pw_aff<Range> pullback(const typed::union_pw_aff<Domain> &upma) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::union_pw_aff<Domain, Range2> &multi2) const;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_union_pw_aff<Domain, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_union_pw_aff<Domain, Range> scale(const typed::val<Range> &v) const;
+  inline typed::multi_union_pw_aff<Domain, Range> scale(long v) const;
+  inline typed::multi_union_pw_aff<Domain, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_union_pw_aff<Domain, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::multi_union_pw_aff<Domain, Range> scale_down(long v) const;
+  inline typed::multi_union_pw_aff<Domain, Range> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::multi_pw_aff<Domain, Range> &mupa2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::union_pw_aff<Domain, Range> &mupa2) const;
+};
+
+template <typename Domain>
+struct multi_val<Domain> : public isl::multi_val {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  multi_val() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  multi_val(const multi_val<Arg1> &obj) : isl::multi_val(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::multi_val>{}, bool>::type = true>
+  multi_val(const base &obj) : isl::multi_val(obj) {}
+ public:
+  static multi_val from(const isl::multi_val &obj) {
+    return multi_val(obj);
+  }
+  inline explicit multi_val(const typed::space<Domain> &space, const typed::val_list<Anonymous> &list);
+  inline explicit multi_val(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_val<Domain> add(const typed::multi_val<Domain> &multi2) const;
+  inline typed::multi_val<Domain> add(const typed::val<Domain> &v) const;
+  inline typed::multi_val<Domain> add(long v) const;
+  inline typed::val<Anonymous> at(int pos) const;
+  inline typed::val<Domain> get_at(int pos) const = delete;
+  inline typed::val_list<Anonymous> list() const;
+  inline typed::val_list<Domain> get_list() const = delete;
+  inline typed::multi_val<Domain> max(const typed::multi_val<Domain> &multi2) const;
+  inline typed::multi_val<Domain> min(const typed::multi_val<Domain> &multi2) const;
+  inline typed::multi_val<Domain> neg() const;
+  template <typename Range>
+  inline typed::multi_val<pair<Domain, Range>> product(const typed::multi_val<Range> &multi2) const;
+  inline typed::multi_val<Domain> range_product(const typed::multi_val<> &multi2) const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::multi_val<Domain> scale(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_val<Domain> scale(const typed::val<Domain> &v) const;
+  inline typed::multi_val<Domain> scale(long v) const;
+  inline typed::multi_val<Domain> scale_down(const typed::multi_val<Domain> &mv) const;
+  inline typed::multi_val<Domain> scale_down(const typed::val<Domain> &v) const;
+  inline typed::multi_val<Domain> scale_down(long v) const;
+  inline typed::multi_val<Domain> set_at(int pos, const typed::val<Anonymous> &el) const;
+  inline typed::multi_val<Domain> set_at(int pos, long el) const;
+  template <typename Domain2>
+  inline typed::multi_val<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_val<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::multi_val<Domain> sub(const typed::multi_val<Domain> &multi2) const;
+};
+
+template <>
+struct point<> : public isl::point {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  point() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::point>{}, bool>::type = true>
+  point(const base &obj) : isl::point(obj) {}
+ public:
+  static point from(const isl::point &obj) {
+    return point(obj);
+  }
+  inline typed::basic_set<> apply(const typed::basic_map<> &bmap) const = delete;
+  inline typed::set<> apply(const typed::map<> &map) const = delete;
+  inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
+  inline typed::pw_multi_aff<> as_pw_multi_aff() const = delete;
+  inline typed::set<> as_set() const = delete;
+  inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
+  inline typed::set<> coalesce() const;
+  inline typed::basic_set<> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
+  inline typed::basic_set<> gist(const typed::basic_set<> &context) const;
+  inline typed::set<> gist(const typed::set<> &context) const;
+  inline typed::union_set<> gist(const typed::union_set<> &context) const;
+  inline typed::map<> identity() const = delete;
+  inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::basic_set<> intersect(const typed::basic_set<> &bset2) const;
+  inline typed::set<> intersect(const typed::set<> &set2) const;
+  inline typed::union_set<> intersect(const typed::union_set<> &uset2) const;
+  inline typed::basic_set<> intersect_params(const typed::basic_set<> &bset2) const = delete;
+  inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
+  inline typed::set<> lexmax() const = delete;
+  inline typed::pw_multi_aff<> lexmax_pw_multi_aff() const = delete;
+  inline typed::set<> lexmin() const = delete;
+  inline typed::pw_multi_aff<> lexmin_pw_multi_aff() const = delete;
+  inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
+  inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
+  inline typed::multi_pw_aff<> max_multi_pw_aff() const = delete;
+  inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<> min_multi_pw_aff() const = delete;
+  inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_val<> multi_val() const = delete;
+  inline typed::multi_val<> get_multi_val() const = delete;
+  inline typed::basic_set<> params() const = delete;
+  inline typed::multi_val<> plain_multi_val_if_fixed() const = delete;
+  inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
+  inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::set<> product(const typed::set<> &set2) const = delete;
+  inline typed::set<> project_out_all_params() const;
+  inline typed::set<> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<> project_out_param(const std::string &id) const;
+  inline typed::set<> project_out_param(const typed::id_list<Anonymous> &list) const;
+  inline typed::pw_multi_aff<> pw_multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::fixed_box<> simple_fixed_box_hull() const = delete;
+  inline typed::space<> space() const;
+  inline typed::set<> subtract(const typed::set<> &set2) const;
+  inline typed::union_set<> subtract(const typed::union_set<> &uset2) const;
+  inline typed::set<> to_set() const;
+  inline typed::union_set<> to_union_set() const;
+  inline typed::map<> translation() const = delete;
+  template <typename Domain>
+  inline typed::set<Domain> unbind_params(const typed::multi_id<Domain> &tuple) const;
+  inline typed::map<> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::set<> unite(const typed::basic_set<> &bset2) const;
+  inline typed::set<> unite(const typed::set<> &set2) const;
+  inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
+  inline typed::map<> unwrap() const = delete;
+  inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
+  inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
+};
+
+template <typename Domain>
+struct point<Domain> : public isl::point {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  point() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  point(const point<Arg1> &obj) : isl::point(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::point>{}, bool>::type = true>
+  point(const base &obj) : isl::point(obj) {}
+ public:
+  static point from(const isl::point &obj) {
+    return point(obj);
+  }
+  template <typename Range>
+  inline typed::basic_set<Range> apply(const typed::basic_map<Domain, Range> &bmap) const;
+  template <typename Range>
+  inline typed::set<Range> apply(const typed::map<Domain, Range> &map) const;
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::union_map<Domain, Range> &umap) const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> coalesce() const;
+  inline typed::basic_set<Domain> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
+  inline typed::basic_set<Domain> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::set<Domain> gist(const typed::set<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::union_set<Domain> &context) const;
+  inline typed::map<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::basic_set<Domain> intersect(const typed::basic_set<Domain> &bset2) const;
+  inline typed::set<Domain> intersect(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> intersect(const typed::union_set<Domain> &uset2) const;
+  inline typed::basic_set<Domain> intersect_params(const typed::basic_set<> &bset2) const;
+  inline typed::set<Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::set<Domain> lexmax() const;
+  inline typed::pw_multi_aff<Domain> lexmax_pw_multi_aff() const;
+  inline typed::set<Domain> lexmin() const;
+  inline typed::pw_multi_aff<Domain> lexmin_pw_multi_aff() const;
+  inline typed::set<Domain> lower_bound(const typed::multi_pw_aff<Domain> &lower) const;
+  inline typed::set<Domain> lower_bound(const typed::multi_val<Domain> &lower) const;
+  inline typed::multi_pw_aff<Domain> max_multi_pw_aff() const;
+  inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<Domain> min_multi_pw_aff() const;
+  inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_val<Domain> multi_val() const;
+  inline typed::multi_val<Domain> get_multi_val() const = delete;
+  inline typed::basic_set<> params() const;
+  inline typed::multi_val<Domain> plain_multi_val_if_fixed() const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range>
+  inline typed::set<pair<Domain, Range>> product(const typed::set<Range> &set2) const;
+  inline typed::set<Domain> project_out_all_params() const;
+  inline typed::set<Domain> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<Domain> project_out_param(const std::string &id) const;
+  inline typed::set<Domain> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<Domain, Range> pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const;
+  inline typed::fixed_box<Domain> simple_fixed_box_hull() const;
+  inline typed::space<Domain> space() const;
+  inline typed::set<Domain> subtract(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> subtract(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> to_set() const;
+  inline typed::union_set<Domain> to_union_set() const;
+  inline typed::map<Domain, Domain> translation() const;
+  inline typed::set<Domain> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::set<Domain> unite(const typed::basic_set<Domain> &bset2) const;
+  inline typed::set<Domain> unite(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> unite(const typed::union_set<Domain> &uset2) const;
+  inline typed::map<Domain> unwrap() const = delete;
+  inline typed::set<Domain> upper_bound(const typed::multi_pw_aff<Domain> &upper) const;
+  inline typed::set<Domain> upper_bound(const typed::multi_val<Domain> &upper) const;
+};
+
+template <typename Domain, typename Range>
+struct point<pair<Domain, Range>> : public isl::point {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  point() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  point(const point<pair<Arg1, Arg2>> &obj) : isl::point(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::point>{}, bool>::type = true>
+  point(const base &obj) : isl::point(obj) {}
+ public:
+  static point from(const isl::point &obj) {
+    return point(obj);
+  }
+  template <typename Arg2>
+  inline typed::basic_set<Arg2> apply(const typed::basic_map<pair<Domain, Range>, Arg2> &bmap) const;
+  template <typename Arg2>
+  inline typed::set<Arg2> apply(const typed::map<pair<Domain, Range>, Arg2> &map) const;
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<pair<Domain, Range>> &tuple) const;
+  inline typed::set<pair<Domain, Range>> coalesce() const;
+  inline typed::basic_set<pair<Domain, Range>> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
+  inline typed::basic_set<pair<Domain, Range>> gist(const typed::basic_set<pair<Domain, Range>> &context) const;
+  inline typed::set<pair<Domain, Range>> gist(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::union_set<pair<Domain, Range>> &context) const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> identity() const;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> insert_domain(const typed::space<Arg2> &domain) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect(const typed::basic_set<pair<Domain, Range>> &bset2) const;
+  inline typed::set<pair<Domain, Range>> intersect(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::basic_set<pair<Domain, Range>> intersect_params(const typed::basic_set<> &bset2) const;
+  inline typed::set<pair<Domain, Range>> intersect_params(const typed::set<> &params) const;
+  inline typed::set<pair<Domain, Range>> lexmax() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmax_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lexmin() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmin_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>> max_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<pair<Domain, Range>> min_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_val<pair<Domain, Range>> multi_val() const;
+  inline typed::multi_val<pair<Domain, Range>> get_multi_val() const = delete;
+  inline typed::basic_set<> params() const;
+  inline typed::multi_val<pair<Domain, Range>> plain_multi_val_if_fixed() const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg2>
+  inline typed::set<pair<pair<Domain, Range>, Arg2>> product(const typed::set<Arg2> &set2) const;
+  inline typed::set<pair<Domain, Range>> project_out_all_params() const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const std::string &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain, Range>, Arg2> pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const;
+  inline typed::fixed_box<pair<Domain, Range>> simple_fixed_box_hull() const;
+  inline typed::space<pair<Domain, Range>> space() const;
+  inline typed::set<pair<Domain, Range>> subtract(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> to_set() const;
+  inline typed::union_set<pair<Domain, Range>> to_union_set() const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> translation() const;
+  inline typed::set<pair<Domain, Range>> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::basic_set<pair<Domain, Range>> &bset2) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::map<Domain, Range> unwrap() const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const;
+};
+
+template <>
+struct pw_aff<Anonymous> : public isl::pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_aff() = default;
+  pw_aff(const isl::pw_aff &obj) : isl::pw_aff(obj) {}
+  static pw_aff from(const isl::pw_aff &obj) {
+    return pw_aff(obj);
+  }
+  inline /* implicit */ pw_aff(const typed::aff<Anonymous> &aff);
+  inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Anonymous> add(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Anonymous> add(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> add(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> add(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::pw_aff<Anonymous> add(const typed::aff<Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<Anonymous> add_constant(long v) const;
+  inline typed::pw_multi_aff<Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const;
+  inline typed::aff<Anonymous> as_aff() const;
+  inline typed::map<Anonymous> as_map() const = delete;
+  inline typed::multi_aff<Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Anonymous> as_pw_multi_aff() const;
+  inline typed::set<Anonymous> as_set() const;
+  inline typed::union_map<Anonymous> as_union_map() const = delete;
+  inline typed::pw_aff<Anonymous> at(int pos) const;
+  inline typed::set<> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::set<> bind(const typed::id<Anonymous> &id) const;
+  inline typed::set<> bind(const std::string &id) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Anonymous> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Anonymous> coalesce() const;
+  inline typed::set<> domain() const;
+  inline typed::pw_aff<Anonymous> floor() const;
+  inline typed::set<Anonymous> ge_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::set<Anonymous> ge_set(const typed::aff<> &pwaff2) const = delete;
+  inline typed::pw_aff<Anonymous> gist(const typed::set<> &context) const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::union_set<> &context) const;
+  inline typed::pw_aff<Anonymous> gist(const typed::basic_set<> &context) const;
+  inline typed::pw_aff<Anonymous> gist(const typed::point<> &context) const;
+  inline typed::set<Anonymous> gt_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::set<Anonymous> gt_set(const typed::aff<> &pwaff2) const = delete;
+  inline typed::multi_pw_aff<Anonymous, Anonymous> identity() const;
+  template <typename Domain>
+  inline typed::pw_aff<Domain, Anonymous> insert_domain(const typed::space<Domain> &domain) const;
+  inline typed::pw_aff<Anonymous> intersect_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_aff<Anonymous> intersect_domain(const typed::basic_set<> &set) const = delete;
+  inline typed::pw_aff<Anonymous> intersect_domain(const typed::point<> &set) const = delete;
+  inline typed::pw_aff<Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_aff<Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_aff<Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::set<Anonymous> le_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::set<Anonymous> le_set(const typed::aff<> &pwaff2) const = delete;
+  inline typed::pw_aff_list<Anonymous> list() const;
+  inline typed::set<Anonymous> lt_set(const typed::pw_aff<> &pwaff2) const = delete;
+  inline typed::set<Anonymous> lt_set(const typed::aff<> &pwaff2) const = delete;
+  inline typed::multi_pw_aff<Anonymous> max(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> max(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Anonymous> max(const typed::aff<Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<Anonymous> min(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> min(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Anonymous> min(const typed::aff<Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::pw_aff<Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::pw_aff<Anonymous> mod(long mod) const;
+  inline typed::pw_aff<Anonymous> neg() const;
+  inline typed::pw_multi_aff<Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Anonymous, Range>> product(const typed::multi_pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Anonymous, Range>> product(const typed::pw_multi_aff<Range> &pma2) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_aff<> &ma) const = delete;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_factor_range() const = delete;
+  inline typed::multi_pw_aff<Anonymous> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::pw_multi_aff<Anonymous> range_product(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::multi_pw_aff<Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<Anonymous> scale(long v) const;
+  inline typed::multi_pw_aff<Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<Anonymous> scale_down(const typed::val<Anonymous> &f) const;
+  inline typed::pw_aff<Anonymous> scale_down(long f) const;
+  inline typed::multi_pw_aff<Anonymous> set_at(int pos, const typed::pw_aff<Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Anonymous> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Anonymous> space() const;
+  inline typed::multi_pw_aff<Anonymous> sub(const typed::multi_pw_aff<Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Anonymous> sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::pw_aff<Anonymous> sub(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> sub(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> sub(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::pw_aff<Anonymous> sub(const typed::aff<Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Anonymous> subtract_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_aff<Anonymous> subtract_domain(const typed::basic_set<> &set) const = delete;
+  inline typed::pw_aff<Anonymous> subtract_domain(const typed::point<> &set) const = delete;
+  inline typed::multi_pw_aff<Anonymous> to_multi_pw_aff() const;
+  inline typed::union_pw_aff<Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Anonymous> to_union_pw_multi_aff() const;
+  template <typename Domain>
+  inline typed::multi_pw_aff<Domain, Anonymous> unbind_params_insert_domain(const typed::multi_id<Domain> &domain) const;
+  inline typed::multi_pw_aff<Anonymous> union_add(const typed::multi_pw_aff<Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<Anonymous> union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const;
+  inline typed::pw_aff<Anonymous> union_add(const typed::pw_aff<Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Anonymous> union_add(const typed::pw_multi_aff<Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Anonymous> union_add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::pw_aff<Anonymous> union_add(const typed::aff<Anonymous> &pwaff2) const;
+};
+
+template <typename Domain>
+struct pw_aff<Domain, Anonymous> : public isl::pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  pw_aff(const pw_aff<Arg1, Anonymous> &obj) : isl::pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_aff>{}, bool>::type = true>
+  pw_aff(const base &obj) : isl::pw_aff(obj) {}
+ public:
+  static pw_aff from(const isl::pw_aff &obj) {
+    return pw_aff(obj);
+  }
+  inline /* implicit */ pw_aff(const typed::aff<Domain, Anonymous> &aff);
+  inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain, Anonymous> add(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::pw_aff<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Domain, Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<Domain, Anonymous> add_constant(long v) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const;
+  inline typed::aff<Domain, Anonymous> as_aff() const;
+  inline typed::map<Domain, Anonymous> as_map() const;
+  inline typed::multi_aff<Domain, Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> as_pw_multi_aff() const;
+  inline typed::set<Domain, Anonymous> as_set() const = delete;
+  inline typed::union_map<Domain, Anonymous> as_union_map() const;
+  inline typed::pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::set<Domain> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::set<Domain> bind(const typed::id<Anonymous> &id) const;
+  inline typed::set<Domain> bind(const std::string &id) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::pw_aff<Domain, Anonymous> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_aff<Domain, Anonymous> coalesce() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::pw_aff<Domain, Anonymous> floor() const;
+  inline typed::set<Domain> ge_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::set<Domain> ge_set(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Domain, Anonymous> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::union_set<Domain> &context) const;
+  inline typed::pw_aff<Domain, Anonymous> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::pw_aff<Domain, Anonymous> gist(const typed::point<Domain> &context) const;
+  inline typed::set<Domain> gt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::set<Domain> gt_set(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> identity() const;
+  inline typed::pw_aff<Domain, Anonymous> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_aff<Domain, Anonymous> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_aff<Domain, Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::set<Domain> le_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::set<Domain> le_set(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::set<Domain> lt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::set<Domain> lt_set(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> max(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> max(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Domain, Anonymous> max(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Anonymous> min(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> min(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Domain, Anonymous> min(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::pw_aff<Domain, Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::pw_aff<Domain, Anonymous> mod(long mod) const;
+  inline typed::pw_aff<Domain, Anonymous> neg() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2>
+  inline typed::pw_aff<Domain2, Anonymous> pullback(const typed::multi_aff<Domain2, Domain> &ma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_aff<Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::pw_aff<Domain2, Anonymous> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::pw_aff<Domain2, Anonymous> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<Domain> &upma) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, Anonymous> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<Domain, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<Domain, Anonymous> scale(long v) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<Domain, Anonymous> scale_down(const typed::val<Anonymous> &f) const;
+  inline typed::pw_aff<Domain, Anonymous> scale_down(long f) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Anonymous> space() const;
+  inline typed::multi_pw_aff<Domain, Anonymous> sub(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::pw_aff<Domain, Anonymous> sub(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> sub(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::pw_aff<Domain, Anonymous> sub(const typed::aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<Domain, Anonymous> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_aff<Domain, Anonymous> subtract_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_aff<Domain, Anonymous> subtract_domain(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, Anonymous> to_multi_pw_aff() const;
+  inline typed::union_pw_aff<Domain, Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<Domain, Anonymous> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Anonymous> union_add(const typed::multi_pw_aff<Domain, Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const;
+  inline typed::pw_aff<Domain, Anonymous> union_add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<Domain, Anonymous> union_add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::pw_aff<Domain, Anonymous> union_add(const typed::aff<Domain, Anonymous> &pwaff2) const;
+};
+
+template <typename Domain2, typename Range2>
+struct pw_aff<pair<Domain2, Range2>, Anonymous> : public isl::pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain2, Arg1>{} &&
+              std::is_base_of<Range2, Arg2>{},
+            bool>::type = true>
+  pw_aff(const pw_aff<pair<Arg1, Arg2>, Anonymous> &obj) : isl::pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_aff>{}, bool>::type = true>
+  pw_aff(const base &obj) : isl::pw_aff(obj) {}
+ public:
+  static pw_aff from(const isl::pw_aff &obj) {
+    return pw_aff(obj);
+  }
+  inline /* implicit */ pw_aff(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff);
+  inline explicit pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> add(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> add_constant(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> add_constant(long v) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> add_constant(const typed::multi_val<Anonymous> &mv) const;
+  template <typename Arg1>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> apply(const typed::union_pw_multi_aff<Anonymous, Arg1> &upma2) const;
+  inline typed::aff<pair<Domain2, Range2>, Anonymous> as_aff() const;
+  inline typed::map<pair<Domain2, Range2>, Anonymous> as_map() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Anonymous> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain2, Range2>, Anonymous> as_set() const = delete;
+  inline typed::union_map<pair<Domain2, Range2>, Anonymous> as_union_map() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> at(int pos) const;
+  inline typed::set<pair<Domain2, Range2>> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::set<pair<Domain2, Range2>> bind(const typed::id<Anonymous> &id) const;
+  inline typed::set<pair<Domain2, Range2>> bind(const std::string &id) const;
+  inline typed::pw_aff<Anonymous> bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const;
+  inline typed::pw_aff<Range2, Anonymous> bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> coalesce() const;
+  inline typed::set<pair<Domain2, Range2>> domain() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> floor() const;
+  inline typed::set<pair<Domain2, Range2>> ge_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::set<pair<Domain2, Range2>> ge_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> gist(const typed::set<pair<Domain2, Range2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> gist(const typed::union_set<pair<Domain2, Range2>> &context) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> gist(const typed::basic_set<pair<Domain2, Range2>> &context) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> gist(const typed::point<pair<Domain2, Range2>> &context) const;
+  inline typed::set<pair<Domain2, Range2>> gt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::set<pair<Domain2, Range2>> gt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> identity() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_domain(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::set<pair<Domain2, Range2>> le_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::set<pair<Domain2, Range2>> le_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> list() const;
+  inline typed::set<pair<Domain2, Range2>> lt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::set<pair<Domain2, Range2>> lt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> max(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> max(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> max(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> min(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> min(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> min(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::multi_val<Anonymous> min_multi_val() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> mod(const typed::val<Anonymous> &mod) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> mod(long mod) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const;
+  template <typename Arg1, typename Arg2>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> product(const typed::multi_pw_aff<Arg1, Arg2> &multi2) const;
+  template <typename Arg1, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> product(const typed::pw_multi_aff<Arg1, Arg2> &pma2) const;
+  template <typename Arg1>
+  inline typed::pw_aff<Arg1, Anonymous> pullback(const typed::multi_aff<Arg1, pair<Domain2, Range2>> &ma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const;
+  template <typename Arg1>
+  inline typed::pw_aff<Arg1, Anonymous> pullback(const typed::multi_pw_aff<Arg1, pair<Domain2, Range2>> &mpa) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa) const;
+  template <typename Arg1>
+  inline typed::pw_aff<Arg1, Anonymous> pullback(const typed::pw_multi_aff<Arg1, pair<Domain2, Range2>> &pma) const;
+  inline typed::pw_aff<Anonymous> pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const;
+  template <typename Arg1>
+  inline typed::union_pw_aff<Arg1, Anonymous> pullback(const typed::union_pw_multi_aff<Arg1, pair<Domain2, Range2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> range_factor_range() const = delete;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const;
+  template <typename Arg1>
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> &pma2) const;
+  template <typename Arg1>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> &upma2) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> scale(long v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> scale_down(const typed::val<Anonymous> &f) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> scale_down(long f) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain2, Range2>, Anonymous> space() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> sub(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> subtract_domain(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> to_multi_pw_aff() const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> to_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &mupa2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const;
+  inline typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> union_add(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const;
+};
+
+template <>
+struct pw_aff_list<Anonymous> : public isl::pw_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_aff_list() = default;
+  pw_aff_list(const isl::pw_aff_list &obj) : isl::pw_aff_list(obj) {}
+  static pw_aff_list from(const isl::pw_aff_list &obj) {
+    return pw_aff_list(obj);
+  }
+  inline explicit pw_aff_list(const isl::ctx &ctx, int n);
+  inline explicit pw_aff_list(const typed::pw_aff<Anonymous> &el);
+  inline typed::pw_aff_list<Anonymous> add(const typed::pw_aff<Anonymous> &el) const;
+  inline typed::pw_aff_list<Anonymous> add(const typed::aff<Anonymous> &el) const;
+  inline typed::pw_aff<Anonymous> at(int index) const;
+  inline typed::pw_aff<Anonymous> get_at(int index) const = delete;
+  inline typed::pw_aff_list<Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::pw_aff<Anonymous>)> &fn) const;
+};
+
+template <typename Domain>
+struct pw_aff_list<Domain, Anonymous> : public isl::pw_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_aff_list() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  pw_aff_list(const pw_aff_list<Arg1, Anonymous> &obj) : isl::pw_aff_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_aff_list>{}, bool>::type = true>
+  pw_aff_list(const base &obj) : isl::pw_aff_list(obj) {}
+ public:
+  static pw_aff_list from(const isl::pw_aff_list &obj) {
+    return pw_aff_list(obj);
+  }
+  inline explicit pw_aff_list(const isl::ctx &ctx, int n);
+  inline explicit pw_aff_list(const typed::pw_aff<Domain, Anonymous> &el);
+  inline typed::pw_aff_list<Domain, Anonymous> add(const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::pw_aff_list<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::pw_aff<Domain, Anonymous> at(int index) const;
+  inline typed::pw_aff<Domain, Anonymous> get_at(int index) const = delete;
+  inline typed::pw_aff_list<Domain, Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::pw_aff<Domain, Anonymous>)> &fn) const;
+};
+
+template <typename Domain>
+struct pw_multi_aff<Domain> : public isl::pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  pw_multi_aff(const pw_multi_aff<Arg1> &obj) : isl::pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
+  pw_multi_aff(const base &obj) : isl::pw_multi_aff(obj) {}
+ public:
+  static pw_multi_aff from(const isl::pw_multi_aff &obj) {
+    return pw_multi_aff(obj);
+  }
+  inline /* implicit */ pw_multi_aff(const typed::multi_aff<Domain> &ma);
+  inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain> &pa);
+  inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain> add(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> add(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::pw_multi_aff<Domain> add(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::pw_multi_aff<Domain> add(const typed::multi_aff<Domain> &pma2) const;
+  inline typed::pw_multi_aff<Domain> add(const typed::pw_aff<Domain> &pma2) const;
+  inline typed::pw_multi_aff<Domain> add_constant(const typed::multi_val<Domain> &mv) const;
+  inline typed::pw_multi_aff<Domain> add_constant(const typed::val<Domain> &v) const;
+  inline typed::pw_multi_aff<Domain> add_constant(long v) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::map<Domain> as_map() const = delete;
+  inline typed::multi_aff<Domain> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::union_map<Domain> as_union_map() const = delete;
+  inline typed::pw_aff<Anonymous> at(int pos) const;
+  inline typed::pw_aff<Domain> get_at(int pos) const = delete;
+  inline typed::set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::pw_multi_aff<Domain> bind_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain> coalesce() const;
+  inline typed::set<> domain() const;
+  inline typed::pw_multi_aff<Domain> gist(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::union_set<> &context) const;
+  inline typed::pw_multi_aff<Domain> gist(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<Domain> gist(const typed::point<> &set) const;
+  inline typed::multi_pw_aff<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::pw_multi_aff<Domain> intersect_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_multi_aff<Domain> intersect_domain(const typed::basic_set<> &set) const = delete;
+  inline typed::pw_multi_aff<Domain> intersect_domain(const typed::point<> &set) const = delete;
+  inline typed::pw_multi_aff<Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_multi_aff<Domain> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<Domain> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<Anonymous> list() const;
+  inline typed::multi_pw_aff<Domain> max(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain> min(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_val<Domain> min_multi_val() const;
+  inline typed::multi_pw_aff<Domain> neg() const;
+  inline typed::pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::multi_aff<> &pma2) const = delete;
+  inline typed::pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::pw_aff<> &pma2) const = delete;
+  template <typename Range>
+  inline typed::multi_pw_aff<pair<Domain, Range>> product(const typed::multi_pw_aff<Range> &multi2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Domain, Range>> product(const typed::pw_multi_aff<Range> &pma2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Domain, Range>> product(const typed::multi_aff<Range> &pma2) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<pair<Domain, Range>> product(const typed::pw_aff<Range> &pma2) const;
+  inline typed::multi_pw_aff<Domain> pullback(const typed::multi_pw_aff<> &mpa2) const = delete;
+  inline typed::pw_multi_aff<Domain> pullback(const typed::multi_aff<> &ma) const = delete;
+  inline typed::pw_multi_aff<Domain> pullback(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain> range_factor_range() const = delete;
+  inline typed::multi_pw_aff<Domain> range_product(const typed::multi_pw_aff<> &multi2) const = delete;
+  inline typed::multi_union_pw_aff<Domain> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_product(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_product(const typed::multi_aff<> &pma2) const = delete;
+  inline typed::pw_multi_aff<Domain> range_product(const typed::pw_aff<> &pma2) const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<Domain> scale(const typed::multi_val<Domain> &mv) const;
+  inline typed::pw_multi_aff<Domain> scale(const typed::val<Domain> &v) const;
+  inline typed::pw_multi_aff<Domain> scale(long v) const;
+  inline typed::multi_pw_aff<Domain> scale_down(const typed::multi_val<Domain> &mv) const;
+  inline typed::pw_multi_aff<Domain> scale_down(const typed::val<Domain> &v) const;
+  inline typed::pw_multi_aff<Domain> scale_down(long v) const;
+  inline typed::multi_pw_aff<Domain> set_at(int pos, const typed::pw_aff<Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::multi_pw_aff<Domain> sub(const typed::multi_pw_aff<Domain> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain> sub(const typed::multi_union_pw_aff<Domain> &multi2) const;
+  inline typed::pw_multi_aff<Domain> sub(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::pw_multi_aff<Domain> sub(const typed::multi_aff<Domain> &pma2) const;
+  inline typed::pw_multi_aff<Domain> sub(const typed::pw_aff<Domain> &pma2) const;
+  inline typed::pw_multi_aff<Domain> subtract_domain(const typed::set<> &set) const = delete;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::pw_multi_aff<Domain> subtract_domain(const typed::basic_set<> &set) const = delete;
+  inline typed::pw_multi_aff<Domain> subtract_domain(const typed::point<> &set) const = delete;
+  inline typed::multi_pw_aff<Domain> to_multi_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain> to_union_pw_multi_aff() const;
+  template <typename Arg1>
+  inline typed::multi_pw_aff<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::multi_pw_aff<Domain> union_add(const typed::multi_pw_aff<Domain> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain> union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const;
+  inline typed::pw_multi_aff<Domain> union_add(const typed::pw_multi_aff<Domain> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::pw_multi_aff<Domain> union_add(const typed::multi_aff<Domain> &pma2) const;
+  inline typed::pw_multi_aff<Domain> union_add(const typed::pw_aff<Domain> &pma2) const;
+};
+
+template <typename Domain, typename Range>
+struct pw_multi_aff<Domain, Range> : public isl::pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  pw_multi_aff(const pw_multi_aff<Arg1, Arg2> &obj) : isl::pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
+  pw_multi_aff(const base &obj) : isl::pw_multi_aff(obj) {}
+ public:
+  static pw_multi_aff from(const isl::pw_multi_aff &obj) {
+    return pw_multi_aff(obj);
+  }
+  inline /* implicit */ pw_multi_aff(const typed::multi_aff<Domain, Range> &ma);
+  inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain, Range> &pa);
+  inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain, Range> add(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::pw_multi_aff<Domain, Range> add(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::pw_multi_aff<Domain, Range> add(const typed::multi_aff<Domain, Range> &pma2) const;
+  inline typed::pw_multi_aff<Domain, Range> add(const typed::pw_aff<Domain, Range> &pma2) const;
+  inline typed::pw_multi_aff<Domain, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<Domain, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<Domain, Range> add_constant(long v) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::multi_aff<Domain, Range> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> as_pw_multi_aff() const;
+  inline typed::set<Domain, Range> as_set() const = delete;
+  inline typed::union_map<Domain, Range> as_union_map() const;
+  inline typed::pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::pw_aff<Domain, Range> get_at(int pos) const = delete;
+  inline typed::set<Domain> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::pw_multi_aff<Range> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::pw_multi_aff<Domain, Range> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> coalesce() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::pw_multi_aff<Domain, Range> gist(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::union_set<Domain> &context) const;
+  inline typed::pw_multi_aff<Domain, Range> gist(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> gist(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> identity() const;
+  inline typed::pw_multi_aff<Domain, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::multi_pw_aff<Domain, Range> max(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Range> min(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_pw_aff<Domain, Range> neg() const;
+  inline typed::pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::multi_aff<> &pma2) const = delete;
+  inline typed::pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::pw_aff<> &pma2) const = delete;
+  template <typename Domain2, typename Range2>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::multi_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::pw_aff<Domain2, Range2> &pma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, Range> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<Domain> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, Range> pullback(const typed::multi_aff<Domain2, Domain> &ma) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::multi_aff<Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, Range> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::pw_multi_aff<Domain> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_aff<Domain, Range2> &pma2) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_aff<Domain, Range2> &pma2) const;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<Domain, Range> scale(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<Domain, Range> scale(long v) const;
+  inline typed::multi_pw_aff<Domain, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<Domain, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<Domain, Range> scale_down(long v) const;
+  inline typed::multi_pw_aff<Domain, Range> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, Range> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::pw_multi_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> sub(const typed::multi_pw_aff<Domain, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const;
+  inline typed::pw_multi_aff<Domain, Range> sub(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::pw_multi_aff<Domain, Range> sub(const typed::multi_aff<Domain, Range> &pma2) const;
+  inline typed::pw_multi_aff<Domain, Range> sub(const typed::pw_aff<Domain, Range> &pma2) const;
+  inline typed::pw_multi_aff<Domain, Range> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, Range> subtract_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, Range> subtract_domain(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, Range> to_multi_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Range> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<Domain, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const;
+  inline typed::pw_multi_aff<Domain, Range> union_add(const typed::pw_multi_aff<Domain, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::pw_multi_aff<Domain, Range> union_add(const typed::multi_aff<Domain, Range> &pma2) const;
+  inline typed::pw_multi_aff<Domain, Range> union_add(const typed::pw_aff<Domain, Range> &pma2) const;
+};
+
+template <typename Domain2, typename Range2, typename Range>
+struct pw_multi_aff<pair<Domain2, Range2>, Range> : public isl::pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain2, Arg1>{} &&
+              std::is_base_of<Range2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{},
+            bool>::type = true>
+  pw_multi_aff(const pw_multi_aff<pair<Arg1, Arg2>, Arg3> &obj) : isl::pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
+  pw_multi_aff(const base &obj) : isl::pw_multi_aff(obj) {}
+ public:
+  static pw_multi_aff from(const isl::pw_multi_aff &obj) {
+    return pw_multi_aff(obj);
+  }
+  inline /* implicit */ pw_multi_aff(const typed::multi_aff<pair<Domain2, Range2>, Range> &ma);
+  inline /* implicit */ pw_multi_aff(const typed::pw_aff<pair<Domain2, Range2>, Range> &pa);
+  inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add_constant(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add_constant(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> add_constant(long v) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> apply(const typed::union_pw_multi_aff<Range, Arg2> &upma2) const;
+  inline typed::map<pair<Domain2, Range2>, Range> as_map() const;
+  inline typed::multi_aff<pair<Domain2, Range2>, Range> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain2, Range2>, Range> as_set() const = delete;
+  inline typed::union_map<pair<Domain2, Range2>, Range> as_union_map() const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Anonymous> at(int pos) const;
+  inline typed::pw_aff<pair<Domain2, Range2>, Range> get_at(int pos) const = delete;
+  inline typed::set<pair<Domain2, Range2>> bind(const typed::multi_id<Range> &tuple) const;
+  inline typed::pw_multi_aff<Range> bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const;
+  inline typed::pw_multi_aff<Range2, Range> bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> coalesce() const;
+  inline typed::set<pair<Domain2, Range2>> domain() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> gist(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> gist(const typed::union_set<pair<Domain2, Range2>> &context) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> gist(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> gist(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> identity() const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_domain(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> list() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_val<Range> min_multi_val() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, Domain2> &pma2) const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, Range2>, Range> preimage_domain_wrapped_domain(const typed::pw_aff<Domain3, Domain2> &pma2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::pw_multi_aff<Arg2, Arg3> &pma2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::multi_aff<Arg2, Arg3> &pma2) const;
+  template <typename Arg2, typename Arg3>
+  inline typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> product(const typed::pw_aff<Arg2, Arg3> &pma2) const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<Arg2, Range> pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const;
+  inline typed::multi_pw_aff<Range> pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<Arg2, Range> pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<Arg2, Range> pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Range> pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<Arg2, Range> pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> range_factor_domain() const = delete;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> range_factor_range() const = delete;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> range_product(const typed::pw_aff<pair<Domain2, Range2>, Arg2> &pma2) const;
+  inline typed::id<pair<Domain2, Range2>, Range> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> scale(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> scale(long v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> scale_down(const typed::multi_val<Range> &mv) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> scale_down(const typed::val<Range> &v) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> scale_down(long v) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg1>
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain2, Range2>, Range> space() const;
+  inline typed::space<pair<Domain2, Range2>, Range> get_space() const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> sub(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> subtract_domain(const typed::point<pair<Domain2, Range2>> &set) const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> to_multi_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const;
+  inline typed::pw_multi_aff<pair<Domain2, Range2>, Range> union_add(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct pw_multi_aff<Domain, pair<Range, Range2>> : public isl::pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  pw_multi_aff(const pw_multi_aff<Arg1, pair<Arg2, Arg3>> &obj) : isl::pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
+  pw_multi_aff(const base &obj) : isl::pw_multi_aff(obj) {}
+ public:
+  static pw_multi_aff from(const isl::pw_multi_aff &obj) {
+    return pw_multi_aff(obj);
+  }
+  inline /* implicit */ pw_multi_aff(const typed::multi_aff<Domain, pair<Range, Range2>> &ma);
+  inline /* implicit */ pw_multi_aff(const typed::pw_aff<Domain, pair<Range, Range2>> &pa);
+  inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add_constant(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> add_constant(long v) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  inline typed::map<Domain, pair<Range, Range2>> as_map() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::set<Domain, pair<Range, Range2>> as_set() const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> as_union_map() const;
+  inline typed::pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::pw_aff<Domain, pair<Range, Range2>> get_at(int pos) const = delete;
+  inline typed::set<Domain> bind(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> bind_domain(const typed::multi_id<Domain> &tuple) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> bind_domain_wrapped_domain(const typed::multi_id<> &tuple) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::set<Domain> domain() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::union_set<Domain> &context) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> identity() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::point<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> max(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> max_multi_val() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> min(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> min_multi_val() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> neg() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &pma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::multi_aff<> &pma2) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_aff<> &pma2) const = delete;
+  template <typename Domain2, typename Arg3>
+  inline typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::multi_pw_aff<Domain2, Arg3> &multi2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::pw_multi_aff<Domain2, Arg3> &pma2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::multi_aff<Domain2, Arg3> &pma2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::pw_aff<Domain2, Arg3> &pma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, Domain> &ma) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::pw_multi_aff<Domain, Range> range_factor_domain() const;
+  inline typed::pw_multi_aff<Domain, Range2> range_factor_range() const;
+  template <typename Arg3>
+  inline typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_pw_aff<Domain, Arg3> &multi2) const;
+  template <typename Arg3>
+  inline typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_union_pw_aff<Domain, Arg3> &multi2) const;
+  template <typename Arg3>
+  inline typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::pw_multi_aff<Domain, Arg3> &pma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_aff<Domain, Arg3> &pma2) const;
+  template <typename Arg3>
+  inline typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::pw_aff<Domain, Arg3> &pma2) const;
+  inline typed::id<Domain, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> scale(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> scale(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> scale(long v) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> scale_down(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> scale_down(long v) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> space() const;
+  inline typed::space<Domain, pair<Range, Range2>> get_space() const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> sub(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> sub(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::set<Domain> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::basic_set<Domain> &set) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::point<Domain> &set) const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> to_multi_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &mpa2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &mupa2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> : public isl::pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  pw_multi_aff(const pw_multi_aff<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff>{}, bool>::type = true>
+  pw_multi_aff(const base &obj) : isl::pw_multi_aff(obj) {}
+ public:
+  static pw_multi_aff from(const isl::pw_multi_aff &obj) {
+    return pw_multi_aff(obj);
+  }
+  inline /* implicit */ pw_multi_aff(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &ma);
+  inline /* implicit */ pw_multi_aff(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pa);
+  inline explicit pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add_constant(long v) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> as_map() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_aff() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::set<pair<T1, T2>, pair<Range, Range2>> as_set() const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> as_union_map() const;
+  inline typed::pw_aff<pair<T1, T2>, Anonymous> at(int pos) const;
+  inline typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> get_at(int pos) const = delete;
+  inline typed::set<pair<T1, T2>> bind(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::pw_multi_aff<T2, pair<Range, Range2>> bind_domain_wrapped_domain(const typed::multi_id<T1> &tuple) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::set<pair<T1, T2>> domain() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_set<pair<T1, T2>> &context) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::point<pair<T1, T2>> &set) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> identity() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::point<pair<T1, T2>> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  inline typed::pw_aff_list<pair<T1, T2>, Anonymous> list() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> max(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> max_multi_val() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> min(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_val<pair<Range, Range2>> min_multi_val() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> neg() const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &pma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, T1> &pma2) const;
+  template <typename Domain3>
+  inline typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_aff<Domain3, T1> &pma2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::multi_pw_aff<Domain2, Arg2> &multi2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::pw_multi_aff<Domain2, Arg2> &pma2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::multi_aff<Domain2, Arg2> &pma2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::pw_aff<Domain2, Arg2> &pma2) const;
+  template <typename Domain2>
+  inline typed::multi_pw_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa2) const;
+  inline typed::multi_pw_aff<pair<Range, Range2>> pullback(const typed::multi_pw_aff<pair<T1, T2>> &mpa2) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<pair<T1, T2>> &pma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, Range2> range_factor_range() const;
+  template <typename Arg2>
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_pw_aff<pair<T1, T2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_union_pw_aff<pair<T1, T2>, Arg2> &multi2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &pma2) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::pw_aff<pair<T1, T2>, Arg2> &pma2) const;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> scale(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> scale(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> scale(long v) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(const typed::val<pair<Range, Range2>> &v) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> scale_down(long v) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> set_at(int pos, const typed::pw_aff<pair<T1, T2>, Anonymous> &el) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> set_at(int pos, const typed::union_pw_aff<pair<T1, T2>, Anonymous> &el) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> space() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> get_space() const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::set<pair<T1, T2>> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::basic_set<pair<T1, T2>> &set) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::point<pair<T1, T2>> &set) const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> to_multi_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> to_union_pw_multi_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mpa2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mupa2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const;
+};
+
+template <typename Domain>
+struct pw_multi_aff_list<Domain> : public isl::pw_multi_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff_list() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  pw_multi_aff_list(const pw_multi_aff_list<Arg1> &obj) : isl::pw_multi_aff_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff_list>{}, bool>::type = true>
+  pw_multi_aff_list(const base &obj) : isl::pw_multi_aff_list(obj) {}
+ public:
+  static pw_multi_aff_list from(const isl::pw_multi_aff_list &obj) {
+    return pw_multi_aff_list(obj);
+  }
+  inline explicit pw_multi_aff_list(const isl::ctx &ctx, int n);
+  inline explicit pw_multi_aff_list(const typed::pw_multi_aff<Domain> &el);
+  inline typed::pw_multi_aff_list<Domain> add(const typed::pw_multi_aff<Domain> &el) const;
+  inline typed::pw_multi_aff_list<Domain> add(const typed::multi_aff<Domain> &el) const;
+  inline typed::pw_multi_aff_list<Domain> add(const typed::pw_aff<Domain> &el) const;
+  inline typed::pw_multi_aff<Domain> at(int index) const;
+  inline typed::pw_multi_aff<Domain> get_at(int index) const = delete;
+  inline typed::pw_multi_aff_list<Domain> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::pw_multi_aff<Domain>)> &fn) const;
+};
+
+template <typename Domain, typename Range>
+struct pw_multi_aff_list<Domain, Range> : public isl::pw_multi_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  pw_multi_aff_list() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  pw_multi_aff_list(const pw_multi_aff_list<Arg1, Arg2> &obj) : isl::pw_multi_aff_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::pw_multi_aff_list>{}, bool>::type = true>
+  pw_multi_aff_list(const base &obj) : isl::pw_multi_aff_list(obj) {}
+ public:
+  static pw_multi_aff_list from(const isl::pw_multi_aff_list &obj) {
+    return pw_multi_aff_list(obj);
+  }
+  inline explicit pw_multi_aff_list(const isl::ctx &ctx, int n);
+  inline explicit pw_multi_aff_list(const typed::pw_multi_aff<Domain, Range> &el);
+  inline typed::pw_multi_aff_list<Domain, Range> add(const typed::pw_multi_aff<Domain, Range> &el) const;
+  inline typed::pw_multi_aff_list<Domain, Range> add(const typed::multi_aff<Domain, Range> &el) const;
+  inline typed::pw_multi_aff_list<Domain, Range> add(const typed::pw_aff<Domain, Range> &el) const;
+  inline typed::pw_multi_aff<Domain, Range> at(int index) const;
+  inline typed::pw_multi_aff<Domain, Range> get_at(int index) const = delete;
+  inline typed::pw_multi_aff_list<Domain, Range> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::pw_multi_aff<Domain, Range>)> &fn) const;
+};
+
+template <>
+struct set<> : public isl::set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  set() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::set>{}, bool>::type = true>
+  set(const base &obj) : isl::set(obj) {}
+ public:
+  static set from(const isl::set &obj) {
+    return set(obj);
+  }
+  inline /* implicit */ set(const typed::basic_set<> &bset);
+  inline /* implicit */ set(const typed::point<> &pnt);
+  inline explicit set(const isl::ctx &ctx, const std::string &str);
+  inline typed::set<> apply(const typed::map<> &map) const = delete;
+  inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
+  inline typed::set<> apply(const typed::basic_map<> &map) const = delete;
+  inline typed::pw_multi_aff<> as_pw_multi_aff() const = delete;
+  inline typed::set<> as_set() const = delete;
+  inline typed::set<> bind(const typed::multi_id<> &tuple) const = delete;
+  inline typed::set<> coalesce() const;
+  inline typed::set<> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
+  inline typed::set<> gist(const typed::set<> &context) const;
+  inline typed::union_set<> gist(const typed::union_set<> &context) const;
+  inline typed::set<> gist(const typed::basic_set<> &context) const;
+  inline typed::set<> gist(const typed::point<> &context) const;
+  inline typed::map<> identity() const = delete;
+  inline typed::map<> insert_domain(const typed::space<> &domain) const = delete;
+  inline typed::set<> intersect(const typed::set<> &set2) const;
+  inline typed::union_set<> intersect(const typed::union_set<> &uset2) const;
+  inline typed::set<> intersect(const typed::basic_set<> &set2) const;
+  inline typed::set<> intersect(const typed::point<> &set2) const;
+  inline typed::set<> intersect_params(const typed::set<> &params) const = delete;
+  inline typed::set<> intersect_params(const typed::basic_set<> &params) const = delete;
+  inline typed::set<> intersect_params(const typed::point<> &params) const = delete;
+  inline typed::set<> lexmax() const = delete;
+  inline typed::pw_multi_aff<> lexmax_pw_multi_aff() const = delete;
+  inline typed::set<> lexmin() const = delete;
+  inline typed::pw_multi_aff<> lexmin_pw_multi_aff() const = delete;
+  inline typed::set<> lower_bound(const typed::multi_pw_aff<> &lower) const = delete;
+  inline typed::set<> lower_bound(const typed::multi_val<> &lower) const = delete;
+  inline typed::multi_pw_aff<> max_multi_pw_aff() const = delete;
+  inline typed::val<> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<> min_multi_pw_aff() const = delete;
+  inline typed::val<> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::set<> params() const = delete;
+  inline typed::multi_val<> plain_multi_val_if_fixed() const = delete;
+  inline typed::multi_val<> get_plain_multi_val_if_fixed() const = delete;
+  inline typed::set<> preimage(const typed::multi_aff<> &ma) const = delete;
+  inline typed::set<> preimage(const typed::multi_pw_aff<> &mpa) const = delete;
+  inline typed::set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::set<> product(const typed::set<> &set2) const = delete;
+  inline typed::set<> product(const typed::basic_set<> &set2) const = delete;
+  inline typed::set<> product(const typed::point<> &set2) const = delete;
+  inline typed::set<> project_out_all_params() const;
+  inline typed::set<> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<> project_out_param(const std::string &id) const;
+  inline typed::set<> project_out_param(const typed::id_list<Anonymous> &list) const;
+  inline typed::pw_multi_aff<> pw_multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::fixed_box<> simple_fixed_box_hull() const = delete;
+  inline typed::fixed_box<> get_simple_fixed_box_hull() const = delete;
+  inline typed::space<> space() const;
+  inline typed::space<> get_space() const = delete;
+  inline typed::val<> get_stride(int pos) const = delete;
+  inline typed::set<> subtract(const typed::set<> &set2) const;
+  inline typed::union_set<> subtract(const typed::union_set<> &uset2) const;
+  inline typed::set<> subtract(const typed::basic_set<> &set2) const;
+  inline typed::set<> subtract(const typed::point<> &set2) const;
+  inline typed::union_set<> to_union_set() const;
+  inline typed::map<> translation() const = delete;
+  template <typename Domain>
+  inline typed::set<Domain> unbind_params(const typed::multi_id<Domain> &tuple) const;
+  inline typed::map<> unbind_params_insert_domain(const typed::multi_id<> &domain) const = delete;
+  inline typed::set<> unite(const typed::set<> &set2) const;
+  inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
+  inline typed::set<> unite(const typed::basic_set<> &set2) const;
+  inline typed::set<> unite(const typed::point<> &set2) const;
+  static inline typed::set<> universe(const typed::space<> &space);
+  inline typed::map<> unwrap() const = delete;
+  inline typed::set<> upper_bound(const typed::multi_pw_aff<> &upper) const = delete;
+  inline typed::set<> upper_bound(const typed::multi_val<> &upper) const = delete;
+};
+
+template <typename Domain>
+struct set<Domain> : public isl::set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  set() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  set(const set<Arg1> &obj) : isl::set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::set>{}, bool>::type = true>
+  set(const base &obj) : isl::set(obj) {}
+ public:
+  static set from(const isl::set &obj) {
+    return set(obj);
+  }
+  inline /* implicit */ set(const typed::basic_set<Domain> &bset);
+  inline /* implicit */ set(const typed::point<Domain> &pnt);
+  inline explicit set(const isl::ctx &ctx, const std::string &str);
+  template <typename Range>
+  inline typed::set<Range> apply(const typed::map<Domain, Range> &map) const;
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::union_map<Domain, Range> &umap) const;
+  template <typename Range>
+  inline typed::set<Range> apply(const typed::basic_map<Domain, Range> &map) const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<Domain> &tuple) const;
+  inline typed::set<Domain> coalesce() const;
+  inline typed::set<Domain> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
+  inline typed::set<Domain> gist(const typed::set<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::union_set<Domain> &context) const;
+  inline typed::set<Domain> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::set<Domain> gist(const typed::point<Domain> &context) const;
+  inline typed::map<Domain, Domain> identity() const;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> insert_domain(const typed::space<Arg1> &domain) const;
+  inline typed::set<Domain> intersect(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> intersect(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> intersect(const typed::basic_set<Domain> &set2) const;
+  inline typed::set<Domain> intersect(const typed::point<Domain> &set2) const;
+  inline typed::set<Domain> intersect_params(const typed::set<> &params) const;
+  inline typed::set<Domain> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::set<Domain> intersect_params(const typed::point<> &params) const;
+  inline typed::set<Domain> lexmax() const;
+  inline typed::pw_multi_aff<Domain> lexmax_pw_multi_aff() const;
+  inline typed::set<Domain> lexmin() const;
+  inline typed::pw_multi_aff<Domain> lexmin_pw_multi_aff() const;
+  inline typed::set<Domain> lower_bound(const typed::multi_pw_aff<Domain> &lower) const;
+  inline typed::set<Domain> lower_bound(const typed::multi_val<Domain> &lower) const;
+  inline typed::multi_pw_aff<Domain> max_multi_pw_aff() const;
+  inline typed::val<Domain> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<Domain> min_multi_pw_aff() const;
+  inline typed::val<Domain> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::set<> params() const;
+  inline typed::multi_val<Domain> plain_multi_val_if_fixed() const;
+  inline typed::multi_val<Domain> get_plain_multi_val_if_fixed() const = delete;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range>
+  inline typed::set<pair<Domain, Range>> product(const typed::set<Range> &set2) const;
+  template <typename Range>
+  inline typed::set<pair<Domain, Range>> product(const typed::basic_set<Range> &set2) const;
+  template <typename Range>
+  inline typed::set<pair<Domain, Range>> product(const typed::point<Range> &set2) const;
+  inline typed::set<Domain> project_out_all_params() const;
+  inline typed::set<Domain> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<Domain> project_out_param(const std::string &id) const;
+  inline typed::set<Domain> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Range>
+  inline typed::pw_multi_aff<Domain, Range> pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const;
+  inline typed::fixed_box<Domain> simple_fixed_box_hull() const;
+  inline typed::fixed_box<Domain> get_simple_fixed_box_hull() const = delete;
+  inline typed::space<Domain> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::val<Domain> get_stride(int pos) const = delete;
+  inline typed::set<Domain> subtract(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> subtract(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> subtract(const typed::basic_set<Domain> &set2) const;
+  inline typed::set<Domain> subtract(const typed::point<Domain> &set2) const;
+  inline typed::union_set<Domain> to_union_set() const;
+  inline typed::map<Domain, Domain> translation() const;
+  inline typed::set<Domain> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg1>
+  inline typed::map<Arg1, Domain> unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const;
+  inline typed::set<Domain> unite(const typed::set<Domain> &set2) const;
+  inline typed::union_set<Domain> unite(const typed::union_set<Domain> &uset2) const;
+  inline typed::set<Domain> unite(const typed::basic_set<Domain> &set2) const;
+  inline typed::set<Domain> unite(const typed::point<Domain> &set2) const;
+  static inline typed::set<Domain> universe(const typed::space<Domain> &space);
+  inline typed::map<Domain> unwrap() const = delete;
+  inline typed::set<Domain> upper_bound(const typed::multi_pw_aff<Domain> &upper) const;
+  inline typed::set<Domain> upper_bound(const typed::multi_val<Domain> &upper) const;
+};
+
+template <typename Domain, typename Range>
+struct set<pair<Domain, Range>> : public isl::set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  set() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  set(const set<pair<Arg1, Arg2>> &obj) : isl::set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::set>{}, bool>::type = true>
+  set(const base &obj) : isl::set(obj) {}
+ public:
+  static set from(const isl::set &obj) {
+    return set(obj);
+  }
+  inline /* implicit */ set(const typed::basic_set<pair<Domain, Range>> &bset);
+  inline /* implicit */ set(const typed::point<pair<Domain, Range>> &pnt);
+  inline explicit set(const isl::ctx &ctx, const std::string &str);
+  template <typename Arg2>
+  inline typed::set<Arg2> apply(const typed::map<pair<Domain, Range>, Arg2> &map) const;
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const;
+  template <typename Arg2>
+  inline typed::set<Arg2> apply(const typed::basic_map<pair<Domain, Range>, Arg2> &map) const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> as_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> as_set() const;
+  inline typed::set<> bind(const typed::multi_id<pair<Domain, Range>> &tuple) const;
+  inline typed::set<pair<Domain, Range>> coalesce() const;
+  inline typed::set<pair<Domain, Range>> detect_equalities() const;
+  inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
+  inline void foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
+  inline typed::set<pair<Domain, Range>> gist(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::union_set<pair<Domain, Range>> &context) const;
+  inline typed::set<pair<Domain, Range>> gist(const typed::basic_set<pair<Domain, Range>> &context) const;
+  inline typed::set<pair<Domain, Range>> gist(const typed::point<pair<Domain, Range>> &context) const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> identity() const;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> insert_domain(const typed::space<Arg2> &domain) const;
+  inline typed::set<pair<Domain, Range>> intersect(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> intersect(const typed::basic_set<pair<Domain, Range>> &set2) const;
+  inline typed::set<pair<Domain, Range>> intersect(const typed::point<pair<Domain, Range>> &set2) const;
+  inline typed::set<pair<Domain, Range>> intersect_params(const typed::set<> &params) const;
+  inline typed::set<pair<Domain, Range>> intersect_params(const typed::basic_set<> &params) const;
+  inline typed::set<pair<Domain, Range>> intersect_params(const typed::point<> &params) const;
+  inline typed::set<pair<Domain, Range>> lexmax() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmax_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lexmin() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>> lexmin_pw_multi_aff() const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const;
+  inline typed::set<pair<Domain, Range>> lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>> max_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> max_val(const typed::aff<> &obj) const = delete;
+  inline typed::multi_pw_aff<pair<Domain, Range>> min_multi_pw_aff() const;
+  inline typed::val<pair<Domain, Range>> min_val(const typed::aff<> &obj) const = delete;
+  inline typed::set<> params() const;
+  inline typed::multi_val<pair<Domain, Range>> plain_multi_val_if_fixed() const;
+  inline typed::multi_val<pair<Domain, Range>> get_plain_multi_val_if_fixed() const = delete;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::set<Domain2> preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg2>
+  inline typed::set<pair<pair<Domain, Range>, Arg2>> product(const typed::set<Arg2> &set2) const;
+  template <typename Arg2>
+  inline typed::set<pair<pair<Domain, Range>, Arg2>> product(const typed::basic_set<Arg2> &set2) const;
+  template <typename Arg2>
+  inline typed::set<pair<pair<Domain, Range>, Arg2>> product(const typed::point<Arg2> &set2) const;
+  inline typed::set<pair<Domain, Range>> project_out_all_params() const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id<Anonymous> &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const std::string &id) const;
+  inline typed::set<pair<Domain, Range>> project_out_param(const typed::id_list<Anonymous> &list) const;
+  template <typename Arg2>
+  inline typed::pw_multi_aff<pair<Domain, Range>, Arg2> pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const;
+  inline typed::fixed_box<pair<Domain, Range>> simple_fixed_box_hull() const;
+  inline typed::fixed_box<pair<Domain, Range>> get_simple_fixed_box_hull() const = delete;
+  inline typed::space<pair<Domain, Range>> space() const;
+  inline typed::space<pair<Domain, Range>> get_space() const = delete;
+  inline typed::val<pair<Domain, Range>> get_stride(int pos) const = delete;
+  inline typed::set<pair<Domain, Range>> subtract(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> subtract(const typed::basic_set<pair<Domain, Range>> &set2) const;
+  inline typed::set<pair<Domain, Range>> subtract(const typed::point<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> to_union_set() const;
+  inline typed::map<pair<Domain, Range>, pair<Domain, Range>> translation() const;
+  inline typed::set<pair<Domain, Range>> unbind_params(const typed::multi_id<> &tuple) const = delete;
+  template <typename Arg2>
+  inline typed::map<Arg2, pair<Domain, Range>> unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::set<pair<Domain, Range>> &set2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::basic_set<pair<Domain, Range>> &set2) const;
+  inline typed::set<pair<Domain, Range>> unite(const typed::point<pair<Domain, Range>> &set2) const;
+  static inline typed::set<pair<Domain, Range>> universe(const typed::space<pair<Domain, Range>> &space);
+  inline typed::map<Domain, Range> unwrap() const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const;
+  inline typed::set<pair<Domain, Range>> upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const;
+};
+
+template <>
+struct space<> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  template <typename Domain>
+  inline typed::space<Domain> add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const;
+  template <typename Domain>
+  inline typed::space<Domain> add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  template <typename Domain>
+  inline typed::space<Domain> add_unnamed_tuple(unsigned int dim) const;
+  inline typed::space<> curry() const = delete;
+  inline typed::space<> domain() const = delete;
+  inline typed::multi_aff<> domain_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<> domain_map_pw_multi_aff() const = delete;
+  inline typed::id<> get_domain_tuple_id() const = delete;
+  inline typed::space<> flatten_domain() const = delete;
+  inline typed::space<> flatten_range() const = delete;
+  inline typed::multi_aff<> identity_multi_aff_on_domain() const = delete;
+  inline typed::multi_pw_aff<> identity_multi_pw_aff_on_domain() const = delete;
+  inline typed::pw_multi_aff<> identity_pw_multi_aff_on_domain() const = delete;
+  inline typed::space<> map_from_set() const = delete;
+  inline typed::multi_aff<> multi_aff(const typed::aff_list<> &list) const = delete;
+  inline typed::multi_aff<> multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::multi_id<> multi_id(const typed::id_list<> &list) const = delete;
+  inline typed::multi_pw_aff<> multi_pw_aff(const typed::pw_aff_list<> &list) const = delete;
+  inline typed::multi_union_pw_aff<> multi_union_pw_aff(const typed::union_pw_aff_list<> &list) const = delete;
+  inline typed::multi_val<> multi_val(const typed::val_list<> &list) const = delete;
+  inline typed::space<> params() const = delete;
+  inline typed::space<> product(const typed::space<> &right) const = delete;
+  inline typed::space<> range() const = delete;
+  inline typed::multi_aff<> range_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<> range_map_pw_multi_aff() const = delete;
+  inline typed::space<> range_reverse() const = delete;
+  inline typed::id<> get_range_tuple_id() const = delete;
+  inline typed::space<> reverse() const = delete;
+  inline typed::space<> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::space<> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<> uncurry() const = delete;
+  static inline typed::space<> unit(const isl::ctx &ctx);
+  inline typed::map<> universe_map() const = delete;
+  inline typed::set<> universe_set() const;
+  inline typed::space<> unwrap() const = delete;
+  inline typed::space<> wrap() const = delete;
+  inline typed::aff<> zero_aff_on_domain() const = delete;
+  inline typed::multi_aff<> zero_multi_aff() const = delete;
+  inline typed::multi_pw_aff<> zero_multi_pw_aff() const = delete;
+  inline typed::multi_union_pw_aff<> zero_multi_union_pw_aff() const = delete;
+  inline typed::multi_val<> zero_multi_val() const = delete;
+};
+
+template <typename Domain>
+struct space<Domain> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  space(const space<Arg1> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  template <typename Range>
+  inline typed::space<Domain, Range> add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const;
+  template <typename Range>
+  inline typed::space<Domain, Range> add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  template <typename Range>
+  inline typed::space<Domain, Range> add_unnamed_tuple(unsigned int dim) const;
+  inline typed::space<Domain> curry() const = delete;
+  inline typed::space<> domain() const;
+  inline typed::multi_aff<Domain> domain_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<Domain> domain_map_pw_multi_aff() const = delete;
+  inline typed::id<Domain> get_domain_tuple_id() const = delete;
+  inline typed::space<Domain> flatten_domain() const = delete;
+  inline typed::space<Domain> flatten_range() const = delete;
+  inline typed::multi_aff<Domain, Domain> identity_multi_aff_on_domain() const;
+  inline typed::multi_pw_aff<Domain, Domain> identity_multi_pw_aff_on_domain() const;
+  inline typed::pw_multi_aff<Domain, Domain> identity_pw_multi_aff_on_domain() const;
+  inline typed::space<Domain, Domain> map_from_set() const;
+  inline typed::multi_aff<Domain> multi_aff(const typed::aff_list<Anonymous> &list) const;
+  template <typename Range>
+  inline typed::multi_aff<Domain, Range> multi_aff_on_domain(const typed::multi_val<Range> &mv) const;
+  inline typed::multi_id<Domain> multi_id(const typed::id_list<Anonymous> &list) const;
+  inline typed::multi_pw_aff<Domain> multi_pw_aff(const typed::pw_aff_list<Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<Domain> multi_union_pw_aff(const typed::union_pw_aff_list<Anonymous> &list) const;
+  inline typed::multi_val<Domain> multi_val(const typed::val_list<Anonymous> &list) const;
+  inline typed::space<> params() const;
+  template <typename Range>
+  inline typed::space<pair<Domain, Range>> product(const typed::space<Range> &right) const;
+  inline typed::space<Domain> range() const = delete;
+  inline typed::multi_aff<Domain> range_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<Domain> range_map_pw_multi_aff() const = delete;
+  inline typed::space<Domain> range_reverse() const = delete;
+  inline typed::id<Domain> get_range_tuple_id() const = delete;
+  inline typed::space<Domain> reverse() const = delete;
+  inline typed::space<Domain> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<Domain> set_domain_tuple(const std::string &id) const = delete;
+  template <typename Domain2>
+  inline typed::space<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::space<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain> uncurry() const = delete;
+  static inline typed::space<Domain> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<Domain> universe_map() const = delete;
+  inline typed::set<Domain> universe_set() const;
+  inline typed::space<Domain> unwrap() const = delete;
+  inline typed::space<Domain> wrap() const = delete;
+  inline typed::aff<Domain, Anonymous> zero_aff_on_domain() const;
+  inline typed::multi_aff<Domain> zero_multi_aff() const;
+  inline typed::multi_pw_aff<Domain> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<Domain> zero_multi_val() const;
+};
+
+template <typename Domain, typename Range>
+struct space<Domain, Range> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  space(const space<Arg1, Arg2> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  inline typed::space<Domain, Range> add_named_tuple(const typed::id<> &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<Domain, Range> add_named_tuple(const std::string &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<Domain, Range> add_unnamed_tuple(unsigned int dim) const = delete;
+  inline typed::space<Domain, Range> curry() const = delete;
+  inline typed::space<Domain> domain() const;
+  inline typed::multi_aff<pair<Domain, Range>, Domain> domain_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Domain> domain_map_pw_multi_aff() const;
+  inline typed::id<Domain, Range> get_domain_tuple_id() const = delete;
+  inline typed::space<Domain, Range> flatten_domain() const = delete;
+  inline typed::space<Domain, Range> flatten_range() const = delete;
+  inline typed::multi_aff<Domain, Range> identity_multi_aff_on_domain() const = delete;
+  inline typed::multi_pw_aff<Domain, Range> identity_multi_pw_aff_on_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, Range> identity_pw_multi_aff_on_domain() const = delete;
+  inline typed::space<Domain, Range> map_from_set() const = delete;
+  inline typed::multi_aff<Domain, Range> multi_aff(const typed::aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_aff<Domain, Range> multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::multi_id<Domain, Range> multi_id(const typed::id_list<> &list) const = delete;
+  inline typed::multi_pw_aff<Domain, Range> multi_pw_aff(const typed::pw_aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<Domain, Range> multi_union_pw_aff(const typed::union_pw_aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_val<Domain, Range> multi_val(const typed::val_list<> &list) const = delete;
+  inline typed::space<> params() const;
+  template <typename Domain2, typename Range2>
+  inline typed::space<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::space<Domain2, Range2> &right) const;
+  inline typed::space<Range> range() const;
+  inline typed::multi_aff<pair<Domain, Range>, Range> range_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range> range_map_pw_multi_aff() const;
+  inline typed::space<Domain, Range> range_reverse() const = delete;
+  inline typed::id<Domain, Range> get_range_tuple_id() const = delete;
+  inline typed::space<Range, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::space<Domain2, Range> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::space<Domain2, Range> set_domain_tuple(const std::string &id) const;
+  template <typename Range2>
+  inline typed::space<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::space<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<Domain, Range> uncurry() const = delete;
+  static inline typed::space<Domain, Range> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<Domain, Range> universe_map() const;
+  inline typed::set<Domain, Range> universe_set() const = delete;
+  inline typed::space<Domain, Range> unwrap() const = delete;
+  inline typed::space<pair<Domain, Range>> wrap() const;
+  inline typed::aff<Domain, Range> zero_aff_on_domain() const = delete;
+  inline typed::multi_aff<Domain, Range> zero_multi_aff() const;
+  inline typed::multi_pw_aff<Domain, Range> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain, Range> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<Domain, Range> zero_multi_val() const = delete;
+};
+
+template <typename Domain, typename Range>
+struct space<pair<Domain, Range>> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  space(const space<pair<Arg1, Arg2>> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  template <typename Arg2>
+  inline typed::space<pair<Domain, Range>, Arg2> add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const;
+  template <typename Arg2>
+  inline typed::space<pair<Domain, Range>, Arg2> add_named_tuple(const std::string &tuple_id, unsigned int dim) const;
+  template <typename Arg2>
+  inline typed::space<pair<Domain, Range>, Arg2> add_unnamed_tuple(unsigned int dim) const;
+  inline typed::space<pair<Domain, Range>> curry() const = delete;
+  inline typed::space<> domain() const;
+  inline typed::multi_aff<pair<Domain, Range>> domain_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<pair<Domain, Range>> domain_map_pw_multi_aff() const = delete;
+  inline typed::id<pair<Domain, Range>> get_domain_tuple_id() const = delete;
+  inline typed::space<pair<Domain, Range>> flatten_domain() const = delete;
+  inline typed::space<pair<Domain, Range>> flatten_range() const = delete;
+  inline typed::multi_aff<pair<Domain, Range>, pair<Domain, Range>> identity_multi_aff_on_domain() const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, pair<Domain, Range>> identity_multi_pw_aff_on_domain() const;
+  inline typed::pw_multi_aff<pair<Domain, Range>, pair<Domain, Range>> identity_pw_multi_aff_on_domain() const;
+  inline typed::space<pair<Domain, Range>, pair<Domain, Range>> map_from_set() const;
+  inline typed::multi_aff<pair<Domain, Range>> multi_aff(const typed::aff_list<Anonymous> &list) const;
+  template <typename Arg2>
+  inline typed::multi_aff<pair<Domain, Range>, Arg2> multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const;
+  inline typed::multi_id<pair<Domain, Range>> multi_id(const typed::id_list<Anonymous> &list) const;
+  inline typed::multi_pw_aff<pair<Domain, Range>> multi_pw_aff(const typed::pw_aff_list<Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>> multi_union_pw_aff(const typed::union_pw_aff_list<Anonymous> &list) const;
+  inline typed::multi_val<pair<Domain, Range>> multi_val(const typed::val_list<Anonymous> &list) const;
+  inline typed::space<> params() const;
+  template <typename Arg2>
+  inline typed::space<pair<pair<Domain, Range>, Arg2>> product(const typed::space<Arg2> &right) const;
+  inline typed::space<pair<Domain, Range>> range() const = delete;
+  inline typed::multi_aff<pair<Domain, Range>> range_map_multi_aff() const = delete;
+  inline typed::pw_multi_aff<pair<Domain, Range>> range_map_pw_multi_aff() const = delete;
+  inline typed::space<pair<Domain, Range>> range_reverse() const = delete;
+  inline typed::id<pair<Domain, Range>> get_range_tuple_id() const = delete;
+  inline typed::space<pair<Domain, Range>> reverse() const = delete;
+  inline typed::space<pair<Domain, Range>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<pair<Domain, Range>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<Domain, Range>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<pair<Domain, Range>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<Domain, Range>> uncurry() const = delete;
+  static inline typed::space<pair<Domain, Range>> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<pair<Domain, Range>> universe_map() const = delete;
+  inline typed::set<pair<Domain, Range>> universe_set() const;
+  inline typed::space<Domain, Range> unwrap() const;
+  inline typed::space<pair<Domain, Range>> wrap() const = delete;
+  inline typed::aff<pair<Domain, Range>, Anonymous> zero_aff_on_domain() const;
+  inline typed::multi_aff<pair<Domain, Range>> zero_multi_aff() const;
+  inline typed::multi_pw_aff<pair<Domain, Range>> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<pair<Domain, Range>> zero_multi_val() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct space<pair<Domain, Range>, Range2> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  space(const space<pair<Arg1, Arg2>, Arg3> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  inline typed::space<pair<Domain, Range>, Range2> add_named_tuple(const typed::id<> &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> add_named_tuple(const std::string &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> add_unnamed_tuple(unsigned int dim) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> curry() const;
+  inline typed::space<pair<Domain, Range>> domain() const;
+  inline typed::multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map_pw_multi_aff() const;
+  inline typed::id<pair<Domain, Range>, Range2> get_domain_tuple_id() const = delete;
+  inline typed::space<Anonymous, Range2> flatten_domain() const;
+  inline typed::space<pair<Domain, Range>, Range2> flatten_range() const = delete;
+  inline typed::multi_aff<pair<Domain, Range>, Range2> identity_multi_aff_on_domain() const = delete;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> identity_multi_pw_aff_on_domain() const = delete;
+  inline typed::pw_multi_aff<pair<Domain, Range>, Range2> identity_pw_multi_aff_on_domain() const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> map_from_set() const = delete;
+  inline typed::multi_aff<pair<Domain, Range>, Range2> multi_aff(const typed::aff_list<pair<Domain, Range>, Anonymous> &list) const;
+  inline typed::multi_aff<pair<Domain, Range>, Range2> multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::multi_id<pair<Domain, Range>, Range2> multi_id(const typed::id_list<> &list) const = delete;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> multi_pw_aff(const typed::pw_aff_list<pair<Domain, Range>, Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>, Range2> multi_union_pw_aff(const typed::union_pw_aff_list<pair<Domain, Range>, Anonymous> &list) const;
+  inline typed::multi_val<pair<Domain, Range>, Range2> multi_val(const typed::val_list<> &list) const = delete;
+  inline typed::space<> params() const;
+  template <typename Domain2, typename Arg3>
+  inline typed::space<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::space<Domain2, Arg3> &right) const;
+  inline typed::space<Range2> range() const;
+  inline typed::multi_aff<pair<pair<Domain, Range>, Range2>, Range2> range_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, Range2> range_map_pw_multi_aff() const;
+  inline typed::space<pair<Domain, Range>, Range2> range_reverse() const = delete;
+  inline typed::id<pair<Domain, Range>, Range2> get_range_tuple_id() const = delete;
+  inline typed::space<Range2, pair<Domain, Range>> reverse() const;
+  inline typed::space<pair<Domain, Range>, Range2> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> set_domain_tuple(const std::string &id) const = delete;
+  template <typename Arg2>
+  inline typed::space<pair<Domain, Range>, Arg2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Arg2>
+  inline typed::space<pair<Domain, Range>, Arg2> set_range_tuple(const std::string &id) const;
+  inline typed::space<pair<Domain, Range>, Range2> uncurry() const = delete;
+  static inline typed::space<pair<Domain, Range>, Range2> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<pair<Domain, Range>, Range2> universe_map() const;
+  inline typed::set<pair<Domain, Range>, Range2> universe_set() const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> unwrap() const = delete;
+  inline typed::space<pair<pair<Domain, Range>, Range2>> wrap() const;
+  inline typed::aff<pair<Domain, Range>, Range2> zero_aff_on_domain() const = delete;
+  inline typed::multi_aff<pair<Domain, Range>, Range2> zero_multi_aff() const;
+  inline typed::multi_pw_aff<pair<Domain, Range>, Range2> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>, Range2> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<pair<Domain, Range>, Range2> zero_multi_val() const = delete;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct space<Domain, pair<Range, Range2>> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  space(const space<Arg1, pair<Arg2, Arg3>> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  inline typed::space<Domain, pair<Range, Range2>> add_named_tuple(const typed::id<> &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> add_named_tuple(const std::string &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> add_unnamed_tuple(unsigned int dim) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> curry() const = delete;
+  inline typed::space<Domain> domain() const;
+  inline typed::multi_aff<pair<Domain, pair<Range, Range2>>, Domain> domain_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> domain_map_pw_multi_aff() const;
+  inline typed::id<Domain, pair<Range, Range2>> get_domain_tuple_id() const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> flatten_domain() const = delete;
+  inline typed::space<Domain, Anonymous> flatten_range() const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> identity_multi_aff_on_domain() const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> identity_multi_pw_aff_on_domain() const = delete;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> identity_pw_multi_aff_on_domain() const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> map_from_set() const = delete;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> multi_aff(const typed::aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::multi_id<Domain, pair<Range, Range2>> multi_id(const typed::id_list<> &list) const = delete;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> multi_pw_aff(const typed::pw_aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> multi_union_pw_aff(const typed::union_pw_aff_list<Domain, Anonymous> &list) const;
+  inline typed::multi_val<Domain, pair<Range, Range2>> multi_val(const typed::val_list<> &list) const = delete;
+  inline typed::space<> params() const;
+  template <typename Domain2, typename Arg3>
+  inline typed::space<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::space<Domain2, Arg3> &right) const;
+  inline typed::space<pair<Range, Range2>> range() const;
+  inline typed::multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> range_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> range_map_pw_multi_aff() const;
+  inline typed::space<Domain, pair<Range2, Range>> range_reverse() const;
+  inline typed::id<Domain, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::space<pair<Range, Range2>, Domain> reverse() const;
+  template <typename Domain2>
+  inline typed::space<Domain2, pair<Range, Range2>> set_domain_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::space<Domain2, pair<Range, Range2>> set_domain_tuple(const std::string &id) const;
+  inline typed::space<Domain, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<Domain, Range>, Range2> uncurry() const;
+  static inline typed::space<Domain, pair<Range, Range2>> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<Domain, pair<Range, Range2>> universe_map() const;
+  inline typed::set<Domain, pair<Range, Range2>> universe_set() const = delete;
+  inline typed::space<Domain, pair<Range, Range2>> unwrap() const = delete;
+  inline typed::space<pair<Domain, pair<Range, Range2>>> wrap() const;
+  inline typed::aff<Domain, pair<Range, Range2>> zero_aff_on_domain() const = delete;
+  inline typed::multi_aff<Domain, pair<Range, Range2>> zero_multi_aff() const;
+  inline typed::multi_pw_aff<Domain, pair<Range, Range2>> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<Domain, pair<Range, Range2>> zero_multi_val() const = delete;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct space<pair<T1, T2>, pair<Range, Range2>> : public isl::space {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  space() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  space(const space<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::space(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::space>{}, bool>::type = true>
+  space(const base &obj) : isl::space(obj) {}
+ public:
+  static space from(const isl::space &obj) {
+    return space(obj);
+  }
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> add_named_tuple(const typed::id<> &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> add_named_tuple(const std::string &tuple_id, unsigned int dim) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> add_unnamed_tuple(unsigned int dim) const = delete;
+  inline typed::space<T1, pair<T2, pair<Range, Range2>>> curry() const;
+  inline typed::space<pair<T1, T2>> domain() const;
+  inline typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map_pw_multi_aff() const;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_domain_tuple_id() const = delete;
+  inline typed::space<Anonymous, pair<Range, Range2>> flatten_domain() const;
+  inline typed::space<pair<T1, T2>, Anonymous> flatten_range() const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> identity_multi_aff_on_domain() const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> identity_multi_pw_aff_on_domain() const = delete;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> identity_pw_multi_aff_on_domain() const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> map_from_set() const = delete;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> multi_aff(const typed::aff_list<pair<T1, T2>, Anonymous> &list) const;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> multi_aff_on_domain(const typed::multi_val<> &mv) const = delete;
+  inline typed::multi_id<pair<T1, T2>, pair<Range, Range2>> multi_id(const typed::id_list<> &list) const = delete;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> multi_pw_aff(const typed::pw_aff_list<pair<T1, T2>, Anonymous> &list) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> multi_union_pw_aff(const typed::union_pw_aff_list<pair<T1, T2>, Anonymous> &list) const;
+  inline typed::multi_val<pair<T1, T2>, pair<Range, Range2>> multi_val(const typed::val_list<> &list) const = delete;
+  inline typed::space<> params() const;
+  template <typename Domain2, typename Arg2>
+  inline typed::space<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::space<Domain2, Arg2> &right) const;
+  inline typed::space<pair<Range, Range2>> range() const;
+  inline typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> range_map_multi_aff() const;
+  inline typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> range_map_pw_multi_aff() const;
+  inline typed::space<pair<T1, T2>, pair<Range2, Range>> range_reverse() const;
+  inline typed::id<pair<T1, T2>, pair<Range, Range2>> get_range_tuple_id() const = delete;
+  inline typed::space<pair<Range, Range2>, pair<T1, T2>> reverse() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> set_domain_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const typed::id<> &id) const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> set_range_tuple(const std::string &id) const = delete;
+  inline typed::space<pair<pair<T1, T2>, Range>, Range2> uncurry() const;
+  static inline typed::space<pair<T1, T2>, pair<Range, Range2>> unit(const isl::ctx &ctx) = delete;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> universe_map() const;
+  inline typed::set<pair<T1, T2>, pair<Range, Range2>> universe_set() const = delete;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> unwrap() const = delete;
+  inline typed::space<pair<pair<T1, T2>, pair<Range, Range2>>> wrap() const;
+  inline typed::aff<pair<T1, T2>, pair<Range, Range2>> zero_aff_on_domain() const = delete;
+  inline typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> zero_multi_aff() const;
+  inline typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> zero_multi_pw_aff() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> zero_multi_union_pw_aff() const;
+  inline typed::multi_val<pair<T1, T2>, pair<Range, Range2>> zero_multi_val() const = delete;
+};
+
+template <typename Domain, typename Range>
+struct union_map<Domain, Range> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  union_map(const union_map<Arg1, Arg2> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<Domain, Range> &bmap);
+  inline /* implicit */ union_map(const typed::map<Domain, Range> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> apply_domain(const typed::map<Domain, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Range, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::basic_map<Range, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::map<Range, Range2> &umap2) const;
+  inline typed::map<Domain, Range> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Range> as_union_pw_multi_aff() const;
+  inline typed::union_set<Domain> bind_range(const typed::multi_id<Range> &tuple) const;
+  inline typed::union_map<Domain, Range> coalesce() const;
+  inline typed::union_map<Domain, Range> curry() const = delete;
+  inline typed::union_set<Domain, Range> deltas() const = delete;
+  inline typed::union_map<Domain, Range> detect_equalities() const;
+  inline typed::union_set<Domain> domain() const;
+  inline typed::union_map<Domain, Range> domain_factor_domain() const = delete;
+  inline typed::union_map<Domain, Range> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Range> domain_product(const typed::union_map<Domain2, Range> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Range> domain_product(const typed::basic_map<Domain2, Range> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Range> domain_product(const typed::map<Domain2, Range> &umap2) const;
+  static inline typed::union_map<Domain, Range> empty(const isl::ctx &ctx);
+  inline typed::union_map<Domain, Range> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<Domain, Range> eq_at(const typed::multi_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<Domain, Range> eq_at(const typed::union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const;
+  inline typed::union_map<Domain, Range> gist(const typed::union_map<Domain, Range> &context) const;
+  inline typed::union_map<Domain, Range> gist(const typed::basic_map<Domain, Range> &context) const;
+  inline typed::union_map<Domain, Range> gist(const typed::map<Domain, Range> &context) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::basic_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::point<Domain> &uset) const;
+  inline typed::union_map<Domain, Range> gist_domain(const typed::set<Domain> &uset) const;
+  inline typed::union_map<Domain, Range> intersect(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> intersect(const typed::basic_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> intersect(const typed::map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<Domain, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<Domain, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::space<Range> &space) const;
+  inline typed::union_map<Domain, Range> intersect_range(const typed::union_set<Range> &uset) const;
+  inline typed::union_map<Domain, Range> lexmax() const;
+  inline typed::union_map<Domain, Range> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Range> &ma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::basic_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> product(const typed::map<Domain2, Range2> &umap2) const;
+  inline typed::union_map<Domain, Range> project_out_all_params() const;
+  inline typed::union_set<Range> range() const;
+  inline typed::union_map<Domain, Range> range_factor_domain() const = delete;
+  inline typed::union_map<Domain, Range> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range> range_map() const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Range, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Range, Range2>> range_product(const typed::basic_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Range, Range2>> range_product(const typed::map<Domain, Range2> &umap2) const;
+  inline typed::union_map<Domain, Range> range_reverse() const = delete;
+  inline typed::union_map<Range, Domain> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::union_map<Domain, Range> subtract(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> subtract(const typed::basic_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> subtract(const typed::map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::basic_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::point<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_domain(const typed::set<Domain> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::union_set<Range> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::basic_set<Range> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::point<Range> &dom) const;
+  inline typed::union_map<Domain, Range> subtract_range(const typed::set<Range> &dom) const;
+  inline typed::union_map<Domain, Range> uncurry() const = delete;
+  inline typed::union_map<Domain, Range> unite(const typed::union_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> unite(const typed::basic_map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> unite(const typed::map<Domain, Range> &umap2) const;
+  inline typed::union_map<Domain, Range> universe() const;
+  inline typed::union_set<pair<Domain, Range>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct union_map<pair<Domain, Range>, Range2> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  union_map(const union_map<pair<Arg1, Arg2>, Arg3> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<pair<Domain, Range>, Range2> &bmap);
+  inline /* implicit */ union_map(const typed::map<pair<Domain, Range>, Range2> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> apply_domain(const typed::map<pair<Domain, Range>, Domain2> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> apply_range(const typed::union_map<Range2, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> apply_range(const typed::basic_map<Range2, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> apply_range(const typed::map<Range2, Arg3> &umap2) const;
+  inline typed::map<pair<Domain, Range>, Range2> as_map() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Range>, Range2> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Range>, Range2> as_union_pw_multi_aff() const;
+  inline typed::union_set<pair<Domain, Range>> bind_range(const typed::multi_id<Range2> &tuple) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> coalesce() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> curry() const;
+  inline typed::union_set<pair<Domain, Range>, Range2> deltas() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> detect_equalities() const;
+  inline typed::union_set<pair<Domain, Range>> domain() const;
+  inline typed::union_map<Domain, Range2> domain_factor_domain() const;
+  inline typed::union_map<Range, Range2> domain_factor_range() const;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::basic_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> domain_product(const typed::map<Domain2, Range2> &umap2) const;
+  static inline typed::union_map<pair<Domain, Range>, Range2> empty(const isl::ctx &ctx);
+  inline typed::union_map<pair<Domain, Range>, Range2> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> eq_at(const typed::multi_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> eq_at(const typed::union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist(const typed::map<pair<Domain, Range>, Range2> &context) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::basic_set<pair<Domain, Range>> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::point<pair<Domain, Range>> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> gist_domain(const typed::set<pair<Domain, Range>> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect(const typed::map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::space<pair<Domain, Range>> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::space<Range2> &space) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> intersect_range(const typed::union_set<Range2> &uset) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> lexmax() const;
+  inline typed::union_map<pair<Domain, Range>, Range2> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Range2> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::basic_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> product(const typed::map<Domain2, Arg3> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> project_out_all_params() const;
+  inline typed::union_set<Range2> range() const;
+  inline typed::union_map<pair<Domain, Range>, Range2> range_factor_domain() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> range_factor_range() const = delete;
+  inline typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> range_map() const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::basic_map<pair<Domain, Range>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> range_product(const typed::map<pair<Domain, Range>, Arg3> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> range_reverse() const = delete;
+  inline typed::union_map<Range2, pair<Domain, Range>> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<Domain, Range>, Range2> get_space() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract(const typed::map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::basic_set<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::point<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_domain(const typed::set<pair<Domain, Range>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::union_set<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::basic_set<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::point<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> subtract_range(const typed::set<Range2> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> uncurry() const = delete;
+  inline typed::union_map<pair<Domain, Range>, Range2> unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> unite(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> unite(const typed::map<pair<Domain, Range>, Range2> &umap2) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> universe() const;
+  inline typed::union_set<pair<pair<Domain, Range>, Range2>> wrap() const;
+};
+
+template <typename Domain>
+struct union_map<Domain, Domain> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_map(const union_map<Arg1, Arg1> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<Domain, Domain> &bmap);
+  inline /* implicit */ union_map(const typed::map<Domain, Domain> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> apply_domain(const typed::map<Domain, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::basic_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> apply_range(const typed::map<Domain, Range2> &umap2) const;
+  inline typed::map<Domain, Domain> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, Domain> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, Domain> as_union_pw_multi_aff() const;
+  inline typed::union_set<Domain> bind_range(const typed::multi_id<Domain> &tuple) const;
+  inline typed::union_map<Domain, Domain> coalesce() const;
+  inline typed::union_map<Domain, Domain> curry() const = delete;
+  inline typed::union_set<Domain> deltas() const;
+  inline typed::union_map<Domain, Domain> detect_equalities() const;
+  inline typed::union_set<Domain> domain() const;
+  inline typed::union_map<Domain, Domain> domain_factor_domain() const = delete;
+  inline typed::union_map<Domain, Domain> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Domain> domain_product(const typed::union_map<Domain2, Domain> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Domain> domain_product(const typed::basic_map<Domain2, Domain> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, Domain> domain_product(const typed::map<Domain2, Domain> &umap2) const;
+  static inline typed::union_map<Domain, Domain> empty(const isl::ctx &ctx);
+  template <typename Range>
+  inline typed::union_map<Domain, Domain> eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const;
+  template <typename Range>
+  inline typed::union_map<Domain, Domain> eq_at(const typed::multi_pw_aff<Domain, Range> &mupa) const;
+  template <typename Range>
+  inline typed::union_map<Domain, Domain> eq_at(const typed::union_pw_aff<Domain, Range> &mupa) const;
+  inline bool every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const;
+  inline typed::union_map<Domain, Domain> gist(const typed::union_map<Domain, Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist(const typed::basic_map<Domain, Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist(const typed::map<Domain, Domain> &context) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::basic_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::point<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> gist_domain(const typed::set<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> intersect(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> intersect(const typed::basic_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> intersect(const typed::map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, Domain> intersect_range(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, Domain> lexmax() const;
+  inline typed::union_map<Domain, Domain> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, Domain> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::multi_aff<Range2, Domain> &ma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::basic_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> product(const typed::map<Domain2, Range2> &umap2) const;
+  inline typed::union_map<Domain, Domain> project_out_all_params() const;
+  inline typed::union_set<Domain> range() const;
+  inline typed::union_map<Domain, Domain> range_factor_domain() const = delete;
+  inline typed::union_map<Domain, Domain> range_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, Domain>, Domain> range_map() const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Domain, Range2>> range_product(const typed::union_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Domain, Range2>> range_product(const typed::basic_map<Domain, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<Domain, pair<Domain, Range2>> range_product(const typed::map<Domain, Range2> &umap2) const;
+  inline typed::union_map<Domain, Domain> range_reverse() const = delete;
+  inline typed::union_map<Domain, Domain> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, Domain> get_space() const = delete;
+  inline typed::union_map<Domain, Domain> subtract(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> subtract(const typed::basic_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> subtract(const typed::map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::basic_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::point<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_domain(const typed::set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::basic_set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::point<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> subtract_range(const typed::set<Domain> &dom) const;
+  inline typed::union_map<Domain, Domain> uncurry() const = delete;
+  inline typed::union_map<Domain, Domain> unite(const typed::union_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> unite(const typed::basic_map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> unite(const typed::map<Domain, Domain> &umap2) const;
+  inline typed::union_map<Domain, Domain> universe() const;
+  inline typed::union_set<pair<Domain, Domain>> wrap() const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct union_map<Domain, pair<Range, Range2>> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  union_map(const union_map<Arg1, pair<Arg2, Arg3>> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<Domain, pair<Range, Range2>> &bmap);
+  inline /* implicit */ union_map(const typed::map<Domain, pair<Range, Range2>> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<Domain, Domain2> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> apply_range(const typed::map<pair<Range, Range2>, Arg3> &umap2) const;
+  inline typed::map<Domain, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::union_set<Domain> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> curry() const = delete;
+  inline typed::union_set<Domain, pair<Range, Range2>> deltas() const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> detect_equalities() const;
+  inline typed::union_set<Domain> domain() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> domain_factor_domain() const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> domain_factor_range() const = delete;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &umap2) const;
+  static inline typed::union_map<Domain, pair<Range, Range2>> empty(const isl::ctx &ctx);
+  inline typed::union_map<Domain, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> eq_at(const typed::union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist(const typed::map<Domain, pair<Range, Range2>> &context) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::basic_set<Domain> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::point<Domain> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> gist_domain(const typed::set<Domain> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect(const typed::map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> lexmax() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, Arg3> preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::union_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::basic_map<Domain2, Arg3> &umap2) const;
+  template <typename Domain2, typename Arg3>
+  inline typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> product(const typed::map<Domain2, Arg3> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::union_set<pair<Range, Range2>> range() const;
+  inline typed::union_map<Domain, Range> range_factor_domain() const;
+  inline typed::union_map<Domain, Range2> range_factor_range() const;
+  inline typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_map<Domain, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::basic_map<Domain, Arg3> &umap2) const;
+  template <typename Arg3>
+  inline typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::map<Domain, Arg3> &umap2) const;
+  inline typed::union_map<Domain, pair<Range2, Range>> range_reverse() const;
+  inline typed::union_map<pair<Range, Range2>, Domain> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, pair<Range, Range2>> get_space() const = delete;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract(const typed::map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::basic_set<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::point<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_domain(const typed::set<Domain> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::basic_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::point<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> subtract_range(const typed::set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<Domain, Range>, Range2> uncurry() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> unite(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> unite(const typed::map<Domain, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<Domain, pair<Range, Range2>> universe() const;
+  inline typed::union_set<pair<Domain, pair<Range, Range2>>> wrap() const;
+};
+
+template <typename T1, typename T2>
+struct union_map<pair<T1, T2>, pair<T1, T2>> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{},
+            bool>::type = true>
+  union_map(const union_map<pair<Arg1, Arg2>, pair<Arg1, Arg2>> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap);
+  inline /* implicit */ union_map(const typed::map<pair<T1, T2>, pair<T1, T2>> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> apply_range(const typed::basic_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> apply_range(const typed::map<pair<T1, T2>, Range2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<T1, T2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> as_union_pw_multi_aff() const;
+  inline typed::union_set<pair<T1, T2>> bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> coalesce() const;
+  inline typed::union_map<T1, pair<T2, pair<T1, T2>>> curry() const;
+  inline typed::union_set<pair<T1, T2>> deltas() const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> detect_equalities() const;
+  inline typed::union_set<pair<T1, T2>> domain() const;
+  inline typed::union_map<T1, pair<T1, T2>> domain_factor_domain() const;
+  inline typed::union_map<T2, pair<T1, T2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::basic_map<Domain2, pair<T1, T2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> domain_product(const typed::map<Domain2, pair<T1, T2>> &umap2) const;
+  static inline typed::union_map<pair<T1, T2>, pair<T1, T2>> empty(const isl::ctx &ctx);
+  template <typename Range>
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const;
+  template <typename Range>
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mupa) const;
+  template <typename Range>
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> eq_at(const typed::union_pw_aff<pair<T1, T2>, Range> &mupa) const;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::basic_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::point<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> gist_domain(const typed::set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> intersect_range(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> lexmax() const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<T1, T2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, Range2> preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::union_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::basic_map<Domain2, Range2> &umap2) const;
+  template <typename Domain2, typename Range2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> product(const typed::map<Domain2, Range2> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> project_out_all_params() const;
+  inline typed::union_set<pair<T1, T2>> range() const;
+  inline typed::union_map<pair<T1, T2>, T1> range_factor_domain() const;
+  inline typed::union_map<pair<T1, T2>, T2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> range_map() const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::basic_map<pair<T1, T2>, Range2> &umap2) const;
+  template <typename Range2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> range_product(const typed::map<pair<T1, T2>, Range2> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T2, T1>> range_reverse() const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<T1, T2>, pair<T1, T2>> get_space() const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::basic_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::point<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_domain(const typed::set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::basic_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::point<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> subtract_range(const typed::set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<pair<T1, T2>, T1>, T2> uncurry() const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<T1, T2>> universe() const;
+  inline typed::union_set<pair<pair<T1, T2>, pair<T1, T2>>> wrap() const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct union_map<pair<T1, T2>, pair<Range, Range2>> : public isl::union_map {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_map() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  union_map(const union_map<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::union_map(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_map>{}, bool>::type = true>
+  union_map(const base &obj) : isl::union_map(obj) {}
+ public:
+  static union_map from(const isl::union_map &obj) {
+    return union_map(obj);
+  }
+  inline /* implicit */ union_map(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap);
+  inline /* implicit */ union_map(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map);
+  inline explicit union_map(const isl::ctx &ctx, const std::string &str);
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> apply_domain(const typed::map<pair<T1, T2>, Domain2> &umap2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> apply_range(const typed::map<pair<Range, Range2>, Arg2> &umap2) const;
+  inline typed::map<pair<T1, T2>, pair<Range, Range2>> as_map() const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_union_pw_multi_aff() const;
+  inline typed::union_set<pair<T1, T2>> bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::union_map<T1, pair<T2, pair<Range, Range2>>> curry() const;
+  inline typed::union_set<pair<T1, T2>, pair<Range, Range2>> deltas() const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> detect_equalities() const;
+  inline typed::union_set<pair<T1, T2>> domain() const;
+  inline typed::union_map<T1, pair<Range, Range2>> domain_factor_domain() const;
+  inline typed::union_map<T2, pair<Range, Range2>> domain_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map() const;
+  inline typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> domain_map_union_pw_multi_aff() const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &umap2) const;
+  template <typename Domain2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> domain_product(const typed::map<Domain2, pair<Range, Range2>> &umap2) const;
+  static inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> empty(const isl::ctx &ctx);
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_union_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::multi_pw_aff<> &mupa) const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> eq_at(const typed::union_pw_aff<> &mupa) const = delete;
+  inline bool every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const;
+  inline void foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::basic_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::point<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> gist_domain(const typed::set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::space<pair<Range, Range2>> &space) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> lexmax() const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_map<Domain2, pair<Range, Range2>> preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, Arg2> preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::union_map<Domain2, Arg2> &umap2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::basic_map<Domain2, Arg2> &umap2) const;
+  template <typename Domain2, typename Arg2>
+  inline typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> product(const typed::map<Domain2, Arg2> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> project_out_all_params() const;
+  inline typed::union_set<pair<Range, Range2>> range() const;
+  inline typed::union_map<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::union_map<pair<T1, T2>, Range2> range_factor_range() const;
+  inline typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> range_map() const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::basic_map<pair<T1, T2>, Arg2> &umap2) const;
+  template <typename Arg2>
+  inline typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::map<pair<T1, T2>, Arg2> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range2, Range>> range_reverse() const;
+  inline typed::union_map<pair<Range, Range2>, pair<T1, T2>> reverse() const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> get_space() const = delete;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::basic_set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::point<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::set<pair<T1, T2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::basic_set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::point<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> subtract_range(const typed::set<pair<Range, Range2>> &dom) const;
+  inline typed::union_map<pair<pair<T1, T2>, Range>, Range2> uncurry() const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> universe() const;
+  inline typed::union_set<pair<pair<T1, T2>, pair<Range, Range2>>> wrap() const;
+};
+
+template <>
+struct union_pw_aff<Anonymous> : public isl::union_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_aff() = default;
+  union_pw_aff(const isl::union_pw_aff &obj) : isl::union_pw_aff(obj) {}
+  static union_pw_aff from(const isl::union_pw_aff &obj) {
+    return union_pw_aff(obj);
+  }
+  inline /* implicit */ union_pw_aff(const typed::aff<Anonymous> &aff);
+  inline /* implicit */ union_pw_aff(const typed::pw_aff<Anonymous> &pa);
+  inline explicit union_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_union_pw_aff<Anonymous> add(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::union_pw_aff<Anonymous> add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Anonymous> add(const typed::aff<Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Anonymous> add(const typed::pw_aff<Anonymous> &upa2) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const;
+  inline typed::multi_union_pw_aff<Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Anonymous> as_pw_multi_aff() const;
+  inline typed::union_map<Anonymous> as_union_map() const = delete;
+  inline typed::union_pw_aff<Anonymous> at(int pos) const;
+  inline typed::union_set<> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::union_set<> bind(const typed::id<Anonymous> &id) const;
+  inline typed::union_set<> bind(const std::string &id) const;
+  inline typed::union_pw_aff<Anonymous> coalesce() const;
+  inline typed::union_set<> domain() const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::union_set<> &context) const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::basic_set<> &context) const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::point<> &context) const;
+  inline typed::union_pw_aff<Anonymous> gist(const typed::set<> &context) const;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::union_pw_aff<Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_aff<Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_aff<Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_aff_list<Anonymous> list() const;
+  inline typed::multi_union_pw_aff<Anonymous> neg() const;
+  inline typed::union_pw_multi_aff<Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::multi_aff<> &upma) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::pw_multi_aff<> &upma) const = delete;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_aff<> &upma) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> range_factor_range() const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> range_product(const typed::multi_union_pw_aff<> &multi2) const = delete;
+  inline typed::union_pw_multi_aff<Anonymous> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<Anonymous> scale(long v) const;
+  inline typed::multi_union_pw_aff<Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<Anonymous> scale_down(long v) const;
+  inline typed::multi_union_pw_aff<Anonymous> set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Domain2>
+  inline typed::multi_union_pw_aff<Domain2> set_range_tuple(const std::string &id) const;
+  inline typed::space<> space() const;
+  inline typed::space<Anonymous> get_space() const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const;
+  inline typed::union_pw_aff<Anonymous> sub(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Anonymous> sub(const typed::aff<Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Anonymous> sub(const typed::pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_aff<Anonymous> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::multi_union_pw_aff<Anonymous> union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const;
+  inline typed::union_pw_aff<Anonymous> union_add(const typed::union_pw_aff<Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Anonymous> union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Anonymous> union_add(const typed::aff<Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Anonymous> union_add(const typed::pw_aff<Anonymous> &upa2) const;
+};
+
+template <typename Domain>
+struct union_pw_aff<Domain, Anonymous> : public isl::union_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_pw_aff(const union_pw_aff<Arg1, Anonymous> &obj) : isl::union_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_aff>{}, bool>::type = true>
+  union_pw_aff(const base &obj) : isl::union_pw_aff(obj) {}
+ public:
+  static union_pw_aff from(const isl::union_pw_aff &obj) {
+    return union_pw_aff(obj);
+  }
+  inline /* implicit */ union_pw_aff(const typed::aff<Domain, Anonymous> &aff);
+  inline /* implicit */ union_pw_aff(const typed::pw_aff<Domain, Anonymous> &pa);
+  inline explicit union_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_union_pw_aff<Domain, Anonymous> add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> add(const typed::pw_aff<Domain, Anonymous> &upa2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Anonymous> as_pw_multi_aff() const;
+  inline typed::union_map<Domain, Anonymous> as_union_map() const;
+  inline typed::union_pw_aff<Domain, Anonymous> at(int pos) const;
+  inline typed::union_set<Domain> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::union_set<Domain> bind(const typed::id<Anonymous> &id) const;
+  inline typed::union_set<Domain> bind(const std::string &id) const;
+  inline typed::union_pw_aff<Domain, Anonymous> coalesce() const;
+  inline typed::union_set<Domain> domain() const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::union_set<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::point<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_aff<Domain, Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_aff_list<Domain, Anonymous> list() const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> neg() const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::multi_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::pw_multi_aff<Domain> &upma) const;
+  template <typename Domain2>
+  inline typed::union_pw_aff<Domain2, Anonymous> pullback(const typed::union_pw_aff<Domain2, Domain> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_aff<Domain> &upma) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale(long v) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> scale_down(long v) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<Domain, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, Anonymous> get_space() const = delete;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> sub(const typed::aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> sub(const typed::pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_aff<Domain, Anonymous> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::multi_union_pw_aff<Domain, Anonymous> union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<Domain, Anonymous> union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> union_add(const typed::aff<Domain, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<Domain, Anonymous> union_add(const typed::pw_aff<Domain, Anonymous> &upa2) const;
+};
+
+template <typename Domain, typename Domain2>
+struct union_pw_aff<pair<Domain, Domain2>, Anonymous> : public isl::union_pw_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Domain2, Arg2>{},
+            bool>::type = true>
+  union_pw_aff(const union_pw_aff<pair<Arg1, Arg2>, Anonymous> &obj) : isl::union_pw_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_aff>{}, bool>::type = true>
+  union_pw_aff(const base &obj) : isl::union_pw_aff(obj) {}
+ public:
+  static union_pw_aff from(const isl::union_pw_aff &obj) {
+    return union_pw_aff(obj);
+  }
+  inline /* implicit */ union_pw_aff(const typed::aff<pair<Domain, Domain2>, Anonymous> &aff);
+  inline /* implicit */ union_pw_aff(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &pa);
+  inline explicit union_pw_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> add(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &multi2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> add(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> add(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> add(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, Anonymous> as_pw_multi_aff() const;
+  inline typed::union_map<pair<Domain, Domain2>, Anonymous> as_union_map() const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> at(int pos) const;
+  inline typed::union_set<pair<Domain, Domain2>> bind(const typed::multi_id<Anonymous> &tuple) const;
+  inline typed::union_set<pair<Domain, Domain2>> bind(const typed::id<Anonymous> &id) const;
+  inline typed::union_set<pair<Domain, Domain2>> bind(const std::string &id) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> coalesce() const;
+  inline typed::union_set<pair<Domain, Domain2>> domain() const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> gist(const typed::union_set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> gist(const typed::basic_set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> gist(const typed::point<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> gist(const typed::set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> intersect_domain(const typed::space<pair<Domain, Domain2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> intersect_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_aff_list<pair<Domain, Domain2>, Anonymous> list() const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> neg() const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Domain2>, Anonymous> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_aff<Arg2, Anonymous> pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain, Domain2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_multi_aff<pair<Domain, Domain2>> &upma) const;
+  template <typename Arg2>
+  inline typed::union_pw_aff<Arg2, Anonymous> pullback(const typed::multi_aff<Arg2, pair<Domain, Domain2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::multi_aff<pair<Domain, Domain2>> &upma) const;
+  template <typename Arg2>
+  inline typed::union_pw_aff<Arg2, Anonymous> pullback(const typed::pw_multi_aff<Arg2, pair<Domain, Domain2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::pw_multi_aff<pair<Domain, Domain2>> &upma) const;
+  template <typename Arg2>
+  inline typed::union_pw_aff<Arg2, Anonymous> pullback(const typed::union_pw_aff<Arg2, pair<Domain, Domain2>> &upma) const;
+  inline typed::union_pw_aff<Anonymous> pullback(const typed::union_pw_aff<pair<Domain, Domain2>> &upma) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> range_product(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> &multi2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> range_product(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale(long v) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale_down(const typed::multi_val<Anonymous> &mv) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale_down(const typed::val<Anonymous> &v) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> scale_down(long v) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> set_at(int pos, const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &el) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> set_range_tuple(const typed::id<Anonymous> &id) const;
+  template <typename Range2>
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> set_range_tuple(const std::string &id) const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<Domain, Domain2>, Anonymous> get_space() const = delete;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> sub(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &multi2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> sub(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> sub(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> sub(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> sub(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> subtract_domain(const typed::space<pair<Domain, Domain2>> &space) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> subtract_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> union_add(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &mupa2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> union_add(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> union_add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> union_add(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+  inline typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> union_add(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const;
+};
+
+template <>
+struct union_pw_aff_list<Anonymous> : public isl::union_pw_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_aff_list() = default;
+  union_pw_aff_list(const isl::union_pw_aff_list &obj) : isl::union_pw_aff_list(obj) {}
+  static union_pw_aff_list from(const isl::union_pw_aff_list &obj) {
+    return union_pw_aff_list(obj);
+  }
+  inline explicit union_pw_aff_list(const isl::ctx &ctx, int n);
+  inline explicit union_pw_aff_list(const typed::union_pw_aff<Anonymous> &el);
+  inline typed::union_pw_aff_list<Anonymous> add(const typed::union_pw_aff<Anonymous> &el) const;
+  inline typed::union_pw_aff_list<Anonymous> add(const typed::aff<Anonymous> &el) const;
+  inline typed::union_pw_aff_list<Anonymous> add(const typed::pw_aff<Anonymous> &el) const;
+  inline typed::union_pw_aff<Anonymous> at(int index) const;
+  inline typed::union_pw_aff<Anonymous> get_at(int index) const = delete;
+  inline typed::union_pw_aff_list<Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::union_pw_aff<Anonymous>)> &fn) const;
+};
+
+template <typename Domain>
+struct union_pw_aff_list<Domain, Anonymous> : public isl::union_pw_aff_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_aff_list() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_pw_aff_list(const union_pw_aff_list<Arg1, Anonymous> &obj) : isl::union_pw_aff_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_aff_list>{}, bool>::type = true>
+  union_pw_aff_list(const base &obj) : isl::union_pw_aff_list(obj) {}
+ public:
+  static union_pw_aff_list from(const isl::union_pw_aff_list &obj) {
+    return union_pw_aff_list(obj);
+  }
+  inline explicit union_pw_aff_list(const isl::ctx &ctx, int n);
+  inline explicit union_pw_aff_list(const typed::union_pw_aff<Domain, Anonymous> &el);
+  inline typed::union_pw_aff_list<Domain, Anonymous> add(const typed::union_pw_aff<Domain, Anonymous> &el) const;
+  inline typed::union_pw_aff_list<Domain, Anonymous> add(const typed::aff<Domain, Anonymous> &el) const;
+  inline typed::union_pw_aff_list<Domain, Anonymous> add(const typed::pw_aff<Domain, Anonymous> &el) const;
+  inline typed::union_pw_aff<Domain, Anonymous> at(int index) const;
+  inline typed::union_pw_aff<Domain, Anonymous> get_at(int index) const = delete;
+  inline typed::union_pw_aff_list<Domain, Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::union_pw_aff<Domain, Anonymous>)> &fn) const;
+};
+
+template <typename Domain>
+struct union_pw_multi_aff<Domain> : public isl::union_pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_multi_aff() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_pw_multi_aff(const union_pw_multi_aff<Arg1> &obj) : isl::union_pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_multi_aff>{}, bool>::type = true>
+  union_pw_multi_aff(const base &obj) : isl::union_pw_multi_aff(obj) {}
+ public:
+  static union_pw_multi_aff from(const isl::union_pw_multi_aff &obj) {
+    return union_pw_multi_aff(obj);
+  }
+  inline /* implicit */ union_pw_multi_aff(const typed::multi_aff<Domain> &ma);
+  inline /* implicit */ union_pw_multi_aff(const typed::pw_multi_aff<Domain> &pma);
+  inline /* implicit */ union_pw_multi_aff(const typed::union_pw_aff<Domain> &upa);
+  inline explicit union_pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_pw_multi_aff<Domain> add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> add(const typed::multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> add(const typed::pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> add(const typed::union_pw_aff<Domain> &upma2) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::multi_aff<Domain, Range> &upma2) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::pw_multi_aff<Domain, Range> &upma2) const;
+  template <typename Range>
+  inline typed::union_pw_multi_aff<Range> apply(const typed::union_pw_aff<Domain, Range> &upma2) const;
+  inline typed::multi_union_pw_aff<Domain> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain> as_pw_multi_aff() const;
+  inline typed::union_map<Domain> as_union_map() const = delete;
+  inline typed::union_pw_multi_aff<Domain> coalesce() const;
+  inline typed::union_set<> domain() const;
+  static inline typed::union_pw_multi_aff<Domain> empty(const isl::ctx &ctx);
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::union_set<> &context) const;
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::basic_set<> &context) const;
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::point<> &context) const;
+  inline typed::union_pw_multi_aff<Domain> gist(const typed::set<> &context) const;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::union_pw_multi_aff<Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> preimage_domain_wrapped_domain(const typed::union_pw_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> pullback(const typed::union_pw_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_factor_range() const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain> range_product(const typed::union_pw_aff<> &upma2) const = delete;
+  inline typed::space<> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> sub(const typed::union_pw_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::space<> &space) const = delete;
+  inline typed::union_pw_multi_aff<Domain> subtract_domain(const typed::union_set<> &uset) const = delete;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::pw_multi_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain> union_add(const typed::union_pw_aff<Domain> &upma2) const;
+};
+
+template <typename Domain, typename Range>
+struct union_pw_multi_aff<Domain, Range> : public isl::union_pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  union_pw_multi_aff(const union_pw_multi_aff<Arg1, Arg2> &obj) : isl::union_pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_multi_aff>{}, bool>::type = true>
+  union_pw_multi_aff(const base &obj) : isl::union_pw_multi_aff(obj) {}
+ public:
+  static union_pw_multi_aff from(const isl::union_pw_multi_aff &obj) {
+    return union_pw_multi_aff(obj);
+  }
+  inline /* implicit */ union_pw_multi_aff(const typed::multi_aff<Domain, Range> &ma);
+  inline /* implicit */ union_pw_multi_aff(const typed::pw_multi_aff<Domain, Range> &pma);
+  inline /* implicit */ union_pw_multi_aff(const typed::union_pw_aff<Domain, Range> &upa);
+  inline explicit union_pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> add(const typed::union_pw_aff<Domain, Range> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::pw_multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, Range2> apply(const typed::union_pw_aff<Range, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<Domain, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, Range> as_pw_multi_aff() const;
+  inline typed::union_map<Domain, Range> as_union_map() const;
+  inline typed::union_pw_multi_aff<Domain, Range> coalesce() const;
+  inline typed::union_set<Domain> domain() const;
+  static inline typed::union_pw_multi_aff<Domain, Range> empty(const isl::ctx &ctx);
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::union_set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::point<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, Range> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> preimage_domain_wrapped_domain(const typed::union_pw_aff<> &upma2) const = delete;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, Range> pullback(const typed::union_pw_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::multi_aff<Domain, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::pw_multi_aff<Domain, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> range_product(const typed::union_pw_aff<Domain, Range2> &upma2) const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, Range> get_space() const = delete;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> sub(const typed::union_pw_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, Range> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::pw_multi_aff<Domain, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> union_add(const typed::union_pw_aff<Domain, Range> &upma2) const;
+};
+
+template <typename Domain, typename Domain2, typename Range>
+struct union_pw_multi_aff<pair<Domain, Domain2>, Range> : public isl::union_pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Domain2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{},
+            bool>::type = true>
+  union_pw_multi_aff(const union_pw_multi_aff<pair<Arg1, Arg2>, Arg3> &obj) : isl::union_pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_multi_aff>{}, bool>::type = true>
+  union_pw_multi_aff(const base &obj) : isl::union_pw_multi_aff(obj) {}
+ public:
+  static union_pw_multi_aff from(const isl::union_pw_multi_aff &obj) {
+    return union_pw_multi_aff(obj);
+  }
+  inline /* implicit */ union_pw_multi_aff(const typed::multi_aff<pair<Domain, Domain2>, Range> &ma);
+  inline /* implicit */ union_pw_multi_aff(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &pma);
+  inline /* implicit */ union_pw_multi_aff(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upa);
+  inline explicit union_pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> add(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> add(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> add(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> apply(const typed::multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> apply(const typed::pw_multi_aff<Range, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> apply(const typed::union_pw_aff<Range, Range2> &upma2) const;
+  inline typed::multi_union_pw_aff<pair<Domain, Domain2>, Range> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<Domain, Domain2>, Range> as_pw_multi_aff() const;
+  inline typed::union_map<pair<Domain, Domain2>, Range> as_union_map() const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> coalesce() const;
+  inline typed::union_set<pair<Domain, Domain2>> domain() const;
+  static inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> empty(const isl::ctx &ctx);
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> gist(const typed::union_set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> gist(const typed::basic_set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> gist(const typed::point<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> gist(const typed::set<pair<Domain, Domain2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> intersect_domain(const typed::space<pair<Domain, Domain2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> intersect_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> intersect_params(const typed::point<> &set) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, Domain> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> preimage_domain_wrapped_domain(const typed::union_pw_aff<Domain3, Domain> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Arg3, Range> pullback(const typed::union_pw_multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_multi_aff<pair<Domain, Domain2>> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Arg3, Range> pullback(const typed::multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::multi_aff<pair<Domain, Domain2>> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Arg3, Range> pullback(const typed::pw_multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::pw_multi_aff<pair<Domain, Domain2>> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Arg3, Range> pullback(const typed::union_pw_aff<Arg3, pair<Domain, Domain2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Range> pullback(const typed::union_pw_aff<pair<Domain, Domain2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> range_factor_domain() const = delete;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> range_factor_range() const = delete;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> range_product(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> range_product(const typed::multi_aff<pair<Domain, Domain2>, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> range_product(const typed::pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const;
+  template <typename Range2>
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> range_product(const typed::union_pw_aff<pair<Domain, Domain2>, Range2> &upma2) const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<Domain, Domain2>, Range> get_space() const = delete;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> sub(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> sub(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> sub(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> sub(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> subtract_domain(const typed::space<pair<Domain, Domain2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> subtract_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> union_add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> union_add(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> union_add(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> union_add(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const;
+};
+
+template <typename Domain, typename Range, typename Range2>
+struct union_pw_multi_aff<Domain, pair<Range, Range2>> : public isl::union_pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{} &&
+              std::is_base_of<Range2, Arg3>{},
+            bool>::type = true>
+  union_pw_multi_aff(const union_pw_multi_aff<Arg1, pair<Arg2, Arg3>> &obj) : isl::union_pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_multi_aff>{}, bool>::type = true>
+  union_pw_multi_aff(const base &obj) : isl::union_pw_multi_aff(obj) {}
+ public:
+  static union_pw_multi_aff from(const isl::union_pw_multi_aff &obj) {
+    return union_pw_multi_aff(obj);
+  }
+  inline /* implicit */ union_pw_multi_aff(const typed::multi_aff<Domain, pair<Range, Range2>> &ma);
+  inline /* implicit */ union_pw_multi_aff(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma);
+  inline /* implicit */ union_pw_multi_aff(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upa);
+  inline explicit union_pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> add(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::multi_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, Arg3> apply(const typed::union_pw_aff<pair<Range, Range2>, Arg3> &upma2) const;
+  inline typed::multi_union_pw_aff<Domain, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<Domain, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_map<Domain, pair<Range, Range2>> as_union_map() const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> coalesce() const;
+  inline typed::union_set<Domain> domain() const;
+  static inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> empty(const isl::ctx &ctx);
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::union_set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::point<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> gist(const typed::set<Domain> &context) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<> &upma2) const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_aff<> &upma2) const = delete;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_aff<Domain2, Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_aff<Domain> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, Range> range_factor_domain() const;
+  inline typed::union_pw_multi_aff<Domain, Range2> range_factor_range() const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::multi_aff<Domain, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::pw_multi_aff<Domain, Arg3> &upma2) const;
+  template <typename Arg3>
+  inline typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> range_product(const typed::union_pw_aff<Domain, Arg3> &upma2) const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain, pair<Range, Range2>> get_space() const = delete;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> sub(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::space<Domain> &space) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> subtract_domain(const typed::union_set<Domain> &uset) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<Domain, pair<Range, Range2>> union_add(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const;
+};
+
+template <typename T1, typename T2, typename Range, typename Range2>
+struct union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> : public isl::union_pw_multi_aff {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_pw_multi_aff() = default;
+  template <typename Arg1, typename Arg2, typename Arg3, typename Arg4,
+            typename std::enable_if<
+              std::is_base_of<T1, Arg1>{} &&
+              std::is_base_of<T2, Arg2>{} &&
+              std::is_base_of<Range, Arg3>{} &&
+              std::is_base_of<Range2, Arg4>{},
+            bool>::type = true>
+  union_pw_multi_aff(const union_pw_multi_aff<pair<Arg1, Arg2>, pair<Arg3, Arg4>> &obj) : isl::union_pw_multi_aff(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_pw_multi_aff>{}, bool>::type = true>
+  union_pw_multi_aff(const base &obj) : isl::union_pw_multi_aff(obj) {}
+ public:
+  static union_pw_multi_aff from(const isl::union_pw_multi_aff &obj) {
+    return union_pw_multi_aff(obj);
+  }
+  inline /* implicit */ union_pw_multi_aff(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &ma);
+  inline /* implicit */ union_pw_multi_aff(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma);
+  inline /* implicit */ union_pw_multi_aff(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upa);
+  inline explicit union_pw_multi_aff(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> add(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::multi_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Arg2> apply(const typed::union_pw_aff<pair<Range, Range2>, Arg2> &upma2) const;
+  inline typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> as_multi_union_pw_aff() const;
+  inline typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> as_pw_multi_aff() const;
+  inline typed::union_map<pair<T1, T2>, pair<Range, Range2>> as_union_map() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> coalesce() const;
+  inline typed::union_set<pair<T1, T2>> domain() const;
+  static inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> empty(const isl::ctx &ctx);
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::union_set<pair<T1, T2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::basic_set<pair<T1, T2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::point<pair<T1, T2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> gist(const typed::set<pair<T1, T2>> &context) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> intersect_params(const typed::point<> &set) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, T1> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &upma2) const;
+  template <typename Domain3>
+  inline typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> preimage_domain_wrapped_domain(const typed::union_pw_aff<Domain3, T1> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::multi_aff<pair<T1, T2>> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::pw_multi_aff<pair<T1, T2>> &upma2) const;
+  template <typename Domain2>
+  inline typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> pullback(const typed::union_pw_aff<Domain2, pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<Range, Range2>> pullback(const typed::union_pw_aff<pair<T1, T2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Range> range_factor_domain() const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, Range2> range_factor_range() const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const;
+  template <typename Arg2>
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> range_product(const typed::union_pw_aff<pair<T1, T2>, Arg2> &upma2) const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<T1, T2>, pair<Range, Range2>> get_space() const = delete;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> sub(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::space<pair<T1, T2>> &space) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+  inline typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> union_add(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const;
+};
+
+template <>
+struct union_set<> : public isl::union_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_set() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_set>{}, bool>::type = true>
+  union_set(const base &obj) : isl::union_set(obj) {}
+ public:
+  static union_set from(const isl::union_set &obj) {
+    return union_set(obj);
+  }
+  inline /* implicit */ union_set(const typed::basic_set<> &bset);
+  inline /* implicit */ union_set(const typed::point<> &pnt);
+  inline /* implicit */ union_set(const typed::set<> &set);
+  inline explicit union_set(const isl::ctx &ctx, const std::string &str);
+  inline typed::union_set<> apply(const typed::union_map<> &umap) const = delete;
+  inline typed::union_set<> apply(const typed::basic_map<> &umap) const = delete;
+  inline typed::union_set<> apply(const typed::map<> &umap) const = delete;
+  inline typed::set<> as_set() const = delete;
+  inline typed::union_set<> coalesce() const;
+  inline typed::union_set<> detect_equalities() const;
+  static inline typed::union_set<> empty(const isl::ctx &ctx);
+  inline bool every_set(const std::function<bool(typed::set<>)> &test) const;
+  inline void foreach_point(const std::function<void(typed::point<>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<>)> &fn) const;
+  inline typed::union_set<> gist(const typed::union_set<> &context) const;
+  inline typed::union_set<> gist(const typed::basic_set<> &context) const;
+  inline typed::union_set<> gist(const typed::point<> &context) const;
+  inline typed::union_set<> gist(const typed::set<> &context) const;
+  inline typed::union_map<> identity() const = delete;
+  inline typed::union_set<> intersect(const typed::union_set<> &uset2) const;
+  inline typed::union_set<> intersect(const typed::basic_set<> &uset2) const;
+  inline typed::union_set<> intersect(const typed::point<> &uset2) const;
+  inline typed::union_set<> intersect(const typed::set<> &uset2) const;
+  inline typed::union_set<> intersect_params(const typed::set<> &set) const = delete;
+  inline typed::union_set<> intersect_params(const typed::basic_set<> &set) const = delete;
+  inline typed::union_set<> intersect_params(const typed::point<> &set) const = delete;
+  inline typed::union_set<> lexmax() const = delete;
+  inline typed::union_set<> lexmin() const = delete;
+  inline typed::union_set<> preimage(const typed::multi_aff<> &ma) const = delete;
+  inline typed::union_set<> preimage(const typed::pw_multi_aff<> &pma) const = delete;
+  inline typed::union_set<> preimage(const typed::union_pw_multi_aff<> &upma) const = delete;
+  inline typed::space<> space() const;
+  inline typed::space<> get_space() const = delete;
+  inline typed::union_set<> subtract(const typed::union_set<> &uset2) const;
+  inline typed::union_set<> subtract(const typed::basic_set<> &uset2) const;
+  inline typed::union_set<> subtract(const typed::point<> &uset2) const;
+  inline typed::union_set<> subtract(const typed::set<> &uset2) const;
+  inline typed::union_set<> unite(const typed::union_set<> &uset2) const;
+  inline typed::union_set<> unite(const typed::basic_set<> &uset2) const;
+  inline typed::union_set<> unite(const typed::point<> &uset2) const;
+  inline typed::union_set<> unite(const typed::set<> &uset2) const;
+  inline typed::union_set<> universe() const;
+  inline typed::union_map<> unwrap() const = delete;
+};
+
+template <typename Domain>
+struct union_set<Domain> : public isl::union_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_set() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_set(const union_set<Arg1> &obj) : isl::union_set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_set>{}, bool>::type = true>
+  union_set(const base &obj) : isl::union_set(obj) {}
+ public:
+  static union_set from(const isl::union_set &obj) {
+    return union_set(obj);
+  }
+  inline /* implicit */ union_set(const typed::basic_set<Domain> &bset);
+  inline /* implicit */ union_set(const typed::point<Domain> &pnt);
+  inline /* implicit */ union_set(const typed::set<Domain> &set);
+  inline explicit union_set(const isl::ctx &ctx, const std::string &str);
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::union_map<Domain, Range> &umap) const;
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::basic_map<Domain, Range> &umap) const;
+  template <typename Range>
+  inline typed::union_set<Range> apply(const typed::map<Domain, Range> &umap) const;
+  inline typed::set<Domain> as_set() const;
+  inline typed::union_set<Domain> coalesce() const;
+  inline typed::union_set<Domain> detect_equalities() const;
+  static inline typed::union_set<Domain> empty(const isl::ctx &ctx);
+  inline bool every_set(const std::function<bool(typed::set<Domain>)> &test) const;
+  inline void foreach_point(const std::function<void(typed::point<Domain>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<Domain>)> &fn) const;
+  inline typed::union_set<Domain> gist(const typed::union_set<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::basic_set<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::point<Domain> &context) const;
+  inline typed::union_set<Domain> gist(const typed::set<Domain> &context) const;
+  inline typed::union_map<Domain, Domain> identity() const;
+  inline typed::union_set<Domain> intersect(const typed::union_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> intersect(const typed::basic_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> intersect(const typed::point<Domain> &uset2) const;
+  inline typed::union_set<Domain> intersect(const typed::set<Domain> &uset2) const;
+  inline typed::union_set<Domain> intersect_params(const typed::set<> &set) const;
+  inline typed::union_set<Domain> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_set<Domain> intersect_params(const typed::point<> &set) const;
+  inline typed::union_set<Domain> lexmax() const;
+  inline typed::union_set<Domain> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::multi_aff<Domain2, Domain> &ma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const;
+  inline typed::space<> space() const;
+  inline typed::space<Domain> get_space() const = delete;
+  inline typed::union_set<Domain> subtract(const typed::union_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> subtract(const typed::basic_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> subtract(const typed::point<Domain> &uset2) const;
+  inline typed::union_set<Domain> subtract(const typed::set<Domain> &uset2) const;
+  inline typed::union_set<Domain> unite(const typed::union_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> unite(const typed::basic_set<Domain> &uset2) const;
+  inline typed::union_set<Domain> unite(const typed::point<Domain> &uset2) const;
+  inline typed::union_set<Domain> unite(const typed::set<Domain> &uset2) const;
+  inline typed::union_set<Domain> universe() const;
+  inline typed::union_map<Domain> unwrap() const = delete;
+};
+
+template <typename Domain, typename Range>
+struct union_set<pair<Domain, Range>> : public isl::union_set {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_set() = default;
+  template <typename Arg1, typename Arg2,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{} &&
+              std::is_base_of<Range, Arg2>{},
+            bool>::type = true>
+  union_set(const union_set<pair<Arg1, Arg2>> &obj) : isl::union_set(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_set>{}, bool>::type = true>
+  union_set(const base &obj) : isl::union_set(obj) {}
+ public:
+  static union_set from(const isl::union_set &obj) {
+    return union_set(obj);
+  }
+  inline /* implicit */ union_set(const typed::basic_set<pair<Domain, Range>> &bset);
+  inline /* implicit */ union_set(const typed::point<pair<Domain, Range>> &pnt);
+  inline /* implicit */ union_set(const typed::set<pair<Domain, Range>> &set);
+  inline explicit union_set(const isl::ctx &ctx, const std::string &str);
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const;
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::basic_map<pair<Domain, Range>, Arg2> &umap) const;
+  template <typename Arg2>
+  inline typed::union_set<Arg2> apply(const typed::map<pair<Domain, Range>, Arg2> &umap) const;
+  inline typed::set<pair<Domain, Range>> as_set() const;
+  inline typed::union_set<pair<Domain, Range>> coalesce() const;
+  inline typed::union_set<pair<Domain, Range>> detect_equalities() const;
+  static inline typed::union_set<pair<Domain, Range>> empty(const isl::ctx &ctx);
+  inline bool every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const;
+  inline void foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const;
+  inline void foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::union_set<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::basic_set<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::point<pair<Domain, Range>> &context) const;
+  inline typed::union_set<pair<Domain, Range>> gist(const typed::set<pair<Domain, Range>> &context) const;
+  inline typed::union_map<pair<Domain, Range>, pair<Domain, Range>> identity() const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::basic_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::point<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect(const typed::set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> intersect_params(const typed::set<> &set) const;
+  inline typed::union_set<pair<Domain, Range>> intersect_params(const typed::basic_set<> &set) const;
+  inline typed::union_set<pair<Domain, Range>> intersect_params(const typed::point<> &set) const;
+  inline typed::union_set<pair<Domain, Range>> lexmax() const;
+  inline typed::union_set<pair<Domain, Range>> lexmin() const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const;
+  template <typename Domain2>
+  inline typed::union_set<Domain2> preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const;
+  inline typed::space<> space() const;
+  inline typed::space<pair<Domain, Range>> get_space() const = delete;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::basic_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::point<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> subtract(const typed::set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::union_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::basic_set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::point<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> unite(const typed::set<pair<Domain, Range>> &uset2) const;
+  inline typed::union_set<pair<Domain, Range>> universe() const;
+  inline typed::union_map<Domain, Range> unwrap() const;
+};
+
+template <>
+struct union_set_list<> : public isl::union_set_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_set_list() = default;
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_set_list>{}, bool>::type = true>
+  union_set_list(const base &obj) : isl::union_set_list(obj) {}
+ public:
+  static union_set_list from(const isl::union_set_list &obj) {
+    return union_set_list(obj);
+  }
+  inline explicit union_set_list(const isl::ctx &ctx, int n);
+  inline explicit union_set_list(const typed::union_set<> &el);
+  inline typed::union_set_list<> add(const typed::union_set<> &el) const;
+  inline typed::union_set_list<> add(const typed::basic_set<> &el) const;
+  inline typed::union_set_list<> add(const typed::point<> &el) const;
+  inline typed::union_set_list<> add(const typed::set<> &el) const;
+  inline typed::union_set<> at(int index) const = delete;
+  inline typed::union_set<> get_at(int index) const = delete;
+  inline typed::union_set_list<> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::union_set<>)> &fn) const;
+};
+
+template <typename Domain>
+struct union_set_list<Domain> : public isl::union_set_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  union_set_list() = default;
+  template <typename Arg1,
+            typename std::enable_if<
+              std::is_base_of<Domain, Arg1>{},
+            bool>::type = true>
+  union_set_list(const union_set_list<Arg1> &obj) : isl::union_set_list(obj) {}
+ private:
+  template <typename base,
+            typename std::enable_if<
+              std::is_same<base, isl::union_set_list>{}, bool>::type = true>
+  union_set_list(const base &obj) : isl::union_set_list(obj) {}
+ public:
+  static union_set_list from(const isl::union_set_list &obj) {
+    return union_set_list(obj);
+  }
+  inline explicit union_set_list(const isl::ctx &ctx, int n);
+  inline explicit union_set_list(const typed::union_set<Domain> &el);
+  inline typed::union_set_list<Domain> add(const typed::union_set<Domain> &el) const;
+  inline typed::union_set_list<Domain> add(const typed::basic_set<Domain> &el) const;
+  inline typed::union_set_list<Domain> add(const typed::point<Domain> &el) const;
+  inline typed::union_set_list<Domain> add(const typed::set<Domain> &el) const;
+  inline typed::union_set<Domain> at(int index) const;
+  inline typed::union_set<Domain> get_at(int index) const = delete;
+  inline typed::union_set_list<Domain> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::union_set<Domain>)> &fn) const;
+};
+
+template <>
+struct val<Anonymous> : public isl::val {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  val() = default;
+  val(const isl::val &obj) : isl::val(obj) {}
+  static val from(const isl::val &obj) {
+    return val(obj);
+  }
+  inline explicit val(const isl::ctx &ctx, long i);
+  inline explicit val(const isl::ctx &ctx, const std::string &str);
+  inline typed::val<Anonymous> add(const typed::val<Anonymous> &v2) const;
+  inline typed::val<Anonymous> add(long v2) const;
+  inline long get_den_si() const = delete;
+  inline typed::val<Anonymous> floor() const;
+  inline typed::val<Anonymous> max(const typed::val<Anonymous> &v2) const;
+  inline typed::val<Anonymous> max(long v2) const;
+  inline typed::val<Anonymous> min(const typed::val<Anonymous> &v2) const;
+  inline typed::val<Anonymous> min(long v2) const;
+  inline typed::val<Anonymous> mod(const typed::val<Anonymous> &v2) const;
+  inline typed::val<Anonymous> mod(long v2) const;
+  inline typed::val<Anonymous> neg() const;
+  inline long get_num_si() const = delete;
+  inline typed::val<Anonymous> sub(const typed::val<Anonymous> &v2) const;
+  inline typed::val<Anonymous> sub(long v2) const;
+};
+
+template <>
+struct val_list<Anonymous> : public isl::val_list {
+  template <typename...>
+  friend struct aff;
+  template <typename...>
+  friend struct aff_list;
+  template <typename...>
+  friend struct basic_map;
+  template <typename...>
+  friend struct basic_set;
+  template <typename...>
+  friend struct fixed_box;
+  template <typename...>
+  friend struct id;
+  template <typename...>
+  friend struct id_list;
+  template <typename...>
+  friend struct map;
+  template <typename...>
+  friend struct multi_aff;
+  template <typename...>
+  friend struct multi_id;
+  template <typename...>
+  friend struct multi_pw_aff;
+  template <typename...>
+  friend struct multi_union_pw_aff;
+  template <typename...>
+  friend struct multi_val;
+  template <typename...>
+  friend struct point;
+  template <typename...>
+  friend struct pw_aff;
+  template <typename...>
+  friend struct pw_aff_list;
+  template <typename...>
+  friend struct pw_multi_aff;
+  template <typename...>
+  friend struct pw_multi_aff_list;
+  template <typename...>
+  friend struct set;
+  template <typename...>
+  friend struct space;
+  template <typename...>
+  friend struct union_map;
+  template <typename...>
+  friend struct union_pw_aff;
+  template <typename...>
+  friend struct union_pw_aff_list;
+  template <typename...>
+  friend struct union_pw_multi_aff;
+  template <typename...>
+  friend struct union_set;
+  template <typename...>
+  friend struct union_set_list;
+  template <typename...>
+  friend struct val;
+  template <typename...>
+  friend struct val_list;
+
+  val_list() = default;
+  val_list(const isl::val_list &obj) : isl::val_list(obj) {}
+  static val_list from(const isl::val_list &obj) {
+    return val_list(obj);
+  }
+  inline explicit val_list(const isl::ctx &ctx, int n);
+  inline explicit val_list(const typed::val<Anonymous> &el);
+  inline typed::val_list<Anonymous> add(const typed::val<Anonymous> &el) const;
+  inline typed::val_list<Anonymous> add(long el) const;
+  inline typed::val<Anonymous> at(int index) const;
+  inline typed::val<Anonymous> get_at(int index) const = delete;
+  inline typed::val_list<Anonymous> drop(unsigned int first, unsigned int n) const;
+  inline void foreach(const std::function<void(typed::val<Anonymous>)> &fn) const;
+};
+
+typed::aff<Anonymous>::aff(const isl::ctx &ctx, const std::string &str)
+  : isl::aff(ctx, str)
+{
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::add(const typed::aff<Anonymous> &aff2) const
+{
+  auto res = isl::aff::add(aff2);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::add(const typed::multi_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::add(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::add(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::add(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::aff<Anonymous>::add(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::aff::add(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::aff<Anonymous>::add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::aff::add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::aff<Anonymous>::add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::aff::add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::add_constant(long v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::add_constant(mv);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::aff<Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const
+{
+  auto res = isl::aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::as_aff() const
+{
+  auto res = isl::aff::as_aff();
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::as_multi_aff() const
+{
+  auto res = isl::aff::as_multi_aff();
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::aff<Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::set<Anonymous> typed::aff<Anonymous>::as_set() const
+{
+  auto res = isl::aff::as_set();
+  return typed::set<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::at(int pos) const
+{
+  auto res = isl::aff::at(pos);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::basic_set<> typed::aff<Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<>(res);
+}
+
+typed::basic_set<> typed::aff<Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<>(res);
+}
+
+typed::basic_set<> typed::aff<Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::aff::bind(tuple);
+  return typed::basic_set<>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::coalesce() const
+{
+  auto res = isl::aff::coalesce();
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_val<Anonymous> typed::aff<Anonymous>::constant_multi_val() const
+{
+  auto res = isl::aff::constant_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+typed::set<> typed::aff<Anonymous>::domain() const
+{
+  auto res = isl::aff::domain();
+  return typed::set<>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::floor() const
+{
+  auto res = isl::aff::floor();
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::gist(const typed::set<> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::aff<Anonymous>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::gist(const typed::point<> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous, Anonymous> typed::aff<Anonymous>::identity() const
+{
+  auto res = isl::aff::identity();
+  return typed::multi_aff<Anonymous, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Anonymous>::insert_domain(const typed::space<Domain> &domain) const
+{
+  auto res = isl::aff::insert_domain(domain);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::aff::intersect_params(set);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::aff_list<Anonymous> typed::aff<Anonymous>::list() const
+{
+  auto res = isl::aff::list();
+  return typed::aff_list<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::max(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::max(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::max(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::max(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_val<Anonymous> typed::aff<Anonymous>::max_multi_val() const
+{
+  auto res = isl::aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::min(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::min(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::min(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::min(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_val<Anonymous> typed::aff<Anonymous>::min_multi_val() const
+{
+  auto res = isl::aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::mod(long mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::neg() const
+{
+  auto res = isl::aff::neg();
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Range>
+typed::multi_aff<pair<Anonymous, Range>> typed::aff<Anonymous>::product(const typed::multi_aff<Range> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_aff<pair<Anonymous, Range>>(res);
+}
+
+template <typename Range>
+typed::multi_pw_aff<pair<Anonymous, Range>> typed::aff<Anonymous>::product(const typed::multi_pw_aff<Range> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_pw_aff<pair<Anonymous, Range>>(res);
+}
+
+template <typename Range>
+typed::pw_multi_aff<pair<Anonymous, Range>> typed::aff<Anonymous>::product(const typed::pw_multi_aff<Range> &pma2) const
+{
+  auto res = isl::aff::product(pma2);
+  return typed::pw_multi_aff<pair<Anonymous, Range>>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::scale(long v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale(mv);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::scale_down(long v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale_down(mv);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::set_at(int pos, const typed::aff<Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::set_at(int pos, const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2>
+typed::multi_aff<Domain2> typed::aff<Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<Domain2>(res);
+}
+
+template <typename Domain2>
+typed::multi_aff<Domain2> typed::aff<Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<Domain2>(res);
+}
+
+typed::space<Anonymous> typed::aff<Anonymous>::space() const
+{
+  auto res = isl::aff::space();
+  return typed::space<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff<Anonymous>::sub(const typed::aff<Anonymous> &aff2) const
+{
+  auto res = isl::aff::sub(aff2);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::multi_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::sub(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::aff::sub(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::aff::sub(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::aff<Anonymous>::sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::aff::sub(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::to_multi_union_pw_aff() const
+{
+  auto res = isl::aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::aff<Anonymous>::to_pw_multi_aff() const
+{
+  auto res = isl::aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::aff<Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::aff::to_union_pw_aff();
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::aff<Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Anonymous>::unbind_params_insert_domain(const typed::multi_id<Domain> &domain) const
+{
+  auto res = isl::aff::unbind_params_insert_domain(domain);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::multi_pw_aff<Anonymous> &mpa2) const
+{
+  auto res = isl::aff::union_add(mpa2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const
+{
+  auto res = isl::aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::union_add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::aff::union_add(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::aff::union_add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::aff<Anonymous>::union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous>::aff(const isl::ctx &ctx, const std::string &str)
+  : isl::aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::add(aff2);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::multi_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::aff::add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add_constant(long v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::add_constant(mv);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::aff<Domain, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const
+{
+  auto res = isl::aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_aff() const
+{
+  auto res = isl::aff::as_aff();
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_map() const
+{
+  auto res = isl::aff::as_map();
+  return typed::map<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_multi_aff() const
+{
+  auto res = isl::aff::as_multi_aff();
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Anonymous> typed::aff<Domain, Anonymous>::as_union_map() const
+{
+  auto res = isl::aff::as_union_map();
+  return typed::union_map<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::at(int pos) const
+{
+  auto res = isl::aff::at(pos);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::aff<Domain, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::aff<Domain, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::aff<Domain, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::aff::bind(tuple);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::aff<Domain, Anonymous>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::aff::bind_domain(tuple);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::coalesce() const
+{
+  auto res = isl::aff::coalesce();
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Anonymous> typed::aff<Domain, Anonymous>::constant_multi_val() const
+{
+  auto res = isl::aff::constant_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::domain() const
+{
+  auto res = isl::aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::floor() const
+{
+  auto res = isl::aff::floor();
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::ge_set(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::ge_set(aff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::ge_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::ge_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::gt_set(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::gt_set(aff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::gt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::gt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::identity() const
+{
+  auto res = isl::aff::identity();
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::aff::intersect_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::aff::intersect_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::aff::intersect_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::aff::intersect_params(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::le_set(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::le_set(aff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::le_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::le_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff_list<Domain, Anonymous> typed::aff<Domain, Anonymous>::list() const
+{
+  auto res = isl::aff::list();
+  return typed::aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::lt_set(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::lt_set(aff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::aff<Domain, Anonymous>::lt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::lt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::max(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::max(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::max(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Anonymous> typed::aff<Domain, Anonymous>::max_multi_val() const
+{
+  auto res = isl::aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::min(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::min(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::min(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Anonymous> typed::aff<Domain, Anonymous>::min_multi_val() const
+{
+  auto res = isl::aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::mod(long mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::neg() const
+{
+  auto res = isl::aff::neg();
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::product(const typed::multi_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::aff<Domain2, Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_aff<Domain2, Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::aff::pullback(mpa);
+  return typed::pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::multi_pw_aff<Domain> &mpa) const
+{
+  auto res = isl::aff::pullback(mpa);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_aff<Domain2, Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::aff::pullback(pma);
+  return typed::pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain> &pma) const
+{
+  auto res = isl::aff::pullback(pma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::aff<Domain2, Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Anonymous> typed::aff<Domain, Anonymous>::pullback(const typed::aff<Domain> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_aff<Domain, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::range_product(const typed::multi_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> typed::aff<Domain, Anonymous>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale(long v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale(mv);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale_down(long v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale_down(mv);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::set_at(int pos, const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_aff<Domain, Range2> typed::aff<Domain, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_aff<Domain, Range2> typed::aff<Domain, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain, Anonymous> typed::aff<Domain, Anonymous>::space() const
+{
+  auto res = isl::aff::space();
+  return typed::space<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::aff<Domain, Anonymous> &aff2) const
+{
+  auto res = isl::aff::sub(aff2);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::multi_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::sub(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::aff::sub(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::aff::subtract_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::aff::subtract_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::aff::subtract_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::to_multi_union_pw_aff() const
+{
+  auto res = isl::aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::to_pw_multi_aff() const
+{
+  auto res = isl::aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::aff::to_union_pw_aff();
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::multi_pw_aff<Domain, Anonymous> &mpa2) const
+{
+  auto res = isl::aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const
+{
+  auto res = isl::aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::union_add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::aff::union_add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::aff<Domain, Anonymous>::union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous>::aff(const isl::ctx &ctx, const std::string &str)
+  : isl::aff(ctx, str)
+{
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::add(aff2);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::multi_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::aff::add(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add_constant(long v) const
+{
+  auto res = isl::aff::add_constant(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::add_constant(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::aff<pair<Domain2, Range2>, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Arg1> &upma2) const
+{
+  auto res = isl::aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_aff() const
+{
+  auto res = isl::aff::as_aff();
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_map() const
+{
+  auto res = isl::aff::as_map();
+  return typed::map<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_multi_aff() const
+{
+  auto res = isl::aff::as_multi_aff();
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::as_union_map() const
+{
+  auto res = isl::aff::as_union_map();
+  return typed::union_map<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::at(int pos) const
+{
+  auto res = isl::aff::at(pos);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::basic_set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::basic_set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::aff::bind(id);
+  return typed::basic_set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::basic_set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::aff::bind(tuple);
+  return typed::basic_set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const
+{
+  auto res = isl::aff::bind_domain(tuple);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Range2, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const
+{
+  auto res = isl::aff::bind_domain_wrapped_domain(tuple);
+  return typed::pw_aff<Range2, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::coalesce() const
+{
+  auto res = isl::aff::coalesce();
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_val<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::constant_multi_val() const
+{
+  auto res = isl::aff::constant_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::domain() const
+{
+  auto res = isl::aff::domain();
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::floor() const
+{
+  auto res = isl::aff::floor();
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::ge_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::ge_set(aff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::ge_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::ge_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::union_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::basic_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::point<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::aff::gist(context);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::gt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::gt_set(aff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::gt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::gt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::identity() const
+{
+  auto res = isl::aff::identity();
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::aff::intersect_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::aff::intersect_domain(space);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::aff::intersect_domain(uset);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::aff::intersect_params(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::le_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::le_set(aff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::le_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::le_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff_list<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::list() const
+{
+  auto res = isl::aff::list();
+  return typed::aff_list<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::lt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::lt_set(aff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::aff<pair<Domain2, Range2>, Anonymous>::lt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::lt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::max(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::max(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::max(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_val<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::max_multi_val() const
+{
+  auto res = isl::aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::min(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::min(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::min(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_val<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::min_multi_val() const
+{
+  auto res = isl::aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::mod(long mod) const
+{
+  auto res = isl::aff::mod(mod);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::neg() const
+{
+  auto res = isl::aff::neg();
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const
+{
+  auto res = isl::aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1, typename Arg2>
+typed::multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> typed::aff<pair<Domain2, Range2>, Anonymous>::product(const typed::multi_aff<Arg1, Arg2> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1, typename Arg2>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> typed::aff<pair<Domain2, Range2>, Anonymous>::product(const typed::multi_pw_aff<Arg1, Arg2> &multi2) const
+{
+  auto res = isl::aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1, typename Arg2>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> typed::aff<pair<Domain2, Range2>, Anonymous>::product(const typed::pw_multi_aff<Arg1, Arg2> &pma2) const
+{
+  auto res = isl::aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::aff<Arg1, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_aff<Arg1, pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_aff<Arg1, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_pw_aff<Arg1, pair<Domain2, Range2>> &mpa) const
+{
+  auto res = isl::aff::pullback(mpa);
+  return typed::pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa) const
+{
+  auto res = isl::aff::pullback(mpa);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_aff<Arg1, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::pw_multi_aff<Arg1, pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::aff::pullback(pma);
+  return typed::pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::aff::pullback(pma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_aff<Arg1, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::union_pw_multi_aff<Arg1, pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::aff::pullback(upma);
+  return typed::union_pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::aff<Arg1, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::aff<Arg1, pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::aff<pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::aff::pullback(ma);
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg1> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const
+{
+  auto res = isl::aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> &pma2) const
+{
+  auto res = isl::aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> &upma2) const
+{
+  auto res = isl::aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale(long v) const
+{
+  auto res = isl::aff::scale(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale_down(long v) const
+{
+  auto res = isl::aff::scale_down(v);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::aff::scale_down(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::set_at(int pos, const typed::aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_aff<pair<Domain2, Range2>, Arg1> typed::aff<pair<Domain2, Range2>, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_aff<pair<Domain2, Range2>, Arg1> typed::aff<pair<Domain2, Range2>, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::aff::set_range_tuple(id);
+  return typed::multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::space<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::space() const
+{
+  auto res = isl::aff::space();
+  return typed::space<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff2) const
+{
+  auto res = isl::aff::sub(aff2);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::multi_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::sub(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::aff::sub(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::aff::subtract_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::aff::subtract_domain(space);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::aff::subtract_domain(uset);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::to_multi_union_pw_aff() const
+{
+  auto res = isl::aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::to_pw_multi_aff() const
+{
+  auto res = isl::aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::aff::to_union_pw_aff();
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &mpa2) const
+{
+  auto res = isl::aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &mupa2) const
+{
+  auto res = isl::aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::aff::union_add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::aff::union_add(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+typed::aff_list<Anonymous>::aff_list(const isl::ctx &ctx, int n)
+  : isl::aff_list(ctx, n)
+{
+}
+
+typed::aff_list<Anonymous>::aff_list(const typed::aff<Anonymous> &el)
+  : isl::aff_list(el)
+{
+}
+
+typed::aff_list<Anonymous> typed::aff_list<Anonymous>::add(const typed::aff<Anonymous> &el) const
+{
+  auto res = isl::aff_list::add(el);
+  return typed::aff_list<Anonymous>(res);
+}
+
+typed::aff<Anonymous> typed::aff_list<Anonymous>::at(int index) const
+{
+  auto res = isl::aff_list::at(index);
+  return typed::aff<Anonymous>(res);
+}
+
+typed::aff_list<Anonymous> typed::aff_list<Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::aff_list::drop(first, n);
+  return typed::aff_list<Anonymous>(res);
+}
+
+void typed::aff_list<Anonymous>::foreach(const std::function<void(typed::aff<Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::aff arg0) {
+    return fn(typed::aff<Anonymous>(arg0));
+  };
+  return isl::aff_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::aff_list<Domain, Anonymous>::aff_list(const isl::ctx &ctx, int n)
+  : isl::aff_list(ctx, n)
+{
+}
+
+template <typename Domain>
+typed::aff_list<Domain, Anonymous>::aff_list(const typed::aff<Domain, Anonymous> &el)
+  : isl::aff_list(el)
+{
+}
+
+template <typename Domain>
+typed::aff_list<Domain, Anonymous> typed::aff_list<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::aff_list::add(el);
+  return typed::aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::aff_list<Domain, Anonymous>::at(int index) const
+{
+  auto res = isl::aff_list::at(index);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::aff_list<Domain, Anonymous> typed::aff_list<Domain, Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::aff_list::drop(first, n);
+  return typed::aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+void typed::aff_list<Domain, Anonymous>::foreach(const std::function<void(typed::aff<Domain, Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::aff arg0) {
+    return fn(typed::aff<Domain, Anonymous>(arg0));
+  };
+  return isl::aff_list::foreach(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::basic_map<Domain2, Range> typed::basic_map<Domain, Range>::apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::basic_map<Domain, Range>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::basic_map<Domain, Range2> typed::basic_map<Domain, Range>::apply_range(const typed::basic_map<Range, Range2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Range>::apply_range(const typed::map<Range, Range2> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::basic_map<Domain, Range>::apply_range(const typed::union_map<Range, Range2> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::basic_map<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::basic_map<Domain, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::basic_map<Domain, Range>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Range> typed::basic_map<Domain, Range>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::basic_map<Domain, Range>::bind_range(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::basic_map<Domain, Range>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Domain> typed::basic_map<Domain, Range>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Range>, Domain> typed::basic_map<Domain, Range>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Range> typed::basic_map<Domain, Range>::domain_product(const typed::map<Domain2, Range> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Range> typed::basic_map<Domain, Range>::domain_product(const typed::union_map<Domain2, Range> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::basic_map<Domain, Range>::every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Range>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::basic_map<Domain, Range>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, Range>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::basic_map<Domain, Range>::foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Range>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::gist(const typed::basic_map<Domain, Range> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::gist(const typed::map<Domain, Range> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::gist(const typed::union_map<Domain, Range> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::intersect(const typed::basic_map<Domain, Range> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::intersect(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::intersect(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_domain(const typed::basic_set<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_domain(const typed::point<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_range(const typed::basic_set<Range> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::intersect_range(const typed::set<Range> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_range(const typed::space<Range> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_range(const typed::union_set<Range> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Domain, Range> typed::basic_map<Domain, Range>::intersect_range(const typed::point<Range> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::basic_map<Domain, Range>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::basic_map<Domain, Range>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::lower_bound(const typed::multi_pw_aff<Domain, Range> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::basic_map<Domain, Range>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::basic_map<Domain, Range>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::basic_map<Domain, Range>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Range>::preimage_range(const typed::multi_aff<Range2, Range> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Range>::preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::basic_map<Domain, Range>::preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::basic_map<Domain, Range>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::basic_map<Domain, Range>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Range> typed::basic_map<Domain, Range>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Range> typed::basic_map<Domain, Range>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<Domain, Range>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, Range>::range_product(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, Range>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::fixed_box<Domain, Range> typed::basic_map<Domain, Range>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_map<Range, Domain> typed::basic_map<Domain, Range>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<Range, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::basic_map<Domain, Range>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::basic_map<Domain, Range>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::subtract(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::subtract(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::subtract_range(const typed::union_set<Range> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::unite(const typed::basic_map<Domain, Range> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::unite(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::basic_map<Domain, Range>::unite(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_map<Domain, Range>::upper_bound(const typed::multi_pw_aff<Domain, Range> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_map<Domain, Range>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::basic_map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::apply_domain(const typed::map<pair<Domain, Range>, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::basic_map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::apply_range(const typed::basic_map<Range2, Arg3> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::apply_range(const typed::map<Range2, Arg3> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::apply_range(const typed::union_map<Range2, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Range2> typed::basic_map<pair<Domain, Range>, Range2>::bind_domain(const typed::multi_id<pair<Domain, Range>> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, Range>> typed::basic_map<pair<Domain, Range>, Range2>::bind_range(const typed::multi_id<Range2> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<pair<Domain, Range>, Range2>::curry() const
+{
+  auto res = isl::basic_map::curry();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, Range>> typed::basic_map<pair<Domain, Range>, Range2>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range2> typed::basic_map<pair<Domain, Range>, Range2>::domain_factor_domain() const
+{
+  auto res = isl::basic_map::domain_factor_domain();
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Range, Range2> typed::basic_map<pair<Domain, Range>, Range2>::domain_factor_range() const
+{
+  auto res = isl::basic_map::domain_factor_range();
+  return typed::map<Range, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::basic_map<pair<Domain, Range>, Range2>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::basic_map<pair<Domain, Range>, Range2>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<Domain, Range>, Domain2>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::domain_product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::domain_product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::basic_map<pair<Domain, Range>, Range2>::every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Anonymous, Range2> typed::basic_map<pair<Domain, Range>, Range2>::flatten_domain() const
+{
+  auto res = isl::basic_map::flatten_domain();
+  return typed::basic_map<Anonymous, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::basic_map<pair<Domain, Range>, Range2>::foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::basic_map<pair<Domain, Range>, Range2>::foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::gist(const typed::map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::gist_domain(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect(const typed::basic_map<pair<Domain, Range>, Range2> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::basic_set<pair<Domain, Range>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::set<pair<Domain, Range>> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::space<pair<Domain, Range>> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::point<pair<Domain, Range>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_range(const typed::basic_set<Range2> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_range(const typed::set<Range2> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_range(const typed::space<Range2> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_range(const typed::union_set<Range2> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::intersect_range(const typed::point<Range2> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::lower_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::basic_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::basic_map<pair<Domain, Range>, Range2>::preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::basic_map<pair<Domain, Range>, Range2>::product(const typed::map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::basic_map<pair<Domain, Range>, Range2>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Range2> typed::basic_map<pair<Domain, Range>, Range2>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, pair<Range2, Arg3>> typed::basic_map<pair<Domain, Range>, Range2>::range_product(const typed::map<pair<Domain, Range>, Arg3> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> typed::basic_map<pair<Domain, Range>, Range2>::range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::fixed_box<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Range2, pair<Domain, Range>> typed::basic_map<pair<Domain, Range>, Range2>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<Range2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<Domain, Range>, Arg2> typed::basic_map<pair<Domain, Range>, Range2>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<Domain, Range>, Arg2> typed::basic_map<pair<Domain, Range>, Range2>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::subtract(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::subtract_range(const typed::union_set<Range2> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::unite(const typed::basic_map<pair<Domain, Range>, Range2> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::unite(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<pair<Domain, Range>, Range2>::upper_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<pair<Domain, Range>, Range2>> typed::basic_map<pair<Domain, Range>, Range2>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<pair<Domain, Range>, Range2>>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::basic_map<Domain2, Domain> typed::basic_map<Domain, Domain>::apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::basic_map<Domain, Domain>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::basic_map<Domain, Range2> typed::basic_map<Domain, Domain>::apply_range(const typed::basic_map<Domain, Range2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Domain>::apply_range(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::basic_map<Domain, Domain>::apply_range(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Domain> typed::basic_map<Domain, Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::basic_map<Domain, Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Domain> typed::basic_map<Domain, Domain>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_map<Domain, Domain>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_map<Domain, Domain>::bind_range(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_map<Domain, Domain>::deltas() const
+{
+  auto res = isl::basic_map::deltas();
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_map<Domain, Domain>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::basic_map<Domain, Domain>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> typed::basic_map<Domain, Domain>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Domain> typed::basic_map<Domain, Domain>::domain_product(const typed::map<Domain2, Domain> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Domain> typed::basic_map<Domain, Domain>::domain_product(const typed::union_map<Domain2, Domain> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::eq_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::basic_map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const
+{
+  auto res = isl::basic_map::eq_at(mupa);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+bool typed::basic_map<Domain, Domain>::every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename Domain>
+void typed::basic_map<Domain, Domain>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, Domain>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename Domain>
+void typed::basic_map<Domain, Domain>::foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::gist(const typed::basic_map<Domain, Domain> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::gist(const typed::map<Domain, Domain> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::gist(const typed::union_map<Domain, Domain> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect(const typed::basic_map<Domain, Domain> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_domain(const typed::basic_set<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_domain(const typed::point<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_range(const typed::basic_set<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_range(const typed::set<Domain> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_range(const typed::space<Domain> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_range(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::intersect_range(const typed::point<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lex_ge_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lex_gt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lex_le_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lex_lt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::basic_map<Domain, Domain>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::basic_map<Domain, Domain>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::lower_bound(const typed::multi_pw_aff<Domain, Domain> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::basic_map<Domain, Domain>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::basic_map<Domain, Domain>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::basic_map<Domain, Domain>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Domain>::preimage_range(const typed::multi_aff<Range2, Domain> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Domain>::preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::basic_map<Domain, Domain>::preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::basic_map<Domain, Domain>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::basic_map<Domain, Domain>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_map<Domain, Domain>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::basic_map<Domain, Domain>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, pair<Domain, Range2>> typed::basic_map<Domain, Domain>::range_product(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, pair<Domain, Range2>> typed::basic_map<Domain, Domain>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::fixed_box<Domain, Domain> typed::basic_map<Domain, Domain>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_map<Domain, Domain> typed::basic_map<Domain, Domain>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::basic_map<Domain, Domain>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain, Domain> typed::basic_map<Domain, Domain>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::subtract(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::subtract(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::subtract_range(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::unite(const typed::basic_map<Domain, Domain> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::unite(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::basic_map<Domain, Domain>::unite(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_map<Domain, Domain>::upper_bound(const typed::multi_pw_aff<Domain, Domain> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<pair<Domain, Domain>> typed::basic_map<Domain, Domain>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<Domain, Domain>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::basic_map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::apply_domain(const typed::basic_map<Domain, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::basic_map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg3> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::basic_map<Domain, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::basic_map<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> typed::basic_map<Domain, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> typed::basic_map<Domain, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::basic_map<Domain, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, Anonymous> typed::basic_map<Domain, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::basic_map::flatten_range();
+  return typed::basic_map<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::basic_map<Domain, pair<Range, Range2>>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::basic_map<Domain, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::gist(const typed::map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect(const typed::basic_map<Domain, pair<Range, Range2>> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::basic_set<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::point<Domain> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_range(const typed::basic_set<pair<Range, Range2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_range(const typed::set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::intersect_range(const typed::point<pair<Range, Range2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::lower_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::basic_map<Domain, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::basic_map<Domain, pair<Range, Range2>>::product(const typed::map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::basic_map<Domain, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range> typed::basic_map<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::basic_map::range_factor_domain();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range2> typed::basic_map<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::basic_map::range_factor_range();
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, pair<pair<Range, Range2>, Arg3>> typed::basic_map<Domain, pair<Range, Range2>>::range_product(const typed::map<Domain, Arg3> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> typed::basic_map<Domain, pair<Range, Range2>>::range_product(const typed::union_map<Domain, Arg3> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range2, Range>> typed::basic_map<Domain, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::basic_map::range_reverse();
+  return typed::map<Domain, pair<Range2, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::fixed_box<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_map<pair<Range, Range2>, Domain> typed::basic_map<Domain, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<pair<Range, Range2>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::basic_map::set_domain_tuple(id);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::subtract(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::basic_map<Domain, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::basic_map::uncurry();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::unite(const typed::basic_map<Domain, pair<Range, Range2>> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::unite(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::basic_map<Domain, pair<Range, Range2>>::upper_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, pair<Range, Range2>>> typed::basic_map<Domain, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<Domain, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::basic_map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::basic_map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::basic_map<pair<T1, T2>, Range2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T1, pair<T2, pair<T1, T2>>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::curry() const
+{
+  auto res = isl::basic_map::curry();
+  return typed::map<T1, pair<T2, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::deltas() const
+{
+  auto res = isl::basic_map::deltas();
+  return typed::basic_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T1, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_factor_domain() const
+{
+  auto res = isl::basic_map::domain_factor_domain();
+  return typed::map<T1, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_factor_range() const
+{
+  auto res = isl::basic_map::domain_factor_range();
+  return typed::map<T2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::map<Domain2, pair<T1, T2>> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::basic_map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const
+{
+  auto res = isl::basic_map::eq_at(mupa);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+bool typed::basic_map<pair<T1, T2>, pair<T1, T2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<Anonymous, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::flatten_domain() const
+{
+  auto res = isl::basic_map::flatten_domain();
+  return typed::basic_map<Anonymous, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, Anonymous> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::flatten_range() const
+{
+  auto res = isl::basic_map::flatten_range();
+  return typed::basic_map<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2>
+void typed::basic_map<pair<T1, T2>, pair<T1, T2>>::foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename T1, typename T2>
+void typed::basic_map<pair<T1, T2>, pair<T1, T2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::basic_set<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::point<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::basic_set<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::point<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::basic_map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, T1> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_factor_domain() const
+{
+  auto res = isl::basic_map::range_factor_domain();
+  return typed::map<pair<T1, T2>, T1>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, T2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_factor_range() const
+{
+  auto res = isl::basic_map::range_factor_range();
+  return typed::map<pair<T1, T2>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T2, T1>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_reverse() const
+{
+  auto res = isl::basic_map::range_reverse();
+  return typed::map<pair<T1, T2>, pair<T2, T1>>(res);
+}
+
+template <typename T1, typename T2>
+typed::fixed_box<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::basic_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::space<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<pair<T1, T2>, T1>, T2> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::uncurry() const
+{
+  auto res = isl::basic_map::uncurry();
+  return typed::map<pair<pair<T1, T2>, T1>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<pair<T1, T2>, pair<T1, T2>>> typed::basic_map<pair<T1, T2>, pair<T1, T2>>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<pair<T1, T2>, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::basic_map(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_map(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::basic_map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_domain(bmap2);
+  return typed::basic_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::basic_map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::basic_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::basic_map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &bmap2) const
+{
+  auto res = isl::basic_map::apply_range(bmap2);
+  return typed::basic_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg2> &map2) const
+{
+  auto res = isl::basic_map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const
+{
+  auto res = isl::basic_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::basic_map::as_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::basic_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::basic_map::bind_domain(tuple);
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::basic_map::bind_range(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::basic_map::coalesce();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T1, pair<T2, pair<Range, Range2>>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::curry() const
+{
+  auto res = isl::basic_map::curry();
+  return typed::map<T1, pair<T2, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::basic_map::detect_equalities();
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::basic_map::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T1, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_domain() const
+{
+  auto res = isl::basic_map::domain_factor_domain();
+  return typed::map<T1, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_range() const
+{
+  auto res = isl::basic_map::domain_factor_range();
+  return typed::map<T2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::basic_map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::basic_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+bool typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::every_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<Anonymous, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::flatten_domain() const
+{
+  auto res = isl::basic_map::flatten_domain();
+  return typed::basic_map<Anonymous, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, Anonymous> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::basic_map::flatten_range();
+  return typed::basic_map<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+void typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::foreach_basic_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+void typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::basic_map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::basic_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::basic_map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::basic_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap2) const
+{
+  auto res = isl::basic_map::intersect(bmap2);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::basic_set<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::basic_map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::basic_map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::basic_map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::point<pair<T1, T2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_domain(bset);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::basic_set<pair<Range, Range2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::basic_map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::basic_map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::basic_map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::point<pair<Range, Range2>> &bset) const
+{
+  auto res = isl::basic_map::intersect_range(bset);
+  return typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::basic_map::lexmax();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::basic_map::lexmin();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::basic_map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::basic_map::preimage_domain(ma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::basic_map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::basic_map::preimage_domain(pma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::basic_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::basic_map::preimage_range(ma);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::basic_map::preimage_range(pma);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::basic_map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::map<Domain2, Arg2> &map2) const
+{
+  auto res = isl::basic_map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg2> &umap2) const
+{
+  auto res = isl::basic_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::basic_map::project_out_all_params();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range() const
+{
+  auto res = isl::basic_map::range();
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, Range> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::basic_map::range_factor_domain();
+  return typed::map<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::basic_map::range_factor_range();
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::basic_map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::map<pair<T1, T2>, Arg2> &map2) const
+{
+  auto res = isl::basic_map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const
+{
+  auto res = isl::basic_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range2, Range>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::basic_map::range_reverse();
+  return typed::map<pair<T1, T2>, pair<Range2, Range>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::fixed_box<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::basic_map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_map<pair<Range, Range2>, pair<T1, T2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::basic_map::reverse();
+  return typed::basic_map<pair<Range, Range2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::basic_map::space();
+  return typed::space<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::basic_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::basic_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::to_union_map() const
+{
+  auto res = isl::basic_map::to_union_map();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<pair<T1, T2>, Range>, Range2> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::basic_map::uncurry();
+  return typed::map<pair<pair<T1, T2>, Range>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap2) const
+{
+  auto res = isl::basic_map::unite(bmap2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::basic_map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::basic_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::basic_map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<pair<T1, T2>, pair<Range, Range2>>> typed::basic_map<pair<T1, T2>, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::basic_map::wrap();
+  return typed::set<pair<pair<T1, T2>, pair<Range, Range2>>>(res);
+}
+
+typed::basic_set<>::basic_set(const typed::point<> &pnt)
+  : isl::basic_set(pnt)
+{
+}
+
+typed::basic_set<>::basic_set(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_set(ctx, str)
+{
+}
+
+typed::set<> typed::basic_set<>::coalesce() const
+{
+  auto res = isl::basic_set::coalesce();
+  return typed::set<>(res);
+}
+
+typed::basic_set<> typed::basic_set<>::detect_equalities() const
+{
+  auto res = isl::basic_set::detect_equalities();
+  return typed::basic_set<>(res);
+}
+
+bool typed::basic_set<>::every_set(const std::function<bool(typed::set<>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<>(arg0));
+  };
+  return isl::basic_set::every_set(lambda);
+}
+
+void typed::basic_set<>::foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<>(arg0));
+  };
+  return isl::basic_set::foreach_basic_set(lambda);
+}
+
+void typed::basic_set<>::foreach_point(const std::function<void(typed::point<>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<>(arg0));
+  };
+  return isl::basic_set::foreach_point(lambda);
+}
+
+void typed::basic_set<>::foreach_set(const std::function<void(typed::set<>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<>(arg0));
+  };
+  return isl::basic_set::foreach_set(lambda);
+}
+
+typed::basic_set<> typed::basic_set<>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<>(res);
+}
+
+typed::set<> typed::basic_set<>::gist(const typed::set<> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::basic_set<>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::basic_set<> typed::basic_set<>::gist(const typed::point<> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<>(res);
+}
+
+typed::basic_set<> typed::basic_set<>::intersect(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<>(res);
+}
+
+typed::set<> typed::basic_set<>::intersect(const typed::set<> &set2) const
+{
+  auto res = isl::basic_set::intersect(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::basic_set<>::intersect(const typed::union_set<> &uset2) const
+{
+  auto res = isl::basic_set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::basic_set<> typed::basic_set<>::intersect(const typed::point<> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<>(res);
+}
+
+typed::set<> typed::basic_set<>::project_out_all_params() const
+{
+  auto res = isl::basic_set::project_out_all_params();
+  return typed::set<>(res);
+}
+
+typed::set<> typed::basic_set<>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::basic_set<>::project_out_param(const std::string &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::basic_set<>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::basic_set::project_out_param(list);
+  return typed::set<>(res);
+}
+
+typed::space<> typed::basic_set<>::space() const
+{
+  auto res = isl::basic_set::space();
+  return typed::space<>(res);
+}
+
+typed::set<> typed::basic_set<>::subtract(const typed::set<> &set2) const
+{
+  auto res = isl::basic_set::subtract(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::basic_set<>::subtract(const typed::union_set<> &uset2) const
+{
+  auto res = isl::basic_set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::basic_set<>::to_set() const
+{
+  auto res = isl::basic_set::to_set();
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::basic_set<>::to_union_set() const
+{
+  auto res = isl::basic_set::to_union_set();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<>::unbind_params(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_set::unbind_params(tuple);
+  return typed::set<Domain>(res);
+}
+
+typed::set<> typed::basic_set<>::unite(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::basic_set<>::unite(const typed::set<> &set2) const
+{
+  auto res = isl::basic_set::unite(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::basic_set<>::unite(const typed::union_set<> &uset2) const
+{
+  auto res = isl::basic_set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::basic_set<>::unite(const typed::point<> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain>::basic_set(const typed::point<Domain> &pnt)
+  : isl::basic_set(pnt)
+{
+}
+
+template <typename Domain>
+typed::basic_set<Domain>::basic_set(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_set(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Range>
+typed::basic_set<Range> typed::basic_set<Domain>::apply(const typed::basic_map<Domain, Range> &bmap) const
+{
+  auto res = isl::basic_set::apply(bmap);
+  return typed::basic_set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<Range> typed::basic_set<Domain>::apply(const typed::map<Domain, Range> &map) const
+{
+  auto res = isl::basic_set::apply(map);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::basic_set<Domain>::apply(const typed::union_map<Domain, Range> &umap) const
+{
+  auto res = isl::basic_set::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::basic_set<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_set::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::as_set() const
+{
+  auto res = isl::basic_set::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::basic_set<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::basic_set::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::coalesce() const
+{
+  auto res = isl::basic_set::coalesce();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::detect_equalities() const
+{
+  auto res = isl::basic_set::detect_equalities();
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+bool typed::basic_set<Domain>::every_set(const std::function<bool(typed::set<Domain>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<Domain>(arg0));
+  };
+  return isl::basic_set::every_set(lambda);
+}
+
+template <typename Domain>
+void typed::basic_set<Domain>::foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<Domain>(arg0));
+  };
+  return isl::basic_set::foreach_basic_set(lambda);
+}
+
+template <typename Domain>
+void typed::basic_set<Domain>::foreach_point(const std::function<void(typed::point<Domain>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<Domain>(arg0));
+  };
+  return isl::basic_set::foreach_point(lambda);
+}
+
+template <typename Domain>
+void typed::basic_set<Domain>::foreach_set(const std::function<void(typed::set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<Domain>(arg0));
+  };
+  return isl::basic_set::foreach_set(lambda);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::basic_set<Domain>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_set<Domain>::identity() const
+{
+  auto res = isl::basic_set::identity();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::basic_set<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::basic_set::insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::intersect(const typed::basic_set<Domain> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::intersect(const typed::set<Domain> &set2) const
+{
+  auto res = isl::basic_set::intersect(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::basic_set<Domain>::intersect(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::basic_set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::intersect(const typed::point<Domain> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::intersect_params(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::basic_set::intersect_params(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_set::intersect_params(params);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::basic_set<Domain>::intersect_params(const typed::point<> &bset2) const
+{
+  auto res = isl::basic_set::intersect_params(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::lexmax() const
+{
+  auto res = isl::basic_set::lexmax();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::basic_set<Domain>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_set::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::lexmin() const
+{
+  auto res = isl::basic_set::lexmin();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::basic_set<Domain>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_set::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::lower_bound(const typed::multi_pw_aff<Domain> &lower) const
+{
+  auto res = isl::basic_set::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::lower_bound(const typed::multi_val<Domain> &lower) const
+{
+  auto res = isl::basic_set::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::basic_set<Domain>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_set::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::basic_set<Domain>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_set::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<> typed::basic_set<Domain>::params() const
+{
+  auto res = isl::basic_set::params();
+  return typed::basic_set<>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::basic_set<Domain>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::basic_set::plain_multi_val_if_fixed();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<Domain>::preimage(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::basic_set::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<Domain>::preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::basic_set::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<Domain>::preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::basic_set::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::basic_set<Domain>::preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::basic_set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<Domain>::product(const typed::set<Range> &set2) const
+{
+  auto res = isl::basic_set::product(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::project_out_all_params() const
+{
+  auto res = isl::basic_set::project_out_all_params();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::project_out_param(const std::string &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::basic_set::project_out_param(list);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<Domain, Range> typed::basic_set<Domain>::pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::basic_set::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::fixed_box<Domain> typed::basic_set<Domain>::simple_fixed_box_hull() const
+{
+  auto res = isl::basic_set::simple_fixed_box_hull();
+  return typed::fixed_box<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::basic_set<Domain>::space() const
+{
+  auto res = isl::basic_set::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::subtract(const typed::set<Domain> &set2) const
+{
+  auto res = isl::basic_set::subtract(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::basic_set<Domain>::subtract(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::basic_set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::to_set() const
+{
+  auto res = isl::basic_set::to_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::basic_set<Domain>::to_union_set() const
+{
+  auto res = isl::basic_set::to_union_set();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::basic_set<Domain>::translation() const
+{
+  auto res = isl::basic_set::translation();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::basic_set<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::basic_set::unbind_params_insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::unite(const typed::basic_set<Domain> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::unite(const typed::set<Domain> &set2) const
+{
+  auto res = isl::basic_set::unite(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::basic_set<Domain>::unite(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::basic_set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::unite(const typed::point<Domain> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::upper_bound(const typed::multi_pw_aff<Domain> &upper) const
+{
+  auto res = isl::basic_set::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::basic_set<Domain>::upper_bound(const typed::multi_val<Domain> &upper) const
+{
+  auto res = isl::basic_set::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>>::basic_set(const typed::point<pair<Domain, Range>> &pnt)
+  : isl::basic_set(pnt)
+{
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>>::basic_set(const isl::ctx &ctx, const std::string &str)
+  : isl::basic_set(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::basic_set<Arg2> typed::basic_set<pair<Domain, Range>>::apply(const typed::basic_map<pair<Domain, Range>, Arg2> &bmap) const
+{
+  auto res = isl::basic_set::apply(bmap);
+  return typed::basic_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<Arg2> typed::basic_set<pair<Domain, Range>>::apply(const typed::map<pair<Domain, Range>, Arg2> &map) const
+{
+  auto res = isl::basic_set::apply(map);
+  return typed::set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::basic_set<pair<Domain, Range>>::apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::basic_set::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::as_pw_multi_aff() const
+{
+  auto res = isl::basic_set::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::as_set() const
+{
+  auto res = isl::basic_set::as_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<> typed::basic_set<pair<Domain, Range>>::bind(const typed::multi_id<pair<Domain, Range>> &tuple) const
+{
+  auto res = isl::basic_set::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::coalesce() const
+{
+  auto res = isl::basic_set::coalesce();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::detect_equalities() const
+{
+  auto res = isl::basic_set::detect_equalities();
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::basic_set<pair<Domain, Range>>::every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::basic_set::every_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::basic_set<pair<Domain, Range>>::foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<pair<Domain, Range>>(arg0));
+  };
+  return isl::basic_set::foreach_basic_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::basic_set<pair<Domain, Range>>::foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<pair<Domain, Range>>(arg0));
+  };
+  return isl::basic_set::foreach_point(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::basic_set<pair<Domain, Range>>::foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::basic_set::foreach_set(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::gist(const typed::basic_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::gist(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::gist(const typed::union_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::gist(const typed::point<pair<Domain, Range>> &context) const
+{
+  auto res = isl::basic_set::gist(context);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::identity() const
+{
+  auto res = isl::basic_set::identity();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::insert_domain(const typed::space<Arg2> &domain) const
+{
+  auto res = isl::basic_set::insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect(const typed::basic_set<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::basic_set::intersect(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::basic_set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect(const typed::point<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::basic_set::intersect(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect_params(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::basic_set::intersect_params(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::basic_set::intersect_params(params);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::intersect_params(const typed::point<> &bset2) const
+{
+  auto res = isl::basic_set::intersect_params(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lexmax() const
+{
+  auto res = isl::basic_set::lexmax();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::basic_set::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lexmin() const
+{
+  auto res = isl::basic_set::lexmin();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::basic_set::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::basic_set::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::basic_set::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::max_multi_pw_aff() const
+{
+  auto res = isl::basic_set::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::min_multi_pw_aff() const
+{
+  auto res = isl::basic_set::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<> typed::basic_set<pair<Domain, Range>>::params() const
+{
+  auto res = isl::basic_set::params();
+  return typed::basic_set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::basic_set::plain_multi_val_if_fixed();
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<pair<Domain, Range>>::preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::basic_set::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<pair<Domain, Range>>::preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::basic_set::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::basic_set<pair<Domain, Range>>::preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::basic_set::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::basic_set<pair<Domain, Range>>::preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::basic_set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<pair<pair<Domain, Range>, Arg2>> typed::basic_set<pair<Domain, Range>>::product(const typed::set<Arg2> &set2) const
+{
+  auto res = isl::basic_set::product(set2);
+  return typed::set<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::project_out_all_params() const
+{
+  auto res = isl::basic_set::project_out_all_params();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::project_out_param(const std::string &id) const
+{
+  auto res = isl::basic_set::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::basic_set::project_out_param(list);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain, Range>, Arg2> typed::basic_set<pair<Domain, Range>>::pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const
+{
+  auto res = isl::basic_set::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::fixed_box<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::simple_fixed_box_hull() const
+{
+  auto res = isl::basic_set::simple_fixed_box_hull();
+  return typed::fixed_box<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::space() const
+{
+  auto res = isl::basic_set::space();
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::subtract(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::basic_set::subtract(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::subtract(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::basic_set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::to_set() const
+{
+  auto res = isl::basic_set::to_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::to_union_set() const
+{
+  auto res = isl::basic_set::to_union_set();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::translation() const
+{
+  auto res = isl::basic_set::translation();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const
+{
+  auto res = isl::basic_set::unbind_params_insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::unite(const typed::basic_set<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::unite(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::basic_set::unite(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::unite(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::basic_set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::unite(const typed::point<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::basic_set::unite(bset2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::basic_set<pair<Domain, Range>>::unwrap() const
+{
+  auto res = isl::basic_set::unwrap();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::basic_set::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::basic_set<pair<Domain, Range>>::upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::basic_set::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::fixed_box<Domain>::offset() const
+{
+  auto res = isl::fixed_box::offset();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::fixed_box<Domain>::size() const
+{
+  auto res = isl::fixed_box::size();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::fixed_box<Domain>::space() const
+{
+  auto res = isl::fixed_box::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::fixed_box<Domain, Range>::offset() const
+{
+  auto res = isl::fixed_box::offset();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::fixed_box<Domain, Range>::size() const
+{
+  auto res = isl::fixed_box::size();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::fixed_box<Domain, Range>::space() const
+{
+  auto res = isl::fixed_box::space();
+  return typed::space<Domain, Range>(res);
+}
+
+typed::id<Anonymous>::id(const isl::ctx &ctx, const std::string &str)
+  : isl::id(ctx, str)
+{
+}
+
+typed::id_list<Anonymous>::id_list(const isl::ctx &ctx, int n)
+  : isl::id_list(ctx, n)
+{
+}
+
+typed::id_list<Anonymous>::id_list(const typed::id<Anonymous> &el)
+  : isl::id_list(el)
+{
+}
+
+typed::id_list<Anonymous> typed::id_list<Anonymous>::add(const typed::id<Anonymous> &el) const
+{
+  auto res = isl::id_list::add(el);
+  return typed::id_list<Anonymous>(res);
+}
+
+typed::id_list<Anonymous> typed::id_list<Anonymous>::add(const std::string &el) const
+{
+  auto res = isl::id_list::add(el);
+  return typed::id_list<Anonymous>(res);
+}
+
+typed::id<Anonymous> typed::id_list<Anonymous>::at(int index) const
+{
+  auto res = isl::id_list::at(index);
+  return typed::id<Anonymous>(res);
+}
+
+typed::id_list<Anonymous> typed::id_list<Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::id_list::drop(first, n);
+  return typed::id_list<Anonymous>(res);
+}
+
+void typed::id_list<Anonymous>::foreach(const std::function<void(typed::id<Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::id arg0) {
+    return fn(typed::id<Anonymous>(arg0));
+  };
+  return isl::id_list::foreach(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range>::map(const typed::basic_map<Domain, Range> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::map<Domain, Range>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::apply_domain(const typed::basic_map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::apply_range(const typed::map<Range, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::map<Domain, Range>::apply_range(const typed::union_map<Range, Range2> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::apply_range(const typed::basic_map<Range, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::map<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::map<Domain, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::map<Domain, Range>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Range> typed::map<Domain, Range>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::map<Domain, Range>::bind_range(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::map<Domain, Range>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Domain> typed::map<Domain, Range>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Range>, Domain> typed::map<Domain, Range>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Range> typed::map<Domain, Range>::domain_product(const typed::map<Domain2, Range> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Range> typed::map<Domain, Range>::domain_product(const typed::union_map<Domain2, Range> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Range> typed::map<Domain, Range>::domain_product(const typed::basic_map<Domain2, Range> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::map<Domain, Range>::every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Range>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::map<Domain, Range>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, Range>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::map<Domain, Range>::foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Range>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::gist(const typed::map<Domain, Range> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::gist(const typed::union_map<Domain, Range> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::gist(const typed::basic_map<Domain, Range> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::gist_domain(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::gist_domain(const typed::point<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::intersect(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect(const typed::basic_map<Domain, Range> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_range(const typed::set<Range> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::intersect_range(const typed::space<Range> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::intersect_range(const typed::union_set<Range> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_range(const typed::basic_set<Range> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::intersect_range(const typed::point<Range> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::map<Domain, Range>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::map<Domain, Range>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lower_bound(const typed::multi_pw_aff<Domain, Range> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lower_bound(const typed::aff<Domain, Range> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lower_bound(const typed::multi_aff<Domain, Range> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lower_bound(const typed::pw_aff<Domain, Range> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::lower_bound(const typed::pw_multi_aff<Domain, Range> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::map<Domain, Range>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::map<Domain, Range>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::map<Domain, Range>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::preimage_range(const typed::multi_aff<Range2, Range> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::map<Domain, Range>::preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, Range>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, Range>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, Range>::product(const typed::basic_map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Range> typed::map<Domain, Range>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Range> typed::map<Domain, Range>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<Domain, Range>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, Range>::range_product(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, Range>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, Range>::range_product(const typed::basic_map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::fixed_box<Domain, Range> typed::map<Domain, Range>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Range, Domain> typed::map<Domain, Range>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<Range, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::map<Domain2, Range> typed::map<Domain, Range>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::map<Domain, Range>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::subtract(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::subtract(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::subtract(const typed::basic_map<Domain, Range> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::subtract_range(const typed::union_set<Range> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::unite(const typed::map<Domain, Range> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::map<Domain, Range>::unite(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::unite(const typed::basic_map<Domain, Range> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::universe(const typed::space<Domain, Range> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::upper_bound(const typed::multi_pw_aff<Domain, Range> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::upper_bound(const typed::aff<Domain, Range> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::upper_bound(const typed::multi_aff<Domain, Range> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::upper_bound(const typed::pw_aff<Domain, Range> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::map<Domain, Range>::upper_bound(const typed::pw_multi_aff<Domain, Range> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::map<Domain, Range>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2>::map(const typed::basic_map<pair<Domain, Range>, Range2> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::apply_domain(const typed::map<pair<Domain, Range>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::apply_range(const typed::map<Range2, Arg3> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::apply_range(const typed::union_map<Range2, Arg3> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::apply_range(const typed::basic_map<Range2, Arg3> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Range2> typed::map<pair<Domain, Range>, Range2>::bind_domain(const typed::multi_id<pair<Domain, Range>> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, Range>> typed::map<pair<Domain, Range>, Range2>::bind_range(const typed::multi_id<Range2> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<pair<Domain, Range>, Range2>::curry() const
+{
+  auto res = isl::map::curry();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, Range>> typed::map<pair<Domain, Range>, Range2>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range2> typed::map<pair<Domain, Range>, Range2>::domain_factor_domain() const
+{
+  auto res = isl::map::domain_factor_domain();
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Range, Range2> typed::map<pair<Domain, Range>, Range2>::domain_factor_range() const
+{
+  auto res = isl::map::domain_factor_range();
+  return typed::map<Range, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::map<pair<Domain, Range>, Range2>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::map<pair<Domain, Range>, Range2>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<Domain, Range>, Domain2>, Range2> typed::map<pair<Domain, Range>, Range2>::domain_product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> typed::map<pair<Domain, Range>, Range2>::domain_product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<Domain, Range>, Domain2>, Range2> typed::map<pair<Domain, Range>, Range2>::domain_product(const typed::basic_map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::map<pair<Domain, Range>, Range2>::every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Anonymous, Range2> typed::map<pair<Domain, Range>, Range2>::flatten_domain() const
+{
+  auto res = isl::map::flatten_domain();
+  return typed::map<Anonymous, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::map<pair<Domain, Range>, Range2>::foreach_basic_map(const std::function<void(typed::basic_map<pair<Domain, Range>, Range2>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::map<pair<Domain, Range>, Range2>::foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist(const typed::map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist_domain(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist_domain(const typed::basic_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::gist_domain(const typed::point<pair<Domain, Range>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_domain(const typed::set<pair<Domain, Range>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_domain(const typed::space<pair<Domain, Range>> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_domain(const typed::basic_set<pair<Domain, Range>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_domain(const typed::point<pair<Domain, Range>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_range(const typed::set<Range2> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_range(const typed::space<Range2> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_range(const typed::union_set<Range2> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_range(const typed::basic_set<Range2> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::intersect_range(const typed::point<Range2> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lower_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lower_bound(const typed::aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lower_bound(const typed::multi_aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lower_bound(const typed::pw_aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::lower_bound(const typed::pw_multi_aff<pair<Domain, Range>, Range2> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::map<pair<Domain, Range>, Range2>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::map<pair<Domain, Range>, Range2>::preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::product(const typed::map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::product(const typed::basic_map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Range2> typed::map<pair<Domain, Range>, Range2>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> typed::map<pair<Domain, Range>, Range2>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::range_product(const typed::map<pair<Domain, Range>, Arg3> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<pair<Domain, Range>, pair<Range2, Arg3>> typed::map<pair<Domain, Range>, Range2>::range_product(const typed::basic_map<pair<Domain, Range>, Arg3> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::fixed_box<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Range2, pair<Domain, Range>> typed::map<pair<Domain, Range>, Range2>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<Range2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<Domain, Range>, Arg2> typed::map<pair<Domain, Range>, Range2>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<Domain, Range>, Arg2> typed::map<pair<Domain, Range>, Range2>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::subtract(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::subtract(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::subtract_range(const typed::union_set<Range2> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::unite(const typed::map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::unite(const typed::basic_map<pair<Domain, Range>, Range2> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::universe(const typed::space<pair<Domain, Range>, Range2> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::upper_bound(const typed::multi_pw_aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::upper_bound(const typed::aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::upper_bound(const typed::multi_aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::upper_bound(const typed::pw_aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<pair<Domain, Range>, Range2>::upper_bound(const typed::pw_multi_aff<pair<Domain, Range>, Range2> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<pair<Domain, Range>, Range2>> typed::map<pair<Domain, Range>, Range2>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<pair<Domain, Range>, Range2>>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain>::map(const typed::basic_map<Domain, Domain> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename Domain>
+typed::map<Domain, Domain>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::map<Domain, Domain>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::apply_domain(const typed::basic_map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::apply_range(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::map<Domain, Domain>::apply_range(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::apply_range(const typed::basic_map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Domain> typed::map<Domain, Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::map<Domain, Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Domain> typed::map<Domain, Domain>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::map<Domain, Domain>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::map<Domain, Domain>::bind_range(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::map<Domain, Domain>::deltas() const
+{
+  auto res = isl::map::deltas();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::map<Domain, Domain>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::map<Domain, Domain>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> typed::map<Domain, Domain>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Domain> typed::map<Domain, Domain>::domain_product(const typed::map<Domain2, Domain> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Domain> typed::map<Domain, Domain>::domain_product(const typed::union_map<Domain2, Domain> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, Domain> typed::map<Domain, Domain>::domain_product(const typed::basic_map<Domain2, Domain> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const
+{
+  auto res = isl::map::eq_at(mupa);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::eq_at(const typed::pw_multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+bool typed::map<Domain, Domain>::every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename Domain>
+void typed::map<Domain, Domain>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, Domain>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, Domain>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename Domain>
+void typed::map<Domain, Domain>::foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::gist(const typed::map<Domain, Domain> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::gist(const typed::union_map<Domain, Domain> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::gist(const typed::basic_map<Domain, Domain> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::gist_domain(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::gist_domain(const typed::point<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::intersect(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect(const typed::basic_map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_range(const typed::set<Domain> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::intersect_range(const typed::space<Domain> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::intersect_range(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_range(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::intersect_range(const typed::point<Domain> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_ge_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_ge_at(const typed::aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_ge_at(const typed::multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_ge_at(const typed::pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_ge_at(const typed::pw_multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_gt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_gt_at(const typed::aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_gt_at(const typed::multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_gt_at(const typed::pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_gt_at(const typed::pw_multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_le_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_le_at(const typed::aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_le_at(const typed::multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_le_at(const typed::pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_le_at(const typed::pw_multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_lt_at(const typed::multi_pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_lt_at(const typed::aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_lt_at(const typed::multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_lt_at(const typed::pw_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lex_lt_at(const typed::pw_multi_aff<Domain, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::map<Domain, Domain>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::map<Domain, Domain>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lower_bound(const typed::multi_pw_aff<Domain, Domain> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lower_bound(const typed::aff<Domain, Domain> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lower_bound(const typed::multi_aff<Domain, Domain> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lower_bound(const typed::pw_aff<Domain, Domain> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::lower_bound(const typed::pw_multi_aff<Domain, Domain> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::map<Domain, Domain>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::map<Domain, Domain>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::map<Domain, Domain>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::preimage_range(const typed::multi_aff<Range2, Domain> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::map<Domain, Domain>::preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::map<Domain, Domain>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::map<Domain, Domain>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::map<Domain, Domain>::product(const typed::basic_map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::map<Domain, Domain>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::map<Domain, Domain>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, pair<Domain, Range2>> typed::map<Domain, Domain>::range_product(const typed::map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, pair<Domain, Range2>> typed::map<Domain, Domain>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, pair<Domain, Range2>> typed::map<Domain, Domain>::range_product(const typed::basic_map<Domain, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::fixed_box<Domain, Domain> typed::map<Domain, Domain>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::map<Domain2, Domain> typed::map<Domain, Domain>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_range_tuple(id);
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain, Domain> typed::map<Domain, Domain>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::subtract(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::subtract(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::subtract(const typed::basic_map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::subtract_range(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::unite(const typed::map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::map<Domain, Domain>::unite(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::unite(const typed::basic_map<Domain, Domain> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::universe(const typed::space<Domain, Domain> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::upper_bound(const typed::multi_pw_aff<Domain, Domain> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::upper_bound(const typed::aff<Domain, Domain> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::upper_bound(const typed::multi_aff<Domain, Domain> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::upper_bound(const typed::pw_aff<Domain, Domain> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::map<Domain, Domain>::upper_bound(const typed::pw_multi_aff<Domain, Domain> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<pair<Domain, Domain>> typed::map<Domain, Domain>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<Domain, Domain>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>>::map(const typed::basic_map<Domain, pair<Range, Range2>> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::apply_domain(const typed::map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::apply_domain(const typed::basic_map<Domain, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg3> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::map<Domain, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::map<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> typed::map<Domain, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> typed::map<Domain, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<Domain, Domain2>, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::map<Domain, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Anonymous> typed::map<Domain, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::map::flatten_range();
+  return typed::map<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::map<Domain, pair<Range, Range2>>::foreach_basic_map(const std::function<void(typed::basic_map<Domain, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::map<Domain, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist(const typed::map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist_domain(const typed::set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist_domain(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::gist_domain(const typed::point<Domain> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_range(const typed::set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_range(const typed::basic_set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::intersect_range(const typed::point<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lower_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lower_bound(const typed::aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lower_bound(const typed::multi_aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lower_bound(const typed::pw_aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::lower_bound(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::map<Domain, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::product(const typed::map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::product(const typed::basic_map<Domain2, Arg3> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range> typed::map<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::map::range_factor_domain();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, Range2> typed::map<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::map::range_factor_range();
+  return typed::map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::range_product(const typed::map<Domain, Arg3> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::range_product(const typed::union_map<Domain, Arg3> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::map<Domain, pair<pair<Range, Range2>, Arg3>> typed::map<Domain, pair<Range, Range2>>::range_product(const typed::basic_map<Domain, Arg3> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range2, Range>> typed::map<Domain, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::map::range_reverse();
+  return typed::map<Domain, pair<Range2, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::fixed_box<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Range, Range2>, Domain> typed::map<Domain, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<pair<Range, Range2>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::map::set_domain_tuple(id);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::subtract(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::subtract(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::map<Domain, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::map::uncurry();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::unite(const typed::map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::unite(const typed::basic_map<Domain, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::universe(const typed::space<Domain, pair<Range, Range2>> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::upper_bound(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::upper_bound(const typed::aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::upper_bound(const typed::multi_aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::upper_bound(const typed::pw_aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::map<Domain, pair<Range, Range2>>::upper_bound(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<pair<Domain, pair<Range, Range2>>> typed::map<Domain, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<Domain, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>>::map(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::basic_map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T1, pair<T2, pair<T1, T2>>> typed::map<pair<T1, T2>, pair<T1, T2>>::curry() const
+{
+  auto res = isl::map::curry();
+  return typed::map<T1, pair<T2, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::deltas() const
+{
+  auto res = isl::map::deltas();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T1, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_factor_domain() const
+{
+  auto res = isl::map::domain_factor_domain();
+  return typed::map<T1, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<T2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_factor_range() const
+{
+  auto res = isl::map::domain_factor_range();
+  return typed::map<T2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::map<Domain2, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::basic_map<Domain2, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const
+{
+  auto res = isl::map::eq_at(mupa);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::eq_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+bool typed::map<pair<T1, T2>, pair<T1, T2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename T1, typename T2>
+typed::map<Anonymous, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::flatten_domain() const
+{
+  auto res = isl::map::flatten_domain();
+  return typed::map<Anonymous, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, Anonymous> typed::map<pair<T1, T2>, pair<T1, T2>>::flatten_range() const
+{
+  auto res = isl::map::flatten_range();
+  return typed::map<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2>
+void typed::map<pair<T1, T2>, pair<T1, T2>>::foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<T1, T2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename T1, typename T2>
+void typed::map<pair<T1, T2>, pair<T1, T2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::basic_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::point<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_ge_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_ge_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_gt_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_gt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_le_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_le_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::pw_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lex_lt_at(const typed::pw_multi_aff<pair<T1, T2>, Range> &mpa) const
+{
+  auto res = isl::map::lex_lt_at(mpa);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::multi_aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::pw_aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::lower_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::product(const typed::map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::product(const typed::basic_map<Domain2, Range2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, T1> typed::map<pair<T1, T2>, pair<T1, T2>>::range_factor_domain() const
+{
+  auto res = isl::map::range_factor_domain();
+  return typed::map<pair<T1, T2>, T1>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, T2> typed::map<pair<T1, T2>, pair<T1, T2>>::range_factor_range() const
+{
+  auto res = isl::map::range_factor_range();
+  return typed::map<pair<T1, T2>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::basic_map<pair<T1, T2>, Range2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T2, T1>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_reverse() const
+{
+  auto res = isl::map::range_reverse();
+  return typed::map<pair<T1, T2>, pair<T2, T1>>(res);
+}
+
+template <typename T1, typename T2>
+typed::fixed_box<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::space<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<pair<T1, T2>, T1>, T2> typed::map<pair<T1, T2>, pair<T1, T2>>::uncurry() const
+{
+  auto res = isl::map::uncurry();
+  return typed::map<pair<pair<T1, T2>, T1>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::universe(const typed::space<pair<T1, T2>, pair<T1, T2>> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::multi_aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::pw_aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<T1, T2>>::upper_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<T1, T2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::set<pair<pair<T1, T2>, pair<T1, T2>>> typed::map<pair<T1, T2>, pair<T1, T2>>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<pair<T1, T2>, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>>::map(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap)
+  : isl::map(bmap)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>>::map(const isl::ctx &ctx, const std::string &str)
+  : isl::map(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &map2) const
+{
+  auto res = isl::map::apply_domain(map2);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const
+{
+  auto res = isl::map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &map2) const
+{
+  auto res = isl::map::apply_range(map2);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::map::as_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::map::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::map::bind_domain(tuple);
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::map::bind_range(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::map::coalesce();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T1, pair<T2, pair<Range, Range2>>> typed::map<pair<T1, T2>, pair<Range, Range2>>::curry() const
+{
+  auto res = isl::map::curry();
+  return typed::map<T1, pair<T2, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::map::detect_equalities();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::map::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T1, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_domain() const
+{
+  auto res = isl::map::domain_factor_domain();
+  return typed::map<T1, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<T2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_range() const
+{
+  auto res = isl::map::domain_factor_range();
+  return typed::map<T2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::domain_product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+bool typed::map<pair<T1, T2>, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::every_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<Anonymous, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::flatten_domain() const
+{
+  auto res = isl::map::flatten_domain();
+  return typed::map<Anonymous, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, Anonymous> typed::map<pair<T1, T2>, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::map::flatten_range();
+  return typed::map<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+void typed::map<pair<T1, T2>, pair<Range, Range2>>::foreach_basic_map(const std::function<void(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::basic_map arg0) {
+    return fn(typed::basic_map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::foreach_basic_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+void typed::map<pair<T1, T2>, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::map::gist(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::basic_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::point<pair<T1, T2>> &context) const
+{
+  auto res = isl::map::gist_domain(context);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::intersect(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::map::intersect_domain(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::map::intersect_params(params);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::basic_set<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::point<pair<Range, Range2>> &set) const
+{
+  auto res = isl::map::intersect_range(set);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::map::lexmax();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::map::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::map::lexmin();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::map::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::lower_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &lower) const
+{
+  auto res = isl::map::lower_bound(lower);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::max_multi_pw_aff() const
+{
+  auto res = isl::map::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::min_multi_pw_aff() const
+{
+  auto res = isl::map::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::map::preimage_domain(ma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::map::preimage_domain(mpa);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::map::preimage_domain(pma);
+  return typed::map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::map::preimage_range(ma);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::map::preimage_range(pma);
+  return typed::map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::map<Domain2, Arg2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg2> &umap2) const
+{
+  auto res = isl::map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::basic_map<Domain2, Arg2> &map2) const
+{
+  auto res = isl::map::product(map2);
+  return typed::map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::map::project_out_all_params();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range() const
+{
+  auto res = isl::map::range();
+  return typed::set<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, Range> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::map::range_factor_domain();
+  return typed::map<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, Range2> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::map::range_factor_range();
+  return typed::map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::map<pair<T1, T2>, Arg2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const
+{
+  auto res = isl::map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::basic_map<pair<T1, T2>, Arg2> &map2) const
+{
+  auto res = isl::map::range_product(map2);
+  return typed::map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range2, Range>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::map::range_reverse();
+  return typed::map<pair<T1, T2>, pair<Range2, Range>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::fixed_box<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::range_simple_fixed_box_hull() const
+{
+  auto res = isl::map::range_simple_fixed_box_hull();
+  return typed::fixed_box<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<Range, Range2>, pair<T1, T2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::map::reverse();
+  return typed::map<pair<Range, Range2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::map::space();
+  return typed::space<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::subtract(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::to_union_map() const
+{
+  auto res = isl::map::to_union_map();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<pair<T1, T2>, Range>, Range2> typed::map<pair<T1, T2>, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::map::uncurry();
+  return typed::map<pair<pair<T1, T2>, Range>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &map2) const
+{
+  auto res = isl::map::unite(map2);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::universe(const typed::space<pair<T1, T2>, pair<Range, Range2>> &space)
+{
+  auto res = isl::map::universe(space);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::map<pair<T1, T2>, pair<Range, Range2>>::upper_bound(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upper) const
+{
+  auto res = isl::map::upper_bound(upper);
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<pair<T1, T2>, pair<Range, Range2>>> typed::map<pair<T1, T2>, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::map::wrap();
+  return typed::set<pair<pair<T1, T2>, pair<Range, Range2>>>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain>::multi_aff(const typed::aff<Domain> &aff)
+  : isl::multi_aff(aff)
+{
+}
+
+template <typename Domain>
+typed::multi_aff<Domain>::multi_aff(const typed::space<Domain> &space, const typed::aff_list<Anonymous> &list)
+  : isl::multi_aff(space, list)
+{
+}
+
+template <typename Domain>
+typed::multi_aff<Domain>::multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::add(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::add(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::add(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::add(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::multi_aff<Domain>::add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::add(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::add_constant(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_aff::add_constant(mv);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::add_constant(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::add_constant(long v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::multi_aff<Domain>::apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::as_multi_aff() const
+{
+  auto res = isl::multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::multi_aff<Domain>::as_set() const
+{
+  auto res = isl::multi_aff::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff<Anonymous> typed::multi_aff<Domain>::at(int pos) const
+{
+  auto res = isl::multi_aff::at(pos);
+  return typed::aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::basic_set<> typed::multi_aff<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_aff::bind(tuple);
+  return typed::basic_set<>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::coalesce() const
+{
+  auto res = isl::multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_aff<Domain>::constant_multi_val() const
+{
+  auto res = isl::multi_aff::constant_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::multi_aff<Domain>::domain() const
+{
+  auto res = isl::multi_aff::domain();
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::floor() const
+{
+  auto res = isl::multi_aff::floor();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::gist(const typed::set<> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::multi_aff<Domain>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::gist(const typed::point<> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Domain> typed::multi_aff<Domain>::identity() const
+{
+  auto res = isl::multi_aff::identity();
+  return typed::multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::multi_aff<Arg1, Domain> typed::multi_aff<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::multi_aff::insert_domain(domain);
+  return typed::multi_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff_list<Anonymous> typed::multi_aff<Domain>::list() const
+{
+  auto res = isl::multi_aff::list();
+  return typed::aff_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::max(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_aff<Domain>::max_multi_val() const
+{
+  auto res = isl::multi_aff::max_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::min(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_aff<Domain>::min_multi_val() const
+{
+  auto res = isl::multi_aff::min_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::neg() const
+{
+  auto res = isl::multi_aff::neg();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_aff<pair<Domain, Range>> typed::multi_aff<Domain>::product(const typed::multi_aff<Range> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_aff<Domain>::product(const typed::multi_pw_aff<Range> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::multi_aff<Domain>::product(const typed::pw_multi_aff<Range> &pma2) const
+{
+  auto res = isl::multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_aff<pair<Domain, Range>> typed::multi_aff<Domain>::product(const typed::aff<Range> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_aff::scale(mv);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale(long v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale_down(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_aff::scale_down(mv);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale_down(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::scale_down(long v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::set_at(int pos, const typed::aff<Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::set_at(int pos, const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_aff<Domain2> typed::multi_aff<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_aff<Domain2> typed::multi_aff<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::multi_aff<Domain>::space() const
+{
+  auto res = isl::multi_aff::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::sub(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::sub(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::sub(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::sub(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::multi_aff<Domain>::sub(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::multi_aff<Domain>::sub(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::to_multi_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::to_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::to_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::multi_aff<Domain>::to_union_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::multi_aff<Arg1, Domain> typed::multi_aff<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::multi_aff::unbind_params_insert_domain(domain);
+  return typed::multi_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_aff<Domain>::union_add(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_aff<Domain>::union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::multi_aff<Domain>::union_add(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::multi_aff<Domain>::union_add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range>::multi_aff(const typed::aff<Domain, Range> &aff)
+  : isl::multi_aff(aff)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range>::multi_aff(const typed::space<Domain, Range> &space, const typed::aff_list<Domain, Anonymous> &list)
+  : isl::multi_aff(space, list)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range>::multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::add_constant(mv);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::add_constant(long v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::multi_aff<Domain, Range>::apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::multi_aff<Domain, Range>::as_map() const
+{
+  auto res = isl::multi_aff::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::as_multi_aff() const
+{
+  auto res = isl::multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::multi_aff<Domain, Range>::as_union_map() const
+{
+  auto res = isl::multi_aff::as_union_map();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::aff<Domain, Anonymous> typed::multi_aff<Domain, Range>::at(int pos) const
+{
+  auto res = isl::multi_aff::at(pos);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<Domain> typed::multi_aff<Domain, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::multi_aff::bind(tuple);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Range> typed::multi_aff<Domain, Range>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain(tuple);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::coalesce() const
+{
+  auto res = isl::multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::multi_aff<Domain, Range>::constant_multi_val() const
+{
+  auto res = isl::multi_aff::constant_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::multi_aff<Domain, Range>::domain() const
+{
+  auto res = isl::multi_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::floor() const
+{
+  auto res = isl::multi_aff::floor();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::identity() const
+{
+  auto res = isl::multi_aff::identity();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::aff_list<Domain, Anonymous> typed::multi_aff<Domain, Range>::list() const
+{
+  auto res = isl::multi_aff::list();
+  return typed::aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::max(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::multi_aff<Domain, Range>::max_multi_val() const
+{
+  auto res = isl::multi_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::min(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::multi_aff<Domain, Range>::min_multi_val() const
+{
+  auto res = isl::multi_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::neg() const
+{
+  auto res = isl::multi_aff::neg();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_aff<Domain, Range>::product(const typed::multi_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_aff<Domain, Range>::product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_aff<Domain, Range>::product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_aff<Domain, Range>::product(const typed::aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_aff<Domain2, Range> typed::multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain2, Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Range> typed::multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, Range> typed::multi_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::multi_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, Range> typed::multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Range> typed::multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_aff<Domain2, Range> typed::multi_aff<Domain, Range>::pullback(const typed::aff<Domain2, Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Range> typed::multi_aff<Domain, Range>::pullback(const typed::aff<Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::multi_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, Range>::range_product(const typed::aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::scale(mv);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale(long v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::scale_down(mv);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::scale_down(long v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::set_at(int pos, const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_aff<Domain, Range2> typed::multi_aff<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_aff<Domain, Range2> typed::multi_aff<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::multi_aff<Domain, Range>::space() const
+{
+  auto res = isl::multi_aff::space();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::sub(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::to_multi_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::to_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::to_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::to_union_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_aff<Domain, Range>::union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::union_add(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::multi_aff<Domain, Range>::union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range>::multi_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff)
+  : isl::multi_aff(aff)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range>::multi_aff(const typed::space<pair<Domain2, Range2>, Range> &space, const typed::aff_list<pair<Domain2, Range2>, Anonymous> &list)
+  : isl::multi_aff(space, list)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range>::multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_aff(ctx, str)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::add_constant(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::add_constant(long v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> typed::multi_aff<pair<Domain2, Range2>, Range>::apply(const typed::union_pw_multi_aff<Range, Arg2> &upma2) const
+{
+  auto res = isl::multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::map<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::as_map() const
+{
+  auto res = isl::multi_aff::as_map();
+  return typed::map<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::as_multi_aff() const
+{
+  auto res = isl::multi_aff::as_multi_aff();
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_map<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::as_union_map() const
+{
+  auto res = isl::multi_aff::as_union_map();
+  return typed::union_map<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::multi_aff<pair<Domain2, Range2>, Range>::at(int pos) const
+{
+  auto res = isl::multi_aff::at(pos);
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::basic_set<pair<Domain2, Range2>> typed::multi_aff<pair<Domain2, Range2>, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::multi_aff::bind(tuple);
+  return typed::basic_set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain(tuple);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<Range2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain_wrapped_domain(tuple);
+  return typed::multi_aff<Range2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::coalesce() const
+{
+  auto res = isl::multi_aff::coalesce();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::constant_multi_val() const
+{
+  auto res = isl::multi_aff::constant_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::set<pair<Domain2, Range2>> typed::multi_aff<pair<Domain2, Range2>, Range>::domain() const
+{
+  auto res = isl::multi_aff::domain();
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::floor() const
+{
+  auto res = isl::multi_aff::floor();
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::union_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::basic_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::point<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::identity() const
+{
+  auto res = isl::multi_aff::identity();
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::aff_list<pair<Domain2, Range2>, Anonymous> typed::multi_aff<pair<Domain2, Range2>, Range>::list() const
+{
+  auto res = isl::multi_aff::list();
+  return typed::aff_list<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::max_multi_val() const
+{
+  auto res = isl::multi_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::min_multi_val() const
+{
+  auto res = isl::multi_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::neg() const
+{
+  auto res = isl::multi_aff::neg();
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const
+{
+  auto res = isl::multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_aff<pair<Domain2, Range2>, Range>::product(const typed::pw_multi_aff<Arg2, Arg3> &pma2) const
+{
+  auto res = isl::multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_aff<pair<Domain2, Range2>, Range>::product(const typed::aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_aff<Arg2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<Arg2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<Arg2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<Arg2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_aff<Arg2, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::aff<Arg2, pair<Domain2, Range2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<Range> typed::multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::aff<pair<Domain2, Range2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const
+{
+  auto res = isl::multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::scale(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale(long v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_aff::scale_down(mv);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::scale_down(long v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::multi_aff<pair<Domain2, Range2>, Arg1> typed::multi_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::multi_aff<pair<Domain2, Range2>, Arg1> typed::multi_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_aff::set_range_tuple(id);
+  return typed::multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::space<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::space() const
+{
+  auto res = isl::multi_aff::space();
+  return typed::space<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::to_multi_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::to_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::to_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::to_union_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const
+{
+  auto res = isl::multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>>::multi_aff(const typed::aff<Domain, pair<Range, Range2>> &aff)
+  : isl::multi_aff(aff)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>>::multi_aff(const typed::space<Domain, pair<Range, Range2>> &space, const typed::aff_list<Domain, Anonymous> &list)
+  : isl::multi_aff(space, list)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>>::multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add(const typed::aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::add_constant(mv);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add_constant(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::add_constant(long v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::multi_aff<Domain, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::multi_aff::as_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::as_multi_aff() const
+{
+  auto res = isl::multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::multi_aff::as_union_map();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::aff<Domain, Anonymous> typed::multi_aff<Domain, pair<Range, Range2>>::at(int pos) const
+{
+  auto res = isl::multi_aff::at(pos);
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::basic_set<Domain> typed::multi_aff<Domain, pair<Range, Range2>>::bind(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::multi_aff::bind(tuple);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain(tuple);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::constant_multi_val() const
+{
+  auto res = isl::multi_aff::constant_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::multi_aff<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::multi_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::floor() const
+{
+  auto res = isl::multi_aff::floor();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::identity() const
+{
+  auto res = isl::multi_aff::identity();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::aff_list<Domain, Anonymous> typed::multi_aff<Domain, pair<Range, Range2>>::list() const
+{
+  auto res = isl::multi_aff::list();
+  return typed::aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::max(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::max_multi_val() const
+{
+  auto res = isl::multi_aff::max_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::min(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::min_multi_val() const
+{
+  auto res = isl::multi_aff::min_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::neg() const
+{
+  auto res = isl::multi_aff::neg();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::product(const typed::multi_aff<Domain2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::product(const typed::multi_pw_aff<Domain2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::product(const typed::pw_multi_aff<Domain2, Arg3> &pma2) const
+{
+  auto res = isl::multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::product(const typed::aff<Domain2, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::aff<Domain2, Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::aff<Domain> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, Range> typed::multi_aff<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::multi_aff::range_factor_domain();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::multi_aff<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::multi_aff::range_factor_range();
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_pw_aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_union_pw_aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<Domain, Arg3> &pma2) const
+{
+  auto res = isl::multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::scale(mv);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale(long v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::scale_down(mv);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale_down(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::scale_down(long v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::set_at(int pos, const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::multi_aff::space();
+  return typed::space<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::sub(const typed::aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::to_multi_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::to_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::to_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::to_union_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &mpa2) const
+{
+  auto res = isl::multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &mupa2) const
+{
+  auto res = isl::multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::multi_aff(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &aff)
+  : isl::multi_aff(aff)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::multi_aff(const typed::space<pair<T1, T2>, pair<Range, Range2>> &space, const typed::aff_list<pair<T1, T2>, Anonymous> &list)
+  : isl::multi_aff(space, list)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_aff(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::add(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::add_constant(mv);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(long v) const
+{
+  auto res = isl::multi_aff::add_constant(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::multi_aff::as_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_multi_aff() const
+{
+  auto res = isl::multi_aff::as_multi_aff();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::multi_aff::as_union_map();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::aff<pair<T1, T2>, Anonymous> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::at(int pos) const
+{
+  auto res = isl::multi_aff::at(pos);
+  return typed::aff<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::basic_set<pair<T1, T2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::multi_aff::bind(tuple);
+  return typed::basic_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain(tuple);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<T2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind_domain_wrapped_domain(const typed::multi_id<T1> &tuple) const
+{
+  auto res = isl::multi_aff::bind_domain_wrapped_domain(tuple);
+  return typed::multi_aff<T2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::multi_aff::coalesce();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::constant_multi_val() const
+{
+  auto res = isl::multi_aff::constant_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::multi_aff::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::floor() const
+{
+  auto res = isl::multi_aff::floor();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::point<pair<T1, T2>> &context) const
+{
+  auto res = isl::multi_aff::gist(context);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::identity() const
+{
+  auto res = isl::multi_aff::identity();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::aff_list<pair<T1, T2>, Anonymous> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::list() const
+{
+  auto res = isl::multi_aff::list();
+  return typed::aff_list<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::max(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::max(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::max_multi_val() const
+{
+  auto res = isl::multi_aff::max_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::min(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::min(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::min_multi_val() const
+{
+  auto res = isl::multi_aff::min_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::neg() const
+{
+  auto res = isl::multi_aff::neg();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &pma2) const
+{
+  auto res = isl::multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::multi_aff<Domain2, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::multi_pw_aff<Domain2, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::pw_multi_aff<Domain2, Arg2> &pma2) const
+{
+  auto res = isl::multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::aff<Domain2, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::product(multi2);
+  return typed::multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<pair<T1, T2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<pair<T1, T2>> &mpa2) const
+{
+  auto res = isl::multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<pair<T1, T2>> &pma2) const
+{
+  auto res = isl::multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_aff<Domain2, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::aff<Domain2, pair<T1, T2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::aff<pair<T1, T2>> &ma2) const
+{
+  auto res = isl::multi_aff::pullback(ma2);
+  return typed::multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, Range> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::multi_aff::range_factor_domain();
+  return typed::pw_multi_aff<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, Range2> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::multi_aff::range_factor_range();
+  return typed::pw_multi_aff<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_pw_aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_union_pw_aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &pma2) const
+{
+  auto res = isl::multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_aff::range_product(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::scale(mv);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(long v) const
+{
+  auto res = isl::multi_aff::scale(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::multi_aff::scale_down(mv);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(long v) const
+{
+  auto res = isl::multi_aff::scale_down(v);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::set_at(int pos, const typed::aff<pair<T1, T2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::set_at(int pos, const typed::pw_aff<pair<T1, T2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::set_at(int pos, const typed::union_pw_aff<pair<T1, T2>, Anonymous> &el) const
+{
+  auto res = isl::multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::multi_aff::space();
+  return typed::space<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::multi_aff::sub(multi2);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_multi_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_multi_union_pw_aff() const
+{
+  auto res = isl::multi_aff::to_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_union_pw_multi_aff() const
+{
+  auto res = isl::multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mpa2) const
+{
+  auto res = isl::multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mupa2) const
+{
+  auto res = isl::multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain>
+typed::multi_id<Domain>::multi_id(const typed::space<Domain> &space, const typed::id_list<Anonymous> &list)
+  : isl::multi_id(space, list)
+{
+}
+
+template <typename Domain>
+typed::multi_id<Domain>::multi_id(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_id(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::id<Anonymous> typed::multi_id<Domain>::at(int pos) const
+{
+  auto res = isl::multi_id::at(pos);
+  return typed::id<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::id_list<Anonymous> typed::multi_id<Domain>::list() const
+{
+  auto res = isl::multi_id::list();
+  return typed::id_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_id<Domain> typed::multi_id<Domain>::set_at(int pos, const typed::id<Anonymous> &el) const
+{
+  auto res = isl::multi_id::set_at(pos, el);
+  return typed::multi_id<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_id<Domain> typed::multi_id<Domain>::set_at(int pos, const std::string &el) const
+{
+  auto res = isl::multi_id::set_at(pos, el);
+  return typed::multi_id<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::multi_id<Domain>::space() const
+{
+  auto res = isl::multi_id::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const typed::aff<Domain> &aff)
+  : isl::multi_pw_aff(aff)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const typed::multi_aff<Domain> &ma)
+  : isl::multi_pw_aff(ma)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const typed::pw_aff<Domain> &pa)
+  : isl::multi_pw_aff(pa)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const typed::space<Domain> &space, const typed::pw_aff_list<Anonymous> &list)
+  : isl::multi_pw_aff(space, list)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const typed::pw_multi_aff<Domain> &pma)
+  : isl::multi_pw_aff(pma)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain>::multi_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add(const typed::pw_multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add_constant(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_pw_aff::add_constant(mv);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add_constant(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::add_constant(long v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::multi_pw_aff<Domain>::as_set() const
+{
+  auto res = isl::multi_pw_aff::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::multi_pw_aff<Domain>::at(int pos) const
+{
+  auto res = isl::multi_pw_aff::at(pos);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::multi_pw_aff<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::coalesce() const
+{
+  auto res = isl::multi_pw_aff::coalesce();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::multi_pw_aff<Domain>::domain() const
+{
+  auto res = isl::multi_pw_aff::domain();
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::gist(const typed::set<> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_pw_aff<Domain>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::multi_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::gist(const typed::basic_set<> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::gist(const typed::point<> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::multi_pw_aff<Domain>::identity() const
+{
+  auto res = isl::multi_pw_aff::identity();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::multi_pw_aff<Arg1, Domain> typed::multi_pw_aff<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::multi_pw_aff::insert_domain(domain);
+  return typed::multi_pw_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Anonymous> typed::multi_pw_aff<Domain>::list() const
+{
+  auto res = isl::multi_pw_aff::list();
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::max(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::max(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::max(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::max(const typed::pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::max(const typed::pw_multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_pw_aff<Domain>::max_multi_val() const
+{
+  auto res = isl::multi_pw_aff::max_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::min(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::min(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::min(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::min(const typed::pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::min(const typed::pw_multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_pw_aff<Domain>::min_multi_val() const
+{
+  auto res = isl::multi_pw_aff::min_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::neg() const
+{
+  auto res = isl::multi_pw_aff::neg();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_pw_aff<Domain>::product(const typed::multi_pw_aff<Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_pw_aff<Domain>::product(const typed::aff<Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_pw_aff<Domain>::product(const typed::multi_aff<Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_pw_aff<Domain>::product(const typed::pw_aff<Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::multi_pw_aff<Domain>::product(const typed::pw_multi_aff<Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale(mv);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale(long v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale_down(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale_down(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::scale_down(long v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::set_at(int pos, const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_pw_aff<Domain>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2> typed::multi_pw_aff<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2> typed::multi_pw_aff<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::multi_pw_aff<Domain>::space() const
+{
+  auto res = isl::multi_pw_aff::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::sub(const typed::pw_multi_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::multi_pw_aff<Arg1, Domain> typed::multi_pw_aff<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::multi_pw_aff::unbind_params_insert_domain(domain);
+  return typed::multi_pw_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::multi_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::multi_pw_aff<Domain>::union_add(const typed::pw_multi_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const typed::aff<Domain, Range> &aff)
+  : isl::multi_pw_aff(aff)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const typed::multi_aff<Domain, Range> &ma)
+  : isl::multi_pw_aff(ma)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const typed::pw_aff<Domain, Range> &pa)
+  : isl::multi_pw_aff(pa)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const typed::space<Domain, Range> &space, const typed::pw_aff_list<Domain, Anonymous> &list)
+  : isl::multi_pw_aff(space, list)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const typed::pw_multi_aff<Domain, Range> &pma)
+  : isl::multi_pw_aff(pma)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range>::multi_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add(const typed::pw_multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::add_constant(mv);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::add_constant(long v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::multi_pw_aff<Domain, Range>::as_map() const
+{
+  auto res = isl::multi_pw_aff::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_aff<Domain, Anonymous> typed::multi_pw_aff<Domain, Range>::at(int pos) const
+{
+  auto res = isl::multi_pw_aff::at(pos);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::multi_pw_aff<Domain, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<Domain, Range>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind_domain(tuple);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::coalesce() const
+{
+  auto res = isl::multi_pw_aff::coalesce();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::multi_pw_aff<Domain, Range>::domain() const
+{
+  auto res = isl::multi_pw_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::gist(const typed::set<Domain> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::multi_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::gist(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::gist(const typed::point<Domain> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::identity() const
+{
+  auto res = isl::multi_pw_aff::identity();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_domain(const typed::set<Domain> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_domain(const typed::basic_set<Domain> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_domain(const typed::point<Domain> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_aff_list<Domain, Anonymous> typed::multi_pw_aff<Domain, Range>::list() const
+{
+  auto res = isl::multi_pw_aff::list();
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::max(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::max(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::max(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::max(const typed::pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::max(const typed::pw_multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::multi_pw_aff<Domain, Range>::max_multi_val() const
+{
+  auto res = isl::multi_pw_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::min(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::min(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::min(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::min(const typed::pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::min(const typed::pw_multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::multi_pw_aff<Domain, Range>::min_multi_val() const
+{
+  auto res = isl::multi_pw_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::neg() const
+{
+  auto res = isl::multi_pw_aff::neg();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::product(const typed::aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::product(const typed::multi_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::product(const typed::pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::product(const typed::pw_multi_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::multi_pw_aff::pullback(ma);
+  return typed::multi_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::multi_aff<Domain> &ma) const
+{
+  auto res = isl::multi_pw_aff::pullback(ma);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::multi_pw_aff::pullback(pma);
+  return typed::multi_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain> &pma) const
+{
+  auto res = isl::multi_pw_aff::pullback(pma);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2, Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::multi_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_pw_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::multi_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::multi_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::multi_pw_aff<Domain, Range>::range_product(const typed::pw_multi_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale(mv);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale(long v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::scale_down(long v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, Range2> typed::multi_pw_aff<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, Range2> typed::multi_pw_aff<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::multi_pw_aff<Domain, Range>::space() const
+{
+  auto res = isl::multi_pw_aff::space();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::sub(const typed::pw_multi_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::multi_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::pw_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::multi_pw_aff<Domain, Range>::union_add(const typed::pw_multi_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const typed::aff<pair<Domain2, Range2>, Range> &aff)
+  : isl::multi_pw_aff(aff)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const typed::multi_aff<pair<Domain2, Range2>, Range> &ma)
+  : isl::multi_pw_aff(ma)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const typed::pw_aff<pair<Domain2, Range2>, Range> &pa)
+  : isl::multi_pw_aff(pa)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const typed::space<pair<Domain2, Range2>, Range> &space, const typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> &list)
+  : isl::multi_pw_aff(space, list)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma)
+  : isl::multi_pw_aff(pma)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range>::multi_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::add_constant(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::add_constant(long v) const
+{
+  auto res = isl::multi_pw_aff::add_constant(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::map<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::as_map() const
+{
+  auto res = isl::multi_pw_aff::as_map();
+  return typed::map<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::at(int pos) const
+{
+  auto res = isl::multi_pw_aff::at(pos);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::set<pair<Domain2, Range2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind(tuple);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind_domain(tuple);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range2, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const
+{
+  auto res = isl::multi_pw_aff::bind_domain_wrapped_domain(tuple);
+  return typed::multi_pw_aff<Range2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::coalesce() const
+{
+  auto res = isl::multi_pw_aff::coalesce();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::set<pair<Domain2, Range2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::domain() const
+{
+  auto res = isl::multi_pw_aff::domain();
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::gist(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::gist(const typed::union_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::multi_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::gist(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::gist(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::multi_pw_aff::gist(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::identity() const
+{
+  auto res = isl::multi_pw_aff::identity();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::set<pair<Domain2, Range2>> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::point<pair<Domain2, Range2>> &domain) const
+{
+  auto res = isl::multi_pw_aff::intersect_domain(domain);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::multi_pw_aff::intersect_params(set);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::list() const
+{
+  auto res = isl::multi_pw_aff::list();
+  return typed::pw_aff_list<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::max_multi_val() const
+{
+  auto res = isl::multi_pw_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::min_multi_val() const
+{
+  auto res = isl::multi_pw_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::neg() const
+{
+  auto res = isl::multi_pw_aff::neg();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::product(const typed::aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::product(const typed::pw_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::product(const typed::pw_multi_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::multi_pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<Arg2, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::multi_pw_aff::pullback(ma);
+  return typed::multi_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::multi_pw_aff::pullback(ma);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<Arg2, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<Arg2, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::multi_pw_aff::pullback(pma);
+  return typed::multi_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::multi_pw_aff::pullback(pma);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_union_pw_aff<Arg2, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::multi_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::multi_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::multi_pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale(long v) const
+{
+  auto res = isl::multi_pw_aff::scale(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::scale_down(long v) const
+{
+  auto res = isl::multi_pw_aff::scale_down(v);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::multi_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_pw_aff::set_range_tuple(id);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::space<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::space() const
+{
+  auto res = isl::multi_pw_aff::space();
+  return typed::space<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::multi_pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::pw_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::multi_pw_aff<pair<Domain2, Range2>, Range>::union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::multi_pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain>::multi_union_pw_aff(const typed::multi_pw_aff<Domain> &mpa)
+  : isl::multi_union_pw_aff(mpa)
+{
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain>::multi_union_pw_aff(const typed::union_pw_aff<Domain> &upa)
+  : isl::multi_union_pw_aff(upa)
+{
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain>::multi_union_pw_aff(const typed::space<Domain> &space, const typed::union_pw_aff_list<Anonymous> &list)
+  : isl::multi_union_pw_aff(space, list)
+{
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain>::multi_union_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_union_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::add(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::add(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::add(const typed::union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::multi_union_pw_aff<Domain>::at(int pos) const
+{
+  auto res = isl::multi_union_pw_aff::at(pos);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_set<> typed::multi_union_pw_aff<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::multi_union_pw_aff::bind(tuple);
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::coalesce() const
+{
+  auto res = isl::multi_union_pw_aff::coalesce();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<> typed::multi_union_pw_aff<Domain>::domain() const
+{
+  auto res = isl::multi_union_pw_aff::domain();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::gist(const typed::point<> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::gist(const typed::set<> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Anonymous> typed::multi_union_pw_aff<Domain>::list() const
+{
+  auto res = isl::multi_union_pw_aff::list();
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::neg() const
+{
+  auto res = isl::multi_union_pw_aff::neg();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_union_pw_aff::scale(mv);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale(long v) const
+{
+  auto res = isl::multi_union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale_down(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(mv);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale_down(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::scale_down(long v) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::multi_union_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2> typed::multi_union_pw_aff<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2> typed::multi_union_pw_aff<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::multi_union_pw_aff<Domain>::space() const
+{
+  auto res = isl::multi_union_pw_aff::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::sub(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::sub(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::sub(const typed::union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::union_add(const typed::multi_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::multi_union_pw_aff<Domain>::union_add(const typed::union_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range>::multi_union_pw_aff(const typed::multi_pw_aff<Domain, Range> &mpa)
+  : isl::multi_union_pw_aff(mpa)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range>::multi_union_pw_aff(const typed::union_pw_aff<Domain, Range> &upa)
+  : isl::multi_union_pw_aff(upa)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range>::multi_union_pw_aff(const typed::space<Domain, Range> &space, const typed::union_pw_aff_list<Domain, Anonymous> &list)
+  : isl::multi_union_pw_aff(space, list)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range>::multi_union_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_union_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::add(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::add(const typed::union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_aff<Domain, Anonymous> typed::multi_union_pw_aff<Domain, Range>::at(int pos) const
+{
+  auto res = isl::multi_union_pw_aff::at(pos);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Domain> typed::multi_union_pw_aff<Domain, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::multi_union_pw_aff::bind(tuple);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::coalesce() const
+{
+  auto res = isl::multi_union_pw_aff::coalesce();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Domain> typed::multi_union_pw_aff<Domain, Range>::domain() const
+{
+  auto res = isl::multi_union_pw_aff::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::multi_union_pw_aff::gist(context);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_domain(const typed::basic_set<Domain> &uset) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_domain(const typed::point<Domain> &uset) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_domain(const typed::set<Domain> &uset) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_domain(uset);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::multi_union_pw_aff::intersect_params(params);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_aff_list<Domain, Anonymous> typed::multi_union_pw_aff<Domain, Range>::list() const
+{
+  auto res = isl::multi_union_pw_aff::list();
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::neg() const
+{
+  auto res = isl::multi_union_pw_aff::neg();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2, Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2, Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::multi_aff<Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2, Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2, Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::union_pw_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Range> typed::multi_union_pw_aff<Domain, Range>::pullback(const typed::union_pw_aff<Domain> &upma) const
+{
+  auto res = isl::multi_union_pw_aff::pullback(upma);
+  return typed::multi_union_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_union_pw_aff<Domain, Range>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_union_pw_aff<Domain, Range>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::multi_union_pw_aff<Domain, Range>::range_product(const typed::union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_union_pw_aff::scale(mv);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale(long v) const
+{
+  auto res = isl::multi_union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(mv);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::scale_down(long v) const
+{
+  auto res = isl::multi_union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::multi_union_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, Range2> typed::multi_union_pw_aff<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, Range2> typed::multi_union_pw_aff<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Range> typed::multi_union_pw_aff<Domain, Range>::space() const
+{
+  auto res = isl::multi_union_pw_aff::space();
+  return typed::space<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::sub(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::sub(const typed::union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::multi_union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::union_add(const typed::multi_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::multi_union_pw_aff<Domain, Range>::union_add(const typed::union_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::multi_union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain>::multi_val(const typed::space<Domain> &space, const typed::val_list<Anonymous> &list)
+  : isl::multi_val(space, list)
+{
+}
+
+template <typename Domain>
+typed::multi_val<Domain>::multi_val(const isl::ctx &ctx, const std::string &str)
+  : isl::multi_val(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::add(const typed::multi_val<Domain> &multi2) const
+{
+  auto res = isl::multi_val::add(multi2);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::add(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_val::add(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::add(long v) const
+{
+  auto res = isl::multi_val::add(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::val<Anonymous> typed::multi_val<Domain>::at(int pos) const
+{
+  auto res = isl::multi_val::at(pos);
+  return typed::val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::val_list<Anonymous> typed::multi_val<Domain>::list() const
+{
+  auto res = isl::multi_val::list();
+  return typed::val_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::max(const typed::multi_val<Domain> &multi2) const
+{
+  auto res = isl::multi_val::max(multi2);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::min(const typed::multi_val<Domain> &multi2) const
+{
+  auto res = isl::multi_val::min(multi2);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::neg() const
+{
+  auto res = isl::multi_val::neg();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_val<pair<Domain, Range>> typed::multi_val<Domain>::product(const typed::multi_val<Range> &multi2) const
+{
+  auto res = isl::multi_val::product(multi2);
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_val::scale(mv);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_val::scale(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale(long v) const
+{
+  auto res = isl::multi_val::scale(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale_down(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::multi_val::scale_down(mv);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale_down(const typed::val<Domain> &v) const
+{
+  auto res = isl::multi_val::scale_down(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::scale_down(long v) const
+{
+  auto res = isl::multi_val::scale_down(v);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::set_at(int pos, const typed::val<Anonymous> &el) const
+{
+  auto res = isl::multi_val::set_at(pos, el);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::set_at(int pos, long el) const
+{
+  auto res = isl::multi_val::set_at(pos, el);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_val<Domain2> typed::multi_val<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::multi_val::set_range_tuple(id);
+  return typed::multi_val<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::multi_val<Domain2> typed::multi_val<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::multi_val::set_range_tuple(id);
+  return typed::multi_val<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::multi_val<Domain>::space() const
+{
+  auto res = isl::multi_val::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::multi_val<Domain>::sub(const typed::multi_val<Domain> &multi2) const
+{
+  auto res = isl::multi_val::sub(multi2);
+  return typed::multi_val<Domain>(res);
+}
+
+typed::set<> typed::point<>::coalesce() const
+{
+  auto res = isl::point::coalesce();
+  return typed::set<>(res);
+}
+
+typed::basic_set<> typed::point<>::detect_equalities() const
+{
+  auto res = isl::point::detect_equalities();
+  return typed::basic_set<>(res);
+}
+
+bool typed::point<>::every_set(const std::function<bool(typed::set<>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<>(arg0));
+  };
+  return isl::point::every_set(lambda);
+}
+
+void typed::point<>::foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<>(arg0));
+  };
+  return isl::point::foreach_basic_set(lambda);
+}
+
+void typed::point<>::foreach_point(const std::function<void(typed::point<>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<>(arg0));
+  };
+  return isl::point::foreach_point(lambda);
+}
+
+void typed::point<>::foreach_set(const std::function<void(typed::set<>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<>(arg0));
+  };
+  return isl::point::foreach_set(lambda);
+}
+
+typed::basic_set<> typed::point<>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::basic_set<>(res);
+}
+
+typed::set<> typed::point<>::gist(const typed::set<> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::point<>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::basic_set<> typed::point<>::intersect(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::point::intersect(bset2);
+  return typed::basic_set<>(res);
+}
+
+typed::set<> typed::point<>::intersect(const typed::set<> &set2) const
+{
+  auto res = isl::point::intersect(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::point<>::intersect(const typed::union_set<> &uset2) const
+{
+  auto res = isl::point::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::point<>::project_out_all_params() const
+{
+  auto res = isl::point::project_out_all_params();
+  return typed::set<>(res);
+}
+
+typed::set<> typed::point<>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::point<>::project_out_param(const std::string &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::point<>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::point::project_out_param(list);
+  return typed::set<>(res);
+}
+
+typed::space<> typed::point<>::space() const
+{
+  auto res = isl::point::space();
+  return typed::space<>(res);
+}
+
+typed::set<> typed::point<>::subtract(const typed::set<> &set2) const
+{
+  auto res = isl::point::subtract(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::point<>::subtract(const typed::union_set<> &uset2) const
+{
+  auto res = isl::point::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::point<>::to_set() const
+{
+  auto res = isl::point::to_set();
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::point<>::to_union_set() const
+{
+  auto res = isl::point::to_union_set();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<>::unbind_params(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::point::unbind_params(tuple);
+  return typed::set<Domain>(res);
+}
+
+typed::set<> typed::point<>::unite(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::point::unite(bset2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::point<>::unite(const typed::set<> &set2) const
+{
+  auto res = isl::point::unite(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::point<>::unite(const typed::union_set<> &uset2) const
+{
+  auto res = isl::point::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::basic_set<Range> typed::point<Domain>::apply(const typed::basic_map<Domain, Range> &bmap) const
+{
+  auto res = isl::point::apply(bmap);
+  return typed::basic_set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<Range> typed::point<Domain>::apply(const typed::map<Domain, Range> &map) const
+{
+  auto res = isl::point::apply(map);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::point<Domain>::apply(const typed::union_map<Domain, Range> &umap) const
+{
+  auto res = isl::point::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::point<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::point::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::as_set() const
+{
+  auto res = isl::point::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::point<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::point::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::coalesce() const
+{
+  auto res = isl::point::coalesce();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::point<Domain>::detect_equalities() const
+{
+  auto res = isl::point::detect_equalities();
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+bool typed::point<Domain>::every_set(const std::function<bool(typed::set<Domain>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<Domain>(arg0));
+  };
+  return isl::point::every_set(lambda);
+}
+
+template <typename Domain>
+void typed::point<Domain>::foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<Domain>(arg0));
+  };
+  return isl::point::foreach_basic_set(lambda);
+}
+
+template <typename Domain>
+void typed::point<Domain>::foreach_point(const std::function<void(typed::point<Domain>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<Domain>(arg0));
+  };
+  return isl::point::foreach_point(lambda);
+}
+
+template <typename Domain>
+void typed::point<Domain>::foreach_set(const std::function<void(typed::set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<Domain>(arg0));
+  };
+  return isl::point::foreach_set(lambda);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::point<Domain>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::point<Domain>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::point<Domain>::identity() const
+{
+  auto res = isl::point::identity();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::point<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::point::insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::point<Domain>::intersect(const typed::basic_set<Domain> &bset2) const
+{
+  auto res = isl::point::intersect(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::intersect(const typed::set<Domain> &set2) const
+{
+  auto res = isl::point::intersect(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::point<Domain>::intersect(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::point::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<Domain> typed::point<Domain>::intersect_params(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::point::intersect_params(bset2);
+  return typed::basic_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::point::intersect_params(params);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::lexmax() const
+{
+  auto res = isl::point::lexmax();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::point<Domain>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::point::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::lexmin() const
+{
+  auto res = isl::point::lexmin();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::point<Domain>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::point::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::lower_bound(const typed::multi_pw_aff<Domain> &lower) const
+{
+  auto res = isl::point::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::lower_bound(const typed::multi_val<Domain> &lower) const
+{
+  auto res = isl::point::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::point<Domain>::max_multi_pw_aff() const
+{
+  auto res = isl::point::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::point<Domain>::min_multi_pw_aff() const
+{
+  auto res = isl::point::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::point<Domain>::multi_val() const
+{
+  auto res = isl::point::multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::basic_set<> typed::point<Domain>::params() const
+{
+  auto res = isl::point::params();
+  return typed::basic_set<>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::point<Domain>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::point::plain_multi_val_if_fixed();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::point<Domain>::preimage(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::point::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::point<Domain>::preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::point::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::point<Domain>::preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::point::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::point<Domain>::preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::point::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<pair<Domain, Range>> typed::point<Domain>::product(const typed::set<Range> &set2) const
+{
+  auto res = isl::point::product(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::project_out_all_params() const
+{
+  auto res = isl::point::project_out_all_params();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::project_out_param(const std::string &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::point::project_out_param(list);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<Domain, Range> typed::point<Domain>::pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::point::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::fixed_box<Domain> typed::point<Domain>::simple_fixed_box_hull() const
+{
+  auto res = isl::point::simple_fixed_box_hull();
+  return typed::fixed_box<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::point<Domain>::space() const
+{
+  auto res = isl::point::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::subtract(const typed::set<Domain> &set2) const
+{
+  auto res = isl::point::subtract(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::point<Domain>::subtract(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::point::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::to_set() const
+{
+  auto res = isl::point::to_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::point<Domain>::to_union_set() const
+{
+  auto res = isl::point::to_union_set();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::point<Domain>::translation() const
+{
+  auto res = isl::point::translation();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::point<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::point::unbind_params_insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::unite(const typed::basic_set<Domain> &bset2) const
+{
+  auto res = isl::point::unite(bset2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::unite(const typed::set<Domain> &set2) const
+{
+  auto res = isl::point::unite(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::point<Domain>::unite(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::point::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::upper_bound(const typed::multi_pw_aff<Domain> &upper) const
+{
+  auto res = isl::point::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::point<Domain>::upper_bound(const typed::multi_val<Domain> &upper) const
+{
+  auto res = isl::point::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::basic_set<Arg2> typed::point<pair<Domain, Range>>::apply(const typed::basic_map<pair<Domain, Range>, Arg2> &bmap) const
+{
+  auto res = isl::point::apply(bmap);
+  return typed::basic_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<Arg2> typed::point<pair<Domain, Range>>::apply(const typed::map<pair<Domain, Range>, Arg2> &map) const
+{
+  auto res = isl::point::apply(map);
+  return typed::set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::point<pair<Domain, Range>>::apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::point::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::point<pair<Domain, Range>>::as_pw_multi_aff() const
+{
+  auto res = isl::point::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::as_set() const
+{
+  auto res = isl::point::as_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<> typed::point<pair<Domain, Range>>::bind(const typed::multi_id<pair<Domain, Range>> &tuple) const
+{
+  auto res = isl::point::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::coalesce() const
+{
+  auto res = isl::point::coalesce();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::detect_equalities() const
+{
+  auto res = isl::point::detect_equalities();
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::point<pair<Domain, Range>>::every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::point::every_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::point<pair<Domain, Range>>::foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<pair<Domain, Range>>(arg0));
+  };
+  return isl::point::foreach_basic_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::point<pair<Domain, Range>>::foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<pair<Domain, Range>>(arg0));
+  };
+  return isl::point::foreach_point(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::point<pair<Domain, Range>>::foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::point::foreach_set(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::gist(const typed::basic_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::gist(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::gist(const typed::union_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::point::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::point<pair<Domain, Range>>::identity() const
+{
+  auto res = isl::point::identity();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::point<pair<Domain, Range>>::insert_domain(const typed::space<Arg2> &domain) const
+{
+  auto res = isl::point::insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::intersect(const typed::basic_set<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::point::intersect(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::intersect(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::point::intersect(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::intersect(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::point::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::intersect_params(const typed::basic_set<> &bset2) const
+{
+  auto res = isl::point::intersect_params(bset2);
+  return typed::basic_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::point::intersect_params(params);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lexmax() const
+{
+  auto res = isl::point::lexmax();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::point::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lexmin() const
+{
+  auto res = isl::point::lexmin();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::point::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::point::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::point::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::point<pair<Domain, Range>>::max_multi_pw_aff() const
+{
+  auto res = isl::point::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::point<pair<Domain, Range>>::min_multi_pw_aff() const
+{
+  auto res = isl::point::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::point<pair<Domain, Range>>::multi_val() const
+{
+  auto res = isl::point::multi_val();
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::basic_set<> typed::point<pair<Domain, Range>>::params() const
+{
+  auto res = isl::point::params();
+  return typed::basic_set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::point<pair<Domain, Range>>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::point::plain_multi_val_if_fixed();
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::point<pair<Domain, Range>>::preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::point::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::point<pair<Domain, Range>>::preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::point::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::point<pair<Domain, Range>>::preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::point::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::point<pair<Domain, Range>>::preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::point::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<pair<pair<Domain, Range>, Arg2>> typed::point<pair<Domain, Range>>::product(const typed::set<Arg2> &set2) const
+{
+  auto res = isl::point::product(set2);
+  return typed::set<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::project_out_all_params() const
+{
+  auto res = isl::point::project_out_all_params();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::project_out_param(const std::string &id) const
+{
+  auto res = isl::point::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::point::project_out_param(list);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain, Range>, Arg2> typed::point<pair<Domain, Range>>::pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const
+{
+  auto res = isl::point::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::fixed_box<pair<Domain, Range>> typed::point<pair<Domain, Range>>::simple_fixed_box_hull() const
+{
+  auto res = isl::point::simple_fixed_box_hull();
+  return typed::fixed_box<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<pair<Domain, Range>> typed::point<pair<Domain, Range>>::space() const
+{
+  auto res = isl::point::space();
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::subtract(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::point::subtract(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::subtract(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::point::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::to_set() const
+{
+  auto res = isl::point::to_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::to_union_set() const
+{
+  auto res = isl::point::to_union_set();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::point<pair<Domain, Range>>::translation() const
+{
+  auto res = isl::point::translation();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::point<pair<Domain, Range>>::unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const
+{
+  auto res = isl::point::unbind_params_insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::unite(const typed::basic_set<pair<Domain, Range>> &bset2) const
+{
+  auto res = isl::point::unite(bset2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::unite(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::point::unite(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::unite(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::point::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::point<pair<Domain, Range>>::unwrap() const
+{
+  auto res = isl::point::unwrap();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::point::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::point<pair<Domain, Range>>::upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::point::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+typed::pw_aff<Anonymous>::pw_aff(const typed::aff<Anonymous> &aff)
+  : isl::pw_aff(aff)
+{
+}
+
+typed::pw_aff<Anonymous>::pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_aff(ctx, str)
+{
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::add(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::add(const typed::aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::add_constant(long v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::add_constant(mv);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::pw_aff<Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const
+{
+  auto res = isl::pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+typed::aff<Anonymous> typed::pw_aff<Anonymous>::as_aff() const
+{
+  auto res = isl::pw_aff::as_aff();
+  return typed::aff<Anonymous>(res);
+}
+
+typed::multi_aff<Anonymous> typed::pw_aff<Anonymous>::as_multi_aff() const
+{
+  auto res = isl::pw_aff::as_multi_aff();
+  return typed::multi_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::set<Anonymous> typed::pw_aff<Anonymous>::as_set() const
+{
+  auto res = isl::pw_aff::as_set();
+  return typed::set<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::at(int pos) const
+{
+  auto res = isl::pw_aff::at(pos);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::set<> typed::pw_aff<Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::pw_aff::bind(tuple);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::pw_aff<Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::pw_aff<Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::coalesce() const
+{
+  auto res = isl::pw_aff::coalesce();
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::set<> typed::pw_aff<Anonymous>::domain() const
+{
+  auto res = isl::pw_aff::domain();
+  return typed::set<>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::floor() const
+{
+  auto res = isl::pw_aff::floor();
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::gist(const typed::set<> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::gist(const typed::point<> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous, Anonymous> typed::pw_aff<Anonymous>::identity() const
+{
+  auto res = isl::pw_aff::identity();
+  return typed::multi_pw_aff<Anonymous, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Anonymous>::insert_domain(const typed::space<Domain> &domain) const
+{
+  auto res = isl::pw_aff::insert_domain(domain);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff_list<Anonymous> typed::pw_aff<Anonymous>::list() const
+{
+  auto res = isl::pw_aff::list();
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::max(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::max(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::max(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::max(const typed::aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_val<Anonymous> typed::pw_aff<Anonymous>::max_multi_val() const
+{
+  auto res = isl::pw_aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::min(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::min(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::min(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::min(const typed::aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_val<Anonymous> typed::pw_aff<Anonymous>::min_multi_val() const
+{
+  auto res = isl::pw_aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::mod(long mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::neg() const
+{
+  auto res = isl::pw_aff::neg();
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Range>
+typed::multi_pw_aff<pair<Anonymous, Range>> typed::pw_aff<Anonymous>::product(const typed::multi_pw_aff<Range> &multi2) const
+{
+  auto res = isl::pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Anonymous, Range>>(res);
+}
+
+template <typename Range>
+typed::pw_multi_aff<pair<Anonymous, Range>> typed::pw_aff<Anonymous>::product(const typed::pw_multi_aff<Range> &pma2) const
+{
+  auto res = isl::pw_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Anonymous, Range>>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale(mv);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale(long v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale_down(const typed::val<Anonymous> &f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::scale_down(long f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::set_at(int pos, const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2>
+typed::pw_multi_aff<Domain2> typed::pw_aff<Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain2>(res);
+}
+
+template <typename Domain2>
+typed::pw_multi_aff<Domain2> typed::pw_aff<Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain2>(res);
+}
+
+typed::space<Anonymous> typed::pw_aff<Anonymous>::space() const
+{
+  auto res = isl::pw_aff::space();
+  return typed::space<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::multi_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::sub(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::sub(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::sub(const typed::aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_aff();
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Anonymous>::unbind_params_insert_domain(const typed::multi_id<Domain> &domain) const
+{
+  auto res = isl::pw_aff::unbind_params_insert_domain(domain);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+typed::multi_pw_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::multi_pw_aff<Anonymous> &mpa2) const
+{
+  auto res = isl::pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const
+{
+  auto res = isl::pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::pw_aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::pw_multi_aff<Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::union_add(pma2);
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff<Anonymous>::union_add(const typed::aff<Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous>::pw_aff(const typed::aff<Domain, Anonymous> &aff)
+  : isl::pw_aff(aff)
+{
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous>::pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add_constant(long v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::add_constant(mv);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::pw_aff<Domain, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const
+{
+  auto res = isl::pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_aff() const
+{
+  auto res = isl::pw_aff::as_aff();
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_map() const
+{
+  auto res = isl::pw_aff::as_map();
+  return typed::map<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_multi_aff() const
+{
+  auto res = isl::pw_aff::as_multi_aff();
+  return typed::multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::as_union_map() const
+{
+  auto res = isl::pw_aff::as_union_map();
+  return typed::union_map<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::at(int pos) const
+{
+  auto res = isl::pw_aff::at(pos);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::pw_aff::bind(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::pw_aff<Domain, Anonymous>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::pw_aff::bind_domain(tuple);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::coalesce() const
+{
+  auto res = isl::pw_aff::coalesce();
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::domain() const
+{
+  auto res = isl::pw_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::floor() const
+{
+  auto res = isl::pw_aff::floor();
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::ge_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::ge_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::ge_set(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::ge_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::gt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::gt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::gt_set(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::gt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::identity() const
+{
+  auto res = isl::pw_aff::identity();
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_aff::intersect_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_aff::intersect_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::le_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::le_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::le_set(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::le_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::list() const
+{
+  auto res = isl::pw_aff::list();
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::lt_set(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::lt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_aff<Domain, Anonymous>::lt_set(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::lt_set(pwaff2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::max(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::max(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::max(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Anonymous> typed::pw_aff<Domain, Anonymous>::max_multi_val() const
+{
+  auto res = isl::pw_aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::min(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::min(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::min(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Anonymous> typed::pw_aff<Domain, Anonymous>::min_multi_val() const
+{
+  auto res = isl::pw_aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::mod(long mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::neg() const
+{
+  auto res = isl::pw_aff::neg();
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::pw_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_aff<Domain2, Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::pw_aff::pullback(ma);
+  return typed::pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain> &ma) const
+{
+  auto res = isl::pw_aff::pullback(ma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_aff<Domain2, Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::pw_aff::pullback(mpa);
+  return typed::pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::multi_pw_aff<Domain> &mpa) const
+{
+  auto res = isl::pw_aff::pullback(mpa);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_aff<Domain2, Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::pw_aff::pullback(pma);
+  return typed::pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain> &pma) const
+{
+  auto res = isl::pw_aff::pullback(pma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::pw_aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::pw_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> typed::pw_aff<Domain, Anonymous>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::pw_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale(mv);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale(long v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale_down(const typed::val<Anonymous> &f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::scale_down(long f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::pw_aff<Domain, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::pw_aff<Domain, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::space() const
+{
+  auto res = isl::pw_aff::space();
+  return typed::space<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::multi_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::sub(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::sub(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_aff::subtract_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_aff::subtract_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::subtract_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::subtract_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_aff();
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::multi_pw_aff<Domain, Anonymous> &mpa2) const
+{
+  auto res = isl::pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const
+{
+  auto res = isl::pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::pw_aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::pw_multi_aff<Domain, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff<Domain, Anonymous>::union_add(const typed::aff<Domain, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pw_aff(const typed::aff<pair<Domain2, Range2>, Anonymous> &aff)
+  : isl::pw_aff(aff)
+{
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_aff(ctx, str)
+{
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::add(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add_constant(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add_constant(long v) const
+{
+  auto res = isl::pw_aff::add_constant(v);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::add_constant(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::add_constant(mv);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Arg1> &upma2) const
+{
+  auto res = isl::pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_aff() const
+{
+  auto res = isl::pw_aff::as_aff();
+  return typed::aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::map<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_map() const
+{
+  auto res = isl::pw_aff::as_map();
+  return typed::map<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_multi_aff() const
+{
+  auto res = isl::pw_aff::as_multi_aff();
+  return typed::multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::as_union_map() const
+{
+  auto res = isl::pw_aff::as_union_map();
+  return typed::union_map<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::at(int pos) const
+{
+  auto res = isl::pw_aff::at(pos);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::pw_aff::bind(tuple);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::pw_aff::bind(id);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const
+{
+  auto res = isl::pw_aff::bind_domain(tuple);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Range2, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const
+{
+  auto res = isl::pw_aff::bind_domain_wrapped_domain(tuple);
+  return typed::pw_aff<Range2, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::coalesce() const
+{
+  auto res = isl::pw_aff::coalesce();
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::domain() const
+{
+  auto res = isl::pw_aff::domain();
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::floor() const
+{
+  auto res = isl::pw_aff::floor();
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::ge_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::ge_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::ge_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::ge_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::union_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::basic_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gist(const typed::point<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::pw_aff::gist(context);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::gt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::gt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::gt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::identity() const
+{
+  auto res = isl::pw_aff::identity();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::pw_aff::intersect_domain(space);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::pw_aff::intersect_domain(uset);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_domain(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::intersect_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_aff::intersect_params(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::le_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::le_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::le_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::le_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::list() const
+{
+  auto res = isl::pw_aff::list();
+  return typed::pw_aff_list<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::lt_set(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::lt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::set<pair<Domain2, Range2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::lt_set(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::lt_set(pwaff2);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::max(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::max(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::max(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::max(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_val<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::max_multi_val() const
+{
+  auto res = isl::pw_aff::max_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::min(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::min(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::min(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::min(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_val<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::min_multi_val() const
+{
+  auto res = isl::pw_aff::min_multi_val();
+  return typed::multi_val<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::mod(const typed::val<Anonymous> &mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::mod(long mod) const
+{
+  auto res = isl::pw_aff::mod(mod);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::neg() const
+{
+  auto res = isl::pw_aff::neg();
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::pw_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const
+{
+  auto res = isl::pw_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1, typename Arg2>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::product(const typed::multi_pw_aff<Arg1, Arg2> &multi2) const
+{
+  auto res = isl::pw_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1, typename Arg2>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::product(const typed::pw_multi_aff<Arg1, Arg2> &pma2) const
+{
+  auto res = isl::pw_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg1>, pair<Anonymous, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_aff<Arg1, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_aff<Arg1, pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::pw_aff::pullback(ma);
+  return typed::pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::pw_aff::pullback(ma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_aff<Arg1, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_pw_aff<Arg1, pair<Domain2, Range2>> &mpa) const
+{
+  auto res = isl::pw_aff::pullback(mpa);
+  return typed::pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa) const
+{
+  auto res = isl::pw_aff::pullback(mpa);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_aff<Arg1, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::pw_multi_aff<Arg1, pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::pw_aff::pullback(pma);
+  return typed::pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma) const
+{
+  auto res = isl::pw_aff::pullback(pma);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_aff<Arg1, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::union_pw_multi_aff<Arg1, pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::pw_aff::pullback(upma);
+  return typed::union_pw_aff<Arg1, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma) const
+{
+  auto res = isl::pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const
+{
+  auto res = isl::pw_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg1> &multi2) const
+{
+  auto res = isl::pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> &pma2) const
+{
+  auto res = isl::pw_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg1> &upma2) const
+{
+  auto res = isl::pw_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Anonymous, Arg1>>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale(long v) const
+{
+  auto res = isl::pw_aff::scale(v);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::pw_aff::scale_down(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale_down(const typed::val<Anonymous> &f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::scale_down(long f) const
+{
+  auto res = isl::pw_aff::scale_down(f);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::space<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::space() const
+{
+  auto res = isl::pw_aff::space();
+  return typed::space<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &multi2) const
+{
+  auto res = isl::pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::sub(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::sub(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::sub(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::pw_aff::subtract_domain(space);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::pw_aff::subtract_domain(uset);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::subtract_domain(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_aff::subtract_domain(set);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::to_union_pw_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_aff();
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous> &mpa2) const
+{
+  auto res = isl::pw_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous> &mupa2) const
+{
+  auto res = isl::pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous> &pma2) const
+{
+  auto res = isl::pw_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &upa2) const
+{
+  auto res = isl::pw_aff::union_add(upa2);
+  return typed::union_pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous> &upma2) const
+{
+  auto res = isl::pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_aff<pair<Domain2, Range2>, Anonymous>::union_add(const typed::aff<pair<Domain2, Range2>, Anonymous> &pwaff2) const
+{
+  auto res = isl::pw_aff::union_add(pwaff2);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+typed::pw_aff_list<Anonymous>::pw_aff_list(const isl::ctx &ctx, int n)
+  : isl::pw_aff_list(ctx, n)
+{
+}
+
+typed::pw_aff_list<Anonymous>::pw_aff_list(const typed::pw_aff<Anonymous> &el)
+  : isl::pw_aff_list(el)
+{
+}
+
+typed::pw_aff_list<Anonymous> typed::pw_aff_list<Anonymous>::add(const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::pw_aff_list::add(el);
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+typed::pw_aff_list<Anonymous> typed::pw_aff_list<Anonymous>::add(const typed::aff<Anonymous> &el) const
+{
+  auto res = isl::pw_aff_list::add(el);
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+typed::pw_aff<Anonymous> typed::pw_aff_list<Anonymous>::at(int index) const
+{
+  auto res = isl::pw_aff_list::at(index);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+typed::pw_aff_list<Anonymous> typed::pw_aff_list<Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::pw_aff_list::drop(first, n);
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+void typed::pw_aff_list<Anonymous>::foreach(const std::function<void(typed::pw_aff<Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::pw_aff arg0) {
+    return fn(typed::pw_aff<Anonymous>(arg0));
+  };
+  return isl::pw_aff_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous>::pw_aff_list(const isl::ctx &ctx, int n)
+  : isl::pw_aff_list(ctx, n)
+{
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous>::pw_aff_list(const typed::pw_aff<Domain, Anonymous> &el)
+  : isl::pw_aff_list(el)
+{
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_aff_list<Domain, Anonymous>::add(const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_aff_list::add(el);
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_aff_list<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_aff_list::add(el);
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Domain, Anonymous> typed::pw_aff_list<Domain, Anonymous>::at(int index) const
+{
+  auto res = isl::pw_aff_list::at(index);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_aff_list<Domain, Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::pw_aff_list::drop(first, n);
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+void typed::pw_aff_list<Domain, Anonymous>::foreach(const std::function<void(typed::pw_aff<Domain, Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::pw_aff arg0) {
+    return fn(typed::pw_aff<Domain, Anonymous>(arg0));
+  };
+  return isl::pw_aff_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain>::pw_multi_aff(const typed::multi_aff<Domain> &ma)
+  : isl::pw_multi_aff(ma)
+{
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain>::pw_multi_aff(const typed::pw_aff<Domain> &pa)
+  : isl::pw_multi_aff(pa)
+{
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain>::pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add(const typed::pw_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add_constant(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::pw_multi_aff::add_constant(mv);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add_constant(const typed::val<Domain> &v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::add_constant(long v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::pw_multi_aff<Domain>::apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::pw_multi_aff<Domain>::as_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::pw_multi_aff<Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::pw_multi_aff<Domain>::as_set() const
+{
+  auto res = isl::pw_multi_aff::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff<Anonymous> typed::pw_multi_aff<Domain>::at(int pos) const
+{
+  auto res = isl::pw_multi_aff::at(pos);
+  return typed::pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::pw_multi_aff<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::coalesce() const
+{
+  auto res = isl::pw_multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::pw_multi_aff<Domain>::domain() const
+{
+  auto res = isl::pw_multi_aff::domain();
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::gist(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::gist(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::gist(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::pw_multi_aff<Domain>::identity() const
+{
+  auto res = isl::pw_multi_aff::identity();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::pw_multi_aff<Arg1, Domain> typed::pw_multi_aff<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::pw_multi_aff::insert_domain(domain);
+  return typed::pw_multi_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_aff_list<Anonymous> typed::pw_multi_aff<Domain>::list() const
+{
+  auto res = isl::pw_multi_aff::list();
+  return typed::pw_aff_list<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::max(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::pw_multi_aff<Domain>::max_multi_val() const
+{
+  auto res = isl::pw_multi_aff::max_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::min(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::pw_multi_aff<Domain>::min_multi_val() const
+{
+  auto res = isl::pw_multi_aff::min_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::neg() const
+{
+  auto res = isl::pw_multi_aff::neg();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::pw_multi_aff<Domain>::product(const typed::multi_pw_aff<Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::pw_multi_aff<Domain>::product(const typed::pw_multi_aff<Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::pw_multi_aff<Domain>::product(const typed::multi_aff<Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::pw_multi_aff<Domain>::product(const typed::pw_aff<Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::scale(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale(mv);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::scale(const typed::val<Domain> &v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::scale(long v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::scale_down(const typed::multi_val<Domain> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::scale_down(const typed::val<Domain> &v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::scale_down(long v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::set_at(int pos, const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::pw_multi_aff<Domain>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2> typed::pw_multi_aff<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2> typed::pw_multi_aff<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::pw_multi_aff<Domain>::space() const
+{
+  auto res = isl::pw_multi_aff::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::multi_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::multi_union_pw_aff<Domain> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::sub(const typed::pw_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::multi_pw_aff<Arg1, Domain> typed::pw_multi_aff<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::pw_multi_aff::unbind_params_insert_domain(domain);
+  return typed::multi_pw_aff<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::multi_union_pw_aff<Domain> &mupa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff<Domain>::union_add(const typed::pw_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range>::pw_multi_aff(const typed::multi_aff<Domain, Range> &ma)
+  : isl::pw_multi_aff(ma)
+{
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range>::pw_multi_aff(const typed::pw_aff<Domain, Range> &pa)
+  : isl::pw_multi_aff(pa)
+{
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range>::pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add(const typed::pw_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::add_constant(mv);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::add_constant(long v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::pw_multi_aff<Domain, Range>::apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::pw_multi_aff<Domain, Range>::as_map() const
+{
+  auto res = isl::pw_multi_aff::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::as_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::pw_multi_aff<Domain, Range>::as_union_map() const
+{
+  auto res = isl::pw_multi_aff::as_union_map();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_aff<Domain, Anonymous> typed::pw_multi_aff<Domain, Range>::at(int pos) const
+{
+  auto res = isl::pw_multi_aff::at(pos);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::pw_multi_aff<Domain, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<Domain, Range>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain(tuple);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::coalesce() const
+{
+  auto res = isl::pw_multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<Domain> typed::pw_multi_aff<Domain, Range>::domain() const
+{
+  auto res = isl::pw_multi_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::gist(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::gist(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::gist(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::identity() const
+{
+  auto res = isl::pw_multi_aff::identity();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_multi_aff<Domain, Range>::list() const
+{
+  auto res = isl::pw_multi_aff::list();
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::max(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::pw_multi_aff<Domain, Range>::max_multi_val() const
+{
+  auto res = isl::pw_multi_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::min(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<Range> typed::pw_multi_aff<Domain, Range>::min_multi_val() const
+{
+  auto res = isl::pw_multi_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::neg() const
+{
+  auto res = isl::pw_multi_aff::neg();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::product(const typed::multi_pw_aff<Domain2, Range2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::product(const typed::pw_multi_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::product(const typed::multi_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::product(const typed::pw_aff<Domain2, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::multi_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::pw_multi_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::multi_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, Range>::range_product(const typed::pw_aff<Domain, Range2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale(mv);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale(long v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::scale_down(long v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::pw_multi_aff<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::pw_multi_aff<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::pw_multi_aff<Domain, Range>::space() const
+{
+  auto res = isl::pw_multi_aff::space();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::multi_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::multi_union_pw_aff<Domain, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::sub(const typed::pw_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::subtract_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::subtract_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::multi_pw_aff<Domain, Range> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::multi_union_pw_aff<Domain, Range> &mupa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::pw_multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::multi_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, Range>::union_add(const typed::pw_aff<Domain, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pw_multi_aff(const typed::multi_aff<pair<Domain2, Range2>, Range> &ma)
+  : isl::pw_multi_aff(ma)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pw_multi_aff(const typed::pw_aff<pair<Domain2, Range2>, Range> &pa)
+  : isl::pw_multi_aff(pa)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::add_constant(mv);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add_constant(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::add_constant(long v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::apply(const typed::union_pw_multi_aff<Range, Arg2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::map<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::as_map() const
+{
+  auto res = isl::pw_multi_aff::as_map();
+  return typed::map<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::as_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_aff();
+  return typed::multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_map<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::as_union_map() const
+{
+  auto res = isl::pw_multi_aff::as_union_map();
+  return typed::union_map<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_aff<pair<Domain2, Range2>, Anonymous> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::at(int pos) const
+{
+  auto res = isl::pw_multi_aff::at(pos);
+  return typed::pw_aff<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::set<pair<Domain2, Range2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::bind(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind(tuple);
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::bind_domain(const typed::multi_id<pair<Domain2, Range2>> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain(tuple);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<Range2, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::bind_domain_wrapped_domain(const typed::multi_id<Domain2> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain_wrapped_domain(tuple);
+  return typed::pw_multi_aff<Range2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::coalesce() const
+{
+  auto res = isl::pw_multi_aff::coalesce();
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::set<pair<Domain2, Range2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::domain() const
+{
+  auto res = isl::pw_multi_aff::domain();
+  return typed::set<pair<Domain2, Range2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::union_set<pair<Domain2, Range2>> &context) const
+{
+  auto res = isl::pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::gist(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::identity() const
+{
+  auto res = isl::pw_multi_aff::identity();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_domain(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_aff_list<pair<Domain2, Range2>, Anonymous> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::list() const
+{
+  auto res = isl::pw_multi_aff::list();
+  return typed::pw_aff_list<pair<Domain2, Range2>, Anonymous>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::max(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::max(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::max_multi_val() const
+{
+  auto res = isl::pw_multi_aff::max_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::min(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::min(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_val<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::min_multi_val() const
+{
+  auto res = isl::pw_multi_aff::min_multi_val();
+  return typed::multi_val<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::neg() const
+{
+  auto res = isl::pw_multi_aff::neg();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::preimage_domain_wrapped_domain(const typed::pw_aff<Domain3, Domain2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_pw_aff<Arg2, Arg3> &multi2) const
+{
+  auto res = isl::pw_multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::product(const typed::pw_multi_aff<Arg2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::product(const typed::multi_aff<Arg2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2, typename Arg3>
+typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::product(const typed::pw_aff<Arg2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<Domain2, Range2>, Arg2>, pair<Range, Arg3>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<Arg2, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<Arg2, pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_pw_aff<pair<Domain2, Range2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<Arg2, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<Arg2, pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::multi_aff<pair<Domain2, Range2>> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<Arg2, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<Arg2, pair<Domain2, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::pw_multi_aff<pair<Domain2, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<Arg2, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain2, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg2, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::pullback(const typed::union_pw_multi_aff<pair<Domain2, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Arg2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::pw_multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::multi_aff<pair<Domain2, Range2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::range_product(const typed::pw_aff<pair<Domain2, Range2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, pair<Range, Arg2>>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale(long v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale_down(mv);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale_down(const typed::val<Range> &v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::scale_down(long v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::set_at(int pos, const typed::union_pw_aff<pair<Domain2, Range2>, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+template <typename Arg1>
+typed::pw_multi_aff<pair<Domain2, Range2>, Arg1> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::pw_multi_aff::set_range_tuple(id);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Arg1>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::space<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::space() const
+{
+  auto res = isl::pw_multi_aff::space();
+  return typed::space<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::sub(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::space<pair<Domain2, Range2>> &space) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::union_set<pair<Domain2, Range2>> &uset) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::basic_set<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::subtract_domain(const typed::point<pair<Domain2, Range2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_pw_aff<pair<Domain2, Range2>, Range> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_union_pw_aff<pair<Domain2, Range2>, Range> &mupa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::pw_multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::union_pw_multi_aff<pair<Domain2, Range2>, Range> &upma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::multi_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain2, typename Range2, typename Range>
+typed::pw_multi_aff<pair<Domain2, Range2>, Range> typed::pw_multi_aff<pair<Domain2, Range2>, Range>::union_add(const typed::pw_aff<pair<Domain2, Range2>, Range> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<Domain2, Range2>, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>>::pw_multi_aff(const typed::multi_aff<Domain, pair<Range, Range2>> &ma)
+  : isl::pw_multi_aff(ma)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>>::pw_multi_aff(const typed::pw_aff<Domain, pair<Range, Range2>> &pa)
+  : isl::pw_multi_aff(pa)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>>::pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::add_constant(mv);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add_constant(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::add_constant(long v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::pw_multi_aff<Domain, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::pw_multi_aff::as_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::as_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_aff();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::pw_multi_aff::as_union_map();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_aff<Domain, Anonymous> typed::pw_multi_aff<Domain, pair<Range, Range2>>::at(int pos) const
+{
+  auto res = isl::pw_multi_aff::at(pos);
+  return typed::pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::pw_multi_aff<Domain, pair<Range, Range2>>::bind(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind(tuple);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::bind_domain(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain(tuple);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::pw_multi_aff::coalesce();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::set<Domain> typed::pw_multi_aff<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::pw_multi_aff::domain();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::identity() const
+{
+  auto res = isl::pw_multi_aff::identity();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_aff_list<Domain, Anonymous> typed::pw_multi_aff<Domain, pair<Range, Range2>>::list() const
+{
+  auto res = isl::pw_multi_aff::list();
+  return typed::pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::max(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::max(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::max_multi_val() const
+{
+  auto res = isl::pw_multi_aff::max_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::min(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::min(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::min_multi_val() const
+{
+  auto res = isl::pw_multi_aff::min_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::neg() const
+{
+  auto res = isl::pw_multi_aff::neg();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::product(const typed::multi_pw_aff<Domain2, Arg3> &multi2) const
+{
+  auto res = isl::pw_multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::product(const typed::pw_multi_aff<Domain2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::product(const typed::multi_aff<Domain2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::product(const typed::pw_aff<Domain2, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain2, Domain> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::pw_multi_aff::range_factor_domain();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, Range2> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::pw_multi_aff::range_factor_range();
+  return typed::pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_pw_aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_union_pw_aff<Domain, Arg3> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<Domain, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_aff<Domain, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::pw_aff<Domain, Arg3> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale(mv);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale(long v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale_down(mv);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale_down(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::scale_down(long v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::set_at(int pos, const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::pw_multi_aff::space();
+  return typed::space<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::basic_set<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::point<Domain> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_pw_aff<Domain, pair<Range, Range2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_union_pw_aff<Domain, pair<Range, Range2>> &mupa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::pw_aff<Domain, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pw_multi_aff(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &ma)
+  : isl::pw_multi_aff(ma)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pw_multi_aff(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pa)
+  : isl::pw_multi_aff(pa)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::pw_multi_aff(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::add_constant(mv);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add_constant(long v) const
+{
+  auto res = isl::pw_multi_aff::add_constant(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::pw_multi_aff::as_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_aff();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::pw_multi_aff::as_union_map();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_aff<pair<T1, T2>, Anonymous> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::at(int pos) const
+{
+  auto res = isl::pw_multi_aff::at(pos);
+  return typed::pw_aff<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind(tuple);
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind_domain(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain(tuple);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<T2, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::bind_domain_wrapped_domain(const typed::multi_id<T1> &tuple) const
+{
+  auto res = isl::pw_multi_aff::bind_domain_wrapped_domain(tuple);
+  return typed::pw_multi_aff<T2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::pw_multi_aff::coalesce();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::set<pair<T1, T2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::pw_multi_aff::domain();
+  return typed::set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::gist(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::identity() const
+{
+  auto res = isl::pw_multi_aff::identity();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::pw_multi_aff::intersect_params(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_aff_list<pair<T1, T2>, Anonymous> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::list() const
+{
+  auto res = isl::pw_multi_aff::list();
+  return typed::pw_aff_list<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::max(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::max(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::max_multi_val() const
+{
+  auto res = isl::pw_multi_aff::max_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::min(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::min(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_val<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::min_multi_val() const
+{
+  auto res = isl::pw_multi_aff::min_multi_val();
+  return typed::multi_val<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::neg() const
+{
+  auto res = isl::pw_multi_aff::neg();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, T1> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::pw_aff<Domain3, T1> &pma2) const
+{
+  auto res = isl::pw_multi_aff::preimage_domain_wrapped_domain(pma2);
+  return typed::pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::multi_pw_aff<Domain2, Arg2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::product(multi2);
+  return typed::multi_pw_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::pw_multi_aff<Domain2, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::multi_aff<Domain2, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::product(const typed::pw_aff<Domain2, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::product(pma2);
+  return typed::pw_multi_aff<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::multi_pw_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_pw_aff<pair<T1, T2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::pullback(mpa2);
+  return typed::multi_pw_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<pair<T1, T2>> &ma) const
+{
+  auto res = isl::pw_multi_aff::pullback(ma);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<pair<T1, T2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(pma2);
+  return typed::pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, Range> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::pw_multi_aff::range_factor_domain();
+  return typed::pw_multi_aff<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, Range2> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::pw_multi_aff::range_factor_range();
+  return typed::pw_multi_aff<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_pw_aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_union_pw_aff<pair<T1, T2>, Arg2> &multi2) const
+{
+  auto res = isl::pw_multi_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::pw_aff<pair<T1, T2>, Arg2> &pma2) const
+{
+  auto res = isl::pw_multi_aff::range_product(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale(mv);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale(long v) const
+{
+  auto res = isl::pw_multi_aff::scale(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(const typed::multi_val<pair<Range, Range2>> &mv) const
+{
+  auto res = isl::pw_multi_aff::scale_down(mv);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(const typed::val<pair<Range, Range2>> &v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::scale_down(long v) const
+{
+  auto res = isl::pw_multi_aff::scale_down(v);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::set_at(int pos, const typed::pw_aff<pair<T1, T2>, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::set_at(int pos, const typed::union_pw_aff<pair<T1, T2>, Anonymous> &el) const
+{
+  auto res = isl::pw_multi_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::pw_multi_aff::space();
+  return typed::space<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &multi2) const
+{
+  auto res = isl::pw_multi_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::sub(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::basic_set<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::point<pair<T1, T2>> &set) const
+{
+  auto res = isl::pw_multi_aff::subtract_domain(set);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_multi_pw_aff() const
+{
+  auto res = isl::pw_multi_aff::to_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::to_union_pw_multi_aff() const
+{
+  auto res = isl::pw_multi_aff::to_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mpa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mpa2);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &mupa2) const
+{
+  auto res = isl::pw_multi_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::pw_aff<pair<T1, T2>, pair<Range, Range2>> &pma2) const
+{
+  auto res = isl::pw_multi_aff::union_add(pma2);
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain>::pw_multi_aff_list(const isl::ctx &ctx, int n)
+  : isl::pw_multi_aff_list(ctx, n)
+{
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain>::pw_multi_aff_list(const typed::pw_multi_aff<Domain> &el)
+  : isl::pw_multi_aff_list(el)
+{
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain> typed::pw_multi_aff_list<Domain>::add(const typed::pw_multi_aff<Domain> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain> typed::pw_multi_aff_list<Domain>::add(const typed::multi_aff<Domain> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain> typed::pw_multi_aff_list<Domain>::add(const typed::pw_aff<Domain> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::pw_multi_aff_list<Domain>::at(int index) const
+{
+  auto res = isl::pw_multi_aff_list::at(index);
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff_list<Domain> typed::pw_multi_aff_list<Domain>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::pw_multi_aff_list::drop(first, n);
+  return typed::pw_multi_aff_list<Domain>(res);
+}
+
+template <typename Domain>
+void typed::pw_multi_aff_list<Domain>::foreach(const std::function<void(typed::pw_multi_aff<Domain>)> &fn) const
+{
+  auto lambda = & (isl::pw_multi_aff arg0) {
+    return fn(typed::pw_multi_aff<Domain>(arg0));
+  };
+  return isl::pw_multi_aff_list::foreach(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range>::pw_multi_aff_list(const isl::ctx &ctx, int n)
+  : isl::pw_multi_aff_list(ctx, n)
+{
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range>::pw_multi_aff_list(const typed::pw_multi_aff<Domain, Range> &el)
+  : isl::pw_multi_aff_list(el)
+{
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range> typed::pw_multi_aff_list<Domain, Range>::add(const typed::pw_multi_aff<Domain, Range> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range> typed::pw_multi_aff_list<Domain, Range>::add(const typed::multi_aff<Domain, Range> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range> typed::pw_multi_aff_list<Domain, Range>::add(const typed::pw_aff<Domain, Range> &el) const
+{
+  auto res = isl::pw_multi_aff_list::add(el);
+  return typed::pw_multi_aff_list<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::pw_multi_aff_list<Domain, Range>::at(int index) const
+{
+  auto res = isl::pw_multi_aff_list::at(index);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff_list<Domain, Range> typed::pw_multi_aff_list<Domain, Range>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::pw_multi_aff_list::drop(first, n);
+  return typed::pw_multi_aff_list<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+void typed::pw_multi_aff_list<Domain, Range>::foreach(const std::function<void(typed::pw_multi_aff<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::pw_multi_aff arg0) {
+    return fn(typed::pw_multi_aff<Domain, Range>(arg0));
+  };
+  return isl::pw_multi_aff_list::foreach(lambda);
+}
+
+typed::set<>::set(const typed::basic_set<> &bset)
+  : isl::set(bset)
+{
+}
+
+typed::set<>::set(const typed::point<> &pnt)
+  : isl::set(pnt)
+{
+}
+
+typed::set<>::set(const isl::ctx &ctx, const std::string &str)
+  : isl::set(ctx, str)
+{
+}
+
+typed::set<> typed::set<>::coalesce() const
+{
+  auto res = isl::set::coalesce();
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::detect_equalities() const
+{
+  auto res = isl::set::detect_equalities();
+  return typed::set<>(res);
+}
+
+bool typed::set<>::every_set(const std::function<bool(typed::set<>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<>(arg0));
+  };
+  return isl::set::every_set(lambda);
+}
+
+void typed::set<>::foreach_basic_set(const std::function<void(typed::basic_set<>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<>(arg0));
+  };
+  return isl::set::foreach_basic_set(lambda);
+}
+
+void typed::set<>::foreach_point(const std::function<void(typed::point<>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<>(arg0));
+  };
+  return isl::set::foreach_point(lambda);
+}
+
+void typed::set<>::foreach_set(const std::function<void(typed::set<>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<>(arg0));
+  };
+  return isl::set::foreach_set(lambda);
+}
+
+typed::set<> typed::set<>::gist(const typed::set<> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::set<>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::set<>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::gist(const typed::point<> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::intersect(const typed::set<> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::set<>::intersect(const typed::union_set<> &uset2) const
+{
+  auto res = isl::set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::set<>::intersect(const typed::basic_set<> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::intersect(const typed::point<> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::project_out_all_params() const
+{
+  auto res = isl::set::project_out_all_params();
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::project_out_param(const std::string &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::set::project_out_param(list);
+  return typed::set<>(res);
+}
+
+typed::space<> typed::set<>::space() const
+{
+  auto res = isl::set::space();
+  return typed::space<>(res);
+}
+
+typed::set<> typed::set<>::subtract(const typed::set<> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::set<>::subtract(const typed::union_set<> &uset2) const
+{
+  auto res = isl::set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::set<>::subtract(const typed::basic_set<> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::subtract(const typed::point<> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::set<>::to_union_set() const
+{
+  auto res = isl::set::to_union_set();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<>::unbind_params(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::set::unbind_params(tuple);
+  return typed::set<Domain>(res);
+}
+
+typed::set<> typed::set<>::unite(const typed::set<> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<>(res);
+}
+
+typed::union_set<> typed::set<>::unite(const typed::union_set<> &uset2) const
+{
+  auto res = isl::set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::set<> typed::set<>::unite(const typed::basic_set<> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::unite(const typed::point<> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<>(res);
+}
+
+typed::set<> typed::set<>::universe(const typed::space<> &space)
+{
+  auto res = isl::set::universe(space);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain>::set(const typed::basic_set<Domain> &bset)
+  : isl::set(bset)
+{
+}
+
+template <typename Domain>
+typed::set<Domain>::set(const typed::point<Domain> &pnt)
+  : isl::set(pnt)
+{
+}
+
+template <typename Domain>
+typed::set<Domain>::set(const isl::ctx &ctx, const std::string &str)
+  : isl::set(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<Range> typed::set<Domain>::apply(const typed::map<Domain, Range> &map) const
+{
+  auto res = isl::set::apply(map);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::set<Domain>::apply(const typed::union_map<Domain, Range> &umap) const
+{
+  auto res = isl::set::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<Range> typed::set<Domain>::apply(const typed::basic_map<Domain, Range> &map) const
+{
+  auto res = isl::set::apply(map);
+  return typed::set<Range>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::set<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::set::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::as_set() const
+{
+  auto res = isl::set::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::set<Domain>::bind(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::set::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::coalesce() const
+{
+  auto res = isl::set::coalesce();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::detect_equalities() const
+{
+  auto res = isl::set::detect_equalities();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+bool typed::set<Domain>::every_set(const std::function<bool(typed::set<Domain>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<Domain>(arg0));
+  };
+  return isl::set::every_set(lambda);
+}
+
+template <typename Domain>
+void typed::set<Domain>::foreach_basic_set(const std::function<void(typed::basic_set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<Domain>(arg0));
+  };
+  return isl::set::foreach_basic_set(lambda);
+}
+
+template <typename Domain>
+void typed::set<Domain>::foreach_point(const std::function<void(typed::point<Domain>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<Domain>(arg0));
+  };
+  return isl::set::foreach_point(lambda);
+}
+
+template <typename Domain>
+void typed::set<Domain>::foreach_set(const std::function<void(typed::set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<Domain>(arg0));
+  };
+  return isl::set::foreach_set(lambda);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::set<Domain>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::set<Domain>::identity() const
+{
+  auto res = isl::set::identity();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::set<Domain>::insert_domain(const typed::space<Arg1> &domain) const
+{
+  auto res = isl::set::insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect(const typed::set<Domain> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::set<Domain>::intersect(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect(const typed::basic_set<Domain> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect(const typed::point<Domain> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::lexmax() const
+{
+  auto res = isl::set::lexmax();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::set<Domain>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::set::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::lexmin() const
+{
+  auto res = isl::set::lexmin();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::set<Domain>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::set::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::lower_bound(const typed::multi_pw_aff<Domain> &lower) const
+{
+  auto res = isl::set::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::lower_bound(const typed::multi_val<Domain> &lower) const
+{
+  auto res = isl::set::lower_bound(lower);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::set<Domain>::max_multi_pw_aff() const
+{
+  auto res = isl::set::max_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::set<Domain>::min_multi_pw_aff() const
+{
+  auto res = isl::set::min_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<> typed::set<Domain>::params() const
+{
+  auto res = isl::set::params();
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::set<Domain>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::set::plain_multi_val_if_fixed();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::set<Domain>::preimage(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::set::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::set<Domain>::preimage(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::set::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::set<Domain2> typed::set<Domain>::preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::set::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::set<Domain>::preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<pair<Domain, Range>> typed::set<Domain>::product(const typed::set<Range> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<pair<Domain, Range>> typed::set<Domain>::product(const typed::basic_set<Range> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::set<pair<Domain, Range>> typed::set<Domain>::product(const typed::point<Range> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::project_out_all_params() const
+{
+  auto res = isl::set::project_out_all_params();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::project_out_param(const std::string &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::set::project_out_param(list);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::pw_multi_aff<Domain, Range> typed::set<Domain>::pw_multi_aff_on_domain(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::set::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::fixed_box<Domain> typed::set<Domain>::simple_fixed_box_hull() const
+{
+  auto res = isl::set::simple_fixed_box_hull();
+  return typed::fixed_box<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::set<Domain>::space() const
+{
+  auto res = isl::set::space();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::subtract(const typed::set<Domain> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::set<Domain>::subtract(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::subtract(const typed::basic_set<Domain> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::subtract(const typed::point<Domain> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::set<Domain>::to_union_set() const
+{
+  auto res = isl::set::to_union_set();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::set<Domain>::translation() const
+{
+  auto res = isl::set::translation();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Arg1>
+typed::map<Arg1, Domain> typed::set<Domain>::unbind_params_insert_domain(const typed::multi_id<Arg1> &domain) const
+{
+  auto res = isl::set::unbind_params_insert_domain(domain);
+  return typed::map<Arg1, Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::unite(const typed::set<Domain> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::set<Domain>::unite(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::unite(const typed::basic_set<Domain> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::unite(const typed::point<Domain> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::universe(const typed::space<Domain> &space)
+{
+  auto res = isl::set::universe(space);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::upper_bound(const typed::multi_pw_aff<Domain> &upper) const
+{
+  auto res = isl::set::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::set<Domain>::upper_bound(const typed::multi_val<Domain> &upper) const
+{
+  auto res = isl::set::upper_bound(upper);
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>>::set(const typed::basic_set<pair<Domain, Range>> &bset)
+  : isl::set(bset)
+{
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>>::set(const typed::point<pair<Domain, Range>> &pnt)
+  : isl::set(pnt)
+{
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>>::set(const isl::ctx &ctx, const std::string &str)
+  : isl::set(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<Arg2> typed::set<pair<Domain, Range>>::apply(const typed::map<pair<Domain, Range>, Arg2> &map) const
+{
+  auto res = isl::set::apply(map);
+  return typed::set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::set<pair<Domain, Range>>::apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::set::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<Arg2> typed::set<pair<Domain, Range>>::apply(const typed::basic_map<pair<Domain, Range>, Arg2> &map) const
+{
+  auto res = isl::set::apply(map);
+  return typed::set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::set<pair<Domain, Range>>::as_pw_multi_aff() const
+{
+  auto res = isl::set::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::as_set() const
+{
+  auto res = isl::set::as_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<> typed::set<pair<Domain, Range>>::bind(const typed::multi_id<pair<Domain, Range>> &tuple) const
+{
+  auto res = isl::set::bind(tuple);
+  return typed::set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::coalesce() const
+{
+  auto res = isl::set::coalesce();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::detect_equalities() const
+{
+  auto res = isl::set::detect_equalities();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::set<pair<Domain, Range>>::every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::set::every_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::set<pair<Domain, Range>>::foreach_basic_set(const std::function<void(typed::basic_set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::basic_set arg0) {
+    return fn(typed::basic_set<pair<Domain, Range>>(arg0));
+  };
+  return isl::set::foreach_basic_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::set<pair<Domain, Range>>::foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<pair<Domain, Range>>(arg0));
+  };
+  return isl::set::foreach_point(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::set<pair<Domain, Range>>::foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::set::foreach_set(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::gist(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::gist(const typed::union_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::gist(const typed::basic_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::gist(const typed::point<pair<Domain, Range>> &context) const
+{
+  auto res = isl::set::gist(context);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::set<pair<Domain, Range>>::identity() const
+{
+  auto res = isl::set::identity();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::set<pair<Domain, Range>>::insert_domain(const typed::space<Arg2> &domain) const
+{
+  auto res = isl::set::insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect(const typed::basic_set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect(const typed::point<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::intersect(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect_params(const typed::set<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect_params(const typed::basic_set<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::intersect_params(const typed::point<> &params) const
+{
+  auto res = isl::set::intersect_params(params);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lexmax() const
+{
+  auto res = isl::set::lexmax();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lexmax_pw_multi_aff() const
+{
+  auto res = isl::set::lexmax_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lexmin() const
+{
+  auto res = isl::set::lexmin();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lexmin_pw_multi_aff() const
+{
+  auto res = isl::set::lexmin_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lower_bound(const typed::multi_pw_aff<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::set::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::lower_bound(const typed::multi_val<pair<Domain, Range>> &lower) const
+{
+  auto res = isl::set::lower_bound(lower);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::set<pair<Domain, Range>>::max_multi_pw_aff() const
+{
+  auto res = isl::set::max_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::set<pair<Domain, Range>>::min_multi_pw_aff() const
+{
+  auto res = isl::set::min_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<> typed::set<pair<Domain, Range>>::params() const
+{
+  auto res = isl::set::params();
+  return typed::set<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::set<pair<Domain, Range>>::plain_multi_val_if_fixed() const
+{
+  auto res = isl::set::plain_multi_val_if_fixed();
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::set<pair<Domain, Range>>::preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::set::preimage(ma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::set<pair<Domain, Range>>::preimage(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::set::preimage(mpa);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::set<Domain2> typed::set<pair<Domain, Range>>::preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::set::preimage(pma);
+  return typed::set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::set<pair<Domain, Range>>::preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<pair<pair<Domain, Range>, Arg2>> typed::set<pair<Domain, Range>>::product(const typed::set<Arg2> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<pair<pair<Domain, Range>, Arg2>> typed::set<pair<Domain, Range>>::product(const typed::basic_set<Arg2> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::set<pair<pair<Domain, Range>, Arg2>> typed::set<pair<Domain, Range>>::product(const typed::point<Arg2> &set2) const
+{
+  auto res = isl::set::product(set2);
+  return typed::set<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::project_out_all_params() const
+{
+  auto res = isl::set::project_out_all_params();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::project_out_param(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::project_out_param(const std::string &id) const
+{
+  auto res = isl::set::project_out_param(id);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::project_out_param(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::set::project_out_param(list);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::pw_multi_aff<pair<Domain, Range>, Arg2> typed::set<pair<Domain, Range>>::pw_multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const
+{
+  auto res = isl::set::pw_multi_aff_on_domain(mv);
+  return typed::pw_multi_aff<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::fixed_box<pair<Domain, Range>> typed::set<pair<Domain, Range>>::simple_fixed_box_hull() const
+{
+  auto res = isl::set::simple_fixed_box_hull();
+  return typed::fixed_box<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<pair<Domain, Range>> typed::set<pair<Domain, Range>>::space() const
+{
+  auto res = isl::set::space();
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::subtract(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::subtract(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::subtract(const typed::basic_set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::subtract(const typed::point<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::subtract(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::to_union_set() const
+{
+  auto res = isl::set::to_union_set();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<pair<Domain, Range>, pair<Domain, Range>> typed::set<pair<Domain, Range>>::translation() const
+{
+  auto res = isl::set::translation();
+  return typed::map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::map<Arg2, pair<Domain, Range>> typed::set<pair<Domain, Range>>::unbind_params_insert_domain(const typed::multi_id<Arg2> &domain) const
+{
+  auto res = isl::set::unbind_params_insert_domain(domain);
+  return typed::map<Arg2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::unite(const typed::set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::unite(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::unite(const typed::basic_set<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::unite(const typed::point<pair<Domain, Range>> &set2) const
+{
+  auto res = isl::set::unite(set2);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::universe(const typed::space<pair<Domain, Range>> &space)
+{
+  auto res = isl::set::universe(space);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::set<pair<Domain, Range>>::unwrap() const
+{
+  auto res = isl::set::unwrap();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::upper_bound(const typed::multi_pw_aff<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::set::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::set<pair<Domain, Range>>::upper_bound(const typed::multi_val<pair<Domain, Range>> &upper) const
+{
+  auto res = isl::set::upper_bound(upper);
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::space<>::add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::space<>::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain> typed::space<>::add_unnamed_tuple(unsigned int dim) const
+{
+  auto res = isl::space::add_unnamed_tuple(dim);
+  return typed::space<Domain>(res);
+}
+
+typed::space<> typed::space<>::unit(const isl::ctx &ctx)
+{
+  auto res = isl::space::unit(ctx);
+  return typed::space<>(res);
+}
+
+typed::set<> typed::space<>::universe_set() const
+{
+  auto res = isl::space::universe_set();
+  return typed::set<>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::space<Domain, Range> typed::space<Domain>::add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::space<Domain, Range> typed::space<Domain>::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::space<Domain, Range> typed::space<Domain>::add_unnamed_tuple(unsigned int dim) const
+{
+  auto res = isl::space::add_unnamed_tuple(dim);
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::space<Domain>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain, Domain> typed::space<Domain>::identity_multi_aff_on_domain() const
+{
+  auto res = isl::space::identity_multi_aff_on_domain();
+  return typed::multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain, Domain> typed::space<Domain>::identity_multi_pw_aff_on_domain() const
+{
+  auto res = isl::space::identity_multi_pw_aff_on_domain();
+  return typed::multi_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Domain> typed::space<Domain>::identity_pw_multi_aff_on_domain() const
+{
+  auto res = isl::space::identity_pw_multi_aff_on_domain();
+  return typed::pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::space<Domain, Domain> typed::space<Domain>::map_from_set() const
+{
+  auto res = isl::space::map_from_set();
+  return typed::space<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::space<Domain>::multi_aff(const typed::aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::multi_aff<Domain, Range> typed::space<Domain>::multi_aff_on_domain(const typed::multi_val<Range> &mv) const
+{
+  auto res = isl::space::multi_aff_on_domain(mv);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain>
+typed::multi_id<Domain> typed::space<Domain>::multi_id(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_id(list);
+  return typed::multi_id<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::space<Domain>::multi_pw_aff(const typed::pw_aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::space<Domain>::multi_union_pw_aff(const typed::union_pw_aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::space<Domain>::multi_val(const typed::val_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_val(list);
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::space<Domain>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::space<pair<Domain, Range>> typed::space<Domain>::product(const typed::space<Range> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::space<Domain2> typed::space<Domain>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::space<Domain2> typed::space<Domain>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<Domain2>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::space<Domain>::universe_set() const
+{
+  auto res = isl::space::universe_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::aff<Domain, Anonymous> typed::space<Domain>::zero_aff_on_domain() const
+{
+  auto res = isl::space::zero_aff_on_domain();
+  return typed::aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_aff<Domain> typed::space<Domain>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_pw_aff<Domain> typed::space<Domain>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::space<Domain>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_val<Domain> typed::space<Domain>::zero_multi_val() const
+{
+  auto res = isl::space::zero_multi_val();
+  return typed::multi_val<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain> typed::space<Domain, Range>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<pair<Domain, Range>, Domain> typed::space<Domain, Range>::domain_map_multi_aff() const
+{
+  auto res = isl::space::domain_map_multi_aff();
+  return typed::multi_aff<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>, Domain> typed::space<Domain, Range>::domain_map_pw_multi_aff() const
+{
+  auto res = isl::space::domain_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::space<Domain, Range>::multi_aff(const typed::aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::space<Domain, Range>::multi_pw_aff(const typed::pw_aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::space<Domain, Range>::multi_union_pw_aff(const typed::union_pw_aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::space<Domain, Range>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::space<pair<Domain, Domain2>, pair<Range, Range2>> typed::space<Domain, Range>::product(const typed::space<Domain2, Range2> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Range> typed::space<Domain, Range>::range() const
+{
+  auto res = isl::space::range();
+  return typed::space<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<pair<Domain, Range>, Range> typed::space<Domain, Range>::range_map_multi_aff() const
+{
+  auto res = isl::space::range_map_multi_aff();
+  return typed::multi_aff<pair<Domain, Range>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>, Range> typed::space<Domain, Range>::range_map_pw_multi_aff() const
+{
+  auto res = isl::space::range_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Range>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Range, Domain> typed::space<Domain, Range>::reverse() const
+{
+  auto res = isl::space::reverse();
+  return typed::space<Range, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::space<Domain2, Range> typed::space<Domain, Range>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::space::set_domain_tuple(id);
+  return typed::space<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::space<Domain2, Range> typed::space<Domain, Range>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::space::set_domain_tuple(id);
+  return typed::space<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::space<Domain, Range2> typed::space<Domain, Range>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::space<Domain, Range2> typed::space<Domain, Range>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::space<Domain, Range>::universe_map() const
+{
+  auto res = isl::space::universe_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<pair<Domain, Range>> typed::space<Domain, Range>::wrap() const
+{
+  auto res = isl::space::wrap();
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<Domain, Range> typed::space<Domain, Range>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<Domain, Range> typed::space<Domain, Range>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::space<Domain, Range>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::space<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>>::add_named_tuple(const typed::id<Anonymous> &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::space<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>>::add_named_tuple(const std::string &tuple_id, unsigned int dim) const
+{
+  auto res = isl::space::add_named_tuple(tuple_id, dim);
+  return typed::space<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::space<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>>::add_unnamed_tuple(unsigned int dim) const
+{
+  auto res = isl::space::add_unnamed_tuple(dim);
+  return typed::space<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::space<pair<Domain, Range>>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<pair<Domain, Range>, pair<Domain, Range>> typed::space<pair<Domain, Range>>::identity_multi_aff_on_domain() const
+{
+  auto res = isl::space::identity_multi_aff_on_domain();
+  return typed::multi_aff<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>, pair<Domain, Range>> typed::space<pair<Domain, Range>>::identity_multi_pw_aff_on_domain() const
+{
+  auto res = isl::space::identity_multi_pw_aff_on_domain();
+  return typed::multi_pw_aff<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<pair<Domain, Range>, pair<Domain, Range>> typed::space<pair<Domain, Range>>::identity_pw_multi_aff_on_domain() const
+{
+  auto res = isl::space::identity_pw_multi_aff_on_domain();
+  return typed::pw_multi_aff<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<pair<Domain, Range>, pair<Domain, Range>> typed::space<pair<Domain, Range>>::map_from_set() const
+{
+  auto res = isl::space::map_from_set();
+  return typed::space<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::multi_aff(const typed::aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::multi_aff<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>>::multi_aff_on_domain(const typed::multi_val<Arg2> &mv) const
+{
+  auto res = isl::space::multi_aff_on_domain(mv);
+  return typed::multi_aff<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_id<pair<Domain, Range>> typed::space<pair<Domain, Range>>::multi_id(const typed::id_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_id(list);
+  return typed::multi_id<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::multi_pw_aff(const typed::pw_aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::multi_union_pw_aff(const typed::union_pw_aff_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::space<pair<Domain, Range>>::multi_val(const typed::val_list<Anonymous> &list) const
+{
+  auto res = isl::space::multi_val(list);
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::space<pair<Domain, Range>>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::space<pair<pair<Domain, Range>, Arg2>> typed::space<pair<Domain, Range>>::product(const typed::space<Arg2> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<pair<Domain, Range>, Arg2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::space<pair<Domain, Range>>::universe_set() const
+{
+  auto res = isl::space::universe_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<Domain, Range> typed::space<pair<Domain, Range>>::unwrap() const
+{
+  auto res = isl::space::unwrap();
+  return typed::space<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::aff<pair<Domain, Range>, Anonymous> typed::space<pair<Domain, Range>>::zero_aff_on_domain() const
+{
+  auto res = isl::space::zero_aff_on_domain();
+  return typed::aff<pair<Domain, Range>, Anonymous>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_pw_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<pair<Domain, Range>> typed::space<pair<Domain, Range>>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_val<pair<Domain, Range>> typed::space<pair<Domain, Range>>::zero_multi_val() const
+{
+  auto res = isl::space::zero_multi_val();
+  return typed::multi_val<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range, Range2>> typed::space<pair<Domain, Range>, Range2>::curry() const
+{
+  auto res = isl::space::curry();
+  return typed::space<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Domain, Range>> typed::space<pair<Domain, Range>, Range2>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::space<pair<Domain, Range>, Range2>::domain_map_multi_aff() const
+{
+  auto res = isl::space::domain_map_multi_aff();
+  return typed::multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::space<pair<Domain, Range>, Range2>::domain_map_pw_multi_aff() const
+{
+  auto res = isl::space::domain_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Anonymous, Range2> typed::space<pair<Domain, Range>, Range2>::flatten_domain() const
+{
+  auto res = isl::space::flatten_domain();
+  return typed::space<Anonymous, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::multi_aff(const typed::aff_list<pair<Domain, Range>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::multi_pw_aff(const typed::pw_aff_list<pair<Domain, Range>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::multi_union_pw_aff(const typed::union_pw_aff_list<pair<Domain, Range>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<> typed::space<pair<Domain, Range>, Range2>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::space<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::space<pair<Domain, Range>, Range2>::product(const typed::space<Domain2, Arg3> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Range2> typed::space<pair<Domain, Range>, Range2>::range() const
+{
+  auto res = isl::space::range();
+  return typed::space<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<pair<Domain, Range>, Range2>, Range2> typed::space<pair<Domain, Range>, Range2>::range_map_multi_aff() const
+{
+  auto res = isl::space::range_map_multi_aff();
+  return typed::multi_aff<pair<pair<Domain, Range>, Range2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, Range2> typed::space<pair<Domain, Range>, Range2>::range_map_pw_multi_aff() const
+{
+  auto res = isl::space::range_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<pair<Domain, Range>, Range2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Range2, pair<Domain, Range>> typed::space<pair<Domain, Range>, Range2>::reverse() const
+{
+  auto res = isl::space::reverse();
+  return typed::space<Range2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::space<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>, Range2>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg2>
+typed::space<pair<Domain, Range>, Arg2> typed::space<pair<Domain, Range>, Range2>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::space::set_range_tuple(id);
+  return typed::space<pair<Domain, Range>, Arg2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::universe_map() const
+{
+  auto res = isl::space::universe_map();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<pair<Domain, Range>, Range2>> typed::space<pair<Domain, Range>, Range2>::wrap() const
+{
+  auto res = isl::space::wrap();
+  return typed::space<pair<pair<Domain, Range>, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Range>, Range2> typed::space<pair<Domain, Range>, Range2>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain> typed::space<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Domain, pair<Range, Range2>>, Domain> typed::space<Domain, pair<Range, Range2>>::domain_map_multi_aff() const
+{
+  auto res = isl::space::domain_map_multi_aff();
+  return typed::multi_aff<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> typed::space<Domain, pair<Range, Range2>>::domain_map_pw_multi_aff() const
+{
+  auto res = isl::space::domain_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, Anonymous> typed::space<Domain, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::space::flatten_range();
+  return typed::space<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::multi_aff(const typed::aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::multi_pw_aff(const typed::pw_aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::multi_union_pw_aff(const typed::union_pw_aff_list<Domain, Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<> typed::space<Domain, pair<Range, Range2>>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::space<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::space<Domain, pair<Range, Range2>>::product(const typed::space<Domain2, Arg3> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::range() const
+{
+  auto res = isl::space::range();
+  return typed::space<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::range_map_multi_aff() const
+{
+  auto res = isl::space::range_map_multi_aff();
+  return typed::multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::range_map_pw_multi_aff() const
+{
+  auto res = isl::space::range_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<Domain, pair<Range2, Range>> typed::space<Domain, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::space::range_reverse();
+  return typed::space<Domain, pair<Range2, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Range, Range2>, Domain> typed::space<Domain, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::space::reverse();
+  return typed::space<pair<Range, Range2>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::space<Domain2, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::set_domain_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::space::set_domain_tuple(id);
+  return typed::space<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::space<Domain2, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::set_domain_tuple(const std::string &id) const
+{
+  auto res = isl::space::set_domain_tuple(id);
+  return typed::space<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Domain, Range>, Range2> typed::space<Domain, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::space::uncurry();
+  return typed::space<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::universe_map() const
+{
+  auto res = isl::space::universe_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<pair<Domain, pair<Range, Range2>>> typed::space<Domain, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::space::wrap();
+  return typed::space<pair<Domain, pair<Range, Range2>>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_pw_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::space<Domain, pair<Range, Range2>>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<T1, pair<T2, pair<Range, Range2>>> typed::space<pair<T1, T2>, pair<Range, Range2>>::curry() const
+{
+  auto res = isl::space::curry();
+  return typed::space<T1, pair<T2, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::space::domain();
+  return typed::space<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::domain_map_multi_aff() const
+{
+  auto res = isl::space::domain_map_multi_aff();
+  return typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::domain_map_pw_multi_aff() const
+{
+  auto res = isl::space::domain_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<Anonymous, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::flatten_domain() const
+{
+  auto res = isl::space::flatten_domain();
+  return typed::space<Anonymous, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, Anonymous> typed::space<pair<T1, T2>, pair<Range, Range2>>::flatten_range() const
+{
+  auto res = isl::space::flatten_range();
+  return typed::space<pair<T1, T2>, Anonymous>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::multi_aff(const typed::aff_list<pair<T1, T2>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_aff(list);
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::multi_pw_aff(const typed::pw_aff_list<pair<T1, T2>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_pw_aff(list);
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::multi_union_pw_aff(const typed::union_pw_aff_list<pair<T1, T2>, Anonymous> &list) const
+{
+  auto res = isl::space::multi_union_pw_aff(list);
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<> typed::space<pair<T1, T2>, pair<Range, Range2>>::params() const
+{
+  auto res = isl::space::params();
+  return typed::space<>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::space<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::product(const typed::space<Domain2, Arg2> &right) const
+{
+  auto res = isl::space::product(right);
+  return typed::space<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::range() const
+{
+  auto res = isl::space::range();
+  return typed::space<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::range_map_multi_aff() const
+{
+  auto res = isl::space::range_map_multi_aff();
+  return typed::multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::range_map_pw_multi_aff() const
+{
+  auto res = isl::space::range_map_pw_multi_aff();
+  return typed::pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<T1, T2>, pair<Range2, Range>> typed::space<pair<T1, T2>, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::space::range_reverse();
+  return typed::space<pair<T1, T2>, pair<Range2, Range>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<Range, Range2>, pair<T1, T2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::space::reverse();
+  return typed::space<pair<Range, Range2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<pair<T1, T2>, Range>, Range2> typed::space<pair<T1, T2>, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::space::uncurry();
+  return typed::space<pair<pair<T1, T2>, Range>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::universe_map() const
+{
+  auto res = isl::space::universe_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<pair<pair<T1, T2>, pair<Range, Range2>>> typed::space<pair<T1, T2>, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::space::wrap();
+  return typed::space<pair<pair<T1, T2>, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::zero_multi_aff() const
+{
+  auto res = isl::space::zero_multi_aff();
+  return typed::multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::zero_multi_pw_aff() const
+{
+  auto res = isl::space::zero_multi_pw_aff();
+  return typed::multi_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::space<pair<T1, T2>, pair<Range, Range2>>::zero_multi_union_pw_aff() const
+{
+  auto res = isl::space::zero_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range>::union_map(const typed::basic_map<Domain, Range> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range>::union_map(const typed::map<Domain, Range> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::apply_domain(const typed::map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::apply_range(const typed::union_map<Range, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::apply_range(const typed::basic_map<Range, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::apply_range(const typed::map<Range, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::map<Domain, Range> typed::union_map<Domain, Range>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::union_map<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_map<Domain, Range>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Domain> typed::union_map<Domain, Range>::bind_range(const typed::multi_id<Range> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Domain> typed::union_map<Domain, Range>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Domain> typed::union_map<Domain, Range>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Range>, Domain> typed::union_map<Domain, Range>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Range> typed::union_map<Domain, Range>::domain_product(const typed::union_map<Domain2, Range> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Range> typed::union_map<Domain, Range>::domain_product(const typed::basic_map<Domain2, Range> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Range> typed::union_map<Domain, Range>::domain_product(const typed::map<Domain2, Range> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::union_map<Domain, Range>::every_map(const std::function<bool(typed::map<Domain, Range>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Range>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::union_map<Domain, Range>::foreach_map(const std::function<void(typed::map<Domain, Range>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Range>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist(const typed::union_map<Domain, Range> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist(const typed::basic_map<Domain, Range> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist(const typed::map<Domain, Range> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist_domain(const typed::basic_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist_domain(const typed::point<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::gist_domain(const typed::set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect(const typed::basic_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect(const typed::map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_range(const typed::space<Range> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::intersect_range(const typed::union_set<Range> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_map<Domain2, Range> typed::union_map<Domain, Range>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::preimage_range(const typed::multi_aff<Range2, Range> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::preimage_range(const typed::pw_multi_aff<Range2, Range> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Range>::preimage_range(const typed::union_pw_multi_aff<Range2, Range> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, Range>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, Range>::product(const typed::basic_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, Range>::product(const typed::map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Range> typed::union_map<Domain, Range>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, Range> typed::union_map<Domain, Range>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<Domain, Range>, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, Range>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, Range>::range_product(const typed::basic_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, Range>::range_product(const typed::map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Range, Domain> typed::union_map<Domain, Range>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<Range, Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::union_map<Domain, Range>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract(const typed::basic_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract(const typed::map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_domain(const typed::basic_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_domain(const typed::point<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_domain(const typed::set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_range(const typed::union_set<Range> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_range(const typed::basic_set<Range> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_range(const typed::point<Range> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::subtract_range(const typed::set<Range> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::unite(const typed::union_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::unite(const typed::basic_map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::unite(const typed::map<Domain, Range> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_map<Domain, Range>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_map<Domain, Range>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2>::union_map(const typed::basic_map<pair<Domain, Range>, Range2> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2>::union_map(const typed::map<pair<Domain, Range>, Range2> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::apply_domain(const typed::union_map<pair<Domain, Range>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::apply_domain(const typed::basic_map<pair<Domain, Range>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::apply_domain(const typed::map<pair<Domain, Range>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::apply_range(const typed::union_map<Range2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::apply_range(const typed::basic_map<Range2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::apply_range(const typed::map<Range2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<pair<Domain, Range>> typed::union_map<pair<Domain, Range>, Range2>::bind_range(const typed::multi_id<Range2> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<pair<Domain, Range>, Range2>::curry() const
+{
+  auto res = isl::union_map::curry();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<pair<Domain, Range>> typed::union_map<pair<Domain, Range>, Range2>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<pair<Domain, Range>, Range2>::domain_factor_domain() const
+{
+  auto res = isl::union_map::domain_factor_domain();
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Range, Range2> typed::union_map<pair<Domain, Range>, Range2>::domain_factor_range() const
+{
+  auto res = isl::union_map::domain_factor_range();
+  return typed::union_map<Range, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::union_map<pair<Domain, Range>, Range2>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>> typed::union_map<pair<Domain, Range>, Range2>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<Domain, Range>, Range2>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> typed::union_map<pair<Domain, Range>, Range2>::domain_product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> typed::union_map<pair<Domain, Range>, Range2>::domain_product(const typed::basic_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2> typed::union_map<pair<Domain, Range>, Range2>::domain_product(const typed::map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::union_map<pair<Domain, Range>, Range2>::every_map(const std::function<bool(typed::map<pair<Domain, Range>, Range2>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::union_map<pair<Domain, Range>, Range2>::foreach_map(const std::function<void(typed::map<pair<Domain, Range>, Range2>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<Domain, Range>, Range2>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist(const typed::union_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist(const typed::basic_map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist(const typed::map<pair<Domain, Range>, Range2> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist_domain(const typed::basic_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist_domain(const typed::point<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::gist_domain(const typed::set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect(const typed::map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::space<pair<Domain, Range>> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_domain(const typed::union_set<pair<Domain, Range>> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_range(const typed::space<Range2> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::intersect_range(const typed::union_set<Range2> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<Domain, Range>> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, Range2> typed::union_map<pair<Domain, Range>, Range2>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::preimage_range(const typed::multi_aff<Arg3, Range2> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::preimage_range(const typed::pw_multi_aff<Arg3, Range2> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, Arg3> typed::union_map<pair<Domain, Range>, Range2>::preimage_range(const typed::union_pw_multi_aff<Arg3, Range2> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<pair<Domain, Range>, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::product(const typed::basic_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::product(const typed::map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<Domain, Range>, Domain2>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<Range2> typed::union_map<pair<Domain, Range>, Range2>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<pair<Domain, Range>, Range2>, Range2> typed::union_map<pair<Domain, Range>, Range2>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<pair<Domain, Range>, Range2>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::range_product(const typed::union_map<pair<Domain, Range>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::range_product(const typed::basic_map<pair<Domain, Range>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>> typed::union_map<pair<Domain, Range>, Range2>::range_product(const typed::map<pair<Domain, Range>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<Domain, Range>, pair<Range2, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Range2, pair<Domain, Range>> typed::union_map<pair<Domain, Range>, Range2>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<Range2, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<> typed::union_map<pair<Domain, Range>, Range2>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract(const typed::map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_domain(const typed::union_set<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_domain(const typed::basic_set<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_domain(const typed::point<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_domain(const typed::set<pair<Domain, Range>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_range(const typed::union_set<Range2> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_range(const typed::basic_set<Range2> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_range(const typed::point<Range2> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::subtract_range(const typed::set<Range2> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::unite(const typed::union_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::unite(const typed::basic_map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::unite(const typed::map<pair<Domain, Range>, Range2> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<pair<Domain, Range>, Range2>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<pair<pair<Domain, Range>, Range2>> typed::union_map<pair<Domain, Range>, Range2>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<pair<Domain, Range>, Range2>>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain>::union_map(const typed::basic_map<Domain, Domain> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain>::union_map(const typed::map<Domain, Domain> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::apply_domain(const typed::map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::apply_range(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::apply_range(const typed::basic_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::apply_range(const typed::map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::map<Domain, Domain> typed::union_map<Domain, Domain>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Domain> typed::union_map<Domain, Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Domain> typed::union_map<Domain, Domain>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_map<Domain, Domain>::bind_range(const typed::multi_id<Domain> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_map<Domain, Domain>::deltas() const
+{
+  auto res = isl::union_map::deltas();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_map<Domain, Domain>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::union_map<Domain, Domain>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<pair<Domain, Domain>, Domain> typed::union_map<Domain, Domain>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Domain> typed::union_map<Domain, Domain>::domain_product(const typed::union_map<Domain2, Domain> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Domain> typed::union_map<Domain, Domain>::domain_product(const typed::basic_map<Domain2, Domain> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Domain> typed::union_map<Domain, Domain>::domain_product(const typed::map<Domain2, Domain> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::eq_at(const typed::multi_union_pw_aff<Domain, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::eq_at(const typed::multi_pw_aff<Domain, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::eq_at(const typed::union_pw_aff<Domain, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+bool typed::union_map<Domain, Domain>::every_map(const std::function<bool(typed::map<Domain, Domain>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename Domain>
+void typed::union_map<Domain, Domain>::foreach_map(const std::function<void(typed::map<Domain, Domain>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, Domain>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist(const typed::union_map<Domain, Domain> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist(const typed::basic_map<Domain, Domain> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist(const typed::map<Domain, Domain> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist_domain(const typed::basic_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist_domain(const typed::point<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::gist_domain(const typed::set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect(const typed::basic_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect(const typed::map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_range(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::intersect_range(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_map<Domain2, Domain> typed::union_map<Domain, Domain>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::preimage_range(const typed::multi_aff<Range2, Domain> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::preimage_range(const typed::pw_multi_aff<Range2, Domain> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, Domain>::preimage_range(const typed::union_pw_multi_aff<Range2, Domain> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::union_map<Domain, Domain>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::union_map<Domain, Domain>::product(const typed::basic_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>> typed::union_map<Domain, Domain>::product(const typed::map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_map<Domain, Domain>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<pair<Domain, Domain>, Domain> typed::union_map<Domain, Domain>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<Domain, Domain>, Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, pair<Domain, Range2>> typed::union_map<Domain, Domain>::range_product(const typed::union_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, pair<Domain, Range2>> typed::union_map<Domain, Domain>::range_product(const typed::basic_map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_map<Domain, pair<Domain, Range2>> typed::union_map<Domain, Domain>::range_product(const typed::map<Domain, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<Domain, Range2>>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::union_map<Domain, Domain>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract(const typed::basic_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract(const typed::map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_domain(const typed::basic_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_domain(const typed::point<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_domain(const typed::set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_range(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_range(const typed::basic_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_range(const typed::point<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::subtract_range(const typed::set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::unite(const typed::union_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::unite(const typed::basic_map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::unite(const typed::map<Domain, Domain> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_map<Domain, Domain>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<pair<Domain, Domain>> typed::union_map<Domain, Domain>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<Domain, Domain>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>>::union_map(const typed::basic_map<Domain, pair<Range, Range2>> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>>::union_map(const typed::map<Domain, pair<Range, Range2>> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::apply_domain(const typed::union_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::apply_domain(const typed::basic_map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::apply_domain(const typed::map<Domain, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg3> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<Domain> typed::union_map<Domain, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<Domain> typed::union_map<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, Domain> typed::union_map<Domain, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain> typed::union_map<Domain, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<Domain, pair<Range, Range2>>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+bool typed::union_map<Domain, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<Domain, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+void typed::union_map<Domain, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<Domain, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<Domain, pair<Range, Range2>>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist(const typed::union_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist(const typed::basic_map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist(const typed::map<Domain, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist_domain(const typed::basic_set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist_domain(const typed::point<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::gist_domain(const typed::set<Domain> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect(const typed::map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, Domain> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg3, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg3, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, Arg3> typed::union_map<Domain, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg3, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::product(const typed::basic_map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2, typename Arg3>
+typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::product(const typed::map<Domain2, Arg3> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<Domain, Domain2>, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, Range> typed::union_map<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::union_map::range_factor_domain();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, Range2> typed::union_map<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::union_map::range_factor_range();
+  return typed::union_map<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<Domain, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::range_product(const typed::union_map<Domain, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::range_product(const typed::basic_map<Domain, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_map<Domain, pair<Range, Range2>>::range_product(const typed::map<Domain, Arg3> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range2, Range>> typed::union_map<Domain, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::union_map::range_reverse();
+  return typed::union_map<Domain, pair<Range2, Range>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Range, Range2>, Domain> typed::union_map<Domain, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<pair<Range, Range2>, Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<> typed::union_map<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract(const typed::map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_domain(const typed::basic_set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_domain(const typed::point<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_domain(const typed::set<Domain> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_range(const typed::basic_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_range(const typed::point<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::subtract_range(const typed::set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<pair<Domain, Range>, Range2> typed::union_map<Domain, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::union_map::uncurry();
+  return typed::union_map<pair<Domain, Range>, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::unite(const typed::union_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::unite(const typed::basic_map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::unite(const typed::map<Domain, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_map<Domain, pair<Range, Range2>>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<pair<Domain, pair<Range, Range2>>> typed::union_map<Domain, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<Domain, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>>::union_map(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>>::union_map(const typed::map<pair<T1, T2>, pair<T1, T2>> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::basic_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::apply_range(const typed::map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+typed::map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::bind_range(const typed::multi_id<pair<T1, T2>> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<T1, pair<T2, pair<T1, T2>>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::curry() const
+{
+  auto res = isl::union_map::curry();
+  return typed::union_map<T1, pair<T2, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::deltas() const
+{
+  auto res = isl::union_map::deltas();
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<T1, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_factor_domain() const
+{
+  auto res = isl::union_map::domain_factor_domain();
+  return typed::union_map<T1, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<T2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_factor_range() const
+{
+  auto res = isl::union_map::domain_factor_range();
+  return typed::union_map<T2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::union_map<Domain2, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::basic_map<Domain2, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::domain_product(const typed::map<Domain2, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_union_pw_aff<pair<T1, T2>, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::multi_pw_aff<pair<T1, T2>, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::eq_at(const typed::union_pw_aff<pair<T1, T2>, Range> &mupa) const
+{
+  auto res = isl::union_map::eq_at(mupa);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+bool typed::union_map<pair<T1, T2>, pair<T1, T2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<T1, T2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename T1, typename T2>
+void typed::union_map<pair<T1, T2>, pair<T1, T2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<T1, T2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<T1, T2>>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist(const typed::map<pair<T1, T2>, pair<T1, T2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::basic_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::point<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::gist_domain(const typed::set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::intersect_range(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::multi_aff<Range2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::pw_multi_aff<Range2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::preimage_range(const typed::union_pw_multi_aff<Range2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::product(const typed::union_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::product(const typed::basic_map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Domain2, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::product(const typed::map<Domain2, Range2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, T1> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_factor_domain() const
+{
+  auto res = isl::union_map::range_factor_domain();
+  return typed::union_map<pair<T1, T2>, T1>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, T2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_factor_range() const
+{
+  auto res = isl::union_map::range_factor_range();
+  return typed::union_map<pair<T1, T2>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<T1, T2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::union_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::basic_map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+template <typename Range2>
+typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_product(const typed::map<pair<T1, T2>, Range2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<T1, T2>, Range2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T2, T1>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::range_reverse() const
+{
+  auto res = isl::union_map::range_reverse();
+  return typed::union_map<pair<T1, T2>, pair<T2, T1>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::space<> typed::union_map<pair<T1, T2>, pair<T1, T2>>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::basic_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::point<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_domain(const typed::set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::basic_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::point<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::subtract_range(const typed::set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<pair<T1, T2>, T1>, T2> typed::union_map<pair<T1, T2>, pair<T1, T2>>::uncurry() const
+{
+  auto res = isl::union_map::uncurry();
+  return typed::union_map<pair<pair<T1, T2>, T1>, T2>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::union_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::basic_map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::unite(const typed::map<pair<T1, T2>, pair<T1, T2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_map<pair<T1, T2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<pair<T1, T2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2>
+typed::union_set<pair<pair<T1, T2>, pair<T1, T2>>> typed::union_map<pair<T1, T2>, pair<T1, T2>>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<pair<T1, T2>, pair<T1, T2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>>::union_map(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &bmap)
+  : isl::union_map(bmap)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>>::union_map(const typed::map<pair<T1, T2>, pair<Range, Range2>> &map)
+  : isl::union_map(map)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>>::union_map(const isl::ctx &ctx, const std::string &str)
+  : isl::union_map(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::union_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::basic_map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_domain(const typed::map<pair<T1, T2>, Domain2> &umap2) const
+{
+  auto res = isl::union_map::apply_domain(umap2);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::union_map<pair<Range, Range2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::basic_map<pair<Range, Range2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::apply_range(const typed::map<pair<Range, Range2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::apply_range(umap2);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::as_map() const
+{
+  auto res = isl::union_map::as_map();
+  return typed::map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_map::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::as_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::as_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::bind_range(const typed::multi_id<pair<Range, Range2>> &tuple) const
+{
+  auto res = isl::union_map::bind_range(tuple);
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::union_map::coalesce();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<T1, pair<T2, pair<Range, Range2>>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::curry() const
+{
+  auto res = isl::union_map::curry();
+  return typed::union_map<T1, pair<T2, pair<Range, Range2>>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::detect_equalities() const
+{
+  auto res = isl::union_map::detect_equalities();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_set<pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::union_map::domain();
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<T1, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_domain() const
+{
+  auto res = isl::union_map::domain_factor_domain();
+  return typed::union_map<T1, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<T2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_factor_range() const
+{
+  auto res = isl::union_map::domain_factor_range();
+  return typed::union_map<T2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_map() const
+{
+  auto res = isl::union_map::domain_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_map_union_pw_multi_aff() const
+{
+  auto res = isl::union_map::domain_map_union_pw_multi_aff();
+  return typed::union_pw_multi_aff<pair<pair<T1, T2>, pair<Range, Range2>>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::union_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::basic_map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::domain_product(const typed::map<Domain2, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::domain_product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_map::empty(ctx);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+bool typed::union_map<pair<T1, T2>, pair<Range, Range2>>::every_map(const std::function<bool(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &test) const
+{
+  auto lambda = & (isl::map arg0) {
+    return test(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::union_map::every_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+void typed::union_map<pair<T1, T2>, pair<Range, Range2>>::foreach_map(const std::function<void(typed::map<pair<T1, T2>, pair<Range, Range2>>)> &fn) const
+{
+  auto lambda = & (isl::map arg0) {
+    return fn(typed::map<pair<T1, T2>, pair<Range, Range2>>(arg0));
+  };
+  return isl::union_map::foreach_map(lambda);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::map<pair<T1, T2>, pair<Range, Range2>> &context) const
+{
+  auto res = isl::union_map::gist(context);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::basic_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::point<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::gist_domain(const typed::set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::gist_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::intersect(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::union_map::intersect_domain(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_map::intersect_domain(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_map::intersect_params(set);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::space<pair<Range, Range2>> &space) const
+{
+  auto res = isl::union_map::intersect_range(space);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::intersect_range(const typed::union_set<pair<Range, Range2>> &uset) const
+{
+  auto res = isl::union_map::intersect_range(uset);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::lexmax() const
+{
+  auto res = isl::union_map::lexmax();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::lexmin() const
+{
+  auto res = isl::union_map::lexmin();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_aff<Domain2, pair<T1, T2>> &ma) const
+{
+  auto res = isl::union_map::preimage_domain(ma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::multi_pw_aff<Domain2, pair<T1, T2>> &mpa) const
+{
+  auto res = isl::union_map::preimage_domain(mpa);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &pma) const
+{
+  auto res = isl::union_map::preimage_domain(pma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_map<Domain2, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_domain(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma) const
+{
+  auto res = isl::union_map::preimage_domain(upma);
+  return typed::union_map<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::multi_aff<Arg2, pair<Range, Range2>> &ma) const
+{
+  auto res = isl::union_map::preimage_range(ma);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::pw_multi_aff<Arg2, pair<Range, Range2>> &pma) const
+{
+  auto res = isl::union_map::preimage_range(pma);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, Arg2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::preimage_range(const typed::union_pw_multi_aff<Arg2, pair<Range, Range2>> &upma) const
+{
+  auto res = isl::union_map::preimage_range(upma);
+  return typed::union_map<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::union_map<Domain2, Arg2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::basic_map<Domain2, Arg2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2, typename Arg2>
+typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::product(const typed::map<Domain2, Arg2> &umap2) const
+{
+  auto res = isl::union_map::product(umap2);
+  return typed::union_map<pair<pair<T1, T2>, Domain2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::project_out_all_params() const
+{
+  auto res = isl::union_map::project_out_all_params();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_set<pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range() const
+{
+  auto res = isl::union_map::range();
+  return typed::union_set<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, Range> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::union_map::range_factor_domain();
+  return typed::union_map<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, Range2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::union_map::range_factor_range();
+  return typed::union_map<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_map() const
+{
+  auto res = isl::union_map::range_map();
+  return typed::union_map<pair<pair<T1, T2>, pair<Range, Range2>>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_map<pair<T1, T2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::basic_map<pair<T1, T2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::map<pair<T1, T2>, Arg2> &umap2) const
+{
+  auto res = isl::union_map::range_product(umap2);
+  return typed::union_map<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range2, Range>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::range_reverse() const
+{
+  auto res = isl::union_map::range_reverse();
+  return typed::union_map<pair<T1, T2>, pair<Range2, Range>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<Range, Range2>, pair<T1, T2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::reverse() const
+{
+  auto res = isl::union_map::reverse();
+  return typed::union_map<pair<Range, Range2>, pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::union_map::space();
+  return typed::space<>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::subtract(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::basic_set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::point<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::set<pair<T1, T2>> &dom) const
+{
+  auto res = isl::union_map::subtract_domain(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::union_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::basic_set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::point<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::subtract_range(const typed::set<pair<Range, Range2>> &dom) const
+{
+  auto res = isl::union_map::subtract_range(dom);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<pair<T1, T2>, Range>, Range2> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::uncurry() const
+{
+  auto res = isl::union_map::uncurry();
+  return typed::union_map<pair<pair<T1, T2>, Range>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::union_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::basic_map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::unite(const typed::map<pair<T1, T2>, pair<Range, Range2>> &umap2) const
+{
+  auto res = isl::union_map::unite(umap2);
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::universe() const
+{
+  auto res = isl::union_map::universe();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_set<pair<pair<T1, T2>, pair<Range, Range2>>> typed::union_map<pair<T1, T2>, pair<Range, Range2>>::wrap() const
+{
+  auto res = isl::union_map::wrap();
+  return typed::union_set<pair<pair<T1, T2>, pair<Range, Range2>>>(res);
+}
+
+typed::union_pw_aff<Anonymous>::union_pw_aff(const typed::aff<Anonymous> &aff)
+  : isl::union_pw_aff(aff)
+{
+}
+
+typed::union_pw_aff<Anonymous>::union_pw_aff(const typed::pw_aff<Anonymous> &pa)
+  : isl::union_pw_aff(pa)
+{
+}
+
+typed::union_pw_aff<Anonymous>::union_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_aff(ctx, str)
+{
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::add(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::union_pw_aff<Anonymous>::add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::add(const typed::aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::add(const typed::pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_aff<Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range> &upma2) const
+{
+  auto res = isl::union_pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::pw_multi_aff<Anonymous> typed::union_pw_aff<Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::at(int pos) const
+{
+  auto res = isl::union_pw_aff::at(pos);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_set<> typed::union_pw_aff<Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::union_pw_aff::bind(tuple);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_pw_aff<Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_pw_aff<Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::coalesce() const
+{
+  auto res = isl::union_pw_aff::coalesce();
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_set<> typed::union_pw_aff<Anonymous>::domain() const
+{
+  auto res = isl::union_pw_aff::domain();
+  return typed::union_set<>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::gist(const typed::point<> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::gist(const typed::set<> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff_list<Anonymous> typed::union_pw_aff<Anonymous>::list() const
+{
+  auto res = isl::union_pw_aff::list();
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::neg() const
+{
+  auto res = isl::union_pw_aff::neg();
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale(mv);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale(long v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale_down(mv);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::scale_down(long v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::set_at(int pos, const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2> typed::union_pw_aff<Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain2>(res);
+}
+
+template <typename Domain2>
+typed::multi_union_pw_aff<Domain2> typed::union_pw_aff<Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain2>(res);
+}
+
+typed::space<> typed::union_pw_aff<Anonymous>::space() const
+{
+  auto res = isl::union_pw_aff::space();
+  return typed::space<>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::sub(const typed::multi_union_pw_aff<Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::sub(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::union_pw_aff<Anonymous>::sub(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::sub(const typed::aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::sub(const typed::pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::multi_union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::union_add(const typed::multi_union_pw_aff<Anonymous> &mupa2) const
+{
+  auto res = isl::union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::union_add(const typed::union_pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_multi_aff<Anonymous> typed::union_pw_aff<Anonymous>::union_add(const typed::union_pw_multi_aff<Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::union_add(const typed::aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Anonymous>::union_add(const typed::pw_aff<Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous>::union_pw_aff(const typed::aff<Domain, Anonymous> &aff)
+  : isl::union_pw_aff(aff)
+{
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous>::union_pw_aff(const typed::pw_aff<Domain, Anonymous> &pa)
+  : isl::union_pw_aff(pa)
+{
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous>::union_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::add(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::add(const typed::pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_aff<Domain, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const
+{
+  auto res = isl::union_pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::as_union_map() const
+{
+  auto res = isl::union_pw_aff::as_union_map();
+  return typed::union_map<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::at(int pos) const
+{
+  auto res = isl::union_pw_aff::at(pos);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_pw_aff<Domain, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::union_pw_aff::bind(tuple);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_pw_aff<Domain, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_pw_aff<Domain, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::coalesce() const
+{
+  auto res = isl::union_pw_aff::coalesce();
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_pw_aff<Domain, Anonymous>::domain() const
+{
+  auto res = isl::union_pw_aff::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_aff::intersect_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_aff::intersect_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::list() const
+{
+  auto res = isl::union_pw_aff::list();
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::neg() const
+{
+  auto res = isl::union_pw_aff::neg();
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::multi_aff<Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::pw_multi_aff<Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_pw_aff<Domain2, Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Domain2, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<Domain, Anonymous>::pullback(const typed::union_pw_aff<Domain> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>> typed::union_pw_aff<Domain, Anonymous>::range_product(const typed::multi_union_pw_aff<Domain, Range2> &multi2) const
+{
+  auto res = isl::union_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>> typed::union_pw_aff<Domain, Anonymous>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::union_pw_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale(mv);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale(long v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale_down(mv);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::scale_down(long v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::set_at(int pos, const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, Range2> typed::union_pw_aff<Domain, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+template <typename Range2>
+typed::multi_union_pw_aff<Domain, Range2> typed::union_pw_aff<Domain, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<Domain, Range2>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::union_pw_aff<Domain, Anonymous>::space() const
+{
+  auto res = isl::union_pw_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::sub(const typed::multi_union_pw_aff<Domain, Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::sub(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::sub(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::sub(const typed::aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::sub(const typed::pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_aff::subtract_domain(space);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_aff::subtract_domain(uset);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::union_add(const typed::multi_union_pw_aff<Domain, Anonymous> &mupa2) const
+{
+  auto res = isl::union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::union_add(const typed::union_pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::union_add(const typed::union_pw_multi_aff<Domain, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::union_add(const typed::aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff<Domain, Anonymous>::union_add(const typed::pw_aff<Domain, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_pw_aff(const typed::aff<pair<Domain, Domain2>, Anonymous> &aff)
+  : isl::union_pw_aff(aff)
+{
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_pw_aff(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &pa)
+  : isl::union_pw_aff(pa)
+{
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_pw_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::add(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::add(multi2);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::add(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::add(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::add(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::apply(const typed::union_pw_multi_aff<Anonymous, Range2> &upma2) const
+{
+  auto res = isl::union_pw_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::pw_multi_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_map<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::as_union_map() const
+{
+  auto res = isl::union_pw_aff::as_union_map();
+  return typed::union_map<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::at(int pos) const
+{
+  auto res = isl::union_pw_aff::at(pos);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_set<pair<Domain, Domain2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::bind(const typed::multi_id<Anonymous> &tuple) const
+{
+  auto res = isl::union_pw_aff::bind(tuple);
+  return typed::union_set<pair<Domain, Domain2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_set<pair<Domain, Domain2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::bind(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<pair<Domain, Domain2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_set<pair<Domain, Domain2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::bind(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::bind(id);
+  return typed::union_set<pair<Domain, Domain2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::coalesce() const
+{
+  auto res = isl::union_pw_aff::coalesce();
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_set<pair<Domain, Domain2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::domain() const
+{
+  auto res = isl::union_pw_aff::domain();
+  return typed::union_set<pair<Domain, Domain2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::gist(const typed::union_set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::gist(const typed::basic_set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::gist(const typed::point<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::gist(const typed::set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_aff::gist(context);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::intersect_domain(const typed::space<pair<Domain, Domain2>> &space) const
+{
+  auto res = isl::union_pw_aff::intersect_domain(space);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::intersect_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const
+{
+  auto res = isl::union_pw_aff::intersect_domain(uset);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_aff::intersect_params(set);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff_list<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::list() const
+{
+  auto res = isl::union_pw_aff::list();
+  return typed::union_pw_aff_list<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::neg() const
+{
+  auto res = isl::union_pw_aff::neg();
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain> &upma2) const
+{
+  auto res = isl::union_pw_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Arg2>
+typed::union_pw_aff<Arg2, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::union_pw_multi_aff<Arg2, pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Arg2, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::union_pw_multi_aff<pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Arg2>
+typed::union_pw_aff<Arg2, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::multi_aff<Arg2, pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Arg2, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::multi_aff<pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Arg2>
+typed::union_pw_aff<Arg2, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::pw_multi_aff<Arg2, pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Arg2, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::pw_multi_aff<pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Arg2>
+typed::union_pw_aff<Arg2, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::union_pw_aff<Arg2, pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Arg2, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::pullback(const typed::union_pw_aff<pair<Domain, Domain2>> &upma) const
+{
+  auto res = isl::union_pw_aff::pullback(upma);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::range_product(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> &multi2) const
+{
+  auto res = isl::union_pw_aff::range_product(multi2);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::range_product(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const
+{
+  auto res = isl::union_pw_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Anonymous, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale(mv);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale(long v) const
+{
+  auto res = isl::union_pw_aff::scale(v);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale_down(const typed::multi_val<Anonymous> &mv) const
+{
+  auto res = isl::union_pw_aff::scale_down(mv);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale_down(const typed::val<Anonymous> &v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::scale_down(long v) const
+{
+  auto res = isl::union_pw_aff::scale_down(v);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::set_at(int pos, const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff::set_at(pos, el);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::set_range_tuple(const typed::id<Anonymous> &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2>
+template <typename Range2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::set_range_tuple(const std::string &id) const
+{
+  auto res = isl::union_pw_aff::set_range_tuple(id);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::space<> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::space() const
+{
+  auto res = isl::union_pw_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::sub(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &multi2) const
+{
+  auto res = isl::union_pw_aff::sub(multi2);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::sub(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::sub(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::sub(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::sub(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::sub(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::subtract_domain(const typed::space<pair<Domain, Domain2>> &space) const
+{
+  auto res = isl::union_pw_aff::subtract_domain(space);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::subtract_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const
+{
+  auto res = isl::union_pw_aff::subtract_domain(uset);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_add(const typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous> &mupa2) const
+{
+  auto res = isl::union_pw_aff::union_add(mupa2);
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_add(const typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous> &upma2) const
+{
+  auto res = isl::union_pw_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_add(const typed::aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+template <typename Domain, typename Domain2>
+typed::union_pw_aff<pair<Domain, Domain2>, Anonymous> typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>::union_add(const typed::pw_aff<pair<Domain, Domain2>, Anonymous> &upa2) const
+{
+  auto res = isl::union_pw_aff::union_add(upa2);
+  return typed::union_pw_aff<pair<Domain, Domain2>, Anonymous>(res);
+}
+
+typed::union_pw_aff_list<Anonymous>::union_pw_aff_list(const isl::ctx &ctx, int n)
+  : isl::union_pw_aff_list(ctx, n)
+{
+}
+
+typed::union_pw_aff_list<Anonymous>::union_pw_aff_list(const typed::union_pw_aff<Anonymous> &el)
+  : isl::union_pw_aff_list(el)
+{
+}
+
+typed::union_pw_aff_list<Anonymous> typed::union_pw_aff_list<Anonymous>::add(const typed::union_pw_aff<Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+typed::union_pw_aff_list<Anonymous> typed::union_pw_aff_list<Anonymous>::add(const typed::aff<Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+typed::union_pw_aff_list<Anonymous> typed::union_pw_aff_list<Anonymous>::add(const typed::pw_aff<Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+typed::union_pw_aff<Anonymous> typed::union_pw_aff_list<Anonymous>::at(int index) const
+{
+  auto res = isl::union_pw_aff_list::at(index);
+  return typed::union_pw_aff<Anonymous>(res);
+}
+
+typed::union_pw_aff_list<Anonymous> typed::union_pw_aff_list<Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::union_pw_aff_list::drop(first, n);
+  return typed::union_pw_aff_list<Anonymous>(res);
+}
+
+void typed::union_pw_aff_list<Anonymous>::foreach(const std::function<void(typed::union_pw_aff<Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::union_pw_aff arg0) {
+    return fn(typed::union_pw_aff<Anonymous>(arg0));
+  };
+  return isl::union_pw_aff_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous>::union_pw_aff_list(const isl::ctx &ctx, int n)
+  : isl::union_pw_aff_list(ctx, n)
+{
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous>::union_pw_aff_list(const typed::union_pw_aff<Domain, Anonymous> &el)
+  : isl::union_pw_aff_list(el)
+{
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous> typed::union_pw_aff_list<Domain, Anonymous>::add(const typed::union_pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous> typed::union_pw_aff_list<Domain, Anonymous>::add(const typed::aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous> typed::union_pw_aff_list<Domain, Anonymous>::add(const typed::pw_aff<Domain, Anonymous> &el) const
+{
+  auto res = isl::union_pw_aff_list::add(el);
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff<Domain, Anonymous> typed::union_pw_aff_list<Domain, Anonymous>::at(int index) const
+{
+  auto res = isl::union_pw_aff_list::at(index);
+  return typed::union_pw_aff<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+typed::union_pw_aff_list<Domain, Anonymous> typed::union_pw_aff_list<Domain, Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::union_pw_aff_list::drop(first, n);
+  return typed::union_pw_aff_list<Domain, Anonymous>(res);
+}
+
+template <typename Domain>
+void typed::union_pw_aff_list<Domain, Anonymous>::foreach(const std::function<void(typed::union_pw_aff<Domain, Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::union_pw_aff arg0) {
+    return fn(typed::union_pw_aff<Domain, Anonymous>(arg0));
+  };
+  return isl::union_pw_aff_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain>::union_pw_multi_aff(const typed::multi_aff<Domain> &ma)
+  : isl::union_pw_multi_aff(ma)
+{
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain>::union_pw_multi_aff(const typed::pw_multi_aff<Domain> &pma)
+  : isl::union_pw_multi_aff(pma)
+{
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain>::union_pw_multi_aff(const typed::union_pw_aff<Domain> &upa)
+  : isl::union_pw_multi_aff(upa)
+{
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain>::union_pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::add(const typed::multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::add(const typed::pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::add(const typed::union_pw_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain>::apply(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain>::apply(const typed::multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain>::apply(const typed::pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain>::apply(const typed::union_pw_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain>
+typed::multi_union_pw_aff<Domain> typed::union_pw_multi_aff<Domain>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::coalesce() const
+{
+  auto res = isl::union_pw_multi_aff::coalesce();
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<> typed::union_pw_multi_aff<Domain>::domain() const
+{
+  auto res = isl::union_pw_multi_aff::domain();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_pw_multi_aff::empty(ctx);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::gist(const typed::point<> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::gist(const typed::set<> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::union_pw_multi_aff<Domain>::space() const
+{
+  auto res = isl::union_pw_multi_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::sub(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::sub(const typed::multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::sub(const typed::pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::sub(const typed::union_pw_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::union_add(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::union_add(const typed::multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::union_add(const typed::pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_pw_multi_aff<Domain> typed::union_pw_multi_aff<Domain>::union_add(const typed::union_pw_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range>::union_pw_multi_aff(const typed::multi_aff<Domain, Range> &ma)
+  : isl::union_pw_multi_aff(ma)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range>::union_pw_multi_aff(const typed::pw_multi_aff<Domain, Range> &pma)
+  : isl::union_pw_multi_aff(pma)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range>::union_pw_multi_aff(const typed::union_pw_aff<Domain, Range> &upa)
+  : isl::union_pw_multi_aff(upa)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range>::union_pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::add(const typed::multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::add(const typed::pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::add(const typed::union_pw_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_multi_aff<Domain, Range>::apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_multi_aff<Domain, Range>::apply(const typed::multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_multi_aff<Domain, Range>::apply(const typed::pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_multi_aff<Domain, Range>::apply(const typed::union_pw_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::multi_union_pw_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::as_union_map() const
+{
+  auto res = isl::union_pw_multi_aff::as_union_map();
+  return typed::union_map<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::coalesce() const
+{
+  auto res = isl::union_pw_multi_aff::coalesce();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<Domain> typed::union_pw_multi_aff<Domain, Range>::domain() const
+{
+  auto res = isl::union_pw_multi_aff::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_pw_multi_aff::empty(ctx);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<Domain, Range>::pullback(const typed::union_pw_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, Range>::range_product(const typed::union_pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, Range>::range_product(const typed::multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, Range>::range_product(const typed::pw_multi_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, Range>::range_product(const typed::union_pw_aff<Domain, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::union_pw_multi_aff<Domain, Range>::space() const
+{
+  auto res = isl::union_pw_multi_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::sub(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::sub(const typed::multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::sub(const typed::pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::sub(const typed::union_pw_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::union_add(const typed::union_pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::union_add(const typed::multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::union_add(const typed::pw_multi_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, Range>::union_add(const typed::union_pw_aff<Domain, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_pw_multi_aff(const typed::multi_aff<pair<Domain, Domain2>, Range> &ma)
+  : isl::union_pw_multi_aff(ma)
+{
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_pw_multi_aff(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &pma)
+  : isl::union_pw_multi_aff(pma)
+{
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_pw_multi_aff(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upa)
+  : isl::union_pw_multi_aff(upa)
+{
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::add(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::add(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::add(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::apply(const typed::union_pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::apply(const typed::multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::apply(const typed::pw_multi_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::apply(const typed::union_pw_aff<Range, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::multi_union_pw_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_map<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::as_union_map() const
+{
+  auto res = isl::union_pw_multi_aff::as_union_map();
+  return typed::union_map<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::coalesce() const
+{
+  auto res = isl::union_pw_multi_aff::coalesce();
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_set<pair<Domain, Domain2>> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::domain() const
+{
+  auto res = isl::union_pw_multi_aff::domain();
+  return typed::union_set<pair<Domain, Domain2>>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_pw_multi_aff::empty(ctx);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::gist(const typed::union_set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::gist(const typed::basic_set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::gist(const typed::point<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::gist(const typed::set<pair<Domain, Domain2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::intersect_domain(const typed::space<pair<Domain, Domain2>> &space) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::intersect_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::preimage_domain_wrapped_domain(const typed::union_pw_aff<Domain3, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Arg3>
+typed::union_pw_multi_aff<Arg3, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::union_pw_multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg3, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::union_pw_multi_aff<pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Arg3>
+typed::union_pw_multi_aff<Arg3, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg3, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::multi_aff<pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Arg3>
+typed::union_pw_multi_aff<Arg3, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::pw_multi_aff<Arg3, pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg3, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::pw_multi_aff<pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Arg3>
+typed::union_pw_multi_aff<Arg3, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::union_pw_aff<Arg3, pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Arg3, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::pullback(const typed::union_pw_aff<pair<Domain, Domain2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::range_product(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::range_product(const typed::multi_aff<pair<Domain, Domain2>, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::range_product(const typed::pw_multi_aff<pair<Domain, Domain2>, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+template <typename Range2>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::range_product(const typed::union_pw_aff<pair<Domain, Domain2>, Range2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::space<> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::space() const
+{
+  auto res = isl::union_pw_multi_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::sub(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::sub(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::sub(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::sub(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::subtract_domain(const typed::space<pair<Domain, Domain2>> &space) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::subtract_domain(const typed::union_set<pair<Domain, Domain2>> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_add(const typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_add(const typed::multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_add(const typed::pw_multi_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Domain2, typename Range>
+typed::union_pw_multi_aff<pair<Domain, Domain2>, Range> typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>::union_add(const typed::union_pw_aff<pair<Domain, Domain2>, Range> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<Domain, Domain2>, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_pw_multi_aff(const typed::multi_aff<Domain, pair<Range, Range2>> &ma)
+  : isl::union_pw_multi_aff(ma)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_pw_multi_aff(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &pma)
+  : isl::union_pw_multi_aff(pma)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_pw_multi_aff(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upa)
+  : isl::union_pw_multi_aff(upa)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_multi_aff(ctx, str)
+{
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::add(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::apply(const typed::multi_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::apply(const typed::pw_multi_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, Arg3> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::apply(const typed::union_pw_aff<pair<Range, Range2>, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<Domain, Arg3>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::multi_union_pw_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_map<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::union_pw_multi_aff::as_union_map();
+  return typed::union_map<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::union_pw_multi_aff::coalesce();
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_set<Domain> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::union_pw_multi_aff::domain();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_pw_multi_aff::empty(ctx);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::intersect_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_aff<Domain2, Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::pullback(const typed::union_pw_aff<Domain> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, Range> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::union_pw_multi_aff::range_factor_domain();
+  return typed::union_pw_multi_aff<Domain, Range>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, Range2> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::union_pw_multi_aff::range_factor_range();
+  return typed::union_pw_multi_aff<Domain, Range2>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::multi_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+template <typename Arg3>
+typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::range_product(const typed::union_pw_aff<Domain, Arg3> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<pair<Range, Range2>, Arg3>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::space<> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::space() const
+{
+  auto res = isl::union_pw_multi_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::sub(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::space<Domain> &space) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::subtract_domain(const typed::union_set<Domain> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename Domain, typename Range, typename Range2>
+typed::union_pw_multi_aff<Domain, pair<Range, Range2>> typed::union_pw_multi_aff<Domain, pair<Range, Range2>>::union_add(const typed::union_pw_aff<Domain, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<Domain, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_pw_multi_aff(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &ma)
+  : isl::union_pw_multi_aff(ma)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_pw_multi_aff(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &pma)
+  : isl::union_pw_multi_aff(pma)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_pw_multi_aff(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upa)
+  : isl::union_pw_multi_aff(upa)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_pw_multi_aff(const isl::ctx &ctx, const std::string &str)
+  : isl::union_pw_multi_aff(ctx, str)
+{
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::add(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::union_pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::multi_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::pw_multi_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, Arg2> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::apply(const typed::union_pw_aff<pair<Range, Range2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::apply(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, Arg2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_multi_union_pw_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_multi_union_pw_aff();
+  return typed::multi_union_pw_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_pw_multi_aff() const
+{
+  auto res = isl::union_pw_multi_aff::as_pw_multi_aff();
+  return typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_map<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::as_union_map() const
+{
+  auto res = isl::union_pw_multi_aff::as_union_map();
+  return typed::union_map<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::coalesce() const
+{
+  auto res = isl::union_pw_multi_aff::coalesce();
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_set<pair<T1, T2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::domain() const
+{
+  auto res = isl::union_pw_multi_aff::domain();
+  return typed::union_set<pair<T1, T2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_pw_multi_aff::empty(ctx);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::union_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::basic_set<pair<T1, T2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::point<pair<T1, T2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::gist(const typed::set<pair<T1, T2>> &context) const
+{
+  auto res = isl::union_pw_multi_aff::gist(context);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_pw_multi_aff::intersect_params(set);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::union_pw_multi_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::multi_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::pw_multi_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain3>
+typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::preimage_domain_wrapped_domain(const typed::union_pw_aff<Domain3, T1> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::preimage_domain_wrapped_domain(upma2);
+  return typed::union_pw_multi_aff<pair<Domain3, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_multi_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::multi_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::pw_multi_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Domain2>
+typed::union_pw_multi_aff<Domain2, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_aff<Domain2, pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<Domain2, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::pullback(const typed::union_pw_aff<pair<T1, T2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::pullback(upma2);
+  return typed::union_pw_multi_aff<pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, Range> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_domain() const
+{
+  auto res = isl::union_pw_multi_aff::range_factor_domain();
+  return typed::union_pw_multi_aff<pair<T1, T2>, Range>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, Range2> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_factor_range() const
+{
+  auto res = isl::union_pw_multi_aff::range_factor_range();
+  return typed::union_pw_multi_aff<pair<T1, T2>, Range2>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::multi_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::pw_multi_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+template <typename Arg2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::range_product(const typed::union_pw_aff<pair<T1, T2>, Arg2> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::range_product(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<pair<Range, Range2>, Arg2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::space<> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::space() const
+{
+  auto res = isl::union_pw_multi_aff::space();
+  return typed::space<>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::sub(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::sub(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::space<pair<T1, T2>> &space) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(space);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::subtract_domain(const typed::union_set<pair<T1, T2>> &uset) const
+{
+  auto res = isl::union_pw_multi_aff::subtract_domain(uset);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+template <typename T1, typename T2, typename Range, typename Range2>
+typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>> typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>::union_add(const typed::union_pw_aff<pair<T1, T2>, pair<Range, Range2>> &upma2) const
+{
+  auto res = isl::union_pw_multi_aff::union_add(upma2);
+  return typed::union_pw_multi_aff<pair<T1, T2>, pair<Range, Range2>>(res);
+}
+
+typed::union_set<>::union_set(const typed::basic_set<> &bset)
+  : isl::union_set(bset)
+{
+}
+
+typed::union_set<>::union_set(const typed::point<> &pnt)
+  : isl::union_set(pnt)
+{
+}
+
+typed::union_set<>::union_set(const typed::set<> &set)
+  : isl::union_set(set)
+{
+}
+
+typed::union_set<>::union_set(const isl::ctx &ctx, const std::string &str)
+  : isl::union_set(ctx, str)
+{
+}
+
+typed::union_set<> typed::union_set<>::coalesce() const
+{
+  auto res = isl::union_set::coalesce();
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::detect_equalities() const
+{
+  auto res = isl::union_set::detect_equalities();
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_set::empty(ctx);
+  return typed::union_set<>(res);
+}
+
+bool typed::union_set<>::every_set(const std::function<bool(typed::set<>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<>(arg0));
+  };
+  return isl::union_set::every_set(lambda);
+}
+
+void typed::union_set<>::foreach_point(const std::function<void(typed::point<>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<>(arg0));
+  };
+  return isl::union_set::foreach_point(lambda);
+}
+
+void typed::union_set<>::foreach_set(const std::function<void(typed::set<>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<>(arg0));
+  };
+  return isl::union_set::foreach_set(lambda);
+}
+
+typed::union_set<> typed::union_set<>::gist(const typed::union_set<> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::gist(const typed::basic_set<> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::gist(const typed::point<> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::gist(const typed::set<> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::intersect(const typed::union_set<> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::intersect(const typed::basic_set<> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::intersect(const typed::point<> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::intersect(const typed::set<> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::space<> typed::union_set<>::space() const
+{
+  auto res = isl::union_set::space();
+  return typed::space<>(res);
+}
+
+typed::union_set<> typed::union_set<>::subtract(const typed::union_set<> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::subtract(const typed::basic_set<> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::subtract(const typed::point<> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::subtract(const typed::set<> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::unite(const typed::union_set<> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::unite(const typed::basic_set<> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::unite(const typed::point<> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::unite(const typed::set<> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<>(res);
+}
+
+typed::union_set<> typed::union_set<>::universe() const
+{
+  auto res = isl::union_set::universe();
+  return typed::union_set<>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain>::union_set(const typed::basic_set<Domain> &bset)
+  : isl::union_set(bset)
+{
+}
+
+template <typename Domain>
+typed::union_set<Domain>::union_set(const typed::point<Domain> &pnt)
+  : isl::union_set(pnt)
+{
+}
+
+template <typename Domain>
+typed::union_set<Domain>::union_set(const typed::set<Domain> &set)
+  : isl::union_set(set)
+{
+}
+
+template <typename Domain>
+typed::union_set<Domain>::union_set(const isl::ctx &ctx, const std::string &str)
+  : isl::union_set(ctx, str)
+{
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::union_set<Domain>::apply(const typed::union_map<Domain, Range> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::union_set<Domain>::apply(const typed::basic_map<Domain, Range> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+template <typename Range>
+typed::union_set<Range> typed::union_set<Domain>::apply(const typed::map<Domain, Range> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Range>(res);
+}
+
+template <typename Domain>
+typed::set<Domain> typed::union_set<Domain>::as_set() const
+{
+  auto res = isl::union_set::as_set();
+  return typed::set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::coalesce() const
+{
+  auto res = isl::union_set::coalesce();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::detect_equalities() const
+{
+  auto res = isl::union_set::detect_equalities();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_set::empty(ctx);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+bool typed::union_set<Domain>::every_set(const std::function<bool(typed::set<Domain>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<Domain>(arg0));
+  };
+  return isl::union_set::every_set(lambda);
+}
+
+template <typename Domain>
+void typed::union_set<Domain>::foreach_point(const std::function<void(typed::point<Domain>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<Domain>(arg0));
+  };
+  return isl::union_set::foreach_point(lambda);
+}
+
+template <typename Domain>
+void typed::union_set<Domain>::foreach_set(const std::function<void(typed::set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<Domain>(arg0));
+  };
+  return isl::union_set::foreach_set(lambda);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::gist(const typed::union_set<Domain> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::gist(const typed::basic_set<Domain> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::gist(const typed::point<Domain> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::gist(const typed::set<Domain> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_map<Domain, Domain> typed::union_set<Domain>::identity() const
+{
+  auto res = isl::union_set::identity();
+  return typed::union_map<Domain, Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect(const typed::basic_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect(const typed::point<Domain> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect(const typed::set<Domain> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::lexmax() const
+{
+  auto res = isl::union_set::lexmax();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::lexmin() const
+{
+  auto res = isl::union_set::lexmin();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<Domain>::preimage(const typed::multi_aff<Domain2, Domain> &ma) const
+{
+  auto res = isl::union_set::preimage(ma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<Domain>::preimage(const typed::pw_multi_aff<Domain2, Domain> &pma) const
+{
+  auto res = isl::union_set::preimage(pma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<Domain>::preimage(const typed::union_pw_multi_aff<Domain2, Domain> &upma) const
+{
+  auto res = isl::union_set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain>
+typed::space<> typed::union_set<Domain>::space() const
+{
+  auto res = isl::union_set::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::subtract(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::subtract(const typed::basic_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::subtract(const typed::point<Domain> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::subtract(const typed::set<Domain> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::unite(const typed::union_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::unite(const typed::basic_set<Domain> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::unite(const typed::point<Domain> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::unite(const typed::set<Domain> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set<Domain>::universe() const
+{
+  auto res = isl::union_set::universe();
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>>::union_set(const typed::basic_set<pair<Domain, Range>> &bset)
+  : isl::union_set(bset)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>>::union_set(const typed::point<pair<Domain, Range>> &pnt)
+  : isl::union_set(pnt)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>>::union_set(const typed::set<pair<Domain, Range>> &set)
+  : isl::union_set(set)
+{
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>>::union_set(const isl::ctx &ctx, const std::string &str)
+  : isl::union_set(ctx, str)
+{
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::union_set<pair<Domain, Range>>::apply(const typed::union_map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::union_set<pair<Domain, Range>>::apply(const typed::basic_map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Arg2>
+typed::union_set<Arg2> typed::union_set<pair<Domain, Range>>::apply(const typed::map<pair<Domain, Range>, Arg2> &umap) const
+{
+  auto res = isl::union_set::apply(umap);
+  return typed::union_set<Arg2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::as_set() const
+{
+  auto res = isl::union_set::as_set();
+  return typed::set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::coalesce() const
+{
+  auto res = isl::union_set::coalesce();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::detect_equalities() const
+{
+  auto res = isl::union_set::detect_equalities();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::empty(const isl::ctx &ctx)
+{
+  auto res = isl::union_set::empty(ctx);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+bool typed::union_set<pair<Domain, Range>>::every_set(const std::function<bool(typed::set<pair<Domain, Range>>)> &test) const
+{
+  auto lambda = & (isl::set arg0) {
+    return test(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::union_set::every_set(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::union_set<pair<Domain, Range>>::foreach_point(const std::function<void(typed::point<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::point arg0) {
+    return fn(typed::point<pair<Domain, Range>>(arg0));
+  };
+  return isl::union_set::foreach_point(lambda);
+}
+
+template <typename Domain, typename Range>
+void typed::union_set<pair<Domain, Range>>::foreach_set(const std::function<void(typed::set<pair<Domain, Range>>)> &fn) const
+{
+  auto lambda = & (isl::set arg0) {
+    return fn(typed::set<pair<Domain, Range>>(arg0));
+  };
+  return isl::union_set::foreach_set(lambda);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::gist(const typed::union_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::gist(const typed::basic_set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::gist(const typed::point<pair<Domain, Range>> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::gist(const typed::set<pair<Domain, Range>> &context) const
+{
+  auto res = isl::union_set::gist(context);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<pair<Domain, Range>, pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::identity() const
+{
+  auto res = isl::union_set::identity();
+  return typed::union_map<pair<Domain, Range>, pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect(const typed::basic_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect(const typed::point<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect(const typed::set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::intersect(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect_params(const typed::set<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect_params(const typed::basic_set<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::intersect_params(const typed::point<> &set) const
+{
+  auto res = isl::union_set::intersect_params(set);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::lexmax() const
+{
+  auto res = isl::union_set::lexmax();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::lexmin() const
+{
+  auto res = isl::union_set::lexmin();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<pair<Domain, Range>>::preimage(const typed::multi_aff<Domain2, pair<Domain, Range>> &ma) const
+{
+  auto res = isl::union_set::preimage(ma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<pair<Domain, Range>>::preimage(const typed::pw_multi_aff<Domain2, pair<Domain, Range>> &pma) const
+{
+  auto res = isl::union_set::preimage(pma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+template <typename Domain2>
+typed::union_set<Domain2> typed::union_set<pair<Domain, Range>>::preimage(const typed::union_pw_multi_aff<Domain2, pair<Domain, Range>> &upma) const
+{
+  auto res = isl::union_set::preimage(upma);
+  return typed::union_set<Domain2>(res);
+}
+
+template <typename Domain, typename Range>
+typed::space<> typed::union_set<pair<Domain, Range>>::space() const
+{
+  auto res = isl::union_set::space();
+  return typed::space<>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::subtract(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::subtract(const typed::basic_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::subtract(const typed::point<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::subtract(const typed::set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::subtract(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::unite(const typed::union_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::unite(const typed::basic_set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::unite(const typed::point<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::unite(const typed::set<pair<Domain, Range>> &uset2) const
+{
+  auto res = isl::union_set::unite(uset2);
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_set<pair<Domain, Range>> typed::union_set<pair<Domain, Range>>::universe() const
+{
+  auto res = isl::union_set::universe();
+  return typed::union_set<pair<Domain, Range>>(res);
+}
+
+template <typename Domain, typename Range>
+typed::union_map<Domain, Range> typed::union_set<pair<Domain, Range>>::unwrap() const
+{
+  auto res = isl::union_set::unwrap();
+  return typed::union_map<Domain, Range>(res);
+}
+
+typed::union_set_list<>::union_set_list(const isl::ctx &ctx, int n)
+  : isl::union_set_list(ctx, n)
+{
+}
+
+typed::union_set_list<>::union_set_list(const typed::union_set<> &el)
+  : isl::union_set_list(el)
+{
+}
+
+typed::union_set_list<> typed::union_set_list<>::add(const typed::union_set<> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<>(res);
+}
+
+typed::union_set_list<> typed::union_set_list<>::add(const typed::basic_set<> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<>(res);
+}
+
+typed::union_set_list<> typed::union_set_list<>::add(const typed::point<> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<>(res);
+}
+
+typed::union_set_list<> typed::union_set_list<>::add(const typed::set<> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<>(res);
+}
+
+typed::union_set_list<> typed::union_set_list<>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::union_set_list::drop(first, n);
+  return typed::union_set_list<>(res);
+}
+
+void typed::union_set_list<>::foreach(const std::function<void(typed::union_set<>)> &fn) const
+{
+  auto lambda = & (isl::union_set arg0) {
+    return fn(typed::union_set<>(arg0));
+  };
+  return isl::union_set_list::foreach(lambda);
+}
+
+template <typename Domain>
+typed::union_set_list<Domain>::union_set_list(const isl::ctx &ctx, int n)
+  : isl::union_set_list(ctx, n)
+{
+}
+
+template <typename Domain>
+typed::union_set_list<Domain>::union_set_list(const typed::union_set<Domain> &el)
+  : isl::union_set_list(el)
+{
+}
+
+template <typename Domain>
+typed::union_set_list<Domain> typed::union_set_list<Domain>::add(const typed::union_set<Domain> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set_list<Domain> typed::union_set_list<Domain>::add(const typed::basic_set<Domain> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set_list<Domain> typed::union_set_list<Domain>::add(const typed::point<Domain> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set_list<Domain> typed::union_set_list<Domain>::add(const typed::set<Domain> &el) const
+{
+  auto res = isl::union_set_list::add(el);
+  return typed::union_set_list<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set<Domain> typed::union_set_list<Domain>::at(int index) const
+{
+  auto res = isl::union_set_list::at(index);
+  return typed::union_set<Domain>(res);
+}
+
+template <typename Domain>
+typed::union_set_list<Domain> typed::union_set_list<Domain>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::union_set_list::drop(first, n);
+  return typed::union_set_list<Domain>(res);
+}
+
+template <typename Domain>
+void typed::union_set_list<Domain>::foreach(const std::function<void(typed::union_set<Domain>)> &fn) const
+{
+  auto lambda = & (isl::union_set arg0) {
+    return fn(typed::union_set<Domain>(arg0));
+  };
+  return isl::union_set_list::foreach(lambda);
+}
+
+typed::val<Anonymous>::val(const isl::ctx &ctx, long i)
+  : isl::val(ctx, i)
+{
+}
+
+typed::val<Anonymous>::val(const isl::ctx &ctx, const std::string &str)
+  : isl::val(ctx, str)
+{
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::add(const typed::val<Anonymous> &v2) const
+{
+  auto res = isl::val::add(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::add(long v2) const
+{
+  auto res = isl::val::add(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::floor() const
+{
+  auto res = isl::val::floor();
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::max(const typed::val<Anonymous> &v2) const
+{
+  auto res = isl::val::max(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::max(long v2) const
+{
+  auto res = isl::val::max(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::min(const typed::val<Anonymous> &v2) const
+{
+  auto res = isl::val::min(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::min(long v2) const
+{
+  auto res = isl::val::min(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::mod(const typed::val<Anonymous> &v2) const
+{
+  auto res = isl::val::mod(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::mod(long v2) const
+{
+  auto res = isl::val::mod(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::neg() const
+{
+  auto res = isl::val::neg();
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::sub(const typed::val<Anonymous> &v2) const
+{
+  auto res = isl::val::sub(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val<Anonymous>::sub(long v2) const
+{
+  auto res = isl::val::sub(v2);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val_list<Anonymous>::val_list(const isl::ctx &ctx, int n)
+  : isl::val_list(ctx, n)
+{
+}
+
+typed::val_list<Anonymous>::val_list(const typed::val<Anonymous> &el)
+  : isl::val_list(el)
+{
+}
+
+typed::val_list<Anonymous> typed::val_list<Anonymous>::add(const typed::val<Anonymous> &el) const
+{
+  auto res = isl::val_list::add(el);
+  return typed::val_list<Anonymous>(res);
+}
+
+typed::val_list<Anonymous> typed::val_list<Anonymous>::add(long el) const
+{
+  auto res = isl::val_list::add(el);
+  return typed::val_list<Anonymous>(res);
+}
+
+typed::val<Anonymous> typed::val_list<Anonymous>::at(int index) const
+{
+  auto res = isl::val_list::at(index);
+  return typed::val<Anonymous>(res);
+}
+
+typed::val_list<Anonymous> typed::val_list<Anonymous>::drop(unsigned int first, unsigned int n) const
+{
+  auto res = isl::val_list::drop(first, n);
+  return typed::val_list<Anonymous>(res);
+}
+
+void typed::val_list<Anonymous>::foreach(const std::function<void(typed::val<Anonymous>)> &fn) const
+{
+  auto lambda = & (isl::val arg0) {
+    return fn(typed::val<Anonymous>(arg0));
+  };
+  return isl::val_list::foreach(lambda);
+}
+
+} // namespace typed
+} // namespace isl
+
+#endif /* ISL_TYPED_CPP */

_service:tar_scm:isl-0.14.tar.xz/include/isl/union_map.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/union_map.h Changed

@@ -1,47 +1,73 @@
 #ifndef ISL_UNION_MAP_H
 #define ISL_UNION_MAP_H
 
-#include <isl/space.h>
+#include <isl/stdint.h>
+#include <isl/space_type.h>
+#include <isl/aff_type.h>
 #include <isl/map_type.h>
 #include <isl/union_map_type.h>
 #include <isl/printer.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
+isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
 	enum isl_dim_type type);
+isl_bool isl_union_map_involves_dims(__isl_keep isl_union_map *umap,
+	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_id *isl_union_map_get_dim_id(__isl_keep isl_union_map *umap,
 	enum isl_dim_type type, unsigned pos);
 
 __isl_constructor
 __isl_give isl_union_map *isl_union_map_from_basic_map(
 	__isl_take isl_basic_map *bmap);
+__isl_export
+__isl_give isl_union_map *isl_map_to_union_map(__isl_take isl_map *map);
 __isl_constructor
 __isl_give isl_union_map *isl_union_map_from_map(__isl_take isl_map *map);
-__isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *dim);
+__isl_overload
+__isl_give isl_union_map *isl_union_map_empty_ctx(isl_ctx *ctx);
+__isl_give isl_union_map *isl_union_map_empty_space(
+	__isl_take isl_space *space);
+__isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *space);
 __isl_give isl_union_map *isl_union_map_copy(__isl_keep isl_union_map *umap);
 __isl_null isl_union_map *isl_union_map_free(__isl_take isl_union_map *umap);
 
 isl_ctx *isl_union_map_get_ctx(__isl_keep isl_union_map *umap);
+__isl_export
 __isl_give isl_space *isl_union_map_get_space(__isl_keep isl_union_map *umap);
 
 __isl_give isl_union_map *isl_union_map_reset_user(
 	__isl_take isl_union_map *umap);
 
+int isl_union_map_find_dim_by_name(__isl_keep isl_union_map *umap,
+	enum isl_dim_type type, const char *name);
+
+__isl_export
 __isl_give isl_union_map *isl_union_map_universe(
 	__isl_take isl_union_map *umap);
 __isl_give isl_set *isl_union_map_params(__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_set *isl_union_map_domain(__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_set *isl_union_map_range(__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_domain_map(
 	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_pw_multi_aff *isl_union_map_domain_map_union_pw_multi_aff(
+	__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_range_map(
 	__isl_take isl_union_map *umap);
+__isl_give isl_union_map *isl_union_set_wrapped_domain_map(
+	__isl_take isl_union_set *uset);
+__isl_export
 __isl_give isl_union_map *isl_union_map_from_domain(
 	__isl_take isl_union_set *uset);
+__isl_export
 __isl_give isl_union_map *isl_union_map_from_range(
 	__isl_take isl_union_set *uset);
 
@@ -51,11 +77,14 @@
 __isl_export
 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
 	__isl_take isl_union_map *umap);
+__isl_give isl_union_map *isl_union_map_remove_redundancies(
+	__isl_take isl_union_map *umap);
 __isl_give isl_union_map *isl_union_map_simple_hull(
 	__isl_take isl_union_map *umap);
 __isl_export
 __isl_give isl_union_map *isl_union_map_coalesce(
 	__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_compute_divs(
 	__isl_take isl_union_map *umap);
 __isl_export
@@ -77,15 +106,38 @@
 __isl_export
 __isl_give isl_union_map *isl_union_map_intersect_params(
 	__isl_take isl_union_map *umap, __isl_take isl_set *set);
+__isl_export
 __isl_give isl_union_map *isl_union_map_product(__isl_take isl_union_map *umap1,
 	__isl_take isl_union_map *umap2);
+__isl_export
 __isl_give isl_union_map *isl_union_map_domain_product(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
+__isl_give isl_union_map *isl_union_map_flat_domain_product(
+	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
+__isl_export
 __isl_give isl_union_map *isl_union_map_range_product(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
 __isl_give isl_union_map *isl_union_map_flat_range_product(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
 __isl_export
+__isl_give isl_union_map *isl_union_map_domain_factor_domain(
+	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_domain_factor_range(
+	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_range_factor_domain(
+	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_range_factor_range(
+	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_factor_domain(
+	__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_factor_range(
+	__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_gist(__isl_take isl_union_map *umap,
 	__isl_take isl_union_map *context);
 __isl_export
@@ -98,12 +150,34 @@
 __isl_give isl_union_map *isl_union_map_gist_range(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
 
-__isl_export
+__isl_overload
+__isl_give isl_union_map *isl_union_map_intersect_domain_union_set(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_map *isl_union_map_intersect_domain_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space);
 __isl_give isl_union_map *isl_union_map_intersect_domain(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
-__isl_export
+__isl_overload
+__isl_give isl_union_map *isl_union_map_intersect_range_union_set(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
+__isl_overload
+__isl_give isl_union_map *isl_union_map_intersect_range_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space);
 __isl_give isl_union_map *isl_union_map_intersect_range(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_union_map *isl_union_map_intersect_domain_factor_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor);
+__isl_export
+__isl_give isl_union_map *isl_union_map_intersect_domain_factor_range(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor);
+__isl_export
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor);
+__isl_export
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_range(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor);
 
 __isl_export
 __isl_give isl_union_map *isl_union_map_subtract_domain(
@@ -118,24 +192,35 @@
 __isl_export
 __isl_give isl_union_map *isl_union_map_apply_range(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_domain_multi_aff(
 	__isl_take isl_union_map *umap, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_range_multi_aff(
 	__isl_take isl_union_map *umap, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_domain_pw_multi_aff(
 	__isl_take isl_union_map *umap, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_range_pw_multi_aff(
 	__isl_take isl_union_map *umap, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_domain_multi_pw_aff(
 	__isl_take isl_union_map *umap, __isl_take isl_multi_pw_aff *mpa);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_domain_union_pw_multi_aff(
 	__isl_take isl_union_map *umap,
 	__isl_take isl_union_pw_multi_aff *upma);
+__isl_overload
 __isl_give isl_union_map *isl_union_map_preimage_range_union_pw_multi_aff(
 	__isl_take isl_union_map *umap,
 	__isl_take isl_union_pw_multi_aff *upma);
 __isl_export
 __isl_give isl_union_map *isl_union_map_reverse(__isl_take isl_union_map *umap);
+__isl_export
+__isl_give isl_union_map *isl_union_map_range_reverse(
+	__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_from_domain_and_range(
 	__isl_take isl_union_set *domain, __isl_take isl_union_set *range);
 
@@ -152,45 +237,75 @@
 __isl_give isl_union_map *isl_union_map_project_out(
 	__isl_take isl_union_map *umap,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_export
+__isl_give isl_union_map *isl_union_map_project_out_all_params(
+	__isl_take isl_union_map *umap);
+__isl_give isl_union_map *isl_union_map_remove_divs(
+	__isl_take isl_union_map *bmap);
+
+__isl_export
+__isl_give isl_union_set *isl_union_map_bind_range(
+	__isl_take isl_union_map *umap, __isl_take isl_multi_id *tuple);
 
+isl_bool isl_union_map_plain_is_empty(__isl_keep isl_union_map *umap);
 __isl_export
-int isl_union_map_is_empty(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_is_empty(__isl_keep isl_union_map *umap);
 __isl_export
-int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
-int isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_is_single_valued(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap);
 __isl_export
-int isl_union_map_is_injective(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_is_injective(__isl_keep isl_union_map *umap);
 __isl_export
-int isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_is_bijective(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_is_identity(__isl_keep isl_union_map *umap);
 
 __isl_export
-int isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
+	__isl_keep isl_union_map *umap2);
+__isl_export
+isl_bool isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2);
 __isl_export
-int isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_disjoint(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2);
 __isl_export
-int isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2);
 
-int isl_union_map_n_map(__isl_keep isl_union_map *umap);
+uint32_t isl_union_map_get_hash(__isl_keep isl_union_map *umap);
+
+isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap);
+__isl_export
+isl_stat isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
+	isl_stat (*fn)(__isl_take isl_map *map, void *user), void *user);
+__isl_give isl_map_list *isl_union_map_get_map_list(
+	__isl_keep isl_union_map *umap);
+__isl_export
+isl_bool isl_union_map_every_map(__isl_keep isl_union_map *umap,
+	isl_bool (*test)(__isl_keep isl_map *map, void *user), void *user);
+__isl_give isl_union_map *isl_union_map_remove_map_if(
+	__isl_take isl_union_map *umap,
+	isl_bool (*fn)(__isl_keep isl_map *map, void *user), void *user);
+isl_bool isl_union_map_contains(__isl_keep isl_union_map *umap,
+	__isl_keep isl_space *space);
 __isl_export
-int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
-	int (*fn)(__isl_take isl_map *map, void *user), void *user);
-__isl_give int isl_union_map_contains(__isl_keep isl_union_map *umap,
-	__isl_keep isl_space *dim);
 __isl_give isl_map *isl_union_map_extract_map(__isl_keep isl_union_map *umap,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
+__isl_export
+isl_bool isl_union_map_isa_map(__isl_keep isl_union_map *umap);
+__isl_export
+__isl_give isl_map *isl_union_map_as_map(__isl_take isl_union_map *umap);
 __isl_give isl_map *isl_map_from_union_map(__isl_take isl_union_map *umap);
 
 __isl_give isl_basic_map *isl_union_map_sample(__isl_take isl_union_map *umap);
 
+__isl_overload
 __isl_give isl_union_map *isl_union_map_fixed_power_val(
 	__isl_take isl_union_map *umap, __isl_take isl_val *exp);
 __isl_give isl_union_map *isl_union_map_power(__isl_take isl_union_map *umap,
-	int *exact);
+	isl_bool *exact);
 __isl_give isl_union_map *isl_union_map_transitive_closure(
-	__isl_take isl_union_map *umap, int *exact);
+	__isl_take isl_union_map *umap, isl_bool *exact);
 
 __isl_give isl_union_map *isl_union_map_lex_lt_union_map(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
@@ -201,20 +316,45 @@
 __isl_give isl_union_map *isl_union_map_lex_ge_union_map(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2);
 
+__isl_overload
+__isl_give isl_union_map *isl_union_map_eq_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_union_map *isl_union_map_lex_le_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_union_map *isl_union_map_lex_lt_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_union_map *isl_union_map_lex_ge_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_union_map *isl_union_map_lex_gt_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa);
+
 __isl_give isl_union_map *isl_union_map_read_from_file(isl_ctx *ctx,
 	FILE *input);
 __isl_constructor
 __isl_give isl_union_map *isl_union_map_read_from_str(isl_ctx *ctx,
 	const char *str);
+__isl_give char *isl_union_map_to_str(__isl_keep isl_union_map *umap);
 __isl_give isl_printer *isl_printer_print_union_map(__isl_take isl_printer *p,
 	__isl_keep isl_union_map *umap);
 void isl_union_map_dump(__isl_keep isl_union_map *umap);
 
+__isl_export
 __isl_give isl_union_set *isl_union_map_wrap(__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset);
 
+__isl_export
 __isl_give isl_union_map *isl_union_map_zip(__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_curry(__isl_take isl_union_map *umap);
+__isl_give isl_union_map *isl_union_map_range_curry(
+	__isl_take isl_union_map *umap);
+__isl_export
 __isl_give isl_union_map *isl_union_map_uncurry(__isl_take isl_union_map *umap);
 
 __isl_give isl_union_map *isl_union_map_align_params(
@@ -222,10 +362,10 @@
 __isl_give isl_union_set *isl_union_set_align_params(
 	__isl_take isl_union_set *uset, __isl_take isl_space *model);
 
+ISL_DECLARE_LIST_FN(union_map)
+
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/union_map_type.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/union_map_type.h Changed

_service:tar_scm:isl-0.14.tar.xz/include/isl/union_set.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/union_set.h Changed

@@ -8,21 +8,32 @@
 extern "C" {
 #endif
 
+isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
+	enum isl_dim_type type);
+
 __isl_constructor
 __isl_give isl_union_set *isl_union_set_from_basic_set(
 	__isl_take isl_basic_set *bset);
+__isl_export
+__isl_give isl_union_set *isl_set_to_union_set(__isl_take isl_set *set);
 __isl_constructor
 __isl_give isl_union_set *isl_union_set_from_set(__isl_take isl_set *set);
-__isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *dim);
+__isl_overload
+__isl_give isl_union_set *isl_union_set_empty_ctx(isl_ctx *ctx);
+__isl_give isl_union_set *isl_union_set_empty_space(
+	__isl_take isl_space *space);
+__isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *space);
 __isl_give isl_union_set *isl_union_set_copy(__isl_keep isl_union_set *uset);
 __isl_null isl_union_set *isl_union_set_free(__isl_take isl_union_set *uset);
 
 isl_ctx *isl_union_set_get_ctx(__isl_keep isl_union_set *uset);
+__isl_export
 __isl_give isl_space *isl_union_set_get_space(__isl_keep isl_union_set *uset);
 
 __isl_give isl_union_set *isl_union_set_reset_user(
 	__isl_take isl_union_set *uset);
 
+__isl_export
 __isl_give isl_union_set *isl_union_set_universe(
 	__isl_take isl_union_set *uset);
 __isl_give isl_set *isl_union_set_params(__isl_take isl_union_set *uset);
@@ -36,11 +47,14 @@
 __isl_export
 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
 	__isl_take isl_union_set *uset);
+__isl_give isl_union_set *isl_union_set_remove_redundancies(
+	__isl_take isl_union_set *uset);
 __isl_give isl_union_set *isl_union_set_simple_hull(
 	__isl_take isl_union_set *uset);
 __isl_export
 __isl_give isl_union_set *isl_union_set_coalesce(
 	__isl_take isl_union_set *uset);
+__isl_export
 __isl_give isl_union_set *isl_union_set_compute_divs(
 	__isl_take isl_union_set *uset);
 __isl_export
@@ -50,6 +64,7 @@
 
 __isl_give isl_union_set *isl_union_set_add_set(__isl_take isl_union_set *uset,
 	__isl_take isl_set *set);
+__isl_export
 __isl_give isl_union_set *isl_union_set_union(__isl_take isl_union_set *uset1,
 	__isl_take isl_union_set *uset2);
 __isl_export
@@ -73,41 +88,76 @@
 __isl_export
 __isl_give isl_union_set *isl_union_set_apply(
 	__isl_take isl_union_set *uset, __isl_take isl_union_map *umap);
+__isl_overload
 __isl_give isl_union_set *isl_union_set_preimage_multi_aff(
 	__isl_take isl_union_set *uset, __isl_take isl_multi_aff *ma);
+__isl_overload
 __isl_give isl_union_set *isl_union_set_preimage_pw_multi_aff(
 	__isl_take isl_union_set *uset, __isl_take isl_pw_multi_aff *pma);
+__isl_overload
 __isl_give isl_union_set *isl_union_set_preimage_union_pw_multi_aff(
 	__isl_take isl_union_set *uset,
 	__isl_take isl_union_pw_multi_aff *upma);
 
-int isl_union_set_is_params(__isl_keep isl_union_set *uset);
+__isl_give isl_union_set *isl_union_set_project_out(
+	__isl_take isl_union_set *uset,
+	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_union_set *isl_union_set_project_out_all_params(
+	__isl_take isl_union_set *uset);
+__isl_give isl_union_set *isl_union_set_remove_divs(
+	__isl_take isl_union_set *bset);
+
+isl_bool isl_union_set_is_params(__isl_keep isl_union_set *uset);
 __isl_export
-int isl_union_set_is_empty(__isl_keep isl_union_set *uset);
+isl_bool isl_union_set_is_empty(__isl_keep isl_union_set *uset);
 
 __isl_export
-int isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2);
 __isl_export
-int isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2);
 __isl_export
-int isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_disjoint(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2);
+__isl_export
+isl_bool isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
+	__isl_keep isl_union_set *uset2);
+
+uint32_t isl_union_set_get_hash(__isl_keep isl_union_set *uset);
 
-int isl_union_set_n_set(__isl_keep isl_union_set *uset);
+isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset);
+__isl_export
+isl_stat isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
+	isl_stat (*fn)(__isl_take isl_set *set, void *user), void *user);
+__isl_export
+isl_bool isl_union_set_every_set(__isl_keep isl_union_set *uset,
+	isl_bool (*test)(__isl_keep isl_set *set, void *user), void *user);
+__isl_give isl_basic_set_list *isl_union_set_get_basic_set_list(
+	__isl_keep isl_union_set *uset);
+__isl_give isl_set_list *isl_union_set_get_set_list(
+	__isl_keep isl_union_set *uset);
+isl_bool isl_union_set_contains(__isl_keep isl_union_set *uset,
+	__isl_keep isl_space *space);
 __isl_export
-int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
-	int (*fn)(__isl_take isl_set *set, void *user), void *user);
-__isl_give int isl_union_set_contains(__isl_keep isl_union_set *uset,
-	__isl_keep isl_space *dim);
 __isl_give isl_set *isl_union_set_extract_set(__isl_keep isl_union_set *uset,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
+__isl_export
+isl_bool isl_union_set_isa_set(__isl_keep isl_union_set *uset);
+__isl_export
+__isl_give isl_set *isl_union_set_as_set(__isl_take isl_union_set *uset);
 __isl_give isl_set *isl_set_from_union_set(__isl_take isl_union_set *uset);
-int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
-	int (*fn)(__isl_take isl_point *pnt, void *user), void *user);
+__isl_export
+isl_stat isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user);
 
 __isl_give isl_basic_set *isl_union_set_sample(__isl_take isl_union_set *uset);
+__isl_export
+__isl_give isl_point *isl_union_set_sample_point(
+	__isl_take isl_union_set *uset);
+
+__isl_constructor
+__isl_give isl_union_set *isl_union_set_from_point(__isl_take isl_point *pnt);
 
 __isl_give isl_union_set *isl_union_set_lift(__isl_take isl_union_set *uset);
 
@@ -130,14 +180,18 @@
 __isl_constructor
 __isl_give isl_union_set *isl_union_set_read_from_str(isl_ctx *ctx,
 	const char *str);
+__isl_give char *isl_union_set_to_str(__isl_keep isl_union_set *uset);
 __isl_give isl_printer *isl_printer_print_union_set(__isl_take isl_printer *p,
 	__isl_keep isl_union_set *uset);
 void isl_union_set_dump(__isl_keep isl_union_set *uset);
 
+ISL_DECLARE_EXPORTED_LIST_FN(union_set)
+
+__isl_give isl_union_set *isl_union_set_list_union(
+	__isl_take isl_union_set_list *list);
+
 #if defined(__cplusplus)
 }
 #endif
 
-#include <isl/dim.h>
-
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/val.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/val.h Changed

@@ -1,31 +1,40 @@
 #ifndef ISL_VAL_H
 #define ISL_VAL_H
 
+#include <isl/stdint.h>
 #include <isl/ctx.h>
 #include <isl/list.h>
 #include <isl/multi.h>
 #include <isl/printer.h>
+#include <isl/val_type.h>
 
 #if defined(__cplusplus)
 extern "C" {
 #endif
 
-struct isl_val;
-typedef struct isl_val isl_val;
-
-ISL_DECLARE_LIST(val)
-
-struct isl_multi_val;
-typedef struct isl_multi_val isl_multi_val;
-
 ISL_DECLARE_MULTI(val)
-
+ISL_DECLARE_MULTI_ARITH(val)
+ISL_DECLARE_MULTI_MIN_MAX(val)
+ISL_DECLARE_MULTI_ZERO(val)
+ISL_DECLARE_MULTI_NAN(val)
+ISL_DECLARE_MULTI_DIMS(val)
+ISL_DECLARE_MULTI_DIM_ID(val)
+ISL_DECLARE_MULTI_TUPLE_ID(val)
+ISL_DECLARE_MULTI_WITH_DOMAIN(val)
+
+__isl_export
 __isl_give isl_val *isl_val_zero(isl_ctx *ctx);
+__isl_export
 __isl_give isl_val *isl_val_one(isl_ctx *ctx);
+__isl_export
 __isl_give isl_val *isl_val_negone(isl_ctx *ctx);
+__isl_export
 __isl_give isl_val *isl_val_nan(isl_ctx *ctx);
+__isl_export
 __isl_give isl_val *isl_val_infty(isl_ctx *ctx);
+__isl_export
 __isl_give isl_val *isl_val_neginfty(isl_ctx *ctx);
+__isl_constructor
 __isl_give isl_val *isl_val_int_from_si(isl_ctx *ctx, long i);
 __isl_give isl_val *isl_val_int_from_ui(isl_ctx *ctx, unsigned long u);
 __isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx, size_t n,
@@ -35,76 +44,133 @@
 __isl_null isl_val *isl_val_free(__isl_take isl_val *v);
 
 isl_ctx *isl_val_get_ctx(__isl_keep isl_val *val);
+uint32_t isl_val_get_hash(__isl_keep isl_val *val);
+__isl_export
 long isl_val_get_num_si(__isl_keep isl_val *v);
+__isl_export
 long isl_val_get_den_si(__isl_keep isl_val *v);
+__isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v);
 double isl_val_get_d(__isl_keep isl_val *v);
-size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size);
-int isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
+isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size);
+isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
 	void *chunks);
 
 __isl_give isl_val *isl_val_set_si(__isl_take isl_val *v, long i);
 
+__isl_export
 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v);
+__isl_export
 __isl_give isl_val *isl_val_neg(__isl_take isl_val *v);
+__isl_export
+__isl_give isl_val *isl_val_inv(__isl_take isl_val *v);
+__isl_export
 __isl_give isl_val *isl_val_floor(__isl_take isl_val *v);
+__isl_export
 __isl_give isl_val *isl_val_ceil(__isl_take isl_val *v);
+__isl_export
 __isl_give isl_val *isl_val_trunc(__isl_take isl_val *v);
 __isl_give isl_val *isl_val_2exp(__isl_take isl_val *v);
+__isl_export
+__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v);
+__isl_export
 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2);
+__isl_export
 __isl_give isl_val *isl_val_max(__isl_take isl_val *v1, __isl_take isl_val *v2);
+__isl_export
 __isl_give isl_val *isl_val_add(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_add_ui(__isl_take isl_val *v1, unsigned long v2);
+__isl_export
 __isl_give isl_val *isl_val_sub(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_sub_ui(__isl_take isl_val *v1, unsigned long v2);
+__isl_export
 __isl_give isl_val *isl_val_mul(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_mul_ui(__isl_take isl_val *v1, unsigned long v2);
+__isl_export
 __isl_give isl_val *isl_val_div(__isl_take isl_val *v1, __isl_take isl_val *v2);
+__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2);
+__isl_export
 __isl_give isl_val *isl_val_mod(__isl_take isl_val *v1, __isl_take isl_val *v2);
+__isl_export
 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2);
 __isl_give isl_val *isl_val_gcdext(__isl_take isl_val *v1,
 	__isl_take isl_val *v2, __isl_give isl_val **x, __isl_give isl_val **y);
 
+__isl_export
 int isl_val_sgn(__isl_keep isl_val *v);
-int isl_val_is_zero(__isl_keep isl_val *v);
-int isl_val_is_one(__isl_keep isl_val *v);
-int isl_val_is_negone(__isl_keep isl_val *v);
-int isl_val_is_nonneg(__isl_keep isl_val *v);
-int isl_val_is_nonpos(__isl_keep isl_val *v);
-int isl_val_is_pos(__isl_keep isl_val *v);
-int isl_val_is_neg(__isl_keep isl_val *v);
-int isl_val_is_int(__isl_keep isl_val *v);
-int isl_val_is_rat(__isl_keep isl_val *v);
-int isl_val_is_nan(__isl_keep isl_val *v);
-int isl_val_is_infty(__isl_keep isl_val *v);
-int isl_val_is_neginfty(__isl_keep isl_val *v);
-
+__isl_export
+isl_bool isl_val_is_zero(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_one(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_negone(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_nonneg(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_nonpos(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_pos(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_neg(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_int(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_rat(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_nan(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_infty(__isl_keep isl_val *v);
+__isl_export
+isl_bool isl_val_is_neginfty(__isl_keep isl_val *v);
+
+__isl_export
 int isl_val_cmp_si(__isl_keep isl_val *v, long i);
 
-int isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-int isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-int isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-int isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-int isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-int isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-
-int isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
-
+__isl_export
+isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+__isl_export
+isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+__isl_export
+isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i);
+__isl_export
+isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+__isl_export
+isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i);
+__isl_export
+isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+__isl_export
+isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2);
+
+__isl_export
+isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1,
+	__isl_keep isl_val *v2);
+
+__isl_constructor
 __isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx, const char *str);
 __isl_give isl_printer *isl_printer_print_val(__isl_take isl_printer *p,
 	__isl_keep isl_val *v);
 void isl_val_dump(__isl_keep isl_val *v);
 __isl_give char *isl_val_to_str(__isl_keep isl_val *v);
 
+isl_bool isl_multi_val_is_zero(__isl_keep isl_multi_val *mv);
+
+__isl_overload
 __isl_give isl_multi_val *isl_multi_val_add_val(__isl_take isl_multi_val *mv,
 	__isl_take isl_val *v);
 __isl_give isl_multi_val *isl_multi_val_mod_val(__isl_take isl_multi_val *mv,
 	__isl_take isl_val *v);
 
+__isl_constructor
+__isl_give isl_multi_val *isl_multi_val_read_from_str(isl_ctx *ctx,
+	const char *str);
 __isl_give isl_printer *isl_printer_print_multi_val(__isl_take isl_printer *p,
 	__isl_keep isl_multi_val *mv);
 void isl_multi_val_dump(__isl_keep isl_multi_val *mv);
 __isl_give char *isl_multi_val_to_str(__isl_keep isl_multi_val *mv);
 
+ISL_DECLARE_EXPORTED_LIST_FN(val)
+
 #if defined(__cplusplus)
 }
 #endif

_service:tar_scm:isl-0.14.tar.xz/include/isl/val_gmp.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/val_gmp.h Changed

_service:tar_scm:isl-0.24.tar.gz/include/isl/val_type.h Added

_service:tar_scm:isl-0.14.tar.xz/include/isl/vec.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/vec.h Changed

@@ -13,7 +13,7 @@
 #include <stdio.h>
 
 #include <isl/ctx.h>
-#include <isl/val.h>
+#include <isl/val_type.h>
 #include <isl/printer.h>
 
 #if defined(__cplusplus)
@@ -24,19 +24,20 @@
 typedef struct isl_vec isl_vec;
 
 __isl_give isl_vec *isl_vec_alloc(isl_ctx *ctx, unsigned size);
+__isl_give isl_vec *isl_vec_zero(isl_ctx *ctx, unsigned size);
 __isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec);
 __isl_null isl_vec *isl_vec_free(__isl_take isl_vec *vec);
 
 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec);
 
-int isl_vec_size(__isl_keep isl_vec *vec);
+isl_size isl_vec_size(__isl_keep isl_vec *vec);
 __isl_give isl_val *isl_vec_get_element_val(__isl_keep isl_vec *vec, int pos);
 __isl_give isl_vec *isl_vec_set_element_si(__isl_take isl_vec *vec,
 	int pos, int v);
 __isl_give isl_vec *isl_vec_set_element_val(__isl_take isl_vec *vec,
 	int pos, __isl_take isl_val *v);
 
-int isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2);
+isl_bool isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2);
 int isl_vec_cmp_element(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2,
 	int pos);
 
@@ -44,8 +45,8 @@
 __isl_give isl_printer *isl_printer_print_vec(__isl_take isl_printer *printer,
 	__isl_keep isl_vec *vec);
 
-struct isl_vec *isl_vec_ceil(struct isl_vec *vec);
-struct isl_vec *isl_vec_normalize(struct isl_vec *vec);
+__isl_give isl_vec *isl_vec_ceil(__isl_take isl_vec *vec);
+__isl_give isl_vec *isl_vec_normalize(__isl_take isl_vec *vec);
 __isl_give isl_vec *isl_vec_set_si(__isl_take isl_vec *vec, int v);
 __isl_give isl_vec *isl_vec_set_val(__isl_take isl_vec *vec,
 	__isl_take isl_val *v);
@@ -64,6 +65,7 @@
 
 __isl_give isl_vec *isl_vec_drop_els(__isl_take isl_vec *vec,
 	unsigned pos, unsigned n);
+__isl_give isl_vec *isl_vec_add_els(__isl_take isl_vec *vec, unsigned n);
 __isl_give isl_vec *isl_vec_insert_els(__isl_take isl_vec *vec,
 	unsigned pos, unsigned n);
 __isl_give isl_vec *isl_vec_insert_zero_els(__isl_take isl_vec *vec,

_service:tar_scm:isl-0.14.tar.xz/include/isl/vertices.h -> _service:tar_scm:isl-0.24.tar.gz/include/isl/vertices.h Changed

@@ -18,27 +18,27 @@
 typedef struct isl_vertices	isl_vertices;
 
 isl_ctx *isl_vertex_get_ctx(__isl_keep isl_vertex *vertex);
-int isl_vertex_get_id(__isl_keep isl_vertex *vertex);
+isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex);
 __isl_give isl_basic_set *isl_vertex_get_domain(__isl_keep isl_vertex *vertex);
 __isl_give isl_multi_aff *isl_vertex_get_expr(__isl_keep isl_vertex *vertex);
-void isl_vertex_free(__isl_take isl_vertex *vertex);
+__isl_null isl_vertex *isl_vertex_free(__isl_take isl_vertex *vertex);
 
 __isl_give isl_vertices *isl_basic_set_compute_vertices(
 	__isl_keep isl_basic_set *bset);
 isl_ctx *isl_vertices_get_ctx(__isl_keep isl_vertices *vertices);
-int isl_vertices_get_n_vertices(__isl_keep isl_vertices *vertices);
-int isl_vertices_foreach_vertex(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_vertex *vertex, void *user), void *user);
-void isl_vertices_free(__isl_take isl_vertices *vertices);
+isl_size isl_vertices_get_n_vertices(__isl_keep isl_vertices *vertices);
+isl_stat isl_vertices_foreach_vertex(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_vertex *vertex, void *user), void *user);
+__isl_null isl_vertices *isl_vertices_free(__isl_take isl_vertices *vertices);
 
 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell);
 __isl_give isl_basic_set *isl_cell_get_domain(__isl_keep isl_cell *cell);
-int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
-	int (*fn)(__isl_take isl_vertex *vertex, void *user), void *user);
-void isl_cell_free(__isl_take isl_cell *cell);
+isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
+	isl_stat (*fn)(__isl_take isl_vertex *vertex, void *user), void *user);
+__isl_null isl_cell *isl_cell_free(__isl_take isl_cell *cell);
 
-int isl_vertices_foreach_cell(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_cell *cell, void *user), void *user);
+isl_stat isl_vertices_foreach_cell(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_cell *cell, void *user), void *user);
 
 #if defined(__cplusplus)
 }

_service:tar_scm:isl-0.14.tar.xz/install-sh -> _service:tar_scm:isl-0.24.tar.gz/install-sh Changed

@@ -1,7 +1,7 @@
 #!/bin/sh
 # install - install a program, script, or datafile
 
-scriptversion=2011-11-20.07; # UTC
+scriptversion=2018-03-11.20; # UTC
 
 # This originates from X11R5 (mit/util/scripts/install.sh), which was
 # later released in X11R6 (xc/config/util/install.sh) with the
@@ -41,19 +41,15 @@
 # This script is compatible with the BSD install script, but was written
 # from scratch.
 
+tab='	'
 nl='
 '
-IFS=" ""	$nl"
+IFS=" $tab$nl"
 
-# set DOITPROG to echo to test this script
+# Set DOITPROG to "echo" to test this script.
 
-# Don't use :- since 4.3BSD and earlier shells don't like it.
 doit=${DOITPROG-}
-if test -z "$doit"; then
-  doit_exec=exec
-else
-  doit_exec=$doit
-fi
+doit_exec=${doit:-exec}
 
 # Put in absolute file names if you don't have them in your path;
 # or use environment vars.
@@ -68,17 +64,6 @@
 rmprog=${RMPROG-rm}
 stripprog=${STRIPPROG-strip}
 
-posix_glob='?'
-initialize_posix_glob='
-  test "$posix_glob" != "?" || {
-    if (set -f) 2>/dev/null; then
-      posix_glob=
-    else
-      posix_glob=:
-    fi
-  }
-'
-
 posix_mkdir=
 
 # Desired mode of installed file.
@@ -97,7 +82,7 @@
 dst_arg=
 
 copy_on_change=false
-no_target_directory=
+is_target_a_directory=possibly
 
 usage="\
 Usage: $0 OPTION... -T SRCFILE DSTFILE
@@ -137,46 +122,57 @@
     -d) dir_arg=true;;
 
     -g) chgrpcmd="$chgrpprog $2"
-	shift;;
+        shift;;
 
     --help) echo "$usage"; exit $?;;
 
     -m) mode=$2
-	case $mode in
-	  *' '* | *'	'* | *'
-'*	  | *'*'* | *'?'* | *''*)
-	    echo "$0: invalid mode: $mode" >&2
-	    exit 1;;
-	esac
-	shift;;
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *''*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
 
     -o) chowncmd="$chownprog $2"
-	shift;;
+        shift;;
 
     -s) stripcmd=$stripprog;;
 
-    -t) dst_arg=$2
-	# Protect names problematic for 'test' and other utilities.
-	case $dst_arg in
-	  -* | =!) dst_arg=./$dst_arg;;
-	esac
-	shift;;
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | =!) dst_arg=./$dst_arg;;
+        esac
+        shift;;
 
-    -T) no_target_directory=true;;
+    -T) is_target_a_directory=never;;
 
     --version) echo "$0 $scriptversion"; exit $?;;
 
-    --)	shift
-	break;;
+    --) shift
+        break;;
 
-    -*)	echo "$0: invalid option: $1" >&2
-	exit 1;;
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
 
     *)  break;;
   esac
   shift
 done
 
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+  if test -n "$dst_arg"; then
+    echo "$0: target directory not allowed when installing a directory." >&2
+    exit 1
+  fi
+fi
+
 if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
   # When -d is used, all remaining arguments are directories to create.
   # When -t is used, the destination is already specified.
@@ -208,6 +204,15 @@
 fi
 
 if test -z "$dir_arg"; then
+  if test $# -gt 1 || test "$is_target_a_directory" = always; then
+    if test ! -d "$dst_arg"; then
+      echo "$0: $dst_arg: Is not a directory." >&2
+      exit 1
+    fi
+  fi
+fi
+
+if test -z "$dir_arg"; then
   do_exit='(exit $ret); exit $ret'
   trap "ret=129; $do_exit" 1
   trap "ret=130; $do_exit" 2
@@ -223,16 +228,16 @@
 
     *0-7)
       if test -z "$stripcmd"; then
-	u_plus_rw=
+        u_plus_rw=
       else
-	u_plus_rw='% 200'
+        u_plus_rw='% 200'
       fi
       cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
     *)
       if test -z "$stripcmd"; then
-	u_plus_rw=
+        u_plus_rw=
       else
-	u_plus_rw=,u+rw
+        u_plus_rw=,u+rw
       fi
       cp_umask=$mode$u_plus_rw;;
   esac
@@ -266,122 +271,113 @@
     fi
     dst=$dst_arg
 
-    # If destination is a directory, append the input filename; won't work
-    # if double slashes aren't ignored.
+    # If destination is a directory, append the input filename.
     if test -d "$dst"; then
-      if test -n "$no_target_directory"; then
-	echo "$0: $dst_arg: Is a directory" >&2
-	exit 1
+      if test "$is_target_a_directory" = never; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
       fi
       dstdir=$dst
-      dst=$dstdir/`basename "$src"`
+      dstbase=`basename "$src"`
+      case $dst in
+	*/) dst=$dst$dstbase;;
+	*)  dst=$dst/$dstbase;;
+      esac
       dstdir_status=0
     else
-      # Prefer dirname, but fall back on a substitute if dirname fails.
-      dstdir=`
-	(dirname "$dst") 2>/dev/null ||
-	expr X"$dst" : 'X$.*^/$//*^/^/*/*$' \| \
-	     X"$dst" : 'X$//$^/' \| \
-	     X"$dst" : 'X$//$$' \| \
-	     X"$dst" : 'X$/$' \| . 2>/dev/null ||
-	echo X"$dst" |
-	    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
-		   s//\1/
-		   q
-		 }
-		 /^X$\/\/$^/.*/{
-		   s//\1/
-		   q
-		 }
-		 /^X$\/\/$$/{
-		   s//\1/
-		   q
-		 }
-		 /^X$\/$.*/{
-		   s//\1/
-		   q
-		 }
-		 s/.*/./; q'
-      `
-
+      dstdir=`dirname "$dst"`
       test -d "$dstdir"
       dstdir_status=$?
     fi
   fi
 
+  case $dstdir in
+    */) dstdirslash=$dstdir;;
+    *)  dstdirslash=$dstdir/;;
+  esac
+
   obsolete_mkdir_used=false
 
   if test $dstdir_status != 0; then
     case $posix_mkdir in
       '')
-	# Create intermediate dirs using mode 755 as modified by the umask.
-	# This is like FreeBSD 'install' as of 1997-10-28.
-	umask=`umask`
-	case $stripcmd.$umask in
-	  # Optimize common cases.
-	  *23672367) mkdir_umask=$umask;;
-	  .*00202 | .0202 | .02) mkdir_umask=22;;
-
-	  *0-7)
-	    mkdir_umask=`expr $umask + 22 \
-	      - $umask % 100 % 40 + $umask % 20 \
-	      - $umask % 10 % 4 + $umask % 2
-	    `;;
-	  *) mkdir_umask=$umask,go-w;;
-	esac
-
-	# With -d, create the new directory with the user-specified mode.
-	# Otherwise, rely on $mkdir_umask.
-	if test -n "$dir_arg"; then
-	  mkdir_mode=-m$mode
-	else
-	  mkdir_mode=
-	fi
-
-	posix_mkdir=false
-	case $umask in
-	  *1235670-70-7)
-	    # POSIX mkdir -p sets u+wx bits regardless of umask, which
-	    # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
-	    ;;
-	  *)
-	    tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
-	    trap 'ret=$?; rmdir "$tmpdir/d" "$tmpdir" 2>/dev/null; exit $ret' 0
-
-	    if (umask $mkdir_umask &&
-		exec $mkdirprog $mkdir_mode -p -- "$tmpdir/d") >/dev/null 2>&1
-	    then
-	      if test -z "$dir_arg" || {
-		   # Check for POSIX incompatibilities with -m.
-		   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
-		   # other-writable bit of parent directory when it shouldn't.
-		   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
-		   ls_ld_tmpdir=`ls -ld "$tmpdir"`
-		   case $ls_ld_tmpdir in
-		     d????-?r-*) different_mode=700;;
-		     d????-?--*) different_mode=755;;
-		     *) false;;
-		   esac &&
-		   $mkdirprog -m$different_mode -p -- "$tmpdir" && {
-		     ls_ld_tmpdir_1=`ls -ld "$tmpdir"`
-		     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
-		   }
-		 }
-	      then posix_mkdir=:
-	      fi
-	      rmdir "$tmpdir/d" "$tmpdir"
-	    else
-	      # Remove any dirs left behind by ancient mkdir implementations.
-	      rmdir ./$mkdir_mode ./-p ./-- 2>/dev/null
-	    fi
-	    trap '' 0;;
-	esac;;
+        # Create intermediate dirs using mode 755 as modified by the umask.
+        # This is like FreeBSD 'install' as of 1997-10-28.
+        umask=`umask`
+        case $stripcmd.$umask in
+          # Optimize common cases.
+          *23672367) mkdir_umask=$umask;;
+          .*00202 | .0202 | .02) mkdir_umask=22;;
+
+          *0-7)
+            mkdir_umask=`expr $umask + 22 \
+              - $umask % 100 % 40 + $umask % 20 \
+              - $umask % 10 % 4 + $umask % 2
+            `;;
+          *) mkdir_umask=$umask,go-w;;
+        esac
+
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+
+        posix_mkdir=false
+        case $umask in
+          *1235670-70-7)
+            # POSIX mkdir -p sets u+wx bits regardless of umask, which
+            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+            ;;
+          *)
+            # Note that $RANDOM variable is not portable (e.g. dash);  Use it
+            # here however when possible just to lower collision chance.
+            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+
+            trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+            # Because "mkdir -p" follows existing symlinks and we likely work
+            # directly in world-writeable /tmp, make sure that the '$tmpdir'
+            # directory is successfully created first before we actually test
+            # 'mkdir -p' feature.
+            if (umask $mkdir_umask &&
+                $mkdirprog $mkdir_mode "$tmpdir" &&
+                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+            then
+              if test -z "$dir_arg" || {
+                   # Check for POSIX incompatibilities with -m.
+                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+                   # other-writable bit of parent directory when it shouldn't.
+                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+                   test_tmpdir="$tmpdir/a"
+                   ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+                   case $ls_ld_tmpdir in
+                     d????-?r-*) different_mode=700;;
+                     d????-?--*) different_mode=755;;
+                     *) false;;
+                   esac &&
+                   $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+                     ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+                   }
+                 }
+              then posix_mkdir=:
+              fi
+              rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+            else
+              # Remove any dirs left behind by ancient mkdir implementations.
+              rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+            fi
+            trap '' 0;;
+        esac;;
     esac
 
     if
       $posix_mkdir && (
-	umask $mkdir_umask &&
-	$doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
       )
     then :
     else
@@ -391,53 +387,51 @@
       # directory the slow way, step by step, checking for races as we go.
 
       case $dstdir in
-	/*) prefix='/';;
-	-=!*) prefix='./';;
-	*)  prefix='';;
+        /*) prefix='/';;
+        -=!*) prefix='./';;
+        *)  prefix='';;
       esac
 
-      eval "$initialize_posix_glob"
-
       oIFS=$IFS
       IFS=/
-      $posix_glob set -f
+      set -f
       set fnord $dstdir
       shift
-      $posix_glob set +f
+      set +f
       IFS=$oIFS
 
       prefixes=
 
       for d
       do
-	test X"$d" = X && continue
-
-	prefix=$prefix$d
-	if test -d "$prefix"; then
-	  prefixes=
-	else
-	  if $posix_mkdir; then
-	    (umask=$mkdir_umask &&
-	     $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
-	    # Don't fail if two instances are running concurrently.
-	    test -d "$prefix" || exit 1
-	  else
-	    case $prefix in
-	      *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
-	      *) qprefix=$prefix;;
-	    esac
-	    prefixes="$prefixes '$qprefix'"
-	  fi
-	fi
-	prefix=$prefix/
+        test X"$d" = X && continue
+
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask=$mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
       done
 
       if test -n "$prefixes"; then
-	# Don't fail if two instances are running concurrently.
-	(umask $mkdir_umask &&
-	 eval "\$doit_exec \$mkdirprog $prefixes") ||
-	  test -d "$dstdir" || exit 1
-	obsolete_mkdir_used=true
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
       fi
     fi
   fi
@@ -450,8 +444,8 @@
   else
 
     # Make a couple of temp file names in the proper directory.
-    dsttmp=$dstdir/_inst.$$_
-    rmtmp=$dstdir/_rm.$$_
+    dsttmp=${dstdirslash}_inst.$$_
+    rmtmp=${dstdirslash}_rm.$$_
 
     # Trap to clean up those temp files at exit.
     trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
@@ -472,15 +466,12 @@
 
     # If -C, don't bother to copy if it wouldn't change the file.
     if $copy_on_change &&
-       old=`LC_ALL=C ls -dlL "$dst"	2>/dev/null` &&
-       new=`LC_ALL=C ls -dlL "$dsttmp"	2>/dev/null` &&
-
-       eval "$initialize_posix_glob" &&
-       $posix_glob set -f &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
        set X $old && old=:$2:$4:$5:$6 &&
        set X $new && new=:$2:$4:$5:$6 &&
-       $posix_glob set +f &&
-
+       set +f &&
        test "$old" = "$new" &&
        $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
     then
@@ -493,24 +484,24 @@
       # to itself, or perhaps because mv is so ancient that it does not
       # support -f.
       {
-	# Now remove or move aside any old file at destination location.
-	# We try this two ways since rm can't unlink itself on some
-	# systems and the destination file might be busy for other
-	# reasons.  In this case, the final cleanup might fail but the new
-	# file should still install successfully.
-	{
-	  test ! -f "$dst" ||
-	  $doit $rmcmd -f "$dst" 2>/dev/null ||
-	  { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
-	    { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
-	  } ||
-	  { echo "$0: cannot unlink or rename $dst" >&2
-	    (exit 1); exit 1
-	  }
-	} &&
-
-	# Now rename the file to the real destination.
-	$doit $mvcmd "$dsttmp" "$dst"
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd -f "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
+
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
       }
     fi || exit 1
 
@@ -519,9 +510,9 @@
 done
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:

_service:tar_scm:isl-0.14.tar.xz/interface/Makefile.am -> _service:tar_scm:isl-0.24.tar.gz/interface/Makefile.am Changed

@@ -1,32 +1,28 @@
+ACLOCAL_AMFLAGS = -I ../m4
 AUTOMAKE_OPTIONS = nostdinc
 
 noinst_PROGRAMS = extract_interface
 
-AM_CXXFLAGS = $(CLANG_CXXFLAGS)
-AM_LDFLAGS = $(CLANG_LDFLAGS)
-
 includes = -I$(top_builddir) -I$(top_srcdir) \
 	-I$(top_builddir)/include -I$(top_srcdir)/include
 
 extract_interface_CPPFLAGS = $(includes)
+extract_interface_CXXFLAGS = $(CLANG_CXXFLAGS)
 extract_interface_SOURCES = \
+	generator.h \
+	generator.cc \
 	python.h \
 	python.cc \
+	cpp.h \
+	cpp.cc \
+	cpp_conversion.h \
+	cpp_conversion.cc \
+	plain_cpp.h \
+	plain_cpp.cc \
+	set_lang_defaults_arg4.h \
+	template_cpp.h \
+	template_cpp.cc \
 	extract_interface.h \
 	extract_interface.cc
-extract_interface_LDADD = \
-	-lclangFrontend -lclangSerialization -lclangParse -lclangSema \
-	$(LIB_CLANG_EDIT) \
-	-lclangAnalysis -lclangAST -lclangLex -lclangBasic -lclangDriver \
-	$(CLANG_LIBS) $(CLANG_LDFLAGS)
-
-test: extract_interface
-	./extract_interface$(EXEEXT) $(includes) $(srcdir)/all.h
-
-isl.py: extract_interface isl.py.top
-	(cat $(srcdir)/isl.py.top; \
-		./extract_interface$(EXEEXT) $(includes) $(srcdir)/all.h) \
-			> isl.py
-
-dist-hook: isl.py
-	cp isl.py $(distdir)/
+extract_interface_LDFLAGS = $(CLANG_LDFLAGS) $(CLANG_RFLAG)
+extract_interface_LDADD = $(CLANG_LIBS) $(CLANG_LDFLAGS)

_service:tar_scm:isl-0.14.tar.xz/interface/Makefile.in -> _service:tar_scm:isl-0.24.tar.gz/interface/Makefile.in Changed

_service:tar_scm:isl-0.24.tar.gz/interface/aclocal.m4 Added

@@ -0,0 +1,1146 @@
+# generated automatically by aclocal 1.16.1 -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+m4_ifndef(AC_CONFIG_MACRO_DIRS, m4_defun(_AM_CONFIG_MACRO_DIRS, )m4_defun(AC_CONFIG_MACRO_DIRS, _AM_CONFIG_MACRO_DIRS($@)))
+m4_ifndef(AC_AUTOCONF_VERSION,
+  m4_copy(m4_PACKAGE_VERSION, AC_AUTOCONF_VERSION))dnl
+m4_if(m4_defn(AC_AUTOCONF_VERSION), 2.69,,
+m4_warning(this file was generated for autoconf 2.69.
+You have another version of autoconf.  It may work, but is not guaranteed to.
+If you have problems, you may need to regenerate the build system entirely.
+To do so, use the procedure documented by the package, typically 'autoreconf'.))
+
+# Copyright (C) 2002-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_AUTOMAKE_VERSION(VERSION)
+# ----------------------------
+# Automake X.Y traces this macro to ensure aclocal.m4 has been
+# generated from the m4 files accompanying Automake X.Y.
+# (This private macro should not be called outside this file.)
+AC_DEFUN(AM_AUTOMAKE_VERSION,
+am__api_version='1.16'
+dnl Some users find AM_AUTOMAKE_VERSION and mistake it for a way to
+dnl require some minimum version.  Point them to the right macro.
+m4_if($1, 1.16.1, ,
+      AC_FATAL(Do not call $0, use AM_INIT_AUTOMAKE($1).))dnl
+)
+
+# _AM_AUTOCONF_VERSION(VERSION)
+# -----------------------------
+# aclocal traces this macro to find the Autoconf version.
+# This is a private macro too.  Using m4_define simplifies
+# the logic in aclocal, which can simply ignore this definition.
+m4_define(_AM_AUTOCONF_VERSION, )
+
+# AM_SET_CURRENT_AUTOMAKE_VERSION
+# -------------------------------
+# Call AM_AUTOMAKE_VERSION and AM_AUTOMAKE_VERSION so they can be traced.
+# This function is AC_REQUIREd by AM_INIT_AUTOMAKE.
+AC_DEFUN(AM_SET_CURRENT_AUTOMAKE_VERSION,
+AM_AUTOMAKE_VERSION(1.16.1)dnl
+m4_ifndef(AC_AUTOCONF_VERSION,
+  m4_copy(m4_PACKAGE_VERSION, AC_AUTOCONF_VERSION))dnl
+_AM_AUTOCONF_VERSION(m4_defn(AC_AUTOCONF_VERSION)))
+
+# AM_AUX_DIR_EXPAND                                         -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# For projects using AC_CONFIG_AUX_DIR(foo), Autoconf sets
+# $ac_aux_dir to '$srcdir/foo'.  In other projects, it is set to
+# '$srcdir', '$srcdir/..', or '$srcdir/../..'.
+#
+# Of course, Automake must honor this variable whenever it calls a
+# tool from the auxiliary directory.  The problem is that $srcdir (and
+# therefore $ac_aux_dir as well) can be either absolute or relative,
+# depending on how configure is run.  This is pretty annoying, since
+# it makes $ac_aux_dir quite unusable in subdirectories: in the top
+# source directory, any form will work fine, but in subdirectories a
+# relative path needs to be adjusted first.
+#
+# $ac_aux_dir/missing
+#    fails when called from a subdirectory if $ac_aux_dir is relative
+# $top_srcdir/$ac_aux_dir/missing
+#    fails if $ac_aux_dir is absolute,
+#    fails when called from a subdirectory in a VPATH build with
+#          a relative $ac_aux_dir
+#
+# The reason of the latter failure is that $top_srcdir and $ac_aux_dir
+# are both prefixed by $srcdir.  In an in-source build this is usually
+# harmless because $srcdir is '.', but things will broke when you
+# start a VPATH build or use an absolute $srcdir.
+#
+# So we could use something similar to $top_srcdir/$ac_aux_dir/missing,
+# iff we strip the leading $srcdir from $ac_aux_dir.  That would be:
+#   am_aux_dir='\$(top_srcdir)/'`expr "$ac_aux_dir" : "$srcdir//*$.*$"`
+# and then we would define $MISSING as
+#   MISSING="\${SHELL} $am_aux_dir/missing"
+# This will work as long as MISSING is not called from configure, because
+# unfortunately $(top_srcdir) has no meaning in configure.
+# However there are other variables, like CC, which are often used in
+# configure, and could therefore not use this "fixed" $ac_aux_dir.
+#
+# Another solution, used here, is to always expand $ac_aux_dir to an
+# absolute PATH.  The drawback is that using absolute paths prevent a
+# configured tree to be moved without reconfiguration.
+
+AC_DEFUN(AM_AUX_DIR_EXPAND,
+AC_REQUIRE(AC_CONFIG_AUX_DIR_DEFAULT)dnl
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+)
+
+# AM_CONDITIONAL                                            -*- Autoconf -*-
+
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_CONDITIONAL(NAME, SHELL-CONDITION)
+# -------------------------------------
+# Define a conditional.
+AC_DEFUN(AM_CONDITIONAL,
+AC_PREREQ(2.52)dnl
+ m4_if($1, TRUE,  AC_FATAL($0: invalid condition: $1),
+       $1, FALSE, AC_FATAL($0: invalid condition: $1))dnl
+AC_SUBST($1_TRUE)dnl
+AC_SUBST($1_FALSE)dnl
+_AM_SUBST_NOTMAKE($1_TRUE)dnl
+_AM_SUBST_NOTMAKE($1_FALSE)dnl
+m4_define(_AM_COND_VALUE_$1, $2)dnl
+if $2; then
+  $1_TRUE=
+  $1_FALSE='#'
+else
+  $1_TRUE='#'
+  $1_FALSE=
+fi
+AC_CONFIG_COMMANDS_PRE(
+if test -z "${$1_TRUE}" && test -z "${$1_FALSE}"; then
+  AC_MSG_ERROR(conditional "$1" was never defined.
+Usually this means the macro was only invoked conditionally.)
+fi))
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+
+# There are a few dirty hacks below to avoid letting 'AC_PROG_CC' be
+# written in clear, in which case automake, when reading aclocal.m4,
+# will think it sees a *use*, and therefore will trigger all it's
+# C support machinery.  Also note that it means that autoscan, seeing
+# CC etc. in the Makefile, will ask for an AC_PROG_CC use...
+
+
+# _AM_DEPENDENCIES(NAME)
+# ----------------------
+# See how the compiler implements dependency checking.
+# NAME is "CC", "CXX", "OBJC", "OBJCXX", "UPC", or "GJC".
+# We try a few techniques and use that to set a single cache variable.
+#
+# We don't AC_REQUIRE the corresponding AC_PROG_CC since the latter was
+# modified to invoke _AM_DEPENDENCIES(CC); we would have a circular
+# dependency, and given that the user is not expected to run this macro,
+# just rely on AC_PROG_CC.
+AC_DEFUN(_AM_DEPENDENCIES,
+AC_REQUIRE(AM_SET_DEPDIR)dnl
+AC_REQUIRE(AM_OUTPUT_DEPENDENCY_COMMANDS)dnl
+AC_REQUIRE(AM_MAKE_INCLUDE)dnl
+AC_REQUIRE(AM_DEP_TRACK)dnl
+
+m4_if($1, CC,   depcc="$CC"   am_compiler_list=,
+      $1, CXX,  depcc="$CXX"  am_compiler_list=,
+      $1, OBJC, depcc="$OBJC" am_compiler_list='gcc3 gcc',
+      $1, OBJCXX, depcc="$OBJCXX" am_compiler_list='gcc3 gcc',
+      $1, UPC,  depcc="$UPC"  am_compiler_list=,
+      $1, GCJ,  depcc="$GCJ"  am_compiler_list='gcc3 gcc',
+                    depcc="$$1"   am_compiler_list=)
+
+AC_CACHE_CHECK(dependency style of $depcc,
+               am_cv_$1_dependencies_compiler_type,
+if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_$1_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  m4_case($1, CC,
+    case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac,
+    CXX,
+    case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac)
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_$1_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_$1_dependencies_compiler_type=none
+fi
+)
+AC_SUBST($1DEPMODE, depmode=$am_cv_$1_dependencies_compiler_type)
+AM_CONDITIONAL(am__fastdep$1, 
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_$1_dependencies_compiler_type" = gcc3)
+)
+
+
+# AM_SET_DEPDIR
+# -------------
+# Choose a directory name for dependency files.
+# This macro is AC_REQUIREd in _AM_DEPENDENCIES.
+AC_DEFUN(AM_SET_DEPDIR,
+AC_REQUIRE(AM_SET_LEADING_DOT)dnl
+AC_SUBST(DEPDIR, "${am__leading_dot}deps")dnl
+)
+
+
+# AM_DEP_TRACK
+# ------------
+AC_DEFUN(AM_DEP_TRACK,
+AC_ARG_ENABLE(dependency-tracking, dnl
+AS_HELP_STRING(
+  --enable-dependency-tracking,
+  do not reject slow dependency extractors)
+AS_HELP_STRING(
+  --disable-dependency-tracking,
+  speeds up one-time build))
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+AM_CONDITIONAL(AMDEP, test "x$enable_dependency_tracking" != xno)
+AC_SUBST(AMDEPBACKSLASH)dnl
+_AM_SUBST_NOTMAKE(AMDEPBACKSLASH)dnl
+AC_SUBST(am__nodep)dnl
+_AM_SUBST_NOTMAKE(am__nodep)dnl
+)
+
+# Generate code to set up dependency tracking.              -*- Autoconf -*-
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_OUTPUT_DEPENDENCY_COMMANDS
+# ------------------------------
+AC_DEFUN(_AM_OUTPUT_DEPENDENCY_COMMANDS,
+{
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  AS_CASE($CONFIG_FILES,
+          *\'*, eval set x "$CONFIG_FILES",
+          *, set x $CONFIG_FILES)
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`AS_ECHO("$am_mf") | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`AS_DIRNAME("$am_mf")`
+    am_filepart=`AS_BASENAME("$am_mf")`
+    AM_RUN_LOG(cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    AC_MSG_FAILURE(Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).)
+  fi
+  AS_UNSET(am_dirpart)
+  AS_UNSET(am_filepart)
+  AS_UNSET(am_mf)
+  AS_UNSET(am_rc)
+  rm -f conftest-deps.mk
+}
+)# _AM_OUTPUT_DEPENDENCY_COMMANDS
+
+
+# AM_OUTPUT_DEPENDENCY_COMMANDS
+# -----------------------------
+# This macro should only be invoked once -- use via AC_REQUIRE.
+#
+# This code is only required when automatic dependency tracking is enabled.
+# This creates each '.Po' and '.Plo' makefile fragment that we'll need in
+# order to bootstrap the dependency handling code.
+AC_DEFUN(AM_OUTPUT_DEPENDENCY_COMMANDS,
+AC_CONFIG_COMMANDS(depfiles,
+     test x"$AMDEP_TRUE" != x"" || _AM_OUTPUT_DEPENDENCY_COMMANDS,
+     AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"))
+
+# Do all the work for Automake.                             -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This macro actually does too much.  Some checks are only needed if
+# your package does certain things.  But this isn't really a big deal.
+
+dnl Redefine AC_PROG_CC to automatically invoke _AM_PROG_CC_C_O.
+m4_define(AC_PROG_CC,
+m4_defn(AC_PROG_CC)
+_AM_PROG_CC_C_O
+)
+
+# AM_INIT_AUTOMAKE(PACKAGE, VERSION, NO-DEFINE)
+# AM_INIT_AUTOMAKE(OPTIONS)
+# -----------------------------------------------
+# The call with PACKAGE and VERSION arguments is the old style
+# call (pre autoconf-2.50), which is being phased out.  PACKAGE
+# and VERSION should now be passed to AC_INIT and removed from
+# the call to AM_INIT_AUTOMAKE.
+# We support both call styles for the transition.  After
+# the next Automake release, Autoconf can make the AC_INIT
+# arguments mandatory, and then we can depend on a new Autoconf
+# release and drop the old call support.
+AC_DEFUN(AM_INIT_AUTOMAKE,
+AC_PREREQ(2.65)dnl
+dnl Autoconf wants to disallow AM_ names.  We explicitly allow
+dnl the ones we care about.
+m4_pattern_allow(^AM_A-Z+FLAGS$)dnl
+AC_REQUIRE(AM_SET_CURRENT_AUTOMAKE_VERSION)dnl
+AC_REQUIRE(AC_PROG_INSTALL)dnl
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  AC_SUBST(am__isrc, ' -I$(srcdir)')_AM_SUBST_NOTMAKE(am__isrc)dnl
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    AC_MSG_ERROR(source directory already configured; run "make distclean" there first)
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+AC_SUBST(CYGPATH_W)
+
+# Define the identity of the package.
+dnl Distinguish between old-style and new-style calls.
+m4_ifval($2,
+AC_DIAGNOSE(obsolete,
+             $0: two- and three-arguments forms are deprecated.)
+m4_ifval($3, _AM_SET_OPTION(no-define))dnl
+ AC_SUBST(PACKAGE, $1)dnl
+ AC_SUBST(VERSION, $2),
+_AM_SET_OPTIONS($1)dnl
+dnl Diagnose old-style AC_INIT with new-style AM_AUTOMAKE_INIT.
+m4_if(
+  m4_ifdef(AC_PACKAGE_NAME, ok):m4_ifdef(AC_PACKAGE_VERSION, ok),
+  ok:ok,,
+  m4_fatal(AC_INIT should be called with package and version arguments))dnl
+ AC_SUBST(PACKAGE, 'AC_PACKAGE_TARNAME')dnl
+ AC_SUBST(VERSION, 'AC_PACKAGE_VERSION'))dnl
+
+_AM_IF_OPTION(no-define,,
+AC_DEFINE_UNQUOTED(PACKAGE, "$PACKAGE", Name of package)
+ AC_DEFINE_UNQUOTED(VERSION, "$VERSION", Version number of package))dnl
+
+# Some tools Automake needs.
+AC_REQUIRE(AM_SANITY_CHECK)dnl
+AC_REQUIRE(AC_ARG_PROGRAM)dnl
+AM_MISSING_PROG(ACLOCAL, aclocal-${am__api_version})
+AM_MISSING_PROG(AUTOCONF, autoconf)
+AM_MISSING_PROG(AUTOMAKE, automake-${am__api_version})
+AM_MISSING_PROG(AUTOHEADER, autoheader)
+AM_MISSING_PROG(MAKEINFO, makeinfo)
+AC_REQUIRE(AM_PROG_INSTALL_SH)dnl
+AC_REQUIRE(AM_PROG_INSTALL_STRIP)dnl
+AC_REQUIRE(AC_PROG_MKDIR_P)dnl
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+AC_SUBST(mkdir_p, '$(MKDIR_P)')
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+AC_REQUIRE(AC_PROG_AWK)dnl
+AC_REQUIRE(AC_PROG_MAKE_SET)dnl
+AC_REQUIRE(AM_SET_LEADING_DOT)dnl
+_AM_IF_OPTION(tar-ustar, _AM_PROG_TAR(ustar),
+	      _AM_IF_OPTION(tar-pax, _AM_PROG_TAR(pax),
+			     _AM_PROG_TAR(v7)))
+_AM_IF_OPTION(no-dependencies,,
+AC_PROVIDE_IFELSE(AC_PROG_CC,
+		  _AM_DEPENDENCIES(CC),
+		  m4_define(AC_PROG_CC,
+			     m4_defn(AC_PROG_CC)_AM_DEPENDENCIES(CC)))dnl
+AC_PROVIDE_IFELSE(AC_PROG_CXX,
+		  _AM_DEPENDENCIES(CXX),
+		  m4_define(AC_PROG_CXX,
+			     m4_defn(AC_PROG_CXX)_AM_DEPENDENCIES(CXX)))dnl
+AC_PROVIDE_IFELSE(AC_PROG_OBJC,
+		  _AM_DEPENDENCIES(OBJC),
+		  m4_define(AC_PROG_OBJC,
+			     m4_defn(AC_PROG_OBJC)_AM_DEPENDENCIES(OBJC)))dnl
+AC_PROVIDE_IFELSE(AC_PROG_OBJCXX,
+		  _AM_DEPENDENCIES(OBJCXX),
+		  m4_define(AC_PROG_OBJCXX,
+			     m4_defn(AC_PROG_OBJCXX)_AM_DEPENDENCIES(OBJCXX)))dnl
+)
+AC_REQUIRE(AM_SILENT_RULES)dnl
+dnl The testsuite driver may need to know about EXEEXT, so add the
+dnl 'am__EXEEXT' conditional if _AM_COMPILER_EXEEXT was seen.  This
+dnl macro is hooked onto _AC_COMPILER_EXEEXT early, see below.
+AC_CONFIG_COMMANDS_PRE(dnl
+m4_provide_if(_AM_COMPILER_EXEEXT,
+  AM_CONDITIONAL(am__EXEEXT, test -n "$EXEEXT")))dnl
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    AC_MSG_ERROR(Your 'rm' program is bad, sorry.)
+  fi
+fi
+dnl The trailing newline in this macro's definition is deliberate, for
+dnl backward compatibility and to allow trailing 'dnl'-style comments
+dnl after the AM_INIT_AUTOMAKE invocation. See automake bug#16841.
+)
+
+dnl Hook into '_AC_COMPILER_EXEEXT' early to learn its expansion.  Do not
+dnl add the conditional right here, as _AC_COMPILER_EXEEXT may be further
+dnl mangled by Autoconf and run in a shell conditional statement.
+m4_define(_AC_COMPILER_EXEEXT,
+m4_defn(_AC_COMPILER_EXEEXT)m4_provide(_AM_COMPILER_EXEEXT))
+
+# When config.status generates a header, we must update the stamp-h file.
+# This file resides in the same directory as the config header
+# that is generated.  The stamp files are numbered to have different names.
+
+# Autoconf calls _AC_AM_CONFIG_HEADER_HOOK (when defined) in the
+# loop where config.status creates the headers, so we can generate
+# our stamp files there.
+AC_DEFUN(_AC_AM_CONFIG_HEADER_HOOK,
+# Compute $1's index in $config_headers.
+_am_arg=$1
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`AS_DIRNAME("$_am_arg")`/stamp-h$_am_stamp_count)
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_SH
+# ------------------
+# Define $install_sh.
+AC_DEFUN(AM_PROG_INSTALL_SH,
+AC_REQUIRE(AM_AUX_DIR_EXPAND)dnl
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+AC_SUBST(install_sh))
+
+# Copyright (C) 2003-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# Check whether the underlying file-system supports filenames
+# with a leading dot.  For instance MS-DOS doesn't.
+AC_DEFUN(AM_SET_LEADING_DOT,
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+AC_SUBST(am__leading_dot))
+
+# Check to see how 'make' treats includes.	            -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MAKE_INCLUDE()
+# -----------------
+# Check whether make has an 'include' directive that can support all
+# the idioms we need for our automatic dependency tracking code.
+AC_DEFUN(AM_MAKE_INCLUDE,
+AC_MSG_CHECKING(whether ${MAKE-make} supports the include directive)
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  AM_RUN_LOG(${MAKE-make} -f confmf.$s && cat confinc.out)
+  AS_CASE($?:`cat confinc.out 2>/dev/null`,
+      '0:this is the am__doit target',
+      AS_CASE($s,
+          BSD, am__include='.include' am__quote='"',
+          am__include='include' am__quote=''))
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+AC_MSG_RESULT(${_am_result})
+AC_SUBST(am__include))
+AC_SUBST(am__quote))
+
+# Fake the existence of programs that GNU maintainers use.  -*- Autoconf -*-
+
+# Copyright (C) 1997-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_MISSING_PROG(NAME, PROGRAM)
+# ------------------------------
+AC_DEFUN(AM_MISSING_PROG,
+AC_REQUIRE(AM_MISSING_HAS_RUN)
+$1=${$1-"${am_missing_run}$2"}
+AC_SUBST($1))
+
+# AM_MISSING_HAS_RUN
+# ------------------
+# Define MISSING if not defined so far and test if it is modern enough.
+# If it is, set am_missing_run to use it, otherwise, to nothing.
+AC_DEFUN(AM_MISSING_HAS_RUN,
+AC_REQUIRE(AM_AUX_DIR_EXPAND)dnl
+AC_REQUIRE_AUX_FILE(missing)dnl
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  AC_MSG_WARN('missing' script is too old or missing)
+fi
+)
+
+# Helper functions for option handling.                     -*- Autoconf -*-
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_MANGLE_OPTION(NAME)
+# -----------------------
+AC_DEFUN(_AM_MANGLE_OPTION,
+_AM_OPTION_m4_bpatsubst($1, ^a-zA-Z0-9_, _))
+
+# _AM_SET_OPTION(NAME)
+# --------------------
+# Set option NAME.  Presently that only means defining a flag for this option.
+AC_DEFUN(_AM_SET_OPTION,
+m4_define(_AM_MANGLE_OPTION($1), 1))
+
+# _AM_SET_OPTIONS(OPTIONS)
+# ------------------------
+# OPTIONS is a space-separated list of Automake options.
+AC_DEFUN(_AM_SET_OPTIONS,
+m4_foreach_w(_AM_Option, $1, _AM_SET_OPTION(_AM_Option)))
+
+# _AM_IF_OPTION(OPTION, IF-SET, IF-NOT-SET)
+# -------------------------------------------
+# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
+AC_DEFUN(_AM_IF_OPTION,
+m4_ifset(_AM_MANGLE_OPTION($1), $2, $3))
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_CC_C_O
+# ---------------
+# Like AC_PROG_CC_C_O, but changed for automake.  We rewrite AC_PROG_CC
+# to automatically call this.
+AC_DEFUN(_AM_PROG_CC_C_O,
+AC_REQUIRE(AM_AUX_DIR_EXPAND)dnl
+AC_REQUIRE_AUX_FILE(compile)dnl
+AC_LANG_PUSH(C)dnl
+AC_CACHE_CHECK(
+  whether $CC understands -c and -o together,
+  am_cv_prog_cc_c_o,
+  AC_LANG_CONFTEST(AC_LANG_PROGRAM())
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if AM_RUN_LOG($CC -c conftest.$ac_ext -o conftest2.$ac_objext) \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i)
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+AC_LANG_POP(C))
+
+# For backward compatibility.
+AC_DEFUN_ONCE(AM_PROG_CC_C_O, AC_REQUIRE(AC_PROG_CC))
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_RUN_LOG(COMMAND)
+# -------------------
+# Run COMMAND, save the exit status in ac_status, and log it.
+# (This has been adapted from Autoconf's _AC_RUN_LOG macro.)
+AC_DEFUN(AM_RUN_LOG,
+{ echo "$as_me:$LINENO: $1" >&AS_MESSAGE_LOG_FD
+   ($1) >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
+   (exit $ac_status); })
+
+# Check to make sure that the build environment is sane.    -*- Autoconf -*-
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SANITY_CHECK
+# ---------------
+AC_DEFUN(AM_SANITY_CHECK,
+AC_MSG_CHECKING(whether build environment is sane)
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *\\\"\#\$\&\'\`$am_lf*)
+    AC_MSG_ERROR(unsafe absolute working directory name);;
+esac
+case $srcdir in
+  *\\\"\#\$\&\'\`$am_lf\ \	*)
+    AC_MSG_ERROR(unsafe srcdir value: '$srcdir');;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$*" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$*" != "X $srcdir/configure conftest.file" \
+	&& test "$*" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	AC_MSG_ERROR(ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment)
+     fi
+     if test "$2" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   AC_MSG_ERROR(newly created file is older than distributed files!
+Check your system clock)
+fi
+AC_MSG_RESULT(yes)
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+AC_CONFIG_COMMANDS_PRE(
+  AC_MSG_CHECKING(that generated files are newer than configure)
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   AC_MSG_RESULT(done))
+rm -f conftest.file
+)
+
+# Copyright (C) 2009-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_SILENT_RULES(DEFAULT)
+# --------------------------
+# Enable less verbose build rules; with the default set to DEFAULT
+# ("yes" being less verbose, "no" or empty being verbose).
+AC_DEFUN(AM_SILENT_RULES,
+AC_ARG_ENABLE(silent-rules, dnl
+AS_HELP_STRING(
+  --enable-silent-rules,
+  less verbose build output (undo: "make V=1"))
+AS_HELP_STRING(
+  --disable-silent-rules,
+  verbose build output (undo: "make V=0"))dnl
+)
+case $enable_silent_rules in @%:@ (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=m4_if($1, yes, 0, 1);;
+esac
+dnl
+dnl A few 'make' implementations (e.g., NonStop OS and NextStep)
+dnl do not support nested variable expansions.
+dnl See automake bug#9928 and bug#10237.
+am_make=${MAKE-make}
+AC_CACHE_CHECK(whether $am_make supports nested variables,
+   am_cv_make_support_nested_variables,
+   if AS_ECHO('TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit') | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi)
+if test $am_cv_make_support_nested_variables = yes; then
+  dnl Using '$V' instead of '$(V)' breaks IRIX make.
+  AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AC_SUBST(AM_V)dnl
+AM_SUBST_NOTMAKE(AM_V)dnl
+AC_SUBST(AM_DEFAULT_V)dnl
+AM_SUBST_NOTMAKE(AM_DEFAULT_V)dnl
+AC_SUBST(AM_DEFAULT_VERBOSITY)dnl
+AM_BACKSLASH='\'
+AC_SUBST(AM_BACKSLASH)dnl
+_AM_SUBST_NOTMAKE(AM_BACKSLASH)dnl
+)
+
+# Copyright (C) 2001-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# AM_PROG_INSTALL_STRIP
+# ---------------------
+# One issue with vendor 'install' (even GNU) is that you can't
+# specify the program used to strip binaries.  This is especially
+# annoying in cross-compiling environments, where the build's strip
+# is unlikely to handle the host's binaries.
+# Fortunately install-sh will honor a STRIPPROG variable, so we
+# always use install-sh in "make install-strip", and initialize
+# STRIPPROG with the value of the STRIP variable (set by the user).
+AC_DEFUN(AM_PROG_INSTALL_STRIP,
+AC_REQUIRE(AM_PROG_INSTALL_SH)dnl
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+dnl Don't test for $cross_compiling = yes, because it might be 'maybe'.
+if test "$cross_compiling" != no; then
+  AC_CHECK_TOOL(STRIP, strip, :)
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+AC_SUBST(INSTALL_STRIP_PROGRAM))
+
+# Copyright (C) 2006-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_SUBST_NOTMAKE(VARIABLE)
+# ---------------------------
+# Prevent Automake from outputting VARIABLE = @VARIABLE@ in Makefile.in.
+# This macro is traced by Automake.
+AC_DEFUN(_AM_SUBST_NOTMAKE)
+
+# AM_SUBST_NOTMAKE(VARIABLE)
+# --------------------------
+# Public sister of _AM_SUBST_NOTMAKE.
+AC_DEFUN(AM_SUBST_NOTMAKE, _AM_SUBST_NOTMAKE($@))
+
+# Check how to create a tarball.                            -*- Autoconf -*-
+
+# Copyright (C) 2004-2018 Free Software Foundation, Inc.
+#
+# This file is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# _AM_PROG_TAR(FORMAT)
+# --------------------
+# Check how to create a tarball in format FORMAT.
+# FORMAT should be one of 'v7', 'ustar', or 'pax'.
+#
+# Substitute a variable $(am__tar) that is a command
+# writing to stdout a FORMAT-tarball containing the directory
+# $tardir.
+#     tardir=directory && $(am__tar) > result.tar
+#
+# Substitute a variable $(am__untar) that extract such
+# a tarball read from stdin.
+#     $(am__untar) < result.tar
+#
+AC_DEFUN(_AM_PROG_TAR,
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AC_SUBST(AMTAR, '$${TAR-tar}')
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar m4_if($1, ustar, plaintar) pax cpio none'
+
+m4_if($1, v7,
+  am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -',
+
+  m4_case($1,
+    ustar,
+     # The POSIX 1988 'ustar' format is defined with fixed-size fields.
+      # There is notably a 21 bits limit for the UID and the GID.  In fact,
+      # the 'pax' utility can hang on bigger UID/GID (see automake bug#8343
+      # and bug#13588).
+      am_max_uid=2097151 # 2^21 - 1
+      am_max_gid=$am_max_uid
+      # The $UID and $GID variables are not portable, so we need to resort
+      # to the POSIX-mandated id(1) utility.  Errors in the 'id' calls
+      # below are definitely unexpected, so allow the users to see them
+      # (that is, avoid stderr redirection).
+      am_uid=`id -u || echo unknown`
+      am_gid=`id -g || echo unknown`
+      AC_MSG_CHECKING(whether UID '$am_uid' is supported by ustar format)
+      if test $am_uid -le $am_max_uid; then
+         AC_MSG_RESULT(yes)
+      else
+         AC_MSG_RESULT(no)
+         _am_tools=none
+      fi
+      AC_MSG_CHECKING(whether GID '$am_gid' is supported by ustar format)
+      if test $am_gid -le $am_max_gid; then
+         AC_MSG_RESULT(yes)
+      else
+        AC_MSG_RESULT(no)
+        _am_tools=none
+      fi,
+
+  pax,
+    ,
+
+  m4_fatal(Unknown tar format))
+
+  AC_MSG_CHECKING(how to create a $1 tar archive)
+
+  # Go ahead even if we have the value already cached.  We do so because we
+  # need to set the values for the 'am__tar' and 'am__untar' variables.
+  _am_tools=${am_cv_prog_tar_$1-$_am_tools}
+
+  for _am_tool in $_am_tools; do
+    case $_am_tool in
+    gnutar)
+      for _am_tar in tar gnutar gtar; do
+        AM_RUN_LOG($_am_tar --version) && break
+      done
+      am__tar="$_am_tar --format=m4_if($1, pax, posix, $1) -chf - "'"$$tardir"'
+      am__tar_="$_am_tar --format=m4_if($1, pax, posix, $1) -chf - "'"$tardir"'
+      am__untar="$_am_tar -xf -"
+      ;;
+    plaintar)
+      # Must skip GNU tar: if it does not support --format= it doesn't create
+      # ustar tarball either.
+      (tar --version) >/dev/null 2>&1 && continue
+      am__tar='tar chf - "$$tardir"'
+      am__tar_='tar chf - "$tardir"'
+      am__untar='tar xf -'
+      ;;
+    pax)
+      am__tar='pax -L -x $1 -w "$$tardir"'
+      am__tar_='pax -L -x $1 -w "$tardir"'
+      am__untar='pax -r'
+      ;;
+    cpio)
+      am__tar='find "$$tardir" -print | cpio -o -H $1 -L'
+      am__tar_='find "$tardir" -print | cpio -o -H $1 -L'
+      am__untar='cpio -i -H $1 -d'
+      ;;
+    none)
+      am__tar=false
+      am__tar_=false
+      am__untar=false
+      ;;
+    esac
+
+    # If the value was cached, stop now.  We just wanted to have am__tar
+    # and am__untar set.
+    test -n "${am_cv_prog_tar_$1}" && break
+
+    # tar/untar a dummy directory, and stop if the command works.
+    rm -rf conftest.dir
+    mkdir conftest.dir
+    echo GrepMe > conftest.dir/file
+    AM_RUN_LOG(tardir=conftest.dir && eval $am__tar_ >conftest.tar)
+    rm -rf conftest.dir
+    if test -s conftest.tar; then
+      AM_RUN_LOG($am__untar <conftest.tar)
+      AM_RUN_LOG(cat conftest.dir/file)
+      grep GrepMe conftest.dir/file >/dev/null 2>&1 && break
+    fi
+  done
+  rm -rf conftest.dir
+
+  AC_CACHE_VAL(am_cv_prog_tar_$1, am_cv_prog_tar_$1=$_am_tool)
+  AC_MSG_RESULT($am_cv_prog_tar_$1))
+
+AC_SUBST(am__tar)
+AC_SUBST(am__untar)
+) # _AM_PROG_TAR
+
+m4_include(../m4/ax_cxx_compile_stdcxx.m4)
+m4_include(../m4/ax_cxx_compile_stdcxx_11.m4)
+m4_include(../m4/ax_cxx_compile_stdcxx_11_no_override.m4)
+m4_include(../m4/ax_detect_clang.m4)
+m4_include(../m4/ax_prog_cc_for_build.m4)
+m4_include(../m4/ax_prog_cxx_for_build.m4)
+m4_include(../m4/libtool.m4)
+m4_include(../m4/ltoptions.m4)
+m4_include(../m4/ltsugar.m4)
+m4_include(../m4/ltversion.m4)
+m4_include(../m4/lt~obsolete.m4)

_service:tar_scm:isl-0.24.tar.gz/interface/compile Added

@@ -0,0 +1,348 @@
+#! /bin/sh
+# Wrapper for compilers which do not understand '-c -o'.
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+# Written by Tom Tromey <tromey@cygnus.com>.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+nl='
+'
+
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent tools from complaining about whitespace usage.
+IFS=" ""	$nl"
+
+file_conv=
+
+# func_file_conv build_file lazy
+# Convert a $build file to $host form and store it in $file
+# Currently only supports Windows hosts. If the determined conversion
+# type is listed in (the comma separated) LAZY, no conversion will
+# take place.
+func_file_conv ()
+{
+  file=$1
+  case $file in
+    / | /!/*) # absolute file, and not a UNC file
+      if test -z "$file_conv"; then
+	# lazily determine how to convert abs files
+	case `uname -s` in
+	  MINGW*)
+	    file_conv=mingw
+	    ;;
+	  CYGWIN*)
+	    file_conv=cygwin
+	    ;;
+	  *)
+	    file_conv=wine
+	    ;;
+	esac
+      fi
+      case $file_conv/,$2, in
+	*,$file_conv,*)
+	  ;;
+	mingw/*)
+	  file=`cmd //C echo "$file " | sed -e 's/"$.*$ " *$/\1/'`
+	  ;;
+	cygwin/*)
+	  file=`cygpath -m "$file" || echo "$file"`
+	  ;;
+	wine/*)
+	  file=`winepath -w "$file" || echo "$file"`
+	  ;;
+      esac
+      ;;
+  esac
+}
+
+# func_cl_dashL linkdir
+# Make cl look for libraries in LINKDIR
+func_cl_dashL ()
+{
+  func_file_conv "$1"
+  if test -z "$lib_path"; then
+    lib_path=$file
+  else
+    lib_path="$lib_path;$file"
+  fi
+  linker_opts="$linker_opts -LIBPATH:$file"
+}
+
+# func_cl_dashl library
+# Do a library search-path lookup for cl
+func_cl_dashl ()
+{
+  lib=$1
+  found=no
+  save_IFS=$IFS
+  IFS=';'
+  for dir in $lib_path $LIB
+  do
+    IFS=$save_IFS
+    if $shared && test -f "$dir/$lib.dll.lib"; then
+      found=yes
+      lib=$dir/$lib.dll.lib
+      break
+    fi
+    if test -f "$dir/$lib.lib"; then
+      found=yes
+      lib=$dir/$lib.lib
+      break
+    fi
+    if test -f "$dir/lib$lib.a"; then
+      found=yes
+      lib=$dir/lib$lib.a
+      break
+    fi
+  done
+  IFS=$save_IFS
+
+  if test "$found" != yes; then
+    lib=$lib.lib
+  fi
+}
+
+# func_cl_wrapper cl arg...
+# Adjust compile command to suit cl
+func_cl_wrapper ()
+{
+  # Assume a capable shell
+  lib_path=
+  shared=:
+  linker_opts=
+  for arg
+  do
+    if test -n "$eat"; then
+      eat=
+    else
+      case $1 in
+	-o)
+	  # configure might choose to run compile as 'compile cc -o foo foo.c'.
+	  eat=1
+	  case $2 in
+	    *.o | *.oObBjJ)
+	      func_file_conv "$2"
+	      set x "$@" -Fo"$file"
+	      shift
+	      ;;
+	    *)
+	      func_file_conv "$2"
+	      set x "$@" -Fe"$file"
+	      shift
+	      ;;
+	  esac
+	  ;;
+	-I)
+	  eat=1
+	  func_file_conv "$2" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-I*)
+	  func_file_conv "${1#-I}" mingw
+	  set x "$@" -I"$file"
+	  shift
+	  ;;
+	-l)
+	  eat=1
+	  func_cl_dashl "$2"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-l*)
+	  func_cl_dashl "${1#-l}"
+	  set x "$@" "$lib"
+	  shift
+	  ;;
+	-L)
+	  eat=1
+	  func_cl_dashL "$2"
+	  ;;
+	-L*)
+	  func_cl_dashL "${1#-L}"
+	  ;;
+	-static)
+	  shared=false
+	  ;;
+	-Wl,*)
+	  arg=${1#-Wl,}
+	  save_ifs="$IFS"; IFS=','
+	  for flag in $arg; do
+	    IFS="$save_ifs"
+	    linker_opts="$linker_opts $flag"
+	  done
+	  IFS="$save_ifs"
+	  ;;
+	-Xlinker)
+	  eat=1
+	  linker_opts="$linker_opts $2"
+	  ;;
+	-*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+	*.cc | *.CC | *.cxx | *.CXX | *.cC++)
+	  func_file_conv "$1"
+	  set x "$@" -Tp"$file"
+	  shift
+	  ;;
+	*.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.oO)
+	  func_file_conv "$1" mingw
+	  set x "$@" "$file"
+	  shift
+	  ;;
+	*)
+	  set x "$@" "$1"
+	  shift
+	  ;;
+      esac
+    fi
+    shift
+  done
+  if test -n "$linker_opts"; then
+    linker_opts="-link$linker_opts"
+  fi
+  exec "$@" $linker_opts
+  exit 1
+}
+
+eat=
+
+case $1 in
+  '')
+     echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+     exit 1;
+     ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: compile --help --version PROGRAM ARGS
+
+Wrapper for compilers which do not understand '-c -o'.
+Remove '-o dest.o' from ARGS, run PROGRAM with the remaining
+arguments, and rename the output as expected.
+
+If you are trying to build a whole package this is not the
+right script to run: please start by reading the file 'INSTALL'.
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "compile $scriptversion"
+    exit $?
+    ;;
+  cl | */\\cl | cl.exe | */\\cl.exe | \
+  icl | */\\icl | icl.exe | */\\icl.exe )
+    func_cl_wrapper "$@"      # Doesn't return...
+    ;;
+esac
+
+ofile=
+cfile=
+
+for arg
+do
+  if test -n "$eat"; then
+    eat=
+  else
+    case $1 in
+      -o)
+	# configure might choose to run compile as 'compile cc -o foo foo.c'.
+	# So we strip '-o arg' only if arg is an object.
+	eat=1
+	case $2 in
+	  *.o | *.obj)
+	    ofile=$2
+	    ;;
+	  *)
+	    set x "$@" -o "$2"
+	    shift
+	    ;;
+	esac
+	;;
+      *.c)
+	cfile=$1
+	set x "$@" "$1"
+	shift
+	;;
+      *)
+	set x "$@" "$1"
+	shift
+	;;
+    esac
+  fi
+  shift
+done
+
+if test -z "$ofile" || test -z "$cfile"; then
+  # If no '-o' option was seen then we might have been invoked from a
+  # pattern rule where we don't need one.  That is ok -- this is a
+  # normal compilation that the losing compiler can handle.  If no
+  # '.c' file was seen then we are probably linking.  That is also
+  # ok.
+  exec "$@"
+fi
+
+# Name of file we expect compiler to create.
+cofile=`echo "$cfile" | sed 's|^.*\\/||; s|^a-zA-Z:||; s/\.c$/.o/'`
+
+# Create the lock directory.
+# Note: use '/\\:.-' here to ensure that we don't use the same name
+# that we are using for the .o file.  Also, base the name on the expected
+# object file name, since that is what matters with a parallel build.
+lockdir=`echo "$cofile" | sed -e 's|/\\:.-|_|g'`.d
+while true; do
+  if mkdir "$lockdir" >/dev/null 2>&1; then
+    break
+  fi
+  sleep 1
+done
+# FIXME: race condition here if user kills between mkdir and trap.
+trap "rmdir '$lockdir'; exit 1" 1 2 15
+
+# Run the compile.
+"$@"
+ret=$?
+
+if test -f "$cofile"; then
+  test "$cofile" = "$ofile" || mv "$cofile" "$ofile"
+elif test -f "${cofile}bj"; then
+  test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile"
+fi
+
+rmdir "$lockdir"
+exit $ret
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:

_service:tar_scm:isl-0.24.tar.gz/interface/config.guess Added

@@ -0,0 +1,1480 @@
+#! /bin/sh
+# Attempt to guess a canonical system name.
+#   Copyright 1992-2018 Free Software Foundation, Inc.
+
+timestamp='2018-02-24'
+
+# This file is free software; you can redistribute it and/or modify it
+# under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see <https://www.gnu.org/licenses/>.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that
+# program.  This Exception is an additional permission under section 7
+# of the GNU General Public License, version 3 ("GPLv3").
+#
+# Originally written by Per Bothner; maintained since 2000 by Ben Elliston.
+#
+# You can get the latest version of this script from:
+# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+#
+# Please send patches to <config-patches@gnu.org>.
+
+
+me=`echo "$0" | sed -e 's,.*/,,'`
+
+usage="\
+Usage: $0 OPTION
+
+Output the configuration name of the system \`$me' is run on.
+
+Options:
+  -h, --help         print this help, then exit
+  -t, --time-stamp   print date of last modification, then exit
+  -v, --version      print version number, then exit
+
+Report bugs and patches to <config-patches@gnu.org>."
+
+version="\
+GNU config.guess ($timestamp)
+
+Originally written by Per Bothner.
+Copyright 1992-2018 Free Software Foundation, Inc.
+
+This is free software; see the source for copying conditions.  There is NO
+warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
+
+help="
+Try \`$me --help' for more information."
+
+# Parse command line
+while test $# -gt 0 ; do
+  case $1 in
+    --time-stamp | --time* | -t )
+       echo "$timestamp" ; exit ;;
+    --version | -v )
+       echo "$version" ; exit ;;
+    --help | --h* | -h )
+       echo "$usage"; exit ;;
+    -- )     # Stop option processing
+       shift; break ;;
+    - )	# Use stdin as input.
+       break ;;
+    -* )
+       echo "$me: invalid option $1$help" >&2
+       exit 1 ;;
+    * )
+       break ;;
+  esac
+done
+
+if test $# != 0; then
+  echo "$me: too many arguments$help" >&2
+  exit 1
+fi
+
+trap 'exit 1' 1 2 15
+
+# CC_FOR_BUILD -- compiler used by this script. Note that the use of a
+# compiler to aid in system detection is discouraged as it requires
+# temporary files to be created and, as you can see below, it is a
+# headache to deal with in a portable fashion.
+
+# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still
+# use `HOST_CC' if defined, but it is deprecated.
+
+# Portable tmp directory creation inspired by the Autoconf team.
+
+set_cc_for_build='
+trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ;
+trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ;
+: ${TMPDIR=/tmp} ;
+ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } ||
+ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } ||
+ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } ||
+ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ;
+dummy=$tmp/dummy ;
+tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ;
+case $CC_FOR_BUILD,$HOST_CC,$CC in
+ ,,)    echo "int x;" > "$dummy.c" ;
+	for c in cc gcc c89 c99 ; do
+	  if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then
+	     CC_FOR_BUILD="$c"; break ;
+	  fi ;
+	done ;
+	if test x"$CC_FOR_BUILD" = x ; then
+	  CC_FOR_BUILD=no_compiler_found ;
+	fi
+	;;
+ ,,*)   CC_FOR_BUILD=$CC ;;
+ ,*,*)  CC_FOR_BUILD=$HOST_CC ;;
+esac ; set_cc_for_build= ;'
+
+# This is needed to find uname on a Pyramid OSx when run in the BSD universe.
+# (ghazi@noc.rutgers.edu 1994-08-24)
+if (test -f /.attbin/uname) >/dev/null 2>&1 ; then
+	PATH=$PATH:/.attbin ; export PATH
+fi
+
+UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown
+UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown
+UNAME_SYSTEM=`(uname -s) 2>/dev/null`  || UNAME_SYSTEM=unknown
+UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown
+
+case "$UNAME_SYSTEM" in
+Linux|GNU|GNU/*)
+	# If the system lacks a compiler, then just pick glibc.
+	# We could probably try harder.
+	LIBC=gnu
+
+	eval "$set_cc_for_build"
+	cat <<-EOF > "$dummy.c"
+	#include <features.h>
+	#if defined(__UCLIBC__)
+	LIBC=uclibc
+	#elif defined(__dietlibc__)
+	LIBC=dietlibc
+	#else
+	LIBC=gnu
+	#endif
+	EOF
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`"
+
+	# If ldd exists, use it to detect musl libc.
+	if command -v ldd >/dev/null && \
+		ldd --version 2>&1 | grep -q ^musl
+	then
+	    LIBC=musl
+	fi
+	;;
+esac
+
+# Note: order is significant - the case branches are not exclusive.
+
+case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in
+    *:NetBSD:*:*)
+	# NetBSD (nbsd) targets should (where applicable) match one or
+	# more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*,
+	# *-*-netbsdecoff* and *-*-netbsd*.  For targets that recently
+	# switched to ELF, *-*-netbsd* would select the old
+	# object file format.  This provides both forward
+	# compatibility and a consistent mechanism for selecting the
+	# object file format.
+	#
+	# Note: NetBSD doesn't particularly care about the vendor
+	# portion of the name.  We always set it to "unknown".
+	sysctl="sysctl -n hw.machine_arch"
+	UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \
+	    "/sbin/$sysctl" 2>/dev/null || \
+	    "/usr/sbin/$sysctl" 2>/dev/null || \
+	    echo unknown)`
+	case "$UNAME_MACHINE_ARCH" in
+	    armeb) machine=armeb-unknown ;;
+	    arm*) machine=arm-unknown ;;
+	    sh3el) machine=shl-unknown ;;
+	    sh3eb) machine=sh-unknown ;;
+	    sh5el) machine=sh5le-unknown ;;
+	    earmv*)
+		arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e$armv0-9$.*$,\1,'`
+		endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*$eb$$,\1,p'`
+		machine="${arch}${endian}"-unknown
+		;;
+	    *) machine="$UNAME_MACHINE_ARCH"-unknown ;;
+	esac
+	# The Operating System including object format, if it has switched
+	# to ELF recently (or will in the future) and ABI.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		os=netbsdelf
+		;;
+	    arm*|i386|m68k|ns32k|sh3*|sparc|vax)
+		eval "$set_cc_for_build"
+		if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \
+			| grep -q __ELF__
+		then
+		    # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout).
+		    # Return netbsd for either.  FIX?
+		    os=netbsd
+		else
+		    os=netbsdelf
+		fi
+		;;
+	    *)
+		os=netbsd
+		;;
+	esac
+	# Determine ABI tags.
+	case "$UNAME_MACHINE_ARCH" in
+	    earm*)
+		expr='s/^earmv0-9/-eabi/;s/eb$//'
+		abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"`
+		;;
+	esac
+	# The OS release
+	# Debian GNU/NetBSD machines have a different userland, and
+	# thus, need a distinct triplet. However, they do not need
+	# kernel version information, so it can be replaced with a
+	# suitable tag, in the style of linux-gnu.
+	case "$UNAME_VERSION" in
+	    Debian*)
+		release='-gnu'
+		;;
+	    *)
+		release=`echo "$UNAME_RELEASE" | sed -e 's/-_.*//' | cut -d. -f1,2`
+		;;
+	esac
+	# Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM:
+	# contains redundant information, the shorter form:
+	# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used.
+	echo "$machine-${os}${release}${abi}"
+	exit ;;
+    *:Bitrig:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE"
+	exit ;;
+    *:OpenBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE"
+	exit ;;
+    *:LibertyBSD:*:*)
+	UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'`
+	echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE"
+	exit ;;
+    *:MidnightBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE"
+	exit ;;
+    *:ekkoBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE"
+	exit ;;
+    *:SolidBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE"
+	exit ;;
+    macppc:MirBSD:*:*)
+	echo powerpc-unknown-mirbsd"$UNAME_RELEASE"
+	exit ;;
+    *:MirBSD:*:*)
+	echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE"
+	exit ;;
+    *:Sortix:*:*)
+	echo "$UNAME_MACHINE"-unknown-sortix
+	exit ;;
+    *:Redox:*:*)
+	echo "$UNAME_MACHINE"-unknown-redox
+	exit ;;
+    mips:OSF1:*.*)
+        echo mips-dec-osf1
+        exit ;;
+    alpha:OSF1:*:*)
+	case $UNAME_RELEASE in
+	*4.0)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'`
+		;;
+	*5.*)
+		UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'`
+		;;
+	esac
+	# According to Compaq, /usr/sbin/psrinfo has been available on
+	# OSF/1 and Tru64 systems produced since 1995.  I hope that
+	# covers most systems running today.  This code pipes the CPU
+	# types through head -n 1, so we only detect the type of CPU 0.
+	ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^  The alpha $.*$ processor.*$/\1/p' | head -n 1`
+	case "$ALPHA_CPU_TYPE" in
+	    "EV4 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "EV4.5 (21064)")
+		UNAME_MACHINE=alpha ;;
+	    "LCA4 (21066/21068)")
+		UNAME_MACHINE=alpha ;;
+	    "EV5 (21164)")
+		UNAME_MACHINE=alphaev5 ;;
+	    "EV5.6 (21164A)")
+		UNAME_MACHINE=alphaev56 ;;
+	    "EV5.6 (21164PC)")
+		UNAME_MACHINE=alphapca56 ;;
+	    "EV5.7 (21164PC)")
+		UNAME_MACHINE=alphapca57 ;;
+	    "EV6 (21264)")
+		UNAME_MACHINE=alphaev6 ;;
+	    "EV6.7 (21264A)")
+		UNAME_MACHINE=alphaev67 ;;
+	    "EV6.8CB (21264C)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8AL (21264B)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.8CX (21264D)")
+		UNAME_MACHINE=alphaev68 ;;
+	    "EV6.9A (21264/EV69A)")
+		UNAME_MACHINE=alphaev69 ;;
+	    "EV7 (21364)")
+		UNAME_MACHINE=alphaev7 ;;
+	    "EV7.9 (21364A)")
+		UNAME_MACHINE=alphaev79 ;;
+	esac
+	# A Pn.n version is a patched version.
+	# A Vn.n version is a released version.
+	# A Tn.n version is a released field test version.
+	# A Xn.n version is an unreleased experimental baselevel.
+	# 1.2 uses "1.2" for uname -r.
+	echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^PVTX//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`"
+	# Reset EXIT trap before exiting to avoid spurious non-zero exit code.
+	exitcode=$?
+	trap '' 0
+	exit $exitcode ;;
+    Amiga*:UNIX_System_V:4.0:*)
+	echo m68k-unknown-sysv4
+	exit ;;
+    *:AamigaOoSs:*:*)
+	echo "$UNAME_MACHINE"-unknown-amigaos
+	exit ;;
+    *:MmorphOoSs:*:*)
+	echo "$UNAME_MACHINE"-unknown-morphos
+	exit ;;
+    *:OS/390:*:*)
+	echo i370-ibm-openedition
+	exit ;;
+    *:z/VM:*:*)
+	echo s390-ibm-zvmoe
+	exit ;;
+    *:OS400:*:*)
+	echo powerpc-ibm-os400
+	exit ;;
+    arm:RISC*:1.012*:*|arm:riscix:1.012*:*)
+	echo arm-acorn-riscix"$UNAME_RELEASE"
+	exit ;;
+    arm*:riscos:*:*|arm*:RISCOS:*:*)
+	echo arm-unknown-riscos
+	exit ;;
+    SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*)
+	echo hppa1.1-hitachi-hiuxmpp
+	exit ;;
+    Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*)
+	# akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE.
+	if test "`(/bin/universe) 2>/dev/null`" = att ; then
+		echo pyramid-pyramid-sysv3
+	else
+		echo pyramid-pyramid-bsd
+	fi
+	exit ;;
+    NILE*:*:*:dcosx)
+	echo pyramid-pyramid-svr4
+	exit ;;
+    DRS?6000:unix:4.0:6*)
+	echo sparc-icl-nx6
+	exit ;;
+    DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*)
+	case `/usr/bin/uname -p` in
+	    sparc) echo sparc-icl-nx7; exit ;;
+	esac ;;
+    s390x:SunOS:*:*)
+	echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/^.*//'`"
+	exit ;;
+    sun4H:SunOS:5.*:*)
+	echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
+	exit ;;
+    sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*)
+	echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/^.*//'`"
+	exit ;;
+    i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*)
+	echo i386-pc-auroraux"$UNAME_RELEASE"
+	exit ;;
+    i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*)
+	eval "$set_cc_for_build"
+	SUN_ARCH=i386
+	# If there is a compiler, see if it is configured for 64-bit objects.
+	# Note that the Sun cc does not turn __LP64__ into 1 like gcc does.
+	# This test works for both compilers.
+	if  "$CC_FOR_BUILD" != no_compiler_found ; then
+	    if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \
+		(CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		grep IS_64BIT_ARCH >/dev/null
+	    then
+		SUN_ARCH=x86_64
+	    fi
+	fi
+	echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
+	exit ;;
+    sun4*:SunOS:6*:*)
+	# According to config.sub, this is the proper way to canonicalize
+	# SunOS6.  Hard to guess exactly what SunOS6 will be like, but
+	# it's likely to be more like Solaris than SunOS4.
+	echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
+	exit ;;
+    sun4*:SunOS:*:*)
+	case "`/usr/bin/arch -k`" in
+	    Series*|S4*)
+		UNAME_RELEASE=`uname -v`
+		;;
+	esac
+	# Japanese Language versions have a version number like `4.1.3-JL'.
+	echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`"
+	exit ;;
+    sun3*:SunOS:*:*)
+	echo m68k-sun-sunos"$UNAME_RELEASE"
+	exit ;;
+    sun*:*:4.2BSD:*)
+	UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null`
+	test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3
+	case "`/bin/arch`" in
+	    sun3)
+		echo m68k-sun-sunos"$UNAME_RELEASE"
+		;;
+	    sun4)
+		echo sparc-sun-sunos"$UNAME_RELEASE"
+		;;
+	esac
+	exit ;;
+    aushp:SunOS:*:*)
+	echo sparc-auspex-sunos"$UNAME_RELEASE"
+	exit ;;
+    # The situation for MiNT is a little confusing.  The machine name
+    # can be virtually everything (everything which is not
+    # "atarist" or "atariste" at least should have a processor
+    # > m68000).  The system name ranges from "MiNT" over "FreeMiNT"
+    # to the lowercase version "mint" (or "freemint").  Finally
+    # the system name "TOS" denotes a system which is actually not
+    # MiNT.  But MiNT is downward compatible to TOS, so this should
+    # be no problem.
+    atariste:*MiNT:*:* | atariste:*mint:*:* | atariste:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    atari*:*MiNT:*:* | atari*:*mint:*:* | atariste:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*)
+	echo m68k-atari-mint"$UNAME_RELEASE"
+	exit ;;
+    milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*)
+	echo m68k-milan-mint"$UNAME_RELEASE"
+	exit ;;
+    hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*)
+	echo m68k-hades-mint"$UNAME_RELEASE"
+	exit ;;
+    *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*)
+	echo m68k-unknown-mint"$UNAME_RELEASE"
+	exit ;;
+    m68k:machten:*:*)
+	echo m68k-apple-machten"$UNAME_RELEASE"
+	exit ;;
+    powerpc:machten:*:*)
+	echo powerpc-apple-machten"$UNAME_RELEASE"
+	exit ;;
+    RISC*:Mach:*:*)
+	echo mips-dec-mach_bsd4.3
+	exit ;;
+    RISC*:ULTRIX:*:*)
+	echo mips-dec-ultrix"$UNAME_RELEASE"
+	exit ;;
+    VAX*:ULTRIX*:*:*)
+	echo vax-dec-ultrix"$UNAME_RELEASE"
+	exit ;;
+    2020:CLIX:*:* | 2430:CLIX:*:*)
+	echo clipper-intergraph-clix"$UNAME_RELEASE"
+	exit ;;
+    mips:*:*:UMIPS | mips:*:*:RISCos)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+#ifdef __cplusplus
+#include <stdio.h>  /* for printf() prototype */
+	int main (int argc, char *argv) {
+#else
+	int main (argc, argv) int argc; char *argv; {
+#endif
+	#if defined (host_mips) && defined (MIPSEB)
+	#if defined (SYSTYPE_SYSV)
+	  printf ("mips-mips-riscos%ssysv\\n", argv1); exit (0);
+	#endif
+	#if defined (SYSTYPE_SVR4)
+	  printf ("mips-mips-riscos%ssvr4\\n", argv1); exit (0);
+	#endif
+	#if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD)
+	  printf ("mips-mips-riscos%sbsd\\n", argv1); exit (0);
+	#endif
+	#endif
+	  exit (-1);
+	}
+EOF
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" &&
+	  dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/$0-9*$.*/\1/p'` &&
+	  SYSTEM_NAME=`"$dummy" "$dummyarg"` &&
+	    { echo "$SYSTEM_NAME"; exit; }
+	echo mips-mips-riscos"$UNAME_RELEASE"
+	exit ;;
+    Motorola:PowerMAX_OS:*:*)
+	echo powerpc-motorola-powermax
+	exit ;;
+    Motorola:*:4.3:PL8-*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*)
+	echo powerpc-harris-powermax
+	exit ;;
+    Night_Hawk:Power_UNIX:*:*)
+	echo powerpc-harris-powerunix
+	exit ;;
+    m88k:CX/UX:7*:*)
+	echo m88k-harris-cxux7
+	exit ;;
+    m88k:*:4*:R4*)
+	echo m88k-motorola-sysv4
+	exit ;;
+    m88k:*:3*:R3*)
+	echo m88k-motorola-sysv3
+	exit ;;
+    AViiON:dgux:*:*)
+	# DG/UX returns AViiON for all architectures
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	if  "$UNAME_PROCESSOR" = mc88100  ||  "$UNAME_PROCESSOR" = mc88110 
+	then
+	    if  "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx  || \
+	        "$TARGET_BINARY_INTERFACE"x = x 
+	    then
+		echo m88k-dg-dgux"$UNAME_RELEASE"
+	    else
+		echo m88k-dg-dguxbcs"$UNAME_RELEASE"
+	    fi
+	else
+	    echo i586-dg-dgux"$UNAME_RELEASE"
+	fi
+	exit ;;
+    M88*:DolphinOS:*:*)	# DolphinOS (SVR3)
+	echo m88k-dolphin-sysv3
+	exit ;;
+    M88*:*:R3*:*)
+	# Delta 88k system running SVR3
+	echo m88k-motorola-sysv3
+	exit ;;
+    XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3)
+	echo m88k-tektronix-sysv3
+	exit ;;
+    Tek430-90-9:UTek:*:*) # Tektronix 4300 system running UTek (BSD)
+	echo m68k-tektronix-bsd
+	exit ;;
+    *:IRIX*:*:*)
+	echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`"
+	exit ;;
+    ????????:AIX?:12.1:2)   # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX.
+	echo romp-ibm-aix     # uname -m gives an 8 hex-code CPU id
+	exit ;;               # Note that: echo "'`uname -s`'" gives 'AIX '
+    i*86:AIX:*:*)
+	echo i386-ibm-aix
+	exit ;;
+    ia64:AIX:*:*)
+	if  -x /usr/bin/oslevel  ; then
+		IBM_REV=`/usr/bin/oslevel`
+	else
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+	fi
+	echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV"
+	exit ;;
+    *:AIX:2:3)
+	if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then
+		eval "$set_cc_for_build"
+		sed 's/^		//' << EOF > "$dummy.c"
+		#include <sys/systemcfg.h>
+
+		main()
+			{
+			if (!__power_pc())
+				exit(1);
+			puts("powerpc-ibm-aix3.2.5");
+			exit(0);
+			}
+EOF
+		if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"`
+		then
+			echo "$SYSTEM_NAME"
+		else
+			echo rs6000-ibm-aix3.2.5
+		fi
+	elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then
+		echo rs6000-ibm-aix3.2.4
+	else
+		echo rs6000-ibm-aix3.2
+	fi
+	exit ;;
+    *:AIX:*:4567)
+	IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'`
+	if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then
+		IBM_ARCH=rs6000
+	else
+		IBM_ARCH=powerpc
+	fi
+	if  -x /usr/bin/lslpp  ; then
+		IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc |
+			   awk -F: '{ print $3 }' | sed s/0-9*$/0/`
+	else
+		IBM_REV="$UNAME_VERSION.$UNAME_RELEASE"
+	fi
+	echo "$IBM_ARCH"-ibm-aix"$IBM_REV"
+	exit ;;
+    *:AIX:*:*)
+	echo rs6000-ibm-aix
+	exit ;;
+    ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*)
+	echo romp-ibm-bsd4.4
+	exit ;;
+    ibmrt:*BSD:*|romp-ibm:BSD:*)            # covers RT/PC BSD and
+	echo romp-ibm-bsd"$UNAME_RELEASE"   # 4.3 with uname added to
+	exit ;;                             # report: romp-ibm BSD 4.3
+    *:BOSX:*:*)
+	echo rs6000-bull-bosx
+	exit ;;
+    DPX/2?00:B.O.S.:*:*)
+	echo m68k-bull-sysv3
+	exit ;;
+    9000/34??:4.3bsd:1.*:*)
+	echo m68k-hp-bsd
+	exit ;;
+    hp300:4.4BSD:*:* | 9000/34??:4.3bsd:2.*:*)
+	echo m68k-hp-bsd4.4
+	exit ;;
+    9000/34678??:HP-UX:*:*)
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/^.*.0B*//'`
+	case "$UNAME_MACHINE" in
+	    9000/31?)            HP_ARCH=m68000 ;;
+	    9000/34??)         HP_ARCH=m68k ;;
+	    9000/6780-90-9)
+		if  -x /usr/bin/getconf ; then
+		    sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null`
+		    sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null`
+		    case "$sc_cpu_version" in
+		      523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0
+		      528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1
+		      532)                      # CPU_PA_RISC2_0
+			case "$sc_kernel_bits" in
+			  32) HP_ARCH=hppa2.0n ;;
+			  64) HP_ARCH=hppa2.0w ;;
+			  '') HP_ARCH=hppa2.0 ;;   # HP-UX 10.20
+			esac ;;
+		    esac
+		fi
+		if  "$HP_ARCH" = "" ; then
+		    eval "$set_cc_for_build"
+		    sed 's/^		//' << EOF > "$dummy.c"
+
+		#define _HPUX_SOURCE
+		#include <stdlib.h>
+		#include <unistd.h>
+
+		int main ()
+		{
+		#if defined(_SC_KERNEL_BITS)
+		    long bits = sysconf(_SC_KERNEL_BITS);
+		#endif
+		    long cpu  = sysconf (_SC_CPU_VERSION);
+
+		    switch (cpu)
+			{
+			case CPU_PA_RISC1_0: puts ("hppa1.0"); break;
+			case CPU_PA_RISC1_1: puts ("hppa1.1"); break;
+			case CPU_PA_RISC2_0:
+		#if defined(_SC_KERNEL_BITS)
+			    switch (bits)
+				{
+				case 64: puts ("hppa2.0w"); break;
+				case 32: puts ("hppa2.0n"); break;
+				default: puts ("hppa2.0"); break;
+				} break;
+		#else  /* !defined(_SC_KERNEL_BITS) */
+			    puts ("hppa2.0"); break;
+		#endif
+			default: puts ("hppa1.0"); break;
+			}
+		    exit (0);
+		}
+EOF
+		    (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"`
+		    test -z "$HP_ARCH" && HP_ARCH=hppa
+		fi ;;
+	esac
+	if  "$HP_ARCH" = hppa2.0w 
+	then
+	    eval "$set_cc_for_build"
+
+	    # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating
+	    # 32-bit code.  hppa64-hp-hpux* has the same kernel and a compiler
+	    # generating 64-bit code.  GNU and HP use different nomenclature:
+	    #
+	    # $ CC_FOR_BUILD=cc ./config.guess
+	    # => hppa2.0w-hp-hpux11.23
+	    # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess
+	    # => hppa64-hp-hpux11.23
+
+	    if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) |
+		grep -q __LP64__
+	    then
+		HP_ARCH=hppa2.0w
+	    else
+		HP_ARCH=hppa64
+	    fi
+	fi
+	echo "$HP_ARCH"-hp-hpux"$HPUX_REV"
+	exit ;;
+    ia64:HP-UX:*:*)
+	HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/^.*.0B*//'`
+	echo ia64-hp-hpux"$HPUX_REV"
+	exit ;;
+    3050*:HI-UX:*:*)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+	#include <unistd.h>
+	int
+	main ()
+	{
+	  long cpu = sysconf (_SC_CPU_VERSION);
+	  /* The order matters, because CPU_IS_HP_MC68K erroneously returns
+	     true for CPU_PA_RISC1_0.  CPU_IS_PA_RISC returns correct
+	     results, however.  */
+	  if (CPU_IS_PA_RISC (cpu))
+	    {
+	      switch (cpu)
+		{
+		  case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break;
+		  case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break;
+		  default: puts ("hppa-hitachi-hiuxwe2"); break;
+		}
+	    }
+	  else if (CPU_IS_HP_MC68K (cpu))
+	    puts ("m68k-hitachi-hiuxwe2");
+	  else puts ("unknown-hitachi-hiuxwe2");
+	  exit (0);
+	}
+EOF
+	$CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` &&
+		{ echo "$SYSTEM_NAME"; exit; }
+	echo unknown-hitachi-hiuxwe2
+	exit ;;
+    9000/7??:4.3bsd:*:* | 9000/8?79:4.3bsd:*:*)
+	echo hppa1.1-hp-bsd
+	exit ;;
+    9000/8??:4.3bsd:*:*)
+	echo hppa1.0-hp-bsd
+	exit ;;
+    *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*)
+	echo hppa1.0-hp-mpeix
+	exit ;;
+    hp7??:OSF1:*:* | hp8?79:OSF1:*:*)
+	echo hppa1.1-hp-osf
+	exit ;;
+    hp8??:OSF1:*:*)
+	echo hppa1.0-hp-osf
+	exit ;;
+    i*86:OSF1:*:*)
+	if  -x /usr/sbin/sysversion  ; then
+	    echo "$UNAME_MACHINE"-unknown-osf1mk
+	else
+	    echo "$UNAME_MACHINE"-unknown-osf1
+	fi
+	exit ;;
+    parisc*:Lites*:*:*)
+	echo hppa1.1-hp-lites
+	exit ;;
+    C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*)
+	echo c1-convex-bsd
+	exit ;;
+    C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*)
+	if getsysinfo -f scalar_acc
+	then echo c32-convex-bsd
+	else echo c2-convex-bsd
+	fi
+	exit ;;
+    C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*)
+	echo c34-convex-bsd
+	exit ;;
+    C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*)
+	echo c38-convex-bsd
+	exit ;;
+    C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*)
+	echo c4-convex-bsd
+	exit ;;
+    CRAY*Y-MP:*:*:*)
+	echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
+	exit ;;
+    CRAY*A-Z90:*:*:*)
+	echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \
+	| sed -e 's/CRAY.*$A-Z90$/\1/' \
+	      -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \
+	      -e 's/\.^.*$/.X/'
+	exit ;;
+    CRAY*TS:*:*:*)
+	echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
+	exit ;;
+    CRAY*T3E:*:*:*)
+	echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
+	exit ;;
+    CRAY*SV1:*:*:*)
+	echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
+	exit ;;
+    *:UNICOS/mp:*:*)
+	echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.^.*$/.X/'
+	exit ;;
+    F3001:UNIX_System_V:*:* | F700:UNIX_System_V:*:*)
+	FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'`
+	echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    5000:UNIX_System_V:4.*:*)
+	FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'`
+	FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'`
+	echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}"
+	exit ;;
+    i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*)
+	echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE"
+	exit ;;
+    sparc*:BSD/OS:*:*)
+	echo sparc-unknown-bsdi"$UNAME_RELEASE"
+	exit ;;
+    *:BSD/OS:*:*)
+	echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE"
+	exit ;;
+    *:FreeBSD:*:*)
+	UNAME_PROCESSOR=`/usr/bin/uname -p`
+	case "$UNAME_PROCESSOR" in
+	    amd64)
+		UNAME_PROCESSOR=x86_64 ;;
+	    i386)
+		UNAME_PROCESSOR=i586 ;;
+	esac
+	echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`"
+	exit ;;
+    i*:CYGWIN*:*)
+	echo "$UNAME_MACHINE"-pc-cygwin
+	exit ;;
+    *:MINGW64*:*)
+	echo "$UNAME_MACHINE"-pc-mingw64
+	exit ;;
+    *:MINGW*:*)
+	echo "$UNAME_MACHINE"-pc-mingw32
+	exit ;;
+    *:MSYS*:*)
+	echo "$UNAME_MACHINE"-pc-msys
+	exit ;;
+    i*:PW*:*)
+	echo "$UNAME_MACHINE"-pc-pw32
+	exit ;;
+    *:Interix*:*)
+	case "$UNAME_MACHINE" in
+	    x86)
+		echo i586-pc-interix"$UNAME_RELEASE"
+		exit ;;
+	    authenticamd | genuineintel | EM64T)
+		echo x86_64-unknown-interix"$UNAME_RELEASE"
+		exit ;;
+	    IA64)
+		echo ia64-unknown-interix"$UNAME_RELEASE"
+		exit ;;
+	esac ;;
+    i*:UWIN*:*)
+	echo "$UNAME_MACHINE"-pc-uwin
+	exit ;;
+    amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*)
+	echo x86_64-unknown-cygwin
+	exit ;;
+    prep*:SunOS:5.*:*)
+	echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/^.*//'`"
+	exit ;;
+    *:GNU:*:*)
+	# the GNU system
+	echo "`echo "$UNAME_MACHINE"|sed -e 's,-/.*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`"
+	exit ;;
+    *:GNU/*:*:*)
+	# other systems with GNU libc and userland
+	echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^^/*/,,' | tr ":upper:" ":lower:"``echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`-$LIBC"
+	exit ;;
+    i*86:Minix:*:*)
+	echo "$UNAME_MACHINE"-pc-minix
+	exit ;;
+    aarch64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    aarch64_be:Linux:*:*)
+	UNAME_MACHINE=aarch64_be
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    alpha:Linux:*:*)
+	case `sed -n '/^cpu model/s/^.*: $.*$/\1/p' < /proc/cpuinfo` in
+	  EV5)   UNAME_MACHINE=alphaev5 ;;
+	  EV56)  UNAME_MACHINE=alphaev56 ;;
+	  PCA56) UNAME_MACHINE=alphapca56 ;;
+	  PCA57) UNAME_MACHINE=alphapca56 ;;
+	  EV6)   UNAME_MACHINE=alphaev6 ;;
+	  EV67)  UNAME_MACHINE=alphaev67 ;;
+	  EV68*) UNAME_MACHINE=alphaev68 ;;
+	esac
+	objdump --private-headers /bin/sh | grep -q ld.so.1
+	if test "$?" = 0 ; then LIBC=gnulibc1 ; fi
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    arc:Linux:*:* | arceb:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    arm*:Linux:*:*)
+	eval "$set_cc_for_build"
+	if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \
+	    | grep -q __ARM_EABI__
+	then
+	    echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	else
+	    if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \
+		| grep -q __ARM_PCS_VFP
+	    then
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi
+	    else
+		echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf
+	    fi
+	fi
+	exit ;;
+    avr32*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    cris:Linux:*:*)
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
+	exit ;;
+    crisv32:Linux:*:*)
+	echo "$UNAME_MACHINE"-axis-linux-"$LIBC"
+	exit ;;
+    e2k:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    frv:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    hexagon:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    i*86:Linux:*:*)
+	echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	exit ;;
+    ia64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    k1om:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    m32r*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    m68*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    mips:Linux:*:* | mips64:Linux:*:*)
+	eval "$set_cc_for_build"
+	sed 's/^	//' << EOF > "$dummy.c"
+	#undef CPU
+	#undef ${UNAME_MACHINE}
+	#undef ${UNAME_MACHINE}el
+	#if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL)
+	CPU=${UNAME_MACHINE}el
+	#else
+	#if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB)
+	CPU=${UNAME_MACHINE}
+	#else
+	CPU=
+	#endif
+	#endif
+EOF
+	eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`"
+	test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; }
+	;;
+    mips64el:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    openrisc*:Linux:*:*)
+	echo or1k-unknown-linux-"$LIBC"
+	exit ;;
+    or32:Linux:*:* | or1k*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    padre:Linux:*:*)
+	echo sparc-unknown-linux-"$LIBC"
+	exit ;;
+    parisc64:Linux:*:* | hppa64:Linux:*:*)
+	echo hppa64-unknown-linux-"$LIBC"
+	exit ;;
+    parisc:Linux:*:* | hppa:Linux:*:*)
+	# Look for CPU level
+	case `grep '^cpu^a-z*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in
+	  PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;;
+	  PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;;
+	  *)    echo hppa-unknown-linux-"$LIBC" ;;
+	esac
+	exit ;;
+    ppc64:Linux:*:*)
+	echo powerpc64-unknown-linux-"$LIBC"
+	exit ;;
+    ppc:Linux:*:*)
+	echo powerpc-unknown-linux-"$LIBC"
+	exit ;;
+    ppc64le:Linux:*:*)
+	echo powerpc64le-unknown-linux-"$LIBC"
+	exit ;;
+    ppcle:Linux:*:*)
+	echo powerpcle-unknown-linux-"$LIBC"
+	exit ;;
+    riscv32:Linux:*:* | riscv64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    s390:Linux:*:* | s390x:Linux:*:*)
+	echo "$UNAME_MACHINE"-ibm-linux-"$LIBC"
+	exit ;;
+    sh64*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    sh*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    sparc:Linux:*:* | sparc64:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    tile*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    vax:Linux:*:*)
+	echo "$UNAME_MACHINE"-dec-linux-"$LIBC"
+	exit ;;
+    x86_64:Linux:*:*)
+	if objdump -f /bin/sh | grep -q elf32-x86-64; then
+	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32
+	else
+	    echo "$UNAME_MACHINE"-pc-linux-"$LIBC"
+	fi
+	exit ;;
+    xtensa*:Linux:*:*)
+	echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"
+	exit ;;
+    i*86:DYNIX/ptx:4*:*)
+	# ptx 4.0 does uname -s correctly, with DYNIX/ptx in there.
+	# earlier versions are messed up and put the nodename in both
+	# sysname and nodename.
+	echo i386-sequent-sysv4
+	exit ;;
+    i*86:UNIX_SV:4.2MP:2.*)
+	# Unixware is an offshoot of SVR4, but it has its own version
+	# number series starting with 2...
+	# I am not positive that other SVR4 systems won't match this,
+	# I just have to hope.  -- rms.
+	# Use sysv4.2uw... so that sysv4* matches it.
+	echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION"
+	exit ;;
+    i*86:OS/2:*:*)
+	# If we were able to find `uname', then EMX Unix compatibility
+	# is probably installed.
+	echo "$UNAME_MACHINE"-pc-os2-emx
+	exit ;;
+    i*86:XTS-300:*:STOP)
+	echo "$UNAME_MACHINE"-unknown-stop
+	exit ;;
+    i*86:atheos:*:*)
+	echo "$UNAME_MACHINE"-unknown-atheos
+	exit ;;
+    i*86:syllable:*:*)
+	echo "$UNAME_MACHINE"-pc-syllable
+	exit ;;
+    i*86:LynxOS:2.*:* | i*86:LynxOS:3.01*:* | i*86:LynxOS:4.02*:*)
+	echo i386-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    i*86:*DOS:*:*)
+	echo "$UNAME_MACHINE"-pc-msdosdjgpp
+	exit ;;
+    i*86:*:4.*:*)
+	UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'`
+	if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then
+		echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL"
+	else
+		echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL"
+	fi
+	exit ;;
+    i*86:*:5:678*)
+	# UnixWare 7.x, OpenUNIX and OpenServer 6.
+	case `/bin/uname -X | grep "^Machine"` in
+	    *486*)	     UNAME_MACHINE=i486 ;;
+	    *Pentium)	     UNAME_MACHINE=i586 ;;
+	    *Pent*|*Celeron) UNAME_MACHINE=i686 ;;
+	esac
+	echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}"
+	exit ;;
+    i*86:*:3.2:*)
+	if test -f /usr/options/cb.name; then
+		UNAME_REL=`sed -n 's/.*Version //p' </usr/options/cb.name`
+		echo "$UNAME_MACHINE"-pc-isc"$UNAME_REL"
+	elif /bin/uname -X 2>/dev/null >/dev/null ; then
+		UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')`
+		(/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486
+		(/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \
+			&& UNAME_MACHINE=i586
+		(/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		(/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \
+			&& UNAME_MACHINE=i686
+		echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL"
+	else
+		echo "$UNAME_MACHINE"-pc-sysv32
+	fi
+	exit ;;
+    pc:*:*:*)
+	# Left here for compatibility:
+	# uname -m prints for DJGPP always 'pc', but it prints nothing about
+	# the processor, so we play safe by assuming i586.
+	# Note: whatever this is, it MUST be the same as what config.sub
+	# prints for the "djgpp" host, or else GDB configure will decide that
+	# this is a cross-build.
+	echo i586-pc-msdosdjgpp
+	exit ;;
+    Intel:Mach:3*:*)
+	echo i386-pc-mach3
+	exit ;;
+    paragon:*:*:*)
+	echo i860-intel-osf1
+	exit ;;
+    i860:*:4.*:*) # i860-SVR4
+	if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then
+	  echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4
+	else # Add other i860-SVR4 vendors below as they are discovered.
+	  echo i860-unknown-sysv"$UNAME_RELEASE"  # Unknown i860-SVR4
+	fi
+	exit ;;
+    mini*:CTIX:SYS*5:*)
+	# "miniframe"
+	echo m68010-convergent-sysv
+	exit ;;
+    mc68k:UNIX:SYSTEM5:3.51m)
+	echo m68k-convergent-sysv
+	exit ;;
+    M680?0:D-NIX:5.3:*)
+	echo m68k-diab-dnix
+	exit ;;
+    M68*:*:R3V5678*:*)
+	test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;;
+    3345??:*:4.0:3.0 | 334??A:*:4.0:3.0 | 334??,*:*:4.0:3.0 | 334??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0)
+	OS_REL=''
+	test -r /etc/.relid \
+	&& OS_REL=.`sed -n 's/^ * ^ * $0-90-9$.*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	  && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
+    334??:*:4.0:* | 334??,*:*:4.0:*)
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	  && { echo i486-ncr-sysv4; exit; } ;;
+    NCR*:*:4.2:* | MPRAS*:*:4.2:*)
+	OS_REL='.3'
+	test -r /etc/.relid \
+	    && OS_REL=.`sed -n 's/^ * ^ * $0-90-9$.*/\1/p' < /etc/.relid`
+	/bin/uname -p 2>/dev/null | grep 86 >/dev/null \
+	    && { echo i486-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; }
+	/bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \
+	    && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;;
+    m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*)
+	echo m68k-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    mc68030:UNIX_System_V:4.*:*)
+	echo m68k-atari-sysv4
+	exit ;;
+    TSUNAMI:LynxOS:2.*:*)
+	echo sparc-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    rs6000:LynxOS:2.*:*)
+	echo rs6000-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.01*:* | PowerPC:LynxOS:4.02*:*)
+	echo powerpc-unknown-lynxos"$UNAME_RELEASE"
+	exit ;;
+    SMBES:UNIX_SV:*:*)
+	echo mips-dde-sysv"$UNAME_RELEASE"
+	exit ;;
+    RM*:ReliantUNIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    RM*:SINIX-*:*:*)
+	echo mips-sni-sysv4
+	exit ;;
+    *:SINIX-*:*:*)
+	if uname -p 2>/dev/null >/dev/null ; then
+		UNAME_MACHINE=`(uname -p) 2>/dev/null`
+		echo "$UNAME_MACHINE"-sni-sysv4
+	else
+		echo ns32k-sni-sysv
+	fi
+	exit ;;
+    PENTIUM:*:4.0*:*)	# Unisys `ClearPath HMP IX 4000' SVR4/MP effort
+			# says <Richard.M.Bartel@ccMail.Census.GOV>
+	echo i586-unisys-sysv4
+	exit ;;
+    *:UNIX_System_V:4*:FTX*)
+	# From Gerald Hewes <hewes@openmarket.com>.
+	# How about differentiating between stratus architectures? -djm
+	echo hppa1.1-stratus-sysv4
+	exit ;;
+    *:*:*:FTX*)
+	# From seanf@swdc.stratus.com.
+	echo i860-stratus-sysv4
+	exit ;;
+    i*86:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo "$UNAME_MACHINE"-stratus-vos
+	exit ;;
+    *:VOS:*:*)
+	# From Paul.Green@stratus.com.
+	echo hppa1.1-stratus-vos
+	exit ;;
+    mc68*:A/UX:*:*)
+	echo m68k-apple-aux"$UNAME_RELEASE"
+	exit ;;
+    news*:NEWS-OS:6*:*)
+	echo mips-sony-newsos6
+	exit ;;
+    R34000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*)
+	if  -d /usr/nec ; then
+		echo mips-nec-sysv"$UNAME_RELEASE"
+	else
+		echo mips-unknown-sysv"$UNAME_RELEASE"
+	fi
+	exit ;;
+    BeBox:BeOS:*:*)	# BeOS running on hardware made by Be, PPC only.
+	echo powerpc-be-beos
+	exit ;;
+    BeMac:BeOS:*:*)	# BeOS running on Mac or Mac clone, PPC only.
+	echo powerpc-apple-beos
+	exit ;;
+    BePC:BeOS:*:*)	# BeOS running on Intel PC compatible.
+	echo i586-pc-beos
+	exit ;;
+    BePC:Haiku:*:*)	# Haiku running on Intel PC compatible.
+	echo i586-pc-haiku
+	exit ;;
+    x86_64:Haiku:*:*)
+	echo x86_64-unknown-haiku
+	exit ;;
+    SX-4:SUPER-UX:*:*)
+	echo sx4-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-5:SUPER-UX:*:*)
+	echo sx5-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-6:SUPER-UX:*:*)
+	echo sx6-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-7:SUPER-UX:*:*)
+	echo sx7-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-8:SUPER-UX:*:*)
+	echo sx8-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-8R:SUPER-UX:*:*)
+	echo sx8r-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    SX-ACE:SUPER-UX:*:*)
+	echo sxace-nec-superux"$UNAME_RELEASE"
+	exit ;;
+    Power*:Rhapsody:*:*)
+	echo powerpc-apple-rhapsody"$UNAME_RELEASE"
+	exit ;;
+    *:Rhapsody:*:*)
+	echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE"
+	exit ;;
+    *:Darwin:*:*)
+	UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown
+	eval "$set_cc_for_build"
+	if test "$UNAME_PROCESSOR" = unknown ; then
+	    UNAME_PROCESSOR=powerpc
+	fi
+	if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then
+	    if  "$CC_FOR_BUILD" != no_compiler_found ; then
+		if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_64BIT_ARCH >/dev/null
+		then
+		    case $UNAME_PROCESSOR in
+			i386) UNAME_PROCESSOR=x86_64 ;;
+			powerpc) UNAME_PROCESSOR=powerpc64 ;;
+		    esac
+		fi
+		# On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc
+		if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \
+		       (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \
+		       grep IS_PPC >/dev/null
+		then
+		    UNAME_PROCESSOR=powerpc
+		fi
+	    fi
+	elif test "$UNAME_PROCESSOR" = i386 ; then
+	    # Avoid executing cc on OS X 10.9, as it ships with a stub
+	    # that puts up a graphical alert prompting to install
+	    # developer tools.  Any system running Mac OS X 10.7 or
+	    # later (Darwin 11 and later) is required to have a 64-bit
+	    # processor. This is not true of the ARM version of Darwin
+	    # that Apple uses in portable devices.
+	    UNAME_PROCESSOR=x86_64
+	fi
+	echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE"
+	exit ;;
+    *:procnto*:*:* | *:QNX:0123456789*:*)
+	UNAME_PROCESSOR=`uname -p`
+	if test "$UNAME_PROCESSOR" = x86; then
+		UNAME_PROCESSOR=i386
+		UNAME_MACHINE=pc
+	fi
+	echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE"
+	exit ;;
+    *:QNX:*:4*)
+	echo i386-pc-qnx
+	exit ;;
+    NEO-*:NONSTOP_KERNEL:*:*)
+	echo neo-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSE-*:NONSTOP_KERNEL:*:*)
+	echo nse-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSR-*:NONSTOP_KERNEL:*:*)
+	echo nsr-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSV-*:NONSTOP_KERNEL:*:*)
+	echo nsv-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    NSX-*:NONSTOP_KERNEL:*:*)
+	echo nsx-tandem-nsk"$UNAME_RELEASE"
+	exit ;;
+    *:NonStop-UX:*:*)
+	echo mips-compaq-nonstopux
+	exit ;;
+    BS2000:POSIX*:*:*)
+	echo bs2000-siemens-sysv
+	exit ;;
+    DS/*:UNIX_System_V:*:*)
+	echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE"
+	exit ;;
+    *:Plan9:*:*)
+	# "uname -m" is not consistent, so use $cputype instead. 386
+	# is converted to i386 for consistency with other x86
+	# operating systems.
+	if test "$cputype" = 386; then
+	    UNAME_MACHINE=i386
+	else
+	    UNAME_MACHINE="$cputype"
+	fi
+	echo "$UNAME_MACHINE"-unknown-plan9
+	exit ;;
+    *:TOPS-10:*:*)
+	echo pdp10-unknown-tops10
+	exit ;;
+    *:TENEX:*:*)
+	echo pdp10-unknown-tenex
+	exit ;;
+    KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*)
+	echo pdp10-dec-tops20
+	exit ;;
+    XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*)
+	echo pdp10-xkl-tops20
+	exit ;;
+    *:TOPS-20:*:*)
+	echo pdp10-unknown-tops20
+	exit ;;
+    *:ITS:*:*)
+	echo pdp10-unknown-its
+	exit ;;
+    SEI:*:*:SEIUX)
+	echo mips-sei-seiux"$UNAME_RELEASE"
+	exit ;;
+    *:DragonFly:*:*)
+	echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/-(.*//'`"
+	exit ;;
+    *:*VMS:*:*)
+	UNAME_MACHINE=`(uname -p) 2>/dev/null`
+	case "$UNAME_MACHINE" in
+	    A*) echo alpha-dec-vms ; exit ;;
+	    I*) echo ia64-dec-vms ; exit ;;
+	    V*) echo vax-dec-vms ; exit ;;
+	esac ;;
+    *:XENIX:*:SysV)
+	echo i386-pc-xenix
+	exit ;;
+    i*86:skyos:*:*)
+	echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`"
+	exit ;;
+    i*86:rdos:*:*)
+	echo "$UNAME_MACHINE"-pc-rdos
+	exit ;;
+    i*86:AROS:*:*)
+	echo "$UNAME_MACHINE"-pc-aros
+	exit ;;
+    x86_64:VMkernel:*:*)
+	echo "$UNAME_MACHINE"-unknown-esx
+	exit ;;
+    amd64:Isilon\ OneFS:*:*)
+	echo x86_64-unknown-onefs
+	exit ;;
+esac
+
+echo "$0: unable to guess system type" >&2
+
+case "$UNAME_MACHINE:$UNAME_SYSTEM" in
+    mips:Linux | mips64:Linux)
+	# If we got here on MIPS GNU/Linux, output extra information.
+	cat >&2 <<EOF
+
+NOTE: MIPS GNU/Linux systems require a C compiler to fully recognize
+the system type. Please install a C compiler and try again.
+EOF
+	;;
+esac
+
+cat >&2 <<EOF
+
+This script (version $timestamp), has failed to recognize the
+operating system you are using. If your script is old, overwrite *all*
+copies of config.guess and config.sub with the latest versions from:
+
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess
+and
+  https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub
+
+If $0 has already been updated, send the following data and any
+information you think might be pertinent to config-patches@gnu.org to
+provide the necessary information to handle your system.
+
+config.guess timestamp = $timestamp
+
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null`
+
+hostinfo               = `(hostinfo) 2>/dev/null`
+/bin/universe          = `(/bin/universe) 2>/dev/null`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null`
+/bin/arch              = `(/bin/arch) 2>/dev/null`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null`
+
+UNAME_MACHINE = "$UNAME_MACHINE"
+UNAME_RELEASE = "$UNAME_RELEASE"
+UNAME_SYSTEM  = "$UNAME_SYSTEM"
+UNAME_VERSION = "$UNAME_VERSION"
+EOF
+
+exit 1
+
+# Local variables:
+# eval: (add-hook 'write-file-functions 'time-stamp)
+# time-stamp-start: "timestamp='"
+# time-stamp-format: "%:y-%02m-%02d"
+# time-stamp-end: "'"
+# End:

_service:tar_scm:isl-0.24.tar.gz/interface/config.sub Added

_service:tar_scm:isl-0.24.tar.gz/interface/configure Added

@@ -0,0 +1,22158 @@
+#! /bin/sh
+# Guess values for system-dependent variables and create Makefiles.
+# Generated by GNU Autoconf 2.69 for isl-interface 0.
+#
+# Report bugs to <isl-development@googlegroups.com>.
+#
+#
+# Copyright (C) 1992-1996, 1998-2012 Free Software Foundation, Inc.
+#
+#
+# This configure script is free software; the Free Software Foundation
+# gives unlimited permission to copy, distribute and modify it.
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\$.*\$"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\$.*\$$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\$.*\$"`;;
+      esac;
+      expr "X$arg" : "X\$.*\$" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *\\/* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Use a proper internal environment variable to ensure we don't fall
+  # into an infinite loop, continuously re-executing ourselves.
+  if test x"${_as_can_reexec}" != xno && test "x$CONFIG_SHELL" != x; then
+    _as_can_reexec=no; export _as_can_reexec;
+    # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+as_fn_exit 255
+  fi
+  # We don't want this to propagate to other subprocesses.
+          { _as_can_reexec=; unset _as_can_reexec;}
+if test "x$CONFIG_SHELL" = x; then
+  as_bourne_compatible="if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+"
+  as_required="as_fn_return () { (exit \$1); }
+as_fn_success () { as_fn_return 0; }
+as_fn_failure () { as_fn_return 1; }
+as_fn_ret_success () { return 0; }
+as_fn_ret_failure () { return 1; }
+
+exitcode=0
+as_fn_success || { exitcode=1; echo as_fn_success failed.; }
+as_fn_failure && { exitcode=1; echo as_fn_failure succeeded.; }
+as_fn_ret_success || { exitcode=1; echo as_fn_ret_success failed.; }
+as_fn_ret_failure && { exitcode=1; echo as_fn_ret_failure succeeded.; }
+if ( set x; as_fn_ret_success y && test x = \"\$1\" ); then :
+
+else
+  exitcode=1; echo positional parameters were not saved.
+fi
+test x\$exitcode = x0 || exit 1
+test -x / || exit 1"
+  as_suggested="  as_lineno_1=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_1a=\$LINENO
+  as_lineno_2=";as_suggested=$as_suggested$LINENO;as_suggested=$as_suggested" as_lineno_2a=\$LINENO
+  eval 'test \"x\$as_lineno_1'\$as_run'\" != \"x\$as_lineno_2'\$as_run'\" &&
+  test \"x\`expr \$as_lineno_1'\$as_run' + 1\`\" = \"x\$as_lineno_2'\$as_run'\"' || exit 1
+test \$(( 1 + 1 )) = 2 || exit 1
+
+  test -n \"\${ZSH_VERSION+set}\${BASH_VERSION+set}\" || (
+    ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    ECHO=\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO\$ECHO
+    PATH=/empty FPATH=/empty; export PATH FPATH
+    test \"X\`printf %s \$ECHO\`\" = \"X\$ECHO\" \\
+      || test \"X\`print -r -- \$ECHO\`\" = \"X\$ECHO\" ) || exit 1"
+  if (eval "$as_required") 2>/dev/null; then :
+  as_have_required=yes
+else
+  as_have_required=no
+fi
+  if test x$as_have_required = xyes && (eval "$as_suggested") 2>/dev/null; then :
+
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+as_found=false
+for as_dir in /bin$PATH_SEPARATOR/usr/bin$PATH_SEPARATOR$PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+  as_found=:
+  case $as_dir in #(
+	 /*)
+	   for as_base in sh bash ksh sh5; do
+	     # Try only shells that exist, to save several forks.
+	     as_shell=$as_dir/$as_base
+	     if { test -f "$as_shell" || test -f "$as_shell.exe"; } &&
+		    { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  CONFIG_SHELL=$as_shell as_have_required=yes
+		   if { $as_echo "$as_bourne_compatible""$as_suggested" | as_run=a "$as_shell"; } 2>/dev/null; then :
+  break 2
+fi
+fi
+	   done;;
+       esac
+  as_found=false
+done
+$as_found || { if { test -f "$SHELL" || test -f "$SHELL.exe"; } &&
+	      { $as_echo "$as_bourne_compatible""$as_required" | as_run=a "$SHELL"; } 2>/dev/null; then :
+  CONFIG_SHELL=$SHELL as_have_required=yes
+fi; }
+IFS=$as_save_IFS
+
+
+      if test "x$CONFIG_SHELL" != x; then :
+  export CONFIG_SHELL
+             # We cannot yet assume a decent shell, so we have to provide a
+# neutralization value for shells without unset; and this also
+# works around shells that cannot unset nonexistent variables.
+# Preserve -v and -x to the replacement shell.
+BASH_ENV=/dev/null
+ENV=/dev/null
+(unset BASH_ENV) >/dev/null 2>&1 && unset BASH_ENV ENV
+case $- in # ((((
+  *v*x* | *x*v* ) as_opts=-vx ;;
+  *v* ) as_opts=-v ;;
+  *x* ) as_opts=-x ;;
+  * ) as_opts= ;;
+esac
+exec $CONFIG_SHELL $as_opts "$as_myself" ${1+"$@"}
+# Admittedly, this is quite paranoid, since all the known shells bail
+# out after a failed `exec'.
+$as_echo "$0: could not re-execute with $CONFIG_SHELL" >&2
+exit 255
+fi
+
+    if test x$as_have_required = xno; then :
+  $as_echo "$0: This script requires a shell more modern than all"
+  $as_echo "$0: the shells that I found on your system."
+  if test x${ZSH_VERSION+set} = xset ; then
+    $as_echo "$0: In particular, zsh $ZSH_VERSION has bugs and should"
+    $as_echo "$0: be upgraded to zsh 4.3.4 or later."
+  else
+    $as_echo "$0: Please tell bug-autoconf@gnu.org and
+$0: isl-development@googlegroups.com about your system,
+$0: including any error possibly output before this
+$0: message. Then install a modern shell, or manually run
+$0: the script under such a shell if you do have one."
+  fi
+  exit 1
+fi
+fi
+fi
+SHELL=${CONFIG_SHELL-/bin/sh}
+export SHELL
+# Unset more variables known to interfere with behavior of common tools.
+CLICOLOR_FORCE= GREP_OPTIONS=
+unset CLICOLOR_FORCE GREP_OPTIONS
+
+## --------------------- ##
+## M4sh Shell Functions. ##
+## --------------------- ##
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$as_dir" : 'X$//$^/' \| \
+	 X"$as_dir" : 'X$//$$' \| \
+	 X"$as_dir" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+# as_fn_error STATUS ERROR LINENO LOG_FD
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+if expr a : '$a$' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*$...$'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/$^/^/*$/*$' \| \
+	 X"$0" : 'X$//$$' \| \
+	 X"$0" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/$^/^/*$\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+
+  as_lineno_1=$LINENO as_lineno_1a=$LINENO
+  as_lineno_2=$LINENO as_lineno_2a=$LINENO
+  eval 'test "x$as_lineno_1'$as_run'" != "x$as_lineno_2'$as_run'" &&
+  test "x`expr $as_lineno_1'$as_run' + 1`" = "x$as_lineno_2'$as_run'"' || {
+  # Blame Lee E. McMahon (1931-1989) for sed's syntax.  :-)
+  sed -n '
+    p
+    /$LINENO/=
+  ' <$as_myself |
+    sed '
+      s/$LINENO.*/&-/
+      t lineno
+      b
+      :lineno
+      N
+      :loop
+      s/$LINENO$^'$as_cr_alnum'_.*\n$$.*$/\2\1\2/
+      t loop
+      s/-\n.*//
+    ' >$as_me.lineno &&
+  chmod +x "$as_me.lineno" ||
+    { $as_echo "$as_me: error: cannot create $as_me.lineno; rerun with a POSIX shell" >&2; as_fn_exit 1; }
+
+  # If we had to re-execute with $CONFIG_SHELL, we're ensured to have
+  # already done that, so ensure we don't try to do so again and fall
+  # in an infinite loop.  This has already happened in practice.
+  _as_can_reexec=no; export _as_can_reexec
+  # Don't try to exec as it changes $0, causing all sort of problems
+  # (the dirname of $0 is not the place where we might find the
+  # original and so on.  Autoconf is especially sensitive to this).
+  . "./$as_me.lineno"
+  # Exit status is that of the last command.
+  exit
+}
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%^_$as_cr_alnum%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%^_$as_cr_alnum%_%g'"
+
+SHELL=${CONFIG_SHELL-/bin/sh}
+
+
+test -n "$DJDIR" || exec 7<&0 </dev/null
+exec 6>&1
+
+# Name of the host.
+# hostname on some systems (SVR3.2, old GNU/Linux) returns a bogus exit status,
+# so uname gets run too.
+ac_hostname=`(hostname || uname -n) 2>/dev/null | sed 1q`
+
+#
+# Initializations.
+#
+ac_default_prefix=/usr/local
+ac_clean_files=
+ac_config_libobj_dir=.
+LIBOBJS=
+cross_compiling=no
+subdirs=
+MFLAGS=
+MAKEFLAGS=
+
+# Identity of this package.
+PACKAGE_NAME='isl-interface'
+PACKAGE_TARNAME='isl-interface'
+PACKAGE_VERSION='0'
+PACKAGE_STRING='isl-interface 0'
+PACKAGE_BUGREPORT='isl-development@googlegroups.com'
+PACKAGE_URL=''
+
+# Factoring default headers for most tests.
+ac_includes_default="\
+#include <stdio.h>
+#ifdef HAVE_SYS_TYPES_H
+# include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
+#ifdef STDC_HEADERS
+# include <stdlib.h>
+# include <stddef.h>
+#else
+# ifdef HAVE_STDLIB_H
+#  include <stdlib.h>
+# endif
+#endif
+#ifdef HAVE_STRING_H
+# if !defined STDC_HEADERS && defined HAVE_MEMORY_H
+#  include <memory.h>
+# endif
+# include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+#endif
+#ifdef HAVE_STDINT_H
+# include <stdint.h>
+#endif
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif"
+
+ac_subst_vars='am__EXEEXT_FALSE
+am__EXEEXT_TRUE
+LTLIBOBJS
+LIBOBJS
+CONFIG_STATUS_DEPENDENCIES
+XCODE_SELECT
+LLVM_CONFIG
+CLANG_LIBS
+CLANG_RFLAG
+CLANG_LDFLAGS
+CLANG_CXXFLAGS
+LT_SYS_LIBRARY_PATH
+OTOOL64
+OTOOL
+LIPO
+NMEDIT
+DSYMUTIL
+MANIFEST_TOOL
+RANLIB
+ac_ct_AR
+AR
+DLLTOOL
+OBJDUMP
+LN_S
+NM
+ac_ct_DUMPBIN
+DUMPBIN
+LD
+FGREP
+EGREP
+SED
+LIBTOOL
+HAVE_CXX11
+GREP
+CXXCPPFLAGS_FOR_BUILD
+CXXFLAGS_FOR_BUILD
+CXXCPP_FOR_BUILD
+ac_ct_CXX_FOR_BUILD
+CXX_FOR_BUILD
+host_os
+host_vendor
+host_cpu
+host
+CXXCPP
+LDFLAGS_FOR_BUILD
+CPPFLAGS_FOR_BUILD
+CFLAGS_FOR_BUILD
+BUILD_OBJEXT
+BUILD_EXEEXT
+CPP_FOR_BUILD
+ac_ct_CC_FOR_BUILD
+CC_FOR_BUILD
+build_os
+build_vendor
+build_cpu
+build
+CPP
+am__fastdepCC_FALSE
+am__fastdepCC_TRUE
+CCDEPMODE
+ac_ct_CC
+CFLAGS
+CC
+am__fastdepCXX_FALSE
+am__fastdepCXX_TRUE
+CXXDEPMODE
+am__nodep
+AMDEPBACKSLASH
+AMDEP_FALSE
+AMDEP_TRUE
+am__include
+DEPDIR
+OBJEXT
+EXEEXT
+ac_ct_CXX
+CPPFLAGS
+LDFLAGS
+CXXFLAGS
+CXX
+AM_BACKSLASH
+AM_DEFAULT_VERBOSITY
+AM_DEFAULT_V
+AM_V
+am__untar
+am__tar
+AMTAR
+am__leading_dot
+SET_MAKE
+AWK
+mkdir_p
+MKDIR_P
+INSTALL_STRIP_PROGRAM
+STRIP
+install_sh
+MAKEINFO
+AUTOHEADER
+AUTOMAKE
+AUTOCONF
+ACLOCAL
+VERSION
+PACKAGE
+CYGPATH_W
+am__isrc
+INSTALL_DATA
+INSTALL_SCRIPT
+INSTALL_PROGRAM
+target_alias
+host_alias
+build_alias
+LIBS
+ECHO_T
+ECHO_N
+ECHO_C
+DEFS
+mandir
+localedir
+libdir
+psdir
+pdfdir
+dvidir
+htmldir
+infodir
+docdir
+oldincludedir
+includedir
+runstatedir
+localstatedir
+sharedstatedir
+sysconfdir
+datadir
+datarootdir
+libexecdir
+sbindir
+bindir
+program_transform_name
+prefix
+exec_prefix
+PACKAGE_URL
+PACKAGE_BUGREPORT
+PACKAGE_STRING
+PACKAGE_VERSION
+PACKAGE_TARNAME
+PACKAGE_NAME
+PATH_SEPARATOR
+SHELL
+am__quote'
+ac_subst_files=''
+ac_user_opts='
+enable_option_checking
+enable_silent_rules
+enable_dependency_tracking
+enable_shared
+enable_static
+with_pic
+enable_fast_install
+with_aix_soname
+with_gnu_ld
+with_sysroot
+enable_libtool_lock
+'
+      ac_precious_vars='build_alias
+host_alias
+target_alias
+CXX
+CXXFLAGS
+LDFLAGS
+LIBS
+CPPFLAGS
+CCC
+CC
+CFLAGS
+CPP
+CXXCPP
+LT_SYS_LIBRARY_PATH'
+
+
+# Initialize some variables set by options.
+ac_init_help=
+ac_init_version=false
+ac_unrecognized_opts=
+ac_unrecognized_sep=
+# The variables have the same names as the options, with
+# dashes changed to underlines.
+cache_file=/dev/null
+exec_prefix=NONE
+no_create=
+no_recursion=
+prefix=NONE
+program_prefix=NONE
+program_suffix=NONE
+program_transform_name=s,x,x,
+silent=
+site=
+srcdir=
+verbose=
+x_includes=NONE
+x_libraries=NONE
+
+# Installation directory options.
+# These are left unexpanded so users can "make install exec_prefix=/foo"
+# and all the variables that are supposed to be based on exec_prefix
+# by default will actually change.
+# Use braces instead of parens because sh, perl, etc. also accept them.
+# (The list follows the same order as the GNU Coding Standards.)
+bindir='${exec_prefix}/bin'
+sbindir='${exec_prefix}/sbin'
+libexecdir='${exec_prefix}/libexec'
+datarootdir='${prefix}/share'
+datadir='${datarootdir}'
+sysconfdir='${prefix}/etc'
+sharedstatedir='${prefix}/com'
+localstatedir='${prefix}/var'
+runstatedir='${localstatedir}/run'
+includedir='${prefix}/include'
+oldincludedir='/usr/include'
+docdir='${datarootdir}/doc/${PACKAGE_TARNAME}'
+infodir='${datarootdir}/info'
+htmldir='${docdir}'
+dvidir='${docdir}'
+pdfdir='${docdir}'
+psdir='${docdir}'
+libdir='${exec_prefix}/lib'
+localedir='${datarootdir}/locale'
+mandir='${datarootdir}/man'
+
+ac_prev=
+ac_dashdash=
+for ac_option
+do
+  # If the previous option needs an argument, assign it.
+  if test -n "$ac_prev"; then
+    eval $ac_prev=\$ac_option
+    ac_prev=
+    continue
+  fi
+
+  case $ac_option in
+  *=?*) ac_optarg=`expr "X$ac_option" : '^=*=$.*$'` ;;
+  *=)   ac_optarg= ;;
+  *)    ac_optarg=yes ;;
+  esac
+
+  # Accept the important Cygnus configure options, so we can diagnose typos.
+
+  case $ac_dashdash$ac_option in
+  --)
+    ac_dashdash=yes ;;
+
+  -bindir | --bindir | --bindi | --bind | --bin | --bi)
+    ac_prev=bindir ;;
+  -bindir=* | --bindir=* | --bindi=* | --bind=* | --bin=* | --bi=*)
+    bindir=$ac_optarg ;;
+
+  -build | --build | --buil | --bui | --bu)
+    ac_prev=build_alias ;;
+  -build=* | --build=* | --buil=* | --bui=* | --bu=*)
+    build_alias=$ac_optarg ;;
+
+  -cache-file | --cache-file | --cache-fil | --cache-fi \
+  | --cache-f | --cache- | --cache | --cach | --cac | --ca | --c)
+    ac_prev=cache_file ;;
+  -cache-file=* | --cache-file=* | --cache-fil=* | --cache-fi=* \
+  | --cache-f=* | --cache-=* | --cache=* | --cach=* | --cac=* | --ca=* | --c=*)
+    cache_file=$ac_optarg ;;
+
+  --config-cache | -C)
+    cache_file=config.cache ;;
+
+  -datadir | --datadir | --datadi | --datad)
+    ac_prev=datadir ;;
+  -datadir=* | --datadir=* | --datadi=* | --datad=*)
+    datadir=$ac_optarg ;;
+
+  -datarootdir | --datarootdir | --datarootdi | --datarootd | --dataroot \
+  | --dataroo | --dataro | --datar)
+    ac_prev=datarootdir ;;
+  -datarootdir=* | --datarootdir=* | --datarootdi=* | --datarootd=* \
+  | --dataroot=* | --dataroo=* | --dataro=* | --datar=*)
+    datarootdir=$ac_optarg ;;
+
+  -disable-* | --disable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*disable-$.*$'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*^-+._$as_cr_alnum" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/-+./_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--disable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=no ;;
+
+  -docdir | --docdir | --docdi | --doc | --do)
+    ac_prev=docdir ;;
+  -docdir=* | --docdir=* | --docdi=* | --doc=* | --do=*)
+    docdir=$ac_optarg ;;
+
+  -dvidir | --dvidir | --dvidi | --dvid | --dvi | --dv)
+    ac_prev=dvidir ;;
+  -dvidir=* | --dvidir=* | --dvidi=* | --dvid=* | --dvi=* | --dv=*)
+    dvidir=$ac_optarg ;;
+
+  -enable-* | --enable-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*enable-$^=*$'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*^-+._$as_cr_alnum" >/dev/null &&
+      as_fn_error $? "invalid feature name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/-+./_/g'`
+    case $ac_user_opts in
+      *"
+"enable_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--enable-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval enable_$ac_useropt=\$ac_optarg ;;
+
+  -exec-prefix | --exec_prefix | --exec-prefix | --exec-prefi \
+  | --exec-pref | --exec-pre | --exec-pr | --exec-p | --exec- \
+  | --exec | --exe | --ex)
+    ac_prev=exec_prefix ;;
+  -exec-prefix=* | --exec_prefix=* | --exec-prefix=* | --exec-prefi=* \
+  | --exec-pref=* | --exec-pre=* | --exec-pr=* | --exec-p=* | --exec-=* \
+  | --exec=* | --exe=* | --ex=*)
+    exec_prefix=$ac_optarg ;;
+
+  -gas | --gas | --ga | --g)
+    # Obsolete; use --with-gas.
+    with_gas=yes ;;
+
+  -help | --help | --hel | --he | -h)
+    ac_init_help=long ;;
+  -help=r* | --help=r* | --hel=r* | --he=r* | -hr*)
+    ac_init_help=recursive ;;
+  -help=s* | --help=s* | --hel=s* | --he=s* | -hs*)
+    ac_init_help=short ;;
+
+  -host | --host | --hos | --ho)
+    ac_prev=host_alias ;;
+  -host=* | --host=* | --hos=* | --ho=*)
+    host_alias=$ac_optarg ;;
+
+  -htmldir | --htmldir | --htmldi | --htmld | --html | --htm | --ht)
+    ac_prev=htmldir ;;
+  -htmldir=* | --htmldir=* | --htmldi=* | --htmld=* | --html=* | --htm=* \
+  | --ht=*)
+    htmldir=$ac_optarg ;;
+
+  -includedir | --includedir | --includedi | --included | --include \
+  | --includ | --inclu | --incl | --inc)
+    ac_prev=includedir ;;
+  -includedir=* | --includedir=* | --includedi=* | --included=* | --include=* \
+  | --includ=* | --inclu=* | --incl=* | --inc=*)
+    includedir=$ac_optarg ;;
+
+  -infodir | --infodir | --infodi | --infod | --info | --inf)
+    ac_prev=infodir ;;
+  -infodir=* | --infodir=* | --infodi=* | --infod=* | --info=* | --inf=*)
+    infodir=$ac_optarg ;;
+
+  -libdir | --libdir | --libdi | --libd)
+    ac_prev=libdir ;;
+  -libdir=* | --libdir=* | --libdi=* | --libd=*)
+    libdir=$ac_optarg ;;
+
+  -libexecdir | --libexecdir | --libexecdi | --libexecd | --libexec \
+  | --libexe | --libex | --libe)
+    ac_prev=libexecdir ;;
+  -libexecdir=* | --libexecdir=* | --libexecdi=* | --libexecd=* | --libexec=* \
+  | --libexe=* | --libex=* | --libe=*)
+    libexecdir=$ac_optarg ;;
+
+  -localedir | --localedir | --localedi | --localed | --locale)
+    ac_prev=localedir ;;
+  -localedir=* | --localedir=* | --localedi=* | --localed=* | --locale=*)
+    localedir=$ac_optarg ;;
+
+  -localstatedir | --localstatedir | --localstatedi | --localstated \
+  | --localstate | --localstat | --localsta | --localst | --locals)
+    ac_prev=localstatedir ;;
+  -localstatedir=* | --localstatedir=* | --localstatedi=* | --localstated=* \
+  | --localstate=* | --localstat=* | --localsta=* | --localst=* | --locals=*)
+    localstatedir=$ac_optarg ;;
+
+  -mandir | --mandir | --mandi | --mand | --man | --ma | --m)
+    ac_prev=mandir ;;
+  -mandir=* | --mandir=* | --mandi=* | --mand=* | --man=* | --ma=* | --m=*)
+    mandir=$ac_optarg ;;
+
+  -nfp | --nfp | --nf)
+    # Obsolete; use --without-fp.
+    with_fp=no ;;
+
+  -no-create | --no-create | --no-creat | --no-crea | --no-cre \
+  | --no-cr | --no-c | -n)
+    no_create=yes ;;
+
+  -no-recursion | --no-recursion | --no-recursio | --no-recursi \
+  | --no-recurs | --no-recur | --no-recu | --no-rec | --no-re | --no-r)
+    no_recursion=yes ;;
+
+  -oldincludedir | --oldincludedir | --oldincludedi | --oldincluded \
+  | --oldinclude | --oldinclud | --oldinclu | --oldincl | --oldinc \
+  | --oldin | --oldi | --old | --ol | --o)
+    ac_prev=oldincludedir ;;
+  -oldincludedir=* | --oldincludedir=* | --oldincludedi=* | --oldincluded=* \
+  | --oldinclude=* | --oldinclud=* | --oldinclu=* | --oldincl=* | --oldinc=* \
+  | --oldin=* | --oldi=* | --old=* | --ol=* | --o=*)
+    oldincludedir=$ac_optarg ;;
+
+  -prefix | --prefix | --prefi | --pref | --pre | --pr | --p)
+    ac_prev=prefix ;;
+  -prefix=* | --prefix=* | --prefi=* | --pref=* | --pre=* | --pr=* | --p=*)
+    prefix=$ac_optarg ;;
+
+  -program-prefix | --program-prefix | --program-prefi | --program-pref \
+  | --program-pre | --program-pr | --program-p)
+    ac_prev=program_prefix ;;
+  -program-prefix=* | --program-prefix=* | --program-prefi=* \
+  | --program-pref=* | --program-pre=* | --program-pr=* | --program-p=*)
+    program_prefix=$ac_optarg ;;
+
+  -program-suffix | --program-suffix | --program-suffi | --program-suff \
+  | --program-suf | --program-su | --program-s)
+    ac_prev=program_suffix ;;
+  -program-suffix=* | --program-suffix=* | --program-suffi=* \
+  | --program-suff=* | --program-suf=* | --program-su=* | --program-s=*)
+    program_suffix=$ac_optarg ;;
+
+  -program-transform-name | --program-transform-name \
+  | --program-transform-nam | --program-transform-na \
+  | --program-transform-n | --program-transform- \
+  | --program-transform | --program-transfor \
+  | --program-transfo | --program-transf \
+  | --program-trans | --program-tran \
+  | --progr-tra | --program-tr | --program-t)
+    ac_prev=program_transform_name ;;
+  -program-transform-name=* | --program-transform-name=* \
+  | --program-transform-nam=* | --program-transform-na=* \
+  | --program-transform-n=* | --program-transform-=* \
+  | --program-transform=* | --program-transfor=* \
+  | --program-transfo=* | --program-transf=* \
+  | --program-trans=* | --program-tran=* \
+  | --progr-tra=* | --program-tr=* | --program-t=*)
+    program_transform_name=$ac_optarg ;;
+
+  -pdfdir | --pdfdir | --pdfdi | --pdfd | --pdf | --pd)
+    ac_prev=pdfdir ;;
+  -pdfdir=* | --pdfdir=* | --pdfdi=* | --pdfd=* | --pdf=* | --pd=*)
+    pdfdir=$ac_optarg ;;
+
+  -psdir | --psdir | --psdi | --psd | --ps)
+    ac_prev=psdir ;;
+  -psdir=* | --psdir=* | --psdi=* | --psd=* | --ps=*)
+    psdir=$ac_optarg ;;
+
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil)
+    silent=yes ;;
+
+  -runstatedir | --runstatedir | --runstatedi | --runstated \
+  | --runstate | --runstat | --runsta | --runst | --runs \
+  | --run | --ru | --r)
+    ac_prev=runstatedir ;;
+  -runstatedir=* | --runstatedir=* | --runstatedi=* | --runstated=* \
+  | --runstate=* | --runstat=* | --runsta=* | --runst=* | --runs=* \
+  | --run=* | --ru=* | --r=*)
+    runstatedir=$ac_optarg ;;
+
+  -sbindir | --sbindir | --sbindi | --sbind | --sbin | --sbi | --sb)
+    ac_prev=sbindir ;;
+  -sbindir=* | --sbindir=* | --sbindi=* | --sbind=* | --sbin=* \
+  | --sbi=* | --sb=*)
+    sbindir=$ac_optarg ;;
+
+  -sharedstatedir | --sharedstatedir | --sharedstatedi \
+  | --sharedstated | --sharedstate | --sharedstat | --sharedsta \
+  | --sharedst | --shareds | --shared | --share | --shar \
+  | --sha | --sh)
+    ac_prev=sharedstatedir ;;
+  -sharedstatedir=* | --sharedstatedir=* | --sharedstatedi=* \
+  | --sharedstated=* | --sharedstate=* | --sharedstat=* | --sharedsta=* \
+  | --sharedst=* | --shareds=* | --shared=* | --share=* | --shar=* \
+  | --sha=* | --sh=*)
+    sharedstatedir=$ac_optarg ;;
+
+  -site | --site | --sit)
+    ac_prev=site ;;
+  -site=* | --site=* | --sit=*)
+    site=$ac_optarg ;;
+
+  -srcdir | --srcdir | --srcdi | --srcd | --src | --sr)
+    ac_prev=srcdir ;;
+  -srcdir=* | --srcdir=* | --srcdi=* | --srcd=* | --src=* | --sr=*)
+    srcdir=$ac_optarg ;;
+
+  -sysconfdir | --sysconfdir | --sysconfdi | --sysconfd | --sysconf \
+  | --syscon | --sysco | --sysc | --sys | --sy)
+    ac_prev=sysconfdir ;;
+  -sysconfdir=* | --sysconfdir=* | --sysconfdi=* | --sysconfd=* | --sysconf=* \
+  | --syscon=* | --sysco=* | --sysc=* | --sys=* | --sy=*)
+    sysconfdir=$ac_optarg ;;
+
+  -target | --target | --targe | --targ | --tar | --ta | --t)
+    ac_prev=target_alias ;;
+  -target=* | --target=* | --targe=* | --targ=* | --tar=* | --ta=* | --t=*)
+    target_alias=$ac_optarg ;;
+
+  -v | -verbose | --verbose | --verbos | --verbo | --verb)
+    verbose=yes ;;
+
+  -version | --version | --versio | --versi | --vers | -V)
+    ac_init_version=: ;;
+
+  -with-* | --with-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*with-$^=*$'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*^-+._$as_cr_alnum" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/-+./_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--with-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=\$ac_optarg ;;
+
+  -without-* | --without-*)
+    ac_useropt=`expr "x$ac_option" : 'x-*without-$.*$'`
+    # Reject names that are not valid shell variable names.
+    expr "x$ac_useropt" : ".*^-+._$as_cr_alnum" >/dev/null &&
+      as_fn_error $? "invalid package name: $ac_useropt"
+    ac_useropt_orig=$ac_useropt
+    ac_useropt=`$as_echo "$ac_useropt" | sed 's/-+./_/g'`
+    case $ac_user_opts in
+      *"
+"with_$ac_useropt"
+"*) ;;
+      *) ac_unrecognized_opts="$ac_unrecognized_opts$ac_unrecognized_sep--without-$ac_useropt_orig"
+	 ac_unrecognized_sep=', ';;
+    esac
+    eval with_$ac_useropt=no ;;
+
+  --x)
+    # Obsolete; use --with-x.
+    with_x=yes ;;
+
+  -x-includes | --x-includes | --x-include | --x-includ | --x-inclu \
+  | --x-incl | --x-inc | --x-in | --x-i)
+    ac_prev=x_includes ;;
+  -x-includes=* | --x-includes=* | --x-include=* | --x-includ=* | --x-inclu=* \
+  | --x-incl=* | --x-inc=* | --x-in=* | --x-i=*)
+    x_includes=$ac_optarg ;;
+
+  -x-libraries | --x-libraries | --x-librarie | --x-librari \
+  | --x-librar | --x-libra | --x-libr | --x-lib | --x-li | --x-l)
+    ac_prev=x_libraries ;;
+  -x-libraries=* | --x-libraries=* | --x-librarie=* | --x-librari=* \
+  | --x-librar=* | --x-libra=* | --x-libr=* | --x-lib=* | --x-li=* | --x-l=*)
+    x_libraries=$ac_optarg ;;
+
+  -*) as_fn_error $? "unrecognized option: \`$ac_option'
+Try \`$0 --help' for more information"
+    ;;
+
+  *=*)
+    ac_envvar=`expr "x$ac_option" : 'x$^=*$='`
+    # Reject names that are not valid shell variable names.
+    case $ac_envvar in #(
+      '' | 0-9* | *!_$as_cr_alnum* )
+      as_fn_error $? "invalid variable name: \`$ac_envvar'" ;;
+    esac
+    eval $ac_envvar=\$ac_optarg
+    export $ac_envvar ;;
+
+  *)
+    # FIXME: should be removed in autoconf 3.0.
+    $as_echo "$as_me: WARNING: you should use --build, --host, --target" >&2
+    expr "x$ac_option" : ".*^-._$as_cr_alnum" >/dev/null &&
+      $as_echo "$as_me: WARNING: invalid host type: $ac_option" >&2
+    : "${build_alias=$ac_option} ${host_alias=$ac_option} ${target_alias=$ac_option}"
+    ;;
+
+  esac
+done
+
+if test -n "$ac_prev"; then
+  ac_option=--`echo $ac_prev | sed 's/_/-/g'`
+  as_fn_error $? "missing argument to $ac_option"
+fi
+
+if test -n "$ac_unrecognized_opts"; then
+  case $enable_option_checking in
+    no) ;;
+    fatal) as_fn_error $? "unrecognized options: $ac_unrecognized_opts" ;;
+    *)     $as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2 ;;
+  esac
+fi
+
+# Check all directory arguments for consistency.
+for ac_var in	exec_prefix prefix bindir sbindir libexecdir datarootdir \
+		datadir sysconfdir sharedstatedir localstatedir includedir \
+		oldincludedir docdir infodir htmldir dvidir pdfdir psdir \
+		libdir localedir mandir runstatedir
+do
+  eval ac_val=\$$ac_var
+  # Remove trailing slashes.
+  case $ac_val in
+    */ )
+      ac_val=`expr "X$ac_val" : 'X$.*^/$' \| "X$ac_val" : 'X$.*$'`
+      eval $ac_var=\$ac_val;;
+  esac
+  # Be sure to have absolute directory names.
+  case $ac_val in
+    \\/$* | ?:\\/* )  continue;;
+    NONE | '' ) case $ac_var in *prefix ) continue;; esac;;
+  esac
+  as_fn_error $? "expected an absolute directory name for --$ac_var: $ac_val"
+done
+
+# There might be people who depend on the old broken behavior: `$host'
+# used to hold the argument of --host etc.
+# FIXME: To remove some day.
+build=$build_alias
+host=$host_alias
+target=$target_alias
+
+# FIXME: To remove some day.
+if test "x$host_alias" != x; then
+  if test "x$build_alias" = x; then
+    cross_compiling=maybe
+  elif test "x$build_alias" != "x$host_alias"; then
+    cross_compiling=yes
+  fi
+fi
+
+ac_tool_prefix=
+test -n "$host_alias" && ac_tool_prefix=$host_alias-
+
+test "$silent" = yes && exec 6>/dev/null
+
+
+ac_pwd=`pwd` && test -n "$ac_pwd" &&
+ac_ls_di=`ls -di .` &&
+ac_pwd_ls_di=`cd "$ac_pwd" && ls -di .` ||
+  as_fn_error $? "working directory cannot be determined"
+test "X$ac_ls_di" = "X$ac_pwd_ls_di" ||
+  as_fn_error $? "pwd does not report name of working directory"
+
+
+# Find the source files, if location was not specified.
+if test -z "$srcdir"; then
+  ac_srcdir_defaulted=yes
+  # Try the directory containing this script, then the parent directory.
+  ac_confdir=`$as_dirname -- "$as_myself" ||
+$as_expr X"$as_myself" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$as_myself" : 'X$//$^/' \| \
+	 X"$as_myself" : 'X$//$$' \| \
+	 X"$as_myself" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$as_myself" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  srcdir=$ac_confdir
+  if test ! -r "$srcdir/$ac_unique_file"; then
+    srcdir=..
+  fi
+else
+  ac_srcdir_defaulted=no
+fi
+if test ! -r "$srcdir/$ac_unique_file"; then
+  test "$ac_srcdir_defaulted" = yes && srcdir="$ac_confdir or .."
+  as_fn_error $? "cannot find sources ($ac_unique_file) in $srcdir"
+fi
+ac_msg="sources are in $srcdir, but \`cd $srcdir' does not work"
+ac_abs_confdir=`(
+	cd "$srcdir" && test -r "./$ac_unique_file" || as_fn_error $? "$ac_msg"
+	pwd)`
+# When building in place, set srcdir=.
+if test "$ac_abs_confdir" = "$ac_pwd"; then
+  srcdir=.
+fi
+# Remove unnecessary trailing slashes from srcdir.
+# Double slashes in file names in object file debugging info
+# mess up M-x gdb in Emacs.
+case $srcdir in
+*/) srcdir=`expr "X$srcdir" : 'X$.*^/$' \| "X$srcdir" : 'X$.*$'`;;
+esac
+for ac_var in $ac_precious_vars; do
+  eval ac_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_env_${ac_var}_value=\$${ac_var}
+  eval ac_cv_env_${ac_var}_set=\${${ac_var}+set}
+  eval ac_cv_env_${ac_var}_value=\$${ac_var}
+done
+
+#
+# Report the --help message.
+#
+if test "$ac_init_help" = "long"; then
+  # Omit some internal or obsolete options to make the list less imposing.
+  # This message is too long to be a string in the A/UX 3.1 sh.
+  cat <<_ACEOF
+\`configure' configures isl-interface 0 to adapt to many kinds of systems.
+
+Usage: $0 OPTION... VAR=VALUE...
+
+To assign environment variables (e.g., CC, CFLAGS...), specify them as
+VAR=VALUE.  See below for descriptions of some of the useful variables.
+
+Defaults for the options are specified in brackets.
+
+Configuration:
+  -h, --help              display this help and exit
+      --help=short        display options specific to this package
+      --help=recursive    display the short help of all the included packages
+  -V, --version           display version information and exit
+  -q, --quiet, --silent   do not print \`checking ...' messages
+      --cache-file=FILE   cache test results in FILE disabled
+  -C, --config-cache      alias for \`--cache-file=config.cache'
+  -n, --no-create         do not create output files
+      --srcdir=DIR        find the sources in DIR configure dir or \`..'
+
+Installation directories:
+  --prefix=PREFIX         install architecture-independent files in PREFIX
+                          $ac_default_prefix
+  --exec-prefix=EPREFIX   install architecture-dependent files in EPREFIX
+                          PREFIX
+
+By default, \`make install' will install all the files in
+\`$ac_default_prefix/bin', \`$ac_default_prefix/lib' etc.  You can specify
+an installation prefix other than \`$ac_default_prefix' using \`--prefix',
+for instance \`--prefix=\$HOME'.
+
+For better control, use the options below.
+
+Fine tuning of the installation directories:
+  --bindir=DIR            user executables EPREFIX/bin
+  --sbindir=DIR           system admin executables EPREFIX/sbin
+  --libexecdir=DIR        program executables EPREFIX/libexec
+  --sysconfdir=DIR        read-only single-machine data PREFIX/etc
+  --sharedstatedir=DIR    modifiable architecture-independent data PREFIX/com
+  --localstatedir=DIR     modifiable single-machine data PREFIX/var
+  --runstatedir=DIR       modifiable per-process data LOCALSTATEDIR/run
+  --libdir=DIR            object code libraries EPREFIX/lib
+  --includedir=DIR        C header files PREFIX/include
+  --oldincludedir=DIR     C header files for non-gcc /usr/include
+  --datarootdir=DIR       read-only arch.-independent data root PREFIX/share
+  --datadir=DIR           read-only architecture-independent data DATAROOTDIR
+  --infodir=DIR           info documentation DATAROOTDIR/info
+  --localedir=DIR         locale-dependent data DATAROOTDIR/locale
+  --mandir=DIR            man documentation DATAROOTDIR/man
+  --docdir=DIR            documentation root DATAROOTDIR/doc/isl-interface
+  --htmldir=DIR           html documentation DOCDIR
+  --dvidir=DIR            dvi documentation DOCDIR
+  --pdfdir=DIR            pdf documentation DOCDIR
+  --psdir=DIR             ps documentation DOCDIR
+_ACEOF
+
+  cat <<\_ACEOF
+
+Program names:
+  --program-prefix=PREFIX            prepend PREFIX to installed program names
+  --program-suffix=SUFFIX            append SUFFIX to installed program names
+  --program-transform-name=PROGRAM   run sed PROGRAM on installed program names
+
+System types:
+  --build=BUILD     configure for building on BUILD guessed
+  --host=HOST       cross-compile to build programs to run on HOST BUILD
+_ACEOF
+fi
+
+if test -n "$ac_init_help"; then
+  case $ac_init_help in
+     short | recursive ) echo "Configuration of isl-interface 0:";;
+   esac
+  cat <<\_ACEOF
+
+Optional Features:
+  --disable-option-checking  ignore unrecognized --enable/--with options
+  --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
+  --enable-FEATURE=ARG  include FEATURE ARG=yes
+  --enable-silent-rules   less verbose build output (undo: "make V=1")
+  --disable-silent-rules  verbose build output (undo: "make V=0")
+  --enable-dependency-tracking
+                          do not reject slow dependency extractors
+  --disable-dependency-tracking
+                          speeds up one-time build
+  --enable-shared=PKGS  build shared libraries default=no
+  --enable-static=PKGS  build static libraries default=yes
+  --enable-fast-install=PKGS
+                          optimize for fast installation default=yes
+  --disable-libtool-lock  avoid locking (might break parallel builds)
+
+Optional Packages:
+  --with-PACKAGE=ARG    use PACKAGE ARG=yes
+  --without-PACKAGE       do not use PACKAGE (same as --with-PACKAGE=no)
+  --with-pic=PKGS       try to use only PIC/non-PIC objects default=use
+                          both
+  --with-aix-soname=aix|svr4|both
+                          shared library versioning (aka "SONAME") variant to
+                          provide on AIX, default=aix.
+  --with-gnu-ld           assume the C compiler uses GNU ld default=no
+  --with-sysroot=DIR    Search for dependent libraries within DIR (or the
+                          compiler's sysroot if not specified).
+
+Some influential environment variables:
+  CXX         C++ compiler command
+  CXXFLAGS    C++ compiler flags
+  LDFLAGS     linker flags, e.g. -L<lib dir> if you have libraries in a
+              nonstandard directory <lib dir>
+  LIBS        libraries to pass to the linker, e.g. -l<library>
+  CPPFLAGS    (Objective) C/C++ preprocessor flags, e.g. -I<include dir> if
+              you have headers in a nonstandard directory <include dir>
+  CC          C compiler command
+  CFLAGS      C compiler flags
+  CPP         C preprocessor
+  CXXCPP      C++ preprocessor
+  LT_SYS_LIBRARY_PATH
+              User-defined run-time library search path.
+
+Use these variables to override the choices made by `configure' or to help
+it to find libraries and programs with nonstandard names/locations.
+
+Report bugs to <isl-development@googlegroups.com>.
+_ACEOF
+ac_status=$?
+fi
+
+if test "$ac_init_help" = "recursive"; then
+  # If there are subdirs, report their specific --help.
+  for ac_dir in : $ac_subdirs_all; do test "x$ac_dir" = x: && continue
+    test -d "$ac_dir" ||
+      { cd "$srcdir" && ac_pwd=`pwd` && srcdir=. && test -d "$ac_dir"; } ||
+      continue
+    ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.\\/||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/^\\/*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  \\/* | ?:\\/* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+    cd "$ac_dir" || { ac_status=$?; continue; }
+    # Check for guested configure.
+    if test -f "$ac_srcdir/configure.gnu"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure.gnu" --help=recursive
+    elif test -f "$ac_srcdir/configure"; then
+      echo &&
+      $SHELL "$ac_srcdir/configure" --help=recursive
+    else
+      $as_echo "$as_me: WARNING: no configuration information is in $ac_dir" >&2
+    fi || ac_status=$?
+    cd "$ac_pwd" || { ac_status=$?; break; }
+  done
+fi
+
+test -n "$ac_init_help" && exit $ac_status
+if $ac_init_version; then
+  cat <<\_ACEOF
+isl-interface configure 0
+generated by GNU Autoconf 2.69
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This configure script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it.
+_ACEOF
+  exit
+fi
+
+## ------------------------ ##
+## Autoconf initialization. ##
+## ------------------------ ##
+
+# ac_fn_cxx_try_compile LINENO
+# ----------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_compile
+
+# ac_fn_c_try_compile LINENO
+# --------------------------
+# Try to compile conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext
+  if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest.$ac_objext; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_compile
+
+# ac_fn_c_try_cpp LINENO
+# ----------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_cpp
+
+# ac_fn_cxx_try_cpp LINENO
+# ------------------------
+# Try to preprocess conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_cpp ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_cpp conftest.$ac_ext"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_cpp conftest.$ac_ext") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } > conftest.i && {
+	 test -z "$ac_cxx_preproc_warn_flag$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+    ac_retval=1
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_cpp
+
+# ac_fn_c_try_link LINENO
+# -----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_c_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_c_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_link
+
+# ac_fn_c_check_header_compile LINENO HEADER VAR INCLUDES
+# -------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_c_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_header_compile
+
+# ac_fn_c_try_run LINENO
+# ----------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded. Assumes
+# that executables *can* be run.
+ac_fn_c_try_run ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && { ac_try='./conftest$ac_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: program exited with status $ac_status" >&5
+       $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+       ac_retval=$ac_status
+fi
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_c_try_run
+
+# ac_fn_c_check_func LINENO FUNC VAR
+# ----------------------------------
+# Tests whether FUNC exists, setting the cache variable VAR accordingly
+ac_fn_c_check_func ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+/* Define $2 to an innocuous variant, in case <limits.h> declares $2.
+   For example, HP-UX 11i <limits.h> declares gettimeofday.  */
+#define $2 innocuous_$2
+
+/* System header to define __stub macros and hopefully few prototypes,
+    which can conflict with char $2 (); below.
+    Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+    <limits.h> exists even on freestanding compilers.  */
+
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+
+#undef $2
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char $2 ();
+/* The GNU C library defines this for functions which it implements
+    to always fail with ENOSYS.  Some functions are actually named
+    something starting with __ and the normal name is an alias.  */
+#if defined __stub_$2 || defined __stub___$2
+choke me
+#endif
+
+int
+main ()
+{
+return $2 ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_c_check_func
+
+# ac_fn_cxx_try_link LINENO
+# -------------------------
+# Try to link conftest.$ac_ext, and return whether this succeeded.
+ac_fn_cxx_try_link ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  rm -f conftest.$ac_objext conftest$ac_exeext
+  if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    grep -v '^ *+' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+    mv -f conftest.er1 conftest.err
+  fi
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && {
+	 test -z "$ac_cxx_werror_flag" ||
+	 test ! -s conftest.err
+       } && test -s conftest$ac_exeext && {
+	 test "$cross_compiling" = yes ||
+	 test -x conftest$ac_exeext
+       }; then :
+  ac_retval=0
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+	ac_retval=1
+fi
+  # Delete the IPA/IPO (Inter Procedural Analysis/Optimization) information
+  # created by the PGI compiler (conftest_ipa8_conftest.oo), as it would
+  # interfere with the next link command; also delete a directory that is
+  # left behind by Apple's compiler.  We do this before executing the actions.
+  rm -rf conftest.dSYM conftest_ipa8_conftest.oo
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+  as_fn_set_status $ac_retval
+
+} # ac_fn_cxx_try_link
+
+# ac_fn_cxx_check_header_mongrel LINENO HEADER VAR INCLUDES
+# ---------------------------------------------------------
+# Tests whether HEADER exists, giving a warning if it cannot be compiled using
+# the include files in INCLUDES and setting the cache variable VAR
+# accordingly.
+ac_fn_cxx_check_header_mongrel ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  if eval \${$3+:} false; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+else
+  # Is the header compilable?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 usability" >&5
+$as_echo_n "checking $2 usability... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_header_compiler=yes
+else
+  ac_header_compiler=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_compiler" >&5
+$as_echo "$ac_header_compiler" >&6; }
+
+# Is the header present?
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking $2 presence" >&5
+$as_echo_n "checking $2 presence... " >&6; }
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <$2>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  ac_header_preproc=yes
+else
+  ac_header_preproc=no
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_header_preproc" >&5
+$as_echo "$ac_header_preproc" >&6; }
+
+# So?  What about this header?
+case $ac_header_compiler:$ac_header_preproc:$ac_cxx_preproc_warn_flag in #((
+  yes:no: )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&5
+$as_echo "$as_me: WARNING: $2: accepted by the compiler, rejected by the preprocessor!" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+    ;;
+  no:yes:* )
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: present but cannot be compiled" >&5
+$as_echo "$as_me: WARNING: $2: present but cannot be compiled" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     check for missing prerequisite headers?" >&5
+$as_echo "$as_me: WARNING: $2:     check for missing prerequisite headers?" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: see the Autoconf documentation" >&5
+$as_echo "$as_me: WARNING: $2: see the Autoconf documentation" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&5
+$as_echo "$as_me: WARNING: $2:     section \"Present But Cannot Be Compiled\"" >&2;}
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $2: proceeding with the compiler's result" >&5
+$as_echo "$as_me: WARNING: $2: proceeding with the compiler's result" >&2;}
+( $as_echo "## ----------------------------------------------- ##
+## Report this to isl-development@googlegroups.com ##
+## ----------------------------------------------- ##"
+     ) | sed "s/^/$as_me: WARNING:     /" >&2
+    ;;
+esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  eval "$3=\$ac_header_compiler"
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+fi
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_cxx_check_header_mongrel
+
+# ac_fn_cxx_check_header_compile LINENO HEADER VAR INCLUDES
+# ---------------------------------------------------------
+# Tests whether HEADER exists and can be compiled using the include files in
+# INCLUDES, setting the cache variable VAR accordingly.
+ac_fn_cxx_check_header_compile ()
+{
+  as_lineno=${as_lineno-"$1"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for $2" >&5
+$as_echo_n "checking for $2... " >&6; }
+if eval \${$3+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+$4
+#include <$2>
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  eval "$3=yes"
+else
+  eval "$3=no"
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+eval ac_res=\$$3
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+  eval $as_lineno_stack; ${as_lineno_stack:+:} unset as_lineno
+
+} # ac_fn_cxx_check_header_compile
+cat >config.log <<_ACEOF
+This file contains any messages produced by compilers while
+running configure, to aid debugging if configure makes a mistake.
+
+It was created by isl-interface $as_me 0, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  $ $0 $@
+
+_ACEOF
+exec 5>>config.log
+{
+cat <<_ASUNAME
+## --------- ##
+## Platform. ##
+## --------- ##
+
+hostname = `(hostname || uname -n) 2>/dev/null | sed 1q`
+uname -m = `(uname -m) 2>/dev/null || echo unknown`
+uname -r = `(uname -r) 2>/dev/null || echo unknown`
+uname -s = `(uname -s) 2>/dev/null || echo unknown`
+uname -v = `(uname -v) 2>/dev/null || echo unknown`
+
+/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null || echo unknown`
+/bin/uname -X     = `(/bin/uname -X) 2>/dev/null     || echo unknown`
+
+/bin/arch              = `(/bin/arch) 2>/dev/null              || echo unknown`
+/usr/bin/arch -k       = `(/usr/bin/arch -k) 2>/dev/null       || echo unknown`
+/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null || echo unknown`
+/usr/bin/hostinfo      = `(/usr/bin/hostinfo) 2>/dev/null      || echo unknown`
+/bin/machine           = `(/bin/machine) 2>/dev/null           || echo unknown`
+/usr/bin/oslevel       = `(/usr/bin/oslevel) 2>/dev/null       || echo unknown`
+/bin/universe          = `(/bin/universe) 2>/dev/null          || echo unknown`
+
+_ASUNAME
+
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    $as_echo "PATH: $as_dir"
+  done
+IFS=$as_save_IFS
+
+} >&5
+
+cat >&5 <<_ACEOF
+
+
+## ----------- ##
+## Core tests. ##
+## ----------- ##
+
+_ACEOF
+
+
+# Keep a trace of the command line.
+# Strip out --no-create and --no-recursion so they do not pile up.
+# Strip out --silent because we don't want to record it for future runs.
+# Also quote any args containing shell meta-characters.
+# Make two passes to allow for proper duplicate-argument suppression.
+ac_configure_args=
+ac_configure_args0=
+ac_configure_args1=
+ac_must_keep_next=false
+for ac_pass in 1 2
+do
+  for ac_arg
+  do
+    case $ac_arg in
+    -no-create | --no-c* | -n | -no-recursion | --no-r*) continue ;;
+    -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+    | -silent | --silent | --silen | --sile | --sil)
+      continue ;;
+    *\'*)
+      ac_arg=`$as_echo "$ac_arg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    case $ac_pass in
+    1) as_fn_append ac_configure_args0 " '$ac_arg'" ;;
+    2)
+      as_fn_append ac_configure_args1 " '$ac_arg'"
+      if test $ac_must_keep_next = true; then
+	ac_must_keep_next=false # Got value, back to normal.
+      else
+	case $ac_arg in
+	  *=* | --config-cache | -C | -disable-* | --disable-* \
+	  | -enable-* | --enable-* | -gas | --g* | -nfp | --nf* \
+	  | -q | -quiet | --q* | -silent | --sil* | -v | -verb* \
+	  | -with-* | --with-* | -without-* | --without-* | --x)
+	    case "$ac_configure_args0 " in
+	      "$ac_configure_args1"*" '$ac_arg' "* ) continue ;;
+	    esac
+	    ;;
+	  -* ) ac_must_keep_next=true ;;
+	esac
+      fi
+      as_fn_append ac_configure_args " '$ac_arg'"
+      ;;
+    esac
+  done
+done
+{ ac_configure_args0=; unset ac_configure_args0;}
+{ ac_configure_args1=; unset ac_configure_args1;}
+
+# When interrupted or exit'd, cleanup temporary files, and complete
+# config.log.  We remove comments because anyway the quotes in there
+# would cause problems or look ugly.
+# WARNING: Use '\'' to represent an apostrophe within the trap.
+# WARNING: Do not start the trap code with a newline, due to a FreeBSD 4.0 bug.
+trap 'exit_status=$?
+  # Save into config.log some information that might help in debugging.
+  {
+    echo
+
+    $as_echo "## ---------------- ##
+## Cache variables. ##
+## ---------------- ##"
+    echo
+    # The following way of writing the cache mishandles newlines in values,
+(
+  for ac_var in `(set) 2>&1 | sed -n '\''s/^$a-zA-Z_a-zA-Z0-9_*$=.*/\1/p'\''`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+  (set) 2>&1 |
+    case $as_nl`(ac_space='\'' '\''; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      sed -n \
+	"s/'\''/'\''\\\\'\'''\''/g;
+	  s/^\$_$as_cr_alnum*_cv__$as_cr_alnum*\$=\$.*\$/\\1='\''\\2'\''/p"
+      ;; #(
+    *)
+      sed -n "/^_$as_cr_alnum*_cv__$as_cr_alnum*=/p"
+      ;;
+    esac |
+    sort
+)
+    echo
+
+    $as_echo "## ----------------- ##
+## Output variables. ##
+## ----------------- ##"
+    echo
+    for ac_var in $ac_subst_vars
+    do
+      eval ac_val=\$$ac_var
+      case $ac_val in
+      *\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+      esac
+      $as_echo "$ac_var='\''$ac_val'\''"
+    done | sort
+    echo
+
+    if test -n "$ac_subst_files"; then
+      $as_echo "## ------------------- ##
+## File substitutions. ##
+## ------------------- ##"
+      echo
+      for ac_var in $ac_subst_files
+      do
+	eval ac_val=\$$ac_var
+	case $ac_val in
+	*\'\''*) ac_val=`$as_echo "$ac_val" | sed "s/'\''/'\''\\\\\\\\'\'''\''/g"`;;
+	esac
+	$as_echo "$ac_var='\''$ac_val'\''"
+      done | sort
+      echo
+    fi
+
+    if test -s confdefs.h; then
+      $as_echo "## ----------- ##
+## confdefs.h. ##
+## ----------- ##"
+      echo
+      cat confdefs.h
+      echo
+    fi
+    test "$ac_signal" != 0 &&
+      $as_echo "$as_me: caught signal $ac_signal"
+    $as_echo "$as_me: exit $exit_status"
+  } >&5
+  rm -f core *.core core.conftest.* &&
+    rm -f -r conftest* confdefs* conf$$* $ac_clean_files &&
+    exit $exit_status
+' 0
+for ac_signal in 1 2 13 15; do
+  trap 'ac_signal='$ac_signal'; as_fn_exit 1' $ac_signal
+done
+ac_signal=0
+
+# confdefs.h avoids OS command line length limits that DEFS can exceed.
+rm -f -r conftest* confdefs.h
+
+$as_echo "/* confdefs.h */" > confdefs.h
+
+# Predefined preprocessor variables.
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_NAME "$PACKAGE_NAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_TARNAME "$PACKAGE_TARNAME"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_VERSION "$PACKAGE_VERSION"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_STRING "$PACKAGE_STRING"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_BUGREPORT "$PACKAGE_BUGREPORT"
+_ACEOF
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE_URL "$PACKAGE_URL"
+_ACEOF
+
+
+# Let the site file select an alternate cache file if it wants to.
+# Prefer an explicitly selected file to automatically selected ones.
+ac_site_file1=NONE
+ac_site_file2=NONE
+if test -n "$CONFIG_SITE"; then
+  # We do not want a PATH search for config.site.
+  case $CONFIG_SITE in #((
+    -*)  ac_site_file1=./$CONFIG_SITE;;
+    */*) ac_site_file1=$CONFIG_SITE;;
+    *)   ac_site_file1=./$CONFIG_SITE;;
+  esac
+elif test "x$prefix" != xNONE; then
+  ac_site_file1=$prefix/share/config.site
+  ac_site_file2=$prefix/etc/config.site
+else
+  ac_site_file1=$ac_default_prefix/share/config.site
+  ac_site_file2=$ac_default_prefix/etc/config.site
+fi
+for ac_site_file in "$ac_site_file1" "$ac_site_file2"
+do
+  test "x$ac_site_file" = xNONE && continue
+  if test /dev/null != "$ac_site_file" && test -r "$ac_site_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading site script $ac_site_file" >&5
+$as_echo "$as_me: loading site script $ac_site_file" >&6;}
+    sed 's/^/| /' "$ac_site_file" >&5
+    . "$ac_site_file" \
+      || { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "failed to load site script $ac_site_file
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+done
+
+if test -r "$cache_file"; then
+  # Some versions of bash will fail to source /dev/null (special files
+  # actually), so we avoid doing that.  DJGPP emulates it as a regular file.
+  if test /dev/null != "$cache_file" && test -f "$cache_file"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: loading cache $cache_file" >&5
+$as_echo "$as_me: loading cache $cache_file" >&6;}
+    case $cache_file in
+      \\/* | ?:\\/* ) . "$cache_file";;
+      *)                      . "./$cache_file";;
+    esac
+  fi
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: creating cache $cache_file" >&5
+$as_echo "$as_me: creating cache $cache_file" >&6;}
+  >$cache_file
+fi
+
+# Check that the precious variables saved in the cache have kept the same
+# value.
+ac_cache_corrupted=false
+for ac_var in $ac_precious_vars; do
+  eval ac_old_set=\$ac_cv_env_${ac_var}_set
+  eval ac_new_set=\$ac_env_${ac_var}_set
+  eval ac_old_val=\$ac_cv_env_${ac_var}_value
+  eval ac_new_val=\$ac_env_${ac_var}_value
+  case $ac_old_set,$ac_new_set in
+    set,)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was set to \`$ac_old_val' in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,set)
+      { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' was not set in the previous run" >&5
+$as_echo "$as_me: error: \`$ac_var' was not set in the previous run" >&2;}
+      ac_cache_corrupted=: ;;
+    ,);;
+    *)
+      if test "x$ac_old_val" != "x$ac_new_val"; then
+	# differences in whitespace do not lead to failure.
+	ac_old_val_w=`echo x $ac_old_val`
+	ac_new_val_w=`echo x $ac_new_val`
+	if test "$ac_old_val_w" != "$ac_new_val_w"; then
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: error: \`$ac_var' has changed since the previous run:" >&5
+$as_echo "$as_me: error: \`$ac_var' has changed since the previous run:" >&2;}
+	  ac_cache_corrupted=:
+	else
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&5
+$as_echo "$as_me: warning: ignoring whitespace changes in \`$ac_var' since the previous run:" >&2;}
+	  eval $ac_var=\$ac_old_val
+	fi
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   former value:  \`$ac_old_val'" >&5
+$as_echo "$as_me:   former value:  \`$ac_old_val'" >&2;}
+	{ $as_echo "$as_me:${as_lineno-$LINENO}:   current value: \`$ac_new_val'" >&5
+$as_echo "$as_me:   current value: \`$ac_new_val'" >&2;}
+      fi;;
+  esac
+  # Pass precious variables to config.status.
+  if test "$ac_new_set" = set; then
+    case $ac_new_val in
+    *\'*) ac_arg=$ac_var=`$as_echo "$ac_new_val" | sed "s/'/'\\\\\\\\''/g"` ;;
+    *) ac_arg=$ac_var=$ac_new_val ;;
+    esac
+    case " $ac_configure_args " in
+      *" '$ac_arg' "*) ;; # Avoid dups.  Use of quotes ensures accuracy.
+      *) as_fn_append ac_configure_args " '$ac_arg'" ;;
+    esac
+  fi
+done
+if $ac_cache_corrupted; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+  { $as_echo "$as_me:${as_lineno-$LINENO}: error: changes in the environment can compromise the build" >&5
+$as_echo "$as_me: error: changes in the environment can compromise the build" >&2;}
+  as_fn_error $? "run \`make distclean' and/or \`rm $cache_file' and start over" "$LINENO" 5
+fi
+## -------------------- ##
+## Main body of script. ##
+## -------------------- ##
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+ac_aux_dir=
+for ac_dir in . "$srcdir"/.; do
+  if test -f "$ac_dir/install-sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install-sh -c"
+    break
+  elif test -f "$ac_dir/install.sh"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/install.sh -c"
+    break
+  elif test -f "$ac_dir/shtool"; then
+    ac_aux_dir=$ac_dir
+    ac_install_sh="$ac_aux_dir/shtool install -c"
+    break
+  fi
+done
+if test -z "$ac_aux_dir"; then
+  as_fn_error $? "cannot find install-sh, install.sh, or shtool in . \"$srcdir\"/." "$LINENO" 5
+fi
+
+# These three variables are undocumented and unsupported,
+# and are intended to be withdrawn in a future Autoconf release.
+# They can cause serious problems if a builder's source tree is in a directory
+# whose full name contains unusual characters.
+ac_config_guess="$SHELL $ac_aux_dir/config.guess"  # Please don't use this var.
+ac_config_sub="$SHELL $ac_aux_dir/config.sub"  # Please don't use this var.
+ac_configure="$SHELL $ac_aux_dir/configure"  # Please don't use this var.
+
+
+
+am__api_version='1.16'
+
+# Find a good install program.  We prefer a C program (faster),
+# so one script is as good as another.  But avoid the broken or
+# incompatible versions:
+# SysV /etc/install, /usr/sbin/install
+# SunOS /usr/etc/install
+# IRIX /sbin/install
+# AIX /bin/install
+# AmigaOS /C/install, which installs bootblocks on floppy discs
+# AIX 4 /usr/bin/installbsd, which doesn't work without a -g flag
+# AFS /usr/afsws/bin/install, which mishandles nonexistent args
+# SVR4 /usr/ucb/install, which tries to use the nonexistent group "staff"
+# OS/2's system install, which has a completely different semantic
+# ./install, which can be erroneously created by make from ./install.sh.
+# Reject install programs that cannot install multiple files.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a BSD-compatible install" >&5
+$as_echo_n "checking for a BSD-compatible install... " >&6; }
+if test -z "$INSTALL"; then
+if ${ac_cv_path_install+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    # Account for people who put trailing slashes in PATH elements.
+case $as_dir/ in #((
+  ./ | .// | /cC/* | \
+  /etc/* | /usr/sbin/* | /usr/etc/* | /sbin/* | /usr/afsws/bin/* | \
+  ?:\\/os2\\/install\\/* | ?:\\/OS2\\/INSTALL\\/* | \
+  /usr/ucb/* ) ;;
+  *)
+    # OSF1 and SCO ODT 3.0 have their own names for install.
+    # Don't use installbsd from OSF since it installs stuff as root
+    # by default.
+    for ac_prog in ginstall scoinst install; do
+      for ac_exec_ext in '' $ac_executable_extensions; do
+	if as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext"; then
+	  if test $ac_prog = install &&
+	    grep dspmsg "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # AIX install.  It has an incompatible calling convention.
+	    :
+	  elif test $ac_prog = install &&
+	    grep pwplus "$as_dir/$ac_prog$ac_exec_ext" >/dev/null 2>&1; then
+	    # program-specific install script used by HP pwplus--don't use.
+	    :
+	  else
+	    rm -rf conftest.one conftest.two conftest.dir
+	    echo one > conftest.one
+	    echo two > conftest.two
+	    mkdir conftest.dir
+	    if "$as_dir/$ac_prog$ac_exec_ext" -c conftest.one conftest.two "`pwd`/conftest.dir" &&
+	      test -s conftest.one && test -s conftest.two &&
+	      test -s conftest.dir/conftest.one &&
+	      test -s conftest.dir/conftest.two
+	    then
+	      ac_cv_path_install="$as_dir/$ac_prog$ac_exec_ext -c"
+	      break 3
+	    fi
+	  fi
+	fi
+      done
+    done
+    ;;
+esac
+
+  done
+IFS=$as_save_IFS
+
+rm -rf conftest.one conftest.two conftest.dir
+
+fi
+  if test "${ac_cv_path_install+set}" = set; then
+    INSTALL=$ac_cv_path_install
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for INSTALL within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    INSTALL=$ac_install_sh
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $INSTALL" >&5
+$as_echo "$INSTALL" >&6; }
+
+# Use test -z because SunOS4 sh mishandles braces in ${var-val}.
+# It thinks the first close brace ends the variable substitution.
+test -z "$INSTALL_PROGRAM" && INSTALL_PROGRAM='${INSTALL}'
+
+test -z "$INSTALL_SCRIPT" && INSTALL_SCRIPT='${INSTALL}'
+
+test -z "$INSTALL_DATA" && INSTALL_DATA='${INSTALL} -m 644'
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether build environment is sane" >&5
+$as_echo_n "checking whether build environment is sane... " >&6; }
+# Reject unsafe characters in $srcdir or the absolute working directory
+# name.  Accept space and tab only in the latter.
+am_lf='
+'
+case `pwd` in
+  *\\\"\#\$\&\'\`$am_lf*)
+    as_fn_error $? "unsafe absolute working directory name" "$LINENO" 5;;
+esac
+case $srcdir in
+  *\\\"\#\$\&\'\`$am_lf\ \	*)
+    as_fn_error $? "unsafe srcdir value: '$srcdir'" "$LINENO" 5;;
+esac
+
+# Do 'set' in a subshell so we don't clobber the current shell's
+# arguments.  Must try -L first in case configure is actually a
+# symlink; some systems play weird games with the mod time of symlinks
+# (eg FreeBSD returns the mod time of the symlink's containing
+# directory).
+if (
+   am_has_slept=no
+   for am_try in 1 2; do
+     echo "timestamp, slept: $am_has_slept" > conftest.file
+     set X `ls -Lt "$srcdir/configure" conftest.file 2> /dev/null`
+     if test "$*" = "X"; then
+	# -L didn't work.
+	set X `ls -t "$srcdir/configure" conftest.file`
+     fi
+     if test "$*" != "X $srcdir/configure conftest.file" \
+	&& test "$*" != "X conftest.file $srcdir/configure"; then
+
+	# If neither matched, then we have a broken ls.  This can happen
+	# if, for instance, CONFIG_SHELL is bash and it inherits a
+	# broken ls alias from the environment.  This has actually
+	# happened.  Such a system could not be considered "sane".
+	as_fn_error $? "ls -t appears to fail.  Make sure there is not a broken
+  alias in your environment" "$LINENO" 5
+     fi
+     if test "$2" = conftest.file || test $am_try -eq 2; then
+       break
+     fi
+     # Just in case.
+     sleep 1
+     am_has_slept=yes
+   done
+   test "$2" = conftest.file
+   )
+then
+   # Ok.
+   :
+else
+   as_fn_error $? "newly created file is older than distributed files!
+Check your system clock" "$LINENO" 5
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+# If we didn't sleep, we still need to ensure time stamps of config.status and
+# generated files are strictly newer.
+am_sleep_pid=
+if grep 'slept: no' conftest.file >/dev/null 2>&1; then
+  ( sleep 1 ) &
+  am_sleep_pid=$!
+fi
+
+rm -f conftest.file
+
+test "$program_prefix" != NONE &&
+  program_transform_name="s&^&$program_prefix&;$program_transform_name"
+# Use a double $ so make ignores it.
+test "$program_suffix" != NONE &&
+  program_transform_name="s&\$&$program_suffix&;$program_transform_name"
+# Double any \ or $.
+# By default was `s,x,x', remove it if useless.
+ac_script='s/\\$/&&/g;s/;s,x,x,$//'
+program_transform_name=`$as_echo "$program_transform_name" | sed "$ac_script"`
+
+# Expand $ac_aux_dir to an absolute path.
+am_aux_dir=`cd "$ac_aux_dir" && pwd`
+
+if test x"${MISSING+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    MISSING="\${SHELL} \"$am_aux_dir/missing\"" ;;
+  *)
+    MISSING="\${SHELL} $am_aux_dir/missing" ;;
+  esac
+fi
+# Use eval to expand $SHELL
+if eval "$MISSING --is-lightweight"; then
+  am_missing_run="$MISSING "
+else
+  am_missing_run=
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: 'missing' script is too old or missing" >&5
+$as_echo "$as_me: WARNING: 'missing' script is too old or missing" >&2;}
+fi
+
+if test x"${install_sh+set}" != xset; then
+  case $am_aux_dir in
+  *\ * | *\	*)
+    install_sh="\${SHELL} '$am_aux_dir/install-sh'" ;;
+  *)
+    install_sh="\${SHELL} $am_aux_dir/install-sh"
+  esac
+fi
+
+# Installed binaries are usually stripped using 'strip' when the user
+# run "make install-strip".  However 'strip' might not be the right
+# tool to use in cross-compilation environments, therefore Automake
+# will honor the 'STRIP' environment variable to overrule this program.
+if test "$cross_compiling" != no; then
+  if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+fi
+INSTALL_STRIP_PROGRAM="\$(install_sh) -c -s"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a thread-safe mkdir -p" >&5
+$as_echo_n "checking for a thread-safe mkdir -p... " >&6; }
+if test -z "$MKDIR_P"; then
+  if ${ac_cv_path_mkdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/opt/sfw/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in mkdir gmkdir; do
+	 for ac_exec_ext in '' $ac_executable_extensions; do
+	   as_fn_executable_p "$as_dir/$ac_prog$ac_exec_ext" || continue
+	   case `"$as_dir/$ac_prog$ac_exec_ext" --version 2>&1` in #(
+	     'mkdir (GNU coreutils) '* | \
+	     'mkdir (coreutils) '* | \
+	     'mkdir (fileutils) '4.1*)
+	       ac_cv_path_mkdir=$as_dir/$ac_prog$ac_exec_ext
+	       break 3;;
+	   esac
+	 done
+       done
+  done
+IFS=$as_save_IFS
+
+fi
+
+  test -d ./--version && rmdir ./--version
+  if test "${ac_cv_path_mkdir+set}" = set; then
+    MKDIR_P="$ac_cv_path_mkdir -p"
+  else
+    # As a last resort, use the slow shell script.  Don't cache a
+    # value for MKDIR_P within a source directory, because that will
+    # break other packages using the cache if that directory is
+    # removed, or if the value is a relative name.
+    MKDIR_P="$ac_install_sh -d"
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $MKDIR_P" >&5
+$as_echo "$MKDIR_P" >&6; }
+
+for ac_prog in gawk mawk nawk awk
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AWK+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AWK"; then
+  ac_cv_prog_AWK="$AWK" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AWK="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AWK=$ac_cv_prog_AWK
+if test -n "$AWK"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AWK" >&5
+$as_echo "$AWK" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$AWK" && break
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} sets \$(MAKE)" >&5
+$as_echo_n "checking whether ${MAKE-make} sets \$(MAKE)... " >&6; }
+set x ${MAKE-make}
+ac_make=`$as_echo "$2" | sed 's/+/p/g; s/^a-zA-Z0-9_/_/g'`
+if eval \${ac_cv_prog_make_${ac_make}_set+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat >conftest.make <<\_ACEOF
+SHELL = /bin/sh
+all:
+	@echo '@@@%%%=$(MAKE)=@@@%%%'
+_ACEOF
+# GNU make sometimes prints "make1: Entering ...", which would confuse us.
+case `${MAKE-make} -f conftest.make 2>/dev/null` in
+  *@@@%%%=?*=@@@%%%*)
+    eval ac_cv_prog_make_${ac_make}_set=yes;;
+  *)
+    eval ac_cv_prog_make_${ac_make}_set=no;;
+esac
+rm -f conftest.make
+fi
+if eval test \$ac_cv_prog_make_${ac_make}_set = yes; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+  SET_MAKE=
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+  SET_MAKE="MAKE=${MAKE-make}"
+fi
+
+rm -rf .tst 2>/dev/null
+mkdir .tst 2>/dev/null
+if test -d .tst; then
+  am__leading_dot=.
+else
+  am__leading_dot=_
+fi
+rmdir .tst 2>/dev/null
+
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+  enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=1;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+    AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+if test "`cd $srcdir && pwd`" != "`pwd`"; then
+  # Use -I$(srcdir) only when $(srcdir) != ., so that make's output
+  # is not polluted with repeated "-I."
+  am__isrc=' -I$(srcdir)'
+  # test to see if srcdir already configured
+  if test -f $srcdir/config.status; then
+    as_fn_error $? "source directory already configured; run \"make distclean\" there first" "$LINENO" 5
+  fi
+fi
+
+# test whether we have cygpath
+if test -z "$CYGPATH_W"; then
+  if (cygpath --version) >/dev/null 2>/dev/null; then
+    CYGPATH_W='cygpath -w'
+  else
+    CYGPATH_W=echo
+  fi
+fi
+
+
+# Define the identity of the package.
+ PACKAGE='isl-interface'
+ VERSION='0'
+
+
+cat >>confdefs.h <<_ACEOF
+#define PACKAGE "$PACKAGE"
+_ACEOF
+
+
+cat >>confdefs.h <<_ACEOF
+#define VERSION "$VERSION"
+_ACEOF
+
+# Some tools Automake needs.
+
+ACLOCAL=${ACLOCAL-"${am_missing_run}aclocal-${am__api_version}"}
+
+
+AUTOCONF=${AUTOCONF-"${am_missing_run}autoconf"}
+
+
+AUTOMAKE=${AUTOMAKE-"${am_missing_run}automake-${am__api_version}"}
+
+
+AUTOHEADER=${AUTOHEADER-"${am_missing_run}autoheader"}
+
+
+MAKEINFO=${MAKEINFO-"${am_missing_run}makeinfo"}
+
+# For better backward compatibility.  To be removed once Automake 1.9.x
+# dies out for good.  For more background, see:
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00001.html>
+# <https://lists.gnu.org/archive/html/automake/2012-07/msg00014.html>
+mkdir_p='$(MKDIR_P)'
+
+# We need awk for the "check" target (and possibly the TAP driver).  The
+# system "awk" is bad on some platforms.
+# Always define AMTAR for backward compatibility.  Yes, it's still used
+# in the wild :-(  We should find a proper way to deprecate it ...
+AMTAR='$${TAR-tar}'
+
+
+# We'll loop over all known methods to create a tar archive until one works.
+_am_tools='gnutar  pax cpio none'
+
+am__tar='$${TAR-tar} chof - "$$tardir"' am__untar='$${TAR-tar} xf -'
+
+
+
+
+
+
+# POSIX will say in a future version that running "rm -f" with no argument
+# is OK; and we want to be able to make that assumption in our Makefile
+# recipes.  So use an aggressive probe to check that the usage we want is
+# actually supported "in the wild" to an acceptable degree.
+# See automake bug#10828.
+# To make any issue more visible, cause the running configure to be aborted
+# by default if the 'rm' program in use doesn't match our expectations; the
+# user can still override this though.
+if rm -f && rm -fr && rm -rf; then : OK; else
+  cat >&2 <<'END'
+Oops!
+
+Your 'rm' program seems unable to run without file operands specified
+on the command line, even when the '-f' option is present.  This is contrary
+to the behaviour of most rm programs out there, and not conforming with
+the upcoming POSIX standard: <http://austingroupbugs.net/view.php?id=542>
+
+Please tell bug-automake@gnu.org about your system, including the value
+of your $PATH and any error possibly output before this message.  This
+can help us improve future automake versions.
+
+END
+  if test x"$ACCEPT_INFERIOR_RM_PROGRAM" = x"yes"; then
+    echo 'Configuration will proceed anyway, since you have set the' >&2
+    echo 'ACCEPT_INFERIOR_RM_PROGRAM variable to "yes"' >&2
+    echo >&2
+  else
+    cat >&2 <<'END'
+Aborting the configuration process, to ensure you take notice of the issue.
+
+You can download and install GNU coreutils to get an 'rm' implementation
+that behaves properly: <https://www.gnu.org/software/coreutils/>.
+
+If you want to complete the configuration process using your problematic
+'rm' anyway, export the environment variable ACCEPT_INFERIOR_RM_PROGRAM
+to "yes", and re-run configure.
+
+END
+    as_fn_error $? "Your 'rm' program is bad, sorry." "$LINENO" 5
+  fi
+fi
+
+# Check whether --enable-silent-rules was given.
+if test "${enable_silent_rules+set}" = set; then :
+  enableval=$enable_silent_rules;
+fi
+
+case $enable_silent_rules in # (((
+  yes) AM_DEFAULT_VERBOSITY=0;;
+   no) AM_DEFAULT_VERBOSITY=1;;
+    *) AM_DEFAULT_VERBOSITY=0;;
+esac
+am_make=${MAKE-make}
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $am_make supports nested variables" >&5
+$as_echo_n "checking whether $am_make supports nested variables... " >&6; }
+if ${am_cv_make_support_nested_variables+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if $as_echo 'TRUE=$(BAR$(V))
+BAR0=false
+BAR1=true
+V=1
+am__doit:
+	@$(TRUE)
+.PHONY: am__doit' | $am_make -f - >/dev/null 2>&1; then
+  am_cv_make_support_nested_variables=yes
+else
+  am_cv_make_support_nested_variables=no
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_make_support_nested_variables" >&5
+$as_echo "$am_cv_make_support_nested_variables" >&6; }
+if test $am_cv_make_support_nested_variables = yes; then
+    AM_V='$(V)'
+  AM_DEFAULT_V='$(AM_DEFAULT_VERBOSITY)'
+else
+  AM_V=$AM_DEFAULT_VERBOSITY
+  AM_DEFAULT_V=$AM_DEFAULT_VERBOSITY
+fi
+AM_BACKSLASH='\'
+
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -z "$CXX"; then
+  if test -n "$CCC"; then
+    CXX=$CCC
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CXX"; then
+  ac_cv_prog_CXX="$CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CXX="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CXX=$ac_cv_prog_CXX
+if test -n "$CXX"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX" >&5
+$as_echo "$CXX" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CXX" && break
+  done
+fi
+if test -z "$CXX"; then
+  ac_ct_CXX=$CXX
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CXX"; then
+  ac_cv_prog_ac_ct_CXX="$ac_ct_CXX" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CXX="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CXX=$ac_cv_prog_ac_ct_CXX
+if test -n "$ac_ct_CXX"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX" >&5
+$as_echo "$ac_ct_CXX" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CXX" && break
+done
+
+  if test "x$ac_ct_CXX" = x; then
+    CXX="g++"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CXX=$ac_ct_CXX
+  fi
+fi
+
+  fi
+fi
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C++ compiler works" >&5
+$as_echo_n "checking whether the C++ compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest^ *//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    ab.out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_exeext+set}" = set && test "$ac_cv_exeext" != no;
+	then :; else
+	   ac_cv_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_exeext" = no && ac_cv_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C++ compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler default output file name" >&5
+$as_echo_n "checking for C++ compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_exeext=$ac_cv_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_exeext" >&5
+$as_echo "$ac_cv_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+EXEEXT=$ac_cv_exeext
+ac_exeext=$EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling=no
+  else
+    if test "$cross_compiling" = maybe; then
+	cross_compiling=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C++ compiled programs.
+If you meant to cross compile, use \`--host'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling" >&5
+$as_echo "$cross_compiling" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_objext=`expr "$ac_file" : '.*\.$.*$'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_objext" >&5
+$as_echo "$ac_cv_objext" >&6; }
+OBJEXT=$ac_cv_objext
+ac_objext=$OBJEXT
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
+$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
+if ${ac_cv_cxx_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
+$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GXX=yes
+else
+  GXX=
+fi
+ac_test_CXXFLAGS=${CXXFLAGS+set}
+ac_save_CXXFLAGS=$CXXFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX accepts -g" >&5
+$as_echo_n "checking whether $CXX accepts -g... " >&6; }
+if ${ac_cv_prog_cxx_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+   ac_cxx_werror_flag=yes
+   ac_cv_prog_cxx_g=no
+   CXXFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_cv_prog_cxx_g=yes
+else
+  CXXFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+else
+  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+	 CXXFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_cv_prog_cxx_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cxx_g" >&5
+$as_echo "$ac_cv_prog_cxx_g" >&6; }
+if test "$ac_test_CXXFLAGS" = set; then
+  CXXFLAGS=$ac_save_CXXFLAGS
+elif test $ac_cv_prog_cxx_g = yes; then
+  if test "$GXX" = yes; then
+    CXXFLAGS="-g -O2"
+  else
+    CXXFLAGS="-g"
+  fi
+else
+  if test "$GXX" = yes; then
+    CXXFLAGS="-O2"
+  else
+    CXXFLAGS=
+  fi
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+DEPDIR="${am__leading_dot}deps"
+
+ac_config_commands="$ac_config_commands depfiles"
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ${MAKE-make} supports the include directive" >&5
+$as_echo_n "checking whether ${MAKE-make} supports the include directive... " >&6; }
+cat > confinc.mk << 'END'
+am__doit:
+	@echo this is the am__doit target >confinc.out
+.PHONY: am__doit
+END
+am__include="#"
+am__quote=
+# BSD make does it like this.
+echo '.include "confinc.mk" # ignored' > confmf.BSD
+# Other make implementations (GNU, Solaris 10, AIX) do it like this.
+echo 'include confinc.mk # ignored' > confmf.GNU
+_am_result=no
+for s in GNU BSD; do
+  { echo "$as_me:$LINENO: ${MAKE-make} -f confmf.$s && cat confinc.out" >&5
+   (${MAKE-make} -f confmf.$s && cat confinc.out) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); }
+  case $?:`cat confinc.out 2>/dev/null` in #(
+  '0:this is the am__doit target') :
+    case $s in #(
+  BSD) :
+    am__include='.include' am__quote='"' ;; #(
+  *) :
+    am__include='include' am__quote='' ;;
+esac ;; #(
+  *) :
+     ;;
+esac
+  if test "$am__include" != "#"; then
+    _am_result="yes ($s style)"
+    break
+  fi
+done
+rm -f confinc.* confmf.*
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: ${_am_result}" >&5
+$as_echo "${_am_result}" >&6; }
+
+# Check whether --enable-dependency-tracking was given.
+if test "${enable_dependency_tracking+set}" = set; then :
+  enableval=$enable_dependency_tracking;
+fi
+
+if test "x$enable_dependency_tracking" != xno; then
+  am_depcomp="$ac_aux_dir/depcomp"
+  AMDEPBACKSLASH='\'
+  am__nodep='_no'
+fi
+ if test "x$enable_dependency_tracking" != xno; then
+  AMDEP_TRUE=
+  AMDEP_FALSE='#'
+else
+  AMDEP_TRUE='#'
+  AMDEP_FALSE=
+fi
+
+
+
+depcc="$CXX"  am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CXX_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CXX_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CXX_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CXX_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
+CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
+  am__fastdepCXX_TRUE=
+  am__fastdepCXX_FALSE='#'
+else
+  am__fastdepCXX_TRUE='#'
+  am__fastdepCXX_FALSE=
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC"; then
+  ac_ct_CC=$CC
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+else
+  CC="$ac_cv_prog_CC"
+fi
+
+if test -z "$CC"; then
+          if test -n "$ac_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="${ac_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC"; then
+  if test -n "$ac_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC"; then
+  ac_cv_prog_CC="$CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC=$ac_cv_prog_CC
+if test -n "$CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC" >&5
+$as_echo "$CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC" && break
+  done
+fi
+if test -z "$CC"; then
+  ac_ct_CC=$CC
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC"; then
+  ac_cv_prog_ac_ct_CC="$ac_ct_CC" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC=$ac_cv_prog_ac_ct_CC
+if test -n "$ac_ct_CC"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC" >&5
+$as_echo "$ac_ct_CC" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC" && break
+done
+
+  if test "x$ac_ct_CC" = x; then
+    CC=""
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC=$ac_ct_CC
+  fi
+fi
+
+fi
+
+
+test -z "$CC" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC=yes
+else
+  GCC=
+fi
+ac_test_CFLAGS=${CFLAGS+set}
+ac_save_CFLAGS=$CFLAGS
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC accepts -g" >&5
+$as_echo_n "checking whether $CC accepts -g... " >&6; }
+if ${ac_cv_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_prog_cc_g=no
+   CFLAGS="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+else
+  CFLAGS=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_g" >&5
+$as_echo "$ac_cv_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS=$ac_save_CFLAGS
+elif test $ac_cv_prog_cc_g = yes; then
+  if test "$GCC" = yes; then
+    CFLAGS="-g -O2"
+  else
+    CFLAGS="-g"
+  fi
+else
+  if test "$GCC" = yes; then
+    CFLAGS="-O2"
+  else
+    CFLAGS=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return pi;
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array '\x00' == 0 ? 1 : -1;
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_arrayFOO(a) == 'x' ? 1 : -1;
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv0  ||  f (e, argv, 1) != argv1;
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+  test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC="$CC $ac_cv_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC understands -c and -o together" >&5
+$as_echo_n "checking whether $CC understands -c and -o together... " >&6; }
+if ${am_cv_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC -c conftest.$ac_ext -o conftest2.$ac_objext" >&5
+   ($CC -c conftest.$ac_ext -o conftest2.$ac_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_objext; then
+      : OK
+    else
+      am_cv_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_prog_cc_c_o" >&5
+$as_echo "$am_cv_prog_cc_c_o" >&6; }
+if test "$am_cv_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC="$am_aux_dir/compile $CC"
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+depcc="$CC"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE=depmode=$am_cv_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_TRUE=
+  am__fastdepCC_FALSE='#'
+else
+  am__fastdepCC_TRUE='#'
+  am__fastdepCC_FALSE=
+fi
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP" && test -d "$CPP"; then
+  CPP=
+fi
+if test -z "$CPP"; then
+  if ${ac_cv_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CPP=$CPP
+
+fi
+  CPP=$ac_cv_prog_CPP
+else
+  ac_cv_prog_CPP=$CPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP" >&5
+$as_echo "$CPP" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+# Make sure we can run config.sub.
+$SHELL "$ac_aux_dir/config.sub" sun4 >/dev/null 2>&1 ||
+  as_fn_error $? "cannot run $SHELL $ac_aux_dir/config.sub" "$LINENO" 5
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking build system type" >&5
+$as_echo_n "checking build system type... " >&6; }
+if ${ac_cv_build+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_build_alias=$build_alias
+test "x$ac_build_alias" = x &&
+  ac_build_alias=`$SHELL "$ac_aux_dir/config.guess"`
+test "x$ac_build_alias" = x &&
+  as_fn_error $? "cannot guess build type; you must specify one" "$LINENO" 5
+ac_cv_build=`$SHELL "$ac_aux_dir/config.sub" $ac_build_alias` ||
+  as_fn_error $? "$SHELL $ac_aux_dir/config.sub $ac_build_alias failed" "$LINENO" 5
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build" >&5
+$as_echo "$ac_cv_build" >&6; }
+case $ac_cv_build in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical build" "$LINENO" 5;;
+esac
+build=$ac_cv_build
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_build
+shift
+build_cpu=$1
+build_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+build_os=$*
+IFS=$ac_save_IFS
+case $build_os in *\ *) build_os=`echo "$build_os" | sed 's/ /-/g'`;; esac
+
+
+
+
+cross_compiling_build=no
+
+ac_build_tool_prefix=
+if test -n "$build"; then :
+  ac_build_tool_prefix="$build-"
+elif test -n "$build_alias"; then :
+  ac_build_tool_prefix="$build_alias-"
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+if test -n "$ac_build_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}gcc", so it can be a program name with args.
+set dummy ${ac_build_tool_prefix}gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="${ac_build_tool_prefix}gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_CC_FOR_BUILD"; then
+  ac_ct_CC_FOR_BUILD=$CC_FOR_BUILD
+  # Extract the first word of "gcc", so it can be a program name with args.
+set dummy gcc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC_FOR_BUILD"; then
+  ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_ct_CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC_FOR_BUILD="gcc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC_FOR_BUILD=$ac_cv_prog_ac_ct_CC_FOR_BUILD
+if test -n "$ac_ct_CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC_FOR_BUILD" >&5
+$as_echo "$ac_ct_CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_CC_FOR_BUILD" = x; then
+    CC_FOR_BUILD=""
+  else
+    case $cross_compiling_build:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with build triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with build triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC_FOR_BUILD=$ac_ct_CC_FOR_BUILD
+  fi
+else
+  CC_FOR_BUILD="$ac_cv_prog_CC_FOR_BUILD"
+fi
+
+if test -z "$CC_FOR_BUILD"; then
+          if test -n "$ac_build_tool_prefix"; then
+    # Extract the first word of "${ac_tool_prefix}cc", so it can be a program name with args.
+set dummy ${ac_build_tool_prefix}cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="${ac_build_tool_prefix}cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  fi
+fi
+if test -z "$CC_FOR_BUILD"; then
+  # Extract the first word of "cc", so it can be a program name with args.
+set dummy cc; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+  ac_prog_rejected=no
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    if test "$as_dir/$ac_word$ac_exec_ext" = "/usr/ucb/cc"; then
+       ac_prog_rejected=yes
+       continue
+     fi
+    ac_cv_prog_CC_FOR_BUILD="cc"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+if test $ac_prog_rejected = yes; then
+  # We found a bogon in the path, so make sure we never use it.
+  set dummy $ac_cv_prog_CC_FOR_BUILD
+  shift
+  if test $# != 0; then
+    # We chose a different compiler from the bogus one.
+    # However, it has the same basename, so the bogon will be chosen
+    # first if we set CC_FOR_BUILD to just the basename; use the full file name.
+    shift
+    ac_cv_prog_CC_FOR_BUILD="$as_dir/$ac_word${1+' '}$@"
+  fi
+fi
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$CC_FOR_BUILD"; then
+  if test -n "$ac_build_tool_prefix"; then
+  for ac_prog in cl.exe
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_build_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CC_FOR_BUILD"; then
+  ac_cv_prog_CC_FOR_BUILD="$CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CC_FOR_BUILD="$ac_build_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CC_FOR_BUILD=$ac_cv_prog_CC_FOR_BUILD
+if test -n "$CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CC_FOR_BUILD" >&5
+$as_echo "$CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CC_FOR_BUILD" && break
+  done
+fi
+if test -z "$CC_FOR_BUILD"; then
+  ac_ct_CC_FOR_BUILD=$CC_FOR_BUILD
+  for ac_prog in cl.exe
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CC_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CC_FOR_BUILD"; then
+  ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_ct_CC_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CC_FOR_BUILD="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CC_FOR_BUILD=$ac_cv_prog_ac_ct_CC_FOR_BUILD
+if test -n "$ac_ct_CC_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CC_FOR_BUILD" >&5
+$as_echo "$ac_ct_CC_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CC_FOR_BUILD" && break
+done
+
+  if test "x$ac_ct_CC_FOR_BUILD" = x; then
+    CC_FOR_BUILD=""
+  else
+    case $cross_compiling_build:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with build triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with build triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CC_FOR_BUILD=$ac_ct_CC_FOR_BUILD
+  fi
+fi
+
+fi
+
+
+test -z "$CC_FOR_BUILD" && { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "no acceptable C compiler found in \$PATH
+See \`config.log' for more details" "$LINENO" 5; }
+
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler version" >&5
+set X $ac_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C compiler" >&5
+$as_echo_n "checking whether we are using the GNU C compiler... " >&6; }
+if ${ac_cv_c_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+ac_cv_c_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_c_compiler_gnu" >&5
+$as_echo "$ac_cv_c_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GCC_FOR_BUILD=yes
+else
+  GCC_FOR_BUILD=
+fi
+ac_test_CFLAGS=${CFLAGS_FOR_BUILD+set}
+ac_save_CFLAGS=$CFLAGS_FOR_BUILD
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC_FOR_BUILD accepts -g" >&5
+$as_echo_n "checking whether $CC_FOR_BUILD accepts -g... " >&6; }
+if ${ac_cv_build_prog_cc_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_c_werror_flag=$ac_c_werror_flag
+   ac_c_werror_flag=yes
+   ac_cv_build_prog_cc_g=no
+   CFLAGS_FOR_BUILD="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_g=yes
+else
+  CFLAGS_FOR_BUILD=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+
+else
+  ac_c_werror_flag=$ac_save_c_werror_flag
+	 CFLAGS_FOR_BUILD="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_g=yes
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_build_objext conftest.$ac_ext
+   ac_c_werror_flag=$ac_save_c_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_prog_cc_g" >&5
+$as_echo "$ac_cv_build_prog_cc_g" >&6; }
+if test "$ac_test_CFLAGS" = set; then
+  CFLAGS_FOR_BUILD=$ac_save_CFLAGS
+elif test $ac_cv_build_prog_cc_g = yes; then
+  if test "$GCC_FOR_BUILD" = yes; then
+    CFLAGS_FOR_BUILD="-g -O2"
+  else
+    CFLAGS_FOR_BUILD="-g"
+  fi
+else
+  if test "$GCC_FOR_BUILD" = yes; then
+    CFLAGS_FOR_BUILD="-O2"
+  else
+    CFLAGS_FOR_BUILD=
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC_FOR_BUILD option to accept ISO C89" >&5
+$as_echo_n "checking for $CC_FOR_BUILD option to accept ISO C89... " >&6; }
+if ${ac_cv_build_prog_cc_c89+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_cv_build_prog_cc_c89=no
+ac_save_CC=$CC_FOR_BUILD
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+     char **p;
+     int i;
+{
+  return pi;
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+  char *s;
+  va_list v;
+  va_start (v,p);
+  s = g (p, va_arg (v,int));
+  va_end (v);
+  return s;
+}
+
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+   function prototypes and stuff, but not '\xHH' hex character constants.
+   These don't provoke an error unfortunately, instead are silently treated
+   as 'x'.  The following induces an error, until -std is added to get
+   proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+   array size at least.  It's necessary to write '\x00'==0 to get something
+   that's true only with -std.  */
+int osf4_cc_array '\x00' == 0 ? 1 : -1;
+
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+   inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_arrayFOO(a) == 'x' ? 1 : -1;
+
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv0  ||  f (e, argv, 1) != argv1;
+  ;
+  return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+  CC_FOR_BUILD="$ac_save_CC $ac_arg"
+  if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_build_objext
+  test "x$ac_cv_build_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC_FOR_BUILD=$ac_save_CC
+
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_build_prog_cc_c89" in
+  x)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+  xno)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+  *)
+    CC_FOR_BUILD="$CC_FOR_BUILD $ac_cv_build_prog_cc_c89"
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_prog_cc_c89" >&5
+$as_echo "$ac_cv_build_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_build_prog_cc_c89" != xno; then :
+
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CC_FOR_BUILD understands -c and -o together" >&5
+$as_echo_n "checking whether $CC_FOR_BUILD understands -c and -o together... " >&6; }
+if ${am_cv_build_prog_cc_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+  # Make sure it works both with $CC and with simple cc.
+  # Following AC_PROG_CC_C_O, we do the test twice because some
+  # compilers refuse to overwrite an existing .o file with -o,
+  # though they will create one.
+  am_cv_build_prog_cc_c_o=yes
+  for am_i in 1 2; do
+    if { echo "$as_me:$LINENO: $CC_FOR_BUILD -c conftest.$ac_ext -o conftest2.$ac_build_objext" >&5
+   ($CC_FOR_BUILD -c conftest.$ac_ext -o conftest2.$ac_build_objext) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } \
+         && test -f conftest2.$ac_build_objext; then
+      : OK
+    else
+      am_cv_build_prog_cc_c_o=no
+      break
+    fi
+  done
+  rm -f core conftest*
+  unset am_i
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_build_prog_cc_c_o" >&5
+$as_echo "$am_cv_build_prog_cc_c_o" >&6; }
+if test "$am_cv_build_prog_cc_c_o" != yes; then
+   # Losing compiler, so override with the script.
+   # FIXME: It is wrong to rewrite CC.
+   # But if we don't then we get into trouble of one sort or another.
+   # A longer-term fix would be to have automake use am__CC in this case,
+   # and then we could set am__CC="\$(top_srcdir)/compile \$(CC)"
+   CC_FOR_BUILD="$am_aux_dir/compile $CC_FOR_BUILD"
+fi
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+
+depcc="$CC_FOR_BUILD"   am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_build_CC_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_build_CC_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${BUILD_OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${BUILD_OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_build_CC_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_build_CC_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_build_CC_dependencies_compiler_type" >&5
+$as_echo "$am_cv_build_CC_dependencies_compiler_type" >&6; }
+CCDEPMODE_FOR_BUILD=depmode=$am_cv_build_CC_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_build_CC_dependencies_compiler_type" = gcc3; then
+  am__fastdepCC_build_TRUE=
+  am__fastdepCC_build_FALSE='#'
+else
+  am__fastdepCC_build_TRUE='#'
+  am__fastdepCC_build_FALSE=
+fi
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files a.out a.out.dSYM a.exe b.out"
+# Try to create an executable without -o first, disregard a.out.
+# It will help us diagnose broken compilers, and finding out an intuition
+# of exeext.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler works" >&5
+$as_echo_n "checking whether the C compiler works... " >&6; }
+ac_link_default=`$as_echo "$ac_link" | sed 's/ -o *conftest^ *//'`
+
+# The possible output files:
+ac_files="a.out conftest.exe conftest a.exe a_out.exe b.out conftest.*"
+
+ac_rmfiles=
+for ac_file in $ac_files
+do
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    * ) ac_rmfiles="$ac_rmfiles $ac_file";;
+  esac
+done
+rm -f $ac_rmfiles
+
+if { { ac_try="$ac_link_default"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link_default") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # Autoconf-2.13 could set the ac_cv_exeext variable to `no'.
+# So ignore a value of `no', otherwise this would lead to `EXEEXT = no'
+# in a Makefile.  We should not override ac_cv_exeext if it was cached,
+# so that the user can short-circuit this test for compilers unknown to
+# Autoconf.
+for ac_file in $ac_files ''
+do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj )
+	;;
+    ab.out )
+	# We found the default executable, but exeext='' is most
+	# certainly right.
+	break;;
+    *.* )
+	if test "${ac_cv_build_exeext+set}" = set && test "$ac_cv_build_exeext" != no;
+	then :; else
+	   ac_cv_build_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	fi
+	# We set ac_cv_exeext here because the later test for it is not
+	# safe: cross compilers may not add the suffix if given an `-o'
+	# argument, so we may need to know it at that point already.
+	# Even if this section looks crufty: it has the advantage of
+	# actually working.
+	break;;
+    * )
+	break;;
+  esac
+done
+test "$ac_cv_build_exeext" = no && ac_cv_build_exeext=
+
+else
+  ac_file=''
+fi
+if test -z "$ac_file"; then :
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+$as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error 77 "C compiler cannot create executables
+See \`config.log' for more details" "$LINENO" 5; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for C compiler default output file name" >&5
+$as_echo_n "checking for C compiler default output file name... " >&6; }
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_file" >&5
+$as_echo "$ac_file" >&6; }
+ac_build_exeext=$ac_cv_build_exeext
+
+rm -f -r a.out a.out.dSYM a.exe conftest$ac_cv_build_exeext b.out
+ac_clean_files=$ac_clean_files_save
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of executables" >&5
+$as_echo_n "checking for suffix of executables... " >&6; }
+if { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  # If both `conftest.exe' and `conftest' are `present' (well, observable)
+# catch `conftest.exe'.  For instance with Cygwin, `ls conftest' will
+# work properly (i.e., refer to `conftest.exe'), while it won't with
+# `rm'.
+for ac_file in conftest.exe conftest conftest.*; do
+  test -f "$ac_file" || continue
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM | *.o | *.obj ) ;;
+    *.* ) ac_cv_build_exeext=`expr "$ac_file" : '^.*$\..*$'`
+	  break;;
+    * ) break;;
+  esac
+done
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of executables: cannot compile and link
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest conftest$ac_cv_build_exeext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_exeext" >&5
+$as_echo "$ac_cv_build_exeext" >&6; }
+
+rm -f conftest.$ac_ext
+BUILD_EXEEXT=$ac_cv_build_exeext
+ac_build_exeext=$BUILD_EXEEXT
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+FILE *f = fopen ("conftest.out", "w");
+ return ferror (f) || fclose (f) != 0;
+
+  ;
+  return 0;
+}
+_ACEOF
+ac_clean_files="$ac_clean_files conftest.out"
+# Check that the compiler produces executables we can run.  If not, either
+# the compiler is broken, or we cross compile.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are cross compiling" >&5
+$as_echo_n "checking whether we are cross compiling... " >&6; }
+if test "$cross_compiling_build" != yes; then
+  { { ac_try="$ac_link"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_link") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+  if { ac_try='./conftest$ac_cv_build_exeext'
+  { { case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_try") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }; then
+    cross_compiling_build=no
+  else
+    if test "$cross_compiling_build" = maybe; then
+	cross_compiling_build=yes
+    else
+	{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot run C compiled programs.
+If you meant to cross compile, use \`--build'.
+See \`config.log' for more details" "$LINENO" 5; }
+    fi
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $cross_compiling_build" >&5
+$as_echo "$cross_compiling_build" >&6; }
+
+rm -f conftest.$ac_ext conftest$ac_cv_build_exeext conftest.out
+ac_clean_files=$ac_clean_files_save
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for suffix of object files" >&5
+$as_echo_n "checking for suffix of object files... " >&6; }
+if ${ac_cv_build_objext+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+rm -f conftest.o conftest.obj
+if { { ac_try="$ac_compile"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compile") 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then :
+  for ac_file in conftest.o conftest.obj conftest.*; do
+  test -f "$ac_file" || continue;
+  case $ac_file in
+    *.$ac_ext | *.xcoff | *.tds | *.d | *.pdb | *.xSYM | *.bb | *.bbg | *.map | *.inf | *.dSYM ) ;;
+    *) ac_cv_build_objext=`expr "$ac_file" : '.*\.$.*$'`
+       break;;
+  esac
+done
+else
+  $as_echo "$as_me: failed program was:" >&5
+sed 's/^/| /' conftest.$ac_ext >&5
+
+{ { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "cannot compute suffix of object files: cannot compile
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+rm -f conftest.$ac_cv_build_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_objext" >&5
+$as_echo "$ac_cv_build_objext" >&6; }
+BUILD_OBJEXT=$ac_cv_build_objext
+ac_build_objext=$BUILD_OBJEXT
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C preprocessor" >&5
+$as_echo_n "checking how to run the C preprocessor... " >&6; }
+# On Suns, sometimes $CPP names a directory.
+if test -n "$CPP_FOR_BUILD" && test -d "$CPP_FOR_BUILD"; then
+  CPP_FOR_BUILD=
+fi
+if test -z "$CPP_FOR_BUILD"; then
+  if ${ac_cv_build_prog_CPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CPP needs to be expanded
+    for CPP_FOR_BUILD in "$CC_FOR_BUILD -E" "$CC_FOR_BUILD -E -traditional-cpp" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_build_prog_CPP=$CPP_FOR_BUILD
+
+fi
+  CPP_FOR_BUILD=$ac_cv_build_prog_CPP
+else
+  ac_cv_build_prog_CPP=$CPP_FOR_BUILD
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CPP_FOR_BUILD" >&5
+$as_echo "$CPP_FOR_BUILD" >&6; }
+ac_preproc_ok=false
+for ac_c_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_c_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C preprocessor \"$CPP_FOR_BUILD\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_compile='$CC_FOR_BUILD -c $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_link='$CC_FOR_BUILD -o conftest$ac_build_exeext $CFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS_FOR_BUILD conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_build_c_compiler_gnu
+
+
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
+if test -z "$CXXCPP"; then
+  if ${ac_cv_prog_CXXCPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CXXCPP needs to be expanded
+    for CXXCPP in "$CXX -E" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CXXCPP=$CXXCPP
+
+fi
+  CXXCPP=$ac_cv_prog_CXXCPP
+else
+  ac_cv_prog_CXXCPP=$CXXCPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
+$as_echo "$CXXCPP" >&6; }
+ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking host system type" >&5
+$as_echo_n "checking host system type... " >&6; }
+if ${ac_cv_host+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test "x$host_alias" = x; then
+  ac_cv_host=$ac_cv_build
+else
+  ac_cv_host=`$SHELL "$ac_aux_dir/config.sub" $host_alias` ||
+    as_fn_error $? "$SHELL $ac_aux_dir/config.sub $host_alias failed" "$LINENO" 5
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_host" >&5
+$as_echo "$ac_cv_host" >&6; }
+case $ac_cv_host in
+*-*-*) ;;
+*) as_fn_error $? "invalid value of canonical host" "$LINENO" 5;;
+esac
+host=$ac_cv_host
+ac_save_IFS=$IFS; IFS='-'
+set x $ac_cv_host
+shift
+host_cpu=$1
+host_vendor=$2
+shift; shift
+# Remember, the first character of IFS is used to create $*,
+# except with old shells:
+host_os=$*
+IFS=$ac_save_IFS
+case $host_os in *\ *) host_os=`echo "$host_os" | sed 's/ /-/g'`;; esac
+
+
+
+
+save_cross_compiling=$cross_compiling
+save_ac_tool_prefix=$ac_tool_prefix
+cross_compiling=no
+ac_tool_prefix=
+
+ac_ext=cpp
+ac_cpp='$CXXCPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_build_compile='$CXX_FOR_BUILD -c $CXXFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_build_link='$CXX_FOR_BUILD -o conftest$ac_exeext $CXXFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+if test -z "$CXX_FOR_BUILD"; then
+  if test -n "$CCC"; then
+    CXX_FOR_BUILD=$CCC
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_CXX_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$CXX_FOR_BUILD"; then
+  ac_cv_prog_CXX_FOR_BUILD="$CXX_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_CXX_FOR_BUILD="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+CXX_FOR_BUILD=$ac_cv_prog_CXX_FOR_BUILD
+if test -n "$CXX_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXX_FOR_BUILD" >&5
+$as_echo "$CXX_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$CXX_FOR_BUILD" && break
+  done
+fi
+if test -z "$CXX_FOR_BUILD"; then
+  ac_ct_CXX_FOR_BUILD=$CXX_FOR_BUILD
+  for ac_prog in g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_CXX_FOR_BUILD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_CXX_FOR_BUILD"; then
+  ac_cv_prog_ac_ct_CXX_FOR_BUILD="$ac_ct_CXX_FOR_BUILD" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_CXX_FOR_BUILD="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_CXX_FOR_BUILD=$ac_cv_prog_ac_ct_CXX_FOR_BUILD
+if test -n "$ac_ct_CXX_FOR_BUILD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_CXX_FOR_BUILD" >&5
+$as_echo "$ac_ct_CXX_FOR_BUILD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_CXX_FOR_BUILD" && break
+done
+
+  if test "x$ac_ct_CXX_FOR_BUILD" = x; then
+    CXX_FOR_BUILD="g++"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with build triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with build triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    CXX_FOR_BUILD=$ac_ct_CXX_FOR_BUILD
+  fi
+fi
+
+  fi
+fi
+# Provide some information about the compiler.
+$as_echo "$as_me:${as_lineno-$LINENO}: checking for C++ compiler version" >&5
+set X $ac_build_compile
+ac_compiler=$2
+for ac_option in --version -v -V -qversion; do
+  { { ac_try="$ac_compiler $ac_option >&5"
+case "(($ac_try" in
+  *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;;
+  *) ac_try_echo=$ac_try;;
+esac
+eval ac_try_echo="\"\$as_me:${as_lineno-$LINENO}: $ac_try_echo\""
+$as_echo "$ac_try_echo"; } >&5
+  (eval "$ac_compiler $ac_option >&5") 2>conftest.err
+  ac_status=$?
+  if test -s conftest.err; then
+    sed '10a\
+... rest of stderr output deleted ...
+         10q' conftest.err >conftest.er1
+    cat conftest.er1 >&5
+  fi
+  rm -f conftest.er1 conftest.err
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+done
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether we are using the GNU C++ compiler" >&5
+$as_echo_n "checking whether we are using the GNU C++ compiler... " >&6; }
+if ${ac_cv_cxx_compiler_gnu+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+#ifndef __GNUC__
+       choke me
+#endif
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_compiler_gnu=yes
+else
+  ac_compiler_gnu=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_cv_cxx_compiler_gnu=$ac_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_cxx_compiler_gnu" >&5
+$as_echo "$ac_cv_cxx_compiler_gnu" >&6; }
+if test $ac_compiler_gnu = yes; then
+  GXX=yes
+else
+  GXX=
+fi
+ac_test_CXXFLAGS=${CXXFLAGS_FOR_BUILD+set}
+ac_save_CXXFLAGS=$CXXFLAGS_FOR_BUILD
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX_FOR_BUILD accepts -g" >&5
+$as_echo_n "checking whether $CXX_FOR_BUILD accepts -g... " >&6; }
+if ${ac_cv_build_prog_cxx_g+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_cxx_werror_flag=$ac_cxx_werror_flag
+   ac_cxx_werror_flag=yes
+   ac_cv_build_prog_cxx_g=no
+   CXXFLAGS_FOR_BUILD="-g"
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cxx_g=yes
+else
+  CXXFLAGS_FOR_BUILD=""
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+else
+  ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+	 CXXFLAGS_FOR_BUILD="-g"
+	 cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ac_cv_build_prog_cxx_g=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+   ac_cxx_werror_flag=$ac_save_cxx_werror_flag
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_build_prog_cxx_g" >&5
+$as_echo "$ac_cv_build_prog_cxx_g" >&6; }
+if test "$ac_test_CXXFLAGS" = set; then
+  CXXFLAGS_FOR_BUILD=$ac_save_CXXFLAGS
+elif test $ac_cv_build_prog_cxx_g = yes; then
+  if test "$GXX" = yes; then
+    CXXFLAGS_FOR_BUILD="-g -O2"
+  else
+    CXXFLAGS_FOR_BUILD="-g"
+  fi
+else
+  if test "$GXX" = yes; then
+    CXXFLAGS_FOR_BUILD="-O2"
+  else
+    CXXFLAGS_FOR_BUILD=
+  fi
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS_FOR_BUILD'
+ac_build_compile='$CC -c $CFLAGS $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_build_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS_FOR_BUILD $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+depcc="$CXX_FOR_BUILD"  am_compiler_list=
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking dependency style of $depcc" >&5
+$as_echo_n "checking dependency style of $depcc... " >&6; }
+if ${am_cv_CXX_dependencies_compiler_type+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$AMDEP_TRUE" && test -f "$am_depcomp"; then
+  # We make a subdir and do the tests there.  Otherwise we can end up
+  # making bogus files that we don't know about and never remove.  For
+  # instance it was reported that on HP-UX the gcc test will end up
+  # making a dummy file named 'D' -- because '-MD' means "put the output
+  # in D".
+  rm -rf conftest.dir
+  mkdir conftest.dir
+  # Copy depcomp to subdir because otherwise we won't find it if we're
+  # using a relative directory.
+  cp "$am_depcomp" conftest.dir
+  cd conftest.dir
+  # We will build objects and dependencies in a subdirectory because
+  # it helps to detect inapplicable dependency modes.  For instance
+  # both Tru64's cc and ICC support -MD to output dependencies as a
+  # side effect of compilation, but ICC will put the dependencies in
+  # the current directory while Tru64 will put them in the object
+  # directory.
+  mkdir sub
+
+  am_cv_CXX_dependencies_compiler_type=none
+  if test "$am_compiler_list" = ""; then
+     am_compiler_list=`sed -n 's/^#*$a-zA-Z0-9*$)$/\1/p' < ./depcomp`
+  fi
+  am__universal=false
+  case " $depcc " in #(
+     *\ -arch\ *\ -arch\ *) am__universal=true ;;
+     esac
+
+  for depmode in $am_compiler_list; do
+    # Setup a source with many dependencies, because some compilers
+    # like to wrap large dependency lists on column 80 (with \), and
+    # we should not choose a depcomp mode which is confused by this.
+    #
+    # We need to recreate these files for each test, as the compiler may
+    # overwrite some of them when testing with obscure command lines.
+    # This happens at least with the AIX C compiler.
+    : > sub/conftest.c
+    for i in 1 2 3 4 5 6; do
+      echo '#include "conftst'$i'.h"' >> sub/conftest.c
+      # Using ": > sub/conftst$i.h" creates only sub/conftst1.h with
+      # Solaris 10 /bin/sh.
+      echo '/* dummy */' > sub/conftst$i.h
+    done
+    echo "${am__include} ${am__quote}sub/conftest.Po${am__quote}" > confmf
+
+    # We check with '-c' and '-o' for the sake of the "dashmstdout"
+    # mode.  It turns out that the SunPro C++ compiler does not properly
+    # handle '-M -o', and we need to detect this.  Also, some Intel
+    # versions had trouble with output in subdirs.
+    am__obj=sub/conftest.${OBJEXT-o}
+    am__minus_obj="-o $am__obj"
+    case $depmode in
+    gcc)
+      # This depmode causes a compiler race in universal mode.
+      test "$am__universal" = false || continue
+      ;;
+    nosideeffect)
+      # After this tag, mechanisms are not by side-effect, so they'll
+      # only be used when explicitly requested.
+      if test "x$enable_dependency_tracking" = xyes; then
+	continue
+      else
+	break
+      fi
+      ;;
+    msvc7 | msvc7msys | msvisualcpp | msvcmsys)
+      # This compiler won't grok '-c -o', but also, the minuso test has
+      # not run yet.  These depmodes are late enough in the game, and
+      # so weak that their functioning should not be impacted.
+      am__obj=conftest.${OBJEXT-o}
+      am__minus_obj=
+      ;;
+    none) break ;;
+    esac
+    if depmode=$depmode \
+       source=sub/conftest.c object=$am__obj \
+       depfile=sub/conftest.Po tmpdepfile=sub/conftest.TPo \
+       $SHELL ./depcomp $depcc -c $am__minus_obj sub/conftest.c \
+         >/dev/null 2>conftest.err &&
+       grep sub/conftst1.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep sub/conftst6.h sub/conftest.Po > /dev/null 2>&1 &&
+       grep $am__obj sub/conftest.Po > /dev/null 2>&1 &&
+       ${MAKE-make} -s -f confmf > /dev/null 2>&1; then
+      # icc doesn't choke on unknown options, it will just issue warnings
+      # or remarks (even with -Werror).  So we grep stderr for any message
+      # that says an option was ignored or not supported.
+      # When given -MP, icc 7.0 and 7.1 complain thusly:
+      #   icc: Command line warning: ignoring option '-M'; no argument required
+      # The diagnosis changed in icc 8.0:
+      #   icc: Command line remark: option '-MP' not supported
+      if (grep 'ignoring option' conftest.err ||
+          grep 'not supported' conftest.err) >/dev/null 2>&1; then :; else
+        am_cv_CXX_dependencies_compiler_type=$depmode
+        break
+      fi
+    fi
+  done
+
+  cd ..
+  rm -rf conftest.dir
+else
+  am_cv_CXX_dependencies_compiler_type=none
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $am_cv_CXX_dependencies_compiler_type" >&5
+$as_echo "$am_cv_CXX_dependencies_compiler_type" >&6; }
+CXXDEPMODE=depmode=$am_cv_CXX_dependencies_compiler_type
+
+ if
+  test "x$enable_dependency_tracking" != xno \
+  && test "$am_cv_CXX_dependencies_compiler_type" = gcc3; then
+  am__fastdepCXX_TRUE=
+  am__fastdepCXX_FALSE='#'
+else
+  am__fastdepCXX_TRUE='#'
+  am__fastdepCXX_FALSE=
+fi
+
+
+ac_ext=cpp
+ac_cpp='$CXXCPP_FOR_BUILD $CPPFLAGS_FOR_BUILD'
+ac_build_compile='$CXX_FOR_BUILD -c $CXXFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_build_link='$CXX_FOR_BUILD -o conftest$ac_exeext $CXXFLAGS_FOR_BUILD $CPPFLAGS_FOR_BUILD $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
+if test -z "$CXXCPP_FOR_BUILD"; then
+  if ${ac_cv_build_prog_CXXCPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CXXCPP needs to be expanded
+    for CXXCPP_FOR_BUILD in "$CXX_FOR_BUILD -E" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_build_prog_CXXCPP=$CXXCPP_FOR_BUILD
+
+fi
+  CXXCPP_FOR_BUILD=$ac_cv_build_prog_CXXCPP
+else
+  ac_cv_build_prog_CXXCPP=$CXXCPP_FOR_BUILD
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP_FOR_BUILD" >&5
+$as_echo "$CXXCPP_FOR_BUILD" >&6; }
+ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C++ preprocessor \"$CXXCPP_FOR_BUILD\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS_FOR_BUILD'
+ac_build_compile='$CC -c $CFLAGS $CPPFLAGS_FOR_BUILD conftest.$ac_ext >&5'
+ac_build_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS_FOR_BUILD $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+ac_tool_prefix=$save_ac_tool_prefix
+cross_compiling=$save_cross_compiling
+
+
+
+
+# extract_interface needs to be run on the build system.
+# Since this is the only target that is being built,
+# simply use the build compiler throughout.
+# This ensures that the clang configure checks are
+# performed using the right compiler.
+CXX="$CXX_FOR_BUILD"
+CXXCPP="$CXXCPP_FOR_BUILD"
+EXEEXT="$BUILD_EXEEXT"
+OBJEXT="$BUILD_OBJEXT"
+
+
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+	echo $CXX | $GREP -e "-std=" > /dev/null 2> /dev/null
+	if test $? -eq 0; then
+		  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ax_cv_cxx_compile_cxx11=yes
+else
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+  else
+    HAVE_CXX11=1
+
+$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+
+  fi
+
+
+	else
+		  ax_cxx_compile_alternatives="11 0x"    ax_cxx_compile_cxx11_required=false
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+  ac_success=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features by default" >&5
+$as_echo_n "checking whether $CXX supports C++11 features by default... " >&6; }
+if ${ax_cv_cxx_compile_cxx11+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  ax_cv_cxx_compile_cxx11=yes
+else
+  ax_cv_cxx_compile_cxx11=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ax_cv_cxx_compile_cxx11" >&5
+$as_echo "$ax_cv_cxx_compile_cxx11" >&6; }
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+
+
+    if test x$ac_success = xno; then
+                for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=`$as_echo "ax_cv_cxx_compile_cxx11_$switch" | $as_tr_sh`
+        { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CXX supports C++11 features with $switch" >&5
+$as_echo_n "checking whether $CXX supports C++11 features with $switch... " >&6; }
+if eval \${$cachevar+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+
+
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+  eval $cachevar=yes
+else
+  eval $cachevar=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+           CXX="$ac_save_CXX"
+fi
+eval ac_res=\$$cachevar
+	       { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_res" >&5
+$as_echo "$ac_res" >&6; }
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      as_fn_error $? "*** A compiler with support for C++11 language features is required." "$LINENO" 5
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+    { $as_echo "$as_me:${as_lineno-$LINENO}: No compiler with C++11 support was found" >&5
+$as_echo "$as_me: No compiler with C++11 support was found" >&6;}
+  else
+    HAVE_CXX11=1
+
+$as_echo "#define HAVE_CXX11 1" >>confdefs.h
+
+  fi
+
+
+
+	fi
+
+
+# Check whether --enable-shared was given.
+if test "${enable_shared+set}" = set; then :
+  enableval=$enable_shared; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_shared=yes ;;
+    no) enable_shared=no ;;
+    *)
+      enable_shared=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_shared=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_shared=no
+fi
+
+
+
+
+
+
+
+
+
+case `pwd` in
+  *\ * | *\	*)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&5
+$as_echo "$as_me: WARNING: Libtool does not cope well with whitespace in \`pwd\`" >&2;} ;;
+esac
+
+
+
+macro_version='2.4.6'
+macro_revision='2.4.6'
+
+
+
+
+
+
+
+
+
+
+
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+# Backslashify metacharacters that are still active within
+# double-quoted strings.
+sed_quote_subst='s/$"`$\\$/\\\1/g'
+
+# Same as above, but do not quote variable references.
+double_quote_subst='s/$"`\\$/\\\1/g'
+
+# Sed substitution to delay expansion of an escaped shell variable in a
+# double_quote_subst'ed string.
+delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
+
+# Sed substitution to delay expansion of an escaped single quote.
+delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
+
+# Sed substitution to avoid accidental globbing in evaled expressions
+no_glob_subst='s/\*/\\\*/g'
+
+ECHO='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO
+ECHO=$ECHO$ECHO$ECHO$ECHO$ECHO$ECHO
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to print strings" >&5
+$as_echo_n "checking how to print strings... " >&6; }
+# Test print first, because it will be a builtin if present.
+if test "X`( print -r -- -n ) 2>/dev/null`" = X-n && \
+   test "X`print -r -- $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='print -r --'
+elif test "X`printf %s $ECHO 2>/dev/null`" = "X$ECHO"; then
+  ECHO='printf %s\n'
+else
+  # Use this function as a fallback that always works.
+  func_fallback_echo ()
+  {
+    eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+  }
+  ECHO='func_fallback_echo'
+fi
+
+# func_echo_all arg...
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO ""
+}
+
+case $ECHO in
+  printf*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: printf" >&5
+$as_echo "printf" >&6; } ;;
+  print*) { $as_echo "$as_me:${as_lineno-$LINENO}: result: print -r" >&5
+$as_echo "print -r" >&6; } ;;
+  *) { $as_echo "$as_me:${as_lineno-$LINENO}: result: cat" >&5
+$as_echo "cat" >&6; } ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+test -z "$SED" && SED=sed
+Xsed="$SED -e 1s/^X//"
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for egrep" >&5
+$as_echo_n "checking for egrep... " >&6; }
+if ${ac_cv_path_EGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo a | $GREP -E '(a|b)' >/dev/null 2>&1
+   then ac_cv_path_EGREP="$GREP -E"
+   else
+     if test -z "$EGREP"; then
+  ac_path_EGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in egrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_EGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_EGREP" || continue
+# Check for GNU ac_path_EGREP and select it if it is found.
+  # Check for GNU $ac_path_EGREP
+case `"$ac_path_EGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_EGREP="$ac_path_EGREP" ac_path_EGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'EGREP' >> "conftest.nl"
+    "$ac_path_EGREP" 'EGREP$' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_EGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_EGREP="$ac_path_EGREP"
+      ac_path_EGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_EGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_EGREP"; then
+    as_fn_error $? "no acceptable egrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_EGREP=$EGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_EGREP" >&5
+$as_echo "$ac_cv_path_EGREP" >&6; }
+ EGREP="$ac_cv_path_EGREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for fgrep" >&5
+$as_echo_n "checking for fgrep... " >&6; }
+if ${ac_cv_path_FGREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if echo 'ab*c' | $GREP -F 'ab*c' >/dev/null 2>&1
+   then ac_cv_path_FGREP="$GREP -F"
+   else
+     if test -z "$FGREP"; then
+  ac_path_FGREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in fgrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_FGREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_FGREP" || continue
+# Check for GNU ac_path_FGREP and select it if it is found.
+  # Check for GNU $ac_path_FGREP
+case `"$ac_path_FGREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_FGREP="$ac_path_FGREP" ac_path_FGREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'FGREP' >> "conftest.nl"
+    "$ac_path_FGREP" FGREP < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_FGREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_FGREP="$ac_path_FGREP"
+      ac_path_FGREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_FGREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_FGREP"; then
+    as_fn_error $? "no acceptable fgrep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_FGREP=$FGREP
+fi
+
+   fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_FGREP" >&5
+$as_echo "$ac_cv_path_FGREP" >&6; }
+ FGREP="$ac_cv_path_FGREP"
+
+
+test -z "$GREP" && GREP=grep
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    \\/* | ?:\\/*)
+      re_direlt='/^/^/*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if ${lt_cv_path_LD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi
+fi
+
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+$as_echo "$LD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
+if ${lt_cv_prog_gnu_ld+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for BSD- or MS-compatible name lister (nm)" >&5
+$as_echo_n "checking for BSD- or MS-compatible name lister (nm)... " >&6; }
+if ${lt_cv_path_NM+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NM"; then
+  # Let the user override the test.
+  lt_cv_path_NM=$NM
+else
+  lt_nm_to_check=${ac_tool_prefix}nm
+  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then
+    lt_nm_to_check="$lt_nm_to_check nm"
+  fi
+  for lt_tmp_nm in $lt_nm_to_check; do
+    lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
+      IFS=$lt_save_ifs
+      test -z "$ac_dir" && ac_dir=.
+      tmp_nm=$ac_dir/$lt_tmp_nm
+      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext"; then
+	# Check to see if the nm accepts a BSD-compat flag.
+	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
+	#   nm: unknown option "B" ignored
+	# Tru64's nm complains that /dev/null is an invalid object file
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
+	  lt_cv_path_NM="$tmp_nm -B"
+	  break 2
+	  ;;
+	*)
+	  case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
+	  */dev/null*)
+	    lt_cv_path_NM="$tmp_nm -p"
+	    break 2
+	    ;;
+	  *)
+	    lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
+	    continue # so that we can try to find one that supports BSD flags
+	    ;;
+	  esac
+	  ;;
+	esac
+      fi
+    done
+    IFS=$lt_save_ifs
+  done
+  : ${lt_cv_path_NM=no}
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_NM" >&5
+$as_echo "$lt_cv_path_NM" >&6; }
+if test no != "$lt_cv_path_NM"; then
+  NM=$lt_cv_path_NM
+else
+  # Didn't find any BSD compatible name lister, look for dumpbin.
+  if test -n "$DUMPBIN"; then :
+    # Let the user override the test.
+  else
+    if test -n "$ac_tool_prefix"; then
+  for ac_prog in dumpbin "link -dump"
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DUMPBIN+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DUMPBIN"; then
+  ac_cv_prog_DUMPBIN="$DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DUMPBIN="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DUMPBIN=$ac_cv_prog_DUMPBIN
+if test -n "$DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DUMPBIN" >&5
+$as_echo "$DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$DUMPBIN" && break
+  done
+fi
+if test -z "$DUMPBIN"; then
+  ac_ct_DUMPBIN=$DUMPBIN
+  for ac_prog in dumpbin "link -dump"
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DUMPBIN+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DUMPBIN"; then
+  ac_cv_prog_ac_ct_DUMPBIN="$ac_ct_DUMPBIN" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DUMPBIN="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DUMPBIN=$ac_cv_prog_ac_ct_DUMPBIN
+if test -n "$ac_ct_DUMPBIN"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DUMPBIN" >&5
+$as_echo "$ac_ct_DUMPBIN" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_DUMPBIN" && break
+done
+
+  if test "x$ac_ct_DUMPBIN" = x; then
+    DUMPBIN=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DUMPBIN=$ac_ct_DUMPBIN
+  fi
+fi
+
+    case `$DUMPBIN -symbols -headers /dev/null 2>&1 | sed '1q'` in
+    *COFF*)
+      DUMPBIN="$DUMPBIN -symbols -headers"
+      ;;
+    *)
+      DUMPBIN=:
+      ;;
+    esac
+  fi
+
+  if test : != "$DUMPBIN"; then
+    NM=$DUMPBIN
+  fi
+fi
+test -z "$NM" && NM=nm
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the name lister ($NM) interface" >&5
+$as_echo_n "checking the name lister ($NM) interface... " >&6; }
+if ${lt_cv_nm_interface+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_nm_interface="BSD nm"
+  echo "int some_variable = 0;" > conftest.$ac_ext
+  (eval echo "\"\$as_me:$LINENO: $ac_compile\"" >&5)
+  (eval "$ac_compile" 2>conftest.err)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: $NM \\\"conftest.$ac_objext\\\"\"" >&5)
+  (eval "$NM \"conftest.$ac_objext\"" 2>conftest.err > conftest.out)
+  cat conftest.err >&5
+  (eval echo "\"\$as_me:$LINENO: output\"" >&5)
+  cat conftest.out >&5
+  if $GREP 'External.*some_variable' conftest.out > /dev/null; then
+    lt_cv_nm_interface="MS dumpbin"
+  fi
+  rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_nm_interface" >&5
+$as_echo "$lt_cv_nm_interface" >&6; }
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether ln -s works" >&5
+$as_echo_n "checking whether ln -s works... " >&6; }
+LN_S=$as_ln_s
+if test "$LN_S" = "ln -s"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no, using $LN_S" >&5
+$as_echo "no, using $LN_S" >&6; }
+fi
+
+# find the maximum length of command line arguments
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking the maximum length of command line arguments" >&5
+$as_echo_n "checking the maximum length of command line arguments... " >&6; }
+if ${lt_cv_sys_max_cmd_len+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+    i=0
+  teststring=ABCD
+
+  case $build_os in
+  msdosdjgpp*)
+    # On DJGPP, this test can blow up pretty badly due to problems in libc
+    # (any single argument exceeding 2000 bytes causes a buffer overrun
+    # during glob expansion).  Even if it were fixed, the result of this
+    # check would be larger than it should be.
+    lt_cv_sys_max_cmd_len=12288;    # 12K is about right
+    ;;
+
+  gnu*)
+    # Under GNU Hurd, this test is not required because there is
+    # no limit to the length of command line arguments.
+    # Libtool will interpret -1 as no limit whatsoever
+    lt_cv_sys_max_cmd_len=-1;
+    ;;
+
+  cygwin* | mingw* | cegcc*)
+    # On Win9x/ME, this test blows up -- it succeeds, but takes
+    # about 5 minutes as the teststring grows exponentially.
+    # Worse, since 9x/ME are not pre-emptively multitasking,
+    # you end up with a "frozen" computer, even though with patience
+    # the test eventually succeeds (with a max line length of 256k).
+    # Instead, let's just punt: use the minimum linelength reported by
+    # all of the supported platforms: 8192 (on NT/2K/XP).
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  mint*)
+    # On MiNT this can take a long time and run out of memory.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  amigaos*)
+    # On AmigaOS with pdksh, this test takes hours, literally.
+    # So we just punt and use a minimum line length of 8192.
+    lt_cv_sys_max_cmd_len=8192;
+    ;;
+
+  bitrig* | darwin* | dragonfly* | freebsd* | netbsd* | openbsd*)
+    # This has been around since 386BSD, at least.  Likely further.
+    if test -x /sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
+    elif test -x /usr/sbin/sysctl; then
+      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
+    else
+      lt_cv_sys_max_cmd_len=65536	# usable default for all BSDs
+    fi
+    # And add a safety zone
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    ;;
+
+  interix*)
+    # We know the value 262144 and hardcode it with a safety zone (like BSD)
+    lt_cv_sys_max_cmd_len=196608
+    ;;
+
+  os2*)
+    # The test takes a long time on OS/2.
+    lt_cv_sys_max_cmd_len=8192
+    ;;
+
+  osf*)
+    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
+    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
+    # nice to cause kernel panics so lets avoid the loop below.
+    # First set a reasonable default.
+    lt_cv_sys_max_cmd_len=16384
+    #
+    if test -x /sbin/sysconfig; then
+      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
+        *1*) lt_cv_sys_max_cmd_len=-1 ;;
+      esac
+    fi
+    ;;
+  sco3.2v5*)
+    lt_cv_sys_max_cmd_len=102400
+    ;;
+  sysv5* | sco5v6* | sysv4.2uw2*)
+    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
+    if test -n "$kargmax"; then
+      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*	 //'`
+    else
+      lt_cv_sys_max_cmd_len=32768
+    fi
+    ;;
+  *)
+    lt_cv_sys_max_cmd_len=`(getconf ARG_MAX) 2> /dev/null`
+    if test -n "$lt_cv_sys_max_cmd_len" && \
+       test undefined != "$lt_cv_sys_max_cmd_len"; then
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
+    else
+      # Make teststring a little bigger before we do anything with it.
+      # a 1K string should be a reasonable start.
+      for i in 1 2 3 4 5 6 7 8; do
+        teststring=$teststring$teststring
+      done
+      SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
+      # If test is not a shell built-in, we'll probably end up computing a
+      # maximum length that is only half of the actual maximum length, but
+      # we can't tell.
+      while { test X`env echo "$teststring$teststring" 2>/dev/null` \
+	         = "X$teststring$teststring"; } >/dev/null 2>&1 &&
+	      test 17 != "$i" # 1/2 MB should be enough
+      do
+        i=`expr $i + 1`
+        teststring=$teststring$teststring
+      done
+      # Only check the string length outside the loop.
+      lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
+      teststring=
+      # Add a significant safety factor because C++ compilers can tack on
+      # massive amounts of additional arguments before passing them to the
+      # linker.  It appears as though 1/2 is a usable value.
+      lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
+    fi
+    ;;
+  esac
+
+fi
+
+if test -n "$lt_cv_sys_max_cmd_len"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sys_max_cmd_len" >&5
+$as_echo "$lt_cv_sys_max_cmd_len" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: none" >&5
+$as_echo "none" >&6; }
+fi
+max_cmd_len=$lt_cv_sys_max_cmd_len
+
+
+
+
+
+
+: ${CP="cp -f"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+
+if ( (MAIL=60; unset MAIL) || exit) >/dev/null 2>&1; then
+  lt_unset=unset
+else
+  lt_unset=false
+fi
+
+
+
+
+
+# test EBCDIC or ASCII
+case `echo X|tr X '\101'` in
+ A) # ASCII based system
+    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
+  lt_SP2NL='tr \040 \012'
+  lt_NL2SP='tr \015\012 \040\040'
+  ;;
+ *) # EBCDIC based system
+  lt_SP2NL='tr \100 \n'
+  lt_NL2SP='tr \r\n \100\100'
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to $host format" >&5
+$as_echo_n "checking how to convert $build file names to $host format... " >&6; }
+if ${lt_cv_to_host_file_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_w32
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_cygwin_to_w32
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_w32
+        ;;
+    esac
+    ;;
+  *-*-cygwin* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_host_file_cmd=func_convert_file_msys_to_cygwin
+        ;;
+      *-*-cygwin* )
+        lt_cv_to_host_file_cmd=func_convert_file_noop
+        ;;
+      * ) # otherwise, assume *nix
+        lt_cv_to_host_file_cmd=func_convert_file_nix_to_cygwin
+        ;;
+    esac
+    ;;
+  * ) # unhandled hosts (and "normal" native builds)
+    lt_cv_to_host_file_cmd=func_convert_file_noop
+    ;;
+esac
+
+fi
+
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_host_file_cmd" >&5
+$as_echo "$lt_cv_to_host_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to convert $build file names to toolchain format" >&5
+$as_echo_n "checking how to convert $build file names to toolchain format... " >&6; }
+if ${lt_cv_to_tool_file_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  #assume ordinary cross tools, or native build.
+lt_cv_to_tool_file_cmd=func_convert_file_noop
+case $host in
+  *-*-mingw* )
+    case $build in
+      *-*-mingw* ) # actually msys
+        lt_cv_to_tool_file_cmd=func_convert_file_msys_to_w32
+        ;;
+    esac
+    ;;
+esac
+
+fi
+
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_to_tool_file_cmd" >&5
+$as_echo "$lt_cv_to_tool_file_cmd" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $LD option to reload object files" >&5
+$as_echo_n "checking for $LD option to reload object files... " >&6; }
+if ${lt_cv_ld_reload_flag+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_reload_flag='-r'
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_reload_flag" >&5
+$as_echo "$lt_cv_ld_reload_flag" >&6; }
+reload_flag=$lt_cv_ld_reload_flag
+case $reload_flag in
+"" | " "*) ;;
+*) reload_flag=" $reload_flag" ;;
+esac
+reload_cmds='$LD$reload_flag -o $output$reload_objs'
+case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    if test yes != "$GCC"; then
+      reload_cmds=false
+    fi
+    ;;
+  darwin*)
+    if test yes = "$GCC"; then
+      reload_cmds='$LTCC $LTCFLAGS -nostdlib $wl-r -o $output$reload_objs'
+    else
+      reload_cmds='$LD$reload_flag -o $output$reload_objs'
+    fi
+    ;;
+esac
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}objdump", so it can be a program name with args.
+set dummy ${ac_tool_prefix}objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OBJDUMP"; then
+  ac_cv_prog_OBJDUMP="$OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OBJDUMP="${ac_tool_prefix}objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OBJDUMP=$ac_cv_prog_OBJDUMP
+if test -n "$OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OBJDUMP" >&5
+$as_echo "$OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OBJDUMP"; then
+  ac_ct_OBJDUMP=$OBJDUMP
+  # Extract the first word of "objdump", so it can be a program name with args.
+set dummy objdump; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OBJDUMP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OBJDUMP"; then
+  ac_cv_prog_ac_ct_OBJDUMP="$ac_ct_OBJDUMP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OBJDUMP="objdump"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OBJDUMP=$ac_cv_prog_ac_ct_OBJDUMP
+if test -n "$ac_ct_OBJDUMP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OBJDUMP" >&5
+$as_echo "$ac_ct_OBJDUMP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OBJDUMP" = x; then
+    OBJDUMP="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OBJDUMP=$ac_ct_OBJDUMP
+  fi
+else
+  OBJDUMP="$ac_cv_prog_OBJDUMP"
+fi
+
+test -z "$OBJDUMP" && OBJDUMP=objdump
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to recognize dependent libraries" >&5
+$as_echo_n "checking how to recognize dependent libraries... " >&6; }
+if ${lt_cv_deplibs_check_method+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_file_magic_cmd='$MAGIC_CMD'
+lt_cv_file_magic_test_file=
+lt_cv_deplibs_check_method='unknown'
+# Need to set the preceding variable on all platforms that support
+# interlibrary dependencies.
+# 'none' -- dependencies not supported.
+# 'unknown' -- same as none, but documents that we really don't know.
+# 'pass_all' -- all dependencies passed with no checks.
+# 'test_compile' -- check by making test program.
+# 'file_magic regex' -- check by looking for files in library path
+# that responds to the $file_magic_cmd with a given extended regex.
+# If you have 'file' or equivalent on your system and you're not sure
+# whether 'pass_all' will *always* work, you probably want this one.
+
+case $host_os in
+aix4-9*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+beos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+bsdi45*)
+  lt_cv_deplibs_check_method='file_magic ELF 0-90-9*-bit MLSB (shared object|dynamic lib)'
+  lt_cv_file_magic_cmd='/usr/bin/file -L'
+  lt_cv_file_magic_test_file=/shlib/libc.so
+  ;;
+
+cygwin*)
+  # func_win32_libid is a shell function defined in ltmain.sh
+  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+  lt_cv_file_magic_cmd='func_win32_libid'
+  ;;
+
+mingw* | pw32*)
+  # Base MSYS/MinGW do not provide the 'file' command needed by
+  # func_win32_libid shell function, so use a weaker test based on 'objdump',
+  # unless we find 'file', for example because we are cross-compiling.
+  if ( file / ) >/dev/null 2>&1; then
+    lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
+    lt_cv_file_magic_cmd='func_win32_libid'
+  else
+    # Keep this pattern in sync with the one in func_win32_libid.
+    lt_cv_deplibs_check_method='file_magic file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)'
+    lt_cv_file_magic_cmd='$OBJDUMP -f'
+  fi
+  ;;
+
+cegcc*)
+  # use the weaker test based on 'objdump'. See mingw*.
+  lt_cv_deplibs_check_method='file_magic file format pe-arm-.*little(.*architecture: arm)?'
+  lt_cv_file_magic_cmd='$OBJDUMP -f'
+  ;;
+
+darwin* | rhapsody*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+freebsd* | dragonfly*)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    case $host_cpu in
+    i*86 )
+      # Not sure whether the presence of OpenBSD here was a mistake.
+      # Let's accept both of them until this is cleared up.
+      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i3-986 (compact )?demand paged shared library'
+      lt_cv_file_magic_cmd=/usr/bin/file
+      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
+      ;;
+    esac
+  else
+    lt_cv_deplibs_check_method=pass_all
+  fi
+  ;;
+
+haiku*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+hpux10.20* | hpux11*)
+  lt_cv_file_magic_cmd=/usr/bin/file
+  case $host_cpu in
+  ia64*)
+    lt_cv_deplibs_check_method='file_magic (s0-90-90-9|ELF-0-90-9) shared object file - IA64'
+    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
+    ;;
+  hppa*64*)
+    lt_cv_deplibs_check_method='file_magic (s0-90-90-9|ELF -0-90-9)(-bit)?( LMSB)? shared object( file)?, -* PA-RISC 0-9\.0-9'
+    lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
+    ;;
+  *)
+    lt_cv_deplibs_check_method='file_magic (s0-90-90-9|PA-RISC0-9\.0-9) shared library'
+    lt_cv_file_magic_test_file=/usr/lib/libc.sl
+    ;;
+  esac
+  ;;
+
+interix3-9*)
+  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
+  lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so|\.a)$'
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $LD in
+  *-32|*"-32 ") libmagic=32-bit;;
+  *-n32|*"-n32 ") libmagic=N32;;
+  *-64|*"-64 ") libmagic=64-bit;;
+  *) libmagic=never-match;;
+  esac
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+netbsd* | netbsdelf*-gnu)
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
+    lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so\.0-9+\.0-9+|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so|_pic\.a)$'
+  fi
+  ;;
+
+newos6*)
+  lt_cv_deplibs_check_method='file_magic ELF 0-90-9*-bit MLSB (executable|dynamic lib)'
+  lt_cv_file_magic_cmd=/usr/bin/file
+  lt_cv_file_magic_test_file=/usr/lib/libnls.so
+  ;;
+
+*nto* | *qnx*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+openbsd* | bitrig*)
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so\.0-9+\.0-9+|\.so|_pic\.a)$'
+  else
+    lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so\.0-9+\.0-9+|_pic\.a)$'
+  fi
+  ;;
+
+osf3* | osf4* | osf5*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+rdos*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+solaris*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+
+sysv4 | sysv4.3*)
+  case $host_vendor in
+  motorola)
+    lt_cv_deplibs_check_method='file_magic ELF 0-90-9*-bit MLSB (shared object|dynamic lib) M0-90-9* Version 0-9'
+    lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
+    ;;
+  ncr)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  sequent)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method='file_magic ELF 0-90-9*-bit LMSB (shared object|dynamic lib )'
+    ;;
+  sni)
+    lt_cv_file_magic_cmd='/bin/file'
+    lt_cv_deplibs_check_method="file_magic ELF 0-90-9*-bit LMSB dynamic lib"
+    lt_cv_file_magic_test_file=/lib/libc.so
+    ;;
+  siemens)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  pc)
+    lt_cv_deplibs_check_method=pass_all
+    ;;
+  esac
+  ;;
+
+tpf*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_deplibs_check_method" >&5
+$as_echo "$lt_cv_deplibs_check_method" >&6; }
+
+file_magic_glob=
+want_nocaseglob=no
+if test "$build" = "$host"; then
+  case $host_os in
+  mingw* | pw32*)
+    if ( shopt | grep nocaseglob ) >/dev/null 2>&1; then
+      want_nocaseglob=yes
+    else
+      file_magic_glob=`echo aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ | $SED -e "s/$..$/s\/\1\/\1\/g;/g"`
+    fi
+    ;;
+  esac
+fi
+
+file_magic_cmd=$lt_cv_file_magic_cmd
+deplibs_check_method=$lt_cv_deplibs_check_method
+test -z "$deplibs_check_method" && deplibs_check_method=unknown
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dlltool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DLLTOOL"; then
+  ac_cv_prog_DLLTOOL="$DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DLLTOOL="${ac_tool_prefix}dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DLLTOOL=$ac_cv_prog_DLLTOOL
+if test -n "$DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DLLTOOL" >&5
+$as_echo "$DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DLLTOOL"; then
+  ac_ct_DLLTOOL=$DLLTOOL
+  # Extract the first word of "dlltool", so it can be a program name with args.
+set dummy dlltool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DLLTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DLLTOOL"; then
+  ac_cv_prog_ac_ct_DLLTOOL="$ac_ct_DLLTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DLLTOOL="dlltool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DLLTOOL=$ac_cv_prog_ac_ct_DLLTOOL
+if test -n "$ac_ct_DLLTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DLLTOOL" >&5
+$as_echo "$ac_ct_DLLTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DLLTOOL" = x; then
+    DLLTOOL="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DLLTOOL=$ac_ct_DLLTOOL
+  fi
+else
+  DLLTOOL="$ac_cv_prog_DLLTOOL"
+fi
+
+test -z "$DLLTOOL" && DLLTOOL=dlltool
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to associate runtime and link libraries" >&5
+$as_echo_n "checking how to associate runtime and link libraries... " >&6; }
+if ${lt_cv_sharedlib_from_linklib_cmd+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_sharedlib_from_linklib_cmd='unknown'
+
+case $host_os in
+cygwin* | mingw* | pw32* | cegcc*)
+  # two different shell functions defined in ltmain.sh;
+  # decide which one to use based on capabilities of $DLLTOOL
+  case `$DLLTOOL --help 2>&1` in
+  *--identify-strict*)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib
+    ;;
+  *)
+    lt_cv_sharedlib_from_linklib_cmd=func_cygming_dll_for_implib_fallback
+    ;;
+  esac
+  ;;
+*)
+  # fallback: assume linklib IS sharedlib
+  lt_cv_sharedlib_from_linklib_cmd=$ECHO
+  ;;
+esac
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_sharedlib_from_linklib_cmd" >&5
+$as_echo "$lt_cv_sharedlib_from_linklib_cmd" >&6; }
+sharedlib_from_linklib_cmd=$lt_cv_sharedlib_from_linklib_cmd
+test -z "$sharedlib_from_linklib_cmd" && sharedlib_from_linklib_cmd=$ECHO
+
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  for ac_prog in ar
+  do
+    # Extract the first word of "$ac_tool_prefix$ac_prog", so it can be a program name with args.
+set dummy $ac_tool_prefix$ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$AR"; then
+  ac_cv_prog_AR="$AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_AR="$ac_tool_prefix$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+AR=$ac_cv_prog_AR
+if test -n "$AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $AR" >&5
+$as_echo "$AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+    test -n "$AR" && break
+  done
+fi
+if test -z "$AR"; then
+  ac_ct_AR=$AR
+  for ac_prog in ar
+do
+  # Extract the first word of "$ac_prog", so it can be a program name with args.
+set dummy $ac_prog; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_AR+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_AR"; then
+  ac_cv_prog_ac_ct_AR="$ac_ct_AR" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_AR="$ac_prog"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_AR=$ac_cv_prog_ac_ct_AR
+if test -n "$ac_ct_AR"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_AR" >&5
+$as_echo "$ac_ct_AR" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  test -n "$ac_ct_AR" && break
+done
+
+  if test "x$ac_ct_AR" = x; then
+    AR="false"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    AR=$ac_ct_AR
+  fi
+fi
+
+: ${AR=ar}
+: ${AR_FLAGS=cr}
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for archiver @FILE support" >&5
+$as_echo_n "checking for archiver @FILE support... " >&6; }
+if ${lt_cv_ar_at_file+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ar_at_file=no
+   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  echo conftest.$ac_objext > conftest.lst
+      lt_ar_try='$AR $AR_FLAGS libconftest.a @conftest.lst >&5'
+      { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+      if test 0 -eq "$ac_status"; then
+	# Ensure the archiver fails upon bogus file names.
+	rm -f conftest.$ac_objext libconftest.a
+	{ { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$lt_ar_try\""; } >&5
+  (eval $lt_ar_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	if test 0 -ne "$ac_status"; then
+          lt_cv_ar_at_file=@
+        fi
+      fi
+      rm -f conftest.* libconftest.a
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ar_at_file" >&5
+$as_echo "$lt_cv_ar_at_file" >&6; }
+
+if test no = "$lt_cv_ar_at_file"; then
+  archiver_list_spec=
+else
+  archiver_list_spec=$lt_cv_ar_at_file
+fi
+
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}strip", so it can be a program name with args.
+set dummy ${ac_tool_prefix}strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$STRIP"; then
+  ac_cv_prog_STRIP="$STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_STRIP="${ac_tool_prefix}strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+STRIP=$ac_cv_prog_STRIP
+if test -n "$STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $STRIP" >&5
+$as_echo "$STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_STRIP"; then
+  ac_ct_STRIP=$STRIP
+  # Extract the first word of "strip", so it can be a program name with args.
+set dummy strip; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_STRIP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_STRIP"; then
+  ac_cv_prog_ac_ct_STRIP="$ac_ct_STRIP" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_STRIP="strip"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_STRIP=$ac_cv_prog_ac_ct_STRIP
+if test -n "$ac_ct_STRIP"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_STRIP" >&5
+$as_echo "$ac_ct_STRIP" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_STRIP" = x; then
+    STRIP=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    STRIP=$ac_ct_STRIP
+  fi
+else
+  STRIP="$ac_cv_prog_STRIP"
+fi
+
+test -z "$STRIP" && STRIP=:
+
+
+
+
+
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}ranlib", so it can be a program name with args.
+set dummy ${ac_tool_prefix}ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$RANLIB"; then
+  ac_cv_prog_RANLIB="$RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_RANLIB="${ac_tool_prefix}ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+RANLIB=$ac_cv_prog_RANLIB
+if test -n "$RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $RANLIB" >&5
+$as_echo "$RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_RANLIB"; then
+  ac_ct_RANLIB=$RANLIB
+  # Extract the first word of "ranlib", so it can be a program name with args.
+set dummy ranlib; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_RANLIB+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_RANLIB"; then
+  ac_cv_prog_ac_ct_RANLIB="$ac_ct_RANLIB" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_RANLIB="ranlib"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_RANLIB=$ac_cv_prog_ac_ct_RANLIB
+if test -n "$ac_ct_RANLIB"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_RANLIB" >&5
+$as_echo "$ac_ct_RANLIB" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_RANLIB" = x; then
+    RANLIB=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    RANLIB=$ac_ct_RANLIB
+  fi
+else
+  RANLIB="$ac_cv_prog_RANLIB"
+fi
+
+test -z "$RANLIB" && RANLIB=:
+
+
+
+
+
+
+# Determine commands to create old-style static archives.
+old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs'
+old_postinstall_cmds='chmod 644 $oldlib'
+old_postuninstall_cmds=
+
+if test -n "$RANLIB"; then
+  case $host_os in
+  bitrig* | openbsd*)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$tool_oldlib"
+    ;;
+  *)
+    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$tool_oldlib"
+    ;;
+  esac
+  old_archive_cmds="$old_archive_cmds~\$RANLIB \$tool_oldlib"
+fi
+
+case $host_os in
+  darwin*)
+    lock_old_archive_extraction=yes ;;
+  *)
+    lock_old_archive_extraction=no ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+# Check for command to grab the raw symbol name followed by C symbol from nm.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking command to parse $NM output from $compiler object" >&5
+$as_echo_n "checking command to parse $NM output from $compiler object... " >&6; }
+if ${lt_cv_sys_global_symbol_pipe+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+
+# These are sane defaults that work on at least a few old systems.
+# They come from Ultrix.  What could be older than Ultrix?!! ;)
+
+# Character class describing NM global symbol codes.
+symcode='BCDEGRST'
+
+# Regexp to match symbols that can be accessed directly from C.
+sympat='$_A-Za-z_A-Za-z0-9*$'
+
+# Define system-specific variables.
+case $host_os in
+aix*)
+  symcode='BCDT'
+  ;;
+cygwin* | mingw* | pw32* | cegcc*)
+  symcode='ABCDGISTW'
+  ;;
+hpux*)
+  if test ia64 = "$host_cpu"; then
+    symcode='ABCDEGRST'
+  fi
+  ;;
+irix* | nonstopux*)
+  symcode='BCDEGRST'
+  ;;
+osf*)
+  symcode='BCDEGQRST'
+  ;;
+solaris*)
+  symcode='BDRT'
+  ;;
+sco3.2v5*)
+  symcode='DT'
+  ;;
+sysv4.2uw2*)
+  symcode='DT'
+  ;;
+sysv5* | sco5v6* | unixware* | OpenUNIX*)
+  symcode='ABDT'
+  ;;
+sysv4)
+  symcode='DFNSTU'
+  ;;
+esac
+
+# If we're using GNU nm, then use its standard symbol codes.
+case `$NM -V 2>&1` in
+*GNU* | *'with BFD'*)
+  symcode='ABCDGIRSTW' ;;
+esac
+
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  # Gets list of data symbols to import.
+  lt_cv_sys_global_symbol_to_import="sed -n -e 's/^I .* $.*$$/\1/p'"
+  # Adjust the below global symbol transforms to fixup imported variables.
+  lt_cdecl_hook=" -e 's/^I .* $.*$$/extern __declspec(dllimport) char \1;/p'"
+  lt_c_name_hook=" -e 's/^I .* $.*$$/  {\"\1\", (void *) 0},/p'"
+  lt_c_name_lib_hook="\
+  -e 's/^I .* $lib.*$$/  {\"\1\", (void *) 0},/p'\
+  -e 's/^I .* $.*$$/  {\"lib\1\", (void *) 0},/p'"
+else
+  # Disable hooks by default.
+  lt_cv_sys_global_symbol_to_import=
+  lt_cdecl_hook=
+  lt_c_name_hook=
+  lt_c_name_lib_hook=
+fi
+
+# Transform an extracted symbol line into a proper C declaration.
+# Some systems (esp. on ia64) link data and code symbols differently,
+# so use this general approach.
+lt_cv_sys_global_symbol_to_cdecl="sed -n"\
+$lt_cdecl_hook\
+" -e 's/^T .* $.*$$/extern int \1();/p'"\
+" -e 's/^$symcode$symcode* .* $.*$$/extern char \1;/p'"
+
+# Transform an extracted symbol line into symbol name and symbol address
+lt_cv_sys_global_symbol_to_c_name_address="sed -n"\
+$lt_c_name_hook\
+" -e 's/^: $.*$ .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* $.*$$/  {\"\1\", (void *) \&\1},/p'"
+
+# Transform an extracted symbol line into symbol name with lib prefix and
+# symbol address.
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix="sed -n"\
+$lt_c_name_lib_hook\
+" -e 's/^: $.*$ .*$/  {\"\1\", (void *) 0},/p'"\
+" -e 's/^$symcode$symcode* .* $lib.*$$/  {\"\1\", (void *) \&\1},/p'"\
+" -e 's/^$symcode$symcode* .* $.*$$/  {\"lib\1\", (void *) \&\1},/p'"
+
+# Handle CRLF in mingw tool chain
+opt_cr=
+case $build_os in
+mingw*)
+  opt_cr=`$ECHO 'x\{0,1\}' | tr x '\015'` # option cr in regexp
+  ;;
+esac
+
+# Try without a prefix underscore, then with it.
+for ac_symprfx in "" "_"; do
+
+  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
+  symxfrm="\\1 $ac_symprfx\\2 \\2"
+
+  # Write the raw and C identifiers.
+  if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+    # Fake it for dumpbin and say T for any non-static function,
+    # D for any global variable and I for any imported variable.
+    # Also find C++ and __fastcall symbols from MSVC++,
+    # which start with @ or ?.
+    lt_cv_sys_global_symbol_pipe="$AWK '"\
+"     {last_section=section; section=\$ 3};"\
+"     /^COFF SYMBOL TABLE/{for(i in hide) delete hidei};"\
+"     /Section length .*#relocs.*(pick any)/{hidelast_section=1};"\
+"     /^ *Symbol name *: /{split(\$ 0,sn,\":\"); si=substr(sn2,2)};"\
+"     /^ *Type *: code/{print \"T\",si,substr(si,length(prfx))};"\
+"     /^ *Type *: data/{print \"I\",si,substr(si,length(prfx))};"\
+"     \$ 0!~/External *\|/{next};"\
+"     / 0+ UNDEF /{next}; / UNDEF $^|$*()/{next};"\
+"     {if(hidesection) next};"\
+"     {f=\"D\"}; \$ 0~/.*\|/{f=\"T\"};"\
+"     {split(\$ 0,a,/\||\r/); split(a2,s)};"\
+"     s1~/^@?/{print f,s1,s1; next};"\
+"     s1~prfx {split(s1,t,\"@\"); print f,t1,substr(t1,length(prfx))}"\
+"     ' prfx=^$ac_symprfx"
+  else
+    lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*	 $$symcode$symcode*$	 	 *$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
+  fi
+  lt_cv_sys_global_symbol_pipe="$lt_cv_sys_global_symbol_pipe | sed '/ __gnu_lto/d'"
+
+  # Check to see that the pipe works correctly.
+  pipe_works=no
+
+  rm -f conftest*
+  cat > conftest.$ac_ext <<_LT_EOF
+#ifdef __cplusplus
+extern "C" {
+#endif
+char nm_test_var;
+void nm_test_func(void);
+void nm_test_func(void){}
+#ifdef __cplusplus
+}
+#endif
+int main(){nm_test_var='a';nm_test_func();return(0);}
+_LT_EOF
+
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    # Now try to grab the symbols.
+    nlist=conftest.nm
+    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&5
+    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&5 && test -s "$nlist"; then
+      # Try sorting and uniquifying the output.
+      if sort "$nlist" | uniq > "$nlist"T; then
+	mv -f "$nlist"T "$nlist"
+      else
+	rm -f "$nlist"T
+      fi
+
+      # Make sure that we snagged all the symbols we need.
+      if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
+	if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
+	  cat <<_LT_EOF > conftest.$ac_ext
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+_LT_EOF
+	  # Now generate the symbol file.
+	  eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
+
+	  cat <<_LT_EOF >> conftest.$ac_ext
+
+/* The mapping between symbol names and symbols.  */
+LT_DLSYM_CONST struct {
+  const char *name;
+  void       *address;
+}
+lt__PROGRAM__LTX_preloaded_symbols =
+{
+  { "@PROGRAM@", (void *) 0 },
+_LT_EOF
+	  $SED "s/^$symcode$symcode* .* $.*$$/  {\"\1\", (void *) \&\1},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
+	  cat <<\_LT_EOF >> conftest.$ac_ext
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt__PROGRAM__LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+_LT_EOF
+	  # Now try linking the two files.
+	  mv conftest.$ac_objext conftstm.$ac_objext
+	  lt_globsym_save_LIBS=$LIBS
+	  lt_globsym_save_CFLAGS=$CFLAGS
+	  LIBS=conftstm.$ac_objext
+	  CFLAGS="$CFLAGS$lt_prog_compiler_no_builtin_flag"
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s conftest$ac_exeext; then
+	    pipe_works=yes
+	  fi
+	  LIBS=$lt_globsym_save_LIBS
+	  CFLAGS=$lt_globsym_save_CFLAGS
+	else
+	  echo "cannot find nm_test_func in $nlist" >&5
+	fi
+      else
+	echo "cannot find nm_test_var in $nlist" >&5
+      fi
+    else
+      echo "cannot run $lt_cv_sys_global_symbol_pipe" >&5
+    fi
+  else
+    echo "$progname: failed program was:" >&5
+    cat conftest.$ac_ext >&5
+  fi
+  rm -rf conftest* conftst*
+
+  # Do not use the global_symbol_pipe unless it works.
+  if test yes = "$pipe_works"; then
+    break
+  else
+    lt_cv_sys_global_symbol_pipe=
+  fi
+done
+
+fi
+
+if test -z "$lt_cv_sys_global_symbol_pipe"; then
+  lt_cv_sys_global_symbol_to_cdecl=
+fi
+if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: failed" >&5
+$as_echo "failed" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: ok" >&5
+$as_echo "ok" >&6; }
+fi
+
+# Response file support.
+if test "$lt_cv_nm_interface" = "MS dumpbin"; then
+  nm_file_list_spec='@'
+elif $NM --help 2>/dev/null | grep '@FILE' >/dev/null; then
+  nm_file_list_spec='@'
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for sysroot" >&5
+$as_echo_n "checking for sysroot... " >&6; }
+
+# Check whether --with-sysroot was given.
+if test "${with_sysroot+set}" = set; then :
+  withval=$with_sysroot;
+else
+  with_sysroot=no
+fi
+
+
+lt_sysroot=
+case $with_sysroot in #(
+ yes)
+   if test yes = "$GCC"; then
+     lt_sysroot=`$CC --print-sysroot 2>/dev/null`
+   fi
+   ;; #(
+ /*)
+   lt_sysroot=`echo "$with_sysroot" | sed -e "$sed_quote_subst"`
+   ;; #(
+ no|'')
+   ;; #(
+ *)
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_sysroot" >&5
+$as_echo "$with_sysroot" >&6; }
+   as_fn_error $? "The sysroot must be an absolute path." "$LINENO" 5
+   ;;
+esac
+
+ { $as_echo "$as_me:${as_lineno-$LINENO}: result: ${lt_sysroot:-no}" >&5
+$as_echo "${lt_sysroot:-no}" >&6; }
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a working dd" >&5
+$as_echo_n "checking for a working dd... " >&6; }
+if ${ac_cv_path_lt_DD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+if test -z "$lt_DD"; then
+  ac_path_lt_DD_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in dd; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_lt_DD="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_lt_DD" || continue
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi
+      $ac_path_lt_DD_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_lt_DD"; then
+    :
+  fi
+else
+  ac_cv_path_lt_DD=$lt_DD
+fi
+
+rm -f conftest.i conftest2.i conftest.out
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_lt_DD" >&5
+$as_echo "$ac_cv_path_lt_DD" >&6; }
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to truncate binary pipes" >&5
+$as_echo_n "checking how to truncate binary pipes... " >&6; }
+if ${lt_cv_truncate_bin+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q"
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_truncate_bin" >&5
+$as_echo "$lt_cv_truncate_bin" >&6; }
+
+
+
+
+
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *\\/compile | ccache | *\\/ccache ) ;;
+        distcc | *\\/distcc | purify | *\\/purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+# Check whether --enable-libtool-lock was given.
+if test "${enable_libtool_lock+set}" = set; then :
+  enableval=$enable_libtool_lock;
+fi
+
+test no = "$enable_libtool_lock" || enable_libtool_lock=yes
+
+# Some flags need to be propagated to the compiler or linker for good
+# libtool support.
+case $host in
+ia64-*-hpux*)
+  # Find out what ABI is being produced by ac_compile, and set mode
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.$ac_objext` in
+      *ELF-32*)
+	HPUX_IA64_MODE=32
+	;;
+      *ELF-64*)
+	HPUX_IA64_MODE=64
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+*-*-irix6*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    if test yes = "$lt_cv_prog_gnu_ld"; then
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -melf32bsmip"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -melf32bmipn32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -melf64bmip"
+	;;
+      esac
+    else
+      case `/usr/bin/file conftest.$ac_objext` in
+	*32-bit*)
+	  LD="${LD-ld} -32"
+	  ;;
+	*N32*)
+	  LD="${LD-ld} -n32"
+	  ;;
+	*64-bit*)
+	  LD="${LD-ld} -64"
+	  ;;
+      esac
+    fi
+  fi
+  rm -rf conftest*
+  ;;
+
+mips64*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo '#line '$LINENO' "configure"' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    emul=elf
+    case `/usr/bin/file conftest.$ac_objext` in
+      *32-bit*)
+	emul="${emul}32"
+	;;
+      *64-bit*)
+	emul="${emul}64"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *MSB*)
+	emul="${emul}btsmip"
+	;;
+      *LSB*)
+	emul="${emul}ltsmip"
+	;;
+    esac
+    case `/usr/bin/file conftest.$ac_objext` in
+      *N32*)
+	emul="${emul}n32"
+	;;
+    esac
+    LD="${LD-ld} -m $emul"
+  fi
+  rm -rf conftest*
+  ;;
+
+x86_64-*kfreebsd*-gnu|x86_64-*linux*|powerpc*-*linux*| \
+s390*-*linux*|s390*-*tpf*|sparc*-*linux*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.  Note that the listed cases only cover the
+  # situations where additional linker options are needed (such as when
+  # doing 32-bit compilation for a host where ld defaults to 64-bit, or
+  # vice versa); the common cases where no linker options are needed do
+  # not appear in the list.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+      *32-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_i386_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    case `/usr/bin/file conftest.o` in
+	      *x86-64*)
+		LD="${LD-ld} -m elf32_x86_64"
+		;;
+	      *)
+		LD="${LD-ld} -m elf_i386"
+		;;
+	    esac
+	    ;;
+	  powerpc64le-*linux*)
+	    LD="${LD-ld} -m elf32lppclinux"
+	    ;;
+	  powerpc64-*linux*)
+	    LD="${LD-ld} -m elf32ppclinux"
+	    ;;
+	  s390x-*linux*)
+	    LD="${LD-ld} -m elf_s390"
+	    ;;
+	  sparc64-*linux*)
+	    LD="${LD-ld} -m elf32_sparc"
+	    ;;
+	esac
+	;;
+      *64-bit*)
+	case $host in
+	  x86_64-*kfreebsd*-gnu)
+	    LD="${LD-ld} -m elf_x86_64_fbsd"
+	    ;;
+	  x86_64-*linux*)
+	    LD="${LD-ld} -m elf_x86_64"
+	    ;;
+	  powerpcle-*linux*)
+	    LD="${LD-ld} -m elf64lppc"
+	    ;;
+	  powerpc-*linux*)
+	    LD="${LD-ld} -m elf64ppc"
+	    ;;
+	  s390*-*linux*|s390*-*tpf*)
+	    LD="${LD-ld} -m elf64_s390"
+	    ;;
+	  sparc*-*linux*)
+	    LD="${LD-ld} -m elf64_sparc"
+	    ;;
+	esac
+	;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+
+*-*-sco3.2v5*)
+  # On SCO OpenServer 5, we need -belf to get full-featured binaries.
+  SAVE_CFLAGS=$CFLAGS
+  CFLAGS="$CFLAGS -belf"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the C compiler needs -belf" >&5
+$as_echo_n "checking whether the C compiler needs -belf... " >&6; }
+if ${lt_cv_cc_needs_belf+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+     cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_cc_needs_belf=yes
+else
+  lt_cv_cc_needs_belf=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+     ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_cc_needs_belf" >&5
+$as_echo "$lt_cv_cc_needs_belf" >&6; }
+  if test yes != "$lt_cv_cc_needs_belf"; then
+    # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
+    CFLAGS=$SAVE_CFLAGS
+  fi
+  ;;
+*-*solaris*)
+  # Find out what ABI is being produced by ac_compile, and set linker
+  # options accordingly.
+  echo 'int i;' > conftest.$ac_ext
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+    case `/usr/bin/file conftest.o` in
+    *64-bit*)
+      case $lt_cv_prog_gnu_ld in
+      yes*)
+        case $host in
+        i?86-*-solaris*|x86_64-*-solaris*)
+          LD="${LD-ld} -m elf_x86_64"
+          ;;
+        sparc*-*-solaris*)
+          LD="${LD-ld} -m elf64_sparc"
+          ;;
+        esac
+        # GNU ld 2.21 introduced _sol2 emulations.  Use them if available.
+        if ${LD-ld} -V | grep _sol2 >/dev/null 2>&1; then
+          LD=${LD-ld}_sol2
+        fi
+        ;;
+      *)
+	if ${LD-ld} -64 -r -o conftest2.o conftest.o >/dev/null 2>&1; then
+	  LD="${LD-ld} -64"
+	fi
+	;;
+      esac
+      ;;
+    esac
+  fi
+  rm -rf conftest*
+  ;;
+esac
+
+need_locks=$enable_libtool_lock
+
+if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}mt", so it can be a program name with args.
+set dummy ${ac_tool_prefix}mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_MANIFEST_TOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$MANIFEST_TOOL"; then
+  ac_cv_prog_MANIFEST_TOOL="$MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_MANIFEST_TOOL="${ac_tool_prefix}mt"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+MANIFEST_TOOL=$ac_cv_prog_MANIFEST_TOOL
+if test -n "$MANIFEST_TOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MANIFEST_TOOL" >&5
+$as_echo "$MANIFEST_TOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_MANIFEST_TOOL"; then
+  ac_ct_MANIFEST_TOOL=$MANIFEST_TOOL
+  # Extract the first word of "mt", so it can be a program name with args.
+set dummy mt; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_MANIFEST_TOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_MANIFEST_TOOL"; then
+  ac_cv_prog_ac_ct_MANIFEST_TOOL="$ac_ct_MANIFEST_TOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_MANIFEST_TOOL="mt"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_MANIFEST_TOOL=$ac_cv_prog_ac_ct_MANIFEST_TOOL
+if test -n "$ac_ct_MANIFEST_TOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_MANIFEST_TOOL" >&5
+$as_echo "$ac_ct_MANIFEST_TOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_MANIFEST_TOOL" = x; then
+    MANIFEST_TOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    MANIFEST_TOOL=$ac_ct_MANIFEST_TOOL
+  fi
+else
+  MANIFEST_TOOL="$ac_cv_prog_MANIFEST_TOOL"
+fi
+
+test -z "$MANIFEST_TOOL" && MANIFEST_TOOL=mt
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $MANIFEST_TOOL is a manifest tool" >&5
+$as_echo_n "checking if $MANIFEST_TOOL is a manifest tool... " >&6; }
+if ${lt_cv_path_mainfest_tool+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_path_mainfest_tool=no
+  echo "$as_me:$LINENO: $MANIFEST_TOOL '-?'" >&5
+  $MANIFEST_TOOL '-?' 2>conftest.err > conftest.out
+  cat conftest.err >&5
+  if $GREP 'Manifest Tool' conftest.out > /dev/null; then
+    lt_cv_path_mainfest_tool=yes
+  fi
+  rm -f conftest*
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_path_mainfest_tool" >&5
+$as_echo "$lt_cv_path_mainfest_tool" >&6; }
+if test yes != "$lt_cv_path_mainfest_tool"; then
+  MANIFEST_TOOL=:
+fi
+
+
+
+
+
+
+  case $host_os in
+    rhapsody* | darwin*)
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}dsymutil", so it can be a program name with args.
+set dummy ${ac_tool_prefix}dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_DSYMUTIL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$DSYMUTIL"; then
+  ac_cv_prog_DSYMUTIL="$DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_DSYMUTIL="${ac_tool_prefix}dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+DSYMUTIL=$ac_cv_prog_DSYMUTIL
+if test -n "$DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $DSYMUTIL" >&5
+$as_echo "$DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_DSYMUTIL"; then
+  ac_ct_DSYMUTIL=$DSYMUTIL
+  # Extract the first word of "dsymutil", so it can be a program name with args.
+set dummy dsymutil; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_DSYMUTIL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_DSYMUTIL"; then
+  ac_cv_prog_ac_ct_DSYMUTIL="$ac_ct_DSYMUTIL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_DSYMUTIL="dsymutil"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_DSYMUTIL=$ac_cv_prog_ac_ct_DSYMUTIL
+if test -n "$ac_ct_DSYMUTIL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_DSYMUTIL" >&5
+$as_echo "$ac_ct_DSYMUTIL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_DSYMUTIL" = x; then
+    DSYMUTIL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    DSYMUTIL=$ac_ct_DSYMUTIL
+  fi
+else
+  DSYMUTIL="$ac_cv_prog_DSYMUTIL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}nmedit", so it can be a program name with args.
+set dummy ${ac_tool_prefix}nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_NMEDIT+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$NMEDIT"; then
+  ac_cv_prog_NMEDIT="$NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_NMEDIT="${ac_tool_prefix}nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+NMEDIT=$ac_cv_prog_NMEDIT
+if test -n "$NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $NMEDIT" >&5
+$as_echo "$NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_NMEDIT"; then
+  ac_ct_NMEDIT=$NMEDIT
+  # Extract the first word of "nmedit", so it can be a program name with args.
+set dummy nmedit; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_NMEDIT+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_NMEDIT"; then
+  ac_cv_prog_ac_ct_NMEDIT="$ac_ct_NMEDIT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_NMEDIT="nmedit"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_NMEDIT=$ac_cv_prog_ac_ct_NMEDIT
+if test -n "$ac_ct_NMEDIT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_NMEDIT" >&5
+$as_echo "$ac_ct_NMEDIT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_NMEDIT" = x; then
+    NMEDIT=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    NMEDIT=$ac_ct_NMEDIT
+  fi
+else
+  NMEDIT="$ac_cv_prog_NMEDIT"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}lipo", so it can be a program name with args.
+set dummy ${ac_tool_prefix}lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_LIPO+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$LIPO"; then
+  ac_cv_prog_LIPO="$LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_LIPO="${ac_tool_prefix}lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+LIPO=$ac_cv_prog_LIPO
+if test -n "$LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LIPO" >&5
+$as_echo "$LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_LIPO"; then
+  ac_ct_LIPO=$LIPO
+  # Extract the first word of "lipo", so it can be a program name with args.
+set dummy lipo; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_LIPO+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_LIPO"; then
+  ac_cv_prog_ac_ct_LIPO="$ac_ct_LIPO" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_LIPO="lipo"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_LIPO=$ac_cv_prog_ac_ct_LIPO
+if test -n "$ac_ct_LIPO"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_LIPO" >&5
+$as_echo "$ac_ct_LIPO" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_LIPO" = x; then
+    LIPO=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    LIPO=$ac_ct_LIPO
+  fi
+else
+  LIPO="$ac_cv_prog_LIPO"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL"; then
+  ac_cv_prog_OTOOL="$OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL="${ac_tool_prefix}otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL=$ac_cv_prog_OTOOL
+if test -n "$OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL" >&5
+$as_echo "$OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL"; then
+  ac_ct_OTOOL=$OTOOL
+  # Extract the first word of "otool", so it can be a program name with args.
+set dummy otool; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL"; then
+  ac_cv_prog_ac_ct_OTOOL="$ac_ct_OTOOL" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL="otool"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL=$ac_cv_prog_ac_ct_OTOOL
+if test -n "$ac_ct_OTOOL"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL" >&5
+$as_echo "$ac_ct_OTOOL" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL" = x; then
+    OTOOL=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL=$ac_ct_OTOOL
+  fi
+else
+  OTOOL="$ac_cv_prog_OTOOL"
+fi
+
+    if test -n "$ac_tool_prefix"; then
+  # Extract the first word of "${ac_tool_prefix}otool64", so it can be a program name with args.
+set dummy ${ac_tool_prefix}otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_OTOOL64+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$OTOOL64"; then
+  ac_cv_prog_OTOOL64="$OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_OTOOL64="${ac_tool_prefix}otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+OTOOL64=$ac_cv_prog_OTOOL64
+if test -n "$OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $OTOOL64" >&5
+$as_echo "$OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+fi
+if test -z "$ac_cv_prog_OTOOL64"; then
+  ac_ct_OTOOL64=$OTOOL64
+  # Extract the first word of "otool64", so it can be a program name with args.
+set dummy otool64; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_ac_ct_OTOOL64+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$ac_ct_OTOOL64"; then
+  ac_cv_prog_ac_ct_OTOOL64="$ac_ct_OTOOL64" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_ac_ct_OTOOL64="otool64"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+ac_ct_OTOOL64=$ac_cv_prog_ac_ct_OTOOL64
+if test -n "$ac_ct_OTOOL64"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_ct_OTOOL64" >&5
+$as_echo "$ac_ct_OTOOL64" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+  if test "x$ac_ct_OTOOL64" = x; then
+    OTOOL64=":"
+  else
+    case $cross_compiling:$ac_tool_warned in
+yes:)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: using cross tools not prefixed with host triplet" >&5
+$as_echo "$as_me: WARNING: using cross tools not prefixed with host triplet" >&2;}
+ac_tool_warned=yes ;;
+esac
+    OTOOL64=$ac_ct_OTOOL64
+  fi
+else
+  OTOOL64="$ac_cv_prog_OTOOL64"
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -single_module linker flag" >&5
+$as_echo_n "checking for -single_module linker flag... " >&6; }
+if ${lt_cv_apple_cc_single_mod+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_apple_cc_single_mod=no
+      if test -z "$LT_MULTI_MODULE"; then
+	# By default we will add the -single_module flag. You can override
+	# by either setting the environment variable LT_MULTI_MODULE
+	# non-empty at configure time, or by adding -multi_module to the
+	# link flags.
+	rm -rf libconftest.dylib*
+	echo "int foo(void){return 1;}" > conftest.c
+	echo "$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+-dynamiclib -Wl,-single_module conftest.c" >&5
+	$LTCC $LTCFLAGS $LDFLAGS -o libconftest.dylib \
+	  -dynamiclib -Wl,-single_module conftest.c 2>conftest.err
+        _lt_result=$?
+	# If there is a non-empty error log, and "single_module"
+	# appears in it, assume the flag caused a linker warning
+        if test -s conftest.err && $GREP single_module conftest.err; then
+	  cat conftest.err >&5
+	# Otherwise, if the output was created with a 0 exit code from
+	# the compiler, it worked.
+	elif test -f libconftest.dylib && test 0 = "$_lt_result"; then
+	  lt_cv_apple_cc_single_mod=yes
+	else
+	  cat conftest.err >&5
+	fi
+	rm -rf libconftest.dylib*
+	rm -f conftest.*
+      fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_apple_cc_single_mod" >&5
+$as_echo "$lt_cv_apple_cc_single_mod" >&6; }
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -exported_symbols_list linker flag" >&5
+$as_echo_n "checking for -exported_symbols_list linker flag... " >&6; }
+if ${lt_cv_ld_exported_symbols_list+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_exported_symbols_list=no
+      save_LDFLAGS=$LDFLAGS
+      echo "_main" > conftest.sym
+      LDFLAGS="$LDFLAGS -Wl,-exported_symbols_list,conftest.sym"
+      cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_ld_exported_symbols_list=yes
+else
+  lt_cv_ld_exported_symbols_list=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+	LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_exported_symbols_list" >&5
+$as_echo "$lt_cv_ld_exported_symbols_list" >&6; }
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for -force_load linker flag" >&5
+$as_echo_n "checking for -force_load linker flag... " >&6; }
+if ${lt_cv_ld_force_load+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_ld_force_load=no
+      cat > conftest.c << _LT_EOF
+int forced_loaded() { return 2;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&5
+      $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&5
+      echo "$AR cr libconftest.a conftest.o" >&5
+      $AR cr libconftest.a conftest.o 2>&5
+      echo "$RANLIB libconftest.a" >&5
+      $RANLIB libconftest.a 2>&5
+      cat > conftest.c << _LT_EOF
+int main() { return 0;}
+_LT_EOF
+      echo "$LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a" >&5
+      $LTCC $LTCFLAGS $LDFLAGS -o conftest conftest.c -Wl,-force_load,./libconftest.a 2>conftest.err
+      _lt_result=$?
+      if test -s conftest.err && $GREP force_load conftest.err; then
+	cat conftest.err >&5
+      elif test -f conftest && test 0 = "$_lt_result" && $GREP forced_load conftest >/dev/null 2>&1; then
+	lt_cv_ld_force_load=yes
+      else
+	cat conftest.err >&5
+      fi
+        rm -f conftest.err libconftest.a conftest conftest.c
+        rm -rf conftest.dSYM
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_ld_force_load" >&5
+$as_echo "$lt_cv_ld_force_load" >&6; }
+    case $host_os in
+    rhapsody* | darwin1.012)
+      _lt_dar_allow_undefined='$wl-undefined ${wl}suppress' ;;
+    darwin1.*)
+      _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+    darwin*) # darwin 5.x on
+      # if running on 10.5 or later, the deployment target defaults
+      # to the OS version, if on x86, and 10.4, the deployment
+      # target defaults to 10.4. Don't you love it?
+      case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
+	10.0,*86*-darwin8*|10.0,*-darwin91*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+	10.012,.*)
+	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
+	10.*)
+	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
+      esac
+    ;;
+  esac
+    if test yes = "$lt_cv_apple_cc_single_mod"; then
+      _lt_dar_single_mod='$single_module'
+    fi
+    if test yes = "$lt_cv_ld_exported_symbols_list"; then
+      _lt_dar_export_syms=' $wl-exported_symbols_list,$output_objdir/$libname-symbols.expsym'
+    else
+      _lt_dar_export_syms='~$NMEDIT -s $output_objdir/$libname-symbols.expsym $lib'
+    fi
+    if test : != "$DSYMUTIL" && test no = "$lt_cv_ld_force_load"; then
+      _lt_dsymutil='~$DSYMUTIL $lib || :'
+    else
+      _lt_dsymutil=
+    fi
+    ;;
+  esac
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR:DIR:"
+#       string "DIR DIR" will be prepended to VARIABLE
+# ":DIR:DIR"
+#       string "DIR DIR" will be appended to VARIABLE
+# "DIRP:DIRP::DIRA:DIRA"
+#       string "DIRP DIRP" will be prepended to VARIABLE and string
+#       "DIRA DIRA" will be appended to VARIABLE
+# "DIR:DIR"
+#       VARIABLE will be replaced by "DIR DIR"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for ANSI C header files" >&5
+$as_echo_n "checking for ANSI C header files... " >&6; }
+if ${ac_cv_header_stdc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <float.h>
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  ac_cv_header_stdc=yes
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+
+if test $ac_cv_header_stdc = yes; then
+  # SunOS 4.x string.h does not declare mem*, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <string.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "memchr" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # ISC 2.0.2 stdlib.h does not declare free, contrary to ANSI.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdlib.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "free" >/dev/null 2>&1; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f conftest*
+
+fi
+
+if test $ac_cv_header_stdc = yes; then
+  # /bin/cc in Irix-4.0.5 gets non-ANSI ctype macros unless using -ansi.
+  if test "$cross_compiling" = yes; then :
+  :
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ctype.h>
+#include <stdlib.h>
+#if ((' ' & 0x0FF) == 0x020)
+# define ISLOWER(c) ('a' <= (c) && (c) <= 'z')
+# define TOUPPER(c) (ISLOWER(c) ? 'A' + ((c) - 'a') : (c))
+#else
+# define ISLOWER(c) \
+		   (('a' <= (c) && (c) <= 'i') \
+		     || ('j' <= (c) && (c) <= 'r') \
+		     || ('s' <= (c) && (c) <= 'z'))
+# define TOUPPER(c) (ISLOWER(c) ? ((c) | 0x40) : (c))
+#endif
+
+#define XOR(e, f) (((e) && !(f)) || (!(e) && (f)))
+int
+main ()
+{
+  int i;
+  for (i = 0; i < 256; i++)
+    if (XOR (islower (i), ISLOWER (i))
+	|| toupper (i) != TOUPPER (i))
+      return 2;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_run "$LINENO"; then :
+
+else
+  ac_cv_header_stdc=no
+fi
+rm -f core *.core core.conftest.* gmon.out bb.out conftest$ac_exeext \
+  conftest.$ac_objext conftest.beam conftest.$ac_ext
+fi
+
+fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_header_stdc" >&5
+$as_echo "$ac_cv_header_stdc" >&6; }
+if test $ac_cv_header_stdc = yes; then
+
+$as_echo "#define STDC_HEADERS 1" >>confdefs.h
+
+fi
+
+# On IRIX 5.3, sys/types and inttypes.h are conflicting.
+for ac_header in sys/types.h sys/stat.h stdlib.h string.h memory.h strings.h \
+		  inttypes.h stdint.h unistd.h
+do :
+  as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
+ac_fn_c_check_header_compile "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default
+"
+if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
+  cat >>confdefs.h <<_ACEOF
+#define `$as_echo "HAVE_$ac_header" | $as_tr_cpp` 1
+_ACEOF
+
+fi
+
+done
+
+
+for ac_header in dlfcn.h
+do :
+  ac_fn_c_check_header_compile "$LINENO" "dlfcn.h" "ac_cv_header_dlfcn_h" "$ac_includes_default
+"
+if test "x$ac_cv_header_dlfcn_h" = xyes; then :
+  cat >>confdefs.h <<_ACEOF
+#define HAVE_DLFCN_H 1
+_ACEOF
+
+fi
+
+done
+
+
+
+func_stripname_cnf ()
+{
+  case $2 in
+  .*) func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%\\\\$2\$%%"`;;
+  *)  func_stripname_result=`$ECHO "$3" | $SED "s%^$1%%; s%$2\$%%"`;;
+  esac
+} # func_stripname_cnf
+
+
+
+
+
+# Set options
+
+
+
+        enable_dlopen=no
+
+
+  enable_win32_dll=no
+
+
+
+  # Check whether --enable-static was given.
+if test "${enable_static+set}" = set; then :
+  enableval=$enable_static; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_static=yes ;;
+    no) enable_static=no ;;
+    *)
+     enable_static=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_static=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_static=yes
+fi
+
+
+
+
+
+
+
+
+
+
+# Check whether --with-pic was given.
+if test "${with_pic+set}" = set; then :
+  withval=$with_pic; lt_p=${PACKAGE-default}
+    case $withval in
+    yes|no) pic_mode=$withval ;;
+    *)
+      pic_mode=default
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for lt_pkg in $withval; do
+	IFS=$lt_save_ifs
+	if test "X$lt_pkg" = "X$lt_p"; then
+	  pic_mode=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  pic_mode=default
+fi
+
+
+
+
+
+
+
+
+  # Check whether --enable-fast-install was given.
+if test "${enable_fast_install+set}" = set; then :
+  enableval=$enable_fast_install; p=${PACKAGE-default}
+    case $enableval in
+    yes) enable_fast_install=yes ;;
+    no) enable_fast_install=no ;;
+    *)
+      enable_fast_install=no
+      # Look at the argument we got.  We use all the common list separators.
+      lt_save_ifs=$IFS; IFS=$IFS$PATH_SEPARATOR,
+      for pkg in $enableval; do
+	IFS=$lt_save_ifs
+	if test "X$pkg" = "X$p"; then
+	  enable_fast_install=yes
+	fi
+      done
+      IFS=$lt_save_ifs
+      ;;
+    esac
+else
+  enable_fast_install=yes
+fi
+
+
+
+
+
+
+
+
+  shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix5-9*,yes)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking which variant of shared library versioning to provide" >&5
+$as_echo_n "checking which variant of shared library versioning to provide... " >&6; }
+
+# Check whether --with-aix-soname was given.
+if test "${with_aix_soname+set}" = set; then :
+  withval=$with_aix_soname; case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      as_fn_error $? "Unknown argument to --with-aix-soname" "$LINENO" 5
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname
+else
+  if ${lt_cv_with_aix_soname+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_with_aix_soname=aix
+fi
+
+    with_aix_soname=$lt_cv_with_aix_soname
+fi
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $with_aix_soname" >&5
+$as_echo "$with_aix_soname" >&6; }
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+# This can be used to rebuild libtool when needed
+LIBTOOL_DEPS=$ltmain
+
+# Always use our own libtool.
+LIBTOOL='$(SHELL) $(top_builddir)/libtool'
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+test -z "$LN_S" && LN_S="ln -s"
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+if test -n "${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for objdir" >&5
+$as_echo_n "checking for objdir... " >&6; }
+if ${lt_cv_objdir+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  rm -f .libs 2>/dev/null
+mkdir .libs 2>/dev/null
+if test -d .libs; then
+  lt_cv_objdir=.libs
+else
+  # MS-DOS does not allow filenames that begin with a dot.
+  lt_cv_objdir=_libs
+fi
+rmdir .libs 2>/dev/null
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_objdir" >&5
+$as_echo "$lt_cv_objdir" >&6; }
+objdir=$lt_cv_objdir
+
+
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define LT_OBJDIR "$lt_cv_objdir/"
+_ACEOF
+
+
+
+
+case $host_os in
+aix3*)
+  # AIX sometimes has problems with the GCC collect2 program.  For some
+  # reason, if we set the COLLECT_NAMES environment variable, the problems
+  # vanish in a puff of smoke.
+  if test set != "${COLLECT_NAMES+set}"; then
+    COLLECT_NAMES=
+    export COLLECT_NAMES
+  fi
+  ;;
+esac
+
+# Global variables:
+ofile=libtool
+can_build_shared=yes
+
+# All known linkers require a '.a' archive for static linking (except MSVC,
+# which needs '.lib').
+libext=a
+
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+old_CC=$CC
+old_CFLAGS=$CFLAGS
+
+# Set sane defaults for various variables
+test -z "$CC" && CC=cc
+test -z "$LTCC" && LTCC=$CC
+test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
+test -z "$LD" && LD=ld
+test -z "$ac_objext" && ac_objext=o
+
+func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+
+# Only perform the check for file, if the check method requires it
+test -z "$MAGIC_CMD" && MAGIC_CMD=file
+case $deplibs_check_method in
+file_magic*)
+  if test "$file_magic_cmd" = '$MAGIC_CMD'; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ${ac_tool_prefix}file" >&5
+$as_echo_n "checking for ${ac_tool_prefix}file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+\\/* |  ?:\\/*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/${ac_tool_prefix}file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"${ac_tool_prefix}file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic $.*$"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+
+
+
+if test -z "$lt_cv_path_MAGIC_CMD"; then
+  if test -n "$ac_tool_prefix"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for file" >&5
+$as_echo_n "checking for file... " >&6; }
+if ${lt_cv_path_MAGIC_CMD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $MAGIC_CMD in
+\\/* |  ?:\\/*)
+  lt_cv_path_MAGIC_CMD=$MAGIC_CMD # Let the user override the test with a path.
+  ;;
+*)
+  lt_save_MAGIC_CMD=$MAGIC_CMD
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  ac_dummy="/usr/bin$PATH_SEPARATOR$PATH"
+  for ac_dir in $ac_dummy; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/file"; then
+      lt_cv_path_MAGIC_CMD=$ac_dir/"file"
+      if test -n "$file_magic_test_file"; then
+	case $deplibs_check_method in
+	"file_magic "*)
+	  file_magic_regex=`expr "$deplibs_check_method" : "file_magic $.*$"`
+	  MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+	  if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
+	    $EGREP "$file_magic_regex" > /dev/null; then
+	    :
+	  else
+	    cat <<_LT_EOF 1>&2
+
+*** Warning: the command libtool uses to detect shared libraries,
+*** $file_magic_cmd, produces output that libtool cannot recognize.
+*** The result is that libtool may fail to recognize shared libraries
+*** as such.  This will affect the creation of libtool libraries that
+*** depend on shared libraries, but programs linked with such libtool
+*** libraries will work regardless of this problem.  Nevertheless, you
+*** may want to report the problem to your system manager and/or to
+*** bug-libtool@gnu.org
+
+_LT_EOF
+	  fi ;;
+	esac
+      fi
+      break
+    fi
+  done
+  IFS=$lt_save_ifs
+  MAGIC_CMD=$lt_save_MAGIC_CMD
+  ;;
+esac
+fi
+
+MAGIC_CMD=$lt_cv_path_MAGIC_CMD
+if test -n "$MAGIC_CMD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $MAGIC_CMD" >&5
+$as_echo "$MAGIC_CMD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+  else
+    MAGIC_CMD=:
+  fi
+fi
+
+  fi
+  ;;
+esac
+
+# Use C for the default configuration in the libtool script
+
+lt_save_CC=$CC
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+# Source file extension for C test sources.
+ac_ext=c
+
+# Object file extension for compiled C test sources.
+objext=o
+objext=$objext
+
+# Code to be used in simple compile tests
+lt_simple_compile_test_code="int some_variable = 0;"
+
+# Code to be used in simple link tests
+lt_simple_link_test_code='int main(){return(0);}'
+
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+# Save the default compiler, since it gets overwritten when the other
+# tags are being tested, and _LT_TAGVAR(compiler, ) is a NOP.
+compiler_DEFAULT=$CC
+
+# save warnings/boilerplate of simple test code
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+## CAVEAT EMPTOR:
+## There is no encapsulation within the following macros, do not change
+## the running order or otherwise move them around unless you know exactly
+## what you are doing...
+if test -n "$compiler"; then
+
+lt_prog_compiler_no_builtin_flag=
+
+if test yes = "$GCC"; then
+  case $cc_basename in
+  nvcc*)
+    lt_prog_compiler_no_builtin_flag=' -Xcompiler -fno-builtin' ;;
+  *)
+    lt_prog_compiler_no_builtin_flag=' -fno-builtin' ;;
+  esac
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -fno-rtti -fno-exceptions" >&5
+$as_echo_n "checking if $compiler supports -fno-rtti -fno-exceptions... " >&6; }
+if ${lt_cv_prog_compiler_rtti_exceptions+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_rtti_exceptions=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="-fno-rtti -fno-exceptions"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_rtti_exceptions=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_rtti_exceptions" >&5
+$as_echo "$lt_cv_prog_compiler_rtti_exceptions" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_rtti_exceptions"; then
+    lt_prog_compiler_no_builtin_flag="$lt_prog_compiler_no_builtin_flag -fno-rtti -fno-exceptions"
+else
+    :
+fi
+
+fi
+
+
+
+
+
+
+  lt_prog_compiler_wl=
+lt_prog_compiler_pic=
+lt_prog_compiler_static=
+
+
+  if test yes = "$GCC"; then
+    lt_prog_compiler_wl='-Wl,'
+    lt_prog_compiler_static='-static'
+
+    case $host_os in
+      aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            lt_prog_compiler_pic='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      ;;
+
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static=
+      ;;
+
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='-fPIC'
+	;;
+      esac
+      ;;
+
+    interix3-9*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+
+    msdosdjgpp*)
+      # Just because we use GCC doesn't mean we suddenly get shared libraries
+      # on systems that don't support them.
+      lt_prog_compiler_can_build_shared=no
+      enable_shared=no
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic=-Kconform_pic
+      fi
+      ;;
+
+    *)
+      lt_prog_compiler_pic='-fPIC'
+      ;;
+    esac
+
+    case $cc_basename in
+    nvcc*) # Cuda Compiler Driver 2.2
+      lt_prog_compiler_wl='-Xlinker '
+      if test -n "$lt_prog_compiler_pic"; then
+        lt_prog_compiler_pic="-Xcompiler $lt_prog_compiler_pic"
+      fi
+      ;;
+    esac
+  else
+    # PORTME Check for flag to pass linker flags through the system compiler.
+    case $host_os in
+    aix*)
+      lt_prog_compiler_wl='-Wl,'
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static='-Bstatic'
+      else
+	lt_prog_compiler_static='-bnso -bI:/lib/syscalls.exp'
+      fi
+      ;;
+
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic='-fno-common'
+      case $cc_basename in
+      nagfor*)
+        # NAG Fortran compiler
+        lt_prog_compiler_wl='-Wl,-Wl,,'
+        lt_prog_compiler_pic='-PIC'
+        lt_prog_compiler_static='-Bstatic'
+        ;;
+      esac
+      ;;
+
+    mingw* | cygwin* | pw32* | os2* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      lt_prog_compiler_pic='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static='$wl-static'
+	;;
+      esac
+      ;;
+
+    hpux9* | hpux10* | hpux11*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
+      # not for PA HP-UX.
+      case $host_cpu in
+      hppa*64*|ia64*)
+	# +Z the default
+	;;
+      *)
+	lt_prog_compiler_pic='+Z'
+	;;
+      esac
+      # Is there a better lt_prog_compiler_static that works with the bundled CC?
+      lt_prog_compiler_static='$wl-a ${wl}archive'
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      lt_prog_compiler_wl='-Wl,'
+      # PIC (with -KPIC) is the default.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+      case $cc_basename in
+      # old Intel for x86_64, which still supported -KPIC.
+      ecc*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-KPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # flang / f18. f95 an alias for gfortran or flang on Debian
+      flang* | f18* | f95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # icc used to be incompatible with GCC.
+      # ICC 10 doesn't accept -KPIC any more.
+      icc* | ifort*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+        ;;
+      # Lahey Fortran 8.1.
+      lf95*)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='--shared'
+	lt_prog_compiler_static='--static'
+	;;
+      nagfor*)
+	# NAG Fortran compiler
+	lt_prog_compiler_wl='-Wl,-Wl,,'
+	lt_prog_compiler_pic='-PIC'
+	lt_prog_compiler_static='-Bstatic'
+	;;
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fPIC'
+	lt_prog_compiler_static='-static'
+	;;
+      pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*)
+        # Portland Group compilers (*not* the Pentium gcc compiler,
+	# which looks to be a dead project)
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-fpic'
+	lt_prog_compiler_static='-Bstatic'
+        ;;
+      ccc*)
+        lt_prog_compiler_wl='-Wl,'
+        # All Alpha code is PIC.
+        lt_prog_compiler_static='-non_shared'
+        ;;
+      xl* | bgxl* | bgf* | mpixl*)
+	# IBM XL C 8.0/Fortran 10.1, 11.1 on PPC and BlueGene
+	lt_prog_compiler_wl='-Wl,'
+	lt_prog_compiler_pic='-qpic'
+	lt_prog_compiler_static='-qstaticlink'
+	;;
+      *)
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ Ceres\ Fortran* | *Sun*Fortran*\ 1-7.* | *Sun*Fortran*\ 8.0-3*)
+	  # Sun Fortran 8.3 passes all unrecognized flags to the linker
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl=''
+	  ;;
+	*Sun\ F* | *Sun*Fortran*)
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Qoption ld '
+	  ;;
+	*Sun\ C*)
+	  # Sun C 5.9
+	  lt_prog_compiler_pic='-KPIC'
+	  lt_prog_compiler_static='-Bstatic'
+	  lt_prog_compiler_wl='-Wl,'
+	  ;;
+        *Intel*\ CF*Compiler*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fPIC'
+	  lt_prog_compiler_static='-static'
+	  ;;
+	*Portland\ Group*)
+	  lt_prog_compiler_wl='-Wl,'
+	  lt_prog_compiler_pic='-fpic'
+	  lt_prog_compiler_static='-Bstatic'
+	  ;;
+	esac
+	;;
+      esac
+      ;;
+
+    newsos6)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *nto* | *qnx*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic='-fPIC -shared'
+      ;;
+
+    osf3* | osf4* | osf5*)
+      lt_prog_compiler_wl='-Wl,'
+      # All OSF/1 code is PIC.
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    rdos*)
+      lt_prog_compiler_static='-non_shared'
+      ;;
+
+    solaris*)
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      case $cc_basename in
+      f77* | f90* | f95* | sunf77* | sunf90* | sunf95*)
+	lt_prog_compiler_wl='-Qoption ld ';;
+      *)
+	lt_prog_compiler_wl='-Wl,';;
+      esac
+      ;;
+
+    sunos4*)
+      lt_prog_compiler_wl='-Qoption ld '
+      lt_prog_compiler_pic='-PIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4 | sysv4.2uw2* | sysv4.3*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic='-Kconform_pic'
+	lt_prog_compiler_static='-Bstatic'
+      fi
+      ;;
+
+    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_pic='-KPIC'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    unicos*)
+      lt_prog_compiler_wl='-Wl,'
+      lt_prog_compiler_can_build_shared=no
+      ;;
+
+    uts4*)
+      lt_prog_compiler_pic='-pic'
+      lt_prog_compiler_static='-Bstatic'
+      ;;
+
+    *)
+      lt_prog_compiler_can_build_shared=no
+      ;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic=
+    ;;
+  *)
+    lt_prog_compiler_pic="$lt_prog_compiler_pic -DPIC"
+    ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+if ${lt_cv_prog_compiler_pic+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic=$lt_prog_compiler_pic
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic" >&5
+$as_echo "$lt_cv_prog_compiler_pic" >&6; }
+lt_prog_compiler_pic=$lt_cv_prog_compiler_pic
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic works... " >&6; }
+if ${lt_cv_prog_compiler_pic_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic_works=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic -DPIC"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_pic_works"; then
+    case $lt_prog_compiler_pic in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic=" $lt_prog_compiler_pic" ;;
+     esac
+else
+    lt_prog_compiler_pic=
+     lt_prog_compiler_can_build_shared=no
+fi
+
+fi
+
+
+
+
+
+
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl eval lt_tmp_static_flag=\"$lt_prog_compiler_static\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if ${lt_cv_prog_compiler_static_works+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_static_works=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works" >&5
+$as_echo "$lt_cv_prog_compiler_static_works" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_static_works"; then
+    :
+else
+    lt_prog_compiler_static=
+fi
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o" >&5
+$as_echo "$lt_cv_prog_compiler_c_o" >&6; }
+
+
+
+
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+  if test no = "$hard_links"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  runpath_var=
+  allow_undefined_flag=
+  always_export_symbols=no
+  archive_cmds=
+  archive_expsym_cmds=
+  compiler_needs_object=no
+  enable_shared_with_static_runtimes=no
+  export_dynamic_flag_spec=
+  export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  hardcode_automatic=no
+  hardcode_direct=no
+  hardcode_direct_absolute=no
+  hardcode_libdir_flag_spec=
+  hardcode_libdir_separator=
+  hardcode_minus_L=no
+  hardcode_shlibpath_var=unsupported
+  inherit_rpath=no
+  link_all_deplibs=unknown
+  module_cmds=
+  module_expsym_cmds=
+  old_archive_from_new_cmds=
+  old_archive_from_expsyms_cmds=
+  thread_safe_flag_spec=
+  whole_archive_flag_spec=
+  # include_expsyms should be a list of space-separated symbols to be *always*
+  # included in the symbol list
+  include_expsyms=
+  # exclude_expsyms can be an extended regexp of symbols to exclude
+  # it will be wrapped by ' (' and ')$', so one must not match beginning or
+  # end of line.  Example: 'a|bc|.*d.*' will exclude the symbols 'a' and 'bc',
+  # as well as any symbol that contains 'd'.
+  exclude_expsyms='_GLOBAL_OFFSET_TABLE_|_GLOBAL__FID_.*'
+  # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
+  # platforms (ab)use it in PIC code, but their linkers get confused if
+  # the symbol is explicitly referenced.  Since portable code cannot
+  # rely on this symbol name, it's probably fine to never include it in
+  # preloaded symbol tables.
+  # Exclude shared library initialization/finalization symbols.
+  extract_expsyms_cmds=
+
+  case $host_os in
+  cygwin* | mingw* | pw32* | cegcc*)
+    # FIXME: the MSVC++ port hasn't been tested in a loooong time
+    # When not using gcc, we currently assume that we are using
+    # Microsoft Visual C++.
+    if test yes != "$GCC"; then
+      with_gnu_ld=no
+    fi
+    ;;
+  interix*)
+    # we just hope/assume this is gcc and not c89 (= MSVC++)
+    with_gnu_ld=yes
+    ;;
+  openbsd* | bitrig*)
+    with_gnu_ld=no
+    ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs=no
+    ;;
+  esac
+
+  ld_shlibs=yes
+
+  # On some targets, GNU ld is compatible enough with the native linker
+  # that we're better off using the native interface for both.
+  lt_use_gnu_ld_interface=no
+  if test yes = "$with_gnu_ld"; then
+    case $host_os in
+      aix*)
+	# The AIX port of GNU ld has always aspired to compatibility
+	# with the native linker.  However, as the warning in the GNU ld
+	# block says, versions before 2.19.5* couldn't really create working
+	# shared libraries, regardless of the interface used.
+	case `$LD -v 2>&1` in
+	  *\ $GNU\ Binutils$\ 2.19.5*) ;;
+	  *\ $GNU\ Binutils$\ 2.2-9*) ;;
+	  *\ $GNU\ Binutils$\ 3-9*) ;;
+	  *)
+	    lt_use_gnu_ld_interface=yes
+	    ;;
+	esac
+	;;
+      *)
+	lt_use_gnu_ld_interface=yes
+	;;
+    esac
+  fi
+
+  if test yes = "$lt_use_gnu_ld_interface"; then
+    # If archive_cmds runs LD, not CC, wlarc should be empty
+    wlarc='$wl'
+
+    # Set some defaults for GNU ld with shared library support. These
+    # are reset later if shared libraries are not supported. Putting them
+    # here allows them to be overridden if necessary.
+    runpath_var=LD_RUN_PATH
+    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+    export_dynamic_flag_spec='$wl--export-dynamic'
+    # ancient GNU ld didn't support --whole-archive et. al.
+    if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
+      whole_archive_flag_spec=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+    else
+      whole_archive_flag_spec=
+    fi
+    supports_anon_versioning=no
+    case `$LD -v | $SED -e 's/(^)\+)\s\+//' 2>&1` in
+      *GNU\ gold*) supports_anon_versioning=yes ;;
+      *\ 01.* | *\ 2.0-9.* | *\ 2.10.*) ;; # catch versions < 2.11
+      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
+      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
+      *\ 2.11.*) ;; # other 2.11 versions
+      *) supports_anon_versioning=yes ;;
+    esac
+
+    # See if GNU ld supports shared libraries.
+    case $host_os in
+    aix3-9*)
+      # On AIX/PPC, the GNU linker is very broken
+      if test ia64 != "$host_cpu"; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: the GNU linker, at least up to release 2.19, is reported
+*** to be unable to reliably create shared libraries on AIX.
+*** Therefore, libtool is disabling shared libraries support.  If you
+*** really care for shared libraries, you may want to install binutils
+*** 2.20 or above, or modify your PATH so that a non-GNU linker is found.
+*** You will then need to restart the configuration process.
+
+_LT_EOF
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    beos*)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	allow_undefined_flag=unsupported
+	# Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	# support --undefined.  This deserves some investigation.  FIXME
+	archive_cmds='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # _LT_TAGVAR(hardcode_libdir_flag_spec, ) is actually meaningless,
+      # as there is no search path for DLLs.
+      hardcode_libdir_flag_spec='-L$libdir'
+      export_dynamic_flag_spec='$wl--export-all-symbols'
+      allow_undefined_flag=unsupported
+      always_export_symbols=no
+      enable_shared_with_static_runtimes=yes
+      export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^BCDGRS /s/.* $^ *$/\1 DATA/;s/^.* __nm__$^ *$ ^ */\1 DATA/;/^I /d;/^AITW /s/.* //'\'' | sort | uniq > $export_symbols'
+      exclude_expsyms='_+GLOBAL_OFFSET_TABLE_|_+GLOBAL__FID_.*|_+head_A-Za-z0-9_+_dll|A-Za-z0-9_+_dll_iname'
+
+      if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+        archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	# If the export-symbols file already is a .def file, use it as
+	# is; otherwise, prepend EXPORTS...
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^	 *//'\''     -e '\''/^$;.*$*$/d'\''     -e '\''s/^$EXPORTS\|LIBRARY$$	 .*$*$/DEF/p'\''     -e q     $export_symbols`" ; then
+          cp $export_symbols $output_objdir/$soname.def;
+        else
+          echo EXPORTS > $output_objdir/$soname.def;
+          cat $export_symbols >> $output_objdir/$soname.def;
+        fi~
+        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    haiku*)
+      archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+      link_all_deplibs=yes
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    interix3-9*)
+      hardcode_direct=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+      export_dynamic_flag_spec='$wl-E'
+      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+      # Instead, shared libraries are loaded at an image base (0x10000000 by
+      # default) and relocated if they conflict, which is a slow very memory
+      # consuming and fragmenting process.  To avoid this, we pick a random,
+      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+      archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      archive_expsym_cmds='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+      ;;
+
+    gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu)
+      tmp_diet=no
+      if test linux-dietlibc = "$host_os"; then
+	case $cc_basename in
+	  diet\ *) tmp_diet=yes;;	# linux-dietlibc with static linking (!diet-dyn)
+	esac
+      fi
+      if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null \
+	 && test no = "$tmp_diet"
+      then
+	tmp_addflag=' $pic_flag'
+	tmp_sharedflag='-shared'
+	case $cc_basename,$host_cpu in
+        pgcc*)				# Portland Group C compiler
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag'
+	  ;;
+	pgf77* | pgf90* | pgf95* | pgfortran*)
+					# Portland Group f77 and f90 compilers
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  tmp_addflag=' $pic_flag -Mnomain' ;;
+	ecc*,ia64* | icc*,ia64*)	# Intel C compiler on ia64
+	  tmp_addflag=' -i_dynamic' ;;
+	efc*,ia64* | ifort*,ia64*)	# Intel Fortran compiler on ia64
+	  tmp_addflag=' -i_dynamic -nofor_main' ;;
+	ifc* | ifort*)			# Intel Fortran compiler
+	  tmp_addflag=' -nofor_main' ;;
+	lf95*)				# Lahey Fortran 8.1
+	  whole_archive_flag_spec=
+	  tmp_sharedflag='--shared' ;;
+        nagfor*)                        # NAGFOR 5.3
+          tmp_sharedflag='-Wl,-shared' ;;
+	xlcC* | bgxlcC* | mpixlcC*) # IBM XL C 8.0 on PPC (deal with xlf below)
+	  tmp_sharedflag='-qmkshrobj'
+	  tmp_addflag= ;;
+	nvcc*)	# Cuda Compiler Driver 2.2
+	  whole_archive_flag_spec='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  ;;
+	esac
+	case `$CC -V 2>&1 | sed 5q` in
+	*Sun\ C*)			# Sun C 5.9
+	  whole_archive_flag_spec='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	  compiler_needs_object=yes
+	  tmp_sharedflag='-G' ;;
+	*Sun\ F*)			# Sun Fortran 8.3
+	  tmp_sharedflag='-G' ;;
+	esac
+	archive_cmds='$CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+
+        if test yes = "$supports_anon_versioning"; then
+          archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+            cat $export_symbols | sed -e "s/$.*$/\1;/" >> $output_objdir/$libname.ver~
+            echo "local: *; };" >> $output_objdir/$libname.ver~
+            $CC '"$tmp_sharedflag""$tmp_addflag"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+        fi
+
+	case $cc_basename in
+	tcc*)
+	  export_dynamic_flag_spec='-rdynamic'
+	  ;;
+	xlf* | bgf* | bgxlf* | mpixlf*)
+	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
+	  whole_archive_flag_spec='--whole-archive$convenience --no-whole-archive'
+	  hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	  archive_cmds='$LD -shared $libobjs $deplibs $linker_flags -soname $soname -o $lib'
+	  if test yes = "$supports_anon_versioning"; then
+	    archive_expsym_cmds='echo "{ global:" > $output_objdir/$libname.ver~
+              cat $export_symbols | sed -e "s/$.*$/\1;/" >> $output_objdir/$libname.ver~
+              echo "local: *; };" >> $output_objdir/$libname.ver~
+              $LD -shared $libobjs $deplibs $linker_flags -soname $soname -version-script $output_objdir/$libname.ver -o $lib'
+	  fi
+	  ;;
+	esac
+      else
+        ld_shlibs=no
+      fi
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
+	wlarc=
+      else
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      fi
+      ;;
+
+    solaris*)
+      if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: The releases 2.8.* of the GNU linker cannot reliably
+*** create shared libraries on Solaris systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.9.1 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+      elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
+      case `$LD -v 2>&1` in
+        *\ 01.* | *\ 2.0-9.* | *\ 2.10-5.*)
+	ld_shlibs=no
+	cat <<_LT_EOF 1>&2
+
+*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 cannot
+*** reliably create shared libraries on SCO systems.  Therefore, libtool
+*** is disabling shared libraries support.  We urge you to upgrade GNU
+*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
+*** your PATH or compiler configuration so that the native linker is
+*** used, and then restart.
+
+_LT_EOF
+	;;
+	*)
+	  # For security reasons, it is highly recommended that you always
+	  # use absolute paths for naming shared libraries, and exclude the
+	  # DT_RUNPATH tag from executables and libraries.  But doing so
+	  # requires that you compile everything twice, which is a pain.
+	  if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	    hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+	    archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	  else
+	    ld_shlibs=no
+	  fi
+	;;
+      esac
+      ;;
+
+    sunos4*)
+      archive_cmds='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      wlarc=
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+      else
+	ld_shlibs=no
+      fi
+      ;;
+    esac
+
+    if test no = "$ld_shlibs"; then
+      runpath_var=
+      hardcode_libdir_flag_spec=
+      export_dynamic_flag_spec=
+      whole_archive_flag_spec=
+    fi
+  else
+    # PORTME fill in a description of your system's linker (not GNU ld)
+    case $host_os in
+    aix3*)
+      allow_undefined_flag=unsupported
+      always_export_symbols=yes
+      archive_expsym_cmds='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
+      # Note: this linker hardcodes the directories in LIBPATH if there
+      # are no directories specified by -L.
+      hardcode_minus_L=yes
+      if test yes = "$GCC" && test -z "$lt_prog_compiler_static"; then
+	# Neither direct hardcoding nor static linking is supported with a
+	# broken collect2.
+	hardcode_direct=unsupported
+      fi
+      ;;
+
+    aix4-9*)
+      if test ia64 = "$host_cpu"; then
+	# On IA64, the linker does run time linking by default, so we don't
+	# have to do anything special.
+	aix_use_runtimelinking=no
+	exp_sym_flag='-Bexport'
+	no_entry_flag=
+      else
+	# If we're using GNU nm, then we don't want the "-C" option.
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
+	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+	  export_symbols_cmds='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+	else
+	  export_symbols_cmds='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+	fi
+	aix_use_runtimelinking=no
+
+	# Test if we are trying to use run time linking or normal
+	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
+	case $host_os in aix4.23|aix4.23.*|aix5-9*)
+	  for ld_flag in $LDFLAGS; do
+	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
+	    aix_use_runtimelinking=yes
+	    break
+	  fi
+	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
+	  ;;
+	esac
+
+	exp_sym_flag='-bexport'
+	no_entry_flag='-bnoentry'
+      fi
+
+      # When large executables or shared objects are built, AIX ld can
+      # have problems creating the table of contents.  If linking a library
+      # or program results in "error TOC overflow" add -mminimal-toc to
+      # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+      # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+      archive_cmds=''
+      hardcode_direct=yes
+      hardcode_direct_absolute=yes
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      file_list_spec='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	hardcode_direct=no
+	hardcode_direct_absolute=no
+	;;
+      esac
+
+      if test yes = "$GCC"; then
+	case $host_os in aix4.012|aix4.012.*)
+	# We only want to do this on AIX 4.2 and lower, the check
+	# below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	   strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	  # We have reworked collect2
+	  :
+	  else
+	  # We have old collect2
+	  hardcode_direct=unsupported
+	  # It fails to find uninstalled libraries when the uninstalled
+	  # path is not listed in the libpath.  Setting hardcode_minus_L
+	  # to unsupported forces relinking
+	  hardcode_minus_L=yes
+	  hardcode_libdir_flag_spec='-L$libdir'
+	  hardcode_libdir_separator=
+	  fi
+	  ;;
+	esac
+	shared_flag='-shared'
+	if test yes = "$aix_use_runtimelinking"; then
+	  shared_flag="$shared_flag "'$wl-G'
+	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
+      else
+	# not using gcc
+	if test ia64 = "$host_cpu"; then
+	# VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	# chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+	else
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag='$wl-G'
+	  else
+	    shared_flag='$wl-bM:SRE'
+	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
+	fi
+      fi
+
+      export_dynamic_flag_spec='$wl-bexpall'
+      # It seems that -bexpall does not export symbols beginning with
+      # underscore (_), so it is better to generate a list of symbols to export.
+      always_export_symbols=yes
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+	# Warning - without using the other runtime loading flags (-brtl),
+	# -berok will link without error, but may produce a broken library.
+	allow_undefined_flag='-berok'
+        # Determine the default libpath from the value encoded in an
+        # empty executable.
+        if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath_+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *$^ *$ *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+        hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+        archive_expsym_cmds='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+      else
+	if test ia64 = "$host_cpu"; then
+	  hardcode_libdir_flag_spec='$wl-R $libdir:/usr/lib:/lib'
+	  allow_undefined_flag="-z nodefs"
+	  archive_expsym_cmds="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+	else
+	 # Determine the default libpath from the value encoded in an
+	 # empty executable.
+	 if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath_+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *$^ *$ *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath_=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath_"; then
+    lt_cv_aix_libpath_=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath_
+fi
+
+	 hardcode_libdir_flag_spec='$wl-blibpath:$libdir:'"$aix_libpath"
+	  # Warning - without using the other run time loading flags,
+	  # -berok will link without error, but may produce a broken library.
+	  no_undefined_flag=' $wl-bernotok'
+	  allow_undefined_flag=' $wl-berok'
+	  if test yes = "$with_gnu_ld"; then
+	    # We only use this code for GNU lds that support --whole-archive.
+	    whole_archive_flag_spec='$wl--whole-archive$convenience $wl--no-whole-archive'
+	  else
+	    # Exported symbols can be pulled into shared objects from archives
+	    whole_archive_flag_spec='$convenience'
+	  fi
+	  archive_cmds_need_lc=yes
+	  archive_expsym_cmds='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    archive_expsym_cmds="$archive_expsym_cmds"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  archive_expsym_cmds="$archive_expsym_cmds"'~$RM -r $output_objdir/$realname.d'
+	fi
+      fi
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+            archive_expsym_cmds=''
+        ;;
+      m68k)
+            archive_cmds='$RM $output_objdir/a2ixlibrary.data~$ECHO "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$ECHO "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$ECHO "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$ECHO "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
+            hardcode_libdir_flag_spec='-L$libdir'
+            hardcode_minus_L=yes
+        ;;
+      esac
+      ;;
+
+    bsdi45*)
+      export_dynamic_flag_spec=-rdynamic
+      ;;
+
+    cygwin* | mingw* | pw32* | cegcc*)
+      # When not using gcc, we currently assume that we are using
+      # Microsoft Visual C++.
+      # hardcode_libdir_flag_spec is actually meaningless, as there is
+      # no search path for DLLs.
+      case $cc_basename in
+      cl*)
+	# Native MSVC
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	always_export_symbols=yes
+	file_list_spec='@'
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	archive_expsym_cmds='if   test DEF = "`$SED -n     -e '\''s/^	 *//'\''     -e '\''/^$;.*$*$/d'\''     -e '\''s/^$EXPORTS\|LIBRARY$$	 .*$*$/DEF/p'\''     -e q     $export_symbols`" ; then
+            cp "$export_symbols" "$output_objdir/$soname.def";
+            echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+          else
+            $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+          fi~
+          $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+          linknames='
+	# The linker will not automatically build a static lib if we build a DLL.
+	# _LT_TAGVAR(old_archive_from_new_cmds, )='true'
+	enable_shared_with_static_runtimes=yes
+	exclude_expsyms='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+	export_symbols_cmds='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^BCDGRS /s/.* $^ *$/\1,DATA/'\'' | $SED -e '\''/^AITW /s/.* //'\'' | sort | uniq > $export_symbols'
+	# Don't use ranlib
+	old_postinstall_cmds='chmod 644 $oldlib'
+	postlink_cmds='lt_outputfile="@OUTPUT@"~
+          lt_tool_outputfile="@TOOL_OUTPUT@"~
+          case $lt_outputfile in
+            *.exe|*.EXE) ;;
+            *)
+              lt_outputfile=$lt_outputfile.exe
+              lt_tool_outputfile=$lt_tool_outputfile.exe
+              ;;
+          esac~
+          if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+            $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+            $RM "$lt_outputfile.manifest";
+          fi'
+	;;
+      *)
+	# Assume MSVC wrapper
+	hardcode_libdir_flag_spec=' '
+	allow_undefined_flag=unsupported
+	# Tell ltmain to make .lib files, not .a files.
+	libext=lib
+	# Tell ltmain to make .dll files, not .so files.
+	shrext_cmds=.dll
+	# FIXME: Setting linknames here is a bad hack.
+	archive_cmds='$CC -o $lib $libobjs $compiler_flags `func_echo_all "$deplibs" | $SED '\''s/ -lc$//'\''` -link -dll~linknames='
+	# The linker will automatically build a .lib file if we build a DLL.
+	old_archive_from_new_cmds='true'
+	# FIXME: Should let the user specify the lib program.
+	old_archive_cmds='lib -OUT:$oldlib$oldobjs$old_deplibs'
+	enable_shared_with_static_runtimes=yes
+	;;
+      esac
+      ;;
+
+    darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc=no
+  hardcode_direct=no
+  hardcode_automatic=yes
+  hardcode_shlibpath_var=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+  else
+    whole_archive_flag_spec=''
+  fi
+  link_all_deplibs=yes
+  allow_undefined_flag=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+
+  else
+  ld_shlibs=no
+  fi
+
+      ;;
+
+    dgux*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 2.2.012 allows us to include c++rt0.o to get C++ constructor
+    # support.  Future versions do this automatically, but an explicit c++rt0.o
+    # does not break anything, and helps significantly (at the cost of a little
+    # extra space).
+    freebsd2.2*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # Unfortunately, older versions of FreeBSD 2 do not have this feature.
+    freebsd2.*)
+      archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
+    freebsd* | dragonfly*)
+      archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    hpux9*)
+      if test yes = "$GCC"; then
+	archive_cmds='$RM $output_objdir/$soname~$CC -shared $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      else
+	archive_cmds='$RM $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+      fi
+      hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_direct=yes
+
+      # hardcode_minus_L: Not really in the search PATH,
+      # but as the default location of the library.
+      hardcode_minus_L=yes
+      export_dynamic_flag_spec='$wl-E'
+      ;;
+
+    hpux10*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+	hardcode_direct=yes
+	hardcode_direct_absolute=yes
+	export_dynamic_flag_spec='$wl-E'
+	# hardcode_minus_L: Not really in the search PATH,
+	# but as the default location of the library.
+	hardcode_minus_L=yes
+      fi
+      ;;
+
+    hpux11*)
+      if test yes,no = "$GCC,$with_gnu_ld"; then
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -shared $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds='$CC -shared $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	esac
+      else
+	case $host_cpu in
+	hppa*64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	ia64*)
+	  archive_cmds='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+
+	  # Older versions of the 11.00 compiler do not understand -b yet
+	  # (HP92453-01 A.11.01.20 doesn't, HP92453-01 B.11.X.35175-35176.GP does)
+	  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $CC understands -b" >&5
+$as_echo_n "checking if $CC understands -b... " >&6; }
+if ${lt_cv_prog_compiler__b+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler__b=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS -b"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler__b=yes
+       fi
+     else
+       lt_cv_prog_compiler__b=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler__b" >&5
+$as_echo "$lt_cv_prog_compiler__b" >&6; }
+
+if test yes = "$lt_cv_prog_compiler__b"; then
+    archive_cmds='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
+else
+    archive_cmds='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
+fi
+
+	  ;;
+	esac
+      fi
+      if test no = "$with_gnu_ld"; then
+	hardcode_libdir_flag_spec='$wl+b $wl$libdir'
+	hardcode_libdir_separator=:
+
+	case $host_cpu in
+	hppa*64*|ia64*)
+	  hardcode_direct=no
+	  hardcode_shlibpath_var=no
+	  ;;
+	*)
+	  hardcode_direct=yes
+	  hardcode_direct_absolute=yes
+	  export_dynamic_flag_spec='$wl-E'
+
+	  # hardcode_minus_L: Not really in the search PATH,
+	  # but as the default location of the library.
+	  hardcode_minus_L=yes
+	  ;;
+	esac
+      fi
+      ;;
+
+    irix5* | irix6* | nonstopux*)
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	# Try to use the -exported_symbol ld option, if it does not
+	# work, assume that -exports_file does not work either and
+	# implicitly export all symbols.
+	# This should be the same for all languages, so no per-tag cache variable.
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $host_os linker accepts -exported_symbol" >&5
+$as_echo_n "checking whether the $host_os linker accepts -exported_symbol... " >&6; }
+if ${lt_cv_irix_exported_symbol+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  save_LDFLAGS=$LDFLAGS
+	   LDFLAGS="$LDFLAGS -shared $wl-exported_symbol ${wl}foo $wl-update_registry $wl/dev/null"
+	   cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+int foo (void) { return 0; }
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  lt_cv_irix_exported_symbol=yes
+else
+  lt_cv_irix_exported_symbol=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+           LDFLAGS=$save_LDFLAGS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_irix_exported_symbol" >&5
+$as_echo "$lt_cv_irix_exported_symbol" >&6; }
+	if test yes = "$lt_cv_irix_exported_symbol"; then
+          archive_expsym_cmds='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
+	fi
+	link_all_deplibs=no
+      else
+	archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      inherit_rpath=yes
+      link_all_deplibs=yes
+      ;;
+
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	ld_shlibs=yes
+	archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
+      if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	archive_cmds='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
+      else
+	archive_cmds='$LD -shared -o $lib $libobjs $deplibs $linker_flags'      # ELF
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_direct=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    newsos6)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_direct=yes
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      hardcode_shlibpath_var=no
+      ;;
+
+    *nto* | *qnx*)
+      ;;
+
+    openbsd* | bitrig*)
+      if test -f /usr/libexec/ld.so; then
+	hardcode_direct=yes
+	hardcode_shlibpath_var=no
+	hardcode_direct_absolute=yes
+	if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags $wl-retain-symbols-file,$export_symbols'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	  export_dynamic_flag_spec='$wl-E'
+	else
+	  archive_cmds='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	  hardcode_libdir_flag_spec='$wl-rpath,$libdir'
+	fi
+      else
+	ld_shlibs=no
+      fi
+      ;;
+
+    os2*)
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_minus_L=yes
+      allow_undefined_flag=unsupported
+      shrext_cmds=.dll
+      archive_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      archive_expsym_cmds='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      old_archive_From_new_cmds='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      enable_shared_with_static_runtimes=yes
+      ;;
+
+    osf3*)
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      hardcode_libdir_separator=:
+      ;;
+
+    osf4* | osf5*)	# as osf3* with the addition of -msym flag
+      if test yes = "$GCC"; then
+	allow_undefined_flag=' $wl-expect_unresolved $wl\*'
+	archive_cmds='$CC -shared$allow_undefined_flag $pic_flag $libobjs $deplibs $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	hardcode_libdir_flag_spec='$wl-rpath $wl$libdir'
+      else
+	allow_undefined_flag=' -expect_unresolved \*'
+	archive_cmds='$CC -shared$allow_undefined_flag $libobjs $deplibs $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	archive_expsym_cmds='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; printf "%s\\n" "-hidden">> $lib.exp~
+          $CC -shared$allow_undefined_flag $wl-input $wl$lib.exp $compiler_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~$RM $lib.exp'
+
+	# Both c and cxx compiler support -rpath directly
+	hardcode_libdir_flag_spec='-rpath $libdir'
+      fi
+      archive_cmds_need_lc='no'
+      hardcode_libdir_separator=:
+      ;;
+
+    solaris*)
+      no_undefined_flag=' -z defs'
+      if test yes = "$GCC"; then
+	wlarc='$wl'
+	archive_cmds='$CC -shared $pic_flag $wl-z ${wl}text $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+          $CC -shared $pic_flag $wl-z ${wl}text $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+      else
+	case `$CC -V 2>&1` in
+	*"Compilers 5.0"*)
+	  wlarc=''
+	  archive_cmds='$LD -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $LD -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$RM $lib.exp'
+	  ;;
+	*)
+	  wlarc='$wl'
+	  archive_cmds='$CC -G$allow_undefined_flag -h $soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+            $CC -G$allow_undefined_flag -M $lib.exp -h $soname -o $lib $libobjs $deplibs $compiler_flags~$RM $lib.exp'
+	  ;;
+	esac
+      fi
+      hardcode_libdir_flag_spec='-R$libdir'
+      hardcode_shlibpath_var=no
+      case $host_os in
+      solaris2.0-5 | solaris2.0-5.*) ;;
+      *)
+	# The compiler driver will combine and reorder linker options,
+	# but understands '-z linker_flag'.  GCC discards it without '$wl',
+	# but is careful enough not to reorder.
+	# Supported since Solaris 2.6 (maybe 2.5.1?)
+	if test yes = "$GCC"; then
+	  whole_archive_flag_spec='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+	else
+	  whole_archive_flag_spec='-z allextract$convenience -z defaultextract'
+	fi
+	;;
+      esac
+      link_all_deplibs=yes
+      ;;
+
+    sunos4*)
+      if test sequent = "$host_vendor"; then
+	# Use $CC to link under sequent, because it throws in some extra .o
+	# files that make .init and .fini sections work.
+	archive_cmds='$CC -G $wl-h $soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
+      fi
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_direct=yes
+      hardcode_minus_L=yes
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4)
+      case $host_vendor in
+	sni)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=yes # is this really true???
+	;;
+	siemens)
+	  ## LD is ld it makes a PLAMLIB
+	  ## CC just makes a GrossModule.
+	  archive_cmds='$LD -G -o $lib $libobjs $deplibs $linker_flags'
+	  reload_cmds='$CC -r -o $output$reload_objs'
+	  hardcode_direct=no
+        ;;
+	motorola)
+	  archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	  hardcode_direct=no #Motorola manual says yes, but my tests say they lie
+	;;
+      esac
+      runpath_var='LD_RUN_PATH'
+      hardcode_shlibpath_var=no
+      ;;
+
+    sysv4.3*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_shlibpath_var=no
+      export_dynamic_flag_spec='-Bexport'
+      ;;
+
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+	hardcode_shlibpath_var=no
+	runpath_var=LD_RUN_PATH
+	hardcode_runpath_var=yes
+	ld_shlibs=yes
+      fi
+      ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.01.10* | unixware7* | sco3.2v5.0.024*)
+      no_undefined_flag='$wl-z,text'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    sysv5* | sco3.2v5* | sco5v6*)
+      # Note: We CANNOT use -z defs as we might desire, because we do not
+      # link with -lc, and that would cause any symbols used from libc to
+      # always be unresolved, which means just about no library would
+      # ever link correctly.  If we're not using GNU ld we use -z text
+      # though, which does catch some bad symbols but isn't as heavy-handed
+      # as -z defs.
+      no_undefined_flag='$wl-z,text'
+      allow_undefined_flag='$wl-z,nodefs'
+      archive_cmds_need_lc=no
+      hardcode_shlibpath_var=no
+      hardcode_libdir_flag_spec='$wl-R,$libdir'
+      hardcode_libdir_separator=':'
+      link_all_deplibs=yes
+      export_dynamic_flag_spec='$wl-Bexport'
+      runpath_var='LD_RUN_PATH'
+
+      if test yes = "$GCC"; then
+	archive_cmds='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      else
+	archive_cmds='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	archive_expsym_cmds='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+      fi
+      ;;
+
+    uts4*)
+      archive_cmds='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
+      hardcode_libdir_flag_spec='-L$libdir'
+      hardcode_shlibpath_var=no
+      ;;
+
+    *)
+      ld_shlibs=no
+      ;;
+    esac
+
+    if test sni = "$host_vendor"; then
+      case $host in
+      sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
+	export_dynamic_flag_spec='$wl-Blargedynsym'
+	;;
+      esac
+    fi
+  fi
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs" >&5
+$as_echo "$ld_shlibs" >&6; }
+test no = "$ld_shlibs" && can_build_shared=no
+
+with_gnu_ld=$with_gnu_ld
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $archive_cmds in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if ${lt_cv_archive_cmds_need_lc+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl
+	  pic_flag=$lt_prog_compiler_pic
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag
+	  allow_undefined_flag=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc=no
+	  else
+	    lt_cv_archive_cmds_need_lc=yes
+	  fi
+	  allow_undefined_flag=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc" >&6; }
+      archive_cmds_need_lc=$lt_cv_archive_cmds_need_lc
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+if test yes = "$GCC"; then
+  case $host_os in
+    darwin*) lt_awk_arg='/^libraries:/,/LR/' ;;
+    *) lt_awk_arg='/^libraries:/' ;;
+  esac
+  case $host_os in
+    mingw* | cegcc*) lt_sed_strip_eq='s|=$A-Za-z:$|\1|g' ;;
+    *) lt_sed_strip_eq='s|=/|/|g' ;;
+  esac
+  lt_search_path_spec=`$CC -print-search-dirs | awk $lt_awk_arg | $SED -e "s/^libraries://" -e $lt_sed_strip_eq`
+  case $lt_search_path_spec in
+  *\;*)
+    # if the path contains ";" then we assume it to be the separator
+    # otherwise default to the standard path separator (i.e. ":") - it is
+    # assumed that no part of a normal pathname contains ";" but that should
+    # okay in the real world where ";" in dirpaths is itself problematic.
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED 's/;/ /g'`
+    ;;
+  *)
+    lt_search_path_spec=`$ECHO "$lt_search_path_spec" | $SED "s/$PATH_SEPARATOR/ /g"`
+    ;;
+  esac
+  # Ok, now we have the path, separated by spaces, we can step through it
+  # and add multilib dir if necessary...
+  lt_tmp_lt_search_path_spec=
+  lt_multi_os_dir=/`$CC $CPPFLAGS $CFLAGS $LDFLAGS -print-multi-os-directory 2>/dev/null`
+  # ...but if some path component already ends with the multilib dir we assume
+  # that all is fine and trust -print-search-dirs as is (GCC 4.2? or newer).
+  case "$lt_multi_os_dir; $lt_search_path_spec " in
+  "/; "* | "/.; "* | "/./; "* | *"$lt_multi_os_dir "* | *"$lt_multi_os_dir/ "*)
+    lt_multi_os_dir=
+    ;;
+  esac
+  for lt_sys_path in $lt_search_path_spec; do
+    if test -d "$lt_sys_path$lt_multi_os_dir"; then
+      lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path$lt_multi_os_dir"
+    elif test -n "$lt_multi_os_dir"; then
+      test -d "$lt_sys_path" && \
+	lt_tmp_lt_search_path_spec="$lt_tmp_lt_search_path_spec $lt_sys_path"
+    fi
+  done
+  lt_search_path_spec=`$ECHO "$lt_tmp_lt_search_path_spec" | awk '
+BEGIN {RS = " "; FS = "/|\n";} {
+  lt_foo = "";
+  lt_count = 0;
+  for (lt_i = NF; lt_i > 0; lt_i--) {
+    if ($lt_i != "" && $lt_i != ".") {
+      if ($lt_i == "..") {
+        lt_count++;
+      } else {
+        if (lt_count == 0) {
+          lt_foo = "/" $lt_i lt_foo;
+        } else {
+          lt_count--;
+        }
+      }
+    }
+  }
+  if (lt_foo != "") { lt_freqlt_foo++; }
+  if (lt_freqlt_foo == 1) { print lt_foo; }
+}'`
+  # AWK program above erroneously prepends '/' to C:/dos/paths
+  # for these hosts.
+  case $host_os in
+    mingw* | cegcc*) lt_search_path_spec=`$ECHO "$lt_search_path_spec" |\
+      $SED 's|/$A-Za-z:$|\1|g'` ;;
+  esac
+  sys_lib_search_path_spec=`$ECHO "$lt_search_path_spec" | $lt_NL2SP`
+else
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+fi
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix4-9*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.01 | aix4.01.*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/$^/*$\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi45*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+
+      sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/lib/w32api"
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \$a-zA-Z\$:| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | $GREP ';c-zC-Z:/' >/dev/null; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_search_path_spec="$sys_lib_search_path_spec /usr/local/lib"
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd23.*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.01* | freebsdelf3.01*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.2-9* | freebsdelf3.2-9* | \
+  freebsd4.0-5 | freebsdelf4.0-5 | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix3-9*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^	 *hwcap	 /d;s/:,	/ /g;s/=^=*$//;s/=^= * / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action=
+if test -n "$hardcode_libdir_flag_spec" ||
+   test -n "$runpath_var" ||
+   test yes = "$hardcode_automatic"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$hardcode_direct" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, )" &&
+     test no != "$hardcode_minus_L"; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action" >&5
+$as_echo "$hardcode_action" >&6; }
+
+if test relink = "$hardcode_action" ||
+   test yes = "$inherit_rpath"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+  if test yes != "$enable_dlopen"; then
+  enable_dlopen=unknown
+  enable_dlopen_self=unknown
+  enable_dlopen_self_static=unknown
+else
+  lt_cv_dlopen=no
+  lt_cv_dlopen_libs=
+
+  case $host_os in
+  beos*)
+    lt_cv_dlopen=load_add_on
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+    ;;
+
+  mingw* | pw32* | cegcc*)
+    lt_cv_dlopen=LoadLibrary
+    lt_cv_dlopen_libs=
+    ;;
+
+  cygwin*)
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    ;;
+
+  darwin*)
+    # if libdl is installed we need to link against it
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else
+
+    lt_cv_dlopen=dyld
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=yes
+
+fi
+
+    ;;
+
+  tpf*)
+    # Don't try to run any link tests for TPF.  We know it's impossible
+    # because TPF is a cross-compiler, and we know how we open DSOs.
+    lt_cv_dlopen=dlopen
+    lt_cv_dlopen_libs=
+    lt_cv_dlopen_self=no
+    ;;
+
+  *)
+    ac_fn_c_check_func "$LINENO" "shl_load" "ac_cv_func_shl_load"
+if test "x$ac_cv_func_shl_load" = xyes; then :
+  lt_cv_dlopen=shl_load
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for shl_load in -ldld" >&5
+$as_echo_n "checking for shl_load in -ldld... " >&6; }
+if ${ac_cv_lib_dld_shl_load+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char shl_load ();
+int
+main ()
+{
+return shl_load ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_shl_load=yes
+else
+  ac_cv_lib_dld_shl_load=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_shl_load" >&5
+$as_echo "$ac_cv_lib_dld_shl_load" >&6; }
+if test "x$ac_cv_lib_dld_shl_load" = xyes; then :
+  lt_cv_dlopen=shl_load lt_cv_dlopen_libs=-ldld
+else
+  ac_fn_c_check_func "$LINENO" "dlopen" "ac_cv_func_dlopen"
+if test "x$ac_cv_func_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -ldl" >&5
+$as_echo_n "checking for dlopen in -ldl... " >&6; }
+if ${ac_cv_lib_dl_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldl  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dl_dlopen=yes
+else
+  ac_cv_lib_dl_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dl_dlopen" >&5
+$as_echo "$ac_cv_lib_dl_dlopen" >&6; }
+if test "x$ac_cv_lib_dl_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-ldl
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dlopen in -lsvld" >&5
+$as_echo_n "checking for dlopen in -lsvld... " >&6; }
+if ${ac_cv_lib_svld_dlopen+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lsvld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dlopen ();
+int
+main ()
+{
+return dlopen ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_svld_dlopen=yes
+else
+  ac_cv_lib_svld_dlopen=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_svld_dlopen" >&5
+$as_echo "$ac_cv_lib_svld_dlopen" >&6; }
+if test "x$ac_cv_lib_svld_dlopen" = xyes; then :
+  lt_cv_dlopen=dlopen lt_cv_dlopen_libs=-lsvld
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for dld_link in -ldld" >&5
+$as_echo_n "checking for dld_link in -ldld... " >&6; }
+if ${ac_cv_lib_dld_dld_link+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-ldld  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+/* Override any GCC internal prototype to avoid an error.
+   Use char because int might match the return type of a GCC
+   builtin and then its argument prototype would still apply.  */
+#ifdef __cplusplus
+extern "C"
+#endif
+char dld_link ();
+int
+main ()
+{
+return dld_link ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_link "$LINENO"; then :
+  ac_cv_lib_dld_dld_link=yes
+else
+  ac_cv_lib_dld_dld_link=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_dld_dld_link" >&5
+$as_echo "$ac_cv_lib_dld_dld_link" >&6; }
+if test "x$ac_cv_lib_dld_dld_link" = xyes; then :
+  lt_cv_dlopen=dld_link lt_cv_dlopen_libs=-ldld
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+
+fi
+
+    ;;
+  esac
+
+  if test no = "$lt_cv_dlopen"; then
+    enable_dlopen=no
+  else
+    enable_dlopen=yes
+  fi
+
+  case $lt_cv_dlopen in
+  dlopen)
+    save_CPPFLAGS=$CPPFLAGS
+    test yes = "$ac_cv_header_dlfcn_h" && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
+
+    save_LDFLAGS=$LDFLAGS
+    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
+
+    save_LIBS=$LIBS
+    LIBS="$lt_cv_dlopen_libs $LIBS"
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a program can dlopen itself" >&5
+$as_echo_n "checking whether a program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self" >&5
+$as_echo "$lt_cv_dlopen_self" >&6; }
+
+    if test yes = "$lt_cv_dlopen_self"; then
+      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether a statically linked program can dlopen itself" >&5
+$as_echo_n "checking whether a statically linked program can dlopen itself... " >&6; }
+if ${lt_cv_dlopen_self_static+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  	  if test yes = "$cross_compiling"; then :
+  lt_cv_dlopen_self_static=cross
+else
+  lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
+  lt_status=$lt_dlunknown
+  cat > conftest.$ac_ext <<_LT_EOF
+#line $LINENO "configure"
+#include "confdefs.h"
+
+#if HAVE_DLFCN_H
+#include <dlfcn.h>
+#endif
+
+#include <stdio.h>
+
+#ifdef RTLD_GLOBAL
+#  define LT_DLGLOBAL		RTLD_GLOBAL
+#else
+#  ifdef DL_GLOBAL
+#    define LT_DLGLOBAL		DL_GLOBAL
+#  else
+#    define LT_DLGLOBAL		0
+#  endif
+#endif
+
+/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
+   find out it does not work in some platform. */
+#ifndef LT_DLLAZY_OR_NOW
+#  ifdef RTLD_LAZY
+#    define LT_DLLAZY_OR_NOW		RTLD_LAZY
+#  else
+#    ifdef DL_LAZY
+#      define LT_DLLAZY_OR_NOW		DL_LAZY
+#    else
+#      ifdef RTLD_NOW
+#        define LT_DLLAZY_OR_NOW	RTLD_NOW
+#      else
+#        ifdef DL_NOW
+#          define LT_DLLAZY_OR_NOW	DL_NOW
+#        else
+#          define LT_DLLAZY_OR_NOW	0
+#        endif
+#      endif
+#    endif
+#  endif
+#endif
+
+/* When -fvisibility=hidden is used, assume the code has been annotated
+   correspondingly for the symbols needed.  */
+#if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
+int fnord () __attribute__((visibility("default")));
+#endif
+
+int fnord () { return 42; }
+int main ()
+{
+  void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
+  int status = $lt_dlunknown;
+
+  if (self)
+    {
+      if (dlsym (self,"fnord"))       status = $lt_dlno_uscore;
+      else
+        {
+	  if (dlsym( self,"_fnord"))  status = $lt_dlneed_uscore;
+          else puts (dlerror ());
+	}
+      /* dlclose (self); */
+    }
+  else
+    puts (dlerror ());
+
+  return status;
+}
+_LT_EOF
+  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_link\""; } >&5
+  (eval $ac_link) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } && test -s "conftest$ac_exeext" 2>/dev/null; then
+    (./conftest; exit; ) >&5 2>/dev/null
+    lt_status=$?
+    case x$lt_status in
+      x$lt_dlno_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlneed_uscore) lt_cv_dlopen_self_static=yes ;;
+      x$lt_dlunknown|x*) lt_cv_dlopen_self_static=no ;;
+    esac
+  else :
+    # compilation failed
+    lt_cv_dlopen_self_static=no
+  fi
+fi
+rm -fr conftest*
+
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_dlopen_self_static" >&5
+$as_echo "$lt_cv_dlopen_self_static" >&6; }
+    fi
+
+    CPPFLAGS=$save_CPPFLAGS
+    LDFLAGS=$save_LDFLAGS
+    LIBS=$save_LIBS
+    ;;
+  esac
+
+  case $lt_cv_dlopen_self in
+  yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
+  *) enable_dlopen_self=unknown ;;
+  esac
+
+  case $lt_cv_dlopen_self_static in
+  yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
+  *) enable_dlopen_self_static=unknown ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+striplib=
+old_striplib=
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether stripping libraries is possible" >&5
+$as_echo_n "checking whether stripping libraries is possible... " >&6; }
+if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
+  test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
+  test -z "$striplib" && striplib="$STRIP --strip-unneeded"
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+else
+# FIXME - insert some real tests, host_os isn't really good enough
+  case $host_os in
+  darwin*)
+    if test -n "$STRIP"; then
+      striplib="$STRIP -x"
+      old_striplib="$STRIP -S"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: yes" >&5
+$as_echo "yes" >&6; }
+    else
+      { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    fi
+    ;;
+  *)
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+    ;;
+  esac
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+  # Report what library types will actually be built
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if libtool supports shared libraries" >&5
+$as_echo_n "checking if libtool supports shared libraries... " >&6; }
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $can_build_shared" >&5
+$as_echo "$can_build_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build shared libraries" >&5
+$as_echo_n "checking whether to build shared libraries... " >&6; }
+  test no = "$can_build_shared" && enable_shared=no
+
+  # On AIX, shared libraries and static libraries use the same namespace, and
+  # are all built from PIC.
+  case $host_os in
+  aix3*)
+    test yes = "$enable_shared" && enable_static=no
+    if test -n "$RANLIB"; then
+      archive_cmds="$archive_cmds~\$RANLIB \$lib"
+      postinstall_cmds='$RANLIB $lib'
+    fi
+    ;;
+
+  aix4-9*)
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
+    fi
+    ;;
+  esac
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_shared" >&5
+$as_echo "$enable_shared" >&6; }
+
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether to build static libraries" >&5
+$as_echo_n "checking whether to build static libraries... " >&6; }
+  # Make sure either enable_shared or enable_static is yes.
+  test yes = "$enable_shared" || enable_static=yes
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $enable_static" >&5
+$as_echo "$enable_static" >&6; }
+
+
+
+
+fi
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+CC=$lt_save_CC
+
+      if test -n "$CXX" && ( test no != "$CXX" &&
+    ( (test g++ = "$CXX" && `g++ -v >/dev/null 2>&1` ) ||
+    (test g++ != "$CXX"))); then
+  ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking how to run the C++ preprocessor" >&5
+$as_echo_n "checking how to run the C++ preprocessor... " >&6; }
+if test -z "$CXXCPP"; then
+  if ${ac_cv_prog_CXXCPP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+      # Double quotes because CXXCPP needs to be expanded
+    for CXXCPP in "$CXX -E" "/lib/cpp"
+    do
+      ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+  break
+fi
+
+    done
+    ac_cv_prog_CXXCPP=$CXXCPP
+
+fi
+  CXXCPP=$ac_cv_prog_CXXCPP
+else
+  ac_cv_prog_CXXCPP=$CXXCPP
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $CXXCPP" >&5
+$as_echo "$CXXCPP" >&6; }
+ac_preproc_ok=false
+for ac_cxx_preproc_warn_flag in '' yes
+do
+  # Use a header file that comes with gcc, so configuring glibc
+  # with a fresh cross-compiler works.
+  # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
+  # <limits.h> exists even on freestanding compilers.
+  # On the NeXT, cc -E runs the code through the compiler's parser,
+  # not just through cpp. "Syntax error" is here to catch this case.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#ifdef __STDC__
+# include <limits.h>
+#else
+# include <assert.h>
+#endif
+		     Syntax error
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+
+else
+  # Broken: fails on valid input.
+continue
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+  # OK, works on sane cases.  Now check whether nonexistent headers
+  # can be detected and how.
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <ac_nonexistent.h>
+_ACEOF
+if ac_fn_cxx_try_cpp "$LINENO"; then :
+  # Broken: success on invalid input.
+continue
+else
+  # Passes both tests.
+ac_preproc_ok=:
+break
+fi
+rm -f conftest.err conftest.i conftest.$ac_ext
+
+done
+# Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
+rm -f conftest.i conftest.err conftest.$ac_ext
+if $ac_preproc_ok; then :
+
+else
+  { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "C++ preprocessor \"$CXXCPP\" fails sanity check
+See \`config.log' for more details" "$LINENO" 5; }
+fi
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+else
+  _lt_caught_CXX_error=yes
+fi
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+archive_cmds_need_lc_CXX=no
+allow_undefined_flag_CXX=
+always_export_symbols_CXX=no
+archive_expsym_cmds_CXX=
+compiler_needs_object_CXX=no
+export_dynamic_flag_spec_CXX=
+hardcode_direct_CXX=no
+hardcode_direct_absolute_CXX=no
+hardcode_libdir_flag_spec_CXX=
+hardcode_libdir_separator_CXX=
+hardcode_minus_L_CXX=no
+hardcode_shlibpath_var_CXX=unsupported
+hardcode_automatic_CXX=no
+inherit_rpath_CXX=no
+module_cmds_CXX=
+module_expsym_cmds_CXX=
+link_all_deplibs_CXX=unknown
+old_archive_cmds_CXX=$old_archive_cmds
+reload_flag_CXX=$reload_flag
+reload_cmds_CXX=$reload_cmds
+no_undefined_flag_CXX=
+whole_archive_flag_spec_CXX=
+enable_shared_with_static_runtimes_CXX=no
+
+# Source file extension for C++ test sources.
+ac_ext=cpp
+
+# Object file extension for compiled C++ test sources.
+objext=o
+objext_CXX=$objext
+
+# No sense in running all these tests if we already determined that
+# the CXX compiler isn't working.  Some variables (like enable_shared)
+# are currently assumed to apply to all compilers on this platform,
+# and will be corrupted by setting them based on a non-working compiler.
+if test yes != "$_lt_caught_CXX_error"; then
+  # Code to be used in simple compile tests
+  lt_simple_compile_test_code="int some_variable = 0;"
+
+  # Code to be used in simple link tests
+  lt_simple_link_test_code='int main(int, char *) { return(0); }'
+
+  # ltmain only uses $CC for tagged configurations so make sure $CC is set.
+
+
+
+
+
+
+# If no C compiler was specified, use CC.
+LTCC=${LTCC-"$CC"}
+
+# If no C compiler flags were specified, use CFLAGS.
+LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
+
+# Allow CC to be a program name with arguments.
+compiler=$CC
+
+
+  # save warnings/boilerplate of simple test code
+  ac_outfile=conftest.$ac_objext
+echo "$lt_simple_compile_test_code" >conftest.$ac_ext
+eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_compiler_boilerplate=`cat conftest.err`
+$RM conftest*
+
+  ac_outfile=conftest.$ac_objext
+echo "$lt_simple_link_test_code" >conftest.$ac_ext
+eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
+_lt_linker_boilerplate=`cat conftest.err`
+$RM -r conftest*
+
+
+  # Allow CC to be a program name with arguments.
+  lt_save_CC=$CC
+  lt_save_CFLAGS=$CFLAGS
+  lt_save_LD=$LD
+  lt_save_GCC=$GCC
+  GCC=$GXX
+  lt_save_with_gnu_ld=$with_gnu_ld
+  lt_save_path_LD=$lt_cv_path_LD
+  if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
+    lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
+  else
+    $as_unset lt_cv_prog_gnu_ld
+  fi
+  if test -n "${lt_cv_path_LDCXX+set}"; then
+    lt_cv_path_LD=$lt_cv_path_LDCXX
+  else
+    $as_unset lt_cv_path_LD
+  fi
+  test -z "${LDCXX+set}" || LD=$LDCXX
+  CC=${CXX-"c++"}
+  CFLAGS=$CXXFLAGS
+  compiler=$CC
+  compiler_CXX=$CC
+  func_cc_basename $compiler
+cc_basename=$func_cc_basename_result
+
+
+  if test -n "$compiler"; then
+    # We don't want -fno-exception when compiling C++ code, so set the
+    # no_builtin_flag separately
+    if test yes = "$GXX"; then
+      lt_prog_compiler_no_builtin_flag_CXX=' -fno-builtin'
+    else
+      lt_prog_compiler_no_builtin_flag_CXX=
+    fi
+
+    if test yes = "$GXX"; then
+      # Set up default GNU C++ configuration
+
+
+
+# Check whether --with-gnu-ld was given.
+if test "${with_gnu_ld+set}" = set; then :
+  withval=$with_gnu_ld; test no = "$withval" || with_gnu_ld=yes
+else
+  with_gnu_ld=no
+fi
+
+ac_prog=ld
+if test yes = "$GCC"; then
+  # Check if gcc -print-prog-name=ld gives a path.
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for ld used by $CC" >&5
+$as_echo_n "checking for ld used by $CC... " >&6; }
+  case $host in
+  *-*-mingw*)
+    # gcc leaves a trailing carriage return, which upsets mingw
+    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
+  *)
+    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
+  esac
+  case $ac_prog in
+    # Accept absolute paths.
+    \\/* | ?:\\/*)
+      re_direlt='/^/^/*/\.\./'
+      # Canonicalize the pathname of ld
+      ac_prog=`$ECHO "$ac_prog"| $SED 's%\\\\%/%g'`
+      while $ECHO "$ac_prog" | $GREP "$re_direlt" > /dev/null 2>&1; do
+	ac_prog=`$ECHO $ac_prog| $SED "s%$re_direlt%/%"`
+      done
+      test -z "$LD" && LD=$ac_prog
+      ;;
+  "")
+    # If it fails, then pretend we aren't using GCC.
+    ac_prog=ld
+    ;;
+  *)
+    # If it is relative, then search for the first ld in PATH.
+    with_gnu_ld=unknown
+    ;;
+  esac
+elif test yes = "$with_gnu_ld"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for GNU ld" >&5
+$as_echo_n "checking for GNU ld... " >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking for non-GNU ld" >&5
+$as_echo_n "checking for non-GNU ld... " >&6; }
+fi
+if ${lt_cv_path_LD+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$LD"; then
+  lt_save_ifs=$IFS; IFS=$PATH_SEPARATOR
+  for ac_dir in $PATH; do
+    IFS=$lt_save_ifs
+    test -z "$ac_dir" && ac_dir=.
+    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
+      lt_cv_path_LD=$ac_dir/$ac_prog
+      # Check to see if the program is GNU ld.  I'd rather use --version,
+      # but apparently some variants of GNU ld only accept -v.
+      # Break only if it was the GNU/non-GNU ld that we prefer.
+      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
+      *GNU* | *'with BFD'*)
+	test no != "$with_gnu_ld" && break
+	;;
+      *)
+	test yes != "$with_gnu_ld" && break
+	;;
+      esac
+    fi
+  done
+  IFS=$lt_save_ifs
+else
+  lt_cv_path_LD=$LD # Let the user override the test with a path.
+fi
+fi
+
+LD=$lt_cv_path_LD
+if test -n "$LD"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LD" >&5
+$as_echo "$LD" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+test -z "$LD" && as_fn_error $? "no acceptable ld found in \$PATH" "$LINENO" 5
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if the linker ($LD) is GNU ld" >&5
+$as_echo_n "checking if the linker ($LD) is GNU ld... " >&6; }
+if ${lt_cv_prog_gnu_ld+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  # I'd rather use --version here, but apparently some GNU lds only accept -v.
+case `$LD -v 2>&1 </dev/null` in
+*GNU* | *'with BFD'*)
+  lt_cv_prog_gnu_ld=yes
+  ;;
+*)
+  lt_cv_prog_gnu_ld=no
+  ;;
+esac
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_gnu_ld" >&5
+$as_echo "$lt_cv_prog_gnu_ld" >&6; }
+with_gnu_ld=$lt_cv_prog_gnu_ld
+
+
+
+
+
+
+
+      # Check if GNU C++ uses GNU ld as the underlying linker, since the
+      # archiving commands below assume that GNU ld is being used.
+      if test yes = "$with_gnu_ld"; then
+        archive_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+        archive_expsym_cmds_CXX='$CC $pic_flag -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+        export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+
+        # If archive_cmds runs LD, not CC, wlarc should be empty
+        # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
+        #     investigate it a little bit more. (MM)
+        wlarc='$wl'
+
+        # ancient GNU ld didn't support --whole-archive et. al.
+        if eval "`$CC -print-prog-name=ld` --help 2>&1" |
+	  $GREP 'no-whole-archive' > /dev/null; then
+          whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+        else
+          whole_archive_flag_spec_CXX=
+        fi
+      else
+        with_gnu_ld=no
+        wlarc=
+
+        # A generic and very simple default shared library creation
+        # command for GNU C++ for the case where it uses the native
+        # linker, instead of GNU ld.  If possible, this setting should
+        # overridden to take advantage of the native linker features on
+        # the platform it is being used on.
+        archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+      fi
+
+      # Commands to make compiler produce verbose output that lists
+      # what "hidden" libraries, object files and flags are used when
+      # linking a shared library.
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+
+    else
+      GXX=no
+      with_gnu_ld=no
+      wlarc=
+    fi
+
+    # PORTME: fill in a description of your system's C++ link characteristics
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+    ld_shlibs_CXX=yes
+    case $host_os in
+      aix3*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+      aix4-9*)
+        if test ia64 = "$host_cpu"; then
+          # On IA64, the linker does run time linking by default, so we don't
+          # have to do anything special.
+          aix_use_runtimelinking=no
+          exp_sym_flag='-Bexport'
+          no_entry_flag=
+        else
+          aix_use_runtimelinking=no
+
+          # Test if we are trying to use run time linking or normal
+          # AIX style linking. If -brtl is somewhere in LDFLAGS, we
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
+          case $host_os in aix4.23|aix4.23.*|aix5-9*)
+	    for ld_flag in $LDFLAGS; do
+	      case $ld_flag in
+	      *-brtl*)
+	        aix_use_runtimelinking=yes
+	        break
+	        ;;
+	      esac
+	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
+	    ;;
+          esac
+
+          exp_sym_flag='-bexport'
+          no_entry_flag='-bnoentry'
+        fi
+
+        # When large executables or shared objects are built, AIX ld can
+        # have problems creating the table of contents.  If linking a library
+        # or program results in "error TOC overflow" add -mminimal-toc to
+        # CXXFLAGS/CFLAGS for g++/gcc.  In the cases where that is not
+        # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
+
+        archive_cmds_CXX=''
+        hardcode_direct_CXX=yes
+        hardcode_direct_absolute_CXX=yes
+        hardcode_libdir_separator_CXX=':'
+        link_all_deplibs_CXX=yes
+        file_list_spec_CXX='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          hardcode_direct_CXX=no
+          hardcode_direct_absolute_CXX=no
+          ;;
+        esac
+
+        if test yes = "$GXX"; then
+          case $host_os in aix4.012|aix4.012.*)
+          # We only want to do this on AIX 4.2 and lower, the check
+          # below for broken collect2 doesn't work under 4.3+
+	  collect2name=`$CC -print-prog-name=collect2`
+	  if test -f "$collect2name" &&
+	     strings "$collect2name" | $GREP resolve_lib_name >/dev/null
+	  then
+	    # We have reworked collect2
+	    :
+	  else
+	    # We have old collect2
+	    hardcode_direct_CXX=unsupported
+	    # It fails to find uninstalled libraries when the uninstalled
+	    # path is not listed in the libpath.  Setting hardcode_minus_L
+	    # to unsupported forces relinking
+	    hardcode_minus_L_CXX=yes
+	    hardcode_libdir_flag_spec_CXX='-L$libdir'
+	    hardcode_libdir_separator_CXX=
+	  fi
+          esac
+          shared_flag='-shared'
+	  if test yes = "$aix_use_runtimelinking"; then
+	    shared_flag=$shared_flag' $wl-G'
+	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
+        else
+          # not using gcc
+          if test ia64 = "$host_cpu"; then
+	  # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
+	  # chokes on -Wl,-G. The following line is correct:
+	  shared_flag='-G'
+          else
+	    if test yes = "$aix_use_runtimelinking"; then
+	      shared_flag='$wl-G'
+	    else
+	      shared_flag='$wl-bM:SRE'
+	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
+          fi
+        fi
+
+        export_dynamic_flag_spec_CXX='$wl-bexpall'
+        # It seems that -bexpall does not export symbols beginning with
+        # underscore (_), so it is better to generate a list of symbols to
+	# export.
+        always_export_symbols_CXX=yes
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
+          # Warning - without using the other runtime loading flags (-brtl),
+          # -berok will link without error, but may produce a broken library.
+          # The "-G" linker flag allows undefined symbols.
+          no_undefined_flag_CXX='-bernotok'
+          # Determine the default libpath from the value encoded in an empty
+          # executable.
+          if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath__CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *$^ *$ *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+          hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
+
+          archive_expsym_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $deplibs $wl'$no_entry_flag' $compiler_flags `if test -n "$allow_undefined_flag"; then func_echo_all "$wl$allow_undefined_flag"; else :; fi` $wl'$exp_sym_flag:\$export_symbols' '$shared_flag
+        else
+          if test ia64 = "$host_cpu"; then
+	    hardcode_libdir_flag_spec_CXX='$wl-R $libdir:/usr/lib:/lib'
+	    allow_undefined_flag_CXX="-z nodefs"
+	    archive_expsym_cmds_CXX="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\$wl$no_entry_flag"' $compiler_flags $wl$allow_undefined_flag '"\$wl$exp_sym_flag:\$export_symbols"
+          else
+	    # Determine the default libpath from the value encoded in an
+	    # empty executable.
+	    if test set = "${lt_cv_aix_libpath+set}"; then
+  aix_libpath=$lt_cv_aix_libpath
+else
+  if ${lt_cv_aix_libpath__CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+
+  lt_aix_libpath_sed='
+      /Import File Strings/,/^$/ {
+	  /^0/ {
+	      s/^0  *$^ *$ *$/\1/
+	      p
+	  }
+      }'
+  lt_cv_aix_libpath__CXX=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  # Check for a 64-bit object if we didn't find anything.
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e "$lt_aix_libpath_sed"`
+  fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+  if test -z "$lt_cv_aix_libpath__CXX"; then
+    lt_cv_aix_libpath__CXX=/usr/lib:/lib
+  fi
+
+fi
+
+  aix_libpath=$lt_cv_aix_libpath__CXX
+fi
+
+	    hardcode_libdir_flag_spec_CXX='$wl-blibpath:$libdir:'"$aix_libpath"
+	    # Warning - without using the other run time loading flags,
+	    # -berok will link without error, but may produce a broken library.
+	    no_undefined_flag_CXX=' $wl-bernotok'
+	    allow_undefined_flag_CXX=' $wl-berok'
+	    if test yes = "$with_gnu_ld"; then
+	      # We only use this code for GNU lds that support --whole-archive.
+	      whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    else
+	      # Exported symbols can be pulled into shared objects from archives
+	      whole_archive_flag_spec_CXX='$convenience'
+	    fi
+	    archive_cmds_need_lc_CXX=yes
+	    archive_expsym_cmds_CXX='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    archive_expsym_cmds_CXX="$archive_expsym_cmds_CXX"'~$RM -r $output_objdir/$realname.d'
+          fi
+        fi
+        ;;
+
+      beos*)
+	if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
+	  allow_undefined_flag_CXX=unsupported
+	  # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
+	  # support --undefined.  This deserves some investigation.  FIXME
+	  archive_cmds_CXX='$CC -nostart $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	else
+	  ld_shlibs_CXX=no
+	fi
+	;;
+
+      chorus*)
+        case $cc_basename in
+          *)
+	  # FIXME: insert proper C++ library support
+	  ld_shlibs_CXX=no
+	  ;;
+        esac
+        ;;
+
+      cygwin* | mingw* | pw32* | cegcc*)
+	case $GXX,$cc_basename in
+	,cl* | no,cl*)
+	  # Native MSVC
+	  # hardcode_libdir_flag_spec is actually meaningless, as there is
+	  # no search path for DLLs.
+	  hardcode_libdir_flag_spec_CXX=' '
+	  allow_undefined_flag_CXX=unsupported
+	  always_export_symbols_CXX=yes
+	  file_list_spec_CXX='@'
+	  # Tell ltmain to make .lib files, not .a files.
+	  libext=lib
+	  # Tell ltmain to make .dll files, not .so files.
+	  shrext_cmds=.dll
+	  # FIXME: Setting linknames here is a bad hack.
+	  archive_cmds_CXX='$CC -o $output_objdir/$soname $libobjs $compiler_flags $deplibs -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~linknames='
+	  archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^	 *//'\''     -e '\''/^$;.*$*$/d'\''     -e '\''s/^$EXPORTS\|LIBRARY$$	 .*$*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp "$export_symbols" "$output_objdir/$soname.def";
+              echo "$tool_output_objdir$soname.def" > "$output_objdir/$soname.exp";
+            else
+              $SED -e '\''s/^/-link -EXPORT:/'\'' < $export_symbols > $output_objdir/$soname.exp;
+            fi~
+            $CC -o $tool_output_objdir$soname $libobjs $compiler_flags $deplibs "@$tool_output_objdir$soname.exp" -Wl,-DLL,-IMPLIB:"$tool_output_objdir$libname.dll.lib"~
+            linknames='
+	  # The linker will not automatically build a static lib if we build a DLL.
+	  # _LT_TAGVAR(old_archive_from_new_cmds, CXX)='true'
+	  enable_shared_with_static_runtimes_CXX=yes
+	  # Don't use ranlib
+	  old_postinstall_cmds_CXX='chmod 644 $oldlib'
+	  postlink_cmds_CXX='lt_outputfile="@OUTPUT@"~
+            lt_tool_outputfile="@TOOL_OUTPUT@"~
+            case $lt_outputfile in
+              *.exe|*.EXE) ;;
+              *)
+                lt_outputfile=$lt_outputfile.exe
+                lt_tool_outputfile=$lt_tool_outputfile.exe
+                ;;
+            esac~
+            func_to_tool_file "$lt_outputfile"~
+            if test : != "$MANIFEST_TOOL" && test -f "$lt_outputfile.manifest"; then
+              $MANIFEST_TOOL -manifest "$lt_tool_outputfile.manifest" -outputresource:"$lt_tool_outputfile" || exit 1;
+              $RM "$lt_outputfile.manifest";
+            fi'
+	  ;;
+	*)
+	  # g++
+	  # _LT_TAGVAR(hardcode_libdir_flag_spec, CXX) is actually meaningless,
+	  # as there is no search path for DLLs.
+	  hardcode_libdir_flag_spec_CXX='-L$libdir'
+	  export_dynamic_flag_spec_CXX='$wl--export-all-symbols'
+	  allow_undefined_flag_CXX=unsupported
+	  always_export_symbols_CXX=no
+	  enable_shared_with_static_runtimes_CXX=yes
+
+	  if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
+	    archive_cmds_CXX='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	    # If the export-symbols file already is a .def file, use it as
+	    # is; otherwise, prepend EXPORTS...
+	    archive_expsym_cmds_CXX='if   test DEF = "`$SED -n     -e '\''s/^	 *//'\''     -e '\''/^$;.*$*$/d'\''     -e '\''s/^$EXPORTS\|LIBRARY$$	 .*$*$/DEF/p'\''     -e q     $export_symbols`" ; then
+              cp $export_symbols $output_objdir/$soname.def;
+            else
+              echo EXPORTS > $output_objdir/$soname.def;
+              cat $export_symbols >> $output_objdir/$soname.def;
+            fi~
+            $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname $wl--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
+	  else
+	    ld_shlibs_CXX=no
+	  fi
+	  ;;
+	esac
+	;;
+      darwin* | rhapsody*)
+
+
+  archive_cmds_need_lc_CXX=no
+  hardcode_direct_CXX=no
+  hardcode_automatic_CXX=yes
+  hardcode_shlibpath_var_CXX=unsupported
+  if test yes = "$lt_cv_ld_force_load"; then
+    whole_archive_flag_spec_CXX='`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience $wl-force_load,$conv\"; done; func_echo_all \"$new_convenience\"`'
+
+  else
+    whole_archive_flag_spec_CXX=''
+  fi
+  link_all_deplibs_CXX=yes
+  allow_undefined_flag_CXX=$_lt_dar_allow_undefined
+  case $cc_basename in
+     ifort*|nagfor*) _lt_dar_can_shared=yes ;;
+     *) _lt_dar_can_shared=$GCC ;;
+  esac
+  if test yes = "$_lt_dar_can_shared"; then
+    output_verbose_link_cmd=func_echo_all
+    archive_cmds_CXX="\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dsymutil"
+    module_cmds_CXX="\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dsymutil"
+    archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$libobjs \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring $_lt_dar_single_mod$_lt_dar_export_syms$_lt_dsymutil"
+    module_expsym_cmds_CXX="sed -e 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC \$allow_undefined_flag -o \$lib -bundle \$libobjs \$deplibs \$compiler_flags$_lt_dar_export_syms$_lt_dsymutil"
+       if test yes != "$lt_cv_apple_cc_single_mod"; then
+      archive_cmds_CXX="\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dsymutil"
+      archive_expsym_cmds_CXX="sed 's|^|_|' < \$export_symbols > \$output_objdir/\$libname-symbols.expsym~\$CC -r -keep_private_externs -nostdlib -o \$lib-master.o \$libobjs~\$CC -dynamiclib \$allow_undefined_flag -o \$lib \$lib-master.o \$deplibs \$compiler_flags -install_name \$rpath/\$soname \$verstring$_lt_dar_export_syms$_lt_dsymutil"
+    fi
+
+  else
+  ld_shlibs_CXX=no
+  fi
+
+	;;
+
+      os2*)
+	hardcode_libdir_flag_spec_CXX='-L$libdir'
+	hardcode_minus_L_CXX=yes
+	allow_undefined_flag_CXX=unsupported
+	shrext_cmds=.dll
+	archive_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	archive_expsym_cmds_CXX='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	old_archive_From_new_cmds_CXX='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	enable_shared_with_static_runtimes_CXX=yes
+	;;
+
+      dgux*)
+        case $cc_basename in
+          ec++*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          ghcx*)
+	    # Green Hills C++ Compiler
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      freebsd2.*)
+        # C++ shared libraries reported to be fairly broken before
+	# switch to ELF
+        ld_shlibs_CXX=no
+        ;;
+
+      freebsd-elf*)
+        archive_cmds_need_lc_CXX=no
+        ;;
+
+      freebsd* | dragonfly*)
+        # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
+        # conventions
+        ld_shlibs_CXX=yes
+        ;;
+
+      haiku*)
+        archive_cmds_CXX='$CC -shared $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+        link_all_deplibs_CXX=yes
+        ;;
+
+      hpux9*)
+        hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
+        hardcode_libdir_separator_CXX=:
+        export_dynamic_flag_spec_CXX='$wl-E'
+        hardcode_direct_CXX=yes
+        hardcode_minus_L_CXX=yes # Not in the search PATH,
+				             # but as the default
+				             # location of the library.
+
+        case $cc_basename in
+          CC*)
+            # FIXME: insert proper C++ library support
+            ld_shlibs_CXX=no
+            ;;
+          aCC*)
+            archive_cmds_CXX='$RM $output_objdir/$soname~$CC -b $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            # Commands to make compiler produce verbose output that lists
+            # what "hidden" libraries, object files and flags are used when
+            # linking a shared library.
+            #
+            # There doesn't appear to be a way to prevent this compiler from
+            # explicitly linking system object files so we need to strip them
+            # from the output so that they don't get included in the library
+            # dependencies.
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            ;;
+          *)
+            if test yes = "$GXX"; then
+              archive_cmds_CXX='$RM $output_objdir/$soname~$CC -shared -nostdlib $pic_flag $wl+b $wl$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test "x$output_objdir/$soname" = "x$lib" || mv $output_objdir/$soname $lib'
+            else
+              # FIXME: insert proper C++ library support
+              ld_shlibs_CXX=no
+            fi
+            ;;
+        esac
+        ;;
+
+      hpux10*|hpux11*)
+        if test no = "$with_gnu_ld"; then
+	  hardcode_libdir_flag_spec_CXX='$wl+b $wl$libdir'
+	  hardcode_libdir_separator_CXX=:
+
+          case $host_cpu in
+            hppa*64*|ia64*)
+              ;;
+            *)
+	      export_dynamic_flag_spec_CXX='$wl-E'
+              ;;
+          esac
+        fi
+        case $host_cpu in
+          hppa*64*|ia64*)
+            hardcode_direct_CXX=no
+            hardcode_shlibpath_var_CXX=no
+            ;;
+          *)
+            hardcode_direct_CXX=yes
+            hardcode_direct_absolute_CXX=yes
+            hardcode_minus_L_CXX=yes # Not in the search PATH,
+					         # but as the default
+					         # location of the library.
+            ;;
+        esac
+
+        case $cc_basename in
+          CC*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          aCC*)
+	    case $host_cpu in
+	      hppa*64*)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      ia64*)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	      *)
+	        archive_cmds_CXX='$CC -b $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	        ;;
+	    esac
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        case $host_cpu in
+	          hppa*64*)
+	            archive_cmds_CXX='$CC -shared -nostdlib -fPIC $wl+h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          ia64*)
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	          *)
+	            archive_cmds_CXX='$CC -shared -nostdlib $pic_flag $wl+h $wl$soname $wl+b $wl$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	            ;;
+	        esac
+	      fi
+	    else
+	      # FIXME: insert proper C++ library support
+	      ld_shlibs_CXX=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      interix3-9*)
+	hardcode_direct_CXX=no
+	hardcode_shlibpath_var_CXX=no
+	hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	export_dynamic_flag_spec_CXX='$wl-E'
+	# Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
+	# Instead, shared libraries are loaded at an image base (0x10000000 by
+	# default) and relocated if they conflict, which is a slow very memory
+	# consuming and fragmenting process.  To avoid this, we pick a random,
+	# 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
+	# time.  Moving up from 0x10000000 also allows more sbrk(2) space.
+	archive_cmds_CXX='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	archive_expsym_cmds_CXX='sed "s|^|_|" $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-h,$soname $wl--retain-symbols-file,$output_objdir/$soname.expsym $wl--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
+	;;
+      irix5* | irix6*)
+        case $cc_basename in
+          CC*)
+	    # SGI C++
+	    archive_cmds_CXX='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    old_archive_cmds_CXX='$CC -ar -WR,-u -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    if test yes = "$GXX"; then
+	      if test no = "$with_gnu_ld"; then
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+	      else
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` -o $lib'
+	      fi
+	    fi
+	    link_all_deplibs_CXX=yes
+	    ;;
+        esac
+        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+        hardcode_libdir_separator_CXX=:
+        inherit_rpath_CXX=yes
+        ;;
+
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/$^()0-9A-Za-z{}$/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+	    archive_expsym_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/$^()0-9A-Za-z{}$/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib $wl-retain-symbols-file,$export_symbols; mv \$templib $lib'
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -Bstatic", where "CC" is the KAI C++ compiler.
+	    old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs'
+	    ;;
+	  icpc* | ecpc* )
+	    # Intel C++
+	    with_gnu_ld=yes
+	    # version 8.0 and above of icpc choke on multiply defined symbols
+	    # if we add $predep_objects and $postdep_objects, however 7.1 and
+	    # earlier do not add the objects themselves.
+	    case `$CC -V 2>&1` in
+	      *"Version 7."*)
+	        archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	      *)  # Version 8.0 or newer
+	        tmp_idyn=
+	        case $host_cpu in
+		  ia64*) tmp_idyn=' -i_dynamic';;
+		esac
+	        archive_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+		archive_expsym_cmds_CXX='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+		;;
+	    esac
+	    archive_cmds_need_lc_CXX=no
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive$convenience $wl--no-whole-archive'
+	    ;;
+          pgCC* | pgcpp*)
+            # Portland Group C++ compiler
+	    case `$CC -V` in
+	    *pgCC\ 1-5.* | *pgcpp\ 1-5.*)
+	      prelink_cmds_CXX='tpldir=Template.dir~
+               rm -rf $tpldir~
+               $CC --prelink_objects --instantiation_dir $tpldir $objs $libobjs $compile_deplibs~
+               compile_command="$compile_command `find $tpldir -name \*.o | sort | $NL2SP`"'
+	      old_archive_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $oldobjs$old_deplibs~
+                $AR $AR_FLAGS $oldlib$oldobjs$old_deplibs `find $tpldir -name \*.o | sort | $NL2SP`~
+                $RANLIB $oldlib'
+	      archive_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      archive_expsym_cmds_CXX='tpldir=Template.dir~
+                rm -rf $tpldir~
+                $CC --prelink_objects --instantiation_dir $tpldir $predep_objects $libobjs $deplibs $convenience $postdep_objects~
+                $CC -shared $pic_flag $predep_objects $libobjs $deplibs `find $tpldir -name \*.o | sort | $NL2SP` $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    *) # Version 6 and above use weak symbols
+	      archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	      archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname $wl-retain-symbols-file $wl$export_symbols -o $lib'
+	      ;;
+	    esac
+
+	    hardcode_libdir_flag_spec_CXX='$wl--rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    whole_archive_flag_spec_CXX='$wl--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+            ;;
+	  cxx*)
+	    # Compaq C++
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname -o $lib'
+	    archive_expsym_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname  -o $lib $wl-retain-symbols-file $wl$export_symbols'
+
+	    runpath_var=LD_RUN_PATH
+	    hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+	    hardcode_libdir_separator_CXX=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`func_echo_all "$templist" | $SED "s/$^.*ld.*$$ .*ld .*$$/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "X$list" | $Xsed'
+	    ;;
+	  xl* | mpixl* | bgxl*)
+	    # IBM XL 8.0 on PPC, with GNU ld
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+	    export_dynamic_flag_spec_CXX='$wl--export-dynamic'
+	    archive_cmds_CXX='$CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname -o $lib'
+	    if test yes = "$supports_anon_versioning"; then
+	      archive_expsym_cmds_CXX='echo "{ global:" > $output_objdir/$libname.ver~
+                cat $export_symbols | sed -e "s/$.*$/\1;/" >> $output_objdir/$libname.ver~
+                echo "local: *; };" >> $output_objdir/$libname.ver~
+                $CC -qmkshrobj $libobjs $deplibs $compiler_flags $wl-soname $wl$soname $wl-version-script $wl$output_objdir/$libname.ver -o $lib'
+	    fi
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      no_undefined_flag_CXX=' -zdefs'
+	      archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	      archive_expsym_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file $wl$export_symbols'
+	      hardcode_libdir_flag_spec_CXX='-R$libdir'
+	      whole_archive_flag_spec_CXX='$wl--whole-archive`new_convenience=; for conv in $convenience\"\"; do test -z \"$conv\" || new_convenience=\"$new_convenience,$conv\"; done; func_echo_all \"$new_convenience\"` $wl--no-whole-archive'
+	      compiler_needs_object_CXX=yes
+
+	      # Not sure whether something based on
+	      # $CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1
+	      # would be better.
+	      output_verbose_link_cmd='func_echo_all'
+
+	      # Archives containing C++ object files must be created using
+	      # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	      # necessary to make sure instantiated templates are included
+	      # in the archive.
+	      old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+
+      lynxos*)
+        # FIXME: insert proper C++ library support
+	ld_shlibs_CXX=no
+	;;
+
+      m88k*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+	;;
+
+      mvs*)
+        case $cc_basename in
+          cxx*)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+	  *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+	esac
+	;;
+
+      netbsd*)
+        if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+	  archive_cmds_CXX='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
+	  wlarc=
+	  hardcode_libdir_flag_spec_CXX='-R$libdir'
+	  hardcode_direct_CXX=yes
+	  hardcode_shlibpath_var_CXX=no
+	fi
+	# Workaround some broken pre-1.5 toolchains
+	output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
+	;;
+
+      *nto* | *qnx*)
+        ld_shlibs_CXX=yes
+	;;
+
+      openbsd* | bitrig*)
+	if test -f /usr/libexec/ld.so; then
+	  hardcode_direct_CXX=yes
+	  hardcode_shlibpath_var_CXX=no
+	  hardcode_direct_absolute_CXX=yes
+	  archive_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
+	  hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`"; then
+	    archive_expsym_cmds_CXX='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-retain-symbols-file,$export_symbols -o $lib'
+	    export_dynamic_flag_spec_CXX='$wl-E'
+	    whole_archive_flag_spec_CXX=$wlarc'--whole-archive$convenience '$wlarc'--no-whole-archive'
+	  fi
+	  output_verbose_link_cmd=func_echo_all
+	else
+	  ld_shlibs_CXX=no
+	fi
+	;;
+
+      osf3* | osf4* | osf5*)
+        case $cc_basename in
+          KCC*)
+	    # Kuck and Associates, Inc. (KAI) C++ Compiler
+
+	    # KCC will only create a shared library if the output file
+	    # ends with ".so" (or ".sl" for HP-UX), so rename the library
+	    # to its proper name (with version) after linking.
+	    archive_cmds_CXX='tempext=`echo $shared_ext | $SED -e '\''s/$^()0-9A-Za-z{}$/\\\\\1/g'\''`; templib=`echo "$lib" | $SED -e "s/\$tempext\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
+
+	    hardcode_libdir_flag_spec_CXX='$wl-rpath,$libdir'
+	    hardcode_libdir_separator_CXX=:
+
+	    # Archives containing C++ object files must be created using
+	    # the KAI C++ compiler.
+	    case $host in
+	      osf3*) old_archive_cmds_CXX='$CC -Bstatic -o $oldlib $oldobjs' ;;
+	      *) old_archive_cmds_CXX='$CC -o $oldlib $oldobjs' ;;
+	    esac
+	    ;;
+          RCC*)
+	    # Rational C++ 2.4.1
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          cxx*)
+	    case $host in
+	      osf3*)
+	        allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $soname `test -n "$verstring" && func_echo_all "$wl-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+		;;
+	      *)
+	        allow_undefined_flag_CXX=' -expect_unresolved \*'
+	        archive_cmds_CXX='$CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
+	        archive_expsym_cmds_CXX='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
+                  echo "-hidden">> $lib.exp~
+                  $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname $wl-input $wl$lib.exp  `test -n "$verstring" && $ECHO "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib~
+                  $RM $lib.exp'
+	        hardcode_libdir_flag_spec_CXX='-rpath $libdir'
+		;;
+	    esac
+
+	    hardcode_libdir_separator_CXX=:
+
+	    # Commands to make compiler produce verbose output that lists
+	    # what "hidden" libraries, object files and flags are used when
+	    # linking a shared library.
+	    #
+	    # There doesn't appear to be a way to prevent this compiler from
+	    # explicitly linking system object files so we need to strip them
+	    # from the output so that they don't get included in the library
+	    # dependencies.
+	    output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`func_echo_all "$templist" | $SED "s/$^.*ld.*$$ .*ld.*$$/\1/"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    ;;
+	  *)
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      allow_undefined_flag_CXX=' $wl-expect_unresolved $wl\*'
+	      case $host in
+	        osf3*)
+	          archive_cmds_CXX='$CC -shared -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	        *)
+	          archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-msym $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations -o $lib'
+		  ;;
+	      esac
+
+	      hardcode_libdir_flag_spec_CXX='$wl-rpath $wl$libdir'
+	      hardcode_libdir_separator_CXX=:
+
+	      # Commands to make compiler produce verbose output that lists
+	      # what "hidden" libraries, object files and flags are used when
+	      # linking a shared library.
+	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+
+	    else
+	      # FIXME: insert proper C++ library support
+	      ld_shlibs_CXX=no
+	    fi
+	    ;;
+        esac
+        ;;
+
+      psos*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+
+      sunos4*)
+        case $cc_basename in
+          CC*)
+	    # Sun C++ 4.x
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          lcc*)
+	    # Lucid
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      solaris*)
+        case $cc_basename in
+          CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+            archive_cmds_need_lc_CXX=yes
+	    no_undefined_flag_CXX=' -zdefs'
+	    archive_cmds_CXX='$CC -G$allow_undefined_flag -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
+	    archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+              $CC -G$allow_undefined_flag $wl-M $wl$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	    hardcode_libdir_flag_spec_CXX='-R$libdir'
+	    hardcode_shlibpath_var_CXX=no
+	    case $host_os in
+	      solaris2.0-5 | solaris2.0-5.*) ;;
+	      *)
+		# The compiler driver will combine and reorder linker options,
+		# but understands '-z linker_flag'.
+	        # Supported since Solaris 2.6 (maybe 2.5.1?)
+		whole_archive_flag_spec_CXX='-z allextract$convenience -z defaultextract'
+	        ;;
+	    esac
+	    link_all_deplibs_CXX=yes
+
+	    output_verbose_link_cmd='func_echo_all'
+
+	    # Archives containing C++ object files must be created using
+	    # "CC -xar", where "CC" is the Sun C++ compiler.  This is
+	    # necessary to make sure instantiated templates are included
+	    # in the archive.
+	    old_archive_cmds_CXX='$CC -xar -o $oldlib $oldobjs'
+	    ;;
+          gcx*)
+	    # Green Hills C++ Compiler
+	    archive_cmds_CXX='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+
+	    # The C++ compiler must be used to create the archive.
+	    old_archive_cmds_CXX='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
+	    ;;
+          *)
+	    # GNU C++ compiler with Solaris linker
+	    if test yes,no = "$GXX,$with_gnu_ld"; then
+	      no_undefined_flag_CXX=' $wl-z ${wl}defs'
+	      if $CC --version | $GREP -v '^2\.7' > /dev/null; then
+	        archive_cmds_CXX='$CC -shared $pic_flag -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -shared $pic_flag -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+	      else
+	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
+	        # platform.
+	        archive_cmds_CXX='$CC -G -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags $wl-h $wl$soname -o $lib'
+	        archive_expsym_cmds_CXX='echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/$.*$/\1;/" >> $lib.exp~echo "local: *; };" >> $lib.exp~
+                  $CC -G -nostdlib $wl-M $wl$lib.exp $wl-h $wl$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$RM $lib.exp'
+
+	        # Commands to make compiler produce verbose output that lists
+	        # what "hidden" libraries, object files and flags are used when
+	        # linking a shared library.
+	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
+	      fi
+
+	      hardcode_libdir_flag_spec_CXX='$wl-R $wl$libdir'
+	      case $host_os in
+		solaris2.0-5 | solaris2.0-5.*) ;;
+		*)
+		  whole_archive_flag_spec_CXX='$wl-z ${wl}allextract$convenience $wl-z ${wl}defaultextract'
+		  ;;
+	      esac
+	    fi
+	    ;;
+        esac
+        ;;
+
+    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.01.10* | unixware7* | sco3.2v5.0.024*)
+      no_undefined_flag_CXX='$wl-z,text'
+      archive_cmds_need_lc_CXX=no
+      hardcode_shlibpath_var_CXX=no
+      runpath_var='LD_RUN_PATH'
+
+      case $cc_basename in
+        CC*)
+	  archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+	*)
+	  archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	  ;;
+      esac
+      ;;
+
+      sysv5* | sco3.2v5* | sco5v6*)
+	# Note: We CANNOT use -z defs as we might desire, because we do not
+	# link with -lc, and that would cause any symbols used from libc to
+	# always be unresolved, which means just about no library would
+	# ever link correctly.  If we're not using GNU ld we use -z text
+	# though, which does catch some bad symbols but isn't as heavy-handed
+	# as -z defs.
+	no_undefined_flag_CXX='$wl-z,text'
+	allow_undefined_flag_CXX='$wl-z,nodefs'
+	archive_cmds_need_lc_CXX=no
+	hardcode_shlibpath_var_CXX=no
+	hardcode_libdir_flag_spec_CXX='$wl-R,$libdir'
+	hardcode_libdir_separator_CXX=':'
+	link_all_deplibs_CXX=yes
+	export_dynamic_flag_spec_CXX='$wl-Bexport'
+	runpath_var='LD_RUN_PATH'
+
+	case $cc_basename in
+          CC*)
+	    archive_cmds_CXX='$CC -G $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -G $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    old_archive_cmds_CXX='$CC -Tprelink_objects $oldobjs~
+              '"$old_archive_cmds_CXX"
+	    reload_cmds_CXX='$CC -Tprelink_objects $reload_objs~
+              '"$reload_cmds_CXX"
+	    ;;
+	  *)
+	    archive_cmds_CXX='$CC -shared $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    archive_expsym_cmds_CXX='$CC -shared $wl-Bexport:$export_symbols $wl-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
+	    ;;
+	esac
+      ;;
+
+      tandem*)
+        case $cc_basename in
+          NCC*)
+	    # NonStop-UX NCC 3.20
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+          *)
+	    # FIXME: insert proper C++ library support
+	    ld_shlibs_CXX=no
+	    ;;
+        esac
+        ;;
+
+      vxworks*)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+
+      *)
+        # FIXME: insert proper C++ library support
+        ld_shlibs_CXX=no
+        ;;
+    esac
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+$as_echo "$ld_shlibs_CXX" >&6; }
+    test no = "$ld_shlibs_CXX" && can_build_shared=no
+
+    GCC_CXX=$GXX
+    LD_CXX=$LD
+
+    ## CAVEAT EMPTOR:
+    ## There is no encapsulation within the following macros, do not change
+    ## the running order or otherwise move them around unless you know exactly
+    ## what you are doing...
+    # Dependencies to place before and after the object being linked:
+predep_objects_CXX=
+postdep_objects_CXX=
+predeps_CXX=
+postdeps_CXX=
+compiler_lib_search_path_CXX=
+
+cat > conftest.$ac_ext <<_LT_EOF
+class Foo
+{
+public:
+  Foo (void) { a = 0; }
+private:
+  int a;
+};
+_LT_EOF
+
+
+_lt_libdeps_save_CFLAGS=$CFLAGS
+case "$CC $CFLAGS " in #(
+*\ -flto*\ *) CFLAGS="$CFLAGS -fno-lto" ;;
+*\ -fwhopr*\ *) CFLAGS="$CFLAGS -fno-whopr" ;;
+*\ -fuse-linker-plugin*\ *) CFLAGS="$CFLAGS -fno-use-linker-plugin" ;;
+esac
+
+if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; then
+  # Parse the compiler output and extract the necessary
+  # objects, libraries and library flags.
+
+  # Sentinel used to keep track of whether or not we are before
+  # the conftest object file.
+  pre_test_object_deps_done=no
+
+  for p in `eval "$output_verbose_link_cmd"`; do
+    case $prev$p in
+
+    -L* | -R* | -l*)
+       # Some compilers place space between "-{L,R}" and the path.
+       # Remove the space.
+       if test x-L = "$p" ||
+          test x-R = "$p"; then
+	 prev=$p
+	 continue
+       fi
+
+       # Expand the sysroot to ease extracting the directories later.
+       if test -z "$prev"; then
+         case $p in
+         -L*) func_stripname_cnf '-L' '' "$p"; prev=-L; p=$func_stripname_result ;;
+         -R*) func_stripname_cnf '-R' '' "$p"; prev=-R; p=$func_stripname_result ;;
+         -l*) func_stripname_cnf '-l' '' "$p"; prev=-l; p=$func_stripname_result ;;
+         esac
+       fi
+       case $p in
+       =*) func_stripname_cnf '=' '' "$p"; p=$lt_sysroot$func_stripname_result ;;
+       esac
+       if test no = "$pre_test_object_deps_done"; then
+	 case $prev in
+	 -L | -R)
+	   # Internal compiler library paths should come after those
+	   # provided the user.  The postdeps already come after the
+	   # user supplied libs so there is no need to process them.
+	   if test -z "$compiler_lib_search_path_CXX"; then
+	     compiler_lib_search_path_CXX=$prev$p
+	   else
+	     compiler_lib_search_path_CXX="${compiler_lib_search_path_CXX} $prev$p"
+	   fi
+	   ;;
+	 # The "-l" case would never come before the object being
+	 # linked, so don't bother handling this case.
+	 esac
+       else
+	 if test -z "$postdeps_CXX"; then
+	   postdeps_CXX=$prev$p
+	 else
+	   postdeps_CXX="${postdeps_CXX} $prev$p"
+	 fi
+       fi
+       prev=
+       ;;
+
+    *.lto.$objext) ;; # Ignore GCC LTO objects
+    *.$objext)
+       # This assumes that the test object file only shows up
+       # once in the compiler output.
+       if test "$p" = "conftest.$objext"; then
+	 pre_test_object_deps_done=yes
+	 continue
+       fi
+
+       if test no = "$pre_test_object_deps_done"; then
+	 if test -z "$predep_objects_CXX"; then
+	   predep_objects_CXX=$p
+	 else
+	   predep_objects_CXX="$predep_objects_CXX $p"
+	 fi
+       else
+	 if test -z "$postdep_objects_CXX"; then
+	   postdep_objects_CXX=$p
+	 else
+	   postdep_objects_CXX="$postdep_objects_CXX $p"
+	 fi
+       fi
+       ;;
+
+    *) ;; # Ignore the rest.
+
+    esac
+  done
+
+  # Clean up.
+  rm -f a.out a.exe
+else
+  echo "libtool.m4: error: problem compiling CXX test program"
+fi
+
+$RM -f confest.$objext
+CFLAGS=$_lt_libdeps_save_CFLAGS
+
+# PORTME: override above test on systems where it is broken
+case $host_os in
+interix3-9*)
+  # Interix 3.5 installs completely hosed .la files for C++, so rather than
+  # hack all around it, let's just trust "g++" to DTRT.
+  predep_objects_CXX=
+  postdep_objects_CXX=
+  postdeps_CXX=
+  ;;
+esac
+
+
+case " $postdeps_CXX " in
+*" -lc "*) archive_cmds_need_lc_CXX=no ;;
+esac
+ compiler_lib_search_dirs_CXX=
+if test -n "${compiler_lib_search_path_CXX}"; then
+ compiler_lib_search_dirs_CXX=`echo " ${compiler_lib_search_path_CXX}" | $SED -e 's! -L! !g' -e 's!^ !!'`
+fi
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    lt_prog_compiler_wl_CXX=
+lt_prog_compiler_pic_CXX=
+lt_prog_compiler_static_CXX=
+
+
+  # C++ specific cases for pic, static, wl, etc.
+  if test yes = "$GXX"; then
+    lt_prog_compiler_wl_CXX='-Wl,'
+    lt_prog_compiler_static_CXX='-static'
+
+    case $host_os in
+    aix*)
+      # All AIX code is PIC.
+      if test ia64 = "$host_cpu"; then
+	# AIX 5 now supports IA64 processor
+	lt_prog_compiler_static_CXX='-Bstatic'
+      fi
+      lt_prog_compiler_pic_CXX='-fPIC'
+      ;;
+
+    amigaos*)
+      case $host_cpu in
+      powerpc)
+            # see comment about AmigaOS4 .so support
+            lt_prog_compiler_pic_CXX='-fPIC'
+        ;;
+      m68k)
+            # FIXME: we need at least 68020 code to build shared libraries, but
+            # adding the '-m68020' flag to GCC prevents building anything better,
+            # like '-m68040'.
+            lt_prog_compiler_pic_CXX='-m68020 -resident32 -malways-restore-a4'
+        ;;
+      esac
+      ;;
+
+    beos* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
+      # PIC is the default for these OSes.
+      ;;
+    mingw* | cygwin* | os2* | pw32* | cegcc*)
+      # This hack is so that the source file can tell whether it is being
+      # built for inclusion in a dll (and should export symbols for example).
+      # Although the cygwin gcc ignores -fPIC, still need this for old-style
+      # (--disable-auto-import) libraries
+      lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+      case $host_os in
+      os2*)
+	lt_prog_compiler_static_CXX='$wl-static'
+	;;
+      esac
+      ;;
+    darwin* | rhapsody*)
+      # PIC is the default on this platform
+      # Common symbols not allowed in MH_DYLIB files
+      lt_prog_compiler_pic_CXX='-fno-common'
+      ;;
+    *djgpp*)
+      # DJGPP does not support shared libraries at all
+      lt_prog_compiler_pic_CXX=
+      ;;
+    haiku*)
+      # PIC is the default for Haiku.
+      # The "-static" flag exists, but is broken.
+      lt_prog_compiler_static_CXX=
+      ;;
+    interix3-9*)
+      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
+      # Instead, we relocate shared libraries at runtime.
+      ;;
+    sysv4*MP*)
+      if test -d /usr/nec; then
+	lt_prog_compiler_pic_CXX=-Kconform_pic
+      fi
+      ;;
+    hpux*)
+      # PIC is the default for 64-bit PA HP-UX, but not for 32-bit
+      # PA HP-UX.  On IA64 HP-UX, PIC is the default but the pic flag
+      # sets the default TLS model and affects inlining.
+      case $host_cpu in
+      hppa*64*)
+	;;
+      *)
+	lt_prog_compiler_pic_CXX='-fPIC'
+	;;
+      esac
+      ;;
+    *qnx* | *nto*)
+      # QNX uses GNU C++, but need to define -shared option too, otherwise
+      # it will coredump.
+      lt_prog_compiler_pic_CXX='-fPIC -shared'
+      ;;
+    *)
+      lt_prog_compiler_pic_CXX='-fPIC'
+      ;;
+    esac
+  else
+    case $host_os in
+      aix4-9*)
+	# All AIX code is PIC.
+	if test ia64 = "$host_cpu"; then
+	  # AIX 5 now supports IA64 processor
+	  lt_prog_compiler_static_CXX='-Bstatic'
+	else
+	  lt_prog_compiler_static_CXX='-bnso -bI:/lib/syscalls.exp'
+	fi
+	;;
+      chorus*)
+	case $cc_basename in
+	cxch68*)
+	  # Green Hills C++ Compiler
+	  # _LT_TAGVAR(lt_prog_compiler_static, CXX)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
+	  ;;
+	esac
+	;;
+      mingw* | cygwin* | os2* | pw32* | cegcc*)
+	# This hack is so that the source file can tell whether it is being
+	# built for inclusion in a dll (and should export symbols for example).
+	lt_prog_compiler_pic_CXX='-DDLL_EXPORT'
+	;;
+      dgux*)
+	case $cc_basename in
+	  ec++*)
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  ghcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      freebsd* | dragonfly*)
+	# FreeBSD uses GNU C++
+	;;
+      hpux9* | hpux10* | hpux11*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
+	    if test ia64 != "$host_cpu"; then
+	      lt_prog_compiler_pic_CXX='+Z'
+	    fi
+	    ;;
+	  aCC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='$wl-a ${wl}archive'
+	    case $host_cpu in
+	    hppa*64*|ia64*)
+	      # +Z the default
+	      ;;
+	    *)
+	      lt_prog_compiler_pic_CXX='+Z'
+	      ;;
+	    esac
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      interix*)
+	# This is c89, which is MS Visual C++ (no shared libs)
+	# Anyone wants to do a port?
+	;;
+      irix5* | irix6* | nonstopux*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    # CC pic flag -KPIC is the default.
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+	case $cc_basename in
+	  KCC*)
+	    # KAI C++ Compiler
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    lt_prog_compiler_pic_CXX='-fPIC'
+	    ;;
+	  ecpc* )
+	    # old Intel C++ for x86_64, which still supported -KPIC.
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-static'
+	    ;;
+	  icpc* )
+	    # Intel C++, used to be incompatible with GCC.
+	    # ICC 10 doesn't accept -KPIC any more.
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-fPIC'
+	    lt_prog_compiler_static_CXX='-static'
+	    ;;
+	  pgCC* | pgcpp*)
+	    # Portland Group C++ compiler
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-fpic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  cxx*)
+	    # Compaq C++
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  xlc* | xlC* | bgxlcC* | mpixlcC*)
+	    # IBM XL 8.0, 9.0 on PPC and BlueGene
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-qpic'
+	    lt_prog_compiler_static_CXX='-qstaticlink'
+	    ;;
+	  *)
+	    case `$CC -V 2>&1 | sed 5q` in
+	    *Sun\ C*)
+	      # Sun C++ 5.9
+	      lt_prog_compiler_pic_CXX='-KPIC'
+	      lt_prog_compiler_static_CXX='-Bstatic'
+	      lt_prog_compiler_wl_CXX='-Qoption ld '
+	      ;;
+	    esac
+	    ;;
+	esac
+	;;
+      lynxos*)
+	;;
+      m88k*)
+	;;
+      mvs*)
+	case $cc_basename in
+	  cxx*)
+	    lt_prog_compiler_pic_CXX='-W c,exportall'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      netbsd* | netbsdelf*-gnu)
+	;;
+      *qnx* | *nto*)
+        # QNX uses GNU C++, but need to define -shared option too, otherwise
+        # it will coredump.
+        lt_prog_compiler_pic_CXX='-fPIC -shared'
+        ;;
+      osf3* | osf4* | osf5*)
+	case $cc_basename in
+	  KCC*)
+	    lt_prog_compiler_wl_CXX='--backend -Wl,'
+	    ;;
+	  RCC*)
+	    # Rational C++ 2.4.1
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  cxx*)
+	    # Digital/Compaq C++
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    # Make sure the PIC flag is empty.  It appears that all Alpha
+	    # Linux and Compaq Tru64 Unix objects are PIC.
+	    lt_prog_compiler_pic_CXX=
+	    lt_prog_compiler_static_CXX='-non_shared'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      psos*)
+	;;
+      solaris*)
+	case $cc_basename in
+	  CC* | sunCC*)
+	    # Sun C++ 4.2, 5.x and Centerline C++
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    lt_prog_compiler_wl_CXX='-Qoption ld '
+	    ;;
+	  gcx*)
+	    # Green Hills C++ Compiler
+	    lt_prog_compiler_pic_CXX='-PIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sunos4*)
+	case $cc_basename in
+	  CC*)
+	    # Sun C++ 4.x
+	    lt_prog_compiler_pic_CXX='-pic'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	  lcc*)
+	    # Lucid
+	    lt_prog_compiler_pic_CXX='-pic'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
+	case $cc_basename in
+	  CC*)
+	    lt_prog_compiler_wl_CXX='-Wl,'
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    lt_prog_compiler_static_CXX='-Bstatic'
+	    ;;
+	esac
+	;;
+      tandem*)
+	case $cc_basename in
+	  NCC*)
+	    # NonStop-UX NCC 3.20
+	    lt_prog_compiler_pic_CXX='-KPIC'
+	    ;;
+	  *)
+	    ;;
+	esac
+	;;
+      vxworks*)
+	;;
+      *)
+	lt_prog_compiler_can_build_shared_CXX=no
+	;;
+    esac
+  fi
+
+case $host_os in
+  # For platforms that do not support PIC, -DPIC is meaningless:
+  *djgpp*)
+    lt_prog_compiler_pic_CXX=
+    ;;
+  *)
+    lt_prog_compiler_pic_CXX="$lt_prog_compiler_pic_CXX -DPIC"
+    ;;
+esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $compiler option to produce PIC" >&5
+$as_echo_n "checking for $compiler option to produce PIC... " >&6; }
+if ${lt_cv_prog_compiler_pic_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic_CXX=$lt_prog_compiler_pic_CXX
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_pic_CXX" >&6; }
+lt_prog_compiler_pic_CXX=$lt_cv_prog_compiler_pic_CXX
+
+#
+# Check to make sure the PIC flag actually works.
+#
+if test -n "$lt_prog_compiler_pic_CXX"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works" >&5
+$as_echo_n "checking if $compiler PIC flag $lt_prog_compiler_pic_CXX works... " >&6; }
+if ${lt_cv_prog_compiler_pic_works_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_pic_works_CXX=no
+   ac_outfile=conftest.$ac_objext
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+   lt_compiler_flag="$lt_prog_compiler_pic_CXX -DPIC"  ## exclude from sc_useless_quotes_in_assignment
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   # The option is referenced via a variable to avoid confusing sed.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>conftest.err)
+   ac_status=$?
+   cat conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s "$ac_outfile"; then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings other than the usual output.
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' >conftest.exp
+     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_pic_works_CXX=yes
+     fi
+   fi
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_pic_works_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_pic_works_CXX" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_pic_works_CXX"; then
+    case $lt_prog_compiler_pic_CXX in
+     "" | " "*) ;;
+     *) lt_prog_compiler_pic_CXX=" $lt_prog_compiler_pic_CXX" ;;
+     esac
+else
+    lt_prog_compiler_pic_CXX=
+     lt_prog_compiler_can_build_shared_CXX=no
+fi
+
+fi
+
+
+
+
+
+#
+# Check to make sure the static flag actually works.
+#
+wl=$lt_prog_compiler_wl_CXX eval lt_tmp_static_flag=\"$lt_prog_compiler_static_CXX\"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler static flag $lt_tmp_static_flag works" >&5
+$as_echo_n "checking if $compiler static flag $lt_tmp_static_flag works... " >&6; }
+if ${lt_cv_prog_compiler_static_works_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_static_works_CXX=no
+   save_LDFLAGS=$LDFLAGS
+   LDFLAGS="$LDFLAGS $lt_tmp_static_flag"
+   echo "$lt_simple_link_test_code" > conftest.$ac_ext
+   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
+     # The linker can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     if test -s conftest.err; then
+       # Append any errors to the config.log.
+       cat conftest.err 1>&5
+       $ECHO "$_lt_linker_boilerplate" | $SED '/^$/d' > conftest.exp
+       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
+       if diff conftest.exp conftest.er2 >/dev/null; then
+         lt_cv_prog_compiler_static_works_CXX=yes
+       fi
+     else
+       lt_cv_prog_compiler_static_works_CXX=yes
+     fi
+   fi
+   $RM -r conftest*
+   LDFLAGS=$save_LDFLAGS
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_static_works_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_static_works_CXX" >&6; }
+
+if test yes = "$lt_cv_prog_compiler_static_works_CXX"; then
+    :
+else
+    lt_prog_compiler_static_CXX=
+fi
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o_CXX=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_CXX=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking if $compiler supports -c -o file.$ac_objext" >&5
+$as_echo_n "checking if $compiler supports -c -o file.$ac_objext... " >&6; }
+if ${lt_cv_prog_compiler_c_o_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_prog_compiler_c_o_CXX=no
+   $RM -r conftest 2>/dev/null
+   mkdir conftest
+   cd conftest
+   mkdir out
+   echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+   lt_compiler_flag="-o out/conftest2.$ac_objext"
+   # Insert the option either (1) after the last *FLAGS variable, or
+   # (2) before a word containing "conftest.", or (3) at the end.
+   # Note that $ac_compile itself does not contain backslashes and begins
+   # with a dollar sign (not a hyphen), so the echo should work correctly.
+   lt_compile=`echo "$ac_compile" | $SED \
+   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
+   -e 's: ^ *conftest\.: $lt_compiler_flag&:; t' \
+   -e 's:$: $lt_compiler_flag:'`
+   (eval echo "\"\$as_me:$LINENO: $lt_compile\"" >&5)
+   (eval "$lt_compile" 2>out/conftest.err)
+   ac_status=$?
+   cat out/conftest.err >&5
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   if (exit $ac_status) && test -s out/conftest2.$ac_objext
+   then
+     # The compiler can only warn and ignore the option if not recognized
+     # So say no if there are warnings
+     $ECHO "$_lt_compiler_boilerplate" | $SED '/^$/d' > out/conftest.exp
+     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
+     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
+       lt_cv_prog_compiler_c_o_CXX=yes
+     fi
+   fi
+   chmod u+w . 2>&5
+   $RM conftest*
+   # SGI C++ compiler will create directory out/ii_files/ for
+   # template instantiation
+   test -d out/ii_files && $RM out/ii_files/* && rmdir out/ii_files
+   $RM out/* && rmdir out
+   cd ..
+   $RM -r conftest
+   $RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_prog_compiler_c_o_CXX" >&5
+$as_echo "$lt_cv_prog_compiler_c_o_CXX" >&6; }
+
+
+
+
+hard_links=nottested
+if test no = "$lt_cv_prog_compiler_c_o_CXX" && test no != "$need_locks"; then
+  # do not overwrite the value of need_locks provided by the user
+  { $as_echo "$as_me:${as_lineno-$LINENO}: checking if we can lock with hard links" >&5
+$as_echo_n "checking if we can lock with hard links... " >&6; }
+  hard_links=yes
+  $RM conftest*
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  touch conftest.a
+  ln conftest.a conftest.b 2>&5 || hard_links=no
+  ln conftest.a conftest.b 2>/dev/null && hard_links=no
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $hard_links" >&5
+$as_echo "$hard_links" >&6; }
+  if test no = "$hard_links"; then
+    { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&5
+$as_echo "$as_me: WARNING: '$CC' does not support '-c -o', so 'make -j' may be unsafe" >&2;}
+    need_locks=warn
+  fi
+else
+  need_locks=no
+fi
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether the $compiler linker ($LD) supports shared libraries" >&5
+$as_echo_n "checking whether the $compiler linker ($LD) supports shared libraries... " >&6; }
+
+  export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+  exclude_expsyms_CXX='_GLOBAL_OFFSET_TABLE_|_GLOBAL__FID_.*'
+  case $host_os in
+  aix4-9*)
+    # If we're using GNU nm, then we don't want the "-C" option.
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
+    if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
+      export_symbols_cmds_CXX='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
+    else
+      export_symbols_cmds_CXX='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
+    fi
+    ;;
+  pw32*)
+    export_symbols_cmds_CXX=$ltdll_cmds
+    ;;
+  cygwin* | mingw* | cegcc*)
+    case $cc_basename in
+    cl*)
+      exclude_expsyms_CXX='_NULL_IMPORT_DESCRIPTOR|_IMPORT_DESCRIPTOR_.*'
+      ;;
+    *)
+      export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^BCDGRS /s/.* $^ *$/\1 DATA/;s/^.* __nm__$^ *$ ^ */\1 DATA/;/^I /d;/^AITW /s/.* //'\'' | sort | uniq > $export_symbols'
+      exclude_expsyms_CXX='_+GLOBAL_OFFSET_TABLE_|_+GLOBAL__FID_.*|_+head_A-Za-z0-9_+_dll|A-Za-z0-9_+_dll_iname'
+      ;;
+    esac
+    ;;
+  linux* | k*bsd*-gnu | gnu*)
+    link_all_deplibs_CXX=no
+    ;;
+  *)
+    export_symbols_cmds_CXX='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
+    ;;
+  esac
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ld_shlibs_CXX" >&5
+$as_echo "$ld_shlibs_CXX" >&6; }
+test no = "$ld_shlibs_CXX" && can_build_shared=no
+
+with_gnu_ld_CXX=$with_gnu_ld
+
+
+
+
+
+
+#
+# Do we need to explicitly link libc?
+#
+case "x$archive_cmds_need_lc_CXX" in
+x|xyes)
+  # Assume -lc should be added
+  archive_cmds_need_lc_CXX=yes
+
+  if test yes,yes = "$GCC,$enable_shared"; then
+    case $archive_cmds_CXX in
+    *'~'*)
+      # FIXME: we may have to deal with multi-command sequences.
+      ;;
+    '$CC '*)
+      # Test whether the compiler implicitly links with -lc since on some
+      # systems, -lgcc has to come before -lc. If gcc already passes -lc
+      # to ld, don't add -lc before -lgcc.
+      { $as_echo "$as_me:${as_lineno-$LINENO}: checking whether -lc should be explicitly linked in" >&5
+$as_echo_n "checking whether -lc should be explicitly linked in... " >&6; }
+if ${lt_cv_archive_cmds_need_lc_CXX+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  $RM conftest*
+	echo "$lt_simple_compile_test_code" > conftest.$ac_ext
+
+	if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_compile\""; } >&5
+  (eval $ac_compile) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; } 2>conftest.err; then
+	  soname=conftest
+	  lib=conftest
+	  libobjs=conftest.$ac_objext
+	  deplibs=
+	  wl=$lt_prog_compiler_wl_CXX
+	  pic_flag=$lt_prog_compiler_pic_CXX
+	  compiler_flags=-v
+	  linker_flags=-v
+	  verstring=
+	  output_objdir=.
+	  libname=conftest
+	  lt_save_allow_undefined_flag=$allow_undefined_flag_CXX
+	  allow_undefined_flag_CXX=
+	  if { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1\""; } >&5
+  (eval $archive_cmds_CXX 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }
+	  then
+	    lt_cv_archive_cmds_need_lc_CXX=no
+	  else
+	    lt_cv_archive_cmds_need_lc_CXX=yes
+	  fi
+	  allow_undefined_flag_CXX=$lt_save_allow_undefined_flag
+	else
+	  cat conftest.err 1>&5
+	fi
+	$RM conftest*
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $lt_cv_archive_cmds_need_lc_CXX" >&5
+$as_echo "$lt_cv_archive_cmds_need_lc_CXX" >&6; }
+      archive_cmds_need_lc_CXX=$lt_cv_archive_cmds_need_lc_CXX
+      ;;
+    esac
+  fi
+  ;;
+esac
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking dynamic linker characteristics" >&5
+$as_echo_n "checking dynamic linker characteristics... " >&6; }
+
+library_names_spec=
+libname_spec='lib$name'
+soname_spec=
+shrext_cmds=.so
+postinstall_cmds=
+postuninstall_cmds=
+finish_cmds=
+finish_eval=
+shlibpath_var=
+shlibpath_overrides_runpath=unknown
+version_type=none
+dynamic_linker="$host_os ld.so"
+sys_lib_dlsearch_path_spec="/lib /usr/lib"
+need_lib_prefix=unknown
+hardcode_into_libs=no
+
+# when you set need_version to no, make sure it does not cause -set_version
+# flags to be left without arguments
+need_version=unknown
+
+
+
+case $host_os in
+aix3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname.a'
+  shlibpath_var=LIBPATH
+
+  # AIX 3 has no versioning support, so we append a major version to the name.
+  soname_spec='$libname$release$shared_ext$major'
+  ;;
+
+aix4-9*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  hardcode_into_libs=yes
+  if test ia64 = "$host_cpu"; then
+    # AIX 5 supports IA64
+    library_names_spec='$libname$release$shared_ext$major $libname$release$shared_ext$versuffix $libname$shared_ext'
+    shlibpath_var=LD_LIBRARY_PATH
+  else
+    # With GCC up to 2.95.x, collect2 would create an import file
+    # for dependence libraries.  The import file would start with
+    # the line '#! .'.  This would cause the generated library to
+    # depend on '.', always an invalid library.  This was fixed in
+    # development snapshots of GCC prior to 3.0.
+    case $host_os in
+      aix4 | aix4.01 | aix4.01.*)
+      if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
+	   echo ' yes '
+	   echo '#endif'; } | $CC -E - | $GREP yes > /dev/null; then
+	:
+      else
+	can_build_shared=no
+      fi
+      ;;
+    esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
+    # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
+    # soname into executable. Probably we can add versioning support to
+    # collect2, so additional links can be useful in future.
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
+      # If using run time linking (on AIX 4.2 or later) use lib<name>.so
+      # instead of lib<name>.a to let people know that these are not
+      # typical AIX shared libraries.
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
+      # We preserve .a as extension for shared libraries through AIX4.2
+      # and later when we are not doing run time linking.
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
+    shlibpath_var=LIBPATH
+  fi
+  ;;
+
+amigaos*)
+  case $host_cpu in
+  powerpc)
+    # Since July 2007 AmigaOS4 officially supports .so libraries.
+    # When compiling the executable, add -use-dynld -Lsobjs: to the compileline.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    ;;
+  m68k)
+    library_names_spec='$libname.ixlibrary $libname.a'
+    # Create ${libname}_ixlibrary.a entries in /sys/libs.
+    finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`func_echo_all "$lib" | $SED '\''s%^.*/$^/*$\.ixlibrary$%\1%'\''`; $RM /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
+    ;;
+  esac
+  ;;
+
+beos*)
+  library_names_spec='$libname$shared_ext'
+  dynamic_linker="$host_os ld.so"
+  shlibpath_var=LIBRARY_PATH
+  ;;
+
+bsdi45*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
+  # the default ld.so.conf also contains /usr/contrib/lib and
+  # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
+  # libtool to hard-code these into programs
+  ;;
+
+cygwin* | mingw* | pw32* | cegcc*)
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+
+  case $GCC,$cc_basename in
+  yes,*)
+    # gcc
+    library_names_spec='$libname.dll.a'
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname~
+      chmod a+x \$dldir/$dlname~
+      if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+        eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+      fi'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+
+    case $host_os in
+    cygwin*)
+      # Cygwin DLLs use 'cyg' prefix rather than 'lib'
+      soname_spec='`echo $libname | sed -e 's/^lib/cyg/'``echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+
+      ;;
+    mingw* | cegcc*)
+      # MinGW DLLs use traditional 'lib' prefix
+      soname_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+      ;;
+    pw32*)
+      # pw32 DLLs use 'pw' prefix rather than 'lib'
+      library_names_spec='`echo $libname | sed -e 's/^lib/pw/'``echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+      ;;
+    esac
+    dynamic_linker='Win32 ld.exe'
+    ;;
+
+  *,cl*)
+    # Native MSVC
+    libname_spec='$name'
+    soname_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext'
+    library_names_spec='$libname.dll.lib'
+
+    case $build_os in
+    mingw*)
+      sys_lib_search_path_spec=
+      lt_save_ifs=$IFS
+      IFS=';'
+      for lt_path in $LIB
+      do
+        IFS=$lt_save_ifs
+        # Let DOS variable expansion print the short 8.3 style file name.
+        lt_path=`cd "$lt_path" 2>/dev/null && cmd //C "for %i in (".") do @echo %~si"`
+        sys_lib_search_path_spec="$sys_lib_search_path_spec $lt_path"
+      done
+      IFS=$lt_save_ifs
+      # Convert to MSYS style.
+      sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | sed -e 's|\\\\|/|g' -e 's| \$a-zA-Z\$:| /\\1|g' -e 's|^ ||'`
+      ;;
+    cygwin*)
+      # Convert to unix form, then to dos form, then back to unix form
+      # but this time dos style (no spaces!) so that the unix form looks
+      # like /cygdrive/c/PROGRA~1:/cygdr...
+      sys_lib_search_path_spec=`cygpath --path --unix "$LIB"`
+      sys_lib_search_path_spec=`cygpath --path --dos "$sys_lib_search_path_spec" 2>/dev/null`
+      sys_lib_search_path_spec=`cygpath --path --unix "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      ;;
+    *)
+      sys_lib_search_path_spec=$LIB
+      if $ECHO "$sys_lib_search_path_spec" | $GREP ';c-zC-Z:/' >/dev/null; then
+        # It is most probably a Windows format PATH.
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
+      else
+        sys_lib_search_path_spec=`$ECHO "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
+      fi
+      # FIXME: find the short name or the path components, as spaces are
+      # common. (e.g. "Program Files" -> "PROGRA~1")
+      ;;
+    esac
+
+    # DLL is installed to $(libdir)/../bin by postinstall_cmds
+    postinstall_cmds='base_file=`basename \$file`~
+      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; echo \$dlname'\''`~
+      dldir=$destdir/`dirname \$dlpath`~
+      test -d \$dldir || mkdir -p \$dldir~
+      $install_prog $dir/$dlname \$dldir/$dlname'
+    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
+      dlpath=$dir/\$dldll~
+       $RM \$dlpath'
+    shlibpath_overrides_runpath=yes
+    dynamic_linker='Win32 link.exe'
+    ;;
+
+  *)
+    # Assume MSVC wrapper
+    library_names_spec='$libname`echo $release | $SED -e 's/./-/g'`$versuffix$shared_ext $libname.lib'
+    dynamic_linker='Win32 ld.exe'
+    ;;
+  esac
+  # FIXME: first we should search . and the directory the executable is in
+  shlibpath_var=PATH
+  ;;
+
+darwin* | rhapsody*)
+  dynamic_linker="$host_os dyld"
+  version_type=darwin
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$major$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$major$shared_ext'
+  shlibpath_overrides_runpath=yes
+  shlibpath_var=DYLD_LIBRARY_PATH
+  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
+
+  sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
+  ;;
+
+dgux*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+freebsd* | dragonfly*)
+  # DragonFly does not have aout.  When/if they implement a new
+  # versioning mechanism, adjust this.
+  if test -x /usr/bin/objformat; then
+    objformat=`/usr/bin/objformat`
+  else
+    case $host_os in
+    freebsd23.*) objformat=aout ;;
+    *) objformat=elf ;;
+    esac
+  fi
+  version_type=freebsd-$objformat
+  case $version_type in
+    freebsd-elf*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
+      need_version=no
+      need_lib_prefix=no
+      ;;
+    freebsd-*)
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+      need_version=yes
+      ;;
+  esac
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_os in
+  freebsd2.*)
+    shlibpath_overrides_runpath=yes
+    ;;
+  freebsd3.01* | freebsdelf3.01*)
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  freebsd3.2-9* | freebsdelf3.2-9* | \
+  freebsd4.0-5 | freebsdelf4.0-5 | freebsd4.1.1 | freebsdelf4.1.1)
+    shlibpath_overrides_runpath=no
+    hardcode_into_libs=yes
+    ;;
+  *) # from 4.6 on, and DragonFly
+    shlibpath_overrides_runpath=yes
+    hardcode_into_libs=yes
+    ;;
+  esac
+  ;;
+
+haiku*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  dynamic_linker="$host_os runtime_loader"
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_dlsearch_path_spec='/boot/home/config/lib /boot/common/lib /boot/system/lib'
+  hardcode_into_libs=yes
+  ;;
+
+hpux9* | hpux10* | hpux11*)
+  # Give a soname corresponding to the major version so that dld.sl refuses to
+  # link against other versions.
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  case $host_cpu in
+  ia64*)
+    shrext_cmds='.so'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.so"
+    shlibpath_var=LD_LIBRARY_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    if test 32 = "$HPUX_IA64_MODE"; then
+      sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
+    else
+      sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
+    fi
+    ;;
+  hppa*64*)
+    shrext_cmds='.sl'
+    hardcode_into_libs=yes
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
+    shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
+    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+    ;;
+  *)
+    shrext_cmds='.sl'
+    dynamic_linker="$host_os dld.sl"
+    shlibpath_var=SHLIB_PATH
+    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    ;;
+  esac
+  # HP-UX runs *really* slowly unless shared libraries are mode 555, ...
+  postinstall_cmds='chmod 555 $lib'
+  # or fails outright, so override atomically:
+  install_override_mode=555
+  ;;
+
+interix3-9*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+irix5* | irix6* | nonstopux*)
+  case $host_os in
+    nonstopux*) version_type=nonstopux ;;
+    *)
+	if test yes = "$lt_cv_prog_gnu_ld"; then
+		version_type=linux # correct to gnu/linux during the next big refactor
+	else
+		version_type=irix
+	fi ;;
+  esac
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$release$shared_ext $libname$shared_ext'
+  case $host_os in
+  irix5* | nonstopux*)
+    libsuff= shlibsuff=
+    ;;
+  *)
+    case $LD in # libtool.m4 will add one of these switches to LD
+    *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
+      libsuff= shlibsuff= libmagic=32-bit;;
+    *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
+      libsuff=32 shlibsuff=N32 libmagic=N32;;
+    *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
+      libsuff=64 shlibsuff=64 libmagic=64-bit;;
+    *) libsuff= shlibsuff= libmagic=never-match;;
+    esac
+    ;;
+  esac
+  shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
+  shlibpath_overrides_runpath=no
+  sys_lib_search_path_spec="/usr/lib$libsuff /lib$libsuff /usr/local/lib$libsuff"
+  sys_lib_dlsearch_path_spec="/usr/lib$libsuff /lib$libsuff"
+  hardcode_into_libs=yes
+  ;;
+
+# No shared lib support for Linux oldld, aout, or coff.
+linux*oldld* | linux*aout* | linux*coff*)
+  dynamic_linker=no
+  ;;
+
+linux*android*)
+  version_type=none # Android doesn't support versioned libraries.
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext'
+  soname_spec='$libname$release$shared_ext'
+  finish_cmds=
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  dynamic_linker='Android linker'
+  # Don't embed -rpath directories since the linker doesn't support them.
+  hardcode_libdir_flag_spec_CXX='-L$libdir'
+  ;;
+
+# This must be glibc/ELF.
+linux* | k*bsd*-gnu | kopensolaris*-gnu | gnu*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+
+  # Some binutils ld are patched to set DT_RUNPATH
+  if ${lt_cv_shlibpath_overrides_runpath+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  lt_cv_shlibpath_overrides_runpath=no
+    save_LDFLAGS=$LDFLAGS
+    save_libdir=$libdir
+    eval "libdir=/foo; wl=\"$lt_prog_compiler_wl_CXX\"; \
+	 LDFLAGS=\"\$LDFLAGS $hardcode_libdir_flag_spec_CXX\""
+    cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+  if  ($OBJDUMP -p conftest$ac_exeext) 2>/dev/null | grep "RUNPATH.*$libdir" >/dev/null; then :
+  lt_cv_shlibpath_overrides_runpath=yes
+fi
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+    LDFLAGS=$save_LDFLAGS
+    libdir=$save_libdir
+
+fi
+
+  shlibpath_overrides_runpath=$lt_cv_shlibpath_overrides_runpath
+
+  # This implies no fast_install, which is unacceptable.
+  # Some rework will be needed to allow for fast_install
+  # before this can be enabled.
+  hardcode_into_libs=yes
+
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
+  if test -f /etc/ld.so.conf; then
+    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^	 *hwcap	 /d;s/:,	/ /g;s/=^=*$//;s/=^= * / /g;s/"//g;/^$/d' | tr '\n' ' '`
+    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
+  fi
+
+  # We used to test for /lib/ld.so.1 and disable shared libraries on
+  # powerpc, because MkLinux only supported shared libraries with the
+  # GNU dynamic linker.  Since this was broken with cross compilers,
+  # most powerpc-linux boxes support dynamic linking these days and
+  # people can always --disable-shared, the test was removed, and we
+  # assume the GNU/Linux dynamic linker is in use.
+  dynamic_linker='GNU/Linux ld.so'
+  ;;
+
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
+netbsd*)
+  version_type=sunos
+  need_lib_prefix=no
+  need_version=no
+  if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+    dynamic_linker='NetBSD (a.out) ld.so'
+  else
+    library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+    soname_spec='$libname$release$shared_ext$major'
+    dynamic_linker='NetBSD ld.elf_so'
+  fi
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  ;;
+
+newsos6)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+*nto* | *qnx*)
+  version_type=qnx
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='ldqnx.so'
+  ;;
+
+openbsd* | bitrig*)
+  version_type=sunos
+  sys_lib_dlsearch_path_spec=/usr/lib
+  need_lib_prefix=no
+  if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`"; then
+    need_version=no
+  else
+    need_version=yes
+  fi
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  ;;
+
+os2*)
+  libname_spec='$name'
+  version_type=windows
+  shrext_cmds=.dll
+  need_version=no
+  need_lib_prefix=no
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
+  dynamic_linker='OS/2 ld.exe'
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
+  ;;
+
+osf3* | osf4* | osf5*)
+  version_type=osf
+  need_lib_prefix=no
+  need_version=no
+  soname_spec='$libname$release$shared_ext$major'
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  ;;
+
+rdos*)
+  dynamic_linker=no
+  ;;
+
+solaris*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  # ldd complains unless libraries are executable
+  postinstall_cmds='chmod +x $lib'
+  ;;
+
+sunos4*)
+  version_type=sunos
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$shared_ext$versuffix'
+  finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  if test yes = "$with_gnu_ld"; then
+    need_lib_prefix=no
+  fi
+  need_version=yes
+  ;;
+
+sysv4 | sysv4.3*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  case $host_vendor in
+    sni)
+      shlibpath_overrides_runpath=no
+      need_lib_prefix=no
+      runpath_var=LD_RUN_PATH
+      ;;
+    siemens)
+      need_lib_prefix=no
+      ;;
+    motorola)
+      need_lib_prefix=no
+      need_version=no
+      shlibpath_overrides_runpath=no
+      sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
+      ;;
+  esac
+  ;;
+
+sysv4*MP*)
+  if test -d /usr/nec; then
+    version_type=linux # correct to gnu/linux during the next big refactor
+    library_names_spec='$libname$shared_ext.$versuffix $libname$shared_ext.$major $libname$shared_ext'
+    soname_spec='$libname$shared_ext.$major'
+    shlibpath_var=LD_LIBRARY_PATH
+  fi
+  ;;
+
+sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
+  version_type=sco
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=yes
+  hardcode_into_libs=yes
+  if test yes = "$with_gnu_ld"; then
+    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
+  else
+    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
+    case $host_os in
+      sco3.2v5*)
+        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
+	;;
+    esac
+  fi
+  sys_lib_dlsearch_path_spec='/usr/lib'
+  ;;
+
+tpf*)
+  # TPF is a cross-target only.  Preferred cross-host = GNU/Linux.
+  version_type=linux # correct to gnu/linux during the next big refactor
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  ;;
+
+uts4*)
+  version_type=linux # correct to gnu/linux during the next big refactor
+  library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+  soname_spec='$libname$release$shared_ext$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  ;;
+
+*)
+  dynamic_linker=no
+  ;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $dynamic_linker" >&5
+$as_echo "$dynamic_linker" >&6; }
+test no = "$dynamic_linker" && can_build_shared=no
+
+variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
+if test yes = "$GCC"; then
+  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
+fi
+
+if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
+  sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
+fi
+
+if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
+  sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
+fi
+
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking how to hardcode library paths into programs" >&5
+$as_echo_n "checking how to hardcode library paths into programs... " >&6; }
+hardcode_action_CXX=
+if test -n "$hardcode_libdir_flag_spec_CXX" ||
+   test -n "$runpath_var_CXX" ||
+   test yes = "$hardcode_automatic_CXX"; then
+
+  # We can hardcode non-existent directories.
+  if test no != "$hardcode_direct_CXX" &&
+     # If the only mechanism to avoid hardcoding is shlibpath_var, we
+     # have to relink, otherwise we might link with an installed library
+     # when we should be linking with a yet-to-be-installed one
+     ## test no != "$_LT_TAGVAR(hardcode_shlibpath_var, CXX)" &&
+     test no != "$hardcode_minus_L_CXX"; then
+    # Linking always hardcodes the temporary library directory.
+    hardcode_action_CXX=relink
+  else
+    # We can link without hardcoding, and we can hardcode nonexisting dirs.
+    hardcode_action_CXX=immediate
+  fi
+else
+  # We cannot hardcode anything, or else we can only hardcode existing
+  # directories.
+  hardcode_action_CXX=unsupported
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $hardcode_action_CXX" >&5
+$as_echo "$hardcode_action_CXX" >&6; }
+
+if test relink = "$hardcode_action_CXX" ||
+   test yes = "$inherit_rpath_CXX"; then
+  # Fast installation is not supported
+  enable_fast_install=no
+elif test yes = "$shlibpath_overrides_runpath" ||
+     test no = "$enable_shared"; then
+  # Fast installation is not necessary
+  enable_fast_install=needless
+fi
+
+
+
+
+
+
+
+  fi # test -n "$compiler"
+
+  CC=$lt_save_CC
+  CFLAGS=$lt_save_CFLAGS
+  LDCXX=$LD
+  LD=$lt_save_LD
+  GCC=$lt_save_GCC
+  with_gnu_ld=$lt_save_with_gnu_ld
+  lt_cv_path_LDCXX=$lt_cv_path_LD
+  lt_cv_path_LD=$lt_save_path_LD
+  lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
+  lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
+fi # test yes != "$_lt_caught_CXX_error"
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        ac_config_commands="$ac_config_commands libtool"
+
+
+
+
+# Only expand once:
+
+
+
+
+
+
+
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for grep that handles long lines and -e" >&5
+$as_echo_n "checking for grep that handles long lines and -e... " >&6; }
+if ${ac_cv_path_GREP+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -z "$GREP"; then
+  ac_path_GREP_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH$PATH_SEPARATOR/usr/xpg4/bin
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in grep ggrep; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_GREP="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_GREP" || continue
+# Check for GNU ac_path_GREP and select it if it is found.
+  # Check for GNU $ac_path_GREP
+case `"$ac_path_GREP" --version 2>&1` in
+*GNU*)
+  ac_cv_path_GREP="$ac_path_GREP" ac_path_GREP_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo 'GREP' >> "conftest.nl"
+    "$ac_path_GREP" -e 'GREP$' -e '-(cannot match)-' < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_GREP_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_GREP="$ac_path_GREP"
+      ac_path_GREP_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_GREP_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_GREP"; then
+    as_fn_error $? "no acceptable grep could be found in $PATH$PATH_SEPARATOR/usr/xpg4/bin" "$LINENO" 5
+  fi
+else
+  ac_cv_path_GREP=$GREP
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_GREP" >&5
+$as_echo "$ac_cv_path_GREP" >&6; }
+ GREP="$ac_cv_path_GREP"
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for a sed that does not truncate output" >&5
+$as_echo_n "checking for a sed that does not truncate output... " >&6; }
+if ${ac_cv_path_SED+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+            ac_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+     for ac_i in 1 2 3 4 5 6 7; do
+       ac_script="$ac_script$as_nl$ac_script"
+     done
+     echo "$ac_script" 2>/dev/null | sed 99q >conftest.sed
+     { ac_script=; unset ac_script;}
+     if test -z "$SED"; then
+  ac_path_SED_found=false
+  # Loop through the user's path and test for each of PROGNAME-LIST
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_prog in sed gsed; do
+    for ac_exec_ext in '' $ac_executable_extensions; do
+      ac_path_SED="$as_dir/$ac_prog$ac_exec_ext"
+      as_fn_executable_p "$ac_path_SED" || continue
+# Check for GNU ac_path_SED and select it if it is found.
+  # Check for GNU $ac_path_SED
+case `"$ac_path_SED" --version 2>&1` in
+*GNU*)
+  ac_cv_path_SED="$ac_path_SED" ac_path_SED_found=:;;
+*)
+  ac_count=0
+  $as_echo_n 0123456789 >"conftest.in"
+  while :
+  do
+    cat "conftest.in" "conftest.in" >"conftest.tmp"
+    mv "conftest.tmp" "conftest.in"
+    cp "conftest.in" "conftest.nl"
+    $as_echo '' >> "conftest.nl"
+    "$ac_path_SED" -f conftest.sed < "conftest.nl" >"conftest.out" 2>/dev/null || break
+    diff "conftest.out" "conftest.nl" >/dev/null 2>&1 || break
+    as_fn_arith $ac_count + 1 && ac_count=$as_val
+    if test $ac_count -gt ${ac_path_SED_max-0}; then
+      # Best one so far, save it but keep looking for a better one
+      ac_cv_path_SED="$ac_path_SED"
+      ac_path_SED_max=$ac_count
+    fi
+    # 10*(2^10) chars as input seems more than enough
+    test $ac_count -gt 10 && break
+  done
+  rm -f conftest.in conftest.tmp conftest.nl conftest.out;;
+esac
+
+      $ac_path_SED_found && break 3
+    done
+  done
+  done
+IFS=$as_save_IFS
+  if test -z "$ac_cv_path_SED"; then
+    as_fn_error $? "no acceptable sed could be found in \$PATH" "$LINENO" 5
+  fi
+else
+  ac_cv_path_SED=$SED
+fi
+
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_path_SED" >&5
+$as_echo "$ac_cv_path_SED" >&6; }
+ SED="$ac_cv_path_SED"
+  rm -f conftest.sed
+
+if test "x$with_clang_prefix" != "x"; then
+	LLVM_CONFIG="$with_clang_prefix/bin/llvm-config"
+fi
+# Extract the first word of ""llvm-config"", so it can be a program name with args.
+set dummy "llvm-config"; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_path_LLVM_CONFIG+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  case $LLVM_CONFIG in
+  \\/* | ?:\\/*)
+  ac_cv_path_LLVM_CONFIG="$LLVM_CONFIG" # Let the user override the test with a path.
+  ;;
+  *)
+  as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_path_LLVM_CONFIG="$as_dir/$ac_word$ac_exec_ext"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+  ;;
+esac
+fi
+LLVM_CONFIG=$ac_cv_path_LLVM_CONFIG
+if test -n "$LLVM_CONFIG"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $LLVM_CONFIG" >&5
+$as_echo "$LLVM_CONFIG" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+if test -z "$LLVM_CONFIG" || test ! -x "$LLVM_CONFIG"; then
+	as_fn_error $? "llvm-config not found" "$LINENO" 5
+fi
+CLANG_CXXFLAGS=`$LLVM_CONFIG --cxxflags | \
+	$SED -e 's/-Wcovered-switch-default//;s/-gsplit-dwarf//'`
+CLANG_LDFLAGS=`$LLVM_CONFIG --ldflags`
+# Construct a -R argument for libtool.
+# This is needed in case some of the clang libraries are shared libraries.
+CLANG_RFLAG=`echo "$CLANG_LDFLAGS" | $SED -e 's/-L/-R/g'`
+targets=`$LLVM_CONFIG --targets-built`
+components="$targets asmparser bitreader support mc"
+# Link in option and frontendopenmp components when available
+# since they may be used by the clang libraries.
+for c in option frontendopenmp; do
+	$LLVM_CONFIG --components | $GREP $c > /dev/null 2> /dev/null
+	if test $? -eq 0; then
+		components="$components $c"
+	fi
+done
+CLANG_LIBS=`$LLVM_CONFIG --libs $components`
+systemlibs=`$LLVM_CONFIG --system-libs 2> /dev/null | tail -1`
+if test $? -eq 0; then
+	CLANG_LIBS="$CLANG_LIBS $systemlibs"
+fi
+CLANG_PREFIX=`$LLVM_CONFIG --prefix`
+
+cat >>confdefs.h <<_ACEOF
+#define CLANG_PREFIX "$CLANG_PREFIX"
+_ACEOF
+
+
+# If $CLANG_PREFIX/bin/clang cannot find the standard include files,
+# then see if setting sysroot to `xcode-select -p`/SDKs/MacOSX.sdk helps.
+# This may be required on some versions of OS X since they lack /usr/include.
+# If so, set CLANG_SYSROOT accordingly.
+SAVE_CC="$CC"
+CC="$CLANG_PREFIX/bin/clang"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether $CLANG_PREFIX/bin/clang can find standard include files" >&5
+$as_echo_n "checking whether $CLANG_PREFIX/bin/clang can find standard include files... " >&6; }
+found_header=no
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  found_header=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $found_header" >&5
+$as_echo "$found_header" >&6; }
+if test "x$found_header" != "xyes"; then
+	# Extract the first word of "xcode-select", so it can be a program name with args.
+set dummy xcode-select; ac_word=$2
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $ac_word" >&5
+$as_echo_n "checking for $ac_word... " >&6; }
+if ${ac_cv_prog_XCODE_SELECT+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  if test -n "$XCODE_SELECT"; then
+  ac_cv_prog_XCODE_SELECT="$XCODE_SELECT" # Let the user override the test.
+else
+as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    for ac_exec_ext in '' $ac_executable_extensions; do
+  if as_fn_executable_p "$as_dir/$ac_word$ac_exec_ext"; then
+    ac_cv_prog_XCODE_SELECT="xcode-select"
+    $as_echo "$as_me:${as_lineno-$LINENO}: found $as_dir/$ac_word$ac_exec_ext" >&5
+    break 2
+  fi
+done
+  done
+IFS=$as_save_IFS
+
+fi
+fi
+XCODE_SELECT=$ac_cv_prog_XCODE_SELECT
+if test -n "$XCODE_SELECT"; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: $XCODE_SELECT" >&5
+$as_echo "$XCODE_SELECT" >&6; }
+else
+  { $as_echo "$as_me:${as_lineno-$LINENO}: result: no" >&5
+$as_echo "no" >&6; }
+fi
+
+
+	if test -z "$XCODE_SELECT"; then
+		as_fn_error $? "Cannot find xcode-select" "$LINENO" 5
+	fi
+	sysroot=`$XCODE_SELECT -p`/SDKs/MacOSX.sdk
+	SAVE_CPPFLAGS="$CPPFLAGS"
+	CPPFLAGS="$CPPFLAGS -isysroot $sysroot"
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking whether standard include files can be found with sysroot set" >&5
+$as_echo_n "checking whether standard include files can be found with sysroot set... " >&6; }
+	found_header=no
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdio.h>
+int
+main ()
+{
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_c_try_compile "$LINENO"; then :
+  found_header=yes
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $found_header" >&5
+$as_echo "$found_header" >&6; }
+	CPPFLAGS="$SAVE_CPPFLAGS"
+	if test "x$found_header" != "xyes"; then
+		as_fn_error $? "Cannot find standard include files" "$LINENO" 5
+	else
+
+cat >>confdefs.h <<_ACEOF
+#define CLANG_SYSROOT "$sysroot"
+_ACEOF
+
+	fi
+fi
+CC="$SAVE_CC"
+
+ac_ext=cpp
+ac_cpp='$CXXCPP $CPPFLAGS'
+ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
+
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$CLANG_CXXFLAGS -I$srcdir $CPPFLAGS"
+ac_fn_cxx_check_header_mongrel "$LINENO" "clang/Basic/SourceLocation.h" "ac_cv_header_clang_Basic_SourceLocation_h" "$ac_includes_default"
+if test "x$ac_cv_header_clang_Basic_SourceLocation_h" = xyes; then :
+
+else
+  as_fn_error $? "clang header file not found" "$LINENO" 5
+fi
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <llvm/Support/Host.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getDefaultTargetTriple" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define getDefaultTargetTriple getHostTriple" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/SourceLocation.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getExpansionLineNumber" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define getExpansionLineNumber getInstantiationLineNumber" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/SourceManager.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getImmediateExpansionRange" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define getImmediateExpansionRange getImmediateInstantiationRange" >>confdefs.h
+
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/Diagnostic.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "DiagnosticsEngine" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define DiagnosticsEngine Diagnostic" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Driver/Driver.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "ArrayRef" >/dev/null 2>&1; then :
+
+$as_echo "#define USE_ARRAYREF /**/" >>confdefs.h
+
+	cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Frontend/CompilerInvocation.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "ArrayRef.*CommandLineArgs" >/dev/null 2>&1; then :
+
+$as_echo "#define CREATE_FROM_ARGS_TAKES_ARRAYREF /**/" >>confdefs.h
+
+
+fi
+rm -f conftest*
+
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Driver/Driver.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "CXXIsProduction" >/dev/null 2>&1; then :
+
+$as_echo "#define HAVE_CXXISPRODUCTION /**/" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Driver/Driver.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP " IsProduction" >/dev/null 2>&1; then :
+
+$as_echo "#define HAVE_ISPRODUCTION /**/" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Driver/Driver.h>
+int
+main ()
+{
+
+	using namespace clang;
+	DiagnosticsEngine *Diags;
+	new driver::Driver("", "", "", *Diags);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define DRIVER_CTOR_TAKES_DEFAULTIMAGENAME /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/AST/ASTConsumer.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "void HandleTopLevelDecl\(" >/dev/null 2>&1; then :
+
+$as_echo "#define HandleTopLevelDeclReturn void" >>confdefs.h
+
+
+$as_echo "#define HandleTopLevelDeclContinue /**/" >>confdefs.h
+
+else
+
+$as_echo "#define HandleTopLevelDeclReturn bool" >>confdefs.h
+
+
+$as_echo "#define HandleTopLevelDeclContinue true" >>confdefs.h
+
+fi
+rm -f conftest*
+
+ac_fn_cxx_check_header_mongrel "$LINENO" "clang/Basic/DiagnosticOptions.h" "ac_cv_header_clang_Basic_DiagnosticOptions_h" "$ac_includes_default"
+if test "x$ac_cv_header_clang_Basic_DiagnosticOptions_h" = xyes; then :
+
+$as_echo "#define HAVE_BASIC_DIAGNOSTICOPTIONS_H /**/" >>confdefs.h
+
+fi
+
+
+ac_fn_cxx_check_header_compile "$LINENO" "clang/Lex/PreprocessorOptions.h" "ac_cv_header_clang_Lex_PreprocessorOptions_h" "#include <clang/Basic/LLVM.h>
+"
+if test "x$ac_cv_header_clang_Lex_PreprocessorOptions_h" = xyes; then :
+
+$as_echo "#define HAVE_LEX_PREPROCESSOROPTIONS_H /**/" >>confdefs.h
+
+fi
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/TargetInfo.h>
+int
+main ()
+{
+
+	using namespace clang;
+	std::shared_ptr<TargetOptions> TO;
+	DiagnosticsEngine *Diags;
+	TargetInfo::CreateTargetInfo(*Diags, TO);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define CREATETARGETINFO_TAKES_SHARED_PTR /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/TargetInfo.h>
+int
+main ()
+{
+
+	using namespace clang;
+	TargetOptions *TO;
+	DiagnosticsEngine *Diags;
+	TargetInfo::CreateTargetInfo(*Diags, TO);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define CREATETARGETINFO_TAKES_POINTER /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Frontend/CompilerInstance.h>
+int
+main ()
+{
+
+	using namespace clang;
+	DiagnosticConsumer *client;
+	CompilerInstance *Clang;
+	Clang->createDiagnostics(client);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+else
+
+$as_echo "#define CREATEDIAGNOSTICS_TAKES_ARG /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Lex/HeaderSearchOptions.h>
+int
+main ()
+{
+
+	using namespace clang;
+	HeaderSearchOptions HSO;
+	HSO.AddPath("", frontend::Angled, false, false);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define ADDPATH_TAKES_4_ARGUMENTS /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/AST/CanonicalType.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getNumParams" >/dev/null 2>&1; then :
+
+$as_echo "#define getNumArgs getNumParams" >>confdefs.h
+
+
+$as_echo "#define getArgType getParamType" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/AST/CanonicalType.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "getReturnType" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define getReturnType getResultType" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Frontend/CompilerInstance.h>
+int
+main ()
+{
+
+	using namespace clang;
+	CompilerInstance *Clang;
+	Clang->createPreprocessor(TU_Complete);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define CREATEPREPROCESSOR_TAKES_TUKIND /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/SourceManager.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "setMainFileID" >/dev/null 2>&1; then :
+
+$as_echo "#define HAVE_SETMAINFILEID /**/" >>confdefs.h
+
+fi
+rm -f conftest*
+
+ac_fn_cxx_check_header_mongrel "$LINENO" "llvm/ADT/OwningPtr.h" "ac_cv_header_llvm_ADT_OwningPtr_h" "$ac_includes_default"
+if test "x$ac_cv_header_llvm_ADT_OwningPtr_h" = xyes; then :
+
+$as_echo "#define HAVE_ADT_OWNINGPTR_H /**/" >>confdefs.h
+
+fi
+
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Basic/Builtins.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "initializeBuiltins" >/dev/null 2>&1; then :
+
+else
+
+$as_echo "#define initializeBuiltins InitializeBuiltins" >>confdefs.h
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <clang/Frontend/FrontendOptions.h>
+
+_ACEOF
+if (eval "$ac_cpp conftest.$ac_ext") 2>&5 |
+  $EGREP "IK_C" >/dev/null 2>&1; then :
+
+else
+  ac_fn_cxx_check_header_mongrel "$LINENO" "clang/Basic/LangStandard.h" "ac_cv_header_clang_Basic_LangStandard_h" "$ac_includes_default"
+if test "x$ac_cv_header_clang_Basic_LangStandard_h" = xyes; then :
+  IK_C=Language::C
+else
+  IK_C=InputKind::C
+fi
+
+
+
+cat >>confdefs.h <<_ACEOF
+#define IK_C $IK_C
+_ACEOF
+
+
+fi
+rm -f conftest*
+
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <clang/Basic/TargetOptions.h>
+	#include <clang/Lex/PreprocessorOptions.h>
+	#include <clang/Frontend/CompilerInstance.h>
+
+	#include "set_lang_defaults_arg4.h"
+
+int
+main ()
+{
+
+	using namespace clang;
+	CompilerInstance *Clang;
+	TargetOptions TO;
+	llvm::Triple T(TO.Triple);
+	PreprocessorOptions PO;
+	CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
+			T, setLangDefaultsArg4(PO),
+			LangStandard::lang_unspecified);
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define SETLANGDEFAULTS_TAKES_5_ARGUMENTS /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+	#include <clang/Frontend/CompilerInstance.h>
+	#include <clang/Frontend/CompilerInvocation.h>
+
+int
+main ()
+{
+
+	using namespace clang;
+	CompilerInvocation *invocation;
+	CompilerInstance *Clang;
+	Clang->setInvocation(std::make_shared<CompilerInvocation>(*invocation));
+
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_compile "$LINENO"; then :
+
+$as_echo "#define SETINVOCATION_TAKES_SHARED_PTR /**/" >>confdefs.h
+
+fi
+rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext
+ac_fn_cxx_check_header_mongrel "$LINENO" "llvm/Option/Arg.h" "ac_cv_header_llvm_Option_Arg_h" "$ac_includes_default"
+if test "x$ac_cv_header_llvm_Option_Arg_h" = xyes; then :
+
+$as_echo "#define HAVE_LLVM_OPTION_ARG_H /**/" >>confdefs.h
+
+fi
+
+
+CPPFLAGS="$SAVE_CPPFLAGS"
+
+SAVE_LDFLAGS="$LDFLAGS"
+LDFLAGS="$CLANG_LDFLAGS $LDFLAGS"
+
+# Use single libclang-cpp shared library when available.
+# Otherwise, use a selection of clang libraries that appears to work.
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lclang-cpp" >&5
+$as_echo_n "checking for main in -lclang-cpp... " >&6; }
+if ${ac_cv_lib_clang_cpp_main+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lclang-cpp  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+int
+main ()
+{
+return main ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+  ac_cv_lib_clang_cpp_main=yes
+else
+  ac_cv_lib_clang_cpp_main=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_clang_cpp_main" >&5
+$as_echo "$ac_cv_lib_clang_cpp_main" >&6; }
+if test "x$ac_cv_lib_clang_cpp_main" = xyes; then :
+  have_lib_clang=yes
+else
+  have_lib_clang=no
+fi
+
+if test "$have_lib_clang" = yes; then
+	CLANG_LIBS="-lclang-cpp $CLANG_LIBS"
+else
+	CLANG_LIBS="-lclangBasic -lclangDriver $CLANG_LIBS"
+	CLANG_LIBS="-lclangAnalysis -lclangAST -lclangLex $CLANG_LIBS"
+	LDFLAGS="$CLANG_LDFLAGS $CLANG_LIBS $SAVE_LDFLAGS"
+	{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for main in -lclangEdit" >&5
+$as_echo_n "checking for main in -lclangEdit... " >&6; }
+if ${ac_cv_lib_clangEdit_main+:} false; then :
+  $as_echo_n "(cached) " >&6
+else
+  ac_check_lib_save_LIBS=$LIBS
+LIBS="-lclangEdit  $LIBS"
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+
+
+int
+main ()
+{
+return main ();
+  ;
+  return 0;
+}
+_ACEOF
+if ac_fn_cxx_try_link "$LINENO"; then :
+  ac_cv_lib_clangEdit_main=yes
+else
+  ac_cv_lib_clangEdit_main=no
+fi
+rm -f core conftest.err conftest.$ac_objext \
+    conftest$ac_exeext conftest.$ac_ext
+LIBS=$ac_check_lib_save_LIBS
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_lib_clangEdit_main" >&5
+$as_echo "$ac_cv_lib_clangEdit_main" >&6; }
+if test "x$ac_cv_lib_clangEdit_main" = xyes; then :
+  LIB_CLANG_EDIT=-lclangEdit
+fi
+
+	CLANG_LIBS="$LIB_CLANG_EDIT $CLANG_LIBS"
+	CLANG_LIBS="-lclangParse -lclangSema $CLANG_LIBS"
+	CLANG_LIBS="-lclangFrontend -lclangSerialization $CLANG_LIBS"
+fi
+
+LDFLAGS="$SAVE_LDFLAGS"
+
+ac_ext=c
+ac_cpp='$CPP $CPPFLAGS'
+ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
+ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
+ac_compiler_gnu=$ac_cv_c_compiler_gnu
+
+
+
+CONFIG_STATUS_DEPENDENCIES=$LLVM_CONFIG
+
+ac_config_headers="$ac_config_headers isl_config.h"
+
+ac_config_files="$ac_config_files Makefile"
+
+
+cat >confcache <<\_ACEOF
+# This file is a shell script that caches the results of configure
+# tests run on this system so they can be shared between configure
+# scripts and configure runs, see configure's option --config-cache.
+# It is not useful on other systems.  If it contains results you don't
+# want to keep, you may remove or edit it.
+#
+# config.status only pays attention to the cache file if you give it
+# the --recheck option to rerun configure.
+#
+# `ac_cv_env_foo' variables (set or unset) will be overridden when
+# loading this file, other *unset* `ac_cv_foo' will be assigned the
+# following values.
+
+_ACEOF
+
+# The following way of writing the cache mishandles newlines in values,
+# but we know of no workaround that is simple, portable, and efficient.
+# So, we kill variables containing newlines.
+# Ultrix sh set writes to stderr and can't be redirected directly,
+# and sets the high bit in the cache file unless we assign to the vars.
+(
+  for ac_var in `(set) 2>&1 | sed -n 's/^$a-zA-Z_a-zA-Z0-9_*$=.*/\1/p'`; do
+    eval ac_val=\$$ac_var
+    case $ac_val in #(
+    *${as_nl}*)
+      case $ac_var in #(
+      *_cv_*) { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: cache variable $ac_var contains a newline" >&5
+$as_echo "$as_me: WARNING: cache variable $ac_var contains a newline" >&2;} ;;
+      esac
+      case $ac_var in #(
+      _ | IFS | as_nl) ;; #(
+      BASH_ARGV | BASH_SOURCE) eval $ac_var= ;; #(
+      *) { eval $ac_var=; unset $ac_var;} ;;
+      esac ;;
+    esac
+  done
+
+  (set) 2>&1 |
+    case $as_nl`(ac_space=' '; set) 2>&1` in #(
+    *${as_nl}ac_space=\ *)
+      # `set' does not quote correctly, so add quotes: double-quote
+      # substitution turns \\\\ into \\, and sed turns \\ into \.
+      sed -n \
+	"s/'/'\\\\''/g;
+	  s/^\$_$as_cr_alnum*_cv__$as_cr_alnum*\$=\$.*\$/\\1='\\2'/p"
+      ;; #(
+    *)
+      # `set' quotes correctly as required by POSIX, so do not add quotes.
+      sed -n "/^_$as_cr_alnum*_cv__$as_cr_alnum*=/p"
+      ;;
+    esac |
+    sort
+) |
+  sed '
+     /^ac_cv_env_/b end
+     t clear
+     :clear
+     s/^$^=*$=$.*{}.*$$/test "${\1+set}" = set || &/
+     t end
+     s/^$^=*$=$.*$$/\1=${\1=\2}/
+     :end' >>confcache
+if diff "$cache_file" confcache >/dev/null 2>&1; then :; else
+  if test -w "$cache_file"; then
+    if test "x$cache_file" != "x/dev/null"; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: updating cache $cache_file" >&5
+$as_echo "$as_me: updating cache $cache_file" >&6;}
+      if test ! -f "$cache_file" || test -h "$cache_file"; then
+	cat confcache >"$cache_file"
+      else
+        case $cache_file in #(
+        */* | ?:*)
+	  mv -f confcache "$cache_file"$$ &&
+	  mv -f "$cache_file"$$ "$cache_file" ;; #(
+        *)
+	  mv -f confcache "$cache_file" ;;
+	esac
+      fi
+    fi
+  else
+    { $as_echo "$as_me:${as_lineno-$LINENO}: not updating unwritable cache $cache_file" >&5
+$as_echo "$as_me: not updating unwritable cache $cache_file" >&6;}
+  fi
+fi
+rm -f confcache
+
+test "x$prefix" = xNONE && prefix=$ac_default_prefix
+# Let make expand exec_prefix.
+test "x$exec_prefix" = xNONE && exec_prefix='${prefix}'
+
+DEFS=-DHAVE_CONFIG_H
+
+ac_libobjs=
+ac_ltlibobjs=
+U=
+for ac_i in : $LIBOBJS; do test "x$ac_i" = x: && continue
+  # 1. Remove the extension, and $U if already installed.
+  ac_script='s/\$U\././;s/\.o$//;s/\.obj$//'
+  ac_i=`$as_echo "$ac_i" | sed "$ac_script"`
+  # 2. Prepend LIBOBJDIR.  When used with automake>=1.10 LIBOBJDIR
+  #    will be set to the directory where LIBOBJS objects are built.
+  as_fn_append ac_libobjs " \${LIBOBJDIR}$ac_i\$U.$ac_objext"
+  as_fn_append ac_ltlibobjs " \${LIBOBJDIR}$ac_i"'$U.lo'
+done
+LIBOBJS=$ac_libobjs
+
+LTLIBOBJS=$ac_ltlibobjs
+
+
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking that generated files are newer than configure" >&5
+$as_echo_n "checking that generated files are newer than configure... " >&6; }
+   if test -n "$am_sleep_pid"; then
+     # Hide warnings about reused PIDs.
+     wait $am_sleep_pid 2>/dev/null
+   fi
+   { $as_echo "$as_me:${as_lineno-$LINENO}: result: done" >&5
+$as_echo "done" >&6; }
+ if test -n "$EXEEXT"; then
+  am__EXEEXT_TRUE=
+  am__EXEEXT_FALSE='#'
+else
+  am__EXEEXT_TRUE='#'
+  am__EXEEXT_FALSE=
+fi
+
+if test -z "${AMDEP_TRUE}" && test -z "${AMDEP_FALSE}"; then
+  as_fn_error $? "conditional \"AMDEP\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCC_TRUE}" && test -z "${am__fastdepCC_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCC\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+if test -z "${am__fastdepCXX_TRUE}" && test -z "${am__fastdepCXX_FALSE}"; then
+  as_fn_error $? "conditional \"am__fastdepCXX\" was never defined.
+Usually this means the macro was only invoked conditionally." "$LINENO" 5
+fi
+
+: "${CONFIG_STATUS=./config.status}"
+ac_write_fail=0
+ac_clean_files_save=$ac_clean_files
+ac_clean_files="$ac_clean_files $CONFIG_STATUS"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: creating $CONFIG_STATUS" >&5
+$as_echo "$as_me: creating $CONFIG_STATUS" >&6;}
+as_write_fail=0
+cat >$CONFIG_STATUS <<_ASEOF || as_write_fail=1
+#! $SHELL
+# Generated by $as_me.
+# Run this file to recreate the current configuration.
+# Compiler output produced by configure, useful for debugging
+# configure, is in config.log if it exists.
+
+debug=false
+ac_cs_recheck=false
+ac_cs_silent=false
+
+SHELL=\${CONFIG_SHELL-$SHELL}
+export SHELL
+_ASEOF
+cat >>$CONFIG_STATUS <<\_ASEOF || as_write_fail=1
+## -------------------- ##
+## M4sh Initialization. ##
+## -------------------- ##
+
+# Be more Bourne compatible
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in #(
+  *posix*) :
+    set -o posix ;; #(
+  *) :
+     ;;
+esac
+fi
+
+
+as_nl='
+'
+export as_nl
+# Printing a long string crashes Solaris 7 /usr/bin/printf.
+as_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo
+as_echo=$as_echo$as_echo$as_echo$as_echo$as_echo$as_echo
+# Prefer a ksh shell builtin over an external printf program on Solaris,
+# but without wasting forks for bash or zsh.
+if test -z "$BASH_VERSION$ZSH_VERSION" \
+    && (test "X`print -r -- $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='print -r --'
+  as_echo_n='print -rn --'
+elif (test "X`printf %s $as_echo`" = "X$as_echo") 2>/dev/null; then
+  as_echo='printf %s\n'
+  as_echo_n='printf %s'
+else
+  if test "X`(/usr/ucb/echo -n -n $as_echo) 2>/dev/null`" = "X-n $as_echo"; then
+    as_echo_body='eval /usr/ucb/echo -n "$1$as_nl"'
+    as_echo_n='/usr/ucb/echo -n'
+  else
+    as_echo_body='eval expr "X$1" : "X\$.*\$"'
+    as_echo_n_body='eval
+      arg=$1;
+      case $arg in #(
+      *"$as_nl"*)
+	expr "X$arg" : "X\$.*\$$as_nl";
+	arg=`expr "X$arg" : ".*$as_nl\$.*\$"`;;
+      esac;
+      expr "X$arg" : "X\$.*\$" | tr -d "$as_nl"
+    '
+    export as_echo_n_body
+    as_echo_n='sh -c $as_echo_n_body as_echo'
+  fi
+  export as_echo_body
+  as_echo='sh -c $as_echo_body as_echo'
+fi
+
+# The user is always right.
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+# IFS
+# We need space, tab and new line, in precisely that order.  Quoting is
+# there to prevent editors from complaining about space-tab.
+# (If _AS_PATH_WALK were called with IFS unset, it would disable word
+# splitting by setting IFS to empty value.)
+IFS=" ""	$as_nl"
+
+# Find who we are.  Look in the path if we contain no directory separator.
+as_myself=
+case $0 in #((
+  *\\/* ) as_myself=$0 ;;
+  *) as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
+for as_dir in $PATH
+do
+  IFS=$as_save_IFS
+  test -z "$as_dir" && as_dir=.
+    test -r "$as_dir/$0" && as_myself=$as_dir/$0 && break
+  done
+IFS=$as_save_IFS
+
+     ;;
+esac
+# We did not find ourselves, most probably we were run as `sh COMMAND'
+# in which case we are not to be found in the path.
+if test "x$as_myself" = x; then
+  as_myself=$0
+fi
+if test ! -f "$as_myself"; then
+  $as_echo "$as_myself: error: cannot find myself; rerun with an absolute file name" >&2
+  exit 1
+fi
+
+# Unset variables that we do not need and which cause bugs (e.g. in
+# pre-3.0 UWIN ksh).  But do not cause bugs in bash 2.01; the "|| exit 1"
+# suppresses any "Segmentation fault" message there.  '((' could
+# trigger a bug in pdksh 5.2.14.
+for as_var in BASH_ENV ENV MAIL MAILPATH
+do eval test x\${$as_var+set} = xset \
+  && ( (unset $as_var) || exit 1) >/dev/null 2>&1 && unset $as_var || :
+done
+PS1='$ '
+PS2='> '
+PS4='+ '
+
+# NLS nuisances.
+LC_ALL=C
+export LC_ALL
+LANGUAGE=C
+export LANGUAGE
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+
+# as_fn_error STATUS ERROR LINENO LOG_FD
+# ----------------------------------------
+# Output "`basename $0`: error: ERROR" to stderr. If LINENO and LOG_FD are
+# provided, also output the error to LOG_FD, referencing LINENO. Then exit the
+# script with STATUS, using 1 if that was 0.
+as_fn_error ()
+{
+  as_status=$1; test $as_status -eq 0 && as_status=1
+  if test "$4"; then
+    as_lineno=${as_lineno-"$3"} as_lineno_stack=as_lineno_stack=$as_lineno_stack
+    $as_echo "$as_me:${as_lineno-$LINENO}: error: $2" >&$4
+  fi
+  $as_echo "$as_me: error: $2" >&2
+  as_fn_exit $as_status
+} # as_fn_error
+
+
+# as_fn_set_status STATUS
+# -----------------------
+# Set $? to STATUS, without forking.
+as_fn_set_status ()
+{
+  return $1
+} # as_fn_set_status
+
+# as_fn_exit STATUS
+# -----------------
+# Exit the shell with STATUS, even in a "trap 0" or "set -e" context.
+as_fn_exit ()
+{
+  set +e
+  as_fn_set_status $1
+  exit $1
+} # as_fn_exit
+
+# as_fn_unset VAR
+# ---------------
+# Portably unset VAR.
+as_fn_unset ()
+{
+  { eval $1=; unset $1;}
+}
+as_unset=as_fn_unset
+# as_fn_append VAR VALUE
+# ----------------------
+# Append the text in VALUE to the end of the definition contained in VAR. Take
+# advantage of any shell optimizations that allow amortized linear growth over
+# repeated appends, instead of the typical quadratic growth present in naive
+# implementations.
+if (eval "as_var=1; as_var+=2; test x\$as_var = x12") 2>/dev/null; then :
+  eval 'as_fn_append ()
+  {
+    eval $1+=\$2
+  }'
+else
+  as_fn_append ()
+  {
+    eval $1=\$$1\$2
+  }
+fi # as_fn_append
+
+# as_fn_arith ARG...
+# ------------------
+# Perform arithmetic evaluation on the ARGs, and store the result in the
+# global $as_val. Take advantage of shells that can avoid forks. The arguments
+# must be portable across $(()) and expr.
+if (eval "test \$(( 1 + 1 )) = 2") 2>/dev/null; then :
+  eval 'as_fn_arith ()
+  {
+    as_val=$(( $* ))
+  }'
+else
+  as_fn_arith ()
+  {
+    as_val=`expr "$@" || test $? -eq 1`
+  }
+fi # as_fn_arith
+
+
+if expr a : '$a$' >/dev/null 2>&1 &&
+   test "X`expr 00001 : '.*$...$'`" = X001; then
+  as_expr=expr
+else
+  as_expr=false
+fi
+
+if (basename -- /) >/dev/null 2>&1 && test "X`basename -- / 2>&1`" = "X/"; then
+  as_basename=basename
+else
+  as_basename=false
+fi
+
+if (as_dir=`dirname -- /` && test "X$as_dir" = X/) >/dev/null 2>&1; then
+  as_dirname=dirname
+else
+  as_dirname=false
+fi
+
+as_me=`$as_basename -- "$0" ||
+$as_expr X/"$0" : '.*/$^/^/*$/*$' \| \
+	 X"$0" : 'X$//$$' \| \
+	 X"$0" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X/"$0" |
+    sed '/^.*\/$^/^/*$\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+
+# Avoid depending upon Character Ranges.
+as_cr_letters='abcdefghijklmnopqrstuvwxyz'
+as_cr_LETTERS='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+as_cr_Letters=$as_cr_letters$as_cr_LETTERS
+as_cr_digits='0123456789'
+as_cr_alnum=$as_cr_Letters$as_cr_digits
+
+ECHO_C= ECHO_N= ECHO_T=
+case `echo -n x` in #(((((
+-n*)
+  case `echo 'xy\c'` in
+  *c*) ECHO_T='	';;	# ECHO_T is single tab character.
+  xy)  ECHO_C='\c';;
+  *)   echo `echo ksh88 bug on AIX 6.1` > /dev/null
+       ECHO_T='	';;
+  esac;;
+*)
+  ECHO_N='-n';;
+esac
+
+rm -f conf$$ conf$$.exe conf$$.file
+if test -d conf$$.dir; then
+  rm -f conf$$.dir/conf$$.file
+else
+  rm -f conf$$.dir
+  mkdir conf$$.dir 2>/dev/null
+fi
+if (echo >conf$$.file) 2>/dev/null; then
+  if ln -s conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s='ln -s'
+    # ... but there are two gotchas:
+    # 1) On MSYS, both `ln -s file dir' and `ln file dir' fail.
+    # 2) DJGPP < 2.04 has no symlinks; `ln -s' creates a wrapper executable.
+    # In both cases, we have to default to `cp -pR'.
+    ln -s conf$$.file conf$$.dir 2>/dev/null && test ! -f conf$$.exe ||
+      as_ln_s='cp -pR'
+  elif ln conf$$.file conf$$ 2>/dev/null; then
+    as_ln_s=ln
+  else
+    as_ln_s='cp -pR'
+  fi
+else
+  as_ln_s='cp -pR'
+fi
+rm -f conf$$ conf$$.exe conf$$.dir/conf$$.file conf$$.file
+rmdir conf$$.dir 2>/dev/null
+
+
+# as_fn_mkdir_p
+# -------------
+# Create "$as_dir" as a directory, including parents if necessary.
+as_fn_mkdir_p ()
+{
+
+  case $as_dir in #(
+  -*) as_dir=./$as_dir;;
+  esac
+  test -d "$as_dir" || eval $as_mkdir_p || {
+    as_dirs=
+    while :; do
+      case $as_dir in #(
+      *\'*) as_qdir=`$as_echo "$as_dir" | sed "s/'/'\\\\\\\\''/g"`;; #'(
+      *) as_qdir=$as_dir;;
+      esac
+      as_dirs="'$as_qdir' $as_dirs"
+      as_dir=`$as_dirname -- "$as_dir" ||
+$as_expr X"$as_dir" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$as_dir" : 'X$//$^/' \| \
+	 X"$as_dir" : 'X$//$$' \| \
+	 X"$as_dir" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$as_dir" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+      test -d "$as_dir" && break
+    done
+    test -z "$as_dirs" || eval "mkdir $as_dirs"
+  } || test -d "$as_dir" || as_fn_error $? "cannot create directory $as_dir"
+
+
+} # as_fn_mkdir_p
+if mkdir -p . 2>/dev/null; then
+  as_mkdir_p='mkdir -p "$as_dir"'
+else
+  test -d ./-p && rmdir ./-p
+  as_mkdir_p=false
+fi
+
+
+# as_fn_executable_p FILE
+# -----------------------
+# Test if FILE is an executable regular file.
+as_fn_executable_p ()
+{
+  test -f "$1" && test -x "$1"
+} # as_fn_executable_p
+as_test_x='test -x'
+as_executable_p=as_fn_executable_p
+
+# Sed expression to map a string onto a valid CPP name.
+as_tr_cpp="eval sed 'y%*$as_cr_letters%P$as_cr_LETTERS%;s%^_$as_cr_alnum%_%g'"
+
+# Sed expression to map a string onto a valid variable name.
+as_tr_sh="eval sed 'y%*+%pp%;s%^_$as_cr_alnum%_%g'"
+
+
+exec 6>&1
+## ----------------------------------- ##
+## Main body of $CONFIG_STATUS script. ##
+## ----------------------------------- ##
+_ASEOF
+test $as_write_fail = 0 && chmod +x $CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# Save the log message, to keep $0 and so on meaningful, and to
+# report actual input values of CONFIG_FILES etc. instead of their
+# values after options handling.
+ac_log="
+This file was extended by isl-interface $as_me 0, which was
+generated by GNU Autoconf 2.69.  Invocation command line was
+
+  CONFIG_FILES    = $CONFIG_FILES
+  CONFIG_HEADERS  = $CONFIG_HEADERS
+  CONFIG_LINKS    = $CONFIG_LINKS
+  CONFIG_COMMANDS = $CONFIG_COMMANDS
+  $ $0 $@
+
+on `(hostname || uname -n) 2>/dev/null | sed 1q`
+"
+
+_ACEOF
+
+case $ac_config_files in *"
+"*) set x $ac_config_files; shift; ac_config_files=$*;;
+esac
+
+case $ac_config_headers in *"
+"*) set x $ac_config_headers; shift; ac_config_headers=$*;;
+esac
+
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+# Files that config.status was made for.
+config_files="$ac_config_files"
+config_headers="$ac_config_headers"
+config_commands="$ac_config_commands"
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+ac_cs_usage="\
+\`$as_me' instantiates files and other configuration actions
+from templates according to the current configuration.  Unless the files
+and actions are specified as TAGs, all are instantiated by default.
+
+Usage: $0 OPTION... TAG...
+
+  -h, --help       print this help, then exit
+  -V, --version    print version number and configuration settings, then exit
+      --config     print configuration, then exit
+  -q, --quiet, --silent
+                   do not print progress messages
+  -d, --debug      don't remove temporary files
+      --recheck    update $as_me by reconfiguring in the same conditions
+      --file=FILE:TEMPLATE
+                   instantiate the configuration file FILE
+      --header=FILE:TEMPLATE
+                   instantiate the configuration header FILE
+
+Configuration files:
+$config_files
+
+Configuration headers:
+$config_headers
+
+Configuration commands:
+$config_commands
+
+Report bugs to <isl-development@googlegroups.com>."
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_cs_config="`$as_echo "$ac_configure_args" | sed 's/^ //; s/\\""\`\$/\\\\&/g'`"
+ac_cs_version="\\
+isl-interface config.status 0
+configured by $0, generated by GNU Autoconf 2.69,
+  with options \\"\$ac_cs_config\\"
+
+Copyright (C) 2012 Free Software Foundation, Inc.
+This config.status script is free software; the Free Software Foundation
+gives unlimited permission to copy, distribute and modify it."
+
+ac_pwd='$ac_pwd'
+srcdir='$srcdir'
+INSTALL='$INSTALL'
+MKDIR_P='$MKDIR_P'
+AWK='$AWK'
+test -n "\$AWK" || AWK=awk
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# The default lists apply if the user does not specify any file.
+ac_need_defaults=:
+while test $# != 0
+do
+  case $1 in
+  --*=?*)
+    ac_option=`expr "X$1" : 'X$^=*$='`
+    ac_optarg=`expr "X$1" : 'X^=*=$.*$'`
+    ac_shift=:
+    ;;
+  --*=)
+    ac_option=`expr "X$1" : 'X$^=*$='`
+    ac_optarg=
+    ac_shift=:
+    ;;
+  *)
+    ac_option=$1
+    ac_optarg=$2
+    ac_shift=shift
+    ;;
+  esac
+
+  case $ac_option in
+  # Handling of the options.
+  -recheck | --recheck | --rechec | --reche | --rech | --rec | --re | --r)
+    ac_cs_recheck=: ;;
+  --version | --versio | --versi | --vers | --ver | --ve | --v | -V )
+    $as_echo "$ac_cs_version"; exit ;;
+  --config | --confi | --conf | --con | --co | --c )
+    $as_echo "$ac_cs_config"; exit ;;
+  --debug | --debu | --deb | --de | --d | -d )
+    debug=: ;;
+  --file | --fil | --fi | --f )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    '') as_fn_error $? "missing file argument" ;;
+    esac
+    as_fn_append CONFIG_FILES " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --header | --heade | --head | --hea )
+    $ac_shift
+    case $ac_optarg in
+    *\'*) ac_optarg=`$as_echo "$ac_optarg" | sed "s/'/'\\\\\\\\''/g"` ;;
+    esac
+    as_fn_append CONFIG_HEADERS " '$ac_optarg'"
+    ac_need_defaults=false;;
+  --he | --h)
+    # Conflict between --help and --header
+    as_fn_error $? "ambiguous option: \`$1'
+Try \`$0 --help' for more information.";;
+  --help | --hel | -h )
+    $as_echo "$ac_cs_usage"; exit ;;
+  -q | -quiet | --quiet | --quie | --qui | --qu | --q \
+  | -silent | --silent | --silen | --sile | --sil | --si | --s)
+    ac_cs_silent=: ;;
+
+  # This is an error.
+  -*) as_fn_error $? "unrecognized option: \`$1'
+Try \`$0 --help' for more information." ;;
+
+  *) as_fn_append ac_config_targets " $1"
+     ac_need_defaults=false ;;
+
+  esac
+  shift
+done
+
+ac_configure_extra_args=
+
+if $ac_cs_silent; then
+  exec 6>/dev/null
+  ac_configure_extra_args="$ac_configure_extra_args --silent"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+if \$ac_cs_recheck; then
+  set X $SHELL '$0' $ac_configure_args \$ac_configure_extra_args --no-create --no-recursion
+  shift
+  \$as_echo "running CONFIG_SHELL=$SHELL \$*" >&6
+  CONFIG_SHELL='$SHELL'
+  export CONFIG_SHELL
+  exec "\$@"
+fi
+
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+exec 5>>config.log
+{
+  echo
+  sed 'h;s/./-/g;s/^.../## /;s/...$/ ##/;p;x;p;x' <<_ASBOX
+## Running $as_me. ##
+_ASBOX
+  $as_echo "$ac_log"
+} >&5
+
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+#
+# INIT-COMMANDS
+#
+AMDEP_TRUE="$AMDEP_TRUE" MAKE="${MAKE-make}"
+
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+sed_quote_subst='$sed_quote_subst'
+double_quote_subst='$double_quote_subst'
+delay_variable_subst='$delay_variable_subst'
+enable_shared='`$ECHO "$enable_shared" | $SED "$delay_single_quote_subst"`'
+macro_version='`$ECHO "$macro_version" | $SED "$delay_single_quote_subst"`'
+macro_revision='`$ECHO "$macro_revision" | $SED "$delay_single_quote_subst"`'
+enable_static='`$ECHO "$enable_static" | $SED "$delay_single_quote_subst"`'
+pic_mode='`$ECHO "$pic_mode" | $SED "$delay_single_quote_subst"`'
+enable_fast_install='`$ECHO "$enable_fast_install" | $SED "$delay_single_quote_subst"`'
+shared_archive_member_spec='`$ECHO "$shared_archive_member_spec" | $SED "$delay_single_quote_subst"`'
+SHELL='`$ECHO "$SHELL" | $SED "$delay_single_quote_subst"`'
+ECHO='`$ECHO "$ECHO" | $SED "$delay_single_quote_subst"`'
+PATH_SEPARATOR='`$ECHO "$PATH_SEPARATOR" | $SED "$delay_single_quote_subst"`'
+host_alias='`$ECHO "$host_alias" | $SED "$delay_single_quote_subst"`'
+host='`$ECHO "$host" | $SED "$delay_single_quote_subst"`'
+host_os='`$ECHO "$host_os" | $SED "$delay_single_quote_subst"`'
+build_alias='`$ECHO "$build_alias" | $SED "$delay_single_quote_subst"`'
+build='`$ECHO "$build" | $SED "$delay_single_quote_subst"`'
+build_os='`$ECHO "$build_os" | $SED "$delay_single_quote_subst"`'
+SED='`$ECHO "$SED" | $SED "$delay_single_quote_subst"`'
+Xsed='`$ECHO "$Xsed" | $SED "$delay_single_quote_subst"`'
+GREP='`$ECHO "$GREP" | $SED "$delay_single_quote_subst"`'
+EGREP='`$ECHO "$EGREP" | $SED "$delay_single_quote_subst"`'
+FGREP='`$ECHO "$FGREP" | $SED "$delay_single_quote_subst"`'
+LD='`$ECHO "$LD" | $SED "$delay_single_quote_subst"`'
+NM='`$ECHO "$NM" | $SED "$delay_single_quote_subst"`'
+LN_S='`$ECHO "$LN_S" | $SED "$delay_single_quote_subst"`'
+max_cmd_len='`$ECHO "$max_cmd_len" | $SED "$delay_single_quote_subst"`'
+ac_objext='`$ECHO "$ac_objext" | $SED "$delay_single_quote_subst"`'
+exeext='`$ECHO "$exeext" | $SED "$delay_single_quote_subst"`'
+lt_unset='`$ECHO "$lt_unset" | $SED "$delay_single_quote_subst"`'
+lt_SP2NL='`$ECHO "$lt_SP2NL" | $SED "$delay_single_quote_subst"`'
+lt_NL2SP='`$ECHO "$lt_NL2SP" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_host_file_cmd='`$ECHO "$lt_cv_to_host_file_cmd" | $SED "$delay_single_quote_subst"`'
+lt_cv_to_tool_file_cmd='`$ECHO "$lt_cv_to_tool_file_cmd" | $SED "$delay_single_quote_subst"`'
+reload_flag='`$ECHO "$reload_flag" | $SED "$delay_single_quote_subst"`'
+reload_cmds='`$ECHO "$reload_cmds" | $SED "$delay_single_quote_subst"`'
+OBJDUMP='`$ECHO "$OBJDUMP" | $SED "$delay_single_quote_subst"`'
+deplibs_check_method='`$ECHO "$deplibs_check_method" | $SED "$delay_single_quote_subst"`'
+file_magic_cmd='`$ECHO "$file_magic_cmd" | $SED "$delay_single_quote_subst"`'
+file_magic_glob='`$ECHO "$file_magic_glob" | $SED "$delay_single_quote_subst"`'
+want_nocaseglob='`$ECHO "$want_nocaseglob" | $SED "$delay_single_quote_subst"`'
+DLLTOOL='`$ECHO "$DLLTOOL" | $SED "$delay_single_quote_subst"`'
+sharedlib_from_linklib_cmd='`$ECHO "$sharedlib_from_linklib_cmd" | $SED "$delay_single_quote_subst"`'
+AR='`$ECHO "$AR" | $SED "$delay_single_quote_subst"`'
+AR_FLAGS='`$ECHO "$AR_FLAGS" | $SED "$delay_single_quote_subst"`'
+archiver_list_spec='`$ECHO "$archiver_list_spec" | $SED "$delay_single_quote_subst"`'
+STRIP='`$ECHO "$STRIP" | $SED "$delay_single_quote_subst"`'
+RANLIB='`$ECHO "$RANLIB" | $SED "$delay_single_quote_subst"`'
+old_postinstall_cmds='`$ECHO "$old_postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_postuninstall_cmds='`$ECHO "$old_postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds='`$ECHO "$old_archive_cmds" | $SED "$delay_single_quote_subst"`'
+lock_old_archive_extraction='`$ECHO "$lock_old_archive_extraction" | $SED "$delay_single_quote_subst"`'
+CC='`$ECHO "$CC" | $SED "$delay_single_quote_subst"`'
+CFLAGS='`$ECHO "$CFLAGS" | $SED "$delay_single_quote_subst"`'
+compiler='`$ECHO "$compiler" | $SED "$delay_single_quote_subst"`'
+GCC='`$ECHO "$GCC" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_pipe='`$ECHO "$lt_cv_sys_global_symbol_pipe" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_cdecl='`$ECHO "$lt_cv_sys_global_symbol_to_cdecl" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_import='`$ECHO "$lt_cv_sys_global_symbol_to_import" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address" | $SED "$delay_single_quote_subst"`'
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix='`$ECHO "$lt_cv_sys_global_symbol_to_c_name_address_lib_prefix" | $SED "$delay_single_quote_subst"`'
+lt_cv_nm_interface='`$ECHO "$lt_cv_nm_interface" | $SED "$delay_single_quote_subst"`'
+nm_file_list_spec='`$ECHO "$nm_file_list_spec" | $SED "$delay_single_quote_subst"`'
+lt_sysroot='`$ECHO "$lt_sysroot" | $SED "$delay_single_quote_subst"`'
+lt_cv_truncate_bin='`$ECHO "$lt_cv_truncate_bin" | $SED "$delay_single_quote_subst"`'
+objdir='`$ECHO "$objdir" | $SED "$delay_single_quote_subst"`'
+MAGIC_CMD='`$ECHO "$MAGIC_CMD" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag='`$ECHO "$lt_prog_compiler_no_builtin_flag" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic='`$ECHO "$lt_prog_compiler_pic" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl='`$ECHO "$lt_prog_compiler_wl" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static='`$ECHO "$lt_prog_compiler_static" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o='`$ECHO "$lt_cv_prog_compiler_c_o" | $SED "$delay_single_quote_subst"`'
+need_locks='`$ECHO "$need_locks" | $SED "$delay_single_quote_subst"`'
+MANIFEST_TOOL='`$ECHO "$MANIFEST_TOOL" | $SED "$delay_single_quote_subst"`'
+DSYMUTIL='`$ECHO "$DSYMUTIL" | $SED "$delay_single_quote_subst"`'
+NMEDIT='`$ECHO "$NMEDIT" | $SED "$delay_single_quote_subst"`'
+LIPO='`$ECHO "$LIPO" | $SED "$delay_single_quote_subst"`'
+OTOOL='`$ECHO "$OTOOL" | $SED "$delay_single_quote_subst"`'
+OTOOL64='`$ECHO "$OTOOL64" | $SED "$delay_single_quote_subst"`'
+libext='`$ECHO "$libext" | $SED "$delay_single_quote_subst"`'
+shrext_cmds='`$ECHO "$shrext_cmds" | $SED "$delay_single_quote_subst"`'
+extract_expsyms_cmds='`$ECHO "$extract_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc='`$ECHO "$archive_cmds_need_lc" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes='`$ECHO "$enable_shared_with_static_runtimes" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec='`$ECHO "$export_dynamic_flag_spec" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec='`$ECHO "$whole_archive_flag_spec" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object='`$ECHO "$compiler_needs_object" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds='`$ECHO "$old_archive_from_new_cmds" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds='`$ECHO "$old_archive_from_expsyms_cmds" | $SED "$delay_single_quote_subst"`'
+archive_cmds='`$ECHO "$archive_cmds" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds='`$ECHO "$archive_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+module_cmds='`$ECHO "$module_cmds" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds='`$ECHO "$module_expsym_cmds" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld='`$ECHO "$with_gnu_ld" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag='`$ECHO "$allow_undefined_flag" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag='`$ECHO "$no_undefined_flag" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec='`$ECHO "$hardcode_libdir_flag_spec" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator='`$ECHO "$hardcode_libdir_separator" | $SED "$delay_single_quote_subst"`'
+hardcode_direct='`$ECHO "$hardcode_direct" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute='`$ECHO "$hardcode_direct_absolute" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L='`$ECHO "$hardcode_minus_L" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var='`$ECHO "$hardcode_shlibpath_var" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic='`$ECHO "$hardcode_automatic" | $SED "$delay_single_quote_subst"`'
+inherit_rpath='`$ECHO "$inherit_rpath" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs='`$ECHO "$link_all_deplibs" | $SED "$delay_single_quote_subst"`'
+always_export_symbols='`$ECHO "$always_export_symbols" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds='`$ECHO "$export_symbols_cmds" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms='`$ECHO "$exclude_expsyms" | $SED "$delay_single_quote_subst"`'
+include_expsyms='`$ECHO "$include_expsyms" | $SED "$delay_single_quote_subst"`'
+prelink_cmds='`$ECHO "$prelink_cmds" | $SED "$delay_single_quote_subst"`'
+postlink_cmds='`$ECHO "$postlink_cmds" | $SED "$delay_single_quote_subst"`'
+file_list_spec='`$ECHO "$file_list_spec" | $SED "$delay_single_quote_subst"`'
+variables_saved_for_relink='`$ECHO "$variables_saved_for_relink" | $SED "$delay_single_quote_subst"`'
+need_lib_prefix='`$ECHO "$need_lib_prefix" | $SED "$delay_single_quote_subst"`'
+need_version='`$ECHO "$need_version" | $SED "$delay_single_quote_subst"`'
+version_type='`$ECHO "$version_type" | $SED "$delay_single_quote_subst"`'
+runpath_var='`$ECHO "$runpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_var='`$ECHO "$shlibpath_var" | $SED "$delay_single_quote_subst"`'
+shlibpath_overrides_runpath='`$ECHO "$shlibpath_overrides_runpath" | $SED "$delay_single_quote_subst"`'
+libname_spec='`$ECHO "$libname_spec" | $SED "$delay_single_quote_subst"`'
+library_names_spec='`$ECHO "$library_names_spec" | $SED "$delay_single_quote_subst"`'
+soname_spec='`$ECHO "$soname_spec" | $SED "$delay_single_quote_subst"`'
+install_override_mode='`$ECHO "$install_override_mode" | $SED "$delay_single_quote_subst"`'
+postinstall_cmds='`$ECHO "$postinstall_cmds" | $SED "$delay_single_quote_subst"`'
+postuninstall_cmds='`$ECHO "$postuninstall_cmds" | $SED "$delay_single_quote_subst"`'
+finish_cmds='`$ECHO "$finish_cmds" | $SED "$delay_single_quote_subst"`'
+finish_eval='`$ECHO "$finish_eval" | $SED "$delay_single_quote_subst"`'
+hardcode_into_libs='`$ECHO "$hardcode_into_libs" | $SED "$delay_single_quote_subst"`'
+sys_lib_search_path_spec='`$ECHO "$sys_lib_search_path_spec" | $SED "$delay_single_quote_subst"`'
+configure_time_dlsearch_path='`$ECHO "$configure_time_dlsearch_path" | $SED "$delay_single_quote_subst"`'
+configure_time_lt_sys_library_path='`$ECHO "$configure_time_lt_sys_library_path" | $SED "$delay_single_quote_subst"`'
+hardcode_action='`$ECHO "$hardcode_action" | $SED "$delay_single_quote_subst"`'
+enable_dlopen='`$ECHO "$enable_dlopen" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self='`$ECHO "$enable_dlopen_self" | $SED "$delay_single_quote_subst"`'
+enable_dlopen_self_static='`$ECHO "$enable_dlopen_self_static" | $SED "$delay_single_quote_subst"`'
+old_striplib='`$ECHO "$old_striplib" | $SED "$delay_single_quote_subst"`'
+striplib='`$ECHO "$striplib" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs='`$ECHO "$compiler_lib_search_dirs" | $SED "$delay_single_quote_subst"`'
+predep_objects='`$ECHO "$predep_objects" | $SED "$delay_single_quote_subst"`'
+postdep_objects='`$ECHO "$postdep_objects" | $SED "$delay_single_quote_subst"`'
+predeps='`$ECHO "$predeps" | $SED "$delay_single_quote_subst"`'
+postdeps='`$ECHO "$postdeps" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path='`$ECHO "$compiler_lib_search_path" | $SED "$delay_single_quote_subst"`'
+LD_CXX='`$ECHO "$LD_CXX" | $SED "$delay_single_quote_subst"`'
+reload_flag_CXX='`$ECHO "$reload_flag_CXX" | $SED "$delay_single_quote_subst"`'
+reload_cmds_CXX='`$ECHO "$reload_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_cmds_CXX='`$ECHO "$old_archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_CXX='`$ECHO "$compiler_CXX" | $SED "$delay_single_quote_subst"`'
+GCC_CXX='`$ECHO "$GCC_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_no_builtin_flag_CXX='`$ECHO "$lt_prog_compiler_no_builtin_flag_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_pic_CXX='`$ECHO "$lt_prog_compiler_pic_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_wl_CXX='`$ECHO "$lt_prog_compiler_wl_CXX" | $SED "$delay_single_quote_subst"`'
+lt_prog_compiler_static_CXX='`$ECHO "$lt_prog_compiler_static_CXX" | $SED "$delay_single_quote_subst"`'
+lt_cv_prog_compiler_c_o_CXX='`$ECHO "$lt_cv_prog_compiler_c_o_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_need_lc_CXX='`$ECHO "$archive_cmds_need_lc_CXX" | $SED "$delay_single_quote_subst"`'
+enable_shared_with_static_runtimes_CXX='`$ECHO "$enable_shared_with_static_runtimes_CXX" | $SED "$delay_single_quote_subst"`'
+export_dynamic_flag_spec_CXX='`$ECHO "$export_dynamic_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+whole_archive_flag_spec_CXX='`$ECHO "$whole_archive_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_needs_object_CXX='`$ECHO "$compiler_needs_object_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_new_cmds_CXX='`$ECHO "$old_archive_from_new_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+old_archive_from_expsyms_cmds_CXX='`$ECHO "$old_archive_from_expsyms_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_cmds_CXX='`$ECHO "$archive_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+archive_expsym_cmds_CXX='`$ECHO "$archive_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_cmds_CXX='`$ECHO "$module_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+module_expsym_cmds_CXX='`$ECHO "$module_expsym_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+with_gnu_ld_CXX='`$ECHO "$with_gnu_ld_CXX" | $SED "$delay_single_quote_subst"`'
+allow_undefined_flag_CXX='`$ECHO "$allow_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+no_undefined_flag_CXX='`$ECHO "$no_undefined_flag_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_flag_spec_CXX='`$ECHO "$hardcode_libdir_flag_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_libdir_separator_CXX='`$ECHO "$hardcode_libdir_separator_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_CXX='`$ECHO "$hardcode_direct_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_direct_absolute_CXX='`$ECHO "$hardcode_direct_absolute_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_minus_L_CXX='`$ECHO "$hardcode_minus_L_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_shlibpath_var_CXX='`$ECHO "$hardcode_shlibpath_var_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_automatic_CXX='`$ECHO "$hardcode_automatic_CXX" | $SED "$delay_single_quote_subst"`'
+inherit_rpath_CXX='`$ECHO "$inherit_rpath_CXX" | $SED "$delay_single_quote_subst"`'
+link_all_deplibs_CXX='`$ECHO "$link_all_deplibs_CXX" | $SED "$delay_single_quote_subst"`'
+always_export_symbols_CXX='`$ECHO "$always_export_symbols_CXX" | $SED "$delay_single_quote_subst"`'
+export_symbols_cmds_CXX='`$ECHO "$export_symbols_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+exclude_expsyms_CXX='`$ECHO "$exclude_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+include_expsyms_CXX='`$ECHO "$include_expsyms_CXX" | $SED "$delay_single_quote_subst"`'
+prelink_cmds_CXX='`$ECHO "$prelink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+postlink_cmds_CXX='`$ECHO "$postlink_cmds_CXX" | $SED "$delay_single_quote_subst"`'
+file_list_spec_CXX='`$ECHO "$file_list_spec_CXX" | $SED "$delay_single_quote_subst"`'
+hardcode_action_CXX='`$ECHO "$hardcode_action_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_dirs_CXX='`$ECHO "$compiler_lib_search_dirs_CXX" | $SED "$delay_single_quote_subst"`'
+predep_objects_CXX='`$ECHO "$predep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+postdep_objects_CXX='`$ECHO "$postdep_objects_CXX" | $SED "$delay_single_quote_subst"`'
+predeps_CXX='`$ECHO "$predeps_CXX" | $SED "$delay_single_quote_subst"`'
+postdeps_CXX='`$ECHO "$postdeps_CXX" | $SED "$delay_single_quote_subst"`'
+compiler_lib_search_path_CXX='`$ECHO "$compiler_lib_search_path_CXX" | $SED "$delay_single_quote_subst"`'
+
+LTCC='$LTCC'
+LTCFLAGS='$LTCFLAGS'
+compiler='$compiler_DEFAULT'
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+
+# Quote evaled strings.
+for var in SHELL \
+ECHO \
+PATH_SEPARATOR \
+SED \
+GREP \
+EGREP \
+FGREP \
+LD \
+NM \
+LN_S \
+lt_SP2NL \
+lt_NL2SP \
+reload_flag \
+OBJDUMP \
+deplibs_check_method \
+file_magic_cmd \
+file_magic_glob \
+want_nocaseglob \
+DLLTOOL \
+sharedlib_from_linklib_cmd \
+AR \
+AR_FLAGS \
+archiver_list_spec \
+STRIP \
+RANLIB \
+CC \
+CFLAGS \
+compiler \
+lt_cv_sys_global_symbol_pipe \
+lt_cv_sys_global_symbol_to_cdecl \
+lt_cv_sys_global_symbol_to_import \
+lt_cv_sys_global_symbol_to_c_name_address \
+lt_cv_sys_global_symbol_to_c_name_address_lib_prefix \
+lt_cv_nm_interface \
+nm_file_list_spec \
+lt_cv_truncate_bin \
+lt_prog_compiler_no_builtin_flag \
+lt_prog_compiler_pic \
+lt_prog_compiler_wl \
+lt_prog_compiler_static \
+lt_cv_prog_compiler_c_o \
+need_locks \
+MANIFEST_TOOL \
+DSYMUTIL \
+NMEDIT \
+LIPO \
+OTOOL \
+OTOOL64 \
+shrext_cmds \
+export_dynamic_flag_spec \
+whole_archive_flag_spec \
+compiler_needs_object \
+with_gnu_ld \
+allow_undefined_flag \
+no_undefined_flag \
+hardcode_libdir_flag_spec \
+hardcode_libdir_separator \
+exclude_expsyms \
+include_expsyms \
+file_list_spec \
+variables_saved_for_relink \
+libname_spec \
+library_names_spec \
+soname_spec \
+install_override_mode \
+finish_eval \
+old_striplib \
+striplib \
+compiler_lib_search_dirs \
+predep_objects \
+postdep_objects \
+predeps \
+postdeps \
+compiler_lib_search_path \
+LD_CXX \
+reload_flag_CXX \
+compiler_CXX \
+lt_prog_compiler_no_builtin_flag_CXX \
+lt_prog_compiler_pic_CXX \
+lt_prog_compiler_wl_CXX \
+lt_prog_compiler_static_CXX \
+lt_cv_prog_compiler_c_o_CXX \
+export_dynamic_flag_spec_CXX \
+whole_archive_flag_spec_CXX \
+compiler_needs_object_CXX \
+with_gnu_ld_CXX \
+allow_undefined_flag_CXX \
+no_undefined_flag_CXX \
+hardcode_libdir_flag_spec_CXX \
+hardcode_libdir_separator_CXX \
+exclude_expsyms_CXX \
+include_expsyms_CXX \
+file_list_spec_CXX \
+compiler_lib_search_dirs_CXX \
+predep_objects_CXX \
+postdep_objects_CXX \
+predeps_CXX \
+postdeps_CXX \
+compiler_lib_search_path_CXX; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *\\\\\\\`\\"\\\$*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED \\"\\\$sed_quote_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+# Double-quote double-evaled strings.
+for var in reload_cmds \
+old_postinstall_cmds \
+old_postuninstall_cmds \
+old_archive_cmds \
+extract_expsyms_cmds \
+old_archive_from_new_cmds \
+old_archive_from_expsyms_cmds \
+archive_cmds \
+archive_expsym_cmds \
+module_cmds \
+module_expsym_cmds \
+export_symbols_cmds \
+prelink_cmds \
+postlink_cmds \
+postinstall_cmds \
+postuninstall_cmds \
+finish_cmds \
+sys_lib_search_path_spec \
+configure_time_dlsearch_path \
+configure_time_lt_sys_library_path \
+reload_cmds_CXX \
+old_archive_cmds_CXX \
+old_archive_from_new_cmds_CXX \
+old_archive_from_expsyms_cmds_CXX \
+archive_cmds_CXX \
+archive_expsym_cmds_CXX \
+module_cmds_CXX \
+module_expsym_cmds_CXX \
+export_symbols_cmds_CXX \
+prelink_cmds_CXX \
+postlink_cmds_CXX; do
+    case \`eval \\\\\$ECHO \\\\""\\\\\$\$var"\\\\"\` in
+    *\\\\\\\`\\"\\\$*)
+      eval "lt_\$var=\\\\\\"\\\`\\\$ECHO \\"\\\$\$var\\" | \\\$SED -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\"" ## exclude from sc_prohibit_nested_quotes
+      ;;
+    *)
+      eval "lt_\$var=\\\\\\"\\\$\$var\\\\\\""
+      ;;
+    esac
+done
+
+ac_aux_dir='$ac_aux_dir'
+
+# See if we are running on zsh, and set the options that allow our
+# commands through without removal of \ escapes INIT.
+if test -n "\${ZSH_VERSION+set}"; then
+   setopt NO_GLOB_SUBST
+fi
+
+
+    PACKAGE='$PACKAGE'
+    VERSION='$VERSION'
+    RM='$RM'
+    ofile='$ofile'
+
+
+
+
+
+
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+
+# Handling of arguments.
+for ac_config_target in $ac_config_targets
+do
+  case $ac_config_target in
+    "depfiles") CONFIG_COMMANDS="$CONFIG_COMMANDS depfiles" ;;
+    "libtool") CONFIG_COMMANDS="$CONFIG_COMMANDS libtool" ;;
+    "isl_config.h") CONFIG_HEADERS="$CONFIG_HEADERS isl_config.h" ;;
+    "Makefile") CONFIG_FILES="$CONFIG_FILES Makefile" ;;
+
+  *) as_fn_error $? "invalid argument: \`$ac_config_target'" "$LINENO" 5;;
+  esac
+done
+
+
+# If the user did not use the arguments to specify the items to instantiate,
+# then the envvar interface is used.  Set only those that are not.
+# We use the long form for the default assignment because of an extremely
+# bizarre bug on SunOS 4.1.3.
+if $ac_need_defaults; then
+  test "${CONFIG_FILES+set}" = set || CONFIG_FILES=$config_files
+  test "${CONFIG_HEADERS+set}" = set || CONFIG_HEADERS=$config_headers
+  test "${CONFIG_COMMANDS+set}" = set || CONFIG_COMMANDS=$config_commands
+fi
+
+# Have a temporary directory for convenience.  Make it in the build tree
+# simply because there is no reason against having it here, and in addition,
+# creating and moving files from /tmp can sometimes cause problems.
+# Hook for its removal unless debugging.
+# Note that there is a small window in which the directory will not be cleaned:
+# after its creation but before its name has been assigned to `$tmp'.
+$debug ||
+{
+  tmp= ac_tmp=
+  trap 'exit_status=$?
+  : "${ac_tmp:=$tmp}"
+  { test ! -d "$ac_tmp" || rm -fr "$ac_tmp"; } && exit $exit_status
+' 0
+  trap 'as_fn_exit 1' 1 2 13 15
+}
+# Create a (secure) tmp directory for tmp files.
+
+{
+  tmp=`(umask 077 && mktemp -d "./confXXXXXX") 2>/dev/null` &&
+  test -d "$tmp"
+}  ||
+{
+  tmp=./conf$$-$RANDOM
+  (umask 077 && mkdir "$tmp")
+} || as_fn_error $? "cannot create a temporary directory in ." "$LINENO" 5
+ac_tmp=$tmp
+
+# Set up the scripts for CONFIG_FILES section.
+# No need to generate them if there are no CONFIG_FILES.
+# This happens for instance with `./config.status config.h'.
+if test -n "$CONFIG_FILES"; then
+
+
+ac_cr=`echo X | tr X '\015'`
+# On cygwin, bash can eat \r inside `` if the user requested igncr.
+# But we know of no other shell where ac_cr would be empty at this
+# point, so we can use a bashism as a fallback.
+if test "x$ac_cr" = x; then
+  eval ac_cr=\$\'\\r\'
+fi
+ac_cs_awk_cr=`$AWK 'BEGIN { print "a\rb" }' </dev/null 2>/dev/null`
+if test "$ac_cs_awk_cr" = "a${ac_cr}b"; then
+  ac_cs_awk_cr='\\r'
+else
+  ac_cs_awk_cr=$ac_cr
+fi
+
+echo 'BEGIN {' >"$ac_tmp/subs1.awk" &&
+_ACEOF
+
+
+{
+  echo "cat >conf$$subs.awk <<_ACEOF" &&
+  echo "$ac_subst_vars" | sed 's/.*/&!$&$ac_delim/' &&
+  echo "_ACEOF"
+} >conf$$subs.sh ||
+  as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+ac_delim_num=`echo "$ac_subst_vars" | grep -c '^'`
+ac_delim='%!_!# '
+for ac_last_try in false false false false false :; do
+  . ./conf$$subs.sh ||
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+
+  ac_delim_n=`sed -n "s/.*$ac_delim\$/X/p" conf$$subs.awk | grep -c X`
+  if test $ac_delim_n = $ac_delim_num; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_STATUS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+rm -f conf$$subs.sh
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+cat >>"\$ac_tmp/subs1.awk" <<\\_ACAWK &&
+_ACEOF
+sed -n '
+h
+s/^/S"/; s/!.*/"=/
+p
+g
+s/^^!*!//
+:repl
+t repl
+s/'"$ac_delim"'$//
+t delim
+:nl
+h
+s/$.\{148\}$..*/\1/
+t more1
+s/"\\/\\&/g; s/^/"/; s/$/\\n"\\/
+p
+n
+b repl
+:more1
+s/"\\/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t nl
+:delim
+h
+s/$.\{148\}$..*/\1/
+t more2
+s/"\\/\\&/g; s/^/"/; s/$/"/
+p
+b
+:more2
+s/"\\/\\&/g; s/^/"/; s/$/"\\/
+p
+g
+s/.\{148\}//
+t delim
+' <conf$$subs.awk | sed '
+/^^""/{
+  N
+  s/\n//
+}
+' >>$CONFIG_STATUS || ac_write_fail=1
+rm -f conf$$subs.awk
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+_ACAWK
+cat >>"\$ac_tmp/subs1.awk" <<_ACAWK &&
+  for (key in S) S_is_setkey = 1
+  FS = "&#x7;"
+
+}
+{
+  line = $ 0
+  nfields = split(line, field, "@")
+  substed = 0
+  len = length(field1)
+  for (i = 2; i < nfields; i++) {
+    key = fieldi
+    keylen = length(key)
+    if (S_is_setkey) {
+      value = Skey
+      line = substr(line, 1, len) "" value "" substr(line, len + keylen + 3)
+      len += length(value) + length(field++i)
+      substed = 1
+    } else
+      len += 1 + keylen
+  }
+
+  print line
+}
+
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+if sed "s/$ac_cr//" < /dev/null > /dev/null 2>&1; then
+  sed "s/$ac_cr\$//; s/$ac_cr/$ac_cs_awk_cr/g"
+else
+  cat
+fi < "$ac_tmp/subs1.awk" > "$ac_tmp/subs.awk" \
+  || as_fn_error $? "could not setup config files machinery" "$LINENO" 5
+_ACEOF
+
+# VPATH may cause trouble with some makes, so we remove sole $(srcdir),
+# ${srcdir} and @srcdir@ entries from VPATH if srcdir is ".", strip leading and
+# trailing colons and then remove the whole line if VPATH becomes empty
+# (actually we leave an empty line to preserve line numbers).
+if test "x$srcdir" = x.; then
+  ac_vpsub='/^	 *VPATH	 *=	 */{
+h
+s///
+s/^/:/
+s/	 *$/:/
+s/:\$(srcdir):/:/g
+s/:\${srcdir}:/:/g
+s/:@srcdir@:/:/g
+s/^:*//
+s/:*$//
+x
+s/$=	 *$.*/\1/
+G
+s/\n//
+s/^^=*=	 *$//
+}'
+fi
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+fi # test -n "$CONFIG_FILES"
+
+# Set up the scripts for CONFIG_HEADERS section.
+# No need to generate them if there are no CONFIG_HEADERS.
+# This happens for instance with `./config.status Makefile'.
+if test -n "$CONFIG_HEADERS"; then
+cat >"$ac_tmp/defines.awk" <<\_ACAWK ||
+BEGIN {
+_ACEOF
+
+# Transform confdefs.h into an awk script `defines.awk', embedded as
+# here-document in config.status, that substitutes the proper values into
+# config.h.in to produce config.h.
+
+# Create a delimiter string that does not exist in confdefs.h, to ease
+# handling of long lines.
+ac_delim='%!_!# '
+for ac_last_try in false false :; do
+  ac_tt=`sed -n "/$ac_delim/p" confdefs.h`
+  if test -z "$ac_tt"; then
+    break
+  elif $ac_last_try; then
+    as_fn_error $? "could not make $CONFIG_HEADERS" "$LINENO" 5
+  else
+    ac_delim="$ac_delim!$ac_delim _$ac_delim!! "
+  fi
+done
+
+# For the awk script, D is an array of macro values keyed by name,
+# likewise P contains macro parameters if any.  Preserve backslash
+# newline sequences.
+
+ac_word_re=_$as_cr_Letters_$as_cr_alnum*
+sed -n '
+s/.\{148\}/&'"$ac_delim"'/g
+t rset
+:rset
+s/^	 *#	 *define	 	 */ /
+t def
+d
+:def
+s/\\$//
+t bsnl
+s/"\\/\\&/g
+s/^ $'"$ac_word_re"'$$(^()*)$	 *$.*$/P"\1"="\2"\
+D"\1"=" \3"/p
+s/^ $'"$ac_word_re"'$	 *$.*$/D"\1"=" \2"/p
+d
+:bsnl
+s/"\\/\\&/g
+s/^ $'"$ac_word_re"'$$(^()*)$	 *$.*$/P"\1"="\2"\
+D"\1"=" \3\\\\\\n"\\/p
+t cont
+s/^ $'"$ac_word_re"'$	 *$.*$/D"\1"=" \2\\\\\\n"\\/p
+t cont
+d
+:cont
+n
+s/.\{148\}/&'"$ac_delim"'/g
+t clear
+:clear
+s/\\$//
+t bsnlc
+s/"\\/\\&/g; s/^/"/; s/$/"/p
+d
+:bsnlc
+s/"\\/\\&/g; s/^/"/; s/$/\\\\\\n"\\/p
+b cont
+' <confdefs.h | sed '
+s/'"$ac_delim"'/"\\\
+"/g' >>$CONFIG_STATUS || ac_write_fail=1
+
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  for (key in D) D_is_setkey = 1
+  FS = "&#x7;"
+}
+/^\t *#\t *(define|undef)\t +$ac_word_re(\t (|\$)/ {
+  line = \$ 0
+  split(line, arg, " ")
+  if (arg1 == "#") {
+    defundef = arg2
+    mac1 = arg3
+  } else {
+    defundef = substr(arg1, 2)
+    mac1 = arg2
+  }
+  split(mac1, mac2, "(") #)
+  macro = mac21
+  prefix = substr(line, 1, index(line, defundef) - 1)
+  if (D_is_setmacro) {
+    # Preserve the white space surrounding the "#".
+    print prefix "define", macro Pmacro Dmacro
+    next
+  } else {
+    # Replace #undef with comments.  This is necessary, for example,
+    # in the case of _POSIX_SOURCE, which is predefined and required
+    # on some systems where configure will not decide to define it.
+    if (defundef == "undef") {
+      print "/*", prefix defundef, macro, "*/"
+      next
+    }
+  }
+}
+{ print }
+_ACAWK
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+  as_fn_error $? "could not setup config headers machinery" "$LINENO" 5
+fi # test -n "$CONFIG_HEADERS"
+
+
+eval set X "  :F $CONFIG_FILES  :H $CONFIG_HEADERS    :C $CONFIG_COMMANDS"
+shift
+for ac_tag
+do
+  case $ac_tag in
+  :FHLC) ac_mode=$ac_tag; continue;;
+  esac
+  case $ac_mode$ac_tag in
+  :FHL*:*);;
+  :L* | :C*:*) as_fn_error $? "invalid tag \`$ac_tag'" "$LINENO" 5;;
+  :FH-) ac_tag=-:-;;
+  :FH*) ac_tag=$ac_tag:$ac_tag.in;;
+  esac
+  ac_save_IFS=$IFS
+  IFS=:
+  set x $ac_tag
+  IFS=$ac_save_IFS
+  shift
+  ac_file=$1
+  shift
+
+  case $ac_mode in
+  :L) ac_source=$1;;
+  :FH)
+    ac_file_inputs=
+    for ac_f
+    do
+      case $ac_f in
+      -) ac_f="$ac_tmp/stdin";;
+      *) # Look for the file first in the build tree, then in the source tree
+	 # (if the path is not absolute).  The absolute path cannot be DOS-style,
+	 # because $ac_f cannot contain `:'.
+	 test -f "$ac_f" ||
+	   case $ac_f in
+	   \\/$*) false;;
+	   *) test -f "$srcdir/$ac_f" && ac_f="$srcdir/$ac_f";;
+	   esac ||
+	   as_fn_error 1 "cannot find input file: \`$ac_f'" "$LINENO" 5;;
+      esac
+      case $ac_f in *\'*) ac_f=`$as_echo "$ac_f" | sed "s/'/'\\\\\\\\''/g"`;; esac
+      as_fn_append ac_file_inputs " '$ac_f'"
+    done
+
+    # Let's still pretend it is `configure' which instantiates (i.e., don't
+    # use $as_me), people would be surprised to read:
+    #    /* config.h.  Generated by config.status.  */
+    configure_input='Generated from '`
+	  $as_echo "$*" | sed 's|^^:*/||;s|:^:*/|, |g'
+	`' by configure.'
+    if test x"$ac_file" != x-; then
+      configure_input="$ac_file.  $configure_input"
+      { $as_echo "$as_me:${as_lineno-$LINENO}: creating $ac_file" >&5
+$as_echo "$as_me: creating $ac_file" >&6;}
+    fi
+    # Neutralize special characters interpreted by sed in replacement strings.
+    case $configure_input in #(
+    *\&* | *\|* | *\\* )
+       ac_sed_conf_input=`$as_echo "$configure_input" |
+       sed 's/\\\\&|/\\\\&/g'`;; #(
+    *) ac_sed_conf_input=$configure_input;;
+    esac
+
+    case $ac_tag in
+    *:-:* | *:-) cat >"$ac_tmp/stdin" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5 ;;
+    esac
+    ;;
+  esac
+
+  ac_dir=`$as_dirname -- "$ac_file" ||
+$as_expr X"$ac_file" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$ac_file" : 'X$//$^/' \| \
+	 X"$ac_file" : 'X$//$$' \| \
+	 X"$ac_file" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$ac_file" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+  as_dir="$ac_dir"; as_fn_mkdir_p
+  ac_builddir=.
+
+case "$ac_dir" in
+.) ac_dir_suffix= ac_top_builddir_sub=. ac_top_build_prefix= ;;
+*)
+  ac_dir_suffix=/`$as_echo "$ac_dir" | sed 's|^\.\\/||'`
+  # A ".." for each directory in $ac_dir_suffix.
+  ac_top_builddir_sub=`$as_echo "$ac_dir_suffix" | sed 's|/^\\/*|/..|g;s|/||'`
+  case $ac_top_builddir_sub in
+  "") ac_top_builddir_sub=. ac_top_build_prefix= ;;
+  *)  ac_top_build_prefix=$ac_top_builddir_sub/ ;;
+  esac ;;
+esac
+ac_abs_top_builddir=$ac_pwd
+ac_abs_builddir=$ac_pwd$ac_dir_suffix
+# for backward compatibility:
+ac_top_builddir=$ac_top_build_prefix
+
+case $srcdir in
+  .)  # We are building in place.
+    ac_srcdir=.
+    ac_top_srcdir=$ac_top_builddir_sub
+    ac_abs_top_srcdir=$ac_pwd ;;
+  \\/* | ?:\\/* )  # Absolute name.
+    ac_srcdir=$srcdir$ac_dir_suffix;
+    ac_top_srcdir=$srcdir
+    ac_abs_top_srcdir=$srcdir ;;
+  *) # Relative name.
+    ac_srcdir=$ac_top_build_prefix$srcdir$ac_dir_suffix
+    ac_top_srcdir=$ac_top_build_prefix$srcdir
+    ac_abs_top_srcdir=$ac_pwd/$srcdir ;;
+esac
+ac_abs_srcdir=$ac_abs_top_srcdir$ac_dir_suffix
+
+
+  case $ac_mode in
+  :F)
+  #
+  # CONFIG_FILE
+  #
+
+  case $INSTALL in
+  \\/$* | ?:\\/* ) ac_INSTALL=$INSTALL ;;
+  *) ac_INSTALL=$ac_top_build_prefix$INSTALL ;;
+  esac
+  ac_MKDIR_P=$MKDIR_P
+  case $MKDIR_P in
+  \\/$* | ?:\\/* ) ;;
+  */*) ac_MKDIR_P=$ac_top_build_prefix$MKDIR_P ;;
+  esac
+_ACEOF
+
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+# If the template does not know about datarootdir, expand it.
+# FIXME: This hack should be removed a few years after 2.60.
+ac_datarootdir_hack=; ac_datarootdir_seen=
+ac_sed_dataroot='
+/datarootdir/ {
+  p
+  q
+}
+/@datadir@/p
+/@docdir@/p
+/@infodir@/p
+/@localedir@/p
+/@mandir@/p'
+case `eval "sed -n \"\$ac_sed_dataroot\" $ac_file_inputs"` in
+*datarootdir*) ac_datarootdir_seen=yes;;
+*@datadir@*|*@docdir@*|*@infodir@*|*@localedir@*|*@mandir@*)
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&5
+$as_echo "$as_me: WARNING: $ac_file_inputs seems to ignore the --datarootdir setting" >&2;}
+_ACEOF
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+  ac_datarootdir_hack='
+  s&@datadir@&$datadir&g
+  s&@docdir@&$docdir&g
+  s&@infodir@&$infodir&g
+  s&@localedir@&$localedir&g
+  s&@mandir@&$mandir&g
+  s&\\\${datarootdir}&$datarootdir&g' ;;
+esac
+_ACEOF
+
+# Neutralize VPATH when `$srcdir' = `.'.
+# Shell code in configure.ac might set extrasub.
+# FIXME: do we really want to maintain this feature?
+cat >>$CONFIG_STATUS <<_ACEOF || ac_write_fail=1
+ac_sed_extra="$ac_vpsub
+$extrasub
+_ACEOF
+cat >>$CONFIG_STATUS <<\_ACEOF || ac_write_fail=1
+:t
+/@a-zA-Z_a-zA-Z_0-9*@/!b
+s|@configure_input@|$ac_sed_conf_input|;t t
+s&@top_builddir@&$ac_top_builddir_sub&;t t
+s&@top_build_prefix@&$ac_top_build_prefix&;t t
+s&@srcdir@&$ac_srcdir&;t t
+s&@abs_srcdir@&$ac_abs_srcdir&;t t
+s&@top_srcdir@&$ac_top_srcdir&;t t
+s&@abs_top_srcdir@&$ac_abs_top_srcdir&;t t
+s&@builddir@&$ac_builddir&;t t
+s&@abs_builddir@&$ac_abs_builddir&;t t
+s&@abs_top_builddir@&$ac_abs_top_builddir&;t t
+s&@INSTALL@&$ac_INSTALL&;t t
+s&@MKDIR_P@&$ac_MKDIR_P&;t t
+$ac_datarootdir_hack
+"
+eval sed \"\$ac_sed_extra\" "$ac_file_inputs" | $AWK -f "$ac_tmp/subs.awk" \
+  >$ac_tmp/out || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+
+test -z "$ac_datarootdir_hack$ac_datarootdir_seen" &&
+  { ac_out=`sed -n '/\${datarootdir}/p' "$ac_tmp/out"`; test -n "$ac_out"; } &&
+  { ac_out=`sed -n '/^	 *datarootdir	 *:*=/p' \
+      "$ac_tmp/out"`; test -z "$ac_out"; } &&
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&5
+$as_echo "$as_me: WARNING: $ac_file contains a reference to the variable \`datarootdir'
+which seems to be undefined.  Please make sure it is defined" >&2;}
+
+  rm -f "$ac_tmp/stdin"
+  case $ac_file in
+  -) cat "$ac_tmp/out" && rm -f "$ac_tmp/out";;
+  *) rm -f "$ac_file" && mv "$ac_tmp/out" "$ac_file";;
+  esac \
+  || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+ ;;
+  :H)
+  #
+  # CONFIG_HEADER
+  #
+  if test x"$ac_file" != x-; then
+    {
+      $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs"
+    } >"$ac_tmp/config.h" \
+      || as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    if diff "$ac_file" "$ac_tmp/config.h" >/dev/null 2>&1; then
+      { $as_echo "$as_me:${as_lineno-$LINENO}: $ac_file is unchanged" >&5
+$as_echo "$as_me: $ac_file is unchanged" >&6;}
+    else
+      rm -f "$ac_file"
+      mv "$ac_tmp/config.h" "$ac_file" \
+	|| as_fn_error $? "could not create $ac_file" "$LINENO" 5
+    fi
+  else
+    $as_echo "/* $configure_input  */" \
+      && eval '$AWK -f "$ac_tmp/defines.awk"' "$ac_file_inputs" \
+      || as_fn_error $? "could not create -" "$LINENO" 5
+  fi
+# Compute "$ac_file"'s index in $config_headers.
+_am_arg="$ac_file"
+_am_stamp_count=1
+for _am_header in $config_headers :; do
+  case $_am_header in
+    $_am_arg | $_am_arg:* )
+      break ;;
+    * )
+      _am_stamp_count=`expr $_am_stamp_count + 1` ;;
+  esac
+done
+echo "timestamp for $_am_arg" >`$as_dirname -- "$_am_arg" ||
+$as_expr X"$_am_arg" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$_am_arg" : 'X$//$^/' \| \
+	 X"$_am_arg" : 'X$//$$' \| \
+	 X"$_am_arg" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$_am_arg" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`/stamp-h$_am_stamp_count
+ ;;
+
+  :C)  { $as_echo "$as_me:${as_lineno-$LINENO}: executing $ac_file commands" >&5
+$as_echo "$as_me: executing $ac_file commands" >&6;}
+ ;;
+  esac
+
+
+  case $ac_file$ac_mode in
+    "depfiles":C) test x"$AMDEP_TRUE" != x"" || {
+  # Older Autoconf quotes --file arguments for eval, but not when files
+  # are listed without --file.  Let's play safe and only enable the eval
+  # if we detect the quoting.
+  # TODO: see whether this extra hack can be removed once we start
+  # requiring Autoconf 2.70 or later.
+  case $CONFIG_FILES in #(
+  *\'*) :
+    eval set x "$CONFIG_FILES" ;; #(
+  *) :
+    set x $CONFIG_FILES ;; #(
+  *) :
+     ;;
+esac
+  shift
+  # Used to flag and report bootstrapping failures.
+  am_rc=0
+  for am_mf
+  do
+    # Strip MF so we end up with the name of the file.
+    am_mf=`$as_echo "$am_mf" | sed -e 's/:.*$//'`
+    # Check whether this is an Automake generated Makefile which includes
+    # dependency-tracking related rules and includes.
+    # Grep'ing the whole file directly is not great: AIX grep has a line
+    # limit of 2048, but all sed's we know have understand at least 4000.
+    sed -n 's,^am--depfiles:.*,X,p' "$am_mf" | grep X >/dev/null 2>&1 \
+      || continue
+    am_dirpart=`$as_dirname -- "$am_mf" ||
+$as_expr X"$am_mf" : 'X$.*^/$//*^/^/*/*$' \| \
+	 X"$am_mf" : 'X$//$^/' \| \
+	 X"$am_mf" : 'X$//$$' \| \
+	 X"$am_mf" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X"$am_mf" |
+    sed '/^X$.*^/$\/\/*^/^/*\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$^/.*/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    am_filepart=`$as_basename -- "$am_mf" ||
+$as_expr X/"$am_mf" : '.*/$^/^/*$/*$' \| \
+	 X"$am_mf" : 'X$//$$' \| \
+	 X"$am_mf" : 'X$/$' \| . 2>/dev/null ||
+$as_echo X/"$am_mf" |
+    sed '/^.*\/$^/^/*$\/*$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/\/$$/{
+	    s//\1/
+	    q
+	  }
+	  /^X\/$\/$.*/{
+	    s//\1/
+	    q
+	  }
+	  s/.*/./; q'`
+    { echo "$as_me:$LINENO: cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles" >&5
+   (cd "$am_dirpart" \
+      && sed -e '/# am--include-marker/d' "$am_filepart" \
+        | $MAKE -f - am--depfiles) >&5 2>&5
+   ac_status=$?
+   echo "$as_me:$LINENO: \$? = $ac_status" >&5
+   (exit $ac_status); } || am_rc=$?
+  done
+  if test $am_rc -ne 0; then
+    { { $as_echo "$as_me:${as_lineno-$LINENO}: error: in \`$ac_pwd':" >&5
+$as_echo "$as_me: error: in \`$ac_pwd':" >&2;}
+as_fn_error $? "Something went wrong bootstrapping makefile fragments
+    for automatic dependency tracking.  Try re-running configure with the
+    '--disable-dependency-tracking' option to at least be able to build
+    the package (albeit without support for automatic dependency tracking).
+See \`config.log' for more details" "$LINENO" 5; }
+  fi
+  { am_dirpart=; unset am_dirpart;}
+  { am_filepart=; unset am_filepart;}
+  { am_mf=; unset am_mf;}
+  { am_rc=; unset am_rc;}
+  rm -f conftest-deps.mk
+}
+ ;;
+    "libtool":C)
+
+    # See if we are running on zsh, and set the options that allow our
+    # commands through without removal of \ escapes.
+    if test -n "${ZSH_VERSION+set}"; then
+      setopt NO_GLOB_SUBST
+    fi
+
+    cfgfile=${ofile}T
+    trap "$RM \"$cfgfile\"; exit 1" 1 2 15
+    $RM "$cfgfile"
+
+    cat <<_LT_EOF >> "$cfgfile"
+#! $SHELL
+# Generated automatically by $as_me ($PACKAGE) $VERSION
+# NOTE: Changes made to this file will be lost: look at ltmain.sh.
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+# The names of the tagged configurations supported by this script.
+available_tags='CXX '
+
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
+# ### BEGIN LIBTOOL CONFIG
+
+# Whether or not to build shared libraries.
+build_libtool_libs=$enable_shared
+
+# Which release of libtool.m4 was used?
+macro_version=$macro_version
+macro_revision=$macro_revision
+
+# Whether or not to build static libraries.
+build_old_libs=$enable_static
+
+# What type of objects to build.
+pic_mode=$pic_mode
+
+# Whether or not to optimize for fast installation.
+fast_install=$enable_fast_install
+
+# Shared archive member basename,for filename based shared library versioning on AIX.
+shared_archive_member_spec=$shared_archive_member_spec
+
+# Shell to use when invoking shell scripts.
+SHELL=$lt_SHELL
+
+# An echo program that protects backslashes.
+ECHO=$lt_ECHO
+
+# The PATH separator for the build system.
+PATH_SEPARATOR=$lt_PATH_SEPARATOR
+
+# The host system.
+host_alias=$host_alias
+host=$host
+host_os=$host_os
+
+# The build system.
+build_alias=$build_alias
+build=$build
+build_os=$build_os
+
+# A sed program that does not truncate output.
+SED=$lt_SED
+
+# Sed that helps us avoid accidentally triggering echo(1) options like -n.
+Xsed="\$SED -e 1s/^X//"
+
+# A grep program that handles long lines.
+GREP=$lt_GREP
+
+# An ERE matcher.
+EGREP=$lt_EGREP
+
+# A literal string matcher.
+FGREP=$lt_FGREP
+
+# A BSD- or MS-compatible name lister.
+NM=$lt_NM
+
+# Whether we need soft or hard links.
+LN_S=$lt_LN_S
+
+# What is the maximum length of a command?
+max_cmd_len=$max_cmd_len
+
+# Object file suffix (normally "o").
+objext=$ac_objext
+
+# Executable file suffix (normally "").
+exeext=$exeext
+
+# whether the shell understands "unset".
+lt_unset=$lt_unset
+
+# turn spaces into newlines.
+SP2NL=$lt_lt_SP2NL
+
+# turn newlines into spaces.
+NL2SP=$lt_lt_NL2SP
+
+# convert \$build file names to \$host format.
+to_host_file_cmd=$lt_cv_to_host_file_cmd
+
+# convert \$build files to toolchain format.
+to_tool_file_cmd=$lt_cv_to_tool_file_cmd
+
+# An object symbol dumper.
+OBJDUMP=$lt_OBJDUMP
+
+# Method to check whether dependent libraries are shared objects.
+deplibs_check_method=$lt_deplibs_check_method
+
+# Command to use when deplibs_check_method = "file_magic".
+file_magic_cmd=$lt_file_magic_cmd
+
+# How to find potential files when deplibs_check_method = "file_magic".
+file_magic_glob=$lt_file_magic_glob
+
+# Find potential files using nocaseglob when deplibs_check_method = "file_magic".
+want_nocaseglob=$lt_want_nocaseglob
+
+# DLL creation program.
+DLLTOOL=$lt_DLLTOOL
+
+# Command to associate shared and link libraries.
+sharedlib_from_linklib_cmd=$lt_sharedlib_from_linklib_cmd
+
+# The archiver.
+AR=$lt_AR
+
+# Flags to create an archive.
+AR_FLAGS=$lt_AR_FLAGS
+
+# How to feed a file listing to the archiver.
+archiver_list_spec=$lt_archiver_list_spec
+
+# A symbol stripping program.
+STRIP=$lt_STRIP
+
+# Commands used to install an old-style archive.
+RANLIB=$lt_RANLIB
+old_postinstall_cmds=$lt_old_postinstall_cmds
+old_postuninstall_cmds=$lt_old_postuninstall_cmds
+
+# Whether to use a lock for old archive extraction.
+lock_old_archive_extraction=$lock_old_archive_extraction
+
+# A C compiler.
+LTCC=$lt_CC
+
+# LTCC compiler flags.
+LTCFLAGS=$lt_CFLAGS
+
+# Take the output of nm and produce a listing of raw symbols and C names.
+global_symbol_pipe=$lt_lt_cv_sys_global_symbol_pipe
+
+# Transform the output of nm in a proper C declaration.
+global_symbol_to_cdecl=$lt_lt_cv_sys_global_symbol_to_cdecl
+
+# Transform the output of nm into a list of symbols to manually relocate.
+global_symbol_to_import=$lt_lt_cv_sys_global_symbol_to_import
+
+# Transform the output of nm in a C name address pair.
+global_symbol_to_c_name_address=$lt_lt_cv_sys_global_symbol_to_c_name_address
+
+# Transform the output of nm in a C name address pair when lib prefix is needed.
+global_symbol_to_c_name_address_lib_prefix=$lt_lt_cv_sys_global_symbol_to_c_name_address_lib_prefix
+
+# The name lister interface.
+nm_interface=$lt_lt_cv_nm_interface
+
+# Specify filename containing input files for \$NM.
+nm_file_list_spec=$lt_nm_file_list_spec
+
+# The root where to search for dependent libraries,and where our libraries should be installed.
+lt_sysroot=$lt_sysroot
+
+# Command to truncate a binary pipe.
+lt_truncate_bin=$lt_lt_cv_truncate_bin
+
+# The name of the directory that contains temporary libtool files.
+objdir=$objdir
+
+# Used to examine libraries when file_magic_cmd begins with "file".
+MAGIC_CMD=$MAGIC_CMD
+
+# Must we lock files when doing compilation?
+need_locks=$lt_need_locks
+
+# Manifest tool.
+MANIFEST_TOOL=$lt_MANIFEST_TOOL
+
+# Tool to manipulate archived DWARF debug symbol files on Mac OS X.
+DSYMUTIL=$lt_DSYMUTIL
+
+# Tool to change global to local symbols on Mac OS X.
+NMEDIT=$lt_NMEDIT
+
+# Tool to manipulate fat objects and archives on Mac OS X.
+LIPO=$lt_LIPO
+
+# ldd/readelf like tool for Mach-O binaries on Mac OS X.
+OTOOL=$lt_OTOOL
+
+# ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
+OTOOL64=$lt_OTOOL64
+
+# Old archive suffix (normally "a").
+libext=$libext
+
+# Shared library suffix (normally ".so").
+shrext_cmds=$lt_shrext_cmds
+
+# The commands to extract the exported symbol list from a shared archive.
+extract_expsyms_cmds=$lt_extract_expsyms_cmds
+
+# Variables whose values should be saved in libtool wrapper scripts and
+# restored at link time.
+variables_saved_for_relink=$lt_variables_saved_for_relink
+
+# Do we need the "lib" prefix for modules?
+need_lib_prefix=$need_lib_prefix
+
+# Do we need a version for libraries?
+need_version=$need_version
+
+# Library versioning type.
+version_type=$version_type
+
+# Shared library runtime path variable.
+runpath_var=$runpath_var
+
+# Shared library path variable.
+shlibpath_var=$shlibpath_var
+
+# Is shlibpath searched before the hard-coded library search path?
+shlibpath_overrides_runpath=$shlibpath_overrides_runpath
+
+# Format of library name prefix.
+libname_spec=$lt_libname_spec
+
+# List of archive names.  First name is the real one, the rest are links.
+# The last name is the one that the linker finds with -lNAME
+library_names_spec=$lt_library_names_spec
+
+# The coded name of the library, if different from the real name.
+soname_spec=$lt_soname_spec
+
+# Permission mode override for installation of shared libraries.
+install_override_mode=$lt_install_override_mode
+
+# Command to use after installation of a shared archive.
+postinstall_cmds=$lt_postinstall_cmds
+
+# Command to use after uninstallation of a shared archive.
+postuninstall_cmds=$lt_postuninstall_cmds
+
+# Commands used to finish a libtool library installation in a directory.
+finish_cmds=$lt_finish_cmds
+
+# As "finish_cmds", except a single script fragment to be evaled but
+# not shown.
+finish_eval=$lt_finish_eval
+
+# Whether we should hardcode library paths into libraries.
+hardcode_into_libs=$hardcode_into_libs
+
+# Compile-time system search path for libraries.
+sys_lib_search_path_spec=$lt_sys_lib_search_path_spec
+
+# Detected run-time system search path for libraries.
+sys_lib_dlsearch_path_spec=$lt_configure_time_dlsearch_path
+
+# Explicit LT_SYS_LIBRARY_PATH set during ./configure time.
+configure_time_lt_sys_library_path=$lt_configure_time_lt_sys_library_path
+
+# Whether dlopen is supported.
+dlopen_support=$enable_dlopen
+
+# Whether dlopen of programs is supported.
+dlopen_self=$enable_dlopen_self
+
+# Whether dlopen of statically linked programs is supported.
+dlopen_self_static=$enable_dlopen_self_static
+
+# Commands to strip libraries.
+old_striplib=$lt_old_striplib
+striplib=$lt_striplib
+
+
+# The linker used to build libraries.
+LD=$lt_LD
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag
+reload_cmds=$lt_reload_cmds
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds
+
+# A language specific compiler.
+CC=$lt_compiler
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds
+archive_expsym_cmds=$lt_archive_expsym_cmds
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds
+module_expsym_cmds=$lt_module_expsym_cmds
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects
+postdep_objects=$lt_postdep_objects
+predeps=$lt_predeps
+postdeps=$lt_postdeps
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path
+
+# ### END LIBTOOL CONFIG
+
+_LT_EOF
+
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR:DIR:"
+#       string "DIR DIR" will be prepended to VARIABLE
+# ":DIR:DIR"
+#       string "DIR DIR" will be appended to VARIABLE
+# "DIRP:DIRP::DIRA:DIRA"
+#       string "DIRP DIRP" will be prepended to VARIABLE and string
+#       "DIRA DIRA" will be appended to VARIABLE
+# "DIR:DIR"
+#       VARIABLE will be replaced by "DIR DIR"
+func_munge_path_list ()
+{
+    case x$2 in
+    x)
+        ;;
+    *:)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'` \$$1\"
+        ;;
+    x:*)
+        eval $1=\"\$$1 `$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval $1=\"\$$1\ `$ECHO $2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval $1=\"`$ECHO $2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \$$1\"
+        ;;
+    *)
+        eval $1=\"`$ECHO $2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+
+
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in $*""; do
+      case $cc_temp in
+        compile | *\\/compile | ccache | *\\/ccache ) ;;
+        distcc | *\\/distcc | purify | *\\/purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
+  case $host_os in
+  aix3*)
+    cat <<\_LT_EOF >> "$cfgfile"
+# AIX sometimes has problems with the GCC collect2 program.  For some
+# reason, if we set the COLLECT_NAMES environment variable, the problems
+# vanish in a puff of smoke.
+if test set != "${COLLECT_NAMES+set}"; then
+  COLLECT_NAMES=
+  export COLLECT_NAMES
+fi
+_LT_EOF
+    ;;
+  esac
+
+
+ltmain=$ac_aux_dir/ltmain.sh
+
+
+  # We use sed instead of cat because bash on DJGPP gets confused if
+  # if finds mixed CR/LF and LF-only lines.  Since sed operates in
+  # text mode, it properly converts lines to CR/LF.  This bash problem
+  # is reportedly fixed, but why not run on old versions too?
+  sed '$q' "$ltmain" >> "$cfgfile" \
+     || (rm -f "$cfgfile"; exit 1)
+
+   mv -f "$cfgfile" "$ofile" ||
+    (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
+  chmod +x "$ofile"
+
+
+    cat <<_LT_EOF >> "$ofile"
+
+# ### BEGIN LIBTOOL TAG CONFIG: CXX
+
+# The linker used to build libraries.
+LD=$lt_LD_CXX
+
+# How to create reloadable object files.
+reload_flag=$lt_reload_flag_CXX
+reload_cmds=$lt_reload_cmds_CXX
+
+# Commands used to build an old-style archive.
+old_archive_cmds=$lt_old_archive_cmds_CXX
+
+# A language specific compiler.
+CC=$lt_compiler_CXX
+
+# Is the compiler the GNU compiler?
+with_gcc=$GCC_CXX
+
+# Compiler flag to turn off builtin functions.
+no_builtin_flag=$lt_lt_prog_compiler_no_builtin_flag_CXX
+
+# Additional compiler flags for building library objects.
+pic_flag=$lt_lt_prog_compiler_pic_CXX
+
+# How to pass a linker flag through the compiler.
+wl=$lt_lt_prog_compiler_wl_CXX
+
+# Compiler flag to prevent dynamic linking.
+link_static_flag=$lt_lt_prog_compiler_static_CXX
+
+# Does compiler simultaneously support -c and -o options?
+compiler_c_o=$lt_lt_cv_prog_compiler_c_o_CXX
+
+# Whether or not to add -lc for building shared libraries.
+build_libtool_need_lc=$archive_cmds_need_lc_CXX
+
+# Whether or not to disallow shared libs when runtime libs are static.
+allow_libtool_libs_with_static_runtimes=$enable_shared_with_static_runtimes_CXX
+
+# Compiler flag to allow reflexive dlopens.
+export_dynamic_flag_spec=$lt_export_dynamic_flag_spec_CXX
+
+# Compiler flag to generate shared objects directly from archives.
+whole_archive_flag_spec=$lt_whole_archive_flag_spec_CXX
+
+# Whether the compiler copes with passing no objects directly.
+compiler_needs_object=$lt_compiler_needs_object_CXX
+
+# Create an old-style archive from a shared archive.
+old_archive_from_new_cmds=$lt_old_archive_from_new_cmds_CXX
+
+# Create a temporary old-style archive to link instead of a shared archive.
+old_archive_from_expsyms_cmds=$lt_old_archive_from_expsyms_cmds_CXX
+
+# Commands used to build a shared archive.
+archive_cmds=$lt_archive_cmds_CXX
+archive_expsym_cmds=$lt_archive_expsym_cmds_CXX
+
+# Commands used to build a loadable module if different from building
+# a shared archive.
+module_cmds=$lt_module_cmds_CXX
+module_expsym_cmds=$lt_module_expsym_cmds_CXX
+
+# Whether we are building with GNU ld or not.
+with_gnu_ld=$lt_with_gnu_ld_CXX
+
+# Flag that allows shared libraries with undefined symbols to be built.
+allow_undefined_flag=$lt_allow_undefined_flag_CXX
+
+# Flag that enforces no undefined symbols.
+no_undefined_flag=$lt_no_undefined_flag_CXX
+
+# Flag to hardcode \$libdir into a binary during linking.
+# This must work even if \$libdir does not exist
+hardcode_libdir_flag_spec=$lt_hardcode_libdir_flag_spec_CXX
+
+# Whether we need a single "-rpath" flag with a separated argument.
+hardcode_libdir_separator=$lt_hardcode_libdir_separator_CXX
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary.
+hardcode_direct=$hardcode_direct_CXX
+
+# Set to "yes" if using DIR/libNAME\$shared_ext during linking hardcodes
+# DIR into the resulting binary and the resulting library dependency is
+# "absolute",i.e impossible to change by setting \$shlibpath_var if the
+# library is relocated.
+hardcode_direct_absolute=$hardcode_direct_absolute_CXX
+
+# Set to "yes" if using the -LDIR flag during linking hardcodes DIR
+# into the resulting binary.
+hardcode_minus_L=$hardcode_minus_L_CXX
+
+# Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
+# into the resulting binary.
+hardcode_shlibpath_var=$hardcode_shlibpath_var_CXX
+
+# Set to "yes" if building a shared library automatically hardcodes DIR
+# into the library and all subsequent libraries and executables linked
+# against it.
+hardcode_automatic=$hardcode_automatic_CXX
+
+# Set to yes if linker adds runtime paths of dependent libraries
+# to runtime path list.
+inherit_rpath=$inherit_rpath_CXX
+
+# Whether libtool must link a program against all its dependency libraries.
+link_all_deplibs=$link_all_deplibs_CXX
+
+# Set to "yes" if exported symbols are required.
+always_export_symbols=$always_export_symbols_CXX
+
+# The commands to list exported symbols.
+export_symbols_cmds=$lt_export_symbols_cmds_CXX
+
+# Symbols that should not be listed in the preloaded symbols.
+exclude_expsyms=$lt_exclude_expsyms_CXX
+
+# Symbols that must always be exported.
+include_expsyms=$lt_include_expsyms_CXX
+
+# Commands necessary for linking programs (against libraries) with templates.
+prelink_cmds=$lt_prelink_cmds_CXX
+
+# Commands necessary for finishing linking programs.
+postlink_cmds=$lt_postlink_cmds_CXX
+
+# Specify filename containing input files.
+file_list_spec=$lt_file_list_spec_CXX
+
+# How to hardcode a shared library path into an executable.
+hardcode_action=$hardcode_action_CXX
+
+# The directories searched by this compiler when creating a shared library.
+compiler_lib_search_dirs=$lt_compiler_lib_search_dirs_CXX
+
+# Dependencies to place before and after the objects being linked to
+# create a shared library.
+predep_objects=$lt_predep_objects_CXX
+postdep_objects=$lt_postdep_objects_CXX
+predeps=$lt_predeps_CXX
+postdeps=$lt_postdeps_CXX
+
+# The library search path used internally by the compiler when linking
+# a shared library.
+compiler_lib_search_path=$lt_compiler_lib_search_path_CXX
+
+# ### END LIBTOOL TAG CONFIG: CXX
+_LT_EOF
+
+ ;;
+
+  esac
+done # for ac_tag
+
+
+as_fn_exit 0
+_ACEOF
+ac_clean_files=$ac_clean_files_save
+
+test $ac_write_fail = 0 ||
+  as_fn_error $? "write failure creating $CONFIG_STATUS" "$LINENO" 5
+
+
+# configure is writing to config.log, and then calls config.status.
+# config.status does its own redirection, appending to config.log.
+# Unfortunately, on DOS this fails, as config.log is still kept open
+# by configure, so config.status won't be able to write to it; its
+# output is simply discarded.  So we exec the FD to /dev/null,
+# effectively closing config.log, so it can be properly (re)opened and
+# appended to by config.status.  When coming back to configure, we
+# need to make the FD available again.
+if test "$no_create" != yes; then
+  ac_cs_success=:
+  ac_config_status_args=
+  test "$silent" = yes &&
+    ac_config_status_args="$ac_config_status_args --quiet"
+  exec 5>/dev/null
+  $SHELL $CONFIG_STATUS $ac_config_status_args || ac_cs_success=false
+  exec 5>>config.log
+  # Use ||, not &&, to avoid exiting from the if with $? = 1, which
+  # would make configure fail if this is the last instruction.
+  $ac_cs_success || as_fn_exit 1
+fi
+if test -n "$ac_unrecognized_opts" && test "$enable_option_checking" != no; then
+  { $as_echo "$as_me:${as_lineno-$LINENO}: WARNING: unrecognized options: $ac_unrecognized_opts" >&5
+$as_echo "$as_me: WARNING: unrecognized options: $ac_unrecognized_opts" >&2;}
+fi
+

_service:tar_scm:isl-0.24.tar.gz/interface/configure.ac Added

_service:tar_scm:isl-0.24.tar.gz/interface/cpp.cc Added

@@ -0,0 +1,1201 @@
+/*
+ * Copyright 2016, 2017 Tobias Grosser. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY TOBIAS GROSSER ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TOBIAS GROSSER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as
+ * representing official policies, either expressed or implied, of
+ * Tobias Grosser.
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "cpp.h"
+#include "isl_config.h"
+
+/* Determine the isl types from which the given class can be implicitly
+ * constructed using a unary constructor.
+ *
+ * Look through all constructors for implicit conversion constructors that take
+ * an isl type and add those types, along with the corresponding
+ * constructor argument.
+ */
+void cpp_generator::set_class_construction_types(isl_class &clazz)
+{
+	for (const auto &cons : clazz.constructors) {
+		ParmVarDecl *param;
+		QualType type;
+		std::string arg_type;
+
+		if (!is_implicit_conversion(Method(clazz, cons)))
+			continue;
+
+		param = cons->getParamDecl(0);
+		type = param->getOriginalType();
+		arg_type = extract_type(type);
+		clazz.construction_types.emplace(arg_type, param);
+	}
+}
+
+/* Determine the isl types from which any (proper) class can be constructed
+ * using a unary constructor.
+ */
+void cpp_generator::set_construction_types()
+{
+	for (auto &kvp : classes) {
+		auto &clazz = kvp.second;
+		set_class_construction_types(clazz);
+	}
+}
+
+/* Construct a generator for C++ bindings.
+ *
+ * The classes and methods are extracted by the constructor
+ * of the generator superclass.
+ *
+ * Additionally extract information about types
+ * that can be converted to a class and copy all methods
+ * from superclasses that can be converted to a given class
+ * to that class.
+ */
+cpp_generator::cpp_generator(SourceManager &SM,
+	set<RecordDecl *> &exported_types,
+	set<FunctionDecl *> exported_functions, set<FunctionDecl *> functions) :
+		generator(SM, exported_types, exported_functions, functions)
+{
+	set_construction_types();
+	copy_super_methods();
+}
+
+/* Copy the method called "name" described by "fd" from "super" to "clazz"
+ * with the distance to the original ancestor given by "depth".
+ *
+ * In particular, keep track of "fd" as well as the superclass
+ * from which it was copied and the distance to the original ancestor.
+ */
+static void copy_method(isl_class &clazz, const isl_class &super,
+	const std::string &name, FunctionDecl *fd, int depth)
+{
+	clazz.methodsname.insert(fd);
+	clazz.copied_from.emplace(fd, super);
+	clazz.copy_depth.emplace(fd, depth);
+}
+
+/* Do "fd1" and "fd2" have the same signature (ignoring the first argument
+ * which represents the object class on which the corresponding method
+ * gets called).
+ */
+static bool same_signature(FunctionDecl *fd1, FunctionDecl *fd2)
+{
+	int n1 = fd1->getNumParams();
+	int n2 = fd2->getNumParams();
+
+	if (n1 != n2)
+		return false;
+
+	for (int i = 1; i < n1; ++i) {
+		ParmVarDecl *p1 = fd1->getParamDecl(i);
+		ParmVarDecl *p2 = fd2->getParamDecl(i);
+
+		if (p1->getOriginalType() != p2->getOriginalType())
+			return false;
+	}
+
+	return true;
+}
+
+/* Return the distance between "clazz" and the ancestor
+ * from which "fd" got copied.
+ * If no distance was recorded, then the method has not been copied
+ * but appears in "clazz" itself and so the distance is zero.
+ */
+static int copy_depth(const isl_class &clazz, FunctionDecl *fd)
+{
+	if (clazz.copy_depth.count(fd) == 0)
+		return 0;
+	return clazz.copy_depth.at(fd);
+}
+
+/* Is the method derived from "fd", with method name "name" and
+ * with distance to the original ancestor "depth",
+ * overridden by a method already in "clazz"?
+ *
+ * A method is considered to have been overridden if there
+ * is a method with the same name in "clazz" that has the same signature and
+ * that comes from an ancestor closer to "clazz",
+ * where an ancestor is closer if the distance in the class hierarchy
+ * is smaller or the distance is the same and the ancestor appears
+ * closer in the declaration of the type (in which case it gets added first).
+ *
+ * If a method with the same signature has already been added,
+ * but it does not override the method derived from "fd",
+ * then this method is removed since it is overridden by "fd".
+ */
+static bool is_overridden(FunctionDecl *fd, isl_class &clazz,
+	const std::string &name, int depth)
+{
+	if (clazz.methods.count(name) == 0)
+		return false;
+
+	for (const auto &m : clazz.methods.at(name)) {
+		if (!same_signature(fd, m))
+			continue;
+		if (copy_depth(clazz, m) <= depth)
+			return true;
+		clazz.methodsname.erase(m);
+		return false;
+	}
+	return false;
+}
+
+/* Add the methods "methods" with method name "name" from "super" to "clazz"
+ * provided they have not been overridden by a method already in "clazz".
+ *
+ * Methods that are static in their original class are not copied.
+ */
+void cpp_generator::copy_methods(isl_class &clazz, const std::string &name,
+	const isl_class &super, const function_set &methods)
+{
+	for (auto fd : methods) {
+		int depth;
+
+		if (method2class(fd)->is_static(fd))
+			continue;
+		depth = copy_depth(super, fd) + 1;
+		if (is_overridden(fd, clazz, name, depth))
+			continue;
+		copy_method(clazz, super, name, fd, depth);
+	}
+}
+
+/* Add all methods from "super" to "clazz" that have not been overridden
+ * by a method already in "clazz".
+ *
+ * Look through all groups of methods with the same name.
+ */
+void cpp_generator::copy_super_methods(isl_class &clazz, const isl_class &super)
+{
+	for (const auto &kvp : super.methods) {
+		const auto &name = kvp.first;
+		const auto &methods = kvp.second;
+
+		copy_methods(clazz, name, super, methods);
+	}
+}
+
+/* Copy methods from the superclasses of "clazz"
+ * if an object of this class can be implicitly converted to an object
+ * from the superclass, keeping track
+ * of the classes that have already been handled in "done".
+ *
+ * Make sure the superclasses have copied methods from their superclasses first
+ * since those methods could be copied further down to this class.
+ *
+ * Consider the superclass that appears closest to the subclass first.
+ */
+void cpp_generator::copy_super_methods(isl_class &clazz, set<string> &done)
+{
+	auto supers = find_superclasses(clazz.type);
+
+	for (const auto &super : supers)
+		if (done.count(super) == 0)
+			copy_super_methods(classessuper, done);
+	done.insert(clazz.name);
+
+	for (const auto &super_name : supers) {
+		const auto &super = classessuper_name;
+
+		if (super.construction_types.count(clazz.name) == 0)
+			continue;
+		copy_super_methods(clazz, super);
+	}
+}
+
+/* For each (proper) class, copy methods from its superclasses,
+ * if an object from the class can be converted to an object
+ * from the superclass.
+ *
+ * Type based subclasses are not considered for now since
+ * they do not have any explicit superclasses.
+ *
+ * Iterate through all (proper) classes and copy methods
+ * from their superclasses,
+ * unless they have already been determined by a recursive call.
+ */
+void cpp_generator::copy_super_methods()
+{
+	set<string> done;
+
+	for (auto &kvp : classes) {
+		auto &clazz = kvp.second;
+
+		if (clazz.is_type_subclass())
+			continue;
+		if (done.count(clazz.name) != 0)
+			continue;
+		copy_super_methods(clazz, done);
+	}
+}
+
+/* Print declarations or implementations of constructors.
+ *
+ * For each isl function that is marked as __isl_constructor,
+ * add a corresponding C++ constructor.
+ *
+ * Example of declarations:
+ *
+ * 	inline /\* implicit *\/ union_set(basic_set bset);
+ * 	inline /\* implicit *\/ union_set(set set);
+ * 	inline explicit val(ctx ctx, long i);
+ * 	inline explicit val(ctx ctx, const std::string &str);
+ */
+void cpp_generator::class_printer::print_constructors()
+{
+	for (const auto &cons : clazz.constructors)
+		print_method(Method(clazz, cons));
+}
+
+/* Print declarations or definitions for methods in the class.
+ */
+void cpp_generator::class_printer::print_methods()
+{
+	for (const auto &kvp : clazz.methods)
+		print_method_group(kvp.second, kvp.first);
+}
+
+/* Print declarations or implementations for the methods derived from "fd",
+ * which sets an enum.
+ *
+ * A method is generated for each value in the enum, setting
+ * the enum to that value.
+ */
+void cpp_generator::class_printer::print_set_enums(FunctionDecl *fd)
+{
+	for (const auto &set : clazz.set_enums.at(fd)) {
+		EnumMethod method(clazz, fd, set.method_name, set.name);
+
+		print_method(method);
+	}
+}
+
+/* Print declarations or implementations for methods derived from functions
+ * that set an enum.
+ */
+void cpp_generator::class_printer::print_set_enums()
+{
+	for (const auto &kvp : clazz.set_enums)
+		print_set_enums(kvp.first);
+}
+
+/* Update "convert" to reflect the next combination of automatic conversions
+ * for the arguments of "fd",
+ * returning false if there are no more combinations.
+ *
+ * In particular, find the last argument for which an automatic
+ * conversion function is available mapping to the type of this argument and
+ * that is not already marked for conversion.
+ * Mark this argument, if any, for conversion and clear the markings
+ * of all subsequent arguments.
+ * Repeated calls to this method therefore run through
+ * all possible combinations.
+ *
+ * Note that the first function argument is never considered
+ * for automatic conversion since this is the argument
+ * from which the isl_ctx used in the conversion is extracted.
+ */
+bool cpp_generator::class_printer::next_variant(FunctionDecl *fd,
+	std::vector<bool> &convert)
+{
+	size_t n = convert.size();
+
+	for (int i = n - 1; i >= 1; --i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
+		const Type *type = param->getOriginalType().getTypePtr();
+
+		if (generator.conversions.count(type) == 0)
+			continue;
+		if (converti)
+			continue;
+		converti = true;
+		for (size_t j = i + 1; j < n; ++j)
+			convertj = false;
+		return true;
+	}
+
+	return false;
+}
+
+/* Print a declaration or definition for a method called "name"
+ * derived from "fd".
+ *
+ * If the method was copied from a superclass, then print a definition
+ * that calls the corresponding method in the superclass.
+ * Otherwise, for methods that are identified as "get" methods, also
+ * print a declaration or definition for the method
+ * using a name that includes the "get_" prefix.
+ *
+ * If the generated method is an object method, then check
+ * whether any of its arguments can be automatically converted
+ * from something else, and, if so, generate a method
+ * for each combination of converted arguments.
+ * Do so by constructing a ConversionMethod that changes the converted arguments
+ * to those of the sources of the conversions.
+ *
+ * Note that a method may be both copied from a superclass and
+ * have arguments that can be automatically converted.
+ * In this case, the conversion methods for the arguments
+ * call the corresponding method in this class, which
+ * in turn will call the method in the superclass.
+ */
+void cpp_generator::class_printer::print_method_variants(FunctionDecl *fd,
+	const std::string &name)
+{
+	Method method(clazz, fd, name);
+	std::vector<bool> convert(method.num_params());
+
+	if (method.clazz.copied_from.count(method.fd) == 0) {
+		print_method(method);
+		if (clazz.is_get_method(fd))
+			print_get_method(fd);
+	} else {
+		auto super = method.clazz.copied_from.at(method.fd);
+		print_method(ConversionMethod(method, super.name));
+	}
+	if (method.kind != Method::Kind::member_method)
+		return;
+	while (next_variant(fd, convert)) {
+		print_method(ConversionMethod(method, & (int pos) {
+			return get_param(fd, pos, convert);
+		}));
+	}
+}
+
+/* Given a function declaration representing a method,
+ * does this method have a single argument (beyond the object
+ * on which the method is called) that corresponds to
+ * an isl object?
+ */
+static bool has_single_isl_argument(FunctionDecl *fd)
+{
+	ParmVarDecl *param;
+
+	if (fd->getNumParams() != 2)
+		return false;
+
+	param = fd->getParamDecl(1);
+	return generator::is_isl_type(param->getOriginalType());
+}
+
+/* Does the set "methods" contain exactly one function declaration
+ * that corresponds to a method of "clazz" itself (i.e., that
+ * was not copied from an ancestor)?
+ */
+static FunctionDecl *single_local(const isl_class &clazz,
+	const function_set &methods)
+{
+	int count = 0;
+	FunctionDecl *local;
+
+	for (const auto &fn : methods) {
+		if (!clazz.first_arg_matches_class(fn))
+			continue;
+		++count;
+		local = fn;
+	}
+
+	return count == 1 ? local : NULL;
+}
+
+/* Given a function declaration "fd" for a method called "name"
+ * with a single argument representing an isl object,
+ * generate declarations or definitions for methods with the same name,
+ * but with as argument an isl object of a class that can be implicitly
+ * converted to that of the original argument.
+ * In particular, generate methods for converting this argument.
+ */
+void cpp_generator::class_printer::print_descendent_overloads(
+	FunctionDecl *fd, const std::string &name)
+{
+	Method method(clazz, fd, name);
+	ParmVarDecl *param = fd->getParamDecl(1);
+	QualType type = param->getOriginalType();
+	std::string arg = type->getPointeeType().getAsString();
+
+	for (const auto &kvp : generator.classesarg.construction_types) {
+		const auto sub = kvp.second;
+		print_method(ConversionMethod(method, & (int pos) {
+			return sub;
+		}));
+	}
+}
+
+/* Print declarations or definitions for methods called "name"
+ * derived from "methods".
+ *
+ * If want_descendent_overloads signals that variants should be added that take
+ * as arguments those types that can be converted to the original argument type
+ * through a unary constructor and if only one of the methods in the group
+ * was originally defined in "clazz", then effectively add those variants.
+ * Only do this for methods with a single (isl object) argument.
+ */
+void cpp_generator::class_printer::print_method_group(
+	const function_set &methods, const std::string &name)
+{
+	FunctionDecl *local;
+
+	for (const auto &fd : methods)
+		print_method_variants(fd, name);
+	if (!want_descendent_overloads(methods))
+		return;
+	local = single_local(clazz, methods);
+	if (!local)
+		return;
+	if (!has_single_isl_argument(local))
+		return;
+	print_descendent_overloads(local, name);
+}
+
+/* Print the use of the argument at position "pos" to "os".
+ *
+ * Member methods pass the isl object corresponding to "this"
+ * as first argument (at position 0).
+ * Any other arguments are passed along from the method arguments.
+ *
+ * If the argument value is loaded from a this pointer, the original
+ * value must be preserved and must consequently be copied.  Values that are
+ * loaded from method parameters do not need to be preserved, as such values
+ * will already be copies of the actual parameters.  It is consequently possible
+ * to directly take the pointer from these values, which saves
+ * an unnecessary copy.
+ *
+ * In case the parameter is a callback function, two parameters get printed,
+ * a wrapper for the callback function and a pointer to the actual
+ * callback function.  The wrapper is expected to be available
+ * in a previously declared variable <name>_lambda, while
+ * the actual callback function is expected to be stored
+ * in a structure called <name>_data.
+ * The caller of this function must ensure that these variables exist.
+ */
+void Method::print_param_use(ostream &os, int pos) const
+{
+	ParmVarDecl *param = fd->getParamDecl(pos);
+	bool load_from_this_ptr = pos == 0 && kind == member_method;
+	string name = param->getName().str();
+	QualType type = param->getOriginalType();
+
+	if (type->isIntegerType()) {
+		os << name;
+		return;
+	}
+
+	if (generator::is_string(type)) {
+		os << name << ".c_str()";
+		return;
+	}
+
+	if (generator::is_callback(type)) {
+		os << name << "_lambda, ";
+		os << "&" << name << "_data";
+		return;
+	}
+
+	if (!load_from_this_ptr)
+		os << name << ".";
+
+	if (generator::keeps(param)) {
+		os << "get()";
+	} else {
+		if (load_from_this_ptr)
+			os << "copy()";
+		else
+			os << "release()";
+	}
+}
+
+/* Does the isl function from which this method is derived
+ * modify an object of a subclass based on a type function?
+ */
+bool Method::is_subclass_mutator() const
+{
+	return clazz.is_type_subclass() && generator::is_mutator(clazz, fd);
+}
+
+/* Return the C++ return type of the method "method".
+ *
+ * If the corresponding function modifies an object of a subclass, then return
+ * the type of this subclass.
+ * Otherwise, return the C++ counterpart of the actual return type.
+ */
+std::string cpp_type_printer::return_type(const Method &method) const
+{
+	if (method.is_subclass_mutator())
+		return cpp_generator::type2cpp(method.clazz);
+	else
+		return param(-1, method.fd->getReturnType());
+}
+
+/* Return the formal parameter at position "pos" of "fd".
+ * However, if this parameter should be converted, as indicated
+ * by "convert", then return the second formal parameter
+ * of the conversion function instead.
+ */
+ParmVarDecl *cpp_generator::class_printer::get_param(FunctionDecl *fd,
+	int pos, const std::vector<bool> &convert)
+{
+	ParmVarDecl *param = fd->getParamDecl(pos);
+
+	if (!convertpos)
+		return param;
+	return generator.conversionsparam->getOriginalType().getTypePtr();
+}
+
+/* Print the header for "method", without newline or semicolon,
+ * using "type_printer" to print argument and return types.
+ *
+ * Print the header of a declaration if this->declarations is set,
+ * otherwise print the header of a method definition.
+ *
+ * This function prints headers for member methods, static methods, and
+ * constructors, either for their declaration or definition.
+ *
+ * Member functions are declared as "const", as they do not change the current
+ * object, but instead create a new object. They always retrieve the first
+ * parameter of the original isl function from the this-pointer of the object,
+ * such that only starting at the second parameter the parameters of the
+ * original function become part of the method's interface.
+ *
+ * A function
+ *
+ * 	__isl_give isl_set *isl_set_intersect(__isl_take isl_set *s1,
+ * 		__isl_take isl_set *s2);
+ *
+ * is translated into:
+ *
+ * 	inline set intersect(set set2) const
+ *
+ * For static functions and constructors all parameters of the original isl
+ * function are exposed.
+ *
+ * Parameters of which no copy is required, are passed
+ * as const reference, which allows the compiler to optimize the parameter
+ * transfer.
+ *
+ * Constructors are marked as explicit using the C++ keyword 'explicit' or as
+ * implicit using a comment in place of the explicit keyword. By annotating
+ * implicit constructors with a comment, users of the interface are made
+ * aware of the potential danger that implicit construction is possible
+ * for these constructors, whereas without a comment not every user would
+ * know that implicit construction is allowed in absence of an explicit keyword.
+ *
+ * Note that in case "method" is a ConversionMethod, the argument returned
+ * by Method::get_param may be different from the original argument.
+ * The name of the argument is, however, derived from the original
+ * function argument.
+ */
+void cpp_generator::class_printer::print_method_header(
+	const Method &method, const cpp_type_printer &type_printer)
+{
+	string rettype_str = type_printer.return_type(method);
+
+	if (declarations) {
+		os << "  ";
+
+		if (method.kind == Method::Kind::static_method)
+			os << "static ";
+
+		os << "inline ";
+
+		if (method.kind == Method::Kind::constructor) {
+			if (generator.is_implicit_conversion(method))
+				os << "/* implicit */ ";
+			else
+				os << "explicit ";
+		}
+	}
+
+	if (method.kind != Method::Kind::constructor)
+		os << rettype_str << " ";
+
+	if (!declarations)
+		os << type_printer.class_type(cppstring) << "::";
+
+	if (method.kind != Method::Kind::constructor)
+		os << method.name;
+	else
+		os << cppstring;
+
+	method.print_cpp_arg_list(os, & (int i) {
+		std::string name = method.fd->getParamDecl(i)->getName().str();
+		ParmVarDecl *param = method.get_param(i);
+		QualType type = param->getOriginalType();
+		string cpptype = type_printer.param(i, type);
+
+		if (!method.param_needs_copy(i))
+			os << "const " << cpptype << " &" << name;
+		else
+			os << cpptype << " " << name;
+	});
+
+	if (method.kind == Method::Kind::member_method)
+		os << " const";
+}
+
+/* Generate the list of argument types for a callback function of
+ * type "type", appearing in argument position "arg".
+ * If "cpp" is set, then generate the C++ type list, otherwise
+ * the C type list.
+ *
+ * For a callback of type
+ *
+ *      isl_stat (*)(__isl_take isl_map *map, void *user)
+ *
+ * the following C++ argument list is generated:
+ *
+ *      map
+ *
+ * The arguments of the callback are considered to appear
+ * after the position of the callback itself.
+ */
+std::string cpp_type_printer::generate_callback_args(int arg, QualType type,
+	bool cpp) const
+{
+	std::string type_str;
+	const FunctionProtoType *callback;
+	int num_params;
+
+	callback = generator::extract_prototype(type);
+	num_params = callback->getNumArgs();
+	if (cpp)
+		num_params--;
+
+	for (long i = 0; i < num_params; i++) {
+		QualType type = callback->getArgType(i);
+
+		if (cpp)
+			type_str += param(arg + 1 + i, type);
+		else
+			type_str += type.getAsString();
+
+		if (!cpp)
+			type_str += "arg_" + ::to_string(i);
+
+		if (i != num_params - 1)
+			type_str += ", ";
+	}
+
+	return type_str;
+}
+
+/* Generate the full cpp type of a callback function of type "type",
+ * appearing in argument position "arg".
+ *
+ * For a callback of type
+ *
+ *      isl_stat (*)(__isl_take isl_map *map, void *user)
+ *
+ * the following type is generated:
+ *
+ *      std::function<stat(map)>
+ */
+std::string cpp_type_printer::generate_callback_type(int arg, QualType type)
+	const
+{
+	std::string type_str;
+	const FunctionProtoType *callback = generator::extract_prototype(type);
+	QualType return_type = callback->getReturnType();
+	string rettype_str = param(arg, return_type);
+
+	type_str = "std::function<";
+	type_str += rettype_str;
+	type_str += "(";
+	type_str += generate_callback_args(arg, type, true);
+	type_str += ")>";
+
+	return type_str;
+}
+
+/* An array listing functions that must be renamed and the function name they
+ * should be renamed to. We currently rename functions in case their name would
+ * match a reserved C++ keyword, which is not allowed in C++.
+ */
+static const char *rename_map2 = {
+	{ "union", "unite" },
+};
+
+/* Rename method "name" in case the method name in the C++ bindings should not
+ * match the name in the C bindings. We do this for example to avoid
+ * C++ keywords.
+ */
+static std::string rename_method(std::string name)
+{
+	for (size_t i = 0; i < sizeof(rename_map) / sizeof(rename_map0); i++)
+		if (name.compare(rename_mapi0) == 0)
+			return rename_mapi1;
+
+	return name;
+}
+
+/* Translate isl class "clazz" to its corresponding C++ type.
+ * Use the name of the type based subclass, if any.
+ */
+string cpp_generator::type2cpp(const isl_class &clazz)
+{
+	return type2cpp(clazz.subclass_name);
+}
+
+/* Translate type string "type_str" to its C++ name counterpart.
+*/
+string cpp_generator::type2cpp(string type_str)
+{
+	return type_str.substr(4);
+}
+
+/* Return the C++ counterpart to the isl_bool type.
+ *
+ * By default, this is simply "bool" since
+ * the exceptional case is handled through exceptions.
+ */
+std::string cpp_type_printer::isl_bool() const
+{
+	return "bool";
+}
+
+/* Return the C++ counterpart to the isl_stat type.
+ *
+ * By default, this is simply "void" since
+ * the exceptional case is handled through exceptions.
+ */
+string cpp_type_printer::isl_stat() const
+{
+	return "void";
+}
+
+/* Return the C++ counterpart to the isl_size type.
+ *
+ * By default, this is simply "unsigned" since
+ * the exceptional case is handled through exceptions.
+ */
+string cpp_type_printer::isl_size() const
+{
+	return "unsigned";
+}
+
+/* Return the namespace of the generated C++ bindings.
+ *
+ * By default, this is "isl::".
+ */
+std::string cpp_type_printer::isl_namespace() const
+{
+	return "isl::";
+}
+
+/* Return the class type given the C++ name.
+ *
+ * By default, directly use the C++ name.
+ */
+std::string cpp_type_printer::class_type(const std::string &cpp_name) const
+{
+	return cpp_name;
+}
+
+/* Return the qualified form of the given C++ isl type name appearing
+ * in argument position "arg" (-1 for return type).
+ *
+ * By default, the argument position is ignored.
+ */
+std::string cpp_type_printer::qualified(int arg, const std::string &cpp_type)
+	const
+{
+	return isl_namespace() + cpp_type;
+}
+
+/* Return the C++ counterpart to the given isl type appearing
+ * in argument position "arg" (-1 for return type).
+ */
+std::string cpp_type_printer::isl_type(int arg, QualType type) const
+{
+	auto name = type->getPointeeType().getAsString();
+	return qualified(arg, cpp_generator::type2cpp(name));
+}
+
+/* Translate parameter or return type "type" to its C++ name counterpart.
+ * "arg" is the position of the argument, or -1 in case of the return type.
+ * If any callback is involved, then the return type and arguments types
+ * of the callback are considered to start at the position of the callback.
+ */
+std::string cpp_type_printer::param(int arg, QualType type) const
+{
+	if (cpp_generator::is_isl_type(type))
+		return isl_type(arg, type);
+
+	if (cpp_generator::is_isl_bool(type))
+		return isl_bool();
+
+	if (cpp_generator::is_isl_stat(type))
+		return isl_stat();
+
+	if (cpp_generator::is_isl_size(type))
+		return isl_size();
+
+	if (type->isIntegerType())
+		return type.getAsString();
+
+	if (cpp_generator::is_string(type))
+		return "std::string";
+
+	if (cpp_generator::is_callback(type))
+		return generate_callback_type(arg, type);
+
+	generator::die("Cannot convert type to C++ type");
+}
+
+/* Check if "subclass_type" is a subclass of "class_type".
+ */
+bool cpp_generator::is_subclass(QualType subclass_type,
+	const isl_class &class_type)
+{
+	std::string type_str = subclass_type->getPointeeType().getAsString();
+	std::vector<std::string> superclasses;
+	std::vector<const isl_class *> parents;
+	std::vector<std::string>::iterator ci;
+
+	superclasses = generator::find_superclasses(classestype_str.type);
+
+	for (ci = superclasses.begin(); ci < superclasses.end(); ci++)
+		parents.push_back(&classes*ci);
+
+	while (!parents.empty()) {
+		const isl_class *candidate = parents.back();
+
+		parents.pop_back();
+
+		if (&class_type == candidate)
+			return true;
+
+		superclasses = generator::find_superclasses(candidate->type);
+
+		for (ci = superclasses.begin(); ci < superclasses.end(); ci++)
+			parents.push_back(&classes*ci);
+	}
+
+	return false;
+}
+
+/* Check if "cons" is an implicit conversion constructor of class "clazz".
+ *
+ * An implicit conversion constructor is generated in case "cons" has a single
+ * parameter, where the parameter type is a subclass of the class that is
+ * currently being generated.
+ */
+bool cpp_generator::is_implicit_conversion(const Method &cons)
+{
+	const auto &clazz = cons.clazz;
+	ParmVarDecl *param = cons.fd->getParamDecl(0);
+	QualType type = param->getOriginalType();
+
+	int num_params = cons.fd->getNumParams();
+	if (num_params != 1)
+		return false;
+
+	if (is_isl_type(type) && !is_isl_ctx(type) && is_subclass(type, clazz))
+		return true;
+
+	return false;
+}
+
+/* Get kind of "method" in "clazz".
+ *
+ * Given the declaration of a static or member method, returns its kind.
+ */
+static Method::Kind get_kind(const isl_class &clazz, FunctionDecl *method)
+{
+	if (generator::is_constructor(method))
+		return Method::Kind::constructor;
+	else if (generator::is_static(clazz, method))
+		return Method::Kind::static_method;
+	else
+		return Method::Kind::member_method;
+}
+
+/* Return the callback argument of "fd", if there is any.
+ * Return NULL otherwise.
+ */
+static ParmVarDecl *find_callback_arg(FunctionDecl *fd)
+{
+	int num_params = fd->getNumParams();
+
+	for (int i = 0; i < num_params; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
+		if (generator::is_callback(param->getType()))
+			return param;
+	}
+
+	return NULL;
+}
+
+/* Construct a C++ method object from the class to which is belongs,
+ * the isl function from which it is derived and the method name.
+ *
+ * Perform any renaming of the method that may be required and
+ * determine the type of the method.
+ */
+Method::Method(const isl_class &clazz, FunctionDecl *fd,
+	const std::string &name) :
+		clazz(clazz), fd(fd), name(rename_method(name)),
+		kind(get_kind(clazz, fd)),
+		callback(find_callback_arg(fd))
+{
+}
+
+/* Construct a C++ method object from the class to which is belongs and
+ * the isl function from which it is derived.
+ *
+ * Obtain the default method name and continue
+ * with the generic constructor.
+ */
+Method::Method(const isl_class &clazz, FunctionDecl *fd) :
+	Method(clazz, fd, clazz.method_name(fd))
+{
+}
+
+/* Return the number of parameters of the corresponding C function.
+ *
+ * If the method has a callback argument, we reduce the number of parameters
+ * that are exposed by one to hide the user pointer from the interface. On
+ * the C++ side no user pointer is needed, as arguments can be forwarded
+ * as part of the std::function argument which specifies the callback function.
+ *
+ * The user pointer is also removed from the number of parameters
+ * of the C function because the pair of callback and user pointer
+ * is considered as a single argument that is printed as a whole
+ * by Method::print_param_use.
+ */
+int Method::c_num_params() const
+{
+	return fd->getNumParams() - (callback != NULL);
+}
+
+/* Return the number of parameters of the method
+ * (including the implicit "this").
+ *
+ * By default, it is the same as the number of parameters
+ * of the corresponding C function.
+ */
+int Method::num_params() const
+{
+	return c_num_params();
+}
+
+/* Print the arguments from "start" (inclusive) to "end" (exclusive)
+ * as arguments to a method of C function call, using "print_arg"
+ * to print each individual argument.
+ */
+void Method::print_arg_list(std::ostream &os, int start, int end,
+	const std::function<void(int i)> &print_arg)
+{
+	os << "(";
+	for (int i = start; i < end; ++i) {
+		if (i != start)
+			os << ", ";
+		print_arg(i);
+	}
+	os << ")";
+}
+
+/* Print the arguments to the method call, using "print_arg"
+ * to print each individual argument.
+ */
+void Method::print_cpp_arg_list(std::ostream &os,
+	const std::function<void(int i)> &print_arg) const
+{
+	int first_param = kind == member_method ? 1 : 0;
+	print_arg_list(os, first_param, num_params(), print_arg);
+}
+
+/* Should the parameter at position "pos" be a copy (rather than
+ * a const reference)?
+ *
+ * Strictly speaking, a copy is only needed on isl types that are
+ * not marked __isl_keep, since those will be release()'d
+ * by code printed by Method::print_param_use.
+ *
+ * However, there may be other arguments such as integer types
+ * that are more naturally passed as a copy.
+ * The default is therefore to require a copy, except for
+ * arguments marked __isl_keep, string arguments or callback arguments.
+ */
+bool Method::param_needs_copy(int pos) const
+{
+	ParmVarDecl *param = get_param(pos);
+	QualType type = param->getOriginalType();
+
+	if (generator::keeps(param))
+		return false;
+	if (generator::is_string(type) || generator::is_callback(type))
+		return false;
+	return true;
+}
+
+/* Return the method argument at position "pos".
+ */
+clang::ParmVarDecl *Method::get_param(int pos) const
+{
+	return fd->getParamDecl(pos);
+}
+
+/* Construct a method that performs one or more conversions
+ * from the original Method (without conversions),
+ * the name of the type to which "this" should be converted and
+ * a function for determining the arguments of the constructed method.
+ */
+ConversionMethod::ConversionMethod(const Method &method,
+	const std::string &this_type,
+	const std::function<clang::ParmVarDecl *(int pos)> &get_param) :
+		NoCopyMethod(method), this_type(this_type),
+		get_param_fn(get_param)
+{
+}
+
+/* Construct a method that only performs a conversion on "this"
+ * from the original Method (without conversions) and
+ * the name of the type to which "this" should be converted.
+ *
+ * Call the generic constructor with
+ * a function for determining the arguments of the constructed method
+ * that performs no conversion.
+ */
+ConversionMethod::ConversionMethod(const Method &method,
+	const std::string &this_type) :
+		ConversionMethod(method, this_type, this (int pos) {
+			return Method::get_param(pos);
+		})
+{
+}
+
+/* Construct a method that performs one or more argument conversions
+ * from the original Method (without conversions) and
+ * a function for determining the arguments of the constructed method.
+ *
+ * Call the generic constructor with method.clazz.name as "this" type,
+ * indicating that "this" should not be converted.
+ */
+ConversionMethod::ConversionMethod(const Method &method,
+	const std::function<clang::ParmVarDecl *(int pos)> &get_param) :
+		ConversionMethod(method, method.clazz.name, get_param)
+{
+}
+
+/* Should the parameter at position "pos" be a copy (rather than
+ * a const reference)?
+ *
+ * Parameters of isl type do not need to be a copy.
+ * For other types, use the same defaults as Method.
+ */
+bool NoCopyMethod::param_needs_copy(int pos) const
+{
+	ParmVarDecl *param = get_param(pos);
+	QualType type = param->getOriginalType();
+
+	if (generator::is_isl_type(type))
+		return false;
+
+	return Method::param_needs_copy(pos);
+}
+
+/* Return the method argument at position "pos".
+ *
+ * Call get_param_fn to determine this argument.
+ */
+clang::ParmVarDecl *ConversionMethod::get_param(int pos) const
+{
+	return get_param_fn(pos);
+}
+
+/* Print a call to the method (without the arguments),
+ * with "ns" the namespace of the generated C++ bindings.
+ *
+ * If "this_type" is different from the name of the class of the method,
+ * then "this" needs to be converted to that type before
+ * the call is performed.
+ */
+void ConversionMethod::print_call(std::ostream &os, const std::string &ns) const
+{
+	if (clazz.name == this_type) {
+		os << "this->";
+	} else {
+		auto cpp_type = ns + cpp_generator::type2cpp(this_type);
+		os << cpp_type << "(*this).";
+	}
+	os << name;
+}
+
+/* Construct an object representing a C++ method for setting an enum
+ * from the class to which is belongs,
+ * the isl function from which it is derived and the method and enum names.
+ */
+EnumMethod::EnumMethod(const isl_class &clazz, FunctionDecl *fd,
+	const std::string &method_name, const std::string &enum_name) :
+		Method(clazz, fd, method_name), enum_name(enum_name)
+{
+}
+
+/* Print the use of the argument at position "pos" to "os".
+ *
+ * If the position is beyond the number of method arguments,
+ * then it corresponds to the enum value corresponding to this EnumMethod.
+ * Otherwise, delegate to Method::print_param_use.
+ */
+void EnumMethod::print_param_use(ostream &os, int pos) const
+{
+	if (pos == num_params())
+		os << enum_name;
+	else
+		Method::print_param_use(os, pos);
+}
+
+/* Return the number of parameters of the method
+ * (including the implicit "this").
+ *
+ * The last argument of the C function does not appear in the method call,
+ * because it is replaced by a break-up into several methods.
+ */
+int EnumMethod::num_params() const
+{
+	return Method::num_params() - 1;
+}
+
+/* Initialize a class method printer from the stream onto which the methods
+ * are printed, the class method description and the C++ interface generator.
+ */
+cpp_generator::class_printer::class_printer(std::ostream &os,
+		const isl_class &clazz, cpp_generator &generator,
+		bool declarations) :
+	os(os), clazz(clazz), cppstring(type2cpp(clazz)), generator(generator),
+	declarations(declarations)
+{
+}

_service:tar_scm:isl-0.24.tar.gz/interface/cpp.h Added

@@ -0,0 +1,183 @@
+#ifndef ISL_INTERFACE_CPP_H
+#define ISL_INTERFACE_CPP_H
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include "generator.h"
+
+/* A generated C++ method derived from an isl function.
+ *
+ * "clazz" is the class to which the method belongs.
+ * "fd" is the original isl function.
+ * "name" is the name of the method, which may be different
+ * from the default name derived from "fd".
+ * "kind" is the type of the method.
+ * "callback" stores the callback argument, if any, or NULL.
+ */
+struct Method {
+	enum Kind {
+		static_method,
+		member_method,
+		constructor,
+	};
+
+	Method(const isl_class &clazz, FunctionDecl *fd,
+		const std::string &name);
+	Method(const isl_class &clazz, FunctionDecl *fd);
+
+	int c_num_params() const;
+	virtual int num_params() const;
+	virtual bool param_needs_copy(int pos) const;
+	virtual clang::ParmVarDecl *get_param(int pos) const;
+	virtual void print_param_use(ostream &os, int pos) const;
+	bool is_subclass_mutator() const;
+	static void print_arg_list(std::ostream &os, int start, int end,
+		const std::function<void(int i)> &print_arg);
+	void print_cpp_arg_list(std::ostream &os,
+		const std::function<void(int i)> &print_arg) const;
+
+	const isl_class &clazz;
+	FunctionDecl *const fd;
+	const std::string name;
+	const enum Kind kind;
+	ParmVarDecl *const callback;
+};
+
+/* A method that does not require its isl type parameters to be a copy.
+ */
+struct NoCopyMethod : Method {
+	NoCopyMethod(const Method &method) : Method(method) {}
+
+	virtual bool param_needs_copy(int pos) const override;
+};
+
+/* A generated method that performs one or more argument conversions and
+ * then calls the original method.
+ *
+ * A ConversionMethod inherits from a NoCopyMethod, because
+ * unlike methods that call an isl C function,
+ * a conversion method never calls release() on an isl type argument,
+ * so they can all be passed as const references.
+ *
+ * "this_type" is the name of the type to which "this" should be converted
+ * (if different from clazz.name).
+ * "get_param_fn" returns the method argument at position "pos".
+ */
+struct ConversionMethod : NoCopyMethod {
+	ConversionMethod(const Method &method, const std::string &this_type,
+		const std::function<clang::ParmVarDecl *(int pos)> &get_param);
+	ConversionMethod(const Method &method, const std::string &this_type);
+	ConversionMethod(const Method &method,
+		const std::function<clang::ParmVarDecl *(int pos)> &get_param);
+	virtual clang::ParmVarDecl *get_param(int pos) const override;
+
+	void print_call(std::ostream &os, const std::string &ns) const;
+
+	const std::string this_type;
+	const std::function<clang::ParmVarDecl *(int pos)> get_param_fn;
+};
+
+/* A specialized generated C++ method for setting an enum.
+ *
+ * "enum_name" is a string representation of the enum value
+ * set by this method.
+ */
+struct EnumMethod : public Method {
+	EnumMethod(const isl_class &clazz, FunctionDecl *fd,
+		const std::string &method_name, const std::string &enum_name);
+
+	virtual int num_params() const override;
+	virtual void print_param_use(ostream &os, int pos) const override;
+
+	std::string enum_name;
+};
+
+/* A type printer for converting argument and return types,
+ * as well as the class type,
+ * to string representations of the corresponding types
+ * in the C++ interface.
+ */
+struct cpp_type_printer {
+	cpp_type_printer() {}
+
+	virtual std::string isl_bool() const;
+	virtual std::string isl_stat() const;
+	virtual std::string isl_size() const;
+	virtual std::string isl_namespace() const;
+	virtual std::string class_type(const std::string &cpp_name) const;
+	virtual std::string qualified(int arg, const std::string &cpp_type)
+		const;
+	std::string isl_type(int arg, QualType type) const;
+	std::string generate_callback_args(int arg, QualType type, bool cpp)
+		const;
+	std::string generate_callback_type(int arg, QualType type) const;
+	std::string param(int arg, QualType type) const;
+	std::string return_type(const Method &method) const;
+};
+
+/* Generator for C++ bindings.
+ */
+class cpp_generator : public generator {
+protected:
+	struct class_printer;
+public:
+	cpp_generator(SourceManager &SM, set<RecordDecl *> &exported_types,
+		set<FunctionDecl *> exported_functions,
+		set<FunctionDecl *> functions);
+private:
+	void set_class_construction_types(isl_class &clazz);
+	void set_construction_types();
+	void copy_methods(isl_class &clazz, const std::string &name,
+		const isl_class &super, const function_set &methods);
+	void copy_super_methods(isl_class &clazz, const isl_class &super);
+	void copy_super_methods(isl_class &clazz, set<string> &done);
+	void copy_super_methods();
+	bool is_implicit_conversion(const Method &cons);
+	bool is_subclass(QualType subclass_type, const isl_class &class_type);
+public:
+	static string type2cpp(const isl_class &clazz);
+	static string type2cpp(string type_string);
+};
+
+/* A helper class for printing method declarations and definitions
+ * of a class.
+ *
+ * "os" is the stream onto which the methods are printed.
+ * "clazz" describes the methods of the class.
+ * "cppstring" is the C++ name of the class.
+ * "generator" is the C++ interface generator printing the classes.
+ * "declarations" is set if this object is used to print declarations.
+ */
+struct cpp_generator::class_printer {
+	std::ostream &os;
+	const isl_class &clazz;
+	const std::string cppstring;
+	cpp_generator &generator;
+	const bool declarations;
+
+	class_printer(std::ostream &os, const isl_class &clazz,
+			cpp_generator &generator, bool declarations);
+
+	void print_constructors();
+	void print_methods();
+	bool next_variant(FunctionDecl *fd, std::vector<bool> &convert);
+	void print_method_variants(FunctionDecl *fd, const std::string &name);
+	virtual bool want_descendent_overloads(const function_set &methods) = 0;
+	void print_descendent_overloads(FunctionDecl *fd,
+		const std::string &name);
+	void print_method_group(const function_set &methods,
+		const std::string &name);
+	virtual void print_method(const Method &method) = 0;
+	virtual void print_method(const ConversionMethod &method) = 0;
+	virtual void print_get_method(FunctionDecl *fd) = 0;
+	void print_set_enums(FunctionDecl *fd);
+	void print_set_enums();
+	ParmVarDecl *get_param(FunctionDecl *fd, int pos,
+		const std::vector<bool> &convert);
+	void print_method_header(const Method &method,
+		const cpp_type_printer &type_printer);
+};
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/interface/cpp_conversion.cc Added

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2018      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <stdio.h>
+#include <map>
+#include <string>
+
+#include "cpp.h"
+#include "cpp_conversion.h"
+
+/* If "clazz" describes a subclass of a C type, then print code
+ * for converting an object of the class derived from the C type
+ * to the subclass.  Do this by first converting this class
+ * to the immediate superclass of the subclass and then converting
+ * from this superclass to the subclass.
+ */
+void cpp_conversion_generator::cast(const isl_class &clazz, const char *to)
+{
+	string name = cpp_generator::type2cpp(clazz);
+
+	if (!clazz.is_type_subclass())
+		return;
+
+	cast(classesclazz.superclass_name, to);
+	printf(".as<%s%s>()", to, name.c_str());
+}
+
+/* Print a function called "function" for converting objects of
+ * "clazz" from the "from" bindings to the "to" bindings.
+ * If "clazz" describes a subclass of a C type, then the result
+ * of the conversion between bindings is derived from the C type and
+ * needs to be converted back to the subclass.
+ */
+void cpp_conversion_generator::convert(const isl_class &clazz,
+	const char *from, const char *to, const char *function)
+{
+	string name = cpp_generator::type2cpp(clazz);
+
+	printf("%s%s %s(%s%s obj) {\n",
+		to, name.c_str(), function, from, name.c_str());
+	printf("\t""return %s""manage(obj.copy())", to);
+	cast(clazz, to);
+	printf(";\n");
+	printf("}\n");
+	printf("\n");
+}
+
+/* Print functions for converting objects of "clazz"
+ * between the default and the checked C++ bindings.
+ *
+ * The conversion from default to checked is called "check".
+ * The inverse conversion is called "uncheck".
+ * For example, to "set", the following two functions are generated:
+ *
+ *	checked::set check(set obj) {
+ *		return checked::manage(obj.copy());
+ *	}
+ *
+ *	set uncheck(checked::set obj) {
+ *		return manage(obj.copy());
+ *	}
+ */
+void cpp_conversion_generator::print(const isl_class &clazz)
+{
+	convert(clazz, "", "checked::", "check");
+	convert(clazz, "checked::", "", "uncheck");
+}
+
+/* Generate conversion functions for converting objects between
+ * the default and the checked C++ bindings.
+ * Do this for each exported class.
+ */
+void cpp_conversion_generator::generate()
+{
+	map<string, isl_class>::iterator ci;
+
+	printf("namespace isl {\n\n");
+	for (ci = classes.begin(); ci != classes.end(); ++ci)
+		print(ci->second);
+	printf("} // namespace isl\n");
+}

_service:tar_scm:isl-0.24.tar.gz/interface/cpp_conversion.h Added

_service:tar_scm:isl-0.24.tar.gz/interface/depcomp Added

@@ -0,0 +1,791 @@
+#! /bin/sh
+# depcomp - compile a program generating dependencies as side-effects
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1999-2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# Originally written by Alexandre Oliva <oliva@dcc.unicamp.br>.
+
+case $1 in
+  '')
+    echo "$0: No command.  Try '$0 --help' for more information." 1>&2
+    exit 1;
+    ;;
+  -h | --h*)
+    cat <<\EOF
+Usage: depcomp --help --version PROGRAM ARGS
+
+Run PROGRAMS ARGS to compile a file, generating dependencies
+as side-effects.
+
+Environment variables:
+  depmode     Dependency tracking mode.
+  source      Source file read by 'PROGRAMS ARGS'.
+  object      Object file output by 'PROGRAMS ARGS'.
+  DEPDIR      directory where to store dependencies.
+  depfile     Dependency file to output.
+  tmpdepfile  Temporary file to use when outputting dependencies.
+  libtool     Whether libtool is used (yes/no).
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+    exit $?
+    ;;
+  -v | --v*)
+    echo "depcomp $scriptversion"
+    exit $?
+    ;;
+esac
+
+# Get the directory component of the given path, and save it in the
+# global variables '$dir'.  Note that this directory component will
+# be either empty or ending with a '/' character.  This is deliberate.
+set_dir_from ()
+{
+  case $1 in
+    */*) dir=`echo "$1" | sed -e 's|/^/*$|/|'`;;
+      *) dir=;;
+  esac
+}
+
+# Get the suffix-stripped basename of the given path, and save it the
+# global variable '$base'.
+set_base_from ()
+{
+  base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.^.*$//'`
+}
+
+# If no dependency file was actually created by the compiler invocation,
+# we still have to create a dummy depfile, to avoid errors with the
+# Makefile "include basename.Plo" scheme.
+make_dummy_depfile ()
+{
+  echo "#dummy" > "$depfile"
+}
+
+# Factor out some common post-processing of the generated depfile.
+# Requires the auxiliary global variable '$tmpdepfile' to be set.
+aix_post_process_depfile ()
+{
+  # If the compiler actually managed to produce a dependency file,
+  # post-process it.
+  if test -f "$tmpdepfile"; then
+    # Each line is of the form 'foo.o: dependency.h'.
+    # Do two passes, one to just change these to
+    #   $object: dependency.h
+    # and one to simply output
+    #   dependency.h:
+    # which is needed to avoid the deleted-header problem.
+    { sed -e "s,^.*\.$lower*:,$object:," < "$tmpdepfile"
+      sed -e "s,^.*\.$lower*:$tab *,," -e 's,$,:,' < "$tmpdepfile"
+    } > "$depfile"
+    rm -f "$tmpdepfile"
+  else
+    make_dummy_depfile
+  fi
+}
+
+# A tabulation character.
+tab='	'
+# A newline character.
+nl='
+'
+# Character ranges might be problematic outside the C locale.
+# These definitions help.
+upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ
+lower=abcdefghijklmnopqrstuvwxyz
+digits=0123456789
+alpha=${upper}${lower}
+
+if test -z "$depmode" || test -z "$source" || test -z "$object"; then
+  echo "depcomp: Variables source, object and depmode must be set" 1>&2
+  exit 1
+fi
+
+# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po.
+depfile=${depfile-`echo "$object" |
+  sed 's|^\\/*$|'${DEPDIR-.deps}'/&|;s|\.$^.*$$|.P\1|;s|Pobj$|Po|'`}
+tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.$^.*$$/.T\1/'`}
+
+rm -f "$tmpdepfile"
+
+# Avoid interferences from the environment.
+gccflag= dashmflag=
+
+# Some modes work just like other modes, but use different flags.  We
+# parameterize here, but still list the modes in the big case below,
+# to make depend.m4 easier to write.  Note that we *cannot* use a case
+# here, because this file can only contain one case statement.
+if test "$depmode" = hp; then
+  # HP compiler uses -M and no extra arg.
+  gccflag=-M
+  depmode=gcc
+fi
+
+if test "$depmode" = dashXmstdout; then
+  # This is just like dashmstdout with a different argument.
+  dashmflag=-xM
+  depmode=dashmstdout
+fi
+
+cygpath_u="cygpath -u -f -"
+if test "$depmode" = msvcmsys; then
+  # This is just like msvisualcpp but w/o cygpath translation.
+  # Just convert the backslash-escaped backslashes to single forward
+  # slashes to satisfy depend.m4
+  cygpath_u='sed s,\\\\,/,g'
+  depmode=msvisualcpp
+fi
+
+if test "$depmode" = msvc7msys; then
+  # This is just like msvc7 but w/o cygpath translation.
+  # Just convert the backslash-escaped backslashes to single forward
+  # slashes to satisfy depend.m4
+  cygpath_u='sed s,\\\\,/,g'
+  depmode=msvc7
+fi
+
+if test "$depmode" = xlc; then
+  # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information.
+  gccflag=-qmakedep=gcc,-MF
+  depmode=gcc
+fi
+
+case "$depmode" in
+gcc3)
+## gcc 3 implements dependency tracking that does exactly what
+## we want.  Yay!  Note: for some reason libtool 1.4 doesn't like
+## it if -MD -MP comes after the -MF stuff.  Hmm.
+## Unfortunately, FreeBSD c89 acceptance of flags depends upon
+## the command line argument order; so add the flags where they
+## appear in depend2.am.  Note that the slowdown incurred here
+## affects only configure: in makefiles, %FASTDEP% shortcuts this.
+  for arg
+  do
+    case $arg in
+    -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;;
+    *)  set fnord "$@" "$arg" ;;
+    esac
+    shift # fnord
+    shift # $arg
+  done
+  "$@"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  mv "$tmpdepfile" "$depfile"
+  ;;
+
+gcc)
+## Note that this doesn't just cater to obsosete pre-3.x GCC compilers.
+## but also to in-use compilers like IMB xlc/xlC and the HP C compiler.
+## (see the conditional assignment to $gccflag above).
+## There are various ways to get dependency output from gcc.  Here's
+## why we pick this rather obscure method:
+## - Don't want to use -MD because we'd like the dependencies to end
+##   up in a subdir.  Having to rename by hand is ugly.
+##   (We might end up doing this anyway to support other compilers.)
+## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like
+##   -MM, not -M (despite what the docs say).  Also, it might not be
+##   supported by the other compilers which use the 'gcc' depmode.
+## - Using -M directly means running the compiler twice (even worse
+##   than renaming).
+  if test -z "$gccflag"; then
+    gccflag=-MD,
+  fi
+  "$@" -Wp,"$gccflag$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The second -e expression handles DOS-style file names with drive
+  # letters.
+  sed -e 's/^^:*: / /' \
+      -e 's/^'$alpha':\/^:*: / /' < "$tmpdepfile" >> "$depfile"
+## This next piece of magic avoids the "deleted header file" problem.
+## The problem is that when a header file which appears in a .P file
+## is deleted, the dependency causes make to die (because there is
+## typically no way to rebuild the header).  We avoid this by adding
+## dummy dependencies for each header file.  Too bad gcc doesn't do
+## this for us directly.
+## Some versions of gcc put a space before the ':'.  On the theory
+## that the space means something, we add a space to the output as
+## well.  hp depmode also adds that space, but also prefixes the VPATH
+## to the object.  Take care to not repeat it in the output.
+## Some versions of the HPUX 10.20 sed can't process this invocation
+## correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+sgi)
+  if test "$libtool" = yes; then
+    "$@" "-Wp,-MDupdate,$tmpdepfile"
+  else
+    "$@" -MDupdate "$tmpdepfile"
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+
+  if test -f "$tmpdepfile"; then  # yes, the sourcefile depend on other files
+    echo "$object : \\" > "$depfile"
+    # Clip off the initial element (the dependent).  Don't try to be
+    # clever and replace this with sed code, as IRIX sed won't handle
+    # lines with more than a fixed number of characters (4096 in
+    # IRIX 6.2 sed, 8192 in IRIX 6.5).  We also remove comment lines;
+    # the IRIX cc adds comments like '#:fec' to the end of the
+    # dependency line.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \
+      | tr "$nl" ' ' >> "$depfile"
+    echo >> "$depfile"
+    # The second pass generates a dummy entry for each header file.
+    tr ' ' "$nl" < "$tmpdepfile" \
+      | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \
+      >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile"
+  ;;
+
+xlc)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+aix)
+  # The C for AIX Compiler uses -M and outputs the dependencies
+  # in a .u file.  In older versions, this file always lives in the
+  # current directory.  Also, the AIX compiler puts '$object:' at the
+  # start of each line; $object doesn't have directory information.
+  # Version 6 uses the directory in both cases.
+  set_dir_from "$object"
+  set_base_from "$object"
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$base.u
+    tmpdepfile3=$dir.libs/$base.u
+    "$@" -Wc,-M
+  else
+    tmpdepfile1=$dir$base.u
+    tmpdepfile2=$dir$base.u
+    tmpdepfile3=$dir$base.u
+    "$@" -M
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  aix_post_process_depfile
+  ;;
+
+tcc)
+  # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26
+  # FIXME: That version still under development at the moment of writing.
+  #        Make that this statement remains true also for stable, released
+  #        versions.
+  # It will wrap lines (doesn't matter whether long or short) with a
+  # trailing '\', as in:
+  #
+  #   foo.o : \
+  #    foo.c \
+  #    foo.h \
+  #
+  # It will put a trailing '\' even on the last line, and will use leading
+  # spaces rather than leading tabs (at least since its commit 0394caf7
+  # "Emit spaces for -MD").
+  "$@" -MD -MF "$tmpdepfile"
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'.
+  # We have to change lines of the first kind to '$object: \'.
+  sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile"
+  # And for each line of the second kind, we have to emit a 'dep.h:'
+  # dummy dependency, to avoid the deleted-header problem.
+  sed -n -e 's|^  *$.*$ *\\$|\1:|p' < "$tmpdepfile" >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+## The order of this option in the case statement is important, since the
+## shell code in configure will try each of these formats in the order
+## listed in this file.  A plain '-MD' option would be understood by many
+## compilers, so we must ensure this comes after the gcc and icc options.
+pgcc)
+  # Portland's C compiler understands '-MD'.
+  # Will always output deps to 'file.d' where file is the root name of the
+  # source file under compilation, even if file resides in a subdirectory.
+  # The object file name does not affect the name of the '.d' file.
+  # pgcc 10.2 will output
+  #    foo.o: sub/foo.c sub/foo.h
+  # and will wrap long lines using '\' :
+  #    foo.o: sub/foo.c ... \
+  #     sub/foo.h ... \
+  #     ...
+  set_dir_from "$object"
+  # Use the source, not the object, to determine the base name, since
+  # that's sadly what pgcc will do too.
+  set_base_from "$source"
+  tmpdepfile=$base.d
+
+  # For projects that build the same source file twice into different object
+  # files, the pgcc approach of using the *source* file root name can cause
+  # problems in parallel builds.  Use a locking strategy to avoid stomping on
+  # the same $tmpdepfile.
+  lockdir=$base.d-lock
+  trap "
+    echo '$0: caught signal, cleaning up...' >&2
+    rmdir '$lockdir'
+    exit 1
+  " 1 2 13 15
+  numtries=100
+  i=$numtries
+  while test $i -gt 0; do
+    # mkdir is a portable test-and-set.
+    if mkdir "$lockdir" 2>/dev/null; then
+      # This process acquired the lock.
+      "$@" -MD
+      stat=$?
+      # Release the lock.
+      rmdir "$lockdir"
+      break
+    else
+      # If the lock is being held by a different process, wait
+      # until the winning process is done or we timeout.
+      while test -d "$lockdir" && test $i -gt 0; do
+        sleep 1
+        i=`expr $i - 1`
+      done
+    fi
+    i=`expr $i - 1`
+  done
+  trap - 1 2 13 15
+  if test $i -le 0; then
+    echo "$0: failed to acquire lock after $numtries attempts" >&2
+    echo "$0: check lockdir '$lockdir'" >&2
+    exit 1
+  fi
+
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  # Each line is of the form `foo.o: dependent.h',
+  # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'.
+  # Do two passes, one to just change these to
+  # `$object: dependent.h' and one to simply `dependent.h:'.
+  sed "s,^^:*:,$object :," < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed 's,^^:*: $.*$$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+hp2)
+  # The "hp" stanza above does not work with aCC (C++) and HP's ia64
+  # compilers, which have integrated preprocessors.  The correct option
+  # to use with these is +Maked; it writes dependencies to a file named
+  # 'foo.d', which lands next to the object file, wherever that
+  # happens to be.
+  # Much of this is similar to the tru64 case; see comments there.
+  set_dir_from  "$object"
+  set_base_from "$object"
+  if test "$libtool" = yes; then
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir.libs/$base.d
+    "$@" -Wc,+Maked
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    "$@" +Maked
+  fi
+  stat=$?
+  if test $stat -ne 0; then
+     rm -f "$tmpdepfile1" "$tmpdepfile2"
+     exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  if test -f "$tmpdepfile"; then
+    sed -e "s,^.*\.$lower*:,$object:," "$tmpdepfile" > "$depfile"
+    # Add 'dependent.h:' lines.
+    sed -ne '2,${
+               s/^ *//
+               s/ \\*$//
+               s/$/:/
+               p
+             }' "$tmpdepfile" >> "$depfile"
+  else
+    make_dummy_depfile
+  fi
+  rm -f "$tmpdepfile" "$tmpdepfile2"
+  ;;
+
+tru64)
+  # The Tru64 compiler uses -MD to generate dependencies as a side
+  # effect.  'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'.
+  # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put
+  # dependencies in 'foo.d' instead, so we check for that too.
+  # Subdirectories are respected.
+  set_dir_from  "$object"
+  set_base_from "$object"
+
+  if test "$libtool" = yes; then
+    # Libtool generates 2 separate objects for the 2 libraries.  These
+    # two compilations output dependencies in $dir.libs/$base.o.d and
+    # in $dir$base.o.d.  We have to check for both files, because
+    # one of the two compilations can be disabled.  We should prefer
+    # $dir$base.o.d over $dir.libs/$base.o.d because the latter is
+    # automatically cleaned when .libs/ is deleted, while ignoring
+    # the former would cause a distcleancheck panic.
+    tmpdepfile1=$dir$base.o.d          # libtool 1.5
+    tmpdepfile2=$dir.libs/$base.o.d    # Likewise.
+    tmpdepfile3=$dir.libs/$base.d      # Compaq CCC V6.2-504
+    "$@" -Wc,-MD
+  else
+    tmpdepfile1=$dir$base.d
+    tmpdepfile2=$dir$base.d
+    tmpdepfile3=$dir$base.d
+    "$@" -MD
+  fi
+
+  stat=$?
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+    exit $stat
+  fi
+
+  for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3"
+  do
+    test -f "$tmpdepfile" && break
+  done
+  # Same post-processing that is required for AIX mode.
+  aix_post_process_depfile
+  ;;
+
+msvc7)
+  if test "$libtool" = yes; then
+    showIncludes=-Wc,-showIncludes
+  else
+    showIncludes=-showIncludes
+  fi
+  "$@" $showIncludes > "$tmpdepfile"
+  stat=$?
+  grep -v '^Note: including file: ' "$tmpdepfile"
+  if test $stat -ne 0; then
+    rm -f "$tmpdepfile"
+    exit $stat
+  fi
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  # The first sed program below extracts the file names and escapes
+  # backslashes for cygpath.  The second sed program outputs the file
+  # name when reading, but also accumulates all include files in the
+  # hold buffer in order to output them again at the end.  This only
+  # works with sed implementations that can handle large buffers.
+  sed < "$tmpdepfile" -n '
+/^Note: including file:  *$.*$/ {
+  s//\1/
+  s/\\/\\\\/g
+  p
+}' | $cygpath_u | sort -u | sed -n '
+s/ /\\ /g
+s/$.*$/'"$tab"'\1 \\/p
+s/.$.*$ \\/\1:/
+H
+$ {
+  s/.*/'"$tab"'/
+  G
+  p
+}' >> "$depfile"
+  echo >> "$depfile" # make sure the fragment doesn't end with a backslash
+  rm -f "$tmpdepfile"
+  ;;
+
+msvc7msys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+#nosideeffect)
+  # This comment above is used by automake to tell side-effect
+  # dependency tracking mechanisms from slower ones.
+
+dashmstdout)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout, regardless of -o.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  test -z "$dashmflag" && dashmflag=-M
+  # Require at least two characters before searching for ':'
+  # in the target name.  This is to cope with DOS-style filenames:
+  # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise.
+  "$@" $dashmflag |
+    sed "s|^$tab *^:$tab ^:^:*:$tab *|$object: |" > "$tmpdepfile"
+  rm -f "$depfile"
+  cat < "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process this sed invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  tr ' ' "$nl" < "$tmpdepfile" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+dashXmstdout)
+  # This case only exists to satisfy depend.m4.  It is never actually
+  # run, as this mode is specially recognized in the preamble.
+  exit 1
+  ;;
+
+makedepend)
+  "$@" || exit $?
+  # Remove any Libtool call
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+  # X makedepend
+  shift
+  cleared=no eat=no
+  for arg
+  do
+    case $cleared in
+    no)
+      set ""; shift
+      cleared=yes ;;
+    esac
+    if test $eat = yes; then
+      eat=no
+      continue
+    fi
+    case "$arg" in
+    -D*|-I*)
+      set fnord "$@" "$arg"; shift ;;
+    # Strip any option that makedepend may not understand.  Remove
+    # the object too, otherwise makedepend will parse it as a source file.
+    -arch)
+      eat=yes ;;
+    -*|$object)
+      ;;
+    *)
+      set fnord "$@" "$arg"; shift ;;
+    esac
+  done
+  obj_suffix=`echo "$object" | sed 's/^.*\././'`
+  touch "$tmpdepfile"
+  ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@"
+  rm -f "$depfile"
+  # makedepend may prepend the VPATH from the source file name to the object.
+  # No need to regex-escape $object, excess matching of '.' is harmless.
+  sed "s|^.*$$object *:$|\1|" "$tmpdepfile" > "$depfile"
+  # Some versions of the HPUX 10.20 sed can't process the last invocation
+  # correctly.  Breaking it into two sed invocations is a workaround.
+  sed '1,2d' "$tmpdepfile" \
+    | tr ' ' "$nl" \
+    | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \
+    | sed -e 's/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile" "$tmpdepfile".bak
+  ;;
+
+cpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  # Remove '-o $object'.
+  IFS=" "
+  for arg
+  do
+    case $arg in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    *)
+      set fnord "$@" "$arg"
+      shift # fnord
+      shift # $arg
+      ;;
+    esac
+  done
+
+  "$@" -E \
+    | sed -n -e '/^# 0-90-9* "$^"*$".*/ s:: \1 \\:p' \
+             -e '/^#line 0-90-9* "$^"*$".*/ s:: \1 \\:p' \
+    | sed '$ s: \\$::' > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  cat < "$tmpdepfile" >> "$depfile"
+  sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvisualcpp)
+  # Important note: in order to support this mode, a compiler *must*
+  # always write the preprocessed file to stdout.
+  "$@" || exit $?
+
+  # Remove the call to Libtool.
+  if test "$libtool" = yes; then
+    while test "X$1" != 'X--mode=compile'; do
+      shift
+    done
+    shift
+  fi
+
+  IFS=" "
+  for arg
+  do
+    case "$arg" in
+    -o)
+      shift
+      ;;
+    $object)
+      shift
+      ;;
+    "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI")
+        set fnord "$@"
+        shift
+        shift
+        ;;
+    *)
+        set fnord "$@" "$arg"
+        shift
+        shift
+        ;;
+    esac
+  done
+  "$@" -E 2>/dev/null |
+  sed -n '/^#line 0-90-9* "$^"*$"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile"
+  rm -f "$depfile"
+  echo "$object : \\" > "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^$.*$$/ s::'"$tab"'\1 \\:p' >> "$depfile"
+  echo "$tab" >> "$depfile"
+  sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^$.*$$/ s::\1\::p' >> "$depfile"
+  rm -f "$tmpdepfile"
+  ;;
+
+msvcmsys)
+  # This case exists only to let depend.m4 do its work.  It works by
+  # looking at the text of this script.  This case will never be run,
+  # since it is checked for above.
+  exit 1
+  ;;
+
+none)
+  exec "$@"
+  ;;
+
+*)
+  echo "Unknown depmode $depmode" 1>&2
+  exit 1
+  ;;
+esac
+
+exit 0
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:

_service:tar_scm:isl-0.14.tar.xz/interface/extract_interface.cc -> _service:tar_scm:isl-0.24.tar.gz/interface/extract_interface.cc Changed

@@ -32,20 +32,26 @@
  */ 
 
 #include "isl_config.h"
+#undef PACKAGE
 
 #include <assert.h>
 #include <iostream>
+#include <stdlib.h>
 #ifdef HAVE_ADT_OWNINGPTR_H
 #include <llvm/ADT/OwningPtr.h>
 #else
 #include <memory>
 #endif
+#ifdef HAVE_LLVM_OPTION_ARG_H
+#include <llvm/Option/Arg.h>
+#endif
 #include <llvm/Support/raw_ostream.h>
 #include <llvm/Support/CommandLine.h>
 #include <llvm/Support/Host.h>
 #include <llvm/Support/ManagedStatic.h>
 #include <clang/AST/ASTContext.h>
 #include <clang/AST/ASTConsumer.h>
+#include <clang/Basic/Builtins.h>
 #include <clang/Basic/FileSystemOptions.h>
 #include <clang/Basic/FileManager.h>
 #include <clang/Basic/TargetOptions.h>
@@ -64,16 +70,28 @@
 #include <clang/Frontend/TextDiagnosticPrinter.h>
 #include <clang/Frontend/Utils.h>
 #include <clang/Lex/HeaderSearch.h>
+#ifdef HAVE_LEX_PREPROCESSOROPTIONS_H
+#include <clang/Lex/PreprocessorOptions.h>
+#else
+#include <clang/Frontend/PreprocessorOptions.h>
+#endif
 #include <clang/Lex/Preprocessor.h>
 #include <clang/Parse/ParseAST.h>
 #include <clang/Sema/Sema.h>
 
 #include "extract_interface.h"
+#include "generator.h"
 #include "python.h"
+#include "plain_cpp.h"
+#include "cpp_conversion.h"
+#include "template_cpp.h"
 
 using namespace std;
 using namespace clang;
 using namespace clang::driver;
+#ifdef HAVE_LLVM_OPTION_ARG_H
+using namespace llvm::opt;
+#endif
 
 #ifdef HAVE_ADT_OWNINGPTR_H
 #define unique_ptr	llvm::OwningPtr
@@ -85,6 +103,11 @@
 			llvm::cl::desc("Header search path"),
 			llvm::cl::value_desc("path"), llvm::cl::Prefix);
 
+static llvm::cl::opt<string> OutputLanguage(llvm::cl::Required,
+	llvm::cl::ValueRequired, "language",
+	llvm::cl::desc("Bindings to generate"),
+	llvm::cl::value_desc("name"));
+
 static const char *ResourceDir =
 	CLANG_PREFIX "/lib/clang/" CLANG_VERSION_STRING;
 
@@ -117,12 +140,14 @@
 }
 
 /* Collect all types and functions that are annotated "isl_export"
- * in "types" and "function".
+ * in "exported_types" and "exported_function".  Collect all function
+ * declarations in "functions".
  *
  * We currently only consider single declarations.
  */
 struct MyASTConsumer : public ASTConsumer {
-	set<RecordDecl *> types;
+	set<RecordDecl *> exported_types;
+	set<FunctionDecl *> exported_functions;
 	set<FunctionDecl *> functions;
 
 	virtual HandleTopLevelDeclReturn HandleTopLevelDecl(DeclGroupRef D) {
@@ -131,14 +156,16 @@
 		if (!D.isSingleDecl())
 			return HandleTopLevelDeclContinue;
 		decl = D.getSingleDecl();
+		if (isa<FunctionDecl>(decl))
+			functions.insert(cast<FunctionDecl>(decl));
 		if (!is_exported(decl))
 			return HandleTopLevelDeclContinue;
 		switch (decl->getKind()) {
 		case Decl::Record:
-			types.insert(cast<RecordDecl>(decl));
+			exported_types.insert(cast<RecordDecl>(decl));
 			break;
 		case Decl::Function:
-			functions.insert(cast<FunctionDecl>(decl));
+			exported_functions.insert(cast<FunctionDecl>(decl));
 			break;
 		default:
 			break;
@@ -174,6 +201,63 @@
 }
 #endif
 
+namespace clang { namespace driver { class Job; } }
+
+/* Clang changed its API from 3.5 to 3.6 and once more in 3.7.
+ * We fix this with a simple overloaded function here.
+ */
+struct ClangAPI {
+	static Job *command(Job *J) { return J; }
+	static Job *command(Job &J) { return &J; }
+	static Command *command(Command &C) { return &C; }
+};
+
+#ifdef CREATE_FROM_ARGS_TAKES_ARRAYREF
+
+/* Call CompilerInvocation::CreateFromArgs with the right arguments.
+ * In this case, an ArrayRef<const char *>.
+ */
+static void create_from_args(CompilerInvocation &invocation,
+	const ArgStringList *args, DiagnosticsEngine &Diags)
+{
+	CompilerInvocation::CreateFromArgs(invocation, *args, Diags);
+}
+
+#else
+
+/* Call CompilerInvocation::CreateFromArgs with the right arguments.
+ * In this case, two "const char *" pointers.
+ */
+static void create_from_args(CompilerInvocation &invocation,
+	const ArgStringList *args, DiagnosticsEngine &Diags)
+{
+	CompilerInvocation::CreateFromArgs(invocation, args->data() + 1,
+						args->data() + args->size(),
+						Diags);
+}
+
+#endif
+
+#ifdef CLANG_SYSROOT
+/* Set sysroot if required.
+ *
+ * If CLANG_SYSROOT is defined, then set it to this value.
+ */
+static void set_sysroot(ArgStringList &args)
+{
+	args.push_back("-isysroot");
+	args.push_back(CLANG_SYSROOT);
+}
+#else
+/* Set sysroot if required.
+ *
+ * If CLANG_SYSROOT is not defined, then it does not need to be set.
+ */
+static void set_sysroot(ArgStringList &args)
+{
+}
+#endif
+
 /* Create a CompilerInvocation object that stores the command line
  * arguments constructed by the driver.
  * The arguments are mainly useful for setting up the system include
@@ -191,16 +275,15 @@
 		driver->BuildCompilation(llvm::ArrayRef<const char *>(Argv)));
 	JobList &Jobs = compilation->getJobs();
 
-	Command *cmd = cast<Command>(*Jobs.begin());
+	Command *cmd = cast<Command>(ClangAPI::command(*Jobs.begin()));
 	if (strcmp(cmd->getCreator().getName(), "clang"))
 		return NULL;
 
-	const ArgStringList *args = &cmd->getArguments();
+	ArgStringList args = cmd->getArguments();
+	set_sysroot(args);
 
 	CompilerInvocation *invocation = new CompilerInvocation;
-	CompilerInvocation::CreateFromArgs(*invocation, args->data() + 1,
-						args->data() + args->size(),
-						Diags);
+	create_from_args(*invocation, &args, Diags);
 	return invocation;
 }
 
@@ -297,13 +380,21 @@
 
 #ifdef ADDPATH_TAKES_4_ARGUMENTS
 
+/* Add "Path" to the header search options.
+ *
+ * Do not take into account sysroot, i.e., set ignoreSysRoot to true.
+ */
 void add_path(HeaderSearchOptions &HSO, string Path)
 {
-	HSO.AddPath(Path, frontend::Angled, false, false);
+	HSO.AddPath(Path, frontend::Angled, false, true);
 }
 
 #else
 
+/* Add "Path" to the header search options.
+ *
+ * Do not take into account sysroot, i.e., set IsSysRootRelative to false.
+ */
 void add_path(HeaderSearchOptions &HSO, string Path)
 {
 	HSO.AddPath(Path, frontend::Angled, true, false, false);
@@ -328,6 +419,118 @@
 
 #endif
 
+#ifdef SETLANGDEFAULTS_TAKES_5_ARGUMENTS
+
+#include "set_lang_defaults_arg4.h"
+
+static void set_lang_defaults(CompilerInstance *Clang)
+{
+	PreprocessorOptions &PO = Clang->getPreprocessorOpts();
+	TargetOptions &TO = Clang->getTargetOpts();
+	llvm::Triple T(TO.Triple);
+	CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C, T,
+					    setLangDefaultsArg4(PO),
+					    LangStandard::lang_unspecified);
+}
+
+#else
+
+static void set_lang_defaults(CompilerInstance *Clang)
+{
+	CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
+					    LangStandard::lang_unspecified);
+}
+
+#endif
+
+#ifdef SETINVOCATION_TAKES_SHARED_PTR
+
+static void set_invocation(CompilerInstance *Clang,
+	CompilerInvocation *invocation)
+{
+	Clang->setInvocation(std::make_shared<CompilerInvocation>(*invocation));
+}
+
+#else
+
+static void set_invocation(CompilerInstance *Clang,
+	CompilerInvocation *invocation)
+{
+	Clang->setInvocation(invocation);
+}
+
+#endif
+
+/* Helper function for ignore_error that only gets enabled if T
+ * (which is either const FileEntry * or llvm::ErrorOr<const FileEntry *>)
+ * has getError method, i.e., if it is llvm::ErrorOr<const FileEntry *>.
+ */
+template <class T>
+static const FileEntry *ignore_error_helper(const T obj, int,
+	int1sizeof(obj.getError()))
+{
+	return *obj;
+}
+
+/* Helper function for ignore_error that is always enabled,
+ * but that only gets selected if the variant above is not enabled,
+ * i.e., if T is const FileEntry *.
+ */
+template <class T>
+static const FileEntry *ignore_error_helper(const T obj, long, void *)
+{
+	return obj;
+}
+
+/* Given either a const FileEntry * or a llvm::ErrorOr<const FileEntry *>,
+ * extract out the const FileEntry *.
+ */
+template <class T>
+static const FileEntry *ignore_error(const T obj)
+{
+	return ignore_error_helper(obj, 0, NULL);
+}
+
+/* Return the FileEntry corresponding to the given file name
+ * in the given compiler instances, ignoring any error.
+ */
+static const FileEntry *getFile(CompilerInstance *Clang, std::string Filename)
+{
+	return ignore_error(Clang->getFileManager().getFile(Filename));
+}
+
+/* Create an interface generator for the selected language and
+ * then use it to generate the interface.
+ */
+static void generate(MyASTConsumer &consumer, SourceManager &SM)
+{
+	generator *gen;
+
+	if (OutputLanguage.compare("python") == 0) {
+		gen = new python_generator(SM, consumer.exported_types,
+			consumer.exported_functions, consumer.functions);
+	} else if (OutputLanguage.compare("cpp") == 0) {
+		gen = new plain_cpp_generator(SM, consumer.exported_types,
+			consumer.exported_functions, consumer.functions);
+	} else if (OutputLanguage.compare("cpp-checked") == 0) {
+		gen = new plain_cpp_generator(SM, consumer.exported_types,
+			consumer.exported_functions, consumer.functions, true);
+	} else if (OutputLanguage.compare("cpp-checked-conversion") == 0) {
+		gen = new cpp_conversion_generator(SM, consumer.exported_types,
+			consumer.exported_functions, consumer.functions);
+	} else if (OutputLanguage.compare("template-cpp") == 0) {
+		gen = new template_cpp_generator(SM, consumer.exported_types,
+			consumer.exported_functions, consumer.functions);
+	} else {
+		cerr << "Language '" << OutputLanguage
+		     << "' not recognized." << endl
+		     << "Not generating bindings." << endl;
+		exit(EXIT_FAILURE);
+	}
+
+	gen->generate();
+}
+
 int main(int argc, char *argv)
 {
 	llvm::cl::ParseCommandLineOptions(argc, argv);
@@ -336,37 +539,39 @@
 	create_diagnostics(Clang);
 	DiagnosticsEngine &Diags = Clang->getDiagnostics();
 	Diags.setSuppressSystemWarnings(true);
+	TargetInfo *target = create_target_info(Clang, Diags);
+	Clang->setTarget(target);
+	set_lang_defaults(Clang);
 	CompilerInvocation *invocation =
 		construct_invocation(InputFilename.c_str(), Diags);
 	if (invocation)
-		Clang->setInvocation(invocation);
+		set_invocation(Clang, invocation);
 	Clang->createFileManager();
 	Clang->createSourceManager(Clang->getFileManager());
-	TargetInfo *target = create_target_info(Clang, Diags);
-	Clang->setTarget(target);
-	CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
-					    LangStandard::lang_unspecified);
 	HeaderSearchOptions &HSO = Clang->getHeaderSearchOpts();
 	LangOptions &LO = Clang->getLangOpts();
 	PreprocessorOptions &PO = Clang->getPreprocessorOpts();
 	HSO.ResourceDir = ResourceDir;
 
-	for (int i = 0; i < Includes.size(); ++i)
+	for (llvm::cl::list<string>::size_type i = 0; i < Includes.size(); ++i)
 		add_path(HSO, Includesi);
 
 	PO.addMacroDef("__isl_give=__attribute__((annotate(\"isl_give\")))");
 	PO.addMacroDef("__isl_keep=__attribute__((annotate(\"isl_keep\")))");
 	PO.addMacroDef("__isl_take=__attribute__((annotate(\"isl_take\")))");
 	PO.addMacroDef("__isl_export=__attribute__((annotate(\"isl_export\")))");
+	PO.addMacroDef("__isl_overload="
+	    "__attribute__((annotate(\"isl_overload\"))) "
+	    "__attribute__((annotate(\"isl_export\")))");
 	PO.addMacroDef("__isl_constructor=__attribute__((annotate(\"isl_constructor\"))) __attribute__((annotate(\"isl_export\")))");
 	PO.addMacroDef("__isl_subclass(super)=__attribute__((annotate(\"isl_subclass(\" #super \")\"))) __attribute__((annotate(\"isl_export\")))");
 
 	create_preprocessor(Clang);
 	Preprocessor &PP = Clang->getPreprocessor();
 
-	PP.getBuiltinInfo().InitializeBuiltins(PP.getIdentifierTable(), LO);
+	PP.getBuiltinInfo().initializeBuiltins(PP.getIdentifierTable(), LO);
 
-	const FileEntry *file = Clang->getFileManager().getFile(InputFilename);
+	const FileEntry *file = getFile(Clang, InputFilename);
 	assert(file);
 	create_main_file_id(Clang->getSourceManager(), file);
 
@@ -378,11 +583,13 @@
 	ParseAST(*sema);
 	Diags.getClient()->EndSourceFile();
 
-	generate_python(consumer.types, consumer.functions);
+	generate(consumer, Clang->getSourceManager());
 
 	delete sema;
 	delete Clang;
 	llvm::llvm_shutdown();
 
-	return 0;
+	if (Diags.hasErrorOccurred())
+		return EXIT_FAILURE;
+	return EXIT_SUCCESS;
 }

_service:tar_scm:isl-0.24.tar.gz/interface/generator.cc Added

@@ -0,0 +1,871 @@
+/*
+ * Copyright 2011,2015 Sven Verdoolaege. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY SVEN VERDOOLAEGE ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SVEN VERDOOLAEGE OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as
+ * representing official policies, either expressed or implied, of
+ * Sven Verdoolaege.
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <algorithm>
+#include <iostream>
+
+#include <clang/AST/Attr.h>
+#include <clang/Basic/SourceManager.h>
+
+#include "isl_config.h"
+#include "extract_interface.h"
+#include "generator.h"
+
+const char *isl_class::get_prefix = "get_";
+const char *isl_class::set_callback_prefix = "set_";
+
+/* Is the first argument an instance of the class?
+ */
+bool isl_class::first_arg_matches_class(FunctionDecl *method) const
+{
+	ParmVarDecl *param;
+	QualType type;
+
+	if (method->getNumParams() < 1)
+		return false;
+
+	param = method->getParamDecl(0);
+	type = param->getOriginalType();
+	if (!generator::is_isl_type(type))
+		return false;
+	return generator::extract_type(type) == name;
+}
+
+/* Should "method" be considered to be a static method?
+ * That is, is the first argument something other than
+ * an instance of the class?
+ *
+ * If this method was copied from a superclass, then check
+ * whether the method is static with respect to this superclass.
+ */
+bool isl_class::is_static(FunctionDecl *method) const
+{
+	if (copied_from.count(method) != 0)
+		return copied_from.at(method).is_static(method);
+	return !first_arg_matches_class(method);
+}
+
+/* Should "method" be considered to be a static method?
+ * That is, is the first argument something other than
+ * an instance of the class?
+ */
+bool generator::is_static(const isl_class &clazz, FunctionDecl *method)
+{
+	return clazz.is_static(method);
+}
+
+/* Does "fd" modify an object of "clazz"?
+ * That is, is it an object method that takes the object and
+ * returns (gives) an object of the same type?
+ */
+bool generator::is_mutator(const isl_class &clazz, FunctionDecl *fd)
+{
+	ParmVarDecl *param;
+	QualType type, return_type;
+
+	if (fd->getNumParams() < 1)
+		return false;
+	if (is_static(clazz, fd))
+		return false;
+
+	if (!gives(fd))
+		return false;
+	param = fd->getParamDecl(0);
+	if (!takes(param))
+		return false;
+	type = param->getOriginalType();
+	return_type = fd->getReturnType();
+	return return_type == type;
+}
+
+/* Find the FunctionDecl with name "name",
+ * returning NULL if there is no such FunctionDecl.
+ * If "required" is set, then error out if no FunctionDecl can be found.
+ */
+FunctionDecl *generator::find_by_name(const string &name, bool required)
+{
+	map<string, FunctionDecl *>::iterator i;
+
+	i = functions_by_name.find(name);
+	if (i != functions_by_name.end())
+		return i->second;
+	if (required)
+		die("No " + name + " function found");
+	return NULL;
+}
+
+/* List of conversion functions that are used to automatically convert
+ * the second argument of the conversion function to its function result.
+ */
+const std::set<std::string> generator::automatic_conversion_functions = {
+	"isl_id_read_from_str",
+	"isl_val_int_from_si",
+};
+
+/* Extract information about the automatic conversion function "fd",
+ * storing the results in this->conversions.
+ *
+ * A function used for automatic conversion has exactly two arguments,
+ * an isl_ctx and a non-isl object, and it returns an isl object.
+ * Store a mapping from the isl object return type
+ * to the non-isl object source type.
+ */
+void generator::extract_automatic_conversion(FunctionDecl *fd)
+{
+	QualType return_type = fd->getReturnType();
+	const Type *type = return_type.getTypePtr();
+
+	if (fd->getNumParams() != 2)
+		die("Expecting two arguments");
+	if (!is_isl_ctx(fd->getParamDecl(0)->getOriginalType()))
+		die("Expecting isl_ctx first argument");
+	if (!is_isl_type(return_type))
+		die("Expecting isl object return type");
+	conversionstype = fd->getParamDecl(1);
+}
+
+/* Extract information about all automatic conversion functions
+ * for the given class, storing the results in this->conversions.
+ *
+ * In particular, look through all exported constructors for the class and
+ * check if any of them is explicitly marked as a conversion function.
+ */
+void generator::extract_class_automatic_conversions(const isl_class &clazz)
+{
+	const function_set &constructors = clazz.constructors;
+	function_set::iterator fi;
+
+	for (fi = constructors.begin(); fi != constructors.end(); ++fi) {
+		FunctionDecl *fd = *fi;
+		string name = fd->getName().str();
+		if (automatic_conversion_functions.count(name) != 0)
+			extract_automatic_conversion(fd);
+	}
+}
+
+/* Extract information about all automatic conversion functions,
+ * storing the results in this->conversions.
+ */
+void generator::extract_automatic_conversions()
+{
+	map<string, isl_class>::iterator ci;
+
+	for (ci = classes.begin(); ci != classes.end(); ++ci)
+		extract_class_automatic_conversions(ci->second);
+}
+
+/* Add a subclass derived from "decl" called "sub_name" to the set of classes,
+ * keeping track of the _to_str, _copy and _free functions, if any, separately.
+ * "sub_name" is either the name of the class itself or
+ * the name of a type based subclass.
+ * If the class is a proper subclass, then "super_name" is the name
+ * of its immediate superclass.
+ */
+void generator::add_subclass(RecordDecl *decl, const string &super_name,
+	const string &sub_name)
+{
+	string name = decl->getName().str();
+
+	classessub_name.name = name;
+	classessub_name.superclass_name = super_name;
+	classessub_name.subclass_name = sub_name;
+	classessub_name.type = decl;
+	classessub_name.fn_to_str = find_by_name(name + "_to_str", false);
+	classessub_name.fn_copy = find_by_name(name + "_copy", true);
+	classessub_name.fn_free = find_by_name(name + "_free", true);
+}
+
+/* Add a class derived from "decl" to the set of classes,
+ * keeping track of the _to_str, _copy and _free functions, if any, separately.
+ */
+void generator::add_class(RecordDecl *decl)
+{
+	return add_subclass(decl, "", decl->getName().str());
+}
+
+/* Given a function "fn_type" that returns the subclass type
+ * of a C object, create subclasses for each of the (non-negative)
+ * return values.
+ *
+ * The function "fn_type" is also stored in the superclass,
+ * along with all pairs of type values and subclass names.
+ */
+void generator::add_type_subclasses(FunctionDecl *fn_type)
+{
+	QualType return_type = fn_type->getReturnType();
+	const EnumType *enum_type = return_type->getAs<EnumType>();
+	EnumDecl *decl = enum_type->getDecl();
+	isl_class *c = method2class(fn_type);
+	DeclContext::decl_iterator i;
+
+	c->fn_type = fn_type;
+	for (i = decl->decls_begin(); i != decl->decls_end(); ++i) {
+		EnumConstantDecl *ecd = dyn_cast<EnumConstantDecl>(*i);
+		int val = (int) ecd->getInitVal().getSExtValue();
+		string name = ecd->getNameAsString();
+
+		if (val < 0)
+			continue;
+		c->type_subclassesval = name;
+		add_subclass(c->type, c->subclass_name, name);
+	}
+}
+
+/* Add information about the enum values in "decl", set by "fd",
+ * to c->set_enums. "prefix" is the prefix of the generated method names.
+ * In particular, it has the name of the enum type removed.
+ *
+ * In particular, for each non-negative enum value, keep track of
+ * the value, the name and the corresponding method name.
+ */
+static void add_set_enum(isl_class *c, const string &prefix, EnumDecl *decl,
+	FunctionDecl *fd)
+{
+	DeclContext::decl_iterator i;
+
+	for (i = decl->decls_begin(); i != decl->decls_end(); ++i) {
+		EnumConstantDecl *ecd = dyn_cast<EnumConstantDecl>(*i);
+		int val = (int) ecd->getInitVal().getSExtValue();
+		string name = ecd->getNameAsString();
+		string method_name;
+
+		if (val < 0)
+			continue;
+		method_name = prefix + name.substr(4);
+		c->set_enumsfd.push_back(set_enum(val, name, method_name));
+	}
+}
+
+/* Check if "fd" sets an enum value and, if so, add information
+ * about the enum values to c->set_enums.
+ *
+ * A function is considered to set an enum value if:
+ * - the function returns an object of the same type
+ * - the last argument is of type enum
+ * - the name of the function ends with the name of the enum
+ */
+static bool handled_sets_enum(isl_class *c, FunctionDecl *fd)
+{
+	unsigned n;
+	ParmVarDecl *param;
+	const EnumType *enum_type;
+	EnumDecl *decl;
+	string enum_name;
+	string fd_name;
+	string prefix;
+	size_t pos;
+
+	if (!generator::is_mutator(*c, fd))
+		return false;
+	n = fd->getNumParams();
+	if (n < 2)
+		return false;
+	param = fd->getParamDecl(n - 1);
+	enum_type = param->getType()->getAs<EnumType>();
+	if (!enum_type)
+		return false;
+	decl = enum_type->getDecl();
+	enum_name = decl->getName().str();
+	enum_name = enum_name.substr(4);
+	fd_name = c->method_name(fd);
+	pos = fd_name.find(enum_name);
+	if (pos == std::string::npos)
+		return false;
+	prefix = fd_name.substr(0, pos);
+
+	add_set_enum(c, prefix, decl, fd);
+
+	return true;
+}
+
+/* Return the callback argument of a function setting
+ * a persistent callback.
+ * This callback is in the second argument (position 1).
+ */
+ParmVarDecl *generator::persistent_callback_arg(FunctionDecl *fd)
+{
+	return fd->getParamDecl(1);
+}
+
+/* Does the given function set a persistent callback?
+ * The following heuristics are used to determine this property:
+ * - the function returns an object of the same type
+ * - its name starts with "set_"
+ * - it has exactly three arguments
+ * - the second (position 1) of which is a callback
+ */
+static bool sets_persistent_callback(isl_class *c, FunctionDecl *fd)
+{
+	ParmVarDecl *param;
+
+	if (!generator::is_mutator(*c, fd))
+		return false;
+	if (fd->getNumParams() != 3)
+		return false;
+	param = generator::persistent_callback_arg(fd);
+	if (!generator::is_callback(param->getType()))
+		return false;
+	return prefixcmp(c->method_name(fd).c_str(),
+			 c->set_callback_prefix) == 0;
+}
+
+/* Does this function take any enum arguments?
+ */
+static bool takes_enums(FunctionDecl *fd)
+{
+	unsigned n;
+
+	n = fd->getNumParams();
+	for (unsigned i = 0; i < n; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
+		if (param->getType()->getAs<EnumType>())
+			return true;
+	}
+	return false;
+}
+
+/* Sorting function that places declaration of functions
+ * with a shorter name first.
+ */
+static bool less_name(const FunctionDecl *a, const FunctionDecl *b)
+{
+	return a->getName().size() < b->getName().size();
+}
+
+/* Collect all functions that belong to a certain type, separating
+ * constructors from methods that set an enum value,
+ * methods that set a persistent callback and
+ * from regular methods, while keeping track of the _to_str,
+ * _copy and _free functions, if any, separately.
+ * Methods that accept any enum arguments that are not specifically handled
+ * are not supported.
+ * If there are any overloaded
+ * functions, then they are grouped based on their name after removing the
+ * argument type suffix.
+ * Check for functions that describe subclasses before considering
+ * any other functions in order to be able to detect those other
+ * functions as belonging to the subclasses.
+ * Sort the names of the functions based on their lengths
+ * to ensure that nested subclasses are handled later.
+ *
+ * Also extract information about automatic conversion functions.
+ */
+generator::generator(SourceManager &SM, set<RecordDecl *> &exported_types,
+	set<FunctionDecl *> exported_functions, set<FunctionDecl *> functions) :
+	SM(SM)
+{
+	set<FunctionDecl *>::iterator in;
+	set<RecordDecl *>::iterator it;
+	vector<FunctionDecl *> type_subclasses;
+	vector<FunctionDecl *>::iterator iv;
+
+	for (in = functions.begin(); in != functions.end(); ++in) {
+		FunctionDecl *decl = *in;
+		functions_by_namedecl->getName().str() = decl;
+	}
+
+	for (it = exported_types.begin(); it != exported_types.end(); ++it)
+		add_class(*it);
+
+	for (in = exported_functions.begin(); in != exported_functions.end();
+	     ++in) {
+		if (is_subclass(*in))
+			type_subclasses.push_back(*in);
+	}
+	std::sort(type_subclasses.begin(), type_subclasses.end(), &less_name);
+	for (iv = type_subclasses.begin(); iv != type_subclasses.end(); ++iv) {
+		add_type_subclasses(*iv);
+	}
+
+	for (in = exported_functions.begin(); in != exported_functions.end();
+	     ++in) {
+		FunctionDecl *method = *in;
+		isl_class *c;
+
+		if (is_subclass(method))
+			continue;
+
+		c = method2class(method);
+		if (!c)
+			continue;
+		if (is_constructor(method)) {
+			c->constructors.insert(method);
+		} else if (handled_sets_enum(c, method)) {
+		} else if (sets_persistent_callback(c, method)) {
+			c->persistent_callbacks.insert(method);
+		} else if (takes_enums(method)) {
+			std::string name = method->getName().str();
+			die(name + " has unhandled enum argument");
+		} else {
+			string name = c->method_name(method);
+			c->methodsname.insert(method);
+		}
+	}
+
+	extract_automatic_conversions();
+}
+
+/* Print error message "msg" and abort.
+ */
+void generator::die(const char *msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	abort();
+}
+
+/* Print error message "msg" and abort.
+ */
+void generator::die(string msg)
+{
+	die(msg.c_str());
+}
+
+/* Return a sequence of the types of which the given type declaration is
+ * marked as being a subtype.
+ * The order of the types is the opposite of the order in which they
+ * appear in the source.  In particular, the first annotation
+ * is the one that is closest to the annotated type and the corresponding
+ * type is then also the first that will appear in the sequence of types.
+ * This is also the order in which the annotations appear
+ * in the AttrVec returned by Decl::getAttrs() in older versions of clang.
+ * In newer versions of clang, the order is that in which
+ * the attribute appears in the source.
+ * Use the position of the "isl_export" attribute to determine
+ * whether this is an old (with reversed order) or a new version.
+ * The "isl_export" attribute is automatically added
+ * after each "isl_subclass" attribute.  If it appears in the list before
+ * any "isl_subclass" is encountered, then this must be a reversed list.
+ */
+std::vector<string> generator::find_superclasses(Decl *decl)
+{
+	vector<string> super;
+	bool reversed = false;
+
+	if (!decl->hasAttrs())
+		return super;
+
+	string sub = "isl_subclass";
+	size_t len = sub.length();
+	AttrVec attrs = decl->getAttrs();
+	for (AttrVec::const_iterator i = attrs.begin(); i != attrs.end(); ++i) {
+		const AnnotateAttr *ann = dyn_cast<AnnotateAttr>(*i);
+		if (!ann)
+			continue;
+		string s = ann->getAnnotation().str();
+		if (s == "isl_export" && super.size() == 0)
+			reversed = true;
+		if (s.substr(0, len) == sub) {
+			s = s.substr(len + 1, s.length() - len  - 2);
+			if (reversed)
+				super.push_back(s);
+			else
+				super.insert(super.begin(), s);
+		}
+	}
+
+	return super;
+}
+
+/* Is "decl" marked as describing subclasses?
+ */
+bool generator::is_subclass(FunctionDecl *decl)
+{
+	return find_superclasses(decl).size() > 0;
+}
+
+/* Is decl marked as being part of an overloaded method?
+ */
+bool generator::is_overload(Decl *decl)
+{
+	return has_annotation(decl, "isl_overload");
+}
+
+/* Is decl marked as a constructor?
+ */
+bool generator::is_constructor(Decl *decl)
+{
+	return has_annotation(decl, "isl_constructor");
+}
+
+/* Is decl marked as consuming a reference?
+ */
+bool generator::takes(Decl *decl)
+{
+	return has_annotation(decl, "isl_take");
+}
+
+/* Is decl marked as preserving a reference?
+ */
+bool generator::keeps(Decl *decl)
+{
+	return has_annotation(decl, "isl_keep");
+}
+
+/* Is decl marked as returning a reference that is required to be freed.
+ */
+bool generator::gives(Decl *decl)
+{
+	return has_annotation(decl, "isl_give");
+}
+
+/* Return the class that has a name that best matches the initial part
+ * of the name of function "fd" or NULL if no such class could be found.
+ */
+isl_class *generator::method2class(FunctionDecl *fd)
+{
+	string best;
+	map<string, isl_class>::iterator ci;
+	string name = fd->getNameAsString();
+
+	for (ci = classes.begin(); ci != classes.end(); ++ci) {
+		size_t len = ci->first.length();
+		if (len > best.length() && name.substr(0, len) == ci->first &&
+		    namelen == '_')
+			best = ci->first;
+	}
+
+	if (classes.find(best) == classes.end()) {
+		cerr << "Unable to find class of " << name << endl;
+		return NULL;
+	}
+
+	return &classesbest;
+}
+
+/* Is "type" the type "isl_ctx *"?
+ */
+bool generator::is_isl_ctx(QualType type)
+{
+	if (!type->isPointerType())
+		return false;
+	type = type->getPointeeType();
+	if (type.getAsString() != "isl_ctx")
+		return false;
+
+	return true;
+}
+
+/* Is the first argument of "fd" of type "isl_ctx *"?
+ */
+bool generator::first_arg_is_isl_ctx(FunctionDecl *fd)
+{
+	ParmVarDecl *param;
+
+	if (fd->getNumParams() < 1)
+		return false;
+
+	param = fd->getParamDecl(0);
+	return is_isl_ctx(param->getOriginalType());
+}
+
+namespace {
+
+struct ClangAPI {
+	/* Return the first location in the range returned by
+	 * clang::SourceManager::getImmediateExpansionRange.
+	 * Older versions of clang return a pair of SourceLocation objects.
+	 * More recent versions return a CharSourceRange.
+	 */
+	static SourceLocation range_begin(
+			const std::pair<SourceLocation,SourceLocation> &p) {
+		return p.first;
+	}
+	static SourceLocation range_begin(const CharSourceRange &range) {
+		return range.getBegin();
+	}
+};
+
+}
+
+/* Does the callback argument "param" take its argument at position "pos"?
+ *
+ * The memory management annotations of arguments to function pointers
+ * are not recorded by clang, so the information cannot be extracted
+ * from the type of "param".
+ * Instead, go to the location in the source where the callback argument
+ * is declared, look for the right argument of the callback itself and
+ * then check if it has an "__isl_take" memory management annotation.
+ *
+ * If the return value of the function has a memory management annotation,
+ * then the spelling of "param" will point to the spelling
+ * of this memory management annotation.  Since the macro is defined
+ * on the command line (in main), this location does not have a file entry.
+ * In this case, move up one level in the macro expansion to the location
+ * where the memory management annotation is used.
+ */
+bool generator::callback_takes_argument(ParmVarDecl *param,
+	int pos)
+{
+	SourceLocation loc;
+	const char *s, *end, *next;
+	bool takes, keeps;
+
+	loc = param->getSourceRange().getBegin();
+	if (!SM.getFileEntryForID(SM.getFileID(SM.getSpellingLoc(loc))))
+		loc = ClangAPI::range_begin(SM.getImmediateExpansionRange(loc));
+	s = SM.getCharacterData(loc);
+	if (!s)
+		die("No character data");
+	s = strchr(s, '(');
+	if (!s)
+		die("Cannot find function pointer");
+	s = strchr(s + 1, '(');
+	if (!s)
+		die("Cannot find function pointer arguments");
+	end = strchr(s + 1, ')');
+	if (!end)
+		die("Cannot find end of function pointer arguments");
+	while (pos-- > 0) {
+		s = strchr(s + 1, ',');
+		if (!s || s > end)
+			die("Cannot find function pointer argument");
+	}
+	next = strchr(s + 1, ',');
+	if (next && next < end)
+		end = next;
+	s = strchr(s + 1, '_');
+	if (!s || s > end)
+		die("Cannot find function pointer argument annotation");
+	takes = prefixcmp(s, "__isl_take") == 0;
+	keeps = prefixcmp(s, "__isl_keep") == 0;
+	if (!takes && !keeps)
+		die("Cannot find function pointer argument annotation");
+
+	return takes;
+}
+
+/* Is "type" that of a pointer to an isl_* structure?
+ */
+bool generator::is_isl_type(QualType type)
+{
+	if (type->isPointerType()) {
+		string s;
+
+		type = type->getPointeeType();
+		if (type->isFunctionType())
+			return false;
+		s = type.getAsString();
+		return s.substr(0, 4) == "isl_";
+	}
+
+	return false;
+}
+
+/* Is "type" one of the integral types with a negative value
+ * indicating an error condition?
+ */
+bool generator::is_isl_neg_error(QualType type)
+{
+	return is_isl_bool(type) || is_isl_stat(type) || is_isl_size(type);
+}
+
+/* Is "type" the primitive type with the given name?
+ */
+static bool is_isl_primitive(QualType type, const char *name)
+{
+	string s;
+
+	if (type->isPointerType())
+		return false;
+
+	s = type.getAsString();
+	return s == name;
+}
+
+/* Is "type" the type isl_bool?
+ */
+bool generator::is_isl_bool(QualType type)
+{
+	return is_isl_primitive(type, "isl_bool");
+}
+
+/* Is "type" the type isl_stat?
+ */
+bool generator::is_isl_stat(QualType type)
+{
+	return is_isl_primitive(type, "isl_stat");
+}
+
+/* Is "type" the type isl_size?
+ */
+bool generator::is_isl_size(QualType type)
+{
+	return is_isl_primitive(type, "isl_size");
+}
+
+/* Is "type" that of a pointer to a function?
+ */
+bool generator::is_callback(QualType type)
+{
+	if (!type->isPointerType())
+		return false;
+	type = type->getPointeeType();
+	return type->isFunctionType();
+}
+
+/* Is "type" that of "char *" of "const char *"?
+ */
+bool generator::is_string(QualType type)
+{
+	if (type->isPointerType()) {
+		string s = type->getPointeeType().getAsString();
+		return s == "const char" || s == "char";
+	}
+
+	return false;
+}
+
+/* Is "type" that of "long"?
+ */
+bool generator::is_long(QualType type)
+{
+	const BuiltinType *builtin = type->getAs<BuiltinType>();
+	return builtin && builtin->getKind() == BuiltinType::Long;
+}
+
+/* Is "type" that of "unsigned int"?
+ */
+static bool is_unsigned_int(QualType type)
+{
+	const BuiltinType *builtin = type->getAs<BuiltinType>();
+	return builtin && builtin->getKind() == BuiltinType::UInt;
+}
+
+/* Return the name of the type that "type" points to.
+ * The input "type" is assumed to be a pointer type.
+ */
+string generator::extract_type(QualType type)
+{
+	if (type->isPointerType())
+		return type->getPointeeType().getAsString();
+	die("Cannot extract type from non-pointer type");
+}
+
+/* Given the type of a function pointer, return the corresponding
+ * function prototype.
+ */
+const FunctionProtoType *generator::extract_prototype(QualType type)
+{
+	return type->getPointeeType()->getAs<FunctionProtoType>();
+}
+
+/* Return the function name suffix for the type of "param".
+ *
+ * If the type of "param" is an isl object type,
+ * then the suffix is the name of the type with the "isl" prefix removed,
+ * but keeping the "_".
+ * If the type is an unsigned integer, then the type suffix is "_ui".
+ */
+static std::string type_suffix(ParmVarDecl *param)
+{
+	QualType type;
+
+	type = param->getOriginalType();
+	if (generator::is_isl_type(type))
+		return generator::extract_type(type).substr(3);
+	else if (is_unsigned_int(type))
+		return "_ui";
+	generator::die("Unsupported type suffix");
+}
+
+/* If "suffix" is a suffix of "s", then return "s" with the suffix removed.
+ * Otherwise, simply return "s".
+ */
+std::string generator::drop_suffix(const std::string &s,
+	const std::string &suffix)
+{
+	size_t len, suffix_len;
+
+	len = s.length();
+	suffix_len = suffix.length();
+
+	if (len >= suffix_len && s.substr(len - suffix_len) == suffix)
+		return s.substr(0, len - suffix_len);
+	else
+		return s;
+}
+
+/* If "method" is overloaded, then return its name with the suffixes
+ * corresponding to the types of the final arguments removed.
+ * Otherwise, simply return the name of the function.
+ * Start from the final argument and keep removing suffixes
+ * matching arguments, independently of whether previously considered
+ * arguments matched.
+ */
+string isl_class::name_without_type_suffixes(FunctionDecl *method)
+{
+	int num_params;
+	string name;
+
+	name = method->getName().str();
+	if (!generator::is_overload(method))
+		return name;
+
+	num_params = method->getNumParams();
+	for (int i = num_params - 1; i >= 0; --i) {
+		ParmVarDecl *param;
+		string type;
+
+		param = method->getParamDecl(i);
+		type = type_suffix(param);
+
+		name = generator::drop_suffix(name, type);
+	}
+
+	return name;
+}
+
+/* Is function "fd" with the given name a "get" method?
+ *
+ * A "get" method is an instance method
+ * with a name that starts with the get method prefix.
+ */
+bool isl_class::is_get_method_name(FunctionDecl *fd, const string &name) const
+{
+	return !is_static(fd) && prefixcmp(name.c_str(), get_prefix) == 0;
+}
+
+/* Extract the method name corresponding to "fd".
+ *
+ * If "fd" is a "get" method, then drop the "get" method prefix.
+ */
+string isl_class::method_name(FunctionDecl *fd) const
+{
+      string base = base_method_name(fd);
+
+      if (is_get_method_name(fd, base))
+	      return base.substr(strlen(get_prefix));
+      return base;
+}

_service:tar_scm:isl-0.24.tar.gz/interface/generator.h Added

@@ -0,0 +1,201 @@
+#ifndef ISL_INTERFACE_GENERATOR_H
+#define ISL_INTERFACE_GENERATOR_H
+
+#include <map>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <clang/AST/Decl.h>
+
+using namespace std;
+using namespace clang;
+
+/* Compare the prefix of "s" to "prefix" up to the length of "prefix".
+ */
+inline int prefixcmp(const char *s, const char *prefix)
+{
+	return strncmp(s, prefix, strlen(prefix));
+}
+
+/* Information about a single enum value of an enum set by a function.
+ * "value" is the enum value.
+ * "name" is the corresponding name.
+ * "method_name" is the the name of the method that sets this value.
+ */
+struct set_enum {
+	int	value;
+	string	name;
+	string	method_name;
+	set_enum(int value, string name, string method_name) :
+		value(value), name(name), method_name(method_name) {}
+};
+
+/* Helper structure for sorting FunctionDecl pointers
+ * on the corresponding function names.
+ */
+struct function_name_less {
+	bool operator()(FunctionDecl *x, FunctionDecl *y) const {
+		return x->getName() < y->getName();
+	}
+};
+
+/* Set of FunctionDecl pointers sorted on function name.
+ */
+typedef std::set<FunctionDecl *, function_name_less> function_set;
+
+/* isl_class collects all constructors and methods for an isl "class".
+ * "name" is the name of the class.
+ * If this object describes a subclass of a C type, then
+ * "subclass_name" is the name of that subclass and "superclass_name"
+ * is the name of the immediate superclass of that subclass.  Otherwise,
+ * "subclass_name" is equal to "name" and "superclass_name" is undefined.
+ * "type" is the declaration that introduces the type.
+ * "persistent_callbacks" contains the set of functions that
+ * set a persistent callback.
+ * "set_enums" maps the set of functions that set an enum value
+ * to information associated to each value.
+ * A function is considered to set an enum value if it returns
+ * an object of the same type and if its last argument is of an enum type.
+ * "methods" contains the set of methods, grouped by method name.
+ * "fn_to_str" is a reference to the *_to_str method of this class, if any.
+ * "fn_copy" is a reference to the *_copy method of this class, if any.
+ * "fn_free" is a reference to the *_free method of this class, if any.
+ * "fn_type" is a reference to a function that described subclasses, if any.
+ * If "fn_type" is set, then "type_subclasses" maps the values returned
+ * by that function to the names of the corresponding subclasses.
+ *
+ * The following fields are only used for the C++ bindings.
+ * For methods that are not derived from a function that applies
+ * directly to this class, but are rather copied from some ancestor,
+ * "copied_from" records the direct superclass from which the method
+ * was copied (where it may have been copied from a further ancestor) and
+ * "copy_depth" records the distance to the ancestor to which
+ * the function applies.
+ * "construction_types" contains the set of isl classes that can be
+ * implicitly converted to this class through a unary constructor,
+ * mapped to the single argument
+ * of this unary constructor.
+ */
+struct isl_class {
+	string name;
+	string superclass_name;
+	string subclass_name;
+	RecordDecl *type;
+	function_set constructors;
+	set<FunctionDecl *> persistent_callbacks;
+	map<FunctionDecl *, vector<set_enum> > set_enums;
+	map<string, function_set> methods;
+	map<int, string> type_subclasses;
+	FunctionDecl *fn_type;
+	FunctionDecl *fn_to_str;
+	FunctionDecl *fn_copy;
+	FunctionDecl *fn_free;
+
+	std::map<clang::FunctionDecl *, const isl_class &> copied_from;
+	std::map<clang::FunctionDecl *, int> copy_depth;
+	std::map<std::string, clang::ParmVarDecl *> construction_types;
+
+	/* Is the first argument an instance of the class? */
+	bool first_arg_matches_class(FunctionDecl *method) const;
+	/* Does "method" correspond to a static method? */
+	bool is_static(FunctionDecl *method) const;
+	/* Is this class a subclass based on a type function? */
+	bool is_type_subclass() const { return name != subclass_name; }
+	/* Return name of "fd" without type suffixes, if any. */
+	static string name_without_type_suffixes(FunctionDecl *fd);
+	/* Extract the method name corresponding to "fd"
+	 * (including "get" method prefix if any).
+	 */
+	string base_method_name(FunctionDecl *fd) const {
+		string m_name = name_without_type_suffixes(fd);
+		return m_name.substr(subclass_name.length() + 1);
+	}
+	/* The prefix of a "get" method. */
+	static const char *get_prefix;
+	/* Is function "fd" with the given name a "get" method? */
+	bool is_get_method_name(FunctionDecl *fd, const string &name) const;
+	/* Is function "fd" a "get" method? */
+	bool is_get_method(FunctionDecl *fd) const {
+		return is_get_method_name(fd, base_method_name(fd));
+	}
+	/* Extract the method name corresponding to "fd". */
+	string method_name(FunctionDecl *fd) const;
+	/* The prefix of any method that may set a (persistent) callback. */
+	static const char *set_callback_prefix;
+	/* Given a function that sets a persistent callback,
+	 * return the name of the callback.
+	 */
+	string persistent_callback_name(FunctionDecl *fd) const {
+		return method_name(fd).substr(strlen(set_callback_prefix));
+	}
+	/* Does this class have any functions that set a persistent callback?
+	 */
+	bool has_persistent_callbacks() const {
+		return persistent_callbacks.size() != 0;
+	}
+};
+
+/* Base class for interface generators.
+ *
+ * "conversions" maps the target type of automatic conversion
+ * to the second input argument of the conversion function.
+ */
+class generator {
+protected:
+	SourceManager &SM;
+	map<string,isl_class> classes;
+	map<string, FunctionDecl *> functions_by_name;
+
+public:
+	generator(SourceManager &SM, set<RecordDecl *> &exported_types,
+		set<FunctionDecl *> exported_functions,
+		set<FunctionDecl *> functions);
+
+	virtual void generate() = 0;
+	virtual ~generator() {};
+
+protected:
+	void add_subclass(RecordDecl *decl, const string &name,
+		const string &sub_name);
+	void add_class(RecordDecl *decl);
+	void add_type_subclasses(FunctionDecl *method);
+	isl_class *method2class(FunctionDecl *fd);
+	bool callback_takes_argument(ParmVarDecl *param, int pos);
+	FunctionDecl *find_by_name(const string &name, bool required);
+	std::map<const Type *, ParmVarDecl *> conversions;
+private:
+	static const std::set<std::string> automatic_conversion_functions;
+	void extract_automatic_conversion(FunctionDecl *fd);
+	void extract_class_automatic_conversions(const isl_class &clazz);
+	void extract_automatic_conversions();
+public:
+	static std::string drop_suffix(const std::string &s,
+		const std::string &suffix);
+	static void die(const char *msg) __attribute__((noreturn));
+	static void die(string msg) __attribute__((noreturn));
+	static vector<string> find_superclasses(Decl *decl);
+	static bool is_subclass(FunctionDecl *decl);
+	static bool is_overload(Decl *decl);
+	static bool is_constructor(Decl *decl);
+	static bool takes(Decl *decl);
+	static bool keeps(Decl *decl);
+	static bool gives(Decl *decl);
+	static bool is_isl_ctx(QualType type);
+	static bool first_arg_is_isl_ctx(FunctionDecl *fd);
+	static bool is_isl_type(QualType type);
+	static bool is_isl_neg_error(QualType type);
+	static bool is_isl_bool(QualType type);
+	static bool is_isl_stat(QualType type);
+	static bool is_isl_size(QualType type);
+	static bool is_long(QualType type);
+	static bool is_callback(QualType type);
+	static bool is_string(QualType type);
+	static bool is_static(const isl_class &clazz, FunctionDecl *method);
+	static bool is_mutator(const isl_class &clazz, FunctionDecl *fd);
+	static string extract_type(QualType type);
+	static const FunctionProtoType *extract_prototype(QualType type);
+	static ParmVarDecl *persistent_callback_arg(FunctionDecl *fd);
+};
+
+#endif /* ISL_INTERFACE_GENERATOR_H */

_service:tar_scm:isl-0.24.tar.gz/interface/install-sh Added

@@ -0,0 +1,518 @@
+#!/bin/sh
+# install - install a program, script, or datafile
+
+scriptversion=2018-03-11.20; # UTC
+
+# This originates from X11R5 (mit/util/scripts/install.sh), which was
+# later released in X11R6 (xc/config/util/install.sh) with the
+# following copyright and license.
+#
+# Copyright (C) 1994 X Consortium
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC-
+# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#
+# Except as contained in this notice, the name of the X Consortium shall not
+# be used in advertising or otherwise to promote the sale, use or other deal-
+# ings in this Software without prior written authorization from the X Consor-
+# tium.
+#
+#
+# FSF changes to this file are in the public domain.
+#
+# Calling this script install-sh is preferred over install.sh, to prevent
+# 'make' implicit rules from creating a file called install from it
+# when there is no Makefile.
+#
+# This script is compatible with the BSD install script, but was written
+# from scratch.
+
+tab='	'
+nl='
+'
+IFS=" $tab$nl"
+
+# Set DOITPROG to "echo" to test this script.
+
+doit=${DOITPROG-}
+doit_exec=${doit:-exec}
+
+# Put in absolute file names if you don't have them in your path;
+# or use environment vars.
+
+chgrpprog=${CHGRPPROG-chgrp}
+chmodprog=${CHMODPROG-chmod}
+chownprog=${CHOWNPROG-chown}
+cmpprog=${CMPPROG-cmp}
+cpprog=${CPPROG-cp}
+mkdirprog=${MKDIRPROG-mkdir}
+mvprog=${MVPROG-mv}
+rmprog=${RMPROG-rm}
+stripprog=${STRIPPROG-strip}
+
+posix_mkdir=
+
+# Desired mode of installed file.
+mode=0755
+
+chgrpcmd=
+chmodcmd=$chmodprog
+chowncmd=
+mvcmd=$mvprog
+rmcmd="$rmprog -f"
+stripcmd=
+
+src=
+dst=
+dir_arg=
+dst_arg=
+
+copy_on_change=false
+is_target_a_directory=possibly
+
+usage="\
+Usage: $0 OPTION... -T SRCFILE DSTFILE
+   or: $0 OPTION... SRCFILES... DIRECTORY
+   or: $0 OPTION... -t DIRECTORY SRCFILES...
+   or: $0 OPTION... -d DIRECTORIES...
+
+In the 1st form, copy SRCFILE to DSTFILE.
+In the 2nd and 3rd, copy all SRCFILES to DIRECTORY.
+In the 4th, create DIRECTORIES.
+
+Options:
+     --help     display this help and exit.
+     --version  display version info and exit.
+
+  -c            (ignored)
+  -C            install only if different (preserve the last data modification time)
+  -d            create directories instead of installing files.
+  -g GROUP      $chgrpprog installed files to GROUP.
+  -m MODE       $chmodprog installed files to MODE.
+  -o USER       $chownprog installed files to USER.
+  -s            $stripprog installed files.
+  -t DIRECTORY  install into DIRECTORY.
+  -T            report an error if DSTFILE is a directory.
+
+Environment variables override the default commands:
+  CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG
+  RMPROG STRIPPROG
+"
+
+while test $# -ne 0; do
+  case $1 in
+    -c) ;;
+
+    -C) copy_on_change=true;;
+
+    -d) dir_arg=true;;
+
+    -g) chgrpcmd="$chgrpprog $2"
+        shift;;
+
+    --help) echo "$usage"; exit $?;;
+
+    -m) mode=$2
+        case $mode in
+          *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *''*)
+            echo "$0: invalid mode: $mode" >&2
+            exit 1;;
+        esac
+        shift;;
+
+    -o) chowncmd="$chownprog $2"
+        shift;;
+
+    -s) stripcmd=$stripprog;;
+
+    -t)
+        is_target_a_directory=always
+        dst_arg=$2
+        # Protect names problematic for 'test' and other utilities.
+        case $dst_arg in
+          -* | =!) dst_arg=./$dst_arg;;
+        esac
+        shift;;
+
+    -T) is_target_a_directory=never;;
+
+    --version) echo "$0 $scriptversion"; exit $?;;
+
+    --) shift
+        break;;
+
+    -*) echo "$0: invalid option: $1" >&2
+        exit 1;;
+
+    *)  break;;
+  esac
+  shift
+done
+
+# We allow the use of options -d and -T together, by making -d
+# take the precedence; this is for compatibility with GNU install.
+
+if test -n "$dir_arg"; then
+  if test -n "$dst_arg"; then
+    echo "$0: target directory not allowed when installing a directory." >&2
+    exit 1
+  fi
+fi
+
+if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then
+  # When -d is used, all remaining arguments are directories to create.
+  # When -t is used, the destination is already specified.
+  # Otherwise, the last argument is the destination.  Remove it from $@.
+  for arg
+  do
+    if test -n "$dst_arg"; then
+      # $@ is not empty: it contains at least $arg.
+      set fnord "$@" "$dst_arg"
+      shift # fnord
+    fi
+    shift # arg
+    dst_arg=$arg
+    # Protect names problematic for 'test' and other utilities.
+    case $dst_arg in
+      -* | =!) dst_arg=./$dst_arg;;
+    esac
+  done
+fi
+
+if test $# -eq 0; then
+  if test -z "$dir_arg"; then
+    echo "$0: no input file specified." >&2
+    exit 1
+  fi
+  # It's OK to call 'install-sh -d' without argument.
+  # This can happen when creating conditional directories.
+  exit 0
+fi
+
+if test -z "$dir_arg"; then
+  if test $# -gt 1 || test "$is_target_a_directory" = always; then
+    if test ! -d "$dst_arg"; then
+      echo "$0: $dst_arg: Is not a directory." >&2
+      exit 1
+    fi
+  fi
+fi
+
+if test -z "$dir_arg"; then
+  do_exit='(exit $ret); exit $ret'
+  trap "ret=129; $do_exit" 1
+  trap "ret=130; $do_exit" 2
+  trap "ret=141; $do_exit" 13
+  trap "ret=143; $do_exit" 15
+
+  # Set umask so as not to create temps with too-generous modes.
+  # However, 'strip' requires both read and write access to temps.
+  case $mode in
+    # Optimize common cases.
+    *644) cp_umask=133;;
+    *755) cp_umask=22;;
+
+    *0-7)
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw='% 200'
+      fi
+      cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;;
+    *)
+      if test -z "$stripcmd"; then
+        u_plus_rw=
+      else
+        u_plus_rw=,u+rw
+      fi
+      cp_umask=$mode$u_plus_rw;;
+  esac
+fi
+
+for src
+do
+  # Protect names problematic for 'test' and other utilities.
+  case $src in
+    -* | =!) src=./$src;;
+  esac
+
+  if test -n "$dir_arg"; then
+    dst=$src
+    dstdir=$dst
+    test -d "$dstdir"
+    dstdir_status=$?
+  else
+
+    # Waiting for this to be detected by the "$cpprog $src $dsttmp" command
+    # might cause directories to be created, which would be especially bad
+    # if $src (and thus $dsttmp) contains '*'.
+    if test ! -f "$src" && test ! -d "$src"; then
+      echo "$0: $src does not exist." >&2
+      exit 1
+    fi
+
+    if test -z "$dst_arg"; then
+      echo "$0: no destination specified." >&2
+      exit 1
+    fi
+    dst=$dst_arg
+
+    # If destination is a directory, append the input filename.
+    if test -d "$dst"; then
+      if test "$is_target_a_directory" = never; then
+        echo "$0: $dst_arg: Is a directory" >&2
+        exit 1
+      fi
+      dstdir=$dst
+      dstbase=`basename "$src"`
+      case $dst in
+	*/) dst=$dst$dstbase;;
+	*)  dst=$dst/$dstbase;;
+      esac
+      dstdir_status=0
+    else
+      dstdir=`dirname "$dst"`
+      test -d "$dstdir"
+      dstdir_status=$?
+    fi
+  fi
+
+  case $dstdir in
+    */) dstdirslash=$dstdir;;
+    *)  dstdirslash=$dstdir/;;
+  esac
+
+  obsolete_mkdir_used=false
+
+  if test $dstdir_status != 0; then
+    case $posix_mkdir in
+      '')
+        # Create intermediate dirs using mode 755 as modified by the umask.
+        # This is like FreeBSD 'install' as of 1997-10-28.
+        umask=`umask`
+        case $stripcmd.$umask in
+          # Optimize common cases.
+          *23672367) mkdir_umask=$umask;;
+          .*00202 | .0202 | .02) mkdir_umask=22;;
+
+          *0-7)
+            mkdir_umask=`expr $umask + 22 \
+              - $umask % 100 % 40 + $umask % 20 \
+              - $umask % 10 % 4 + $umask % 2
+            `;;
+          *) mkdir_umask=$umask,go-w;;
+        esac
+
+        # With -d, create the new directory with the user-specified mode.
+        # Otherwise, rely on $mkdir_umask.
+        if test -n "$dir_arg"; then
+          mkdir_mode=-m$mode
+        else
+          mkdir_mode=
+        fi
+
+        posix_mkdir=false
+        case $umask in
+          *1235670-70-7)
+            # POSIX mkdir -p sets u+wx bits regardless of umask, which
+            # is incompatible with FreeBSD 'install' when (umask & 300) != 0.
+            ;;
+          *)
+            # Note that $RANDOM variable is not portable (e.g. dash);  Use it
+            # here however when possible just to lower collision chance.
+            tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$
+
+            trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0
+
+            # Because "mkdir -p" follows existing symlinks and we likely work
+            # directly in world-writeable /tmp, make sure that the '$tmpdir'
+            # directory is successfully created first before we actually test
+            # 'mkdir -p' feature.
+            if (umask $mkdir_umask &&
+                $mkdirprog $mkdir_mode "$tmpdir" &&
+                exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1
+            then
+              if test -z "$dir_arg" || {
+                   # Check for POSIX incompatibilities with -m.
+                   # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or
+                   # other-writable bit of parent directory when it shouldn't.
+                   # FreeBSD 6.1 mkdir -m -p sets mode of existing directory.
+                   test_tmpdir="$tmpdir/a"
+                   ls_ld_tmpdir=`ls -ld "$test_tmpdir"`
+                   case $ls_ld_tmpdir in
+                     d????-?r-*) different_mode=700;;
+                     d????-?--*) different_mode=755;;
+                     *) false;;
+                   esac &&
+                   $mkdirprog -m$different_mode -p -- "$test_tmpdir" && {
+                     ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"`
+                     test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1"
+                   }
+                 }
+              then posix_mkdir=:
+              fi
+              rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir"
+            else
+              # Remove any dirs left behind by ancient mkdir implementations.
+              rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null
+            fi
+            trap '' 0;;
+        esac;;
+    esac
+
+    if
+      $posix_mkdir && (
+        umask $mkdir_umask &&
+        $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir"
+      )
+    then :
+    else
+
+      # The umask is ridiculous, or mkdir does not conform to POSIX,
+      # or it failed possibly due to a race condition.  Create the
+      # directory the slow way, step by step, checking for races as we go.
+
+      case $dstdir in
+        /*) prefix='/';;
+        -=!*) prefix='./';;
+        *)  prefix='';;
+      esac
+
+      oIFS=$IFS
+      IFS=/
+      set -f
+      set fnord $dstdir
+      shift
+      set +f
+      IFS=$oIFS
+
+      prefixes=
+
+      for d
+      do
+        test X"$d" = X && continue
+
+        prefix=$prefix$d
+        if test -d "$prefix"; then
+          prefixes=
+        else
+          if $posix_mkdir; then
+            (umask=$mkdir_umask &&
+             $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break
+            # Don't fail if two instances are running concurrently.
+            test -d "$prefix" || exit 1
+          else
+            case $prefix in
+              *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;;
+              *) qprefix=$prefix;;
+            esac
+            prefixes="$prefixes '$qprefix'"
+          fi
+        fi
+        prefix=$prefix/
+      done
+
+      if test -n "$prefixes"; then
+        # Don't fail if two instances are running concurrently.
+        (umask $mkdir_umask &&
+         eval "\$doit_exec \$mkdirprog $prefixes") ||
+          test -d "$dstdir" || exit 1
+        obsolete_mkdir_used=true
+      fi
+    fi
+  fi
+
+  if test -n "$dir_arg"; then
+    { test -z "$chowncmd" || $doit $chowncmd "$dst"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } &&
+    { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false ||
+      test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1
+  else
+
+    # Make a couple of temp file names in the proper directory.
+    dsttmp=${dstdirslash}_inst.$$_
+    rmtmp=${dstdirslash}_rm.$$_
+
+    # Trap to clean up those temp files at exit.
+    trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0
+
+    # Copy the file name to the temp name.
+    (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") &&
+
+    # and set any options; do chmod last to preserve setuid bits.
+    #
+    # If any of these fail, we abort the whole thing.  If we want to
+    # ignore errors from any of these, just make sure not to ignore
+    # errors from the above "$doit $cpprog $src $dsttmp" command.
+    #
+    { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } &&
+    { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } &&
+    { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } &&
+    { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } &&
+
+    # If -C, don't bother to copy if it wouldn't change the file.
+    if $copy_on_change &&
+       old=`LC_ALL=C ls -dlL "$dst"     2>/dev/null` &&
+       new=`LC_ALL=C ls -dlL "$dsttmp"  2>/dev/null` &&
+       set -f &&
+       set X $old && old=:$2:$4:$5:$6 &&
+       set X $new && new=:$2:$4:$5:$6 &&
+       set +f &&
+       test "$old" = "$new" &&
+       $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1
+    then
+      rm -f "$dsttmp"
+    else
+      # Rename the file to the real destination.
+      $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null ||
+
+      # The rename failed, perhaps because mv can't rename something else
+      # to itself, or perhaps because mv is so ancient that it does not
+      # support -f.
+      {
+        # Now remove or move aside any old file at destination location.
+        # We try this two ways since rm can't unlink itself on some
+        # systems and the destination file might be busy for other
+        # reasons.  In this case, the final cleanup might fail but the new
+        # file should still install successfully.
+        {
+          test ! -f "$dst" ||
+          $doit $rmcmd -f "$dst" 2>/dev/null ||
+          { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null &&
+            { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; }
+          } ||
+          { echo "$0: cannot unlink or rename $dst" >&2
+            (exit 1); exit 1
+          }
+        } &&
+
+        # Now rename the file to the real destination.
+        $doit $mvcmd "$dsttmp" "$dst"
+      }
+    fi || exit 1
+
+    trap '' 0
+  fi
+done
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:

_service:tar_scm:isl-0.14.tar.xz/interface/isl.py -> _service:tar_scm:isl-0.24.tar.gz/interface/isl.py Changed

@@ -1,7 +1,16 @@
+isl_dlname='libisl.so.23'
+import os
 from ctypes import *
+from ctypes.util import find_library
 
-isl = cdll.LoadLibrary("libisl.so")
-libc = cdll.LoadLibrary("libc.so.6")
+isl_dyld_library_path = os.environ.get('ISL_DYLD_LIBRARY_PATH')
+if isl_dyld_library_path != None:
+    os.environ'DYLD_LIBRARY_PATH' =  isl_dyld_library_path
+try:
+    isl = cdll.LoadLibrary(isl_dlname)
+except:
+    isl = cdll.LoadLibrary(find_library("isl"))
+libc = cdll.LoadLibrary(find_library("c"))
 
 class Error(Exception):
     pass
@@ -17,7 +26,7 @@
         isl.isl_ctx_free(self)
 
     def from_param(self):
-        return self.ptr
+        return c_void_p(self.ptr)
 
     @staticmethod
     def getDefaultInstance():
@@ -28,7 +37,6709 @@
 isl.isl_ctx_alloc.restype = c_void_p
 isl.isl_ctx_free.argtypes = Context
 
-class union_map:
+class union_pw_multi_aff(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_multi_aff_from_multi_aff(isl.isl_multi_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is pw_multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_multi_aff_from_pw_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is union_pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_multi_aff_from_union_pw_aff(isl.isl_union_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_multi_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_pw_multi_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_pw_multi_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_pw_multi_aff("""%s""")' % s
+        else:
+            return 'isl.union_pw_multi_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_multi_aff:
+                arg1 = union_pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_add(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_pw_multi_aff_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def apply(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_apply_union_pw_multi_aff(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def as_multi_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_as_multi_union_pw_aff(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def as_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_as_pw_multi_aff(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def as_union_map(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_as_union_map(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_coalesce(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_domain(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def empty(*args):
+        if len(args) == 0:
+            ctx = Context.getDefaultInstance()
+            res = isl.isl_union_pw_multi_aff_empty_ctx(ctx)
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def extract_pw_multi_aff(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_extract_pw_multi_aff(arg0.ptr, isl.isl_space_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_multi_aff:
+                arg1 = union_pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_flat_range_product(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_pw_multi_aff_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_gist(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_intersect_domain_space(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_intersect_domain_union_set(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def intersect_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_intersect_domain_wrapped_domain(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain_wrapped_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_intersect_domain_wrapped_range(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_intersect_params(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def involves_locals(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_involves_locals(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def isa_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_isa_pw_multi_aff(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def plain_is_empty(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_plain_is_empty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def preimage_domain_wrapped_domain(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_pullback_union_pw_multi_aff(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def range_factor_domain(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_range_factor_domain(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_range(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_range_factor_range(isl.isl_union_pw_multi_aff_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_multi_aff:
+                arg1 = union_pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_range_product(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_pw_multi_aff_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def space(arg0):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_multi_aff:
+                arg1 = union_pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_sub(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_pw_multi_aff_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def subtract_domain(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_subtract_domain_space(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_multi_aff_subtract_domain_union_set(isl.isl_union_pw_multi_aff_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_multi_aff:
+                arg0 = union_pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_multi_aff:
+                arg1 = union_pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_multi_aff_union_add(isl.isl_union_pw_multi_aff_copy(arg0.ptr), isl.isl_union_pw_multi_aff_copy(arg1.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_union_pw_multi_aff_from_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_from_multi_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_from_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_from_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_from_union_pw_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_from_union_pw_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_read_from_str.restype = c_void_p
+isl.isl_union_pw_multi_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_union_pw_multi_aff_add.restype = c_void_p
+isl.isl_union_pw_multi_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_apply_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_apply_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_as_multi_union_pw_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_as_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_as_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_as_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_as_union_map.restype = c_void_p
+isl.isl_union_pw_multi_aff_as_union_map.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_coalesce.restype = c_void_p
+isl.isl_union_pw_multi_aff_coalesce.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_domain.restype = c_void_p
+isl.isl_union_pw_multi_aff_domain.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_empty_ctx.restype = c_void_p
+isl.isl_union_pw_multi_aff_empty_ctx.argtypes = Context
+isl.isl_union_pw_multi_aff_extract_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_extract_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_flat_range_product.restype = c_void_p
+isl.isl_union_pw_multi_aff_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_gist.restype = c_void_p
+isl.isl_union_pw_multi_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_space.restype = c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_union_set.restype = c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_wrapped_domain.restype = c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_wrapped_range.restype = c_void_p
+isl.isl_union_pw_multi_aff_intersect_domain_wrapped_range.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_intersect_params.restype = c_void_p
+isl.isl_union_pw_multi_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_involves_locals.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_isa_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_plain_is_empty.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_pullback_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_multi_aff_pullback_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_range_factor_domain.restype = c_void_p
+isl.isl_union_pw_multi_aff_range_factor_domain.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_range_factor_range.restype = c_void_p
+isl.isl_union_pw_multi_aff_range_factor_range.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_range_product.restype = c_void_p
+isl.isl_union_pw_multi_aff_range_product.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_get_space.restype = c_void_p
+isl.isl_union_pw_multi_aff_get_space.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_sub.restype = c_void_p
+isl.isl_union_pw_multi_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_subtract_domain_space.restype = c_void_p
+isl.isl_union_pw_multi_aff_subtract_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_subtract_domain_union_set.restype = c_void_p
+isl.isl_union_pw_multi_aff_subtract_domain_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_union_add.restype = c_void_p
+isl.isl_union_pw_multi_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_multi_aff_copy.restype = c_void_p
+isl.isl_union_pw_multi_aff_copy.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_free.restype = c_void_p
+isl.isl_union_pw_multi_aff_free.argtypes = c_void_p
+isl.isl_union_pw_multi_aff_to_str.restype = POINTER(c_char)
+isl.isl_union_pw_multi_aff_to_str.argtypes = c_void_p
+
+class multi_union_pw_aff(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is multi_pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_union_pw_aff_from_multi_pw_aff(isl.isl_multi_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is union_pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_union_pw_aff_from_union_pw_aff(isl.isl_union_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is union_pw_aff_list:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_union_pw_aff_from_union_pw_aff_list(isl.isl_space_copy(args0.ptr), isl.isl_union_pw_aff_list_copy(args1.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_union_pw_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_multi_union_pw_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_multi_union_pw_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.multi_union_pw_aff("""%s""")' % s
+        else:
+            return 'isl.multi_union_pw_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_add(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_get_at(arg0.ptr, arg1)
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def bind(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_bind(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_coalesce(isl.isl_multi_union_pw_aff_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_domain(isl.isl_multi_union_pw_aff_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_flat_range_product(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_gist(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def intersect_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_intersect_domain(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_intersect_params(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def involves_nan(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_involves_nan(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def list(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_get_list(arg0.ptr)
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def get_list(arg0):
+        return arg0.list()
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_neg(isl.isl_multi_union_pw_aff_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def plain_is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_plain_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_pullback_union_pw_multi_aff(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_range_product(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reset_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_reset_range_tuple_id(isl.isl_multi_union_pw_aff_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def scale(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_scale_multi_val(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_scale_val(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_scale_down_multi_val(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_scale_down_val(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_at(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is union_pw_aff:
+                arg2 = union_pw_aff(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_set_at(isl.isl_multi_union_pw_aff_copy(arg0.ptr), arg1, isl.isl_union_pw_aff_copy(arg2.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_union_pw_aff_set_range_tuple_id(isl.isl_multi_union_pw_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def size(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def space(arg0):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_sub(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_union_pw_aff:
+                arg0 = multi_union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_union_add(isl.isl_multi_union_pw_aff_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_union_pw_aff_zero(isl.isl_space_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_multi_union_pw_aff_from_multi_pw_aff.restype = c_void_p
+isl.isl_multi_union_pw_aff_from_multi_pw_aff.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_from_union_pw_aff.restype = c_void_p
+isl.isl_multi_union_pw_aff_from_union_pw_aff.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_from_union_pw_aff_list.restype = c_void_p
+isl.isl_multi_union_pw_aff_from_union_pw_aff_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_read_from_str.restype = c_void_p
+isl.isl_multi_union_pw_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_multi_union_pw_aff_add.restype = c_void_p
+isl.isl_multi_union_pw_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_get_at.restype = c_void_p
+isl.isl_multi_union_pw_aff_get_at.argtypes = c_void_p, c_int
+isl.isl_multi_union_pw_aff_bind.restype = c_void_p
+isl.isl_multi_union_pw_aff_bind.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_coalesce.restype = c_void_p
+isl.isl_multi_union_pw_aff_coalesce.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_domain.restype = c_void_p
+isl.isl_multi_union_pw_aff_domain.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_flat_range_product.restype = c_void_p
+isl.isl_multi_union_pw_aff_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_gist.restype = c_void_p
+isl.isl_multi_union_pw_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_has_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_intersect_domain.restype = c_void_p
+isl.isl_multi_union_pw_aff_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_intersect_params.restype = c_void_p
+isl.isl_multi_union_pw_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_involves_nan.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_get_list.restype = c_void_p
+isl.isl_multi_union_pw_aff_get_list.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_neg.restype = c_void_p
+isl.isl_multi_union_pw_aff_neg.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_plain_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_pullback_union_pw_multi_aff.restype = c_void_p
+isl.isl_multi_union_pw_aff_pullback_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_range_product.restype = c_void_p
+isl.isl_multi_union_pw_aff_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_get_range_tuple_id.restype = c_void_p
+isl.isl_multi_union_pw_aff_get_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_reset_range_tuple_id.restype = c_void_p
+isl.isl_multi_union_pw_aff_reset_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_scale_multi_val.restype = c_void_p
+isl.isl_multi_union_pw_aff_scale_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_scale_val.restype = c_void_p
+isl.isl_multi_union_pw_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_scale_down_multi_val.restype = c_void_p
+isl.isl_multi_union_pw_aff_scale_down_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_scale_down_val.restype = c_void_p
+isl.isl_multi_union_pw_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_set_at.restype = c_void_p
+isl.isl_multi_union_pw_aff_set_at.argtypes = c_void_p, c_int, c_void_p
+isl.isl_multi_union_pw_aff_set_range_tuple_id.restype = c_void_p
+isl.isl_multi_union_pw_aff_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_size.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_get_space.restype = c_void_p
+isl.isl_multi_union_pw_aff_get_space.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_sub.restype = c_void_p
+isl.isl_multi_union_pw_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_union_add.restype = c_void_p
+isl.isl_multi_union_pw_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_union_pw_aff_zero.restype = c_void_p
+isl.isl_multi_union_pw_aff_zero.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_copy.restype = c_void_p
+isl.isl_multi_union_pw_aff_copy.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_free.restype = c_void_p
+isl.isl_multi_union_pw_aff_free.argtypes = c_void_p
+isl.isl_multi_union_pw_aff_to_str.restype = POINTER(c_char)
+isl.isl_multi_union_pw_aff_to_str.argtypes = c_void_p
+
+class union_pw_aff(union_pw_multi_aff, multi_union_pw_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_aff_from_aff(isl.isl_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_aff_from_pw_aff(isl.isl_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_pw_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_pw_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_pw_aff("""%s""")' % s
+        else:
+            return 'isl.union_pw_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff:
+                arg1 = union_pw_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_add(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_pw_aff_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_bind_id(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = union_set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_coalesce(isl.isl_union_pw_aff_copy(arg0.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_domain(isl.isl_union_pw_aff_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_gist(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_intersect_domain_space(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_intersect_domain_union_set(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def intersect_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).intersect_domain_wrapped_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_intersect_domain_wrapped_domain(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain_wrapped_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).intersect_domain_wrapped_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_intersect_domain_wrapped_range(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_intersect_params(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_pullback_union_pw_multi_aff(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def space(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff:
+                arg1 = union_pw_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_sub(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_pw_aff_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def subtract_domain(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_subtract_domain_space(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_pw_aff_subtract_domain_union_set(isl.isl_union_pw_aff_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_to_list(isl.isl_union_pw_aff_copy(arg0.ptr))
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff:
+                arg0 = union_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff:
+                arg1 = union_pw_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).union_add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_union_add(isl.isl_union_pw_aff_copy(arg0.ptr), isl.isl_union_pw_aff_copy(arg1.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_union_pw_aff_from_aff.restype = c_void_p
+isl.isl_union_pw_aff_from_aff.argtypes = c_void_p
+isl.isl_union_pw_aff_from_pw_aff.restype = c_void_p
+isl.isl_union_pw_aff_from_pw_aff.argtypes = c_void_p
+isl.isl_union_pw_aff_read_from_str.restype = c_void_p
+isl.isl_union_pw_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_union_pw_aff_add.restype = c_void_p
+isl.isl_union_pw_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_bind_id.restype = c_void_p
+isl.isl_union_pw_aff_bind_id.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_coalesce.restype = c_void_p
+isl.isl_union_pw_aff_coalesce.argtypes = c_void_p
+isl.isl_union_pw_aff_domain.restype = c_void_p
+isl.isl_union_pw_aff_domain.argtypes = c_void_p
+isl.isl_union_pw_aff_gist.restype = c_void_p
+isl.isl_union_pw_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_intersect_domain_space.restype = c_void_p
+isl.isl_union_pw_aff_intersect_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_intersect_domain_union_set.restype = c_void_p
+isl.isl_union_pw_aff_intersect_domain_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_intersect_domain_wrapped_domain.restype = c_void_p
+isl.isl_union_pw_aff_intersect_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_intersect_domain_wrapped_range.restype = c_void_p
+isl.isl_union_pw_aff_intersect_domain_wrapped_range.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_intersect_params.restype = c_void_p
+isl.isl_union_pw_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_pullback_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_pw_aff_pullback_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_get_space.restype = c_void_p
+isl.isl_union_pw_aff_get_space.argtypes = c_void_p
+isl.isl_union_pw_aff_sub.restype = c_void_p
+isl.isl_union_pw_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_subtract_domain_space.restype = c_void_p
+isl.isl_union_pw_aff_subtract_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_subtract_domain_union_set.restype = c_void_p
+isl.isl_union_pw_aff_subtract_domain_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_to_list.restype = c_void_p
+isl.isl_union_pw_aff_to_list.argtypes = c_void_p
+isl.isl_union_pw_aff_union_add.restype = c_void_p
+isl.isl_union_pw_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_copy.restype = c_void_p
+isl.isl_union_pw_aff_copy.argtypes = c_void_p
+isl.isl_union_pw_aff_free.restype = c_void_p
+isl.isl_union_pw_aff_free.argtypes = c_void_p
+isl.isl_union_pw_aff_to_str.restype = POINTER(c_char)
+isl.isl_union_pw_aff_to_str.argtypes = c_void_p
+
+class multi_pw_aff(multi_union_pw_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_from_aff(isl.isl_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_from_multi_aff(isl.isl_multi_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_from_pw_aff(isl.isl_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is pw_aff_list:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_from_pw_aff_list(isl.isl_space_copy(args0.ptr), isl.isl_pw_aff_list_copy(args1.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is pw_multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_from_pw_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_pw_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_multi_pw_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_multi_pw_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.multi_pw_aff("""%s""")' % s
+        else:
+            return 'isl.multi_pw_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_add(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def add_constant(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_add_constant_multi_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_add_constant_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def as_map(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_as_map(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def as_set(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_as_set(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_get_at(arg0.ptr, arg1)
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def bind(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return multi_union_pw_aff(arg0).bind(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_bind(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return multi_union_pw_aff(arg0).bind_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_bind_domain(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return multi_union_pw_aff(arg0).bind_domain_wrapped_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_bind_domain_wrapped_domain(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_coalesce(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_domain(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).flat_range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_flat_range_product(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return multi_union_pw_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_gist(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def identity(*args):
+        if len(args) == 1:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_identity_multi_pw_aff(isl.isl_multi_pw_aff_copy(args0.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    @staticmethod
+    def identity_on_domain(*args):
+        if len(args) == 1 and args0.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_identity_on_domain_space(isl.isl_space_copy(args0.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            return multi_union_pw_aff(arg0).insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_insert_domain(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return multi_union_pw_aff(arg0).intersect_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_intersect_domain(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return multi_union_pw_aff(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_intersect_params(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def involves_nan(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_involves_nan(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def involves_param(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_involves_param_id(args0.ptr, args1.ptr)
+            if res < 0:
+                raise
+            return bool(res)
+        if len(args) == 2 and args1.__class__ is id_list:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_involves_param_id_list(args0.ptr, args1.ptr)
+            if res < 0:
+                raise
+            return bool(res)
+        raise Error
+    def list(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_get_list(arg0.ptr)
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def get_list(arg0):
+        return arg0.list()
+    def max(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).max(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_max(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def max_multi_val(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_max_multi_val(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def min(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).min(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_min(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def min_multi_val(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_min_multi_val(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_neg(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def plain_is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).plain_is_equal(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_plain_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_product(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_pullback_multi_aff(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_pullback_multi_pw_aff(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_pullback_pw_multi_aff(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_range_product(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reset_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_reset_range_tuple_id(isl.isl_multi_pw_aff_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def scale(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_scale_multi_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_scale_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_scale_down_multi_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_scale_down_val(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_at(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is pw_aff:
+                arg2 = pw_aff(arg2)
+        except:
+            return multi_union_pw_aff(arg0).set_at(arg1, arg2)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_set_at(isl.isl_multi_pw_aff_copy(arg0.ptr), arg1, isl.isl_pw_aff_copy(arg2.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_pw_aff_set_range_tuple_id(isl.isl_multi_pw_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = multi_pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def size(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def space(arg0):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_sub(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def unbind_params_insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return multi_union_pw_aff(arg0).unbind_params_insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_unbind_params_insert_domain(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_pw_aff:
+                arg0 = multi_pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_pw_aff:
+                arg1 = multi_pw_aff(arg1)
+        except:
+            return multi_union_pw_aff(arg0).union_add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_union_add(isl.isl_multi_pw_aff_copy(arg0.ptr), isl.isl_multi_pw_aff_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_pw_aff_zero(isl.isl_space_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_multi_pw_aff_from_aff.restype = c_void_p
+isl.isl_multi_pw_aff_from_aff.argtypes = c_void_p
+isl.isl_multi_pw_aff_from_multi_aff.restype = c_void_p
+isl.isl_multi_pw_aff_from_multi_aff.argtypes = c_void_p
+isl.isl_multi_pw_aff_from_pw_aff.restype = c_void_p
+isl.isl_multi_pw_aff_from_pw_aff.argtypes = c_void_p
+isl.isl_multi_pw_aff_from_pw_aff_list.restype = c_void_p
+isl.isl_multi_pw_aff_from_pw_aff_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_from_pw_multi_aff.restype = c_void_p
+isl.isl_multi_pw_aff_from_pw_multi_aff.argtypes = c_void_p
+isl.isl_multi_pw_aff_read_from_str.restype = c_void_p
+isl.isl_multi_pw_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_multi_pw_aff_add.restype = c_void_p
+isl.isl_multi_pw_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_add_constant_multi_val.restype = c_void_p
+isl.isl_multi_pw_aff_add_constant_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_add_constant_val.restype = c_void_p
+isl.isl_multi_pw_aff_add_constant_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_as_map.restype = c_void_p
+isl.isl_multi_pw_aff_as_map.argtypes = c_void_p
+isl.isl_multi_pw_aff_as_set.restype = c_void_p
+isl.isl_multi_pw_aff_as_set.argtypes = c_void_p
+isl.isl_multi_pw_aff_get_at.restype = c_void_p
+isl.isl_multi_pw_aff_get_at.argtypes = c_void_p, c_int
+isl.isl_multi_pw_aff_bind.restype = c_void_p
+isl.isl_multi_pw_aff_bind.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_bind_domain.restype = c_void_p
+isl.isl_multi_pw_aff_bind_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_bind_domain_wrapped_domain.restype = c_void_p
+isl.isl_multi_pw_aff_bind_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_coalesce.restype = c_void_p
+isl.isl_multi_pw_aff_coalesce.argtypes = c_void_p
+isl.isl_multi_pw_aff_domain.restype = c_void_p
+isl.isl_multi_pw_aff_domain.argtypes = c_void_p
+isl.isl_multi_pw_aff_flat_range_product.restype = c_void_p
+isl.isl_multi_pw_aff_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_gist.restype = c_void_p
+isl.isl_multi_pw_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_has_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_pw_aff_identity_multi_pw_aff.restype = c_void_p
+isl.isl_multi_pw_aff_identity_multi_pw_aff.argtypes = c_void_p
+isl.isl_multi_pw_aff_identity_on_domain_space.restype = c_void_p
+isl.isl_multi_pw_aff_identity_on_domain_space.argtypes = c_void_p
+isl.isl_multi_pw_aff_insert_domain.restype = c_void_p
+isl.isl_multi_pw_aff_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_intersect_domain.restype = c_void_p
+isl.isl_multi_pw_aff_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_intersect_params.restype = c_void_p
+isl.isl_multi_pw_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_involves_nan.argtypes = c_void_p
+isl.isl_multi_pw_aff_involves_param_id.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_involves_param_id_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_get_list.restype = c_void_p
+isl.isl_multi_pw_aff_get_list.argtypes = c_void_p
+isl.isl_multi_pw_aff_max.restype = c_void_p
+isl.isl_multi_pw_aff_max.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_max_multi_val.restype = c_void_p
+isl.isl_multi_pw_aff_max_multi_val.argtypes = c_void_p
+isl.isl_multi_pw_aff_min.restype = c_void_p
+isl.isl_multi_pw_aff_min.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_min_multi_val.restype = c_void_p
+isl.isl_multi_pw_aff_min_multi_val.argtypes = c_void_p
+isl.isl_multi_pw_aff_neg.restype = c_void_p
+isl.isl_multi_pw_aff_neg.argtypes = c_void_p
+isl.isl_multi_pw_aff_plain_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_product.restype = c_void_p
+isl.isl_multi_pw_aff_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_pullback_multi_aff.restype = c_void_p
+isl.isl_multi_pw_aff_pullback_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_pullback_multi_pw_aff.restype = c_void_p
+isl.isl_multi_pw_aff_pullback_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_pullback_pw_multi_aff.restype = c_void_p
+isl.isl_multi_pw_aff_pullback_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_range_product.restype = c_void_p
+isl.isl_multi_pw_aff_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_get_range_tuple_id.restype = c_void_p
+isl.isl_multi_pw_aff_get_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_pw_aff_reset_range_tuple_id.restype = c_void_p
+isl.isl_multi_pw_aff_reset_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_pw_aff_scale_multi_val.restype = c_void_p
+isl.isl_multi_pw_aff_scale_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_scale_val.restype = c_void_p
+isl.isl_multi_pw_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_scale_down_multi_val.restype = c_void_p
+isl.isl_multi_pw_aff_scale_down_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_scale_down_val.restype = c_void_p
+isl.isl_multi_pw_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_set_at.restype = c_void_p
+isl.isl_multi_pw_aff_set_at.argtypes = c_void_p, c_int, c_void_p
+isl.isl_multi_pw_aff_set_range_tuple_id.restype = c_void_p
+isl.isl_multi_pw_aff_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_size.argtypes = c_void_p
+isl.isl_multi_pw_aff_get_space.restype = c_void_p
+isl.isl_multi_pw_aff_get_space.argtypes = c_void_p
+isl.isl_multi_pw_aff_sub.restype = c_void_p
+isl.isl_multi_pw_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_unbind_params_insert_domain.restype = c_void_p
+isl.isl_multi_pw_aff_unbind_params_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_union_add.restype = c_void_p
+isl.isl_multi_pw_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_pw_aff_zero.restype = c_void_p
+isl.isl_multi_pw_aff_zero.argtypes = c_void_p
+isl.isl_multi_pw_aff_copy.restype = c_void_p
+isl.isl_multi_pw_aff_copy.argtypes = c_void_p
+isl.isl_multi_pw_aff_free.restype = c_void_p
+isl.isl_multi_pw_aff_free.argtypes = c_void_p
+isl.isl_multi_pw_aff_to_str.restype = POINTER(c_char)
+isl.isl_multi_pw_aff_to_str.argtypes = c_void_p
+
+class pw_multi_aff(union_pw_multi_aff, multi_pw_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_multi_aff_from_multi_aff(isl.isl_multi_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and args0.__class__ is pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_multi_aff_from_pw_aff(isl.isl_pw_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_multi_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_pw_multi_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_pw_multi_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.pw_multi_aff("""%s""")' % s
+        else:
+            return 'isl.pw_multi_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_add(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def add_constant(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_add_constant_multi_val(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_add_constant_val(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def as_map(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_as_map(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def as_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_as_multi_aff(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def as_set(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_as_set(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_get_at(arg0.ptr, arg1)
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def bind_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_pw_multi_aff(arg0).bind_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_bind_domain(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_pw_multi_aff(arg0).bind_domain_wrapped_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_bind_domain_wrapped_domain(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_coalesce(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_domain(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def domain_map(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_domain_map(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).flat_range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_flat_range_product(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def foreach_piece(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1, cb_arg2):
+            cb_arg0 = set(ctx=arg0.ctx, ptr=(cb_arg0))
+            cb_arg1 = multi_aff(ctx=arg0.ctx, ptr=(cb_arg1))
+            try:
+                arg1(cb_arg0, cb_arg1)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_foreach_piece(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_gist(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    @staticmethod
+    def identity_on_domain(*args):
+        if len(args) == 1 and args0.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_identity_on_domain_space(isl.isl_space_copy(args0.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            return union_pw_multi_aff(arg0).insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_insert_domain(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).intersect_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_intersect_domain(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_intersect_params(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def involves_locals(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_involves_locals(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def isa_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_isa_multi_aff(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def max_multi_val(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_max_multi_val(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def min_multi_val(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_min_multi_val(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def multi_val_on_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            return union_pw_multi_aff(arg0).multi_val_on_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_multi_val_on_domain(isl.isl_set_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def n_piece(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_n_piece(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def preimage_domain_wrapped_domain(*args):
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def product(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_product(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_pullback_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_pullback_pw_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def range_factor_domain(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_range_factor_domain(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_range(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_range_factor_range(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def range_map(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_range_map(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_range_product(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def scale(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_scale_val(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_scale_down_val(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_multi_aff_set_range_tuple_id(isl.isl_pw_multi_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def space(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_sub(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def subtract_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_multi_aff(arg0).subtract_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_subtract_domain(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_to_list(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def to_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_to_multi_pw_aff(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_union_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_to_union_pw_multi_aff(isl.isl_pw_multi_aff_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff:
+                arg0 = pw_multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            return union_pw_multi_aff(arg0).union_add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_union_add(isl.isl_pw_multi_aff_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_zero(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_pw_multi_aff_from_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_from_multi_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_from_pw_aff.restype = c_void_p
+isl.isl_pw_multi_aff_from_pw_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_read_from_str.restype = c_void_p
+isl.isl_pw_multi_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_pw_multi_aff_add.restype = c_void_p
+isl.isl_pw_multi_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_add_constant_multi_val.restype = c_void_p
+isl.isl_pw_multi_aff_add_constant_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_add_constant_val.restype = c_void_p
+isl.isl_pw_multi_aff_add_constant_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_as_map.restype = c_void_p
+isl.isl_pw_multi_aff_as_map.argtypes = c_void_p
+isl.isl_pw_multi_aff_as_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_as_multi_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_as_set.restype = c_void_p
+isl.isl_pw_multi_aff_as_set.argtypes = c_void_p
+isl.isl_pw_multi_aff_get_at.restype = c_void_p
+isl.isl_pw_multi_aff_get_at.argtypes = c_void_p, c_int
+isl.isl_pw_multi_aff_bind_domain.restype = c_void_p
+isl.isl_pw_multi_aff_bind_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_bind_domain_wrapped_domain.restype = c_void_p
+isl.isl_pw_multi_aff_bind_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_coalesce.restype = c_void_p
+isl.isl_pw_multi_aff_coalesce.argtypes = c_void_p
+isl.isl_pw_multi_aff_domain.restype = c_void_p
+isl.isl_pw_multi_aff_domain.argtypes = c_void_p
+isl.isl_pw_multi_aff_domain_map.restype = c_void_p
+isl.isl_pw_multi_aff_domain_map.argtypes = c_void_p
+isl.isl_pw_multi_aff_flat_range_product.restype = c_void_p
+isl.isl_pw_multi_aff_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_foreach_piece.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_pw_multi_aff_gist.restype = c_void_p
+isl.isl_pw_multi_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_has_range_tuple_id.argtypes = c_void_p
+isl.isl_pw_multi_aff_identity_on_domain_space.restype = c_void_p
+isl.isl_pw_multi_aff_identity_on_domain_space.argtypes = c_void_p
+isl.isl_pw_multi_aff_insert_domain.restype = c_void_p
+isl.isl_pw_multi_aff_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_intersect_domain.restype = c_void_p
+isl.isl_pw_multi_aff_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_intersect_params.restype = c_void_p
+isl.isl_pw_multi_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_involves_locals.argtypes = c_void_p
+isl.isl_pw_multi_aff_isa_multi_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_max_multi_val.restype = c_void_p
+isl.isl_pw_multi_aff_max_multi_val.argtypes = c_void_p
+isl.isl_pw_multi_aff_min_multi_val.restype = c_void_p
+isl.isl_pw_multi_aff_min_multi_val.argtypes = c_void_p
+isl.isl_pw_multi_aff_multi_val_on_domain.restype = c_void_p
+isl.isl_pw_multi_aff_multi_val_on_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_n_piece.argtypes = c_void_p
+isl.isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_product.restype = c_void_p
+isl.isl_pw_multi_aff_product.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_pullback_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_pullback_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_pullback_pw_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_pullback_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_range_factor_domain.restype = c_void_p
+isl.isl_pw_multi_aff_range_factor_domain.argtypes = c_void_p
+isl.isl_pw_multi_aff_range_factor_range.restype = c_void_p
+isl.isl_pw_multi_aff_range_factor_range.argtypes = c_void_p
+isl.isl_pw_multi_aff_range_map.restype = c_void_p
+isl.isl_pw_multi_aff_range_map.argtypes = c_void_p
+isl.isl_pw_multi_aff_range_product.restype = c_void_p
+isl.isl_pw_multi_aff_range_product.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_get_range_tuple_id.restype = c_void_p
+isl.isl_pw_multi_aff_get_range_tuple_id.argtypes = c_void_p
+isl.isl_pw_multi_aff_scale_val.restype = c_void_p
+isl.isl_pw_multi_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_scale_down_val.restype = c_void_p
+isl.isl_pw_multi_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_set_range_tuple_id.restype = c_void_p
+isl.isl_pw_multi_aff_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_get_space.restype = c_void_p
+isl.isl_pw_multi_aff_get_space.argtypes = c_void_p
+isl.isl_pw_multi_aff_sub.restype = c_void_p
+isl.isl_pw_multi_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_subtract_domain.restype = c_void_p
+isl.isl_pw_multi_aff_subtract_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_to_list.restype = c_void_p
+isl.isl_pw_multi_aff_to_list.argtypes = c_void_p
+isl.isl_pw_multi_aff_to_multi_pw_aff.restype = c_void_p
+isl.isl_pw_multi_aff_to_multi_pw_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_to_union_pw_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_to_union_pw_multi_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_union_add.restype = c_void_p
+isl.isl_pw_multi_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_zero.restype = c_void_p
+isl.isl_pw_multi_aff_zero.argtypes = c_void_p
+isl.isl_pw_multi_aff_copy.restype = c_void_p
+isl.isl_pw_multi_aff_copy.argtypes = c_void_p
+isl.isl_pw_multi_aff_free.restype = c_void_p
+isl.isl_pw_multi_aff_free.argtypes = c_void_p
+isl.isl_pw_multi_aff_to_str.restype = POINTER(c_char)
+isl.isl_pw_multi_aff_to_str.argtypes = c_void_p
+
+class pw_aff(union_pw_aff, pw_multi_aff, multi_pw_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_aff_from_aff(isl.isl_aff_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_pw_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_pw_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.pw_aff("""%s""")' % s
+        else:
+            return 'isl.pw_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_add(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def add_constant(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_add_constant_val(isl.isl_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def as_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_as_aff(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def as_map(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_as_map(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def bind(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_bind_id(isl.isl_pw_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def bind_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_pw_aff(arg0).bind_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_bind_domain(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_pw_aff(arg0).bind_domain_wrapped_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_bind_domain_wrapped_domain(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def ceil(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_ceil(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_coalesce(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def cond(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).cond(arg1, arg2)
+        try:
+            if not arg2.__class__ is pw_aff:
+                arg2 = pw_aff(arg2)
+        except:
+            return union_pw_aff(arg0).cond(arg1, arg2)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_cond(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr), isl.isl_pw_aff_copy(arg2.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def div(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).div(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_div(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_domain(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def eq_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).eq_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_eq_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def eval(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is point:
+                arg1 = point(arg1)
+        except:
+            return union_pw_aff(arg0).eval(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_eval(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_point_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def floor(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_floor(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def ge_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).ge_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_ge_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_gist(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def gt_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).gt_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_gt_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            return union_pw_aff(arg0).insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_insert_domain(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_aff(arg0).intersect_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_intersect_domain(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_aff(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_intersect_params(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def isa_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_isa_aff(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def le_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).le_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_le_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def lt_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).lt_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_lt_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def max(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).max(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_max(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def min(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).min(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_min(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def mod(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_mod_val(isl.isl_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def mul(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).mul(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_mul(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def ne_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).ne_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_ne_set(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_neg(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def param_on_domain(*args):
+        if len(args) == 2 and args0.__class__ is set and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_param_on_domain_id(isl.isl_set_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_pullback_multi_aff(isl.isl_pw_aff_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_pullback_multi_pw_aff(isl.isl_pw_aff_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_pullback_pw_multi_aff(isl.isl_pw_aff_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_scale_val(isl.isl_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_pw_aff_scale_down_val(isl.isl_pw_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = pw_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_sub(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def subtract_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_pw_aff(arg0).subtract_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_subtract_domain(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def tdiv_q(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).tdiv_q(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_tdiv_q(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def tdiv_r(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).tdiv_r(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_tdiv_r(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_to_list(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def to_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_to_union_pw_aff(isl.isl_pw_aff_copy(arg0.ptr))
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def union_add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff:
+                arg0 = pw_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            return union_pw_aff(arg0).union_add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_union_add(isl.isl_pw_aff_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_pw_aff_from_aff.restype = c_void_p
+isl.isl_pw_aff_from_aff.argtypes = c_void_p
+isl.isl_pw_aff_read_from_str.restype = c_void_p
+isl.isl_pw_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_pw_aff_add.restype = c_void_p
+isl.isl_pw_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_add_constant_val.restype = c_void_p
+isl.isl_pw_aff_add_constant_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_as_aff.restype = c_void_p
+isl.isl_pw_aff_as_aff.argtypes = c_void_p
+isl.isl_pw_aff_as_map.restype = c_void_p
+isl.isl_pw_aff_as_map.argtypes = c_void_p
+isl.isl_pw_aff_bind_id.restype = c_void_p
+isl.isl_pw_aff_bind_id.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_bind_domain.restype = c_void_p
+isl.isl_pw_aff_bind_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_bind_domain_wrapped_domain.restype = c_void_p
+isl.isl_pw_aff_bind_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_ceil.restype = c_void_p
+isl.isl_pw_aff_ceil.argtypes = c_void_p
+isl.isl_pw_aff_coalesce.restype = c_void_p
+isl.isl_pw_aff_coalesce.argtypes = c_void_p
+isl.isl_pw_aff_cond.restype = c_void_p
+isl.isl_pw_aff_cond.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_pw_aff_div.restype = c_void_p
+isl.isl_pw_aff_div.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_domain.restype = c_void_p
+isl.isl_pw_aff_domain.argtypes = c_void_p
+isl.isl_pw_aff_eq_set.restype = c_void_p
+isl.isl_pw_aff_eq_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_eval.restype = c_void_p
+isl.isl_pw_aff_eval.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_floor.restype = c_void_p
+isl.isl_pw_aff_floor.argtypes = c_void_p
+isl.isl_pw_aff_ge_set.restype = c_void_p
+isl.isl_pw_aff_ge_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_gist.restype = c_void_p
+isl.isl_pw_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_gt_set.restype = c_void_p
+isl.isl_pw_aff_gt_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_insert_domain.restype = c_void_p
+isl.isl_pw_aff_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_intersect_domain.restype = c_void_p
+isl.isl_pw_aff_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_intersect_params.restype = c_void_p
+isl.isl_pw_aff_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_isa_aff.argtypes = c_void_p
+isl.isl_pw_aff_le_set.restype = c_void_p
+isl.isl_pw_aff_le_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_lt_set.restype = c_void_p
+isl.isl_pw_aff_lt_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_max.restype = c_void_p
+isl.isl_pw_aff_max.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_min.restype = c_void_p
+isl.isl_pw_aff_min.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_mod_val.restype = c_void_p
+isl.isl_pw_aff_mod_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_mul.restype = c_void_p
+isl.isl_pw_aff_mul.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_ne_set.restype = c_void_p
+isl.isl_pw_aff_ne_set.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_neg.restype = c_void_p
+isl.isl_pw_aff_neg.argtypes = c_void_p
+isl.isl_pw_aff_param_on_domain_id.restype = c_void_p
+isl.isl_pw_aff_param_on_domain_id.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_pullback_multi_aff.restype = c_void_p
+isl.isl_pw_aff_pullback_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_pullback_multi_pw_aff.restype = c_void_p
+isl.isl_pw_aff_pullback_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_pullback_pw_multi_aff.restype = c_void_p
+isl.isl_pw_aff_pullback_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_scale_val.restype = c_void_p
+isl.isl_pw_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_scale_down_val.restype = c_void_p
+isl.isl_pw_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_sub.restype = c_void_p
+isl.isl_pw_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_subtract_domain.restype = c_void_p
+isl.isl_pw_aff_subtract_domain.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_tdiv_q.restype = c_void_p
+isl.isl_pw_aff_tdiv_q.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_tdiv_r.restype = c_void_p
+isl.isl_pw_aff_tdiv_r.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_to_list.restype = c_void_p
+isl.isl_pw_aff_to_list.argtypes = c_void_p
+isl.isl_pw_aff_to_union_pw_aff.restype = c_void_p
+isl.isl_pw_aff_to_union_pw_aff.argtypes = c_void_p
+isl.isl_pw_aff_union_add.restype = c_void_p
+isl.isl_pw_aff_union_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_copy.restype = c_void_p
+isl.isl_pw_aff_copy.argtypes = c_void_p
+isl.isl_pw_aff_free.restype = c_void_p
+isl.isl_pw_aff_free.argtypes = c_void_p
+isl.isl_pw_aff_to_str.restype = POINTER(c_char)
+isl.isl_pw_aff_to_str.argtypes = c_void_p
+
+class multi_aff(pw_multi_aff, multi_pw_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_aff_from_aff(isl.isl_aff_copy(args0.ptr))
+            return
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is aff_list:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_aff_from_aff_list(isl.isl_space_copy(args0.ptr), isl.isl_aff_list_copy(args1.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_multi_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_multi_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.multi_aff("""%s""")' % s
+        else:
+            return 'isl.multi_aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_add(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_aff_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def add_constant(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_add_constant_multi_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_add_constant_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def as_map(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_as_map(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def as_set(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_as_set(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_get_at(arg0.ptr, arg1)
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def bind(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return pw_multi_aff(arg0).bind(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_bind(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return pw_multi_aff(arg0).bind_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_bind_domain(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain_wrapped_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return pw_multi_aff(arg0).bind_domain_wrapped_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_bind_domain_wrapped_domain(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def constant_multi_val(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_get_constant_multi_val(arg0.ptr)
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def get_constant_multi_val(arg0):
+        return arg0.constant_multi_val()
+    @staticmethod
+    def domain_map(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_domain_map(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).flat_range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_flat_range_product(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_aff_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def floor(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_floor(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return pw_multi_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_gist(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def identity(*args):
+        if len(args) == 1:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_identity_multi_aff(isl.isl_multi_aff_copy(args0.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    @staticmethod
+    def identity_on_domain(*args):
+        if len(args) == 1 and args0.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_identity_on_domain_space(isl.isl_space_copy(args0.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            return pw_multi_aff(arg0).insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_insert_domain(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def involves_locals(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_involves_locals(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def involves_nan(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_involves_nan(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def list(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_get_list(arg0.ptr)
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def get_list(arg0):
+        return arg0.list()
+    @staticmethod
+    def multi_val_on_domain(*args):
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_multi_val_on_domain_space(isl.isl_space_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_neg(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def plain_is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).plain_is_equal(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_plain_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_product(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_aff_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_pullback_multi_aff(isl.isl_multi_aff_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    @staticmethod
+    def range_map(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_range_map(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_range_product(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_aff_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reset_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_reset_range_tuple_id(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def scale(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_scale_multi_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_scale_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_scale_down_multi_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_scale_down_val(isl.isl_multi_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_at(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is aff:
+                arg2 = aff(arg2)
+        except:
+            return pw_multi_aff(arg0).set_at(arg1, arg2)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_set_at(isl.isl_multi_aff_copy(arg0.ptr), arg1, isl.isl_aff_copy(arg2.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_aff_set_range_tuple_id(isl.isl_multi_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def size(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def space(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_aff:
+                arg1 = multi_aff(arg1)
+        except:
+            return pw_multi_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_sub(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_aff_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_to_multi_pw_aff(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_multi_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_to_multi_union_pw_aff(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def to_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_to_pw_multi_aff(isl.isl_multi_aff_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def unbind_params_insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_aff:
+                arg0 = multi_aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return pw_multi_aff(arg0).unbind_params_insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_unbind_params_insert_domain(isl.isl_multi_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_aff_zero(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_multi_aff_from_aff.restype = c_void_p
+isl.isl_multi_aff_from_aff.argtypes = c_void_p
+isl.isl_multi_aff_from_aff_list.restype = c_void_p
+isl.isl_multi_aff_from_aff_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_read_from_str.restype = c_void_p
+isl.isl_multi_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_multi_aff_add.restype = c_void_p
+isl.isl_multi_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_add_constant_multi_val.restype = c_void_p
+isl.isl_multi_aff_add_constant_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_add_constant_val.restype = c_void_p
+isl.isl_multi_aff_add_constant_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_as_map.restype = c_void_p
+isl.isl_multi_aff_as_map.argtypes = c_void_p
+isl.isl_multi_aff_as_set.restype = c_void_p
+isl.isl_multi_aff_as_set.argtypes = c_void_p
+isl.isl_multi_aff_get_at.restype = c_void_p
+isl.isl_multi_aff_get_at.argtypes = c_void_p, c_int
+isl.isl_multi_aff_bind.restype = c_void_p
+isl.isl_multi_aff_bind.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_bind_domain.restype = c_void_p
+isl.isl_multi_aff_bind_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_bind_domain_wrapped_domain.restype = c_void_p
+isl.isl_multi_aff_bind_domain_wrapped_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_get_constant_multi_val.restype = c_void_p
+isl.isl_multi_aff_get_constant_multi_val.argtypes = c_void_p
+isl.isl_multi_aff_domain_map.restype = c_void_p
+isl.isl_multi_aff_domain_map.argtypes = c_void_p
+isl.isl_multi_aff_flat_range_product.restype = c_void_p
+isl.isl_multi_aff_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_floor.restype = c_void_p
+isl.isl_multi_aff_floor.argtypes = c_void_p
+isl.isl_multi_aff_gist.restype = c_void_p
+isl.isl_multi_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_has_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_aff_identity_multi_aff.restype = c_void_p
+isl.isl_multi_aff_identity_multi_aff.argtypes = c_void_p
+isl.isl_multi_aff_identity_on_domain_space.restype = c_void_p
+isl.isl_multi_aff_identity_on_domain_space.argtypes = c_void_p
+isl.isl_multi_aff_insert_domain.restype = c_void_p
+isl.isl_multi_aff_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_involves_locals.argtypes = c_void_p
+isl.isl_multi_aff_involves_nan.argtypes = c_void_p
+isl.isl_multi_aff_get_list.restype = c_void_p
+isl.isl_multi_aff_get_list.argtypes = c_void_p
+isl.isl_multi_aff_multi_val_on_domain_space.restype = c_void_p
+isl.isl_multi_aff_multi_val_on_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_neg.restype = c_void_p
+isl.isl_multi_aff_neg.argtypes = c_void_p
+isl.isl_multi_aff_plain_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_product.restype = c_void_p
+isl.isl_multi_aff_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_pullback_multi_aff.restype = c_void_p
+isl.isl_multi_aff_pullback_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_range_map.restype = c_void_p
+isl.isl_multi_aff_range_map.argtypes = c_void_p
+isl.isl_multi_aff_range_product.restype = c_void_p
+isl.isl_multi_aff_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_get_range_tuple_id.restype = c_void_p
+isl.isl_multi_aff_get_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_aff_reset_range_tuple_id.restype = c_void_p
+isl.isl_multi_aff_reset_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_aff_scale_multi_val.restype = c_void_p
+isl.isl_multi_aff_scale_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_scale_val.restype = c_void_p
+isl.isl_multi_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_scale_down_multi_val.restype = c_void_p
+isl.isl_multi_aff_scale_down_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_scale_down_val.restype = c_void_p
+isl.isl_multi_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_set_at.restype = c_void_p
+isl.isl_multi_aff_set_at.argtypes = c_void_p, c_int, c_void_p
+isl.isl_multi_aff_set_range_tuple_id.restype = c_void_p
+isl.isl_multi_aff_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_size.argtypes = c_void_p
+isl.isl_multi_aff_get_space.restype = c_void_p
+isl.isl_multi_aff_get_space.argtypes = c_void_p
+isl.isl_multi_aff_sub.restype = c_void_p
+isl.isl_multi_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_to_multi_pw_aff.restype = c_void_p
+isl.isl_multi_aff_to_multi_pw_aff.argtypes = c_void_p
+isl.isl_multi_aff_to_multi_union_pw_aff.restype = c_void_p
+isl.isl_multi_aff_to_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_multi_aff_to_pw_multi_aff.restype = c_void_p
+isl.isl_multi_aff_to_pw_multi_aff.argtypes = c_void_p
+isl.isl_multi_aff_unbind_params_insert_domain.restype = c_void_p
+isl.isl_multi_aff_unbind_params_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_multi_aff_zero.restype = c_void_p
+isl.isl_multi_aff_zero.argtypes = c_void_p
+isl.isl_multi_aff_copy.restype = c_void_p
+isl.isl_multi_aff_copy.argtypes = c_void_p
+isl.isl_multi_aff_free.restype = c_void_p
+isl.isl_multi_aff_free.argtypes = c_void_p
+isl.isl_multi_aff_to_str.restype = POINTER(c_char)
+isl.isl_multi_aff_to_str.argtypes = c_void_p
+
+class aff(pw_aff, multi_aff):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_aff_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_aff_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ptr = isl.isl_aff_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.aff("""%s""")' % s
+        else:
+            return 'isl.aff("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).add(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_add(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def add_constant(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_aff_add_constant_val(isl.isl_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def bind(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_aff_bind_id(isl.isl_aff_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = basic_set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def ceil(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_ceil(isl.isl_aff_copy(arg0.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def constant_val(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_get_constant_val(arg0.ptr)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def get_constant_val(arg0):
+        return arg0.constant_val()
+    def div(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).div(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_div(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def eq_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).eq_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_eq_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def eval(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is point:
+                arg1 = point(arg1)
+        except:
+            return pw_aff(arg0).eval(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_eval(isl.isl_aff_copy(arg0.ptr), isl.isl_point_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def floor(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_floor(isl.isl_aff_copy(arg0.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def ge_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).ge_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_ge_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return pw_aff(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_gist(isl.isl_aff_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def gt_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).gt_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_gt_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def is_cst(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_is_cst(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def le_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).le_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_le_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def lt_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).lt_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_lt_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def mod(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_aff_mod_val(isl.isl_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def mul(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).mul(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_mul(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def ne_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).ne_set(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_ne_set(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_neg(isl.isl_aff_copy(arg0.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_aff_pullback_multi_aff(isl.isl_aff_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_aff_scale_val(isl.isl_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_aff_scale_down_val(isl.isl_aff_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return pw_aff(arg0).sub(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_sub(isl.isl_aff_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_to_list(isl.isl_aff_copy(arg0.ptr))
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def unbind_params_insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff:
+                arg0 = aff(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return pw_aff(arg0).unbind_params_insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_aff_unbind_params_insert_domain(isl.isl_aff_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero_on_domain(*args):
+        if len(args) == 1 and args0.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_aff_zero_on_domain_space(isl.isl_space_copy(args0.ptr))
+            obj = aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+
+isl.isl_aff_read_from_str.restype = c_void_p
+isl.isl_aff_read_from_str.argtypes = Context, c_char_p
+isl.isl_aff_add.restype = c_void_p
+isl.isl_aff_add.argtypes = c_void_p, c_void_p
+isl.isl_aff_add_constant_val.restype = c_void_p
+isl.isl_aff_add_constant_val.argtypes = c_void_p, c_void_p
+isl.isl_aff_bind_id.restype = c_void_p
+isl.isl_aff_bind_id.argtypes = c_void_p, c_void_p
+isl.isl_aff_ceil.restype = c_void_p
+isl.isl_aff_ceil.argtypes = c_void_p
+isl.isl_aff_get_constant_val.restype = c_void_p
+isl.isl_aff_get_constant_val.argtypes = c_void_p
+isl.isl_aff_div.restype = c_void_p
+isl.isl_aff_div.argtypes = c_void_p, c_void_p
+isl.isl_aff_eq_set.restype = c_void_p
+isl.isl_aff_eq_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_eval.restype = c_void_p
+isl.isl_aff_eval.argtypes = c_void_p, c_void_p
+isl.isl_aff_floor.restype = c_void_p
+isl.isl_aff_floor.argtypes = c_void_p
+isl.isl_aff_ge_set.restype = c_void_p
+isl.isl_aff_ge_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_gist.restype = c_void_p
+isl.isl_aff_gist.argtypes = c_void_p, c_void_p
+isl.isl_aff_gt_set.restype = c_void_p
+isl.isl_aff_gt_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_is_cst.argtypes = c_void_p
+isl.isl_aff_le_set.restype = c_void_p
+isl.isl_aff_le_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_lt_set.restype = c_void_p
+isl.isl_aff_lt_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_mod_val.restype = c_void_p
+isl.isl_aff_mod_val.argtypes = c_void_p, c_void_p
+isl.isl_aff_mul.restype = c_void_p
+isl.isl_aff_mul.argtypes = c_void_p, c_void_p
+isl.isl_aff_ne_set.restype = c_void_p
+isl.isl_aff_ne_set.argtypes = c_void_p, c_void_p
+isl.isl_aff_neg.restype = c_void_p
+isl.isl_aff_neg.argtypes = c_void_p
+isl.isl_aff_pullback_multi_aff.restype = c_void_p
+isl.isl_aff_pullback_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_aff_scale_val.restype = c_void_p
+isl.isl_aff_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_aff_scale_down_val.restype = c_void_p
+isl.isl_aff_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_aff_sub.restype = c_void_p
+isl.isl_aff_sub.argtypes = c_void_p, c_void_p
+isl.isl_aff_to_list.restype = c_void_p
+isl.isl_aff_to_list.argtypes = c_void_p
+isl.isl_aff_unbind_params_insert_domain.restype = c_void_p
+isl.isl_aff_unbind_params_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_aff_zero_on_domain_space.restype = c_void_p
+isl.isl_aff_zero_on_domain_space.argtypes = c_void_p
+isl.isl_aff_copy.restype = c_void_p
+isl.isl_aff_copy.argtypes = c_void_p
+isl.isl_aff_free.restype = c_void_p
+isl.isl_aff_free.argtypes = c_void_p
+isl.isl_aff_to_str.restype = POINTER(c_char)
+isl.isl_aff_to_str.argtypes = c_void_p
+
+class aff_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_aff_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_aff_list_from_aff(isl.isl_aff_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_aff_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_aff_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.aff_list("""%s""")' % s
+        else:
+            return 'isl.aff_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_add(isl.isl_aff_list_copy(arg0.ptr), isl.isl_aff_copy(arg1.ptr))
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_get_at(arg0.ptr, arg1)
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_clear(isl.isl_aff_list_copy(arg0.ptr))
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff_list:
+                arg1 = aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_concat(isl.isl_aff_list_copy(arg0.ptr), isl.isl_aff_list_copy(arg1.ptr))
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_drop(isl.isl_aff_list_copy(arg0.ptr), arg1, arg2)
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = aff(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is aff:
+                arg2 = aff(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_insert(isl.isl_aff_list_copy(arg0.ptr), arg1, isl.isl_aff_copy(arg2.ptr))
+        obj = aff_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is aff_list:
+                arg0 = aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_aff_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_aff_list_alloc.restype = c_void_p
+isl.isl_aff_list_alloc.argtypes = Context, c_int
+isl.isl_aff_list_from_aff.restype = c_void_p
+isl.isl_aff_list_from_aff.argtypes = c_void_p
+isl.isl_aff_list_add.restype = c_void_p
+isl.isl_aff_list_add.argtypes = c_void_p, c_void_p
+isl.isl_aff_list_get_at.restype = c_void_p
+isl.isl_aff_list_get_at.argtypes = c_void_p, c_int
+isl.isl_aff_list_clear.restype = c_void_p
+isl.isl_aff_list_clear.argtypes = c_void_p
+isl.isl_aff_list_concat.restype = c_void_p
+isl.isl_aff_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_aff_list_drop.restype = c_void_p
+isl.isl_aff_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_aff_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_aff_list_insert.restype = c_void_p
+isl.isl_aff_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_aff_list_size.argtypes = c_void_p
+isl.isl_aff_list_copy.restype = c_void_p
+isl.isl_aff_list_copy.argtypes = c_void_p
+isl.isl_aff_list_free.restype = c_void_p
+isl.isl_aff_list_free.argtypes = c_void_p
+isl.isl_aff_list_to_str.restype = POINTER(c_char)
+isl.isl_aff_list_to_str.argtypes = c_void_p
+
+class ast_build(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 0:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_ast_build_alloc(self.ctx)
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_build_free(self.ptr)
+    def copy_callbacks(self, obj):
+        if hasattr(obj, 'at_each_domain'):
+            self.at_each_domain = obj.at_each_domain
+    def set_at_each_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_build:
+                arg0 = ast_build(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_void_p, c_void_p, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1, cb_arg2):
+            cb_arg0 = ast_node(ctx=arg0.ctx, ptr=(cb_arg0))
+            cb_arg1 = ast_build(ctx=arg0.ctx, ptr=isl.isl_ast_build_copy(cb_arg1))
+            try:
+                res = arg1(cb_arg0, cb_arg1)
+            except BaseException as e:
+                exc_info0 = e
+                return None
+            return isl.isl_ast_node_copy(res.ptr)
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_ast_build_set_at_each_domain(isl.isl_ast_build_copy(arg0.ptr), cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if hasattr(arg0, 'at_each_domain') and arg0.at_each_domain'exc_info' != None:
+            exc_info = arg0.at_each_domain'exc_info'0
+            arg0.at_each_domain'exc_info'0 = None
+            if exc_info is not None:
+                raise exc_info
+        obj = ast_build(ctx=ctx, ptr=res)
+        obj.copy_callbacks(arg0)
+        obj.at_each_domain = { 'func': cb, 'exc_info': exc_info }
+        return obj
+    def access_from(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_access_from_multi_pw_aff(args0.ptr, isl.isl_multi_pw_aff_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_access_from_pw_multi_aff(args0.ptr, isl.isl_pw_multi_aff_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def call_from(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_call_from_multi_pw_aff(args0.ptr, isl.isl_multi_pw_aff_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_call_from_pw_multi_aff(args0.ptr, isl.isl_pw_multi_aff_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def expr_from(*args):
+        if len(args) == 2 and args1.__class__ is pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_expr_from_pw_aff(args0.ptr, isl.isl_pw_aff_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is set:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_expr_from_set(args0.ptr, isl.isl_set_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_expr(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    @staticmethod
+    def from_context(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_build_from_context(isl.isl_set_copy(arg0.ptr))
+        obj = ast_build(ctx=ctx, ptr=res)
+        return obj
+    def node_from(*args):
+        if len(args) == 2 and args1.__class__ is schedule:
+            ctx = args0.ctx
+            res = isl.isl_ast_build_node_from_schedule(args0.ptr, isl.isl_schedule_copy(args1.ptr))
+            if hasattr(args0, 'at_each_domain') and args0.at_each_domain'exc_info' != None:
+                exc_info = args0.at_each_domain'exc_info'0
+                args0.at_each_domain'exc_info'0 = None
+                if exc_info is not None:
+                    raise exc_info
+            obj = ast_node(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def node_from_schedule_map(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_build:
+                arg0 = ast_build(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_build_node_from_schedule_map(arg0.ptr, isl.isl_union_map_copy(arg1.ptr))
+        if hasattr(arg0, 'at_each_domain') and arg0.at_each_domain'exc_info' != None:
+            exc_info = arg0.at_each_domain'exc_info'0
+            arg0.at_each_domain'exc_info'0 = None
+            if exc_info is not None:
+                raise exc_info
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def schedule(arg0):
+        try:
+            if not arg0.__class__ is ast_build:
+                arg0 = ast_build(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_build_get_schedule(arg0.ptr)
+        if hasattr(arg0, 'at_each_domain') and arg0.at_each_domain'exc_info' != None:
+            exc_info = arg0.at_each_domain'exc_info'0
+            arg0.at_each_domain'exc_info'0 = None
+            if exc_info is not None:
+                raise exc_info
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_schedule(arg0):
+        return arg0.schedule()
+
+isl.isl_ast_build_alloc.restype = c_void_p
+isl.isl_ast_build_alloc.argtypes = Context
+isl.isl_ast_build_set_at_each_domain.restype = c_void_p
+isl.isl_ast_build_set_at_each_domain.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_ast_build_access_from_multi_pw_aff.restype = c_void_p
+isl.isl_ast_build_access_from_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_access_from_pw_multi_aff.restype = c_void_p
+isl.isl_ast_build_access_from_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_call_from_multi_pw_aff.restype = c_void_p
+isl.isl_ast_build_call_from_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_call_from_pw_multi_aff.restype = c_void_p
+isl.isl_ast_build_call_from_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_expr_from_pw_aff.restype = c_void_p
+isl.isl_ast_build_expr_from_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_expr_from_set.restype = c_void_p
+isl.isl_ast_build_expr_from_set.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_from_context.restype = c_void_p
+isl.isl_ast_build_from_context.argtypes = c_void_p
+isl.isl_ast_build_node_from_schedule.restype = c_void_p
+isl.isl_ast_build_node_from_schedule.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_node_from_schedule_map.restype = c_void_p
+isl.isl_ast_build_node_from_schedule_map.argtypes = c_void_p, c_void_p
+isl.isl_ast_build_get_schedule.restype = c_void_p
+isl.isl_ast_build_get_schedule.argtypes = c_void_p
+isl.isl_ast_build_copy.restype = c_void_p
+isl.isl_ast_build_copy.argtypes = c_void_p
+isl.isl_ast_build_free.restype = c_void_p
+isl.isl_ast_build_free.argtypes = c_void_p
+
+class ast_expr(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_id):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_int):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        if "ptr" in keywords:
+            type = isl.isl_ast_expr_get_type(keywords"ptr")
+            if type == 0:
+                return ast_expr_op(**keywords)
+            if type == 1:
+                return ast_expr_id(**keywords)
+            if type == 2:
+                return ast_expr_int(**keywords)
+            raise
+        return super(ast_expr, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr("""%s""")' % s
+        else:
+            return 'isl.ast_expr("%s")' % s
+    def to_C_str(arg0):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_expr_to_C_str(arg0.ptr)
+        if res == 0:
+            raise
+        string = cast(res, c_char_p).value.decode('ascii')
+        libc.free(res)
+        return string
+
+isl.isl_ast_expr_to_C_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_C_str.argtypes = c_void_p
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+isl.isl_ast_expr_get_type.argtypes = c_void_p
+
+class ast_expr_id(ast_expr):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_id, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_id:
+                arg0 = ast_expr_id(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_id("""%s""")' % s
+        else:
+            return 'isl.ast_expr_id("%s")' % s
+    def id(arg0):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_expr_id_get_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_id(arg0):
+        return arg0.id()
+
+isl.isl_ast_expr_id_get_id.restype = c_void_p
+isl.isl_ast_expr_id_get_id.argtypes = c_void_p
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_int(ast_expr):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_int, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_int:
+                arg0 = ast_expr_int(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_int("""%s""")' % s
+        else:
+            return 'isl.ast_expr_int("%s")' % s
+    def val(arg0):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_expr_int_get_val(arg0.ptr)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def get_val(arg0):
+        return arg0.val()
+
+isl.isl_ast_expr_int_get_val.restype = c_void_p
+isl.isl_ast_expr_int_get_val.argtypes = c_void_p
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op(ast_expr):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_and):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_and_then):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_or):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_or_else):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_max):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_min):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_minus):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_add):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_sub):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_mul):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_div):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_fdiv_q):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_pdiv_q):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_pdiv_r):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_zdiv_r):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_cond):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_select):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_eq):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_le):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_lt):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_ge):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_gt):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_call):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_access):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_member):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_expr_op_address_of):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_expr_copy(args0.ptr)
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        if "ptr" in keywords:
+            type = isl.isl_ast_expr_op_get_type(keywords"ptr")
+            if type == 0:
+                return ast_expr_op_and(**keywords)
+            if type == 1:
+                return ast_expr_op_and_then(**keywords)
+            if type == 2:
+                return ast_expr_op_or(**keywords)
+            if type == 3:
+                return ast_expr_op_or_else(**keywords)
+            if type == 4:
+                return ast_expr_op_max(**keywords)
+            if type == 5:
+                return ast_expr_op_min(**keywords)
+            if type == 6:
+                return ast_expr_op_minus(**keywords)
+            if type == 7:
+                return ast_expr_op_add(**keywords)
+            if type == 8:
+                return ast_expr_op_sub(**keywords)
+            if type == 9:
+                return ast_expr_op_mul(**keywords)
+            if type == 10:
+                return ast_expr_op_div(**keywords)
+            if type == 11:
+                return ast_expr_op_fdiv_q(**keywords)
+            if type == 12:
+                return ast_expr_op_pdiv_q(**keywords)
+            if type == 13:
+                return ast_expr_op_pdiv_r(**keywords)
+            if type == 14:
+                return ast_expr_op_zdiv_r(**keywords)
+            if type == 15:
+                return ast_expr_op_cond(**keywords)
+            if type == 16:
+                return ast_expr_op_select(**keywords)
+            if type == 17:
+                return ast_expr_op_eq(**keywords)
+            if type == 18:
+                return ast_expr_op_le(**keywords)
+            if type == 19:
+                return ast_expr_op_lt(**keywords)
+            if type == 20:
+                return ast_expr_op_ge(**keywords)
+            if type == 21:
+                return ast_expr_op_gt(**keywords)
+            if type == 22:
+                return ast_expr_op_call(**keywords)
+            if type == 23:
+                return ast_expr_op_access(**keywords)
+            if type == 24:
+                return ast_expr_op_member(**keywords)
+            if type == 25:
+                return ast_expr_op_address_of(**keywords)
+            raise
+        return super(ast_expr_op, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op:
+                arg0 = ast_expr_op(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op("%s")' % s
+    def arg(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_expr_op_get_arg(arg0.ptr, arg1)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_arg(arg0, arg1):
+        return arg0.arg(arg1)
+    def n_arg(arg0):
+        try:
+            if not arg0.__class__ is ast_expr:
+                arg0 = ast_expr(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_expr_op_get_n_arg(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def get_n_arg(arg0):
+        return arg0.n_arg()
+
+isl.isl_ast_expr_op_get_arg.restype = c_void_p
+isl.isl_ast_expr_op_get_arg.argtypes = c_void_p, c_int
+isl.isl_ast_expr_op_get_n_arg.argtypes = c_void_p
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+isl.isl_ast_expr_op_get_type.argtypes = c_void_p
+
+class ast_expr_op_access(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_access, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_access:
+                arg0 = ast_expr_op_access(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_access("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_access("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_add(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_add, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_add:
+                arg0 = ast_expr_op_add(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_add("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_add("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_address_of(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_address_of, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_address_of:
+                arg0 = ast_expr_op_address_of(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_address_of("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_address_of("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_and(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_and, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_and:
+                arg0 = ast_expr_op_and(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_and("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_and("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_and_then(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_and_then, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_and_then:
+                arg0 = ast_expr_op_and_then(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_and_then("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_and_then("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_call(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_call, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_call:
+                arg0 = ast_expr_op_call(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_call("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_call("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_cond(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_cond, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_cond:
+                arg0 = ast_expr_op_cond(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_cond("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_cond("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_div(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_div, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_div:
+                arg0 = ast_expr_op_div(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_div("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_div("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_eq(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_eq, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_eq:
+                arg0 = ast_expr_op_eq(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_eq("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_eq("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_fdiv_q(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_fdiv_q, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_fdiv_q:
+                arg0 = ast_expr_op_fdiv_q(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_fdiv_q("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_fdiv_q("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_ge(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_ge, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_ge:
+                arg0 = ast_expr_op_ge(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_ge("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_ge("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_gt(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_gt, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_gt:
+                arg0 = ast_expr_op_gt(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_gt("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_gt("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_le(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_le, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_le:
+                arg0 = ast_expr_op_le(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_le("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_le("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_lt(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_lt, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_lt:
+                arg0 = ast_expr_op_lt(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_lt("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_lt("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_max(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_max, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_max:
+                arg0 = ast_expr_op_max(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_max("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_max("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_member(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_member, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_member:
+                arg0 = ast_expr_op_member(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_member("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_member("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_min(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_min, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_min:
+                arg0 = ast_expr_op_min(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_min("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_min("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_minus(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_minus, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_minus:
+                arg0 = ast_expr_op_minus(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_minus("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_minus("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_mul(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_mul, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_mul:
+                arg0 = ast_expr_op_mul(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_mul("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_mul("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_or(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_or, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_or:
+                arg0 = ast_expr_op_or(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_or("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_or("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_or_else(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_or_else, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_or_else:
+                arg0 = ast_expr_op_or_else(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_or_else("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_or_else("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_pdiv_q(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_pdiv_q, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_pdiv_q:
+                arg0 = ast_expr_op_pdiv_q(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_pdiv_q("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_pdiv_q("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_pdiv_r(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_pdiv_r, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_pdiv_r:
+                arg0 = ast_expr_op_pdiv_r(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_pdiv_r("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_pdiv_r("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_select(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_select, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_select:
+                arg0 = ast_expr_op_select(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_select("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_select("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_sub(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_sub, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_sub:
+                arg0 = ast_expr_op_sub(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_sub("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_sub("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_expr_op_zdiv_r(ast_expr_op):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_expr_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_expr_op_zdiv_r, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_expr_op_zdiv_r:
+                arg0 = ast_expr_op_zdiv_r(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_expr_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_expr_op_zdiv_r("""%s""")' % s
+        else:
+            return 'isl.ast_expr_op_zdiv_r("%s")' % s
+
+isl.isl_ast_expr_copy.restype = c_void_p
+isl.isl_ast_expr_copy.argtypes = c_void_p
+isl.isl_ast_expr_free.restype = c_void_p
+isl.isl_ast_expr_free.argtypes = c_void_p
+isl.isl_ast_expr_to_str.restype = POINTER(c_char)
+isl.isl_ast_expr_to_str.argtypes = c_void_p
+
+class ast_node(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and isinstance(args0, ast_node_for):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_node_if):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_node_block):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_node_mark):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, ast_node_user):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_ast_node_copy(args0.ptr)
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        if "ptr" in keywords:
+            type = isl.isl_ast_node_get_type(keywords"ptr")
+            if type == 1:
+                return ast_node_for(**keywords)
+            if type == 2:
+                return ast_node_if(**keywords)
+            if type == 3:
+                return ast_node_block(**keywords)
+            if type == 4:
+                return ast_node_mark(**keywords)
+            if type == 5:
+                return ast_node_user(**keywords)
+            raise
+        return super(ast_node, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node("""%s""")' % s
+        else:
+            return 'isl.ast_node("%s")' % s
+    def to_C_str(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_to_C_str(arg0.ptr)
+        if res == 0:
+            raise
+        string = cast(res, c_char_p).value.decode('ascii')
+        libc.free(res)
+        return string
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_to_list(isl.isl_ast_node_copy(arg0.ptr))
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_ast_node_to_C_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_C_str.argtypes = c_void_p
+isl.isl_ast_node_to_list.restype = c_void_p
+isl.isl_ast_node_to_list.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+isl.isl_ast_node_get_type.argtypes = c_void_p
+
+class ast_node_block(ast_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_node_block, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_block:
+                arg0 = ast_node_block(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_block("""%s""")' % s
+        else:
+            return 'isl.ast_node_block("%s")' % s
+    def children(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_block_get_children(arg0.ptr)
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def get_children(arg0):
+        return arg0.children()
+
+isl.isl_ast_node_block_get_children.restype = c_void_p
+isl.isl_ast_node_block_get_children.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+
+class ast_node_for(ast_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_node_for, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_for:
+                arg0 = ast_node_for(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_for("""%s""")' % s
+        else:
+            return 'isl.ast_node_for("%s")' % s
+    def body(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_get_body(arg0.ptr)
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def get_body(arg0):
+        return arg0.body()
+    def cond(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_get_cond(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_cond(arg0):
+        return arg0.cond()
+    def inc(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_get_inc(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_inc(arg0):
+        return arg0.inc()
+    def init(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_get_init(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_init(arg0):
+        return arg0.init()
+    def is_degenerate(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_is_degenerate(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def iterator(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_for_get_iterator(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_iterator(arg0):
+        return arg0.iterator()
+
+isl.isl_ast_node_for_get_body.restype = c_void_p
+isl.isl_ast_node_for_get_body.argtypes = c_void_p
+isl.isl_ast_node_for_get_cond.restype = c_void_p
+isl.isl_ast_node_for_get_cond.argtypes = c_void_p
+isl.isl_ast_node_for_get_inc.restype = c_void_p
+isl.isl_ast_node_for_get_inc.argtypes = c_void_p
+isl.isl_ast_node_for_get_init.restype = c_void_p
+isl.isl_ast_node_for_get_init.argtypes = c_void_p
+isl.isl_ast_node_for_is_degenerate.argtypes = c_void_p
+isl.isl_ast_node_for_get_iterator.restype = c_void_p
+isl.isl_ast_node_for_get_iterator.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+
+class ast_node_if(ast_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_node_if, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_if:
+                arg0 = ast_node_if(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_if("""%s""")' % s
+        else:
+            return 'isl.ast_node_if("%s")' % s
+    def cond(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_if_get_cond(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_cond(arg0):
+        return arg0.cond()
+    def else_node(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_if_get_else_node(arg0.ptr)
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def get_else_node(arg0):
+        return arg0.else_node()
+    def has_else_node(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_if_has_else_node(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def then_node(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_if_get_then_node(arg0.ptr)
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def get_then_node(arg0):
+        return arg0.then_node()
+
+isl.isl_ast_node_if_get_cond.restype = c_void_p
+isl.isl_ast_node_if_get_cond.argtypes = c_void_p
+isl.isl_ast_node_if_get_else_node.restype = c_void_p
+isl.isl_ast_node_if_get_else_node.argtypes = c_void_p
+isl.isl_ast_node_if_has_else_node.argtypes = c_void_p
+isl.isl_ast_node_if_get_then_node.restype = c_void_p
+isl.isl_ast_node_if_get_then_node.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+
+class ast_node_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_ast_node_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is ast_node:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_ast_node_list_from_ast_node(isl.isl_ast_node_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_list("""%s""")' % s
+        else:
+            return 'isl.ast_node_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is ast_node:
+                arg1 = ast_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_add(isl.isl_ast_node_list_copy(arg0.ptr), isl.isl_ast_node_copy(arg1.ptr))
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_get_at(arg0.ptr, arg1)
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_clear(isl.isl_ast_node_list_copy(arg0.ptr))
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is ast_node_list:
+                arg1 = ast_node_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_concat(isl.isl_ast_node_list_copy(arg0.ptr), isl.isl_ast_node_list_copy(arg1.ptr))
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_drop(isl.isl_ast_node_list_copy(arg0.ptr), arg1, arg2)
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = ast_node(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is ast_node:
+                arg2 = ast_node(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_insert(isl.isl_ast_node_list_copy(arg0.ptr), arg1, isl.isl_ast_node_copy(arg2.ptr))
+        obj = ast_node_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is ast_node_list:
+                arg0 = ast_node_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_ast_node_list_alloc.restype = c_void_p
+isl.isl_ast_node_list_alloc.argtypes = Context, c_int
+isl.isl_ast_node_list_from_ast_node.restype = c_void_p
+isl.isl_ast_node_list_from_ast_node.argtypes = c_void_p
+isl.isl_ast_node_list_add.restype = c_void_p
+isl.isl_ast_node_list_add.argtypes = c_void_p, c_void_p
+isl.isl_ast_node_list_get_at.restype = c_void_p
+isl.isl_ast_node_list_get_at.argtypes = c_void_p, c_int
+isl.isl_ast_node_list_clear.restype = c_void_p
+isl.isl_ast_node_list_clear.argtypes = c_void_p
+isl.isl_ast_node_list_concat.restype = c_void_p
+isl.isl_ast_node_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_ast_node_list_drop.restype = c_void_p
+isl.isl_ast_node_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_ast_node_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_ast_node_list_insert.restype = c_void_p
+isl.isl_ast_node_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_ast_node_list_size.argtypes = c_void_p
+isl.isl_ast_node_list_copy.restype = c_void_p
+isl.isl_ast_node_list_copy.argtypes = c_void_p
+isl.isl_ast_node_list_free.restype = c_void_p
+isl.isl_ast_node_list_free.argtypes = c_void_p
+isl.isl_ast_node_list_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_list_to_str.argtypes = c_void_p
+
+class ast_node_mark(ast_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_node_mark, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_mark:
+                arg0 = ast_node_mark(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_mark("""%s""")' % s
+        else:
+            return 'isl.ast_node_mark("%s")' % s
+    def id(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_mark_get_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_id(arg0):
+        return arg0.id()
+    def node(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_mark_get_node(arg0.ptr)
+        obj = ast_node(ctx=ctx, ptr=res)
+        return obj
+    def get_node(arg0):
+        return arg0.node()
+
+isl.isl_ast_node_mark_get_id.restype = c_void_p
+isl.isl_ast_node_mark_get_id.argtypes = c_void_p
+isl.isl_ast_node_mark_get_node.restype = c_void_p
+isl.isl_ast_node_mark_get_node.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+
+class ast_node_user(ast_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_ast_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(ast_node_user, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is ast_node_user:
+                arg0 = ast_node_user(arg0)
+        except:
+            raise
+        ptr = isl.isl_ast_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.ast_node_user("""%s""")' % s
+        else:
+            return 'isl.ast_node_user("%s")' % s
+    def expr(arg0):
+        try:
+            if not arg0.__class__ is ast_node:
+                arg0 = ast_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_ast_node_user_get_expr(arg0.ptr)
+        obj = ast_expr(ctx=ctx, ptr=res)
+        return obj
+    def get_expr(arg0):
+        return arg0.expr()
+
+isl.isl_ast_node_user_get_expr.restype = c_void_p
+isl.isl_ast_node_user_get_expr.argtypes = c_void_p
+isl.isl_ast_node_copy.restype = c_void_p
+isl.isl_ast_node_copy.argtypes = c_void_p
+isl.isl_ast_node_free.restype = c_void_p
+isl.isl_ast_node_free.argtypes = c_void_p
+isl.isl_ast_node_to_str.restype = POINTER(c_char)
+isl.isl_ast_node_to_str.argtypes = c_void_p
+
+class union_map(object):
     def __init__(self, *args, **keywords):
         if "ptr" in keywords:
             self.ctx = keywords"ctx"
@@ -44,86 +6755,214 @@
             return
         if len(args) == 1 and type(args0) == str:
             self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_union_map_read_from_str(self.ctx, args0)
+            self.ptr = isl.isl_union_map_read_from_str(self.ctx, args0.encode('ascii'))
             return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_union_map_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_union_map_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_map_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.union_map("%s")' % str(self)
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_map("""%s""")' % s
+        else:
+            return 'isl.union_map("%s")' % s
     def affine_hull(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_affine_hull(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def polyhedral_hull(arg0):
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def apply_domain(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_polyhedral_hull(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_apply_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def apply_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_apply_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def as_map(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_as_map(isl.isl_union_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def as_multi_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_as_multi_union_pw_aff(isl.isl_union_map_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def as_union_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_as_union_pw_multi_aff(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_bind_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
     def coalesce(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_coalesce(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def lexmin(arg0):
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def compute_divs(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_lexmin(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def lexmax(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_compute_divs(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def curry(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_lexmax(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def union(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_curry(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def deltas(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_deltas(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def detect_equalities(arg0):
         try:
-            if not arg1.__class__ is union_map:
-                arg1 = union_map(arg1)
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_union(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def subtract(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_detect_equalities(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def domain_factor_domain(arg0):
         try:
-            if not arg1.__class__ is union_map:
-                arg1 = union_map(arg1)
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_subtract(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def intersect(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain_factor_domain(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def domain_factor_range(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain_factor_range(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def domain_map(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain_map(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def domain_map_union_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain_map_union_pw_multi_aff(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain_product(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
@@ -134,47 +6973,186 @@
                 arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_intersect(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def intersect_params(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_domain_product(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def empty(*args):
+        if len(args) == 0:
+            ctx = Context.getDefaultInstance()
+            res = isl.isl_union_map_empty_ctx(ctx)
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def eq_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_union_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_eq_at_multi_union_pw_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_multi_union_pw_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def every_map(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = map(ctx=arg0.ctx, ptr=isl.isl_map_copy(cb_arg0))
+            try:
+                res = arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 1 if res else 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_map_every_map(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+        return bool(res)
+    def extract_map(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
         except:
             raise
-        res = isl.isl_union_map_intersect_params(isl.isl_union_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def gist(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_extract_map(arg0.ptr, isl.isl_space_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def factor_domain(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_factor_domain(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def factor_range(arg0):
         try:
-            if not arg1.__class__ is union_map:
-                arg1 = union_map(arg1)
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_gist(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def gist_params(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_factor_range(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def fixed_power(*args):
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_union_map_fixed_power_val(isl.isl_union_map_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def foreach_map(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = map(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_map_foreach_map(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    @staticmethod
+    def convert_from(*args):
+        if len(args) == 1 and args0.__class__ is multi_union_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_from_multi_union_pw_aff(isl.isl_multi_union_pw_aff_copy(args0.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 1 and args0.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_from_union_pw_multi_aff(isl.isl_union_pw_multi_aff_copy(args0.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    @staticmethod
+    def from_domain(arg0):
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_map_gist_params(isl.isl_union_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_union_map_from_domain(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def from_domain_and_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_from_domain_and_range(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def from_range(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_from_range(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_gist(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
     def gist_domain(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
@@ -186,8 +7164,25 @@
                 arg1 = union_set(arg1)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_gist_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def gist_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_gist_params(isl.isl_union_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
     def gist_range(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
@@ -199,61 +7194,95 @@
                 arg1 = union_set(arg1)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_gist_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def intersect_domain(arg0, arg1):
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is union_set:
-                arg1 = union_set(arg1)
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_intersect_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def intersect_range(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_map_intersect_domain_space(isl.isl_union_map_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_map_intersect_domain_union_set(isl.isl_union_map_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def intersect_domain_factor_domain(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is union_set:
-                arg1 = union_set(arg1)
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_intersect_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def subtract_domain(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect_domain_factor_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain_factor_range(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is union_set:
-                arg1 = union_set(arg1)
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_subtract_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def subtract_range(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect_domain_factor_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is union_set:
-                arg1 = union_set(arg1)
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
         except:
             raise
-        res = isl.isl_union_map_subtract_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def apply_domain(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect_params(isl.isl_union_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range(*args):
+        if len(args) == 2 and args1.__class__ is space:
+            ctx = args0.ctx
+            res = isl.isl_union_map_intersect_range_space(isl.isl_union_map_copy(args0.ptr), isl.isl_space_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_set:
+            ctx = args0.ctx
+            res = isl.isl_union_map_intersect_range_union_set(isl.isl_union_map_copy(args0.ptr), isl.isl_union_set_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def intersect_range_factor_domain(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
@@ -264,9 +7293,11 @@
                 arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_apply_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def apply_range(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect_range_factor_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range_factor_range(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
@@ -277,64 +7308,102 @@
                 arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_apply_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def reverse(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_intersect_range_factor_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def is_bijective(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_reverse(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def detect_equalities(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_is_bijective(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_disjoint(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_detect_equalities(isl.isl_union_map_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def deltas(arg0):
         try:
-            if not arg0.__class__ is union_map:
-                arg0 = union_map(arg0)
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_deltas(isl.isl_union_map_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_union_map_is_disjoint(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_empty(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_is_empty(arg0.ptr)
-        return res
-    def is_single_valued(arg0):
+        if res < 0:
+            raise
+        return bool(res)
+    def is_equal(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_is_single_valued(arg0.ptr)
-        return res
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_injective(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_is_injective(arg0.ptr)
-        return res
-    def is_bijective(arg0):
+        if res < 0:
+            raise
+        return bool(res)
+    def is_single_valued(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        res = isl.isl_union_map_is_bijective(arg0.ptr)
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_union_map_is_single_valued(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_strict_subset(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_is_strict_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
@@ -346,9 +7415,92 @@
                 arg1 = union_map(arg1)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_map_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_equal(arg0, arg1):
+        if res < 0:
+            raise
+        return bool(res)
+    def isa_map(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_isa_map(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def lexmax(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_lexmax(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_lexmin(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def polyhedral_hull(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_polyhedral_hull(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def preimage_domain(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_domain_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_domain_multi_pw_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_domain_pw_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_domain_union_pw_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def preimage_range(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_range_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_range_pw_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_map_preimage_range_union_pw_multi_aff(isl.isl_union_map_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def product(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
@@ -359,9 +7511,61 @@
                 arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def is_strict_subset(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_product(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def project_out_all_params(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_project_out_all_params(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def range(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_domain(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range_factor_domain(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_range(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range_factor_range(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def range_map(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range_map(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
@@ -372,30 +7576,142 @@
                 arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_map_is_strict_subset(arg0.ptr, arg1.ptr)
-        return res
-    def foreach_map(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range_product(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def range_reverse(arg0):
         try:
             if not arg0.__class__ is union_map:
                 arg0 = union_map(arg0)
         except:
             raise
-        exc_info = None
-        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
-        def cb_func(cb_arg0, cb_arg1):
-            cb_arg0 = map(ctx=arg0.ctx, ptr=cb_arg0)
-            try:
-                arg1(cb_arg0)
-            except:
-                import sys
-                exc_info0 = sys.exc_info()
-                return -1
-            return 0
-        cb = fn(cb_func)
-        res = isl.isl_union_map_foreach_map(arg0.ptr, cb, None)
-        if exc_info0 != None:
-            raise exc_info00, exc_info01, exc_info02
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_union_map_range_reverse(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def reverse(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_reverse(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def space(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def subtract(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_subtract(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def subtract_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_subtract_domain(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def subtract_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_subtract_range(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def uncurry(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_uncurry(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_union(isl.isl_union_map_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def universe(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_universe(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def wrap(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_wrap(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def zip(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_map_zip(isl.isl_union_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
 
 isl.isl_union_map_from_basic_map.restype = c_void_p
 isl.isl_union_map_from_basic_map.argtypes = c_void_p
@@ -404,30 +7720,164 @@
 isl.isl_union_map_read_from_str.restype = c_void_p
 isl.isl_union_map_read_from_str.argtypes = Context, c_char_p
 isl.isl_union_map_affine_hull.restype = c_void_p
-isl.isl_union_map_polyhedral_hull.restype = c_void_p
+isl.isl_union_map_affine_hull.argtypes = c_void_p
+isl.isl_union_map_apply_domain.restype = c_void_p
+isl.isl_union_map_apply_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_map_apply_range.restype = c_void_p
+isl.isl_union_map_apply_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_as_map.restype = c_void_p
+isl.isl_union_map_as_map.argtypes = c_void_p
+isl.isl_union_map_as_multi_union_pw_aff.restype = c_void_p
+isl.isl_union_map_as_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_union_map_as_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_as_union_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_map_bind_range.restype = c_void_p
+isl.isl_union_map_bind_range.argtypes = c_void_p, c_void_p
 isl.isl_union_map_coalesce.restype = c_void_p
-isl.isl_union_map_lexmin.restype = c_void_p
-isl.isl_union_map_lexmax.restype = c_void_p
-isl.isl_union_map_union.restype = c_void_p
-isl.isl_union_map_subtract.restype = c_void_p
-isl.isl_union_map_intersect.restype = c_void_p
-isl.isl_union_map_intersect_params.restype = c_void_p
+isl.isl_union_map_coalesce.argtypes = c_void_p
+isl.isl_union_map_compute_divs.restype = c_void_p
+isl.isl_union_map_compute_divs.argtypes = c_void_p
+isl.isl_union_map_curry.restype = c_void_p
+isl.isl_union_map_curry.argtypes = c_void_p
+isl.isl_union_map_deltas.restype = c_void_p
+isl.isl_union_map_deltas.argtypes = c_void_p
+isl.isl_union_map_detect_equalities.restype = c_void_p
+isl.isl_union_map_detect_equalities.argtypes = c_void_p
+isl.isl_union_map_domain.restype = c_void_p
+isl.isl_union_map_domain.argtypes = c_void_p
+isl.isl_union_map_domain_factor_domain.restype = c_void_p
+isl.isl_union_map_domain_factor_domain.argtypes = c_void_p
+isl.isl_union_map_domain_factor_range.restype = c_void_p
+isl.isl_union_map_domain_factor_range.argtypes = c_void_p
+isl.isl_union_map_domain_map.restype = c_void_p
+isl.isl_union_map_domain_map.argtypes = c_void_p
+isl.isl_union_map_domain_map_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_domain_map_union_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_map_domain_product.restype = c_void_p
+isl.isl_union_map_domain_product.argtypes = c_void_p, c_void_p
+isl.isl_union_map_empty_ctx.restype = c_void_p
+isl.isl_union_map_empty_ctx.argtypes = Context
+isl.isl_union_map_eq_at_multi_union_pw_aff.restype = c_void_p
+isl.isl_union_map_eq_at_multi_union_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_every_map.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_map_extract_map.restype = c_void_p
+isl.isl_union_map_extract_map.argtypes = c_void_p, c_void_p
+isl.isl_union_map_factor_domain.restype = c_void_p
+isl.isl_union_map_factor_domain.argtypes = c_void_p
+isl.isl_union_map_factor_range.restype = c_void_p
+isl.isl_union_map_factor_range.argtypes = c_void_p
+isl.isl_union_map_fixed_power_val.restype = c_void_p
+isl.isl_union_map_fixed_power_val.argtypes = c_void_p, c_void_p
+isl.isl_union_map_foreach_map.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_map_from_multi_union_pw_aff.restype = c_void_p
+isl.isl_union_map_from_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_union_map_from_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_from_union_pw_multi_aff.argtypes = c_void_p
+isl.isl_union_map_from_domain.restype = c_void_p
+isl.isl_union_map_from_domain.argtypes = c_void_p
+isl.isl_union_map_from_domain_and_range.restype = c_void_p
+isl.isl_union_map_from_domain_and_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_from_range.restype = c_void_p
+isl.isl_union_map_from_range.argtypes = c_void_p
 isl.isl_union_map_gist.restype = c_void_p
-isl.isl_union_map_gist_params.restype = c_void_p
+isl.isl_union_map_gist.argtypes = c_void_p, c_void_p
 isl.isl_union_map_gist_domain.restype = c_void_p
+isl.isl_union_map_gist_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_map_gist_params.restype = c_void_p
+isl.isl_union_map_gist_params.argtypes = c_void_p, c_void_p
 isl.isl_union_map_gist_range.restype = c_void_p
-isl.isl_union_map_intersect_domain.restype = c_void_p
-isl.isl_union_map_intersect_range.restype = c_void_p
+isl.isl_union_map_gist_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect.restype = c_void_p
+isl.isl_union_map_intersect.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_domain_space.restype = c_void_p
+isl.isl_union_map_intersect_domain_space.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_domain_union_set.restype = c_void_p
+isl.isl_union_map_intersect_domain_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_domain_factor_domain.restype = c_void_p
+isl.isl_union_map_intersect_domain_factor_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_domain_factor_range.restype = c_void_p
+isl.isl_union_map_intersect_domain_factor_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_params.restype = c_void_p
+isl.isl_union_map_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_range_space.restype = c_void_p
+isl.isl_union_map_intersect_range_space.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_range_union_set.restype = c_void_p
+isl.isl_union_map_intersect_range_union_set.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_range_factor_domain.restype = c_void_p
+isl.isl_union_map_intersect_range_factor_domain.argtypes = c_void_p, c_void_p
+isl.isl_union_map_intersect_range_factor_range.restype = c_void_p
+isl.isl_union_map_intersect_range_factor_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_is_bijective.argtypes = c_void_p
+isl.isl_union_map_is_disjoint.argtypes = c_void_p, c_void_p
+isl.isl_union_map_is_empty.argtypes = c_void_p
+isl.isl_union_map_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_union_map_is_injective.argtypes = c_void_p
+isl.isl_union_map_is_single_valued.argtypes = c_void_p
+isl.isl_union_map_is_strict_subset.argtypes = c_void_p, c_void_p
+isl.isl_union_map_is_subset.argtypes = c_void_p, c_void_p
+isl.isl_union_map_isa_map.argtypes = c_void_p
+isl.isl_union_map_lexmax.restype = c_void_p
+isl.isl_union_map_lexmax.argtypes = c_void_p
+isl.isl_union_map_lexmin.restype = c_void_p
+isl.isl_union_map_lexmin.argtypes = c_void_p
+isl.isl_union_map_polyhedral_hull.restype = c_void_p
+isl.isl_union_map_polyhedral_hull.argtypes = c_void_p
+isl.isl_union_map_preimage_domain_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_domain_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_domain_multi_pw_aff.restype = c_void_p
+isl.isl_union_map_preimage_domain_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_domain_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_domain_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_domain_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_domain_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_range_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_range_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_range_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_range_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_preimage_range_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_map_preimage_range_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_map_product.restype = c_void_p
+isl.isl_union_map_product.argtypes = c_void_p, c_void_p
+isl.isl_union_map_project_out_all_params.restype = c_void_p
+isl.isl_union_map_project_out_all_params.argtypes = c_void_p
+isl.isl_union_map_range.restype = c_void_p
+isl.isl_union_map_range.argtypes = c_void_p
+isl.isl_union_map_range_factor_domain.restype = c_void_p
+isl.isl_union_map_range_factor_domain.argtypes = c_void_p
+isl.isl_union_map_range_factor_range.restype = c_void_p
+isl.isl_union_map_range_factor_range.argtypes = c_void_p
+isl.isl_union_map_range_map.restype = c_void_p
+isl.isl_union_map_range_map.argtypes = c_void_p
+isl.isl_union_map_range_product.restype = c_void_p
+isl.isl_union_map_range_product.argtypes = c_void_p, c_void_p
+isl.isl_union_map_range_reverse.restype = c_void_p
+isl.isl_union_map_range_reverse.argtypes = c_void_p
+isl.isl_union_map_reverse.restype = c_void_p
+isl.isl_union_map_reverse.argtypes = c_void_p
+isl.isl_union_map_get_space.restype = c_void_p
+isl.isl_union_map_get_space.argtypes = c_void_p
+isl.isl_union_map_subtract.restype = c_void_p
+isl.isl_union_map_subtract.argtypes = c_void_p, c_void_p
 isl.isl_union_map_subtract_domain.restype = c_void_p
+isl.isl_union_map_subtract_domain.argtypes = c_void_p, c_void_p
 isl.isl_union_map_subtract_range.restype = c_void_p
-isl.isl_union_map_apply_domain.restype = c_void_p
-isl.isl_union_map_apply_range.restype = c_void_p
-isl.isl_union_map_reverse.restype = c_void_p
-isl.isl_union_map_detect_equalities.restype = c_void_p
-isl.isl_union_map_deltas.restype = c_void_p
+isl.isl_union_map_subtract_range.argtypes = c_void_p, c_void_p
+isl.isl_union_map_uncurry.restype = c_void_p
+isl.isl_union_map_uncurry.argtypes = c_void_p
+isl.isl_union_map_union.restype = c_void_p
+isl.isl_union_map_union.argtypes = c_void_p, c_void_p
+isl.isl_union_map_universe.restype = c_void_p
+isl.isl_union_map_universe.argtypes = c_void_p
+isl.isl_union_map_wrap.restype = c_void_p
+isl.isl_union_map_wrap.argtypes = c_void_p
+isl.isl_union_map_zip.restype = c_void_p
+isl.isl_union_map_zip.argtypes = c_void_p
+isl.isl_union_map_copy.restype = c_void_p
+isl.isl_union_map_copy.argtypes = c_void_p
+isl.isl_union_map_free.restype = c_void_p
 isl.isl_union_map_free.argtypes = c_void_p
-isl.isl_union_map_to_str.argtypes = c_void_p
 isl.isl_union_map_to_str.restype = POINTER(c_char)
+isl.isl_union_map_to_str.argtypes = c_void_p
 
 class map(union_map):
     def __init__(self, *args, **keywords):
@@ -441,28 +7891,39 @@
             return
         if len(args) == 1 and type(args0) == str:
             self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_map_read_from_str(self.ctx, args0)
+            self.ptr = isl.isl_map_read_from_str(self.ctx, args0.encode('ascii'))
             return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_map_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_map_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ptr = isl.isl_map_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.map("%s")' % str(self)
-    def reverse(arg0):
+        s = str(self)
+        if '"' in s:
+            return 'isl.map("""%s""")' % s
+        else:
+            return 'isl.map("%s")' % s
+    def affine_hull(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_reverse(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def union(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_map_affine_hull(isl.isl_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def apply_domain(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -472,36 +7933,147 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).union(arg1)
-        res = isl.isl_map_union(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def intersect_domain(arg0, arg1):
+            return union_map(arg0).apply_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_apply_domain(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def apply_range(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
         except:
-            return union_map(arg0).intersect_domain(arg1)
-        res = isl.isl_map_intersect_domain(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def intersect_range(arg0, arg1):
+            return union_map(arg0).apply_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_apply_range(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def as_pw_multi_aff(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_map_as_pw_multi_aff(isl.isl_map_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind_domain(arg0, arg1):
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
         except:
-            return union_map(arg0).intersect_range(arg1)
-        res = isl.isl_map_intersect_range(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def apply_domain(arg0, arg1):
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_map(arg0).bind_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_bind_domain(isl.isl_map_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def bind_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_map(arg0).bind_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_bind_range(isl.isl_map_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_coalesce(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def complement(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_complement(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def curry(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_curry(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def deltas(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_deltas(isl.isl_map_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def detect_equalities(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_detect_equalities(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_domain(isl.isl_map_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def domain_factor_domain(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_domain_factor_domain(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def domain_factor_range(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_domain_factor_range(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def domain_product(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -511,10 +8083,115 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).apply_domain(arg1)
-        res = isl.isl_map_apply_domain(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def apply_range(arg0, arg1):
+            return union_map(arg0).domain_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_domain_product(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def domain_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_get_domain_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_domain_tuple_id(arg0):
+        return arg0.domain_tuple_id()
+    @staticmethod
+    def empty(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_empty(isl.isl_space_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def eq_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_eq_at_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def factor_domain(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_factor_domain(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def factor_range(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_factor_range(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def flatten(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_flatten(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def flatten_domain(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_flatten_domain(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def flatten_range(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_flatten_range(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def foreach_basic_map(arg0, arg1):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = basic_map(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_map_foreach_basic_map(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def gist(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -524,9 +8201,48 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).apply_range(arg1)
-        res = isl.isl_map_apply_range(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
+            return union_map(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_gist(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def gist_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_map(arg0).gist_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_gist_domain(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def has_domain_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_has_domain_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is map:
@@ -538,9 +8254,11 @@
                 arg1 = map(arg1)
         except:
             return union_map(arg0).intersect(arg1)
+        ctx = arg0.ctx
         res = isl.isl_map_intersect(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def intersect_params(arg0, arg1):
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -550,10 +8268,12 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_map(arg0).intersect_params(arg1)
-        res = isl.isl_map_intersect_params(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def subtract(arg0, arg1):
+            return union_map(arg0).intersect_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_domain(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain_factor_domain(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -563,105 +8283,178 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).subtract(arg1)
-        res = isl.isl_map_subtract(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def complement(arg0):
+            return union_map(arg0).intersect_domain_factor_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_domain_factor_domain(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_domain_factor_range(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_complement(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def deltas(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).intersect_domain_factor_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_domain_factor_range(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_deltas(isl.isl_map_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def detect_equalities(arg0):
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_map(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_params(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_detect_equalities(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def affine_hull(arg0):
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_map(arg0).intersect_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_range(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range_factor_domain(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_affine_hull(isl.isl_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def polyhedral_hull(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).intersect_range_factor_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_range_factor_domain(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range_factor_range(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_polyhedral_hull(isl.isl_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def flatten(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).intersect_range_factor_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_intersect_range_factor_range(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def is_bijective(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_flatten(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def flatten_domain(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_is_bijective(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_disjoint(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_flatten_domain(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def flatten_range(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).is_disjoint(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_is_disjoint(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_empty(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_flatten_range(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def lexmin(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_is_empty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_equal(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_lexmin(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def lexmax(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).is_equal(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_injective(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_lexmax(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def sample(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_is_injective(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_single_valued(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_sample(isl.isl_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def is_empty(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_is_single_valued(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_strict_subset(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_is_empty(arg0.ptr)
-        return res
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).is_strict_subset(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_is_strict_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is map:
@@ -673,35 +8466,146 @@
                 arg1 = map(arg1)
         except:
             return union_map(arg0).is_subset(arg1)
+        ctx = arg0.ctx
         res = isl.isl_map_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_strict_subset(arg0, arg1):
+        if res < 0:
+            raise
+        return bool(res)
+    def lex_ge_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_lex_ge_at_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def lex_gt_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_lex_gt_at_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def lex_le_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_lex_le_at_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def lex_lt_at(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_lex_lt_at_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def lexmax(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_map_lexmax(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def lexmax_pw_multi_aff(arg0):
         try:
-            if not arg1.__class__ is map:
-                arg1 = map(arg1)
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
         except:
-            return union_map(arg0).is_strict_subset(arg1)
-        res = isl.isl_map_is_strict_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_equal(arg0, arg1):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_lexmax_pw_multi_aff(isl.isl_map_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_map_lexmin(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def lexmin_pw_multi_aff(arg0):
         try:
-            if not arg1.__class__ is map:
-                arg1 = map(arg1)
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
         except:
-            return union_map(arg0).is_equal(arg1)
-        res = isl.isl_map_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def is_disjoint(arg0, arg1):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_lexmin_pw_multi_aff(isl.isl_map_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def lower_bound(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_lower_bound_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def max_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_max_multi_pw_aff(isl.isl_map_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def min_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_min_multi_pw_aff(isl.isl_map_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def polyhedral_hull(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_polyhedral_hull(isl.isl_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def preimage_domain(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_preimage_domain_multi_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_preimage_domain_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_preimage_domain_pw_multi_aff(isl.isl_map_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def preimage_range(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_preimage_range_multi_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_preimage_range_pw_multi_aff(isl.isl_map_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def product(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -711,34 +8615,52 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).is_disjoint(arg1)
-        res = isl.isl_map_is_disjoint(arg0.ptr, arg1.ptr)
-        return res
-    def is_single_valued(arg0):
+            return union_map(arg0).product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_product(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def project_out_all_params(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_is_single_valued(arg0.ptr)
-        return res
-    def is_injective(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_project_out_all_params(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def range(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_is_injective(arg0.ptr)
-        return res
-    def is_bijective(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_map_range(isl.isl_map_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_domain(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_is_bijective(arg0.ptr)
-        return res
-    def gist(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_map_range_factor_domain(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def range_factor_range(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_range_factor_range(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
@@ -748,83 +8670,369 @@
             if not arg1.__class__ is map:
                 arg1 = map(arg1)
         except:
-            return union_map(arg0).gist(arg1)
-        res = isl.isl_map_gist(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def gist_domain(arg0, arg1):
+            return union_map(arg0).range_product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_range_product(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def range_reverse(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_map_range_reverse(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def range_simple_fixed_box_hull(arg0):
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
         except:
-            return union_map(arg0).gist_domain(arg1)
-        res = isl.isl_map_gist_domain(isl.isl_map_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def coalesce(arg0):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_get_range_simple_fixed_box_hull(arg0.ptr)
+        obj = fixed_box(ctx=ctx, ptr=res)
+        return obj
+    def get_range_simple_fixed_box_hull(arg0):
+        return arg0.range_simple_fixed_box_hull()
+    def range_tuple_id(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        res = isl.isl_map_coalesce(isl.isl_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def foreach_basic_map(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_map_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reverse(arg0):
         try:
             if not arg0.__class__ is map:
                 arg0 = map(arg0)
         except:
             raise
-        exc_info = None
-        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
-        def cb_func(cb_arg0, cb_arg1):
-            cb_arg0 = basic_map(ctx=arg0.ctx, ptr=cb_arg0)
+        ctx = arg0.ctx
+        res = isl.isl_map_reverse(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def sample(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_sample(isl.isl_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def set_domain_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
             try:
-                arg1(cb_arg0)
+                if not args1.__class__ is id:
+                    args1 = id(args1)
             except:
-                import sys
-                exc_info0 = sys.exc_info()
-                return -1
-            return 0
-        cb = fn(cb_func)
-        res = isl.isl_map_foreach_basic_map(arg0.ptr, cb, None)
-        if exc_info0 != None:
-            raise exc_info00, exc_info01, exc_info02
-        return res
+                raise
+            ctx = args0.ctx
+            res = isl.isl_map_set_domain_tuple_id(isl.isl_map_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_map_set_range_tuple_id(isl.isl_map_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def space(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def subtract(arg0, arg1):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).subtract(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_subtract(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def to_union_map(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_to_union_map(isl.isl_map_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def uncurry(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_uncurry(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_map(arg0).union(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_map_union(isl.isl_map_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def universe(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_universe(isl.isl_space_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def unshifted_simple_hull(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_unshifted_simple_hull(isl.isl_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def upper_bound(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_map_upper_bound_multi_pw_aff(isl.isl_map_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = map(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def wrap(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_wrap(isl.isl_map_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def zip(arg0):
+        try:
+            if not arg0.__class__ is map:
+                arg0 = map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_map_zip(isl.isl_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
 
 isl.isl_map_from_basic_map.restype = c_void_p
 isl.isl_map_from_basic_map.argtypes = c_void_p
 isl.isl_map_read_from_str.restype = c_void_p
 isl.isl_map_read_from_str.argtypes = Context, c_char_p
-isl.isl_map_reverse.restype = c_void_p
-isl.isl_map_union.restype = c_void_p
-isl.isl_map_intersect_domain.restype = c_void_p
-isl.isl_map_intersect_range.restype = c_void_p
+isl.isl_map_affine_hull.restype = c_void_p
+isl.isl_map_affine_hull.argtypes = c_void_p
 isl.isl_map_apply_domain.restype = c_void_p
+isl.isl_map_apply_domain.argtypes = c_void_p, c_void_p
 isl.isl_map_apply_range.restype = c_void_p
-isl.isl_map_intersect.restype = c_void_p
-isl.isl_map_intersect_params.restype = c_void_p
-isl.isl_map_subtract.restype = c_void_p
+isl.isl_map_apply_range.argtypes = c_void_p, c_void_p
+isl.isl_map_as_pw_multi_aff.restype = c_void_p
+isl.isl_map_as_pw_multi_aff.argtypes = c_void_p
+isl.isl_map_bind_domain.restype = c_void_p
+isl.isl_map_bind_domain.argtypes = c_void_p, c_void_p
+isl.isl_map_bind_range.restype = c_void_p
+isl.isl_map_bind_range.argtypes = c_void_p, c_void_p
+isl.isl_map_coalesce.restype = c_void_p
+isl.isl_map_coalesce.argtypes = c_void_p
 isl.isl_map_complement.restype = c_void_p
+isl.isl_map_complement.argtypes = c_void_p
+isl.isl_map_curry.restype = c_void_p
+isl.isl_map_curry.argtypes = c_void_p
 isl.isl_map_deltas.restype = c_void_p
+isl.isl_map_deltas.argtypes = c_void_p
 isl.isl_map_detect_equalities.restype = c_void_p
-isl.isl_map_affine_hull.restype = c_void_p
-isl.isl_map_polyhedral_hull.restype = c_void_p
+isl.isl_map_detect_equalities.argtypes = c_void_p
+isl.isl_map_domain.restype = c_void_p
+isl.isl_map_domain.argtypes = c_void_p
+isl.isl_map_domain_factor_domain.restype = c_void_p
+isl.isl_map_domain_factor_domain.argtypes = c_void_p
+isl.isl_map_domain_factor_range.restype = c_void_p
+isl.isl_map_domain_factor_range.argtypes = c_void_p
+isl.isl_map_domain_product.restype = c_void_p
+isl.isl_map_domain_product.argtypes = c_void_p, c_void_p
+isl.isl_map_get_domain_tuple_id.restype = c_void_p
+isl.isl_map_get_domain_tuple_id.argtypes = c_void_p
+isl.isl_map_empty.restype = c_void_p
+isl.isl_map_empty.argtypes = c_void_p
+isl.isl_map_eq_at_multi_pw_aff.restype = c_void_p
+isl.isl_map_eq_at_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_factor_domain.restype = c_void_p
+isl.isl_map_factor_domain.argtypes = c_void_p
+isl.isl_map_factor_range.restype = c_void_p
+isl.isl_map_factor_range.argtypes = c_void_p
 isl.isl_map_flatten.restype = c_void_p
+isl.isl_map_flatten.argtypes = c_void_p
 isl.isl_map_flatten_domain.restype = c_void_p
+isl.isl_map_flatten_domain.argtypes = c_void_p
 isl.isl_map_flatten_range.restype = c_void_p
-isl.isl_map_lexmin.restype = c_void_p
-isl.isl_map_lexmax.restype = c_void_p
-isl.isl_map_sample.restype = c_void_p
+isl.isl_map_flatten_range.argtypes = c_void_p
+isl.isl_map_foreach_basic_map.argtypes = c_void_p, c_void_p, c_void_p
 isl.isl_map_gist.restype = c_void_p
+isl.isl_map_gist.argtypes = c_void_p, c_void_p
 isl.isl_map_gist_domain.restype = c_void_p
-isl.isl_map_coalesce.restype = c_void_p
+isl.isl_map_gist_domain.argtypes = c_void_p, c_void_p
+isl.isl_map_has_domain_tuple_id.argtypes = c_void_p
+isl.isl_map_has_range_tuple_id.argtypes = c_void_p
+isl.isl_map_intersect.restype = c_void_p
+isl.isl_map_intersect.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_domain.restype = c_void_p
+isl.isl_map_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_domain_factor_domain.restype = c_void_p
+isl.isl_map_intersect_domain_factor_domain.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_domain_factor_range.restype = c_void_p
+isl.isl_map_intersect_domain_factor_range.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_params.restype = c_void_p
+isl.isl_map_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_range.restype = c_void_p
+isl.isl_map_intersect_range.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_range_factor_domain.restype = c_void_p
+isl.isl_map_intersect_range_factor_domain.argtypes = c_void_p, c_void_p
+isl.isl_map_intersect_range_factor_range.restype = c_void_p
+isl.isl_map_intersect_range_factor_range.argtypes = c_void_p, c_void_p
+isl.isl_map_is_bijective.argtypes = c_void_p
+isl.isl_map_is_disjoint.argtypes = c_void_p, c_void_p
+isl.isl_map_is_empty.argtypes = c_void_p
+isl.isl_map_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_map_is_injective.argtypes = c_void_p
+isl.isl_map_is_single_valued.argtypes = c_void_p
+isl.isl_map_is_strict_subset.argtypes = c_void_p, c_void_p
+isl.isl_map_is_subset.argtypes = c_void_p, c_void_p
+isl.isl_map_lex_ge_at_multi_pw_aff.restype = c_void_p
+isl.isl_map_lex_ge_at_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_lex_gt_at_multi_pw_aff.restype = c_void_p
+isl.isl_map_lex_gt_at_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_lex_le_at_multi_pw_aff.restype = c_void_p
+isl.isl_map_lex_le_at_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_lex_lt_at_multi_pw_aff.restype = c_void_p
+isl.isl_map_lex_lt_at_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_lexmax.restype = c_void_p
+isl.isl_map_lexmax.argtypes = c_void_p
+isl.isl_map_lexmax_pw_multi_aff.restype = c_void_p
+isl.isl_map_lexmax_pw_multi_aff.argtypes = c_void_p
+isl.isl_map_lexmin.restype = c_void_p
+isl.isl_map_lexmin.argtypes = c_void_p
+isl.isl_map_lexmin_pw_multi_aff.restype = c_void_p
+isl.isl_map_lexmin_pw_multi_aff.argtypes = c_void_p
+isl.isl_map_lower_bound_multi_pw_aff.restype = c_void_p
+isl.isl_map_lower_bound_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_max_multi_pw_aff.restype = c_void_p
+isl.isl_map_max_multi_pw_aff.argtypes = c_void_p
+isl.isl_map_min_multi_pw_aff.restype = c_void_p
+isl.isl_map_min_multi_pw_aff.argtypes = c_void_p
+isl.isl_map_polyhedral_hull.restype = c_void_p
+isl.isl_map_polyhedral_hull.argtypes = c_void_p
+isl.isl_map_preimage_domain_multi_aff.restype = c_void_p
+isl.isl_map_preimage_domain_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_preimage_domain_multi_pw_aff.restype = c_void_p
+isl.isl_map_preimage_domain_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_preimage_domain_pw_multi_aff.restype = c_void_p
+isl.isl_map_preimage_domain_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_preimage_range_multi_aff.restype = c_void_p
+isl.isl_map_preimage_range_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_preimage_range_pw_multi_aff.restype = c_void_p
+isl.isl_map_preimage_range_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_product.restype = c_void_p
+isl.isl_map_product.argtypes = c_void_p, c_void_p
+isl.isl_map_project_out_all_params.restype = c_void_p
+isl.isl_map_project_out_all_params.argtypes = c_void_p
+isl.isl_map_range.restype = c_void_p
+isl.isl_map_range.argtypes = c_void_p
+isl.isl_map_range_factor_domain.restype = c_void_p
+isl.isl_map_range_factor_domain.argtypes = c_void_p
+isl.isl_map_range_factor_range.restype = c_void_p
+isl.isl_map_range_factor_range.argtypes = c_void_p
+isl.isl_map_range_product.restype = c_void_p
+isl.isl_map_range_product.argtypes = c_void_p, c_void_p
+isl.isl_map_range_reverse.restype = c_void_p
+isl.isl_map_range_reverse.argtypes = c_void_p
+isl.isl_map_get_range_simple_fixed_box_hull.restype = c_void_p
+isl.isl_map_get_range_simple_fixed_box_hull.argtypes = c_void_p
+isl.isl_map_get_range_tuple_id.restype = c_void_p
+isl.isl_map_get_range_tuple_id.argtypes = c_void_p
+isl.isl_map_reverse.restype = c_void_p
+isl.isl_map_reverse.argtypes = c_void_p
+isl.isl_map_sample.restype = c_void_p
+isl.isl_map_sample.argtypes = c_void_p
+isl.isl_map_set_domain_tuple_id.restype = c_void_p
+isl.isl_map_set_domain_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_map_set_range_tuple_id.restype = c_void_p
+isl.isl_map_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_map_get_space.restype = c_void_p
+isl.isl_map_get_space.argtypes = c_void_p
+isl.isl_map_subtract.restype = c_void_p
+isl.isl_map_subtract.argtypes = c_void_p, c_void_p
+isl.isl_map_to_union_map.restype = c_void_p
+isl.isl_map_to_union_map.argtypes = c_void_p
+isl.isl_map_uncurry.restype = c_void_p
+isl.isl_map_uncurry.argtypes = c_void_p
+isl.isl_map_union.restype = c_void_p
+isl.isl_map_union.argtypes = c_void_p, c_void_p
+isl.isl_map_universe.restype = c_void_p
+isl.isl_map_universe.argtypes = c_void_p
+isl.isl_map_unshifted_simple_hull.restype = c_void_p
+isl.isl_map_unshifted_simple_hull.argtypes = c_void_p
+isl.isl_map_upper_bound_multi_pw_aff.restype = c_void_p
+isl.isl_map_upper_bound_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_map_wrap.restype = c_void_p
+isl.isl_map_wrap.argtypes = c_void_p
+isl.isl_map_zip.restype = c_void_p
+isl.isl_map_zip.argtypes = c_void_p
+isl.isl_map_copy.restype = c_void_p
+isl.isl_map_copy.argtypes = c_void_p
+isl.isl_map_free.restype = c_void_p
 isl.isl_map_free.argtypes = c_void_p
-isl.isl_map_to_str.argtypes = c_void_p
 isl.isl_map_to_str.restype = POINTER(c_char)
+isl.isl_map_to_str.argtypes = c_void_p
 
 class basic_map(map):
     def __init__(self, *args, **keywords):
@@ -834,58 +9042,38 @@
             return
         if len(args) == 1 and type(args0) == str:
             self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_basic_map_read_from_str(self.ctx, args0)
+            self.ptr = isl.isl_basic_map_read_from_str(self.ctx, args0.encode('ascii'))
             return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_basic_map_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_basic_map_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
-        libc.free(ptr)
-        return res
-    def __repr__(self):
-        return 'isl.basic_map("%s")' % str(self)
-    def intersect_range(arg0, arg1):
+    def __str__(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        try:
-            if not arg1.__class__ is basic_set:
-                arg1 = basic_set(arg1)
-        except:
-            return map(arg0).intersect_range(arg1)
-        res = isl.isl_basic_map_intersect_range(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def intersect(arg0, arg1):
-        try:
-            if not arg0.__class__ is basic_map:
-                arg0 = basic_map(arg0)
-        except:
-            raise
-        try:
-            if not arg1.__class__ is basic_map:
-                arg1 = basic_map(arg1)
-        except:
-            return map(arg0).intersect(arg1)
-        res = isl.isl_basic_map_intersect(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def union(arg0, arg1):
+        ptr = isl.isl_basic_map_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.basic_map("""%s""")' % s
+        else:
+            return 'isl.basic_map("%s")' % s
+    def affine_hull(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        try:
-            if not arg1.__class__ is basic_map:
-                arg1 = basic_map(arg1)
-        except:
-            return map(arg0).union(arg1)
-        res = isl.isl_basic_map_union(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_affine_hull(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
     def apply_domain(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
@@ -897,8 +9085,10 @@
                 arg1 = basic_map(arg1)
         except:
             return map(arg0).apply_domain(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_map_apply_domain(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
     def apply_range(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
@@ -910,72 +9100,90 @@
                 arg1 = basic_map(arg1)
         except:
             return map(arg0).apply_range(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_map_apply_range(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def affine_hull(arg0):
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def deltas(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_affine_hull(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def reverse(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_deltas(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def detect_equalities(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_reverse(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def sample(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_detect_equalities(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def flatten(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_sample(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def detect_equalities(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_flatten(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def flatten_domain(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_detect_equalities(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def deltas(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_flatten_domain(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def flatten_range(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_deltas(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def flatten(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_flatten_range(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_flatten(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def flatten_domain(arg0):
         try:
-            if not arg0.__class__ is basic_map:
-                arg0 = basic_map(arg0)
+            if not arg1.__class__ is basic_map:
+                arg1 = basic_map(arg1)
         except:
-            raise
-        res = isl.isl_basic_map_flatten_domain(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
-    def flatten_range(arg0):
+            return map(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_gist(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_flatten_range(isl.isl_basic_map_copy(arg0.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
+        try:
+            if not arg1.__class__ is basic_map:
+                arg1 = basic_map(arg1)
+        except:
+            return map(arg0).intersect(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_intersect(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
     def intersect_domain(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
@@ -987,8 +9195,36 @@
                 arg1 = basic_set(arg1)
         except:
             return map(arg0).intersect_domain(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_map_intersect_domain(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect_range(arg0, arg1):
+        try:
+            if not arg0.__class__ is basic_map:
+                arg0 = basic_map(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is basic_set:
+                arg1 = basic_set(arg1)
+        except:
+            return map(arg0).intersect_range(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_intersect_range(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def is_empty(arg0):
+        try:
+            if not arg0.__class__ is basic_map:
+                arg0 = basic_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_is_empty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_equal(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
@@ -1000,46 +9236,68 @@
                 arg1 = basic_map(arg1)
         except:
             return map(arg0).is_equal(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_map_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def lexmin(arg0):
+        if res < 0:
+            raise
+        return bool(res)
+    def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_lexmin(isl.isl_basic_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
+        try:
+            if not arg1.__class__ is basic_map:
+                arg1 = basic_map(arg1)
+        except:
+            return map(arg0).is_subset(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_is_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def lexmax(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_basic_map_lexmax(isl.isl_basic_map_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def is_empty(arg0):
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
-        res = isl.isl_basic_map_is_empty(arg0.ptr)
-        return res
-    def is_subset(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_lexmin(isl.isl_basic_map_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def reverse(arg0):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_reverse(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def sample(arg0):
         try:
-            if not arg1.__class__ is basic_map:
-                arg1 = basic_map(arg1)
+            if not arg0.__class__ is basic_map:
+                arg0 = basic_map(arg0)
         except:
-            return map(arg0).is_subset(arg1)
-        res = isl.isl_basic_map_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def gist(arg0, arg1):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_sample(isl.isl_basic_map_copy(arg0.ptr))
+        obj = basic_map(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
         try:
             if not arg0.__class__ is basic_map:
                 arg0 = basic_map(arg0)
@@ -1049,34 +9307,59 @@
             if not arg1.__class__ is basic_map:
                 arg1 = basic_map(arg1)
         except:
-            return map(arg0).gist(arg1)
-        res = isl.isl_basic_map_gist(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return basic_map(ctx=arg0.ctx, ptr=res)
+            return map(arg0).union(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_map_union(isl.isl_basic_map_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
 
 isl.isl_basic_map_read_from_str.restype = c_void_p
 isl.isl_basic_map_read_from_str.argtypes = Context, c_char_p
-isl.isl_basic_map_intersect_range.restype = c_void_p
-isl.isl_basic_map_intersect.restype = c_void_p
-isl.isl_basic_map_union.restype = c_void_p
+isl.isl_basic_map_affine_hull.restype = c_void_p
+isl.isl_basic_map_affine_hull.argtypes = c_void_p
 isl.isl_basic_map_apply_domain.restype = c_void_p
+isl.isl_basic_map_apply_domain.argtypes = c_void_p, c_void_p
 isl.isl_basic_map_apply_range.restype = c_void_p
-isl.isl_basic_map_affine_hull.restype = c_void_p
-isl.isl_basic_map_reverse.restype = c_void_p
-isl.isl_basic_map_sample.restype = c_void_p
-isl.isl_basic_map_detect_equalities.restype = c_void_p
+isl.isl_basic_map_apply_range.argtypes = c_void_p, c_void_p
 isl.isl_basic_map_deltas.restype = c_void_p
+isl.isl_basic_map_deltas.argtypes = c_void_p
+isl.isl_basic_map_detect_equalities.restype = c_void_p
+isl.isl_basic_map_detect_equalities.argtypes = c_void_p
 isl.isl_basic_map_flatten.restype = c_void_p
+isl.isl_basic_map_flatten.argtypes = c_void_p
 isl.isl_basic_map_flatten_domain.restype = c_void_p
+isl.isl_basic_map_flatten_domain.argtypes = c_void_p
 isl.isl_basic_map_flatten_range.restype = c_void_p
+isl.isl_basic_map_flatten_range.argtypes = c_void_p
+isl.isl_basic_map_gist.restype = c_void_p
+isl.isl_basic_map_gist.argtypes = c_void_p, c_void_p
+isl.isl_basic_map_intersect.restype = c_void_p
+isl.isl_basic_map_intersect.argtypes = c_void_p, c_void_p
 isl.isl_basic_map_intersect_domain.restype = c_void_p
-isl.isl_basic_map_lexmin.restype = c_void_p
+isl.isl_basic_map_intersect_domain.argtypes = c_void_p, c_void_p
+isl.isl_basic_map_intersect_range.restype = c_void_p
+isl.isl_basic_map_intersect_range.argtypes = c_void_p, c_void_p
+isl.isl_basic_map_is_empty.argtypes = c_void_p
+isl.isl_basic_map_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_basic_map_is_subset.argtypes = c_void_p, c_void_p
 isl.isl_basic_map_lexmax.restype = c_void_p
-isl.isl_basic_map_gist.restype = c_void_p
+isl.isl_basic_map_lexmax.argtypes = c_void_p
+isl.isl_basic_map_lexmin.restype = c_void_p
+isl.isl_basic_map_lexmin.argtypes = c_void_p
+isl.isl_basic_map_reverse.restype = c_void_p
+isl.isl_basic_map_reverse.argtypes = c_void_p
+isl.isl_basic_map_sample.restype = c_void_p
+isl.isl_basic_map_sample.argtypes = c_void_p
+isl.isl_basic_map_union.restype = c_void_p
+isl.isl_basic_map_union.argtypes = c_void_p, c_void_p
+isl.isl_basic_map_copy.restype = c_void_p
+isl.isl_basic_map_copy.argtypes = c_void_p
+isl.isl_basic_map_free.restype = c_void_p
 isl.isl_basic_map_free.argtypes = c_void_p
-isl.isl_basic_map_to_str.argtypes = c_void_p
 isl.isl_basic_map_to_str.restype = POINTER(c_char)
+isl.isl_basic_map_to_str.argtypes = c_void_p
 
-class union_set:
+class union_set(object):
     def __init__(self, *args, **keywords):
         if "ptr" in keywords:
             self.ctx = keywords"ctx"
@@ -1086,95 +9369,197 @@
             self.ctx = Context.getDefaultInstance()
             self.ptr = isl.isl_union_set_from_basic_set(isl.isl_basic_set_copy(args0.ptr))
             return
+        if len(args) == 1 and args0.__class__ is point:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_set_from_point(isl.isl_point_copy(args0.ptr))
+            return
         if len(args) == 1 and args0.__class__ is set:
             self.ctx = Context.getDefaultInstance()
             self.ptr = isl.isl_union_set_from_set(isl.isl_set_copy(args0.ptr))
             return
         if len(args) == 1 and type(args0) == str:
             self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_union_set_read_from_str(self.ctx, args0)
+            self.ptr = isl.isl_union_set_read_from_str(self.ctx, args0.encode('ascii'))
             return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_union_set_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_union_set_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_set_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.union_set("%s")' % str(self)
-    def identity(arg0):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_set("""%s""")' % s
+        else:
+            return 'isl.union_set("%s")' % s
+    def affine_hull(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_identity(isl.isl_union_set_copy(arg0.ptr))
-        return union_map(ctx=arg0.ctx, ptr=res)
-    def detect_equalities(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_affine_hull(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def apply(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_detect_equalities(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def affine_hull(arg0):
         try:
-            if not arg0.__class__ is union_set:
-                arg0 = union_set(arg0)
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
         except:
             raise
-        res = isl.isl_union_set_affine_hull(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def polyhedral_hull(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_apply(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def as_set(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_polyhedral_hull(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_as_set(isl.isl_union_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
     def coalesce(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_set_coalesce(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def lexmin(arg0):
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def compute_divs(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_lexmin(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def lexmax(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_compute_divs(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def detect_equalities(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_lexmax(isl.isl_union_set_copy(arg0.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def subtract(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_detect_equalities(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def empty(*args):
+        if len(args) == 0:
+            ctx = Context.getDefaultInstance()
+            res = isl.isl_union_set_empty_ctx(ctx)
+            obj = union_set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def every_set(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = set(ctx=arg0.ctx, ptr=isl.isl_set_copy(cb_arg0))
+            try:
+                res = arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 1 if res else 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_every_set(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+        return bool(res)
+    def extract_set(arg0, arg1):
         try:
-            if not arg1.__class__ is union_set:
-                arg1 = union_set(arg1)
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
         except:
             raise
-        res = isl.isl_union_set_subtract(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def intersect(arg0, arg1):
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_extract_set(arg0.ptr, isl.isl_space_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def foreach_point(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = point(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_foreach_point(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def foreach_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = set(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_foreach_set(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def gist(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1185,9 +9570,11 @@
                 arg1 = union_set(arg1)
         except:
             raise
-        res = isl.isl_union_set_intersect(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def intersect_params(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_gist(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def gist_params(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1198,9 +9585,21 @@
                 arg1 = set(arg1)
         except:
             raise
-        res = isl.isl_union_set_intersect_params(isl.isl_union_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def gist(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_gist_params(isl.isl_union_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def identity(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_identity(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1211,9 +9610,11 @@
                 arg1 = union_set(arg1)
         except:
             raise
-        res = isl.isl_union_set_gist(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def gist_params(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_intersect(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def intersect_params(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1224,29 +9625,69 @@
                 arg1 = set(arg1)
         except:
             raise
-        res = isl.isl_union_set_gist_params(isl.isl_union_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
-    def apply(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_intersect_params(isl.isl_union_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def is_disjoint(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is union_map:
-                arg1 = union_map(arg1)
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
         except:
             raise
-        res = isl.isl_union_set_apply(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
-        return union_set(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_is_disjoint(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_empty(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_set_is_empty(arg0.ptr)
-        return res
+        if res < 0:
+            raise
+        return bool(res)
+    def is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_strict_subset(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_is_strict_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
@@ -1258,9 +9699,92 @@
                 arg1 = union_set(arg1)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_union_set_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_equal(arg0, arg1):
+        if res < 0:
+            raise
+        return bool(res)
+    def isa_set(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_isa_set(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def lexmax(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_lexmax(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_lexmin(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def polyhedral_hull(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_polyhedral_hull(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def preimage(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_set_preimage_multi_aff(isl.isl_union_set_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = union_set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_set_preimage_pw_multi_aff(isl.isl_union_set_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = union_set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_union_set_preimage_union_pw_multi_aff(isl.isl_union_set_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = union_set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def sample_point(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_sample_point(isl.isl_union_set_copy(arg0.ptr))
+        obj = point(ctx=ctx, ptr=res)
+        return obj
+    def space(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def subtract(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1271,9 +9795,21 @@
                 arg1 = union_set(arg1)
         except:
             raise
-        res = isl.isl_union_set_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def is_strict_subset(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_subtract(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_to_list(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
@@ -1284,53 +9820,106 @@
                 arg1 = union_set(arg1)
         except:
             raise
-        res = isl.isl_union_set_is_strict_subset(arg0.ptr, arg1.ptr)
-        return res
-    def foreach_set(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_union_set_union(isl.isl_union_set_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def universe(arg0):
         try:
             if not arg0.__class__ is union_set:
                 arg0 = union_set(arg0)
         except:
             raise
-        exc_info = None
-        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
-        def cb_func(cb_arg0, cb_arg1):
-            cb_arg0 = set(ctx=arg0.ctx, ptr=cb_arg0)
-            try:
-                arg1(cb_arg0)
-            except:
-                import sys
-                exc_info0 = sys.exc_info()
-                return -1
-            return 0
-        cb = fn(cb_func)
-        res = isl.isl_union_set_foreach_set(arg0.ptr, cb, None)
-        if exc_info0 != None:
-            raise exc_info00, exc_info01, exc_info02
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_union_set_universe(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def unwrap(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_unwrap(isl.isl_union_set_copy(arg0.ptr))
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
 
 isl.isl_union_set_from_basic_set.restype = c_void_p
 isl.isl_union_set_from_basic_set.argtypes = c_void_p
+isl.isl_union_set_from_point.restype = c_void_p
+isl.isl_union_set_from_point.argtypes = c_void_p
 isl.isl_union_set_from_set.restype = c_void_p
 isl.isl_union_set_from_set.argtypes = c_void_p
 isl.isl_union_set_read_from_str.restype = c_void_p
 isl.isl_union_set_read_from_str.argtypes = Context, c_char_p
-isl.isl_union_set_identity.restype = c_void_p
-isl.isl_union_set_detect_equalities.restype = c_void_p
 isl.isl_union_set_affine_hull.restype = c_void_p
-isl.isl_union_set_polyhedral_hull.restype = c_void_p
+isl.isl_union_set_affine_hull.argtypes = c_void_p
+isl.isl_union_set_apply.restype = c_void_p
+isl.isl_union_set_apply.argtypes = c_void_p, c_void_p
+isl.isl_union_set_as_set.restype = c_void_p
+isl.isl_union_set_as_set.argtypes = c_void_p
 isl.isl_union_set_coalesce.restype = c_void_p
-isl.isl_union_set_lexmin.restype = c_void_p
-isl.isl_union_set_lexmax.restype = c_void_p
-isl.isl_union_set_subtract.restype = c_void_p
-isl.isl_union_set_intersect.restype = c_void_p
-isl.isl_union_set_intersect_params.restype = c_void_p
+isl.isl_union_set_coalesce.argtypes = c_void_p
+isl.isl_union_set_compute_divs.restype = c_void_p
+isl.isl_union_set_compute_divs.argtypes = c_void_p
+isl.isl_union_set_detect_equalities.restype = c_void_p
+isl.isl_union_set_detect_equalities.argtypes = c_void_p
+isl.isl_union_set_empty_ctx.restype = c_void_p
+isl.isl_union_set_empty_ctx.argtypes = Context
+isl.isl_union_set_every_set.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_set_extract_set.restype = c_void_p
+isl.isl_union_set_extract_set.argtypes = c_void_p, c_void_p
+isl.isl_union_set_foreach_point.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_set_foreach_set.argtypes = c_void_p, c_void_p, c_void_p
 isl.isl_union_set_gist.restype = c_void_p
+isl.isl_union_set_gist.argtypes = c_void_p, c_void_p
 isl.isl_union_set_gist_params.restype = c_void_p
-isl.isl_union_set_apply.restype = c_void_p
+isl.isl_union_set_gist_params.argtypes = c_void_p, c_void_p
+isl.isl_union_set_identity.restype = c_void_p
+isl.isl_union_set_identity.argtypes = c_void_p
+isl.isl_union_set_intersect.restype = c_void_p
+isl.isl_union_set_intersect.argtypes = c_void_p, c_void_p
+isl.isl_union_set_intersect_params.restype = c_void_p
+isl.isl_union_set_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_union_set_is_disjoint.argtypes = c_void_p, c_void_p
+isl.isl_union_set_is_empty.argtypes = c_void_p
+isl.isl_union_set_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_union_set_is_strict_subset.argtypes = c_void_p, c_void_p
+isl.isl_union_set_is_subset.argtypes = c_void_p, c_void_p
+isl.isl_union_set_isa_set.argtypes = c_void_p
+isl.isl_union_set_lexmax.restype = c_void_p
+isl.isl_union_set_lexmax.argtypes = c_void_p
+isl.isl_union_set_lexmin.restype = c_void_p
+isl.isl_union_set_lexmin.argtypes = c_void_p
+isl.isl_union_set_polyhedral_hull.restype = c_void_p
+isl.isl_union_set_polyhedral_hull.argtypes = c_void_p
+isl.isl_union_set_preimage_multi_aff.restype = c_void_p
+isl.isl_union_set_preimage_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_set_preimage_pw_multi_aff.restype = c_void_p
+isl.isl_union_set_preimage_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_set_preimage_union_pw_multi_aff.restype = c_void_p
+isl.isl_union_set_preimage_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_union_set_sample_point.restype = c_void_p
+isl.isl_union_set_sample_point.argtypes = c_void_p
+isl.isl_union_set_get_space.restype = c_void_p
+isl.isl_union_set_get_space.argtypes = c_void_p
+isl.isl_union_set_subtract.restype = c_void_p
+isl.isl_union_set_subtract.argtypes = c_void_p, c_void_p
+isl.isl_union_set_to_list.restype = c_void_p
+isl.isl_union_set_to_list.argtypes = c_void_p
+isl.isl_union_set_union.restype = c_void_p
+isl.isl_union_set_union.argtypes = c_void_p, c_void_p
+isl.isl_union_set_universe.restype = c_void_p
+isl.isl_union_set_universe.argtypes = c_void_p
+isl.isl_union_set_unwrap.restype = c_void_p
+isl.isl_union_set_unwrap.argtypes = c_void_p
+isl.isl_union_set_copy.restype = c_void_p
+isl.isl_union_set_copy.argtypes = c_void_p
+isl.isl_union_set_free.restype = c_void_p
 isl.isl_union_set_free.argtypes = c_void_p
-isl.isl_union_set_to_str.argtypes = c_void_p
 isl.isl_union_set_to_str.restype = POINTER(c_char)
+isl.isl_union_set_to_str.argtypes = c_void_p
 
 class set(union_set):
     def __init__(self, *args, **keywords):
@@ -1338,98 +9927,206 @@
             self.ctx = keywords"ctx"
             self.ptr = keywords"ptr"
             return
-        if len(args) == 1 and type(args0) == str:
-            self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_set_read_from_str(self.ctx, args0)
-            return
         if len(args) == 1 and args0.__class__ is basic_set:
             self.ctx = Context.getDefaultInstance()
             self.ptr = isl.isl_set_from_basic_set(isl.isl_basic_set_copy(args0.ptr))
             return
+        if len(args) == 1 and args0.__class__ is point:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_set_from_point(isl.isl_point_copy(args0.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_set_read_from_str(self.ctx, args0.encode('ascii'))
+            return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_set_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_set_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ptr = isl.isl_set_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.set("%s")' % str(self)
-    def identity(arg0):
+        s = str(self)
+        if '"' in s:
+            return 'isl.set("""%s""")' % s
+        else:
+            return 'isl.set("%s")' % s
+    def affine_hull(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_identity(isl.isl_set_copy(arg0.ptr))
-        return map(ctx=arg0.ctx, ptr=res)
-    def is_wrapping(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_set_affine_hull(isl.isl_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def apply(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_is_wrapping(arg0.ptr)
-        return res
-    def flatten(arg0):
+        try:
+            if not arg1.__class__ is map:
+                arg1 = map(arg1)
+        except:
+            return union_set(arg0).apply(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_apply(isl.isl_set_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def as_pw_multi_aff(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_flatten(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def lexmin(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_set_as_pw_multi_aff(isl.isl_set_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def bind(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_lexmin(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def lexmax(arg0):
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_set(arg0).bind(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_bind(isl.isl_set_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def coalesce(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_lexmax(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def sample(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_set_coalesce(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def complement(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_sample(isl.isl_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_set_complement(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
     def detect_equalities(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_set_detect_equalities(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def affine_hull(arg0):
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def dim_max_val(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_affine_hull(isl.isl_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def polyhedral_hull(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_set_dim_max_val(isl.isl_set_copy(arg0.ptr), arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def dim_min_val(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_polyhedral_hull(isl.isl_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def union(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_set_dim_min_val(isl.isl_set_copy(arg0.ptr), arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def empty(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_empty(isl.isl_space_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def flatten(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_flatten(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def foreach_basic_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = basic_set(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_set_foreach_basic_set(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def foreach_point(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = point(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_set_foreach_point(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def gist(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
@@ -1439,9 +10136,46 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_set(arg0).union(arg1)
-        res = isl.isl_set_union(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
+            return union_set(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_gist(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def identity(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_identity(isl.isl_set_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def indicator_function(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_indicator_function(isl.isl_set_copy(arg0.ptr))
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            return union_set(arg0).insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_insert_domain(isl.isl_set_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
     def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is set:
@@ -1453,8 +10187,10 @@
                 arg1 = set(arg1)
         except:
             return union_set(arg0).intersect(arg1)
+        ctx = arg0.ctx
         res = isl.isl_set_intersect(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
+        obj = set(ctx=ctx, ptr=res)
+        return obj
     def intersect_params(arg0, arg1):
         try:
             if not arg0.__class__ is set:
@@ -1466,9 +10202,22 @@
                 arg1 = set(arg1)
         except:
             return union_set(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
         res = isl.isl_set_intersect_params(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def subtract(arg0, arg1):
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def involves_locals(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_involves_locals(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_disjoint(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
@@ -1478,38 +10227,66 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_set(arg0).subtract(arg1)
-        res = isl.isl_set_subtract(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def complement(arg0):
+            return union_set(arg0).is_disjoint(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_is_disjoint(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_empty(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_complement(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def apply(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_set_is_empty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_equal(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
         try:
-            if not arg1.__class__ is map:
-                arg1 = map(arg1)
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
         except:
-            return union_set(arg0).apply(arg1)
-        res = isl.isl_set_apply(isl.isl_set_copy(arg0.ptr), isl.isl_map_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def is_empty(arg0):
+            return union_set(arg0).is_equal(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_singleton(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_is_empty(arg0.ptr)
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_set_is_singleton(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_strict_subset(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            return union_set(arg0).is_strict_subset(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_is_strict_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is set:
@@ -1521,22 +10298,174 @@
                 arg1 = set(arg1)
         except:
             return union_set(arg0).is_subset(arg1)
+        ctx = arg0.ctx
         res = isl.isl_set_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_strict_subset(arg0, arg1):
+        if res < 0:
+            raise
+        return bool(res)
+    def is_wrapping(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_set_is_wrapping(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def lexmax(arg0):
         try:
-            if not arg1.__class__ is set:
-                arg1 = set(arg1)
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
         except:
-            return union_set(arg0).is_strict_subset(arg1)
-        res = isl.isl_set_is_strict_subset(arg0.ptr, arg1.ptr)
-        return res
-    def is_equal(arg0, arg1):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_lexmax(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def lexmax_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_lexmax_pw_multi_aff(isl.isl_set_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_lexmin(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def lexmin_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_lexmin_pw_multi_aff(isl.isl_set_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def lower_bound(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_set_lower_bound_multi_pw_aff(isl.isl_set_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_set_lower_bound_multi_val(isl.isl_set_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def max_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_max_multi_pw_aff(isl.isl_set_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def max_val(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return union_set(arg0).max_val(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_max_val(arg0.ptr, arg1.ptr)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def min_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_min_multi_pw_aff(isl.isl_set_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def min_val(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff:
+                arg1 = aff(arg1)
+        except:
+            return union_set(arg0).min_val(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_min_val(arg0.ptr, arg1.ptr)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def params(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_params(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def plain_multi_val_if_fixed(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_get_plain_multi_val_if_fixed(arg0.ptr)
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def get_plain_multi_val_if_fixed(arg0):
+        return arg0.plain_multi_val_if_fixed()
+    def polyhedral_hull(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_polyhedral_hull(isl.isl_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def preimage(*args):
+        if len(args) == 2 and args1.__class__ is multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_set_preimage_multi_aff(isl.isl_set_copy(args0.ptr), isl.isl_multi_aff_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_set_preimage_multi_pw_aff(isl.isl_set_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_set_preimage_pw_multi_aff(isl.isl_set_copy(args0.ptr), isl.isl_pw_multi_aff_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def product(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
@@ -1546,10 +10475,103 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_set(arg0).is_equal(arg1)
-        res = isl.isl_set_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def is_disjoint(arg0, arg1):
+            return union_set(arg0).product(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_product(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def project_out_all_params(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_project_out_all_params(isl.isl_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def project_out_param(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_set_project_out_param_id(isl.isl_set_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is id_list:
+            ctx = args0.ctx
+            res = isl.isl_set_project_out_param_id_list(isl.isl_set_copy(args0.ptr), isl.isl_id_list_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def pw_multi_aff_on_domain(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_set_pw_multi_aff_on_domain_multi_val(isl.isl_set_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = pw_multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def sample(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_sample(isl.isl_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def sample_point(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_sample_point(isl.isl_set_copy(arg0.ptr))
+        obj = point(ctx=ctx, ptr=res)
+        return obj
+    def simple_fixed_box_hull(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_get_simple_fixed_box_hull(arg0.ptr)
+        obj = fixed_box(ctx=ctx, ptr=res)
+        return obj
+    def get_simple_fixed_box_hull(arg0):
+        return arg0.simple_fixed_box_hull()
+    def space(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def stride(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_get_stride(arg0.ptr, arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def get_stride(arg0, arg1):
+        return arg0.stride(arg1)
+    def subtract(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
@@ -1559,10 +10581,62 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_set(arg0).is_disjoint(arg1)
-        res = isl.isl_set_is_disjoint(arg0.ptr, arg1.ptr)
-        return res
-    def gist(arg0, arg1):
+            return union_set(arg0).subtract(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_subtract(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def to_union_set(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_to_union_set(isl.isl_set_copy(arg0.ptr))
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def translation(arg0):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_translation(isl.isl_set_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def unbind_params(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_set(arg0).unbind_params(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_unbind_params(isl.isl_set_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def unbind_params_insert_domain(arg0, arg1):
+        try:
+            if not arg0.__class__ is set:
+                arg0 = set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            return union_set(arg0).unbind_params_insert_domain(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_unbind_params_insert_domain(isl.isl_set_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
@@ -1572,63 +10646,185 @@
             if not arg1.__class__ is set:
                 arg1 = set(arg1)
         except:
-            return union_set(arg0).gist(arg1)
-        res = isl.isl_set_gist(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def coalesce(arg0):
+            return union_set(arg0).union(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_set_union(isl.isl_set_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def universe(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_set_universe(isl.isl_space_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def unshifted_simple_hull(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        res = isl.isl_set_coalesce(isl.isl_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def foreach_basic_set(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_set_unshifted_simple_hull(isl.isl_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def unwrap(arg0):
         try:
             if not arg0.__class__ is set:
                 arg0 = set(arg0)
         except:
             raise
-        exc_info = None
-        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
-        def cb_func(cb_arg0, cb_arg1):
-            cb_arg0 = basic_set(ctx=arg0.ctx, ptr=cb_arg0)
-            try:
-                arg1(cb_arg0)
-            except:
-                import sys
-                exc_info0 = sys.exc_info()
-                return -1
-            return 0
-        cb = fn(cb_func)
-        res = isl.isl_set_foreach_basic_set(arg0.ptr, cb, None)
-        if exc_info0 != None:
-            raise exc_info00, exc_info01, exc_info02
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_set_unwrap(isl.isl_set_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def upper_bound(*args):
+        if len(args) == 2 and args1.__class__ is multi_pw_aff:
+            ctx = args0.ctx
+            res = isl.isl_set_upper_bound_multi_pw_aff(isl.isl_set_copy(args0.ptr), isl.isl_multi_pw_aff_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_set_upper_bound_multi_val(isl.isl_set_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = set(ctx=ctx, ptr=res)
+            return obj
+        raise Error
 
-isl.isl_set_read_from_str.restype = c_void_p
-isl.isl_set_read_from_str.argtypes = Context, c_char_p
 isl.isl_set_from_basic_set.restype = c_void_p
 isl.isl_set_from_basic_set.argtypes = c_void_p
-isl.isl_set_identity.restype = c_void_p
-isl.isl_set_flatten.restype = c_void_p
-isl.isl_set_lexmin.restype = c_void_p
-isl.isl_set_lexmax.restype = c_void_p
-isl.isl_set_sample.restype = c_void_p
-isl.isl_set_detect_equalities.restype = c_void_p
+isl.isl_set_from_point.restype = c_void_p
+isl.isl_set_from_point.argtypes = c_void_p
+isl.isl_set_read_from_str.restype = c_void_p
+isl.isl_set_read_from_str.argtypes = Context, c_char_p
 isl.isl_set_affine_hull.restype = c_void_p
-isl.isl_set_polyhedral_hull.restype = c_void_p
-isl.isl_set_union.restype = c_void_p
+isl.isl_set_affine_hull.argtypes = c_void_p
+isl.isl_set_apply.restype = c_void_p
+isl.isl_set_apply.argtypes = c_void_p, c_void_p
+isl.isl_set_as_pw_multi_aff.restype = c_void_p
+isl.isl_set_as_pw_multi_aff.argtypes = c_void_p
+isl.isl_set_bind.restype = c_void_p
+isl.isl_set_bind.argtypes = c_void_p, c_void_p
+isl.isl_set_coalesce.restype = c_void_p
+isl.isl_set_coalesce.argtypes = c_void_p
+isl.isl_set_complement.restype = c_void_p
+isl.isl_set_complement.argtypes = c_void_p
+isl.isl_set_detect_equalities.restype = c_void_p
+isl.isl_set_detect_equalities.argtypes = c_void_p
+isl.isl_set_dim_max_val.restype = c_void_p
+isl.isl_set_dim_max_val.argtypes = c_void_p, c_int
+isl.isl_set_dim_min_val.restype = c_void_p
+isl.isl_set_dim_min_val.argtypes = c_void_p, c_int
+isl.isl_set_empty.restype = c_void_p
+isl.isl_set_empty.argtypes = c_void_p
+isl.isl_set_flatten.restype = c_void_p
+isl.isl_set_flatten.argtypes = c_void_p
+isl.isl_set_foreach_basic_set.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_set_foreach_point.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_set_gist.restype = c_void_p
+isl.isl_set_gist.argtypes = c_void_p, c_void_p
+isl.isl_set_identity.restype = c_void_p
+isl.isl_set_identity.argtypes = c_void_p
+isl.isl_set_indicator_function.restype = c_void_p
+isl.isl_set_indicator_function.argtypes = c_void_p
+isl.isl_set_insert_domain.restype = c_void_p
+isl.isl_set_insert_domain.argtypes = c_void_p, c_void_p
 isl.isl_set_intersect.restype = c_void_p
+isl.isl_set_intersect.argtypes = c_void_p, c_void_p
 isl.isl_set_intersect_params.restype = c_void_p
+isl.isl_set_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_set_involves_locals.argtypes = c_void_p
+isl.isl_set_is_disjoint.argtypes = c_void_p, c_void_p
+isl.isl_set_is_empty.argtypes = c_void_p
+isl.isl_set_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_set_is_singleton.argtypes = c_void_p
+isl.isl_set_is_strict_subset.argtypes = c_void_p, c_void_p
+isl.isl_set_is_subset.argtypes = c_void_p, c_void_p
+isl.isl_set_is_wrapping.argtypes = c_void_p
+isl.isl_set_lexmax.restype = c_void_p
+isl.isl_set_lexmax.argtypes = c_void_p
+isl.isl_set_lexmax_pw_multi_aff.restype = c_void_p
+isl.isl_set_lexmax_pw_multi_aff.argtypes = c_void_p
+isl.isl_set_lexmin.restype = c_void_p
+isl.isl_set_lexmin.argtypes = c_void_p
+isl.isl_set_lexmin_pw_multi_aff.restype = c_void_p
+isl.isl_set_lexmin_pw_multi_aff.argtypes = c_void_p
+isl.isl_set_lower_bound_multi_pw_aff.restype = c_void_p
+isl.isl_set_lower_bound_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_set_lower_bound_multi_val.restype = c_void_p
+isl.isl_set_lower_bound_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_set_max_multi_pw_aff.restype = c_void_p
+isl.isl_set_max_multi_pw_aff.argtypes = c_void_p
+isl.isl_set_max_val.restype = c_void_p
+isl.isl_set_max_val.argtypes = c_void_p, c_void_p
+isl.isl_set_min_multi_pw_aff.restype = c_void_p
+isl.isl_set_min_multi_pw_aff.argtypes = c_void_p
+isl.isl_set_min_val.restype = c_void_p
+isl.isl_set_min_val.argtypes = c_void_p, c_void_p
+isl.isl_set_params.restype = c_void_p
+isl.isl_set_params.argtypes = c_void_p
+isl.isl_set_get_plain_multi_val_if_fixed.restype = c_void_p
+isl.isl_set_get_plain_multi_val_if_fixed.argtypes = c_void_p
+isl.isl_set_polyhedral_hull.restype = c_void_p
+isl.isl_set_polyhedral_hull.argtypes = c_void_p
+isl.isl_set_preimage_multi_aff.restype = c_void_p
+isl.isl_set_preimage_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_set_preimage_multi_pw_aff.restype = c_void_p
+isl.isl_set_preimage_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_set_preimage_pw_multi_aff.restype = c_void_p
+isl.isl_set_preimage_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_set_product.restype = c_void_p
+isl.isl_set_product.argtypes = c_void_p, c_void_p
+isl.isl_set_project_out_all_params.restype = c_void_p
+isl.isl_set_project_out_all_params.argtypes = c_void_p
+isl.isl_set_project_out_param_id.restype = c_void_p
+isl.isl_set_project_out_param_id.argtypes = c_void_p, c_void_p
+isl.isl_set_project_out_param_id_list.restype = c_void_p
+isl.isl_set_project_out_param_id_list.argtypes = c_void_p, c_void_p
+isl.isl_set_pw_multi_aff_on_domain_multi_val.restype = c_void_p
+isl.isl_set_pw_multi_aff_on_domain_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_set_sample.restype = c_void_p
+isl.isl_set_sample.argtypes = c_void_p
+isl.isl_set_sample_point.restype = c_void_p
+isl.isl_set_sample_point.argtypes = c_void_p
+isl.isl_set_get_simple_fixed_box_hull.restype = c_void_p
+isl.isl_set_get_simple_fixed_box_hull.argtypes = c_void_p
+isl.isl_set_get_space.restype = c_void_p
+isl.isl_set_get_space.argtypes = c_void_p
+isl.isl_set_get_stride.restype = c_void_p
+isl.isl_set_get_stride.argtypes = c_void_p, c_int
 isl.isl_set_subtract.restype = c_void_p
-isl.isl_set_complement.restype = c_void_p
-isl.isl_set_apply.restype = c_void_p
-isl.isl_set_gist.restype = c_void_p
-isl.isl_set_coalesce.restype = c_void_p
+isl.isl_set_subtract.argtypes = c_void_p, c_void_p
+isl.isl_set_to_union_set.restype = c_void_p
+isl.isl_set_to_union_set.argtypes = c_void_p
+isl.isl_set_translation.restype = c_void_p
+isl.isl_set_translation.argtypes = c_void_p
+isl.isl_set_unbind_params.restype = c_void_p
+isl.isl_set_unbind_params.argtypes = c_void_p, c_void_p
+isl.isl_set_unbind_params_insert_domain.restype = c_void_p
+isl.isl_set_unbind_params_insert_domain.argtypes = c_void_p, c_void_p
+isl.isl_set_union.restype = c_void_p
+isl.isl_set_union.argtypes = c_void_p, c_void_p
+isl.isl_set_universe.restype = c_void_p
+isl.isl_set_universe.argtypes = c_void_p
+isl.isl_set_unshifted_simple_hull.restype = c_void_p
+isl.isl_set_unshifted_simple_hull.argtypes = c_void_p
+isl.isl_set_unwrap.restype = c_void_p
+isl.isl_set_unwrap.argtypes = c_void_p
+isl.isl_set_upper_bound_multi_pw_aff.restype = c_void_p
+isl.isl_set_upper_bound_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_set_upper_bound_multi_val.restype = c_void_p
+isl.isl_set_upper_bound_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_set_copy.restype = c_void_p
+isl.isl_set_copy.argtypes = c_void_p
+isl.isl_set_free.restype = c_void_p
 isl.isl_set_free.argtypes = c_void_p
-isl.isl_set_to_str.argtypes = c_void_p
 isl.isl_set_to_str.restype = POINTER(c_char)
+isl.isl_set_to_str.argtypes = c_void_p
 
 class basic_set(set):
     def __init__(self, *args, **keywords):
@@ -1636,37 +10832,104 @@
             self.ctx = keywords"ctx"
             self.ptr = keywords"ptr"
             return
+        if len(args) == 1 and args0.__class__ is point:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_basic_set_from_point(isl.isl_point_copy(args0.ptr))
+            return
         if len(args) == 1 and type(args0) == str:
             self.ctx = Context.getDefaultInstance()
-            self.ptr = isl.isl_basic_set_read_from_str(self.ctx, args0)
+            self.ptr = isl.isl_basic_set_read_from_str(self.ctx, args0.encode('ascii'))
             return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
             isl.isl_basic_set_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_basic_set_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
+        except:
+            raise
+        ptr = isl.isl_basic_set_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.basic_set("%s")' % str(self)
-    def is_wrapping(arg0):
+        s = str(self)
+        if '"' in s:
+            return 'isl.basic_set("""%s""")' % s
+        else:
+            return 'isl.basic_set("%s")' % s
+    def affine_hull(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        res = isl.isl_basic_set_is_wrapping(arg0.ptr)
-        return res
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_affine_hull(isl.isl_basic_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def apply(arg0, arg1):
+        try:
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is basic_map:
+                arg1 = basic_map(arg1)
+        except:
+            return set(arg0).apply(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_apply(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def detect_equalities(arg0):
+        try:
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_detect_equalities(isl.isl_basic_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def dim_max_val(arg0, arg1):
+        try:
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_dim_max_val(isl.isl_basic_set_copy(arg0.ptr), arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
     def flatten(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_basic_set_flatten(isl.isl_basic_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def gist(arg0, arg1):
+        try:
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is basic_set:
+                arg1 = basic_set(arg1)
+        except:
+            return set(arg0).gist(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_gist(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
     def intersect(arg0, arg1):
         try:
             if not arg0.__class__ is basic_set:
@@ -1678,8 +10941,10 @@
                 arg1 = basic_set(arg1)
         except:
             return set(arg0).intersect(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_set_intersect(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
     def intersect_params(arg0, arg1):
         try:
             if not arg0.__class__ is basic_set:
@@ -1691,99 +10956,125 @@
                 arg1 = basic_set(arg1)
         except:
             return set(arg0).intersect_params(arg1)
+        ctx = arg0.ctx
         res = isl.isl_basic_set_intersect_params(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def apply(arg0, arg1):
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def is_empty(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        try:
-            if not arg1.__class__ is basic_map:
-                arg1 = basic_map(arg1)
-        except:
-            return set(arg0).apply(arg1)
-        res = isl.isl_basic_set_apply(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_map_copy(arg1.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def affine_hull(arg0):
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_is_empty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_equal(arg0, arg1):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        res = isl.isl_basic_set_affine_hull(isl.isl_basic_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def sample(arg0):
         try:
-            if not arg0.__class__ is basic_set:
-                arg0 = basic_set(arg0)
+            if not arg1.__class__ is basic_set:
+                arg1 = basic_set(arg1)
         except:
+            return set(arg0).is_equal(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
             raise
-        res = isl.isl_basic_set_sample(isl.isl_basic_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def detect_equalities(arg0):
+        return bool(res)
+    def is_subset(arg0, arg1):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        res = isl.isl_basic_set_detect_equalities(isl.isl_basic_set_copy(arg0.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
-    def is_equal(arg0, arg1):
-        res = isl.isl_basic_set_is_equal(arg0.ptr, arg1.ptr)
-        return res
-    def lexmin(arg0):
+        try:
+            if not arg1.__class__ is basic_set:
+                arg1 = basic_set(arg1)
+        except:
+            return set(arg0).is_subset(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_is_subset(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_wrapping(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        res = isl.isl_basic_set_lexmin(isl.isl_basic_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_is_wrapping(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
     def lexmax(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
         res = isl.isl_basic_set_lexmax(isl.isl_basic_set_copy(arg0.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def union(arg0, arg1):
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def lexmin(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_lexmin(isl.isl_basic_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def params(arg0):
         try:
-            if not arg1.__class__ is basic_set:
-                arg1 = basic_set(arg1)
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
         except:
-            return set(arg0).union(arg1)
-        res = isl.isl_basic_set_union(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return set(ctx=arg0.ctx, ptr=res)
-    def is_empty(arg0):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_params(isl.isl_basic_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def sample(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
-        res = isl.isl_basic_set_is_empty(arg0.ptr)
-        return res
-    def is_subset(arg0, arg1):
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_sample(isl.isl_basic_set_copy(arg0.ptr))
+        obj = basic_set(ctx=ctx, ptr=res)
+        return obj
+    def sample_point(arg0):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
         except:
             raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_sample_point(isl.isl_basic_set_copy(arg0.ptr))
+        obj = point(ctx=ctx, ptr=res)
+        return obj
+    def to_set(arg0):
         try:
-            if not arg1.__class__ is basic_set:
-                arg1 = basic_set(arg1)
+            if not arg0.__class__ is basic_set:
+                arg0 = basic_set(arg0)
         except:
-            return set(arg0).is_subset(arg1)
-        res = isl.isl_basic_set_is_subset(arg0.ptr, arg1.ptr)
-        return res
-    def gist(arg0, arg1):
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_to_set(isl.isl_basic_set_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def union(arg0, arg1):
         try:
             if not arg0.__class__ is basic_set:
                 arg0 = basic_set(arg0)
@@ -1793,67 +11084,5195 @@
             if not arg1.__class__ is basic_set:
                 arg1 = basic_set(arg1)
         except:
-            return set(arg0).gist(arg1)
-        res = isl.isl_basic_set_gist(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
-        return basic_set(ctx=arg0.ctx, ptr=res)
+            return set(arg0).union(arg1)
+        ctx = arg0.ctx
+        res = isl.isl_basic_set_union(isl.isl_basic_set_copy(arg0.ptr), isl.isl_basic_set_copy(arg1.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
 
+isl.isl_basic_set_from_point.restype = c_void_p
+isl.isl_basic_set_from_point.argtypes = c_void_p
 isl.isl_basic_set_read_from_str.restype = c_void_p
 isl.isl_basic_set_read_from_str.argtypes = Context, c_char_p
+isl.isl_basic_set_affine_hull.restype = c_void_p
+isl.isl_basic_set_affine_hull.argtypes = c_void_p
+isl.isl_basic_set_apply.restype = c_void_p
+isl.isl_basic_set_apply.argtypes = c_void_p, c_void_p
+isl.isl_basic_set_detect_equalities.restype = c_void_p
+isl.isl_basic_set_detect_equalities.argtypes = c_void_p
+isl.isl_basic_set_dim_max_val.restype = c_void_p
+isl.isl_basic_set_dim_max_val.argtypes = c_void_p, c_int
 isl.isl_basic_set_flatten.restype = c_void_p
+isl.isl_basic_set_flatten.argtypes = c_void_p
+isl.isl_basic_set_gist.restype = c_void_p
+isl.isl_basic_set_gist.argtypes = c_void_p, c_void_p
 isl.isl_basic_set_intersect.restype = c_void_p
+isl.isl_basic_set_intersect.argtypes = c_void_p, c_void_p
 isl.isl_basic_set_intersect_params.restype = c_void_p
-isl.isl_basic_set_apply.restype = c_void_p
-isl.isl_basic_set_affine_hull.restype = c_void_p
-isl.isl_basic_set_sample.restype = c_void_p
-isl.isl_basic_set_detect_equalities.restype = c_void_p
-isl.isl_basic_set_lexmin.restype = c_void_p
+isl.isl_basic_set_intersect_params.argtypes = c_void_p, c_void_p
+isl.isl_basic_set_is_empty.argtypes = c_void_p
+isl.isl_basic_set_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_basic_set_is_subset.argtypes = c_void_p, c_void_p
+isl.isl_basic_set_is_wrapping.argtypes = c_void_p
 isl.isl_basic_set_lexmax.restype = c_void_p
+isl.isl_basic_set_lexmax.argtypes = c_void_p
+isl.isl_basic_set_lexmin.restype = c_void_p
+isl.isl_basic_set_lexmin.argtypes = c_void_p
+isl.isl_basic_set_params.restype = c_void_p
+isl.isl_basic_set_params.argtypes = c_void_p
+isl.isl_basic_set_sample.restype = c_void_p
+isl.isl_basic_set_sample.argtypes = c_void_p
+isl.isl_basic_set_sample_point.restype = c_void_p
+isl.isl_basic_set_sample_point.argtypes = c_void_p
+isl.isl_basic_set_to_set.restype = c_void_p
+isl.isl_basic_set_to_set.argtypes = c_void_p
 isl.isl_basic_set_union.restype = c_void_p
-isl.isl_basic_set_gist.restype = c_void_p
+isl.isl_basic_set_union.argtypes = c_void_p, c_void_p
+isl.isl_basic_set_copy.restype = c_void_p
+isl.isl_basic_set_copy.argtypes = c_void_p
+isl.isl_basic_set_free.restype = c_void_p
 isl.isl_basic_set_free.argtypes = c_void_p
-isl.isl_basic_set_to_str.argtypes = c_void_p
 isl.isl_basic_set_to_str.restype = POINTER(c_char)
+isl.isl_basic_set_to_str.argtypes = c_void_p
+
+class fixed_box(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_fixed_box_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is fixed_box:
+                arg0 = fixed_box(arg0)
+        except:
+            raise
+        ptr = isl.isl_fixed_box_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.fixed_box("""%s""")' % s
+        else:
+            return 'isl.fixed_box("%s")' % s
+    def is_valid(arg0):
+        try:
+            if not arg0.__class__ is fixed_box:
+                arg0 = fixed_box(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_fixed_box_is_valid(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def offset(arg0):
+        try:
+            if not arg0.__class__ is fixed_box:
+                arg0 = fixed_box(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_fixed_box_get_offset(arg0.ptr)
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_offset(arg0):
+        return arg0.offset()
+    def size(arg0):
+        try:
+            if not arg0.__class__ is fixed_box:
+                arg0 = fixed_box(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_fixed_box_get_size(arg0.ptr)
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def get_size(arg0):
+        return arg0.size()
+    def space(arg0):
+        try:
+            if not arg0.__class__ is fixed_box:
+                arg0 = fixed_box(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_fixed_box_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+
+isl.isl_fixed_box_is_valid.argtypes = c_void_p
+isl.isl_fixed_box_get_offset.restype = c_void_p
+isl.isl_fixed_box_get_offset.argtypes = c_void_p
+isl.isl_fixed_box_get_size.restype = c_void_p
+isl.isl_fixed_box_get_size.argtypes = c_void_p
+isl.isl_fixed_box_get_space.restype = c_void_p
+isl.isl_fixed_box_get_space.argtypes = c_void_p
+isl.isl_fixed_box_copy.restype = c_void_p
+isl.isl_fixed_box_copy.argtypes = c_void_p
+isl.isl_fixed_box_free.restype = c_void_p
+isl.isl_fixed_box_free.argtypes = c_void_p
+isl.isl_fixed_box_to_str.restype = POINTER(c_char)
+isl.isl_fixed_box_to_str.argtypes = c_void_p
+
+class id(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_id_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_id_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is id:
+                arg0 = id(arg0)
+        except:
+            raise
+        ptr = isl.isl_id_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.id("""%s""")' % s
+        else:
+            return 'isl.id("%s")' % s
+    def name(arg0):
+        try:
+            if not arg0.__class__ is id:
+                arg0 = id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_get_name(arg0.ptr)
+        if res == 0:
+            raise
+        string = cast(res, c_char_p).value.decode('ascii')
+        return string
+    def get_name(arg0):
+        return arg0.name()
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is id:
+                arg0 = id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_to_list(isl.isl_id_copy(arg0.ptr))
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
 
-class pw_qpolynomial:
+isl.isl_id_read_from_str.restype = c_void_p
+isl.isl_id_read_from_str.argtypes = Context, c_char_p
+isl.isl_id_get_name.restype = POINTER(c_char)
+isl.isl_id_get_name.argtypes = c_void_p
+isl.isl_id_to_list.restype = c_void_p
+isl.isl_id_to_list.argtypes = c_void_p
+isl.isl_id_copy.restype = c_void_p
+isl.isl_id_copy.argtypes = c_void_p
+isl.isl_id_free.restype = c_void_p
+isl.isl_id_free.argtypes = c_void_p
+isl.isl_id_to_str.restype = POINTER(c_char)
+isl.isl_id_to_str.argtypes = c_void_p
+
+class id_list(object):
     def __init__(self, *args, **keywords):
         if "ptr" in keywords:
             self.ctx = keywords"ctx"
             self.ptr = keywords"ptr"
             return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_id_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and (args0.__class__ is id or type(args0) == str):
+            args = list(args)
+            try:
+                if not args0.__class__ is id:
+                    args0 = id(args0)
+            except:
+                raise
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_id_list_from_id(isl.isl_id_copy(args0.ptr))
+            return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
-            isl.isl_pw_qpolynomial_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_pw_qpolynomial_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+            isl.isl_id_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_id_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.pw_qpolynomial("%s")' % str(self)
+        s = str(self)
+        if '"' in s:
+            return 'isl.id_list("""%s""")' % s
+        else:
+            return 'isl.id_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is id:
+                arg1 = id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_add(isl.isl_id_list_copy(arg0.ptr), isl.isl_id_copy(arg1.ptr))
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_get_at(arg0.ptr, arg1)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_clear(isl.isl_id_list_copy(arg0.ptr))
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is id_list:
+                arg1 = id_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_concat(isl.isl_id_list_copy(arg0.ptr), isl.isl_id_list_copy(arg1.ptr))
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_drop(isl.isl_id_list_copy(arg0.ptr), arg1, arg2)
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = id(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_id_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is id:
+                arg2 = id(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_insert(isl.isl_id_list_copy(arg0.ptr), arg1, isl.isl_id_copy(arg2.ptr))
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is id_list:
+                arg0 = id_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_id_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
 
-isl.isl_pw_qpolynomial_free.argtypes = c_void_p
-isl.isl_pw_qpolynomial_to_str.argtypes = c_void_p
-isl.isl_pw_qpolynomial_to_str.restype = POINTER(c_char)
+isl.isl_id_list_alloc.restype = c_void_p
+isl.isl_id_list_alloc.argtypes = Context, c_int
+isl.isl_id_list_from_id.restype = c_void_p
+isl.isl_id_list_from_id.argtypes = c_void_p
+isl.isl_id_list_add.restype = c_void_p
+isl.isl_id_list_add.argtypes = c_void_p, c_void_p
+isl.isl_id_list_get_at.restype = c_void_p
+isl.isl_id_list_get_at.argtypes = c_void_p, c_int
+isl.isl_id_list_clear.restype = c_void_p
+isl.isl_id_list_clear.argtypes = c_void_p
+isl.isl_id_list_concat.restype = c_void_p
+isl.isl_id_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_id_list_drop.restype = c_void_p
+isl.isl_id_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_id_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_id_list_insert.restype = c_void_p
+isl.isl_id_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_id_list_size.argtypes = c_void_p
+isl.isl_id_list_copy.restype = c_void_p
+isl.isl_id_list_copy.argtypes = c_void_p
+isl.isl_id_list_free.restype = c_void_p
+isl.isl_id_list_free.argtypes = c_void_p
+isl.isl_id_list_to_str.restype = POINTER(c_char)
+isl.isl_id_list_to_str.argtypes = c_void_p
 
-class union_pw_qpolynomial:
+class multi_id(object):
     def __init__(self, *args, **keywords):
         if "ptr" in keywords:
             self.ctx = keywords"ctx"
             self.ptr = keywords"ptr"
             return
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is id_list:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_id_from_id_list(isl.isl_space_copy(args0.ptr), isl.isl_id_list_copy(args1.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_id_read_from_str(self.ctx, args0.encode('ascii'))
+            return
         raise Error
     def __del__(self):
         if hasattr(self, 'ptr'):
-            isl.isl_union_pw_qpolynomial_free(self.ptr)
-    def __str__(self):
-        ptr = isl.isl_union_pw_qpolynomial_to_str(self.ptr)
-        res = str(cast(ptr, c_char_p).value)
+            isl.isl_multi_id_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        ptr = isl.isl_multi_id_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
         libc.free(ptr)
         return res
     def __repr__(self):
-        return 'isl.union_pw_qpolynomial("%s")' % str(self)
+        s = str(self)
+        if '"' in s:
+            return 'isl.multi_id("""%s""")' % s
+        else:
+            return 'isl.multi_id("%s")' % s
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_get_at(arg0.ptr, arg1)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_flat_range_product(isl.isl_multi_id_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_id(ctx=ctx, ptr=res)
+        return obj
+    def list(arg0):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_get_list(arg0.ptr)
+        obj = id_list(ctx=ctx, ptr=res)
+        return obj
+    def get_list(arg0):
+        return arg0.list()
+    def plain_is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_plain_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_id:
+                arg1 = multi_id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_range_product(isl.isl_multi_id_copy(arg0.ptr), isl.isl_multi_id_copy(arg1.ptr))
+        obj = multi_id(ctx=ctx, ptr=res)
+        return obj
+    def set_at(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is id:
+                arg2 = id(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_set_at(isl.isl_multi_id_copy(arg0.ptr), arg1, isl.isl_id_copy(arg2.ptr))
+        obj = multi_id(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def space(arg0):
+        try:
+            if not arg0.__class__ is multi_id:
+                arg0 = multi_id(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_id_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+
+isl.isl_multi_id_from_id_list.restype = c_void_p
+isl.isl_multi_id_from_id_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_id_read_from_str.restype = c_void_p
+isl.isl_multi_id_read_from_str.argtypes = Context, c_char_p
+isl.isl_multi_id_get_at.restype = c_void_p
+isl.isl_multi_id_get_at.argtypes = c_void_p, c_int
+isl.isl_multi_id_flat_range_product.restype = c_void_p
+isl.isl_multi_id_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_id_get_list.restype = c_void_p
+isl.isl_multi_id_get_list.argtypes = c_void_p
+isl.isl_multi_id_plain_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_multi_id_range_product.restype = c_void_p
+isl.isl_multi_id_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_id_set_at.restype = c_void_p
+isl.isl_multi_id_set_at.argtypes = c_void_p, c_int, c_void_p
+isl.isl_multi_id_size.argtypes = c_void_p
+isl.isl_multi_id_get_space.restype = c_void_p
+isl.isl_multi_id_get_space.argtypes = c_void_p
+isl.isl_multi_id_copy.restype = c_void_p
+isl.isl_multi_id_copy.argtypes = c_void_p
+isl.isl_multi_id_free.restype = c_void_p
+isl.isl_multi_id_free.argtypes = c_void_p
+isl.isl_multi_id_to_str.restype = POINTER(c_char)
+isl.isl_multi_id_to_str.argtypes = c_void_p
+
+class multi_val(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 2 and args0.__class__ is space and args1.__class__ is val_list:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_val_from_val_list(isl.isl_space_copy(args0.ptr), isl.isl_val_list_copy(args1.ptr))
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_multi_val_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_multi_val_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ptr = isl.isl_multi_val_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.multi_val("""%s""")' % s
+        else:
+            return 'isl.multi_val("%s")' % s
+    def add(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_val_add(isl.isl_multi_val_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_val_add_val(isl.isl_multi_val_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_get_at(arg0.ptr, arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def flat_range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_flat_range_product(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def involves_nan(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_involves_nan(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def list(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_get_list(arg0.ptr)
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def get_list(arg0):
+        return arg0.list()
+    def max(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_max(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def min(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_min(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_neg(isl.isl_multi_val_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def plain_is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_plain_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_product(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def range_product(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_range_product(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reset_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_reset_range_tuple_id(isl.isl_multi_val_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def scale(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_val_scale_multi_val(isl.isl_multi_val_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_val_scale_val(isl.isl_multi_val_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def scale_down(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_multi_val_scale_down_multi_val(isl.isl_multi_val_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        if len(args) == 2 and (args1.__class__ is val or type(args1) == int):
+            args = list(args)
+            try:
+                if not args1.__class__ is val:
+                    args1 = val(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_val_scale_down_val(isl.isl_multi_val_copy(args0.ptr), isl.isl_val_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_at(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is val:
+                arg2 = val(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_set_at(isl.isl_multi_val_copy(arg0.ptr), arg1, isl.isl_val_copy(arg2.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_multi_val_set_range_tuple_id(isl.isl_multi_val_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = multi_val(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def size(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def space(arg0):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_get_space(arg0.ptr)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def get_space(arg0):
+        return arg0.space()
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is multi_val:
+                arg0 = multi_val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_sub(isl.isl_multi_val_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_multi_val_zero(isl.isl_space_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_multi_val_from_val_list.restype = c_void_p
+isl.isl_multi_val_from_val_list.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_read_from_str.restype = c_void_p
+isl.isl_multi_val_read_from_str.argtypes = Context, c_char_p
+isl.isl_multi_val_add.restype = c_void_p
+isl.isl_multi_val_add.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_add_val.restype = c_void_p
+isl.isl_multi_val_add_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_get_at.restype = c_void_p
+isl.isl_multi_val_get_at.argtypes = c_void_p, c_int
+isl.isl_multi_val_flat_range_product.restype = c_void_p
+isl.isl_multi_val_flat_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_has_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_val_involves_nan.argtypes = c_void_p
+isl.isl_multi_val_get_list.restype = c_void_p
+isl.isl_multi_val_get_list.argtypes = c_void_p
+isl.isl_multi_val_max.restype = c_void_p
+isl.isl_multi_val_max.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_min.restype = c_void_p
+isl.isl_multi_val_min.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_neg.restype = c_void_p
+isl.isl_multi_val_neg.argtypes = c_void_p
+isl.isl_multi_val_plain_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_product.restype = c_void_p
+isl.isl_multi_val_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_range_product.restype = c_void_p
+isl.isl_multi_val_range_product.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_get_range_tuple_id.restype = c_void_p
+isl.isl_multi_val_get_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_val_reset_range_tuple_id.restype = c_void_p
+isl.isl_multi_val_reset_range_tuple_id.argtypes = c_void_p
+isl.isl_multi_val_scale_multi_val.restype = c_void_p
+isl.isl_multi_val_scale_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_scale_val.restype = c_void_p
+isl.isl_multi_val_scale_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_scale_down_multi_val.restype = c_void_p
+isl.isl_multi_val_scale_down_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_scale_down_val.restype = c_void_p
+isl.isl_multi_val_scale_down_val.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_set_at.restype = c_void_p
+isl.isl_multi_val_set_at.argtypes = c_void_p, c_int, c_void_p
+isl.isl_multi_val_set_range_tuple_id.restype = c_void_p
+isl.isl_multi_val_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_size.argtypes = c_void_p
+isl.isl_multi_val_get_space.restype = c_void_p
+isl.isl_multi_val_get_space.argtypes = c_void_p
+isl.isl_multi_val_sub.restype = c_void_p
+isl.isl_multi_val_sub.argtypes = c_void_p, c_void_p
+isl.isl_multi_val_zero.restype = c_void_p
+isl.isl_multi_val_zero.argtypes = c_void_p
+isl.isl_multi_val_copy.restype = c_void_p
+isl.isl_multi_val_copy.argtypes = c_void_p
+isl.isl_multi_val_free.restype = c_void_p
+isl.isl_multi_val_free.argtypes = c_void_p
+isl.isl_multi_val_to_str.restype = POINTER(c_char)
+isl.isl_multi_val_to_str.argtypes = c_void_p
+
+class point(basic_set):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_point_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is point:
+                arg0 = point(arg0)
+        except:
+            raise
+        ptr = isl.isl_point_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.point("""%s""")' % s
+        else:
+            return 'isl.point("%s")' % s
+    def multi_val(arg0):
+        try:
+            if not arg0.__class__ is point:
+                arg0 = point(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_point_get_multi_val(arg0.ptr)
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def get_multi_val(arg0):
+        return arg0.multi_val()
+    def to_set(arg0):
+        try:
+            if not arg0.__class__ is point:
+                arg0 = point(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_point_to_set(isl.isl_point_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_point_get_multi_val.restype = c_void_p
+isl.isl_point_get_multi_val.argtypes = c_void_p
+isl.isl_point_to_set.restype = c_void_p
+isl.isl_point_to_set.argtypes = c_void_p
+isl.isl_point_copy.restype = c_void_p
+isl.isl_point_copy.argtypes = c_void_p
+isl.isl_point_free.restype = c_void_p
+isl.isl_point_free.argtypes = c_void_p
+isl.isl_point_to_str.restype = POINTER(c_char)
+isl.isl_point_to_str.argtypes = c_void_p
+
+class pw_aff_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_aff_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_aff_list_from_pw_aff(isl.isl_pw_aff_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_pw_aff_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_pw_aff_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.pw_aff_list("""%s""")' % s
+        else:
+            return 'isl.pw_aff_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff:
+                arg1 = pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_add(isl.isl_pw_aff_list_copy(arg0.ptr), isl.isl_pw_aff_copy(arg1.ptr))
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_get_at(arg0.ptr, arg1)
+        obj = pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_clear(isl.isl_pw_aff_list_copy(arg0.ptr))
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff_list:
+                arg1 = pw_aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_concat(isl.isl_pw_aff_list_copy(arg0.ptr), isl.isl_pw_aff_list_copy(arg1.ptr))
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_drop(isl.isl_pw_aff_list_copy(arg0.ptr), arg1, arg2)
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = pw_aff(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is pw_aff:
+                arg2 = pw_aff(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_insert(isl.isl_pw_aff_list_copy(arg0.ptr), arg1, isl.isl_pw_aff_copy(arg2.ptr))
+        obj = pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is pw_aff_list:
+                arg0 = pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_aff_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_pw_aff_list_alloc.restype = c_void_p
+isl.isl_pw_aff_list_alloc.argtypes = Context, c_int
+isl.isl_pw_aff_list_from_pw_aff.restype = c_void_p
+isl.isl_pw_aff_list_from_pw_aff.argtypes = c_void_p
+isl.isl_pw_aff_list_add.restype = c_void_p
+isl.isl_pw_aff_list_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_list_get_at.restype = c_void_p
+isl.isl_pw_aff_list_get_at.argtypes = c_void_p, c_int
+isl.isl_pw_aff_list_clear.restype = c_void_p
+isl.isl_pw_aff_list_clear.argtypes = c_void_p
+isl.isl_pw_aff_list_concat.restype = c_void_p
+isl.isl_pw_aff_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_pw_aff_list_drop.restype = c_void_p
+isl.isl_pw_aff_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_pw_aff_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_pw_aff_list_insert.restype = c_void_p
+isl.isl_pw_aff_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_pw_aff_list_size.argtypes = c_void_p
+isl.isl_pw_aff_list_copy.restype = c_void_p
+isl.isl_pw_aff_list_copy.argtypes = c_void_p
+isl.isl_pw_aff_list_free.restype = c_void_p
+isl.isl_pw_aff_list_free.argtypes = c_void_p
+isl.isl_pw_aff_list_to_str.restype = POINTER(c_char)
+isl.isl_pw_aff_list_to_str.argtypes = c_void_p
+
+class pw_multi_aff_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_multi_aff_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is pw_multi_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_pw_multi_aff_list_from_pw_multi_aff(isl.isl_pw_multi_aff_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_pw_multi_aff_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_pw_multi_aff_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.pw_multi_aff_list("""%s""")' % s
+        else:
+            return 'isl.pw_multi_aff_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff:
+                arg1 = pw_multi_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_add(isl.isl_pw_multi_aff_list_copy(arg0.ptr), isl.isl_pw_multi_aff_copy(arg1.ptr))
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_get_at(arg0.ptr, arg1)
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_clear(isl.isl_pw_multi_aff_list_copy(arg0.ptr))
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_multi_aff_list:
+                arg1 = pw_multi_aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_concat(isl.isl_pw_multi_aff_list_copy(arg0.ptr), isl.isl_pw_multi_aff_list_copy(arg1.ptr))
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_drop(isl.isl_pw_multi_aff_list_copy(arg0.ptr), arg1, arg2)
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = pw_multi_aff(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is pw_multi_aff:
+                arg2 = pw_multi_aff(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_insert(isl.isl_pw_multi_aff_list_copy(arg0.ptr), arg1, isl.isl_pw_multi_aff_copy(arg2.ptr))
+        obj = pw_multi_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is pw_multi_aff_list:
+                arg0 = pw_multi_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_pw_multi_aff_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_pw_multi_aff_list_alloc.restype = c_void_p
+isl.isl_pw_multi_aff_list_alloc.argtypes = Context, c_int
+isl.isl_pw_multi_aff_list_from_pw_multi_aff.restype = c_void_p
+isl.isl_pw_multi_aff_list_from_pw_multi_aff.argtypes = c_void_p
+isl.isl_pw_multi_aff_list_add.restype = c_void_p
+isl.isl_pw_multi_aff_list_add.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_list_get_at.restype = c_void_p
+isl.isl_pw_multi_aff_list_get_at.argtypes = c_void_p, c_int
+isl.isl_pw_multi_aff_list_clear.restype = c_void_p
+isl.isl_pw_multi_aff_list_clear.argtypes = c_void_p
+isl.isl_pw_multi_aff_list_concat.restype = c_void_p
+isl.isl_pw_multi_aff_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_pw_multi_aff_list_drop.restype = c_void_p
+isl.isl_pw_multi_aff_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_pw_multi_aff_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_pw_multi_aff_list_insert.restype = c_void_p
+isl.isl_pw_multi_aff_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_pw_multi_aff_list_size.argtypes = c_void_p
+isl.isl_pw_multi_aff_list_copy.restype = c_void_p
+isl.isl_pw_multi_aff_list_copy.argtypes = c_void_p
+isl.isl_pw_multi_aff_list_free.restype = c_void_p
+isl.isl_pw_multi_aff_list_free.argtypes = c_void_p
+isl.isl_pw_multi_aff_list_to_str.restype = POINTER(c_char)
+isl.isl_pw_multi_aff_list_to_str.argtypes = c_void_p
+
+class schedule(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_schedule_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule:
+                arg0 = schedule(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule("""%s""")' % s
+        else:
+            return 'isl.schedule("%s")' % s
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is schedule:
+                arg0 = schedule(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_get_domain(arg0.ptr)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_domain(arg0):
+        return arg0.domain()
+    @staticmethod
+    def from_domain(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_from_domain(isl.isl_union_set_copy(arg0.ptr))
+        obj = schedule(ctx=ctx, ptr=res)
+        return obj
+    def map(arg0):
+        try:
+            if not arg0.__class__ is schedule:
+                arg0 = schedule(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_get_map(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_map(arg0):
+        return arg0.map()
+    def pullback(*args):
+        if len(args) == 2 and args1.__class__ is union_pw_multi_aff:
+            ctx = args0.ctx
+            res = isl.isl_schedule_pullback_union_pw_multi_aff(isl.isl_schedule_copy(args0.ptr), isl.isl_union_pw_multi_aff_copy(args1.ptr))
+            obj = schedule(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def root(arg0):
+        try:
+            if not arg0.__class__ is schedule:
+                arg0 = schedule(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_get_root(arg0.ptr)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def get_root(arg0):
+        return arg0.root()
+
+isl.isl_schedule_read_from_str.restype = c_void_p
+isl.isl_schedule_read_from_str.argtypes = Context, c_char_p
+isl.isl_schedule_get_domain.restype = c_void_p
+isl.isl_schedule_get_domain.argtypes = c_void_p
+isl.isl_schedule_from_domain.restype = c_void_p
+isl.isl_schedule_from_domain.argtypes = c_void_p
+isl.isl_schedule_get_map.restype = c_void_p
+isl.isl_schedule_get_map.argtypes = c_void_p
+isl.isl_schedule_pullback_union_pw_multi_aff.restype = c_void_p
+isl.isl_schedule_pullback_union_pw_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_schedule_get_root.restype = c_void_p
+isl.isl_schedule_get_root.argtypes = c_void_p
+isl.isl_schedule_copy.restype = c_void_p
+isl.isl_schedule_copy.argtypes = c_void_p
+isl.isl_schedule_free.restype = c_void_p
+isl.isl_schedule_free.argtypes = c_void_p
+isl.isl_schedule_to_str.restype = POINTER(c_char)
+isl.isl_schedule_to_str.argtypes = c_void_p
+
+class schedule_constraints(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_schedule_constraints_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_constraints_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_constraints_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_constraints("""%s""")' % s
+        else:
+            return 'isl.schedule_constraints("%s")' % s
+    def coincidence(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_coincidence(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_coincidence(arg0):
+        return arg0.coincidence()
+    def compute_schedule(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_compute_schedule(isl.isl_schedule_constraints_copy(arg0.ptr))
+        obj = schedule(ctx=ctx, ptr=res)
+        return obj
+    def conditional_validity(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_conditional_validity(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_conditional_validity(arg0):
+        return arg0.conditional_validity()
+    def conditional_validity_condition(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_conditional_validity_condition(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_conditional_validity_condition(arg0):
+        return arg0.conditional_validity_condition()
+    def context(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_context(arg0.ptr)
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def get_context(arg0):
+        return arg0.context()
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_domain(arg0.ptr)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_domain(arg0):
+        return arg0.domain()
+    @staticmethod
+    def on_domain(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_on_domain(isl.isl_union_set_copy(arg0.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def proximity(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_proximity(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_proximity(arg0):
+        return arg0.proximity()
+    def set_coincidence(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_set_coincidence(isl.isl_schedule_constraints_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def set_conditional_validity(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is union_map:
+                arg2 = union_map(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_set_conditional_validity(isl.isl_schedule_constraints_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr), isl.isl_union_map_copy(arg2.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def set_context(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_set_context(isl.isl_schedule_constraints_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def set_proximity(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_set_proximity(isl.isl_schedule_constraints_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def set_validity(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_set_validity(isl.isl_schedule_constraints_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = schedule_constraints(ctx=ctx, ptr=res)
+        return obj
+    def validity(arg0):
+        try:
+            if not arg0.__class__ is schedule_constraints:
+                arg0 = schedule_constraints(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_constraints_get_validity(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_validity(arg0):
+        return arg0.validity()
+
+isl.isl_schedule_constraints_read_from_str.restype = c_void_p
+isl.isl_schedule_constraints_read_from_str.argtypes = Context, c_char_p
+isl.isl_schedule_constraints_get_coincidence.restype = c_void_p
+isl.isl_schedule_constraints_get_coincidence.argtypes = c_void_p
+isl.isl_schedule_constraints_compute_schedule.restype = c_void_p
+isl.isl_schedule_constraints_compute_schedule.argtypes = c_void_p
+isl.isl_schedule_constraints_get_conditional_validity.restype = c_void_p
+isl.isl_schedule_constraints_get_conditional_validity.argtypes = c_void_p
+isl.isl_schedule_constraints_get_conditional_validity_condition.restype = c_void_p
+isl.isl_schedule_constraints_get_conditional_validity_condition.argtypes = c_void_p
+isl.isl_schedule_constraints_get_context.restype = c_void_p
+isl.isl_schedule_constraints_get_context.argtypes = c_void_p
+isl.isl_schedule_constraints_get_domain.restype = c_void_p
+isl.isl_schedule_constraints_get_domain.argtypes = c_void_p
+isl.isl_schedule_constraints_on_domain.restype = c_void_p
+isl.isl_schedule_constraints_on_domain.argtypes = c_void_p
+isl.isl_schedule_constraints_get_proximity.restype = c_void_p
+isl.isl_schedule_constraints_get_proximity.argtypes = c_void_p
+isl.isl_schedule_constraints_set_coincidence.restype = c_void_p
+isl.isl_schedule_constraints_set_coincidence.argtypes = c_void_p, c_void_p
+isl.isl_schedule_constraints_set_conditional_validity.restype = c_void_p
+isl.isl_schedule_constraints_set_conditional_validity.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_schedule_constraints_set_context.restype = c_void_p
+isl.isl_schedule_constraints_set_context.argtypes = c_void_p, c_void_p
+isl.isl_schedule_constraints_set_proximity.restype = c_void_p
+isl.isl_schedule_constraints_set_proximity.argtypes = c_void_p, c_void_p
+isl.isl_schedule_constraints_set_validity.restype = c_void_p
+isl.isl_schedule_constraints_set_validity.argtypes = c_void_p, c_void_p
+isl.isl_schedule_constraints_get_validity.restype = c_void_p
+isl.isl_schedule_constraints_get_validity.argtypes = c_void_p
+isl.isl_schedule_constraints_copy.restype = c_void_p
+isl.isl_schedule_constraints_copy.argtypes = c_void_p
+isl.isl_schedule_constraints_free.restype = c_void_p
+isl.isl_schedule_constraints_free.argtypes = c_void_p
+isl.isl_schedule_constraints_to_str.restype = POINTER(c_char)
+isl.isl_schedule_constraints_to_str.argtypes = c_void_p
+
+class schedule_node(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_band):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_context):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_domain):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_expansion):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_extension):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_filter):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_leaf):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_guard):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_mark):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_sequence):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        if len(args) == 1 and isinstance(args0, schedule_node_set):
+            self.ctx = args0.ctx
+            self.ptr = isl.isl_schedule_node_copy(args0.ptr)
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        if "ptr" in keywords:
+            type = isl.isl_schedule_node_get_type(keywords"ptr")
+            if type == 0:
+                return schedule_node_band(**keywords)
+            if type == 1:
+                return schedule_node_context(**keywords)
+            if type == 2:
+                return schedule_node_domain(**keywords)
+            if type == 3:
+                return schedule_node_expansion(**keywords)
+            if type == 4:
+                return schedule_node_extension(**keywords)
+            if type == 5:
+                return schedule_node_filter(**keywords)
+            if type == 6:
+                return schedule_node_leaf(**keywords)
+            if type == 7:
+                return schedule_node_guard(**keywords)
+            if type == 8:
+                return schedule_node_mark(**keywords)
+            if type == 9:
+                return schedule_node_sequence(**keywords)
+            if type == 10:
+                return schedule_node_set(**keywords)
+            raise
+        return super(schedule_node, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node("""%s""")' % s
+        else:
+            return 'isl.schedule_node("%s")' % s
+    def ancestor(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_ancestor(isl.isl_schedule_node_copy(arg0.ptr), arg1)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def ancestor_child_position(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule_node:
+                arg1 = schedule_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_ancestor_child_position(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def get_ancestor_child_position(arg0, arg1):
+        return arg0.ancestor_child_position(arg1)
+    def child(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_child(isl.isl_schedule_node_copy(arg0.ptr), arg1)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def child_position(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_child_position(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def get_child_position(arg0):
+        return arg0.child_position()
+    def every_descendant(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = schedule_node(ctx=arg0.ctx, ptr=isl.isl_schedule_node_copy(cb_arg0))
+            try:
+                res = arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 1 if res else 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_every_descendant(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+        return bool(res)
+    def first_child(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_first_child(isl.isl_schedule_node_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def foreach_ancestor_top_down(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = schedule_node(ctx=arg0.ctx, ptr=isl.isl_schedule_node_copy(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_foreach_ancestor_top_down(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def foreach_descendant_top_down(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = schedule_node(ctx=arg0.ctx, ptr=isl.isl_schedule_node_copy(cb_arg0))
+            try:
+                res = arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 1 if res else 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_foreach_descendant_top_down(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    @staticmethod
+    def from_domain(arg0):
+        try:
+            if not arg0.__class__ is union_set:
+                arg0 = union_set(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_from_domain(isl.isl_union_set_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def from_extension(arg0):
+        try:
+            if not arg0.__class__ is union_map:
+                arg0 = union_map(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_from_extension(isl.isl_union_map_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def graft_after(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule_node:
+                arg1 = schedule_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_graft_after(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_schedule_node_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def graft_before(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule_node:
+                arg1 = schedule_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_graft_before(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_schedule_node_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def has_children(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_has_children(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def has_next_sibling(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_has_next_sibling(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def has_parent(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_has_parent(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def has_previous_sibling(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_has_previous_sibling(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def insert_context(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_context(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_filter(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_filter(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_guard(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is set:
+                arg1 = set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_guard(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_mark(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is id:
+                arg1 = id(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_mark(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_id_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_partial_schedule(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_partial_schedule(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_sequence(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set_list:
+                arg1 = union_set_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_sequence(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_list_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def insert_set(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set_list:
+                arg1 = union_set_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_insert_set(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_list_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule_node:
+                arg1 = schedule_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_subtree_anchored(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_is_subtree_anchored(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def map_descendant_bottom_up(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_void_p, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = schedule_node(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                res = arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return None
+            return isl.isl_schedule_node_copy(res.ptr)
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_map_descendant_bottom_up(isl.isl_schedule_node_copy(arg0.ptr), cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def n_children(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_n_children(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def next_sibling(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_next_sibling(isl.isl_schedule_node_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def order_after(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_order_after(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def order_before(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_order_before(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def parent(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_parent(isl.isl_schedule_node_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def prefix_schedule_multi_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(arg0.ptr)
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_prefix_schedule_multi_union_pw_aff(arg0):
+        return arg0.prefix_schedule_multi_union_pw_aff()
+    def prefix_schedule_union_map(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_prefix_schedule_union_map(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_prefix_schedule_union_map(arg0):
+        return arg0.prefix_schedule_union_map()
+    def prefix_schedule_union_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(arg0.ptr)
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_prefix_schedule_union_pw_multi_aff(arg0):
+        return arg0.prefix_schedule_union_pw_multi_aff()
+    def previous_sibling(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_previous_sibling(isl.isl_schedule_node_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def root(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_root(isl.isl_schedule_node_copy(arg0.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def schedule(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_schedule(arg0.ptr)
+        obj = schedule(ctx=ctx, ptr=res)
+        return obj
+    def get_schedule(arg0):
+        return arg0.schedule()
+    def shared_ancestor(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule_node:
+                arg1 = schedule_node(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_shared_ancestor(arg0.ptr, arg1.ptr)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def get_shared_ancestor(arg0, arg1):
+        return arg0.shared_ancestor(arg1)
+    def tree_depth(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_get_tree_depth(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def get_tree_depth(arg0):
+        return arg0.tree_depth()
+
+isl.isl_schedule_node_ancestor.restype = c_void_p
+isl.isl_schedule_node_ancestor.argtypes = c_void_p, c_int
+isl.isl_schedule_node_get_ancestor_child_position.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_child.restype = c_void_p
+isl.isl_schedule_node_child.argtypes = c_void_p, c_int
+isl.isl_schedule_node_get_child_position.argtypes = c_void_p
+isl.isl_schedule_node_every_descendant.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_schedule_node_first_child.restype = c_void_p
+isl.isl_schedule_node_first_child.argtypes = c_void_p
+isl.isl_schedule_node_foreach_ancestor_top_down.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_schedule_node_foreach_descendant_top_down.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_schedule_node_from_domain.restype = c_void_p
+isl.isl_schedule_node_from_domain.argtypes = c_void_p
+isl.isl_schedule_node_from_extension.restype = c_void_p
+isl.isl_schedule_node_from_extension.argtypes = c_void_p
+isl.isl_schedule_node_graft_after.restype = c_void_p
+isl.isl_schedule_node_graft_after.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_graft_before.restype = c_void_p
+isl.isl_schedule_node_graft_before.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_has_children.argtypes = c_void_p
+isl.isl_schedule_node_has_next_sibling.argtypes = c_void_p
+isl.isl_schedule_node_has_parent.argtypes = c_void_p
+isl.isl_schedule_node_has_previous_sibling.argtypes = c_void_p
+isl.isl_schedule_node_insert_context.restype = c_void_p
+isl.isl_schedule_node_insert_context.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_filter.restype = c_void_p
+isl.isl_schedule_node_insert_filter.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_guard.restype = c_void_p
+isl.isl_schedule_node_insert_guard.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_mark.restype = c_void_p
+isl.isl_schedule_node_insert_mark.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_partial_schedule.restype = c_void_p
+isl.isl_schedule_node_insert_partial_schedule.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_sequence.restype = c_void_p
+isl.isl_schedule_node_insert_sequence.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_insert_set.restype = c_void_p
+isl.isl_schedule_node_insert_set.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_is_subtree_anchored.argtypes = c_void_p
+isl.isl_schedule_node_map_descendant_bottom_up.restype = c_void_p
+isl.isl_schedule_node_map_descendant_bottom_up.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_schedule_node_n_children.argtypes = c_void_p
+isl.isl_schedule_node_next_sibling.restype = c_void_p
+isl.isl_schedule_node_next_sibling.argtypes = c_void_p
+isl.isl_schedule_node_order_after.restype = c_void_p
+isl.isl_schedule_node_order_after.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_order_before.restype = c_void_p
+isl.isl_schedule_node_order_before.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_parent.restype = c_void_p
+isl.isl_schedule_node_parent.argtypes = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_multi_union_pw_aff.restype = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_union_map.restype = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_union_map.argtypes = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_union_pw_multi_aff.restype = c_void_p
+isl.isl_schedule_node_get_prefix_schedule_union_pw_multi_aff.argtypes = c_void_p
+isl.isl_schedule_node_previous_sibling.restype = c_void_p
+isl.isl_schedule_node_previous_sibling.argtypes = c_void_p
+isl.isl_schedule_node_root.restype = c_void_p
+isl.isl_schedule_node_root.argtypes = c_void_p
+isl.isl_schedule_node_get_schedule.restype = c_void_p
+isl.isl_schedule_node_get_schedule.argtypes = c_void_p
+isl.isl_schedule_node_get_shared_ancestor.restype = c_void_p
+isl.isl_schedule_node_get_shared_ancestor.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_get_tree_depth.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+isl.isl_schedule_node_get_type.argtypes = c_void_p
+
+class schedule_node_band(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_band, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_band:
+                arg0 = schedule_node_band(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_band("""%s""")' % s
+        else:
+            return 'isl.schedule_node_band("%s")' % s
+    def ast_build_options(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_get_ast_build_options(arg0.ptr)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_ast_build_options(arg0):
+        return arg0.ast_build_options()
+    def ast_isolate_option(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_get_ast_isolate_option(arg0.ptr)
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def get_ast_isolate_option(arg0):
+        return arg0.ast_isolate_option()
+    def member_get_coincident(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_get_coincident(arg0.ptr, arg1)
+        if res < 0:
+            raise
+        return bool(res)
+    def member_set_coincident(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_set_coincident(isl.isl_schedule_node_copy(arg0.ptr), arg1, arg2)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def mod(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_mod(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def n_member(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_n_member(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+    def partial_schedule(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_get_partial_schedule(arg0.ptr)
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_partial_schedule(arg0):
+        return arg0.partial_schedule()
+    def permutable(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_get_permutable(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def get_permutable(arg0):
+        return arg0.permutable()
+    def scale(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_scale(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def scale_down(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_scale_down(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def set_ast_build_options(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_set_ast_build_options(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def set_permutable(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_set_permutable(isl.isl_schedule_node_copy(arg0.ptr), arg1)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def shift(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_union_pw_aff:
+                arg1 = multi_union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_shift(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_union_pw_aff_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def split(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_split(isl.isl_schedule_node_copy(arg0.ptr), arg1)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def tile(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is multi_val:
+                arg1 = multi_val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_tile(isl.isl_schedule_node_copy(arg0.ptr), isl.isl_multi_val_copy(arg1.ptr))
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def member_set_ast_loop_default(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_set_ast_loop_type(isl.isl_schedule_node_copy(arg0.ptr), arg1, 0)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def member_set_ast_loop_atomic(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_set_ast_loop_type(isl.isl_schedule_node_copy(arg0.ptr), arg1, 1)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def member_set_ast_loop_unroll(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_set_ast_loop_type(isl.isl_schedule_node_copy(arg0.ptr), arg1, 2)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+    def member_set_ast_loop_separate(arg0, arg1):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_band_member_set_ast_loop_type(isl.isl_schedule_node_copy(arg0.ptr), arg1, 3)
+        obj = schedule_node(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_schedule_node_band_get_ast_build_options.restype = c_void_p
+isl.isl_schedule_node_band_get_ast_build_options.argtypes = c_void_p
+isl.isl_schedule_node_band_get_ast_isolate_option.restype = c_void_p
+isl.isl_schedule_node_band_get_ast_isolate_option.argtypes = c_void_p
+isl.isl_schedule_node_band_member_get_coincident.argtypes = c_void_p, c_int
+isl.isl_schedule_node_band_member_set_coincident.restype = c_void_p
+isl.isl_schedule_node_band_member_set_coincident.argtypes = c_void_p, c_int, c_int
+isl.isl_schedule_node_band_mod.restype = c_void_p
+isl.isl_schedule_node_band_mod.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_n_member.argtypes = c_void_p
+isl.isl_schedule_node_band_get_partial_schedule.restype = c_void_p
+isl.isl_schedule_node_band_get_partial_schedule.argtypes = c_void_p
+isl.isl_schedule_node_band_get_permutable.argtypes = c_void_p
+isl.isl_schedule_node_band_scale.restype = c_void_p
+isl.isl_schedule_node_band_scale.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_scale_down.restype = c_void_p
+isl.isl_schedule_node_band_scale_down.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_set_ast_build_options.restype = c_void_p
+isl.isl_schedule_node_band_set_ast_build_options.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_set_permutable.restype = c_void_p
+isl.isl_schedule_node_band_set_permutable.argtypes = c_void_p, c_int
+isl.isl_schedule_node_band_shift.restype = c_void_p
+isl.isl_schedule_node_band_shift.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_split.restype = c_void_p
+isl.isl_schedule_node_band_split.argtypes = c_void_p, c_int
+isl.isl_schedule_node_band_tile.restype = c_void_p
+isl.isl_schedule_node_band_tile.argtypes = c_void_p, c_void_p
+isl.isl_schedule_node_band_member_set_ast_loop_type.restype = c_void_p
+isl.isl_schedule_node_band_member_set_ast_loop_type.argtypes = c_void_p, c_int, c_int
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_context(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_context, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_context:
+                arg0 = schedule_node_context(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_context("""%s""")' % s
+        else:
+            return 'isl.schedule_node_context("%s")' % s
+    def context(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_context_get_context(arg0.ptr)
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def get_context(arg0):
+        return arg0.context()
+
+isl.isl_schedule_node_context_get_context.restype = c_void_p
+isl.isl_schedule_node_context_get_context.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_domain(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_domain, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_domain:
+                arg0 = schedule_node_domain(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_domain("""%s""")' % s
+        else:
+            return 'isl.schedule_node_domain("%s")' % s
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_domain_get_domain(arg0.ptr)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_domain(arg0):
+        return arg0.domain()
+
+isl.isl_schedule_node_domain_get_domain.restype = c_void_p
+isl.isl_schedule_node_domain_get_domain.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_expansion(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_expansion, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_expansion:
+                arg0 = schedule_node_expansion(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_expansion("""%s""")' % s
+        else:
+            return 'isl.schedule_node_expansion("%s")' % s
+    def contraction(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_expansion_get_contraction(arg0.ptr)
+        obj = union_pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_contraction(arg0):
+        return arg0.contraction()
+    def expansion(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_expansion_get_expansion(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_expansion(arg0):
+        return arg0.expansion()
+
+isl.isl_schedule_node_expansion_get_contraction.restype = c_void_p
+isl.isl_schedule_node_expansion_get_contraction.argtypes = c_void_p
+isl.isl_schedule_node_expansion_get_expansion.restype = c_void_p
+isl.isl_schedule_node_expansion_get_expansion.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_extension(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_extension, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_extension:
+                arg0 = schedule_node_extension(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_extension("""%s""")' % s
+        else:
+            return 'isl.schedule_node_extension("%s")' % s
+    def extension(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_extension_get_extension(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_extension(arg0):
+        return arg0.extension()
+
+isl.isl_schedule_node_extension_get_extension.restype = c_void_p
+isl.isl_schedule_node_extension_get_extension.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_filter(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_filter, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_filter:
+                arg0 = schedule_node_filter(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_filter("""%s""")' % s
+        else:
+            return 'isl.schedule_node_filter("%s")' % s
+    def filter(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_filter_get_filter(arg0.ptr)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_filter(arg0):
+        return arg0.filter()
+
+isl.isl_schedule_node_filter_get_filter.restype = c_void_p
+isl.isl_schedule_node_filter_get_filter.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_guard(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_guard, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_guard:
+                arg0 = schedule_node_guard(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_guard("""%s""")' % s
+        else:
+            return 'isl.schedule_node_guard("%s")' % s
+    def guard(arg0):
+        try:
+            if not arg0.__class__ is schedule_node:
+                arg0 = schedule_node(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_schedule_node_guard_get_guard(arg0.ptr)
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def get_guard(arg0):
+        return arg0.guard()
+
+isl.isl_schedule_node_guard_get_guard.restype = c_void_p
+isl.isl_schedule_node_guard_get_guard.argtypes = c_void_p
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_leaf(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_leaf, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_leaf:
+                arg0 = schedule_node_leaf(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_leaf("""%s""")' % s
+        else:
+            return 'isl.schedule_node_leaf("%s")' % s
+
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_mark(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_mark, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_mark:
+                arg0 = schedule_node_mark(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_mark("""%s""")' % s
+        else:
+            return 'isl.schedule_node_mark("%s")' % s
+
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_sequence(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_sequence, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_sequence:
+                arg0 = schedule_node_sequence(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_sequence("""%s""")' % s
+        else:
+            return 'isl.schedule_node_sequence("%s")' % s
+
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class schedule_node_set(schedule_node):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_schedule_node_free(self.ptr)
+    def __new__(cls, *args, **keywords):
+        return super(schedule_node_set, cls).__new__(cls)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is schedule_node_set:
+                arg0 = schedule_node_set(arg0)
+        except:
+            raise
+        ptr = isl.isl_schedule_node_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.schedule_node_set("""%s""")' % s
+        else:
+            return 'isl.schedule_node_set("%s")' % s
+
+isl.isl_schedule_node_copy.restype = c_void_p
+isl.isl_schedule_node_copy.argtypes = c_void_p
+isl.isl_schedule_node_free.restype = c_void_p
+isl.isl_schedule_node_free.argtypes = c_void_p
+isl.isl_schedule_node_to_str.restype = POINTER(c_char)
+isl.isl_schedule_node_to_str.argtypes = c_void_p
+
+class space(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_space_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ptr = isl.isl_space_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.space("""%s""")' % s
+        else:
+            return 'isl.space("%s")' % s
+    def add_named_tuple(*args):
+        if len(args) == 3 and (args1.__class__ is id or type(args1) == str) and type(args2) == int:
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_space_add_named_tuple_id_ui(isl.isl_space_copy(args0.ptr), isl.isl_id_copy(args1.ptr), args2)
+            obj = space(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def add_unnamed_tuple(*args):
+        if len(args) == 2 and type(args1) == int:
+            ctx = args0.ctx
+            res = isl.isl_space_add_unnamed_tuple_ui(isl.isl_space_copy(args0.ptr), args1)
+            obj = space(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def curry(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_curry(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_domain(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def domain_map_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_domain_map_multi_aff(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain_map_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_domain_map_pw_multi_aff(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def domain_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_get_domain_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_domain_tuple_id(arg0):
+        return arg0.domain_tuple_id()
+    def flatten_domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_flatten_domain(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def flatten_range(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_flatten_range(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def has_domain_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_has_domain_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def has_range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_has_range_tuple_id(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def identity_multi_aff_on_domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_identity_multi_aff_on_domain(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def identity_multi_pw_aff_on_domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_identity_multi_pw_aff_on_domain(isl.isl_space_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def identity_pw_multi_aff_on_domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_identity_pw_multi_aff_on_domain(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def is_equal(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_is_equal(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_wrapping(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_is_wrapping(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def map_from_set(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_map_from_set(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def multi_aff(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is aff_list:
+                arg1 = aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_multi_aff(isl.isl_space_copy(arg0.ptr), isl.isl_aff_list_copy(arg1.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def multi_aff_on_domain(*args):
+        if len(args) == 2 and args1.__class__ is multi_val:
+            ctx = args0.ctx
+            res = isl.isl_space_multi_aff_on_domain_multi_val(isl.isl_space_copy(args0.ptr), isl.isl_multi_val_copy(args1.ptr))
+            obj = multi_aff(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def multi_id(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is id_list:
+                arg1 = id_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_multi_id(isl.isl_space_copy(arg0.ptr), isl.isl_id_list_copy(arg1.ptr))
+        obj = multi_id(ctx=ctx, ptr=res)
+        return obj
+    def multi_pw_aff(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is pw_aff_list:
+                arg1 = pw_aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_multi_pw_aff(isl.isl_space_copy(arg0.ptr), isl.isl_pw_aff_list_copy(arg1.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def multi_union_pw_aff(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff_list:
+                arg1 = union_pw_aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_multi_union_pw_aff(isl.isl_space_copy(arg0.ptr), isl.isl_union_pw_aff_list_copy(arg1.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def multi_val(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val_list:
+                arg1 = val_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_multi_val(isl.isl_space_copy(arg0.ptr), isl.isl_val_list_copy(arg1.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+    def params(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_params(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def product(arg0, arg1):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is space:
+                arg1 = space(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_product(isl.isl_space_copy(arg0.ptr), isl.isl_space_copy(arg1.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def range(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_range(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def range_map_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_range_map_multi_aff(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_map_pw_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_range_map_pw_multi_aff(isl.isl_space_copy(arg0.ptr))
+        obj = pw_multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def range_reverse(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_range_reverse(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def range_tuple_id(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_get_range_tuple_id(arg0.ptr)
+        obj = id(ctx=ctx, ptr=res)
+        return obj
+    def get_range_tuple_id(arg0):
+        return arg0.range_tuple_id()
+    def reverse(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_reverse(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def set_domain_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_space_set_domain_tuple_id(isl.isl_space_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = space(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def set_range_tuple(*args):
+        if len(args) == 2 and (args1.__class__ is id or type(args1) == str):
+            args = list(args)
+            try:
+                if not args1.__class__ is id:
+                    args1 = id(args1)
+            except:
+                raise
+            ctx = args0.ctx
+            res = isl.isl_space_set_range_tuple_id(isl.isl_space_copy(args0.ptr), isl.isl_id_copy(args1.ptr))
+            obj = space(ctx=ctx, ptr=res)
+            return obj
+        raise Error
+    def uncurry(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_uncurry(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def unit():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_space_unit(ctx)
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def universe_map(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_universe_map(isl.isl_space_copy(arg0.ptr))
+        obj = map(ctx=ctx, ptr=res)
+        return obj
+    def universe_set(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_universe_set(isl.isl_space_copy(arg0.ptr))
+        obj = set(ctx=ctx, ptr=res)
+        return obj
+    def unwrap(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_unwrap(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def wrap(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_wrap(isl.isl_space_copy(arg0.ptr))
+        obj = space(ctx=ctx, ptr=res)
+        return obj
+    def zero_aff_on_domain(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_zero_aff_on_domain(isl.isl_space_copy(arg0.ptr))
+        obj = aff(ctx=ctx, ptr=res)
+        return obj
+    def zero_multi_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_zero_multi_aff(isl.isl_space_copy(arg0.ptr))
+        obj = multi_aff(ctx=ctx, ptr=res)
+        return obj
+    def zero_multi_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_zero_multi_pw_aff(isl.isl_space_copy(arg0.ptr))
+        obj = multi_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def zero_multi_union_pw_aff(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_zero_multi_union_pw_aff(isl.isl_space_copy(arg0.ptr))
+        obj = multi_union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def zero_multi_val(arg0):
+        try:
+            if not arg0.__class__ is space:
+                arg0 = space(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_space_zero_multi_val(isl.isl_space_copy(arg0.ptr))
+        obj = multi_val(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_space_add_named_tuple_id_ui.restype = c_void_p
+isl.isl_space_add_named_tuple_id_ui.argtypes = c_void_p, c_void_p, c_int
+isl.isl_space_add_unnamed_tuple_ui.restype = c_void_p
+isl.isl_space_add_unnamed_tuple_ui.argtypes = c_void_p, c_int
+isl.isl_space_curry.restype = c_void_p
+isl.isl_space_curry.argtypes = c_void_p
+isl.isl_space_domain.restype = c_void_p
+isl.isl_space_domain.argtypes = c_void_p
+isl.isl_space_domain_map_multi_aff.restype = c_void_p
+isl.isl_space_domain_map_multi_aff.argtypes = c_void_p
+isl.isl_space_domain_map_pw_multi_aff.restype = c_void_p
+isl.isl_space_domain_map_pw_multi_aff.argtypes = c_void_p
+isl.isl_space_get_domain_tuple_id.restype = c_void_p
+isl.isl_space_get_domain_tuple_id.argtypes = c_void_p
+isl.isl_space_flatten_domain.restype = c_void_p
+isl.isl_space_flatten_domain.argtypes = c_void_p
+isl.isl_space_flatten_range.restype = c_void_p
+isl.isl_space_flatten_range.argtypes = c_void_p
+isl.isl_space_has_domain_tuple_id.argtypes = c_void_p
+isl.isl_space_has_range_tuple_id.argtypes = c_void_p
+isl.isl_space_identity_multi_aff_on_domain.restype = c_void_p
+isl.isl_space_identity_multi_aff_on_domain.argtypes = c_void_p
+isl.isl_space_identity_multi_pw_aff_on_domain.restype = c_void_p
+isl.isl_space_identity_multi_pw_aff_on_domain.argtypes = c_void_p
+isl.isl_space_identity_pw_multi_aff_on_domain.restype = c_void_p
+isl.isl_space_identity_pw_multi_aff_on_domain.argtypes = c_void_p
+isl.isl_space_is_equal.argtypes = c_void_p, c_void_p
+isl.isl_space_is_wrapping.argtypes = c_void_p
+isl.isl_space_map_from_set.restype = c_void_p
+isl.isl_space_map_from_set.argtypes = c_void_p
+isl.isl_space_multi_aff.restype = c_void_p
+isl.isl_space_multi_aff.argtypes = c_void_p, c_void_p
+isl.isl_space_multi_aff_on_domain_multi_val.restype = c_void_p
+isl.isl_space_multi_aff_on_domain_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_space_multi_id.restype = c_void_p
+isl.isl_space_multi_id.argtypes = c_void_p, c_void_p
+isl.isl_space_multi_pw_aff.restype = c_void_p
+isl.isl_space_multi_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_space_multi_union_pw_aff.restype = c_void_p
+isl.isl_space_multi_union_pw_aff.argtypes = c_void_p, c_void_p
+isl.isl_space_multi_val.restype = c_void_p
+isl.isl_space_multi_val.argtypes = c_void_p, c_void_p
+isl.isl_space_params.restype = c_void_p
+isl.isl_space_params.argtypes = c_void_p
+isl.isl_space_product.restype = c_void_p
+isl.isl_space_product.argtypes = c_void_p, c_void_p
+isl.isl_space_range.restype = c_void_p
+isl.isl_space_range.argtypes = c_void_p
+isl.isl_space_range_map_multi_aff.restype = c_void_p
+isl.isl_space_range_map_multi_aff.argtypes = c_void_p
+isl.isl_space_range_map_pw_multi_aff.restype = c_void_p
+isl.isl_space_range_map_pw_multi_aff.argtypes = c_void_p
+isl.isl_space_range_reverse.restype = c_void_p
+isl.isl_space_range_reverse.argtypes = c_void_p
+isl.isl_space_get_range_tuple_id.restype = c_void_p
+isl.isl_space_get_range_tuple_id.argtypes = c_void_p
+isl.isl_space_reverse.restype = c_void_p
+isl.isl_space_reverse.argtypes = c_void_p
+isl.isl_space_set_domain_tuple_id.restype = c_void_p
+isl.isl_space_set_domain_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_space_set_range_tuple_id.restype = c_void_p
+isl.isl_space_set_range_tuple_id.argtypes = c_void_p, c_void_p
+isl.isl_space_uncurry.restype = c_void_p
+isl.isl_space_uncurry.argtypes = c_void_p
+isl.isl_space_unit.restype = c_void_p
+isl.isl_space_unit.argtypes = Context
+isl.isl_space_universe_map.restype = c_void_p
+isl.isl_space_universe_map.argtypes = c_void_p
+isl.isl_space_universe_set.restype = c_void_p
+isl.isl_space_universe_set.argtypes = c_void_p
+isl.isl_space_unwrap.restype = c_void_p
+isl.isl_space_unwrap.argtypes = c_void_p
+isl.isl_space_wrap.restype = c_void_p
+isl.isl_space_wrap.argtypes = c_void_p
+isl.isl_space_zero_aff_on_domain.restype = c_void_p
+isl.isl_space_zero_aff_on_domain.argtypes = c_void_p
+isl.isl_space_zero_multi_aff.restype = c_void_p
+isl.isl_space_zero_multi_aff.argtypes = c_void_p
+isl.isl_space_zero_multi_pw_aff.restype = c_void_p
+isl.isl_space_zero_multi_pw_aff.argtypes = c_void_p
+isl.isl_space_zero_multi_union_pw_aff.restype = c_void_p
+isl.isl_space_zero_multi_union_pw_aff.argtypes = c_void_p
+isl.isl_space_zero_multi_val.restype = c_void_p
+isl.isl_space_zero_multi_val.argtypes = c_void_p
+isl.isl_space_copy.restype = c_void_p
+isl.isl_space_copy.argtypes = c_void_p
+isl.isl_space_free.restype = c_void_p
+isl.isl_space_free.argtypes = c_void_p
+isl.isl_space_to_str.restype = POINTER(c_char)
+isl.isl_space_to_str.argtypes = c_void_p
+
+class union_access_info(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and args0.__class__ is union_map:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_access_info_from_sink(isl.isl_union_map_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_access_info_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_access_info_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_access_info("""%s""")' % s
+        else:
+            return 'isl.union_access_info("%s")' % s
+    def compute_flow(arg0):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_compute_flow(isl.isl_union_access_info_copy(arg0.ptr))
+        obj = union_flow(ctx=ctx, ptr=res)
+        return obj
+    def set_kill(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_set_kill(isl.isl_union_access_info_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_access_info(ctx=ctx, ptr=res)
+        return obj
+    def set_may_source(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_set_may_source(isl.isl_union_access_info_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_access_info(ctx=ctx, ptr=res)
+        return obj
+    def set_must_source(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_set_must_source(isl.isl_union_access_info_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_access_info(ctx=ctx, ptr=res)
+        return obj
+    def set_schedule(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is schedule:
+                arg1 = schedule(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_set_schedule(isl.isl_union_access_info_copy(arg0.ptr), isl.isl_schedule_copy(arg1.ptr))
+        obj = union_access_info(ctx=ctx, ptr=res)
+        return obj
+    def set_schedule_map(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_access_info:
+                arg0 = union_access_info(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_map:
+                arg1 = union_map(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_access_info_set_schedule_map(isl.isl_union_access_info_copy(arg0.ptr), isl.isl_union_map_copy(arg1.ptr))
+        obj = union_access_info(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_union_access_info_from_sink.restype = c_void_p
+isl.isl_union_access_info_from_sink.argtypes = c_void_p
+isl.isl_union_access_info_compute_flow.restype = c_void_p
+isl.isl_union_access_info_compute_flow.argtypes = c_void_p
+isl.isl_union_access_info_set_kill.restype = c_void_p
+isl.isl_union_access_info_set_kill.argtypes = c_void_p, c_void_p
+isl.isl_union_access_info_set_may_source.restype = c_void_p
+isl.isl_union_access_info_set_may_source.argtypes = c_void_p, c_void_p
+isl.isl_union_access_info_set_must_source.restype = c_void_p
+isl.isl_union_access_info_set_must_source.argtypes = c_void_p, c_void_p
+isl.isl_union_access_info_set_schedule.restype = c_void_p
+isl.isl_union_access_info_set_schedule.argtypes = c_void_p, c_void_p
+isl.isl_union_access_info_set_schedule_map.restype = c_void_p
+isl.isl_union_access_info_set_schedule_map.argtypes = c_void_p, c_void_p
+isl.isl_union_access_info_copy.restype = c_void_p
+isl.isl_union_access_info_copy.argtypes = c_void_p
+isl.isl_union_access_info_free.restype = c_void_p
+isl.isl_union_access_info_free.argtypes = c_void_p
+isl.isl_union_access_info_to_str.restype = POINTER(c_char)
+isl.isl_union_access_info_to_str.argtypes = c_void_p
+
+class union_flow(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_flow_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_flow_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_flow("""%s""")' % s
+        else:
+            return 'isl.union_flow("%s")' % s
+    def full_may_dependence(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_full_may_dependence(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_full_may_dependence(arg0):
+        return arg0.full_may_dependence()
+    def full_must_dependence(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_full_must_dependence(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_full_must_dependence(arg0):
+        return arg0.full_must_dependence()
+    def may_dependence(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_may_dependence(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_may_dependence(arg0):
+        return arg0.may_dependence()
+    def may_no_source(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_may_no_source(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_may_no_source(arg0):
+        return arg0.may_no_source()
+    def must_dependence(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_must_dependence(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_must_dependence(arg0):
+        return arg0.must_dependence()
+    def must_no_source(arg0):
+        try:
+            if not arg0.__class__ is union_flow:
+                arg0 = union_flow(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_flow_get_must_no_source(arg0.ptr)
+        obj = union_map(ctx=ctx, ptr=res)
+        return obj
+    def get_must_no_source(arg0):
+        return arg0.must_no_source()
+
+isl.isl_union_flow_get_full_may_dependence.restype = c_void_p
+isl.isl_union_flow_get_full_may_dependence.argtypes = c_void_p
+isl.isl_union_flow_get_full_must_dependence.restype = c_void_p
+isl.isl_union_flow_get_full_must_dependence.argtypes = c_void_p
+isl.isl_union_flow_get_may_dependence.restype = c_void_p
+isl.isl_union_flow_get_may_dependence.argtypes = c_void_p
+isl.isl_union_flow_get_may_no_source.restype = c_void_p
+isl.isl_union_flow_get_may_no_source.argtypes = c_void_p
+isl.isl_union_flow_get_must_dependence.restype = c_void_p
+isl.isl_union_flow_get_must_dependence.argtypes = c_void_p
+isl.isl_union_flow_get_must_no_source.restype = c_void_p
+isl.isl_union_flow_get_must_no_source.argtypes = c_void_p
+isl.isl_union_flow_copy.restype = c_void_p
+isl.isl_union_flow_copy.argtypes = c_void_p
+isl.isl_union_flow_free.restype = c_void_p
+isl.isl_union_flow_free.argtypes = c_void_p
+isl.isl_union_flow_to_str.restype = POINTER(c_char)
+isl.isl_union_flow_to_str.argtypes = c_void_p
+
+class union_pw_aff_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_aff_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is union_pw_aff:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_pw_aff_list_from_union_pw_aff(isl.isl_union_pw_aff_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_pw_aff_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_pw_aff_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_pw_aff_list("""%s""")' % s
+        else:
+            return 'isl.union_pw_aff_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff:
+                arg1 = union_pw_aff(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_add(isl.isl_union_pw_aff_list_copy(arg0.ptr), isl.isl_union_pw_aff_copy(arg1.ptr))
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_get_at(arg0.ptr, arg1)
+        obj = union_pw_aff(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_clear(isl.isl_union_pw_aff_list_copy(arg0.ptr))
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_pw_aff_list:
+                arg1 = union_pw_aff_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_concat(isl.isl_union_pw_aff_list_copy(arg0.ptr), isl.isl_union_pw_aff_list_copy(arg1.ptr))
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_drop(isl.isl_union_pw_aff_list_copy(arg0.ptr), arg1, arg2)
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = union_pw_aff(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is union_pw_aff:
+                arg2 = union_pw_aff(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_insert(isl.isl_union_pw_aff_list_copy(arg0.ptr), arg1, isl.isl_union_pw_aff_copy(arg2.ptr))
+        obj = union_pw_aff_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is union_pw_aff_list:
+                arg0 = union_pw_aff_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_pw_aff_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_union_pw_aff_list_alloc.restype = c_void_p
+isl.isl_union_pw_aff_list_alloc.argtypes = Context, c_int
+isl.isl_union_pw_aff_list_from_union_pw_aff.restype = c_void_p
+isl.isl_union_pw_aff_list_from_union_pw_aff.argtypes = c_void_p
+isl.isl_union_pw_aff_list_add.restype = c_void_p
+isl.isl_union_pw_aff_list_add.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_list_get_at.restype = c_void_p
+isl.isl_union_pw_aff_list_get_at.argtypes = c_void_p, c_int
+isl.isl_union_pw_aff_list_clear.restype = c_void_p
+isl.isl_union_pw_aff_list_clear.argtypes = c_void_p
+isl.isl_union_pw_aff_list_concat.restype = c_void_p
+isl.isl_union_pw_aff_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_union_pw_aff_list_drop.restype = c_void_p
+isl.isl_union_pw_aff_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_union_pw_aff_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_pw_aff_list_insert.restype = c_void_p
+isl.isl_union_pw_aff_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_union_pw_aff_list_size.argtypes = c_void_p
+isl.isl_union_pw_aff_list_copy.restype = c_void_p
+isl.isl_union_pw_aff_list_copy.argtypes = c_void_p
+isl.isl_union_pw_aff_list_free.restype = c_void_p
+isl.isl_union_pw_aff_list_free.argtypes = c_void_p
+isl.isl_union_pw_aff_list_to_str.restype = POINTER(c_char)
+isl.isl_union_pw_aff_list_to_str.argtypes = c_void_p
+
+class union_set_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_set_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and args0.__class__ is union_set:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_union_set_list_from_union_set(isl.isl_union_set_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_union_set_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_union_set_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.union_set_list("""%s""")' % s
+        else:
+            return 'isl.union_set_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set:
+                arg1 = union_set(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_add(isl.isl_union_set_list_copy(arg0.ptr), isl.isl_union_set_copy(arg1.ptr))
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_get_at(arg0.ptr, arg1)
+        obj = union_set(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_clear(isl.isl_union_set_list_copy(arg0.ptr))
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is union_set_list:
+                arg1 = union_set_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_concat(isl.isl_union_set_list_copy(arg0.ptr), isl.isl_union_set_list_copy(arg1.ptr))
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_drop(isl.isl_union_set_list_copy(arg0.ptr), arg1, arg2)
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = union_set(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is union_set:
+                arg2 = union_set(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_insert(isl.isl_union_set_list_copy(arg0.ptr), arg1, isl.isl_union_set_copy(arg2.ptr))
+        obj = union_set_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is union_set_list:
+                arg0 = union_set_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_union_set_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
+
+isl.isl_union_set_list_alloc.restype = c_void_p
+isl.isl_union_set_list_alloc.argtypes = Context, c_int
+isl.isl_union_set_list_from_union_set.restype = c_void_p
+isl.isl_union_set_list_from_union_set.argtypes = c_void_p
+isl.isl_union_set_list_add.restype = c_void_p
+isl.isl_union_set_list_add.argtypes = c_void_p, c_void_p
+isl.isl_union_set_list_get_at.restype = c_void_p
+isl.isl_union_set_list_get_at.argtypes = c_void_p, c_int
+isl.isl_union_set_list_clear.restype = c_void_p
+isl.isl_union_set_list_clear.argtypes = c_void_p
+isl.isl_union_set_list_concat.restype = c_void_p
+isl.isl_union_set_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_union_set_list_drop.restype = c_void_p
+isl.isl_union_set_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_union_set_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_union_set_list_insert.restype = c_void_p
+isl.isl_union_set_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_union_set_list_size.argtypes = c_void_p
+isl.isl_union_set_list_copy.restype = c_void_p
+isl.isl_union_set_list_copy.argtypes = c_void_p
+isl.isl_union_set_list_free.restype = c_void_p
+isl.isl_union_set_list_free.argtypes = c_void_p
+isl.isl_union_set_list_to_str.restype = POINTER(c_char)
+isl.isl_union_set_list_to_str.argtypes = c_void_p
+
+class val(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_val_int_from_si(self.ctx, args0)
+            return
+        if len(args) == 1 and type(args0) == str:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_val_read_from_str(self.ctx, args0.encode('ascii'))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_val_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ptr = isl.isl_val_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.val("""%s""")' % s
+        else:
+            return 'isl.val("%s")' % s
+    def abs(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_abs(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def abs_eq(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_abs_eq(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_add(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def ceil(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_ceil(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def cmp_si(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_cmp_si(arg0.ptr, arg1)
+        return res
+    def den_si(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_get_den_si(arg0.ptr)
+        return res
+    def get_den_si(arg0):
+        return arg0.den_si()
+    def div(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_div(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def eq(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_eq(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def floor(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_floor(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def gcd(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_gcd(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def ge(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_ge(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def gt(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_gt(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    @staticmethod
+    def infty():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_infty(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def inv(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_inv(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def is_divisible_by(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_divisible_by(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_infty(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_infty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_int(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_int(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_nan(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_nan(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_neg(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_neg(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_neginfty(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_neginfty(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_negone(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_negone(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_nonneg(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_nonneg(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_nonpos(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_nonpos(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_one(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_one(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_pos(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_pos(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_rat(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_rat(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def is_zero(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_is_zero(arg0.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def le(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_le(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def lt(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_lt(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def max(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_max(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def min(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_min(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def mod(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_mod(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def mul(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_mul(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def nan():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_nan(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def ne(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_ne(arg0.ptr, arg1.ptr)
+        if res < 0:
+            raise
+        return bool(res)
+    def neg(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_neg(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def neginfty():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_neginfty(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def negone():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_negone(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def num_si(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_get_num_si(arg0.ptr)
+        return res
+    def get_num_si(arg0):
+        return arg0.num_si()
+    @staticmethod
+    def one():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_one(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def pow2(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_pow2(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def sgn(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_sgn(arg0.ptr)
+        return res
+    def sub(arg0, arg1):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_sub(isl.isl_val_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def to_list(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_to_list(isl.isl_val_copy(arg0.ptr))
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def trunc(arg0):
+        try:
+            if not arg0.__class__ is val:
+                arg0 = val(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_trunc(isl.isl_val_copy(arg0.ptr))
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    @staticmethod
+    def zero():
+        ctx = Context.getDefaultInstance()
+        res = isl.isl_val_zero(ctx)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+
+isl.isl_val_int_from_si.restype = c_void_p
+isl.isl_val_int_from_si.argtypes = Context, c_long
+isl.isl_val_read_from_str.restype = c_void_p
+isl.isl_val_read_from_str.argtypes = Context, c_char_p
+isl.isl_val_abs.restype = c_void_p
+isl.isl_val_abs.argtypes = c_void_p
+isl.isl_val_abs_eq.argtypes = c_void_p, c_void_p
+isl.isl_val_add.restype = c_void_p
+isl.isl_val_add.argtypes = c_void_p, c_void_p
+isl.isl_val_ceil.restype = c_void_p
+isl.isl_val_ceil.argtypes = c_void_p
+isl.isl_val_cmp_si.argtypes = c_void_p, c_long
+isl.isl_val_get_den_si.argtypes = c_void_p
+isl.isl_val_div.restype = c_void_p
+isl.isl_val_div.argtypes = c_void_p, c_void_p
+isl.isl_val_eq.argtypes = c_void_p, c_void_p
+isl.isl_val_floor.restype = c_void_p
+isl.isl_val_floor.argtypes = c_void_p
+isl.isl_val_gcd.restype = c_void_p
+isl.isl_val_gcd.argtypes = c_void_p, c_void_p
+isl.isl_val_ge.argtypes = c_void_p, c_void_p
+isl.isl_val_gt.argtypes = c_void_p, c_void_p
+isl.isl_val_infty.restype = c_void_p
+isl.isl_val_infty.argtypes = Context
+isl.isl_val_inv.restype = c_void_p
+isl.isl_val_inv.argtypes = c_void_p
+isl.isl_val_is_divisible_by.argtypes = c_void_p, c_void_p
+isl.isl_val_is_infty.argtypes = c_void_p
+isl.isl_val_is_int.argtypes = c_void_p
+isl.isl_val_is_nan.argtypes = c_void_p
+isl.isl_val_is_neg.argtypes = c_void_p
+isl.isl_val_is_neginfty.argtypes = c_void_p
+isl.isl_val_is_negone.argtypes = c_void_p
+isl.isl_val_is_nonneg.argtypes = c_void_p
+isl.isl_val_is_nonpos.argtypes = c_void_p
+isl.isl_val_is_one.argtypes = c_void_p
+isl.isl_val_is_pos.argtypes = c_void_p
+isl.isl_val_is_rat.argtypes = c_void_p
+isl.isl_val_is_zero.argtypes = c_void_p
+isl.isl_val_le.argtypes = c_void_p, c_void_p
+isl.isl_val_lt.argtypes = c_void_p, c_void_p
+isl.isl_val_max.restype = c_void_p
+isl.isl_val_max.argtypes = c_void_p, c_void_p
+isl.isl_val_min.restype = c_void_p
+isl.isl_val_min.argtypes = c_void_p, c_void_p
+isl.isl_val_mod.restype = c_void_p
+isl.isl_val_mod.argtypes = c_void_p, c_void_p
+isl.isl_val_mul.restype = c_void_p
+isl.isl_val_mul.argtypes = c_void_p, c_void_p
+isl.isl_val_nan.restype = c_void_p
+isl.isl_val_nan.argtypes = Context
+isl.isl_val_ne.argtypes = c_void_p, c_void_p
+isl.isl_val_neg.restype = c_void_p
+isl.isl_val_neg.argtypes = c_void_p
+isl.isl_val_neginfty.restype = c_void_p
+isl.isl_val_neginfty.argtypes = Context
+isl.isl_val_negone.restype = c_void_p
+isl.isl_val_negone.argtypes = Context
+isl.isl_val_get_num_si.argtypes = c_void_p
+isl.isl_val_one.restype = c_void_p
+isl.isl_val_one.argtypes = Context
+isl.isl_val_pow2.restype = c_void_p
+isl.isl_val_pow2.argtypes = c_void_p
+isl.isl_val_sgn.argtypes = c_void_p
+isl.isl_val_sub.restype = c_void_p
+isl.isl_val_sub.argtypes = c_void_p, c_void_p
+isl.isl_val_to_list.restype = c_void_p
+isl.isl_val_to_list.argtypes = c_void_p
+isl.isl_val_trunc.restype = c_void_p
+isl.isl_val_trunc.argtypes = c_void_p
+isl.isl_val_zero.restype = c_void_p
+isl.isl_val_zero.argtypes = Context
+isl.isl_val_copy.restype = c_void_p
+isl.isl_val_copy.argtypes = c_void_p
+isl.isl_val_free.restype = c_void_p
+isl.isl_val_free.argtypes = c_void_p
+isl.isl_val_to_str.restype = POINTER(c_char)
+isl.isl_val_to_str.argtypes = c_void_p
+
+class val_list(object):
+    def __init__(self, *args, **keywords):
+        if "ptr" in keywords:
+            self.ctx = keywords"ctx"
+            self.ptr = keywords"ptr"
+            return
+        if len(args) == 1 and type(args0) == int:
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_val_list_alloc(self.ctx, args0)
+            return
+        if len(args) == 1 and (args0.__class__ is val or type(args0) == int):
+            args = list(args)
+            try:
+                if not args0.__class__ is val:
+                    args0 = val(args0)
+            except:
+                raise
+            self.ctx = Context.getDefaultInstance()
+            self.ptr = isl.isl_val_list_from_val(isl.isl_val_copy(args0.ptr))
+            return
+        raise Error
+    def __del__(self):
+        if hasattr(self, 'ptr'):
+            isl.isl_val_list_free(self.ptr)
+    def __str__(arg0):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        ptr = isl.isl_val_list_to_str(arg0.ptr)
+        res = cast(ptr, c_char_p).value.decode('ascii')
+        libc.free(ptr)
+        return res
+    def __repr__(self):
+        s = str(self)
+        if '"' in s:
+            return 'isl.val_list("""%s""")' % s
+        else:
+            return 'isl.val_list("%s")' % s
+    def add(arg0, arg1):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val:
+                arg1 = val(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_add(isl.isl_val_list_copy(arg0.ptr), isl.isl_val_copy(arg1.ptr))
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def at(arg0, arg1):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_get_at(arg0.ptr, arg1)
+        obj = val(ctx=ctx, ptr=res)
+        return obj
+    def get_at(arg0, arg1):
+        return arg0.at(arg1)
+    def clear(arg0):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_clear(isl.isl_val_list_copy(arg0.ptr))
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def concat(arg0, arg1):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        try:
+            if not arg1.__class__ is val_list:
+                arg1 = val_list(arg1)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_concat(isl.isl_val_list_copy(arg0.ptr), isl.isl_val_list_copy(arg1.ptr))
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def drop(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_drop(isl.isl_val_list_copy(arg0.ptr), arg1, arg2)
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def foreach(arg0, arg1):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        exc_info = None
+        fn = CFUNCTYPE(c_int, c_void_p, c_void_p)
+        def cb_func(cb_arg0, cb_arg1):
+            cb_arg0 = val(ctx=arg0.ctx, ptr=(cb_arg0))
+            try:
+                arg1(cb_arg0)
+            except BaseException as e:
+                exc_info0 = e
+                return -1
+            return 0
+        cb = fn(cb_func)
+        ctx = arg0.ctx
+        res = isl.isl_val_list_foreach(arg0.ptr, cb, None)
+        if exc_info0 is not None:
+            raise exc_info0
+        if res < 0:
+            raise
+    def insert(arg0, arg1, arg2):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        try:
+            if not arg2.__class__ is val:
+                arg2 = val(arg2)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_insert(isl.isl_val_list_copy(arg0.ptr), arg1, isl.isl_val_copy(arg2.ptr))
+        obj = val_list(ctx=ctx, ptr=res)
+        return obj
+    def size(arg0):
+        try:
+            if not arg0.__class__ is val_list:
+                arg0 = val_list(arg0)
+        except:
+            raise
+        ctx = arg0.ctx
+        res = isl.isl_val_list_size(arg0.ptr)
+        if res < 0:
+            raise
+        return int(res)
 
-isl.isl_union_pw_qpolynomial_free.argtypes = c_void_p
-isl.isl_union_pw_qpolynomial_to_str.argtypes = c_void_p
-isl.isl_union_pw_qpolynomial_to_str.restype = POINTER(c_char)
+isl.isl_val_list_alloc.restype = c_void_p
+isl.isl_val_list_alloc.argtypes = Context, c_int
+isl.isl_val_list_from_val.restype = c_void_p
+isl.isl_val_list_from_val.argtypes = c_void_p
+isl.isl_val_list_add.restype = c_void_p
+isl.isl_val_list_add.argtypes = c_void_p, c_void_p
+isl.isl_val_list_get_at.restype = c_void_p
+isl.isl_val_list_get_at.argtypes = c_void_p, c_int
+isl.isl_val_list_clear.restype = c_void_p
+isl.isl_val_list_clear.argtypes = c_void_p
+isl.isl_val_list_concat.restype = c_void_p
+isl.isl_val_list_concat.argtypes = c_void_p, c_void_p
+isl.isl_val_list_drop.restype = c_void_p
+isl.isl_val_list_drop.argtypes = c_void_p, c_int, c_int
+isl.isl_val_list_foreach.argtypes = c_void_p, c_void_p, c_void_p
+isl.isl_val_list_insert.restype = c_void_p
+isl.isl_val_list_insert.argtypes = c_void_p, c_int, c_void_p
+isl.isl_val_list_size.argtypes = c_void_p
+isl.isl_val_list_copy.restype = c_void_p
+isl.isl_val_list_copy.argtypes = c_void_p
+isl.isl_val_list_free.restype = c_void_p
+isl.isl_val_list_free.argtypes = c_void_p
+isl.isl_val_list_to_str.restype = POINTER(c_char)
+isl.isl_val_list_to_str.argtypes = c_void_p

_service:tar_scm:isl-0.24.tar.gz/interface/isl_config.h.in Added

@@ -0,0 +1,154 @@
+/* isl_config.h.in.  Generated from configure.ac by autoheader.  */
+
+/* Define if HeaderSearchOptions::AddPath takes 4 arguments */
+#undef ADDPATH_TAKES_4_ARGUMENTS
+
+/* Clang installation prefix */
+#undef CLANG_PREFIX
+
+/* Define to sysroot if needed */
+#undef CLANG_SYSROOT
+
+/* Define if CompilerInstance::createDiagnostics takes argc and argv */
+#undef CREATEDIAGNOSTICS_TAKES_ARG
+
+/* Define if CompilerInstance::createPreprocessor takes TranslationUnitKind */
+#undef CREATEPREPROCESSOR_TAKES_TUKIND
+
+/* Define if TargetInfo::CreateTargetInfo takes pointer */
+#undef CREATETARGETINFO_TAKES_POINTER
+
+/* Define if TargetInfo::CreateTargetInfo takes shared_ptr */
+#undef CREATETARGETINFO_TAKES_SHARED_PTR
+
+/* Define if CompilerInvocation::CreateFromArgs takes ArrayRef */
+#undef CREATE_FROM_ARGS_TAKES_ARRAYREF
+
+/* Define if Driver constructor takes default image name */
+#undef DRIVER_CTOR_TAKES_DEFAULTIMAGENAME
+
+/* Define to Diagnostic for older versions of clang */
+#undef DiagnosticsEngine
+
+/* Define if llvm/ADT/OwningPtr.h exists */
+#undef HAVE_ADT_OWNINGPTR_H
+
+/* Define if clang/Basic/DiagnosticOptions.h exists */
+#undef HAVE_BASIC_DIAGNOSTICOPTIONS_H
+
+/* define if the compiler supports basic C++11 syntax */
+#undef HAVE_CXX11
+
+/* Define if Driver constructor takes CXXIsProduction argument */
+#undef HAVE_CXXISPRODUCTION
+
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
+/* Define to 1 if you have the <inttypes.h> header file. */
+#undef HAVE_INTTYPES_H
+
+/* Define if Driver constructor takes IsProduction argument */
+#undef HAVE_ISPRODUCTION
+
+/* Define if clang/Lex/PreprocessorOptions.h exists */
+#undef HAVE_LEX_PREPROCESSOROPTIONS_H
+
+/* Define if llvm/Option/Arg.h exists */
+#undef HAVE_LLVM_OPTION_ARG_H
+
+/* Define to 1 if you have the <memory.h> header file. */
+#undef HAVE_MEMORY_H
+
+/* Define if SourceManager has a setMainFileID method */
+#undef HAVE_SETMAINFILEID
+
+/* Define to 1 if you have the <stdint.h> header file. */
+#undef HAVE_STDINT_H
+
+/* Define to 1 if you have the <stdlib.h> header file. */
+#undef HAVE_STDLIB_H
+
+/* Define to 1 if you have the <strings.h> header file. */
+#undef HAVE_STRINGS_H
+
+/* Define to 1 if you have the <string.h> header file. */
+#undef HAVE_STRING_H
+
+/* Define to 1 if you have the <sys/stat.h> header file. */
+#undef HAVE_SYS_STAT_H
+
+/* Define to 1 if you have the <sys/types.h> header file. */
+#undef HAVE_SYS_TYPES_H
+
+/* Define to 1 if you have the <unistd.h> header file. */
+#undef HAVE_UNISTD_H
+
+/* Return type of HandleTopLevelDeclReturn */
+#undef HandleTopLevelDeclContinue
+
+/* Return type of HandleTopLevelDeclReturn */
+#undef HandleTopLevelDeclReturn
+
+/* Define to Language::C or InputKind::C for newer versions of clang */
+#undef IK_C
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#undef LT_OBJDIR
+
+/* Name of package */
+#undef PACKAGE
+
+/* Define to the address where bug reports for this package should be sent. */
+#undef PACKAGE_BUGREPORT
+
+/* Define to the full name of this package. */
+#undef PACKAGE_NAME
+
+/* Define to the full name and version of this package. */
+#undef PACKAGE_STRING
+
+/* Define to the one symbol short name of this package. */
+#undef PACKAGE_TARNAME
+
+/* Define to the home page for this package. */
+#undef PACKAGE_URL
+
+/* Define to the version of this package. */
+#undef PACKAGE_VERSION
+
+/* Defined if CompilerInstance::setInvocation takes a shared_ptr */
+#undef SETINVOCATION_TAKES_SHARED_PTR
+
+/* Define if CompilerInvocation::setLangDefaults takes 5 arguments */
+#undef SETLANGDEFAULTS_TAKES_5_ARGUMENTS
+
+/* Define to 1 if you have the ANSI C header files. */
+#undef STDC_HEADERS
+
+/* Define if Driver::BuildCompilation takes ArrayRef */
+#undef USE_ARRAYREF
+
+/* Version number of package */
+#undef VERSION
+
+/* Define to getParamType for newer versions of clang */
+#undef getArgType
+
+/* Define to getHostTriple for older versions of clang */
+#undef getDefaultTargetTriple
+
+/* Define to getInstantiationLineNumber for older versions of clang */
+#undef getExpansionLineNumber
+
+/* Define to getImmediateInstantiationRange for older versions of clang */
+#undef getImmediateExpansionRange
+
+/* Define to getNumParams for newer versions of clang */
+#undef getNumArgs
+
+/* Define to getResultType for older versions of clang */
+#undef getReturnType
+
+/* Define to InitializeBuiltins for older versions of clang */
+#undef initializeBuiltins

_service:tar_scm:isl-0.24.tar.gz/interface/ltmain.sh Added

@@ -0,0 +1,11251 @@
+#! /bin/sh
+## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
+##               by inline-source v2014-01-03.01
+
+# libtool (GNU libtool) 2.4.6
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
+
+# Copyright (C) 1996-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# As a special exception to the GNU General Public License,
+# if you distribute this file as part of a program or library that
+# is built using GNU Libtool, you may include this file under the
+# same distribution terms that you use for the rest of that program.
+#
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+# General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+PROGRAM=libtool
+PACKAGE=libtool
+VERSION="2.4.6 Debian-2.4.6-14"
+package_revision=2.4.6
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Run './libtool --help' for help with using this script from the
+# command line.
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# After configure completes, it has a better idea of some of the
+# shell tools we need than the defaults used by the functions shared
+# with bootstrap, so set those here where they can still be over-
+# ridden by the user, but otherwise take precedence.
+
+: ${AUTOCONF="autoconf"}
+: ${AUTOMAKE="automake"}
+
+
+## -------------------------- ##
+## Source external libraries. ##
+## -------------------------- ##
+
+# Much of our low-level functionality needs to be sourced from external
+# libraries, which are installed to $pkgauxdir.
+
+# Set a version string for this script.
+scriptversion=2015-01-20.17; # UTC
+
+# General shell script boiler plate, and helper functions.
+# Written by Gary V. Vaughan, 2004
+
+# Copyright (C) 2004-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+# As a special exception to the GNU General Public License, if you distribute
+# this file as part of a program or library that is built using GNU Libtool,
+# you may include this file under the same distribution terms that you use
+# for the rest of that program.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
+# General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# Evaluate this file near the top of your script to gain access to
+# the functions and variables defined here:
+#
+#   . `echo "$0" | ${SED-sed} 's|^/*$||'`/build-aux/funclib.sh
+#
+# If you need to override any of the default environment variable
+# settings, do that before evaluating this file.
+
+
+## -------------------- ##
+## Shell normalisation. ##
+## -------------------- ##
+
+# Some shells need a little help to be as Bourne compatible as possible.
+# Before doing anything else, make sure all that help has been provided!
+
+DUALCASE=1; export DUALCASE # for MKS sh
+if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
+  emulate sh
+  NULLCMD=:
+  # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '${1+"$@"}'='"$@"'
+  setopt NO_GLOB_SUBST
+else
+  case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
+fi
+
+# NLS nuisances: We save the old values in case they are required later.
+_G_user_locale=
+_G_safe_locale=
+for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+do
+  eval "if test set = \"\${$_G_var+set}\"; then
+          save_$_G_var=\$$_G_var
+          $_G_var=C
+	  export $_G_var
+	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
+	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
+	fi"
+done
+
+# CDPATH.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+# Make sure IFS has a sensible default
+sp=' '
+nl='
+'
+IFS="$sp	$nl"
+
+# There are apparently some retarded systems that use ';' as a PATH separator!
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
+fi
+
+
+
+## ------------------------- ##
+## Locate command utilities. ##
+## ------------------------- ##
+
+
+# func_executable_p FILE
+# ----------------------
+# Check that FILE is an executable regular file.
+func_executable_p ()
+{
+    test -f "$1" && test -x "$1"
+}
+
+
+# func_path_progs PROGS_LIST CHECK_FUNC PATH
+# --------------------------------------------
+# Search for either a program that responds to --version with output
+# containing "GNU", or else returned by CHECK_FUNC otherwise, by
+# trying all the directories in PATH with each of the elements of
+# PROGS_LIST.
+#
+# CHECK_FUNC should accept the path to a candidate program, and
+# set $func_check_prog_result if it truncates its output less than
+# $_G_path_prog_max characters.
+func_path_progs ()
+{
+    _G_progs_list=$1
+    _G_check_func=$2
+    _G_PATH=${3-"$PATH"}
+
+    _G_path_prog_max=0
+    _G_path_prog_found=false
+    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
+    for _G_dir in $_G_PATH; do
+      IFS=$_G_save_IFS
+      test -z "$_G_dir" && _G_dir=.
+      for _G_prog_name in $_G_progs_list; do
+        for _exeext in '' .EXE; do
+          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
+          func_executable_p "$_G_path_prog" || continue
+          case `"$_G_path_prog" --version 2>&1` in
+            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
+            *)     $_G_check_func $_G_path_prog
+		   func_path_progs_result=$func_check_prog_result
+		   ;;
+          esac
+          $_G_path_prog_found && break 3
+        done
+      done
+    done
+    IFS=$_G_save_IFS
+    test -z "$func_path_progs_result" && {
+      echo "no acceptable sed could be found in \$PATH" >&2
+      exit 1
+    }
+}
+
+
+# We want to be able to use the functions in this file before configure
+# has figured out where the best binaries are kept, which means we have
+# to search for them ourselves - except when the results are already set
+# where we skip the searches.
+
+# Unless the user overrides by setting SED, search the path for either GNU
+# sed, or the sed that truncates its output the least.
+test -z "$SED" && {
+  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+  for _G_i in 1 2 3 4 5 6 7; do
+    _G_sed_script=$_G_sed_script$nl$_G_sed_script
+  done
+  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
+  _G_sed_script=
+
+  func_check_prog_sed ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo '' >> conftest.nl
+      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  rm -f conftest.sed
+  SED=$func_path_progs_result
+}
+
+
+# Unless the user overrides by setting GREP, search the path for either GNU
+# grep, or the grep that truncates its output the least.
+test -z "$GREP" && {
+  func_check_prog_grep ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    _G_path_prog_max=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo 'GREP' >> conftest.nl
+      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  GREP=$func_path_progs_result
+}
+
+
+## ------------------------------- ##
+## User overridable command paths. ##
+## ------------------------------- ##
+
+# All uppercase variable names are used for environment variables.  These
+# variables can be overridden by the user before calling a script that
+# uses them if a suitable command of that name is not already available
+# in the command search PATH.
+
+: ${CP="cp -f"}
+: ${ECHO="printf %s\n"}
+: ${EGREP="$GREP -E"}
+: ${FGREP="$GREP -F"}
+: ${LN_S="ln -s"}
+: ${MAKE="make"}
+: ${MKDIR="mkdir"}
+: ${MV="mv -f"}
+: ${RM="rm -f"}
+: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
+
+
+## -------------------- ##
+## Useful sed snippets. ##
+## -------------------- ##
+
+sed_dirname='s|/^/*$||'
+sed_basename='s|^.*/||'
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='s|$`"$\\$|\\\1|g'
+
+# Same as above, but do not quote variable references.
+sed_double_quote_subst='s/$"`\\$/\\\1/g'
+
+# Sed substitution that turns a string into a regex matching for the
+# string literally.
+sed_make_literal_regex='s|.^$\\*\/|\\&|g'
+
+# Sed substitution that converts a w32 file name or path
+# that contains forward slashes, into one that contains
+# (escaped) backslashes.  A very naive implementation.
+sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
+
+# Re-'\' parameter expansions in output of sed_double_quote_subst that
+# were '\'-ed in input to the same.  If an odd number of '\' preceded a
+# '$' in input to sed_double_quote_subst, that '$' was protected from
+# expansion.  Since each input '\' is now two '\'s, look for any number
+# of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
+_G_bs='\\'
+_G_bs2='\\\\'
+_G_bs4='\\\\\\\\'
+_G_dollar='\$'
+sed_double_backslash="\
+  s/$_G_bs4/&\\
+/g
+  s/^$_G_bs2$_G_dollar/$_G_bs&/
+  s/\$^$_G_bs\$$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
+  s/\n//g"
+
+
+## ----------------- ##
+## Global variables. ##
+## ----------------- ##
+
+# Except for the global variables explicitly listed below, the following
+# functions in the '^func_' namespace, and the '^require_' namespace
+# variables initialised in the 'Resource management' section, sourcing
+# this file will not pollute your global namespace with anything
+# else. There's no portable way to scope variables in Bourne shell
+# though, so actually running these functions will sometimes place
+# results into a variable named after the function, and often use
+# temporary variables in the '^_G_' namespace. If you are careful to
+# avoid using those namespaces casually in your sourcing script, things
+# should continue to work as you expect. And, of course, you can freely
+# overwrite any of the functions or variables defined here before
+# calling anything to customize them.
+
+EXIT_SUCCESS=0
+EXIT_FAILURE=1
+EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
+EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
+
+# Allow overriding, eg assuming that you follow the convention of
+# putting '$debug_cmd' at the start of all your functions, you can get
+# bash to show function call trace with:
+#
+#    debug_cmd='echo "${FUNCNAME0} $*" >&2' bash your-script-name
+debug_cmd=${debug_cmd-":"}
+exit_cmd=:
+
+# By convention, finish your script with:
+#
+#    exit $exit_status
+#
+# so that you can set exit_status to non-zero if you want to indicate
+# something went wrong during execution without actually bailing out at
+# the point of failure.
+exit_status=$EXIT_SUCCESS
+
+# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
+# is ksh but when the shell is invoked as "sh" and the current value of
+# the _XPG environment variable is not equal to 1 (one), the special
+# positional parameter $0, within a function call, is the name of the
+# function.
+progpath=$0
+
+# The name of this program.
+progname=`$ECHO "$progpath" |$SED "$sed_basename"`
+
+# Make sure we have an absolute progpath for reexecution:
+case $progpath in
+  \\/*|A-Za-z:\\*) ;;
+  *\\/*)
+     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
+     progdir=`cd "$progdir" && pwd`
+     progpath=$progdir/$progname
+     ;;
+  *)
+     _G_IFS=$IFS
+     IFS=${PATH_SEPARATOR-:}
+     for progdir in $PATH; do
+       IFS=$_G_IFS
+       test -x "$progdir/$progname" && break
+     done
+     IFS=$_G_IFS
+     test -n "$progdir" || progdir=`pwd`
+     progpath=$progdir/$progname
+     ;;
+esac
+
+
+## ----------------- ##
+## Standard options. ##
+## ----------------- ##
+
+# The following options affect the operation of the functions defined
+# below, and should be set appropriately depending on run-time para-
+# meters passed on the command line.
+
+opt_dry_run=false
+opt_quiet=false
+opt_verbose=false
+
+# Categories 'all' and 'none' are always available.  Append any others
+# you will pass as the first argument to func_warning from your own
+# code.
+warning_categories=
+
+# By default, display warnings according to 'opt_warning_types'.  Set
+# 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
+# treat the next displayed warning as a fatal error.
+warning_func=func_warn_and_continue
+
+# Set to 'all' to display all warnings, 'none' to suppress all
+# warnings, or a space delimited list of some subset of
+# 'warning_categories' to display only the listed warnings.
+opt_warning_types=all
+
+
+## -------------------- ##
+## Resource management. ##
+## -------------------- ##
+
+# This section contains definitions for functions that each ensure a
+# particular resource (a file, or a non-empty configuration variable for
+# example) is available, and if appropriate to extract default values
+# from pertinent package files. Call them using their associated
+# 'require_*' variable to ensure that they are executed, at most, once.
+#
+# It's entirely deliberate that calling these functions can set
+# variables that don't obey the namespace limitations obeyed by the rest
+# of this file, in order that that they be as useful as possible to
+# callers.
+
+
+# require_term_colors
+# -------------------
+# Allow display of bold text on terminals that support it.
+require_term_colors=func_require_term_colors
+func_require_term_colors ()
+{
+    $debug_cmd
+
+    test -t 1 && {
+      # COLORTERM and USE_ANSI_COLORS environment variables take
+      # precedence, because most terminfo databases neglect to describe
+      # whether color sequences are supported.
+      test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
+
+      if test 1 = "$USE_ANSI_COLORS"; then
+        # Standard ANSI escape sequences
+        tc_reset='&#x1b;0m'
+        tc_bold='&#x1b;1m';   tc_standout='&#x1b;7m'
+        tc_red='&#x1b;31m';   tc_green='&#x1b;32m'
+        tc_blue='&#x1b;34m';  tc_cyan='&#x1b;36m'
+      else
+        # Otherwise trust the terminfo database after all.
+        test -n "`tput sgr0 2>/dev/null`" && {
+          tc_reset=`tput sgr0`
+          test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
+          tc_standout=$tc_bold
+          test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
+          test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
+          test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
+          test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
+          test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
+        }
+      fi
+    }
+
+    require_term_colors=:
+}
+
+
+## ----------------- ##
+## Function library. ##
+## ----------------- ##
+
+# This section contains a variety of useful functions to call in your
+# scripts. Take note of the portable wrappers for features provided by
+# some modern shells, which will fall back to slower equivalents on
+# less featureful shells.
+
+
+# func_append VAR VALUE
+# ---------------------
+# Append VALUE onto the existing contents of VAR.
+
+  # We should try to minimise forks, especially on Windows where they are
+  # unreasonably slow, so skip the feature probes when bash or zsh are
+  # being used:
+  if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
+    : ${_G_HAVE_ARITH_OP="yes"}
+    : ${_G_HAVE_XSI_OPS="yes"}
+    # The += operator was introduced in bash 3.1
+    case $BASH_VERSION in
+      12.* | 3.0 | 3.0*) ;;
+      *)
+        : ${_G_HAVE_PLUSEQ_OP="yes"}
+        ;;
+    esac
+  fi
+
+  # _G_HAVE_PLUSEQ_OP
+  # Can be empty, in which case the shell is probed, "yes" if += is
+  # useable or anything else if it does not work.
+  test -z "$_G_HAVE_PLUSEQ_OP" \
+    && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
+    && _G_HAVE_PLUSEQ_OP=yes
+
+if test yes = "$_G_HAVE_PLUSEQ_OP"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_append ()
+  {
+    $debug_cmd
+
+    eval "$1+=\$2"
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_append ()
+  {
+    $debug_cmd
+
+    eval "$1=\$$1\$2"
+  }
+fi
+
+
+# func_append_quoted VAR VALUE
+# ----------------------------
+# Quote VALUE and append to the end of shell variable VAR, separated
+# by a space.
+if test yes = "$_G_HAVE_PLUSEQ_OP"; then
+  eval 'func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1+=\\ \$func_quote_for_eval_result"
+  }'
+else
+  func_append_quoted ()
+  {
+    $debug_cmd
+
+    func_quote_for_eval "$2"
+    eval "$1=\$$1\\ \$func_quote_for_eval_result"
+  }
+fi
+
+
+# func_append_uniq VAR VALUE
+# --------------------------
+# Append unique VALUE onto the existing contents of VAR, assuming
+# entries are delimited by the first character of VALUE.  For example:
+#
+#   func_append_uniq options " --another-option option-argument"
+#
+# will only append to $options if " --another-option option-argument "
+# is not already present somewhere in $options already (note spaces at
+# each end implied by leading space in second argument).
+func_append_uniq ()
+{
+    $debug_cmd
+
+    eval _G_current_value='`$ECHO $'$1'`'
+    _G_delim=`expr "$2" : '$.$'`
+
+    case $_G_delim$_G_current_value$_G_delim in
+      *"$2$_G_delim"*) ;;
+      *) func_append "$@" ;;
+    esac
+}
+
+
+# func_arith TERM...
+# ------------------
+# Set func_arith_result to the result of evaluating TERMs.
+  test -z "$_G_HAVE_ARITH_OP" \
+    && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
+    && _G_HAVE_ARITH_OP=yes
+
+if test yes = "$_G_HAVE_ARITH_OP"; then
+  eval 'func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=$(( $* ))
+  }'
+else
+  func_arith ()
+  {
+    $debug_cmd
+
+    func_arith_result=`expr "$@"`
+  }
+fi
+
+
+# func_basename FILE
+# ------------------
+# Set func_basename_result to FILE with everything up to and including
+# the last / stripped.
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  # If this shell supports suffix pattern removal, then use it to avoid
+  # forking. Hide the definitions single quotes in case the shell chokes
+  # on unsupported syntax...
+  _b='func_basename_result=${1##*/}'
+  _d='case $1 in
+        */*) func_dirname_result=${1%/*}$2 ;;
+        *  ) func_dirname_result=$3        ;;
+      esac'
+
+else
+  # ...otherwise fall back to using sed.
+  _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
+  _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
+      if test "X$func_dirname_result" = "X$1"; then
+        func_dirname_result=$3
+      else
+        func_append func_dirname_result "$2"
+      fi'
+fi
+
+eval 'func_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+}'
+
+
+# func_dirname FILE APPEND NONDIR_REPLACEMENT
+# -------------------------------------------
+# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
+# otherwise set result to NONDIR_REPLACEMENT.
+eval 'func_dirname ()
+{
+    $debug_cmd
+
+    '"$_d"'
+}'
+
+
+# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
+# --------------------------------------------------------
+# Perform func_basename and func_dirname in a single function
+# call:
+#   dirname:  Compute the dirname of FILE.  If nonempty,
+#             add APPEND to the result, otherwise set result
+#             to NONDIR_REPLACEMENT.
+#             value returned in "$func_dirname_result"
+#   basename: Compute filename of FILE.
+#             value retuned in "$func_basename_result"
+# For efficiency, we do not delegate to the functions above but instead
+# duplicate the functionality here.
+eval 'func_dirname_and_basename ()
+{
+    $debug_cmd
+
+    '"$_b"'
+    '"$_d"'
+}'
+
+
+# func_echo ARG...
+# ----------------
+# Echo program name prefixed message.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_echo_all ARG...
+# --------------------
+# Invoke $ECHO with all args, space-separated.
+func_echo_all ()
+{
+    $ECHO "$*"
+}
+
+
+# func_echo_infix_1 INFIX ARG...
+# ------------------------------
+# Echo program name, followed by INFIX on the first line, with any
+# additional lines not showing INFIX.
+func_echo_infix_1 ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    _G_infix=$1; shift
+    _G_indent=$_G_infix
+    _G_prefix="$progname: $_G_infix: "
+    _G_message=$*
+
+    # Strip color escape sequences before counting printable length
+    for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
+    do
+      test -n "$_G_tc" && {
+        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
+        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
+      }
+    done
+    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
+
+    func_echo_infix_1_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_infix_1_IFS
+      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
+      _G_prefix=$_G_indent
+    done
+    IFS=$func_echo_infix_1_IFS
+}
+
+
+# func_error ARG...
+# -----------------
+# Echo program name prefixed message to standard error.
+func_error ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
+}
+
+
+# func_fatal_error ARG...
+# -----------------------
+# Echo program name prefixed message to standard error, and exit.
+func_fatal_error ()
+{
+    $debug_cmd
+
+    func_error "$*"
+    exit $EXIT_FAILURE
+}
+
+
+# func_grep EXPRESSION FILENAME
+# -----------------------------
+# Check whether EXPRESSION matches any line of FILENAME, without output.
+func_grep ()
+{
+    $debug_cmd
+
+    $GREP "$1" "$2" >/dev/null 2>&1
+}
+
+
+# func_len STRING
+# ---------------
+# Set func_len_result to the length of STRING. STRING may not
+# start with a hyphen.
+  test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=${#1}
+  }'
+else
+  func_len ()
+  {
+    $debug_cmd
+
+    func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
+  }
+fi
+
+
+# func_mkdir_p DIRECTORY-PATH
+# ---------------------------
+# Make sure the entire path to DIRECTORY-PATH is available.
+func_mkdir_p ()
+{
+    $debug_cmd
+
+    _G_directory_path=$1
+    _G_dir_list=
+
+    if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
+
+      # Protect directory names starting with '-'
+      case $_G_directory_path in
+        -*) _G_directory_path=./$_G_directory_path ;;
+      esac
+
+      # While some portion of DIR does not yet exist...
+      while test ! -d "$_G_directory_path"; do
+        # ...make a list in topmost first order.  Use a colon delimited
+	# list incase some portion of path contains whitespace.
+        _G_dir_list=$_G_directory_path:$_G_dir_list
+
+        # If the last portion added has no slash in it, the list is done
+        case $_G_directory_path in */*) ;; *) break ;; esac
+
+        # ...otherwise throw away the child directory and loop
+        _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
+      done
+      _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
+
+      func_mkdir_p_IFS=$IFS; IFS=:
+      for _G_dir in $_G_dir_list; do
+	IFS=$func_mkdir_p_IFS
+        # mkdir can fail with a 'File exist' error if two processes
+        # try to create one of the directories concurrently.  Don't
+        # stop in that case!
+        $MKDIR "$_G_dir" 2>/dev/null || :
+      done
+      IFS=$func_mkdir_p_IFS
+
+      # Bail out if we (or some other process) failed to create a directory.
+      test -d "$_G_directory_path" || \
+        func_fatal_error "Failed to create '$1'"
+    fi
+}
+
+
+# func_mktempdir BASENAME
+# -------------------------
+# Make a temporary directory that won't clash with other running
+# libtool processes, and avoids race conditions if possible.  If
+# given, BASENAME is the basename for that directory.
+func_mktempdir ()
+{
+    $debug_cmd
+
+    _G_template=${TMPDIR-/tmp}/${1-$progname}
+
+    if test : = "$opt_dry_run"; then
+      # Return a directory name, but don't create it in dry-run mode
+      _G_tmpdir=$_G_template-$$
+    else
+
+      # If mktemp works, use that first and foremost
+      _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
+
+      if test ! -d "$_G_tmpdir"; then
+        # Failing that, at least try and use $RANDOM to avoid a race
+        _G_tmpdir=$_G_template-${RANDOM-0}$$
+
+        func_mktempdir_umask=`umask`
+        umask 0077
+        $MKDIR "$_G_tmpdir"
+        umask $func_mktempdir_umask
+      fi
+
+      # If we're not in dry-run mode, bomb out on failure
+      test -d "$_G_tmpdir" || \
+        func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
+    fi
+
+    $ECHO "$_G_tmpdir"
+}
+
+
+# func_normal_abspath PATH
+# ------------------------
+# Remove doubled-up and trailing slashes, "." path components,
+# and cancel out any ".." path components in PATH after making
+# it an absolute path.
+func_normal_abspath ()
+{
+    $debug_cmd
+
+    # These SED scripts presuppose an absolute path with a trailing slash.
+    _G_pathcar='s|^/$^/*$.*$|\1|'
+    _G_pathcdr='s|^/^/*||'
+    _G_removedotparts=':dotsl
+		s|/\./|/|g
+		t dotsl
+		s|/\.$|/|'
+    _G_collapseslashes='s|/\{1,\}|/|g'
+    _G_finalslash='s|/*$|/|'
+
+    # Start from root dir and reassemble the path.
+    func_normal_abspath_result=
+    func_normal_abspath_tpath=$1
+    func_normal_abspath_altnamespace=
+    case $func_normal_abspath_tpath in
+      "")
+        # Empty path, that just means $cwd.
+        func_stripname '' '/' "`pwd`"
+        func_normal_abspath_result=$func_stripname_result
+        return
+        ;;
+      # The next three entries are used to spot a run of precisely
+      # two leading slashes without using negated character classes;
+      # we take advantage of case's first-match behaviour.
+      ///*)
+        # Unusual form of absolute path, do nothing.
+        ;;
+      //*)
+        # Not necessarily an ordinary path; POSIX reserves leading '//'
+        # and for example Cygwin uses it to access remote file shares
+        # over CIFS/SMB, so we conserve a leading double slash if found.
+        func_normal_abspath_altnamespace=/
+        ;;
+      /*)
+        # Absolute path, do nothing.
+        ;;
+      *)
+        # Relative path, prepend $cwd.
+        func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
+        ;;
+    esac
+
+    # Cancel out all the simple stuff to save iterations.  We also want
+    # the path to end with a slash for ease of parsing, so make sure
+    # there is one (and only one) here.
+    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
+    while :; do
+      # Processed it all yet?
+      if test / = "$func_normal_abspath_tpath"; then
+        # If we ascended to the root using ".." the result may be empty now.
+        if test -z "$func_normal_abspath_result"; then
+          func_normal_abspath_result=/
+        fi
+        break
+      fi
+      func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcar"`
+      func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
+          -e "$_G_pathcdr"`
+      # Figure out what to do with it
+      case $func_normal_abspath_tcomponent in
+        "")
+          # Trailing empty path component, ignore it.
+          ;;
+        ..)
+          # Parent dir; strip last assembled component from result.
+          func_dirname "$func_normal_abspath_result"
+          func_normal_abspath_result=$func_dirname_result
+          ;;
+        *)
+          # Actual path component, append it.
+          func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
+          ;;
+      esac
+    done
+    # Restore leading double-slash if one was found on entry.
+    func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
+}
+
+
+# func_notquiet ARG...
+# --------------------
+# Echo program name prefixed message only when not in quiet mode.
+func_notquiet ()
+{
+    $debug_cmd
+
+    $opt_quiet || func_echo ${1+"$@"}
+
+    # A bug in bash halts the script if the last line of a function
+    # fails when set -e is in force, so we need another command to
+    # work around that:
+    :
+}
+
+
+# func_relative_path SRCDIR DSTDIR
+# --------------------------------
+# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
+func_relative_path ()
+{
+    $debug_cmd
+
+    func_relative_path_result=
+    func_normal_abspath "$1"
+    func_relative_path_tlibdir=$func_normal_abspath_result
+    func_normal_abspath "$2"
+    func_relative_path_tbindir=$func_normal_abspath_result
+
+    # Ascend the tree starting from libdir
+    while :; do
+      # check if we have found a prefix of bindir
+      case $func_relative_path_tbindir in
+        $func_relative_path_tlibdir)
+          # found an exact match
+          func_relative_path_tcancelled=
+          break
+          ;;
+        $func_relative_path_tlibdir*)
+          # found a matching prefix
+          func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
+          func_relative_path_tcancelled=$func_stripname_result
+          if test -z "$func_relative_path_result"; then
+            func_relative_path_result=.
+          fi
+          break
+          ;;
+        *)
+          func_dirname $func_relative_path_tlibdir
+          func_relative_path_tlibdir=$func_dirname_result
+          if test -z "$func_relative_path_tlibdir"; then
+            # Have to descend all the way to the root!
+            func_relative_path_result=../$func_relative_path_result
+            func_relative_path_tcancelled=$func_relative_path_tbindir
+            break
+          fi
+          func_relative_path_result=../$func_relative_path_result
+          ;;
+      esac
+    done
+
+    # Now calculate path; take care to avoid doubling-up slashes.
+    func_stripname '' '/' "$func_relative_path_result"
+    func_relative_path_result=$func_stripname_result
+    func_stripname '/' '/' "$func_relative_path_tcancelled"
+    if test -n "$func_stripname_result"; then
+      func_append func_relative_path_result "/$func_stripname_result"
+    fi
+
+    # Normalisation. If bindir is libdir, return '.' else relative path.
+    if test -n "$func_relative_path_result"; then
+      func_stripname './' '' "$func_relative_path_result"
+      func_relative_path_result=$func_stripname_result
+    fi
+
+    test -n "$func_relative_path_result" || func_relative_path_result=.
+
+    :
+}
+
+
+# func_quote_for_eval ARG...
+# --------------------------
+# Aesthetically quote ARGs to be evaled later.
+# This function returns two values:
+#   i) func_quote_for_eval_result
+#      double-quoted, suitable for a subsequent eval
+#  ii) func_quote_for_eval_unquoted_result
+#      has all characters that are still active within double
+#      quotes backslashified.
+func_quote_for_eval ()
+{
+    $debug_cmd
+
+    func_quote_for_eval_unquoted_result=
+    func_quote_for_eval_result=
+    while test 0 -lt $#; do
+      case $1 in
+        *\\\`\"\$*)
+	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
+        *)
+          _G_unquoted_arg=$1 ;;
+      esac
+      if test -n "$func_quote_for_eval_unquoted_result"; then
+	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
+      else
+        func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
+      fi
+
+      case $_G_unquoted_arg in
+        # Double-quote args containing shell metacharacters to delay
+        # word splitting, command substitution and variable expansion
+        # for a subsequent eval.
+        # Many Bourne shells cannot handle close brackets correctly
+        # in scan sets, so we specify it separately.
+        *\\~\#\^\&\*\{\}\|\;\<\>\?\'\ \	*|**|"")
+          _G_quoted_arg=\"$_G_unquoted_arg\"
+          ;;
+        *)
+          _G_quoted_arg=$_G_unquoted_arg
+	  ;;
+      esac
+
+      if test -n "$func_quote_for_eval_result"; then
+	func_append func_quote_for_eval_result " $_G_quoted_arg"
+      else
+        func_append func_quote_for_eval_result "$_G_quoted_arg"
+      fi
+      shift
+    done
+}
+
+
+# func_quote_for_expand ARG
+# -------------------------
+# Aesthetically quote ARG to be evaled later; same as above,
+# but do not quote variable references.
+func_quote_for_expand ()
+{
+    $debug_cmd
+
+    case $1 in
+      *\\\`\"*)
+	_G_arg=`$ECHO "$1" | $SED \
+	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
+      *)
+        _G_arg=$1 ;;
+    esac
+
+    case $_G_arg in
+      # Double-quote args containing shell metacharacters to delay
+      # word splitting and command substitution for a subsequent eval.
+      # Many Bourne shells cannot handle close brackets correctly
+      # in scan sets, so we specify it separately.
+      *\\~\#\^\&\*\{\}\|\;\<\>\?\'\ \	*|**|"")
+        _G_arg=\"$_G_arg\"
+        ;;
+    esac
+
+    func_quote_for_expand_result=$_G_arg
+}
+
+
+# func_stripname PREFIX SUFFIX NAME
+# ---------------------------------
+# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
+# PREFIX and SUFFIX must not contain globbing or regex special
+# characters, hashes, percent signs, but SUFFIX may contain a leading
+# dot (in which case that matches only a dot).
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_stripname ()
+  {
+    $debug_cmd
+
+    # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
+    # positional parameters, so assign one to ordinary variable first.
+    func_stripname_result=$3
+    func_stripname_result=${func_stripname_result#"$1"}
+    func_stripname_result=${func_stripname_result%"$2"}
+  }'
+else
+  func_stripname ()
+  {
+    $debug_cmd
+
+    case $2 in
+      .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
+      *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
+    esac
+  }
+fi
+
+
+# func_show_eval CMD FAIL_EXP
+# -----------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.
+func_show_eval ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    func_quote_for_expand "$_G_cmd"
+    eval "func_notquiet $func_quote_for_expand_result"
+
+    $opt_dry_run || {
+      eval "$_G_cmd"
+      _G_status=$?
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_show_eval_locale CMD FAIL_EXP
+# ------------------------------------
+# Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
+# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
+# is given, then evaluate it.  Use the saved locale for evaluation.
+func_show_eval_locale ()
+{
+    $debug_cmd
+
+    _G_cmd=$1
+    _G_fail_exp=${2-':'}
+
+    $opt_quiet || {
+      func_quote_for_expand "$_G_cmd"
+      eval "func_echo $func_quote_for_expand_result"
+    }
+
+    $opt_dry_run || {
+      eval "$_G_user_locale
+	    $_G_cmd"
+      _G_status=$?
+      eval "$_G_safe_locale"
+      if test 0 -ne "$_G_status"; then
+	eval "(exit $_G_status); $_G_fail_exp"
+      fi
+    }
+}
+
+
+# func_tr_sh
+# ----------
+# Turn $1 into a string suitable for a shell variable name.
+# Result is stored in $func_tr_sh_result.  All characters
+# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
+# if $1 begins with a digit, a '_' is prepended as well.
+func_tr_sh ()
+{
+    $debug_cmd
+
+    case $1 in
+    0-9* | *!a-zA-Z0-9_*)
+      func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^$0-9$/_\1/' -e 's/^a-zA-Z0-9_/_/g'`
+      ;;
+    * )
+      func_tr_sh_result=$1
+      ;;
+    esac
+}
+
+
+# func_verbose ARG...
+# -------------------
+# Echo program name prefixed message in verbose mode only.
+func_verbose ()
+{
+    $debug_cmd
+
+    $opt_verbose && func_echo "$*"
+
+    :
+}
+
+
+# func_warn_and_continue ARG...
+# -----------------------------
+# Echo program name prefixed warning message to standard error.
+func_warn_and_continue ()
+{
+    $debug_cmd
+
+    $require_term_colors
+
+    func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
+}
+
+
+# func_warning CATEGORY ARG...
+# ----------------------------
+# Echo program name prefixed warning message to standard error. Warning
+# messages can be filtered according to CATEGORY, where this function
+# elides messages where CATEGORY is not listed in the global variable
+# 'opt_warning_types'.
+func_warning ()
+{
+    $debug_cmd
+
+    # CATEGORY must be in the warning_categories list!
+    case " $warning_categories " in
+      *" $1 "*) ;;
+      *) func_internal_error "invalid warning category '$1'" ;;
+    esac
+
+    _G_category=$1
+    shift
+
+    case " $opt_warning_types " in
+      *" $_G_category "*) $warning_func ${1+"$@"} ;;
+    esac
+}
+
+
+# func_sort_ver VER1 VER2
+# -----------------------
+# 'sort -V' is not generally available.
+# Note this deviates from the version comparison in automake
+# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
+# but this should suffice as we won't be specifying old
+# version formats or redundant trailing .0 in bootstrap.conf.
+# If we did want full compatibility then we should probably
+# use m4_version_compare from autoconf.
+func_sort_ver ()
+{
+    $debug_cmd
+
+    printf '%s\n%s\n' "$1" "$2" \
+      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
+}
+
+# func_lt_ver PREV CURR
+# ---------------------
+# Return true if PREV and CURR are in the correct order according to
+# func_sort_ver, otherwise false.  Use it like this:
+#
+#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
+func_lt_ver ()
+{
+    $debug_cmd
+
+    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+#! /bin/sh
+
+# Set a version string for this script.
+scriptversion=2015-10-07.11; # UTC
+
+# A portable, pluggable option parser for Bourne shell.
+# Written by Gary V. Vaughan, 2010
+
+# Copyright (C) 2010-2015 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# Please report bugs or propose patches to gary@gnu.org.
+
+
+## ------ ##
+## Usage. ##
+## ------ ##
+
+# This file is a library for parsing options in your shell scripts along
+# with assorted other useful supporting features that you can make use
+# of too.
+#
+# For the simplest scripts you might need only:
+#
+#   #!/bin/sh
+#   . relative/path/to/funclib.sh
+#   . relative/path/to/options-parser
+#   scriptversion=1.0
+#   func_options ${1+"$@"}
+#   eval set dummy "$func_options_result"; shift
+#   ...rest of your script...
+#
+# In order for the '--version' option to work, you will need to have a
+# suitably formatted comment like the one at the top of this file
+# starting with '# Written by ' and ending with '# warranty; '.
+#
+# For '-h' and '--help' to work, you will also need a one line
+# description of your script's purpose in a comment directly above the
+# '# Written by ' line, like the one at the top of this file.
+#
+# The default options also support '--debug', which will turn on shell
+# execution tracing (see the comment above debug_cmd below for another
+# use), and '--verbose' and the func_verbose function to allow your script
+# to display verbose messages only when your user has specified
+# '--verbose'.
+#
+# After sourcing this file, you can plug processing for additional
+# options by amending the variables from the 'Configuration' section
+# below, and following the instructions in the 'Option parsing'
+# section further down.
+
+## -------------- ##
+## Configuration. ##
+## -------------- ##
+
+# You should override these variables in your script after sourcing this
+# file so that they reflect the customisations you have added to the
+# option parser.
+
+# The usage line for option parsing errors and the start of '-h' and
+# '--help' output messages. You can embed shell variables for delayed
+# expansion at the time the message is displayed, but you will need to
+# quote other shell meta-characters carefully to prevent them being
+# expanded when the contents are evaled.
+usage='$progpath OPTION...'
+
+# Short help message in response to '-h' and '--help'.  Add to this or
+# override it after sourcing this library to reflect the full set of
+# options your script accepts.
+usage_message="\
+       --debug        enable verbose shell tracing
+   -W, --warnings=CATEGORY
+                      report the warnings falling in CATEGORY all
+   -v, --verbose      verbosely report processing
+       --version      print version information and exit
+   -h, --help         print short or long help message and exit
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+long_help_message="
+Warning categories include:
+       'all'          show all warnings
+       'none'         turn off all the warnings
+       'error'        warnings are treated as fatal errors"
+
+# Help message printed before fatal option parsing errors.
+fatal_help="Try '\$progname --help' for more information."
+
+
+
+## ------------------------- ##
+## Hook function management. ##
+## ------------------------- ##
+
+# This section contains functions for adding, removing, and running hooks
+# to the main code.  A hook is just a named list of of function, that can
+# be run in order later on.
+
+# func_hookable FUNC_NAME
+# -----------------------
+# Declare that FUNC_NAME will run hooks added with
+# 'func_add_hook FUNC_NAME ...'.
+func_hookable ()
+{
+    $debug_cmd
+
+    func_append hookable_fns " $1"
+}
+
+
+# func_add_hook FUNC_NAME HOOK_FUNC
+# ---------------------------------
+# Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
+# first have been declared "hookable" by a call to 'func_hookable'.
+func_add_hook ()
+{
+    $debug_cmd
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not accept hook functions." ;;
+    esac
+
+    eval func_append ${1}_hooks '" $2"'
+}
+
+
+# func_remove_hook FUNC_NAME HOOK_FUNC
+# ------------------------------------
+# Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
+func_remove_hook ()
+{
+    $debug_cmd
+
+    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
+}
+
+
+# func_run_hooks FUNC_NAME ARG...
+# ---------------------------------
+# Run all hook functions registered to FUNC_NAME.
+# It is assumed that the list of hook functions contains nothing more
+# than a whitespace-delimited list of legal shell function names, and
+# no effort is wasted trying to catch shell meta-characters or preserve
+# whitespace.
+func_run_hooks ()
+{
+    $debug_cmd
+
+    _G_rc_run_hooks=false
+
+    case " $hookable_fns " in
+      *" $1 "*) ;;
+      *) func_fatal_error "'$1' does not support hook funcions.n" ;;
+    esac
+
+    eval _G_hook_fns=\$$1_hooks; shift
+
+    for _G_hook in $_G_hook_fns; do
+      if eval $_G_hook '"$@"'; then
+        # store returned options list back into positional
+        # parameters for next 'cmd' execution.
+        eval _G_hook_result=\$${_G_hook}_result
+        eval set dummy "$_G_hook_result"; shift
+        _G_rc_run_hooks=:
+      fi
+    done
+
+    $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
+}
+
+
+
+## --------------- ##
+## Option parsing. ##
+## --------------- ##
+
+# In order to add your own option parsing hooks, you must accept the
+# full positional parameter list in your hook function, you may remove/edit
+# any options that you action, and then pass back the remaining unprocessed
+# options in '<hooked_function_name>_result', escaped suitably for
+# 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
+# hook's caller know that it should pay attention to
+# '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
+# arguments are left untouched by the hook and therefore caller will ignore the
+# result variable.
+#
+# Like this:
+#
+#    my_options_prep ()
+#    {
+#        $debug_cmd
+#
+#        # Extend the existing usage message.
+#        usage_message=$usage_message'
+#      -s, --silent       don'\''t print informational messages
+#    '
+#        # No change in '$@' (ignored completely by this hook).  There is
+#        # no need to do the equivalent (but slower) action:
+#        # func_quote_for_eval ${1+"$@"}
+#        # my_options_prep_result=$func_quote_for_eval_result
+#        false
+#    }
+#    func_add_hook func_options_prep my_options_prep
+#
+#
+#    my_silent_option ()
+#    {
+#        $debug_cmd
+#
+#        args_changed=false
+#
+#        # Note that for efficiency, we parse as many options as we can
+#        # recognise in a loop before passing the remainder back to the
+#        # caller on the first unrecognised argument we encounter.
+#        while test $# -gt 0; do
+#          opt=$1; shift
+#          case $opt in
+#            --silent|-s) opt_silent=:
+#                         args_changed=:
+#                         ;;
+#            # Separate non-argument short options:
+#            -s*)         func_split_short_opt "$_G_opt"
+#                         set dummy "$func_split_short_opt_name" \
+#                             "-$func_split_short_opt_arg" ${1+"$@"}
+#                         shift
+#                         args_changed=:
+#                         ;;
+#            *)           # Make sure the first unrecognised option "$_G_opt"
+#                         # is added back to "$@", we could need that later
+#                         # if $args_changed is true.
+#                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
+#          esac
+#        done
+#
+#        if $args_changed; then
+#          func_quote_for_eval ${1+"$@"}
+#          my_silent_option_result=$func_quote_for_eval_result
+#        fi
+#
+#        $args_changed
+#    }
+#    func_add_hook func_parse_options my_silent_option
+#
+#
+#    my_option_validation ()
+#    {
+#        $debug_cmd
+#
+#        $opt_silent && $opt_verbose && func_fatal_help "\
+#    '--silent' and '--verbose' options are mutually exclusive."
+#
+#        false
+#    }
+#    func_add_hook func_validate_options my_option_validation
+#
+# You'll also need to manually amend $usage_message to reflect the extra
+# options you parse.  It's preferable to append if you can, so that
+# multiple option parsing hooks can be added safely.
+
+
+# func_options_finish ARG...
+# ----------------------------
+# Finishing the option parse loop (call 'func_options' hooks ATM).
+func_options_finish ()
+{
+    $debug_cmd
+
+    _G_func_options_finish_exit=false
+    if func_run_hooks func_options ${1+"$@"}; then
+      func_options_finish_result=$func_run_hooks_result
+      _G_func_options_finish_exit=:
+    fi
+
+    $_G_func_options_finish_exit
+}
+
+
+# func_options ARG...
+# ---------------------
+# All the functions called inside func_options are hookable. See the
+# individual implementations for details.
+func_hookable func_options
+func_options ()
+{
+    $debug_cmd
+
+    _G_rc_options=false
+
+    for my_func in options_prep parse_options validate_options options_finish
+    do
+      if eval func_$my_func '${1+"$@"}'; then
+        eval _G_res_var='$'"func_${my_func}_result"
+        eval set dummy "$_G_res_var" ; shift
+        _G_rc_options=:
+      fi
+    done
+
+    # Save modified positional parameters for caller.  As a top-level
+    # options-parser function we always need to set the 'func_options_result'
+    # variable (regardless the $_G_rc_options value).
+    if $_G_rc_options; then
+      func_options_result=$_G_res_var
+    else
+      func_quote_for_eval ${1+"$@"}
+      func_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_options
+}
+
+
+# func_options_prep ARG...
+# --------------------------
+# All initialisations required before starting the option parse loop.
+# Note that when calling hook functions, we pass through the list of
+# positional parameters.  If a hook function modifies that list, and
+# needs to propagate that back to rest of this script, then the complete
+# modified list must be put in 'func_run_hooks_result' before
+# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
+func_hookable func_options_prep
+func_options_prep ()
+{
+    $debug_cmd
+
+    # Option defaults:
+    opt_verbose=false
+    opt_warning_types=
+
+    _G_rc_options_prep=false
+    if func_run_hooks func_options_prep ${1+"$@"}; then
+      _G_rc_options_prep=:
+      # save modified positional parameters for caller
+      func_options_prep_result=$func_run_hooks_result
+    fi
+
+    $_G_rc_options_prep
+}
+
+
+# func_parse_options ARG...
+# ---------------------------
+# The main option parsing loop.
+func_hookable func_parse_options
+func_parse_options ()
+{
+    $debug_cmd
+
+    func_parse_options_result=
+
+    _G_rc_parse_options=false
+    # this just eases exit handling
+    while test $# -gt 0; do
+      # Defer to hook functions for initial option parsing, so they
+      # get priority in the event of reusing an option name.
+      if func_run_hooks func_parse_options ${1+"$@"}; then
+        eval set dummy "$func_run_hooks_result"; shift
+        _G_rc_parse_options=:
+      fi
+
+      # Break out of the loop if we already parsed every option.
+      test $# -gt 0 || break
+
+      _G_match_parse_options=:
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --debug|-x)   debug_cmd='set -x'
+                      func_echo "enabling shell trace mode"
+                      $debug_cmd
+                      ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                      set dummy --warnings none ${1+"$@"}
+                      shift
+		      ;;
+
+        --warnings|--warning|-W)
+                      if test $# = 0 && func_missing_arg $_G_opt; then
+                        _G_rc_parse_options=:
+                        break
+                      fi
+                      case " $warning_categories $1" in
+                        *" $1 "*)
+                          # trailing space prevents matching last $1 above
+                          func_append_uniq opt_warning_types " $1"
+                          ;;
+                        *all)
+                          opt_warning_types=$warning_categories
+                          ;;
+                        *none)
+                          opt_warning_types=none
+                          warning_func=:
+                          ;;
+                        *error)
+                          opt_warning_types=$warning_categories
+                          warning_func=func_fatal_error
+                          ;;
+                        *)
+                          func_fatal_error \
+                             "unsupported warning category: '$1'"
+                          ;;
+                      esac
+                      shift
+                      ;;
+
+        --verbose|-v) opt_verbose=: ;;
+        --version)    func_version ;;
+        -\?|-h)       func_usage ;;
+        --help)       func_help ;;
+
+	# Separate optargs to long options (plugins may need this):
+	--*=*)        func_split_equals "$_G_opt"
+	              set dummy "$func_split_equals_lhs" \
+                          "$func_split_equals_rhs" ${1+"$@"}
+                      shift
+                      ;;
+
+       # Separate optargs to short options:
+        -W*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        # Separate non-argument short options:
+        -\?*|-h*|-v*|-x*)
+                      func_split_short_opt "$_G_opt"
+                      set dummy "$func_split_short_opt_name" \
+                          "-$func_split_short_opt_arg" ${1+"$@"}
+                      shift
+                      ;;
+
+        --)           _G_rc_parse_options=: ; break ;;
+        -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
+        *)            set dummy "$_G_opt" ${1+"$@"}; shift
+                      _G_match_parse_options=false
+                      break
+                      ;;
+      esac
+
+      $_G_match_parse_options && _G_rc_parse_options=:
+    done
+
+
+    if $_G_rc_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      func_parse_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_parse_options
+}
+
+
+# func_validate_options ARG...
+# ------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+func_hookable func_validate_options
+func_validate_options ()
+{
+    $debug_cmd
+
+    _G_rc_validate_options=false
+
+    # Display all warnings if -W was not given.
+    test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
+
+    if func_run_hooks func_validate_options ${1+"$@"}; then
+      # save modified positional parameters for caller
+      func_validate_options_result=$func_run_hooks_result
+      _G_rc_validate_options=:
+    fi
+
+    # Bail if the options were screwed!
+    $exit_cmd $EXIT_FAILURE
+
+    $_G_rc_validate_options
+}
+
+
+
+## ----------------- ##
+## Helper functions. ##
+## ----------------- ##
+
+# This section contains the helper functions used by the rest of the
+# hookable option parser framework in ascii-betical order.
+
+
+# func_fatal_help ARG...
+# ----------------------
+# Echo program name prefixed message to standard error, followed by
+# a help hint, and exit.
+func_fatal_help ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    eval \$ECHO \""$fatal_help"\"
+    func_error ${1+"$@"}
+    exit $EXIT_FAILURE
+}
+
+
+# func_help
+# ---------
+# Echo long help message to standard output and exit.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message"
+    exit 0
+}
+
+
+# func_missing_arg ARGNAME
+# ------------------------
+# Echo program name prefixed message to standard error and set global
+# exit_cmd.
+func_missing_arg ()
+{
+    $debug_cmd
+
+    func_error "Missing argument for '$1'."
+    exit_cmd=exit
+}
+
+
+# func_split_equals STRING
+# ------------------------
+# Set func_split_equals_lhs and func_split_equals_rhs shell variables after
+# splitting STRING at the '=' sign.
+test -z "$_G_HAVE_XSI_OPS" \
+    && (eval 'x=a/b/c;
+      test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
+    && _G_HAVE_XSI_OPS=yes
+
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=${1%%=*}
+      func_split_equals_rhs=${1#*=}
+      test "x$func_split_equals_lhs" = "x$1" \
+        && func_split_equals_rhs=
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_equals ()
+  {
+      $debug_cmd
+
+      func_split_equals_lhs=`expr "x$1" : 'x$^=*$'`
+      func_split_equals_rhs=
+      test "x$func_split_equals_lhs" = "x$1" \
+        || func_split_equals_rhs=`expr "x$1" : 'x^=*=$.*$$'`
+  }
+fi #func_split_equals
+
+
+# func_split_short_opt SHORTOPT
+# -----------------------------
+# Set func_split_short_opt_name and func_split_short_opt_arg shell
+# variables after splitting SHORTOPT after the 2nd character.
+if test yes = "$_G_HAVE_XSI_OPS"
+then
+  # This is an XSI compatible shell, allowing a faster implementation...
+  eval 'func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_arg=${1#??}
+      func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
+  }'
+else
+  # ...otherwise fall back to using expr, which is often a shell builtin.
+  func_split_short_opt ()
+  {
+      $debug_cmd
+
+      func_split_short_opt_name=`expr "x$1" : 'x-$.$'`
+      func_split_short_opt_arg=`expr "x$1" : 'x-.$.*$$'`
+  }
+fi #func_split_short_opt
+
+
+# func_usage
+# ----------
+# Echo short help message to standard output and exit.
+func_usage ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
+    exit 0
+}
+
+
+# func_usage_message
+# ------------------
+# Echo short help message to standard output.
+func_usage_message ()
+{
+    $debug_cmd
+
+    eval \$ECHO \""Usage: $usage"\"
+    echo
+    $SED -n 's|^# ||
+        /^Written by/{
+          x;p;x
+        }
+	h
+	/^Written by/q' < "$progpath"
+    echo
+    eval \$ECHO \""$usage_message"\"
+}
+
+
+# func_version
+# ------------
+# Echo version message to standard output and exit.
+func_version ()
+{
+    $debug_cmd
+
+    printf '%s\n' "$progname $scriptversion"
+    $SED -n '
+        /(C)/!b go
+        :more
+        /\./!{
+          N
+          s|\n# | |
+          b more
+        }
+        :go
+        /^# Written by /,/# warranty; / {
+          s|^# ||
+          s|^# *$||
+          s|$(C)$ 0-9,-* ,-$1-90-9* $|\1 \2|
+          p
+        }
+        /^# Written by / {
+          s|^# ||
+          p
+        }
+        /^warranty; /q' < "$progpath"
+
+    exit $?
+}
+
+
+# Local variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
+# time-stamp-time-zone: "UTC"
+# End:
+
+# Set a version string.
+scriptversion='(GNU libtool) 2.4.6'
+
+
+# func_echo ARG...
+# ----------------
+# Libtool also displays the current mode in messages, so override
+# funclib.sh func_echo with this custom definition.
+func_echo ()
+{
+    $debug_cmd
+
+    _G_message=$*
+
+    func_echo_IFS=$IFS
+    IFS=$nl
+    for _G_line in $_G_message; do
+      IFS=$func_echo_IFS
+      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
+    done
+    IFS=$func_echo_IFS
+}
+
+
+# func_warning ARG...
+# -------------------
+# Libtool warnings are not categorized, so override funclib.sh
+# func_warning with this simpler definition.
+func_warning ()
+{
+    $debug_cmd
+
+    $warning_func ${1+"$@"}
+}
+
+
+## ---------------- ##
+## Options parsing. ##
+## ---------------- ##
+
+# Hook in the functions to make sure our own options are parsed during
+# the option parsing loop.
+
+usage='$progpath OPTION... MODE-ARG...'
+
+# Short help message in response to '-h'.
+usage_message="Options:
+       --config             show all configuration variables
+       --debug              enable verbose shell tracing
+   -n, --dry-run            display commands without modifying any files
+       --features           display basic configuration information and exit
+       --mode=MODE          use operation mode MODE
+       --no-warnings        equivalent to '-Wnone'
+       --preserve-dup-deps  don't remove duplicate dependency libraries
+       --quiet, --silent    don't print informational messages
+       --tag=TAG            use configuration variables from tag TAG
+   -v, --verbose            print more informational messages than default
+       --version            print version information
+   -W, --warnings=CATEGORY  report the warnings falling in CATEGORY all
+   -h, --help, --help-all   print short, long, or detailed help message
+"
+
+# Additional text appended to 'usage_message' in response to '--help'.
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message
+
+MODE must be one of the following:
+
+       clean           remove files from the build directory
+       compile         compile a source file into a libtool object
+       execute         automatically set library path, then run a program
+       finish          complete the installation of libtool libraries
+       install         install libraries or executables
+       link            create a library or an executable
+       uninstall       remove libraries from an installed directory
+
+MODE-ARGS vary depending on the MODE.  When passed as first option,
+'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
+Try '$progname --help --mode=MODE' for a more detailed description of MODE.
+
+When reporting a bug, please describe a test case to reproduce it and
+include the following information:
+
+       host-triplet:   $host
+       shell:          $SHELL
+       compiler:       $LTCC
+       compiler flags: $LTCFLAGS
+       linker:         $LD (gnu? $with_gnu_ld)
+       version:        $progname $scriptversion Debian-2.4.6-14
+       automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
+       autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
+
+Report bugs to <bug-libtool@gnu.org>.
+GNU libtool home page: <http://www.gnu.org/s/libtool/>.
+General help using GNU software: <http://www.gnu.org/gethelp/>."
+    exit 0
+}
+
+
+# func_lo2o OBJECT-NAME
+# ---------------------
+# Transform OBJECT-NAME from a '.lo' suffix to the platform specific
+# object suffix.
+
+lo2o=s/\\.lo\$/.$objext/
+o2lo=s/\\.$objext\$/.lo/
+
+if test yes = "$_G_HAVE_XSI_OPS"; then
+  eval 'func_lo2o ()
+  {
+    case $1 in
+      *.lo) func_lo2o_result=${1%.lo}.$objext ;;
+      *   ) func_lo2o_result=$1               ;;
+    esac
+  }'
+
+  # func_xform LIBOBJ-OR-SOURCE
+  # ---------------------------
+  # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
+  # suffix to a '.lo' libtool-object suffix.
+  eval 'func_xform ()
+  {
+    func_xform_result=${1%.*}.lo
+  }'
+else
+  # ...otherwise fall back to using sed.
+  func_lo2o ()
+  {
+    func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
+  }
+
+  func_xform ()
+  {
+    func_xform_result=`$ECHO "$1" | $SED 's|\.^.*$|.lo|'`
+  }
+fi
+
+
+# func_fatal_configuration ARG...
+# -------------------------------
+# Echo program name prefixed message to standard error, followed by
+# a configuration failure hint, and exit.
+func_fatal_configuration ()
+{
+    func__fatal_error ${1+"$@"} \
+      "See the $PACKAGE documentation for more information." \
+      "Fatal configuration error."
+}
+
+
+# func_config
+# -----------
+# Display the configuration for all the tags in this script.
+func_config ()
+{
+    re_begincf='^# ### BEGIN LIBTOOL'
+    re_endcf='^# ### END LIBTOOL'
+
+    # Default configuration.
+    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
+
+    # Now print the configurations for the tags.
+    for tagname in $taglist; do
+      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
+    done
+
+    exit $?
+}
+
+
+# func_features
+# -------------
+# Display the features supported by this script.
+func_features ()
+{
+    echo "host: $host"
+    if test yes = "$build_libtool_libs"; then
+      echo "enable shared libraries"
+    else
+      echo "disable shared libraries"
+    fi
+    if test yes = "$build_old_libs"; then
+      echo "enable static libraries"
+    else
+      echo "disable static libraries"
+    fi
+
+    exit $?
+}
+
+
+# func_enable_tag TAGNAME
+# -----------------------
+# Verify that TAGNAME is valid, and either flag an error and exit, or
+# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
+# variable here.
+func_enable_tag ()
+{
+    # Global variable:
+    tagname=$1
+
+    re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
+    re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
+    sed_extractcf=/$re_begincf/,/$re_endcf/p
+
+    # Validate tagname.
+    case $tagname in
+      *!-_A-Za-z0-9,/*)
+        func_fatal_error "invalid tag name: $tagname"
+        ;;
+    esac
+
+    # Don't test for the "default" C tag, as we know it's
+    # there but not specially marked.
+    case $tagname in
+        CC) ;;
+    *)
+        if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
+	  taglist="$taglist $tagname"
+
+	  # Evaluate the configuration.  Be careful to quote the path
+	  # and the sed script, to avoid splitting on whitespace, but
+	  # also don't use non-portable quotes within backquotes within
+	  # quotes we have to do it in 2 steps:
+	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
+	  eval "$extractedcf"
+        else
+	  func_error "ignoring unknown tag $tagname"
+        fi
+        ;;
+    esac
+}
+
+
+# func_check_version_match
+# ------------------------
+# Ensure that we are using m4 macros, and libtool script from the same
+# release of libtool.
+func_check_version_match ()
+{
+    if test "$package_revision" != "$macro_revision"; then
+      if test "$VERSION" != "$macro_version"; then
+        if test -z "$macro_version"; then
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from an older release.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        else
+          cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
+$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
+$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
+$progname: and run autoconf again.
+_LT_EOF
+        fi
+      else
+        cat >&2 <<_LT_EOF
+$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
+$progname: but the definition of this LT_INIT comes from revision $macro_revision.
+$progname: You should recreate aclocal.m4 with macros from revision $package_revision
+$progname: of $PACKAGE $VERSION and run autoconf again.
+_LT_EOF
+      fi
+
+      exit $EXIT_MISMATCH
+    fi
+}
+
+
+# libtool_options_prep ARG...
+# -----------------------------
+# Preparation for options parsed by libtool.
+libtool_options_prep ()
+{
+    $debug_mode
+
+    # Option defaults:
+    opt_config=false
+    opt_dlopen=
+    opt_dry_run=false
+    opt_help=false
+    opt_mode=
+    opt_preserve_dup_deps=false
+    opt_quiet=false
+
+    nonopt=
+    preserve_args=
+
+    _G_rc_lt_options_prep=:
+
+    # Shorthand for --mode=foo, only valid as the first argument
+    case $1 in
+    clean|clea|cle|cl)
+      shift; set dummy --mode clean ${1+"$@"}; shift
+      ;;
+    compile|compil|compi|comp|com|co|c)
+      shift; set dummy --mode compile ${1+"$@"}; shift
+      ;;
+    execute|execut|execu|exec|exe|ex|e)
+      shift; set dummy --mode execute ${1+"$@"}; shift
+      ;;
+    finish|finis|fini|fin|fi|f)
+      shift; set dummy --mode finish ${1+"$@"}; shift
+      ;;
+    install|instal|insta|inst|ins|in|i)
+      shift; set dummy --mode install ${1+"$@"}; shift
+      ;;
+    link|lin|li|l)
+      shift; set dummy --mode link ${1+"$@"}; shift
+      ;;
+    uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
+      shift; set dummy --mode uninstall ${1+"$@"}; shift
+      ;;
+    *)
+      _G_rc_lt_options_prep=false
+      ;;
+    esac
+
+    if $_G_rc_lt_options_prep; then
+      # Pass back the list of options.
+      func_quote_for_eval ${1+"$@"}
+      libtool_options_prep_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_lt_options_prep
+}
+func_add_hook func_options_prep libtool_options_prep
+
+
+# libtool_parse_options ARG...
+# ---------------------------------
+# Provide handling for libtool specific options.
+libtool_parse_options ()
+{
+    $debug_cmd
+
+    _G_rc_lt_parse_options=false
+
+    # Perform our own loop to consume as many options as possible in
+    # each iteration.
+    while test $# -gt 0; do
+      _G_match_lt_parse_options=:
+      _G_opt=$1
+      shift
+      case $_G_opt in
+        --dry-run|--dryrun|-n)
+                        opt_dry_run=:
+                        ;;
+
+        --config)       func_config ;;
+
+        --dlopen|-dlopen)
+                        opt_dlopen="${opt_dlopen+$opt_dlopen
+}$1"
+                        shift
+                        ;;
+
+        --preserve-dup-deps)
+                        opt_preserve_dup_deps=: ;;
+
+        --features)     func_features ;;
+
+        --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
+
+        --help)         opt_help=: ;;
+
+        --help-all)     opt_help=': help-all' ;;
+
+        --mode)         test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_mode=$1
+                        case $1 in
+                          # Valid mode arguments:
+                          clean|compile|execute|finish|install|link|relink|uninstall) ;;
+
+                          # Catch anything else as an error
+                          *) func_error "invalid argument for $_G_opt"
+                             exit_cmd=exit
+                             break
+                             ;;
+                        esac
+                        shift
+                        ;;
+
+        --no-silent|--no-quiet)
+                        opt_quiet=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-warnings|--no-warning|--no-warn)
+                        opt_warning=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --no-verbose)
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --silent|--quiet)
+                        opt_quiet=:
+                        opt_verbose=false
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        --tag)          test $# = 0 && func_missing_arg $_G_opt && break
+                        opt_tag=$1
+                        func_append preserve_args " $_G_opt $1"
+                        func_enable_tag "$1"
+                        shift
+                        ;;
+
+        --verbose|-v)   opt_quiet=false
+                        opt_verbose=:
+                        func_append preserve_args " $_G_opt"
+                        ;;
+
+        # An option not handled by this hook function:
+        *)              set dummy "$_G_opt" ${1+"$@"} ; shift
+                        _G_match_lt_parse_options=false
+                        break
+                        ;;
+      esac
+      $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
+    done
+
+    if $_G_rc_lt_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      libtool_parse_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_lt_parse_options
+}
+func_add_hook func_parse_options libtool_parse_options
+
+
+
+# libtool_validate_options ARG...
+# ---------------------------------
+# Perform any sanity checks on option settings and/or unconsumed
+# arguments.
+libtool_validate_options ()
+{
+    # save first non-option argument
+    if test 0 -lt $#; then
+      nonopt=$1
+      shift
+    fi
+
+    # preserve --debug
+    test : = "$debug_cmd" || func_append preserve_args " --debug"
+
+    case $host in
+      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
+      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
+      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
+        # don't eliminate duplications in $postdeps and $predeps
+        opt_duplicate_compiler_generated_deps=:
+        ;;
+      *)
+        opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
+        ;;
+    esac
+
+    $opt_help || {
+      # Sanity checks first:
+      func_check_version_match
+
+      test yes != "$build_libtool_libs" \
+        && test yes != "$build_old_libs" \
+        && func_fatal_configuration "not configured to build any kind of library"
+
+      # Darwin sucks
+      eval std_shrext=\"$shrext_cmds\"
+
+      # Only execute mode is allowed to have -dlopen flags.
+      if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
+        func_error "unrecognized option '-dlopen'"
+        $ECHO "$help" 1>&2
+        exit $EXIT_FAILURE
+      fi
+
+      # Change the help message to a mode-specific one.
+      generic_help=$help
+      help="Try '$progname --help --mode=$opt_mode' for more information."
+    }
+
+    # Pass back the unparsed argument list
+    func_quote_for_eval ${1+"$@"}
+    libtool_validate_options_result=$func_quote_for_eval_result
+}
+func_add_hook func_validate_options libtool_validate_options
+
+
+# Process options as early as possible so that --help and --version
+# can return quickly.
+func_options ${1+"$@"}
+eval set dummy "$func_options_result"; shift
+
+
+
+## ----------- ##
+##    Main.    ##
+## ----------- ##
+
+magic='%%%MAGIC variable%%%'
+magic_exe='%%%MAGIC EXE variable%%%'
+
+# Global variables.
+extracted_archives=
+extracted_serial=0
+
+# If this variable is set in any of the actions, the command in it
+# will be execed at the end.  This prevents here-documents from being
+# left over by shells.
+exec_cmd=
+
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+$1
+_LTECHO_EOF'
+}
+
+# func_generated_by_libtool
+# True iff stdin has been generated by Libtool. This function is only
+# a basic sanity check; it will hardly flush out determined imposters.
+func_generated_by_libtool_p ()
+{
+  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
+# func_lalib_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_lalib_p ()
+{
+    test -f "$1" &&
+      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_lalib_unsafe_p file
+# True iff FILE is a libtool '.la' library or '.lo' object file.
+# This function implements the same check as func_lalib_p without
+# resorting to external programs.  To this end, it redirects stdin and
+# closes it afterwards, without saving the original file descriptor.
+# As a safety measure, use it only where a negative result would be
+# fatal anyway.  Works if 'file' does not exist.
+func_lalib_unsafe_p ()
+{
+    lalib_p=no
+    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
+	for lalib_p_l in 1 2 3 4
+	do
+	    read lalib_p_line
+	    case $lalib_p_line in
+		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
+	    esac
+	done
+	exec 0<&5 5<&-
+    fi
+    test yes = "$lalib_p"
+}
+
+# func_ltwrapper_script_p file
+# True iff FILE is a libtool wrapper script
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_script_p ()
+{
+    test -f "$1" &&
+      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
+}
+
+# func_ltwrapper_executable_p file
+# True iff FILE is a libtool wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_executable_p ()
+{
+    func_ltwrapper_exec_suffix=
+    case $1 in
+    *.exe) ;;
+    *) func_ltwrapper_exec_suffix=.exe ;;
+    esac
+    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
+}
+
+# func_ltwrapper_scriptname file
+# Assumes file is an ltwrapper_executable
+# uses $file to determine the appropriate filename for a
+# temporary ltwrapper_script.
+func_ltwrapper_scriptname ()
+{
+    func_dirname_and_basename "$1" "" "."
+    func_stripname '' '.exe' "$func_basename_result"
+    func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
+}
+
+# func_ltwrapper_p file
+# True iff FILE is a libtool wrapper script or wrapper executable
+# This function is only a basic sanity check; it will hardly flush out
+# determined imposters.
+func_ltwrapper_p ()
+{
+    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
+}
+
+
+# func_execute_cmds commands fail_cmd
+# Execute tilde-delimited COMMANDS.
+# If FAIL_CMD is given, eval that upon failure.
+# FAIL_CMD may read-access the current command in variable CMD!
+func_execute_cmds ()
+{
+    $debug_cmd
+
+    save_ifs=$IFS; IFS='~'
+    for cmd in $1; do
+      IFS=$sp$nl
+      eval cmd=\"$cmd\"
+      IFS=$save_ifs
+      func_show_eval "$cmd" "${2-:}"
+    done
+    IFS=$save_ifs
+}
+
+
+# func_source file
+# Source FILE, adding directory component if necessary.
+# Note that it is not necessary on cygwin/mingw to append a dot to
+# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
+# behavior happens only for exec(3), not for open(2)!  Also, sourcing
+# 'FILE.' does not work on cygwin managed mounts.
+func_source ()
+{
+    $debug_cmd
+
+    case $1 in
+    */* | *\\*)	. "$1" ;;
+    *)		. "./$1" ;;
+    esac
+}
+
+
+# func_resolve_sysroot PATH
+# Replace a leading = in PATH with a sysroot.  Store the result into
+# func_resolve_sysroot_result
+func_resolve_sysroot ()
+{
+  func_resolve_sysroot_result=$1
+  case $func_resolve_sysroot_result in
+  =*)
+    func_stripname '=' '' "$func_resolve_sysroot_result"
+    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
+    ;;
+  esac
+}
+
+# func_replace_sysroot PATH
+# If PATH begins with the sysroot, replace it with = and
+# store the result into func_replace_sysroot_result.
+func_replace_sysroot ()
+{
+  case $lt_sysroot:$1 in
+  ?*:"$lt_sysroot"*)
+    func_stripname "$lt_sysroot" '' "$1"
+    func_replace_sysroot_result='='$func_stripname_result
+    ;;
+  *)
+    # Including no sysroot.
+    func_replace_sysroot_result=$1
+    ;;
+  esac
+}
+
+# func_infer_tag arg
+# Infer tagged configuration to use if any are available and
+# if one wasn't chosen via the "--tag" command line option.
+# Only attempt this if the compiler in the base compile
+# command doesn't match the default compiler.
+# arg is usually of the form 'gcc ...'
+func_infer_tag ()
+{
+    $debug_cmd
+
+    if test -n "$available_tags" && test -z "$tagname"; then
+      CC_quoted=
+      for arg in $CC; do
+	func_append_quoted CC_quoted "$arg"
+      done
+      CC_expanded=`func_echo_all $CC`
+      CC_quoted_expanded=`func_echo_all $CC_quoted`
+      case $@ in
+      # Blanks in the command may have been stripped by the calling shell,
+      # but not from the CC environment variable when configure was run.
+      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
+      # Blanks at the start of $base_compile will cause this to fail
+      # if we don't check for them as well.
+      *)
+	for z in $available_tags; do
+	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
+	    # Evaluate the configuration.
+	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
+	    CC_quoted=
+	    for arg in $CC; do
+	      # Double-quote args containing other shell metacharacters.
+	      func_append_quoted CC_quoted "$arg"
+	    done
+	    CC_expanded=`func_echo_all $CC`
+	    CC_quoted_expanded=`func_echo_all $CC_quoted`
+	    case "$@ " in
+	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
+	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
+	      # The compiler in the base compile command matches
+	      # the one in the tagged configuration.
+	      # Assume this is the tagged configuration we want.
+	      tagname=$z
+	      break
+	      ;;
+	    esac
+	  fi
+	done
+	# If $tagname still isn't set, then no tagged configuration
+	# was found and let the user know that the "--tag" command
+	# line option must be used.
+	if test -z "$tagname"; then
+	  func_echo "unable to infer tagged configuration"
+	  func_fatal_error "specify a tag with '--tag'"
+#	else
+#	  func_verbose "using $tagname tagged configuration"
+	fi
+	;;
+      esac
+    fi
+}
+
+
+
+# func_write_libtool_object output_name pic_name nonpic_name
+# Create a libtool object file (analogous to a ".la" file),
+# but don't create it if we're doing a dry run.
+func_write_libtool_object ()
+{
+    write_libobj=$1
+    if test yes = "$build_libtool_libs"; then
+      write_lobj=\'$2\'
+    else
+      write_lobj=none
+    fi
+
+    if test yes = "$build_old_libs"; then
+      write_oldobj=\'$3\'
+    else
+      write_oldobj=none
+    fi
+
+    $opt_dry_run || {
+      cat >${write_libobj}T <<EOF
+# $write_libobj - a libtool object file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# Name of the PIC object.
+pic_object=$write_lobj
+
+# Name of the non-PIC object
+non_pic_object=$write_oldobj
+
+EOF
+      $MV "${write_libobj}T" "$write_libobj"
+    }
+}
+
+
+##################################################
+# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
+##################################################
+
+# func_convert_core_file_wine_to_w32 ARG
+# Helper function used by file name conversion functions when $build is *nix,
+# and $host is mingw, cygwin, or some other w32 environment. Relies on a
+# correctly configured wine environment available, with the winepath program
+# in $build's $PATH.
+#
+# ARG is the $build file name to be converted to w32 format.
+# Result is available in $func_convert_core_file_wine_to_w32_result, and will
+# be empty on error (or when ARG is empty)
+func_convert_core_file_wine_to_w32 ()
+{
+  $debug_cmd
+
+  func_convert_core_file_wine_to_w32_result=$1
+  if test -n "$1"; then
+    # Unfortunately, winepath does not exit with a non-zero error code, so we
+    # are forced to check the contents of stdout. On the other hand, if the
+    # command is not found, the shell will set an exit code of 127 and print
+    # *an error message* to stdout. So we must check for both error code of
+    # zero AND non-empty stdout, which explains the odd construction:
+    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
+    if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
+      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
+        $SED -e "$sed_naive_backslashify"`
+    else
+      func_convert_core_file_wine_to_w32_result=
+    fi
+  fi
+}
+# end: func_convert_core_file_wine_to_w32
+
+
+# func_convert_core_path_wine_to_w32 ARG
+# Helper function used by path conversion functions when $build is *nix, and
+# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
+# configured wine environment available, with the winepath program in $build's
+# $PATH. Assumes ARG has no leading or trailing path separator characters.
+#
+# ARG is path to be converted from $build format to win32.
+# Result is available in $func_convert_core_path_wine_to_w32_result.
+# Unconvertible file (directory) names in ARG are skipped; if no directory names
+# are convertible, then the result may be empty.
+func_convert_core_path_wine_to_w32 ()
+{
+  $debug_cmd
+
+  # unfortunately, winepath doesn't convert paths, only file names
+  func_convert_core_path_wine_to_w32_result=
+  if test -n "$1"; then
+    oldIFS=$IFS
+    IFS=:
+    for func_convert_core_path_wine_to_w32_f in $1; do
+      IFS=$oldIFS
+      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
+      if test -n "$func_convert_core_file_wine_to_w32_result"; then
+        if test -z "$func_convert_core_path_wine_to_w32_result"; then
+          func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
+        else
+          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
+        fi
+      fi
+    done
+    IFS=$oldIFS
+  fi
+}
+# end: func_convert_core_path_wine_to_w32
+
+
+# func_cygpath ARGS...
+# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
+# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
+# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
+# (2), returns the Cygwin file name or path in func_cygpath_result (input
+# file name or path is assumed to be in w32 format, as previously converted
+# from $build's *nix or MSYS format). In case (3), returns the w32 file name
+# or path in func_cygpath_result (input file name or path is assumed to be in
+# Cygwin format). Returns an empty string on error.
+#
+# ARGS are passed to cygpath, with the last one being the file name or path to
+# be converted.
+#
+# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
+# environment variable; do not put it in $PATH.
+func_cygpath ()
+{
+  $debug_cmd
+
+  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
+    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
+    if test "$?" -ne 0; then
+      # on failure, ensure result is empty
+      func_cygpath_result=
+    fi
+  else
+    func_cygpath_result=
+    func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
+  fi
+}
+#end: func_cygpath
+
+
+# func_convert_core_msys_to_w32 ARG
+# Convert file name or path ARG from MSYS format to w32 format.  Return
+# result in func_convert_core_msys_to_w32_result.
+func_convert_core_msys_to_w32 ()
+{
+  $debug_cmd
+
+  # awkward: cmd appends spaces to result
+  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
+    $SED -e 's/ *$//' -e "$sed_naive_backslashify"`
+}
+#end: func_convert_core_msys_to_w32
+
+
+# func_convert_file_check ARG1 ARG2
+# Verify that ARG1 (a file name in $build format) was converted to $host
+# format in ARG2. Otherwise, emit an error message, but continue (resetting
+# func_to_host_file_result to ARG1).
+func_convert_file_check ()
+{
+  $debug_cmd
+
+  if test -z "$2" && test -n "$1"; then
+    func_error "Could not determine host file name corresponding to"
+    func_error "  '$1'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback:
+    func_to_host_file_result=$1
+  fi
+}
+# end func_convert_file_check
+
+
+# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
+# Verify that FROM_PATH (a path in $build format) was converted to $host
+# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
+# func_to_host_file_result to a simplistic fallback value (see below).
+func_convert_path_check ()
+{
+  $debug_cmd
+
+  if test -z "$4" && test -n "$3"; then
+    func_error "Could not determine the host path corresponding to"
+    func_error "  '$3'"
+    func_error "Continuing, but uninstalled executables may not work."
+    # Fallback.  This is a deliberately simplistic "conversion" and
+    # should not be "improved".  See libtool.info.
+    if test "x$1" != "x$2"; then
+      lt_replace_pathsep_chars="s|$1|$2|g"
+      func_to_host_path_result=`echo "$3" |
+        $SED -e "$lt_replace_pathsep_chars"`
+    else
+      func_to_host_path_result=$3
+    fi
+  fi
+}
+# end func_convert_path_check
+
+
+# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
+# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
+# and appending REPL if ORIG matches BACKPAT.
+func_convert_path_front_back_pathsep ()
+{
+  $debug_cmd
+
+  case $4 in
+  $1 ) func_to_host_path_result=$3$func_to_host_path_result
+    ;;
+  esac
+  case $4 in
+  $2 ) func_append func_to_host_path_result "$3"
+    ;;
+  esac
+}
+# end func_convert_path_front_back_pathsep
+
+
+##################################################
+# $build to $host FILE NAME CONVERSION FUNCTIONS #
+##################################################
+# invoked via '$to_host_file_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# Result will be available in $func_to_host_file_result.
+
+
+# func_to_host_file ARG
+# Converts the file name ARG from $build format to $host format. Return result
+# in func_to_host_file_result.
+func_to_host_file ()
+{
+  $debug_cmd
+
+  $to_host_file_cmd "$1"
+}
+# end func_to_host_file
+
+
+# func_to_tool_file ARG LAZY
+# converts the file name ARG from $build format to toolchain format. Return
+# result in func_to_tool_file_result.  If the conversion in use is listed
+# in (the comma separated) LAZY, no conversion takes place.
+func_to_tool_file ()
+{
+  $debug_cmd
+
+  case ,$2, in
+    *,"$to_tool_file_cmd",*)
+      func_to_tool_file_result=$1
+      ;;
+    *)
+      $to_tool_file_cmd "$1"
+      func_to_tool_file_result=$func_to_host_file_result
+      ;;
+  esac
+}
+# end func_to_tool_file
+
+
+# func_convert_file_noop ARG
+# Copy ARG to func_to_host_file_result.
+func_convert_file_noop ()
+{
+  func_to_host_file_result=$1
+}
+# end func_convert_file_noop
+
+
+# func_convert_file_msys_to_w32 ARG
+# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_file_result.
+func_convert_file_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_msys_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_w32
+
+
+# func_convert_file_cygwin_to_w32 ARG
+# Convert file name ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_file_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
+    # LT_CYGPATH in this case.
+    func_to_host_file_result=`cygpath -m "$1"`
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_cygwin_to_w32
+
+
+# func_convert_file_nix_to_w32 ARG
+# Convert file name ARG from *nix to w32 format.  Requires a wine environment
+# and a working winepath. Returns result in func_to_host_file_result.
+func_convert_file_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_file_wine_to_w32 "$1"
+    func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_w32
+
+
+# func_convert_file_msys_to_cygwin ARG
+# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_file_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    func_convert_core_msys_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_msys_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_msys_to_cygwin
+
+
+# func_convert_file_nix_to_cygwin ARG
+# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
+# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
+# in func_to_host_file_result.
+func_convert_file_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_file_result=$1
+  if test -n "$1"; then
+    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
+    func_convert_core_file_wine_to_w32 "$1"
+    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
+    func_to_host_file_result=$func_cygpath_result
+  fi
+  func_convert_file_check "$1" "$func_to_host_file_result"
+}
+# end func_convert_file_nix_to_cygwin
+
+
+#############################################
+# $build to $host PATH CONVERSION FUNCTIONS #
+#############################################
+# invoked via '$to_host_path_cmd ARG'
+#
+# In each case, ARG is the path to be converted from $build to $host format.
+# The result will be available in $func_to_host_path_result.
+#
+# Path separators are also converted from $build format to $host format.  If
+# ARG begins or ends with a path separator character, it is preserved (but
+# converted to $host format) on output.
+#
+# All path conversion functions are named using the following convention:
+#   file name conversion function    : func_convert_file_X_to_Y ()
+#   path conversion function         : func_convert_path_X_to_Y ()
+# where, for any given $build/$host combination the 'X_to_Y' value is the
+# same.  If conversion functions are added for new $build/$host combinations,
+# the two new functions must follow this pattern, or func_init_to_host_path_cmd
+# will break.
+
+
+# func_init_to_host_path_cmd
+# Ensures that function "pointer" variable $to_host_path_cmd is set to the
+# appropriate value, based on the value of $to_host_file_cmd.
+to_host_path_cmd=
+func_init_to_host_path_cmd ()
+{
+  $debug_cmd
+
+  if test -z "$to_host_path_cmd"; then
+    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
+    to_host_path_cmd=func_convert_path_$func_stripname_result
+  fi
+}
+
+
+# func_to_host_path ARG
+# Converts the path ARG from $build format to $host format. Return result
+# in func_to_host_path_result.
+func_to_host_path ()
+{
+  $debug_cmd
+
+  func_init_to_host_path_cmd
+  $to_host_path_cmd "$1"
+}
+# end func_to_host_path
+
+
+# func_convert_path_noop ARG
+# Copy ARG to func_to_host_path_result.
+func_convert_path_noop ()
+{
+  func_to_host_path_result=$1
+}
+# end func_convert_path_noop
+
+
+# func_convert_path_msys_to_w32 ARG
+# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
+# conversion to w32 is not available inside the cwrapper.  Returns result in
+# func_to_host_path_result.
+func_convert_path_msys_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from ARG.  MSYS
+    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
+    # and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_msys_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_msys_to_w32
+
+
+# func_convert_path_cygwin_to_w32 ARG
+# Convert path ARG from Cygwin to w32 format.  Returns result in
+# func_to_host_file_result.
+func_convert_path_cygwin_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_cygwin_to_w32
+
+
+# func_convert_path_nix_to_w32 ARG
+# Convert path ARG from *nix to w32 format.  Requires a wine environment and
+# a working winepath.  Returns result in func_to_host_file_result.
+func_convert_path_nix_to_w32 ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
+    func_convert_path_check : ";" \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
+  fi
+}
+# end func_convert_path_nix_to_w32
+
+
+# func_convert_path_msys_to_cygwin ARG
+# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
+# Returns result in func_to_host_file_result.
+func_convert_path_msys_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # See func_convert_path_msys_to_w32:
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_msys_to_cygwin
+
+
+# func_convert_path_nix_to_cygwin ARG
+# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
+# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
+# func_to_host_file_result.
+func_convert_path_nix_to_cygwin ()
+{
+  $debug_cmd
+
+  func_to_host_path_result=$1
+  if test -n "$1"; then
+    # Remove leading and trailing path separator characters from
+    # ARG. msys behavior is inconsistent here, cygpath turns them
+    # into '.;' and ';.', and winepath ignores them completely.
+    func_stripname : : "$1"
+    func_to_host_path_tmp1=$func_stripname_result
+    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
+    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
+    func_to_host_path_result=$func_cygpath_result
+    func_convert_path_check : : \
+      "$func_to_host_path_tmp1" "$func_to_host_path_result"
+    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
+  fi
+}
+# end func_convert_path_nix_to_cygwin
+
+
+# func_dll_def_p FILE
+# True iff FILE is a Windows DLL '.def' file.
+# Keep in sync with _LT_DLL_DEF_P in libtool.m4
+func_dll_def_p ()
+{
+  $debug_cmd
+
+  func_dll_def_p_tmp=`$SED -n \
+    -e 's/^	 *//' \
+    -e '/^$;.*$*$/d' \
+    -e 's/^$EXPORTS\|LIBRARY$$	 .*$*$/DEF/p' \
+    -e q \
+    "$1"`
+  test DEF = "$func_dll_def_p_tmp"
+}
+
+
+# func_mode_compile arg...
+func_mode_compile ()
+{
+    $debug_cmd
+
+    # Get the compilation command and the source file.
+    base_compile=
+    srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
+    suppress_opt=yes
+    suppress_output=
+    arg_mode=normal
+    libobj=
+    later=
+    pie_flag=
+
+    for arg
+    do
+      case $arg_mode in
+      arg  )
+	# do not "continue".  Instead, add this to base_compile
+	lastarg=$arg
+	arg_mode=normal
+	;;
+
+      target )
+	libobj=$arg
+	arg_mode=normal
+	continue
+	;;
+
+      normal )
+	# Accept any command-line options.
+	case $arg in
+	-o)
+	  test -n "$libobj" && \
+	    func_fatal_error "you cannot specify '-o' more than once"
+	  arg_mode=target
+	  continue
+	  ;;
+
+	-pie | -fpie | -fPIE)
+          func_append pie_flag " $arg"
+	  continue
+	  ;;
+
+	-shared | -static | -prefer-pic | -prefer-non-pic)
+	  func_append later " $arg"
+	  continue
+	  ;;
+
+	-no-suppress)
+	  suppress_opt=no
+	  continue
+	  ;;
+
+	-Xcompiler)
+	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
+	  continue      #  The current "srcfile" will either be retained or
+	  ;;            #  replaced later.  I would guess that would be a bug.
+
+	-Wc,*)
+	  func_stripname '-Wc,' '' "$arg"
+	  args=$func_stripname_result
+	  lastarg=
+	  save_ifs=$IFS; IFS=,
+	  for arg in $args; do
+	    IFS=$save_ifs
+	    func_append_quoted lastarg "$arg"
+	  done
+	  IFS=$save_ifs
+	  func_stripname ' ' '' "$lastarg"
+	  lastarg=$func_stripname_result
+
+	  # Add the arguments to base_compile.
+	  func_append base_compile " $lastarg"
+	  continue
+	  ;;
+
+	*)
+	  # Accept the current argument as the source file.
+	  # The previous "srcfile" becomes the current argument.
+	  #
+	  lastarg=$srcfile
+	  srcfile=$arg
+	  ;;
+	esac  #  case $arg
+	;;
+      esac    #  case $arg_mode
+
+      # Aesthetically quote the previous argument.
+      func_append_quoted base_compile "$lastarg"
+    done # for arg
+
+    case $arg_mode in
+    arg)
+      func_fatal_error "you must specify an argument for -Xcompile"
+      ;;
+    target)
+      func_fatal_error "you must specify a target with '-o'"
+      ;;
+    *)
+      # Get the name of the library object.
+      test -z "$libobj" && {
+	func_basename "$srcfile"
+	libobj=$func_basename_result
+      }
+      ;;
+    esac
+
+    # Recognize several different file suffixes.
+    # If the user specifies -o file.o, it is replaced with file.lo
+    case $libobj in
+    *.cCFSifmso | \
+    *.ada | *.adb | *.ads | *.asm | \
+    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
+    *.fF09? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
+      func_xform "$libobj"
+      libobj=$func_xform_result
+      ;;
+    esac
+
+    case $libobj in
+    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
+    *)
+      func_fatal_error "cannot determine name of library object from '$libobj'"
+      ;;
+    esac
+
+    func_infer_tag $base_compile
+
+    for arg in $later; do
+      case $arg in
+      -shared)
+	test yes = "$build_libtool_libs" \
+	  || func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	continue
+	;;
+
+      -static)
+	build_libtool_libs=no
+	build_old_libs=yes
+	continue
+	;;
+
+      -prefer-pic)
+	pic_mode=yes
+	continue
+	;;
+
+      -prefer-non-pic)
+	pic_mode=no
+	continue
+	;;
+      esac
+    done
+
+    func_quote_for_eval "$libobj"
+    test "X$libobj" != "X$func_quote_for_eval_result" \
+      && $ECHO "X$libobj" | $GREP '~#^*{};<>?"'"'"'	 &()|`$' \
+      && func_warning "libobj name '$libobj' may not contain shell special characters."
+    func_dirname_and_basename "$obj" "/" ""
+    objname=$func_basename_result
+    xdir=$func_dirname_result
+    lobj=$xdir$objdir/$objname
+
+    test -z "$base_compile" && \
+      func_fatal_help "you must specify a compilation command"
+
+    # Delete any leftover library objects.
+    if test yes = "$build_old_libs"; then
+      removelist="$obj $lobj $libobj ${libobj}T"
+    else
+      removelist="$lobj $libobj ${libobj}T"
+    fi
+
+    # On Cygwin there's no "real" PIC flag so we must build both object types
+    case $host_os in
+    cygwin* | mingw* | pw32* | os2* | cegcc*)
+      pic_mode=default
+      ;;
+    esac
+    if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
+      # non-PIC code in shared libraries is not supported
+      pic_mode=default
+    fi
+
+    # Calculate the filename of the output object if compiler does
+    # not support -o with -c
+    if test no = "$compiler_c_o"; then
+      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.^.*$%%'`.$objext
+      lockfile=$output_obj.lock
+    else
+      output_obj=
+      need_locks=no
+      lockfile=
+    fi
+
+    # Lock this critical section if it is needed
+    # We use this script file to make the link, it avoids creating a new file
+    if test yes = "$need_locks"; then
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    elif test warn = "$need_locks"; then
+      if test -f "$lockfile"; then
+	$ECHO "\
+*** ERROR, $lockfile exists and contains:
+`cat $lockfile 2>/dev/null`
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+      func_append removelist " $output_obj"
+      $ECHO "$srcfile" > "$lockfile"
+    fi
+
+    $opt_dry_run || $RM $removelist
+    func_append removelist " $lockfile"
+    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
+
+    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
+    srcfile=$func_to_tool_file_result
+    func_quote_for_eval "$srcfile"
+    qsrcfile=$func_quote_for_eval_result
+
+    # Only build a PIC object if we are building libtool libraries.
+    if test yes = "$build_libtool_libs"; then
+      # Without this assignment, base_compile gets emptied.
+      fbsd_hideous_sh_bug=$base_compile
+
+      if test no != "$pic_mode"; then
+	command="$base_compile $qsrcfile $pic_flag"
+      else
+	# Don't build PIC code
+	command="$base_compile $qsrcfile"
+      fi
+
+      func_mkdir_p "$xdir$objdir"
+
+      if test -z "$output_obj"; then
+	# Place PIC objects in $objdir
+	func_append command " -o $lobj"
+      fi
+
+      func_show_eval_locale "$command"	\
+          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed, then go on to compile the next one
+      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
+	func_show_eval '$MV "$output_obj" "$lobj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+
+      # Allow error messages only from the first compilation.
+      if test yes = "$suppress_opt"; then
+	suppress_output=' >/dev/null 2>&1'
+      fi
+    fi
+
+    # Only build a position-dependent object if we build old libraries.
+    if test yes = "$build_old_libs"; then
+      if test yes != "$pic_mode"; then
+	# Don't build PIC code
+	command="$base_compile $qsrcfile$pie_flag"
+      else
+	command="$base_compile $qsrcfile $pic_flag"
+      fi
+      if test yes = "$compiler_c_o"; then
+	func_append command " -o $obj"
+      fi
+
+      # Suppress compiler output if we already did a PIC compilation.
+      func_append command "$suppress_output"
+      func_show_eval_locale "$command" \
+        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
+
+      if test warn = "$need_locks" &&
+	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
+	$ECHO "\
+*** ERROR, $lockfile contains:
+`cat $lockfile 2>/dev/null`
+
+but it should contain:
+$srcfile
+
+This indicates that another process is trying to use the same
+temporary object file, and libtool could not work around it because
+your compiler does not support '-c' and '-o' together.  If you
+repeat this compilation, it may succeed, by chance, but you had better
+avoid parallel builds (make -j) in this platform, or get a better
+compiler."
+
+	$opt_dry_run || $RM $removelist
+	exit $EXIT_FAILURE
+      fi
+
+      # Just move the object if needed
+      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
+	func_show_eval '$MV "$output_obj" "$obj"' \
+	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
+      fi
+    fi
+
+    $opt_dry_run || {
+      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
+
+      # Unlock the critical section if it was locked
+      if test no != "$need_locks"; then
+	removelist=$lockfile
+        $RM "$lockfile"
+      fi
+    }
+
+    exit $EXIT_SUCCESS
+}
+
+$opt_help || {
+  test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
+}
+
+func_mode_help ()
+{
+    # We need to display help for each of the modes.
+    case $opt_mode in
+      "")
+        # Generic help is extracted from the usage comments
+        # at the start of this file.
+        func_help
+        ;;
+
+      clean)
+        $ECHO \
+"Usage: $progname OPTION... --mode=clean RM RM-OPTION... FILE...
+
+Remove files from the build directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, object or program, all the files associated
+with it are deleted. Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      compile)
+      $ECHO \
+"Usage: $progname OPTION... --mode=compile COMPILE-COMMAND... SOURCEFILE
+
+Compile a source file into a libtool library object.
+
+This mode accepts the following additional options:
+
+  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
+  -no-suppress      do not suppress compiler output for multiple passes
+  -prefer-pic       try to build PIC objects only
+  -prefer-non-pic   try to build non-PIC objects only
+  -shared           do not build a '.o' file suitable for static linking
+  -static           only build a '.o' file suitable for static linking
+  -Wc,FLAG          pass FLAG directly to the compiler
+
+COMPILE-COMMAND is a command to be used in creating a 'standard' object file
+from the given SOURCEFILE.
+
+The output file name is determined by removing the directory component from
+SOURCEFILE, then substituting the C source code suffix '.c' with the
+library object suffix, '.lo'."
+        ;;
+
+      execute)
+        $ECHO \
+"Usage: $progname OPTION... --mode=execute COMMAND ARGS...
+
+Automatically set library path, then run a program.
+
+This mode accepts the following additional options:
+
+  -dlopen FILE      add the directory containing FILE to the library path
+
+This mode sets the library path environment variable according to '-dlopen'
+flags.
+
+If any of the ARGS are libtool executable wrappers, then they are translated
+into their corresponding uninstalled binary, and any of their required library
+directories are added to the library path.
+
+Then, COMMAND is executed, with ARGS as arguments."
+        ;;
+
+      finish)
+        $ECHO \
+"Usage: $progname OPTION... --mode=finish LIBDIR...
+
+Complete the installation of libtool libraries.
+
+Each LIBDIR is a directory that contains libtool libraries.
+
+The commands that this mode executes may require superuser privileges.  Use
+the '--dry-run' option if you just want to see what would be executed."
+        ;;
+
+      install)
+        $ECHO \
+"Usage: $progname OPTION... --mode=install INSTALL-COMMAND...
+
+Install executables or libraries.
+
+INSTALL-COMMAND is the installation command.  The first component should be
+either the 'install' or 'cp' program.
+
+The following components of INSTALL-COMMAND are treated specially:
+
+  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
+
+The rest of the components are interpreted as arguments to that command (only
+BSD-compatible install options are recognized)."
+        ;;
+
+      link)
+        $ECHO \
+"Usage: $progname OPTION... --mode=link LINK-COMMAND...
+
+Link object files or libraries together to form another library, or to
+create an executable program.
+
+LINK-COMMAND is a command using the C compiler that you would use to create
+a program from several object files.
+
+The following components of LINK-COMMAND are treated specially:
+
+  -all-static       do not do any dynamic linking at all
+  -avoid-version    do not add a version suffix if possible
+  -bindir BINDIR    specify path to binaries directory (for systems where
+                    libraries must be found in the PATH setting at runtime)
+  -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
+  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
+  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
+  -export-symbols SYMFILE
+                    try to export only the symbols listed in SYMFILE
+  -export-symbols-regex REGEX
+                    try to export only the symbols matching REGEX
+  -LLIBDIR          search LIBDIR for required installed libraries
+  -lNAME            OUTPUT-FILE requires the installed library libNAME
+  -module           build a library that can dlopened
+  -no-fast-install  disable the fast-install mode
+  -no-install       link a not-installable executable
+  -no-undefined     declare that a library does not refer to external symbols
+  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
+  -objectlist FILE  use a list of object files found in FILE to specify objects
+  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
+  -precious-files-regex REGEX
+                    don't remove output files matching REGEX
+  -release RELEASE  specify package release information
+  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
+  -R LIBDIR       add LIBDIR to the runtime path of programs and libraries
+  -shared           only do dynamic linking of libtool libraries
+  -shrext SUFFIX    override the standard shared library file extension
+  -static           do not do any dynamic linking of uninstalled libtool libraries
+  -static-libtool-libs
+                    do not do any dynamic linking of libtool libraries
+  -version-info CURRENT:REVISION:AGE
+                    specify library version info each variable defaults to 0
+  -weak LIBNAME     declare that the target provides the LIBNAME interface
+  -Wc,FLAG
+  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
+  -Wl,FLAG
+  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
+  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
+
+All other options (arguments beginning with '-') are ignored.
+
+Every other argument is treated as a filename.  Files ending in '.la' are
+treated as uninstalled libtool libraries, other files are standard or library
+object files.
+
+If the OUTPUT-FILE ends in '.la', then a libtool library is created,
+only library objects ('.lo' files) may be specified, and '-rpath' is
+required, except when creating a convenience library.
+
+If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
+using 'ar' and 'ranlib', or on Windows using 'lib'.
+
+If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
+is created, otherwise an executable program is created."
+        ;;
+
+      uninstall)
+        $ECHO \
+"Usage: $progname OPTION... --mode=uninstall RM RM-OPTION... FILE...
+
+Remove libraries from an installation directory.
+
+RM is the name of the program to use to delete files associated with each FILE
+(typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
+to RM.
+
+If FILE is a libtool library, all the files associated with it are deleted.
+Otherwise, only FILE itself is deleted using RM."
+        ;;
+
+      *)
+        func_fatal_help "invalid operation mode '$opt_mode'"
+        ;;
+    esac
+
+    echo
+    $ECHO "Try '$progname --help' for more information about other modes."
+}
+
+# Now that we've collected a possible --mode arg, show help if necessary
+if $opt_help; then
+  if test : = "$opt_help"; then
+    func_mode_help
+  else
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	func_mode_help
+      done
+    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
+    {
+      func_help noexit
+      for opt_mode in compile link execute install finish uninstall clean; do
+	echo
+	func_mode_help
+      done
+    } |
+    $SED '1d
+      /^When reporting/,/^Report/{
+	H
+	d
+      }
+      $x
+      /information about other modes/d
+      /more detailed .*MODE/d
+      s/^Usage:.*--mode=$^ *$ .*/Description of \1 mode:/'
+  fi
+  exit $?
+fi
+
+
+# func_mode_execute arg...
+func_mode_execute ()
+{
+    $debug_cmd
+
+    # The first argument is the command name.
+    cmd=$nonopt
+    test -z "$cmd" && \
+      func_fatal_help "you must specify a COMMAND"
+
+    # Handle -dlopen flags immediately.
+    for file in $opt_dlopen; do
+      test -f "$file" \
+	|| func_fatal_help "'$file' is not a file"
+
+      dir=
+      case $file in
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$lib' is not a valid libtool archive"
+
+	# Read the libtool library.
+	dlname=
+	library_names=
+	func_source "$file"
+
+	# Skip this library if it cannot be dlopened.
+	if test -z "$dlname"; then
+	  # Warn if it was a shared library.
+	  test -n "$library_names" && \
+	    func_warning "'$file' was not linked with '-export-dynamic'"
+	  continue
+	fi
+
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+
+	if test -f "$dir/$objdir/$dlname"; then
+	  func_append dir "/$objdir"
+	else
+	  if test ! -f "$dir/$dlname"; then
+	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
+	  fi
+	fi
+	;;
+
+      *.lo)
+	# Just add the directory containing the .lo file.
+	func_dirname "$file" "" "."
+	dir=$func_dirname_result
+	;;
+
+      *)
+	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
+	continue
+	;;
+      esac
+
+      # Get the absolute pathname.
+      absdir=`cd "$dir" && pwd`
+      test -n "$absdir" && dir=$absdir
+
+      # Now add the directory to shlibpath_var.
+      if eval "test -z \"\$$shlibpath_var\""; then
+	eval "$shlibpath_var=\"\$dir\""
+      else
+	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
+      fi
+    done
+
+    # This variable tells wrapper scripts just to set shlibpath_var
+    # rather than running their programs.
+    libtool_execute_magic=$magic
+
+    # Check if any of the arguments is a wrapper script.
+    args=
+    for file
+    do
+      case $file in
+      -* | *.la | *.lo ) ;;
+      *)
+	# Do a test to see if this is really a libtool program.
+	if func_ltwrapper_script_p "$file"; then
+	  func_source "$file"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	elif func_ltwrapper_executable_p "$file"; then
+	  func_ltwrapper_scriptname "$file"
+	  func_source "$func_ltwrapper_scriptname_result"
+	  # Transform arg to wrapped name.
+	  file=$progdir/$program
+	fi
+	;;
+      esac
+      # Quote arguments (to preserve shell metacharacters).
+      func_append_quoted args "$file"
+    done
+
+    if $opt_dry_run; then
+      # Display what would be done.
+      if test -n "$shlibpath_var"; then
+	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
+	echo "export $shlibpath_var"
+      fi
+      $ECHO "$cmd$args"
+      exit $EXIT_SUCCESS
+    else
+      if test -n "$shlibpath_var"; then
+	# Export the shlibpath_var.
+	eval "export $shlibpath_var"
+      fi
+
+      # Restore saved environment variables
+      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
+      do
+	eval "if test \"\${save_$lt_var+set}\" = set; then
+                $lt_var=\$save_$lt_var; export $lt_var
+	      else
+		$lt_unset $lt_var
+	      fi"
+      done
+
+      # Now prepare to actually exec the command.
+      exec_cmd=\$cmd$args
+    fi
+}
+
+test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
+
+
+# func_mode_finish arg...
+func_mode_finish ()
+{
+    $debug_cmd
+
+    libs=
+    libdirs=
+    admincmds=
+
+    for opt in "$nonopt" ${1+"$@"}
+    do
+      if test -d "$opt"; then
+	func_append libdirs " $opt"
+
+      elif test -f "$opt"; then
+	if func_lalib_unsafe_p "$opt"; then
+	  func_append libs " $opt"
+	else
+	  func_warning "'$opt' is not a valid libtool archive"
+	fi
+
+      else
+	func_fatal_error "invalid argument '$opt'"
+      fi
+    done
+
+    if test -n "$libs"; then
+      if test -n "$lt_sysroot"; then
+        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
+        sysroot_cmd="s/$ '$$sysroot_regex/\1/g;"
+      else
+        sysroot_cmd=
+      fi
+
+      # Remove sysroot references
+      if $opt_dry_run; then
+        for lib in $libs; do
+          echo "removing references to $lt_sysroot and '=' prefixes from $lib"
+        done
+      else
+        tmpdir=`func_mktempdir`
+        for lib in $libs; do
+	  $SED -e "$sysroot_cmd s/$ '-LR$=/\1/g; s/$ '$=/\1/g" $lib \
+	    > $tmpdir/tmp-la
+	  mv -f $tmpdir/tmp-la $lib
+	done
+        ${RM}r "$tmpdir"
+      fi
+    fi
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      for libdir in $libdirs; do
+	if test -n "$finish_cmds"; then
+	  # Do each command in the finish commands.
+	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
+'"$cmd"'"'
+	fi
+	if test -n "$finish_eval"; then
+	  # Do the single finish_eval.
+	  eval cmds=\"$finish_eval\"
+	  $opt_dry_run || eval "$cmds" || func_append admincmds "
+       $cmds"
+	fi
+      done
+    fi
+
+    # Exit here if they wanted silent mode.
+    $opt_quiet && exit $EXIT_SUCCESS
+
+    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
+      echo "----------------------------------------------------------------------"
+      echo "Libraries have been installed in:"
+      for libdir in $libdirs; do
+	$ECHO "   $libdir"
+      done
+      echo
+      echo "If you ever happen to want to link against installed libraries"
+      echo "in a given directory, LIBDIR, you must either use libtool, and"
+      echo "specify the full pathname of the library, or use the '-LLIBDIR'"
+      echo "flag during linking and do at least one of the following:"
+      if test -n "$shlibpath_var"; then
+	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
+	echo "     during execution"
+      fi
+      if test -n "$runpath_var"; then
+	echo "   - add LIBDIR to the '$runpath_var' environment variable"
+	echo "     during linking"
+      fi
+      if test -n "$hardcode_libdir_flag_spec"; then
+	libdir=LIBDIR
+	eval flag=\"$hardcode_libdir_flag_spec\"
+
+	$ECHO "   - use the '$flag' linker flag"
+      fi
+      if test -n "$admincmds"; then
+	$ECHO "   - have your system administrator run these commands:$admincmds"
+      fi
+      if test -f /etc/ld.so.conf; then
+	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
+      fi
+      echo
+
+      echo "See any operating system documentation about shared libraries for"
+      case $host in
+	solaris2.6789|solaris2.10-9)
+	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
+	  echo "pages."
+	  ;;
+	*)
+	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
+	  ;;
+      esac
+      echo "----------------------------------------------------------------------"
+    fi
+    exit $EXIT_SUCCESS
+}
+
+test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
+
+
+# func_mode_install arg...
+func_mode_install ()
+{
+    $debug_cmd
+
+    # There may be an optional sh(1) argument at the beginning of
+    # install_prog (especially on Windows NT).
+    if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
+       # Allow the use of GNU shtool's install command.
+       case $nonopt in *shtool*) :;; *) false;; esac
+    then
+      # Aesthetically quote it.
+      func_quote_for_eval "$nonopt"
+      install_prog="$func_quote_for_eval_result "
+      arg=$1
+      shift
+    else
+      install_prog=
+      arg=$nonopt
+    fi
+
+    # The real first argument should be the name of the installation program.
+    # Aesthetically quote it.
+    func_quote_for_eval "$arg"
+    func_append install_prog "$func_quote_for_eval_result"
+    install_shared_prog=$install_prog
+    case " $install_prog " in
+      *\\\ /cp\ *) install_cp=: ;;
+      *) install_cp=false ;;
+    esac
+
+    # We need to accept at least all the BSD install flags.
+    dest=
+    files=
+    opts=
+    prev=
+    install_type=
+    isdir=false
+    stripme=
+    no_mode=:
+    for arg
+    do
+      arg2=
+      if test -n "$dest"; then
+	func_append files " $dest"
+	dest=$arg
+	continue
+      fi
+
+      case $arg in
+      -d) isdir=: ;;
+      -f)
+	if $install_cp; then :; else
+	  prev=$arg
+	fi
+	;;
+      -g | -m | -o)
+	prev=$arg
+	;;
+      -s)
+	stripme=" -s"
+	continue
+	;;
+      -*)
+	;;
+      *)
+	# If the previous option needed an argument, then skip it.
+	if test -n "$prev"; then
+	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
+	    arg2=$install_override_mode
+	    no_mode=false
+	  fi
+	  prev=
+	else
+	  dest=$arg
+	  continue
+	fi
+	;;
+      esac
+
+      # Aesthetically quote the argument.
+      func_quote_for_eval "$arg"
+      func_append install_prog " $func_quote_for_eval_result"
+      if test -n "$arg2"; then
+	func_quote_for_eval "$arg2"
+      fi
+      func_append install_shared_prog " $func_quote_for_eval_result"
+    done
+
+    test -z "$install_prog" && \
+      func_fatal_help "you must specify an install program"
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prev' option requires an argument"
+
+    if test -n "$install_override_mode" && $no_mode; then
+      if $install_cp; then :; else
+	func_quote_for_eval "$install_override_mode"
+	func_append install_shared_prog " -m $func_quote_for_eval_result"
+      fi
+    fi
+
+    if test -z "$files"; then
+      if test -z "$dest"; then
+	func_fatal_help "no file or destination specified"
+      else
+	func_fatal_help "you must specify a destination"
+      fi
+    fi
+
+    # Strip any trailing slash from the destination.
+    func_stripname '' '/' "$dest"
+    dest=$func_stripname_result
+
+    # Check to see that the destination is a directory.
+    test -d "$dest" && isdir=:
+    if $isdir; then
+      destdir=$dest
+      destname=
+    else
+      func_dirname_and_basename "$dest" "" "."
+      destdir=$func_dirname_result
+      destname=$func_basename_result
+
+      # Not a directory, so check to see that there is only one file specified.
+      set dummy $files; shift
+      test "$#" -gt 1 && \
+	func_fatal_help "'$dest' is not a directory"
+    fi
+    case $destdir in
+    \\/* | A-Za-z:\\/*) ;;
+    *)
+      for file in $files; do
+	case $file in
+	*.lo) ;;
+	*)
+	  func_fatal_help "'$destdir' must be an absolute directory name"
+	  ;;
+	esac
+      done
+      ;;
+    esac
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    staticlibs=
+    future_libdirs=
+    current_libdirs=
+    for file in $files; do
+
+      # Do each installation.
+      case $file in
+      *.$libext)
+	# Do the static libraries later.
+	func_append staticlibs " $file"
+	;;
+
+      *.la)
+	func_resolve_sysroot "$file"
+	file=$func_resolve_sysroot_result
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$file" \
+	  || func_fatal_help "'$file' is not a valid libtool archive"
+
+	library_names=
+	old_library=
+	relink_command=
+	func_source "$file"
+
+	# Add the libdir to current_libdirs if it is the destination.
+	if test "X$destdir" = "X$libdir"; then
+	  case "$current_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append current_libdirs " $libdir" ;;
+	  esac
+	else
+	  # Note the libdir as a future libdir.
+	  case "$future_libdirs " in
+	  *" $libdir "*) ;;
+	  *) func_append future_libdirs " $libdir" ;;
+	  esac
+	fi
+
+	func_dirname "$file" "/" ""
+	dir=$func_dirname_result
+	func_append dir "$objdir"
+
+	if test -n "$relink_command"; then
+	  # Determine the prefix the user has applied to our future dir.
+	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
+
+	  # Don't allow the user to place us outside of our expected
+	  # location b/c this prevents finding dependent libraries that
+	  # are installed to the same prefix.
+	  # At present, this check doesn't affect windows .dll's that
+	  # are installed into $libdir/../bin (currently, that works fine)
+	  # but it's something to keep an eye on.
+	  test "$inst_prefix_dir" = "$destdir" && \
+	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
+
+	  if test -n "$inst_prefix_dir"; then
+	    # Stick the inst_prefix_dir data into the link command.
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
+	  else
+	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
+	  fi
+
+	  func_warning "relinking '$file'"
+	  func_show_eval "$relink_command" \
+	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
+	fi
+
+	# See the names of the shared library.
+	set dummy $library_names; shift
+	if test -n "$1"; then
+	  realname=$1
+	  shift
+
+	  srcname=$realname
+	  test -n "$relink_command" && srcname=${realname}T
+
+	  # Install the shared library and build the symlinks.
+	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
+	      'exit $?'
+	  tstripme=$stripme
+	  case $host_os in
+	  cygwin* | mingw* | pw32* | cegcc*)
+	    case $realname in
+	    *.dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  os2*)
+	    case $realname in
+	    *_dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
+	  esac
+	  if test -n "$tstripme" && test -n "$striplib"; then
+	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
+	  fi
+
+	  if test "$#" -gt 0; then
+	    # Delete the old symlinks, and create new ones.
+	    # Try 'ln -sf' first, because the 'ln' binary might depend on
+	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
+	    # so we also need to try rm && ln -s.
+	    for linkname
+	    do
+	      test "$linkname" != "$realname" \
+		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
+	    done
+	  fi
+
+	  # Do each command in the postinstall commands.
+	  lib=$destdir/$realname
+	  func_execute_cmds "$postinstall_cmds" 'exit $?'
+	fi
+
+	# Install the pseudo-library for information purposes.
+	func_basename "$file"
+	name=$func_basename_result
+	instname=$dir/${name}i
+	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
+
+	# Maybe install the static library, too.
+	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
+	;;
+
+      *.lo)
+	# Install (i.e. copy) a libtool object.
+
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# Deduce the name of the destination old-style object file.
+	case $destfile in
+	*.lo)
+	  func_lo2o "$destfile"
+	  staticdest=$func_lo2o_result
+	  ;;
+	*.$objext)
+	  staticdest=$destfile
+	  destfile=
+	  ;;
+	*)
+	  func_fatal_help "cannot copy a libtool object to '$destfile'"
+	  ;;
+	esac
+
+	# Install the libtool object if requested.
+	test -n "$destfile" && \
+	  func_show_eval "$install_prog $file $destfile" 'exit $?'
+
+	# Install the old object if enabled.
+	if test yes = "$build_old_libs"; then
+	  # Deduce the name of the old-style object file.
+	  func_lo2o "$file"
+	  staticobj=$func_lo2o_result
+	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
+	fi
+	exit $EXIT_SUCCESS
+	;;
+
+      *)
+	# Figure out destination file name, if it wasn't already specified.
+	if test -n "$destname"; then
+	  destfile=$destdir/$destname
+	else
+	  func_basename "$file"
+	  destfile=$func_basename_result
+	  destfile=$destdir/$destfile
+	fi
+
+	# If the file is missing, and there is a .exe on the end, strip it
+	# because it is most likely a libtool script we actually want to
+	# install
+	stripped_ext=
+	case $file in
+	  *.exe)
+	    if test ! -f "$file"; then
+	      func_stripname '' '.exe' "$file"
+	      file=$func_stripname_result
+	      stripped_ext=.exe
+	    fi
+	    ;;
+	esac
+
+	# Do a test to see if this is really a libtool program.
+	case $host in
+	*cygwin* | *mingw*)
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      wrapper=$func_ltwrapper_scriptname_result
+	    else
+	      func_stripname '' '.exe' "$file"
+	      wrapper=$func_stripname_result
+	    fi
+	    ;;
+	*)
+	    wrapper=$file
+	    ;;
+	esac
+	if func_ltwrapper_script_p "$wrapper"; then
+	  notinst_deplibs=
+	  relink_command=
+
+	  func_source "$wrapper"
+
+	  # Check the variables that should have been set.
+	  test -z "$generated_by_libtool_version" && \
+	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
+
+	  finalize=:
+	  for lib in $notinst_deplibs; do
+	    # Check to see that each library is installed.
+	    libdir=
+	    if test -f "$lib"; then
+	      func_source "$lib"
+	    fi
+	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
+	    if test -n "$libdir" && test ! -f "$libfile"; then
+	      func_warning "'$lib' has not been installed in '$libdir'"
+	      finalize=false
+	    fi
+	  done
+
+	  relink_command=
+	  func_source "$wrapper"
+
+	  outputname=
+	  if test no = "$fast_install" && test -n "$relink_command"; then
+	    $opt_dry_run || {
+	      if $finalize; then
+	        tmpdir=`func_mktempdir`
+		func_basename "$file$stripped_ext"
+		file=$func_basename_result
+	        outputname=$tmpdir/$file
+	        # Replace the output file specification.
+	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
+
+	        $opt_quiet || {
+	          func_quote_for_expand "$relink_command"
+		  eval "func_echo $func_quote_for_expand_result"
+	        }
+	        if eval "$relink_command"; then :
+	          else
+		  func_error "error: relink '$file' with the above command before installing it"
+		  $opt_dry_run || ${RM}r "$tmpdir"
+		  continue
+	        fi
+	        file=$outputname
+	      else
+	        func_warning "cannot relink '$file'"
+	      fi
+	    }
+	  else
+	    # Install the binary that we compiled earlier.
+	    file=`$ECHO "$file$stripped_ext" | $SED "s%$^/*$$%$objdir/\1%"`
+	  fi
+	fi
+
+	# remove .exe since cygwin /usr/bin/install will append another
+	# one anyway
+	case $install_prog,$host in
+	*/usr/bin/install*,*cygwin*)
+	  case $file:$destfile in
+	  *.exe:*.exe)
+	    # this is ok
+	    ;;
+	  *.exe:*)
+	    destfile=$destfile.exe
+	    ;;
+	  *:*.exe)
+	    func_stripname '' '.exe' "$destfile"
+	    destfile=$func_stripname_result
+	    ;;
+	  esac
+	  ;;
+	esac
+	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
+	$opt_dry_run || if test -n "$outputname"; then
+	  ${RM}r "$tmpdir"
+	fi
+	;;
+      esac
+    done
+
+    for file in $staticlibs; do
+      func_basename "$file"
+      name=$func_basename_result
+
+      # Set up the ranlib parameters.
+      oldlib=$destdir/$name
+      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+      tool_oldlib=$func_to_tool_file_result
+
+      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
+
+      if test -n "$stripme" && test -n "$old_striplib"; then
+	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
+      fi
+
+      # Do each command in the postinstall commands.
+      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
+    done
+
+    test -n "$future_libdirs" && \
+      func_warning "remember to run '$progname --finish$future_libdirs'"
+
+    if test -n "$current_libdirs"; then
+      # Maybe just do a dry run.
+      $opt_dry_run && current_libdirs=" -n$current_libdirs"
+      exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
+    else
+      exit $EXIT_SUCCESS
+    fi
+}
+
+test install = "$opt_mode" && func_mode_install ${1+"$@"}
+
+
+# func_generate_dlsyms outputname originator pic_p
+# Extract symbols from dlprefiles and create ${outputname}S.o with
+# a dlpreopen symbol table.
+func_generate_dlsyms ()
+{
+    $debug_cmd
+
+    my_outputname=$1
+    my_originator=$2
+    my_pic_p=${3-false}
+    my_prefix=`$ECHO "$my_originator" | $SED 's%^a-zA-Z0-9%_%g'`
+    my_dlsyms=
+
+    if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+      if test -n "$NM" && test -n "$global_symbol_pipe"; then
+	my_dlsyms=${my_outputname}S.c
+      else
+	func_error "not configured to extract global symbols from dlpreopened files"
+      fi
+    fi
+
+    if test -n "$my_dlsyms"; then
+      case $my_dlsyms in
+      "") ;;
+      *.c)
+	# Discover the nlist of each of the dlfiles.
+	nlist=$output_objdir/$my_outputname.nm
+
+	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
+
+	# Parse the name list into a source file.
+	func_verbose "creating $output_objdir/$my_dlsyms"
+
+	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
+/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
+/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
+
+#ifdef __cplusplus
+extern \"C\" {
+#endif
+
+#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
+#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
+#endif
+
+/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
+#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
+/* DATA imports from DLLs on WIN32 can't be const, because runtime
+   relocations are performed -- see ld's documentation on pseudo-relocs.  */
+# define LT_DLSYM_CONST
+#elif defined __osf__
+/* This system does not cope well with relocations in const data.  */
+# define LT_DLSYM_CONST
+#else
+# define LT_DLSYM_CONST const
+#endif
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* External symbol declarations for the compiler. */\
+"
+
+	if test yes = "$dlself"; then
+	  func_verbose "generating symbol list for '$output'"
+
+	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
+
+	  # Add our own program objects to the symbol list.
+	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	  for progfile in $progfiles; do
+	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
+	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
+	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
+	  done
+
+	  if test -n "$exclude_expsyms"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  if test -n "$export_symbols_regex"; then
+	    $opt_dry_run || {
+	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	    }
+	  fi
+
+	  # Prepare the list of exported symbols
+	  if test -z "$export_symbols"; then
+	    export_symbols=$output_objdir/$outputname.exp
+	    $opt_dry_run || {
+	      $RM $export_symbols
+	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* $.*$$/\1/p' "'< "$nlist" > "$export_symbols"'
+	      case $host in
+	      *cygwin* | *mingw* | *cegcc* )
+                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
+	        ;;
+	      esac
+	    }
+	  else
+	    $opt_dry_run || {
+	      eval "$SED -e 's/$.*^$$/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
+	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
+	      eval '$MV "$nlist"T "$nlist"'
+	      case $host in
+	        *cygwin* | *mingw* | *cegcc* )
+	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
+	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
+	          ;;
+	      esac
+	    }
+	  fi
+	fi
+
+	for dlprefile in $dlprefiles; do
+	  func_verbose "extracting global C symbols from '$dlprefile'"
+	  func_basename "$dlprefile"
+	  name=$func_basename_result
+          case $host in
+	    *cygwin* | *mingw* | *cegcc* )
+	      # if an import library, we need to obtain dlname
+	      if func_win32_import_lib_p "$dlprefile"; then
+	        func_tr_sh "$dlprefile"
+	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
+	        dlprefile_dlbasename=
+	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
+	          # Use subshell, to avoid clobbering current variable values
+	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
+	          if test -n "$dlprefile_dlname"; then
+	            func_basename "$dlprefile_dlname"
+	            dlprefile_dlbasename=$func_basename_result
+	          else
+	            # no lafile. user explicitly requested -dlpreopen <import library>.
+	            $sharedlib_from_linklib_cmd "$dlprefile"
+	            dlprefile_dlbasename=$sharedlib_from_linklib_result
+	          fi
+	        fi
+	        $opt_dry_run || {
+	          if test -n "$dlprefile_dlbasename"; then
+	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
+	          else
+	            func_warning "Could not compute DLL name from $name"
+	            eval '$ECHO ": $name " >> "$nlist"'
+	          fi
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
+	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
+	        }
+	      else # not an import lib
+	        $opt_dry_run || {
+	          eval '$ECHO ": $name " >> "$nlist"'
+	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	        }
+	      fi
+	    ;;
+	    *)
+	      $opt_dry_run || {
+	        eval '$ECHO ": $name " >> "$nlist"'
+	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
+	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
+	      }
+	    ;;
+          esac
+	done
+
+	$opt_dry_run || {
+	  # Make sure we have at least an empty file.
+	  test -f "$nlist" || : > "$nlist"
+
+	  if test -n "$exclude_expsyms"; then
+	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
+	    $MV "$nlist"T "$nlist"
+	  fi
+
+	  # Try sorting and uniquifying the output.
+	  if $GREP -v "^: " < "$nlist" |
+	      if sort -k 3 </dev/null >/dev/null 2>&1; then
+		sort -k 3
+	      else
+		sort +2
+	      fi |
+	      uniq > "$nlist"S; then
+	    :
+	  else
+	    $GREP -v "^: " < "$nlist" > "$nlist"S
+	  fi
+
+	  if test -f "$nlist"S; then
+	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
+	  else
+	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
+	  fi
+
+	  func_show_eval '$RM "${nlist}I"'
+	  if test -n "$global_symbol_to_import"; then
+	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
+	  fi
+
+	  echo >> "$output_objdir/$my_dlsyms" "\
+
+/* The mapping between symbol names and symbols.  */
+typedef struct {
+  const char *name;
+  void *address;
+} lt_dlsymlist;
+extern LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols;\
+"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+static void lt_syminit(void)
+{
+  LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
+  for (; symbol->name; ++symbol)
+    {"
+	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
+	    echo >> "$output_objdir/$my_dlsyms" "\
+    }
+}"
+	  fi
+	  echo >> "$output_objdir/$my_dlsyms" "\
+LT_DLSYM_CONST lt_dlsymlist
+lt_${my_prefix}_LTX_preloaded_symbols =
+{ {\"$my_originator\", (void *) 0},"
+
+	  if test -s "$nlist"I; then
+	    echo >> "$output_objdir/$my_dlsyms" "\
+  {\"@INIT@\", (void *) &lt_syminit},"
+	  fi
+
+	  case $need_lib_prefix in
+	  no)
+	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  *)
+	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
+	    ;;
+	  esac
+	  echo >> "$output_objdir/$my_dlsyms" "\
+  {0, (void *) 0}
+};
+
+/* This works around a problem in FreeBSD linker */
+#ifdef FREEBSD_WORKAROUND
+static const void *lt_preloaded_setup() {
+  return lt_${my_prefix}_LTX_preloaded_symbols;
+}
+#endif
+
+#ifdef __cplusplus
+}
+#endif\
+"
+	} # !$opt_dry_run
+
+	pic_flag_for_symtable=
+	case "$compile_command " in
+	*" -static "*) ;;
+	*)
+	  case $host in
+	  # compiling the symbol table file with pic_flag works around
+	  # a FreeBSD bug that causes programs to crash when -lm is
+	  # linked before any other PIC object.  But we must not use
+	  # pic_flag when linking with -static.  The problem exists in
+	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
+	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
+	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
+	  *-*-hpux*)
+	    pic_flag_for_symtable=" $pic_flag"  ;;
+	  *)
+	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
+	    ;;
+	  esac
+	  ;;
+	esac
+	symtab_cflags=
+	for arg in $LTCFLAGS; do
+	  case $arg in
+	  -pie | -fpie | -fPIE) ;;
+	  *) func_append symtab_cflags " $arg" ;;
+	  esac
+	done
+
+	# Now compile the dynamic symbol file.
+	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
+
+	# Clean up the generated files.
+	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
+
+	# Transform the symbol file into the correct name.
+	symfileobj=$output_objdir/${my_outputname}S.$objext
+	case $host in
+	*cygwin* | *mingw* | *cegcc* )
+	  if test -f "$output_objdir/$my_outputname.def"; then
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
+	  else
+	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  fi
+	  ;;
+	*)
+	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
+	  ;;
+	esac
+	;;
+      *)
+	func_fatal_error "unknown suffix for '$my_dlsyms'"
+	;;
+      esac
+    else
+      # We keep going just in case the user didn't refer to
+      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
+      # really was required.
+
+      # Nullify the symbol file.
+      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
+      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
+    fi
+}
+
+# func_cygming_gnu_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is a GNU/binutils-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_gnu_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_A-Za-z0-9_+_adl*|A-Za-z0-9_+_adl*_iname)$'`
+  test -n "$func_cygming_gnu_implib_tmp"
+}
+
+# func_cygming_ms_implib_p ARG
+# This predicate returns with zero status (TRUE) if
+# ARG is an MS-style import library. Returns
+# with nonzero status (FALSE) otherwise.
+func_cygming_ms_implib_p ()
+{
+  $debug_cmd
+
+  func_to_tool_file "$1" func_convert_file_msys_to_w32
+  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
+  test -n "$func_cygming_ms_implib_tmp"
+}
+
+# func_win32_libid arg
+# return the library type of file 'arg'
+#
+# Need a lot of goo to handle *both* DLLs and import libs
+# Has to be a shell function in order to 'eat' the argument
+# that is supplied when $file_magic_command is called.
+# Despite the name, also deal with 64 bit binaries.
+func_win32_libid ()
+{
+  $debug_cmd
+
+  win32_libid_type=unknown
+  win32_fileres=`file -L $1 2>/dev/null`
+  case $win32_fileres in
+  *ar\ archive\ import\ library*) # definitely import
+    win32_libid_type="x86 archive import"
+    ;;
+  *ar\ archive*) # could be an import, or static
+    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
+    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
+       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
+      case $nm_interface in
+      "MS dumpbin")
+	if func_cygming_ms_implib_p "$1" ||
+	   func_cygming_gnu_implib_p "$1"
+	then
+	  win32_nmres=import
+	else
+	  win32_nmres=
+	fi
+	;;
+      *)
+	func_to_tool_file "$1" func_convert_file_msys_to_w32
+	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
+	  $SED -n -e '
+	    1,100{
+		/ I /{
+		    s|.*|import|
+		    p
+		    q
+		}
+	    }'`
+	;;
+      esac
+      case $win32_nmres in
+      import*)  win32_libid_type="x86 archive import";;
+      *)        win32_libid_type="x86 archive static";;
+      esac
+    fi
+    ;;
+  *DLL*)
+    win32_libid_type="x86 DLL"
+    ;;
+  *executable*) # but shell scripts are "executable" too...
+    case $win32_fileres in
+    *MS\ Windows\ PE\ Intel*)
+      win32_libid_type="x86 DLL"
+      ;;
+    esac
+    ;;
+  esac
+  $ECHO "$win32_libid_type"
+}
+
+# func_cygming_dll_for_implib ARG
+#
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib ()
+{
+  $debug_cmd
+
+  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
+}
+
+# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
+#
+# The is the core of a fallback implementation of a
+# platform-specific function to extract the name of the
+# DLL associated with the specified import library LIBNAME.
+#
+# SECTION_NAME is either .idata$6 or .idata$7, depending
+# on the platform and compiler that created the implib.
+#
+# Echos the name of the DLL associated with the
+# specified import library.
+func_cygming_dll_for_implib_fallback_core ()
+{
+  $debug_cmd
+
+  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
+  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
+    $SED '/^Contents of section '"$match_literal"':/{
+      # Place marker at beginning of archive member dllname section
+      s/.*/====MARK====/
+      p
+      d
+    }
+    # These lines can sometimes be longer than 43 characters, but
+    # are always uninteresting
+    /:	 *file format pei\{,1\}-/d
+    /^In archive ^:*:/d
+    # Ensure marker is printed
+    /^====MARK====/p
+    # Remove all lines with less than 43 characters
+    /^.\{43\}/!d
+    # From remaining lines, remove first 43 characters
+    s/^.\{43\}//' |
+    $SED -n '
+      # Join marker and all lines until next marker into a single line
+      /^====MARK====/ b para
+      H
+      $ b para
+      b
+      :para
+      x
+      s/\n//g
+      # Remove the marker
+      s/^====MARK====//
+      # Remove trailing dots and whitespace
+      s/\. \t*$//
+      # Print
+      /./p' |
+    # we now have a list, one entry per line, of the stringified
+    # contents of the appropriate section of all members of the
+    # archive that possess that section. Heuristic: eliminate
+    # all those that have a first or second character that is
+    # a '.' (that is, objdump's representation of an unprintable
+    # character.) This should work for all archives with less than
+    # 0x302f exports -- but will fail for DLLs whose name actually
+    # begins with a literal '.' or a single character followed by
+    # a '.'.
+    #
+    # Of those that remain, print the first one.
+    $SED -e '/^\./d;/^.\./d;q'
+}
+
+# func_cygming_dll_for_implib_fallback ARG
+# Platform-specific function to extract the
+# name of the DLL associated with the specified
+# import library ARG.
+#
+# This fallback implementation is for use when $DLLTOOL
+# does not support the --identify-strict option.
+# Invoked by eval'ing the libtool variable
+#    $sharedlib_from_linklib_cmd
+# Result is available in the variable
+#    $sharedlib_from_linklib_result
+func_cygming_dll_for_implib_fallback ()
+{
+  $debug_cmd
+
+  if func_cygming_gnu_implib_p "$1"; then
+    # binutils import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
+  elif func_cygming_ms_implib_p "$1"; then
+    # ms-generated import library
+    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
+  else
+    # unknown
+    sharedlib_from_linklib_result=
+  fi
+}
+
+
+# func_extract_an_archive dir oldlib
+func_extract_an_archive ()
+{
+    $debug_cmd
+
+    f_ex_an_ar_dir=$1; shift
+    f_ex_an_ar_oldlib=$1
+    if test yes = "$lock_old_archive_extraction"; then
+      lockfile=$f_ex_an_ar_oldlib.lock
+      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
+	func_echo "Waiting for $lockfile to be removed"
+	sleep 2
+      done
+    fi
+    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
+		   'stat=$?; rm -f "$lockfile"; exit $stat'
+    if test yes = "$lock_old_archive_extraction"; then
+      $opt_dry_run || rm -f "$lockfile"
+    fi
+    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
+     :
+    else
+      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
+    fi
+}
+
+
+# func_extract_archives gentop oldlib ...
+func_extract_archives ()
+{
+    $debug_cmd
+
+    my_gentop=$1; shift
+    my_oldlibs=${1+"$@"}
+    my_oldobjs=
+    my_xlib=
+    my_xabs=
+    my_xdir=
+
+    for my_xlib in $my_oldlibs; do
+      # Extract the objects.
+      case $my_xlib in
+	\\/* | A-Za-z:\\/*) my_xabs=$my_xlib ;;
+	*) my_xabs=`pwd`"/$my_xlib" ;;
+      esac
+      func_basename "$my_xlib"
+      my_xlib=$func_basename_result
+      my_xlib_u=$my_xlib
+      while :; do
+        case " $extracted_archives " in
+	*" $my_xlib_u "*)
+	  func_arith $extracted_serial + 1
+	  extracted_serial=$func_arith_result
+	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
+	*) break ;;
+	esac
+      done
+      extracted_archives="$extracted_archives $my_xlib_u"
+      my_xdir=$my_gentop/$my_xlib_u
+
+      func_mkdir_p "$my_xdir"
+
+      case $host in
+      *-darwin*)
+	func_verbose "Extracting $my_xabs"
+	# Do not bother doing anything if just a dry run
+	$opt_dry_run || {
+	  darwin_orig_dir=`pwd`
+	  cd $my_xdir || exit $?
+	  darwin_archive=$my_xabs
+	  darwin_curdir=`pwd`
+	  func_basename "$darwin_archive"
+	  darwin_base_archive=$func_basename_result
+	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
+	  if test -n "$darwin_arches"; then
+	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
+	    darwin_arch=
+	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
+	    for darwin_arch in  $darwin_arches; do
+	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
+	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
+	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
+	      cd "$darwin_curdir"
+	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
+	    done # $darwin_arches
+            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
+	    darwin_file=
+	    darwin_files=
+	    for darwin_file in $darwin_filelist; do
+	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
+	      $LIPO -create -output "$darwin_file" $darwin_files
+	    done # $darwin_filelist
+	    $RM -rf unfat-$$
+	    cd "$darwin_orig_dir"
+	  else
+	    cd $darwin_orig_dir
+	    func_extract_an_archive "$my_xdir" "$my_xabs"
+	  fi # $darwin_arches
+	} # !$opt_dry_run
+	;;
+      *)
+        func_extract_an_archive "$my_xdir" "$my_xabs"
+	;;
+      esac
+      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
+    done
+
+    func_extract_archives_result=$my_oldobjs
+}
+
+
+# func_emit_wrapper arg=no
+#
+# Emit a libtool wrapper script on stdout.
+# Don't directly open a file because we may want to
+# incorporate the script contents within a cygwin/mingw
+# wrapper executable.  Must ONLY be called from within
+# func_mode_link because it depends on a number of variables
+# set therein.
+#
+# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
+# variable will take.  If 'yes', then the emitted script
+# will assume that the directory where it is stored is
+# the $objdir directory.  This is a cygwin/mingw-specific
+# behavior.
+func_emit_wrapper ()
+{
+	func_emit_wrapper_arg1=${1-no}
+
+	$ECHO "\
+#! $SHELL
+
+# $output - temporary wrapper script for $objdir/$outputname
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# The $output program cannot be directly executed until all the libtool
+# libraries that it depends on are installed.
+#
+# This wrapper script should never be moved out of the build directory.
+# If it is, it will not operate correctly.
+
+# Sed substitution that helps us do robust quoting.  It backslashifies
+# metacharacters that are still active within double-quoted strings.
+sed_quote_subst='$sed_quote_subst'
+
+# Be Bourne compatible
+if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
+  emulate sh
+  NULLCMD=:
+  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
+  # is contrary to our usage.  Disable this feature.
+  alias -g '\${1+\"\$@\"}'='\"\$@\"'
+  setopt NO_GLOB_SUBST
+else
+  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
+fi
+BIN_SH=xpg4; export BIN_SH # for Tru64
+DUALCASE=1; export DUALCASE # for MKS sh
+
+# The HP-UX ksh and POSIX shell print the target directory to stdout
+# if CDPATH is set.
+(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
+
+relink_command=\"$relink_command\"
+
+# This environment variable determines our operation mode.
+if test \"\$libtool_install_magic\" = \"$magic\"; then
+  # install mode needs the following variables:
+  generated_by_libtool_version='$macro_version'
+  notinst_deplibs='$notinst_deplibs'
+else
+  # When we are sourced in execute mode, \$file and \$ECHO are already set.
+  if test \"\$libtool_execute_magic\" != \"$magic\"; then
+    file=\"\$0\""
+
+    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
+    $ECHO "\
+
+# A function that is used when there is no print builtin or printf.
+func_fallback_echo ()
+{
+  eval 'cat <<_LTECHO_EOF
+\$1
+_LTECHO_EOF'
+}
+    ECHO=\"$qECHO\"
+  fi
+
+# Very basic option parsing. These options are (a) specific to
+# the libtool wrapper, (b) are identical between the wrapper
+# /script/ and the wrapper /executable/ that is used only on
+# windows platforms, and (c) all begin with the string "--lt-"
+# (application programs are unlikely to have options that match
+# this pattern).
+#
+# There are only two supported options: --lt-debug and
+# --lt-dump-script. There is, deliberately, no --lt-help.
+#
+# The first argument to this parsing function should be the
+# script's $0 value, followed by "$@".
+lt_option_debug=
+func_parse_lt_options ()
+{
+  lt_script_arg0=\$0
+  shift
+  for lt_opt
+  do
+    case \"\$lt_opt\" in
+    --lt-debug) lt_option_debug=1 ;;
+    --lt-dump-script)
+        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/^/*$%%'\`
+        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
+        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
+        cat \"\$lt_dump_D/\$lt_dump_F\"
+        exit 0
+      ;;
+    --lt-*)
+        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
+        exit 1
+      ;;
+    esac
+  done
+
+  # Print the debug banner immediately:
+  if test -n \"\$lt_option_debug\"; then
+    echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
+  fi
+}
+
+# Used when --lt-debug. Prints its arguments to stdout
+# (redirection is the responsibility of the caller)
+func_lt_dump_args ()
+{
+  lt_dump_args_N=1;
+  for lt_arg
+  do
+    \$ECHO \"$outputname:$output:\$LINENO: newargv\$lt_dump_args_N: \$lt_arg\"
+    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
+  done
+}
+
+# Core function for launching the target application
+func_exec_program_core ()
+{
+"
+  case $host in
+  # Backslashes separate directories on plain windows
+  *-*-mingw | *-*-os2* | *-cegcc*)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv0: \$progdir\\\\\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
+"
+    ;;
+
+  *)
+    $ECHO "\
+      if test -n \"\$lt_option_debug\"; then
+        \$ECHO \"$outputname:$output:\$LINENO: newargv0: \$progdir/\$program\" 1>&2
+        func_lt_dump_args \${1+\"\$@\"} 1>&2
+      fi
+      exec \"\$progdir/\$program\" \${1+\"\$@\"}
+"
+    ;;
+  esac
+  $ECHO "\
+      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
+      exit 1
+}
+
+# A function to encapsulate launching the target application
+# Strips options in the --lt-* namespace from \$@ and
+# launches target application with the remaining arguments.
+func_exec_program ()
+{
+  case \" \$* \" in
+  *\\ --lt-*)
+    for lt_wr_arg
+    do
+      case \$lt_wr_arg in
+      --lt-*) ;;
+      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
+      esac
+      shift
+    done ;;
+  esac
+  func_exec_program_core \${1+\"\$@\"}
+}
+
+  # Parse options
+  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
+
+  # Find the directory that this script lives in.
+  thisdir=\`\$ECHO \"\$file\" | $SED 's%/^/*$%%'\`
+  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
+
+  # Follow symbolic links until we get to the real thisdir.
+  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
+  while test -n \"\$file\"; do
+    destdir=\`\$ECHO \"\$file\" | $SED 's%/^/*\$%%'\`
+
+    # If there was a directory component, then change thisdir.
+    if test \"x\$destdir\" != \"x\$file\"; then
+      case \"\$destdir\" in
+      \\\\/* | A-Za-z:\\\\/*) thisdir=\"\$destdir\" ;;
+      *) thisdir=\"\$thisdir/\$destdir\" ;;
+      esac
+    fi
+
+    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
+    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
+  done
+
+  # Usually 'no', except on cygwin/mingw when embedded into
+  # the cwrapper.
+  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
+  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
+    # special case for '.'
+    if test \"\$thisdir\" = \".\"; then
+      thisdir=\`pwd\`
+    fi
+    # remove .libs from thisdir
+    case \"\$thisdir\" in
+    *\\\\/$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%\\\\/^\\\\/*$%%'\` ;;
+    $objdir )   thisdir=. ;;
+    esac
+  fi
+
+  # Try to get the absolute directory name.
+  absdir=\`cd \"\$thisdir\" && pwd\`
+  test -n \"\$absdir\" && thisdir=\"\$absdir\"
+"
+
+	if test yes = "$fast_install"; then
+	  $ECHO "\
+  program=lt-'$outputname'$exeext
+  progdir=\"\$thisdir/$objdir\"
+
+  if test ! -f \"\$progdir/\$program\" ||
+     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
+       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
+
+    file=\"\$\$-\$program\"
+
+    if test ! -d \"\$progdir\"; then
+      $MKDIR \"\$progdir\"
+    else
+      $RM \"\$progdir/\$file\"
+    fi"
+
+	  $ECHO "\
+
+    # relink executable if necessary
+    if test -n \"\$relink_command\"; then
+      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
+      else
+	\$ECHO \"\$relink_command_output\" >&2
+	$RM \"\$progdir/\$file\"
+	exit 1
+      fi
+    fi
+
+    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
+    { $RM \"\$progdir/\$program\";
+      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
+    $RM \"\$progdir/\$file\"
+  fi"
+	else
+	  $ECHO "\
+  program='$outputname'
+  progdir=\"\$thisdir/$objdir\"
+"
+	fi
+
+	$ECHO "\
+
+  if test -f \"\$progdir/\$program\"; then"
+
+	# fixup the dll searchpath if we need to.
+	#
+	# Fix the DLL searchpath if we need to.  Do this before prepending
+	# to shlibpath, because on Windows, both are PATH and uninstalled
+	# libraries must come first.
+	if test -n "$dllsearchpath"; then
+	  $ECHO "\
+    # Add the dll search path components to the executable PATH
+    PATH=$dllsearchpath:\$PATH
+"
+	fi
+
+	# Export our shlibpath_var if we have one.
+	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+	  $ECHO "\
+    # Add our own library path to $shlibpath_var
+    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
+
+    # Some systems cannot cope with colon-terminated $shlibpath_var
+    # The second colon is a workaround for a bug in BeOS R4 sed
+    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
+
+    export $shlibpath_var
+"
+	fi
+
+	$ECHO "\
+    if test \"\$libtool_execute_magic\" != \"$magic\"; then
+      # Run the actual program with our arguments.
+      func_exec_program \${1+\"\$@\"}
+    fi
+  else
+    # The program doesn't exist.
+    \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
+    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
+    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
+    exit 1
+  fi
+fi\
+"
+}
+
+
+# func_emit_cwrapperexe_src
+# emit the source code for a wrapper executable on stdout
+# Must ONLY be called from within func_mode_link because
+# it depends on a number of variable set therein.
+func_emit_cwrapperexe_src ()
+{
+	cat <<EOF
+
+/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
+   Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+
+   The $output program cannot be directly executed until all the libtool
+   libraries that it depends on are installed.
+
+   This wrapper executable should never be moved out of the build directory.
+   If it is, it will not operate correctly.
+*/
+EOF
+	    cat <<"EOF"
+#ifdef _MSC_VER
+# define _CRT_SECURE_NO_DEPRECATE 1
+#endif
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef _MSC_VER
+# include <direct.h>
+# include <process.h>
+# include <io.h>
+#else
+# include <unistd.h>
+# include <stdint.h>
+# ifdef __CYGWIN__
+#  include <io.h>
+# endif
+#endif
+#include <malloc.h>
+#include <stdarg.h>
+#include <assert.h>
+#include <string.h>
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+
+#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
+
+/* declarations of non-ANSI functions */
+#if defined __MINGW32__
+# ifdef __STRICT_ANSI__
+int _putenv (const char *);
+# endif
+#elif defined __CYGWIN__
+# ifdef __STRICT_ANSI__
+char *realpath (const char *, char *);
+int putenv (char *);
+int setenv (const char *, const char *, int);
+# endif
+/* #elif defined other_platform || defined ... */
+#endif
+
+/* portability defines, excluding path handling macros */
+#if defined _MSC_VER
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+# define S_IXUSR _S_IEXEC
+#elif defined __MINGW32__
+# define setmode _setmode
+# define stat    _stat
+# define chmod   _chmod
+# define getcwd  _getcwd
+# define putenv  _putenv
+#elif defined __CYGWIN__
+# define HAVE_SETENV
+# define FOPEN_WB "wb"
+/* #elif defined other platforms ... */
+#endif
+
+#if defined PATH_MAX
+# define LT_PATHMAX PATH_MAX
+#elif defined MAXPATHLEN
+# define LT_PATHMAX MAXPATHLEN
+#else
+# define LT_PATHMAX 1024
+#endif
+
+#ifndef S_IXOTH
+# define S_IXOTH 0
+#endif
+#ifndef S_IXGRP
+# define S_IXGRP 0
+#endif
+
+/* path handling portability macros */
+#ifndef DIR_SEPARATOR
+# define DIR_SEPARATOR '/'
+# define PATH_SEPARATOR ':'
+#endif
+
+#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
+  defined __OS2__
+# define HAVE_DOS_BASED_FILE_SYSTEM
+# define FOPEN_WB "wb"
+# ifndef DIR_SEPARATOR_2
+#  define DIR_SEPARATOR_2 '\\'
+# endif
+# ifndef PATH_SEPARATOR_2
+#  define PATH_SEPARATOR_2 ';'
+# endif
+#endif
+
+#ifndef DIR_SEPARATOR_2
+# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
+#else /* DIR_SEPARATOR_2 */
+# define IS_DIR_SEPARATOR(ch) \
+	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
+#endif /* DIR_SEPARATOR_2 */
+
+#ifndef PATH_SEPARATOR_2
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
+#else /* PATH_SEPARATOR_2 */
+# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
+#endif /* PATH_SEPARATOR_2 */
+
+#ifndef FOPEN_WB
+# define FOPEN_WB "w"
+#endif
+#ifndef _O_BINARY
+# define _O_BINARY 0
+#endif
+
+#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
+#define XFREE(stale) do { \
+  if (stale) { free (stale); stale = 0; } \
+} while (0)
+
+#if defined LT_DEBUGWRAPPER
+static int lt_debug = 1;
+#else
+static int lt_debug = 0;
+#endif
+
+const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
+
+void *xmalloc (size_t num);
+char *xstrdup (const char *string);
+const char *base_name (const char *name);
+char *find_executable (const char *wrapper);
+char *chase_symlinks (const char *pathspec);
+int make_executable (const char *path);
+int check_executable (const char *path);
+char *strendzap (char *str, const char *pat);
+void lt_debugprintf (const char *file, int line, const char *fmt, ...);
+void lt_fatal (const char *file, int line, const char *message, ...);
+static const char *nonnull (const char *s);
+static const char *nonempty (const char *s);
+void lt_setenv (const char *name, const char *value);
+char *lt_extend_str (const char *orig_value, const char *add, int to_end);
+void lt_update_exe_path (const char *name, const char *value);
+void lt_update_lib_path (const char *name, const char *value);
+char **prepare_spawn (char **argv);
+void lt_dump_script (FILE *f);
+EOF
+
+	    cat <<EOF
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define externally_visible volatile
+#else
+# define externally_visible __attribute__((externally_visible)) volatile
+#endif
+externally_visible const char * MAGIC_EXE = "$magic_exe";
+const char * LIB_PATH_VARNAME = "$shlibpath_var";
+EOF
+
+	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
+              func_to_host_path "$temp_rpath"
+	      cat <<EOF
+const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * LIB_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test -n "$dllsearchpath"; then
+              func_to_host_path "$dllsearchpath:"
+	      cat <<EOF
+const char * EXE_PATH_VARNAME = "PATH";
+const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
+EOF
+	    else
+	      cat <<"EOF"
+const char * EXE_PATH_VARNAME = "";
+const char * EXE_PATH_VALUE   = "";
+EOF
+	    fi
+
+	    if test yes = "$fast_install"; then
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
+EOF
+	    else
+	      cat <<EOF
+const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
+EOF
+	    fi
+
+
+	    cat <<"EOF"
+
+#define LTWRAPPER_OPTION_PREFIX         "--lt-"
+
+static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
+static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
+static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
+
+int
+main (int argc, char *argv)
+{
+  char **newargz;
+  int  newargc;
+  char *tmp_pathspec;
+  char *actual_cwrapper_path;
+  char *actual_cwrapper_name;
+  char *target_name;
+  char *lt_argv_zero;
+  int rval = 127;
+
+  int i;
+
+  program_name = (char *) xstrdup (base_name (argv0));
+  newargz = XMALLOC (char *, (size_t) argc + 1);
+
+  /* very simple arg parsing; don't want to rely on getopt
+   * also, copy all non cwrapper options to newargz, except
+   * argz0, which is handled differently
+   */
+  newargc=0;
+  for (i = 1; i < argc; i++)
+    {
+      if (STREQ (argvi, dumpscript_opt))
+	{
+EOF
+	    case $host in
+	      *mingw* | *cygwin* )
+		# make stdout use "unix" line endings
+		echo "          setmode(1,_O_BINARY);"
+		;;
+	      esac
+
+	    cat <<"EOF"
+	  lt_dump_script (stdout);
+	  return 0;
+	}
+      if (STREQ (argvi, debug_opt))
+	{
+          lt_debug = 1;
+          continue;
+	}
+      if (STREQ (argvi, ltwrapper_option_prefix))
+        {
+          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
+             namespace, but it is not one of the ones we know about and
+             have already dealt with, above (inluding dump-script), then
+             report an error. Otherwise, targets might begin to believe
+             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
+             namespace. The first time any user complains about this, we'll
+             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
+             or a configure.ac-settable value.
+           */
+          lt_fatal (__FILE__, __LINE__,
+		    "unrecognized %s option: '%s'",
+                    ltwrapper_option_prefix, argvi);
+        }
+      /* otherwise ... */
+      newargz++newargc = xstrdup (argvi);
+    }
+  newargz++newargc = NULL;
+
+EOF
+	    cat <<EOF
+  /* The GNU banner must be the first non-error debug message */
+  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
+EOF
+	    cat <<"EOF"
+  lt_debugprintf (__FILE__, __LINE__, "(main) argv0: %s\n", argv0);
+  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
+
+  tmp_pathspec = find_executable (argv0);
+  if (tmp_pathspec == NULL)
+    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv0);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (before symlink chase) at: %s\n",
+		  tmp_pathspec);
+
+  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
+  lt_debugprintf (__FILE__, __LINE__,
+                  "(main) found exe (after symlink chase) at: %s\n",
+		  actual_cwrapper_path);
+  XFREE (tmp_pathspec);
+
+  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
+  strendzap (actual_cwrapper_path, actual_cwrapper_name);
+
+  /* wrapper name transforms */
+  strendzap (actual_cwrapper_name, ".exe");
+  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
+  XFREE (actual_cwrapper_name);
+  actual_cwrapper_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  /* target_name transforms -- use actual target program name; might have lt- prefix */
+  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
+  strendzap (target_name, ".exe");
+  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
+  XFREE (target_name);
+  target_name = tmp_pathspec;
+  tmp_pathspec = 0;
+
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(main) libtool target name: %s\n",
+		  target_name);
+EOF
+
+	    cat <<EOF
+  newargz0 =
+    XMALLOC (char, (strlen (actual_cwrapper_path) +
+		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
+  strcpy (newargz0, actual_cwrapper_path);
+  strcat (newargz0, "$objdir");
+  strcat (newargz0, "/");
+EOF
+
+	    cat <<"EOF"
+  /* stop here, and copy so we don't have to do this twice */
+  tmp_pathspec = xstrdup (newargz0);
+
+  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
+  strcat (newargz0, actual_cwrapper_name);
+
+  /* DO want the lt- prefix here if it exists, so use target_name */
+  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
+  XFREE (tmp_pathspec);
+  tmp_pathspec = NULL;
+EOF
+
+	    case $host_os in
+	      mingw*)
+	    cat <<"EOF"
+  {
+    char* p;
+    while ((p = strchr (newargz0, '\\')) != NULL)
+      {
+	*p = '/';
+      }
+    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
+      {
+	*p = '/';
+      }
+  }
+EOF
+	    ;;
+	    esac
+
+	    cat <<"EOF"
+  XFREE (target_name);
+  XFREE (actual_cwrapper_path);
+  XFREE (actual_cwrapper_name);
+
+  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
+  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
+  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
+     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
+     because on Windows, both *_VARNAMEs are PATH but uninstalled
+     libraries must come first. */
+  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
+  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
+
+  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
+		  nonnull (lt_argv_zero));
+  for (i = 0; i < newargc; i++)
+    {
+      lt_debugprintf (__FILE__, __LINE__, "(main) newargz%d: %s\n",
+		      i, nonnull (newargzi));
+    }
+
+EOF
+
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+  /* execv doesn't actually work on mingw as expected on unix */
+  newargz = prepare_spawn (newargz);
+  rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
+  if (rval == -1)
+    {
+      /* failed to start process */
+      lt_debugprintf (__FILE__, __LINE__,
+		      "(main) failed to launch target \"%s\": %s\n",
+		      lt_argv_zero, nonnull (strerror (errno)));
+      return 127;
+    }
+  return rval;
+EOF
+		;;
+	      *)
+		cat <<"EOF"
+  execv (lt_argv_zero, newargz);
+  return rval; /* =127, but avoids unused variable warning */
+EOF
+		;;
+	    esac
+
+	    cat <<"EOF"
+}
+
+void *
+xmalloc (size_t num)
+{
+  void *p = (void *) malloc (num);
+  if (!p)
+    lt_fatal (__FILE__, __LINE__, "memory exhausted");
+
+  return p;
+}
+
+char *
+xstrdup (const char *string)
+{
+  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
+			  string) : NULL;
+}
+
+const char *
+base_name (const char *name)
+{
+  const char *base;
+
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  /* Skip over the disk name in MSDOS pathnames. */
+  if (isalpha ((unsigned char) name0) && name1 == ':')
+    name += 2;
+#endif
+
+  for (base = name; *name; name++)
+    if (IS_DIR_SEPARATOR (*name))
+      base = name + 1;
+  return base;
+}
+
+int
+check_executable (const char *path)
+{
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if ((stat (path, &st) >= 0)
+      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
+    return 1;
+  else
+    return 0;
+}
+
+int
+make_executable (const char *path)
+{
+  int rval = 0;
+  struct stat st;
+
+  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
+                  nonempty (path));
+  if ((!path) || (!*path))
+    return 0;
+
+  if (stat (path, &st) >= 0)
+    {
+      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
+    }
+  return rval;
+}
+
+/* Searches for the full path of the wrapper.  Returns
+   newly allocated full path name if found, NULL otherwise
+   Does not chase symlinks, even on platforms that support them.
+*/
+char *
+find_executable (const char *wrapper)
+{
+  int has_slash = 0;
+  const char *p;
+  const char *p_next;
+  /* static buffer for getcwd */
+  char tmpLT_PATHMAX + 1;
+  size_t tmp_len;
+  char *concat_name;
+
+  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
+                  nonempty (wrapper));
+
+  if ((wrapper == NULL) || (*wrapper == '\0'))
+    return NULL;
+
+  /* Absolute path? */
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+  if (isalpha ((unsigned char) wrapper0) && wrapper1 == ':')
+    {
+      concat_name = xstrdup (wrapper);
+      if (check_executable (concat_name))
+	return concat_name;
+      XFREE (concat_name);
+    }
+  else
+    {
+#endif
+      if (IS_DIR_SEPARATOR (wrapper0))
+	{
+	  concat_name = xstrdup (wrapper);
+	  if (check_executable (concat_name))
+	    return concat_name;
+	  XFREE (concat_name);
+	}
+#if defined HAVE_DOS_BASED_FILE_SYSTEM
+    }
+#endif
+
+  for (p = wrapper; *p; p++)
+    if (*p == '/')
+      {
+	has_slash = 1;
+	break;
+      }
+  if (!has_slash)
+    {
+      /* no slashes; search PATH */
+      const char *path = getenv ("PATH");
+      if (path != NULL)
+	{
+	  for (p = path; *p; p = p_next)
+	    {
+	      const char *q;
+	      size_t p_len;
+	      for (q = p; *q; q++)
+		if (IS_PATH_SEPARATOR (*q))
+		  break;
+	      p_len = (size_t) (q - p);
+	      p_next = (*q == '\0' ? q : q + 1);
+	      if (p_len == 0)
+		{
+		  /* empty path: current directory */
+		  if (getcwd (tmp, LT_PATHMAX) == NULL)
+		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+                              nonnull (strerror (errno)));
+		  tmp_len = strlen (tmp);
+		  concat_name =
+		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, tmp, tmp_len);
+		  concat_nametmp_len = '/';
+		  strcpy (concat_name + tmp_len + 1, wrapper);
+		}
+	      else
+		{
+		  concat_name =
+		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
+		  memcpy (concat_name, p, p_len);
+		  concat_namep_len = '/';
+		  strcpy (concat_name + p_len + 1, wrapper);
+		}
+	      if (check_executable (concat_name))
+		return concat_name;
+	      XFREE (concat_name);
+	    }
+	}
+      /* not found in PATH; assume curdir */
+    }
+  /* Relative path | not found in path: prepend cwd */
+  if (getcwd (tmp, LT_PATHMAX) == NULL)
+    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
+              nonnull (strerror (errno)));
+  tmp_len = strlen (tmp);
+  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
+  memcpy (concat_name, tmp, tmp_len);
+  concat_nametmp_len = '/';
+  strcpy (concat_name + tmp_len + 1, wrapper);
+
+  if (check_executable (concat_name))
+    return concat_name;
+  XFREE (concat_name);
+  return NULL;
+}
+
+char *
+chase_symlinks (const char *pathspec)
+{
+#ifndef S_ISLNK
+  return xstrdup (pathspec);
+#else
+  char bufLT_PATHMAX;
+  struct stat s;
+  char *tmp_pathspec = xstrdup (pathspec);
+  char *p;
+  int has_symlinks = 0;
+  while (strlen (tmp_pathspec) && !has_symlinks)
+    {
+      lt_debugprintf (__FILE__, __LINE__,
+		      "checking path component for symlinks: %s\n",
+		      tmp_pathspec);
+      if (lstat (tmp_pathspec, &s) == 0)
+	{
+	  if (S_ISLNK (s.st_mode) != 0)
+	    {
+	      has_symlinks = 1;
+	      break;
+	    }
+
+	  /* search backwards for last DIR_SEPARATOR */
+	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
+	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    p--;
+	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
+	    {
+	      /* no more DIR_SEPARATORS left */
+	      break;
+	    }
+	  *p = '\0';
+	}
+      else
+	{
+	  lt_fatal (__FILE__, __LINE__,
+		    "error accessing file \"%s\": %s",
+		    tmp_pathspec, nonnull (strerror (errno)));
+	}
+    }
+  XFREE (tmp_pathspec);
+
+  if (!has_symlinks)
+    {
+      return xstrdup (pathspec);
+    }
+
+  tmp_pathspec = realpath (pathspec, buf);
+  if (tmp_pathspec == 0)
+    {
+      lt_fatal (__FILE__, __LINE__,
+		"could not follow symlinks for %s", pathspec);
+    }
+  return xstrdup (tmp_pathspec);
+#endif
+}
+
+char *
+strendzap (char *str, const char *pat)
+{
+  size_t len, patlen;
+
+  assert (str != NULL);
+  assert (pat != NULL);
+
+  len = strlen (str);
+  patlen = strlen (pat);
+
+  if (patlen <= len)
+    {
+      str += len - patlen;
+      if (STREQ (str, pat))
+	*str = '\0';
+    }
+  return str;
+}
+
+void
+lt_debugprintf (const char *file, int line, const char *fmt, ...)
+{
+  va_list args;
+  if (lt_debug)
+    {
+      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
+      va_start (args, fmt);
+      (void) vfprintf (stderr, fmt, args);
+      va_end (args);
+    }
+}
+
+static void
+lt_error_core (int exit_status, const char *file,
+	       int line, const char *mode,
+	       const char *message, va_list ap)
+{
+  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
+  vfprintf (stderr, message, ap);
+  fprintf (stderr, ".\n");
+
+  if (exit_status >= 0)
+    exit (exit_status);
+}
+
+void
+lt_fatal (const char *file, int line, const char *message, ...)
+{
+  va_list ap;
+  va_start (ap, message);
+  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
+  va_end (ap);
+}
+
+static const char *
+nonnull (const char *s)
+{
+  return s ? s : "(null)";
+}
+
+static const char *
+nonempty (const char *s)
+{
+  return (s && !*s) ? "(empty)" : nonnull (s);
+}
+
+void
+lt_setenv (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_setenv) setting '%s' to '%s'\n",
+                  nonnull (name), nonnull (value));
+  {
+#ifdef HAVE_SETENV
+    /* always make a copy, for consistency with !HAVE_SETENV */
+    char *str = xstrdup (value);
+    setenv (name, str, 1);
+#else
+    size_t len = strlen (name) + 1 + strlen (value) + 1;
+    char *str = XMALLOC (char, len);
+    sprintf (str, "%s=%s", name, value);
+    if (putenv (str) != EXIT_SUCCESS)
+      {
+        XFREE (str);
+      }
+#endif
+  }
+}
+
+char *
+lt_extend_str (const char *orig_value, const char *add, int to_end)
+{
+  char *new_value;
+  if (orig_value && *orig_value)
+    {
+      size_t orig_value_len = strlen (orig_value);
+      size_t add_len = strlen (add);
+      new_value = XMALLOC (char, add_len + orig_value_len + 1);
+      if (to_end)
+        {
+          strcpy (new_value, orig_value);
+          strcpy (new_value + orig_value_len, add);
+        }
+      else
+        {
+          strcpy (new_value, add);
+          strcpy (new_value + add_len, orig_value);
+        }
+    }
+  else
+    {
+      new_value = xstrdup (add);
+    }
+  return new_value;
+}
+
+void
+lt_update_exe_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      /* some systems can't cope with a ':'-terminated path #' */
+      size_t len = strlen (new_value);
+      while ((len > 0) && IS_PATH_SEPARATOR (new_valuelen-1))
+        {
+          new_value--len = '\0';
+        }
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+void
+lt_update_lib_path (const char *name, const char *value)
+{
+  lt_debugprintf (__FILE__, __LINE__,
+		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
+                  nonnull (name), nonnull (value));
+
+  if (name && *name && value && *value)
+    {
+      char *new_value = lt_extend_str (getenv (name), value, 0);
+      lt_setenv (name, new_value);
+      XFREE (new_value);
+    }
+}
+
+EOF
+	    case $host_os in
+	      mingw*)
+		cat <<"EOF"
+
+/* Prepares an argument vector before calling spawn().
+   Note that spawn() does not by itself call the command interpreter
+     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
+      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+         GetVersionEx(&v);
+         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
+      }) ? "cmd.exe" : "command.com").
+   Instead it simply concatenates the arguments, separated by ' ', and calls
+   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
+   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
+   special way:
+   - Space and tab are interpreted as delimiters. They are not treated as
+     delimiters if they are surrounded by double quotes: "...".
+   - Unescaped double quotes are removed from the input. Their only effect is
+     that within double quotes, space and tab are treated like normal
+     characters.
+   - Backslashes not followed by double quotes are not special.
+   - But 2*n+1 backslashes followed by a double quote become
+     n backslashes followed by a double quote (n >= 0):
+       \" -> "
+       \\\" -> \"
+       \\\\\" -> \\"
+ */
+#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
+char **
+prepare_spawn (char **argv)
+{
+  size_t argc;
+  char **new_argv;
+  size_t i;
+
+  /* Count number of arguments.  */
+  for (argc = 0; argvargc != NULL; argc++)
+    ;
+
+  /* Allocate new argument vector.  */
+  new_argv = XMALLOC (char *, argc + 1);
+
+  /* Put quoted arguments into the new argument vector.  */
+  for (i = 0; i < argc; i++)
+    {
+      const char *string = argvi;
+
+      if (string0 == '\0')
+	new_argvi = xstrdup ("\"\"");
+      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
+	{
+	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
+	  size_t length;
+	  unsigned int backslashes;
+	  const char *s;
+	  char *quoted_string;
+	  char *p;
+
+	  length = 0;
+	  backslashes = 0;
+	  if (quote_around)
+	    length++;
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		length += backslashes + 1;
+	      length++;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    length += backslashes + 1;
+
+	  quoted_string = XMALLOC (char, length + 1);
+
+	  p = quoted_string;
+	  backslashes = 0;
+	  if (quote_around)
+	    *p++ = '"';
+	  for (s = string; *s != '\0'; s++)
+	    {
+	      char c = *s;
+	      if (c == '"')
+		{
+		  unsigned int j;
+		  for (j = backslashes + 1; j > 0; j--)
+		    *p++ = '\\';
+		}
+	      *p++ = c;
+	      if (c == '\\')
+		backslashes++;
+	      else
+		backslashes = 0;
+	    }
+	  if (quote_around)
+	    {
+	      unsigned int j;
+	      for (j = backslashes; j > 0; j--)
+		*p++ = '\\';
+	      *p++ = '"';
+	    }
+	  *p = '\0';
+
+	  new_argvi = quoted_string;
+	}
+      else
+	new_argvi = (char *) string;
+    }
+  new_argvargc = NULL;
+
+  return new_argv;
+}
+EOF
+		;;
+	    esac
+
+            cat <<"EOF"
+void lt_dump_script (FILE* f)
+{
+EOF
+	    func_emit_wrapper yes |
+	      $SED -n -e '
+s/^$.\{79\}$$..*$/\1\
+\2/
+h
+s/$\\"$/\\\1/g
+s/$/\\n/
+s/$^\n*$.*/  fputs ("\1", f);/p
+g
+D'
+            cat <<"EOF"
+}
+EOF
+}
+# end: func_emit_cwrapperexe_src
+
+# func_win32_import_lib_p ARG
+# True if ARG is an import lib, as indicated by $file_magic_cmd
+func_win32_import_lib_p ()
+{
+    $debug_cmd
+
+    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
+    *import*) : ;;
+    *) false ;;
+    esac
+}
+
+# func_suncc_cstd_abi
+# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
+# Several compiler flags select an ABI that is incompatible with the
+# Cstd library. Avoid specifying it if any are in CXXFLAGS.
+func_suncc_cstd_abi ()
+{
+    $debug_cmd
+
+    case " $compile_command " in
+    *" -compat=g "*|*\ -std=c++0-90-9\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
+      suncc_use_cstd_abi=no
+      ;;
+    *)
+      suncc_use_cstd_abi=yes
+      ;;
+    esac
+}
+
+# func_mode_link arg...
+func_mode_link ()
+{
+    $debug_cmd
+
+    case $host in
+    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+      # It is impossible to link a dll without this setting, and
+      # we shouldn't force the makefile maintainer to figure out
+      # what system we are compiling for in order to pass an extra
+      # flag for every libtool invocation.
+      # allow_undefined=no
+
+      # FIXME: Unfortunately, there are problems with the above when trying
+      # to make a dll that has undefined symbols, in which case not
+      # even a static library is built.  For now, we need to specify
+      # -no-undefined on the libtool link line when we can be certain
+      # that all symbols are satisfied, otherwise we get a static library.
+      allow_undefined=yes
+      ;;
+    *)
+      allow_undefined=yes
+      ;;
+    esac
+    libtool_args=$nonopt
+    base_compile="$nonopt $@"
+    compile_command=$nonopt
+    finalize_command=$nonopt
+
+    compile_rpath=
+    finalize_rpath=
+    compile_shlibpath=
+    finalize_shlibpath=
+    convenience=
+    old_convenience=
+    deplibs=
+    old_deplibs=
+    compiler_flags=
+    linker_flags=
+    dllsearchpath=
+    lib_search_path=`pwd`
+    inst_prefix_dir=
+    new_inherited_linker_flags=
+
+    avoid_version=no
+    bindir=
+    dlfiles=
+    dlprefiles=
+    dlself=no
+    export_dynamic=no
+    export_symbols=
+    export_symbols_regex=
+    generated=
+    libobjs=
+    ltlibs=
+    module=no
+    no_install=no
+    objs=
+    os2dllname=
+    non_pic_objects=
+    precious_files_regex=
+    prefer_static_libs=no
+    preload=false
+    prev=
+    prevarg=
+    release=
+    rpath=
+    xrpath=
+    perm_rpath=
+    temp_rpath=
+    thread_safe=no
+    vinfo=
+    vinfo_number=no
+    weak_libs=
+    single_module=$wl-single_module
+    func_infer_tag $base_compile
+
+    # We need to know -static, to get the right output filenames.
+    for arg
+    do
+      case $arg in
+      -shared)
+	test yes != "$build_libtool_libs" \
+	  && func_fatal_configuration "cannot build a shared library"
+	build_old_libs=no
+	break
+	;;
+      -all-static | -static | -static-libtool-libs)
+	case $arg in
+	-all-static)
+	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
+	    func_warning "complete static linking is impossible in this configuration"
+	  fi
+	  if test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	-static)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=built
+	  ;;
+	-static-libtool-libs)
+	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
+	    dlopen_self=$dlopen_self_static
+	  fi
+	  prefer_static_libs=yes
+	  ;;
+	esac
+	build_libtool_libs=no
+	build_old_libs=yes
+	break
+	;;
+      esac
+    done
+
+    # See if our shared archives depend on static archives.
+    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
+
+    # Go through the arguments, transforming them on the way.
+    while test "$#" -gt 0; do
+      arg=$1
+      shift
+      func_quote_for_eval "$arg"
+      qarg=$func_quote_for_eval_unquoted_result
+      func_append libtool_args " $func_quote_for_eval_result"
+
+      # If the previous option needs an argument, assign it.
+      if test -n "$prev"; then
+	case $prev in
+	output)
+	  func_append compile_command " @OUTPUT@"
+	  func_append finalize_command " @OUTPUT@"
+	  ;;
+	esac
+
+	case $prev in
+	bindir)
+	  bindir=$arg
+	  prev=
+	  continue
+	  ;;
+	dlfiles|dlprefiles)
+	  $preload || {
+	    # Add the symbol object into the linking commands.
+	    func_append compile_command " @SYMFILE@"
+	    func_append finalize_command " @SYMFILE@"
+	    preload=:
+	  }
+	  case $arg in
+	  *.la | *.lo) ;;  # We handle these cases below.
+	  force)
+	    if test no = "$dlself"; then
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  self)
+	    if test dlprefiles = "$prev"; then
+	      dlself=yes
+	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
+	      dlself=yes
+	    else
+	      dlself=needless
+	      export_dynamic=yes
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  *)
+	    if test dlfiles = "$prev"; then
+	      func_append dlfiles " $arg"
+	    else
+	      func_append dlprefiles " $arg"
+	    fi
+	    prev=
+	    continue
+	    ;;
+	  esac
+	  ;;
+	expsyms)
+	  export_symbols=$arg
+	  test -f "$arg" \
+	    || func_fatal_error "symbol file '$arg' does not exist"
+	  prev=
+	  continue
+	  ;;
+	expsyms_regex)
+	  export_symbols_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	framework)
+	  case $host in
+	    *-*-darwin*)
+	      case "$deplibs " in
+		*" $qarg.ltframework "*) ;;
+		*) func_append deplibs " $qarg.ltframework" # this is fixed later
+		   ;;
+	      esac
+	      ;;
+	  esac
+	  prev=
+	  continue
+	  ;;
+	inst_prefix)
+	  inst_prefix_dir=$arg
+	  prev=
+	  continue
+	  ;;
+	mllvm)
+	  # Clang does not use LLVM to link, so we can simply discard any
+	  # '-mllvm $arg' options when doing the link step.
+	  prev=
+	  continue
+	  ;;
+	objectlist)
+	  if test -f "$arg"; then
+	    save_arg=$arg
+	    moreargs=
+	    for fil in `cat "$save_arg"`
+	    do
+#	      func_append moreargs " $fil"
+	      arg=$fil
+	      # A libtool-controlled object.
+
+	      # Check to see that this really is a libtool object.
+	      if func_lalib_unsafe_p "$arg"; then
+		pic_object=
+		non_pic_object=
+
+		# Read the .lo file
+		func_source "$arg"
+
+		if test -z "$pic_object" ||
+		   test -z "$non_pic_object" ||
+		   test none = "$pic_object" &&
+		   test none = "$non_pic_object"; then
+		  func_fatal_error "cannot find name of object for '$arg'"
+		fi
+
+		# Extract subdirectory from the argument.
+		func_dirname "$arg" "/" ""
+		xdir=$func_dirname_result
+
+		if test none != "$pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  pic_object=$xdir$pic_object
+
+		  if test dlfiles = "$prev"; then
+		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		      func_append dlfiles " $pic_object"
+		      prev=
+		      continue
+		    else
+		      # If libtool objects are unsupported, then we need to preload.
+		      prev=dlprefiles
+		    fi
+		  fi
+
+		  # CHECK ME:  I think I busted this.  -Ossama
+		  if test dlprefiles = "$prev"; then
+		    # Preload the old-style object.
+		    func_append dlprefiles " $pic_object"
+		    prev=
+		  fi
+
+		  # A PIC object.
+		  func_append libobjs " $pic_object"
+		  arg=$pic_object
+		fi
+
+		# Non-PIC object.
+		if test none != "$non_pic_object"; then
+		  # Prepend the subdirectory the object is found in.
+		  non_pic_object=$xdir$non_pic_object
+
+		  # A standard non-PIC object
+		  func_append non_pic_objects " $non_pic_object"
+		  if test -z "$pic_object" || test none = "$pic_object"; then
+		    arg=$non_pic_object
+		  fi
+		else
+		  # If the PIC object exists, use it instead.
+		  # $xdir was prepended to $pic_object above.
+		  non_pic_object=$pic_object
+		  func_append non_pic_objects " $non_pic_object"
+		fi
+	      else
+		# Only an error if not doing a dry-run.
+		if $opt_dry_run; then
+		  # Extract subdirectory from the argument.
+		  func_dirname "$arg" "/" ""
+		  xdir=$func_dirname_result
+
+		  func_lo2o "$arg"
+		  pic_object=$xdir$objdir/$func_lo2o_result
+		  non_pic_object=$xdir$func_lo2o_result
+		  func_append libobjs " $pic_object"
+		  func_append non_pic_objects " $non_pic_object"
+	        else
+		  func_fatal_error "'$arg' is not a valid libtool object"
+		fi
+	      fi
+	    done
+	  else
+	    func_fatal_error "link input file '$arg' does not exist"
+	  fi
+	  arg=$save_arg
+	  prev=
+	  continue
+	  ;;
+	os2dllname)
+	  os2dllname=$arg
+	  prev=
+	  continue
+	  ;;
+	precious_regex)
+	  precious_files_regex=$arg
+	  prev=
+	  continue
+	  ;;
+	release)
+	  release=-$arg
+	  prev=
+	  continue
+	  ;;
+	rpath | xrpath)
+	  # We need an absolute path.
+	  case $arg in
+	  \\/* | A-Za-z:\\/*) ;;
+	  *)
+	    func_fatal_error "only absolute run-paths are allowed"
+	    ;;
+	  esac
+	  if test rpath = "$prev"; then
+	    case "$rpath " in
+	    *" $arg "*) ;;
+	    *) func_append rpath " $arg" ;;
+	    esac
+	  else
+	    case "$xrpath " in
+	    *" $arg "*) ;;
+	    *) func_append xrpath " $arg" ;;
+	    esac
+	  fi
+	  prev=
+	  continue
+	  ;;
+	shrext)
+	  shrext_cmds=$arg
+	  prev=
+	  continue
+	  ;;
+	weak)
+	  func_append weak_libs " $arg"
+	  prev=
+	  continue
+	  ;;
+	xcclinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xcompiler)
+	  func_append compiler_flags " $qarg"
+	  prev=
+	  func_append compile_command " $qarg"
+	  func_append finalize_command " $qarg"
+	  continue
+	  ;;
+	xlinker)
+	  func_append linker_flags " $qarg"
+	  func_append compiler_flags " $wl$qarg"
+	  prev=
+	  func_append compile_command " $wl$qarg"
+	  func_append finalize_command " $wl$qarg"
+	  continue
+	  ;;
+	*)
+	  eval "$prev=\"\$arg\""
+	  prev=
+	  continue
+	  ;;
+	esac
+      fi # test -n "$prev"
+
+      prevarg=$arg
+
+      case $arg in
+      -all-static)
+	if test -n "$link_static_flag"; then
+	  # See comment for -static flag below, for more details.
+	  func_append compile_command " $link_static_flag"
+	  func_append finalize_command " $link_static_flag"
+	fi
+	continue
+	;;
+
+      -allow-undefined)
+	# FIXME: remove this flag sometime in the future.
+	func_fatal_error "'-allow-undefined' must not be used because it is the default"
+	;;
+
+      -avoid-version)
+	avoid_version=yes
+	continue
+	;;
+
+      -bindir)
+	prev=bindir
+	continue
+	;;
+
+      -dlopen)
+	prev=dlfiles
+	continue
+	;;
+
+      -dlpreopen)
+	prev=dlprefiles
+	continue
+	;;
+
+      -export-dynamic)
+	export_dynamic=yes
+	continue
+	;;
+
+      -export-symbols | -export-symbols-regex)
+	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
+	  func_fatal_error "more than one -exported-symbols argument is not allowed"
+	fi
+	if test X-export-symbols = "X$arg"; then
+	  prev=expsyms
+	else
+	  prev=expsyms_regex
+	fi
+	continue
+	;;
+
+      -framework)
+	prev=framework
+	continue
+	;;
+
+      -inst-prefix-dir)
+	prev=inst_prefix
+	continue
+	;;
+
+      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
+      # so, if we see these flags be careful not to treat them like -L
+      -LA-ZA-Z*:*)
+	case $with_gcc/$host in
+	no/*-*-irix* | /*-*-irix*)
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  ;;
+	esac
+	continue
+	;;
+
+      -L*)
+	func_stripname "-L" '' "$arg"
+	if test -z "$func_stripname_result"; then
+	  if test "$#" -gt 0; then
+	    func_fatal_error "require no space between '-L' and '$1'"
+	  else
+	    func_fatal_error "need path for '-L' option"
+	  fi
+	fi
+	func_resolve_sysroot "$func_stripname_result"
+	dir=$func_resolve_sysroot_result
+	# We need an absolute path.
+	case $dir in
+	\\/* | A-Za-z:\\/*) ;;
+	*)
+	  absdir=`cd "$dir" && pwd`
+	  test -z "$absdir" && \
+	    func_fatal_error "cannot determine absolute directory name of '$dir'"
+	  dir=$absdir
+	  ;;
+	esac
+	case "$deplibs " in
+	*" -L$dir "* | *" $arg "*)
+	  # Will only happen for absolute or sysroot arguments
+	  ;;
+	*)
+	  # Preserve sysroot, but never include relative directories
+	  case $dir in
+	    \\/* | A-Za-z:\\/* | =*) func_append deplibs " $arg" ;;
+	    *) func_append deplibs " -L$dir" ;;
+	  esac
+	  func_append lib_search_path " $dir"
+	  ;;
+	esac
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$dir:"*) ;;
+	  ::) dllsearchpath=$dir;;
+	  *) func_append dllsearchpath ":$dir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+	continue
+	;;
+
+      -l*)
+	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # These systems don't actually have a C or math library (as such)
+	    continue
+	    ;;
+	  *-*-os2*)
+	    # These systems don't actually have a C library (as such)
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	    # Do not include libc due to us having libc/libc_r.
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.012)
+	    # Rhapsody C and math libraries are in the System framework
+	    func_append deplibs " System.ltframework"
+	    continue
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    test X-lc = "X$arg" && continue
+	    ;;
+	  esac
+	elif test X-lc_r = "X$arg"; then
+	 case $host in
+	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
+	   # Do not include libc_r directly, use -pthread flag.
+	   continue
+	   ;;
+	 esac
+	fi
+	func_append deplibs " $arg"
+	continue
+	;;
+
+      -mllvm)
+	prev=mllvm
+	continue
+	;;
+
+      -module)
+	module=yes
+	continue
+	;;
+
+      # Tru64 UNIX uses -model arg to determine the layout of C++
+      # classes, name mangling, and exception handling.
+      # Darwin uses the -arch flag to determine output architecture.
+      -model|-arch|-isysroot|--sysroot)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	prev=xcompiler
+	continue
+	;;
+
+      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	func_append compiler_flags " $arg"
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+	case "$new_inherited_linker_flags " in
+	    *" $arg "*) ;;
+	    * ) func_append new_inherited_linker_flags " $arg" ;;
+	esac
+	continue
+	;;
+
+      -multi_module)
+	single_module=$wl-multi_module
+	continue
+	;;
+
+      -no-fast-install)
+	fast_install=no
+	continue
+	;;
+
+      -no-install)
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
+	  # The PATH hackery in wrapper scripts is required on Windows
+	  # and Darwin in order for the loader to find any dlls it needs.
+	  func_warning "'-no-install' is ignored for $host"
+	  func_warning "assuming '-no-fast-install' instead"
+	  fast_install=no
+	  ;;
+	*) no_install=yes ;;
+	esac
+	continue
+	;;
+
+      -no-undefined)
+	allow_undefined=no
+	continue
+	;;
+
+      -objectlist)
+	prev=objectlist
+	continue
+	;;
+
+      -os2dllname)
+	prev=os2dllname
+	continue
+	;;
+
+      -o) prev=output ;;
+
+      -precious-files-regex)
+	prev=precious_regex
+	continue
+	;;
+
+      -release)
+	prev=release
+	continue
+	;;
+
+      -rpath)
+	prev=rpath
+	continue
+	;;
+
+      -R)
+	prev=xrpath
+	continue
+	;;
+
+      -R*)
+	func_stripname '-R' '' "$arg"
+	dir=$func_stripname_result
+	# We need an absolute path.
+	case $dir in
+	\\/* | A-Za-z:\\/*) ;;
+	=*)
+	  func_stripname '=' '' "$dir"
+	  dir=$lt_sysroot$func_stripname_result
+	  ;;
+	*)
+	  func_fatal_error "only absolute run-paths are allowed"
+	  ;;
+	esac
+	case "$xrpath " in
+	*" $dir "*) ;;
+	*) func_append xrpath " $dir" ;;
+	esac
+	continue
+	;;
+
+      -shared)
+	# The effects of -shared are defined in a previous loop.
+	continue
+	;;
+
+      -shrext)
+	prev=shrext
+	continue
+	;;
+
+      -static | -static-libtool-libs)
+	# The effects of -static are defined in a previous loop.
+	# We used to do the same as -all-static on platforms that
+	# didn't have a PIC flag, but the assumption that the effects
+	# would be equivalent was wrong.  It would break on at least
+	# Digital Unix and AIX.
+	continue
+	;;
+
+      -thread-safe)
+	thread_safe=yes
+	continue
+	;;
+
+      -version-info)
+	prev=vinfo
+	continue
+	;;
+
+      -version-number)
+	prev=vinfo
+	vinfo_number=yes
+	continue
+	;;
+
+      -weak)
+        prev=weak
+	continue
+	;;
+
+      -Wc,*)
+	func_stripname '-Wc,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $func_quote_for_eval_result"
+	  func_append compiler_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Wl,*)
+	func_stripname '-Wl,' '' "$arg"
+	args=$func_stripname_result
+	arg=
+	save_ifs=$IFS; IFS=,
+	for flag in $args; do
+	  IFS=$save_ifs
+          func_quote_for_eval "$flag"
+	  func_append arg " $wl$func_quote_for_eval_result"
+	  func_append compiler_flags " $wl$func_quote_for_eval_result"
+	  func_append linker_flags " $func_quote_for_eval_result"
+	done
+	IFS=$save_ifs
+	func_stripname ' ' '' "$arg"
+	arg=$func_stripname_result
+	;;
+
+      -Xcompiler)
+	prev=xcompiler
+	continue
+	;;
+
+      -Xlinker)
+	prev=xlinker
+	continue
+	;;
+
+      -XCClinker)
+	prev=xcclinker
+	continue
+	;;
+
+      # -msg_* for osf cc
+      -msg_*)
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      # Flags to be passed through unchanged, with rationale:
+      # -64, -mips0-9      enable 64-bit mode for the SGI compiler
+      # -r0-90-9*        specify processor for the SGI compiler
+      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
+      # +DA*, +DD*           enable 64-bit mode for the HP compiler
+      # -q*                  compiler args for the IBM compiler
+      # -m*, -t45*, -txscale* architecture-specific flags for GCC
+      # -F/path              path to uninstalled frameworks, gcc on darwin
+      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # -fstack-protector*   stack protector flags for GCC
+      # @file                GCC response files
+      # -tp=*                Portland pgcc target processor selection
+      # --sysroot=*          for sysroot support
+      # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -specs=*             GCC specs files
+      # -stdlib=*            select c++ std lib with clang
+      # -fsanitize=*         Clang/GCC memory and address sanitizer
+      # -fuse-ld=*           Linker select flags for GCC
+      # -static-*            direct GCC to link specific libraries statically
+      # -fcilkplus           Cilk Plus language extension features for C/C++
+      -64|-mips0-9|-r0-90-9*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
+      -t45*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
+      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
+      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+        func_append compile_command " $arg"
+        func_append finalize_command " $arg"
+        func_append compiler_flags " $arg"
+        continue
+        ;;
+
+      -Z*)
+        if test os2 = "`expr $host : '.*$os2$'`"; then
+          # OS/2 uses -Zxxx to specify OS/2-specific options
+	  compiler_flags="$compiler_flags $arg"
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  case $arg in
+	  -Zlinker | -Zstack)
+	    prev=xcompiler
+	    ;;
+	  esac
+	  continue
+        else
+	  # Otherwise treat like 'Some other compiler flag' below
+	  func_quote_for_eval "$arg"
+	  arg=$func_quote_for_eval_result
+        fi
+	;;
+
+      # Some other compiler flag.
+      -* | +*)
+        func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+
+      *.$objext)
+	# A standard object.
+	func_append objs " $arg"
+	;;
+
+      *.lo)
+	# A libtool-controlled object.
+
+	# Check to see that this really is a libtool object.
+	if func_lalib_unsafe_p "$arg"; then
+	  pic_object=
+	  non_pic_object=
+
+	  # Read the .lo file
+	  func_source "$arg"
+
+	  if test -z "$pic_object" ||
+	     test -z "$non_pic_object" ||
+	     test none = "$pic_object" &&
+	     test none = "$non_pic_object"; then
+	    func_fatal_error "cannot find name of object for '$arg'"
+	  fi
+
+	  # Extract subdirectory from the argument.
+	  func_dirname "$arg" "/" ""
+	  xdir=$func_dirname_result
+
+	  test none = "$pic_object" || {
+	    # Prepend the subdirectory the object is found in.
+	    pic_object=$xdir$pic_object
+
+	    if test dlfiles = "$prev"; then
+	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
+		func_append dlfiles " $pic_object"
+		prev=
+		continue
+	      else
+		# If libtool objects are unsupported, then we need to preload.
+		prev=dlprefiles
+	      fi
+	    fi
+
+	    # CHECK ME:  I think I busted this.  -Ossama
+	    if test dlprefiles = "$prev"; then
+	      # Preload the old-style object.
+	      func_append dlprefiles " $pic_object"
+	      prev=
+	    fi
+
+	    # A PIC object.
+	    func_append libobjs " $pic_object"
+	    arg=$pic_object
+	  }
+
+	  # Non-PIC object.
+	  if test none != "$non_pic_object"; then
+	    # Prepend the subdirectory the object is found in.
+	    non_pic_object=$xdir$non_pic_object
+
+	    # A standard non-PIC object
+	    func_append non_pic_objects " $non_pic_object"
+	    if test -z "$pic_object" || test none = "$pic_object"; then
+	      arg=$non_pic_object
+	    fi
+	  else
+	    # If the PIC object exists, use it instead.
+	    # $xdir was prepended to $pic_object above.
+	    non_pic_object=$pic_object
+	    func_append non_pic_objects " $non_pic_object"
+	  fi
+	else
+	  # Only an error if not doing a dry-run.
+	  if $opt_dry_run; then
+	    # Extract subdirectory from the argument.
+	    func_dirname "$arg" "/" ""
+	    xdir=$func_dirname_result
+
+	    func_lo2o "$arg"
+	    pic_object=$xdir$objdir/$func_lo2o_result
+	    non_pic_object=$xdir$func_lo2o_result
+	    func_append libobjs " $pic_object"
+	    func_append non_pic_objects " $non_pic_object"
+	  else
+	    func_fatal_error "'$arg' is not a valid libtool object"
+	  fi
+	fi
+	;;
+
+      *.$libext)
+	# An archive.
+	func_append deplibs " $arg"
+	func_append old_deplibs " $arg"
+	continue
+	;;
+
+      *.la)
+	# A libtool-controlled library.
+
+	func_resolve_sysroot "$arg"
+	if test dlfiles = "$prev"; then
+	  # This library was specified with -dlopen.
+	  func_append dlfiles " $func_resolve_sysroot_result"
+	  prev=
+	elif test dlprefiles = "$prev"; then
+	  # The library was specified with -dlpreopen.
+	  func_append dlprefiles " $func_resolve_sysroot_result"
+	  prev=
+	else
+	  func_append deplibs " $func_resolve_sysroot_result"
+	fi
+	continue
+	;;
+
+      # Some other compiler argument.
+      *)
+	# Unknown arguments in both finalize_command and compile_command need
+	# to be aesthetically quoted because they are evaled later.
+	func_quote_for_eval "$arg"
+	arg=$func_quote_for_eval_result
+	;;
+      esac # arg
+
+      # Now actually substitute the argument into the commands.
+      if test -n "$arg"; then
+	func_append compile_command " $arg"
+	func_append finalize_command " $arg"
+      fi
+    done # argument parsing loop
+
+    test -n "$prev" && \
+      func_fatal_help "the '$prevarg' option requires an argument"
+
+    if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
+      eval arg=\"$export_dynamic_flag_spec\"
+      func_append compile_command " $arg"
+      func_append finalize_command " $arg"
+    fi
+
+    oldlibs=
+    # calculate the name of the file, without its directory
+    func_basename "$output"
+    outputname=$func_basename_result
+    libobjs_save=$libobjs
+
+    if test -n "$shlibpath_var"; then
+      # get the directories listed in $shlibpath_var
+      eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
+    else
+      shlib_search_path=
+    fi
+    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
+    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
+
+    # Definition is injected by LT_CONFIG during libtool generation.
+    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
+
+    func_dirname "$output" "/" ""
+    output_objdir=$func_dirname_result$objdir
+    func_to_tool_file "$output_objdir/"
+    tool_output_objdir=$func_to_tool_file_result
+    # Create the object directory.
+    func_mkdir_p "$output_objdir"
+
+    # Determine the type of output
+    case $output in
+    "")
+      func_fatal_help "you must specify an output file"
+      ;;
+    *.$libext) linkmode=oldlib ;;
+    *.lo | *.$objext) linkmode=obj ;;
+    *.la) linkmode=lib ;;
+    *) linkmode=prog ;; # Anything else should be a program.
+    esac
+
+    specialdeplibs=
+
+    libs=
+    # Find all interdependent deplibs by searching for libraries
+    # that are linked more than once (e.g. -la -lb -la)
+    for deplib in $deplibs; do
+      if $opt_preserve_dup_deps; then
+	case "$libs " in
+	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	esac
+      fi
+      func_append libs " $deplib"
+    done
+
+    if test lib = "$linkmode"; then
+      libs="$predeps $libs $compiler_lib_search_path $postdeps"
+
+      # Compute libraries that are listed more than once in $predeps
+      # $postdeps and mark them as special (i.e., whose duplicates are
+      # not to be eliminated).
+      pre_post_deps=
+      if $opt_duplicate_compiler_generated_deps; then
+	for pre_post_dep in $predeps $postdeps; do
+	  case "$pre_post_deps " in
+	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
+	  esac
+	  func_append pre_post_deps " $pre_post_dep"
+	done
+      fi
+      pre_post_deps=
+    fi
+
+    deplibs=
+    newdependency_libs=
+    newlib_search_path=
+    need_relink=no # whether we're linking any uninstalled libtool libraries
+    notinst_deplibs= # not-installed libtool libraries
+    notinst_path= # paths that contain not-installed libtool libraries
+
+    case $linkmode in
+    lib)
+	passes="conv dlpreopen link"
+	for file in $dlfiles $dlprefiles; do
+	  case $file in
+	  *.la) ;;
+	  *)
+	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
+	    ;;
+	  esac
+	done
+	;;
+    prog)
+	compile_deplibs=
+	finalize_deplibs=
+	alldeplibs=false
+	newdlfiles=
+	newdlprefiles=
+	passes="conv scan dlopen dlpreopen link"
+	;;
+    *)  passes="conv"
+	;;
+    esac
+
+    for pass in $passes; do
+      # The preopen pass in lib mode reverses $deplibs; put it back here
+      # so that -L comes before libs that need it for instance...
+      if test lib,link = "$linkmode,$pass"; then
+	## FIXME: Find the place where the list is rebuilt in the wrong
+	##        order, and fix it there properly
+        tmp_deplibs=
+	for deplib in $deplibs; do
+	  tmp_deplibs="$deplib $tmp_deplibs"
+	done
+	deplibs=$tmp_deplibs
+      fi
+
+      if test lib,link = "$linkmode,$pass" ||
+	 test prog,scan = "$linkmode,$pass"; then
+	libs=$deplibs
+	deplibs=
+      fi
+      if test prog = "$linkmode"; then
+	case $pass in
+	dlopen) libs=$dlfiles ;;
+	dlpreopen) libs=$dlprefiles ;;
+	link)
+	  libs="$deplibs %DEPLIBS%"
+	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+	  ;;
+	esac
+      fi
+      if test lib,dlpreopen = "$linkmode,$pass"; then
+	# Collect and forward deplibs of preopened libtool libs
+	for lib in $dlprefiles; do
+	  # Ignore non-libtool-libs
+	  dependency_libs=
+	  func_resolve_sysroot "$lib"
+	  case $lib in
+	  *.la)	func_source "$func_resolve_sysroot_result" ;;
+	  esac
+
+	  # Collect preopened libtool deplibs, except any this library
+	  # has declared as weak libs
+	  for deplib in $dependency_libs; do
+	    func_basename "$deplib"
+            deplib_base=$func_basename_result
+	    case " $weak_libs " in
+	    *" $deplib_base "*) ;;
+	    *) func_append deplibs " $deplib" ;;
+	    esac
+	  done
+	done
+	libs=$dlprefiles
+      fi
+      if test dlopen = "$pass"; then
+	# Collect dlpreopened libraries
+	save_deplibs=$deplibs
+	deplibs=
+      fi
+
+      for deplib in $libs; do
+	lib=
+	found=false
+	case $deplib in
+	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
+        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    func_append compiler_flags " $deplib"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-l*)
+	  if test lib != "$linkmode" && test prog != "$linkmode"; then
+	    func_warning "'-l' is ignored for archives/objects"
+	    continue
+	  fi
+	  func_stripname '-l' '' "$deplib"
+	  name=$func_stripname_result
+	  if test lib = "$linkmode"; then
+	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
+	  else
+	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
+	  fi
+	  for searchdir in $searchdirs; do
+	    for search_ext in .la $std_shrext .so .a; do
+	      # Search the libtool library
+	      lib=$searchdir/lib$name$search_ext
+	      if test -f "$lib"; then
+		if test .la = "$search_ext"; then
+		  found=:
+		else
+		  found=false
+		fi
+		break 2
+	      fi
+	    done
+	  done
+	  if $found; then
+	    # deplib is a libtool library
+	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
+	    # We need to do some special things here, and not later.
+	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	      case " $predeps $postdeps " in
+	      *" $deplib "*)
+		if func_lalib_p "$lib"; then
+		  library_names=
+		  old_library=
+		  func_source "$lib"
+		  for l in $old_library $library_names; do
+		    ll=$l
+		  done
+		  if test "X$ll" = "X$old_library"; then # only static version available
+		    found=false
+		    func_dirname "$lib" "" "."
+		    ladir=$func_dirname_result
+		    lib=$ladir/$old_library
+		    if test prog,link = "$linkmode,$pass"; then
+		      compile_deplibs="$deplib $compile_deplibs"
+		      finalize_deplibs="$deplib $finalize_deplibs"
+		    else
+		      deplibs="$deplib $deplibs"
+		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+		    fi
+		    continue
+		  fi
+		fi
+		;;
+	      *) ;;
+	      esac
+	    fi
+	  else
+	    # deplib doesn't seem to be a libtool library
+	    if test prog,link = "$linkmode,$pass"; then
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      deplibs="$deplib $deplibs"
+	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    continue
+	  fi
+	  ;; # -l
+	*.ltframework)
+	  if test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$deplib $compile_deplibs"
+	    finalize_deplibs="$deplib $finalize_deplibs"
+	  else
+	    deplibs="$deplib $deplibs"
+	    if test lib = "$linkmode"; then
+		case "$new_inherited_linker_flags " in
+		    *" $deplib "*) ;;
+		    * ) func_append new_inherited_linker_flags " $deplib" ;;
+		esac
+	    fi
+	  fi
+	  continue
+	  ;;
+	-L*)
+	  case $linkmode in
+	  lib)
+	    deplibs="$deplib $deplibs"
+	    test conv = "$pass" && continue
+	    newdependency_libs="$deplib $newdependency_libs"
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  prog)
+	    if test conv = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	      continue
+	    fi
+	    if test scan = "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    func_stripname '-L' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    func_append newlib_search_path " $func_resolve_sysroot_result"
+	    ;;
+	  *)
+	    func_warning "'-L' is ignored for archives/objects"
+	    ;;
+	  esac # linkmode
+	  continue
+	  ;; # -L
+	-R*)
+	  if test link = "$pass"; then
+	    func_stripname '-R' '' "$deplib"
+	    func_resolve_sysroot "$func_stripname_result"
+	    dir=$func_resolve_sysroot_result
+	    # Make sure the xrpath contains only unique directories.
+	    case "$xrpath " in
+	    *" $dir "*) ;;
+	    *) func_append xrpath " $dir" ;;
+	    esac
+	  fi
+	  deplibs="$deplib $deplibs"
+	  continue
+	  ;;
+	*.la)
+	  func_resolve_sysroot "$deplib"
+	  lib=$func_resolve_sysroot_result
+	  ;;
+	*.$libext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	    continue
+	  fi
+	  case $linkmode in
+	  lib)
+	    # Linking convenience modules into shared libraries is allowed,
+	    # but linking other static libraries is non-portable.
+	    case " $dlpreconveniencelibs " in
+	    *" $deplib "*) ;;
+	    *)
+	      valid_a_lib=false
+	      case $deplibs_check_method in
+		match_pattern*)
+		  set dummy $deplibs_check_method; shift
+		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
+		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
+		    | $EGREP "$match_pattern_regex" > /dev/null; then
+		    valid_a_lib=:
+		  fi
+		;;
+		pass_all)
+		  valid_a_lib=:
+		;;
+	      esac
+	      if $valid_a_lib; then
+		echo
+		$ECHO "*** Warning: Linking the shared library $output against the"
+		$ECHO "*** static library $deplib is not portable!"
+		deplibs="$deplib $deplibs"
+	      else
+		echo
+		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because the file extensions .$libext of this argument makes me believe"
+		echo "*** that it is just a static archive that I should not use here."
+	      fi
+	      ;;
+	    esac
+	    continue
+	    ;;
+	  prog)
+	    if test link != "$pass"; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    fi
+	    continue
+	    ;;
+	  esac # linkmode
+	  ;; # *.$libext
+	*.lo | *.$objext)
+	  if test conv = "$pass"; then
+	    deplibs="$deplib $deplibs"
+	  elif test prog = "$linkmode"; then
+	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
+	      # If there is no dlopen support or we're linking statically,
+	      # we need to preload.
+	      func_append newdlprefiles " $deplib"
+	      compile_deplibs="$deplib $compile_deplibs"
+	      finalize_deplibs="$deplib $finalize_deplibs"
+	    else
+	      func_append newdlfiles " $deplib"
+	    fi
+	  fi
+	  continue
+	  ;;
+	%DEPLIBS%)
+	  alldeplibs=:
+	  continue
+	  ;;
+	esac # case $deplib
+
+	$found || test -f "$lib" \
+	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
+
+	# Check to see that this really is a libtool archive.
+	func_lalib_unsafe_p "$lib" \
+	  || func_fatal_error "'$lib' is not a valid libtool archive"
+
+	func_dirname "$lib" "" "."
+	ladir=$func_dirname_result
+
+	dlname=
+	dlopen=
+	dlpreopen=
+	libdir=
+	library_names=
+	old_library=
+	inherited_linker_flags=
+	# If the library was installed with an old release of libtool,
+	# it will not redefine variables installed, or shouldnotlink
+	installed=yes
+	shouldnotlink=no
+	avoidtemprpath=
+
+
+	# Read the .la file
+	func_source "$lib"
+
+	# Convert "-framework foo" to "foo.ltframework"
+	if test -n "$inherited_linker_flags"; then
+	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework $^ $*$/\1.ltframework/g'`
+	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
+	    case " $new_inherited_linker_flags " in
+	      *" $tmp_inherited_linker_flag "*) ;;
+	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
+	    esac
+	  done
+	fi
+	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	if test lib,link = "$linkmode,$pass" ||
+	   test prog,scan = "$linkmode,$pass" ||
+	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
+	  test -n "$dlopen" && func_append dlfiles " $dlopen"
+	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
+	fi
+
+	if test conv = "$pass"; then
+	  # Only check for convenience libraries
+	  deplibs="$lib $deplibs"
+	  if test -z "$libdir"; then
+	    if test -z "$old_library"; then
+	      func_fatal_error "cannot find name of link library for '$lib'"
+	    fi
+	    # It is a libtool convenience library, so add in its objects.
+	    func_append convenience " $ladir/$objdir/$old_library"
+	    func_append old_convenience " $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+	      if $opt_preserve_dup_deps; then
+		case "$tmp_libs " in
+		*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+		esac
+	      fi
+	      func_append tmp_libs " $deplib"
+	    done
+	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
+	    func_fatal_error "'$lib' is not a convenience library"
+	  fi
+	  continue
+	fi # $pass = conv
+
+
+	# Get the name of the library we link against.
+	linklib=
+	if test -n "$old_library" &&
+	   { test yes = "$prefer_static_libs" ||
+	     test built,no = "$prefer_static_libs,$installed"; }; then
+	  linklib=$old_library
+	else
+	  for l in $old_library $library_names; do
+	    linklib=$l
+	  done
+	fi
+	if test -z "$linklib"; then
+	  func_fatal_error "cannot find name of link library for '$lib'"
+	fi
+
+	# This library was specified with -dlopen.
+	if test dlopen = "$pass"; then
+	  test -z "$libdir" \
+	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
+	  if test -z "$dlname" ||
+	     test yes != "$dlopen_support" ||
+	     test no = "$build_libtool_libs"
+	  then
+	    # If there is no dlname, no dlopen support or we're linking
+	    # statically, we need to preload.  We also need to preload any
+	    # dependent libraries so libltdl's deplib preloader doesn't
+	    # bomb out in the load deplibs phase.
+	    func_append dlprefiles " $lib $dependency_libs"
+	  else
+	    func_append newdlfiles " $lib"
+	  fi
+	  continue
+	fi # $pass = dlopen
+
+	# We need an absolute path.
+	case $ladir in
+	\\/* | A-Za-z:\\/*) abs_ladir=$ladir ;;
+	*)
+	  abs_ladir=`cd "$ladir" && pwd`
+	  if test -z "$abs_ladir"; then
+	    func_warning "cannot determine absolute directory name of '$ladir'"
+	    func_warning "passing it literally to the linker, although it might fail"
+	    abs_ladir=$ladir
+	  fi
+	  ;;
+	esac
+	func_basename "$lib"
+	laname=$func_basename_result
+
+	# Find the relevant object directory and library name.
+	if test yes = "$installed"; then
+	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    func_warning "library '$lib' was moved."
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    libdir=$abs_ladir
+	  else
+	    dir=$lt_sysroot$libdir
+	    absdir=$lt_sysroot$libdir
+	  fi
+	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
+	else
+	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
+	    dir=$ladir
+	    absdir=$abs_ladir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  else
+	    dir=$ladir/$objdir
+	    absdir=$abs_ladir/$objdir
+	    # Remove this search path later
+	    func_append notinst_path " $abs_ladir"
+	  fi
+	fi # $installed = yes
+	func_stripname 'lib' '.la' "$laname"
+	name=$func_stripname_result
+
+	# This library was specified with -dlpreopen.
+	if test dlpreopen = "$pass"; then
+	  if test -z "$libdir" && test prog = "$linkmode"; then
+	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
+	  fi
+	  case $host in
+	    # special handling for platforms with PE-DLLs.
+	    *cygwin* | *mingw* | *cegcc* )
+	      # Linker will automatically link against shared library if both
+	      # static and shared are present.  Therefore, ensure we extract
+	      # symbols from the import library if a shared library is present
+	      # (otherwise, the dlopen module name will be incorrect).  We do
+	      # this by putting the import library name into $newdlprefiles.
+	      # We recover the dlopen module name by 'saving' the la file
+	      # name in a special purpose variable, and (later) extracting the
+	      # dlname from the la file.
+	      if test -n "$dlname"; then
+	        func_tr_sh "$dir/$linklib"
+	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
+	        func_append newdlprefiles " $dir/$linklib"
+	      else
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      fi
+	    ;;
+	    * )
+	      # Prefer using a static library (so that no silly _DYNAMIC symbols
+	      # are required to link).
+	      if test -n "$old_library"; then
+	        func_append newdlprefiles " $dir/$old_library"
+	        # Keep a list of preopened convenience libraries to check
+	        # that they are being used correctly in the link pass.
+	        test -z "$libdir" && \
+	          func_append dlpreconveniencelibs " $dir/$old_library"
+	      # Otherwise, use the dlname, so that lt_dlopen finds it.
+	      elif test -n "$dlname"; then
+	        func_append newdlprefiles " $dir/$dlname"
+	      else
+	        func_append newdlprefiles " $dir/$linklib"
+	      fi
+	    ;;
+	  esac
+	fi # $pass = dlpreopen
+
+	if test -z "$libdir"; then
+	  # Link the convenience library
+	  if test lib = "$linkmode"; then
+	    deplibs="$dir/$old_library $deplibs"
+	  elif test prog,link = "$linkmode,$pass"; then
+	    compile_deplibs="$dir/$old_library $compile_deplibs"
+	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
+	  else
+	    deplibs="$lib $deplibs" # used for prog,scan pass
+	  fi
+	  continue
+	fi
+
+
+	if test prog = "$linkmode" && test link != "$pass"; then
+	  func_append newlib_search_path " $ladir"
+	  deplibs="$lib $deplibs"
+
+	  linkalldeplibs=false
+	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
+	     test no = "$build_libtool_libs"; then
+	    linkalldeplibs=:
+	  fi
+
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    case $deplib in
+	    -L*) func_stripname '-L' '' "$deplib"
+	         func_resolve_sysroot "$func_stripname_result"
+	         func_append newlib_search_path " $func_resolve_sysroot_result"
+		 ;;
+	    esac
+	    # Need to link against all dependency_libs?
+	    if $linkalldeplibs; then
+	      deplibs="$deplib $deplibs"
+	    else
+	      # Need to hardcode shared library paths
+	      # or/and link against static libraries
+	      newdependency_libs="$deplib $newdependency_libs"
+	    fi
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $deplib"
+	  done # for deplib
+	  continue
+	fi # $linkmode = prog...
+
+	if test prog,link = "$linkmode,$pass"; then
+	  if test -n "$library_names" &&
+	     { { test no = "$prefer_static_libs" ||
+	         test built,yes = "$prefer_static_libs,$installed"; } ||
+	       test -z "$old_library"; }; then
+	    # We need to hardcode the library path
+	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
+	      # Make sure the rpath contains only unique directories.
+	      case $temp_rpath: in
+	      *"$absdir:"*) ;;
+	      *) func_append temp_rpath "$absdir:" ;;
+	      esac
+	    fi
+
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi # $linkmode,$pass = prog,link...
+
+	  if $alldeplibs &&
+	     { test pass_all = "$deplibs_check_method" ||
+	       { test yes = "$build_libtool_libs" &&
+		 test -n "$library_names"; }; }; then
+	    # We only need to search for static libraries
+	    continue
+	  fi
+	fi
+
+	link_static=no # Whether the deplib will be linked statically
+	use_static_libs=$prefer_static_libs
+	if test built = "$use_static_libs" && test yes = "$installed"; then
+	  use_static_libs=no
+	fi
+	if test -n "$library_names" &&
+	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
+	  case $host in
+	  *cygwin* | *mingw* | *cegcc* | *os2*)
+	      # No point in relinking DLLs because paths are not encoded
+	      func_append notinst_deplibs " $lib"
+	      need_relink=no
+	    ;;
+	  *)
+	    if test no = "$installed"; then
+	      func_append notinst_deplibs " $lib"
+	      need_relink=yes
+	    fi
+	    ;;
+	  esac
+	  # This is a shared library
+
+	  # Warn about portability, can't link against -module's on some
+	  # systems (darwin).  Don't bleat about dlopened modules though!
+	  dlopenmodule=
+	  for dlpremoduletest in $dlprefiles; do
+	    if test "X$dlpremoduletest" = "X$lib"; then
+	      dlopenmodule=$dlpremoduletest
+	      break
+	    fi
+	  done
+	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
+	    echo
+	    if test prog = "$linkmode"; then
+	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
+	    else
+	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
+	    fi
+	    $ECHO "*** $linklib is not portable!"
+	  fi
+	  if test lib = "$linkmode" &&
+	     test yes = "$hardcode_into_libs"; then
+	    # Hardcode the library path.
+	    # Skip directories that are in the system default run-time
+	    # search path.
+	    case " $sys_lib_dlsearch_path " in
+	    *" $absdir "*) ;;
+	    *)
+	      case "$compile_rpath " in
+	      *" $absdir "*) ;;
+	      *) func_append compile_rpath " $absdir" ;;
+	      esac
+	      ;;
+	    esac
+	    case " $sys_lib_dlsearch_path " in
+	    *" $libdir "*) ;;
+	    *)
+	      case "$finalize_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append finalize_rpath " $libdir" ;;
+	      esac
+	      ;;
+	    esac
+	  fi
+
+	  if test -n "$old_archive_from_expsyms_cmds"; then
+	    # figure out the soname
+	    set dummy $library_names
+	    shift
+	    realname=$1
+	    shift
+	    libname=`eval "\\$ECHO \"$libname_spec\""`
+	    # use dlname if we got it. it's perfectly good, no?
+	    if test -n "$dlname"; then
+	      soname=$dlname
+	    elif test -n "$soname_spec"; then
+	      # bleh windows
+	      case $host in
+	      *cygwin* | mingw* | *cegcc* | *os2*)
+	        func_arith $current - $age
+		major=$func_arith_result
+		versuffix=-$major
+		;;
+	      esac
+	      eval soname=\"$soname_spec\"
+	    else
+	      soname=$realname
+	    fi
+
+	    # Make a new name for the extract_expsyms_cmds to use
+	    soroot=$soname
+	    func_basename "$soroot"
+	    soname=$func_basename_result
+	    func_stripname 'lib' '.dll' "$soname"
+	    newlib=libimp-$func_stripname_result.a
+
+	    # If the library has no export list, then create one now
+	    if test -f "$output_objdir/$soname-def"; then :
+	    else
+	      func_verbose "extracting exported symbol list from '$soname'"
+	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
+	    fi
+
+	    # Create $newlib
+	    if test -f "$output_objdir/$newlib"; then :; else
+	      func_verbose "generating import library for '$soname'"
+	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
+	    fi
+	    # make sure the library variables are pointing to the new library
+	    dir=$output_objdir
+	    linklib=$newlib
+	  fi # test -n "$old_archive_from_expsyms_cmds"
+
+	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    lib_linked=yes
+	    case $hardcode_action in
+	    immediate | unsupported)
+	      if test no = "$hardcode_direct"; then
+		add=$dir/$linklib
+		case $host in
+		  *-*-sco3.2v5.0.024*) add_dir=-L$dir ;;
+		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
+		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.01.10* | \
+		    *-*-unixware7*) add_dir=-L$dir ;;
+		  *-*-darwin* )
+		    # if the lib is a (non-dlopened) module then we cannot
+		    # link against it, someone is ignoring the earlier warnings
+		    if /usr/bin/file -L $add 2> /dev/null |
+			 $GREP ": ^:* bundle" >/dev/null; then
+		      if test "X$dlopenmodule" != "X$lib"; then
+			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
+			if test -z "$old_library"; then
+			  echo
+			  echo "*** And there doesn't seem to be a static archive available"
+			  echo "*** The link will probably fail, sorry"
+			else
+			  add=$dir/$old_library
+			fi
+		      elif test -n "$old_library"; then
+			add=$dir/$old_library
+		      fi
+		    fi
+		esac
+	      elif test no = "$hardcode_minus_L"; then
+		case $host in
+		*-*-sunos*) add_shlibpath=$dir ;;
+		esac
+		add_dir=-L$dir
+		add=-l$name
+	      elif test no = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    relink)
+	      if test yes = "$hardcode_direct" &&
+	         test no = "$hardcode_direct_absolute"; then
+		add=$dir/$linklib
+	      elif test yes = "$hardcode_minus_L"; then
+		add_dir=-L$absdir
+		# Try looking first in the location we're being installed to.
+		if test -n "$inst_prefix_dir"; then
+		  case $libdir in
+		    \\/*)
+		      func_append add_dir " -L$inst_prefix_dir$libdir"
+		      ;;
+		  esac
+		fi
+		add=-l$name
+	      elif test yes = "$hardcode_shlibpath_var"; then
+		add_shlibpath=$dir
+		add=-l$name
+	      else
+		lib_linked=no
+	      fi
+	      ;;
+	    *) lib_linked=no ;;
+	    esac
+
+	    if test yes != "$lib_linked"; then
+	      func_fatal_configuration "unsupported hardcode properties"
+	    fi
+
+	    if test -n "$add_shlibpath"; then
+	      case :$compile_shlibpath: in
+	      *":$add_shlibpath:"*) ;;
+	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
+	      esac
+	    fi
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
+	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	      if test yes != "$hardcode_direct" &&
+		 test yes != "$hardcode_minus_L" &&
+		 test yes = "$hardcode_shlibpath_var"; then
+		case :$finalize_shlibpath: in
+		*":$libdir:"*) ;;
+		*) func_append finalize_shlibpath "$libdir:" ;;
+		esac
+	      fi
+	    fi
+	  fi
+
+	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
+	    add_shlibpath=
+	    add_dir=
+	    add=
+	    # Finalize command for both is simple: just hardcode it.
+	    if test yes = "$hardcode_direct" &&
+	       test no = "$hardcode_direct_absolute"; then
+	      add=$libdir/$linklib
+	    elif test yes = "$hardcode_minus_L"; then
+	      add_dir=-L$libdir
+	      add=-l$name
+	    elif test yes = "$hardcode_shlibpath_var"; then
+	      case :$finalize_shlibpath: in
+	      *":$libdir:"*) ;;
+	      *) func_append finalize_shlibpath "$libdir:" ;;
+	      esac
+	      add=-l$name
+	    elif test yes = "$hardcode_automatic"; then
+	      if test -n "$inst_prefix_dir" &&
+		 test -f "$inst_prefix_dir$libdir/$linklib"; then
+		add=$inst_prefix_dir$libdir/$linklib
+	      else
+		add=$libdir/$linklib
+	      fi
+	    else
+	      # We cannot seem to hardcode it, guess we'll fake it.
+	      add_dir=-L$libdir
+	      # Try looking first in the location we're being installed to.
+	      if test -n "$inst_prefix_dir"; then
+		case $libdir in
+		  \\/*)
+		    func_append add_dir " -L$inst_prefix_dir$libdir"
+		    ;;
+		esac
+	      fi
+	      add=-l$name
+	    fi
+
+	    if test prog = "$linkmode"; then
+	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
+	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
+	    else
+	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
+	      test -n "$add" && deplibs="$add $deplibs"
+	    fi
+	  fi
+	elif test prog = "$linkmode"; then
+	  # Here we assume that one of hardcode_direct or hardcode_minus_L
+	  # is not unsupported.  This is valid on all known static and
+	  # shared platforms.
+	  if test unsupported != "$hardcode_direct"; then
+	    test -n "$old_library" && linklib=$old_library
+	    compile_deplibs="$dir/$linklib $compile_deplibs"
+	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
+	  else
+	    compile_deplibs="-l$name -L$dir $compile_deplibs"
+	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
+	  fi
+	elif test yes = "$build_libtool_libs"; then
+	  # Not a shared library
+	  if test pass_all != "$deplibs_check_method"; then
+	    # We're trying link a shared library against a static one
+	    # but the system doesn't support it.
+
+	    # Just print a warning and add the library to dependency_libs so
+	    # that the program can be linked against the static library.
+	    echo
+	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
+	    echo "*** I have the capability to make that library automatically link in when"
+	    echo "*** you link to this library.  But I can only do this if you have a"
+	    echo "*** shared version of the library, which you do not appear to have."
+	    if test yes = "$module"; then
+	      echo "*** But as you try to build a module library, libtool will still create "
+	      echo "*** a static module, that should work as long as the dlopening application"
+	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
+	      if test -z "$global_symbol_pipe"; then
+		echo
+		echo "*** However, this would only work if libtool was able to extract symbol"
+		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+		echo "*** not find such a program.  So, this module is probably useless."
+		echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	      fi
+	      if test no = "$build_old_libs"; then
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  else
+	    deplibs="$dir/$old_library $deplibs"
+	    link_static=yes
+	  fi
+	fi # link shared/static library?
+
+	if test lib = "$linkmode"; then
+	  if test -n "$dependency_libs" &&
+	     { test yes != "$hardcode_into_libs" ||
+	       test yes = "$build_old_libs" ||
+	       test yes = "$link_static"; }; then
+	    # Extract -R from dependency_libs
+	    temp_deplibs=
+	    for libdir in $dependency_libs; do
+	      case $libdir in
+	      -R*) func_stripname '-R' '' "$libdir"
+	           temp_xrpath=$func_stripname_result
+		   case " $xrpath " in
+		   *" $temp_xrpath "*) ;;
+		   *) func_append xrpath " $temp_xrpath";;
+		   esac;;
+	      *) func_append temp_deplibs " $libdir";;
+	      esac
+	    done
+	    dependency_libs=$temp_deplibs
+	  fi
+
+	  func_append newlib_search_path " $absdir"
+	  # Link against this library
+	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
+	  # ... and its dependency_libs
+	  tmp_libs=
+	  for deplib in $dependency_libs; do
+	    newdependency_libs="$deplib $newdependency_libs"
+	    case $deplib in
+              -L*) func_stripname '-L' '' "$deplib"
+                   func_resolve_sysroot "$func_stripname_result";;
+              *) func_resolve_sysroot "$deplib" ;;
+            esac
+	    if $opt_preserve_dup_deps; then
+	      case "$tmp_libs " in
+	      *" $func_resolve_sysroot_result "*)
+                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
+	      esac
+	    fi
+	    func_append tmp_libs " $func_resolve_sysroot_result"
+	  done
+
+	  if test no != "$link_all_deplibs"; then
+	    # Add the search paths of all dependency libraries
+	    for deplib in $dependency_libs; do
+	      path=
+	      case $deplib in
+	      -L*) path=$deplib ;;
+	      *.la)
+	        func_resolve_sysroot "$deplib"
+	        deplib=$func_resolve_sysroot_result
+	        func_dirname "$deplib" "" "."
+		dir=$func_dirname_result
+		# We need an absolute path.
+		case $dir in
+		\\/* | A-Za-z:\\/*) absdir=$dir ;;
+		*)
+		  absdir=`cd "$dir" && pwd`
+		  if test -z "$absdir"; then
+		    func_warning "cannot determine absolute directory name of '$dir'"
+		    absdir=$dir
+		  fi
+		  ;;
+		esac
+		if $GREP "^installed=no" $deplib > /dev/null; then
+		case $host in
+		*-*-darwin*)
+		  depdepl=
+		  eval deplibrary_names=`$SED -n -e 's/^library_names=$.*$$/\1/p' $deplib`
+		  if test -n "$deplibrary_names"; then
+		    for tmp in $deplibrary_names; do
+		      depdepl=$tmp
+		    done
+		    if test -f "$absdir/$objdir/$depdepl"; then
+		      depdepl=$absdir/$objdir/$depdepl
+		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
+                      if test -z "$darwin_install_name"; then
+                          darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
+                      fi
+		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
+		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
+		      path=
+		    fi
+		  fi
+		  ;;
+		*)
+		  path=-L$absdir/$objdir
+		  ;;
+		esac
+		else
+		  eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $deplib`
+		  test -z "$libdir" && \
+		    func_fatal_error "'$deplib' is not a valid libtool archive"
+		  test "$absdir" != "$libdir" && \
+		    func_warning "'$deplib' seems to be moved"
+
+		  path=-L$absdir
+		fi
+		;;
+	      esac
+	      case " $deplibs " in
+	      *" $path "*) ;;
+	      *) deplibs="$path $deplibs" ;;
+	      esac
+	    done
+	  fi # link_all_deplibs != no
+	fi # linkmode = lib
+      done # for deplib in $libs
+      if test link = "$pass"; then
+	if test prog = "$linkmode"; then
+	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
+	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
+	else
+	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	fi
+      fi
+      dependency_libs=$newdependency_libs
+      if test dlpreopen = "$pass"; then
+	# Link the dlpreopened libraries before other libraries
+	for deplib in $save_deplibs; do
+	  deplibs="$deplib $deplibs"
+	done
+      fi
+      if test dlopen != "$pass"; then
+	test conv = "$pass" || {
+	  # Make sure lib_search_path contains only unique directories.
+	  lib_search_path=
+	  for dir in $newlib_search_path; do
+	    case "$lib_search_path " in
+	    *" $dir "*) ;;
+	    *) func_append lib_search_path " $dir" ;;
+	    esac
+	  done
+	  newlib_search_path=
+	}
+
+	if test prog,link = "$linkmode,$pass"; then
+	  vars="compile_deplibs finalize_deplibs"
+	else
+	  vars=deplibs
+	fi
+	for var in $vars dependency_libs; do
+	  # Add libraries to $var in reverse order
+	  eval tmp_libs=\"\$$var\"
+	  new_libs=
+	  for deplib in $tmp_libs; do
+	    # FIXME: Pedantically, this is the right thing to do, so
+	    #        that some nasty dependency loop isn't accidentally
+	    #        broken:
+	    #new_libs="$deplib $new_libs"
+	    # Pragmatically, this seems to cause very few problems in
+	    # practice:
+	    case $deplib in
+	    -L*) new_libs="$deplib $new_libs" ;;
+	    -R*) ;;
+	    *)
+	      # And here is the reason: when a library appears more
+	      # than once as an explicit dependence of a library, or
+	      # is implicitly linked in more than once by the
+	      # compiler, it is considered special, and multiple
+	      # occurrences thereof are not removed.  Compare this
+	      # with having the same library being listed as a
+	      # dependency of multiple other libraries: in this case,
+	      # we know (pedantically, we assume) the library does not
+	      # need to be listed more than once, so we keep only the
+	      # last copy.  This is not always right, but it is rare
+	      # enough that we require users that really mean to play
+	      # such unportable linking tricks to link the library
+	      # using -Wl,-lname, so that libtool does not consider it
+	      # for duplicate removal.
+	      case " $specialdeplibs " in
+	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
+	      *)
+		case " $new_libs " in
+		*" $deplib "*) ;;
+		*) new_libs="$deplib $new_libs" ;;
+		esac
+		;;
+	      esac
+	      ;;
+	    esac
+	  done
+	  tmp_libs=
+	  for deplib in $new_libs; do
+	    case $deplib in
+	    -L*)
+	      case " $tmp_libs " in
+	      *" $deplib "*) ;;
+	      *) func_append tmp_libs " $deplib" ;;
+	      esac
+	      ;;
+	    *) func_append tmp_libs " $deplib" ;;
+	    esac
+	  done
+	  eval $var=\"$tmp_libs\"
+	done # for var
+      fi
+
+      # Add Sun CC postdeps if required:
+      test CXX = "$tagname" && {
+        case $host_os in
+        linux*)
+          case `$CC -V 2>&1 | sed 5q` in
+          *Sun\ C*) # Sun C++ 5.9
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+
+        solaris*)
+          func_cc_basename "$CC"
+          case $func_cc_basename_result in
+          CC* | sunCC*)
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+        esac
+      }
+
+      # Last step: remove runtime libs from dependency_libs
+      # (they stay in deplibs)
+      tmp_libs=
+      for i in $dependency_libs; do
+	case " $predeps $postdeps $compiler_lib_search_path " in
+	*" $i "*)
+	  i=
+	  ;;
+	esac
+	if test -n "$i"; then
+	  func_append tmp_libs " $i"
+	fi
+      done
+      dependency_libs=$tmp_libs
+    done # for pass
+    if test prog = "$linkmode"; then
+      dlfiles=$newdlfiles
+    fi
+    if test prog = "$linkmode" || test lib = "$linkmode"; then
+      dlprefiles=$newdlprefiles
+    fi
+
+    case $linkmode in
+    oldlib)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for archives"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for archives" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for archives"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for archives"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info/-version-number' is ignored for archives"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for archives"
+
+      test -n "$export_symbols$export_symbols_regex" && \
+	func_warning "'-export-symbols' is ignored for archives"
+
+      # Now set the variables for building old libraries.
+      build_libtool_libs=no
+      oldlibs=$output
+      func_append objs "$old_deplibs"
+      ;;
+
+    lib)
+      # Make sure we only generate libraries of the form 'libNAME.la'.
+      case $outputname in
+      lib*)
+	func_stripname 'lib' '.la' "$outputname"
+	name=$func_stripname_result
+	eval shared_ext=\"$shrext_cmds\"
+	eval libname=\"$libname_spec\"
+	;;
+      *)
+	test no = "$module" \
+	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
+
+	if test no != "$need_lib_prefix"; then
+	  # Add the "lib" prefix for modules if required
+	  func_stripname '' '.la' "$outputname"
+	  name=$func_stripname_result
+	  eval shared_ext=\"$shrext_cmds\"
+	  eval libname=\"$libname_spec\"
+	else
+	  func_stripname '' '.la' "$outputname"
+	  libname=$func_stripname_result
+	fi
+	;;
+      esac
+
+      if test -n "$objs"; then
+	if test pass_all != "$deplibs_check_method"; then
+	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
+	else
+	  echo
+	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
+	  $ECHO "*** objects $objs is not portable!"
+	  func_append libobjs " $objs"
+	fi
+      fi
+
+      test no = "$dlself" \
+	|| func_warning "'-dlopen self' is ignored for libtool libraries"
+
+      set dummy $rpath
+      shift
+      test 1 -lt "$#" \
+	&& func_warning "ignoring multiple '-rpath's for a libtool library"
+
+      install_libdir=$1
+
+      oldlibs=
+      if test -z "$rpath"; then
+	if test yes = "$build_libtool_libs"; then
+	  # Building a libtool convenience library.
+	  # Some compilers have problems with a '.al' extension so
+	  # convenience libraries should have the same extension an
+	  # archive normally would.
+	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
+	  build_libtool_libs=convenience
+	  build_old_libs=yes
+	fi
+
+	test -n "$vinfo" && \
+	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
+
+	test -n "$release" && \
+	  func_warning "'-release' is ignored for convenience libraries"
+      else
+
+	# Parse the version information argument.
+	save_ifs=$IFS; IFS=:
+	set dummy $vinfo 0 0 0
+	shift
+	IFS=$save_ifs
+
+	test -n "$7" && \
+	  func_fatal_help "too many parameters to '-version-info'"
+
+	# convert absolute version numbers to libtool ages
+	# this retains compatibility with .la files and attempts
+	# to make the code below a bit more comprehensible
+
+	case $vinfo_number in
+	yes)
+	  number_major=$1
+	  number_minor=$2
+	  number_revision=$3
+	  #
+	  # There are really only two kinds -- those that
+	  # use the current revision as the major version
+	  # and those that subtract age and use age as
+	  # a minor version.  But, then there is irix
+	  # that has an extra 1 added just for fun
+	  #
+	  case $version_type in
+	  # correct linux to gnu/linux during the next big refactor
+	  darwin|freebsd-elf|linux|osf|windows|none)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_revision
+	    ;;
+	  freebsd-aout|qnx|sunos)
+	    current=$number_major
+	    revision=$number_minor
+	    age=0
+	    ;;
+	  irix|nonstopux)
+	    func_arith $number_major + $number_minor
+	    current=$func_arith_result
+	    age=$number_minor
+	    revision=$number_minor
+	    lt_irix_increment=no
+	    ;;
+	  *)
+	    func_fatal_configuration "$modename: unknown library version type '$version_type'"
+	    ;;
+	  esac
+	  ;;
+	no)
+	  current=$1
+	  revision=$2
+	  age=$3
+	  ;;
+	esac
+
+	# Check that each of the things are valid numbers.
+	case $current in
+	0|1-9|1-90-9|1-90-90-9|1-90-90-90-9|1-90-90-90-90-9) ;;
+	*)
+	  func_error "CURRENT '$current' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $revision in
+	0|1-9|1-90-9|1-90-90-9|1-90-90-90-9|1-90-90-90-90-9) ;;
+	*)
+	  func_error "REVISION '$revision' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	case $age in
+	0|1-9|1-90-9|1-90-90-9|1-90-90-90-9|1-90-90-90-90-9) ;;
+	*)
+	  func_error "AGE '$age' must be a nonnegative integer"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	  ;;
+	esac
+
+	if test "$age" -gt "$current"; then
+	  func_error "AGE '$age' is greater than the current interface number '$current'"
+	  func_fatal_error "'$vinfo' is not valid version information"
+	fi
+
+	# Calculate the version variables.
+	major=
+	versuffix=
+	verstring=
+	case $version_type in
+	none) ;;
+
+	darwin)
+	  # Like Linux, but with the current version available in
+	  # verstring for coding it into the library header
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  # Darwin ld doesn't like 0 for these options...
+	  func_arith $current + 1
+	  minor_current=$func_arith_result
+	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+          # On Darwin other compilers
+          case $CC in
+              nagfor*)
+                  verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
+                  ;;
+              *)
+                  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
+                  ;;
+          esac
+	  ;;
+
+	freebsd-aout)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	freebsd-elf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	irix | nonstopux)
+	  if test no = "$lt_irix_increment"; then
+	    func_arith $current - $age
+	  else
+	    func_arith $current - $age + 1
+	  fi
+	  major=$func_arith_result
+
+	  case $version_type in
+	    nonstopux) verstring_prefix=nonstopux ;;
+	    *)         verstring_prefix=sgi ;;
+	  esac
+	  verstring=$verstring_prefix$major.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$revision
+	  while test 0 -ne "$loop"; do
+	    func_arith $revision - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring_prefix$major.$iface:$verstring
+	  done
+
+	  # Before this point, $major must not contain '.'.
+	  major=.$major
+	  versuffix=$major.$revision
+	  ;;
+
+	linux) # correct to gnu/linux during the next big refactor
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
+	  ;;
+
+	osf)
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=.$current.$age.$revision
+	  verstring=$current.$age.$revision
+
+	  # Add in all the interfaces that we are compatible with.
+	  loop=$age
+	  while test 0 -ne "$loop"; do
+	    func_arith $current - $loop
+	    iface=$func_arith_result
+	    func_arith $loop - 1
+	    loop=$func_arith_result
+	    verstring=$verstring:$iface.0
+	  done
+
+	  # Make executables depend on our current version.
+	  func_append verstring ":$current.0"
+	  ;;
+
+	qnx)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sco)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
+	sunos)
+	  major=.$current
+	  versuffix=.$current.$revision
+	  ;;
+
+	windows)
+	  # Use '-' rather than '.', since we only want one
+	  # extension on DOS 8.3 file systems.
+	  func_arith $current - $age
+	  major=$func_arith_result
+	  versuffix=-$major
+	  ;;
+
+	*)
+	  func_fatal_configuration "unknown library version type '$version_type'"
+	  ;;
+	esac
+
+	# Clear the version info if we defaulted, and they specified a release.
+	if test -z "$vinfo" && test -n "$release"; then
+	  major=
+	  case $version_type in
+	  darwin)
+	    # we can't check for "0.0" in archive_cmds due to quoting
+	    # problems, so we reset it completely
+	    verstring=
+	    ;;
+	  *)
+	    verstring=0.0
+	    ;;
+	  esac
+	  if test no = "$need_version"; then
+	    versuffix=
+	  else
+	    versuffix=.0.0
+	  fi
+	fi
+
+	# Remove version info from name if versioning should be avoided
+	if test yes,no = "$avoid_version,$need_version"; then
+	  major=
+	  versuffix=
+	  verstring=
+	fi
+
+	# Check to see if the archive will have undefined symbols.
+	if test yes = "$allow_undefined"; then
+	  if test unsupported = "$allow_undefined_flag"; then
+	    if test yes = "$build_old_libs"; then
+	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
+	      build_libtool_libs=no
+	    else
+	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
+	    fi
+	  fi
+	else
+	  # Don't allow undefined symbols.
+	  allow_undefined_flag=$no_undefined_flag
+	fi
+
+      fi
+
+      func_generate_dlsyms "$libname" "$libname" :
+      func_append libobjs " $symfileobj"
+      test " " = "$libobjs" && libobjs=
+
+      if test relink != "$opt_mode"; then
+	# Remove our outputs, but don't remove object files since they
+	# may have been created when compiling PIC objects.
+	removelist=
+	tempremovelist=`$ECHO "$output_objdir/*"`
+	for p in $tempremovelist; do
+	  case $p in
+	    *.$objext | *.gcno)
+	       ;;
+	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
+	       if test -n "$precious_files_regex"; then
+		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
+		 then
+		   continue
+		 fi
+	       fi
+	       func_append removelist " $p"
+	       ;;
+	    *) ;;
+	  esac
+	done
+	test -n "$removelist" && \
+	  func_show_eval "${RM}r \$removelist"
+      fi
+
+      # Now set the variables for building old libraries.
+      if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
+	func_append oldlibs " $output_objdir/$libname.$libext"
+
+	# Transform .lo files to .o files.
+	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
+      fi
+
+      # Eliminate all temporary directories.
+      #for path in $notinst_path; do
+      #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
+      #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
+      #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
+      #done
+
+      if test -n "$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	temp_xrpath=
+	for libdir in $xrpath; do
+	  func_replace_sysroot "$libdir"
+	  func_append temp_xrpath " -R$func_replace_sysroot_result"
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
+	  dependency_libs="$temp_xrpath $dependency_libs"
+	fi
+      fi
+
+      # Make sure dlfiles contains only unique files that won't be dlpreopened
+      old_dlfiles=$dlfiles
+      dlfiles=
+      for lib in $old_dlfiles; do
+	case " $dlprefiles $dlfiles " in
+	*" $lib "*) ;;
+	*) func_append dlfiles " $lib" ;;
+	esac
+      done
+
+      # Make sure dlprefiles contains only unique files
+      old_dlprefiles=$dlprefiles
+      dlprefiles=
+      for lib in $old_dlprefiles; do
+	case "$dlprefiles " in
+	*" $lib "*) ;;
+	*) func_append dlprefiles " $lib" ;;
+	esac
+      done
+
+      if test yes = "$build_libtool_libs"; then
+	if test -n "$rpath"; then
+	  case $host in
+	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
+	    # these systems don't actually have a c library (as such)!
+	    ;;
+	  *-*-rhapsody* | *-*-darwin1.012)
+	    # Rhapsody C library is in the System framework
+	    func_append deplibs " System.ltframework"
+	    ;;
+	  *-*-netbsd*)
+	    # Don't link with libc until the a.out ld.so is fixed.
+	    ;;
+	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
+	    # Do not include libc due to us having libc/libc_r.
+	    ;;
+	  *-*-sco3.2v5* | *-*-sco5v6*)
+	    # Causes problems with __ctype
+	    ;;
+	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
+	    # Compiler inserts libc in the correct place for threads to work
+	    ;;
+	  *)
+	    # Add libc to deplibs on all other systems if necessary.
+	    if test yes = "$build_libtool_need_lc"; then
+	      func_append deplibs " -lc"
+	    fi
+	    ;;
+	  esac
+	fi
+
+	# Transform deplibs into only deplibs that can be linked in shared.
+	name_save=$name
+	libname_save=$libname
+	release_save=$release
+	versuffix_save=$versuffix
+	major_save=$major
+	# I'm not sure if I'm treating the release correctly.  I think
+	# release should show up in the -l (ie -lgmp5) so we don't want to
+	# add it in twice.  Is that correct?
+	release=
+	versuffix=
+	major=
+	newdeplibs=
+	droppeddeps=no
+	case $deplibs_check_method in
+	pass_all)
+	  # Don't check for shared/static.  Everything works.
+	  # This might be a little naive.  We might want to check
+	  # whether the library exists or not.  But this is on
+	  # osf3 & osf4 and I'm not really sure... Just
+	  # implementing what was already the behavior.
+	  newdeplibs=$deplibs
+	  ;;
+	test_compile)
+	  # This code stresses the "libraries are programs" paradigm to its
+	  # limits. Maybe even breaks it.  We compile a program, linking it
+	  # against the deplibs as a proxy for the library.  Then we can check
+	  # whether they linked in statically or dynamically with ldd.
+	  $opt_dry_run || $RM conftest.c
+	  cat > conftest.c <<EOF
+	  int main() { return 0; }
+EOF
+	  $opt_dry_run || $RM conftest
+	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
+	    ldd_output=`ldd conftest`
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		  case " $predeps $postdeps " in
+		  *" $i "*)
+		    func_append newdeplibs " $i"
+		    i=
+		    ;;
+		  esac
+		fi
+		if test -n "$i"; then
+		  libname=`eval "\\$ECHO \"$libname_spec\""`
+		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		  set dummy $deplib_matches; shift
+		  deplib_match=$1
+		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		    func_append newdeplibs " $i"
+		  else
+		    droppeddeps=yes
+		    echo
+		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		    echo "*** I have the capability to make that library automatically link in when"
+		    echo "*** you link to this library.  But I can only do this if you have a"
+		    echo "*** shared version of the library, which I believe you do not have"
+		    echo "*** because a test_compile did reveal that the linker did not use it for"
+		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
+		  fi
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  else
+	    # Error occurred in the first compile.  Let's try to salvage
+	    # the situation: Compile a separate program for each library.
+	    for i in $deplibs; do
+	      case $i in
+	      -l*)
+		func_stripname -l '' "$i"
+		name=$func_stripname_result
+		$opt_dry_run || $RM conftest
+		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
+		  ldd_output=`ldd conftest`
+		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		    case " $predeps $postdeps " in
+		    *" $i "*)
+		      func_append newdeplibs " $i"
+		      i=
+		      ;;
+		    esac
+		  fi
+		  if test -n "$i"; then
+		    libname=`eval "\\$ECHO \"$libname_spec\""`
+		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
+		    set dummy $deplib_matches; shift
+		    deplib_match=$1
+		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
+		      func_append newdeplibs " $i"
+		    else
+		      droppeddeps=yes
+		      echo
+		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
+		      echo "*** I have the capability to make that library automatically link in when"
+		      echo "*** you link to this library.  But I can only do this if you have a"
+		      echo "*** shared version of the library, which you do not appear to have"
+		      echo "*** because a test_compile did reveal that the linker did not use this one"
+		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
+		    fi
+		  fi
+		else
+		  droppeddeps=yes
+		  echo
+		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
+		  echo "*** make it link in!  You will probably need to install it or some"
+		  echo "*** library that it depends on before this library will be fully"
+		  echo "*** functional.  Installing it before continuing would be even better."
+		fi
+		;;
+	      *)
+		func_append newdeplibs " $i"
+		;;
+	      esac
+	    done
+	  fi
+	  ;;
+	file_magic*)
+	  set dummy $deplibs_check_method; shift
+	  file_magic_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		if test -n "$file_magic_glob"; then
+		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
+		else
+		  libnameglob=$libname
+		fi
+		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  if test yes = "$want_nocaseglob"; then
+		    shopt -s nocaseglob
+		    potential_libs=`ls $i/$libnameglob.-* 2>/dev/null`
+		    $nocaseglob
+		  else
+		    potential_libs=`ls $i/$libnameglob.-* 2>/dev/null`
+		  fi
+		  for potent_lib in $potential_libs; do
+		      # Follow soft links.
+		      if ls -lLd "$potent_lib" 2>/dev/null |
+			 $GREP " -> " >/dev/null; then
+			continue
+		      fi
+		      # The statement above tries to avoid entering an
+		      # endless loop below, in case of cyclic links.
+		      # We might still enter an endless loop, since a link
+		      # loop can be closed while we follow links,
+		      # but so what?
+		      potlib=$potent_lib
+		      while test -h "$potlib" 2>/dev/null; do
+			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
+			case $potliblink in
+			\\/* | A-Za-z:\\/*) potlib=$potliblink;;
+			*) potlib=`$ECHO "$potlib" | $SED 's|^/*$||'`"$potliblink";;
+			esac
+		      done
+		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
+			 $SED -e 10q |
+			 $EGREP "$file_magic_regex" > /dev/null; then
+			func_append newdeplibs " $a_deplib"
+			a_deplib=
+			break 2
+		      fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a file magic. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	match_pattern*)
+	  set dummy $deplibs_check_method; shift
+	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 $.*$"`
+	  for a_deplib in $deplibs; do
+	    case $a_deplib in
+	    -l*)
+	      func_stripname -l '' "$a_deplib"
+	      name=$func_stripname_result
+	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+		case " $predeps $postdeps " in
+		*" $a_deplib "*)
+		  func_append newdeplibs " $a_deplib"
+		  a_deplib=
+		  ;;
+		esac
+	      fi
+	      if test -n "$a_deplib"; then
+		libname=`eval "\\$ECHO \"$libname_spec\""`
+		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
+		  potential_libs=`ls $i/$libname.-* 2>/dev/null`
+		  for potent_lib in $potential_libs; do
+		    potlib=$potent_lib # see symlink-check above in file_magic test
+		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
+		       $EGREP "$match_pattern_regex" > /dev/null; then
+		      func_append newdeplibs " $a_deplib"
+		      a_deplib=
+		      break 2
+		    fi
+		  done
+		done
+	      fi
+	      if test -n "$a_deplib"; then
+		droppeddeps=yes
+		echo
+		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
+		echo "*** I have the capability to make that library automatically link in when"
+		echo "*** you link to this library.  But I can only do this if you have a"
+		echo "*** shared version of the library, which you do not appear to have"
+		echo "*** because I did check the linker path looking for a file starting"
+		if test -z "$potlib"; then
+		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
+		else
+		  $ECHO "*** with $libname and none of the candidates passed a file format test"
+		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
+		fi
+	      fi
+	      ;;
+	    *)
+	      # Add a -L argument.
+	      func_append newdeplibs " $a_deplib"
+	      ;;
+	    esac
+	  done # Gone through all deplibs.
+	  ;;
+	none | unknown | *)
+	  newdeplibs=
+	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -LR^ *//g'`
+	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
+	    for i in $predeps $postdeps; do
+	      # can't use Xsed below, because $i might contain '/'
+	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
+	    done
+	  fi
+	  case $tmp_deplibs in
+	  *!\	\ *)
+	    echo
+	    if test none = "$deplibs_check_method"; then
+	      echo "*** Warning: inter-library dependencies are not supported in this platform."
+	    else
+	      echo "*** Warning: inter-library dependencies are not known to be supported."
+	    fi
+	    echo "*** All declared inter-library dependencies are being dropped."
+	    droppeddeps=yes
+	    ;;
+	  esac
+	  ;;
+	esac
+	versuffix=$versuffix_save
+	major=$major_save
+	release=$release_save
+	libname=$libname_save
+	name=$name_save
+
+	case $host in
+	*-*-rhapsody* | *-*-darwin1.012)
+	  # On Rhapsody replace the C library with the System framework
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
+	  ;;
+	esac
+
+	if test yes = "$droppeddeps"; then
+	  if test yes = "$module"; then
+	    echo
+	    echo "*** Warning: libtool could not satisfy all declared inter-library"
+	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
+	    echo "*** a static module, that should work as long as the dlopening"
+	    echo "*** application is linked with the -dlopen flag."
+	    if test -z "$global_symbol_pipe"; then
+	      echo
+	      echo "*** However, this would only work if libtool was able to extract symbol"
+	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
+	      echo "*** not find such a program.  So, this module is probably useless."
+	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
+	    fi
+	    if test no = "$build_old_libs"; then
+	      oldlibs=$output_objdir/$libname.$libext
+	      build_libtool_libs=module
+	      build_old_libs=yes
+	    else
+	      build_libtool_libs=no
+	    fi
+	  else
+	    echo "*** The inter-library dependencies that have been dropped here will be"
+	    echo "*** automatically added whenever a program is linked with this library"
+	    echo "*** or is declared to -dlopen it."
+
+	    if test no = "$allow_undefined"; then
+	      echo
+	      echo "*** Since this library must not contain undefined symbols,"
+	      echo "*** because either the platform does not support them or"
+	      echo "*** it was explicitly requested with -no-undefined,"
+	      echo "*** libtool will only create a static version of it."
+	      if test no = "$build_old_libs"; then
+		oldlibs=$output_objdir/$libname.$libext
+		build_libtool_libs=module
+		build_old_libs=yes
+	      else
+		build_libtool_libs=no
+	      fi
+	    fi
+	  fi
+	fi
+	# Done checking deplibs!
+	deplibs=$newdeplibs
+      fi
+      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
+      case $host in
+	*-*-darwin*)
+	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	  deplibs=`$ECHO " $deplibs" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	  ;;
+      esac
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      deplibs=$new_libs
+
+      # All the library-specific variables (install_libdir is set above).
+      library_names=
+      old_library=
+      dlname=
+
+      # Test again, we may have decided not to build it any more
+      if test yes = "$build_libtool_libs"; then
+	# Remove $wl instances when linking with ld.
+	# FIXME: should test the right _cmds variable.
+	case $archive_cmds in
+	  *\$LD\ *) wl= ;;
+        esac
+	if test yes = "$hardcode_into_libs"; then
+	  # Hardcode the library paths
+	  hardcode_libdirs=
+	  dep_rpath=
+	  rpath=$finalize_rpath
+	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
+	  for libdir in $rpath; do
+	    if test -n "$hardcode_libdir_flag_spec"; then
+	      if test -n "$hardcode_libdir_separator"; then
+		func_replace_sysroot "$libdir"
+		libdir=$func_replace_sysroot_result
+		if test -z "$hardcode_libdirs"; then
+		  hardcode_libdirs=$libdir
+		else
+		  # Just accumulate the unique libdirs.
+		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		    ;;
+		  *)
+		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		    ;;
+		  esac
+		fi
+	      else
+		eval flag=\"$hardcode_libdir_flag_spec\"
+		func_append dep_rpath " $flag"
+	      fi
+	    elif test -n "$runpath_var"; then
+	      case "$perm_rpath " in
+	      *" $libdir "*) ;;
+	      *) func_append perm_rpath " $libdir" ;;
+	      esac
+	    fi
+	  done
+	  # Substitute the hardcoded libdirs into the rpath.
+	  if test -n "$hardcode_libdir_separator" &&
+	     test -n "$hardcode_libdirs"; then
+	    libdir=$hardcode_libdirs
+	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
+	  fi
+	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
+	    # We should set the runpath_var.
+	    rpath=
+	    for dir in $perm_rpath; do
+	      func_append rpath "$dir:"
+	    done
+	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
+	  fi
+	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
+	fi
+
+	shlibpath=$finalize_shlibpath
+	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
+	if test -n "$shlibpath"; then
+	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
+	fi
+
+	# Get the real and link names of the library.
+	eval shared_ext=\"$shrext_cmds\"
+	eval library_names=\"$library_names_spec\"
+	set dummy $library_names
+	shift
+	realname=$1
+	shift
+
+	if test -n "$soname_spec"; then
+	  eval soname=\"$soname_spec\"
+	else
+	  soname=$realname
+	fi
+	if test -z "$dlname"; then
+	  dlname=$soname
+	fi
+
+	lib=$output_objdir/$realname
+	linknames=
+	for link
+	do
+	  func_append linknames " $link"
+	done
+
+	# Use standard objects if they are pic
+	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	test "X$libobjs" = "X " && libobjs=
+
+	delfiles=
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
+	  export_symbols=$output_objdir/$libname.uexp
+	  func_append delfiles " $export_symbols"
+	fi
+
+	orig_export_symbols=
+	case $host_os in
+	cygwin* | mingw* | cegcc*)
+	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
+	    # exporting using user supplied symfile
+	    func_dll_def_p "$export_symbols" || {
+	      # and it's NOT already a .def file. Must figure out
+	      # which of the given symbols are data symbols and tag
+	      # them as such. So, trigger use of export_symbols_cmds.
+	      # export_symbols gets reassigned inside the "prepare
+	      # the list of exported symbols" if statement, so the
+	      # include_expsyms logic still works.
+	      orig_export_symbols=$export_symbols
+	      export_symbols=
+	      always_export_symbols=yes
+	    }
+	  fi
+	  ;;
+	esac
+
+	# Prepare the list of exported symbols
+	if test -z "$export_symbols"; then
+	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
+	    func_verbose "generating symbol list for '$libname.la'"
+	    export_symbols=$output_objdir/$libname.exp
+	    $opt_dry_run || $RM $export_symbols
+	    cmds=$export_symbols_cmds
+	    save_ifs=$IFS; IFS='~'
+	    for cmd1 in $cmds; do
+	      IFS=$save_ifs
+	      # Take the normal branch if the nm_file_list_spec branch
+	      # doesn't work or if tool conversion is not needed.
+	      case $nm_file_list_spec~$to_tool_file_cmd in
+		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
+		  try_normal_branch=yes
+		  eval cmd=\"$cmd1\"
+		  func_len " $cmd"
+		  len=$func_len_result
+		  ;;
+		*)
+		  try_normal_branch=no
+		  ;;
+	      esac
+	      if test yes = "$try_normal_branch" \
+		 && { test "$len" -lt "$max_cmd_len" \
+		      || test "$max_cmd_len" -le -1; }
+	      then
+		func_show_eval "$cmd" 'exit $?'
+		skipped_export=false
+	      elif test -n "$nm_file_list_spec"; then
+		func_basename "$output"
+		output_la=$func_basename_result
+		save_libobjs=$libobjs
+		save_output=$output
+		output=$output_objdir/$output_la.nm
+		func_to_tool_file "$output"
+		libobjs=$nm_file_list_spec$func_to_tool_file_result
+		func_append delfiles " $output"
+		func_verbose "creating $NM input file list: $output"
+		for obj in $save_libobjs; do
+		  func_to_tool_file "$obj"
+		  $ECHO "$func_to_tool_file_result"
+		done > "$output"
+		eval cmd=\"$cmd1\"
+		func_show_eval "$cmd" 'exit $?'
+		output=$save_output
+		libobjs=$save_libobjs
+		skipped_export=false
+	      else
+		# The command line is too long to execute in one step.
+		func_verbose "using reloadable object file for export list..."
+		skipped_export=:
+		# Break out early, otherwise skipped_export may be
+		# set to false by a later but shorter cmd.
+		break
+	      fi
+	    done
+	    IFS=$save_ifs
+	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+	fi
+
+	if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	  tmp_export_symbols=$export_symbols
+	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	fi
+
+	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
+	  # The given exports_symbols file has to be filtered, so filter it.
+	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	  # 's' commands, which not all seds can handle. GNU sed should be fine
+	  # though. Also, the filter scales superlinearly with the number of
+	  # global variables. join(1) would be nice here, but unfortunately
+	  # isn't a blessed tool.
+	  $opt_dry_run || $SED -e '/ ,DATA/!d;s,$.*$$ \,.*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	  export_symbols=$output_objdir/$libname.def
+	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	fi
+
+	tmp_deplibs=
+	for test_deplib in $deplibs; do
+	  case " $convenience " in
+	  *" $test_deplib "*) ;;
+	  *)
+	    func_append tmp_deplibs " $test_deplib"
+	    ;;
+	  esac
+	done
+	deplibs=$tmp_deplibs
+
+	if test -n "$convenience"; then
+	  if test -n "$whole_archive_flag_spec" &&
+	    test yes = "$compiler_needs_object" &&
+	    test -z "$libobjs"; then
+	    # extract the archives, so we have objects to list.
+	    # TODO: could optimize this to just extract one archive.
+	    whole_archive_flag_spec=
+	  fi
+	  if test -n "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  else
+	    gentop=$output_objdir/${outputname}x
+	    func_append generated " $gentop"
+
+	    func_extract_archives $gentop $convenience
+	    func_append libobjs " $func_extract_archives_result"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	fi
+
+	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
+	  eval flag=\"$thread_safe_flag_spec\"
+	  func_append linker_flags " $flag"
+	fi
+
+	# Make a backup of the uninstalled library when relinking
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
+	fi
+
+	# Do each of the archive commands.
+	if test yes = "$module" && test -n "$module_cmds"; then
+	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	    eval test_cmds=\"$module_expsym_cmds\"
+	    cmds=$module_expsym_cmds
+	  else
+	    eval test_cmds=\"$module_cmds\"
+	    cmds=$module_cmds
+	  fi
+	else
+	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	    eval test_cmds=\"$archive_expsym_cmds\"
+	    cmds=$archive_expsym_cmds
+	  else
+	    eval test_cmds=\"$archive_cmds\"
+	    cmds=$archive_cmds
+	  fi
+	fi
+
+	if test : != "$skipped_export" &&
+	   func_len " $test_cmds" &&
+	   len=$func_len_result &&
+	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  :
+	else
+	  # The command line is too long to link in one step, link piecewise
+	  # or, if using GNU ld and skipped_export is not :, use a linker
+	  # script.
+
+	  # Save the value of $output and $libobjs because we want to
+	  # use them later.  If we have whole_archive_flag_spec, we
+	  # want to use save_libobjs as it was before
+	  # whole_archive_flag_spec was expanded, because we can't
+	  # assume the linker understands whole_archive_flag_spec.
+	  # This may have to be revisited, in case too many
+	  # convenience libraries get linked in and end up exceeding
+	  # the spec.
+	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
+	    save_libobjs=$libobjs
+	  fi
+	  save_output=$output
+	  func_basename "$output"
+	  output_la=$func_basename_result
+
+	  # Clear the reloadable object creation command queue and
+	  # initialize k to one.
+	  test_cmds=
+	  concat_cmds=
+	  objlist=
+	  last_robj=
+	  k=1
+
+	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
+	    output=$output_objdir/$output_la.lnkscript
+	    func_verbose "creating GNU ld script: $output"
+	    echo 'INPUT (' > $output
+	    for obj in $save_libobjs
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    echo ')' >> $output
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$func_to_tool_file_result
+	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
+	    output=$output_objdir/$output_la.lnk
+	    func_verbose "creating linker input file list: $output"
+	    : > $output
+	    set x $save_libobjs
+	    shift
+	    firstobj=
+	    if test yes = "$compiler_needs_object"; then
+	      firstobj="$1 "
+	      shift
+	    fi
+	    for obj
+	    do
+	      func_to_tool_file "$obj"
+	      $ECHO "$func_to_tool_file_result" >> $output
+	    done
+	    func_append delfiles " $output"
+	    func_to_tool_file "$output"
+	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
+	  else
+	    if test -n "$save_libobjs"; then
+	      func_verbose "creating reloadable object files..."
+	      output=$output_objdir/$output_la-$k.$objext
+	      eval test_cmds=\"$reload_cmds\"
+	      func_len " $test_cmds"
+	      len0=$func_len_result
+	      len=$len0
+
+	      # Loop over the list of objects to be linked.
+	      for obj in $save_libobjs
+	      do
+		func_len " $obj"
+		func_arith $len + $func_len_result
+		len=$func_arith_result
+		if test -z "$objlist" ||
+		   test "$len" -lt "$max_cmd_len"; then
+		  func_append objlist " $obj"
+		else
+		  # The command $test_cmds is almost too long, add a
+		  # command to the queue.
+		  if test 1 -eq "$k"; then
+		    # The first file doesn't have a previous command to add.
+		    reload_objs=$objlist
+		    eval concat_cmds=\"$reload_cmds\"
+		  else
+		    # All subsequent reloadable object files will link in
+		    # the last one created.
+		    reload_objs="$objlist $last_robj"
+		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
+		  fi
+		  last_robj=$output_objdir/$output_la-$k.$objext
+		  func_arith $k + 1
+		  k=$func_arith_result
+		  output=$output_objdir/$output_la-$k.$objext
+		  objlist=" $obj"
+		  func_len " $last_robj"
+		  func_arith $len0 + $func_len_result
+		  len=$func_arith_result
+		fi
+	      done
+	      # Handle the remaining objects by creating one last
+	      # reloadable object file.  All subsequent reloadable object
+	      # files will link in the last one created.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      reload_objs="$objlist $last_robj"
+	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
+	      if test -n "$last_robj"; then
+	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	      func_append delfiles " $output"
+
+	    else
+	      output=
+	    fi
+
+	    ${skipped_export-false} && {
+	      func_verbose "generating symbol list for '$libname.la'"
+	      export_symbols=$output_objdir/$libname.exp
+	      $opt_dry_run || $RM $export_symbols
+	      libobjs=$output
+	      # Append the command to create the export file.
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
+	      if test -n "$last_robj"; then
+		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
+	      fi
+	    }
+
+	    test -n "$save_libobjs" &&
+	      func_verbose "creating a temporary reloadable object file: $output"
+
+	    # Loop through the commands generated above and execute them.
+	    save_ifs=$IFS; IFS='~'
+	    for cmd in $concat_cmds; do
+	      IFS=$save_ifs
+	      $opt_quiet || {
+		  func_quote_for_expand "$cmd"
+		  eval "func_echo $func_quote_for_expand_result"
+	      }
+	      $opt_dry_run || eval "$cmd" || {
+		lt_exit=$?
+
+		# Restore the uninstalled library and exit
+		if test relink = "$opt_mode"; then
+		  ( cd "$output_objdir" && \
+		    $RM "${realname}T" && \
+		    $MV "${realname}U" "$realname" )
+		fi
+
+		exit $lt_exit
+	      }
+	    done
+	    IFS=$save_ifs
+
+	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
+	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
+	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
+	    fi
+	  fi
+
+          ${skipped_export-false} && {
+	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
+	      tmp_export_symbols=$export_symbols
+	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
+	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
+	    fi
+
+	    if test -n "$orig_export_symbols"; then
+	      # The given exports_symbols file has to be filtered, so filter it.
+	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
+	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
+	      # 's' commands, which not all seds can handle. GNU sed should be fine
+	      # though. Also, the filter scales superlinearly with the number of
+	      # global variables. join(1) would be nice here, but unfortunately
+	      # isn't a blessed tool.
+	      $opt_dry_run || $SED -e '/ ,DATA/!d;s,$.*$$ \,.*$,s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
+	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
+	      export_symbols=$output_objdir/$libname.def
+	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
+	    fi
+	  }
+
+	  libobjs=$output
+	  # Restore the value of output.
+	  output=$save_output
+
+	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
+	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
+	    test "X$libobjs" = "X " && libobjs=
+	  fi
+	  # Expand the library linking commands again to reset the
+	  # value of $libobjs for piecewise linking.
+
+	  # Do each of the archive commands.
+	  if test yes = "$module" && test -n "$module_cmds"; then
+	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
+	      cmds=$module_expsym_cmds
+	    else
+	      cmds=$module_cmds
+	    fi
+	  else
+	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
+	      cmds=$archive_expsym_cmds
+	    else
+	      cmds=$archive_cmds
+	    fi
+	  fi
+	fi
+
+	if test -n "$delfiles"; then
+	  # Append the command to remove temporary files to $cmds.
+	  eval cmds=\"\$cmds~\$RM $delfiles\"
+	fi
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append libobjs " $func_extract_archives_result"
+	  test "X$libobjs" = "X " && libobjs=
+	fi
+
+	save_ifs=$IFS; IFS='~'
+	for cmd in $cmds; do
+	  IFS=$sp$nl
+	  eval cmd=\"$cmd\"
+	  IFS=$save_ifs
+	  $opt_quiet || {
+	    func_quote_for_expand "$cmd"
+	    eval "func_echo $func_quote_for_expand_result"
+	  }
+	  $opt_dry_run || eval "$cmd" || {
+	    lt_exit=$?
+
+	    # Restore the uninstalled library and exit
+	    if test relink = "$opt_mode"; then
+	      ( cd "$output_objdir" && \
+	        $RM "${realname}T" && \
+		$MV "${realname}U" "$realname" )
+	    fi
+
+	    exit $lt_exit
+	  }
+	done
+	IFS=$save_ifs
+
+	# Restore the uninstalled library and exit
+	if test relink = "$opt_mode"; then
+	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
+
+	  if test -n "$convenience"; then
+	    if test -z "$whole_archive_flag_spec"; then
+	      func_show_eval '${RM}r "$gentop"'
+	    fi
+	  fi
+
+	  exit $EXIT_SUCCESS
+	fi
+
+	# Create links to the real library.
+	for linkname in $linknames; do
+	  if test "$realname" != "$linkname"; then
+	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
+	  fi
+	done
+
+	# If -module or -export-dynamic was specified, set the dlname.
+	if test yes = "$module" || test yes = "$export_dynamic"; then
+	  # On all known operating systems, these are identical.
+	  dlname=$soname
+	fi
+      fi
+      ;;
+
+    obj)
+      if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
+	func_warning "'-dlopen' is ignored for objects"
+      fi
+
+      case " $deplibs" in
+      *\ -l* | *\ -L*)
+	func_warning "'-l' and '-L' are ignored for objects" ;;
+      esac
+
+      test -n "$rpath" && \
+	func_warning "'-rpath' is ignored for objects"
+
+      test -n "$xrpath" && \
+	func_warning "'-R' is ignored for objects"
+
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for objects"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for objects"
+
+      case $output in
+      *.lo)
+	test -n "$objs$old_deplibs" && \
+	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
+
+	libobj=$output
+	func_lo2o "$libobj"
+	obj=$func_lo2o_result
+	;;
+      *)
+	libobj=
+	obj=$output
+	;;
+      esac
+
+      # Delete the old objects.
+      $opt_dry_run || $RM $obj $libobj
+
+      # Objects from convenience libraries.  This assumes
+      # single-version convenience libraries.  Whenever we create
+      # different ones for PIC/non-PIC, this we'll have to duplicate
+      # the extraction.
+      reload_conv_objs=
+      gentop=
+      # if reload_cmds runs $LD directly, get rid of -Wl from
+      # whole_archive_flag_spec and hope we can get by with turning comma
+      # into space.
+      case $reload_cmds in
+        *\$LD\ \$*) wl= ;;
+      esac
+      if test -n "$convenience"; then
+	if test -n "$whole_archive_flag_spec"; then
+	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
+	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
+	else
+	  gentop=$output_objdir/${obj}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $convenience
+	  reload_conv_objs="$reload_objs $func_extract_archives_result"
+	fi
+      fi
+
+      # If we're not building shared, we need to use non_pic_objs
+      test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
+
+      # Create the old-style object.
+      reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
+
+      output=$obj
+      func_execute_cmds "$reload_cmds" 'exit $?'
+
+      # Exit if we aren't doing a library object file.
+      if test -z "$libobj"; then
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      test yes = "$build_libtool_libs" || {
+	if test -n "$gentop"; then
+	  func_show_eval '${RM}r "$gentop"'
+	fi
+
+	# Create an invalid libtool object if no PIC, so that we don't
+	# accidentally link it into a program.
+	# $show "echo timestamp > $libobj"
+	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
+	exit $EXIT_SUCCESS
+      }
+
+      if test -n "$pic_flag" || test default != "$pic_mode"; then
+	# Only do commands if we really have different PIC objects.
+	reload_objs="$libobjs $reload_conv_objs"
+	output=$libobj
+	func_execute_cmds "$reload_cmds" 'exit $?'
+      fi
+
+      if test -n "$gentop"; then
+	func_show_eval '${RM}r "$gentop"'
+      fi
+
+      exit $EXIT_SUCCESS
+      ;;
+
+    prog)
+      case $host in
+	*cygwin*) func_stripname '' '.exe' "$output"
+	          output=$func_stripname_result.exe;;
+      esac
+      test -n "$vinfo" && \
+	func_warning "'-version-info' is ignored for programs"
+
+      test -n "$release" && \
+	func_warning "'-release' is ignored for programs"
+
+      $preload \
+	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
+	&& func_warning "'LT_INIT(dlopen)' not used. Assuming no dlopen support."
+
+      case $host in
+      *-*-rhapsody* | *-*-darwin1.012)
+	# On Rhapsody replace the C library is the System framework
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
+	;;
+      esac
+
+      case $host in
+      *-*-darwin*)
+	# Don't allow lazy linking, it breaks C++ global constructors
+	# But is supposedly fixed on 10.4 or later (yay!).
+	if test CXX = "$tagname"; then
+	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
+	    10.0123)
+	      func_append compile_command " $wl-bind_at_load"
+	      func_append finalize_command " $wl-bind_at_load"
+	    ;;
+	  esac
+	fi
+	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
+	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% $^ $*$.ltframework% -framework \1%g'`
+	;;
+      esac
+
+
+      # move library search paths that coincide with paths to not yet
+      # installed libraries to the beginning of the library search list
+      new_libs=
+      for path in $notinst_path; do
+	case " $new_libs " in
+	*" -L$path/$objdir "*) ;;
+	*)
+	  case " $compile_deplibs " in
+	  *" -L$path/$objdir "*)
+	    func_append new_libs " -L$path/$objdir" ;;
+	  esac
+	  ;;
+	esac
+      done
+      for deplib in $compile_deplibs; do
+	case $deplib in
+	-L*)
+	  case " $new_libs " in
+	  *" $deplib "*) ;;
+	  *) func_append new_libs " $deplib" ;;
+	  esac
+	  ;;
+	*) func_append new_libs " $deplib" ;;
+	esac
+      done
+      compile_deplibs=$new_libs
+
+
+      func_append compile_command " $compile_deplibs"
+      func_append finalize_command " $finalize_deplibs"
+
+      if test -n "$rpath$xrpath"; then
+	# If the user specified any rpath flags, then add them.
+	for libdir in $rpath $xrpath; do
+	  # This is the magic to use -rpath.
+	  case "$finalize_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_rpath " $libdir" ;;
+	  esac
+	done
+      fi
+
+      # Now hardcode the library paths
+      rpath=
+      hardcode_libdirs=
+      for libdir in $compile_rpath $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append perm_rpath " $libdir" ;;
+	  esac
+	fi
+	case $host in
+	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
+	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
+	  case :$dllsearchpath: in
+	  *":$libdir:"*) ;;
+	  ::) dllsearchpath=$libdir;;
+	  *) func_append dllsearchpath ":$libdir";;
+	  esac
+	  case :$dllsearchpath: in
+	  *":$testbindir:"*) ;;
+	  ::) dllsearchpath=$testbindir;;
+	  *) func_append dllsearchpath ":$testbindir";;
+	  esac
+	  ;;
+	esac
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      compile_rpath=$rpath
+
+      rpath=
+      hardcode_libdirs=
+      for libdir in $finalize_rpath; do
+	if test -n "$hardcode_libdir_flag_spec"; then
+	  if test -n "$hardcode_libdir_separator"; then
+	    if test -z "$hardcode_libdirs"; then
+	      hardcode_libdirs=$libdir
+	    else
+	      # Just accumulate the unique libdirs.
+	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
+	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
+		;;
+	      *)
+		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
+		;;
+	      esac
+	    fi
+	  else
+	    eval flag=\"$hardcode_libdir_flag_spec\"
+	    func_append rpath " $flag"
+	  fi
+	elif test -n "$runpath_var"; then
+	  case "$finalize_perm_rpath " in
+	  *" $libdir "*) ;;
+	  *) func_append finalize_perm_rpath " $libdir" ;;
+	  esac
+	fi
+      done
+      # Substitute the hardcoded libdirs into the rpath.
+      if test -n "$hardcode_libdir_separator" &&
+	 test -n "$hardcode_libdirs"; then
+	libdir=$hardcode_libdirs
+	eval rpath=\" $hardcode_libdir_flag_spec\"
+      fi
+      finalize_rpath=$rpath
+
+      if test -n "$libobjs" && test yes = "$build_old_libs"; then
+	# Transform all the library objects into standard objects.
+	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
+      fi
+
+      func_generate_dlsyms "$outputname" "@PROGRAM@" false
+
+      # template prelinking step
+      if test -n "$prelink_cmds"; then
+	func_execute_cmds "$prelink_cmds" 'exit $?'
+      fi
+
+      wrappers_required=:
+      case $host in
+      *cegcc* | *mingw32ce*)
+        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
+        wrappers_required=false
+        ;;
+      *cygwin* | *mingw* )
+        test yes = "$build_libtool_libs" || wrappers_required=false
+        ;;
+      *)
+        if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
+          wrappers_required=false
+        fi
+        ;;
+      esac
+      $wrappers_required || {
+	# Replace the output file specification.
+	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	link_command=$compile_command$compile_rpath
+
+	# We have no uninstalled library dependencies, so finalize right now.
+	exit_status=0
+	func_show_eval "$link_command" 'exit_status=$?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	# Delete the generated files.
+	if test -f "$output_objdir/${outputname}S.$objext"; then
+	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
+	fi
+
+	exit $exit_status
+      }
+
+      if test -n "$compile_shlibpath$finalize_shlibpath"; then
+	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
+      fi
+      if test -n "$finalize_shlibpath"; then
+	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
+      fi
+
+      compile_var=
+      finalize_var=
+      if test -n "$runpath_var"; then
+	if test -n "$perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+	if test -n "$finalize_perm_rpath"; then
+	  # We should set the runpath_var.
+	  rpath=
+	  for dir in $finalize_perm_rpath; do
+	    func_append rpath "$dir:"
+	  done
+	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
+	fi
+      fi
+
+      if test yes = "$no_install"; then
+	# We don't need to create a wrapper script.
+	link_command=$compile_var$compile_command$compile_rpath
+	# Replace the output file specification.
+	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
+	# Delete the old output file.
+	$opt_dry_run || $RM $output
+	# Link the executable and exit
+	func_show_eval "$link_command" 'exit $?'
+
+	if test -n "$postlink_cmds"; then
+	  func_to_tool_file "$output"
+	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	  func_execute_cmds "$postlink_cmds" 'exit $?'
+	fi
+
+	exit $EXIT_SUCCESS
+      fi
+
+      case $hardcode_action,$fast_install in
+        relink,*)
+	  # Fast installation is not supported
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+
+	  func_warning "this platform does not like uninstalled shared libraries"
+	  func_warning "'$output' will be relinked during installation"
+	  ;;
+        *,yes)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
+          ;;
+	*,no)
+	  link_command=$compile_var$compile_command$compile_rpath
+	  relink_command=$finalize_var$finalize_command$finalize_rpath
+          ;;
+	*,needless)
+	  link_command=$finalize_var$compile_command$finalize_rpath
+	  relink_command=
+          ;;
+      esac
+
+      # Replace the output file specification.
+      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
+
+      # Delete the old output files.
+      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
+
+      func_show_eval "$link_command" 'exit $?'
+
+      if test -n "$postlink_cmds"; then
+	func_to_tool_file "$output_objdir/$outputname"
+	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
+	func_execute_cmds "$postlink_cmds" 'exit $?'
+      fi
+
+      # Now create the wrapper script.
+      func_verbose "creating $output"
+
+      # Quote the relink command for shipping.
+      if test -n "$relink_command"; then
+	# Preserve any variables that may affect compiler behavior
+	for var in $variables_saved_for_relink; do
+	  if eval test -z \"\${$var+set}\"; then
+	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	  elif eval var_value=\$$var; test -z "$var_value"; then
+	    relink_command="$var=; export $var; $relink_command"
+	  else
+	    func_quote_for_eval "$var_value"
+	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	  fi
+	done
+	relink_command="(cd `pwd`; $relink_command)"
+	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      fi
+
+      # Only actually do things if not in dry run mode.
+      $opt_dry_run || {
+	# win32 will think the script is a binary if it has
+	# a .exe suffix, so we strip it off here.
+	case $output in
+	  *.exe) func_stripname '' '.exe' "$output"
+	         output=$func_stripname_result ;;
+	esac
+	# test for cygwin because mv fails w/o .exe extensions
+	case $host in
+	  *cygwin*)
+	    exeext=.exe
+	    func_stripname '' '.exe' "$outputname"
+	    outputname=$func_stripname_result ;;
+	  *) exeext= ;;
+	esac
+	case $host in
+	  *cygwin* | *mingw* )
+	    func_dirname_and_basename "$output" "" "."
+	    output_name=$func_basename_result
+	    output_path=$func_dirname_result
+	    cwrappersource=$output_path/$objdir/lt-$output_name.c
+	    cwrapper=$output_path/$output_name.exe
+	    $RM $cwrappersource $cwrapper
+	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_cwrapperexe_src > $cwrappersource
+
+	    # The wrapper executable is built using the $host compiler,
+	    # because it contains $host paths and files. If cross-
+	    # compiling, it, like the target executable, must be
+	    # executed on the $host or under an emulation environment.
+	    $opt_dry_run || {
+	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
+	      $STRIP $cwrapper
+	    }
+
+	    # Now, create the wrapper script for func_source use:
+	    func_ltwrapper_scriptname $cwrapper
+	    $RM $func_ltwrapper_scriptname_result
+	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
+	    $opt_dry_run || {
+	      # note: this script will not be executed, so do not chmod.
+	      if test "x$build" = "x$host"; then
+		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
+	      else
+		func_emit_wrapper no > $func_ltwrapper_scriptname_result
+	      fi
+	    }
+	  ;;
+	  * )
+	    $RM $output
+	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
+
+	    func_emit_wrapper no > $output
+	    chmod +x $output
+	  ;;
+	esac
+      }
+      exit $EXIT_SUCCESS
+      ;;
+    esac
+
+    # See if we need to build an old-fashioned archive.
+    for oldlib in $oldlibs; do
+
+      case $build_libtool_libs in
+        convenience)
+	  oldobjs="$libobjs_save $symfileobj"
+	  addlibs=$convenience
+	  build_libtool_libs=no
+	  ;;
+	module)
+	  oldobjs=$libobjs_save
+	  addlibs=$old_convenience
+	  build_libtool_libs=no
+          ;;
+	*)
+	  oldobjs="$old_deplibs $non_pic_objects"
+	  $preload && test -f "$symfileobj" \
+	    && func_append oldobjs " $symfileobj"
+	  addlibs=$old_convenience
+	  ;;
+      esac
+
+      if test -n "$addlibs"; then
+	gentop=$output_objdir/${outputname}x
+	func_append generated " $gentop"
+
+	func_extract_archives $gentop $addlibs
+	func_append oldobjs " $func_extract_archives_result"
+      fi
+
+      # Do each command in the archive commands.
+      if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
+	cmds=$old_archive_from_new_cmds
+      else
+
+	# Add any objects from preloaded convenience libraries
+	if test -n "$dlprefiles"; then
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+
+	  func_extract_archives $gentop $dlprefiles
+	  func_append oldobjs " $func_extract_archives_result"
+	fi
+
+	# POSIX demands no paths to be encoded in archives.  We have
+	# to avoid creating archives with duplicate basenames if we
+	# might have to extract them afterwards, e.g., when creating a
+	# static archive out of a convenience library, or when linking
+	# the entirety of a libtool archive into another (currently
+	# not supported by libtool).
+	if (for obj in $oldobjs
+	    do
+	      func_basename "$obj"
+	      $ECHO "$func_basename_result"
+	    done | sort | sort -uc >/dev/null 2>&1); then
+	  :
+	else
+	  echo "copying selected object files to avoid basename conflicts..."
+	  gentop=$output_objdir/${outputname}x
+	  func_append generated " $gentop"
+	  func_mkdir_p "$gentop"
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  counter=1
+	  for obj in $save_oldobjs
+	  do
+	    func_basename "$obj"
+	    objbase=$func_basename_result
+	    case " $oldobjs " in
+	    " ") oldobjs=$obj ;;
+	    *\ /"$objbase "*)
+	      while :; do
+		# Make sure we don't pick an alternate name that also
+		# overlaps.
+		newobj=lt$counter-$objbase
+		func_arith $counter + 1
+		counter=$func_arith_result
+		case " $oldobjs " in
+		*\ /"$newobj "*) ;;
+		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
+		esac
+	      done
+	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
+	      func_append oldobjs " $gentop/$newobj"
+	      ;;
+	    *) func_append oldobjs " $obj" ;;
+	    esac
+	  done
+	fi
+	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
+	tool_oldlib=$func_to_tool_file_result
+	eval cmds=\"$old_archive_cmds\"
+
+	func_len " $cmds"
+	len=$func_len_result
+	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
+	  cmds=$old_archive_cmds
+	elif test -n "$archiver_list_spec"; then
+	  func_verbose "using command file archive linking..."
+	  for obj in $oldobjs
+	  do
+	    func_to_tool_file "$obj"
+	    $ECHO "$func_to_tool_file_result"
+	  done > $output_objdir/$libname.libcmd
+	  func_to_tool_file "$output_objdir/$libname.libcmd"
+	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
+	  cmds=$old_archive_cmds
+	else
+	  # the command line is too long to link in one step, link in parts
+	  func_verbose "using piecewise archive linking..."
+	  save_RANLIB=$RANLIB
+	  RANLIB=:
+	  objlist=
+	  concat_cmds=
+	  save_oldobjs=$oldobjs
+	  oldobjs=
+	  # Is there a better way of finding the last object in the list?
+	  for obj in $save_oldobjs
+	  do
+	    last_oldobj=$obj
+	  done
+	  eval test_cmds=\"$old_archive_cmds\"
+	  func_len " $test_cmds"
+	  len0=$func_len_result
+	  len=$len0
+	  for obj in $save_oldobjs
+	  do
+	    func_len " $obj"
+	    func_arith $len + $func_len_result
+	    len=$func_arith_result
+	    func_append objlist " $obj"
+	    if test "$len" -lt "$max_cmd_len"; then
+	      :
+	    else
+	      # the above command should be used before it gets too long
+	      oldobjs=$objlist
+	      if test "$obj" = "$last_oldobj"; then
+		RANLIB=$save_RANLIB
+	      fi
+	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
+	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
+	      objlist=
+	      len=$len0
+	    fi
+	  done
+	  RANLIB=$save_RANLIB
+	  oldobjs=$objlist
+	  if test -z "$oldobjs"; then
+	    eval cmds=\"\$concat_cmds\"
+	  else
+	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
+	  fi
+	fi
+      fi
+      func_execute_cmds "$cmds" 'exit $?'
+    done
+
+    test -n "$generated" && \
+      func_show_eval "${RM}r$generated"
+
+    # Now create the libtool archive.
+    case $output in
+    *.la)
+      old_library=
+      test yes = "$build_old_libs" && old_library=$libname.$libext
+      func_verbose "creating $output"
+
+      # Preserve any variables that may affect compiler behavior
+      for var in $variables_saved_for_relink; do
+	if eval test -z \"\${$var+set}\"; then
+	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
+	elif eval var_value=\$$var; test -z "$var_value"; then
+	  relink_command="$var=; export $var; $relink_command"
+	else
+	  func_quote_for_eval "$var_value"
+	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
+	fi
+      done
+      # Quote the link command for shipping.
+      relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
+      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
+      if test yes = "$hardcode_automatic"; then
+	relink_command=
+      fi
+
+      # Only create the output if not a dry run.
+      $opt_dry_run || {
+	for installed in no yes; do
+	  if test yes = "$installed"; then
+	    if test -z "$install_libdir"; then
+	      break
+	    fi
+	    output=$output_objdir/${outputname}i
+	    # Replace all uninstalled libtool libraries with the installed ones
+	    newdependency_libs=
+	    for deplib in $dependency_libs; do
+	      case $deplib in
+	      *.la)
+		func_basename "$deplib"
+		name=$func_basename_result
+		func_resolve_sysroot "$deplib"
+		eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $func_resolve_sysroot_result`
+		test -z "$libdir" && \
+		  func_fatal_error "'$deplib' is not a valid libtool archive"
+		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      -L*)
+		func_stripname -L '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -L$func_replace_sysroot_result"
+		;;
+	      -R*)
+		func_stripname -R '' "$deplib"
+		func_replace_sysroot "$func_stripname_result"
+		func_append newdependency_libs " -R$func_replace_sysroot_result"
+		;;
+	      *) func_append newdependency_libs " $deplib" ;;
+	      esac
+	    done
+	    dependency_libs=$newdependency_libs
+	    newdlfiles=
+
+	    for lib in $dlfiles; do
+	      case $lib in
+	      *.la)
+	        func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      *) func_append newdlfiles " $lib" ;;
+	      esac
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+	      *.la)
+		# Only pass preopened files to the pseudo-archive (for
+		# eventual linking with the app. that links it) if we
+		# didn't already link the preopened objects directly into
+		# the library:
+		func_basename "$lib"
+		name=$func_basename_result
+		eval libdir=`$SED -n -e 's/^libdir=$.*$$/\1/p' $lib`
+		test -z "$libdir" && \
+		  func_fatal_error "'$lib' is not a valid libtool archive"
+		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
+		;;
+	      esac
+	    done
+	    dlprefiles=$newdlprefiles
+	  else
+	    newdlfiles=
+	    for lib in $dlfiles; do
+	      case $lib in
+		\\/* | A-Za-z:\\/*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlfiles " $abs"
+	    done
+	    dlfiles=$newdlfiles
+	    newdlprefiles=
+	    for lib in $dlprefiles; do
+	      case $lib in
+		\\/* | A-Za-z:\\/*) abs=$lib ;;
+		*) abs=`pwd`"/$lib" ;;
+	      esac
+	      func_append newdlprefiles " $abs"
+	    done
+	    dlprefiles=$newdlprefiles
+	  fi
+	  $RM $output
+	  # place dlname in correct position for cygwin
+	  # In fact, it would be nice if we could use this code for all target
+	  # systems that can't hard-code library paths into their executables
+	  # and that have no shared library path variable independent of PATH,
+	  # but it turns out we can't easily determine that from inspecting
+	  # libtool variables, so we have to hard-code the OSs to which it
+	  # applies here; at the moment, that means platforms that use the PE
+	  # object format with DLL files.  See the long comment at the top of
+	  # tests/bindir.at for full details.
+	  tdlname=$dlname
+	  case $host,$output,$installed,$module,$dlname in
+	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
+	      # If a -bindir argument was supplied, place the dll there.
+	      if test -n "$bindir"; then
+		func_relative_path "$install_libdir" "$bindir"
+		tdlname=$func_relative_path_result/$dlname
+	      else
+		# Otherwise fall back on heuristic.
+		tdlname=../bin/$dlname
+	      fi
+	      ;;
+	  esac
+	  $ECHO > $output "\
+# $outputname - a libtool library file
+# Generated by $PROGRAM (GNU $PACKAGE) $VERSION
+#
+# Please DO NOT delete this file!
+# It is necessary for linking the library.
+
+# The name that we can dlopen(3).
+dlname='$tdlname'
+
+# Names of this library.
+library_names='$library_names'
+
+# The name of the static archive.
+old_library='$old_library'
+
+# Linker flags that cannot go in dependency_libs.
+inherited_linker_flags='$new_inherited_linker_flags'
+
+# Libraries that this one depends upon.
+dependency_libs='$dependency_libs'
+
+# Names of additional weak libraries provided by this library
+weak_library_names='$weak_libs'
+
+# Version information for $libname.
+current=$current
+age=$age
+revision=$revision
+
+# Is this an already installed library?
+installed=$installed
+
+# Should we warn about portability when linking against -modules?
+shouldnotlink=$module
+
+# Files to dlopen/dlpreopen
+dlopen='$dlfiles'
+dlpreopen='$dlprefiles'
+
+# Directory that this library needs to be installed in:
+libdir='$install_libdir'"
+	  if test no,yes = "$installed,$need_relink"; then
+	    $ECHO >> $output "\
+relink_command=\"$relink_command\""
+	  fi
+	done
+      }
+
+      # Do a symbolic link so that the libtool archive can be found in
+      # LD_LIBRARY_PATH before the program is installed.
+      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
+      ;;
+    esac
+    exit $EXIT_SUCCESS
+}
+
+if test link = "$opt_mode" || test relink = "$opt_mode"; then
+  func_mode_link ${1+"$@"}
+fi
+
+
+# func_mode_uninstall arg...
+func_mode_uninstall ()
+{
+    $debug_cmd
+
+    RM=$nonopt
+    files=
+    rmforce=false
+    exit_status=0
+
+    # This variable tells wrapper scripts just to set variables rather
+    # than running their programs.
+    libtool_install_magic=$magic
+
+    for arg
+    do
+      case $arg in
+      -f) func_append RM " $arg"; rmforce=: ;;
+      -*) func_append RM " $arg" ;;
+      *) func_append files " $arg" ;;
+      esac
+    done
+
+    test -z "$RM" && \
+      func_fatal_help "you must specify an RM program"
+
+    rmdirs=
+
+    for file in $files; do
+      func_dirname "$file" "" "."
+      dir=$func_dirname_result
+      if test . = "$dir"; then
+	odir=$objdir
+      else
+	odir=$dir/$objdir
+      fi
+      func_basename "$file"
+      name=$func_basename_result
+      test uninstall = "$opt_mode" && odir=$dir
+
+      # Remember odir for removal later, being careful to avoid duplicates
+      if test clean = "$opt_mode"; then
+	case " $rmdirs " in
+	  *" $odir "*) ;;
+	  *) func_append rmdirs " $odir" ;;
+	esac
+      fi
+
+      # Don't error if the file doesn't exist and rm -f was used.
+      if { test -L "$file"; } >/dev/null 2>&1 ||
+	 { test -h "$file"; } >/dev/null 2>&1 ||
+	 test -f "$file"; then
+	:
+      elif test -d "$file"; then
+	exit_status=1
+	continue
+      elif $rmforce; then
+	continue
+      fi
+
+      rmfiles=$file
+
+      case $name in
+      *.la)
+	# Possibly a libtool archive, so verify it.
+	if func_lalib_p "$file"; then
+	  func_source $dir/$name
+
+	  # Delete the libtool libraries and symlinks.
+	  for n in $library_names; do
+	    func_append rmfiles " $odir/$n"
+	  done
+	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
+
+	  case $opt_mode in
+	  clean)
+	    case " $library_names " in
+	    *" $dlname "*) ;;
+	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
+	    esac
+	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
+	    ;;
+	  uninstall)
+	    if test -n "$library_names"; then
+	      # Do each command in the postuninstall commands.
+	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+
+	    if test -n "$old_library"; then
+	      # Do each command in the old_postuninstall commands.
+	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
+	    fi
+	    # FIXME: should reinstall the best remaining shared library.
+	    ;;
+	  esac
+	fi
+	;;
+
+      *.lo)
+	# Possibly a libtool object, so verify it.
+	if func_lalib_p "$file"; then
+
+	  # Read the .lo file
+	  func_source $dir/$name
+
+	  # Add PIC object to the list of files to remove.
+	  if test -n "$pic_object" && test none != "$pic_object"; then
+	    func_append rmfiles " $dir/$pic_object"
+	  fi
+
+	  # Add non-PIC object to the list of files to remove.
+	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
+	    func_append rmfiles " $dir/$non_pic_object"
+	  fi
+	fi
+	;;
+
+      *)
+	if test clean = "$opt_mode"; then
+	  noexename=$name
+	  case $file in
+	  *.exe)
+	    func_stripname '' '.exe' "$file"
+	    file=$func_stripname_result
+	    func_stripname '' '.exe' "$name"
+	    noexename=$func_stripname_result
+	    # $file with .exe has already been added to rmfiles,
+	    # add $file without .exe
+	    func_append rmfiles " $file"
+	    ;;
+	  esac
+	  # Do a test to see if this is a libtool program.
+	  if func_ltwrapper_p "$file"; then
+	    if func_ltwrapper_executable_p "$file"; then
+	      func_ltwrapper_scriptname "$file"
+	      relink_command=
+	      func_source $func_ltwrapper_scriptname_result
+	      func_append rmfiles " $func_ltwrapper_scriptname_result"
+	    else
+	      relink_command=
+	      func_source $dir/$noexename
+	    fi
+
+	    # note $name still contains .exe if it was in $file originally
+	    # as does the version of $file that was added into $rmfiles
+	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
+	    if test yes = "$fast_install" && test -n "$relink_command"; then
+	      func_append rmfiles " $odir/lt-$name"
+	    fi
+	    if test "X$noexename" != "X$name"; then
+	      func_append rmfiles " $odir/lt-$noexename.c"
+	    fi
+	  fi
+	fi
+	;;
+      esac
+      func_show_eval "$RM $rmfiles" 'exit_status=1'
+    done
+
+    # Try to remove the $objdir's in the directories where we deleted files
+    for dir in $rmdirs; do
+      if test -d "$dir"; then
+	func_show_eval "rmdir $dir >/dev/null 2>&1"
+      fi
+    done
+
+    exit $exit_status
+}
+
+if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
+  func_mode_uninstall ${1+"$@"}
+fi
+
+test -z "$opt_mode" && {
+  help=$generic_help
+  func_fatal_help "you must specify a MODE"
+}
+
+test -z "$exec_cmd" && \
+  func_fatal_help "invalid operation mode '$opt_mode'"
+
+if test -n "$exec_cmd"; then
+  eval exec "$exec_cmd"
+  exit $EXIT_FAILURE
+fi
+
+exit $exit_status
+
+
+# The TAGs below are defined such that we never get into a situation
+# where we disable both kinds of libraries.  Given conflicting
+# choices, we go for a static library, that is the most portable,
+# since we can't tell whether shared libraries were disabled because
+# the user asked for that or because the platform doesn't support
+# them.  This is particularly important on AIX, because we don't
+# support having both static and shared libraries enabled at the same
+# time on that platform, so we default to a shared-only configuration.
+# If a disable-shared tag is given, we'll fallback to a static-only
+# configuration.  But we'll never go from static-only to shared-only.
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
+build_libtool_libs=no
+build_old_libs=yes
+# ### END LIBTOOL TAG CONFIG: disable-shared
+
+# ### BEGIN LIBTOOL TAG CONFIG: disable-static
+build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
+# ### END LIBTOOL TAG CONFIG: disable-static
+
+# Local Variables:
+# mode:shell-script
+# sh-indentation:2
+# End:

_service:tar_scm:isl-0.24.tar.gz/interface/missing Added

@@ -0,0 +1,215 @@
+#! /bin/sh
+# Common wrapper for a few potentially missing GNU programs.
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
+# Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+if test $# -eq 0; then
+  echo 1>&2 "Try '$0 --help' for more information"
+  exit 1
+fi
+
+case $1 in
+
+  --is-lightweight)
+    # Used by our autoconf macros to check whether the available missing
+    # script is modern enough.
+    exit 0
+    ;;
+
+  --run)
+    # Back-compat with the calling convention used by older automake.
+    shift
+    ;;
+
+  -h|--h|--he|--hel|--help)
+    echo "\
+$0 OPTION... PROGRAM ARGUMENT...
+
+Run 'PROGRAM ARGUMENT...', returning a proper advice when this fails due
+to PROGRAM being missing or too old.
+
+Options:
+  -h, --help      display this help and exit
+  -v, --version   output version information and exit
+
+Supported PROGRAM values:
+  aclocal   autoconf  autoheader   autom4te  automake  makeinfo
+  bison     yacc      flex         lex       help2man
+
+Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and
+'g' are ignored when checking the name.
+
+Send bug reports to <bug-automake@gnu.org>."
+    exit $?
+    ;;
+
+  -v|--v|--ve|--ver|--vers|--versi|--versio|--version)
+    echo "missing $scriptversion (GNU Automake)"
+    exit $?
+    ;;
+
+  -*)
+    echo 1>&2 "$0: unknown '$1' option"
+    echo 1>&2 "Try '$0 --help' for more information"
+    exit 1
+    ;;
+
+esac
+
+# Run the given program, remember its exit status.
+"$@"; st=$?
+
+# If it succeeded, we are done.
+test $st -eq 0 && exit 0
+
+# Also exit now if we it failed (or wasn't found), and '--version' was
+# passed; such an option is passed most likely to detect whether the
+# program is present and works.
+case $2 in --version|--help) exit $st;; esac
+
+# Exit code 63 means version mismatch.  This often happens when the user
+# tries to use an ancient version of a tool on a file that requires a
+# minimum version.
+if test $st -eq 63; then
+  msg="probably too old"
+elif test $st -eq 127; then
+  # Program was missing.
+  msg="missing on your system"
+else
+  # Program was found and executed, but failed.  Give up.
+  exit $st
+fi
+
+perl_URL=https://www.perl.org/
+flex_URL=https://github.com/westes/flex
+gnu_software_URL=https://www.gnu.org/software
+
+program_details ()
+{
+  case $1 in
+    aclocal|automake)
+      echo "The '$1' program is part of the GNU Automake package:"
+      echo "<$gnu_software_URL/automake>"
+      echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/autoconf>"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+    autoconf|autom4te|autoheader)
+      echo "The '$1' program is part of the GNU Autoconf package:"
+      echo "<$gnu_software_URL/autoconf/>"
+      echo "It also requires GNU m4 and Perl in order to run:"
+      echo "<$gnu_software_URL/m4/>"
+      echo "<$perl_URL>"
+      ;;
+  esac
+}
+
+give_advice ()
+{
+  # Normalize program name to check for.
+  normalized_program=`echo "$1" | sed '
+    s/^gnu-//; t
+    s/^gnu//; t
+    s/^g//; t'`
+
+  printf '%s\n' "'$1' is $msg."
+
+  configure_deps="'configure.ac' or m4 files included by 'configure.ac'"
+  case $normalized_program in
+    autoconf*)
+      echo "You should only need it if you modified 'configure.ac',"
+      echo "or m4 files included by it."
+      program_details 'autoconf'
+      ;;
+    autoheader*)
+      echo "You should only need it if you modified 'acconfig.h' or"
+      echo "$configure_deps."
+      program_details 'autoheader'
+      ;;
+    automake*)
+      echo "You should only need it if you modified 'Makefile.am' or"
+      echo "$configure_deps."
+      program_details 'automake'
+      ;;
+    aclocal*)
+      echo "You should only need it if you modified 'acinclude.m4' or"
+      echo "$configure_deps."
+      program_details 'aclocal'
+      ;;
+   autom4te*)
+      echo "You might have modified some maintainer files that require"
+      echo "the 'autom4te' program to be rebuilt."
+      program_details 'autom4te'
+      ;;
+    bison*|yacc*)
+      echo "You should only need it if you modified a '.y' file."
+      echo "You may want to install the GNU Bison package:"
+      echo "<$gnu_software_URL/bison/>"
+      ;;
+    lex*|flex*)
+      echo "You should only need it if you modified a '.l' file."
+      echo "You may want to install the Fast Lexical Analyzer package:"
+      echo "<$flex_URL>"
+      ;;
+    help2man*)
+      echo "You should only need it if you modified a dependency" \
+           "of a man page."
+      echo "You may want to install the GNU Help2man package:"
+      echo "<$gnu_software_URL/help2man/>"
+    ;;
+    makeinfo*)
+      echo "You should only need it if you modified a '.texi' file, or"
+      echo "any other file indirectly affecting the aspect of the manual."
+      echo "You might want to install the Texinfo package:"
+      echo "<$gnu_software_URL/texinfo/>"
+      echo "The spurious makeinfo call might also be the consequence of"
+      echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might"
+      echo "want to install GNU make:"
+      echo "<$gnu_software_URL/make/>"
+      ;;
+    *)
+      echo "You might have modified some files without having the proper"
+      echo "tools for further handling them.  Check the 'README' file, it"
+      echo "often tells you about the needed prerequisites for installing"
+      echo "this package.  You may also peek at any GNU archive site, in"
+      echo "case some other package contains this missing '$1' program."
+      ;;
+  esac
+}
+
+give_advice "$1" | sed -e '1s/^/WARNING: /' \
+                       -e '2,$s/^/         /' >&2
+
+# Propagate the correct exit status (expected to be 127 for a program
+# not found, 63 for a program that failed due to version mismatch).
+exit $st
+
+# Local variables:
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:

_service:tar_scm:isl-0.24.tar.gz/interface/plain_cpp.cc Added

@@ -0,0 +1,1917 @@
+/*
+ * Copyright 2016, 2017 Tobias Grosser. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY TOBIAS GROSSER ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL TOBIAS GROSSER OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as
+ * representing official policies, either expressed or implied, of
+ * Tobias Grosser.
+ */
+
+#include <cstdarg>
+#include <cstdio>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "plain_cpp.h"
+#include "isl_config.h"
+
+/* Print string formatted according to "fmt" to ostream "os".
+ *
+ * This osprintf method allows us to use printf style formatting constructs when
+ * writing to an ostream.
+ */
+static void osprintf(ostream &os, const char *format, va_list arguments)
+{
+	va_list copy;
+	char *string_pointer;
+	size_t size;
+
+	va_copy(copy, arguments);
+	size = vsnprintf(NULL, 0, format, copy);
+	string_pointer = new charsize + 1;
+	va_end(copy);
+	vsnprintf(string_pointer, size + 1, format, arguments);
+	os << string_pointer;
+	delete string_pointer;
+}
+
+/* Print string formatted according to "fmt" to ostream "os".
+ *
+ * This osprintf method allows us to use printf style formatting constructs when
+ * writing to an ostream.
+ */
+static void osprintf(ostream &os, const char *format, ...)
+{
+	va_list arguments;
+
+	va_start(arguments, format);
+	osprintf(os, format, arguments);
+	va_end(arguments);
+}
+
+/* Print string formatted according to "fmt" to ostream "os"
+ * with the given indentation.
+ *
+ * This osprintf method allows us to use printf style formatting constructs when
+ * writing to an ostream.
+ */
+static void osprintf(ostream &os, int indent, const char *format, ...)
+{
+	va_list arguments;
+
+	osprintf(os, "%*s", indent, " ");
+	va_start(arguments, format);
+	osprintf(os, format, arguments);
+	va_end(arguments);
+}
+
+/* Convert "l" to a string.
+ */
+static std::string to_string(long l)
+{
+	std::ostringstream strm;
+	strm << l;
+	return strm.str();
+}
+
+/* Construct a generator for plain C++ bindings.
+ *
+ * "checked" is set if C++ bindings should be generated
+ * that rely on the user to check for error conditions.
+ */
+plain_cpp_generator::plain_cpp_generator(SourceManager &SM,
+	set<RecordDecl *> &exported_types,
+	set<FunctionDecl *> exported_functions, set<FunctionDecl *> functions,
+	bool checked) :
+		cpp_generator(SM, exported_types, exported_functions,
+			functions),
+		checked(checked)
+{
+}
+
+/* Generate a cpp interface based on the extracted types and functions.
+ *
+ * Print first a set of forward declarations for all isl wrapper
+ * classes, then the declarations of the classes, and at the end all
+ * implementations.
+ *
+ * If checked C++ bindings are being generated,
+ * then wrap them in a namespace to avoid conflicts
+ * with the default C++ bindings (with automatic checks using exceptions).
+ */
+void plain_cpp_generator::generate()
+{
+	ostream &os = cout;
+
+	osprintf(os, "\n");
+	osprintf(os, "namespace isl {\n\n");
+	if (checked)
+		osprintf(os, "namespace checked {\n\n");
+
+	print_forward_declarations(os);
+	osprintf(os, "\n");
+	print_declarations(os);
+	osprintf(os, "\n");
+	print_implementations(os);
+
+	if (checked)
+		osprintf(os, "} // namespace checked\n");
+	osprintf(os, "} // namespace isl\n");
+}
+
+/* Print forward declarations for all classes to "os".
+*/
+void plain_cpp_generator::print_forward_declarations(ostream &os)
+{
+	map<string, isl_class>::iterator ci;
+
+	osprintf(os, "// forward declarations\n");
+
+	for (ci = classes.begin(); ci != classes.end(); ++ci)
+		print_class_forward_decl(os, ci->second);
+}
+
+/* Print all declarations to "os".
+ */
+void plain_cpp_generator::print_declarations(ostream &os)
+{
+	map<string, isl_class>::iterator ci;
+	bool first = true;
+
+	for (ci = classes.begin(); ci != classes.end(); ++ci) {
+		if (first)
+			first = false;
+		else
+			osprintf(os, "\n");
+
+		print_class(os, ci->second);
+	}
+}
+
+/* Print all implementations to "os".
+ */
+void plain_cpp_generator::print_implementations(ostream &os)
+{
+	map<string, isl_class>::iterator ci;
+	bool first = true;
+
+	for (ci = classes.begin(); ci != classes.end(); ++ci) {
+		if (first)
+			first = false;
+		else
+			osprintf(os, "\n");
+
+		print_class_impl(os, ci->second);
+	}
+}
+
+/* If the printed class is a subclass that is based on a type function,
+ * then introduce a "type" field that holds the value of the type
+ * corresponding to the subclass and make the fields of the class
+ * accessible to the "isa" and "as" methods of the (immediate) superclass.
+ * In particular, "isa" needs access to the type field itself,
+ * while "as" needs access to the private constructor.
+ * In case of the "isa" method, all instances are made friends
+ * to avoid access right confusion.
+ */
+void plain_cpp_generator::decl_printer::print_subclass_type()
+{
+	std::string super;
+	const char *cppname = cppstring.c_str();
+	const char *supername;
+
+	if (!clazz.is_type_subclass())
+		return;
+
+	super = type2cpp(clazz.superclass_name);
+	supername = super.c_str();
+	osprintf(os, "  template <class T>\n");
+	osprintf(os, "  friend %s %s::isa() const;\n",
+		generator.isl_bool2cpp().c_str(), supername);
+	osprintf(os, "  friend %s %s::as<%s>() const;\n",
+		cppname, supername, cppname);
+	osprintf(os, "  static const auto type = %s;\n",
+		clazz.subclass_name.c_str());
+}
+
+/* Print declarations for class "clazz" to "os".
+ *
+ * If "clazz" is a subclass based on a type function,
+ * then it is made to inherit from the (immediate) superclass and
+ * a "type" attribute is added for use in the "as" and "isa"
+ * methods of the superclass.
+ *
+ * Conversely, if "clazz" is a superclass with a type function,
+ * then declare those "as" and "isa" methods.
+ *
+ * The pointer to the isl object is only added for classes that
+ * are not subclasses, since subclasses refer to the same isl object.
+ */
+void plain_cpp_generator::print_class(ostream &os, const isl_class &clazz)
+{
+	decl_printer printer(os, clazz, *this);
+	const char *name = clazz.name.c_str();
+	const char *cppname = printer.cppstring.c_str();
+
+	osprintf(os, "// declarations for isl::%s\n", cppname);
+
+	printer.print_class_factory();
+	osprintf(os, "\n");
+	osprintf(os, "class %s ", cppname);
+	if (clazz.is_type_subclass())
+		osprintf(os, ": public %s ",
+			type2cpp(clazz.superclass_name).c_str());
+	osprintf(os, "{\n");
+	printer.print_subclass_type();
+	printer.print_class_factory("  friend ");
+	osprintf(os, "\n");
+	osprintf(os, "protected:\n");
+	if (!clazz.is_type_subclass()) {
+		osprintf(os, "  %s *ptr = nullptr;\n", name);
+		osprintf(os, "\n");
+	}
+	printer.print_protected_constructors();
+	osprintf(os, "\n");
+	osprintf(os, "public:\n");
+	printer.print_public_constructors();
+	printer.print_constructors();
+	printer.print_copy_assignment();
+	printer.print_destructor();
+	printer.print_ptr();
+	printer.print_downcast();
+	printer.print_ctx();
+	osprintf(os, "\n");
+	printer.print_persistent_callbacks();
+	printer.print_methods();
+	printer.print_set_enums();
+
+	osprintf(os, "};\n");
+}
+
+/* Print forward declaration of class "clazz" to "os".
+ */
+void plain_cpp_generator::print_class_forward_decl(ostream &os,
+	const isl_class &clazz)
+{
+	std::string cppstring = type2cpp(clazz);
+	const char *cppname = cppstring.c_str();
+
+	osprintf(os, "class %s;\n", cppname);
+}
+
+/* Print global factory functions.
+ *
+ * Each class has two global factory functions:
+ *
+ * 	set manage(__isl_take isl_set *ptr);
+ * 	set manage_copy(__isl_keep isl_set *ptr);
+ *
+ * A user can construct isl C++ objects from a raw pointer and indicate whether
+ * they intend to take the ownership of the object or not through these global
+ * factory functions. This ensures isl object creation is very explicit and
+ * pointers are not converted by accident. Thanks to overloading, manage() and
+ * manage_copy() can be called on any isl raw pointer and the corresponding
+ * object is automatically created, without the user having to choose the right
+ * isl object type.
+ *
+ * For a subclass based on a type function, no factory functions
+ * are introduced because they share the C object type with
+ * the superclass.
+ */
+void plain_cpp_generator::decl_printer::print_class_factory(
+	const std::string &prefix)
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	if (clazz.is_type_subclass())
+		return;
+
+	os << prefix;
+	osprintf(os, "inline %s manage(__isl_take %s *ptr);\n", cppname, name);
+	os << prefix;
+	osprintf(os, "inline %s manage_copy(__isl_keep %s *ptr);\n",
+		cppname, name);
+}
+
+/* Print declarations of protected constructors.
+ *
+ * Each class has currently one protected constructor:
+ *
+ * 	1) Constructor from a plain isl_* C pointer
+ *
+ * Example:
+ *
+ * 	set(__isl_take isl_set *ptr);
+ *
+ * The raw pointer constructor is kept protected. Object creation is only
+ * possible through manage() or manage_copy().
+ */
+void plain_cpp_generator::decl_printer::print_protected_constructors()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	osprintf(os, "  inline explicit %s(__isl_take %s *ptr);\n", cppname,
+		 name);
+}
+
+/* Print declarations of public constructors.
+ *
+ * Each class currently has two public constructors:
+ *
+ * 	1) A default constructor
+ * 	2) A copy constructor
+ *
+ * Example:
+ *
+ *	set();
+ *	set(const set &set);
+ */
+void plain_cpp_generator::decl_printer::print_public_constructors()
+{
+	const char *cppname = cppstring.c_str();
+	osprintf(os, "  inline /* implicit */ %s();\n", cppname);
+
+	osprintf(os, "  inline /* implicit */ %s(const %s &obj);\n",
+		 cppname, cppname);
+}
+
+/* Print declarations for "method".
+ */
+void plain_cpp_generator::decl_printer::print_method(
+	const ConversionMethod &method)
+{
+	print_full_method_header(method);
+}
+
+/* Print declarations for "method".
+ */
+void plain_cpp_generator::decl_printer::print_method(const Method &method)
+{
+	print_full_method_header(method);
+}
+
+/* Print declarations of copy assignment operator.
+ *
+ * Each class has one assignment operator.
+ *
+ * 	isl:set &set::operator=(set obj)
+ *
+ */
+void plain_cpp_generator::decl_printer::print_copy_assignment()
+{
+	const char *cppname = cppstring.c_str();
+
+	osprintf(os, "  inline %s &operator=(%s obj);\n", cppname, cppname);
+}
+
+/* Print declaration of destructor.
+ *
+ * No explicit destructor is needed for type based subclasses.
+ */
+void plain_cpp_generator::decl_printer::print_destructor()
+{
+	const char *cppname = cppstring.c_str();
+
+	if (clazz.is_type_subclass())
+		return;
+
+	osprintf(os, "  inline ~%s();\n", cppname);
+}
+
+/* Print declaration of pointer functions.
+ * Since type based subclasses share the pointer with their superclass,
+ * they can also reuse these functions from the superclass.
+ *
+ * To obtain a raw pointer three functions are provided:
+ *
+ * 	1) __isl_give isl_set *copy()
+ *
+ * 	  Returns a pointer to a _copy_ of the internal object
+ *
+ * 	2) __isl_keep isl_set *get()
+ *
+ * 	  Returns a pointer to the internal object
+ *
+ * 	3) __isl_give isl_set *release()
+ *
+ * 	  Returns a pointer to the internal object and resets the
+ * 	  internal pointer to nullptr.
+ *
+ * We also provide functionality to explicitly check if a pointer is
+ * currently managed by this object.
+ *
+ * 	4) bool is_null()
+ *
+ * 	  Check if the current object is a null pointer.
+ *
+ * The functions get() and release() model the value_ptr proposed in
+ * http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3339.pdf.
+ * The copy() function is an extension to allow the user to explicitly
+ * copy the underlying object.
+ *
+ * Also generate a declaration to delete copy() for r-values, for
+ * r-values release() should be used to avoid unnecessary copies.
+ */
+void plain_cpp_generator::decl_printer::print_ptr()
+{
+	const char *name = clazz.name.c_str();
+
+	if (clazz.is_type_subclass())
+		return;
+
+	osprintf(os, "  inline __isl_give %s *copy() const &;\n", name);
+	osprintf(os, "  inline __isl_give %s *copy() && = delete;\n", name);
+	osprintf(os, "  inline __isl_keep %s *get() const;\n", name);
+	osprintf(os, "  inline __isl_give %s *release();\n", name);
+	osprintf(os, "  inline bool is_null() const;\n");
+}
+
+/* Print a template declaration with given indentation
+ * for the "isa_type" method that ensures it is only enabled
+ * when called with a template argument
+ * that represents a type that is equal to that
+ * of the return type of the type function of "super".
+ * In particular, "isa_type" gets called from "isa"
+ * with as template argument the type of the "type" field
+ * of the subclass.
+ * The check ensures that this subclass is in fact a direct subclass
+ * of "super".
+ */
+void plain_cpp_generator::decl_printer::print_isa_type_template(int indent,
+	const isl_class &super)
+{
+	osprintf(os, indent,
+		"template <typename T,\n");
+	osprintf(os, indent,
+		"        typename = typename std::enable_if<std::is_same<\n");
+	osprintf(os, indent,
+		"                const decltype(%s(NULL)),\n",
+		super.fn_type->getNameAsString().c_str());
+	osprintf(os, indent,
+		"                const T>::value>::type>\n");
+}
+
+/* Print declarations for the "as" and "isa" methods, if the printed class
+ * is a superclass with a type function.
+ *
+ * "isa" checks whether an object is of a given subclass type.
+ * "isa_type" does the same, but gets passed the value of the type field
+ * of the subclass as a function argument and the type of this field
+ * as a template argument.
+ * "as" tries to cast an object to a given subclass type, returning
+ * an invalid object if the object is not of the given type.
+ */
+void plain_cpp_generator::decl_printer::print_downcast()
+{
+	if (!clazz.fn_type)
+		return;
+
+	osprintf(os, "private:\n");
+	print_isa_type_template(2, clazz);
+	osprintf(os, "  inline %s isa_type(T subtype) const;\n",
+		generator.isl_bool2cpp().c_str());
+	osprintf(os, "public:\n");
+	osprintf(os, "  template <class T> inline %s isa() const;\n",
+		generator.isl_bool2cpp().c_str());
+	osprintf(os, "  template <class T> inline T as() const;\n");
+}
+
+/* Print the declaration of the ctx method.
+ */
+void plain_cpp_generator::decl_printer::print_ctx()
+{
+	std::string ns = generator.isl_namespace();
+
+	osprintf(os, "  inline %sctx ctx() const;\n", ns.c_str());
+}
+
+/* Add a space to the return type "type" if needed,
+ * i.e., if it is not the type of a pointer.
+ */
+static string add_space_to_return_type(const string &type)
+{
+	if (typetype.size() - 1 == '*')
+		return type;
+	return type + " ";
+}
+
+/* Print the prototype of the static inline method that is used
+ * as the C callback set by "method".
+ */
+void plain_cpp_generator::plain_printer::print_persistent_callback_prototype(
+	FunctionDecl *method)
+{
+	string callback_name, rettype, c_args;
+	ParmVarDecl *param = persistent_callback_arg(method);
+	const FunctionProtoType *callback;
+	QualType ptype;
+	string classname;
+
+	ptype = param->getType();
+	callback = extract_prototype(ptype);
+
+	rettype = callback->getReturnType().getAsString();
+	rettype = add_space_to_return_type(rettype);
+	callback_name = clazz.persistent_callback_name(method);
+	c_args = generator.generate_callback_args(ptype, false);
+
+	if (!declarations)
+		classname = type2cpp(clazz) + "::";
+
+	osprintf(os, "%s%s%s(%s)",
+		 rettype.c_str(), classname.c_str(),
+		 callback_name.c_str(), c_args.c_str());
+}
+
+/* Print the prototype of the method for setting the callback function
+ * set by "method".
+ */
+void
+plain_cpp_generator::plain_printer::print_persistent_callback_setter_prototype(
+	FunctionDecl *method)
+{
+	string classname, callback_name, cpptype;
+	ParmVarDecl *param = persistent_callback_arg(method);
+
+	if (!declarations)
+		classname = type2cpp(clazz) + "::";
+
+	cpptype = generator.param2cpp(param->getOriginalType());
+	callback_name = clazz.persistent_callback_name(method);
+	osprintf(os, "void %sset_%s_data(const %s &%s)",
+		classname.c_str(), callback_name.c_str(), cpptype.c_str(),
+		param->getName().str().c_str());
+}
+
+/* Given a method "method" for setting a persistent callback,
+ * print the fields that are needed for marshalling the callback.
+ *
+ * In particular, print
+ * - the declaration of a data structure for storing the C++ callback function
+ * - a shared pointer to such a data structure
+ * - the declaration of a static inline method
+ *   for use as the C callback function
+ * - the declaration of a private method for setting the callback function
+ */
+void plain_cpp_generator::decl_printer::print_persistent_callback_data(
+	FunctionDecl *method)
+{
+	string callback_name;
+	ParmVarDecl *param = generator.persistent_callback_arg(method);
+
+	callback_name = clazz.persistent_callback_name(method);
+	print_callback_data_decl(param, callback_name);
+	osprintf(os, ";\n");
+	osprintf(os, "  std::shared_ptr<%s_data> %s_data;\n",
+		callback_name.c_str(), callback_name.c_str());
+	osprintf(os, "  static inline ");
+	print_persistent_callback_prototype(method);
+	osprintf(os, ";\n");
+	osprintf(os, "  inline ");
+	print_persistent_callback_setter_prototype(method);
+	osprintf(os, ";\n");
+}
+
+/* Print declarations needed for the persistent callbacks of the class.
+ *
+ * In particular, if there are any persistent callbacks, then
+ * print a private method for copying callback data from
+ * one object to another,
+ * private data for keeping track of the persistent callbacks and
+ * public methods for setting the persistent callbacks.
+ */
+void plain_cpp_generator::decl_printer::print_persistent_callbacks()
+{
+	const char *cppname = cppstring.c_str();
+
+	if (!clazz.has_persistent_callbacks())
+		return;
+
+	osprintf(os, "private:\n");
+	osprintf(os, "  inline %s &copy_callbacks(const %s &obj);\n",
+		cppname, cppname);
+	for (const auto &callback : clazz.persistent_callbacks)
+		print_persistent_callback_data(callback);
+
+	osprintf(os, "public:\n");
+	for (const auto &callback : clazz.persistent_callbacks)
+		print_method(Method(clazz, callback));
+}
+
+/* Print a declaration for the "get" method "fd",
+ * using a name that includes the "get_" prefix.
+ */
+void plain_cpp_generator::decl_printer::print_get_method(FunctionDecl *fd)
+{
+	string base = clazz.base_method_name(fd);
+
+	print_method(Method(clazz, fd, base));
+}
+
+/* Print implementations for class "clazz" to "os".
+ */
+void plain_cpp_generator::print_class_impl(ostream &os, const isl_class &clazz)
+{
+	impl_printer printer(os, clazz, *this);
+	const char *cppname = printer.cppstring.c_str();
+
+	osprintf(os, "// implementations for isl::%s", cppname);
+
+	printer.print_class_factory();
+	printer.print_public_constructors();
+	printer.print_protected_constructors();
+	printer.print_constructors();
+	printer.print_copy_assignment();
+	printer.print_destructor();
+	printer.print_ptr();
+	printer.print_downcast();
+	printer.print_ctx();
+	printer.print_persistent_callbacks();
+	printer.print_methods();
+	printer.print_set_enums();
+	printer.print_stream_insertion();
+}
+
+/* Print code for throwing an exception corresponding to the last error
+ * that occurred on "saved_ctx".
+ * This assumes that a valid isl::ctx is available in the "saved_ctx" variable,
+ * e.g., through a prior call to print_save_ctx.
+ */
+static void print_throw_last_error(ostream &os)
+{
+	osprintf(os, "    exception::throw_last_error(saved_ctx);\n");
+}
+
+/* Print code with the given indentation
+ * for throwing an exception_invalid with the given message.
+ */
+static void print_throw_invalid(ostream &os, int indent, const char *msg)
+{
+	osprintf(os, indent,
+		"exception::throw_invalid(\"%s\", __FILE__, __LINE__);\n", msg);
+}
+
+/* Print code for throwing an exception on NULL input.
+ */
+static void print_throw_NULL_input(ostream &os)
+{
+	print_throw_invalid(os, 4, "NULL input");
+}
+
+/* Print code with the given indentation
+ * for acting on an invalid error with message "msg".
+ * In particular, throw an exception_invalid.
+ * In the checked C++ bindings, isl_die is called instead with the code
+ * in "checked_code".
+ */
+void plain_cpp_generator::print_invalid(ostream &os, int indent,
+	const char *msg, const char *checked_code)
+{
+	if (checked)
+		osprintf(os, indent,
+			"isl_die(ctx().get(), isl_error_invalid, "
+			"\"%s\", %s);\n", msg, checked_code);
+	else
+		print_throw_invalid(os, indent, msg);
+}
+
+/* Print an operator for inserting objects of the class
+ * into an output stream.
+ *
+ * Unless checked C++ bindings are being generated,
+ * the operator requires its argument to be non-NULL.
+ * An exception is thrown if anything went wrong during the printing.
+ * During this printing, isl is made not to print any error message
+ * because the error message is included in the exception.
+ *
+ * If checked C++ bindings are being generated and anything went wrong,
+ * then record this failure in the output stream.
+ */
+void plain_cpp_generator::impl_printer::print_stream_insertion()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	if (!clazz.fn_to_str)
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "inline std::ostream &operator<<(std::ostream &os, ");
+	osprintf(os, "const %s &obj)\n", cppname);
+	osprintf(os, "{\n");
+	print_check_ptr_start("obj.get()");
+	osprintf(os, "  char *str = %s_to_str(obj.get());\n", name);
+	print_check_ptr_end("str");
+	if (generator.checked) {
+		osprintf(os, "  if (!str) {\n");
+		osprintf(os, "    os.setstate(std::ios_base::badbit);\n");
+		osprintf(os, "    return os;\n");
+		osprintf(os, "  }\n");
+	}
+	osprintf(os, "  os << str;\n");
+	osprintf(os, "  free(str);\n");
+	osprintf(os, "  return os;\n");
+	osprintf(os, "}\n");
+}
+
+/* Print code that checks that "ptr" is not NULL at input.
+ *
+ * Omit the check if checked C++ bindings are being generated.
+ */
+void plain_cpp_generator::impl_printer::print_check_ptr(const char *ptr)
+{
+	if (generator.checked)
+		return;
+
+	osprintf(os, "  if (!%s)\n", ptr);
+	print_throw_NULL_input(os);
+}
+
+/* Print code that checks that "ptr" is not NULL at input and
+ * that saves a copy of the isl_ctx of "ptr" for a later check.
+ *
+ * Omit the check if checked C++ bindings are being generated.
+ */
+void plain_cpp_generator::impl_printer::print_check_ptr_start(const char *ptr)
+{
+	if (generator.checked)
+		return;
+
+	print_check_ptr(ptr);
+	osprintf(os, "  auto saved_ctx = %s_get_ctx(%s);\n",
+		clazz.name.c_str(), ptr);
+	print_on_error_continue();
+}
+
+/* Print code that checks that "ptr" is not NULL at the end.
+ * A copy of the isl_ctx is expected to have been saved by
+ * code generated by print_check_ptr_start.
+ *
+ * Omit the check if checked C++ bindings are being generated.
+ */
+void plain_cpp_generator::impl_printer::print_check_ptr_end(const char *ptr)
+{
+	if (generator.checked)
+		return;
+
+	osprintf(os, "  if (!%s)\n", ptr);
+	print_throw_last_error(os);
+}
+
+/* Print implementation of global factory functions.
+ *
+ * Each class has two global factory functions:
+ *
+ * 	set manage(__isl_take isl_set *ptr);
+ * 	set manage_copy(__isl_keep isl_set *ptr);
+ *
+ * Unless checked C++ bindings are being generated,
+ * both functions require the argument to be non-NULL.
+ * An exception is thrown if anything went wrong during the copying
+ * in manage_copy.
+ * During the copying, isl is made not to print any error message
+ * because the error message is included in the exception.
+ *
+ * For a subclass based on a type function, no factory functions
+ * are introduced because they share the C object type with
+ * the superclass.
+ */
+void plain_cpp_generator::impl_printer::print_class_factory()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	if (clazz.is_type_subclass())
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "%s manage(__isl_take %s *ptr) {\n", cppname, name);
+	print_check_ptr("ptr");
+	osprintf(os, "  return %s(ptr);\n", cppname);
+	osprintf(os, "}\n");
+
+	osprintf(os, "%s manage_copy(__isl_keep %s *ptr) {\n", cppname,
+		name);
+	print_check_ptr_start("ptr");
+	osprintf(os, "  ptr = %s_copy(ptr);\n", name);
+	print_check_ptr_end("ptr");
+	osprintf(os, "  return %s(ptr);\n", cppname);
+	osprintf(os, "}\n");
+}
+
+/* Print implementations of protected constructors.
+ *
+ * The pointer to the isl object is either initialized directly or
+ * through the (immediate) superclass.
+ */
+void plain_cpp_generator::impl_printer::print_protected_constructors()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+	bool subclass = clazz.is_type_subclass();
+
+	osprintf(os, "\n");
+	osprintf(os, "%s::%s(__isl_take %s *ptr)\n", cppname, cppname, name);
+	if (subclass)
+		osprintf(os, "    : %s(ptr) {}\n",
+			type2cpp(clazz.superclass_name).c_str());
+	else
+		osprintf(os, "    : ptr(ptr) {}\n");
+}
+
+/* Print implementations of public constructors.
+ *
+ * The pointer to the isl object is either initialized directly or
+ * through the (immediate) superclass.
+ *
+ * If the class has any persistent callbacks, then copy them
+ * from the original object in the copy constructor.
+ * If the class is a subclass, then the persistent callbacks
+ * are assumed to be copied by the copy constructor of the superclass.
+ *
+ * Throw an exception from the copy constructor if anything went wrong
+ * during the copying or if the input is NULL, if any copying is performed.
+ * During the copying, isl is made not to print any error message
+ * because the error message is included in the exception.
+ * No exceptions are thrown if checked C++ bindings
+ * are being generated,
+ */
+void plain_cpp_generator::impl_printer::print_public_constructors()
+{
+	std::string super;
+	const char *cppname = cppstring.c_str();
+	bool subclass = clazz.is_type_subclass();
+
+	osprintf(os, "\n");
+	if (subclass)
+		super = type2cpp(clazz.superclass_name);
+	osprintf(os, "%s::%s()\n", cppname, cppname);
+	if (subclass)
+		osprintf(os, "    : %s() {}\n\n", super.c_str());
+	else
+		osprintf(os, "    : ptr(nullptr) {}\n\n");
+	osprintf(os, "%s::%s(const %s &obj)\n", cppname, cppname, cppname);
+	if (subclass)
+		osprintf(os, "    : %s(obj)\n", super.c_str());
+	else
+		osprintf(os, "    : ptr(nullptr)\n");
+	osprintf(os, "{\n");
+	if (!subclass) {
+		print_check_ptr_start("obj.ptr");
+		osprintf(os, "  ptr = obj.copy();\n");
+		if (clazz.has_persistent_callbacks())
+			osprintf(os, "  copy_callbacks(obj);\n");
+		print_check_ptr_end("ptr");
+	}
+	osprintf(os, "}\n");
+}
+
+/* Print definition for "method",
+ * without any automatic type conversions.
+ *
+ * This method distinguishes three kinds of methods: member methods, static
+ * methods, and constructors.
+ *
+ * Member methods and static methods return a newly managed
+ * isl C++ object.
+ *
+ * Constructors create a new object from a given set of input parameters. They
+ * do not return a value, but instead update the pointer stored inside the
+ * newly created object.
+ *
+ * Unless checked C++ bindings are being generated,
+ * the inputs of the method are first checked for being valid isl objects and
+ * a copy of the associated isl::ctx is saved (if needed).
+ * If any failure occurs, either during the check for the inputs or
+ * during the isl function call, an exception is thrown.
+ * During the function call, isl is made not to print any error message
+ * because the error message is included in the exception.
+ */
+void plain_cpp_generator::impl_printer::print_method(const Method &method)
+{
+	string methodname = method.fd->getName().str();
+	int num_params = method.c_num_params();
+
+	osprintf(os, "\n");
+	print_full_method_header(method);
+	osprintf(os, "{\n");
+	print_argument_validity_check(method);
+	print_save_ctx(method);
+	print_on_error_continue();
+
+	if (method.callback)
+		print_callback_local(method.callback);
+
+	osprintf(os, "  auto res = %s", methodname.c_str());
+
+	Method::print_arg_list(os, 0, num_params, & (int i) {
+		method.print_param_use(os, i);
+	});
+	osprintf(os, ";\n");
+
+	print_exceptional_execution_check(method);
+	if (method.kind == Method::Kind::constructor) {
+		osprintf(os, "  ptr = res;\n");
+	} else {
+		print_method_return(method);
+	}
+
+	osprintf(os, "}\n");
+}
+
+/* Convert argument of type "src" to "dst", with a name specified by "dst".
+ *
+ * If "src" is the same as "dst", then no argument conversion is needed.
+ *
+ * Otherwise, call the conversion function
+ * with as arguments the isl_ctx of the object and the argument name,
+ * or simply the argument name if the source type is an isl type.
+ * This means this isl_ctx should be available.
+ */
+void plain_cpp_generator::impl_printer::print_arg_conversion(ParmVarDecl *dst,
+	ParmVarDecl *src)
+{
+	std::string name = dst->getName().str();
+	QualType type = dst->getOriginalType();
+	string cpptype = generator.param2cpp(type);
+
+	if (dst == src)
+		os << name;
+	else if (is_isl_type(src->getOriginalType()))
+		os << cpptype << "(" << name << ")";
+	else
+		os << cpptype << "(ctx(), " << name << ")";
+}
+
+/* Print a definition for "method",
+ * where "this" or at least one of the argument types needs to be converted.
+ *
+ * "method" is assumed to be a member method.
+ *
+ * The generated method performs the required conversion(s) and
+ * calls the method generated without conversions.
+ *
+ * Perform a conversion from the argument in the method declaration
+ * (as specified by Method::get_param) to the argument of the C function,
+ * if needed.
+ * Such a conversion may require the isl_ctx to be available.
+ * In order to be able to use this isl_ctx, the current object needs
+ * to valid.  The validity of other arguments is checked
+ * by the called method.
+ */
+void plain_cpp_generator::impl_printer::print_method(
+	const ConversionMethod &method)
+{
+	if (method.kind != Method::Kind::member_method)
+		die("Automatic conversion currently only supported "
+		    "for object methods");
+
+	osprintf(os, "\n");
+	print_full_method_header(method);
+	osprintf(os, "{\n");
+	print_check_ptr("ptr");
+	osprintf(os, "  return ");
+	method.print_call(os, generator.isl_namespace());
+	method.print_cpp_arg_list(os, & (int i) {
+		ParmVarDecl *param = method.fd->getParamDecl(i);
+
+		print_arg_conversion(param, method.get_param(i));
+	});
+	osprintf(os, ";\n");
+	osprintf(os, "}\n");
+}
+
+/* Print implementation of copy assignment operator.
+ *
+ * If the class has any persistent callbacks, then copy them
+ * from the original object.
+ */
+void plain_cpp_generator::impl_printer::print_copy_assignment()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	osprintf(os, "\n");
+	osprintf(os, "%s &%s::operator=(%s obj) {\n", cppname,
+		 cppname, cppname);
+	osprintf(os, "  std::swap(this->ptr, obj.ptr);\n", name);
+	if (clazz.has_persistent_callbacks())
+		osprintf(os, "  copy_callbacks(obj);\n");
+	osprintf(os, "  return *this;\n");
+	osprintf(os, "}\n");
+}
+
+/* Print implementation of destructor.
+ *
+ * No explicit destructor is needed for type based subclasses.
+ */
+void plain_cpp_generator::impl_printer::print_destructor()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+
+	if (clazz.is_type_subclass())
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "%s::~%s() {\n", cppname, cppname);
+	osprintf(os, "  if (ptr)\n");
+	osprintf(os, "    %s_free(ptr);\n", name);
+	osprintf(os, "}\n");
+}
+
+/* Print a check that the persistent callback corresponding to "fd"
+ * is not set, throwing an exception (or printing an error message
+ * and returning nullptr) if it is set.
+ */
+void plain_cpp_generator::print_check_no_persistent_callback(ostream &os,
+	const isl_class &clazz, FunctionDecl *fd)
+{
+	string callback_name = clazz.persistent_callback_name(fd);
+
+	osprintf(os, "  if (%s_data)\n", callback_name.c_str());
+	print_invalid(os, 4, "cannot release object with persistent callbacks",
+			    "return nullptr");
+}
+
+/* Print implementation of ptr() functions.
+ * Since type based subclasses share the pointer with their superclass,
+ * they can also reuse these functions from the superclass.
+ *
+ * If an object has persistent callbacks set, then the underlying
+ * C object pointer cannot be released because it references data
+ * in the C++ object.
+ */
+void plain_cpp_generator::impl_printer::print_ptr()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+	set<FunctionDecl *>::const_iterator in;
+	const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
+
+	if (clazz.is_type_subclass())
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "__isl_give %s *%s::copy() const & {\n", name, cppname);
+	osprintf(os, "  return %s_copy(ptr);\n", name);
+	osprintf(os, "}\n\n");
+	osprintf(os, "__isl_keep %s *%s::get() const {\n", name, cppname);
+	osprintf(os, "  return ptr;\n");
+	osprintf(os, "}\n\n");
+	osprintf(os, "__isl_give %s *%s::release() {\n", name, cppname);
+	for (in = callbacks.begin(); in != callbacks.end(); ++in)
+		generator.print_check_no_persistent_callback(os, clazz, *in);
+	osprintf(os, "  %s *tmp = ptr;\n", name);
+	osprintf(os, "  ptr = nullptr;\n");
+	osprintf(os, "  return tmp;\n");
+	osprintf(os, "}\n\n");
+	osprintf(os, "bool %s::is_null() const {\n", cppname);
+	osprintf(os, "  return ptr == nullptr;\n");
+	osprintf(os, "}\n");
+}
+
+/* Print implementations for the "as" and "isa" methods, if the printed class
+ * is a superclass with a type function.
+ *
+ * "isa" checks whether an object is of a given subclass type.
+ * "isa_type" does the same, but gets passed the value of the type field
+ * of the subclass as a function argument and the type of this field
+ * as a template argument.
+ * "as" casts an object to a given subclass type, erroring out
+ * if the object is not of the given type.
+ *
+ * If the input is an invalid object, then these methods raise
+ * an exception.
+ * If checked bindings are being generated,
+ * then an invalid boolean or object is returned instead.
+ */
+void plain_cpp_generator::impl_printer::print_downcast()
+{
+	const char *cppname = cppstring.c_str();
+
+	if (!clazz.fn_type)
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "template <typename T, typename>\n");
+	osprintf(os, "%s %s::isa_type(T subtype) const\n",
+		generator.isl_bool2cpp().c_str(), cppname);
+	osprintf(os, "{\n");
+	osprintf(os, "  if (is_null())\n");
+	if (generator.checked)
+		osprintf(os, "    return boolean();\n");
+	else
+		print_throw_NULL_input(os);
+	osprintf(os, "  return %s(get()) == subtype;\n",
+		clazz.fn_type->getNameAsString().c_str());
+	osprintf(os, "}\n");
+
+	osprintf(os, "template <class T>\n");
+	osprintf(os, "%s %s::isa() const\n",
+		generator.isl_bool2cpp().c_str(), cppname);
+	osprintf(os, "{\n");
+	osprintf(os, "  return isa_type<decltype(T::type)>(T::type);\n");
+	osprintf(os, "}\n");
+
+	osprintf(os, "template <class T>\n");
+	osprintf(os, "T %s::as() const\n", cppname);
+	osprintf(os, "{\n");
+	if (generator.checked)
+		osprintf(os, " if (isa<T>().is_false())\n");
+	else
+		osprintf(os, " if (!isa<T>())\n");
+	generator.print_invalid(os, 4, "not an object of the requested subtype",
+		    "return T()");
+	osprintf(os, "  return T(copy());\n");
+	osprintf(os, "}\n");
+}
+
+/* Print the implementation of the ctx method.
+ */
+void plain_cpp_generator::impl_printer::print_ctx()
+{
+	const char *name = clazz.name.c_str();
+	const char *cppname = cppstring.c_str();
+	std::string ns = generator.isl_namespace();
+
+	osprintf(os, "\n");
+	osprintf(os, "%sctx %s::ctx() const {\n", ns.c_str(), cppname);
+	osprintf(os, "  return %sctx(%s_get_ctx(ptr));\n", ns.c_str(), name);
+	osprintf(os, "}\n");
+}
+
+/* Print the implementations of the methods needed for the persistent callbacks
+ * of the class.
+ */
+void plain_cpp_generator::impl_printer::print_persistent_callbacks()
+{
+	const char *cppname = cppstring.c_str();
+	string classname = type2cpp(clazz);
+
+	if (!clazz.has_persistent_callbacks())
+		return;
+
+	osprintf(os, "\n");
+	osprintf(os, "%s &%s::copy_callbacks(const %s &obj)\n",
+		cppname, classname.c_str(), cppname);
+	osprintf(os, "{\n");
+	for (const auto &callback : clazz.persistent_callbacks) {
+		string callback_name = clazz.persistent_callback_name(callback);
+
+		osprintf(os, "  %s_data = obj.%s_data;\n",
+			callback_name.c_str(), callback_name.c_str());
+	}
+	osprintf(os, "  return *this;\n");
+	osprintf(os, "}\n");
+
+	for (const auto &callback : clazz.persistent_callbacks)
+		print_set_persistent_callback(Method(clazz, callback));
+}
+
+/* Print a definition for the "get" method "fd" in class "clazz",
+ * using a name that includes the "get_" prefix, to "os".
+ *
+ * This definition simply calls the variant without the "get_" prefix and
+ * returns its result.
+ * Note that static methods are not considered to be "get" methods.
+ */
+void plain_cpp_generator::impl_printer::print_get_method(FunctionDecl *fd)
+{
+	string get_name = clazz.base_method_name(fd);
+	string name = clazz.method_name(fd);
+	int num_params = fd->getNumParams();
+
+	osprintf(os, "\n");
+	print_full_method_header(Method(clazz, fd, get_name));
+	osprintf(os, "{\n");
+	osprintf(os, "  return %s(", name.c_str());
+	for (int i = 1; i < num_params; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
+
+		if (i != 1)
+			osprintf(os, ", ");
+		osprintf(os, "%s", param->getName().str().c_str());
+	}
+	osprintf(os, ");\n");
+	osprintf(os, "}\n");
+}
+
+/* Print code that checks that all isl object arguments to "method" are valid
+ * (not NULL) and throws an exception if they are not.
+ *
+ * If checked bindings are being generated,
+ * then no such check is performed.
+ */
+void plain_cpp_generator::impl_printer::print_argument_validity_check(
+	const Method &method)
+{
+	int n;
+	bool first = true;
+
+	if (generator.checked)
+		return;
+
+	n = method.num_params();
+	for (int i = 0; i < n; ++i) {
+		bool is_this;
+		ParmVarDecl *param = method.fd->getParamDecl(i);
+		string name = param->getName().str();
+		const char *name_str = name.c_str();
+		QualType type = param->getOriginalType();
+
+		is_this = i == 0 && method.kind == Method::Kind::member_method;
+		if (!is_this && (is_isl_ctx(type) || !is_isl_type(type)))
+			continue;
+
+		if (first)
+			osprintf(os, "  if (");
+		else
+			osprintf(os, " || ");
+
+		if (is_this)
+			osprintf(os, "!ptr");
+		else
+			osprintf(os, "%s.is_null()", name_str);
+
+		first = false;
+	}
+	if (first)
+		return;
+	osprintf(os, ")\n");
+	print_throw_NULL_input(os);
+}
+
+/* Print code for saving a copy of the isl::ctx available at the start
+ * of the method "method" in a "saved_ctx" variable,
+ * for use in exception handling.
+ *
+ * If checked bindings are being generated,
+ * then the "saved_ctx" variable is not needed.
+ * If "method" is a member function, then obtain the isl_ctx from
+ * the "this" object.
+ * If the first argument of the method is an isl::ctx, then use that one.
+ * Otherwise, save a copy of the isl::ctx associated to the first argument
+ * of isl object type.
+ */
+void plain_cpp_generator::impl_printer::print_save_ctx(const Method &method)
+{
+	int n;
+	ParmVarDecl *param = method.fd->getParamDecl(0);
+	QualType type = param->getOriginalType();
+
+	if (generator.checked)
+		return;
+	if (method.kind == Method::Kind::member_method) {
+		osprintf(os, "  auto saved_ctx = ctx();\n");
+		return;
+	}
+	if (is_isl_ctx(type)) {
+		const char *name;
+
+		name = param->getName().str().c_str();
+		osprintf(os, "  auto saved_ctx = %s;\n", name);
+		return;
+	}
+	n = method.num_params();
+	for (int i = 0; i < n; ++i) {
+		ParmVarDecl *param = method.fd->getParamDecl(i);
+		QualType type = param->getOriginalType();
+
+		if (!is_isl_type(type))
+			continue;
+		osprintf(os, "  auto saved_ctx = %s.ctx();\n",
+			param->getName().str().c_str());
+		return;
+	}
+}
+
+/* Print code to make isl not print an error message when an error occurs
+ * within the current scope (if exceptions are available),
+ * since the error message will be included in the exception.
+ * If exceptions are not available, then exception::on_error
+ * is set to ISL_ON_ERROR_ABORT and isl is therefore made to abort instead.
+ *
+ * If checked bindings are being generated,
+ * then leave it to the user to decide what isl should do on error.
+ * Otherwise, assume that a valid isl::ctx is available
+ * in the "saved_ctx" variable,
+ * e.g., through a prior call to print_save_ctx.
+ */
+void plain_cpp_generator::impl_printer::print_on_error_continue()
+{
+	if (generator.checked)
+		return;
+	osprintf(os, "  options_scoped_set_on_error saved_on_error(saved_ctx, "
+		     "exception::on_error);\n");
+}
+
+/* Print code to "os" that checks whether any of the persistent callbacks
+ * of the class of "method" is set and if it failed with an exception.
+ * If so, the "eptr" in the corresponding data structure contains the exception
+ * that was caught and that needs to be rethrown.
+ * This field is cleared because the callback and its data may get reused.
+ *
+ * The check only needs to be generated for member methods since
+ * an object is needed for any of the persistent callbacks to be set.
+ */
+static void print_persistent_callback_exceptional_execution_check(ostream &os,
+	const Method &method)
+{
+	if (method.kind != Method::Kind::member_method)
+		return;
+
+	for (const auto &pcb : method.clazz.persistent_callbacks) {
+		auto callback_name = method.clazz.persistent_callback_name(pcb);
+
+		osprintf(os, "  if (%s_data && %s_data->eptr) {\n",
+			callback_name.c_str(), callback_name.c_str());
+		osprintf(os, "    std::exception_ptr eptr = %s_data->eptr;\n",
+			callback_name.c_str());
+		osprintf(os, "    %s_data->eptr = nullptr;\n",
+			callback_name.c_str());
+		osprintf(os, "    std::rethrow_exception(eptr);\n");
+		osprintf(os, "  }\n");
+	}
+}
+
+/* Print code that checks whether the execution of the core of "method"
+ * was successful.
+ *
+ * If checked bindings are being generated,
+ * then no checks are performed.
+ *
+ * Otherwise, first check if any of the callbacks failed with
+ * an exception.  If so, the "eptr" in the corresponding data structure
+ * contains the exception that was caught and that needs to be rethrown.
+ * Then check if the function call failed in any other way and throw
+ * the appropriate exception.
+ * In particular, if the return type is isl_stat, isl_bool or isl_size,
+ * then a negative value indicates a failure.  If the return type
+ * is an isl type, then a NULL value indicates a failure.
+ * Assume print_save_ctx has made sure that a valid isl::ctx
+ * is available in the "ctx" variable.
+ */
+void plain_cpp_generator::impl_printer::print_exceptional_execution_check(
+	const Method &method)
+{
+	bool check_null, check_neg;
+	QualType return_type = method.fd->getReturnType();
+
+	if (generator.checked)
+		return;
+
+	print_persistent_callback_exceptional_execution_check(os, method);
+
+	if (method.callback) {
+		const char *name;
+
+		name = method.callback->getName().str().c_str();
+		osprintf(os, "  if (%s_data.eptr)\n", name);
+		osprintf(os, "    std::rethrow_exception(%s_data.eptr);\n",
+			name);
+	}
+
+	check_neg = is_isl_neg_error(return_type);
+	check_null = is_isl_type(return_type);
+	if (!check_null && !check_neg)
+		return;
+
+	if (check_neg)
+		osprintf(os, "  if (res < 0)\n");
+	else
+		osprintf(os, "  if (!res)\n");
+	print_throw_last_error(os);
+}
+
+/* Return a pointer to the appropriate type printer,
+ * i.e., the regular type printer or the checked type printer
+ * depending on the setting of this->checked.
+ */
+std::unique_ptr<cpp_type_printer> plain_cpp_generator::type_printer()
+{
+	cpp_type_printer *printer;
+
+	if (checked)
+		printer = new checked_cpp_type_printer();
+	else
+		printer = new cpp_type_printer();
+
+	return std::unique_ptr<cpp_type_printer>(printer);
+}
+
+/* Return the C++ return type of the method "method".
+ *
+ * Use the appropriate type printer.
+ */
+std::string plain_cpp_generator::get_return_type(const Method &method)
+{
+	return type_printer()->return_type(method);
+}
+
+/* Given a method "method" for setting a persistent callback of its class,
+ * print the implementations of the methods needed for that callback.
+ *
+ * In particular, print
+ * - the implementation of a static inline method
+ *   for use as the C callback function
+ * - the definition of a private method for setting the callback function
+ * - the public method for constructing a new object with the callback set.
+ */
+void plain_cpp_generator::impl_printer::print_set_persistent_callback(
+	const Method &method)
+{
+	string fullname = method.fd->getName().str();
+	ParmVarDecl *param = persistent_callback_arg(method.fd);
+	string pname;
+	string callback_name = clazz.persistent_callback_name(method.fd);
+
+	osprintf(os, "\n");
+	print_persistent_callback_prototype(method.fd);
+	osprintf(os, "\n");
+	osprintf(os, "{\n");
+	print_callback_body(2, param, callback_name);
+	osprintf(os, "}\n\n");
+
+	pname = param->getName().str();
+	print_persistent_callback_setter_prototype(method.fd);
+	osprintf(os, "\n");
+	osprintf(os, "{\n");
+	print_check_ptr_start("ptr");
+	osprintf(os, "  %s_data = std::make_shared<struct %s_data>();\n",
+		callback_name.c_str(), callback_name.c_str());
+	osprintf(os, "  %s_data->func = %s;\n",
+		callback_name.c_str(), pname.c_str());
+	osprintf(os, "  ptr = %s(ptr, &%s, %s_data.get());\n",
+		fullname.c_str(), callback_name.c_str(), callback_name.c_str());
+	print_check_ptr_end("ptr");
+	osprintf(os, "}\n\n");
+
+	print_full_method_header(method);
+	osprintf(os, "{\n");
+	osprintf(os, "  auto copy = *this;\n");
+	osprintf(os, "  copy.set_%s_data(%s);\n",
+		callback_name.c_str(), pname.c_str());
+	osprintf(os, "  return copy;\n");
+	osprintf(os, "}\n");
+}
+
+/* Print the return statement of the C++ method "method".
+ *
+ * The result of the corresponding isl function is returned as a new
+ * object if the underlying isl function returns an isl_* ptr, as a bool
+ * if the isl function returns an isl_bool, as void if the isl functions
+ * returns an isl_stat,
+ * as std::string if the isl function returns 'const char *', and as
+ * unmodified return value otherwise.
+ * If checked C++ bindings are being generated,
+ * then an isl_bool return type is transformed into a boolean and
+ * an isl_stat into a stat since no exceptions can be generated
+ * on negative results from the isl function.
+ * If the method returns a new instance of the same object type and
+ * if the class has any persistent callbacks, then the data
+ * for these callbacks are copied from the original to the new object.
+ * If "clazz" is a subclass that is based on a type function and
+ * if the return type corresponds to the superclass data type,
+ * then it is replaced by the subclass data type.
+ */
+void plain_cpp_generator::impl_printer::print_method_return(
+	const Method &method)
+{
+	QualType return_type = method.fd->getReturnType();
+	string rettype_str = generator.get_return_type(method);
+	bool returns_super = method.is_subclass_mutator();
+
+	if (is_isl_type(return_type) ||
+		    (generator.checked && is_isl_neg_error(return_type))) {
+		osprintf(os, "  return manage(res)");
+		if (is_mutator(clazz, method.fd) &&
+		    clazz.has_persistent_callbacks())
+			osprintf(os, ".copy_callbacks(*this)");
+		if (returns_super)
+			osprintf(os, ".as<%s>()", rettype_str.c_str());
+		osprintf(os, ";\n");
+	} else if (is_isl_stat(return_type)) {
+		osprintf(os, "  return;\n");
+	} else if (is_string(return_type)) {
+		osprintf(os, "  std::string tmp(res);\n");
+		if (gives(method.fd))
+			osprintf(os, "  free(res);\n");
+		osprintf(os, "  return tmp;\n");
+	} else {
+		osprintf(os, "  return res;\n");
+	}
+}
+
+/* Print the header for "method", including the terminating semicolon
+ * in case of a declaration and a newline.
+ *
+ * Use the appropriate type printer to print argument and return types.
+ */
+void plain_cpp_generator::plain_printer::print_full_method_header(
+	const Method &method)
+{
+	auto type_printer = generator.type_printer();
+
+	print_method_header(method, *type_printer);
+
+	if (declarations)
+		osprintf(os, ";");
+	osprintf(os, "\n");
+}
+
+/* Generate the list of argument types for a callback function of
+ * type "type".  If "cpp" is set, then generate the C++ type list, otherwise
+ * the C type list.
+ *
+ * Use the appropriate type printer.
+ * For the plain C++ interface, the argument position is irrelevant,
+ * so simply pass in -1.
+ */
+string plain_cpp_generator::generate_callback_args(QualType type, bool cpp)
+{
+	return type_printer()->generate_callback_args(-1, type, cpp);
+}
+
+/* Generate the full cpp type of a callback function of type "type".
+ *
+ * Use the appropriate type printer.
+ * For the plain C++ interface, the argument position is irrelevant,
+ * so simply pass in -1.
+ */
+string plain_cpp_generator::generate_callback_type(QualType type)
+{
+	return type_printer()->generate_callback_type(-1, type);
+}
+
+/* Print the call to the C++ callback function "call",
+ * with the given indentation, wrapped
+ * for use inside the lambda function that is used as the C callback function,
+ * in the case where checked C++ bindings are being generated.
+ *
+ * In particular, print
+ *
+ *        auto ret = @call@;
+ *        return ret.release();
+ */
+void plain_cpp_generator::impl_printer::print_wrapped_call_checked(int indent,
+	const string &call)
+{
+	osprintf(os, indent, "auto ret = %s;\n", call.c_str());
+	osprintf(os, indent, "return ret.release();\n");
+}
+
+/* Print the call to the C++ callback function "call",
+ * with the given indentation and with return type "rtype", wrapped
+ * for use inside the lambda function that is used as the C callback function.
+ *
+ * In particular, print
+ *
+ *        ISL_CPP_TRY {
+ *          @call@;
+ *          return isl_stat_ok;
+ *        } ISL_CPP_CATCH_ALL {
+ *          data->eptr = std::current_exception();
+ *          return isl_stat_error;
+ *        }
+ * or
+ *        ISL_CPP_TRY {
+ *          auto ret = @call@;
+ *          return ret ? isl_bool_true : isl_bool_false;
+ *        } ISL_CPP_CATCH_ALL {
+ *          data->eptr = std::current_exception();
+ *          return isl_bool_error;
+ *        }
+ * or
+ *        ISL_CPP_TRY {
+ *          auto ret = @call@;
+ *          return ret.release();
+ *        } ISL_CPP_CATCH_ALL {
+ *          data->eptr = std::current_exception();
+ *          return NULL;
+ *        }
+ *
+ * depending on the return type.
+ *
+ * where ISL_CPP_TRY is defined to "try" and ISL_CPP_CATCH_ALL to "catch (...)"
+ * (if exceptions are available).
+ *
+ * If checked C++ bindings are being generated, then
+ * the call is wrapped differently.
+ */
+void plain_cpp_generator::impl_printer::print_wrapped_call(int indent,
+	const string &call, QualType rtype)
+{
+	if (generator.checked)
+		return print_wrapped_call_checked(indent, call);
+
+	osprintf(os, indent, "ISL_CPP_TRY {\n");
+	if (is_isl_stat(rtype))
+		osprintf(os, indent, "  %s;\n", call.c_str());
+	else
+		osprintf(os, indent, "  auto ret = %s;\n", call.c_str());
+	if (is_isl_stat(rtype))
+		osprintf(os, indent, "  return isl_stat_ok;\n");
+	else if (is_isl_bool(rtype))
+		osprintf(os, indent,
+			"  return ret ? isl_bool_true : isl_bool_false;\n");
+	else
+		osprintf(os, indent, "  return ret.release();\n");
+	osprintf(os, indent, "} ISL_CPP_CATCH_ALL {\n");
+	osprintf(os, indent, "  data->eptr = std::current_exception();\n");
+	if (is_isl_stat(rtype))
+		osprintf(os, indent, "  return isl_stat_error;\n");
+	else if (is_isl_bool(rtype))
+		osprintf(os, indent, "  return isl_bool_error;\n");
+	else
+		osprintf(os, indent, "  return NULL;\n");
+	osprintf(os, indent, "}\n");
+}
+
+/* Print the declaration for a "prefix"_data data structure
+ * that can be used for passing to a C callback function
+ * containing a copy of the C++ callback function "param",
+ * along with an std::exception_ptr that is used to store any
+ * exceptions thrown in the C++ callback.
+ *
+ * If the C callback is of the form
+ *
+ *      isl_stat (*fn)(__isl_take isl_map *map, void *user)
+ *
+ * then the following declaration is printed:
+ *
+ *      struct <prefix>_data {
+ *        std::function<stat(map)> func;
+ *        std::exception_ptr eptr;
+ *      }
+ *
+ * (without a newline or a semicolon).
+ *
+ * The std::exception_ptr object is not added to "prefix"_data
+ * if checked C++ bindings are being generated.
+ */
+void plain_cpp_generator::plain_printer::print_callback_data_decl(
+	ParmVarDecl *param,
+	const string &prefix)
+{
+	string cpp_args;
+
+	cpp_args = generator.generate_callback_type(param->getType());
+
+	osprintf(os, "  struct %s_data {\n", prefix.c_str());
+	osprintf(os, "    %s func;\n", cpp_args.c_str());
+	if (!generator.checked)
+		osprintf(os, "    std::exception_ptr eptr;\n");
+	osprintf(os, "  }");
+}
+
+/* Given a group of methods with the same name,
+ * should extra methods be added that take as arguments
+ * those types that can be converted to the original argument type
+ * through a unary constructor?
+ *
+ * Note that even if this method returns true,
+ * the extra methods are only printed by the caller
+ * if exactly one of the methods in the group was originally defined
+ * in the printed class.
+ * Signal that they should be printed if the group contains
+ * both methods originally defined in the printed class and
+ * methods that have been copied from an ancestor
+ * by checking whether there are at least two methods in the group.
+ */
+bool plain_cpp_generator::plain_printer::want_descendent_overloads(
+	const function_set &methods)
+{
+	return methods.size() > 1;
+}
+
+/* Print the body of C function callback with the given indentation
+ * that can be use as an argument to "param" for marshalling
+ * the corresponding C++ callback.
+ * The data structure that contains the C++ callback is of type
+ * "prefix"_data.
+ *
+ * For a callback of the form
+ *
+ *      isl_stat (*fn)(__isl_take isl_map *map, void *user)
+ *
+ * the following code is generated:
+ *
+ *        auto *data = static_cast<struct <prefix>_data *>(arg_1);
+ *        ISL_CPP_TRY {
+ *          stat ret = (data->func)(manage(arg_0));
+ *          return isl_stat_ok;
+ *        } ISL_CPP_CATCH_ALL {
+ *          data->eptr = std::current_exception();
+ *          return isl_stat_error;
+ *        }
+ *
+ * If checked C++ bindings are being generated, then
+ * generate the following code:
+ *
+ *        auto *data = static_cast<struct <prefix>_data *>(arg_1);
+ *        stat ret = (data->func)(manage(arg_0));
+ *        return isl_stat(ret);
+ */
+void plain_cpp_generator::impl_printer::print_callback_body(int indent,
+	ParmVarDecl *param, const string &prefix)
+{
+	QualType ptype, rtype;
+	string call, last_idx;
+	const FunctionProtoType *callback;
+	int num_params;
+
+	ptype = param->getType();
+
+	callback = extract_prototype(ptype);
+	rtype = callback->getReturnType();
+	num_params = callback->getNumArgs();
+
+	last_idx = ::to_string(num_params - 1);
+
+	call = "(data->func)(";
+	for (long i = 0; i < num_params - 1; i++) {
+		if (!generator.callback_takes_argument(param, i))
+			call += "manage_copy";
+		else
+			call += "manage";
+		call += "(arg_" + ::to_string(i) + ")";
+		if (i != num_params - 2)
+			call += ", ";
+	}
+	call += ")";
+
+	osprintf(os, indent,
+		 "auto *data = static_cast<struct %s_data *>(arg_%s);\n",
+		 prefix.c_str(), last_idx.c_str());
+	print_wrapped_call(indent, call, rtype);
+}
+
+/* Print the local variables that are needed for a callback argument,
+ * in particular, print a lambda function that wraps the callback and
+ * a pointer to the actual C++ callback function.
+ *
+ * For a callback of the form
+ *
+ *      isl_stat (*fn)(__isl_take isl_map *map, void *user)
+ *
+ * the following lambda function is generated:
+ *
+ *      auto fn_lambda = (isl_map *arg_0, void *arg_1) -> isl_stat {
+ *        auto *data = static_cast<struct fn_data *>(arg_1);
+ *        try {
+ *          stat ret = (data->func)(manage(arg_0));
+ *          return isl_stat_ok;
+ *        } catch (...) {
+ *          data->eptr = std::current_exception();
+ *          return isl_stat_error;
+ *        }
+ *      };
+ *
+ * A copy of the std::function C++ callback function is stored in
+ * a fn_data data structure for passing to the C callback function,
+ * along with an std::exception_ptr that is used to store any
+ * exceptions thrown in the C++ callback.
+ *
+ *      struct fn_data {
+ *        std::function<stat(map)> func;
+ *        std::exception_ptr eptr;
+ *      } fn_data = { fn };
+ *
+ * This std::function object represents the actual user
+ * callback function together with the locally captured state at the caller.
+ *
+ * The lambda function is expected to be used as a C callback function
+ * where the lambda itself is provided as the function pointer and
+ * where the user void pointer is a pointer to fn_data.
+ * The std::function object is extracted from the pointer to fn_data
+ * inside the lambda function.
+ *
+ * The std::exception_ptr object is not added to fn_data
+ * if checked C++ bindings are being generated.
+ * The body of the generated lambda function then is as follows:
+ *
+ *        stat ret = (data->func)(manage(arg_0));
+ *        return isl_stat(ret);
+ *
+ * If the C callback does not take its arguments, then
+ * manage_copy is used instead of manage.
+ */
+void plain_cpp_generator::impl_printer::print_callback_local(ParmVarDecl *param)
+{
+	string pname;
+	QualType ptype, rtype;
+	string c_args, cpp_args, rettype;
+	const FunctionProtoType *callback;
+
+	pname = param->getName().str();
+	ptype = param->getType();
+
+	c_args = generator.generate_callback_args(ptype, false);
+
+	callback = extract_prototype(ptype);
+	rtype = callback->getReturnType();
+	rettype = rtype.getAsString();
+
+	print_callback_data_decl(param, pname);
+	osprintf(os, " %s_data = { %s };\n", pname.c_str(), pname.c_str());
+	osprintf(os, "  auto %s_lambda = (%s) -> %s {\n",
+		 pname.c_str(), c_args.c_str(), rettype.c_str());
+	print_callback_body(4, param, pname);
+	osprintf(os, "  };\n");
+}
+
+/* Return the C++ counterpart to the isl_bool type.
+ *
+ * For the checked C++ bindings this is "boolean".
+ */
+std::string checked_cpp_type_printer::isl_bool() const
+{
+	return "boolean";
+}
+
+/* Return the C++ counterpart to the isl_bool type.
+ *
+ * Use the appropriate type printer.
+ */
+string plain_cpp_generator::isl_bool2cpp()
+{
+	return type_printer()->isl_bool();
+}
+
+/* Return the C++ counterpart to the isl_stat type.
+ *
+ * For the checked C++ bindings this is "stat".
+ */
+string checked_cpp_type_printer::isl_stat() const
+{
+	return "stat";
+}
+
+/* Return the C++ counterpart to the isl_size type.
+ *
+ * For the checked C++ bindings this is "class size".
+ */
+string checked_cpp_type_printer::isl_size() const
+{
+	return "class size";
+}
+
+/* Return the namespace of the generated C++ bindings.
+ *
+ * For the checked C++ bindings this is "isl::checked::".
+ */
+std::string checked_cpp_type_printer::isl_namespace() const
+{
+	return "isl::checked::";
+}
+
+/* Return the namespace of the generated C++ bindings.
+ *
+ * Use the appropriate type printer.
+ */
+string plain_cpp_generator::isl_namespace()
+{
+	return type_printer()->isl_namespace();
+}
+
+/* Translate parameter or return type "type" to its C++ name counterpart.
+ *
+ * Use the appropriate type printer.
+ * For the plain C++ interface, the argument position is irrelevant,
+ * so simply pass in -1.
+ */
+string plain_cpp_generator::param2cpp(QualType type)
+{
+	return type_printer()->param(-1, type);
+}

_service:tar_scm:isl-0.24.tar.gz/interface/plain_cpp.h Added

@@ -0,0 +1,152 @@
+#ifndef ISL_INTERFACE_PLAIN_CPP_H
+#define ISL_INTERFACE_PLAIN_CPP_H
+
+#include <functional>
+#include <memory>
+
+#include "cpp.h"
+#include "generator.h"
+
+using namespace std;
+using namespace clang;
+
+/* A type printer for converting argument and return types
+ * to string representations of the corresponding types
+ * in the checked C++ interface.
+ */
+struct checked_cpp_type_printer : public cpp_type_printer {
+	virtual std::string isl_bool() const override;
+	virtual std::string isl_stat() const override;
+	virtual std::string isl_size() const override;
+	virtual std::string isl_namespace() const override;
+};
+
+/* Generator for plain C++ bindings.
+ *
+ * "checked" is set if C++ bindings should be generated
+ * that rely on the user to check for error conditions.
+ */
+class plain_cpp_generator : public cpp_generator {
+	struct plain_printer;
+	struct decl_printer;
+	struct impl_printer;
+protected:
+	bool checked;
+public:
+	plain_cpp_generator(SourceManager &SM,
+		set<RecordDecl *> &exported_types,
+		set<FunctionDecl *> exported_functions,
+		set<FunctionDecl *> functions,
+		bool checked = false);
+
+	virtual void generate();
+private:
+	void print_forward_declarations(ostream &os);
+	void print_declarations(ostream &os);
+	void print_class(ostream &os, const isl_class &clazz);
+	void print_class_forward_decl(ostream &os, const isl_class &clazz);
+	void print_implementations(ostream &os);
+	void print_class_impl(ostream &os, const isl_class &clazz);
+	void print_check_no_persistent_callback(ostream &os,
+		const isl_class &clazz, FunctionDecl *fd);
+	void print_invalid(ostream &os, int indent, const char *msg,
+		const char *checked_code);
+	void print_method_param_use(ostream &os, ParmVarDecl *param,
+		bool load_from_this_ptr);
+	std::unique_ptr<cpp_type_printer> type_printer();
+	std::string get_return_type(const Method &method);
+	string generate_callback_args(QualType type, bool cpp);
+	string generate_callback_type(QualType type);
+	string isl_bool2cpp();
+	string isl_namespace();
+	string param2cpp(QualType type);
+};
+
+/* A helper class for printing method declarations and definitions
+ * of a class for the plain C++ interface.
+ *
+ * "generator" is the C++ interface generator printing the classes.
+ */
+struct plain_cpp_generator::plain_printer : public cpp_generator::class_printer {
+	plain_cpp_generator &generator;
+
+	plain_printer(std::ostream &os, const isl_class &clazz,
+			plain_cpp_generator &generator, bool is_declaration) :
+		class_printer(os, clazz, generator, is_declaration),
+		generator(generator) {}
+
+	void print_persistent_callback_prototype(FunctionDecl *method);
+	void print_persistent_callback_setter_prototype(FunctionDecl *method);
+	void print_full_method_header(const Method &method);
+	void print_callback_data_decl(ParmVarDecl *param, const string &name);
+	virtual bool want_descendent_overloads(const function_set &methods)
+		override;
+};
+
+/* A helper class for printing method declarations of a class.
+ */
+struct plain_cpp_generator::decl_printer :
+	public plain_cpp_generator::plain_printer
+{
+	decl_printer(std::ostream &os, const isl_class &clazz,
+			plain_cpp_generator &generator) :
+		plain_printer(os, clazz, generator, true) {}
+
+	void print_subclass_type();
+	void print_class_factory(const std::string &prefix = std::string());
+	void print_protected_constructors();
+	void print_copy_assignment();
+	void print_public_constructors();
+	void print_destructor();
+	void print_ptr();
+	void print_isa_type_template(int indent, const isl_class &super);
+	void print_downcast();
+	void print_ctx();
+	void print_persistent_callback_data(FunctionDecl *method);
+	void print_persistent_callbacks();
+	virtual void print_method(const Method &method) override;
+	virtual void print_method(const ConversionMethod &method) override;
+	virtual void print_get_method(FunctionDecl *fd) override;
+};
+
+/* A helper class for printing method definitions of a class.
+ */
+struct plain_cpp_generator::impl_printer :
+	public plain_cpp_generator::plain_printer
+{
+	impl_printer(std::ostream &os, const isl_class &clazz,
+			plain_cpp_generator &generator) :
+		plain_printer(os, clazz, generator, false) {}
+
+	void print_arg_conversion(ParmVarDecl *dst, ParmVarDecl *src);
+	virtual void print_method(const Method &method) override;
+	virtual void print_method(const ConversionMethod &method) override;
+	virtual void print_get_method(FunctionDecl *fd) override;
+	void print_check_ptr(const char *ptr);
+	void print_check_ptr_start(const char *ptr);
+	void print_check_ptr_end(const char *ptr);
+	void print_class_factory();
+	void print_protected_constructors();
+	void print_public_constructors();
+	void print_copy_assignment();
+	void print_destructor();
+	void print_ptr();
+	void print_downcast();
+	void print_ctx();
+	void print_set_persistent_callback(const Method &method);
+	void print_persistent_callbacks();
+	void print_argument_validity_check(const Method &method);
+	void print_save_ctx(const Method &method);
+	void print_on_error_continue();
+	void print_exceptional_execution_check(const Method &method);
+	void print_method_return(const Method &method);
+	void print_stream_insertion();
+	void print_wrapped_call_checked(int indent, const std::string &call);
+	void print_wrapped_call(int indent, const std::string &call,
+		QualType rtype);
+	void print_callback_body(int indent, ParmVarDecl *param,
+		const string &name);
+	void print_callback_local(ParmVarDecl *param);
+};
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/interface/python.cc -> _service:tar_scm:isl-0.24.tar.gz/interface/python.cc Changed

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011 Sven Verdoolaege. All rights reserved.
+ * Copyright 2011,2015 Sven Verdoolaege. All rights reserved.
  * 
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
@@ -33,237 +33,498 @@
 
 #include "isl_config.h"
 
+#include <stdarg.h>
 #include <stdio.h>
+
+#include <algorithm>
 #include <iostream>
 #include <map>
-#include <clang/AST/Attr.h>
-#include "extract_interface.h"
+#include <vector>
+
 #include "python.h"
+#include "generator.h"
 
-/* Is the given type declaration marked as being a subtype of some other
- * type?  If so, return that other type in "super".
+/* Argument format for Python methods with a fixed number of arguments.
  */
-static bool is_subclass(RecordDecl *decl, string &super)
-{
-	if (!decl->hasAttrs())
-		return false;
-
-	string sub = "isl_subclass";
-	size_t len = sub.length();
-	AttrVec attrs = decl->getAttrs();
-	for (AttrVec::const_iterator i = attrs.begin() ; i != attrs.end(); ++i) {
-		const AnnotateAttr *ann = dyn_cast<AnnotateAttr>(*i);
-		if (!ann)
-			continue;
-		string s = ann->getAnnotation().str();
-		if (s.substr(0, len) == sub) {
-			super = s.substr(len + 1, s.length() - len  - 2);
-			return true;
-		}
-	}
-
-	return false;
-}
-
-/* Is decl marked as a constructor?
+static const char *fixed_arg_fmt = "arg%d";
+/* Argument format for Python methods with a variable number of arguments.
  */
-static bool is_constructor(Decl *decl)
-{
-	return has_annotation(decl, "isl_constructor");
-}
+static const char *var_arg_fmt = "args%d";
 
-/* Is decl marked as consuming a reference?
+/* Drop the "isl_" initial part of the type name "name".
  */
-static bool takes(Decl *decl)
+static string type2python(string name)
 {
-	return has_annotation(decl, "isl_take");
+	return name.substr(4);
 }
 
-/* isl_class collects all constructors and methods for an isl "class".
- * "name" is the name of the class.
- * "type" is the declaration that introduces the type.
+/* Print the arguments of a method with "n_arg" arguments, starting at "first".
  */
-struct isl_class {
-	string name;
-	RecordDecl *type;
-	set<FunctionDecl *> constructors;
-	set<FunctionDecl *> methods;
-
-	void print(map<string, isl_class> &classes, set<string> &done);
-	void print_constructor(FunctionDecl *method);
-	void print_method(FunctionDecl *method, bool subclass, string super);
-};
-
-/* Return the class that has a name that matches the initial part
- * of the namd of function "fd".
- */
-static isl_class &method2class(map<string, isl_class> &classes,
-	FunctionDecl *fd)
+void python_generator::print_method_arguments(int first, int n_arg)
 {
-	string best;
-	map<string, isl_class>::iterator ci;
-	string name = fd->getNameAsString();
-
-	for (ci = classes.begin(); ci != classes.end(); ++ci) {
-		if (name.substr(0, ci->first.length()) == ci->first)
-			best = ci->first;
+	for (int i = first; i < n_arg; ++i) {
+		if (i > first)
+			printf(", ");
+		printf("arg%d", i);
 	}
-
-	return classesbest;
 }
 
-/* Is "type" the type "isl_ctx *"?
+/* Print the start of a definition for method "name"
+ * (without specifying the arguments).
+ * If "is_static" is set, then mark the python method as static.
+ *
+ * If the method is called "from", then rename it to "convert_from"
+ * because "from" is a python keyword.
  */
-static bool is_isl_ctx(QualType type)
+static void print_method_def(bool is_static, const string &name)
 {
-	if (!type->isPointerType())
-		return 0;
-	type = type->getPointeeType();
-	if (type.getAsString() != "isl_ctx")
-		return false;
+	const char *s;
+
+	if (is_static)
+		printf("    @staticmethod\n");
 
-	return true;
+	s = name.c_str();
+	if (name == "from")
+		s = "convert_from";
+
+	printf("    def %s", s);
 }
 
-/* Is the first argument of "fd" of type "isl_ctx *"?
+/* Print the header of the method "name" with "n_arg" arguments.
+ * If "is_static" is set, then mark the python method as static.
  */
-static bool first_arg_is_isl_ctx(FunctionDecl *fd)
+void python_generator::print_method_header(bool is_static, const string &name,
+	int n_arg)
 {
-	ParmVarDecl *param;
-
-	if (fd->getNumParams() < 1)
-		return false;
-
-	param = fd->getParamDecl(0);
-	return is_isl_ctx(param->getOriginalType());
+	print_method_def(is_static, name);
+	printf("(");
+	print_method_arguments(0, n_arg);
+	printf("):\n");
 }
 
-/* Is "type" that of a pointer to an isl_* structure?
+/* Print formatted output with the given indentation.
  */
-static bool is_isl_type(QualType type)
+static void print_indent(int indent, const char *format, ...)
 {
-	if (type->isPointerType()) {
-		string s = type->getPointeeType().getAsString();
-		return s.substr(0, 4) == "isl_";
-	}
+	va_list args;
 
-	return false;
+	printf("%*s", indent, " ");
+	va_start(args, format);
+	vprintf(format, args);
+	va_end(args);
 }
 
-/* Is "type" that of a pointer to a function?
+/* Print a check that the argument in position "pos" is of type "type"
+ * with the given indentation.
+ * If this fails and if "upcast" is set, then convert the first
+ * argument to "super" and call the method "name" on it, passing
+ * the remaining of the "n" arguments.
+ * If the check fails and "upcast" is not set, then simply raise
+ * an exception.
+ * If "upcast" is not set, then the "super", "name" and "n" arguments
+ * to this function are ignored.
+ * "fmt" is the format for printing Python method arguments.
  */
-static bool is_callback(QualType type)
+void python_generator::print_type_check(int indent, const string &type,
+	const char *fmt, int pos, bool upcast, const string &super,
+	const string &name, int n)
 {
-	if (!type->isPointerType())
-		return false;
-	type = type->getPointeeType();
-	return type->isFunctionType();
+	print_indent(indent, "try:\n");
+	print_indent(indent, "    if not ");
+	printf(fmt, pos);
+	printf(".__class__ is %s:\n", type.c_str());
+	print_indent(indent, "        ");
+	printf(fmt, pos);
+	printf(" = %s(", type.c_str());
+	printf(fmt, pos);
+	printf(")\n");
+	print_indent(indent, "except:\n");
+	if (upcast) {
+		print_indent(indent, "    return %s(",
+			type2python(super).c_str());
+		printf(fmt, 0);
+		printf(").%s(", name.c_str());
+		for (int i = 1; i < n; ++i) {
+			if (i != 1)
+				printf(", ");
+			printf(fmt, i);
+		}
+		printf(")\n");
+	} else
+		print_indent(indent, "    raise\n");
 }
 
-/* Is "type" that of "char *" of "const char *"?
+/* For each of the "n" initial arguments of the function "method"
+ * that refer to an isl structure,
+ * including the object on which the method is called,
+ * check if the corresponding actual argument is of the right type.
+ * If not, try and convert it to the right type.
+ * If that doesn't work and if "super" contains at least one element,
+ * try and convert self to the type of the first superclass in "super" and
+ * call the corresponding method.
+ * If "first_is_ctx" is set, then the first argument is skipped.
  */
-static bool is_string(QualType type)
+void python_generator::print_type_checks(const string &cname,
+	FunctionDecl *method, bool first_is_ctx, int n,
+	const vector<string> &super)
 {
-	if (type->isPointerType()) {
-		string s = type->getPointeeType().getAsString();
-		return s == "const char" || s == "char";
-	}
+	for (int i = first_is_ctx; i < n; ++i) {
+		ParmVarDecl *param = method->getParamDecl(i);
+		string type;
 
-	return false;
+		if (!is_isl_type(param->getOriginalType()))
+			continue;
+		type = type2python(extract_type(param->getOriginalType()));
+		if (!first_is_ctx && i > 0 && super.size() > 0)
+			print_type_check(8, type, fixed_arg_fmt,
+					i - first_is_ctx, true,
+					super0, cname, n);
+		else
+			print_type_check(8, type, fixed_arg_fmt,
+					i - first_is_ctx, false, "", cname, -1);
+	}
 }
 
-/* Return the name of the type that "type" points to.
- * The input "type" is assumed to be a pointer type.
+/* Print a call to the *_copy function corresponding to "type".
  */
-static string extract_type(QualType type)
+void python_generator::print_copy(QualType type)
 {
-	if (type->isPointerType())
-		return type->getPointeeType().getAsString();
-	assert(0);
-}
+	string type_s = extract_type(type);
 
-/* Drop the "isl_" initial part of the type name "name".
- */
-static string type2python(string name)
-{
-	return name.substr(4);
+	printf("isl.%s_copy", type_s.c_str());
 }
 
-/* Construct a wrapper for a callback argument (at position "arg").
+/* Construct a wrapper for callback argument "param" (at position "arg").
  * Assign the wrapper to "cb".  We assume here that a function call
  * has at most one callback argument.
  *
- * The wrapper converts the arguments of the callback to python types.
+ * The wrapper converts the arguments of the callback to python types,
+ * taking a copy if the C callback does not take its arguments.
  * If any exception is thrown, the wrapper keeps track of it in exc_info0
- * and returns -1.  Otherwise the wrapper returns 0.
+ * and returns a value indicating an error.  Otherwise the wrapper
+ * returns a value indicating success.
+ * In case the C callback is expected to return an isl_stat,
+ * the error value is -1 and the success value is 0.
+ * In case the C callback is expected to return an isl_bool,
+ * the error value is -1 and the success value is 1 or 0 depending
+ * on the result of the Python callback.
+ * Otherwise, None is returned to indicate an error and
+ * a copy of the object in case of success.
  */
-static void print_callback(QualType type, int arg)
+void python_generator::print_callback(ParmVarDecl *param, int arg)
 {
-	const FunctionProtoType *fn = type->getAs<FunctionProtoType>();
+	QualType type = param->getOriginalType();
+	const FunctionProtoType *fn = extract_prototype(type);
+	QualType return_type = fn->getReturnType();
 	unsigned n_arg = fn->getNumArgs();
 
 	printf("        exc_info = None\n");
-	printf("        fn = CFUNCTYPE(c_int");
-	for (int i = 0; i < n_arg - 1; ++i) {
-		QualType arg_type = fn->getArgType(i);
-		assert(is_isl_type(arg_type));
+	printf("        fn = CFUNCTYPE(");
+	if (is_isl_stat(return_type) || is_isl_bool(return_type))
+		printf("c_int");
+	else
+		printf("c_void_p");
+	for (unsigned i = 0; i < n_arg - 1; ++i) {
+		if (!is_isl_type(fn->getArgType(i)))
+			die("Argument has non-isl type");
 		printf(", c_void_p");
 	}
 	printf(", c_void_p)\n");
 	printf("        def cb_func(");
-	for (int i = 0; i < n_arg; ++i) {
+	for (unsigned i = 0; i < n_arg; ++i) {
 		if (i)
 			printf(", ");
 		printf("cb_arg%d", i);
 	}
 	printf("):\n");
-	for (int i = 0; i < n_arg - 1; ++i) {
+	for (unsigned i = 0; i < n_arg - 1; ++i) {
 		string arg_type;
 		arg_type = type2python(extract_type(fn->getArgType(i)));
-		printf("            cb_arg%d = %s(ctx=arg0.ctx, ptr=cb_arg%d)\n",
-			i, arg_type.c_str(), i);
+		printf("            cb_arg%d = %s(ctx=arg0.ctx, ptr=",
+			i, arg_type.c_str());
+		if (!callback_takes_argument(param, i))
+			print_copy(fn->getArgType(i));
+		printf("(cb_arg%d))\n", i);
 	}
 	printf("            try:\n");
-	printf("                arg%d(", arg);
-	for (int i = 0; i < n_arg - 1; ++i) {
+	if (is_isl_stat(return_type))
+		printf("                arg%d(", arg);
+	else
+		printf("                res = arg%d(", arg);
+	for (unsigned i = 0; i < n_arg - 1; ++i) {
 		if (i)
 			printf(", ");
 		printf("cb_arg%d", i);
 	}
 	printf(")\n");
-	printf("            except:\n");
-	printf("                import sys\n");
-	printf("                exc_info0 = sys.exc_info()\n");
-	printf("                return -1\n");
-	printf("            return 0\n");
+	printf("            except BaseException as e:\n");
+	printf("                exc_info0 = e\n");
+	if (is_isl_stat(return_type) || is_isl_bool(return_type))
+		printf("                return -1\n");
+	else
+		printf("                return None\n");
+	if (is_isl_stat(return_type)) {
+		printf("            return 0\n");
+	} else if (is_isl_bool(return_type)) {
+		printf("            return 1 if res else 0\n");
+	} else {
+		printf("            return ");
+		print_copy(return_type);
+		printf("(res.ptr)\n");
+	}
 	printf("        cb = fn(cb_func)\n");
 }
 
+/* Print the argument at position "arg" in call to "fd".
+ * "fmt" is the format for printing Python method arguments.
+ * "skip" is the number of initial arguments of "fd" that are
+ * skipped in the Python method.
+ *
+ * If the (first) argument is an isl_ctx, then print "ctx",
+ * assuming that the caller has made the context available
+ * in a "ctx" variable.
+ * Otherwise, if the argument is a callback, then print a reference to
+ * the callback wrapper "cb".
+ * Otherwise, if the argument is marked as consuming a reference,
+ * then pass a copy of the pointer stored in the corresponding
+ * argument passed to the Python method.
+ * Otherwise, if the argument is a string, then the python string is first
+ * encoded as a byte sequence, using 'ascii' as encoding.  This assumes
+ * that all strings passed to isl can be converted to 'ascii'.
+ * Otherwise, if the argument is a pointer, then pass this pointer itself.
+ * Otherwise, pass the argument directly.
+ */
+void python_generator::print_arg_in_call(FunctionDecl *fd, const char *fmt,
+	int arg, int skip)
+{
+	ParmVarDecl *param = fd->getParamDecl(arg);
+	QualType type = param->getOriginalType();
+	if (is_isl_ctx(type)) {
+		printf("ctx");
+	} else if (is_callback(type)) {
+		printf("cb");
+	} else if (takes(param)) {
+		print_copy(type);
+		printf("(");
+		printf(fmt, arg - skip);
+		printf(".ptr)");
+	} else if (is_string(type)) {
+		printf(fmt, arg - skip);
+		printf(".encode('ascii')");
+	} else if (type->isPointerType()) {
+		printf(fmt, arg - skip);
+		printf(".ptr");
+	} else {
+		printf(fmt, arg - skip);
+	}
+}
+
+/* Generate code that raises the exception captured in "exc_info", if any,
+ * with the given indentation.
+ */
+static void print_rethrow(int indent, const char *exc_info)
+{
+	print_indent(indent, "if %s is not None:\n", exc_info);
+	print_indent(indent, "    raise %s\n", exc_info);
+}
+
+/* Print code with the given indentation that checks
+ * whether any of the persistent callbacks of "clazz"
+ * is set and if it failed with an exception.  If so, the 'exc_info'
+ * field contains the exception and is raised again.
+ * The field is cleared because the callback and its data may get reused.
+ * "fmt" is the format for printing Python method arguments.
+ */
+static void print_persistent_callback_failure_check(int indent,
+	const isl_class &clazz, const char *fmt)
+{
+	const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
+	set<FunctionDecl *>::const_iterator in;
+
+	for (in = callbacks.begin(); in != callbacks.end(); ++in) {
+		string callback_name = clazz.persistent_callback_name(*in);
+
+		print_indent(indent, "if hasattr(");
+		printf(fmt, 0);
+		printf(", '%s') and ", callback_name.c_str());
+		printf(fmt, 0);
+		printf(".%s'exc_info' != None:\n", callback_name.c_str());
+		print_indent(indent, "    exc_info = ");
+		printf(fmt, 0);
+		printf(".%s'exc_info'0\n", callback_name.c_str());
+		print_indent(indent, "    ");
+		printf(fmt, 0);
+		printf(".%s'exc_info'0 = None\n", callback_name.c_str());
+		print_rethrow(indent + 4, "exc_info");
+	}
+}
+
+/* Print the return statement of the python method corresponding
+ * to the C function "method" with the given indentation.
+ * If the object on which the method was called
+ * may have a persistent callback, then first check if any of those failed.
+ * "fmt" is the format for printing Python method arguments.
+ *
+ * If the method returns a new instance of the same object type and
+ * if the class has any persistent callbacks, then the data
+ * for these callbacks are copied from the original to the new object.
+ * If the method it itself setting a persistent callback,
+ * then keep track of the constructed C callback (such that it doesn't
+ * get destroyed) and the data structure that holds the captured exception
+ * (such that it can be raised again).
+ *
+ * If the return type is a (const) char *, then convert the result
+ * to a Python string, raising an error on NULL and freeing
+ * the C string if needed.  For python 3 compatibility, the string returned
+ * by isl is explicitly decoded as an 'ascii' string.  This is correct
+ * as all strings returned by isl are expected to be 'ascii'.
+ *
+ * If the return type is isl_stat, isl_bool or isl_size, then
+ * raise an error on isl_stat_error, isl_bool_error or isl_size_error.
+ * In case of isl_bool, the result is converted to
+ * a Python boolean.
+ * In case of isl_size, the result is converted to a Python int.
+ */
+void python_generator::print_method_return(int indent, const isl_class &clazz,
+	FunctionDecl *method, const char *fmt)
+{
+	QualType return_type = method->getReturnType();
+
+	if (!is_static(clazz, method))
+		print_persistent_callback_failure_check(indent, clazz, fmt);
+
+	if (is_isl_type(return_type)) {
+		string type;
+
+		type = type2python(extract_type(return_type));
+		print_indent(indent,
+			"obj = %s(ctx=ctx, ptr=res)\n", type.c_str());
+		if (is_mutator(clazz, method) &&
+		    clazz.has_persistent_callbacks())
+			print_indent(indent, "obj.copy_callbacks(arg0)\n");
+		if (clazz.persistent_callbacks.count(method)) {
+			string callback_name;
+
+			callback_name = clazz.persistent_callback_name(method);
+			print_indent(indent, "obj.%s = { 'func': cb, "
+				"'exc_info': exc_info }\n",
+				callback_name.c_str());
+		}
+		print_indent(indent, "return obj\n");
+	} else if (is_string(return_type)) {
+		print_indent(indent, "if res == 0:\n");
+		print_indent(indent, "    raise\n");
+		print_indent(indent, "string = "
+		       "cast(res, c_char_p).value.decode('ascii')\n");
+
+		if (gives(method))
+			print_indent(indent, "libc.free(res)\n");
+
+		print_indent(indent, "return string\n");
+	} else if (is_isl_neg_error(return_type)) {
+		print_indent(indent, "if res < 0:\n");
+		print_indent(indent, "    raise\n");
+		if (is_isl_bool(return_type))
+			print_indent(indent, "return bool(res)\n");
+		else if (is_isl_size(return_type))
+			print_indent(indent, "return int(res)\n");
+	} else {
+		print_indent(indent, "return res\n");
+	}
+}
+
+/* Print a python "get" method corresponding to the C function "fd"
+ * in class "clazz" using a name that includes the "get_" prefix.
+ *
+ * This method simply calls the variant without the "get_" prefix and
+ * returns its result.
+ * Note that static methods are not considered to be "get" methods.
+ */
+void python_generator::print_get_method(const isl_class &clazz,
+	FunctionDecl *fd)
+{
+	string get_name = clazz.base_method_name(fd);
+	string name = clazz.method_name(fd);
+	int num_params = fd->getNumParams();
+
+	print_method_header(false, get_name, num_params);
+	printf("        return arg0.%s(", name.c_str());
+	print_method_arguments(1, num_params);
+	printf(")\n");
+}
+
+/* Print a call to "method", along with the corresponding
+ * return statement, with the given indentation.
+ * "drop_ctx" is set if the first argument is an isl_ctx.
+ * "drop_user" is set if the last argument is a "user" argument
+ * corresponding to a callback argument.
+ *
+ * A "ctx" variable is first initialized as it may be needed
+ * in the first call to print_arg_in_call and in print_method_return.
+ *
+ * If the method has a callback function, then any exception
+ * thrown in the callback also need to be rethrown.
+ */
+void python_generator::print_method_call(int indent, const isl_class &clazz,
+	FunctionDecl *method, const char *fmt, int drop_ctx, int drop_user)
+{
+	string fullname = method->getName().str();
+	int num_params = method->getNumParams();
+
+	if (drop_ctx) {
+		print_indent(indent, "ctx = Context.getDefaultInstance()\n");
+	} else {
+		print_indent(indent, "ctx = ");
+		printf(fmt, 0);
+		printf(".ctx\n");
+	}
+	print_indent(indent, "res = isl.%s(", fullname.c_str());
+	for (int i = 0; i < num_params - drop_user; ++i) {
+		if (i > 0)
+			printf(", ");
+		print_arg_in_call(method, fmt, i, drop_ctx);
+	}
+	if (drop_user)
+		printf(", None");
+	printf(")\n");
+
+	if (drop_user)
+		print_rethrow(indent, "exc_info0");
+
+	print_method_return(indent, clazz, method, fmt);
+}
+
 /* Print a python method corresponding to the C function "method".
- * "subclass" is set if the method belongs to a class that is a subclass
- * of some other class ("super").
+ * "super" contains the superclasses of the class to which the method belongs,
+ * with the first element corresponding to the annotation that appears
+ * closest to the annotated type.  This superclass is the least
+ * general extension of the annotated type in the linearization
+ * of the class hierarchy.
+ *
+ * If the first argument of "method" is something other than an instance
+ * of the class, then mark the python method as static.
+ * If, moreover, this first argument is an isl_ctx, then remove
+ * it from the arguments of the Python method.
  *
  * If the function has a callback argument, then it also has a "user"
  * argument.  Since Python has closures, there is no need for such
  * a user argument in the Python interface, so we simply drop it.
  * We also create a wrapper ("cb") for the callback.
  *
- * For each argument of the function that refers to an isl structure,
- * including the object on which the method is called,
- * we check if the corresponding actual argument is of the right type.
- * If not, we try to convert it to the right type.
- * It that doesn't work and if subclass is set, we try to convert self
- * to the type of the superclass and call the corresponding method.
- *
  * If the function consumes a reference, then we pass it a copy of
  * the actual argument.
+ *
+ * For methods that are identified as "get" methods, also
+ * print a variant of the method using a name that includes
+ * the "get_" prefix.
  */
-void isl_class::print_method(FunctionDecl *method, bool subclass, string super)
+void python_generator::print_method(const isl_class &clazz,
+	FunctionDecl *method, vector<string> super)
 {
-	string fullname = method->getName();
-	string cname = fullname.substr(name.length() + 1);
+	string cname = clazz.method_name(method);
 	int num_params = method->getNumParams();
 	int drop_user = 0;
+	int drop_ctx = first_arg_is_isl_ctx(method);
 
 	for (int i = 1; i < num_params; ++i) {
 		ParmVarDecl *param = method->getParamDecl(i);
@@ -272,161 +533,504 @@
 			drop_user = 1;
 	}
 
-	printf("    def %s(arg0", cname.c_str());
-	for (int i = 1; i < num_params - drop_user; ++i)
-		printf(", arg%d", i);
-	printf("):\n");
+	print_method_header(is_static(clazz, method), cname,
+			    num_params - drop_ctx - drop_user);
 
-	for (int i = 0; i < num_params; ++i) {
-		ParmVarDecl *param = method->getParamDecl(i);
-		string type;
-		if (!is_isl_type(param->getOriginalType()))
-			continue;
-		type = type2python(extract_type(param->getOriginalType()));
-		printf("        try:\n");
-		printf("            if not arg%d.__class__ is %s:\n",
-			i, type.c_str());
-		printf("                arg%d = %s(arg%d)\n",
-			i, type.c_str(), i);
-		printf("        except:\n");
-		if (i > 0 && subclass) {
-			printf("            return %s(arg0).%s(",
-				type2python(super).c_str(), cname.c_str());
-			for (int i = 1; i < num_params - drop_user; ++i) {
-				if (i != 1)
-					printf(", ");
-				printf("arg%d", i);
-			}
-			printf(")\n");
-		} else
-			printf("            raise\n");
-	}
+	print_type_checks(cname, method, drop_ctx,
+			    num_params - drop_user, super);
 	for (int i = 1; i < num_params; ++i) {
 		ParmVarDecl *param = method->getParamDecl(i);
 		QualType type = param->getOriginalType();
 		if (!is_callback(type))
 			continue;
-		print_callback(type->getPointeeType(), i);
+		print_callback(param, i - drop_ctx);
 	}
-	printf("        res = isl.%s(", fullname.c_str());
-	if (takes(method->getParamDecl(0)))
-		printf("isl.%s_copy(arg0.ptr)", name.c_str());
-	else
-		printf("arg0.ptr");
-	for (int i = 1; i < num_params - drop_user; ++i) {
-		ParmVarDecl *param = method->getParamDecl(i);
+	print_method_call(8, clazz, method, fixed_arg_fmt, drop_ctx, drop_user);
+
+	if (clazz.is_get_method(method))
+		print_get_method(clazz, method);
+}
+
+/* Print a condition that checks whether Python method argument "i"
+ * corresponds to the C function argument type "type".
+ */
+static void print_argument_check(QualType type, int i)
+{
+	if (generator::is_isl_type(type)) {
+		string type_str;
+		type_str = generator::extract_type(type);
+		type_str = type2python(type_str);
+		printf("args%d.__class__ is %s", i, type_str.c_str());
+	} else if (type->isPointerType()) {
+		printf("type(args%d) == str", i);
+	} else {
+		printf("type(args%d) == int", i);
+	}
+}
+
+/* Print a test that checks whether the arguments passed
+ * to the Python method correspond to the arguments
+ * expected by "fd".
+ * "drop_ctx" is set if the first argument of "fd" is an isl_ctx,
+ * which does not appear as an argument to the Python method.
+ *
+ * If an automatic conversion function is available for any
+ * of the argument types, then also allow the argument
+ * to be of the type as prescribed by the second input argument
+ * of the conversion function.
+ * The corresponding arguments are then converted to the expected types
+ * if needed.  The argument tuple first needs to be converted to a list
+ * in order to be able to modify the entries.
+ */
+void python_generator::print_argument_checks(const isl_class &clazz,
+	FunctionDecl *fd, int drop_ctx)
+{
+	int num_params = fd->getNumParams();
+	int first = generator::is_static(clazz, fd) ? drop_ctx : 1;
+	std::vector<bool> convert(num_params);
+
+	printf("        if len(args) == %d", num_params - drop_ctx);
+	for (int i = first; i < num_params; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
 		QualType type = param->getOriginalType();
-		if (is_callback(type))
-			printf(", cb");
-		else if (takes(param)) {
-			string type_s = extract_type(type);
-			printf(", isl.%s_copy(arg%d.ptr)", type_s.c_str(), i);
-		} else
-			printf(", arg%d.ptr", i);
+		const Type *ptr = type.getTypePtr();
+
+		printf(" and ");
+		if (conversions.count(ptr) == 0) {
+			print_argument_check(type, i - drop_ctx);
+		} else {
+			QualType type2 = conversions.at(ptr)->getOriginalType();
+			converti = true;
+			printf("(");
+			print_argument_check(type, i - drop_ctx);
+			printf(" or ");
+			print_argument_check(type2, i - drop_ctx);
+			printf(")");
+		}
 	}
-	if (drop_user)
-		printf(", None");
-	printf(")\n");
+	printf(":\n");
 
-	if (is_isl_type(method->getReturnType())) {
+	if (std::find(convert.begin(), convert.end(), true) == convert.end())
+		return;
+	print_indent(12, "args = list(args)\n");
+	for (int i = first; i < num_params; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
 		string type;
-		type = type2python(extract_type(method->getReturnType()));
-		printf("        return %s(ctx=arg0.ctx, ptr=res)\n",
-			type.c_str());
-	} else {
-		if (drop_user) {
-			printf("        if exc_info0 != None:\n");
-			printf("            raise exc_info00, "
-				"exc_info01, exc_info02\n");
-		}
-		printf("        return res\n");
+
+		if (!converti)
+			continue;
+		type = type2python(extract_type(param->getOriginalType()));
+		print_type_check(12, type, var_arg_fmt,
+				i - drop_ctx, false, "", "", -1);
 	}
 }
 
+/* Print part of an overloaded python method corresponding to the C function
+ * "method".
+ * "drop_ctx" is set if the first argument of "method" is an isl_ctx.
+ *
+ * In particular, print code to test whether the arguments passed to
+ * the python method correspond to the arguments expected by "method"
+ * and to call "method" if they do.
+ */
+void python_generator::print_method_overload(const isl_class &clazz,
+	FunctionDecl *method)
+{
+	int drop_ctx = first_arg_is_isl_ctx(method);
+
+	print_argument_checks(clazz, method, drop_ctx);
+	print_method_call(12, clazz, method, var_arg_fmt, drop_ctx, 0);
+}
+
+/* Print a python method with a name derived from "fullname"
+ * corresponding to the C functions "methods".
+ * "super" contains the superclasses of the class to which the method belongs.
+ *
+ * If "methods" consists of a single element that is not marked overloaded,
+ * the use print_method to print the method.
+ * Otherwise, print an overloaded method with pieces corresponding
+ * to each function in "methods".
+ */
+void python_generator::print_method(const isl_class &clazz,
+	const string &fullname, const function_set &methods,
+	vector<string> super)
+{
+	string cname;
+	function_set::const_iterator it;
+	FunctionDecl *any_method;
+
+	any_method = *methods.begin();
+	if (methods.size() == 1 && !is_overload(any_method)) {
+		print_method(clazz, any_method, super);
+		return;
+	}
+
+	cname = clazz.method_name(any_method);
+
+	print_method_def(is_static(clazz, any_method), cname);
+	printf("(*args):\n");
+
+	for (it = methods.begin(); it != methods.end(); ++it)
+		print_method_overload(clazz, *it);
+	printf("        raise Error\n");
+}
+
+/* Print a python method "name" corresponding to "fd" setting
+ * the enum value "value".
+ * "super" contains the superclasses of the class to which the method belongs,
+ * with the first element corresponding to the annotation that appears
+ * closest to the annotated type.
+ *
+ * The last argument of the C function does not appear in the method call,
+ * but is fixed to "value" instead.
+ * Other than that, the method printed here is similar to one
+ * printed by python_generator::print_method, except that
+ * some of the special cases do not occur.
+ */
+void python_generator::print_set_enum(const isl_class &clazz,
+	FunctionDecl *fd, int value, const string &name,
+	const vector<string> &super)
+{
+	string fullname = fd->getName().str();
+	int num_params = fd->getNumParams();
+
+	print_method_header(is_static(clazz, fd), name, num_params - 1);
+
+	print_type_checks(name, fd, false, num_params - 1, super);
+	printf("        ctx = arg0.ctx\n");
+	printf("        res = isl.%s(", fullname.c_str());
+	for (int i = 0; i < num_params - 1; ++i) {
+		if (i)
+			printf(", ");
+		print_arg_in_call(fd, fixed_arg_fmt, i, 0);
+	}
+	printf(", %d", value);
+	printf(")\n");
+	print_method_return(8, clazz, fd, fixed_arg_fmt);
+}
+
+/* Print python methods corresponding to "fd", which sets an enum.
+ * "super" contains the superclasses of the class to which the method belongs,
+ * with the first element corresponding to the annotation that appears
+ * closest to the annotated type.
+ *
+ * A method is generated for each value in the enum, setting
+ * the enum to that value.
+ */
+void python_generator::print_set_enum(const isl_class &clazz,
+	FunctionDecl *fd, const vector<string> &super)
+{
+	vector<set_enum>::const_iterator it;
+	const vector<set_enum> &set_enums = clazz.set_enums.at(fd);
+
+	for (it = set_enums.begin(); it != set_enums.end(); ++it)
+		print_set_enum(clazz, fd, it->value, it->method_name, super);
+}
+
 /* Print part of the constructor for this isl_class.
  *
  * In particular, check if the actual arguments correspond to the
  * formal arguments of "cons" and if so call "cons" and put the
  * result in self.ptr and a reference to the default context in self.ctx.
- *
- * If the function consumes a reference, then we pass it a copy of
- * the actual argument.
  */
-void isl_class::print_constructor(FunctionDecl *cons)
+void python_generator::print_constructor(const isl_class &clazz,
+	FunctionDecl *cons)
 {
-	string fullname = cons->getName();
-	string cname = fullname.substr(name.length() + 1);
+	string fullname = cons->getName().str();
+	string cname = clazz.method_name(cons);
 	int num_params = cons->getNumParams();
 	int drop_ctx = first_arg_is_isl_ctx(cons);
 
-	printf("        if len(args) == %d", num_params - drop_ctx);
-	for (int i = drop_ctx; i < num_params; ++i) {
-		ParmVarDecl *param = cons->getParamDecl(i);
-		if (is_isl_type(param->getOriginalType())) {
-			string type;
-			type = extract_type(param->getOriginalType());
-			type = type2python(type);
-			printf(" and args%d.__class__ is %s",
-				i - drop_ctx, type.c_str());
-		} else
-			printf(" and type(args%d) == str", i - drop_ctx);
-	}
-	printf(":\n");
+	print_argument_checks(clazz, cons, drop_ctx);
 	printf("            self.ctx = Context.getDefaultInstance()\n");
 	printf("            self.ptr = isl.%s(", fullname.c_str());
 	if (drop_ctx)
 		printf("self.ctx");
 	for (int i = drop_ctx; i < num_params; ++i) {
-		ParmVarDecl *param = cons->getParamDecl(i);
 		if (i)
 			printf(", ");
-		if (is_isl_type(param->getOriginalType())) {
-			if (takes(param)) {
-				string type;
-				type = extract_type(param->getOriginalType());
-				printf("isl.%s_copy(args%d.ptr)",
-					type.c_str(), i - drop_ctx);
-			} else
-				printf("args%d.ptr", i - drop_ctx);
-		} else
-			printf("args%d", i - drop_ctx);
+		print_arg_in_call(cons, var_arg_fmt, i, drop_ctx);
 	}
 	printf(")\n");
 	printf("            return\n");
 }
 
+/* If "clazz" has a type function describing subclasses,
+ * then add constructors that allow each of these subclasses
+ * to be treated as an object to the superclass.
+ */
+void python_generator::print_upcast_constructors(const isl_class &clazz)
+{
+	map<int, string>::const_iterator i;
+
+	if (!clazz.fn_type)
+		return;
+
+	for (i = clazz.type_subclasses.begin();
+	     i != clazz.type_subclasses.end(); ++i) {
+		printf("        if len(args) == 1 and "
+						"isinstance(args0, %s):\n",
+			 type2python(i->second).c_str());
+		printf("            self.ctx = args0.ctx\n");
+		printf("            self.ptr = isl.%s_copy(args0.ptr)\n",
+			clazz.name.c_str());
+		printf("            return\n");
+	}
+}
+
+/* Print the header of the class "name" with superclasses "super".
+ * The order of the superclasses is the opposite of the order
+ * in which the corresponding annotations appear in the source code.
+ * If "clazz" is a subclass derived from a type function,
+ * then the immediate superclass is recorded in "clazz" itself.
+ */
+void python_generator::print_class_header(const isl_class &clazz,
+	const string &name, const vector<string> &super)
+{
+	printf("class %s", name.c_str());
+	if (super.size() > 0) {
+		printf("(");
+		for (unsigned i = 0; i < super.size(); ++i) {
+			if (i > 0)
+				printf(", ");
+			printf("%s", type2python(superi).c_str());
+		}
+		printf(")");
+	} else if (clazz.is_type_subclass()) {
+		printf("(%s)", type2python(clazz.superclass_name).c_str());
+	} else {
+		printf("(object)");
+	}
+	printf(":\n");
+}
+
+/* Tell ctypes about the return type of "fd".
+ * In particular, if "fd" returns a pointer to an isl object,
+ * then tell ctypes it returns a "c_void_p".
+ * If "fd" returns a char *, then simply tell ctypes.
+ *
+ * Nothing needs to be done for functions returning
+ * isl_bool, isl_stat or isl_size since they are represented by an int and
+ * ctypes assumes that a function returns int by default.
+ */
+void python_generator::print_restype(FunctionDecl *fd)
+{
+	string fullname = fd->getName().str();
+	QualType type = fd->getReturnType();
+	if (is_isl_type(type))
+		printf("isl.%s.restype = c_void_p\n", fullname.c_str());
+	else if (is_string(type))
+		printf("isl.%s.restype = POINTER(c_char)\n", fullname.c_str());
+}
+
+/* Tell ctypes about the types of the arguments of the function "fd".
+ */
+void python_generator::print_argtypes(FunctionDecl *fd)
+{
+	string fullname = fd->getName().str();
+	int n = fd->getNumParams();
+	int drop_user = 0;
+
+	printf("isl.%s.argtypes = ", fullname.c_str());
+	for (int i = 0; i < n - drop_user; ++i) {
+		ParmVarDecl *param = fd->getParamDecl(i);
+		QualType type = param->getOriginalType();
+		if (is_callback(type))
+			drop_user = 1;
+		if (i)
+			printf(", ");
+		if (is_isl_ctx(type))
+			printf("Context");
+		else if (is_isl_type(type) || is_callback(type))
+			printf("c_void_p");
+		else if (is_string(type))
+			printf("c_char_p");
+		else if (is_long(type))
+			printf("c_long");
+		else
+			printf("c_int");
+	}
+	if (drop_user)
+		printf(", c_void_p");
+	printf("\n");
+}
+
+/* Print type definitions for the method 'fd'.
+ */
+void python_generator::print_method_type(FunctionDecl *fd)
+{
+	print_restype(fd);
+	print_argtypes(fd);
+}
+
+/* If "clazz" has a type function describing subclasses or
+ * if it is one of those type subclasses, then print a __new__ method.
+ *
+ * In the superclass, the __new__ method constructs an object
+ * of the subclass type specified by the type function.
+ * In the subclass, the __new__ method reverts to the original behavior.
+ */
+void python_generator::print_new(const isl_class &clazz,
+	const string &python_name)
+{
+	if (!clazz.fn_type && !clazz.is_type_subclass())
+		return;
+
+	printf("    def __new__(cls, *args, **keywords):\n");
+
+	if (clazz.fn_type) {
+		map<int, string>::const_iterator i;
+
+		printf("        if \"ptr\" in keywords:\n");
+		printf("            type = isl.%s(keywords\"ptr\")\n",
+			clazz.fn_type->getNameAsString().c_str());
+
+		for (i = clazz.type_subclasses.begin();
+		     i != clazz.type_subclasses.end(); ++i) {
+			printf("            if type == %d:\n", i->first);
+			printf("                return %s(**keywords)\n",
+				type2python(i->second).c_str());
+		}
+		printf("            raise\n");
+	}
+
+	printf("        return super(%s, cls).__new__(cls)\n",
+		python_name.c_str());
+}
+
+/* Print declarations for methods printing the class representation,
+ * provided there is a corresponding *_to_str function.
+ *
+ * In particular, provide an implementation of __str__ and __repr__ methods to
+ * override the default representation used by python. Python uses __str__ to
+ * pretty print the class (e.g., when calling print(obj)) and uses __repr__
+ * when printing a precise representation of an object (e.g., when dumping it
+ * in the REPL console).
+ *
+ * Check the type of the argument before calling the *_to_str function
+ * on it in case the method was called on an object from a subclass.
+ *
+ * The return value of the *_to_str function is decoded to a python string
+ * assuming an 'ascii' encoding.  This is necessary for python 3 compatibility.
+ */
+void python_generator::print_representation(const isl_class &clazz,
+	const string &python_name)
+{
+	if (!clazz.fn_to_str)
+		return;
+
+	printf("    def __str__(arg0):\n");
+	print_type_check(8, python_name, fixed_arg_fmt, 0, false, "", "", -1);
+	printf("        ptr = isl.%s(arg0.ptr)\n",
+		string(clazz.fn_to_str->getName()).c_str());
+	printf("        res = cast(ptr, c_char_p).value.decode('ascii')\n");
+	printf("        libc.free(ptr)\n");
+	printf("        return res\n");
+	printf("    def __repr__(self):\n");
+	printf("        s = str(self)\n");
+	printf("        if '\"' in s:\n");
+	printf("            return 'isl.%s(\"\"\"%%s\"\"\")' %% s\n",
+		python_name.c_str());
+	printf("        else:\n");
+	printf("            return 'isl.%s(\"%%s\")' %% s\n",
+		python_name.c_str());
+}
+
+/* If "clazz" has any persistent callbacks, then print the definition
+ * of a "copy_callbacks" function that copies the persistent callbacks
+ * from one object to another.
+ */
+void python_generator::print_copy_callbacks(const isl_class &clazz)
+{
+	const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
+	set<FunctionDecl *>::const_iterator in;
+
+	if (!clazz.has_persistent_callbacks())
+		return;
+
+	printf("    def copy_callbacks(self, obj):\n");
+	for (in = callbacks.begin(); in != callbacks.end(); ++in) {
+		string callback_name = clazz.persistent_callback_name(*in);
+
+		printf("        if hasattr(obj, '%s'):\n",
+			callback_name.c_str());
+		printf("            self.%s = obj.%s\n",
+			callback_name.c_str(), callback_name.c_str());
+	}
+}
+
+/* Print code to set method type signatures.
+ *
+ * To be able to call C functions it is necessary to explicitly set their
+ * argument and result types.  Do this for all exported constructors and
+ * methods (including those that set a persistent callback and
+ * those that set an enum value),
+ * as well as for the *_to_str and the type function, if they exist.
+ * Assuming each exported class has a *_copy and a *_free method,
+ * also unconditionally set the type of such methods.
+ */
+void python_generator::print_method_types(const isl_class &clazz)
+{
+	function_set::const_iterator in;
+	map<string, function_set>::const_iterator it;
+	map<FunctionDecl *, vector<set_enum> >::const_iterator ie;
+	const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
+
+	for (in = clazz.constructors.begin(); in != clazz.constructors.end();
+		++in)
+		print_method_type(*in);
+
+	for (in = callbacks.begin(); in != callbacks.end(); ++in)
+		print_method_type(*in);
+	for (it = clazz.methods.begin(); it != clazz.methods.end(); ++it)
+		for (in = it->second.begin(); in != it->second.end(); ++in)
+			print_method_type(*in);
+	for (ie = clazz.set_enums.begin(); ie != clazz.set_enums.end(); ++ie)
+		print_method_type(ie->first);
+
+	print_method_type(clazz.fn_copy);
+	print_method_type(clazz.fn_free);
+	if (clazz.fn_to_str)
+		print_method_type(clazz.fn_to_str);
+	if (clazz.fn_type)
+		print_method_type(clazz.fn_type);
+}
+
 /* Print out the definition of this isl_class.
  *
- * We first check if this isl_class is a subclass of some other class.
- * If it is, we make sure the superclass is printed out first.
+ * We first check if this isl_class is a subclass of one or more other classes.
+ * If it is, we make sure those superclasses are printed out first.
  *
  * Then we print a constructor with several cases, one for constructing
- * a Python object from a return value and one for each function that
- * was marked as a constructor.
+ * a Python object from a return value, one for each function that
+ * was marked as a constructor and for each type based subclass.
  *
  * Next, we print out some common methods and the methods corresponding
- * to functions that are not marked as constructors.
+ * to functions that are not marked as constructors, including those
+ * that set a persistent callback and those that set an enum value.
  *
  * Finally, we tell ctypes about the types of the arguments of the
  * constructor functions and the return types of those function returning
  * an isl object.
  */
-void isl_class::print(map<string, isl_class> &classes, set<string> &done)
+void python_generator::print(const isl_class &clazz)
 {
-	string super;
-	string p_name = type2python(name);
-	set<FunctionDecl *>::iterator in;
-	bool subclass = is_subclass(type, super);
+	string p_name = type2python(clazz.subclass_name);
+	function_set::const_iterator in;
+	map<string, function_set>::const_iterator it;
+	map<FunctionDecl *, vector<set_enum> >::const_iterator ie;
+	vector<string> super = find_superclasses(clazz.type);
+	const set<FunctionDecl *> &callbacks = clazz.persistent_callbacks;
 
-	if (subclass && done.find(super) == done.end())
-		classessuper.print(classes, done);
-	done.insert(name);
+	for (unsigned i = 0; i < super.size(); ++i)
+		if (done.find(superi) == done.end())
+			print(classessuperi);
+	if (clazz.is_type_subclass() && done.find(clazz.name) == done.end())
+		print(classesclazz.name);
+	done.insert(clazz.subclass_name);
 
 	printf("\n");
-	printf("class %s", p_name.c_str());
-	if (subclass)
-		printf("(%s)", type2python(super).c_str());
-	printf(":\n");
+	print_class_header(clazz, p_name, super);
 	printf("    def __init__(self, *args, **keywords):\n");
 
 	printf("        if \"ptr\" in keywords:\n");
@@ -434,86 +1038,44 @@
 	printf("            self.ptr = keywords\"ptr\"\n");
 	printf("            return\n");
 
-	for (in = constructors.begin(); in != constructors.end(); ++in)
-		print_constructor(*in);
+	for (in = clazz.constructors.begin(); in != clazz.constructors.end();
+		++in)
+		print_constructor(clazz, *in);
+	print_upcast_constructors(clazz);
 	printf("        raise Error\n");
 	printf("    def __del__(self):\n");
 	printf("        if hasattr(self, 'ptr'):\n");
-	printf("            isl.%s_free(self.ptr)\n", name.c_str());
-	printf("    def __str__(self):\n");
-	printf("        ptr = isl.%s_to_str(self.ptr)\n", name.c_str());
-	printf("        res = str(cast(ptr, c_char_p).value)\n");
-	printf("        libc.free(ptr)\n");
-	printf("        return res\n");
-	printf("    def __repr__(self):\n");
-	printf("        return 'isl.%s(\"%%s\")' %% str(self)\n", p_name.c_str());
+	printf("            isl.%s_free(self.ptr)\n", clazz.name.c_str());
 
-	for (in = methods.begin(); in != methods.end(); ++in)
-		print_method(*in, subclass, super);
+	print_new(clazz, p_name);
+	print_representation(clazz, p_name);
+	print_copy_callbacks(clazz);
+
+	for (in = callbacks.begin(); in != callbacks.end(); ++in)
+		print_method(clazz, *in, super);
+	for (it = clazz.methods.begin(); it != clazz.methods.end(); ++it)
+		print_method(clazz, it->first, it->second, super);
+	for (ie = clazz.set_enums.begin(); ie != clazz.set_enums.end(); ++ie)
+		print_set_enum(clazz, ie->first, super);
 
 	printf("\n");
-	for (in = constructors.begin(); in != constructors.end(); ++in) {
-		string fullname = (*in)->getName();
-		printf("isl.%s.restype = c_void_p\n", fullname.c_str());
-		printf("isl.%s.argtypes = ", fullname.c_str());
-		for (int i = 0; i < (*in)->getNumParams(); ++i) {
-			ParmVarDecl *param = (*in)->getParamDecl(i);
-			QualType type = param->getOriginalType();
-			if (i)
-				printf(", ");
-			if (is_isl_ctx(type))
-				printf("Context");
-			else if (is_isl_type(type))
-				printf("c_void_p");
-			else if (is_string(type))
-				printf("c_char_p");
-			else
-				printf("c_int");
-		}
-		printf("\n");
-	}
-	for (in = methods.begin(); in != methods.end(); ++in) {
-		string fullname = (*in)->getName();
-		if (is_isl_type((*in)->getReturnType()))
-			printf("isl.%s.restype = c_void_p\n", fullname.c_str());
-	}
-	printf("isl.%s_free.argtypes = c_void_p\n", name.c_str());
-	printf("isl.%s_to_str.argtypes = c_void_p\n", name.c_str());
-	printf("isl.%s_to_str.restype = POINTER(c_char)\n", name.c_str());
+
+	print_method_types(clazz);
 }
 
-/* Generate a python interface based on the extracted types and functions.
- * We first collect all functions that belong to a certain type,
- * separating constructors from regular methods.
+/* Generate a python interface based on the extracted types and
+ * functions.
  *
- * Then we print out each class in turn.  If one of these is a subclass
- * of some other class, it will make sure the superclass is printed out first.
+ * Print out each class in turn.  If one of these is a subclass of some
+ * other class, make sure the superclass is printed out first.
+ * functions.
  */
-void generate_python(set<RecordDecl *> &types, set<FunctionDecl *> functions)
+void python_generator::generate()
 {
-	map<string, isl_class> classes;
 	map<string, isl_class>::iterator ci;
-	set<string> done;
-
-	set<RecordDecl *>::iterator it;
-	for (it = types.begin(); it != types.end(); ++it) {
-		RecordDecl *decl = *it;
-		string name = decl->getName();
-		classesname.name = name;
-		classesname.type = decl;
-	}
-
-	set<FunctionDecl *>::iterator in;
-	for (in = functions.begin(); in != functions.end(); ++in) {
-		isl_class &c = method2class(classes, *in);
-		if (is_constructor(*in))
-			c.constructors.insert(*in);
-		else
-			c.methods.insert(*in);
-	}
 
 	for (ci = classes.begin(); ci != classes.end(); ++ci) {
 		if (done.find(ci->first) == done.end())
-			ci->second.print(classes, done);
+			print(ci->second);
 	}
 }

_service:tar_scm:isl-0.14.tar.xz/interface/python.h -> _service:tar_scm:isl-0.24.tar.gz/interface/python.h Changed

@@ -1,7 +1,66 @@
 #include <set>
 #include <clang/AST/Decl.h>
+#include "generator.h"
 
 using namespace std;
 using namespace clang;
 
-void generate_python(set<RecordDecl *> &types, set<FunctionDecl *> functions);
+class python_generator : public generator {
+private:
+	set<string> done;
+
+public:
+	python_generator(SourceManager &SM, set<RecordDecl *> &exported_types,
+		set<FunctionDecl *> exported_functions,
+		set<FunctionDecl *> functions) :
+		generator(SM, exported_types, exported_functions, functions) {}
+
+	virtual void generate();
+
+private:
+	void print(const isl_class &clazz);
+	void print_method_arguments(int first, int n_arg);
+	void print_method_header(bool is_static, const string &name, int n_arg);
+	void print_class_header(const isl_class &clazz, const string &name,
+		const vector<string> &super);
+	void print_type_check(int indent, const string &type, const char *fmt,
+		int pos, bool upcast, const string &super,
+		const string &name, int n);
+	void print_type_checks(const string &cname, FunctionDecl *method,
+		bool first_is_ctx, int n, const vector<string> &super);
+	void print_copy(QualType type);
+	void print_callback(ParmVarDecl *param, int arg);
+	void print_arg_in_call(FunctionDecl *fd, const char *fmt, int arg,
+		int skip);
+	void print_argtypes(FunctionDecl *fd);
+	void print_method_return(int indent, const isl_class &clazz,
+		FunctionDecl *method, const char *fmt);
+	void print_restype(FunctionDecl *fd);
+	void print(map<string, isl_class> &classes, set<string> &done);
+	void print_constructor(const isl_class &clazz, FunctionDecl *method);
+	void print_upcast_constructors(const isl_class &clazz);
+	void print_new(const isl_class &clazz,
+		const string &python_name);
+	void print_representation(const isl_class &clazz,
+		const string &python_name);
+	void print_copy_callbacks(const isl_class &clazz);
+	void print_method_type(FunctionDecl *fd);
+	void print_method_types(const isl_class &clazz);
+	void print_get_method(const isl_class &clazz, FunctionDecl *fd);
+	void print_method(const isl_class &clazz, FunctionDecl *method,
+		vector<string> super);
+	void print_method_call(int indent, const isl_class &clazz,
+		FunctionDecl *method, const char *fmt,
+		int drop_ctx, int drop_user);
+	void print_argument_checks(const isl_class &clazz, FunctionDecl *fd,
+		int drop_ctx);
+	void print_method_overload(const isl_class &clazz,
+		FunctionDecl *method);
+	void print_method(const isl_class &clazz, const string &fullname,
+		const function_set &methods, vector<string> super);
+	void print_set_enum(const isl_class &clazz, FunctionDecl *fd,
+		int value, const string &name, const vector<string> &super);
+	void print_set_enum(const isl_class &clazz, FunctionDecl *fd,
+		const vector<string> &super);
+
+};

_service:tar_scm:isl-0.24.tar.gz/interface/set_lang_defaults_arg4.h Added

_service:tar_scm:isl-0.24.tar.gz/interface/template_cpp.cc Added

@@ -0,0 +1,2785 @@
+/*
+ * Copyright 2020 Cerebras Systems. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *    1. Redistributions of source code must retain the above copyright
+ *       notice, this list of conditions and the following disclaimer.
+ *
+ *    2. Redistributions in binary form must reproduce the above
+ *       copyright notice, this list of conditions and the following
+ *       disclaimer in the documentation and/or other materials provided
+ *       with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY CEREBRAS SYSTEMS ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL CEREBRAS SYSTEMS OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
+ * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as
+ * representing official policies, either expressed or implied, of
+ * Cerebras Systems.
+ */
+
+#include <ctype.h>
+
+#include <algorithm>
+#include <iostream>
+#include <set>
+#include <sstream>
+#include <string>
+#include <unordered_map>
+#include <unordered_set>
+
+#include "template_cpp.h"
+#include "isl_config.h"
+
+/* The textual representation of this tuple kind.
+ *
+ * By default, the textual representation is just the name.
+ */
+std::string TupleKind::to_string() const
+{
+	return name;
+}
+
+/* Return the parameters of this tuple kind.
+ *
+ * By default, there are no parameters.
+ */
+std::vector<std::string> TupleKind::params() const
+{
+	return { };
+}
+
+/* Apply the substitution "subs" to this tuple kind and return the result.
+ * "self" is a shared pointer to this.
+ *
+ * If the name of this tuple kind appears in the substitution,
+ * then return the corresponding tuple kind pointer.
+ * Otherwise, return "self".
+ */
+TupleKindPtr TupleKind::apply(const Substitution &subs,
+	const TupleKindPtr &self) const
+{
+	if (subs.count(name) != 0)
+		return subs.at(name);
+	return self;
+}
+
+/* Apply the substitution "subs" to "tuple" and return the result.
+ */
+static TupleKindPtr apply(const TupleKindPtr tuple, const Substitution &subs)
+{
+	return tuple->apply(subs, tuple);
+}
+
+/* Return the left child of this tuple kind.
+ *
+ * Since this is not a pair, there is no left child.
+ */
+TupleKindPtr TupleKind::left() const
+{
+	return TupleKindPtr();
+}
+
+/* Return the right child of this tuple kind.
+ *
+ * Since this is not a pair, there is no right child.
+ */
+TupleKindPtr TupleKind::right() const
+{
+	return TupleKindPtr();
+}
+
+/* Helper class used to construct a pointer to a tuple kind
+ * that refers to a non-template type.
+ */
+struct Fixed {
+};
+
+/* Construct a pointer to a tuple kind that refers to a non-template type.
+ *
+ * Use an empty string as name.  Since this is a non-template type,
+ * the kind name will never appear in the generated code.
+ */
+TupleKindPtr::TupleKindPtr(Fixed) : Base(std::make_shared<TupleKind>(""))
+{
+}
+
+/* Tuple pointers for non-template types.
+ */
+static TupleKindPtr Ctx{Fixed()};
+static TupleKindPtr Integer{Fixed()};
+static TupleKindPtr Str{Fixed()};
+static TupleKindPtr Res{Fixed()};
+
+/* Special tuple pointers.
+ * Anonymous appears in the generated code but cannot be unified
+ * with anything else since it is a predefined template argument.
+ * Leaf can only be unified with something that is not a pair and
+ * does not appear in the generated code.
+ */
+static TupleKindPtr Anonymous("Anonymous");
+static TupleKindPtr Leaf("Leaf");
+
+/* Placeholder tuple pointers that refer to (part of) the domain or range.
+ */
+static TupleKindPtr Domain("Domain");
+static TupleKindPtr Domain2("Domain2");
+static TupleKindPtr Domain3("Domain3");
+static TupleKindPtr Range("Range");
+static TupleKindPtr Range2("Range2");
+static TupleKindPtr Range3("Range3");
+
+/* A representation of a proper tuple kind that is used as a template
+ * parameter or a template argument.
+ */
+struct ProperTupleKind : public TupleKind {
+	ProperTupleKind(const std::string &name) : TupleKind(name) {}
+
+	virtual std::vector<std::string> params() const override;
+};
+
+/* Return the parameters of this tuple kind.
+ *
+ * Return the name of this tuple kind, unless it is the special Anonymous
+ * predefined template argument.
+ */
+std::vector<std::string> ProperTupleKind::params() const
+{
+	if (Anonymous.get() == this)
+		return { };
+	return { name };
+}
+
+/* Construct a pointer to a tuple kind that refers
+ * to a proper tuple kind with the given name.
+ */
+TupleKindPtr::TupleKindPtr(const std::string &name) :
+	Base(std::make_shared<ProperTupleKind>(name))
+{
+}
+
+/* A tuple kind that represents an anonymous pair of nested tuple kinds.
+ */
+struct Pair : public TupleKind {
+	Pair(const TupleKindPtr &tuple1, const TupleKindPtr &tuple2) :
+		TupleKind(""), tuple1(tuple1), tuple2(tuple2) {}
+
+	virtual std::string to_string() const override;
+	virtual std::vector<std::string> params() const override;
+	virtual TupleKindPtr apply(const Substitution &match,
+		const TupleKindPtr &self) const override;
+	virtual TupleKindPtr left() const override;
+	virtual TupleKindPtr right() const override;
+
+	const TupleKindPtr tuple1;
+	const TupleKindPtr tuple2;
+};
+
+/* The textual representation of this tuple kind.
+ *
+ * The textual representation of a pair is of the form "pair<tuple1, tuple2>".
+ */
+std::string Pair::to_string() const
+{
+	return std::string("pair<") + tuple1->to_string() + ", " +
+					tuple2->to_string() + ">";
+}
+
+/* Add the elements of "vec2" that do not already appear in "vec1"
+ * at the end of "vec1".
+ *
+ * The two vectors are assumed not to have any repeated elements.
+ * The updated vector will then also not have repeated elements.
+ */
+static void combine(std::vector<std::string> &vec1,
+	const std::vector<std::string> &vec2)
+{
+	for (const auto &s : vec2)
+		if (std::find(vec1.begin(), vec1.end(), s) == vec1.end())
+			vec1.emplace_back(s);
+}
+
+/* Return the parameters of this tuple kind.
+ *
+ * Combine the parameters of the two nested tuple kinds.
+ */
+std::vector<std::string> Pair::params() const
+{
+	auto names1 = tuple1->params();
+	auto names2 = tuple2->params();
+
+	combine(names1, names2);
+
+	return names1;
+}
+
+/* Apply the substitution "subs" to this tuple kind and return the result.
+ * "self" is a shared pointer to this.
+ *
+ * Construct a new tuple kind consisting of the result of applying
+ * the substitution to the two nested tuple kinds.
+ */
+TupleKindPtr Pair::apply(const Substitution &subs, const TupleKindPtr &self)
+	const
+{
+	return TupleKindPtr(::apply(tuple1, subs), ::apply(tuple2, subs));
+}
+
+/* Return the left child of this tuple kind.
+ */
+TupleKindPtr Pair::left() const
+{
+	return tuple1;
+}
+
+/* Return the right child of this tuple kind.
+ */
+TupleKindPtr Pair::right() const
+{
+	return tuple2;
+}
+
+/* Construct a pointer to a tuple kind that refers
+ * to the given pair of nested tuple kinds.
+ */
+TupleKindPtr::TupleKindPtr(const TupleKindPtr &left, const TupleKindPtr &right)
+	: Base(std::make_shared<Pair>(left, right))
+{
+}
+
+/* Is this a kind of object representing an anonymous function?
+ */
+bool Kind::is_anon() const
+{
+	return size() != 0 && back() == Anonymous;
+}
+
+/* Is this a kind of object with a single tuple?
+ */
+bool Kind::is_set() const
+{
+	return size() == 1;
+}
+
+/* Is this a kind of object with a single, anonymous tuple?
+ */
+bool Kind::is_anon_set() const
+{
+	return is_set() && is_anon();
+}
+
+/* Return the parameters of this kind.
+ *
+ * Collect the parameters of the tuple kinds in the sequence.
+ */
+std::vector<std::string> Kind::params() const
+{
+	std::vector<std::string> params;
+
+	for (const auto &tuple : *this)
+		combine(params, tuple->params());
+
+	return params;
+}
+
+/* Apply the substitution "subs" to this kind and return the result.
+ *
+ * Apply the substitution to each of the tuple kinds in the sequence.
+ */
+Kind Kind::apply(const Substitution &subs) const
+{
+	Kind applied;
+
+	for (const auto &tuple : *this)
+		applied.emplace_back(::apply(tuple, subs));
+
+	return applied;
+}
+
+/* A signature of a method in terms of kinds,
+ * consisting of a return kind and a sequence of argument kinds.
+ */
+struct Signature {
+	Kind ret;
+	std::vector<Kind> args;
+
+	std::vector<std::string> params() const;
+	Signature apply(const Substitution &match) const;
+};
+
+/* Return the parameters of this signature.
+ *
+ * Collect the parameters of the argument kinds and the return kind.
+ */
+std::vector<std::string> Signature::params() const
+{
+	std::vector<std::string> params;
+
+	for (const auto &arg : args)
+		combine(params, arg.params());
+	combine(params, ret.params());
+
+	return params;
+}
+
+/* Apply the substitution "subs" to this kind and return the result.
+ *
+ * Apply the substitution to the argument kinds and the return kind.
+ */
+Signature Signature::apply(const Substitution &subs) const
+{
+	std::vector<Kind> applied_args;
+
+	for (const auto &arg : args)
+		applied_args.emplace_back(arg.apply(subs));
+
+	return { ret.apply(subs), applied_args };
+}
+
+/* Return a renaming substitution that renames the elements of "params"
+ * using names starting with "prefix".
+ */
+static Substitution param_renamer(const std::vector<std::string> &params,
+	const std::string &prefix)
+{
+	Substitution renamer;
+	int n = 0;
+
+	for (const auto &name : params) {
+		auto suffix = std::to_string(++n);
+		auto arg_name = prefix + suffix;
+		auto arg = TupleKindPtr(arg_name);
+
+		if (name == Leaf->name)
+			generator::die("Leaf cannot be renamed");
+
+		renamer.emplace(name, arg);
+	}
+
+	return renamer;
+}
+
+/* Does the vector "v" contain the element "el"?
+ */
+static bool contains(const std::vector<std::string> &v, const std::string &el)
+{
+	 return find(v.begin(), v.end(), el) != v.end();
+ }
+
+
+/* Return the shared elements of "v1" and "v2", preserving the order
+ * of those elements in "v1".
+ */
+static std::vector<std::string> intersect(const std::vector<std::string> &v1,
+	const std::vector<std::string> &v2)
+{
+	std::vector<std::string> intersection;
+
+	for (const auto &el : v1)
+		if (contains(v2, el))
+			intersection.push_back(el);
+
+	return intersection;
+}
+
+/* Return a renaming substitution that renames
+ * any parameters that appears in both "sig" and "kind".
+ */
+static Substitution shared_param_renamer(const Signature &sig, const Kind &kind)
+{
+	return param_renamer(intersect(sig.params(), kind.params()), "Arg");
+}
+
+/* Signatures for unary operations.
+ * Functions have at least one tuple.
+ */
+static Signature un_params = { { }, { { } } };
+static Signature un_set = { { Domain }, { { Domain } } };
+static Signature un_map = { { Domain, Range }, { { Domain, Range } } };
+static std::vector<Signature> un_op = { un_params, un_set, un_map };
+static std::vector<Signature> fn_un_op = { un_set, un_map };
+
+/* Signatures for binary operations, with the second argument
+ * possibly referring to part of the first argument.
+ * Functions have at least one tuple.
+ */
+static Signature bin_params = { { }, { { }, { } } };
+static Signature bin_set = { { Domain }, { { Domain }, { Domain } } };
+static Signature bin_map =
+	{ { Domain, Range }, { { Domain, Range }, { Domain, Range } } };
+static std::vector<Signature> bin_op = { bin_params, bin_set, bin_map };
+static std::vector<Signature> fn_bin_op = { bin_set, bin_map };
+static Signature bin_set_params = { { Domain }, { { Domain }, { } } };
+static Signature bin_map_params =
+	{ { Domain, Range }, { { Domain, Range }, { } } };
+static Signature bin_map_domain =
+	{ { Domain, Range }, { { Domain, Range }, { Domain } } };
+static Signature bin_map_range =
+	{ { Domain, Range }, { { Domain, Range }, { Range } } };
+
+/* Signatures for binary operations, where the second argument
+ * is an identifier (with an anonymous tuple).
+ */
+static Signature bin_params_anon = { { }, { { }, { Anonymous } } };
+static Signature bin_set_anon = { { Domain }, { { Domain }, { Anonymous } } };
+static Signature bin_map_anon =
+	{ { Domain, Range }, { { Domain, Range }, { Anonymous } } };
+static std::vector<Signature> bin_op_anon =
+	{ bin_params_anon, bin_set_anon, bin_map_anon };
+
+/* Signatures for ternary operations, where the last two arguments are integers.
+ */
+static Signature ter_params_int_int =
+	{ { }, { { }, { Integer }, { Integer } } };
+static Signature ter_set_int_int =
+	{ { Domain }, { { Domain }, { Integer }, { Integer } } };
+static Signature ter_map_int_int =
+	{ { Domain, Range }, { { Domain, Range }, { Integer }, { Integer } } };
+static std::vector<Signature> ter_int_int =
+	{ ter_params_int_int, ter_set_int_int, ter_map_int_int };
+
+/* Signatures for naming a leaf tuple using an identifier (with an anonymous
+ * tuple).
+ */
+static Signature update_set = { { Domain2 }, { { Leaf }, { Anonymous } } };
+static Signature update_domain =
+	{ { Domain2, Range }, { { Leaf, Range }, { Anonymous } } };
+static Signature update_range =
+	{ { Domain, Range2 }, { { Domain, Leaf }, { Anonymous } } };
+
+/* Signatures for the functions "min" and "max", which can be either
+ * unary or binary operations.
+ */
+static std::vector<Signature> min_max = { un_set, bin_set, un_map, bin_map };
+
+/* Signatures for adding an unnamed tuple to an object with zero or one tuple.
+ */
+static Signature to_set = { { Domain }, { { }, { Integer } } };
+static Signature add_range = { { Domain, Range }, { { Domain }, { Integer } } };
+/* Signatures for adding a named tuple to an object with zero or one tuple.
+ */
+static Signature to_set_named =
+	{ { Domain }, { { }, { Anonymous }, { Integer } } };
+static Signature add_range_named =
+	{ { Domain, Range }, { { Domain }, { Anonymous }, { Integer } } };
+
+/* Signatures for methods applying a map to a set, a function or
+ * part of a map.
+ */
+static Signature set_forward = { { Range }, { { Domain }, { Domain, Range } } };
+static Signature domain_forward =
+	{ { Domain2, Range }, { { Domain, Range }, { Domain, Domain2 } } };
+static Signature range_forward =
+	{ { Domain, Range2 }, { { Domain, Range }, { Range, Range2 } } };
+
+/* Signatures for methods plugging in a function into a set, a function or
+ * part of a map.
+ */
+static Signature set_backward =
+	{ { Domain2 }, { { Domain }, { Domain2, Domain } } };
+static Signature domain_backward =
+	{ { Domain2, Range }, { { Domain, Range }, { Domain2, Domain } } };
+static Signature range_backward =
+	{ { Domain, Range2 }, { { Domain, Range }, { Range2, Range } } };
+static Signature domain_wrapped_domain_backward =
+	{ { { Domain3, Domain2 }, Range },
+	  { { { Domain, Domain2 }, Range }, { Domain3, Domain } } };
+
+/* Signatures for methods binding a set, a function,
+ * or (part of) a map to parameters or an object of the same kind.
+ */
+static Signature bind_set = { { }, { { Domain }, { Domain } } };
+static Signature bind_domain = { { Range }, { { Domain, Range }, { Domain } } };
+static Signature bind_range = { { Domain }, { { Domain, Range }, { Range } } };
+static Signature bind_domain_wrapped_domain =
+	{ { Range2, Range }, { { { Domain2, Range2 }, Range }, { Domain2 } } };
+
+/* Signatures for functions that take a callback accepting
+ * objects of the same kind (but a different type).
+ *
+ * The return and argument kinds of the callback appear
+ * at the position of the callback.
+ */
+static Signature each_params = { { Res }, { { }, { Res }, { } } };
+static Signature each_set = { { Res }, { { Domain }, { Res }, { Domain } } };
+static Signature each_map =
+	{ { Res }, { { Domain, Range }, { Res }, { Domain, Range } } };
+static std::vector<Signature> each = { each_params, each_set, each_map };
+
+/* Signature for creating a map from a range,
+ * where the domain is given by an extra argument.
+ */
+static Signature map_from_range_and_domain =
+	{ { Domain, Range }, { { Range }, { Domain } } };
+
+/* Signature for creating a map from a domain,
+ * where the range is given by an extra argument.
+ */
+static Signature map_from_domain_and_range =
+	{ { Domain, Range }, { { Domain }, { Range } } };
+
+/* Signature for creating a map from a domain,
+ * where the range is anonymous.
+ */
+static Signature anonymous_map_from_domain =
+	{ { Domain, Anonymous }, { { Domain } } };
+
+/* Signature for creating a set from a parameter set,
+ * where the domain is given by an extra argument.
+ */
+static Signature set_from_params = { { Domain }, { { }, { Domain } } };
+
+/* Signature for creating a map from a domain,
+ * where the range tuple is equal to the domain tuple.
+ */
+static Signature set_to_map = { { Domain, Domain }, { { Domain } } };
+
+/* Signatures for obtaining the range or the domain of a map.
+ * In case of a transformation, the domain and range are the same.
+ */
+static Signature domain = { { Domain }, { { Domain, Range } } };
+static Signature range = { { Range }, { { Domain, Range } } };
+static Signature transformation_domain = { { Domain }, { { Domain, Domain } } };
+
+/* Signatures for obtaining the parameter domain of a set or map.
+ */
+static Signature set_params = { { }, { { Domain } } };
+static Signature map_params = { { }, { { Domain, Range } } };
+
+/* Signatures for obtaining the domain of a function.
+ */
+static std::vector<Signature> fn_domain = { domain, set_params };
+
+/* Signatures for interchanging (wrapped) domain and range.
+ */
+static Signature map_reverse = { { Range, Domain }, { { Domain, Range } } };
+static Signature map_range_reverse =
+	{ { Domain, { Range, Range2} }, { { Domain, { Range2, Range} } } };
+
+/* Signatures for constructing products.
+ */
+static Signature set_product =
+	{ { { Domain, Range } }, { { Domain }, { Range } } };
+static Signature map_product =
+	{ { { Domain, Domain2 }, { Range, Range2 } },
+	  { { Domain, Range }, { Domain2, Range2 } } };
+static Signature domain_product =
+	{ { { Domain, Domain2 }, Range },
+	  { { Domain, Range }, { Domain2, Range } } };
+static Signature range_product =
+	{ { Domain, { Range, Range2 } },
+	  { { Domain, Range }, { Domain, Range2 } } };
+
+/* Signatures for obtaining factors from a product.
+ */
+static Signature domain_factor_domain =
+	{ { Domain, Range }, { { { Domain, Domain2 }, Range } } };
+static Signature domain_factor_range =
+	{ { Domain2, Range }, { { { Domain, Domain2 }, Range } } };
+static Signature range_factor_domain =
+	{ { Domain, Range }, { { Domain, { Range, Range2 } } } };
+static Signature range_factor_range =
+	{ { Domain, Range2 }, { { Domain, { Range, Range2 } } } };
+
+/* Signatures for (un)currying.
+ */
+static Signature curry =
+	{ { Domain, { Range, Range2 } },
+	  { { { Domain, Range }, Range2 } } };
+static Signature uncurry =
+	{ { { Domain, Range }, Range2 },
+	  { { Domain, { Range, Range2 } } } };
+
+/* Signatures for (un)wrapping.
+ */
+static Signature wrap = { { { Domain, Range } }, { { Domain, Range } } };
+static Signature unwrap = { { Domain, Range }, { { { Domain, Range } } } };
+
+/* Signatures for constructing objects that map to the domain or range
+ * of a map.
+ */
+static Signature domain_map =
+	{ { { Domain, Range }, Domain }, { { Domain, Range } } };
+static Signature range_map =
+	{ { { Domain, Range }, Range }, { { Domain, Range } } };
+
+/* Signature for applying a comparison between the domain and the range
+ * of a map.
+ */
+static Signature map_cmp =
+	{ { Domain, Domain }, { { Domain, Domain }, { Domain, Range } } };
+
+/* Signature for creating a set corresponding to the domains
+ * of two functions.
+ */
+static Signature set_join =
+	{ { Domain }, { { Domain, Range }, { Domain, Range } } };
+
+/* Signatures for flattening the domain or range of a map,
+ * replacing it with either an anonymous tuple or a tuple with a given name.
+ */
+static Signature anonymize_nested_domain =
+	{ { Anonymous, Range2 }, { { { Domain, Range }, Range2 } } };
+static Signature anonymize_nested_range =
+	{ { Domain, Anonymous }, { { Domain, { Range, Range2 } } } };
+static Signature replace_nested_domain =
+	{ { Domain2, Range2 },
+	  { { { Domain, Range }, Range2 }, { Anonymous} } };
+static Signature replace_nested_range =
+	{ { Domain, Range3 }, { { Domain, { Range, Range2 } }, { Anonymous} } };
+static std::vector<Signature> flatten_domain =
+	{ anonymize_nested_domain, replace_nested_domain };
+static std::vector<Signature> flatten_range =
+	{ anonymize_nested_range, replace_nested_range };
+
+/* Signatures for "set_at" methods.
+ */
+static Signature set_at_set =
+	{ { Domain }, { { Domain }, { Integer }, { Anonymous } } };
+static Signature set_at_map =
+	{ { Domain, Range },
+	  { { Domain, Range }, { Integer }, { Domain, Anonymous } } };
+static std::vector<Signature> set_at = { set_at_set, set_at_map };
+
+/* Signatures for "list" methods, extracting a list
+ * from a multi-expression.
+ */
+static Signature to_list_set = { { Anonymous }, { { Domain } } };
+static Signature to_list_map = { { Domain, Anonymous }, { { Domain, Range } } };
+
+/* Signatures for functions constructing an object from only an isl::ctx.
+ */
+static Signature ctx_params = { { }, { { Ctx } } };
+static Signature ctx_set = { { Domain }, { { Ctx } } };
+static Signature ctx_map = { { Domain, Range }, { { Ctx } } };
+
+/* Helper structure for sorting the keys of static_methods and
+ * special_member_methods such that the larger keys appear first.
+ * In particular, a key should appear before any key that appears
+ * as a substring in the key.
+ * Note that this sorting is currently only important
+ * for special_member_methods.
+ */
+struct larger_infix {
+	bool operator()(const std::string &x, const std::string &y) const {
+		if (x.length() > y. length())
+			return true;
+		return x < y;
+	}
+};
+
+/* A map from part of a type name to a sequence of signatures.
+ */
+typedef std::map<std::string, std::vector<Signature>, larger_infix> infix_map;
+
+/* A map from a method name to a map from part of a type name
+ * to a sequence of signatures.
+ */
+typedef std::map<std::string, infix_map> infix_map_map;
+
+/* Signatures for static methods.
+ *
+ * The "unit" static method is only available in a 0-tuple space.
+ *
+ * The "empty" static method creates union objects with the relevant
+ * number of tuples.
+ *
+ * The "universe" static methods create objects from the corresponding spaces.
+ */
+static const infix_map_map static_methods {
+	{ "unit",
+	  { { "space",			{ ctx_params } } }
+	},
+	{ "empty",
+	  {
+	    { "union_set",		{ ctx_params, ctx_set } },
+	    { "union_map",		{ ctx_map } },
+	    { "union_pw_multi_aff",	{ ctx_set, ctx_map } },
+	  }
+	},
+	{ "universe",
+	  {
+	    { "set",			{ un_params, un_set } },
+	    { "map",			{ un_map } },
+	  }
+	},
+};
+
+/* Signatures for unary operations that either take something in a set space
+ * and return something in the same space or take something in a map space
+ * and return something in the range of that space.
+ */
+static std::vector<Signature> range_op = { un_set, range };
+
+/* Signatures for binary operations where the second argument
+ * is a (multi-)value.
+ */
+static std::vector<Signature> bin_val = { bin_set, bin_map_range };
+
+/* The (default) signatures for methods with a given name.
+ * Some of these are overridden by special_member_methods.
+ */
+static const std::unordered_map<std::string, std::vector<Signature>>
+member_methods {
+	{ "add",		bin_op },
+	{ "add_constant",	bin_val },
+	{ "add_named_tuple",	{ to_set_named, add_range_named } },
+	{ "add_unnamed_tuple",	{ to_set, add_range } },
+	{ "apply",		{ set_forward, range_forward } },
+	{ "apply_domain",	{ domain_forward } },
+	{ "apply_range",	{ range_forward } },
+	{ "as",			un_op },
+	{ "as_map",		{ un_map } },
+	{ "as_union_map",	{ un_map } },
+	{ "as_set",		{ un_set } },
+	{ "bind",		{ bind_set, bind_range } },
+	{ "bind_domain",	{ bind_domain } },
+	{ "bind_range",		{ bind_range } },
+	{ "bind_domain_wrapped_domain",
+				{ bind_domain_wrapped_domain } },
+	{ "coalesce",		un_op },
+	{ "constant_multi_val",	range_op },
+	{ "curry",		{ curry } },
+	{ "deltas",		{ transformation_domain } },
+	{ "detect_equalities",	un_op },
+	{ "domain",		fn_domain },
+	{ "domain_factor_domain",
+				{ domain_factor_domain } },
+	{ "domain_factor_range",
+				{ domain_factor_range } },
+	{ "domain_map",		{ domain_map } },
+	{ "domain_product",	{ domain_product } },
+	{ "drop",		ter_int_int },
+	{ "eq_at",		{ map_cmp } },
+	{ "every",		each },
+	{ "flatten_domain",	flatten_domain },
+	{ "flatten_range",	flatten_range },
+	{ "floor",		fn_un_op },
+	{ "foreach",		each },
+	{ "ge_set",		{ set_join } },
+	{ "gt_set",		{ set_join } },
+	{ "gist",		bin_op },
+	{ "gist_domain",	{ bin_map_domain } },
+	{ "identity",		{ un_map, set_to_map } },
+	{ "identity_on_domain",	{ set_to_map } },
+	{ "insert_domain",	{ map_from_range_and_domain } },
+	{ "intersect",		bin_op },
+	{ "intersect_params",	{ bin_set_params, bin_map_params } },
+	{ "intersect_domain",	{ bin_map_domain } },
+	{ "intersect_range",	{ bin_map_range } },
+	{ "le_set",		{ set_join } },
+	{ "lt_set",		{ set_join } },
+	{ "lex_le_at",		{ map_cmp } },
+	{ "lex_lt_at",		{ map_cmp } },
+	{ "lex_ge_at",		{ map_cmp } },
+	{ "lex_gt_at",		{ map_cmp } },
+	{ "lexmin",		fn_un_op },
+	{ "lexmax",		fn_un_op },
+	{ "list",		{ to_list_set, to_list_map } },
+	{ "lower_bound",	fn_bin_op },
+	{ "map_from_set",	{ set_to_map } },
+	{ "max",		min_max },
+	{ "max_multi_val",	range_op },
+	{ "min",		min_max },
+	{ "min_multi_val",	range_op },
+	{ "mod",		bin_val },
+	{ "on_domain",		{ map_from_domain_and_range } },
+	{ "neg",		fn_un_op },
+	{ "offset",		fn_un_op },
+	{ "params",		{ set_params, map_params } },
+	{ "plain_multi_val_if_fixed",
+				{ un_set } },
+	{ "preimage",		{ set_backward } },
+	{ "preimage_domain",	{ domain_backward } },
+	{ "preimage_domain_wrapped_domain",
+				{ domain_wrapped_domain_backward } },
+	{ "preimage_range",	{ range_backward } },
+	{ "product",		{ set_product, map_product } },
+	{ "project_out_param",	bin_op_anon },
+	{ "project_out_all_params",
+				un_op },
+	{ "pullback",		{ domain_backward, bind_domain } },
+	{ "range",		{ range } },
+	{ "range_factor_domain",
+				{ range_factor_domain } },
+	{ "range_factor_range",	{ range_factor_range } },
+	{ "range_map",		{ range_map } },
+	{ "range_product",	{ range_product } },
+	{ "range_simple_fixed_box_hull",
+				{ un_map } },
+	{ "reverse",		{ map_reverse } },
+	{ "range_reverse",	{ map_range_reverse } },
+	{ "scale",		bin_val },
+	{ "scale_down",		bin_val },
+	{ "set_at",		set_at },
+	{ "set_domain_tuple",	{ update_domain } },
+	{ "set_range_tuple",	{ update_set, update_range } },
+	{ "simple_fixed_box_hull",
+				{ un_set } },
+	{ "sub",		fn_bin_op },
+	{ "subtract",		bin_op },
+	{ "subtract_domain",	{ bin_map_domain } },
+	{ "subtract_range",	{ bin_map_range } },
+	{ "translation",	{ set_to_map } },
+	{ "to",			un_op },
+	{ "unbind_params",	{ set_from_params } },
+	{ "unbind_params_insert_domain",
+				{ map_from_range_and_domain } },
+	{ "uncurry",		{ uncurry } },
+	{ "union_add",		fn_bin_op },
+	{ "unite",		bin_op },
+	{ "universe",		un_op },
+	{ "unwrap",		{ unwrap } },
+	{ "upper_bound",	fn_bin_op },
+	{ "wrap",		{ wrap } },
+	{ "zero",		fn_un_op },
+	{ "zero_on_domain",	{ anonymous_map_from_domain } },
+};
+
+/* Signatures for methods of types containing a given substring
+ * that override the default signatures, where larger substrings
+ * appear first.
+ *
+ * In particular, "gist" is usually a regular binary operation,
+ * but for any type derived from "aff", the argument refers
+ * to the domain of the function.
+ *
+ * The "size" method can usually simply be inherited from
+ * the corresponding plain C++ type, but for a "fixed_box",
+ * the size lives in the space of the box or its range.
+ *
+ * The "space" method is usually a regular unary operation
+ * that returns the single space of the elements in the object,
+ * with the same number of tuples.
+ * However, a "union" object may contain elements from many spaces and
+ * therefore its space only refers to the symbolic constants and
+ * has zero tuples, except if it is also a "multi_union" object,
+ * in which case it has a fixed range space and the space of the object
+ * has a single tuple.
+ * Note that since "space' is also the name of a template class,
+ * the default space method is handled by print_type_named_member_method.
+ */
+static const infix_map_map special_member_methods {
+	{ "gist",
+	  { { "aff",		{ bin_set_params, bin_map_domain } } }
+	},
+	{ "size",
+	  { { "fixed_box",	range_op } },
+	},
+	{ "space",
+	  {
+	    { "multi_union",	range_op },
+	    { "union",		{ un_params, set_params, map_params } },
+	  }
+	},
+};
+
+/* Generic kinds for objects with zero, one or two tuples,
+ * the last of which may be anonymous.
+ */
+static Kind params{};
+static Kind set_type{ Domain };
+static Kind set_anon{ Anonymous };
+static Kind map_type{ Domain, Range };
+static Kind map_anon{ Domain, Anonymous };
+
+/* The initial sequence of specialization kinds for base types.
+ * The specialization kinds for other types are derived
+ * from the corresponding base types.
+ *
+ * In particular, this sequence specifies how many tuples
+ * a given type can have and whether it is anonymous.
+ *
+ * "space" can have any number of tuples.
+ * "set" and "point" can have zero or one tuple.
+ * "map" can only have two tuples.
+ * "aff" can have one or two tuples, the last of which is anonymous.
+ * "fixed_box" can represent a (proper) set) or a map.
+ * "val" and "id" are treated as anonymous sets so that
+ * they can form the basis of "multi_val" and "multi_id".
+ */
+static const std::unordered_map<std::string, std::vector<Kind>> base_kinds {
+	{ "space",	{ params, set_type, map_type } },
+	{ "set",	{ params, set_type } },
+	{ "point",	{ params, set_type } },
+	{ "map",	{ map_type } },
+	{ "aff",	{ set_anon, map_anon } },
+	{ "fixed_box",	{ set_type, map_type } },
+	{ "val",	{ set_anon } },
+	{ "id",		{ set_anon } },
+};
+
+/* Prefixes introduced by type constructors.
+ */
+static const std::unordered_set<std::string> type_prefixes {
+	"basic",
+	"multi",
+	"pw",
+	"union",
+};
+
+/* If "type" has a "_list" suffix, then return "type" with this suffix removed.
+ * Otherwise, simply return "type".
+ */
+static std::string drop_list(const std::string &type)
+{
+	size_t pos = type.rfind('_');
+
+	if (pos == std::string::npos)
+		return type;
+	if (type.substr(pos + 1) == "list")
+		return type.substr(0, pos);
+	return type;
+}
+
+/* Given the name of a plain C++ type, return the base type
+ * from which it was derived using type constructors.
+ *
+ * In particular, drop any "list" suffix and
+ * drop any prefixes from type_prefixes, stopping
+ * as soon as a base type is found for which kinds have been registered
+ * in base_kinds.
+ */
+static std::string base_type(const std::string &type)
+{
+	auto base = type;
+	size_t pos;
+
+	base = drop_list(base);
+	while (base_kinds.count(base) == 0 &&
+			(pos = base.find('_')) != std::string::npos &&
+			type_prefixes.count(base.substr(0, pos)) != 0) {
+		base = base.substr(pos + 1);
+	}
+
+	return base;
+}
+
+/* A mapping from anonymous kinds to named kinds.
+ */
+static std::map<Kind, Kind> anon_to_named {
+	{ set_anon, set_type },
+	{ map_anon, map_type },
+};
+
+/* Given a sequence of anonymous kinds, replace them
+ * by the corresponding named kinds.
+ */
+static std::vector<Kind> add_name(const std::vector<Kind> &tuples)
+{
+	std::vector<Kind> named;
+
+	for (const auto &tuple : tuples)
+		named.emplace_back(anon_to_named.at(tuple));
+
+	return named;
+}
+
+/* Add a template class called "name", of which the methods are described
+ * by "clazz" and where the corresponding base type has kinds "base_kinds".
+ *
+ * If this template class is a multi-expression, then it was derived
+ * from an anonymous function type.  Replace the final Anonymous
+ * tuple kind by a placeholder in this case.
+ */
+void template_cpp_generator::add_template_class(const isl_class &clazz,
+	const std::string &name, const std::vector<Kind> &base_kinds)
+{
+	auto isl_namespace = cpp_type_printer().isl_namespace();
+	auto super = isl_namespace + name;
+	auto class_tuples = base_kinds;
+
+	if (name.find("multi_") != std::string::npos)
+		class_tuples = add_name(class_tuples);
+	template_classes.emplace(name,
+		template_class{name, super, clazz, class_tuples});
+}
+
+/* Construct a templated C++ bindings generator from
+ * the exported types and functions and the set of all declared functions.
+ *
+ * On top of the initialization of the shared parts
+ * of C++ bindings generators, add a template class
+ * for each plain C++ class for which template kinds
+ * have been defined.
+ * In particular, determine the base type from which the plain C++ class
+ * was derived using type constructors and check if any template kinds
+ * have been registered for this base type.
+ */
+template_cpp_generator::template_cpp_generator(clang::SourceManager &SM,
+	std::set<clang::RecordDecl *> &exported_types,
+	std::set<clang::FunctionDecl *> exported_functions,
+	std::set<clang::FunctionDecl *> functions) :
+		cpp_generator(SM, exported_types, exported_functions,
+			functions)
+{
+	for (const auto &kvp : classes) {
+		const auto &clazz = kvp.second;
+		std::string name = type2cpp(clazz);
+		std::string base = base_type(name);
+
+		if (base_kinds.count(base) == 0)
+			continue;
+		add_template_class(clazz, name, base_kinds.at(base));
+	}
+}
+
+/* Call "fn" on each template class.
+ */
+void template_cpp_generator::foreach_template_class(
+	const std::function<void(const template_class &)> &fn) const
+{
+	for (const auto &kvp : template_classes)
+		fn(kvp.second);
+}
+
+/* Print forward declarations for all template classes to "os".
+ *
+ * For template classes that represent an anonymous function
+ * that can also have a domain tuple, provide an <name>_on alias
+ * that adds the fixed Anonymous tuple kind.
+ */
+void template_cpp_generator::print_forward_declarations(std::ostream &os)
+{
+	foreach_template_class(&os (const template_class &template_class) {
+		auto name = template_class.class_name;
+
+		os << "\n";
+		os << "template <typename...>\n";
+		os << "struct " << name << ";\n";
+
+		if (!template_class.is_anon())
+			return;
+		if (template_class.is_anon_set())
+			return;
+
+		os << "\n";
+		os << "template <typename...Ts>\n";
+		os << "using " << name << "_on = "
+		   << name << "<Ts..., Anonymous>;\n";
+	});
+}
+
+/* Print friend declarations for all template classes to "os".
+ */
+void template_cpp_generator::print_friends(std::ostream &os)
+{
+	foreach_template_class(&os (const template_class &template_class) {
+		os << "  template <typename...>\n";
+		os << "  friend struct " << template_class.class_name << ";\n";
+	});
+}
+
+/* Print a template parameter or argument.
+ * In case of a std::string, it's a template parameter
+ * that needs to be declared.
+ */
+static void print_template_arg(std::ostream &os, const std::string &arg)
+{
+	os << "typename " << arg;
+}
+
+/* Print a template parameter or argument.
+ * In case of a TupleKindPtr, it's a template argument.
+ */
+static void print_template_arg(std::ostream &os, const TupleKindPtr &kind)
+{
+	os << kind->to_string();
+}
+
+/* Print a sequence of template parameters (std::string) or
+ * arguments (TupleKindPtr) "args", without the enclosing angle brackets.
+ */
+template <typename List>
+static void print_pure_template_args(std::ostream &os, const List &args)
+{
+	for (size_t i = 0; i < args.size(); ++i) {
+		if (i != 0)
+			os << ", ";
+		print_template_arg(os, argsi);
+	}
+}
+
+/* Print a sequence of template parameters (std::string) or
+ * arguments (TupleKindPtr) "args".
+ */
+template <typename List>
+static void print_template_args(std::ostream &os, const List &args)
+{
+	os << "<";
+	print_pure_template_args(os, args);
+	os << ">";
+}
+
+/* Print a declaration of the template parameters "params".
+ */
+static void print_template(std::ostream &os,
+	const std::vector<std::string> &params)
+{
+	os << "template ";
+	print_template_args(os, params);
+	os << "\n";
+}
+
+/* Print a declaration of the template parameters "params",
+ * if there are any.
+ */
+static void print_non_empty_template(std::ostream &os,
+	const std::vector<std::string> &params)
+{
+	if (params.size() > 0)
+		print_template(os, params);
+}
+
+/* Print a bare template type, i.e., without namespace,
+ * consisting of the type "type" and the kind "kind" to "os".
+ *
+ * In particular, print "type" followed by the template arguments
+ * as specified by "kind".
+ */
+static void print_bare_template_type(std::ostream &os, const std::string &type,
+	const Kind &kind)
+{
+	os << type;
+	print_template_args(os, kind);
+}
+
+/* A specific instance of "template_class", with tuple kinds given by "kind".
+ */
+struct specialization {
+	struct template_class &template_class;
+	Kind kind;
+
+	const std::string &base_name() const;
+	const std::string &class_name() const;
+};
+
+/* The name of the plain C++ interface class
+ * from which this template class (instance) derives.
+ */
+const std::string &specialization::base_name() const
+{
+	return template_class.super_name;
+}
+
+/* The name of the template class.
+ */
+const std::string &specialization::class_name() const
+{
+	return template_class.class_name;
+}
+
+/* Helper class for printing the specializations of template classes
+ * that is used to print both the class declarations and the class definitions.
+ *
+ * "os" is the stream onto which the classes should be printed.
+ * "generator" is the templated C++ interface generator printing the classes.
+ */
+struct specialization_printer {
+	specialization_printer(std::ostream &os,
+			template_cpp_generator &generator) :
+		os(os), generator(generator) {}
+
+	virtual void print_class(const specialization &instance) const = 0;
+	void print_classes() const;
+
+	std::ostream &os;
+	template_cpp_generator &generator;
+};
+
+/* Print all specializations of all template classes.
+ *
+ * Each class has a predefined set of initial specializations,
+ * but while such a specialization is being printed,
+ * the need for other specializations may arise and
+ * these are added at the end of the list of specializations.
+ * That is, class_tuples.size() may change during the execution
+ * of the loop.
+ *
+ * For each specialization of a template class, call
+ * the print_class virtual method.
+ */
+void specialization_printer::print_classes() const
+{
+	for (auto &kvp : generator.template_classes) {
+		auto &template_class = kvp.second;
+		const auto &class_tuples = template_class.class_tuples;
+
+		for (size_t i = 0; i < class_tuples.size(); ++i)
+			print_class({ template_class, class_tuplesi });
+	}
+}
+
+/* A helper class for printing method declarations and definitions
+ * of a template class specialization.
+ *
+ * "instance" is the template class specialization for which methods
+ * are printed.
+ * "generator" is the templated C++ interface generator printing the classes.
+ */
+struct template_cpp_generator::class_printer :
+		public cpp_generator::class_printer {
+	class_printer(const specialization &instance,
+			const specialization_printer &instance_printer,
+			bool is_declaration);
+
+	void print_return_type(const Method &method, const Kind &kind)
+		const;
+	void print_method_template_arguments(const Signature &sig);
+	void print_method_header(const Method &method, const Signature &sig);
+	bool print_special_method(const Method &method,
+		const infix_map_map &special_methods);
+	void print_static_method(const Method &method);
+	void print_constructor(const Method &method);
+	bool is_return_kind(const Method &method, const Kind &return_kind);
+	void add_specialization(const Kind &kind);
+	bool print_matching_method(const Method &method, const Signature &sig,
+		const Kind &match_arg);
+	bool print_matching_method(const Method &method, const Signature &sig);
+	void print_matching_method(const Method &method,
+		const std::vector<Signature> &signatures);
+	void print_at_method(const Method &method);
+	bool print_special_member_method(const Method &method);
+	bool print_type_named_member_method(const Method &method);
+	bool print_member_method_with_name(const Method &method,
+		const std::string &name);
+	void print_member_method(const Method &method);
+	void print_any_method(const Method &method);
+	virtual void print_method(const Method &method) override;
+	virtual void print_method(const ConversionMethod &method) override;
+	virtual void print_method_sig(const Method &method,
+		const Signature &sig, bool deleted) = 0;
+	virtual bool want_descendent_overloads(const function_set &methods)
+		override;
+	void print_all_methods();
+
+	const specialization &instance;
+	template_cpp_generator &generator;
+};
+
+/* Construct a class_printer from the template class specialization
+ * for which methods are printed and
+ * the printer of the template class.
+ *
+ * The template class printer is only used to obtain the output stream and
+ * the templated C++ interface generator printing the classes.
+ */
+template_cpp_generator::class_printer::class_printer(
+		const specialization &instance,
+		const specialization_printer &instance_printer,
+		bool is_declaration) :
+	cpp_generator::class_printer(instance_printer.os,
+		instance.template_class.clazz, instance_printer.generator,
+		is_declaration),
+	instance(instance), generator(instance_printer.generator)
+{
+}
+
+/* An abstract template type printer, where the way of obtaining
+ * the argument kind is specified by the subclasses.
+ */
+struct template_cpp_type_printer : public cpp_type_printer {
+	template_cpp_type_printer() {}
+
+	std::string base(const std::string &type, const Kind &kind) const;
+	virtual Kind kind(int arg) const = 0;
+	virtual std::string qualified(int arg, const std::string &cpp_type)
+		const override;
+};
+
+/* Print a template type consisting of the type "type" and the kind "kind",
+ * including the "typed::" namespace specifier.
+ */
+std::string template_cpp_type_printer::base(const std::string &type,
+	const Kind &kind) const
+{
+	std::ostringstream ss;
+
+	ss << "typed::";
+	print_bare_template_type(ss, type, kind);
+	return ss.str();
+}
+
+/* Return the qualified form of the given C++ isl type name appearing
+ * in argument position "arg" (-1 for return type).
+ *
+ * isl::ctx is not templated, so if "cpp_type" is "ctx",
+ * then print a non-templated version.
+ * Otherwise, look up the kind of the argument and print
+ * the corresponding template type.
+ */
+std::string template_cpp_type_printer::qualified(int arg,
+	const std::string &cpp_type) const
+{
+	if (cpp_type == "ctx")
+		return cpp_type_printer::qualified(arg, cpp_type);
+
+	return base(cpp_type, kind(arg));
+}
+
+/* A template type printer for printing types with a fixed kind.
+ *
+ * "fixed_kind" is the fixed kind.
+ */
+struct template_cpp_kind_type_printer : public template_cpp_type_printer {
+	template_cpp_kind_type_printer(const Kind &kind) :
+		template_cpp_type_printer(), fixed_kind(kind) {}
+
+	virtual Kind kind(int arg) const override;
+
+	const Kind &fixed_kind;
+};
+
+/* Return the kind of the argument at position "arg",
+ * where position -1 refers to the return type.
+ *
+ * Always use the fixed kind.
+ */
+Kind template_cpp_kind_type_printer::kind(int arg) const
+{
+	return fixed_kind;
+}
+
+/* A template type printer for printing a method with a given signature.
+ *
+ * "sig" is the signature of the method being printed.
+ */
+struct template_cpp_arg_type_printer : public template_cpp_type_printer {
+	template_cpp_arg_type_printer(const Signature &sig) :
+		template_cpp_type_printer(), sig(sig) {}
+
+	virtual Kind kind(int arg) const override;
+
+	const Signature &sig;
+};
+
+/* Return the kind of the argument at position "arg",
+ * where position -1 refers to the return type.
+ *
+ * Look up the kind in the signature.
+ */
+Kind template_cpp_arg_type_printer::kind(int arg) const
+{
+	int n_args = sig.args.size();
+
+	if (arg < 0)
+		return sig.ret;
+	if (arg >= n_args)
+		generator::die("argument out of bounds");
+	return sig.argsarg;
+}
+
+/* A template type printer for printing a method with a given signature
+ * as part of a template class specialization of a given kind.
+ *
+ * "class_kind" is the template class specialization kind.
+ */
+struct template_method_type_printer : public template_cpp_arg_type_printer {
+	template_method_type_printer(const Signature &sig,
+			const Kind &class_kind) :
+		template_cpp_arg_type_printer(sig),
+		class_kind(class_kind) {}
+
+	virtual std::string class_type(const std::string &cpp_name)
+		const override;
+
+	const Kind &class_kind;
+};
+
+/* Print the class type "cpp_name".
+ *
+ * Print the templated version using the template class specialization kind.
+ */
+std::string template_method_type_printer::class_type(
+	const std::string &cpp_name) const
+{
+	return base(cpp_name, class_kind);
+}
+
+/* Print the templated return type of "method" of the kind "return_kind".
+ *
+ * Construct a type printer with "return_kind" as fixed kind and
+ * use it to print the return type.
+ */
+void template_cpp_generator::class_printer::print_return_type(
+	const Method &method, const Kind &return_kind) const
+{
+	template_cpp_kind_type_printer printer(return_kind);
+
+	os << printer.return_type(method);
+}
+
+/* Remove the initial "n" elements from "v".
+ */
+template <typename T>
+static void drop_initial(std::vector<T> &v, size_t n)
+{
+	v.erase(v.begin(), v.begin() + n);
+}
+
+/* If a method with signature "sig" requires additional template parameters
+ * compared to those of the class, then print a declaration for them.
+ * If this->declarations is set, then this will be part of a method declaration,
+ * requiring extra indentation.
+ *
+ * Construct the sequence of all required template parameters
+ * with those of the template class appearing first.
+ * If this sequence has any parameters not induced by the template class itself,
+ * then print a declaration for these extra parameters.
+ */
+void template_cpp_generator::class_printer::print_method_template_arguments(
+	const Signature &sig)
+{
+	std::vector<std::string> class_params, method_params;
+
+	class_params = instance.kind.params();
+	method_params = class_params;
+	combine(method_params, sig.params());
+
+	if (class_params.size() == method_params.size())
+		return;
+
+	drop_initial(method_params, class_params.size());
+
+	if (declarations)
+		os << "  ";
+	print_template(os, method_params);
+}
+
+/* Print the header for "method" with signature "sig".
+ *
+ * First print any additional template parameters that may be required and
+ * then print a regular method header, using a template type printer.
+ */
+void template_cpp_generator::class_printer::print_method_header(
+	const Method &method, const Signature &sig)
+{
+	template_method_type_printer type_printer(sig, instance.kind);
+
+	print_method_template_arguments(sig);
+	cpp_generator::class_printer::print_method_header(method,
+							type_printer);
+}
+
+/* Given a group of methods with the same name,
+ * should extra methods be added that take as arguments
+ * those types that can be converted to the original argument type
+ * through a unary constructor?
+ *
+ * Since type deduction does not consider implicit conversions,
+ * these extra methods should always be printed.
+ */
+bool template_cpp_generator::class_printer::want_descendent_overloads(
+	const function_set &methods)
+{
+	return true;
+}
+
+/* Print all constructors and methods that forward
+ * to the corresponding methods in the plain C++ interface class.
+ */
+void template_cpp_generator::class_printer::print_all_methods()
+{
+	print_constructors();
+	print_methods();
+}
+
+/* A helper class for printing method declarations
+ * of a template class specialization.
+ */
+struct template_cpp_generator::method_decl_printer :
+		public template_cpp_generator::class_printer {
+	method_decl_printer(const specialization &instance,
+			const struct specialization_printer &instance_printer) :
+		class_printer(instance, instance_printer, true) {}
+
+	virtual void print_method_sig(const Method &method,
+		const Signature &sig, bool deleted) override;
+	virtual void print_get_method(FunctionDecl *fd) override;
+};
+
+/* Print a declaration of the method "method" with signature "sig".
+ * Mark is "delete" if "deleted" is set.
+ */
+void template_cpp_generator::method_decl_printer::print_method_sig(
+	const Method &method, const Signature &sig, bool deleted)
+{
+	print_method_header(method, sig);
+	if (deleted)
+		os << " = delete";
+	os << ";\n";
+}
+
+/* Return the total number of arguments in the signature for "method",
+ * taking into account a possible callback argument.
+ *
+ * In particular, if the method has a callback argument,
+ * then the return kind of the callback appears at the position
+ * of the callback and the kinds of the arguments (except
+ * the user pointer argument) appear in the following positions.
+ */
+static int total_params(const Method &method)
+{
+	int n = method.num_params();
+
+	if (method.callback) {
+		auto callback_type = method.callback->getType();
+		auto callback = generator::extract_prototype(callback_type);
+
+		n += callback->getNumArgs() - 1;
+	}
+
+	return n;
+}
+
+/* Return a signature for "method" that matches "instance".
+ */
+static Signature instance_sig(const Method &method,
+	const specialization &instance)
+{
+	std::vector<Kind> args(total_params(method));
+
+	args0 = instance.kind;
+	return { instance.kind, args };
+}
+
+/* Print a declaration for the "get" method "fd",
+ * using a name that includes the "get_" prefix.
+ *
+ * These methods are only included in the plain interface.
+ * Explicitly delete them from the templated interface.
+ */
+void template_cpp_generator::method_decl_printer::print_get_method(
+	FunctionDecl *fd)
+{
+	Method method(clazz, fd, clazz.base_method_name(fd));
+
+	print_method_sig(method, instance_sig(method, instance), true);
+}
+
+/* A helper class for printing method definitions
+ * of a template class specialization.
+ */
+struct template_cpp_generator::method_impl_printer :
+		public template_cpp_generator::class_printer {
+	method_impl_printer(const specialization &instance,
+			const struct specialization_printer &instance_printer) :
+		class_printer(instance, instance_printer, false) {}
+
+	void print_callback_method_body(const Method &method,
+		const Signature &sig);
+	void print_method_body(const Method &method, const Signature &sig);
+	void print_constructor_body(const Method &method, const Signature &sig);
+	virtual void print_method_sig(const Method &method,
+		const Signature &sig, bool deleted) override;
+	virtual void print_get_method(FunctionDecl *fd) override;
+};
+
+/* Print a definition of the constructor "method" with signature "sig".
+ *
+ * Simply pass all arguments to the constructor of the corresponding
+ * plain type.
+ */
+void template_cpp_generator::method_impl_printer::print_constructor_body(
+	const Method &method, const Signature &sig)
+{
+	const auto &base_name = instance.base_name();
+
+	os << "  : " << base_name;
+	method.print_cpp_arg_list(os, & (int i) {
+		os << method.fd->getParamDecl(i)->getName().str();
+	});
+	os << "\n";
+
+	os << "{\n";
+	os << "}\n";
+}
+
+/* Print the arguments of the callback function "callback" to "os",
+ * calling "print_arg" with the type and the name of the arguments,
+ * where the type is obtained from "type_printer" with argument positions
+ * shifted by "shift".
+ */
+static void print_callback_args(std::ostream &os,
+	const FunctionProtoType *callback, const cpp_type_printer &type_printer,
+	int shift,
+	const std::function<void(const std::string &type,
+		const std::string &name)> &print_arg)
+{
+	auto n_arg = callback->getNumArgs() - 1;
+
+	Method::print_arg_list(os, 0, n_arg, & (int i) {
+		auto type = callback->getArgType(i);
+		auto name = "arg" + std::to_string(i);
+		auto cpptype = type_printer.param(shift + i, type);
+
+		print_arg(cpptype, name);
+	});
+}
+
+/* Print a lambda for passing to the plain method corresponding to "method"
+ * with signature "sig".
+ *
+ * The method is assumed to have only the callback as argument,
+ * which means the arguments of the callback are shifted by 2
+ * with respect to the arguments of the signature
+ * (one for the position of the callback argument plus
+ * one for the return kind of the callback).
+ *
+ * The lambda takes arguments with plain isl types and
+ * calls the callback of "method" with templated arguments.
+ */
+static void print_callback_lambda(std::ostream &os, const Method &method,
+	const Signature &sig)
+{
+	auto callback_type = method.callback->getType();
+	auto callback_name = method.callback->getName().str();
+	auto callback = generator::extract_prototype(callback_type);
+
+	if (method.num_params() != 2)
+		generator::die("callback is assumed to be single argument");
+
+	os << "  auto lambda = & ";
+	print_callback_args(os, callback, cpp_type_printer(), 2,
+		& (const std::string &type, const std::string &name) {
+			os << type << " " << name;
+		});
+	os << " {\n";
+
+	os << "    return " << callback_name;
+	print_callback_args(os, callback, template_cpp_arg_type_printer(sig), 2,
+		& (const std::string &type, const std::string &name) {
+			os << type << "(" << name << ")";
+		});
+	os << ";\n";
+
+	os << "  };\n";
+}
+
+/* Print a definition of the member method "method", which is known
+ * to have a callback argument, with signature "sig".
+ *
+ * First print a lambda for passing to the corresponding plain method and
+ * calling the callback of "method" with templated arguments.
+ * Then call the plain method, replacing the original callback
+ * by the lambda.
+ *
+ * The return value is assumed to be isl_bool or isl_stat
+ * so that no conversion to a template type is required.
+ */
+void template_cpp_generator::method_impl_printer::print_callback_method_body(
+	const Method &method, const Signature &sig)
+{
+	const auto &base_name = instance.base_name();
+	auto return_type = method.fd->getReturnType();
+
+	if (!is_isl_bool(return_type) && !is_isl_stat(return_type))
+		die("only isl_bool and isl_stat return types are supported");
+
+	os << "{\n";
+
+	print_callback_lambda(os, method, sig);
+
+	os << "  return ";
+	os << base_name << "::" << method.name;
+	method.print_cpp_arg_list(os, & (int i) {
+		auto param = method.fd->getParamDecl(i);
+
+		if (param == method.callback)
+			os << "lambda";
+		else
+			os << param->getName().str();
+	});
+	os << ";\n";
+
+	os << "}\n";
+}
+
+/* Print a definition of the member or static method "method"
+ * with signature "sig".
+ *
+ * The body calls the corresponding method of the base class
+ * in the plain interface and
+ * then casts the result to the templated result type.
+ */
+void template_cpp_generator::method_impl_printer::print_method_body(
+	const Method &method, const Signature &sig)
+{
+	const auto &base_name = instance.base_name();
+
+	os << "{\n";
+	os << "  auto res = ";
+	os << base_name << "::" << method.name;
+	method.print_cpp_arg_list(os, & (int i) {
+		os << method.fd->getParamDecl(i)->getName().str();
+	});
+	os << ";\n";
+
+	os << "  return ";
+	print_return_type(method, sig.ret);
+	os << "(res);\n";
+	os << "}\n";
+}
+
+/* Print a definition of the method "method" with signature "sig",
+ * if "deleted" is not set.
+ *
+ * If "deleted" is set, then the corresponding declaration
+ * is marked "delete" and no definition needs to be printed.
+ *
+ * Otherwise print the method header, preceded by the template parameters,
+ * if needed.
+ * The body depends on whether the method is a constructor or
+ * takes a callback.
+ */
+void template_cpp_generator::method_impl_printer::print_method_sig(
+	const Method &method, const Signature &sig, bool deleted)
+{
+	if (deleted)
+		return;
+
+	os << "\n";
+	print_non_empty_template(os, instance.kind.params());
+	print_method_header(method, sig);
+	os << "\n";
+	if (method.kind == Method::Kind::constructor)
+		print_constructor_body(method, sig);
+	else if (method.callback)
+		print_callback_method_body(method, sig);
+	else
+		print_method_body(method, sig);
+}
+
+/* Print a definition for the "get" method "fd" in class "clazz",
+ * using a name that includes the "get_" prefix, to "os".
+ *
+ * The declarations of these methods are explicitly delete'd
+ * so no definition needs to be printed.
+ */
+void template_cpp_generator::method_impl_printer::print_get_method(
+	FunctionDecl *fd)
+{
+}
+
+/* Print a declaration or definition of the static method "method",
+ * if it has a signature specified by static_methods.
+ */
+void template_cpp_generator::class_printer::print_static_method(
+	const Method &method)
+{
+	print_special_method(method, static_methods);
+}
+
+/* Signatures for constructors of multi-expressions
+ * from a space and a list.
+ */
+static Signature from_list_set = { { Domain }, { { Domain }, { Anonymous } } };
+static Signature from_list_map =
+	{ { Domain, Range }, { { Domain, Range }, { Domain, Anonymous } } };
+
+/* Signatures for constructors from a string.
+ */
+static Signature params_from_str = { { }, { { Ctx }, { Str } } };
+static Signature set_from_str = { { Domain }, { { Ctx }, { Str } } };
+static Signature map_from_str = { { Domain, Range }, { { Ctx }, { Str } } };
+static std::vector<Signature> from_str =
+	{ params_from_str, set_from_str, map_from_str };
+
+/* Signature for a constructor from an integer.
+ */
+static Signature int_from_si = { { Anonymous }, { { Ctx }, { Integer } } };
+
+/* Signatures for constructors of lists from the initial number
+ * of elements.
+ */
+static Signature alloc_params = { { }, { { Ctx }, { Integer } } };
+static Signature alloc_set = { { Domain }, { { Ctx }, { Integer } } };
+static Signature alloc_map = { { Domain, Range }, { { Ctx }, { Integer } } };
+
+/* Signatures for constructors and methods named after some other class.
+ *
+ * Two forms of constructors are handled
+ * - conversion from another object
+ * - construction of a multi-expression from a space and a list
+ *
+ * Methods named after some other class also come in two forms
+ * - extraction of information such as the space or a list
+ * - construction of a multi-expression from a space and a list
+ *
+ * In both cases, the first form is a unary operation and
+ * the second has an extra argument with a kind that is equal
+ * to that of the first argument, except that the final tuple is anonymous.
+ */
+static std::vector<Signature> constructor_sig = {
+	un_params,
+	un_set,
+	un_map,
+	from_list_set,
+	from_list_map,
+};
+
+/* Signatures for constructors derived from methods
+ * with the given names that override the default signatures.
+ */
+static const std::unordered_map<std::string, std::vector<Signature>>
+special_constructors {
+	{ "alloc",		{ alloc_params, alloc_set, alloc_map } },
+	{ "int_from_si",	{ int_from_si } },
+	{ "read_from_str",	from_str },
+};
+
+/* Print a declaration or definition of the constructor "method".
+ */
+void template_cpp_generator::class_printer::print_constructor(
+	const Method &method)
+{
+	if (special_constructors.count(method.name) != 0) {
+		const auto &sigs = special_constructors.at(method.name);
+		return print_matching_method(method, sigs);
+	}
+	print_matching_method(method, constructor_sig);
+}
+
+/* Does this template class represent an anonymous function?
+ *
+ * If any specialization represents an anonymous function,
+ * then every specialization does, so simply check
+ * the first specialization.
+ */
+bool template_class::is_anon() const
+{
+	return class_tuples0.is_anon();
+}
+
+/* Does this template class represent an anonymous value?
+ *
+ * That is, is there only a single specialization that moreover
+ * has a single, anonymous tuple?
+ */
+bool template_class::is_anon_set() const
+{
+	return class_tuples.size() == 1 && class_tuples0.is_anon_set();
+}
+
+/* Update the substitution "sub" to map "general" to "specific"
+ * if "specific" is a special case of "general" consistent with "sub",
+ * given that "general" is not a pair and can be assigned "specific".
+ * Return true if successful.
+ * Otherwise, return false.
+ *
+ * Check whether "general" is already assigned something in "sub".
+ * If so, it must be assigned "specific".
+ * Otherwise, there is a conflict.
+ */
+static bool update_sub_base(Substitution &sub, const TupleKindPtr &general,
+	const TupleKindPtr &specific)
+{
+	auto name = general->name;
+
+	if (sub.count(name) != 0 && sub.at(name) != specific)
+		return false;
+	sub.emplace(name, specific);
+	return true;
+}
+
+/* Update the substitution "sub" to map "general" to "specific"
+ * if "specific" is a special case of "general" consistent with "sub".
+ * Return true if successful.
+ * Otherwise, return false.
+ *
+ * If "general" is a pair and "specific" is not,
+ * then "specific" cannot be a special case.
+ * If both are pairs, then update the substitution based
+ * on both sides.
+ * If "general" is Anonymous, then "specific" must be Anonymous as well.
+ * If "general" is Leaf, then "specific" cannot be a pair.
+ *
+ * Otherwise, assign "specific" to "general", if possible.
+ */
+static bool update_sub(Substitution &sub, const TupleKindPtr &general,
+	const TupleKindPtr &specific)
+{
+	if (general->left() && !specific->left())
+		return false;
+	if (general->left())
+		return update_sub(sub, general->left(), specific->left()) &&
+		    update_sub(sub, general->right(), specific->right());
+	if (general == Anonymous && specific != Anonymous)
+		return false;
+	if (general == Leaf && specific->left())
+		return false;
+
+	return update_sub_base(sub, general, specific);
+}
+
+/* Check if "specific" is a special case of "general" and,
+ * if so, return true along with a substitution
+ * that maps "general" to "specific".
+ * Otherwise return false.
+ *
+ * This can only happen if the number of tuple kinds is the same.
+ * If so, start with an empty substitution and update it
+ * for each pair of tuple kinds, checking that each update succeeds.
+ */
+static std::pair<bool, Substitution> specializer(const Kind &general,
+	const Kind &specific)
+{
+	Substitution specializer;
+
+	if (general.size() != specific.size())
+		return { false, Substitution() };
+
+	for (size_t i = 0; i < general.size(); ++i) {
+		auto general_tuple = generali;
+
+		if (!update_sub(specializer, generali, specifici))
+			return { false, Substitution() };
+	}
+
+	return { true, specializer };
+}
+
+/* Is "kind1" equivalent to "kind2"?
+ * That is, is each a special case of the other?
+ */
+static bool equivalent(const Kind &kind1, const Kind &kind2)
+{
+	return specializer(kind1, kind2).first &&
+	       specializer(kind2, kind1).first;
+}
+
+/* Add the specialization "kind" to the sequence of specializations,
+ * provided there is no equivalent specialization already in there.
+ */
+void template_class::add_specialization(const Kind &kind)
+{
+	for (const auto &special : class_tuples)
+		if (equivalent(special, kind))
+			return;
+	class_tuples.emplace_back(kind);
+}
+
+/* A type printer that prints the plain interface type,
+ * without namespace.
+ */
+struct plain_cpp_type_printer : public cpp_type_printer {
+	plain_cpp_type_printer() {}
+
+	virtual std::string qualified(int arg, const std::string &cpp_type)
+		const override;
+};
+
+/* Return the qualified form of the given C++ isl type name appearing
+ * in argument position "arg" (-1 for return type).
+ *
+ * For printing the plain type without namespace, no modifications
+ * are required.
+ */
+std::string plain_cpp_type_printer::qualified(int arg,
+	const std::string &cpp_type) const
+{
+	return cpp_type;
+}
+
+/* Return a string representation of the plain type "type".
+ *
+ * For the plain printer, the argument position is irrelevant,
+ * so simply pass in -1.
+ */
+static std::string plain_type(QualType type)
+{
+	return plain_cpp_type_printer().param(-1, type);
+}
+
+/* Return a string representation of the plain return type of "method".
+ */
+static std::string plain_return_type(const Method &method)
+{
+	return plain_type(method.fd->getReturnType());
+}
+
+/* Return that part of the signature "sig" that should match
+ * the template class specialization for the given method.
+ *
+ * In particular, if the method is a regular member method,
+ * then the instance should match the first argument.
+ * Otherwise, it should match the return kind.
+ */
+static const Kind &matching_kind(const Method &method, const Signature &sig)
+{
+	if (method.kind == Method::Kind::member_method)
+		return sig.args0;
+	else
+		return sig.ret;
+}
+
+/* Is it possible for "template_class" to have the given kind?
+ *
+ * If the template class represents an anonymous function,
+ * then so must the given kind.
+ * There should also be specialization with the same number of tuple kinds.
+ */
+static bool has_kind(const template_class &template_class, const Kind &kind)
+{
+	if (template_class.is_anon() && !kind.is_anon())
+		return false;
+	for (const auto &class_tuple : template_class.class_tuples)
+		if (class_tuple.size() == kind.size())
+			return true;
+	return false;
+}
+
+/* Is "return_kind" a possible kind for the return type of "method"?
+ *
+ * If the return type is not a template class,
+ * then "return_kind" should not have any template parameters.
+ * Otherwise, "return_kind" should be a valid kind for the template class.
+ */
+bool template_cpp_generator::class_printer::is_return_kind(
+	const Method &method, const Kind &return_kind)
+{
+	const auto &template_classes = generator.template_classes;
+	auto return_type = plain_return_type(method);
+
+	if (template_classes.count(return_type) == 0)
+		return return_kind.params().size() == 0;
+	return has_kind(template_classes.at(return_type), return_kind);
+}
+
+/* Is "kind" a placeholder that can be assigned something else
+ * in a substitution?
+ *
+ * Anonymous can only be mapped to itself.  This is taken care of
+ * by assign().
+ * Leaf can only be assigned a placeholder, but there is no need
+ * to handle this specifically since Leaf can still be assigned
+ * to the placeholder.
+ */
+static bool assignable(const TupleKindPtr &kind)
+{
+	return kind != Anonymous && kind != Leaf;
+}
+
+/* Return a substitution that maps "kind1" to "kind2", if possible.
+ * Otherwise return an empty substitution.
+ *
+ * Check if "kind1" can be assigned anything or
+ * if "kind1" and "kind2" are identical.
+ * The latter case handles mapping Anonymous to itself.
+ */
+static Substitution assign(const TupleKindPtr &kind1, const TupleKindPtr &kind2)
+{
+	Substitution res;
+
+	if (assignable(kind1) || kind1 == kind2)
+		res.emplace(kind1->name, kind2);
+	return res;
+}
+
+/* Return a substitution that first applies "first" and then "second".
+ *
+ * The result consists of "second" and of "second" applied to "first".
+ */
+static Substitution compose(const Substitution &first,
+	const Substitution &second)
+{
+	Substitution res = second;
+
+	for (const auto &kvp : first)
+		res.emplace(kvp.first, apply(kvp.second, second));
+
+	return res;
+}
+
+static Substitution compute_unifier(const TupleKindPtr &kind1,
+	const TupleKindPtr &kind2);
+
+/* Try and extend "unifier" with a unifier for "kind1" and "kind2".
+ * Return the resulting unifier if successful.
+ * Otherwise, return an empty substitution.
+ *
+ * First apply "unifier" to "kind1" and "kind2".
+ * Then compute a unifier for the resulting tuple kinds and
+ * combine it with "unifier".
+ */
+static Substitution combine_unifiers(const TupleKindPtr &kind1,
+	const TupleKindPtr &kind2, const Substitution &unifier)
+{
+	auto k1 = apply(kind1, unifier);
+	auto k2 = apply(kind2, unifier);
+	auto u = compute_unifier(k1, k2);
+	if (u.size() == 0)
+		return Substitution();
+	return compose(unifier, u);
+}
+
+/* Try and compute a unifier of "kind1" and "kind2",
+ * i.e., a substitution that produces the same result when
+ * applied to both "kind1" and "kind2",
+ * for the case where both "kind1" and "kind2" are pairs.
+ * Return this unifier if it was found.
+ * Return an empty substitution if no unifier can be found.
+ *
+ * First compute a unifier for the left parts of the pairs and,
+ * if successful, combine it with a unifier for the right parts.
+ */
+static Substitution compute_pair_unifier(const TupleKindPtr &kind1,
+	const TupleKindPtr &kind2)
+{
+	auto unifier_left = compute_unifier(kind1->left(), kind2->left());
+	if (unifier_left.size() == 0)
+		return Substitution();
+	return combine_unifiers(kind1->right(), kind2->right(), unifier_left);
+}
+
+/* Try and compute a unifier of "kind1" and "kind2",
+ * i.e., a substitution that produces the same result when
+ * applied to both "kind1" and "kind2".
+ * Return this unifier if it was found.
+ * Return an empty substitution if no unifier can be found.
+ *
+ * If one of the tuple kinds is a pair then assign it
+ * to the other tuple kind, if possible.
+ * If neither is a pair, then try and assign one to the other.
+ * Otherwise, let compute_pair_unifier compute a unifier.
+ *
+ * Note that an assignment is added to the unifier even
+ * if "kind1" and "kind2" are identical.
+ * This ensures that a successful substitution is never empty.
+ */
+static Substitution compute_unifier(const TupleKindPtr &kind1,
+	const TupleKindPtr &kind2)
+{
+	if (kind1->left() && !kind2->left())
+		return assign(kind2, kind1);
+	if (!kind1->left() && kind2->left())
+		return assign(kind1, kind2);
+	if (!kind1->left() && !kind2->left()) {
+		if (assignable(kind1))
+			return assign(kind1, kind2);
+		else
+			return assign(kind2, kind1);
+	}
+
+	return compute_pair_unifier(kind1, kind2);
+}
+
+/* Try and compute a unifier of "kind1" and "kind2",
+ * i.e., a substitution that produces the same result when
+ * applied to both "kind1" and "kind2".
+ * Return this unifier if it was found.
+ * Return an empty substitution if no unifier can be found.
+ *
+ * Start with an empty substitution and compute a unifier for
+ * each pair of tuple kinds, combining the results.
+ * If no combined unifier can be found or
+ * if the numbers of tuple kinds are different, then return
+ * an empty substitution.
+ * This assumes that the number of tuples is greater than zero,
+ * as otherwise an empty substitution would be returned as well.
+ */
+static Substitution compute_unifier(const Kind &kind1, const Kind &kind2)
+{
+	Substitution unifier;
+
+	if (kind1.size() != kind2.size())
+		return Substitution();
+
+	for (size_t i = 0; i < kind1.size(); ++i)
+		unifier = combine_unifiers(kind1i, kind2i, unifier);
+
+	return unifier;
+}
+
+/* Try and construct a Kind that is a specialization of both "general" and
+ * "specific", where "specific" is known _not_ to be a specialization
+ * of "general" and not to contain any Leaf.
+ *
+ * First check whether "general" is a specialization of "specific".
+ * If so, simply return "general".
+ * Otherwise, rename the placeholders in the two kinds apart and
+ * try and compute a unifier.
+ * If this succeeds, then return the result of applying the unifier.
+ */
+static std::pair<bool, Kind> unify(const Kind &general, const Kind &specific)
+{
+	if (specializer(specific, general).first) {
+		return { true, general };
+	} else {
+		auto rename = param_renamer(specific.params(), "T");
+		auto renamed = specific.apply(rename);
+		auto unifier = compute_unifier(general, renamed);
+
+		if (unifier.size() == 0)
+			return { false, { } };
+
+		return { true, general.apply(unifier) };
+	}
+}
+
+/* Try and add a template class specialization corresponding to "kind".
+ * The new specialization needs to be a specialization of both
+ * the current specialization and "kind".
+ *
+ * The current template class specialization is known not to be a special case
+ * of "kind".
+ *
+ * Try and unify the two kinds and, if this succeeds, add the result
+ * to this list of template class specializations.
+ */
+void template_cpp_generator::class_printer::add_specialization(
+	const Kind &kind)
+{
+	auto maybe_unified = unify(kind, instance.kind);
+
+	if (!maybe_unified.first)
+		return;
+	instance.template_class.add_specialization(maybe_unified.second);
+}
+
+/* Print a declaration or definition of the method "method"
+ * if the template class specialization matches "match_arg".
+ * Return true if so.
+ * "sig" is the complete signature, of which "match_arg" refers
+ * to the first argument or the return type.
+ *
+ * Since "sig" may have parameters with the same names as
+ * those in instance.kind, rename them apart first.
+ *
+ * If the template class specialization is a special case of
+ * (the renamed) "match_arg"
+ * then apply the specializer to the complete (renamed) signature,
+ * check that the return kind is allowed and, if so,
+ * print the declaration or definition using the specialized signature.
+ *
+ * If the template class specialization is not a special case of "match_arg"
+ * then add a further specialization to the list of specializations
+ * of the template class.
+ */
+bool template_cpp_generator::class_printer::print_matching_method(
+	const Method &method, const Signature &sig, const Kind &match_arg)
+{
+	auto rename = shared_param_renamer(sig, instance.kind);
+	auto renamed_arg = match_arg.apply(rename);
+	auto maybe_specializer = specializer(renamed_arg, instance.kind);
+	if (maybe_specializer.first) {
+		const auto &specializer = maybe_specializer.second;
+		auto specialized_sig = sig.apply(rename).apply(specializer);
+		if (!is_return_kind(method, specialized_sig.ret))
+			return false;
+
+		print_method_sig(method, specialized_sig, false);
+	} else {
+		add_specialization(match_arg);
+	}
+	return maybe_specializer.first;
+}
+
+/* Is the first argument of "method" of type "isl_ctx *"?
+ */
+static bool first_arg_is_ctx(const Method &method)
+{
+	return generator::first_arg_is_isl_ctx(method.fd);
+}
+
+/* Is the first signature argument set to { Ctx }?
+ */
+static bool first_kind_is_ctx(const Signature &sig)
+{
+	return sig.args0.size() > 0 && sig.args00 == Ctx;
+}
+
+/* Print a declaration or definition of the member method "method"
+ * if it matches the signature "sig".
+ * Return true if so.
+ *
+ * First determine the part of the signature that needs to match
+ * the template class specialization and
+ * check that it has the same number of template arguments.
+ * Also check that the number of arguments of the signature
+ * matches that of the method.
+ * If there is at least one argument, then check that the first method argument
+ * is an isl_ctx if and only if the first signature argument is Ctx.
+ *
+ * If these tests succeed, proceed with the actual matching.
+ */
+bool template_cpp_generator::class_printer::print_matching_method(
+	const Method &method, const Signature &sig)
+{
+	auto match_arg = matching_kind(method, sig);
+	int n_args = sig.args.size();
+
+	if (match_arg.size() != instance.kind.size())
+		return false;
+	if (n_args != total_params(method))
+		return false;
+	if (n_args > 0 && first_arg_is_ctx(method) != first_kind_is_ctx(sig))
+		return false;
+
+	return print_matching_method(method, sig, match_arg);
+}
+
+/* Print a declaration or definition of the member method "method"
+ * for each matching signature in "signatures".
+ *
+ * If there is no matching signature in "signatures",
+ * then explicitly delete the method (using a signature based on
+ * the specialization) so that it is not inherited from the base class.
+ */
+void template_cpp_generator::class_printer::print_matching_method(
+	const Method &method, const std::vector<Signature> &signatures)
+{
+	auto any = false;
+
+	for (const auto &sig : signatures)
+		if (print_matching_method(method, sig))
+			any = true;
+
+	if (!any)
+		print_method_sig(method, instance_sig(method, instance), true);
+}
+
+/* Signatures for "at" methods applied to a multi-expression,
+ * which make the final tuple anonymous.
+ */
+static Signature select_set = { { Anonymous }, { { Domain }, { Integer } } };
+static Signature select_map =
+	{ { Domain, Anonymous }, { { Domain, Range }, { Integer } } };
+static std::vector<Signature> at_select = { select_set, select_map };
+
+/* Signatures for other "at" methods applied to a list,
+ * which do not modify the tuple kind.
+ */
+static Signature bin_set_int = { { Domain }, { { Domain }, { Integer } } };
+static Signature bin_map_int =
+	{ { Domain, Range }, { { Domain, Range }, { Integer } } };
+static std::vector<Signature> at_keep = { bin_set_int, bin_map_int };
+
+/* Print a declaration or definition of the "at" member method "method".
+ *
+ * There are two types of methods called "at".
+ * One type extracts an element from a multi-expression and
+ * the other extracts an element from a list.
+ *
+ * In the first case, the return type is an anonymous function
+ * while the object type is not.  In this case, the return kind
+ * should have a final Anonymous tuple.
+ * Otherwise, the return kind should be the same as the object kind.
+ */
+void template_cpp_generator::class_printer::print_at_method(
+	const Method &method)
+{
+	auto anon = instance.template_class.is_anon();
+	auto return_type = plain_return_type(method);
+	auto return_class = generator.template_classes.at(return_type);
+
+	if (!anon && return_class.is_anon())
+		return print_matching_method(method, at_select);
+	else
+		return print_matching_method(method, at_keep);
+}
+
+/* Does the string "s" contain "sub" as a substring?
+ */
+static bool contains(const std::string &s, const std::string &sub)
+{
+	return s.find(sub) != std::string::npos;
+}
+
+/* Print a declaration or definition of the member method "method",
+ * if it has a special signature in "special_methods".
+ * Return true if this is the case.
+ *
+ * Check if any special signatures are specified for this method and
+ * if the class name matches any of those with special signatures.
+ * If so, pick the one with the best match, i.e., the first match
+ * since the largest keys appear first.
+ */
+bool template_cpp_generator::class_printer::print_special_method(
+	const Method &method, const infix_map_map &special_methods)
+{
+	if (special_methods.count(method.name) == 0)
+		return false;
+
+	for (const auto &kvp : special_methods.at(method.name)) {
+		if (!contains(instance.template_class.class_name, kvp.first))
+			continue;
+		print_matching_method(method, kvp.second);
+		return true;
+	}
+
+	return false;
+}
+
+/* Print a declaration or definition of the member method "method",
+ * if it has a special signature specified by special_member_methods.
+ * Return true if this is the case.
+ */
+bool template_cpp_generator::class_printer::print_special_member_method(
+	const Method &method)
+{
+	return print_special_method(method, special_member_methods);
+}
+
+/* Print a declaration or definition of the member method "method",
+ * if it is named after a template class.  Return true if this is the case.
+ */
+bool template_cpp_generator::class_printer::print_type_named_member_method(
+	const Method &method)
+{
+	if (generator.template_classes.count(method.name) == 0)
+		return false;
+
+	print_matching_method(method, constructor_sig);
+
+	return true;
+}
+
+/* Print a declaration or definition of the member method "method"
+ * using a signature associated to method name "name", if there is any.
+ * Return true if this is the case.
+ */
+bool template_cpp_generator::class_printer::print_member_method_with_name(
+	const Method &method, const std::string &name)
+{
+	if (member_methods.count(name) == 0)
+		return false;
+
+	print_matching_method(method, member_methods.at(name));
+	return true;
+}
+
+/* If "sub" appears inside "str", then remove the first occurrence and
+ * return the result.  Otherwise, simply return "str".
+ */
+static std::string drop_occurrence(const std::string &str,
+	const std::string &sub)
+{
+	auto res = str;
+	auto pos = str.find(sub);
+
+	if (pos != std::string::npos)
+		res.erase(pos, sub.length());
+
+	return res;
+}
+
+/* If "sub" appears in "str" next to an underscore, then remove the combination.
+ * Otherwise, simply return "str".
+ */
+static std::string drop_underscore_occurrence(const std::string &str,
+	const std::string &sub)
+{
+	auto res = drop_occurrence(str, sub + "_");
+	if (res != str)
+		return res;
+	return drop_occurrence(res, std::string("_") + sub);
+}
+
+/* Return the name of "method", with the name of the return type,
+ * along with an underscore, removed, if this combination appears in the name.
+ * Otherwise, simply return the name.
+ */
+const std::string name_without_return(const Method &method)
+{
+	auto return_infix = plain_return_type(method);
+	return drop_underscore_occurrence(method.name, return_infix);
+}
+
+/* If this method has a callback, then remove the type
+ * of the first argument of the callback from the name of the method.
+ * Otherwise, simply return the name of the method.
+ */
+const std::string callback_name(const Method &method)
+{
+	if (!method.callback)
+		return method.name;
+
+	auto type = method.callback->getType();
+	auto callback = cpp_generator::extract_prototype(type);
+	auto arg_type = plain_type(callback->getArgType(0));
+	return generator::drop_suffix(method.name, "_" + arg_type);
+}
+
+/* Print a declaration or definition of the member method "method".
+ *
+ * If the method is called "at", then it requires special treatment.
+ * Otherwise, check if the signature is overridden for this class or
+ * if the method is named after some other type.
+ * Otherwise look for an appropriate signature using different variations
+ * of the method name.  First try the method name itself,
+ * then the method name with the return type removed and
+ * finally the method name with the callback argument type removed.
+ */
+void template_cpp_generator::class_printer::print_member_method(
+	const Method &method)
+{
+	if (method.name == "at")
+		return print_at_method(method);
+	if (print_special_member_method(method))
+		return;
+	if (print_type_named_member_method(method))
+		return;
+	if (print_member_method_with_name(method, method.name))
+		return;
+	if (print_member_method_with_name(method, name_without_return(method)))
+		return;
+	if (print_member_method_with_name(method, callback_name(method)))
+		return;
+}
+
+/* Print a declaration or definition of "method" based on its type.
+ */
+void template_cpp_generator::class_printer::print_any_method(
+	const Method &method)
+{
+	switch (method.kind) {
+	case Method::Kind::static_method:
+		print_static_method(method);
+		break;
+	case Method::Kind::constructor:
+		print_constructor(method);
+		break;
+	case Method::Kind::member_method:
+		print_member_method(method);
+		break;
+	}
+}
+
+/* Print a declaration or definition of "method".
+ *
+ * Mark the method as not requiring copies of the arguments.
+ */
+void template_cpp_generator::class_printer::print_method(const Method &method)
+{
+	print_any_method(NoCopyMethod(method));
+}
+
+/* Print a declaration or definition of "method".
+ *
+ * Note that a ConversionMethod is already marked
+ * as not requiring copies of the arguments.
+ */
+void template_cpp_generator::class_printer::print_method(
+	const ConversionMethod &method)
+{
+	print_any_method(method);
+}
+
+/* Helper class for printing the declarations for
+ * template class specializations.
+ */
+struct template_cpp_generator::class_decl_printer :
+	public specialization_printer
+{
+	class_decl_printer(std::ostream &os,
+				template_cpp_generator &generator) :
+		specialization_printer(os, generator) {}
+
+	void print_arg_subclass_constructor(const specialization &instance,
+		const std::vector<std::string> &params) const;
+	void print_super_constructor(const specialization &instance) const;
+	virtual void print_class(const specialization &instance) const override;
+};
+
+/* Print the declaration and definition of a constructor
+ * for the template class specialization "instance" taking
+ * an instance with more specialized template arguments,
+ * where "params" holds the template parameters of "instance".
+ * It is assumed that there is at least one template parameter as otherwise
+ * there are no template arguments to be specialized and
+ * no constructor needs to be printed.
+ *
+ * In particular, the constructor takes an object of the same instance where
+ * for each template parameter, the corresponding template argument
+ * of the input object is a subclass of the template argument
+ * of the constructed object.
+ *
+ * Pick fresh names for all template parameters and
+ * add a constructor with these fresh names as extra template parameters and
+ * a constraint requiring that each of them is a subclass
+ * of the corresponding class template parameter.
+ * The plain C++ interface object of the constructed object is initialized with
+ * the plain C++ interface object of the constructor argument.
+ */
+void template_cpp_generator::class_decl_printer::print_arg_subclass_constructor(
+	const specialization &instance,
+	const std::vector<std::string> &params) const
+{
+	const auto &class_name = instance.class_name();
+	auto rename = param_renamer(params, "Arg");
+	auto derived = instance.kind.apply(rename);
+
+	os << "  template ";
+	os << "<";
+	print_pure_template_args(os, derived.params());
+	os << ",\n";
+	os << "            typename std::enable_if<\n";
+	for (size_t i = 0; i < params.size(); ++i) {
+		if (i != 0)
+			os << " &&\n";
+		os << "              std::is_base_of<"
+		   << paramsi << ", "
+		   << rename.at(paramsi)->params()0 << ">{}";
+	}
+	os << ",\n";
+	os << "            bool>::type = true>";
+	os << "\n";
+	os << "  " << class_name << "(const ";
+	print_bare_template_type(os, class_name, derived);
+	os << " &obj) : " << instance.base_name() << "(obj) {}\n";
+}
+
+/* Print the declaration and definition of a constructor
+ * for the template class specialization "instance" taking
+ * an instance of the base class.
+ *
+ * If the instance kind is that of an anonymous set
+ * (i.e., it has a single tuple that is set to Anonymous),
+ * then allow the constructor to be called externally.
+ * This is mostly useful for being able to use isl::val and
+ * isl::typed::val<Anonymous> interchangeably and similarly for isl::id.
+ *
+ * If the instance is of any other kind, then make this constructor private
+ * to avoid objects of the plain interface being converted automatically.
+ * Also make sure that it does not apply to any type derived
+ * from the base class.  In particular, this makes sure it does
+ * not apply to any other specializations of this template class as
+ * otherwise any conflict in specializations would simply point
+ * to the private constructor.
+ *
+ * A factory method is added to be able to perform the conversion explicitly,
+ * with an explicit specification of the template arguments.
+ */
+void template_cpp_generator::class_decl_printer::print_super_constructor(
+	const specialization &instance) const
+{
+	bool hide = !instance.kind.is_anon_set();
+	const auto &base_name = instance.base_name();
+	const auto &arg_name = hide ? "base" : base_name;
+
+	if (hide) {
+		os << " private:\n";
+		os << "  template <typename base,\n";
+		os << "            typename std::enable_if<\n";
+		os << "              std::is_same<base, " << base_name
+		   << ">{}, bool>::type = true>\n";
+	}
+	os << "  " << instance.class_name()
+	   << "(const " << arg_name << " &obj) : "
+	   << base_name << "(obj) {}\n";
+	if (hide)
+		os << " public:\n";
+	os << "  static " << instance.class_name() << " from"
+	   << "(const " << base_name << " &obj) {\n";
+	os << "    return " << instance.class_name() << "(obj);\n";
+	os << "  }\n";
+}
+
+/* Print a "declaration" for the given template class specialization.
+ * In particular, print the class definition and the method declarations.
+ *
+ * The template parameters are the distinct variable names
+ * in the instance kind.
+ *
+ * Each instance of the template class derives from the corresponding
+ * plain C++ interface class.
+ *
+ * All (other) template classes are made friends of this template class
+ * to allow them to call the private constructor taking an object
+ * of the plain interface.
+ *
+ * Besides the constructors and methods that forward
+ * to the corresponding methods in the plain C++ interface class,
+ * some extra constructors are defined.
+ * The default zero-argument constructor is useful for declaring
+ * a variable that only gets assigned a value at a later stage.
+ * The constructor taking an instance with more specialized
+ * template arguments is useful for lifting the class hierarchy
+ * of the template arguments to the template class.
+ * The constructor taking an instance of the base class
+ * is useful for (explicitly) constructing a template type
+ * from a plain type.
+ */
+void template_cpp_generator::class_decl_printer::print_class(
+	const specialization &instance) const
+{
+	const auto &class_name = instance.class_name();
+	auto params = instance.kind.params();
+
+	os << "\n";
+
+	print_template(os, params);
+
+	os << "struct ";
+	print_bare_template_type(os, class_name, instance.kind);
+	os << " : public " << instance.base_name() << " {\n";
+
+	generator.print_friends(os);
+	os << "\n";
+
+	os << "  " << class_name << "() = default;\n";
+	if (params.size() != 0)
+		print_arg_subclass_constructor(instance, params);
+	print_super_constructor(instance);
+	method_decl_printer(instance, *this).print_all_methods();
+
+	os << "};\n";
+}
+
+/* Helper class for printing the definitions of template class specializations.
+ */
+struct template_cpp_generator::class_impl_printer :
+	public specialization_printer
+{
+	class_impl_printer(std::ostream &os,
+				template_cpp_generator &generator) :
+		specialization_printer(os, generator) {}
+
+	virtual void print_class(const specialization &instance) const override;
+};
+
+/* Print a definition for the given template class specialization.
+ *
+ * In particular, print definitions
+ * for the constructors and methods that forward
+ * to the corresponding methods in the plain C++ interface class.
+ * The extra constructors declared in the class definition
+ * are defined inline.
+ */
+void template_cpp_generator::class_impl_printer::print_class(
+	const specialization &instance) const
+{
+	method_impl_printer(instance, *this).print_all_methods();
+}
+
+/* Generate a templated cpp interface
+ * based on the extracted types and functions.
+ *
+ * First print forward declarations for all template classes,
+ * then the declarations of the classes, and at the end all
+ * method implementations.
+ */
+void template_cpp_generator::generate()
+{
+	ostream &os = std::cout;
+
+	os << "\n";
+
+	print_forward_declarations(os);
+	class_decl_printer(os, *this).print_classes();
+	class_impl_printer(os, *this).print_classes();
+}

_service:tar_scm:isl-0.24.tar.gz/interface/template_cpp.h Added

@@ -0,0 +1,118 @@
+#ifndef ISL_INTERFACE_TEMPLATE_CPP_H
+#define ISL_INTERFACE_TEMPLATE_CPP_H
+
+#include <initializer_list>
+#include <iostream>
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <unordered_map>
+
+#include "cpp.h"
+
+struct Fixed;
+
+struct TupleKind;
+
+/* A shared pointer to a TupleKind.
+ */
+struct TupleKindPtr : public std::shared_ptr<const TupleKind> {
+  using Base = std::shared_ptr<const TupleKind>;
+  TupleKindPtr() = default;
+  TupleKindPtr(Fixed);
+  TupleKindPtr(Base base) : Base(base) {}
+  TupleKindPtr(const std::string &name);
+  TupleKindPtr(const TupleKindPtr &left, const TupleKindPtr &right);
+};
+
+/* A substitution mapping leaf tuple kind names to tuple kinds.
+ */
+using Substitution = std::unordered_map<std::string, TupleKindPtr>;
+
+/* A representation of a (possibly improper) tuple kind.
+ * That is, this also includes tuple kinds for types
+ * that do not have any tuples.
+ *
+ * The kind could be a name (the base case) or
+ * a (currently) unnamed nested pair of tuple kinds.
+ */
+struct TupleKind {
+	TupleKind(const std::string &name) : name(name) {}
+
+	virtual std::string to_string() const;
+	virtual std::vector<std::string> params() const;
+	virtual TupleKindPtr apply(const Substitution &subs,
+		const TupleKindPtr &self) const;
+	virtual TupleKindPtr left() const;
+	virtual TupleKindPtr right() const;
+
+	const std::string name;
+};
+
+/* A sequence of tuple kinds, representing a kind of objects.
+ */
+struct Kind : public std::vector<TupleKindPtr> {
+	Kind() {}
+	Kind(std::initializer_list<TupleKindPtr> list) : vector(list) {}
+
+	bool is_anon() const;
+	bool is_set() const;
+	bool is_anon_set() const;
+	std::vector<std::string> params() const;
+	Kind apply(const Substitution &subs) const;
+};
+
+/* A representation of a template class.
+ *
+ * "class_name" is the name of the template class.
+ * "super_name" is the (fully qualified) name of the corresponding
+ * plain C++ interface class, from which this template class derives.
+ * "clazz" describes the plain class.
+ *
+ * "class_tuples" contains the specializations.
+ * It is initialized with a predefined set of specializations,
+ * but may be extended during the generations of the specializations.
+ */
+struct template_class {
+	const std::string class_name;
+	const std::string super_name;
+	const isl_class &clazz;
+
+	std::vector<Kind> class_tuples;
+
+	bool is_anon() const;
+	bool is_anon_set() const;
+	void add_specialization(const Kind &kind);
+};
+
+/* A generator for templated C++ bindings.
+ *
+ * "template_classes" contains all generated template classes,
+ * keyed on their names.
+ */
+class template_cpp_generator : public cpp_generator {
+	struct class_printer;
+	struct method_decl_printer;
+	struct method_impl_printer;
+	struct class_decl_printer;
+	struct class_impl_printer;
+
+	void add_template_class(const isl_class &clazz, const std::string &name,
+		const std::vector<Kind> &base_kinds);
+public:
+	template_cpp_generator(clang::SourceManager &SM,
+		std::set<clang::RecordDecl *> &exported_types,
+		std::set<clang::FunctionDecl *> exported_functions,
+		std::set<clang::FunctionDecl *> functions);
+
+	virtual void generate() override;
+	void foreach_template_class(
+		const std::function<void(const template_class &)> &fn) const;
+	void print_forward_declarations(std::ostream &os);
+	void print_friends(std::ostream &os);
+
+	std::map<std::string, template_class> template_classes;
+};
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/isl_aff.c -> _service:tar_scm:isl-0.24.tar.gz/isl_aff.c Changed

@@ -2,6 +2,9 @@
  * Copyright 2011      INRIA Saclay
  * Copyright 2011      Sven Verdoolaege
  * Copyright 2012-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      Sven Verdoolaege
+ * Copyright 2018,2020 Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -9,10 +12,12 @@
  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
  * 91893 Orsay, France
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
 #include <isl_ctx_private.h>
-#define ISL_DIM_H
 #include <isl_map_private.h>
 #include <isl_union_map_private.h>
 #include <isl_aff_private.h>
@@ -20,20 +25,36 @@
 #include <isl_local_space_private.h>
 #include <isl_vec_private.h>
 #include <isl_mat_private.h>
+#include <isl_id_private.h>
 #include <isl/constraint.h>
 #include <isl_seq.h>
 #include <isl/set.h>
 #include <isl_val_private.h>
-#include <isl/deprecated/aff_int.h>
+#include <isl_point_private.h>
 #include <isl_config.h>
 
-#undef BASE
-#define BASE aff
+#undef EL_BASE
+#define EL_BASE aff
 
 #include <isl_list_templ.c>
 
-#undef BASE
-#define BASE pw_aff
+#undef EL_BASE
+#define EL_BASE pw_aff
+
+#include <isl_list_templ.c>
+
+#undef EL_BASE
+#define EL_BASE pw_multi_aff
+
+#include <isl_list_templ.c>
+
+#undef EL_BASE
+#define EL_BASE union_pw_aff
+
+#include <isl_list_templ.c>
+
+#undef EL_BASE
+#define EL_BASE union_pw_multi_aff
 
 #include <isl_list_templ.c>
 
@@ -64,7 +85,7 @@
 {
 	isl_ctx *ctx;
 	isl_vec *v;
-	unsigned total;
+	isl_size total;
 
 	if (!ls)
 		return NULL;
@@ -79,6 +100,8 @@
 			goto error);
 
 	total = isl_local_space_dim(ls, isl_dim_all);
+	if (total < 0)
+		goto error;
 	v = isl_vec_alloc(ctx, 1 + 1 + total);
 	return isl_aff_alloc_vec(ls, v);
 error:
@@ -86,6 +109,35 @@
 	return NULL;
 }
 
+__isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff)
+{
+	if (!aff)
+		return NULL;
+
+	aff->ref++;
+	return aff;
+}
+
+__isl_give isl_aff *isl_aff_dup(__isl_keep isl_aff *aff)
+{
+	if (!aff)
+		return NULL;
+
+	return isl_aff_alloc_vec(isl_local_space_copy(aff->ls),
+				 isl_vec_copy(aff->v));
+}
+
+__isl_give isl_aff *isl_aff_cow(__isl_take isl_aff *aff)
+{
+	if (!aff)
+		return NULL;
+
+	if (aff->ref == 1)
+		return aff;
+	aff->ref--;
+	return isl_aff_dup(aff);
+}
+
 __isl_give isl_aff *isl_aff_zero_on_domain(__isl_take isl_local_space *ls)
 {
 	isl_aff *aff;
@@ -100,6 +152,21 @@
 	return aff;
 }
 
+/* Return an affine expression that is equal to zero on domain space "space".
+ */
+__isl_give isl_aff *isl_aff_zero_on_domain_space(__isl_take isl_space *space)
+{
+	return isl_aff_zero_on_domain(isl_local_space_from_space(space));
+}
+
+/* This function performs the same operation as isl_aff_zero_on_domain_space,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_aff *isl_space_zero_aff_on_domain(__isl_take isl_space *space)
+{
+	return isl_aff_zero_on_domain_space(space);
+}
+
 /* Return a piecewise affine expression defined on the specified domain
  * that is equal to zero.
  */
@@ -108,6 +175,24 @@
 	return isl_pw_aff_from_aff(isl_aff_zero_on_domain(ls));
 }
 
+/* Change "aff" into a NaN.
+ *
+ * Note that this function gets called from isl_aff_nan_on_domain,
+ * so "aff" may not have been initialized yet.
+ */
+static __isl_give isl_aff *isl_aff_set_nan(__isl_take isl_aff *aff)
+{
+	aff = isl_aff_cow(aff);
+	if (!aff)
+		return NULL;
+
+	aff->v = isl_vec_clr(aff->v);
+	if (!aff->v)
+		return isl_aff_free(aff);
+
+	return aff;
+}
+
 /* Return an affine expression defined on the specified domain
  * that represents NaN.
  */
@@ -116,12 +201,24 @@
 	isl_aff *aff;
 
 	aff = isl_aff_alloc(ls);
-	if (!aff)
-		return NULL;
+	return isl_aff_set_nan(aff);
+}
 
-	isl_seq_clr(aff->v->el, aff->v->size);
+/* Return an affine expression defined on the specified domain space
+ * that represents NaN.
+ */
+__isl_give isl_aff *isl_aff_nan_on_domain_space(__isl_take isl_space *space)
+{
+	return isl_aff_nan_on_domain(isl_local_space_from_space(space));
+}
 
-	return aff;
+/* Return a piecewise affine expression defined on the specified domain space
+ * that represents NaN.
+ */
+__isl_give isl_pw_aff *isl_pw_aff_nan_on_domain_space(
+	__isl_take isl_space *space)
+{
+	return isl_pw_aff_from_aff(isl_aff_nan_on_domain_space(space));
 }
 
 /* Return a piecewise affine expression defined on the specified domain
@@ -163,6 +260,14 @@
 	return NULL;
 }
 
+/* Return an affine expression that is equal to "val" on domain space "space".
+ */
+__isl_give isl_aff *isl_aff_val_on_domain_space(__isl_take isl_space *space,
+	__isl_take isl_val *val)
+{
+	return isl_aff_val_on_domain(isl_local_space_from_space(space), val);
+}
+
 /* Return an affine expression that is equal to the specified dimension
  * in "ls".
  */
@@ -181,9 +286,8 @@
 	if (isl_space_is_map(space))
 		isl_die(isl_space_get_ctx(space), isl_error_invalid,
 			"expecting (parameter) set space", goto error);
-	if (pos >= isl_local_space_dim(ls, type))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"position out of bounds", goto error);
+	if (isl_local_space_check_range(ls, type, pos, 1) < 0)
+		goto error;
 
 	isl_space_free(space);
 	aff = isl_aff_alloc(ls);
@@ -212,33 +316,28 @@
 	return isl_pw_aff_from_aff(isl_aff_var_on_domain(ls, type, pos));
 }
 
-__isl_give isl_aff *isl_aff_copy(__isl_keep isl_aff *aff)
-{
-	if (!aff)
-		return NULL;
-
-	aff->ref++;
-	return aff;
-}
-
-__isl_give isl_aff *isl_aff_dup(__isl_keep isl_aff *aff)
-{
-	if (!aff)
-		return NULL;
-
-	return isl_aff_alloc_vec(isl_local_space_copy(aff->ls),
-				 isl_vec_copy(aff->v));
-}
-
-__isl_give isl_aff *isl_aff_cow(__isl_take isl_aff *aff)
+/* Return an affine expression that is equal to the parameter
+ * in the domain space "space" with identifier "id".
+ */
+__isl_give isl_aff *isl_aff_param_on_domain_space_id(
+	__isl_take isl_space *space, __isl_take isl_id *id)
 {
-	if (!aff)
-		return NULL;
+	int pos;
+	isl_local_space *ls;
 
-	if (aff->ref == 1)
-		return aff;
-	aff->ref--;
-	return isl_aff_dup(aff);
+	if (!space || !id)
+		goto error;
+	pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
+	if (pos < 0)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"parameter not found in space", goto error);
+	isl_id_free(id);
+	ls = isl_local_space_from_space(space);
+	return isl_aff_var_on_domain(ls, isl_dim_param, pos);
+error:
+	isl_space_free(space);
+	isl_id_free(id);
+	return NULL;
 }
 
 __isl_null isl_aff *isl_aff_free(__isl_take isl_aff *aff)
@@ -262,23 +361,93 @@
 	return aff ? isl_local_space_get_ctx(aff->ls) : NULL;
 }
 
+/* Return a hash value that digests "aff".
+ */
+uint32_t isl_aff_get_hash(__isl_keep isl_aff *aff)
+{
+	uint32_t hash, ls_hash, v_hash;
+
+	if (!aff)
+		return 0;
+
+	hash = isl_hash_init();
+	ls_hash = isl_local_space_get_hash(aff->ls);
+	isl_hash_hash(hash, ls_hash);
+	v_hash = isl_vec_get_hash(aff->v);
+	isl_hash_hash(hash, v_hash);
+
+	return hash;
+}
+
+/* Return the domain local space of "aff".
+ */
+static __isl_keep isl_local_space *isl_aff_peek_domain_local_space(
+	__isl_keep isl_aff *aff)
+{
+	return aff ? aff->ls : NULL;
+}
+
+/* Return the number of variables of the given type in the domain of "aff".
+ */
+isl_size isl_aff_domain_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
+{
+	isl_local_space *ls;
+
+	ls = isl_aff_peek_domain_local_space(aff);
+	return isl_local_space_dim(ls, type);
+}
+
 /* Externally, an isl_aff has a map space, but internally, the
  * ls field corresponds to the domain of that space.
  */
-int isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
+isl_size isl_aff_dim(__isl_keep isl_aff *aff, enum isl_dim_type type)
 {
 	if (!aff)
-		return 0;
+		return isl_size_error;
 	if (type == isl_dim_out)
 		return 1;
 	if (type == isl_dim_in)
 		type = isl_dim_set;
-	return isl_local_space_dim(aff->ls, type);
+	return isl_aff_domain_dim(aff, type);
+}
+
+/* Return the offset of the first coefficient of type "type" in
+ * the domain of "aff".
+ */
+isl_size isl_aff_domain_offset(__isl_keep isl_aff *aff, enum isl_dim_type type)
+{
+	isl_local_space *ls;
+
+	ls = isl_aff_peek_domain_local_space(aff);
+	return isl_local_space_offset(ls, type);
+}
+
+/* Return the position of the dimension of the given type and name
+ * in "aff".
+ * Return -1 if no such dimension can be found.
+ */
+int isl_aff_find_dim_by_name(__isl_keep isl_aff *aff, enum isl_dim_type type,
+	const char *name)
+{
+	if (!aff)
+		return -1;
+	if (type == isl_dim_out)
+		return -1;
+	if (type == isl_dim_in)
+		type = isl_dim_set;
+	return isl_local_space_find_dim_by_name(aff->ls, type, name);
+}
+
+/* Return the domain space of "aff".
+ */
+static __isl_keep isl_space *isl_aff_peek_domain_space(__isl_keep isl_aff *aff)
+{
+	return aff ? isl_local_space_peek_space(aff->ls) : NULL;
 }
 
 __isl_give isl_space *isl_aff_get_domain_space(__isl_keep isl_aff *aff)
 {
-	return aff ? isl_local_space_get_space(aff->ls) : NULL;
+	return isl_space_copy(isl_aff_peek_domain_space(aff));
 }
 
 __isl_give isl_space *isl_aff_get_space(__isl_keep isl_aff *aff)
@@ -292,10 +461,12 @@
 	return space;
 }
 
+/* Return a copy of the domain space of "aff".
+ */
 __isl_give isl_local_space *isl_aff_get_domain_local_space(
 	__isl_keep isl_aff *aff)
 {
-	return aff ? isl_local_space_copy(aff->ls) : NULL;
+	return isl_local_space_copy(isl_aff_peek_domain_local_space(aff));
 }
 
 __isl_give isl_local_space *isl_aff_get_local_space(__isl_keep isl_aff *aff)
@@ -309,6 +480,59 @@
 	return ls;
 }
 
+/* Return the local space of the domain of "aff".
+ * This may be either a copy or the local space itself
+ * if there is only one reference to "aff".
+ * This allows the local space to be modified inplace
+ * if both the expression and its local space have only a single reference.
+ * The caller is not allowed to modify "aff" between this call and
+ * a subsequent call to isl_aff_restore_domain_local_space.
+ * The only exception is that isl_aff_free can be called instead.
+ */
+__isl_give isl_local_space *isl_aff_take_domain_local_space(
+	__isl_keep isl_aff *aff)
+{
+	isl_local_space *ls;
+
+	if (!aff)
+		return NULL;
+	if (aff->ref != 1)
+		return isl_aff_get_domain_local_space(aff);
+	ls = aff->ls;
+	aff->ls = NULL;
+	return ls;
+}
+
+/* Set the local space of the domain of "aff" to "ls",
+ * where the local space of "aff" may be missing
+ * due to a preceding call to isl_aff_take_domain_local_space.
+ * However, in this case, "aff" only has a single reference and
+ * then the call to isl_aff_cow has no effect.
+ */
+__isl_give isl_aff *isl_aff_restore_domain_local_space(
+	__isl_keep isl_aff *aff, __isl_take isl_local_space *ls)
+{
+	if (!aff || !ls)
+		goto error;
+
+	if (aff->ls == ls) {
+		isl_local_space_free(ls);
+		return aff;
+	}
+
+	aff = isl_aff_cow(aff);
+	if (!aff)
+		goto error;
+	isl_local_space_free(aff->ls);
+	aff->ls = ls;
+
+	return aff;
+error:
+	isl_aff_free(aff);
+	isl_local_space_free(ls);
+	return NULL;
+}
+
 /* Externally, an isl_aff has a map space, but internally, the
  * ls field corresponds to the domain of that space.
  */
@@ -325,20 +549,20 @@
 }
 
 __isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
 	aff = isl_aff_cow(aff);
-	if (!aff || !dim)
+	if (!aff || !space)
 		goto error;
 
-	aff->ls = isl_local_space_reset_space(aff->ls, dim);
+	aff->ls = isl_local_space_reset_space(aff->ls, space);
 	if (!aff->ls)
 		return isl_aff_free(aff);
 
 	return aff;
 error:
 	isl_aff_free(aff);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -354,21 +578,28 @@
 }
 
 /* Reorder the coefficients of the affine expression based
- * on the given reodering.
+ * on the given reordering.
  * The reordering r is assumed to have been extended with the local
  * variables.
  */
 static __isl_give isl_vec *vec_reorder(__isl_take isl_vec *vec,
 	__isl_take isl_reordering *r, int n_div)
 {
+	isl_space *space;
 	isl_vec *res;
+	isl_size dim;
 	int i;
 
 	if (!vec || !r)
 		goto error;
 
-	res = isl_vec_alloc(vec->ctx,
-			    2 + isl_space_dim(r->dim, isl_dim_all) + n_div);
+	space = isl_reordering_peek_space(r);
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		goto error;
+	res = isl_vec_alloc(vec->ctx, 2 + dim + n_div);
+	if (!res)
+		goto error;
 	isl_seq_cpy(res->el, vec->el, 2);
 	isl_seq_clr(res->el + 2, res->size - 2);
 	for (i = 0; i < r->len; ++i)
@@ -411,17 +642,17 @@
 __isl_give isl_aff *isl_aff_align_params(__isl_take isl_aff *aff,
 	__isl_take isl_space *model)
 {
+	isl_bool equal_params;
+
 	if (!aff || !model)
 		goto error;
 
-	if (!isl_space_match(aff->ls->dim, isl_dim_param,
-			     model, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(aff->ls->dim, model);
+	if (equal_params < 0)
+		goto error;
+	if (!equal_params) {
 		isl_reordering *exp;
 
-		model = isl_space_drop_dims(model, isl_dim_in,
-					0, isl_space_dim(model, isl_dim_in));
-		model = isl_space_drop_dims(model, isl_dim_out,
-					0, isl_space_dim(model, isl_dim_out));
 		exp = isl_parameter_alignment_reordering(aff->ls->dim, model);
 		exp = isl_reordering_extend_space(exp,
 					isl_aff_get_domain_space(aff));
@@ -436,63 +667,51 @@
 	return NULL;
 }
 
+#undef TYPE
+#define TYPE isl_aff
+#include "isl_unbind_params_templ.c"
+
 /* Is "aff" obviously equal to zero?
  *
  * If the denominator is zero, then "aff" is not equal to zero.
  */
-int isl_aff_plain_is_zero(__isl_keep isl_aff *aff)
+isl_bool isl_aff_plain_is_zero(__isl_keep isl_aff *aff)
 {
+	int pos;
+
 	if (!aff)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_int_is_zero(aff->v->el0))
-		return 0;
-	return isl_seq_first_non_zero(aff->v->el + 1, aff->v->size - 1) < 0;
+		return isl_bool_false;
+	pos = isl_seq_first_non_zero(aff->v->el + 1, aff->v->size - 1);
+	return isl_bool_ok(pos < 0);
 }
 
 /* Does "aff" represent NaN?
  */
-int isl_aff_is_nan(__isl_keep isl_aff *aff)
+isl_bool isl_aff_is_nan(__isl_keep isl_aff *aff)
 {
 	if (!aff)
-		return -1;
+		return isl_bool_error;
 
-	return isl_seq_first_non_zero(aff->v->el, 2) < 0;
-}
-
-/* Does "pa" involve any NaNs?
- */
-int isl_pw_aff_involves_nan(__isl_keep isl_pw_aff *pa)
-{
-	int i;
-
-	if (!pa)
-		return -1;
-	if (pa->n == 0)
-		return 0;
-
-	for (i = 0; i < pa->n; ++i) {
-		int is_nan = isl_aff_is_nan(pa->pi.aff);
-		if (is_nan < 0 || is_nan)
-			return is_nan;
-	}
-
-	return 0;
+	return isl_bool_ok(isl_seq_first_non_zero(aff->v->el, 2) < 0);
 }
 
 /* Are "aff1" and "aff2" obviously equal?
  *
  * NaN is not equal to anything, not even to another NaN.
  */
-int isl_aff_plain_is_equal(__isl_keep isl_aff *aff1, __isl_keep isl_aff *aff2)
+isl_bool isl_aff_plain_is_equal(__isl_keep isl_aff *aff1,
+	__isl_keep isl_aff *aff2)
 {
-	int equal;
+	isl_bool equal;
 
 	if (!aff1 || !aff2)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_aff_is_nan(aff1) || isl_aff_is_nan(aff2))
-		return 0;
+		return isl_bool_false;
 
 	equal = isl_local_space_is_equal(aff1->ls, aff2->ls);
 	if (equal < 0 || !equal)
@@ -505,15 +724,15 @@
  *
  * We cannot return anything meaningful in case of a NaN.
  */
-int isl_aff_get_denominator(__isl_keep isl_aff *aff, isl_int *v)
+isl_stat isl_aff_get_denominator(__isl_keep isl_aff *aff, isl_int *v)
 {
 	if (!aff)
-		return -1;
+		return isl_stat_error;
 	if (isl_aff_is_nan(aff))
 		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"cannot get denominator of NaN", return -1);
+			"cannot get denominator of NaN", return isl_stat_error);
 	isl_int_set(*v, aff->v->el0);
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Return the common denominator of "aff".
@@ -531,21 +750,6 @@
 	return isl_val_int_from_isl_int(ctx, aff->v->el0);
 }
 
-/* Return the constant term of "aff" in "v".
- *
- * We cannot return anything meaningful in case of a NaN.
- */
-int isl_aff_get_constant(__isl_keep isl_aff *aff, isl_int *v)
-{
-	if (!aff)
-		return -1;
-	if (isl_aff_is_nan(aff))
-		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"cannot get constant term of NaN", return -1);
-	isl_int_set(*v, aff->v->el1);
-	return 0;
-}
-
 /* Return the constant term of "aff".
  */
 __isl_give isl_val *isl_aff_get_constant_val(__isl_keep isl_aff *aff)
@@ -564,37 +768,6 @@
 }
 
 /* Return the coefficient of the variable of type "type" at position "pos"
- * of "aff" in "v".
- *
- * We cannot return anything meaningful in case of a NaN.
- */
-int isl_aff_get_coefficient(__isl_keep isl_aff *aff,
-	enum isl_dim_type type, int pos, isl_int *v)
-{
-	if (!aff)
-		return -1;
-
-	if (type == isl_dim_out)
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"output/set dimension does not have a coefficient",
-			return -1);
-	if (type == isl_dim_in)
-		type = isl_dim_set;
-
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", return -1);
-
-	if (isl_aff_is_nan(aff))
-		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"cannot get coefficient of NaN", return -1);
-	pos += isl_local_space_offset(aff->ls, type);
-	isl_int_set(*v, aff->v->el1 + pos);
-
-	return 0;
-}
-
-/* Return the coefficient of the variable of type "type" at position "pos"
  * of "aff".
  */
 __isl_give isl_val *isl_aff_get_coefficient_val(__isl_keep isl_aff *aff,
@@ -614,9 +787,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(ctx, isl_error_invalid,
-			"position out of bounds", return NULL);
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return NULL;
 
 	if (isl_aff_is_nan(aff))
 		return isl_val_nan(ctx);
@@ -625,27 +797,30 @@
 	return isl_val_normalize(v);
 }
 
-/* Replace the denominator of "aff" by "v".
- *
- * A NaN is unaffected by this operation.
+/* Return the sign of the coefficient of the variable of type "type"
+ * at position "pos" of "aff".
  */
-__isl_give isl_aff *isl_aff_set_denominator(__isl_take isl_aff *aff, isl_int v)
+int isl_aff_coefficient_sgn(__isl_keep isl_aff *aff, enum isl_dim_type type,
+	int pos)
 {
+	isl_ctx *ctx;
+
 	if (!aff)
-		return NULL;
-	if (isl_aff_is_nan(aff))
-		return aff;
-	aff = isl_aff_cow(aff);
-	if (!aff)
-		return NULL;
+		return 0;
 
-	aff->v = isl_vec_cow(aff->v);
-	if (!aff->v)
-		return isl_aff_free(aff);
+	ctx = isl_aff_get_ctx(aff);
+	if (type == isl_dim_out)
+		isl_die(ctx, isl_error_invalid,
+			"output/set dimension does not have a coefficient",
+			return 0);
+	if (type == isl_dim_in)
+		type = isl_dim_set;
 
-	isl_int_set(aff->v->el0, v);
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return 0;
 
-	return aff;
+	pos += isl_local_space_offset(aff->ls, type);
+	return isl_int_sgn(aff->v->el1 + pos);
 }
 
 /* Replace the numerator of the constant term of "aff" by "v".
@@ -751,25 +926,12 @@
 	return aff;
 }
 
-/* Add "v" to the constant term of "aff".
- *
- * A NaN is unaffected by this operation.
+/* Add "v" to the constant term of "aff",
+ * in case "aff" is a rational expression.
  */
-__isl_give isl_aff *isl_aff_add_constant_val(__isl_take isl_aff *aff,
+static __isl_give isl_aff *isl_aff_add_rat_constant_val(__isl_take isl_aff *aff,
 	__isl_take isl_val *v)
 {
-	if (!aff || !v)
-		goto error;
-
-	if (isl_aff_is_nan(aff) || isl_val_is_zero(v)) {
-		isl_val_free(v);
-		return aff;
-	}
-
-	if (!isl_val_is_rat(v))
-		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"expecting rational value", goto error);
-
 	aff = isl_aff_cow(aff);
 	if (!aff)
 		goto error;
@@ -803,6 +965,58 @@
 	return NULL;
 }
 
+/* Return the first argument and free the second.
+ */
+static __isl_give isl_aff *pick_free(__isl_take isl_aff *aff,
+	__isl_take isl_val *v)
+{
+	isl_val_free(v);
+	return aff;
+}
+
+/* Replace the first argument by NaN and free the second argument.
+ */
+static __isl_give isl_aff *set_nan_free_val(__isl_take isl_aff *aff,
+	__isl_take isl_val *v)
+{
+	isl_val_free(v);
+	return isl_aff_set_nan(aff);
+}
+
+/* Add "v" to the constant term of "aff".
+ *
+ * A NaN is unaffected by this operation.
+ * Conversely, adding a NaN turns "aff" into a NaN.
+ */
+__isl_give isl_aff *isl_aff_add_constant_val(__isl_take isl_aff *aff,
+	__isl_take isl_val *v)
+{
+	isl_bool is_nan, is_zero, is_rat;
+
+	is_nan = isl_aff_is_nan(aff);
+	is_zero = isl_val_is_zero(v);
+	if (is_nan < 0 || is_zero < 0)
+		goto error;
+	if (is_nan || is_zero)
+		return pick_free(aff, v);
+
+	is_nan = isl_val_is_nan(v);
+	is_rat = isl_val_is_rat(v);
+	if (is_nan < 0 || is_rat < 0)
+		goto error;
+	if (is_nan)
+		return set_nan_free_val(aff, v);
+	if (!is_rat)
+		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
+			"expecting rational value or NaN", goto error);
+
+	return isl_aff_add_rat_constant_val(aff, v);
+error:
+	isl_aff_free(aff);
+	isl_val_free(v);
+	return NULL;
+}
+
 __isl_give isl_aff *isl_aff_add_constant_si(__isl_take isl_aff *aff, int v)
 {
 	isl_int t;
@@ -901,9 +1115,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", return isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return isl_aff_free(aff);
 
 	if (isl_aff_is_nan(aff))
 		return aff;
@@ -939,9 +1152,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos < 0 || pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", return isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return isl_aff_free(aff);
 
 	if (isl_aff_is_nan(aff))
 		return aff;
@@ -980,9 +1192,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", goto error);
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return isl_aff_free(aff);
 
 	if (isl_aff_is_nan(aff)) {
 		isl_val_free(v);
@@ -1046,9 +1257,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", return isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		return isl_aff_free(aff);
 
 	if (isl_aff_is_nan(aff))
 		return aff;
@@ -1089,9 +1299,8 @@
 	if (type == isl_dim_in)
 		type = isl_dim_set;
 
-	if (pos >= isl_local_space_dim(aff->ls, type))
-		isl_die(aff->v->ctx, isl_error_invalid,
-			"position out of bounds", goto error);
+	if (isl_local_space_check_range(aff->ls, type, pos, 1) < 0)
+		goto error;
 
 	if (isl_aff_is_nan(aff)) {
 		isl_val_free(v);
@@ -1185,17 +1394,16 @@
  * expression, but we would also need to check that no other divs are
  * defined in terms of them.
  */
-__isl_give isl_aff *isl_aff_remove_unused_divs( __isl_take isl_aff *aff)
+__isl_give isl_aff *isl_aff_remove_unused_divs(__isl_take isl_aff *aff)
 {
 	int pos;
-	int off;
-	int n;
-
-	if (!aff)
-		return NULL;
+	isl_size off;
+	isl_size n;
 
-	n = isl_local_space_dim(aff->ls, isl_dim_div);
-	off = isl_local_space_offset(aff->ls, isl_dim_div);
+	n = isl_aff_domain_dim(aff, isl_dim_div);
+	off = isl_aff_domain_offset(aff, isl_dim_div);
+	if (n < 0 || off < 0)
+		return isl_aff_free(aff);
 
 	pos = isl_seq_last_non_zero(aff->v->el + 1 + off, n) + 1;
 	if (pos == n)
@@ -1213,53 +1421,24 @@
 	return aff;
 }
 
-/* Given two affine expressions "p" of length p_len (including the
- * denominator and the constant term) and "subs" of length subs_len,
- * plug in "subs" for the variable at position "pos".
- * The variables of "subs" and "p" are assumed to match up to subs_len,
- * but "p" may have additional variables.
- * "v" is an initialized isl_int that can be used internally.
- *
- * In particular, if "p" represents the expression
- *
- *	(a i + g)/m
- *
- * with i the variable at position "pos" and "subs" represents the expression
- *
- *	f/d
- *
- * then the result represents the expression
- *
- *	(a f + d g)/(m d)
- *
- */
-void isl_seq_substitute(isl_int *p, int pos, isl_int *subs,
-	int p_len, int subs_len, isl_int v)
-{
-	isl_int_set(v, p1 + pos);
-	isl_int_set_si(p1 + pos, 0);
-	isl_seq_combine(p + 1, subs0, p + 1, v, subs + 1, subs_len - 1);
-	isl_seq_scale(p + subs_len, p + subs_len, subs0, p_len - subs_len);
-	isl_int_mul(p0, p0, subs0);
-}
-
 /* Look for any divs in the aff->ls with a denominator equal to one
  * and plug them into the affine expression and any subsequent divs
  * that may reference the div.
  */
 static __isl_give isl_aff *plug_in_integral_divs(__isl_take isl_aff *aff)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	int len;
 	isl_int v;
 	isl_vec *vec;
 	isl_local_space *ls;
-	unsigned pos;
+	isl_size off;
 
-	if (!aff)
-		return NULL;
-
-	n = isl_local_space_dim(aff->ls, isl_dim_div);
+	n = isl_aff_domain_dim(aff, isl_dim_div);
+	off = isl_aff_domain_offset(aff, isl_dim_div);
+	if (n < 0 || off < 0)
+		return isl_aff_free(aff);
 	len = aff->v->size;
 	for (i = 0; i < n; ++i) {
 		if (!isl_int_is_one(aff->ls->div->rowi0))
@@ -1274,8 +1453,7 @@
 
 		isl_int_init(v);
 
-		pos = isl_local_space_offset(aff->ls, isl_dim_div) + i;
-		isl_seq_substitute(vec->el, pos, aff->ls->div->rowi,
+		isl_seq_substitute(vec->el, off + i, aff->ls->div->rowi,
 					len, len, v);
 
 		isl_int_clear(v);
@@ -1314,14 +1492,14 @@
  */
 static __isl_give isl_aff *plug_in_unit_divs(__isl_take isl_aff *aff)
 {
-	int i, j, n;
-	int off;
-
-	if (!aff)
-		return NULL;
+	int i, j;
+	isl_size n;
+	isl_size off;
 
-	n = isl_local_space_dim(aff->ls, isl_dim_div);
-	off = isl_local_space_offset(aff->ls, isl_dim_div);
+	n = isl_aff_domain_dim(aff, isl_dim_div);
+	off = isl_aff_domain_offset(aff, isl_dim_div);
+	if (n < 0 || off < 0)
+		return isl_aff_free(aff);
 	for (i = 1; i < n; ++i) {
 		for (j = 0; j < i; ++j) {
 			if (!isl_int_is_one(aff->ls->div->rowi1 + off + j))
@@ -1344,10 +1522,13 @@
  */
 static __isl_give isl_aff *swap_div(__isl_take isl_aff *aff, int a, int b)
 {
-	unsigned off = isl_local_space_offset(aff->ls, isl_dim_div);
+	isl_size off = isl_aff_domain_offset(aff, isl_dim_div);
 	isl_local_space *ls;
 	isl_vec *v;
 
+	if (off < 0)
+		return isl_aff_free(aff);
+
 	ls = isl_local_space_copy(aff->ls);
 	ls = isl_local_space_swap_div(ls, a, b);
 	v = isl_vec_copy(aff->v);
@@ -1375,7 +1556,10 @@
  */
 static __isl_give isl_aff *merge_divs(__isl_take isl_aff *aff, int a, int b)
 {
-	unsigned off = isl_local_space_offset(aff->ls, isl_dim_div);
+	isl_size off = isl_aff_domain_offset(aff, isl_dim_div);
+
+	if (off < 0)
+		return isl_aff_free(aff);
 
 	if (isl_int_is_zero(aff->v->el1 + off + b))
 		return aff;
@@ -1402,14 +1586,12 @@
  */
 static __isl_give isl_aff *sort_divs(__isl_take isl_aff *aff)
 {
-	int i, j, n;
-	unsigned off;
-
-	if (!aff)
-		return NULL;
+	isl_size n;
+	int i, j;
 
-	off = isl_local_space_offset(aff->ls, isl_dim_div);
 	n = isl_aff_dim(aff, isl_dim_div);
+	if (n < 0)
+		return isl_aff_free(aff);
 	for (i = 1; i < n; ++i) {
 		for (j = i - 1; j >= 0; --j) {
 			int cmp = isl_mat_cmp_div(aff->ls->div, j, j + 1);
@@ -1429,7 +1611,7 @@
 
 /* Normalize the representation of "aff".
  *
- * This function should only be called of "new" isl_affs, i.e.,
+ * This function should only be called on "new" isl_affs, i.e.,
  * with only a single reference.  We therefore do not need to
  * worry about affecting other instances.
  */
@@ -1454,6 +1636,8 @@
  * create a new div d = r/m and return the expression q + d.
  * The coefficients in r are taken to lie between -m/2 and m/2.
  *
+ * reduce_div_coefficients performs the same normalization.
+ *
  * As a special case, floor(NaN) = NaN.
  */
 __isl_give isl_aff *isl_aff_floor(__isl_take isl_aff *aff)
@@ -1520,23 +1704,6 @@
 /* Compute
  *
  *	aff mod m = aff - m * floor(aff/m)
- */
-__isl_give isl_aff *isl_aff_mod(__isl_take isl_aff *aff, isl_int m)
-{
-	isl_aff *res;
-
-	res = isl_aff_copy(aff);
-	aff = isl_aff_scale_down(aff, m);
-	aff = isl_aff_floor(aff);
-	aff = isl_aff_scale(aff, m);
-	res = isl_aff_sub(res, aff);
-
-	return res;
-}
-
-/* Compute
- *
- *	aff mod m = aff - m * floor(aff/m)
  *
  * with m an integer value.
  */
@@ -1645,44 +1812,25 @@
  * The expansion itself is given by "exp" while the resulting
  * list of divs is given by "div".
  */
-__isl_give isl_aff *isl_aff_expand_divs( __isl_take isl_aff *aff,
+__isl_give isl_aff *isl_aff_expand_divs(__isl_take isl_aff *aff,
 	__isl_take isl_mat *div, int *exp)
 {
-	int i, j;
-	int old_n_div;
-	int new_n_div;
-	int offset;
+	isl_size old_n_div;
+	isl_size new_n_div;
+	isl_size offset;
 
 	aff = isl_aff_cow(aff);
-	if (!aff || !div)
-		goto error;
 
-	old_n_div = isl_local_space_dim(aff->ls, isl_dim_div);
+	offset = isl_aff_domain_offset(aff, isl_dim_div);
+	old_n_div = isl_aff_domain_dim(aff, isl_dim_div);
 	new_n_div = isl_mat_rows(div);
-	if (new_n_div < old_n_div)
-		isl_die(isl_mat_get_ctx(div), isl_error_invalid,
-			"not an expansion", goto error);
-
-	aff->v = isl_vec_extend(aff->v, aff->v->size + new_n_div - old_n_div);
-	if (!aff->v)
+	if (offset < 0 || old_n_div < 0 || new_n_div < 0)
 		goto error;
 
-	offset = 1 + isl_local_space_offset(aff->ls, isl_dim_div);
-	j = old_n_div - 1;
-	for (i = new_n_div - 1; i >= 0; --i) {
-		if (j >= 0 && expj == i) {
-			if (i != j)
-				isl_int_swap(aff->v->eloffset + i,
-					     aff->v->eloffset + j);
-			j--;
-		} else
-			isl_int_set_si(aff->v->eloffset + i, 0);
-	}
-
-	aff->ls = isl_local_space_replace_divs(aff->ls, isl_mat_copy(div));
-	if (!aff->ls)
-		goto error;
-	isl_mat_free(div);
+	aff->v = isl_vec_expand(aff->v, 1 + offset, old_n_div, exp, new_n_div);
+	aff->ls = isl_local_space_replace_divs(aff->ls, div);
+	if (!aff->v || !aff->ls)
+		return isl_aff_free(aff);
 	return aff;
 error:
 	isl_aff_free(aff);
@@ -1718,6 +1866,7 @@
 	isl_int_clear(gcd);
 
 	isl_aff_free(aff2);
+	aff1 = isl_aff_normalize(aff1);
 	return aff1;
 error:
 	isl_aff_free(aff1);
@@ -1725,6 +1874,15 @@
 	return NULL;
 }
 
+/* Replace one of the arguments by a NaN and free the other one.
+ */
+static __isl_give isl_aff *set_nan_free(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	isl_aff_free(aff2);
+	return isl_aff_set_nan(aff1);
+}
+
 /* Return the sum of "aff1" and "aff2".
  *
  * If either of the two is NaN, then the result is NaN.
@@ -1736,7 +1894,7 @@
 	int *exp1 = NULL;
 	int *exp2 = NULL;
 	isl_mat *div;
-	int n_div1, n_div2;
+	isl_size n_div1, n_div2;
 
 	if (!aff1 || !aff2)
 		goto error;
@@ -1757,6 +1915,8 @@
 
 	n_div1 = isl_aff_dim(aff1, isl_dim_div);
 	n_div2 = isl_aff_dim(aff2, isl_dim_div);
+	if (n_div1 < 0 || n_div2 < 0)
+		goto error;
 	if (n_div1 == 0 && n_div2 == 0)
 		return add_expanded(aff1, aff2);
 
@@ -1988,7 +2148,7 @@
 	aff = isl_aff_cow(aff);
 	if (!aff)
 		goto error;
-	if (type != isl_dim_out)
+	if (type != isl_dim_in)
 		isl_die(aff->v->ctx, isl_error_invalid,
 			"cannot only set id of input tuple", goto error);
 	aff->ls = isl_local_space_set_tuple_id(aff->ls, isl_dim_set, id);
@@ -2011,7 +2171,7 @@
 	__isl_take isl_aff *aff, __isl_take isl_basic_set *eq)
 {
 	int i, j;
-	unsigned total;
+	unsigned o_div;
 	unsigned n_div;
 
 	if (!eq)
@@ -2031,14 +2191,14 @@
 	if (!aff->ls || !aff->v)
 		goto error;
 
-	total = 1 + isl_space_dim(eq->dim, isl_dim_all);
+	o_div = isl_basic_set_offset(eq, isl_dim_div);
 	n_div = eq->n_div;
 	for (i = 0; i < eq->n_eq; ++i) {
-		j = isl_seq_last_non_zero(eq->eqi, total + n_div);
-		if (j < 0 || j == 0 || j >= total)
+		j = isl_seq_last_non_zero(eq->eqi, o_div + n_div);
+		if (j < 0 || j == 0 || j >= o_div)
 			continue;
 
-		isl_seq_elim(aff->v->el + 1, eq->eqi, j, total,
+		isl_seq_elim(aff->v->el + 1, eq->eqi, j, o_div,
 				&aff->v->el0);
 	}
 
@@ -2054,14 +2214,14 @@
 /* Exploit the equalities in "eq" to simplify the affine expression
  * and the expressions of the integer divisions in the local space.
  */
-static __isl_give isl_aff *isl_aff_substitute_equalities(
-	__isl_take isl_aff *aff, __isl_take isl_basic_set *eq)
+__isl_give isl_aff *isl_aff_substitute_equalities(__isl_take isl_aff *aff,
+	__isl_take isl_basic_set *eq)
 {
-	int n_div;
+	isl_size n_div;
 
-	if (!aff || !eq)
+	n_div = isl_aff_domain_dim(aff, isl_dim_div);
+	if (n_div < 0)
 		goto error;
-	n_div = isl_local_space_dim(aff->ls, isl_dim_div);
 	if (n_div > 0)
 		eq = isl_basic_set_add_dims(eq, isl_dim_set, n_div);
 	return isl_aff_substitute_equalities_lifted(aff, eq);
@@ -2079,30 +2239,14 @@
 __isl_give isl_aff *isl_aff_gist(__isl_take isl_aff *aff,
 	__isl_take isl_set *context)
 {
+	isl_local_space *ls;
 	isl_basic_set *hull;
-	int n_div;
 
-	if (!aff)
-		goto error;
-	n_div = isl_local_space_dim(aff->ls, isl_dim_div);
-	if (n_div > 0) {
-		isl_basic_set *bset;
-		isl_local_space *ls;
-		context = isl_set_add_dims(context, isl_dim_set, n_div);
-		ls = isl_aff_get_domain_local_space(aff);
-		bset = isl_basic_set_from_local_space(ls);
-		bset = isl_basic_set_lift(bset);
-		bset = isl_basic_set_flatten(bset);
-		context = isl_set_intersect(context,
-					    isl_set_from_basic_set(bset));
-	}
+	ls = isl_aff_get_domain_local_space(aff);
+	context = isl_local_space_lift_set(ls, context);
 
 	hull = isl_set_affine_hull(context);
 	return isl_aff_substitute_equalities_lifted(aff, hull);
-error:
-	isl_aff_free(aff);
-	isl_set_free(context);
-	return NULL;
 }
 
 __isl_give isl_aff *isl_aff_gist_params(__isl_take isl_aff *aff,
@@ -2114,13 +2258,49 @@
 }
 
 /* Return a basic set containing those elements in the space
+ * of aff where it is positive.  "rational" should not be set.
+ *
+ * If "aff" is NaN, then it is not positive.
+ */
+static __isl_give isl_basic_set *aff_pos_basic_set(__isl_take isl_aff *aff,
+	int rational, void *user)
+{
+	isl_constraint *ineq;
+	isl_basic_set *bset;
+	isl_val *c;
+
+	if (!aff)
+		return NULL;
+	if (isl_aff_is_nan(aff)) {
+		isl_space *space = isl_aff_get_domain_space(aff);
+		isl_aff_free(aff);
+		return isl_basic_set_empty(space);
+	}
+	if (rational)
+		isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
+			"rational sets not supported", goto error);
+
+	ineq = isl_inequality_from_aff(aff);
+	c = isl_constraint_get_constant_val(ineq);
+	c = isl_val_sub_ui(c, 1);
+	ineq = isl_constraint_set_constant_val(ineq, c);
+
+	bset = isl_basic_set_from_constraint(ineq);
+	bset = isl_basic_set_simplify(bset);
+	return bset;
+error:
+	isl_aff_free(aff);
+	return NULL;
+}
+
+/* Return a basic set containing those elements in the space
  * of aff where it is non-negative.
  * If "rational" is set, then return a rational basic set.
  *
  * If "aff" is NaN, then it is not non-negative (it's not negative either).
  */
 static __isl_give isl_basic_set *aff_nonneg_basic_set(
-	__isl_take isl_aff *aff, int rational)
+	__isl_take isl_aff *aff, int rational, void *user)
 {
 	isl_constraint *ineq;
 	isl_basic_set *bset;
@@ -2147,7 +2327,16 @@
  */
 __isl_give isl_basic_set *isl_aff_nonneg_basic_set(__isl_take isl_aff *aff)
 {
-	return aff_nonneg_basic_set(aff, 0);
+	return aff_nonneg_basic_set(aff, 0, NULL);
+}
+
+/* Return a basic set containing those elements in the domain space
+ * of "aff" where it is positive.
+ */
+__isl_give isl_basic_set *isl_aff_pos_basic_set(__isl_take isl_aff *aff)
+{
+	aff = isl_aff_add_constant_num_si(aff, -1);
+	return isl_aff_nonneg_basic_set(aff);
 }
 
 /* Return a basic set containing those elements in the domain space
@@ -2156,8 +2345,7 @@
 __isl_give isl_basic_set *isl_aff_neg_basic_set(__isl_take isl_aff *aff)
 {
 	aff = isl_aff_neg(aff);
-	aff = isl_aff_add_constant_num_si(aff, -1);
-	return isl_aff_nonneg_basic_set(aff);
+	return isl_aff_pos_basic_set(aff);
 }
 
 /* Return a basic set containing those elements in the space
@@ -2167,7 +2355,7 @@
  * If "aff" is NaN, then it is not zero.
  */
 static __isl_give isl_basic_set *aff_zero_basic_set(__isl_take isl_aff *aff,
-	int rational)
+	int rational, void *user)
 {
 	isl_constraint *ineq;
 	isl_basic_set *bset;
@@ -2194,7 +2382,7 @@
  */
 __isl_give isl_basic_set *isl_aff_zero_basic_set(__isl_take isl_aff *aff)
 {
-	return aff_zero_basic_set(aff, 0);
+	return aff_zero_basic_set(aff, 0, NULL);
 }
 
 /* Return a basic set containing those elements in the shared space
@@ -2208,6 +2396,38 @@
 	return isl_aff_nonneg_basic_set(aff1);
 }
 
+/* Return a basic set containing those elements in the shared domain space
+ * of "aff1" and "aff2" where "aff1" is greater than "aff2".
+ */
+__isl_give isl_basic_set *isl_aff_gt_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	aff1 = isl_aff_sub(aff1, aff2);
+
+	return isl_aff_pos_basic_set(aff1);
+}
+
+/* Return a set containing those elements in the shared space
+ * of aff1 and aff2 where aff1 is greater than or equal to aff2.
+ */
+__isl_give isl_set *isl_aff_ge_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_set_from_basic_set(isl_aff_ge_basic_set(aff1, aff2));
+}
+
+/* Return a set containing those elements in the shared domain space
+ * of aff1 and aff2 where aff1 is greater than aff2.
+ *
+ * If either of the two inputs is NaN, then the result is empty,
+ * as comparisons with NaN always return false.
+ */
+__isl_give isl_set *isl_aff_gt_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_set_from_basic_set(isl_aff_gt_basic_set(aff1, aff2));
+}
+
 /* Return a basic set containing those elements in the shared space
  * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
  */
@@ -2217,6 +2437,70 @@
 	return isl_aff_ge_basic_set(aff2, aff1);
 }
 
+/* Return a basic set containing those elements in the shared domain space
+ * of "aff1" and "aff2" where "aff1" is smaller than "aff2".
+ */
+__isl_give isl_basic_set *isl_aff_lt_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_aff_gt_basic_set(aff2, aff1);
+}
+
+/* Return a set containing those elements in the shared space
+ * of aff1 and aff2 where aff1 is smaller than or equal to aff2.
+ */
+__isl_give isl_set *isl_aff_le_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_aff_ge_set(aff2, aff1);
+}
+
+/* Return a set containing those elements in the shared domain space
+ * of "aff1" and "aff2" where "aff1" is smaller than "aff2".
+ */
+__isl_give isl_set *isl_aff_lt_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_set_from_basic_set(isl_aff_lt_basic_set(aff1, aff2));
+}
+
+/* Return a basic set containing those elements in the shared space
+ * of aff1 and aff2 where aff1 and aff2 are equal.
+ */
+__isl_give isl_basic_set *isl_aff_eq_basic_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	aff1 = isl_aff_sub(aff1, aff2);
+
+	return isl_aff_zero_basic_set(aff1);
+}
+
+/* Return a set containing those elements in the shared space
+ * of aff1 and aff2 where aff1 and aff2 are equal.
+ */
+__isl_give isl_set *isl_aff_eq_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	return isl_set_from_basic_set(isl_aff_eq_basic_set(aff1, aff2));
+}
+
+/* Return a set containing those elements in the shared domain space
+ * of aff1 and aff2 where aff1 and aff2 are not equal.
+ *
+ * If either of the two inputs is NaN, then the result is empty,
+ * as comparisons with NaN always return false.
+ */
+__isl_give isl_set *isl_aff_ne_set(__isl_take isl_aff *aff1,
+	__isl_take isl_aff *aff2)
+{
+	isl_set *set_lt, *set_gt;
+
+	set_lt = isl_aff_lt_set(isl_aff_copy(aff1),
+				isl_aff_copy(aff2));
+	set_gt = isl_aff_gt_set(aff1, aff2);
+	return isl_set_union_disjoint(set_lt, set_gt);
+}
+
 __isl_give isl_aff *isl_aff_add_on_domain(__isl_keep isl_set *dom,
 	__isl_take isl_aff *aff1, __isl_take isl_aff *aff2)
 {
@@ -2225,36 +2509,37 @@
 	return aff1;
 }
 
-int isl_aff_is_empty(__isl_keep isl_aff *aff)
+isl_bool isl_aff_is_empty(__isl_keep isl_aff *aff)
 {
 	if (!aff)
-		return -1;
+		return isl_bool_error;
 
-	return 0;
+	return isl_bool_false;
 }
 
+#undef TYPE
+#define TYPE	isl_aff
+static
+#include "check_type_range_templ.c"
+
 /* Check whether the given affine expression has non-zero coefficient
  * for any dimension in the given range or if any of these dimensions
  * appear with non-zero coefficients in any of the integer divisions
  * involved in the affine expression.
  */
-int isl_aff_involves_dims(__isl_keep isl_aff *aff,
+isl_bool isl_aff_involves_dims(__isl_keep isl_aff *aff,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
-	isl_ctx *ctx;
 	int *active = NULL;
-	int involves = 0;
+	isl_bool involves = isl_bool_false;
 
 	if (!aff)
-		return -1;
+		return isl_bool_error;
 	if (n == 0)
-		return 0;
-
-	ctx = isl_aff_get_ctx(aff);
-	if (first + n > isl_aff_dim(aff, type))
-		isl_die(ctx, isl_error_invalid,
-			"range out of bounds", return -1);
+		return isl_bool_false;
+	if (isl_aff_check_range(aff, type, first, n) < 0)
+		return isl_bool_error;
 
 	active = isl_local_space_get_active(aff->ls, aff->v->el + 2);
 	if (!active)
@@ -2263,7 +2548,7 @@
 	first += isl_local_space_offset(aff->ls, type) - 1;
 	for (i = 0; i < n; ++i)
 		if (activefirst + i) {
-			involves = 1;
+			involves = isl_bool_true;
 			break;
 		}
 
@@ -2272,7 +2557,19 @@
 	return involves;
 error:
 	free(active);
-	return -1;
+	return isl_bool_error;
+}
+
+/* Does "aff" involve any local variables, i.e., integer divisions?
+ */
+isl_bool isl_aff_involves_locals(__isl_keep isl_aff *aff)
+{
+	isl_size n;
+
+	n = isl_aff_dim(aff, isl_dim_div);
+	if (n < 0)
+		return isl_bool_error;
+	return isl_bool_ok(n > 0);
 }
 
 __isl_give isl_aff *isl_aff_drop_dims(__isl_take isl_aff *aff,
@@ -2292,9 +2589,8 @@
 		return aff;
 
 	ctx = isl_aff_get_ctx(aff);
-	if (first + n > isl_local_space_dim(aff->ls, type))
-		isl_die(ctx, isl_error_invalid, "range out of bounds",
-			return isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, type, first, n) < 0)
+		return isl_aff_free(aff);
 
 	aff = isl_aff_cow(aff);
 	if (!aff)
@@ -2312,30 +2608,49 @@
 	return aff;
 }
 
+/* Is the domain of "aff" a product?
+ */
+static isl_bool isl_aff_domain_is_product(__isl_keep isl_aff *aff)
+{
+	return isl_space_is_product(isl_aff_peek_domain_space(aff));
+}
+
+#undef TYPE
+#define TYPE	isl_aff
+#include <isl_domain_factor_templ.c>
+
 /* Project the domain of the affine expression onto its parameter space.
  * The affine expression may not involve any of the domain dimensions.
  */
 __isl_give isl_aff *isl_aff_project_domain_on_params(__isl_take isl_aff *aff)
 {
 	isl_space *space;
-	unsigned n;
-	int involves;
+	isl_size n;
 
 	n = isl_aff_dim(aff, isl_dim_in);
-	involves = isl_aff_involves_dims(aff, isl_dim_in, 0, n);
-	if (involves < 0)
+	if (n < 0)
 		return isl_aff_free(aff);
-	if (involves)
-		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-		    "affine expression involves some of the domain dimensions",
-		    return isl_aff_free(aff));
-	aff = isl_aff_drop_dims(aff, isl_dim_in, 0, n);
+	aff = isl_aff_drop_domain(aff, 0, n);
 	space = isl_aff_get_domain_space(aff);
 	space = isl_space_params(space);
 	aff = isl_aff_reset_domain_space(aff, space);
 	return aff;
 }
 
+/* Convert an affine expression defined over a parameter domain
+ * into one that is defined over a zero-dimensional set.
+ */
+__isl_give isl_aff *isl_aff_from_range(__isl_take isl_aff *aff)
+{
+	isl_local_space *ls;
+
+	ls = isl_aff_take_domain_local_space(aff);
+	ls = isl_local_space_set_from_params(ls);
+	aff = isl_aff_restore_domain_local_space(aff, ls);
+
+	return aff;
+}
+
 __isl_give isl_aff *isl_aff_insert_dims(__isl_take isl_aff *aff,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
@@ -2353,9 +2668,8 @@
 		return aff;
 
 	ctx = isl_aff_get_ctx(aff);
-	if (first > isl_local_space_dim(aff->ls, type))
-		isl_die(ctx, isl_error_invalid, "position out of bounds",
-			return isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, type, first, 0) < 0)
+		return isl_aff_free(aff);
 
 	aff = isl_aff_cow(aff);
 	if (!aff)
@@ -2376,23 +2690,15 @@
 __isl_give isl_aff *isl_aff_add_dims(__isl_take isl_aff *aff,
 	enum isl_dim_type type, unsigned n)
 {
-	unsigned pos;
+	isl_size pos;
 
 	pos = isl_aff_dim(aff, type);
+	if (pos < 0)
+		return isl_aff_free(aff);
 
 	return isl_aff_insert_dims(aff, type, pos, n);
 }
 
-__isl_give isl_pw_aff *isl_pw_aff_add_dims(__isl_take isl_pw_aff *pwaff,
-	enum isl_dim_type type, unsigned n)
-{
-	unsigned pos;
-
-	pos = isl_pw_aff_dim(pwaff, type);
-
-	return isl_pw_aff_insert_dims(pwaff, type, pos, n);
-}
-
 /* Move the "n" dimensions of "src_type" starting at "src_pos" of "aff"
  * to dimensions of "dst_type" at "dst_pos".
  *
@@ -2404,6 +2710,7 @@
 {
 	unsigned g_dst_pos;
 	unsigned g_src_pos;
+	isl_size src_off, dst_off;
 
 	if (!aff)
 		return NULL;
@@ -2414,29 +2721,31 @@
 
 	if (dst_type == isl_dim_out || src_type == isl_dim_out)
 		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"cannot move output/set dimension", isl_aff_free(aff));
+			"cannot move output/set dimension",
+			return isl_aff_free(aff));
 	if (dst_type == isl_dim_div || src_type == isl_dim_div)
 		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"cannot move divs", isl_aff_free(aff));
+			"cannot move divs", return isl_aff_free(aff));
 	if (dst_type == isl_dim_in)
 		dst_type = isl_dim_set;
 	if (src_type == isl_dim_in)
 		src_type = isl_dim_set;
 
-	if (src_pos + n > isl_local_space_dim(aff->ls, src_type))
-		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
-			"range out of bounds", isl_aff_free(aff));
+	if (isl_local_space_check_range(aff->ls, src_type, src_pos, n) < 0)
+		return isl_aff_free(aff);
 	if (dst_type == src_type)
 		isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
 			"moving dims within the same type not supported",
-			isl_aff_free(aff));
+			return isl_aff_free(aff));
 
 	aff = isl_aff_cow(aff);
-	if (!aff)
-		return NULL;
+	src_off = isl_aff_domain_offset(aff, src_type);
+	dst_off = isl_aff_domain_offset(aff, dst_type);
+	if (src_off < 0 || dst_off < 0)
+		return isl_aff_free(aff);
 
-	g_src_pos = 1 + isl_local_space_offset(aff->ls, src_type) + src_pos;
-	g_dst_pos = 1 + isl_local_space_offset(aff->ls, dst_type) + dst_pos;
+	g_src_pos = 1 + src_off + src_pos;
+	g_dst_pos = 1 + dst_off + dst_pos;
 	if (dst_type > src_type)
 		g_dst_pos -= n;
 
@@ -2451,16 +2760,25 @@
 	return aff;
 }
 
-__isl_give isl_pw_aff *isl_pw_aff_from_aff(__isl_take isl_aff *aff)
+/* Return a zero isl_aff in the given space.
+ *
+ * This is a helper function for isl_pw_*_as_* that ensures a uniform
+ * interface over all piecewise types.
+ */
+static __isl_give isl_aff *isl_aff_zero_in_space(__isl_take isl_space *space)
 {
-	isl_set *dom = isl_set_universe(isl_aff_get_domain_space(aff));
-	return isl_pw_aff_alloc(dom, aff);
+	isl_local_space *ls;
+
+	ls = isl_local_space_from_space(isl_space_domain(space));
+	return isl_aff_zero_on_domain(ls);
 }
 
+#define isl_aff_involves_nan isl_aff_is_nan
+
 #undef PW
 #define PW isl_pw_aff
-#undef EL
-#define EL isl_aff
+#undef BASE
+#define BASE aff
 #undef EL_IS_ZERO
 #define EL_IS_ZERO is_empty
 #undef ZERO
@@ -2472,118 +2790,29 @@
 #undef DEFAULT_IS_ZERO
 #define DEFAULT_IS_ZERO 0
 
-#define NO_EVAL
-#define NO_OPT
-#define NO_LIFT
-#define NO_MORPH
-
 #include <isl_pw_templ.c>
+#include <isl_pw_add_constant_val_templ.c>
+#include <isl_pw_bind_domain_templ.c>
+#include <isl_pw_eval.c>
+#include <isl_pw_hash.c>
+#include <isl_pw_insert_dims_templ.c>
+#include <isl_pw_insert_domain_templ.c>
+#include <isl_pw_move_dims_templ.c>
+#include <isl_pw_neg_templ.c>
+#include <isl_pw_pullback_templ.c>
+#include <isl_pw_sub_templ.c>
+#include <isl_pw_union_opt.c>
 
-static __isl_give isl_set *align_params_pw_pw_set_and(
-	__isl_take isl_pw_aff *pwaff1, __isl_take isl_pw_aff *pwaff2,
-	__isl_give isl_set *(*fn)(__isl_take isl_pw_aff *pwaff1,
-				    __isl_take isl_pw_aff *pwaff2))
-{
-	if (!pwaff1 || !pwaff2)
-		goto error;
-	if (isl_space_match(pwaff1->dim, isl_dim_param,
-			  pwaff2->dim, isl_dim_param))
-		return fn(pwaff1, pwaff2);
-	if (!isl_space_has_named_params(pwaff1->dim) ||
-	    !isl_space_has_named_params(pwaff2->dim))
-		isl_die(isl_pw_aff_get_ctx(pwaff1), isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	pwaff1 = isl_pw_aff_align_params(pwaff1, isl_pw_aff_get_space(pwaff2));
-	pwaff2 = isl_pw_aff_align_params(pwaff2, isl_pw_aff_get_space(pwaff1));
-	return fn(pwaff1, pwaff2);
-error:
-	isl_pw_aff_free(pwaff1);
-	isl_pw_aff_free(pwaff2);
-	return NULL;
-}
-
-/* Compute a piecewise quasi-affine expression with a domain that
- * is the union of those of pwaff1 and pwaff2 and such that on each
- * cell, the quasi-affine expression is the better (according to cmp)
- * of those of pwaff1 and pwaff2.  If only one of pwaff1 or pwaff2
- * is defined on a given cell, then the associated expression
- * is the defined one.
- */
-static __isl_give isl_pw_aff *pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2,
-	__isl_give isl_basic_set *(*cmp)(__isl_take isl_aff *aff1,
-					__isl_take isl_aff *aff2))
-{
-	int i, j, n;
-	isl_pw_aff *res;
-	isl_ctx *ctx;
-	isl_set *set;
-
-	if (!pwaff1 || !pwaff2)
-		goto error;
-
-	ctx = isl_space_get_ctx(pwaff1->dim);
-	if (!isl_space_is_equal(pwaff1->dim, pwaff2->dim))
-		isl_die(ctx, isl_error_invalid,
-			"arguments should live in same space", goto error);
-
-	if (isl_pw_aff_is_empty(pwaff1)) {
-		isl_pw_aff_free(pwaff1);
-		return pwaff2;
-	}
-
-	if (isl_pw_aff_is_empty(pwaff2)) {
-		isl_pw_aff_free(pwaff2);
-		return pwaff1;
-	}
-
-	n = 2 * (pwaff1->n + 1) * (pwaff2->n + 1);
-	res = isl_pw_aff_alloc_size(isl_space_copy(pwaff1->dim), n);
-
-	for (i = 0; i < pwaff1->n; ++i) {
-		set = isl_set_copy(pwaff1->pi.set);
-		for (j = 0; j < pwaff2->n; ++j) {
-			struct isl_set *common;
-			isl_set *better;
-
-			common = isl_set_intersect(
-					isl_set_copy(pwaff1->pi.set),
-					isl_set_copy(pwaff2->pj.set));
-			better = isl_set_from_basic_set(cmp(
-					isl_aff_copy(pwaff2->pj.aff),
-					isl_aff_copy(pwaff1->pi.aff)));
-			better = isl_set_intersect(common, better);
-			if (isl_set_plain_is_empty(better)) {
-				isl_set_free(better);
-				continue;
-			}
-			set = isl_set_subtract(set, isl_set_copy(better));
-
-			res = isl_pw_aff_add_piece(res, better,
-						isl_aff_copy(pwaff2->pj.aff));
-		}
-		res = isl_pw_aff_add_piece(res, set,
-						isl_aff_copy(pwaff1->pi.aff));
-	}
+#undef BASE
+#define BASE pw_aff
 
-	for (j = 0; j < pwaff2->n; ++j) {
-		set = isl_set_copy(pwaff2->pj.set);
-		for (i = 0; i < pwaff1->n; ++i)
-			set = isl_set_subtract(set,
-					isl_set_copy(pwaff1->pi.set));
-		res = isl_pw_aff_add_piece(res, set,
-						isl_aff_copy(pwaff2->pj.aff));
-	}
+#include <isl_union_single.c>
+#include <isl_union_neg.c>
 
-	isl_pw_aff_free(pwaff1);
-	isl_pw_aff_free(pwaff2);
+#undef BASE
+#define BASE aff
 
-	return res;
-error:
-	isl_pw_aff_free(pwaff1);
-	isl_pw_aff_free(pwaff2);
-	return NULL;
-}
+#include <isl_union_pw_templ.c>
 
 /* Compute a piecewise quasi-affine expression with a domain that
  * is the union of those of pwaff1 and pwaff2 and such that on each
@@ -2591,17 +2820,11 @@
  * and pwaff2.  If only one of pwaff1 or pwaff2 is defined on a given
  * cell, then the associated expression is the defined one.
  */
-static __isl_give isl_pw_aff *pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return pw_aff_union_opt(pwaff1, pwaff2, &isl_aff_ge_basic_set);
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_union_max(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2,
-							&pw_aff_union_max);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return isl_pw_aff_union_opt_cmp(pwaff1, pwaff2, &isl_aff_ge_set);
 }
 
 /* Compute a piecewise quasi-affine expression with a domain that
@@ -2610,17 +2833,11 @@
  * and pwaff2.  If only one of pwaff1 or pwaff2 is defined on a given
  * cell, then the associated expression is the defined one.
  */
-static __isl_give isl_pw_aff *pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return pw_aff_union_opt(pwaff1, pwaff2, &isl_aff_le_basic_set);
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_union_min(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2,
-							&pw_aff_union_min);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return isl_pw_aff_union_opt_cmp(pwaff1, pwaff2, &isl_aff_le_set);
 }
 
 __isl_give isl_pw_aff *isl_pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
@@ -2632,110 +2849,28 @@
 		return isl_pw_aff_union_min(pwaff1, pwaff2);
 }
 
-/* Construct a map with as domain the domain of pwaff and
- * one-dimensional range corresponding to the affine expressions.
+/* Is the domain of "pa" a product?
  */
-static __isl_give isl_map *map_from_pw_aff(__isl_take isl_pw_aff *pwaff)
+static isl_bool isl_pw_aff_domain_is_product(__isl_keep isl_pw_aff *pa)
 {
-	int i;
-	isl_space *dim;
-	isl_map *map;
-
-	if (!pwaff)
-		return NULL;
-
-	dim = isl_pw_aff_get_space(pwaff);
-	map = isl_map_empty(dim);
-
-	for (i = 0; i < pwaff->n; ++i) {
-		isl_basic_map *bmap;
-		isl_map *map_i;
-
-		bmap = isl_basic_map_from_aff(isl_aff_copy(pwaff->pi.aff));
-		map_i = isl_map_from_basic_map(bmap);
-		map_i = isl_map_intersect_domain(map_i,
-						isl_set_copy(pwaff->pi.set));
-		map = isl_map_union_disjoint(map, map_i);
-	}
-
-	isl_pw_aff_free(pwaff);
-
-	return map;
+	return isl_space_domain_is_wrapping(isl_pw_aff_peek_space(pa));
 }
 
-/* Construct a map with as domain the domain of pwaff and
- * one-dimensional range corresponding to the affine expressions.
- */
-__isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff)
-{
-	if (!pwaff)
-		return NULL;
-	if (isl_space_is_set(pwaff->dim))
-		isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
-			"space of input is not a map", goto error);
-	return map_from_pw_aff(pwaff);
-error:
-	isl_pw_aff_free(pwaff);
-	return NULL;
-}
-
-/* Construct a one-dimensional set with as parameter domain
- * the domain of pwaff and the single set dimension
- * corresponding to the affine expressions.
- */
-__isl_give isl_set *isl_set_from_pw_aff(__isl_take isl_pw_aff *pwaff)
-{
-	if (!pwaff)
-		return NULL;
-	if (!isl_space_is_set(pwaff->dim))
-		isl_die(isl_pw_aff_get_ctx(pwaff), isl_error_invalid,
-			"space of input is not a set", goto error);
-	return map_from_pw_aff(pwaff);
-error:
-	isl_pw_aff_free(pwaff);
-	return NULL;
-}
-
-/* Return a set containing those elements in the domain
- * of pwaff where it is non-negative.
- */
-__isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff)
-{
-	int i;
-	isl_set *set;
-
-	if (!pwaff)
-		return NULL;
-
-	set = isl_set_empty(isl_pw_aff_get_domain_space(pwaff));
-
-	for (i = 0; i < pwaff->n; ++i) {
-		isl_basic_set *bset;
-		isl_set *set_i;
-		int rational;
-
-		rational = isl_set_has_rational(pwaff->pi.set);
-		bset = aff_nonneg_basic_set(isl_aff_copy(pwaff->pi.aff),
-						rational);
-		set_i = isl_set_from_basic_set(bset);
-		set_i = isl_set_intersect(set_i, isl_set_copy(pwaff->pi.set));
-		set = isl_set_union_disjoint(set, set_i);
-	}
-
-	isl_pw_aff_free(pwaff);
-
-	return set;
-}
+#undef TYPE
+#define TYPE	isl_pw_aff
+#include <isl_domain_factor_templ.c>
 
 /* Return a set containing those elements in the domain
- * of pwaff where it is zero (if complement is 0) or not zero
- * (if complement is 1).
+ * of "pwaff" where it satisfies "fn" (if complement is 0) or
+ * does not satisfy "fn" (if complement is 1).
  *
  * The pieces with a NaN never belong to the result since
- * NaN is neither zero nor non-zero.
+ * NaN does not satisfy any property.
  */
-static __isl_give isl_set *pw_aff_zero_set(__isl_take isl_pw_aff *pwaff,
-	int complement)
+static __isl_give isl_set *pw_aff_locus(__isl_take isl_pw_aff *pwaff,
+	__isl_give isl_basic_set *(*fn)(__isl_take isl_aff *aff, int rational,
+		void *user),
+	int complement, void *user)
 {
 	int i;
 	isl_set *set;
@@ -2747,21 +2882,20 @@
 
 	for (i = 0; i < pwaff->n; ++i) {
 		isl_basic_set *bset;
-		isl_set *set_i, *zero;
-		int rational;
+		isl_set *set_i, *locus;
+		isl_bool rational;
 
 		if (isl_aff_is_nan(pwaff->pi.aff))
 			continue;
 
 		rational = isl_set_has_rational(pwaff->pi.set);
-		bset = aff_zero_basic_set(isl_aff_copy(pwaff->pi.aff),
-						rational);
-		zero = isl_set_from_basic_set(bset);
+		bset = fn(isl_aff_copy(pwaff->pi.aff), rational, user);
+		locus = isl_set_from_basic_set(bset);
 		set_i = isl_set_copy(pwaff->pi.set);
 		if (complement)
-			set_i = isl_set_subtract(set_i, zero);
+			set_i = isl_set_subtract(set_i, locus);
 		else
-			set_i = isl_set_intersect(set_i, zero);
+			set_i = isl_set_intersect(set_i, locus);
 		set = isl_set_union_disjoint(set, set_i);
 	}
 
@@ -2771,11 +2905,27 @@
 }
 
 /* Return a set containing those elements in the domain
+ * of "pa" where it is positive.
+ */
+__isl_give isl_set *isl_pw_aff_pos_set(__isl_take isl_pw_aff *pa)
+{
+	return pw_aff_locus(pa, &aff_pos_basic_set, 0, NULL);
+}
+
+/* Return a set containing those elements in the domain
+ * of pwaff where it is non-negative.
+ */
+__isl_give isl_set *isl_pw_aff_nonneg_set(__isl_take isl_pw_aff *pwaff)
+{
+	return pw_aff_locus(pwaff, &aff_nonneg_basic_set, 0, NULL);
+}
+
+/* Return a set containing those elements in the domain
  * of pwaff where it is zero.
  */
 __isl_give isl_set *isl_pw_aff_zero_set(__isl_take isl_pw_aff *pwaff)
 {
-	return pw_aff_zero_set(pwaff, 0);
+	return pw_aff_locus(pwaff, &aff_zero_basic_set, 0, NULL);
 }
 
 /* Return a set containing those elements in the domain
@@ -2783,7 +2933,60 @@
  */
 __isl_give isl_set *isl_pw_aff_non_zero_set(__isl_take isl_pw_aff *pwaff)
 {
-	return pw_aff_zero_set(pwaff, 1);
+	return pw_aff_locus(pwaff, &aff_zero_basic_set, 1, NULL);
+}
+
+/* Bind the affine function "aff" to the parameter "id",
+ * returning the elements in the domain where the affine expression
+ * is equal to the parameter.
+ */
+__isl_give isl_basic_set *isl_aff_bind_id(__isl_take isl_aff *aff,
+	__isl_take isl_id *id)
+{
+	isl_space *space;
+	isl_aff *aff_id;
+
+	space = isl_aff_get_domain_space(aff);
+	space = isl_space_add_param_id(space, isl_id_copy(id));
+
+	aff = isl_aff_align_params(aff, isl_space_copy(space));
+	aff_id = isl_aff_param_on_domain_space_id(space, id);
+
+	return isl_aff_eq_basic_set(aff, aff_id);
+}
+
+/* Wrapper around isl_aff_bind_id for use as pw_aff_locus callback.
+ * "rational" should not be set.
+ */
+static __isl_give isl_basic_set *aff_bind_id(__isl_take isl_aff *aff,
+	int rational, void *user)
+{
+	isl_id *id = user;
+
+	if (!aff)
+		return NULL;
+	if (rational)
+		isl_die(isl_aff_get_ctx(aff), isl_error_unsupported,
+			"rational binding not supported", goto error);
+	return isl_aff_bind_id(aff, isl_id_copy(id));
+error:
+	isl_aff_free(aff);
+	return NULL;
+}
+
+/* Bind the piecewise affine function "pa" to the parameter "id",
+ * returning the elements in the domain where the expression
+ * is equal to the parameter.
+ */
+__isl_give isl_set *isl_pw_aff_bind_id(__isl_take isl_pw_aff *pa,
+	__isl_take isl_id *id)
+{
+	isl_set *bound;
+
+	bound = pw_aff_locus(pa, &aff_bind_id, 0, id);
+	isl_id_free(id);
+
+	return bound;
 }
 
 /* Return a set containing those elements in the shared domain
@@ -2808,9 +3011,9 @@
 	pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_neg(pwaff2));
 
 	if (strict) {
-		isl_space *dim = isl_set_get_space(set1);
+		isl_space *space = isl_set_get_space(set1);
 		isl_aff *aff;
-		aff = isl_aff_zero_on_domain(isl_local_space_from_space(dim));
+		aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
 		aff = isl_aff_add_constant_si(aff, -1);
 		pwaff1 = isl_pw_aff_add(pwaff1, isl_pw_aff_alloc(set1, aff));
 	} else
@@ -2824,46 +3027,31 @@
 /* Return a set containing those elements in the shared domain
  * of pwaff1 and pwaff2 where pwaff1 is equal to pwaff2.
  */
-static __isl_give isl_set *pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return pw_aff_gte_set(pwaff1, pwaff2, 0, 1);
-}
-
 __isl_give isl_set *isl_pw_aff_eq_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_eq_set);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return pw_aff_gte_set(pwaff1, pwaff2, 0, 1);
 }
 
 /* Return a set containing those elements in the shared domain
  * of pwaff1 and pwaff2 where pwaff1 is greater than or equal to pwaff2.
  */
-static __isl_give isl_set *pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return pw_aff_gte_set(pwaff1, pwaff2, 0, 0);
-}
-
 __isl_give isl_set *isl_pw_aff_ge_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_ge_set);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return pw_aff_gte_set(pwaff1, pwaff2, 0, 0);
 }
 
 /* Return a set containing those elements in the shared domain
  * of pwaff1 and pwaff2 where pwaff1 is strictly greater than pwaff2.
  */
-static __isl_give isl_set *pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return pw_aff_gte_set(pwaff1, pwaff2, 1, 0);
-}
-
 __isl_give isl_set *isl_pw_aff_gt_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_gt_set);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return pw_aff_gte_set(pwaff1, pwaff2, 1, 0);
 }
 
 __isl_give isl_set *isl_pw_aff_le_set(__isl_take isl_pw_aff *pwaff1,
@@ -2878,6 +3066,86 @@
 	return isl_pw_aff_gt_set(pwaff2, pwaff1);
 }
 
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function values are ordered in the same way as "order",
+ * which returns a set in the shared domain of its two arguments.
+ *
+ * Let "pa1" and "pa2" be defined on domains A and B respectively.
+ * We first pull back the two functions such that they are defined on
+ * the domain A -> B.  Then we apply "order", resulting in a set
+ * in the space A -> B.  Finally, we unwrap this set to obtain
+ * a map in the space A -> B.
+ */
+static __isl_give isl_map *isl_pw_aff_order_map(
+	__isl_take isl_pw_aff *pa1, __isl_take isl_pw_aff *pa2,
+	__isl_give isl_set *(*order)(__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2))
+{
+	isl_space *space1, *space2;
+	isl_multi_aff *ma;
+	isl_set *set;
+
+	isl_pw_aff_align_params_bin(&pa1, &pa2);
+	space1 = isl_space_domain(isl_pw_aff_get_space(pa1));
+	space2 = isl_space_domain(isl_pw_aff_get_space(pa2));
+	space1 = isl_space_map_from_domain_and_range(space1, space2);
+	ma = isl_multi_aff_domain_map(isl_space_copy(space1));
+	pa1 = isl_pw_aff_pullback_multi_aff(pa1, ma);
+	ma = isl_multi_aff_range_map(space1);
+	pa2 = isl_pw_aff_pullback_multi_aff(pa2, ma);
+	set = order(pa1, pa2);
+
+	return isl_set_unwrap(set);
+}
+
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function values are equal.
+ */
+__isl_give isl_map *isl_pw_aff_eq_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	return isl_pw_aff_order_map(pa1, pa2, &isl_pw_aff_eq_set);
+}
+
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function value of "pa1" is less than or equal to
+ * the function value of "pa2".
+ */
+__isl_give isl_map *isl_pw_aff_le_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	return isl_pw_aff_order_map(pa1, pa2, &isl_pw_aff_le_set);
+}
+
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function value of "pa1" is less than the function value of "pa2".
+ */
+__isl_give isl_map *isl_pw_aff_lt_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	return isl_pw_aff_order_map(pa1, pa2, &isl_pw_aff_lt_set);
+}
+
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function value of "pa1" is greater than or equal to
+ * the function value of "pa2".
+ */
+__isl_give isl_map *isl_pw_aff_ge_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	return isl_pw_aff_order_map(pa1, pa2, &isl_pw_aff_ge_set);
+}
+
+/* Return a map containing pairs of elements in the domains of "pa1" and "pa2"
+ * where the function value of "pa1" is greater than the function value
+ * of "pa2".
+ */
+__isl_give isl_map *isl_pw_aff_gt_map(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	return isl_pw_aff_order_map(pa1, pa2, &isl_pw_aff_gt_set);
+}
+
 /* Return a set containing those elements in the shared domain
  * of the elements of list1 and list2 where each element in list1
  * has the relation specified by "fn" with each element in list2.
@@ -2966,23 +3234,18 @@
 /* Return a set containing those elements in the shared domain
  * of pwaff1 and pwaff2 where pwaff1 is not equal to pwaff2.
  */
-static __isl_give isl_set *pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
+__isl_give isl_set *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
 	isl_set *set_lt, *set_gt;
 
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
 	set_lt = isl_pw_aff_lt_set(isl_pw_aff_copy(pwaff1),
 				   isl_pw_aff_copy(pwaff2));
 	set_gt = isl_pw_aff_gt_set(pwaff1, pwaff2);
 	return isl_set_union_disjoint(set_lt, set_gt);
 }
 
-__isl_give isl_set *isl_pw_aff_ne_set(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return align_params_pw_pw_set_and(pwaff1, pwaff2, &pw_aff_ne_set);
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_scale_down(__isl_take isl_pw_aff *pwaff,
 	isl_int v)
 {
@@ -3009,49 +3272,6 @@
 	return pwaff;
 }
 
-/* Divide "pa" by "f".
- */
-__isl_give isl_pw_aff *isl_pw_aff_scale_down_val(__isl_take isl_pw_aff *pa,
-	__isl_take isl_val *f)
-{
-	int i;
-
-	if (!pa || !f)
-		goto error;
-
-	if (isl_val_is_one(f)) {
-		isl_val_free(f);
-		return pa;
-	}
-
-	if (!isl_val_is_rat(f))
-		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
-			"expecting rational factor", goto error);
-	if (!isl_val_is_pos(f))
-		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
-			"factor needs to be positive", goto error);
-
-	pa = isl_pw_aff_cow(pa);
-	if (!pa)
-		return NULL;
-	if (pa->n == 0)
-		return pa;
-
-	for (i = 0; i < pa->n; ++i) {
-		pa->pi.aff = isl_aff_scale_down_val(pa->pi.aff,
-							isl_val_copy(f));
-		if (!pa->pi.aff)
-			goto error;
-	}
-
-	isl_val_free(f);
-	return pa;
-error:
-	isl_pw_aff_free(pa);
-	isl_val_free(f);
-	return NULL;
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_floor(__isl_take isl_pw_aff *pwaff)
 {
 	int i;
@@ -3112,11 +3332,15 @@
  * If "cond" involves and NaN, then we conservatively return a NaN
  * on its entire domain.  In principle, we could consider the pieces
  * where it is NaN separately from those where it is not.
+ *
+ * If "pwaff_true" and "pwaff_false" are obviously equal to each other,
+ * then only use the domain of "cond" to restrict the domain.
  */
 __isl_give isl_pw_aff *isl_pw_aff_cond(__isl_take isl_pw_aff *cond,
 	__isl_take isl_pw_aff *pwaff_true, __isl_take isl_pw_aff *pwaff_false)
 {
 	isl_set *cond_true, *cond_false;
+	isl_bool equal;
 
 	if (!cond)
 		goto error;
@@ -3129,6 +3353,21 @@
 		return isl_pw_aff_nan_on_domain(ls);
 	}
 
+	pwaff_true = isl_pw_aff_align_params(pwaff_true,
+					    isl_pw_aff_get_space(pwaff_false));
+	pwaff_false = isl_pw_aff_align_params(pwaff_false,
+					    isl_pw_aff_get_space(pwaff_true));
+	equal = isl_pw_aff_plain_is_equal(pwaff_true, pwaff_false);
+	if (equal < 0)
+		goto error;
+	if (equal) {
+		isl_set *dom;
+
+		dom = isl_set_coalesce(isl_pw_aff_domain(cond));
+		isl_pw_aff_free(pwaff_false);
+		return isl_pw_aff_intersect_domain(pwaff_true, dom);
+	}
+
 	cond_true = isl_pw_aff_non_zero_set(isl_pw_aff_copy(cond));
 	cond_false = isl_pw_aff_zero_set(cond);
 	return isl_pw_aff_select(cond_true, pwaff_true,
@@ -3140,30 +3379,33 @@
 	return NULL;
 }
 
-int isl_aff_is_cst(__isl_keep isl_aff *aff)
+isl_bool isl_aff_is_cst(__isl_keep isl_aff *aff)
 {
+	int pos;
+
 	if (!aff)
-		return -1;
+		return isl_bool_error;
 
-	return isl_seq_first_non_zero(aff->v->el + 2, aff->v->size - 2) == -1;
+	pos = isl_seq_first_non_zero(aff->v->el + 2, aff->v->size - 2);
+	return isl_bool_ok(pos == -1);
 }
 
 /* Check whether pwaff is a piecewise constant.
  */
-int isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff)
+isl_bool isl_pw_aff_is_cst(__isl_keep isl_pw_aff *pwaff)
 {
 	int i;
 
 	if (!pwaff)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < pwaff->n; ++i) {
-		int is_cst = isl_aff_is_cst(pwaff->pi.aff);
+		isl_bool is_cst = isl_aff_is_cst(pwaff->pi.aff);
 		if (is_cst < 0 || !is_cst)
 			return is_cst;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Return the product of "aff1" and "aff2".
@@ -3213,11 +3455,12 @@
 /* Divide "aff1" by "aff2", assuming "aff2" is a constant.
  *
  * If either of the two is NaN, then the result is NaN.
+ * A division by zero also results in NaN.
  */
 __isl_give isl_aff *isl_aff_div(__isl_take isl_aff *aff1,
 	__isl_take isl_aff *aff2)
 {
-	int is_cst;
+	isl_bool is_cst, is_zero;
 	int neg;
 
 	if (!aff1 || !aff2)
@@ -3238,9 +3481,11 @@
 	if (!is_cst)
 		isl_die(isl_aff_get_ctx(aff2), isl_error_invalid,
 			"second argument should be a constant", goto error);
-
-	if (!aff2)
+	is_zero = isl_aff_plain_is_zero(aff2);
+	if (is_zero < 0)
 		goto error;
+	if (is_zero)
+		return set_nan_free(aff1, aff2);
 
 	neg = isl_int_is_neg(aff2->v->el1);
 	if (neg) {
@@ -3264,16 +3509,11 @@
 	return NULL;
 }
 
-static __isl_give isl_pw_aff *pw_aff_add(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &isl_aff_add);
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_add(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_add);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &isl_aff_add);
 }
 
 __isl_give isl_pw_aff *isl_pw_aff_union_add(__isl_take isl_pw_aff *pwaff1,
@@ -3282,22 +3522,11 @@
 	return isl_pw_aff_union_add_(pwaff1, pwaff2);
 }
 
-static __isl_give isl_pw_aff *pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &isl_aff_mul);
-}
-
 __isl_give isl_pw_aff *isl_pw_aff_mul(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_mul);
-}
-
-static __isl_give isl_pw_aff *pw_aff_div(__isl_take isl_pw_aff *pa1,
-	__isl_take isl_pw_aff *pa2)
-{
-	return isl_pw_aff_on_shared_domain(pa1, pa2, &isl_aff_div);
+	isl_pw_aff_align_params_bin(&pwaff1, &pwaff2);
+	return isl_pw_aff_on_shared_domain(pwaff1, pwaff2, &isl_aff_mul);
 }
 
 /* Divide "pa1" by "pa2", assuming "pa2" is a piecewise constant.
@@ -3314,7 +3543,8 @@
 		isl_die(isl_pw_aff_get_ctx(pa2), isl_error_invalid,
 			"second argument should be a piecewise constant",
 			goto error);
-	return isl_pw_aff_align_params_pw_pw_and(pa1, pa2, &pw_aff_div);
+	isl_pw_aff_align_params_bin(&pa1, &pa2);
+	return isl_pw_aff_on_shared_domain(pa1, pa2, &isl_aff_div);
 error:
 	isl_pw_aff_free(pa1);
 	isl_pw_aff_free(pa2);
@@ -3389,6 +3619,40 @@
 	return NULL;
 }
 
+/* Does either of "pa1" or "pa2" involve any NaN2?
+ */
+static isl_bool either_involves_nan(__isl_keep isl_pw_aff *pa1,
+	__isl_keep isl_pw_aff *pa2)
+{
+	isl_bool has_nan;
+
+	has_nan = isl_pw_aff_involves_nan(pa1);
+	if (has_nan < 0 || has_nan)
+		return has_nan;
+	return isl_pw_aff_involves_nan(pa2);
+}
+
+/* Replace "pa1" and "pa2" (at least one of which involves a NaN)
+ * by a NaN on their shared domain.
+ *
+ * In principle, the result could be refined to only being NaN
+ * on the parts of this domain where at least one of "pa1" or "pa2" is NaN.
+ */
+static __isl_give isl_pw_aff *replace_by_nan(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2)
+{
+	isl_local_space *ls;
+	isl_set *dom;
+	isl_pw_aff *pa;
+
+	dom = isl_set_intersect(isl_pw_aff_domain(pa1), isl_pw_aff_domain(pa2));
+	ls = isl_local_space_from_space(isl_set_get_space(dom));
+	pa = isl_pw_aff_nan_on_domain(ls);
+	pa = isl_pw_aff_intersect_domain(pa, dom);
+
+	return pa;
+}
+
 static __isl_give isl_pw_aff *pw_aff_min(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
@@ -3403,12 +3667,6 @@
 	return isl_pw_aff_select(le, pwaff1, dom, pwaff2);
 }
 
-__isl_give isl_pw_aff *isl_pw_aff_min(__isl_take isl_pw_aff *pwaff1,
-	__isl_take isl_pw_aff *pwaff2)
-{
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_min);
-}
-
 static __isl_give isl_pw_aff *pw_aff_max(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
@@ -3423,10 +3681,43 @@
 	return isl_pw_aff_select(ge, pwaff1, dom, pwaff2);
 }
 
+/* Return an expression for the minimum (if "max" is not set) or
+ * the maximum (if "max" is set) of "pa1" and "pa2".
+ * If either expression involves any NaN, then return a NaN
+ * on the shared domain as result.
+ */
+static __isl_give isl_pw_aff *pw_aff_min_max(__isl_take isl_pw_aff *pa1,
+	__isl_take isl_pw_aff *pa2, int max)
+{
+	isl_bool has_nan;
+
+	has_nan = either_involves_nan(pa1, pa2);
+	if (has_nan < 0)
+		pa1 = isl_pw_aff_free(pa1);
+	else if (has_nan)
+		return replace_by_nan(pa1, pa2);
+
+	isl_pw_aff_align_params_bin(&pa1, &pa2);
+	if (max)
+		return pw_aff_max(pa1, pa2);
+	else
+		return pw_aff_min(pa1, pa2);
+}
+
+/* Return an expression for the minimum of "pwaff1" and "pwaff2".
+ */
+__isl_give isl_pw_aff *isl_pw_aff_min(__isl_take isl_pw_aff *pwaff1,
+	__isl_take isl_pw_aff *pwaff2)
+{
+	return pw_aff_min_max(pwaff1, pwaff2, 0);
+}
+
+/* Return an expression for the maximum of "pwaff1" and "pwaff2".
+ */
 __isl_give isl_pw_aff *isl_pw_aff_max(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2)
 {
-	return isl_pw_aff_align_params_pw_pw_and(pwaff1, pwaff2, &pw_aff_max);
+	return pw_aff_min_max(pwaff1, pwaff2, 1);
 }
 
 static __isl_give isl_pw_aff *pw_aff_list_reduce(
@@ -3522,39 +3813,37 @@
 
 /* Do the parameters of "aff" match those of "space"?
  */
-int isl_aff_matching_params(__isl_keep isl_aff *aff,
+isl_bool isl_aff_matching_params(__isl_keep isl_aff *aff,
 	__isl_keep isl_space *space)
 {
 	isl_space *aff_space;
-	int match;
+	isl_bool match;
 
 	if (!aff || !space)
-		return -1;
+		return isl_bool_error;
 
 	aff_space = isl_aff_get_domain_space(aff);
 
-	match = isl_space_match(space, isl_dim_param, aff_space, isl_dim_param);
+	match = isl_space_has_equal_params(space, aff_space);
 
 	isl_space_free(aff_space);
 	return match;
 }
 
 /* Check that the domain space of "aff" matches "space".
- *
- * Return 0 on success and -1 on error.
  */
-int isl_aff_check_match_domain_space(__isl_keep isl_aff *aff,
+isl_stat isl_aff_check_match_domain_space(__isl_keep isl_aff *aff,
 	__isl_keep isl_space *space)
 {
 	isl_space *aff_space;
-	int match;
+	isl_bool match;
 
 	if (!aff || !space)
-		return -1;
+		return isl_stat_error;
 
 	aff_space = isl_aff_get_domain_space(aff);
 
-	match = isl_space_match(space, isl_dim_param, aff_space, isl_dim_param);
+	match = isl_space_has_equal_params(space, aff_space);
 	if (match < 0)
 		goto error;
 	if (!match)
@@ -3568,21 +3857,154 @@
 		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
 			"domains don't match", goto error);
 	isl_space_free(aff_space);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_space_free(aff_space);
-	return -1;
+	return isl_stat_error;
+}
+
+/* Return the shared (universe) domain of the elements of "ma".
+ *
+ * Since an isl_multi_aff (and an isl_aff) is always total,
+ * the domain is always the universe set in its domain space.
+ * This is a helper function for use in the generic isl_multi_*_bind.
+ */
+static __isl_give isl_basic_set *isl_multi_aff_domain(
+	__isl_take isl_multi_aff *ma)
+{
+	isl_space *space;
+
+	space = isl_multi_aff_get_space(ma);
+	isl_multi_aff_free(ma);
+
+	return isl_basic_set_universe(isl_space_domain(space));
 }
 
 #undef BASE
 #define BASE aff
-#define NO_INTERSECT_DOMAIN
-#define NO_DOMAIN
 
+#include <isl_multi_no_explicit_domain.c>
 #include <isl_multi_templ.c>
+#include <isl_multi_add_constant_templ.c>
+#include <isl_multi_apply_set.c>
+#include <isl_multi_arith_templ.c>
+#include <isl_multi_bind_domain_templ.c>
+#include <isl_multi_cmp.c>
+#include <isl_multi_dim_id_templ.c>
+#include <isl_multi_dims.c>
+#include <isl_multi_floor.c>
+#include <isl_multi_from_base_templ.c>
+#include <isl_multi_identity_templ.c>
+#include <isl_multi_insert_domain_templ.c>
+#include <isl_multi_locals_templ.c>
+#include <isl_multi_move_dims_templ.c>
+#include <isl_multi_nan_templ.c>
+#include <isl_multi_product_templ.c>
+#include <isl_multi_splice_templ.c>
+#include <isl_multi_tuple_id_templ.c>
+#include <isl_multi_unbind_params_templ.c>
+#include <isl_multi_zero_templ.c>
+
+#undef DOMBASE
+#define DOMBASE set
+#include <isl_multi_gist.c>
+
+#undef DOMBASE
+#define DOMBASE basic_set
+#include <isl_multi_bind_templ.c>
 
-#undef NO_DOMAIN
-#undef NO_INTERSECT_DOMAIN
+/* Construct an isl_multi_aff living in "space" that corresponds
+ * to the affine transformation matrix "mat".
+ */
+__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
+	__isl_take isl_space *space, __isl_take isl_mat *mat)
+{
+	isl_ctx *ctx;
+	isl_local_space *ls = NULL;
+	isl_multi_aff *ma = NULL;
+	isl_size n_row, n_col, n_out, total;
+	int i;
+
+	if (!space || !mat)
+		goto error;
+
+	ctx = isl_mat_get_ctx(mat);
+
+	n_row = isl_mat_rows(mat);
+	n_col = isl_mat_cols(mat);
+	n_out = isl_space_dim(space, isl_dim_out);
+	total = isl_space_dim(space, isl_dim_all);
+	if (n_row < 0 || n_col < 0 || n_out < 0 || total < 0)
+		goto error;
+	if (n_row < 1)
+		isl_die(ctx, isl_error_invalid,
+			"insufficient number of rows", goto error);
+	if (n_col < 1)
+		isl_die(ctx, isl_error_invalid,
+			"insufficient number of columns", goto error);
+	if (1 + n_out != n_row || 2 + total != n_row + n_col)
+		isl_die(ctx, isl_error_invalid,
+			"dimension mismatch", goto error);
+
+	ma = isl_multi_aff_zero(isl_space_copy(space));
+	space = isl_space_domain(space);
+	ls = isl_local_space_from_space(isl_space_copy(space));
+
+	for (i = 0; i < n_row - 1; ++i) {
+		isl_vec *v;
+		isl_aff *aff;
+
+		v = isl_vec_alloc(ctx, 1 + n_col);
+		if (!v)
+			goto error;
+		isl_int_set(v->el0, mat->row00);
+		isl_seq_cpy(v->el + 1, mat->row1 + i, n_col);
+		v = isl_vec_normalize(v);
+		aff = isl_aff_alloc_vec(isl_local_space_copy(ls), v);
+		ma = isl_multi_aff_set_aff(ma, i, aff);
+	}
+
+	isl_space_free(space);
+	isl_local_space_free(ls);
+	isl_mat_free(mat);
+	return ma;
+error:
+	isl_space_free(space);
+	isl_local_space_free(ls);
+	isl_mat_free(mat);
+	isl_multi_aff_free(ma);
+	return NULL;
+}
+
+/* Return the constant terms of the affine expressions of "ma".
+ */
+__isl_give isl_multi_val *isl_multi_aff_get_constant_multi_val(
+	__isl_keep isl_multi_aff *ma)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_val *mv;
+
+	n = isl_multi_aff_size(ma);
+	if (n < 0)
+		return NULL;
+	space = isl_space_range(isl_multi_aff_get_space(ma));
+	space = isl_space_drop_all_params(space);
+	mv = isl_multi_val_zero(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_aff *aff;
+		isl_val *val;
+
+		aff = isl_multi_aff_get_at(ma, i);
+		val = isl_aff_get_constant_val(aff);
+		isl_aff_free(aff);
+		mv = isl_multi_val_set_at(mv, i, val);
+	}
+
+	return mv;
+}
 
 /* Remove any internal structure of the domain of "ma".
  * If there is any such internal structure in the input,
@@ -3611,7 +4033,8 @@
  */
 __isl_give isl_multi_aff *isl_multi_aff_domain_map(__isl_take isl_space *space)
 {
-	int i, n_in;
+	int i;
+	isl_size n_in;
 	isl_local_space *ls;
 	isl_multi_aff *ma;
 
@@ -3622,6 +4045,8 @@
 			"not a map space", goto error);
 
 	n_in = isl_space_dim(space, isl_dim_in);
+	if (n_in < 0)
+		goto error;
 	space = isl_space_domain_map(space);
 
 	ma = isl_multi_aff_alloc(isl_space_copy(space));
@@ -3646,12 +4071,22 @@
 	return NULL;
 }
 
+/* This function performs the same operation as isl_multi_aff_domain_map,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_multi_aff *isl_space_domain_map_multi_aff(
+	__isl_take isl_space *space)
+{
+	return isl_multi_aff_domain_map(space);
+}
+
 /* Given a map space, return an isl_multi_aff that maps a wrapped copy
  * of the space to its range.
  */
 __isl_give isl_multi_aff *isl_multi_aff_range_map(__isl_take isl_space *space)
 {
-	int i, n_in, n_out;
+	int i;
+	isl_size n_in, n_out;
 	isl_local_space *ls;
 	isl_multi_aff *ma;
 
@@ -3663,6 +4098,8 @@
 
 	n_in = isl_space_dim(space, isl_dim_in);
 	n_out = isl_space_dim(space, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		goto error;
 	space = isl_space_range_map(space);
 
 	ma = isl_multi_aff_alloc(isl_space_copy(space));
@@ -3687,6 +4124,51 @@
 	return NULL;
 }
 
+/* This function performs the same operation as isl_multi_aff_range_map,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_multi_aff *isl_space_range_map_multi_aff(
+	__isl_take isl_space *space)
+{
+	return isl_multi_aff_range_map(space);
+}
+
+/* Given a map space, return an isl_pw_multi_aff that maps a wrapped copy
+ * of the space to its domain.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_domain_map(
+	__isl_take isl_space *space)
+{
+	return isl_pw_multi_aff_from_multi_aff(isl_multi_aff_domain_map(space));
+}
+
+/* This function performs the same operation as isl_pw_multi_aff_domain_map,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_pw_multi_aff *isl_space_domain_map_pw_multi_aff(
+	__isl_take isl_space *space)
+{
+	return isl_pw_multi_aff_domain_map(space);
+}
+
+/* Given a map space, return an isl_pw_multi_aff that maps a wrapped copy
+ * of the space to its range.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_map(
+	__isl_take isl_space *space)
+{
+	return isl_pw_multi_aff_from_multi_aff(isl_multi_aff_range_map(space));
+}
+
+/* This function performs the same operation as isl_pw_multi_aff_range_map,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_pw_multi_aff *isl_space_range_map_pw_multi_aff(
+	__isl_take isl_space *space)
+{
+	return isl_pw_multi_aff_range_map(space);
+}
+
 /* Given the space of a set and a range of set dimensions,
  * construct an isl_multi_aff that projects out those dimensions.
  */
@@ -3694,7 +4176,8 @@
 	__isl_take isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n)
 {
-	int i, dim;
+	int i;
+	isl_size dim;
 	isl_local_space *ls;
 	isl_multi_aff *ma;
 
@@ -3706,11 +4189,12 @@
 	if (type != isl_dim_set)
 		isl_die(isl_space_get_ctx(space), isl_error_invalid,
 			"only set dimensions can be projected out", goto error);
+	if (isl_space_check_range(space, type, first, n) < 0)
+		goto error;
 
 	dim = isl_space_dim(space, isl_dim_set);
-	if (first + n > dim)
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"range out of bounds", goto error);
+	if (dim < 0)
+		goto error;
 
 	space = isl_space_from_domain(space);
 	space = isl_space_add_dims(space, isl_dim_out, dim - n);
@@ -3758,14 +4242,13 @@
 	return isl_pw_multi_aff_from_multi_aff(ma);
 }
 
-/* Create an isl_pw_multi_aff with the given isl_multi_aff on a universe
- * domain.
+/* This function performs the same operation as isl_pw_multi_aff_from_multi_aff,
+ * but is considered as a function on an isl_multi_aff when exported.
  */
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_aff(
+__isl_give isl_pw_multi_aff *isl_multi_aff_to_pw_multi_aff(
 	__isl_take isl_multi_aff *ma)
 {
-	isl_set *dom = isl_set_universe(isl_multi_aff_get_domain_space(ma));
-	return isl_pw_multi_aff_alloc(dom, ma);
+	return isl_pw_multi_aff_from_multi_aff(ma);
 }
 
 /* Create a piecewise multi-affine expression in the given space that maps each
@@ -3777,42 +4260,26 @@
 	return isl_pw_multi_aff_from_multi_aff(isl_multi_aff_identity(space));
 }
 
-/* Add "ma2" to "ma1" and return the result.
- *
- * The parameters of "ma1" and "ma2" are assumed to have been aligned.
- */
-static __isl_give isl_multi_aff *isl_multi_aff_add_aligned(
-	__isl_take isl_multi_aff *maff1, __isl_take isl_multi_aff *maff2)
-{
-	return isl_multi_aff_bin_op(maff1, maff2, &isl_aff_add);
-}
-
-/* Add "ma2" to "ma1" and return the result.
+/* Create a piecewise multi expression that maps elements in the given space
+ * to themselves.
  */
-__isl_give isl_multi_aff *isl_multi_aff_add(__isl_take isl_multi_aff *ma1,
-	__isl_take isl_multi_aff *ma2)
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_identity_on_domain_space(
+	__isl_take isl_space *space)
 {
-	return isl_multi_aff_align_params_multi_multi_and(ma1, ma2,
-						&isl_multi_aff_add_aligned);
-}
+	isl_multi_aff *ma;
 
-/* Subtract "ma2" from "ma1" and return the result.
- *
- * The parameters of "ma1" and "ma2" are assumed to have been aligned.
- */
-static __isl_give isl_multi_aff *isl_multi_aff_sub_aligned(
-	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2)
-{
-	return isl_multi_aff_bin_op(ma1, ma2, &isl_aff_sub);
+	ma = isl_multi_aff_identity_on_domain_space(space);
+	return isl_pw_multi_aff_from_multi_aff(ma);
 }
 
-/* Subtract "ma2" from "ma1" and return the result.
+/* This function performs the same operation as
+ * isl_pw_multi_aff_identity_on_domain_space,
+ * but is considered as a function on an isl_space when exported.
  */
-__isl_give isl_multi_aff *isl_multi_aff_sub(__isl_take isl_multi_aff *ma1,
-	__isl_take isl_multi_aff *ma2)
+__isl_give isl_pw_multi_aff *isl_space_identity_pw_multi_aff_on_domain(
+	__isl_take isl_space *space)
 {
-	return isl_multi_aff_align_params_multi_multi_and(ma1, ma2,
-						&isl_multi_aff_sub_aligned);
+	return isl_pw_multi_aff_identity_on_domain_space(space);
 }
 
 /* Exploit the equalities in "eq" to simplify the affine expressions.
@@ -3827,9 +4294,9 @@
 		goto error;
 
 	for (i = 0; i < maff->n; ++i) {
-		maff->pi = isl_aff_substitute_equalities(maff->pi,
+		maff->u.pi = isl_aff_substitute_equalities(maff->u.pi,
 						    isl_basic_set_copy(eq));
-		if (!maff->pi)
+		if (!maff->u.pi)
 			goto error;
 	}
 
@@ -3841,25 +4308,6 @@
 	return NULL;
 }
 
-/* Given f, return floor(f).
- */
-__isl_give isl_multi_aff *isl_multi_aff_floor(__isl_take isl_multi_aff *ma)
-{
-	int i;
-
-	ma = isl_multi_aff_cow(ma);
-	if (!ma)
-		return NULL;
-
-	for (i = 0; i < ma->n; ++i) {
-		ma->pi = isl_aff_floor(ma->pi);
-		if (!ma->pi)
-			return isl_multi_aff_free(ma);
-	}
-
-	return ma;
-}
-
 __isl_give isl_multi_aff *isl_multi_aff_scale(__isl_take isl_multi_aff *maff,
 	isl_int f)
 {
@@ -3870,8 +4318,8 @@
 		return NULL;
 
 	for (i = 0; i < maff->n; ++i) {
-		maff->pi = isl_aff_scale(maff->pi, f);
-		if (!maff->pi)
+		maff->u.pi = isl_aff_scale(maff->u.pi, f);
+		if (!maff->u.pi)
 			return isl_multi_aff_free(maff);
 	}
 
@@ -3886,12 +4334,12 @@
 	return maff1;
 }
 
-int isl_multi_aff_is_empty(__isl_keep isl_multi_aff *maff)
+isl_bool isl_multi_aff_is_empty(__isl_keep isl_multi_aff *maff)
 {
 	if (!maff)
-		return -1;
+		return isl_bool_error;
 
-	return 0;
+	return isl_bool_false;
 }
 
 /* Return the set of domain elements where "ma1" is lexicographically
@@ -3904,30 +4352,140 @@
 }
 
 /* Return the set of domain elements where "ma1" is lexicographically
- * greater than or equal to "ma2".
+ * smaller than "ma2".
  */
-__isl_give isl_set *isl_multi_aff_lex_ge_set(__isl_take isl_multi_aff *ma1,
+__isl_give isl_set *isl_multi_aff_lex_lt_set(__isl_take isl_multi_aff *ma1,
 	__isl_take isl_multi_aff *ma2)
 {
+	return isl_multi_aff_lex_gt_set(ma2, ma1);
+}
+
+/* Return the set of domain elements where "ma1" is lexicographically
+ * greater than to "ma2".  If "equal" is set, then include the domain
+ * elements where they are equal.
+ * Do this for the case where there are no entries.
+ * In this case, "ma1" cannot be greater than "ma2",
+ * but it is (greater than or) equal to "ma2".
+ */
+static __isl_give isl_set *isl_multi_aff_lex_gte_set_0d(
+	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2, int equal)
+{
 	isl_space *space;
-	isl_map *map1, *map2;
-	isl_map *map, *ge;
 
-	map1 = isl_map_from_multi_aff(ma1);
-	map2 = isl_map_from_multi_aff(ma2);
-	map = isl_map_range_product(map1, map2);
-	space = isl_space_range(isl_map_get_space(map));
-	space = isl_space_domain(isl_space_unwrap(space));
-	ge = isl_map_lex_ge(space);
-	map = isl_map_intersect_range(map, isl_map_wrap(ge));
+	space = isl_multi_aff_get_domain_space(ma1);
 
-	return isl_map_domain(map);
+	isl_multi_aff_free(ma1);
+	isl_multi_aff_free(ma2);
+
+	if (equal)
+		return isl_set_universe(space);
+	else
+		return isl_set_empty(space);
 }
 
+/* Return the set where entry "i" of "ma1" and "ma2"
+ * satisfy the relation prescribed by "cmp".
+ */
+static __isl_give isl_set *isl_multi_aff_order_at(__isl_keep isl_multi_aff *ma1,
+	__isl_keep isl_multi_aff *ma2, int i,
+	__isl_give isl_set *(*cmp)(__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2))
+{
+	isl_aff *aff1, *aff2;
+
+	aff1 = isl_multi_aff_get_at(ma1, i);
+	aff2 = isl_multi_aff_get_at(ma2, i);
+	return cmp(aff1, aff2);
+}
+
+/* Return the set of domain elements where "ma1" is lexicographically
+ * greater than to "ma2".  If "equal" is set, then include the domain
+ * elements where they are equal.
+ *
+ * In particular, for all but the final entry,
+ * include the set of elements where this entry is strictly greater in "ma1"
+ * and all previous entries are equal.
+ * The final entry is also allowed to be equal in the two functions
+ * if "equal" is set.
+ *
+ * The case where there are no entries is handled separately.
+ */
+static __isl_give isl_set *isl_multi_aff_lex_gte_set(
+	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2, int equal)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_set *res;
+	isl_set *equal_set;
+	isl_set *gte;
+
+	if (isl_multi_aff_check_equal_space(ma1, ma2) < 0)
+		goto error;
+	n = isl_multi_aff_size(ma1);
+	if (n < 0)
+		goto error;
+	if (n == 0)
+		return isl_multi_aff_lex_gte_set_0d(ma1, ma2, equal);
+
+	space = isl_multi_aff_get_domain_space(ma1);
+	res = isl_set_empty(isl_space_copy(space));
+	equal_set = isl_set_universe(space);
+
+	for (i = 0; i + 1 < n; ++i) {
+		isl_bool empty;
+		isl_set *gt, *eq;
+
+		gt = isl_multi_aff_order_at(ma1, ma2, i, &isl_aff_gt_set);
+		gt = isl_set_intersect(gt, isl_set_copy(equal_set));
+		res = isl_set_union(res, gt);
+		eq = isl_multi_aff_order_at(ma1, ma2, i, &isl_aff_eq_set);
+		equal_set = isl_set_intersect(equal_set, eq);
+
+		empty = isl_set_is_empty(equal_set);
+		if (empty >= 0 && empty)
+			break;
+	}
+
+	if (equal)
+		gte = isl_multi_aff_order_at(ma1, ma2, n - 1, &isl_aff_ge_set);
+	else
+		gte = isl_multi_aff_order_at(ma1, ma2, n - 1, &isl_aff_gt_set);
+	isl_multi_aff_free(ma1);
+	isl_multi_aff_free(ma2);
+
+	gte = isl_set_intersect(gte, equal_set);
+	return isl_set_union(res, gte);
+error:
+	isl_multi_aff_free(ma1);
+	isl_multi_aff_free(ma2);
+	return NULL;
+}
+
+/* Return the set of domain elements where "ma1" is lexicographically
+ * greater than or equal to "ma2".
+ */
+__isl_give isl_set *isl_multi_aff_lex_ge_set(__isl_take isl_multi_aff *ma1,
+	__isl_take isl_multi_aff *ma2)
+{
+	return isl_multi_aff_lex_gte_set(ma1, ma2, 1);
+}
+
+/* Return the set of domain elements where "ma1" is lexicographically
+ * greater than "ma2".
+ */
+__isl_give isl_set *isl_multi_aff_lex_gt_set(__isl_take isl_multi_aff *ma1,
+	__isl_take isl_multi_aff *ma2)
+{
+	return isl_multi_aff_lex_gte_set(ma1, ma2, 0);
+}
+
+#define isl_multi_aff_zero_in_space	isl_multi_aff_zero
+
 #undef PW
 #define PW isl_pw_multi_aff
-#undef EL
-#define EL isl_multi_aff
+#undef BASE
+#define BASE multi_aff
 #undef EL_IS_ZERO
 #define EL_IS_ZERO is_empty
 #undef ZERO
@@ -3939,143 +4497,107 @@
 #undef DEFAULT_IS_ZERO
 #define DEFAULT_IS_ZERO 0
 
-#define NO_NEG
-#define NO_EVAL
-#define NO_OPT
-#define NO_INVOLVES_DIMS
-#define NO_INSERT_DIMS
-#define NO_LIFT
-#define NO_MORPH
-
 #include <isl_pw_templ.c>
+#include <isl_pw_add_constant_multi_val_templ.c>
+#include <isl_pw_add_constant_val_templ.c>
+#include <isl_pw_bind_domain_templ.c>
+#include <isl_pw_insert_dims_templ.c>
+#include <isl_pw_insert_domain_templ.c>
+#include <isl_pw_locals_templ.c>
+#include <isl_pw_move_dims_templ.c>
+#include <isl_pw_neg_templ.c>
+#include <isl_pw_pullback_templ.c>
+#include <isl_pw_range_tuple_id_templ.c>
+#include <isl_pw_union_opt.c>
 
-#undef UNION
-#define UNION isl_union_pw_multi_aff
-#undef PART
-#define PART isl_pw_multi_aff
-#undef PARTS
-#define PARTS pw_multi_aff
-#define ALIGN_DOMAIN
-
-#define NO_EVAL
-
-#include <isl_union_templ.c>
-
-/* Given a function "cmp" that returns the set of elements where
- * "ma1" is "better" than "ma2", return the intersection of this
- * set with "dom1" and "dom2".
- */
-static __isl_give isl_set *shared_and_better(__isl_keep isl_set *dom1,
-	__isl_keep isl_set *dom2, __isl_keep isl_multi_aff *ma1,
-	__isl_keep isl_multi_aff *ma2,
-	__isl_give isl_set *(*cmp)(__isl_take isl_multi_aff *ma1,
-				    __isl_take isl_multi_aff *ma2))
-{
-	isl_set *common;
-	isl_set *better;
-	int is_empty;
-
-	common = isl_set_intersect(isl_set_copy(dom1), isl_set_copy(dom2));
-	is_empty = isl_set_plain_is_empty(common);
-	if (is_empty >= 0 && is_empty)
-		return common;
-	if (is_empty < 0)
-		return isl_set_free(common);
-	better = cmp(isl_multi_aff_copy(ma1), isl_multi_aff_copy(ma2));
-	better = isl_set_intersect(common, better);
-
-	return better;
-}
-
-/* Given a function "cmp" that returns the set of elements where
- * "ma1" is "better" than "ma2", return a piecewise multi affine
- * expression defined on the union of the definition domains
- * of "pma1" and "pma2" that maps to the "best" of "pma1" and
- * "pma2" on each cell.  If only one of the two input functions
- * is defined on a given cell, then it is considered the best.
- */
-static __isl_give isl_pw_multi_aff *pw_multi_aff_union_opt(
-	__isl_take isl_pw_multi_aff *pma1,
-	__isl_take isl_pw_multi_aff *pma2,
-	__isl_give isl_set *(*cmp)(__isl_take isl_multi_aff *ma1,
-				    __isl_take isl_multi_aff *ma2))
-{
-	int i, j, n;
-	isl_pw_multi_aff *res = NULL;
-	isl_ctx *ctx;
-	isl_set *set = NULL;
+#undef BASE
+#define BASE pw_multi_aff
 
-	if (!pma1 || !pma2)
-		goto error;
+#include <isl_union_multi.c>
+#include "isl_union_locals_templ.c"
+#include <isl_union_neg.c>
 
-	ctx = isl_space_get_ctx(pma1->dim);
-	if (!isl_space_is_equal(pma1->dim, pma2->dim))
-		isl_die(ctx, isl_error_invalid,
-			"arguments should live in the same space", goto error);
+#undef BASE
+#define BASE multi_aff
 
-	if (isl_pw_multi_aff_is_empty(pma1)) {
-		isl_pw_multi_aff_free(pma1);
-		return pma2;
-	}
+#include <isl_union_pw_templ.c>
 
-	if (isl_pw_multi_aff_is_empty(pma2)) {
-		isl_pw_multi_aff_free(pma2);
-		return pma1;
-	}
+/* Generic function for extracting a factor from a product "pma".
+ * "check_space" checks that the space is that of the right kind of product.
+ * "space_factor" extracts the factor from the space.
+ * "multi_aff_factor" extracts the factor from the constituent functions.
+ */
+static __isl_give isl_pw_multi_aff *pw_multi_aff_factor(
+	__isl_take isl_pw_multi_aff *pma,
+	isl_stat (*check_space)(__isl_keep isl_pw_multi_aff *pma),
+	__isl_give isl_space *(*space_factor)(__isl_take isl_space *space),
+	__isl_give isl_multi_aff *(*multi_aff_factor)(
+		__isl_take isl_multi_aff *ma))
+{
+	int i;
+	isl_space *space;
 
-	n = 2 * (pma1->n + 1) * (pma2->n + 1);
-	res = isl_pw_multi_aff_alloc_size(isl_space_copy(pma1->dim), n);
+	if (check_space(pma) < 0)
+		return isl_pw_multi_aff_free(pma);
 
-	for (i = 0; i < pma1->n; ++i) {
-		set = isl_set_copy(pma1->pi.set);
-		for (j = 0; j < pma2->n; ++j) {
-			isl_set *better;
-			int is_empty;
+	space = isl_pw_multi_aff_take_space(pma);
+	space = space_factor(space);
 
-			better = shared_and_better(pma2->pj.set,
-					pma1->pi.set, pma2->pj.maff,
-					pma1->pi.maff, cmp);
-			is_empty = isl_set_plain_is_empty(better);
-			if (is_empty < 0 || is_empty) {
-				isl_set_free(better);
-				if (is_empty < 0)
-					goto error;
-				continue;
-			}
-			set = isl_set_subtract(set, isl_set_copy(better));
+	for (i = 0; pma && i < pma->n; ++i) {
+		isl_multi_aff *ma;
 
-			res = isl_pw_multi_aff_add_piece(res, better,
-					isl_multi_aff_copy(pma2->pj.maff));
-		}
-		res = isl_pw_multi_aff_add_piece(res, set,
-					isl_multi_aff_copy(pma1->pi.maff));
+		ma = isl_pw_multi_aff_take_base_at(pma, i);
+		ma = multi_aff_factor(ma);
+		pma = isl_pw_multi_aff_restore_base_at(pma, i, ma);
 	}
 
-	for (j = 0; j < pma2->n; ++j) {
-		set = isl_set_copy(pma2->pj.set);
-		for (i = 0; i < pma1->n; ++i)
-			set = isl_set_subtract(set,
-					isl_set_copy(pma1->pi.set));
-		res = isl_pw_multi_aff_add_piece(res, set,
-					isl_multi_aff_copy(pma2->pj.maff));
-	}
+	pma = isl_pw_multi_aff_restore_space(pma, space);
 
-	isl_pw_multi_aff_free(pma1);
-	isl_pw_multi_aff_free(pma2);
+	return pma;
+}
 
-	return res;
-error:
-	isl_pw_multi_aff_free(pma1);
-	isl_pw_multi_aff_free(pma2);
-	isl_set_free(set);
-	return isl_pw_multi_aff_free(res);
+/* Is the range of "pma" a wrapped relation?
+ */
+static isl_bool isl_pw_multi_aff_range_is_wrapping(
+	__isl_keep isl_pw_multi_aff *pma)
+{
+	return isl_space_range_is_wrapping(isl_pw_multi_aff_peek_space(pma));
 }
 
-static __isl_give isl_pw_multi_aff *pw_multi_aff_union_lexmax(
-	__isl_take isl_pw_multi_aff *pma1,
-	__isl_take isl_pw_multi_aff *pma2)
+/* Check that the range of "pma" is a product.
+ */
+static isl_stat pw_multi_aff_check_range_product(
+	__isl_keep isl_pw_multi_aff *pma)
+{
+	isl_bool wraps;
+
+	wraps = isl_pw_multi_aff_range_is_wrapping(pma);
+	if (wraps < 0)
+		return isl_stat_error;
+	if (!wraps)
+		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
+			"range is not a product", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Given a function A -> B -> C, extract the function A -> B.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_domain(
+	__isl_take isl_pw_multi_aff *pma)
+{
+	return pw_multi_aff_factor(pma, &pw_multi_aff_check_range_product,
+				&isl_space_range_factor_domain,
+				&isl_multi_aff_range_factor_domain);
+}
+
+/* Given a function A -> B -> C, extract the function A -> C.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_factor_range(
+	__isl_take isl_pw_multi_aff *pma)
 {
-	return pw_multi_aff_union_opt(pma1, pma2, &isl_multi_aff_lex_ge_set);
+	return pw_multi_aff_factor(pma, &pw_multi_aff_check_range_product,
+				&isl_space_range_factor_range,
+				&isl_multi_aff_range_factor_range);
 }
 
 /* Given two piecewise multi affine expressions, return a piecewise
@@ -4088,15 +4610,9 @@
 	__isl_take isl_pw_multi_aff *pma1,
 	__isl_take isl_pw_multi_aff *pma2)
 {
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-						    &pw_multi_aff_union_lexmax);
-}
-
-static __isl_give isl_pw_multi_aff *pw_multi_aff_union_lexmin(
-	__isl_take isl_pw_multi_aff *pma1,
-	__isl_take isl_pw_multi_aff *pma2)
-{
-	return pw_multi_aff_union_opt(pma1, pma2, &isl_multi_aff_lex_le_set);
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
+	return isl_pw_multi_aff_union_opt_cmp(pma1, pma2,
+					    &isl_multi_aff_lex_ge_set);
 }
 
 /* Given two piecewise multi affine expressions, return a piecewise
@@ -4109,57 +4625,67 @@
 	__isl_take isl_pw_multi_aff *pma1,
 	__isl_take isl_pw_multi_aff *pma2)
 {
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-						    &pw_multi_aff_union_lexmin);
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
+	return isl_pw_multi_aff_union_opt_cmp(pma1, pma2,
+					    &isl_multi_aff_lex_le_set);
 }
 
-static __isl_give isl_pw_multi_aff *pw_multi_aff_add(
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
 	return isl_pw_multi_aff_on_shared_domain(pma1, pma2,
 						&isl_multi_aff_add);
 }
 
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_add(
+/* Subtract "pma2" from "pma1" and return the result.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-						&pw_multi_aff_add);
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
+	return isl_pw_multi_aff_on_shared_domain(pma1, pma2,
+						&isl_multi_aff_sub);
 }
 
-static __isl_give isl_pw_multi_aff *pw_multi_aff_sub(
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
-	return isl_pw_multi_aff_on_shared_domain(pma1, pma2,
-						&isl_multi_aff_sub);
+	return isl_pw_multi_aff_union_add_(pma1, pma2);
 }
 
-/* Subtract "pma2" from "pma1" and return the result.
+/* Compute the sum of "upa1" and "upa2" on the union of their domains,
+ * with the actual sum on the shared domain and
+ * the defined expression on the symmetric difference of the domains.
  */
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_sub(
-	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
+__isl_give isl_union_pw_aff *isl_union_pw_aff_union_add(
+	__isl_take isl_union_pw_aff *upa1, __isl_take isl_union_pw_aff *upa2)
 {
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-						&pw_multi_aff_sub);
+	return isl_union_pw_aff_union_add_(upa1, upa2);
 }
 
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_union_add(
-	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
+/* Compute the sum of "upma1" and "upma2" on the union of their domains,
+ * with the actual sum on the shared domain and
+ * the defined expression on the symmetric difference of the domains.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_union_add(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2)
 {
-	return isl_pw_multi_aff_union_add_(pma1, pma2);
+	return isl_union_pw_multi_aff_union_add_(upma1, upma2);
 }
 
 /* Given two piecewise multi-affine expressions A -> B and C -> D,
  * construct a piecewise multi-affine expression A -> C -> B -> D.
  */
-static __isl_give isl_pw_multi_aff *pw_multi_aff_product(
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
 	int i, j, n;
 	isl_space *space;
 	isl_pw_multi_aff *res;
 
-	if (!pma1 || !pma2)
+	if (isl_pw_multi_aff_align_params_bin(&pma1, &pma2) < 0)
 		goto error;
 
 	n = pma1->n * pma2->n;
@@ -4190,112 +4716,200 @@
 	return NULL;
 }
 
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_product(
-	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
-{
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-						&pw_multi_aff_product);
-}
+/* Subtract the initial "n" elements in "ma" with coefficients in "c" and
+ * denominator "denom".
+ * "denom" is allowed to be negative, in which case the actual denominator
+ * is -denom and the expressions are added instead.
+ */
+static __isl_give isl_aff *subtract_initial(__isl_take isl_aff *aff,
+	__isl_keep isl_multi_aff *ma, int n, isl_int *c, isl_int denom)
+{
+	int i, first;
+	int sign;
+	isl_int d;
 
-/* Construct a map mapping the domain of the piecewise multi-affine expression
- * to its range, with each dimension in the range equated to the
- * corresponding affine expression on its cell.
- */
-__isl_give isl_map *isl_map_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma)
-{
-	int i;
-	isl_map *map;
-
-	if (!pma)
-		return NULL;
+	first = isl_seq_first_non_zero(c, n);
+	if (first == -1)
+		return aff;
 
-	map = isl_map_empty(isl_pw_multi_aff_get_space(pma));
+	sign = isl_int_sgn(denom);
+	isl_int_init(d);
+	isl_int_abs(d, denom);
+	for (i = first; i < n; ++i) {
+		isl_aff *aff_i;
 
-	for (i = 0; i < pma->n; ++i) {
-		isl_multi_aff *maff;
-		isl_basic_map *bmap;
-		isl_map *map_i;
-
-		maff = isl_multi_aff_copy(pma->pi.maff);
-		bmap = isl_basic_map_from_multi_aff(maff);
-		map_i = isl_map_from_basic_map(bmap);
-		map_i = isl_map_intersect_domain(map_i,
-						isl_set_copy(pma->pi.set));
-		map = isl_map_union_disjoint(map, map_i);
+		if (isl_int_is_zero(ci))
+			continue;
+		aff_i = isl_multi_aff_get_aff(ma, i);
+		aff_i = isl_aff_scale(aff_i, ci);
+		aff_i = isl_aff_scale_down(aff_i, d);
+		if (sign >= 0)
+			aff = isl_aff_sub(aff, aff_i);
+		else
+			aff = isl_aff_add(aff, aff_i);
 	}
+	isl_int_clear(d);
 
-	isl_pw_multi_aff_free(pma);
-	return map;
+	return aff;
 }
 
-__isl_give isl_set *isl_set_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma)
+/* Extract an affine expression that expresses the output dimension "pos"
+ * of "bmap" in terms of the parameters and input dimensions from
+ * equality "eq".
+ * Note that this expression may involve integer divisions defined
+ * in terms of parameters and input dimensions.
+ * The equality may also involve references to earlier (but not later)
+ * output dimensions.  These are replaced by the corresponding elements
+ * in "ma".
+ *
+ * If the equality is of the form
+ *
+ *	f(i) + h(j) + a x + g(i) = 0,
+ *
+ * with f(i) a linear combinations of the parameters and input dimensions,
+ * g(i) a linear combination of integer divisions defined in terms of the same
+ * and h(j) a linear combinations of earlier output dimensions,
+ * then the affine expression is
+ *
+ *	(-f(i) - g(i))/a - h(j)/a
+ *
+ * If the equality is of the form
+ *
+ *	f(i) + h(j) - a x + g(i) = 0,
+ *
+ * then the affine expression is
+ *
+ *	(f(i) + g(i))/a - h(j)/(-a)
+ *
+ *
+ * If "div" refers to an integer division (i.e., it is smaller than
+ * the number of integer divisions), then the equality constraint
+ * does involve an integer division (the one at position "div") that
+ * is defined in terms of output dimensions.  However, this integer
+ * division can be eliminated by exploiting a pair of constraints
+ * x >= l and x <= l + n, with n smaller than the coefficient of "div"
+ * in the equality constraint.  "ineq" refers to inequality x >= l, i.e.,
+ * -l + x >= 0.
+ * In particular, let
+ *
+ *	x = e(i) + m floor(...)
+ *
+ * with e(i) the expression derived above and floor(...) the integer
+ * division involving output dimensions.
+ * From
+ *
+ *	l <= x <= l + n,
+ *
+ * we have
+ *
+ *	0 <= x - l <= n
+ *
+ * This means
+ *
+ *	e(i) + m floor(...) - l = (e(i) + m floor(...) - l) mod m
+ *	                        = (e(i) - l) mod m
+ *
+ * Therefore,
+ *
+ *	x - l = (e(i) - l) mod m
+ *
+ * or
+ *
+ *	x = ((e(i) - l) mod m) + l
+ *
+ * The variable "shift" below contains the expression -l, which may
+ * also involve a linear combination of earlier output dimensions.
+ */
+static __isl_give isl_aff *extract_aff_from_equality(
+	__isl_keep isl_basic_map *bmap, int pos, int eq, int div, int ineq,
+	__isl_keep isl_multi_aff *ma)
 {
-	if (!pma)
-		return NULL;
+	unsigned o_out;
+	isl_size n_div, n_out;
+	isl_ctx *ctx;
+	isl_local_space *ls;
+	isl_aff *aff, *shift;
+	isl_val *mod;
 
-	if (!isl_space_is_set(pma->dim))
-		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
-			"isl_pw_multi_aff cannot be converted into an isl_set",
-			goto error);
+	ctx = isl_basic_map_get_ctx(bmap);
+	ls = isl_basic_map_get_local_space(bmap);
+	ls = isl_local_space_domain(ls);
+	aff = isl_aff_alloc(isl_local_space_copy(ls));
+	if (!aff)
+		goto error;
+	o_out = isl_basic_map_offset(bmap, isl_dim_out);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_out < 0 || n_div < 0)
+		goto error;
+	if (isl_int_is_neg(bmap->eqeqo_out + pos)) {
+		isl_seq_cpy(aff->v->el + 1, bmap->eqeq, o_out);
+		isl_seq_cpy(aff->v->el + 1 + o_out,
+			    bmap->eqeq + o_out + n_out, n_div);
+	} else {
+		isl_seq_neg(aff->v->el + 1, bmap->eqeq, o_out);
+		isl_seq_neg(aff->v->el + 1 + o_out,
+			    bmap->eqeq + o_out + n_out, n_div);
+	}
+	if (div < n_div)
+		isl_int_set_si(aff->v->el1 + o_out + div, 0);
+	isl_int_abs(aff->v->el0, bmap->eqeqo_out + pos);
+	aff = subtract_initial(aff, ma, pos, bmap->eqeq + o_out,
+			    bmap->eqeqo_out + pos);
+	if (div < n_div) {
+		shift = isl_aff_alloc(isl_local_space_copy(ls));
+		if (!shift)
+			goto error;
+		isl_seq_cpy(shift->v->el + 1, bmap->ineqineq, o_out);
+		isl_seq_cpy(shift->v->el + 1 + o_out,
+			    bmap->ineqineq + o_out + n_out, n_div);
+		isl_int_set_si(shift->v->el0, 1);
+		shift = subtract_initial(shift, ma, pos,
+					bmap->ineqineq + o_out, ctx->negone);
+		aff = isl_aff_add(aff, isl_aff_copy(shift));
+		mod = isl_val_int_from_isl_int(ctx,
+					    bmap->eqeqo_out + n_out + div);
+		mod = isl_val_abs(mod);
+		aff = isl_aff_mod_val(aff, mod);
+		aff = isl_aff_sub(aff, shift);
+	}
 
-	return isl_map_from_pw_multi_aff(pma);
+	isl_local_space_free(ls);
+	return aff;
 error:
-	isl_pw_multi_aff_free(pma);
+	isl_local_space_free(ls);
+	isl_aff_free(aff);
 	return NULL;
 }
 
-/* Given a basic map with a single output dimension that is defined
- * in terms of the parameters and input dimensions using an equality,
- * extract an isl_aff that expresses the output dimension in terms
+/* Given a basic map with output dimensions defined
+ * in terms of the parameters input dimensions and earlier
+ * output dimensions using an equality (and possibly a pair on inequalities),
+ * extract an isl_aff that expresses output dimension "pos" in terms
  * of the parameters and input dimensions.
  * Note that this expression may involve integer divisions defined
  * in terms of parameters and input dimensions.
+ * "ma" contains the expressions corresponding to earlier output dimensions.
  *
  * This function shares some similarities with
  * isl_basic_map_has_defining_equality and isl_constraint_get_bound.
  */
 static __isl_give isl_aff *extract_isl_aff_from_basic_map(
-	__isl_take isl_basic_map *bmap)
+	__isl_keep isl_basic_map *bmap, int pos, __isl_keep isl_multi_aff *ma)
 {
-	int eq;
-	unsigned offset;
-	unsigned n_div;
-	isl_local_space *ls;
+	int eq, div, ineq;
 	isl_aff *aff;
 
 	if (!bmap)
 		return NULL;
-	if (isl_basic_map_dim(bmap, isl_dim_out) != 1)
-		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
-			"basic map should have a single output dimension",
-			goto error);
-	eq = isl_basic_map_output_defining_equality(bmap, 0);
+	eq = isl_basic_map_output_defining_equality(bmap, pos, &div, &ineq);
 	if (eq >= bmap->n_eq)
 		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
-			"unable to find suitable equality", goto error);
-	ls = isl_basic_map_get_local_space(bmap);
-	aff = isl_aff_alloc(isl_local_space_domain(ls));
-	if (!aff)
-		goto error;
-	offset = isl_basic_map_offset(bmap, isl_dim_out);
-	n_div = isl_basic_map_dim(bmap, isl_dim_div);
-	if (isl_int_is_neg(bmap->eqeqoffset)) {
-		isl_seq_cpy(aff->v->el + 1, bmap->eqeq, offset);
-		isl_seq_cpy(aff->v->el + 1 + offset, bmap->eqeq + offset + 1,
-			    n_div);
-	} else {
-		isl_seq_neg(aff->v->el + 1, bmap->eqeq, offset);
-		isl_seq_neg(aff->v->el + 1 + offset, bmap->eqeq + offset + 1,
-			    n_div);
-	}
-	isl_int_abs(aff->v->el0, bmap->eqeqoffset);
-	isl_basic_map_free(bmap);
+			"unable to find suitable equality", return NULL);
+	aff = extract_aff_from_equality(bmap, pos, eq, div, ineq, ma);
 
 	aff = isl_aff_remove_unused_divs(aff);
 	return aff;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 /* Given a basic map where each output dimension is defined
@@ -4307,7 +4921,7 @@
 	__isl_take isl_basic_map *bmap)
 {
 	int i;
-	unsigned n_out;
+	isl_size n_out;
 	isl_multi_aff *ma;
 
 	if (!bmap)
@@ -4315,16 +4929,13 @@
 
 	ma = isl_multi_aff_alloc(isl_basic_map_get_space(bmap));
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n_out < 0)
+		ma = isl_multi_aff_free(ma);
 
 	for (i = 0; i < n_out; ++i) {
-		isl_basic_map *bmap_i;
 		isl_aff *aff;
 
-		bmap_i = isl_basic_map_copy(bmap);
-		bmap_i = isl_basic_map_project_out(bmap_i, isl_dim_out,
-							i + 1, n_out - (1 + i));
-		bmap_i = isl_basic_map_project_out(bmap_i, isl_dim_out, 0, i);
-		aff = extract_isl_aff_from_basic_map(bmap_i);
+		aff = extract_isl_aff_from_basic_map(bmap, i, ma);
 		ma = isl_multi_aff_set_aff(ma, i, aff);
 	}
 
@@ -4352,12 +4963,22 @@
  * Since some applications expect the result of isl_pw_multi_aff_from_map
  * to only contain integer affine expressions, we compute the floor
  * of the expression before returning.
+ *
+ * Remove all constraints involving local variables without
+ * an explicit representation (resulting in the removal of those
+ * local variables) prior to the actual extraction to ensure
+ * that the local spaces in which the resulting affine expressions
+ * are created do not contain any unknown local variables.
+ * Removing such constraints is safe because constraints involving
+ * unknown local variables are not used to determine whether
+ * a basic map is obviously single-valued.
  */
 static __isl_give isl_pw_multi_aff *plain_pw_multi_aff_from_map(
 	__isl_take isl_set *domain, __isl_take isl_basic_map *bmap)
 {
 	isl_multi_aff *ma;
 
+	bmap = isl_basic_map_drop_constraints_involving_unknown_divs(bmap);
 	ma = extract_isl_multi_aff_from_basic_map(bmap);
 	ma = isl_multi_aff_floor(ma);
 	return isl_pw_multi_aff_alloc(domain, ma);
@@ -4435,25 +5056,29 @@
 	__isl_take isl_map *map, __isl_take isl_basic_map *hull, int d, int i)
 {
 	isl_ctx *ctx;
-	isl_space *space;
+	isl_space *space = NULL;
 	isl_local_space *ls;
 	isl_multi_aff *ma;
 	isl_aff *aff;
 	isl_vec *v;
 	isl_map *insert;
 	int offset;
-	int n;
-	int n_in;
+	isl_size n;
+	isl_size n_in;
 	isl_pw_multi_aff *pma;
-	int is_set;
+	isl_bool is_set;
 
 	is_set = isl_map_is_set(map);
+	if (is_set < 0)
+		goto error;
 
 	offset = isl_basic_map_offset(hull, isl_dim_out);
 	ctx = isl_map_get_ctx(map);
 	space = isl_space_domain(isl_map_get_space(map));
 	n_in = isl_space_dim(space, isl_dim_set);
 	n = isl_space_dim(space, isl_dim_all);
+	if (n_in < 0 || n < 0)
+		goto error;
 
 	v = isl_vec_alloc(ctx, 1 + 1 + n);
 	if (v) {
@@ -4474,13 +5099,18 @@
 						isl_multi_aff_from_aff(aff));
 	}
 
-	insert = isl_map_from_multi_aff(isl_multi_aff_copy(ma));
+	insert = isl_map_from_multi_aff_internal(isl_multi_aff_copy(ma));
 	map = isl_map_apply_domain(map, insert);
 	map = isl_map_equate(map, isl_dim_in, n_in, isl_dim_out, d);
 	pma = isl_pw_multi_aff_from_map(map);
 	pma = isl_pw_multi_aff_pullback_multi_aff(pma, ma);
 
 	return pma;
+error:
+	isl_space_free(space);
+	isl_map_free(map);
+	isl_basic_map_free(hull);
+	return NULL;
 }
 
 /* Is constraint "c" of the form
@@ -4548,29 +5178,31 @@
 static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_check_div(
 	__isl_take isl_map *map)
 {
-	int d, dim;
+	int d;
+	isl_size dim;
 	int i, j, n;
-	int offset, total;
+	int offset;
+	isl_size total;
 	isl_int sum;
 	isl_basic_map *hull;
 
 	hull = isl_map_unshifted_simple_hull(isl_map_copy(map));
-	if (!hull)
+	dim = isl_map_dim(map, isl_dim_out);
+	total = isl_basic_map_dim(hull, isl_dim_all);
+	if (dim < 0 || total < 0)
 		goto error;
 
 	isl_int_init(sum);
-	dim = isl_map_dim(map, isl_dim_out);
 	offset = isl_basic_map_offset(hull, isl_dim_out);
-	total = 1 + isl_basic_map_total_dim(hull);
 	n = hull->n_ineq;
 	for (d = 0; d < dim; ++d) {
 		for (i = 0; i < n; ++i) {
 			if (!is_potential_div_constraint(hull->ineqi,
-							offset, d, total))
+							offset, d, 1 + total))
 				continue;
 			for (j = i + 1; j < n; ++j) {
 				if (!isl_seq_is_neg(hull->ineqi + 1,
-						hull->ineqj + 1, total - 1))
+						hull->ineqj + 1, total))
 					continue;
 				isl_int_add(sum, hull->ineqi0,
 						hull->ineqj0);
@@ -4664,7 +5296,7 @@
  *
  * We basically plug (1) into "map", resulting in a map with "a"
  * in the range instead of "x".  The corresponding isl_pw_multi_aff
- * defining "a" is then plugged back into (1) to obtain a definition fro "x".
+ * defining "a" is then plugged back into (1) to obtain a definition for "x".
  *
  * Specifically, given the input map
  *
@@ -4713,15 +5345,19 @@
 	isl_aff *aff;
 	isl_multi_aff *ma;
 	isl_pw_multi_aff *pma, *id;
-	unsigned n_in;
+	isl_size n_in;
 	unsigned o_out;
-	unsigned n_out;
-	int is_set;
+	isl_size n_out;
+	isl_bool is_set;
 
 	is_set = isl_map_is_set(map);
+	if (is_set < 0)
+		goto error;
 
 	n_in = isl_basic_map_dim(hull, isl_dim_in);
 	n_out = isl_basic_map_dim(hull, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		goto error;
 	o_out = isl_basic_map_offset(hull, isl_dim_out);
 
 	if (is_set)
@@ -4751,7 +5387,7 @@
 		map = set;
 	else
 		map = isl_set_unwrap(set);
-	pma = isl_pw_multi_aff_from_map(set);
+	pma = isl_pw_multi_aff_from_map(map);
 
 	if (!is_set) {
 		space = isl_pw_multi_aff_get_domain_space(pma);
@@ -4764,52 +5400,41 @@
 
 	isl_basic_map_free(hull);
 	return pma;
+error:
+	isl_map_free(map);
+	isl_basic_map_free(hull);
+	return NULL;
 }
 
 /* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
+ * "hull" contains the equalities valid for "map".
  *
- * As a special case, we first check if all output dimensions are uniquely
- * defined in terms of the parameters and input dimensions over the entire
- * domain.  If so, we extract the desired isl_pw_multi_aff directly
- * from the affine hull of "map" and its domain.
- *
- * Otherwise, we check if any of the output dimensions is "strided".
- * That is, we check if can be written as
+ * Check if any of the output dimensions is "strided".
+ * That is, we check if it can be written as
  *
  *	x = m a + f(..)
  *
- * with m greater than 1, a some combination of existentiall quantified
- * variables and f and expression in the parameters and input dimensions.
+ * with m greater than 1, a some combination of existentially quantified
+ * variables and f an expression in the parameters and input dimensions.
  * If so, we remove the stride in pw_multi_aff_from_map_stride.
  *
  * Otherwise, we continue with pw_multi_aff_from_map_check_div for a further
  * special case.
  */
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(__isl_take isl_map *map)
+static __isl_give isl_pw_multi_aff *pw_multi_aff_from_map_check_strides(
+	__isl_take isl_map *map, __isl_take isl_basic_map *hull)
 {
 	int i, j;
-	int sv;
-	isl_basic_map *hull;
-	unsigned n_out;
+	isl_size n_out;
 	unsigned o_out;
-	unsigned n_div;
+	isl_size n_div;
 	unsigned o_div;
 	isl_int gcd;
 
-	if (!map)
-		return NULL;
-
-	hull = isl_map_affine_hull(isl_map_copy(map));
-	sv = isl_basic_map_plain_is_single_valued(hull);
-	if (sv >= 0 && sv)
-		return plain_pw_multi_aff_from_map(isl_map_domain(map), hull);
-	if (sv < 0)
-		hull = isl_basic_map_free(hull);
-	if (!hull)
-		goto error;
-
 	n_div = isl_basic_map_dim(hull, isl_dim_div);
-	o_div = isl_basic_map_offset(hull, isl_dim_div);
+	n_out = isl_basic_map_dim(hull, isl_dim_out);
+	if (n_div < 0 || n_out < 0)
+		goto error;
 
 	if (n_div == 0) {
 		isl_basic_map_free(hull);
@@ -4818,7 +5443,7 @@
 
 	isl_int_init(gcd);
 
-	n_out = isl_basic_map_dim(hull, isl_dim_out);
+	o_div = isl_basic_map_offset(hull, isl_dim_div);
 	o_out = isl_basic_map_offset(hull, isl_dim_out);
 
 	for (i = 0; i < n_out; ++i) {
@@ -4852,18 +5477,77 @@
 	return pw_multi_aff_from_map_check_div(map);
 error:
 	isl_map_free(map);
+	isl_basic_map_free(hull);
+	return NULL;
+}
+
+/* Try and create an isl_pw_multi_aff that is equivalent to the given isl_map.
+ *
+ * As a special case, we first check if all output dimensions are uniquely
+ * defined in terms of the parameters and input dimensions over the entire
+ * domain.  If so, we extract the desired isl_pw_multi_aff directly
+ * from the affine hull of "map" and its domain.
+ *
+ * Otherwise, continue with pw_multi_aff_from_map_check_strides for more
+ * special cases.
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_map(__isl_take isl_map *map)
+{
+	isl_bool sv;
+	isl_size n;
+	isl_basic_map *hull;
+
+	n = isl_map_n_basic_map(map);
+	if (n < 0)
+		goto error;
+
+	if (n == 1) {
+		hull = isl_map_unshifted_simple_hull(isl_map_copy(map));
+		hull = isl_basic_map_plain_affine_hull(hull);
+		sv = isl_basic_map_plain_is_single_valued(hull);
+		if (sv >= 0 && sv)
+			return plain_pw_multi_aff_from_map(isl_map_domain(map),
+							    hull);
+		isl_basic_map_free(hull);
+	}
+	map = isl_map_detect_equalities(map);
+	hull = isl_map_unshifted_simple_hull(isl_map_copy(map));
+	sv = isl_basic_map_plain_is_single_valued(hull);
+	if (sv >= 0 && sv)
+		return plain_pw_multi_aff_from_map(isl_map_domain(map), hull);
+	if (sv >= 0)
+		return pw_multi_aff_from_map_check_strides(map, hull);
+	isl_basic_map_free(hull);
+error:
+	isl_map_free(map);
 	return NULL;
 }
 
+/* This function performs the same operation as isl_pw_multi_aff_from_map,
+ * but is considered as a function on an isl_map when exported.
+ */
+__isl_give isl_pw_multi_aff *isl_map_as_pw_multi_aff(__isl_take isl_map *map)
+{
+	return isl_pw_multi_aff_from_map(map);
+}
+
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_set(__isl_take isl_set *set)
 {
 	return isl_pw_multi_aff_from_map(set);
 }
 
+/* This function performs the same operation as isl_pw_multi_aff_from_set,
+ * but is considered as a function on an isl_set when exported.
+ */
+__isl_give isl_pw_multi_aff *isl_set_as_pw_multi_aff(__isl_take isl_set *set)
+{
+	return isl_pw_multi_aff_from_set(set);
+}
+
 /* Convert "map" into an isl_pw_multi_aff (if possible) and
  * add it to *user.
  */
-static int pw_multi_aff_from_map(__isl_take isl_map *map, void *user)
+static isl_stat pw_multi_aff_from_map(__isl_take isl_map *map, void *user)
 {
 	isl_union_pw_multi_aff **upma = user;
 	isl_pw_multi_aff *pma;
@@ -4871,7 +5555,21 @@
 	pma = isl_pw_multi_aff_from_map(map);
 	*upma = isl_union_pw_multi_aff_add_pw_multi_aff(*upma, pma);
 
-	return *upma ? 0 : -1;
+	return *upma ? isl_stat_ok : isl_stat_error;
+}
+
+/* Create an isl_union_pw_multi_aff with the given isl_aff on a universe
+ * domain.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_aff(
+	__isl_take isl_aff *aff)
+{
+	isl_multi_aff *ma;
+	isl_pw_multi_aff *pma;
+
+	ma = isl_multi_aff_from_aff(aff);
+	pma = isl_pw_multi_aff_from_multi_aff(ma);
+	return isl_union_pw_multi_aff_from_pw_multi_aff(pma);
 }
 
 /* Try and create an isl_union_pw_multi_aff that is equivalent
@@ -4894,6 +5592,16 @@
 	return upma;
 }
 
+/* This function performs the same operation as
+ * isl_union_pw_multi_aff_from_union_map,
+ * but is considered as a function on an isl_union_map when exported.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_map_as_union_pw_multi_aff(
+	__isl_take isl_union_map *umap)
+{
+	return isl_union_pw_multi_aff_from_union_map(umap);
+}
+
 /* Try and create an isl_union_pw_multi_aff that is equivalent
  * to the given isl_union_set.
  * The isl_union_set is required to be a singleton in each space.
@@ -4945,6 +5653,7 @@
 {
 	isl_ctx *ctx;
 	isl_int v;
+	isl_size n_div;
 
 	aff = isl_aff_cow(aff);
 	if (!aff || !subs)
@@ -4954,7 +5663,10 @@
 	if (!isl_space_is_equal(aff->ls->dim, subs->ls->dim))
 		isl_die(ctx, isl_error_invalid,
 			"spaces don't match", return isl_aff_free(aff));
-	if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
+	n_div = isl_aff_domain_dim(subs, isl_dim_div);
+	if (n_div < 0)
+		return isl_aff_free(aff);
+	if (n_div != 0)
 		isl_die(ctx, isl_error_unsupported,
 			"cannot handle divs yet", return isl_aff_free(aff));
 
@@ -4993,8 +5705,9 @@
 		type = isl_dim_set;
 
 	for (i = 0; i < maff->n; ++i) {
-		maff->pi = isl_aff_substitute(maff->pi, type, pos, subs);
-		if (!maff->pi)
+		maff->u.pi = isl_aff_substitute(maff->u.pi,
+						type, pos, subs);
+		if (!maff->u.pi)
 			return isl_multi_aff_free(maff);
 	}
 
@@ -5103,18 +5816,20 @@
  * The multiplication factor f also needs to be multiplied by c_1
  * for the next x_j, j > i.
  */
-void isl_seq_preimage(isl_int *dst, isl_int *src,
+isl_stat isl_seq_preimage(isl_int *dst, isl_int *src,
 	__isl_keep isl_multi_aff *ma, int n_before, int n_after,
 	int n_div_ma, int n_div_bmap,
 	isl_int f, isl_int c1, isl_int c2, isl_int g, int has_denom)
 {
 	int i;
-	int n_param, n_in, n_out;
+	isl_size n_param, n_in, n_out;
 	int o_dst, o_src;
 
 	n_param = isl_multi_aff_dim(ma, isl_dim_param);
 	n_in = isl_multi_aff_dim(ma, isl_dim_in);
 	n_out = isl_multi_aff_dim(ma, isl_dim_out);
+	if (n_param < 0 || n_in < 0 || n_out < 0)
+		return isl_stat_error;
 
 	isl_seq_cpy(dst, src, has_denom + 1 + n_param + n_before);
 	o_dst = o_src = has_denom + 1 + n_param + n_before;
@@ -5135,7 +5850,7 @@
 
 		if (isl_int_is_zero(srcoffset))
 			continue;
-		isl_int_set(c1, ma->pi->v->el0);
+		isl_int_set(c1, ma->u.pi->v->el0);
 		isl_int_mul(c2, f, srcoffset);
 		isl_int_gcd(g, c1, c2);
 		isl_int_divexact(c1, c1, g);
@@ -5145,25 +5860,27 @@
 		o_dst = has_denom;
 		o_src = 1;
 		isl_seq_combine(dst + o_dst, c1, dst + o_dst,
-				c2, ma->pi->v->el + o_src, 1 + n_param);
+				c2, ma->u.pi->v->el + o_src, 1 + n_param);
 		o_dst += 1 + n_param;
 		o_src += 1 + n_param;
 		isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_before);
 		o_dst += n_before;
 		isl_seq_combine(dst + o_dst, c1, dst + o_dst,
-				c2, ma->pi->v->el + o_src, n_in);
+				c2, ma->u.pi->v->el + o_src, n_in);
 		o_dst += n_in;
 		o_src += n_in;
 		isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_after);
 		o_dst += n_after;
 		isl_seq_combine(dst + o_dst, c1, dst + o_dst,
-				c2, ma->pi->v->el + o_src, n_div_ma);
+				c2, ma->u.pi->v->el + o_src, n_div_ma);
 		o_dst += n_div_ma;
 		o_src += n_div_ma;
 		isl_seq_scale(dst + o_dst, dst + o_dst, c1, n_div_bmap);
 		if (has_denom)
 			isl_int_mul(dst0, dst0, c1);
 	}
+
+	return isl_stat_ok;
 }
 
 /* Compute the pullback of "aff" by the function represented by "ma".
@@ -5190,7 +5907,7 @@
 {
 	isl_aff *res = NULL;
 	isl_local_space *ls;
-	int n_div_aff, n_div_ma;
+	isl_size n_div_aff, n_div_ma;
 	isl_int f, c1, c2, g;
 
 	ma = isl_multi_aff_align_divs(ma);
@@ -5198,7 +5915,9 @@
 		goto error;
 
 	n_div_aff = isl_aff_dim(aff, isl_dim_div);
-	n_div_ma = ma->n ? isl_aff_dim(ma->p0, isl_dim_div) : 0;
+	n_div_ma = ma->n ? isl_aff_dim(ma->u.p0, isl_dim_div) : 0;
+	if (n_div_aff < 0 || n_div_ma < 0)
+		goto error;
 
 	ls = isl_aff_get_domain_local_space(aff);
 	ls = isl_local_space_preimage_multi_aff(ls, isl_multi_aff_copy(ma));
@@ -5211,8 +5930,9 @@
 	isl_int_init(c2);
 	isl_int_init(g);
 
-	isl_seq_preimage(res->v->el, aff->v->el, ma, 0, 0, n_div_ma, n_div_aff,
-			f, c1, c2, g, 1);
+	if (isl_seq_preimage(res->v->el, aff->v->el, ma, 0, 0,
+			    n_div_ma, n_div_aff, f, c1, c2, g, 1) < 0)
+		res = isl_aff_free(res);
 
 	isl_int_clear(f);
 	isl_int_clear(c1);
@@ -5248,15 +5968,14 @@
 
 /* Compute the pullback of "ma1" by the function represented by "ma2".
  * In other words, plug in "ma2" in "ma1".
- *
- * The parameters of "ma1" and "ma2" are assumed to have been aligned.
  */
-static __isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff_aligned(
+__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
 	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2)
 {
 	int i;
 	isl_space *space = NULL;
 
+	isl_multi_aff_align_params_bin(&ma1, &ma2);
 	ma2 = isl_multi_aff_align_divs(ma2);
 	ma1 = isl_multi_aff_cow(ma1);
 	if (!ma1 || !ma2)
@@ -5266,9 +5985,9 @@
 				isl_multi_aff_get_space(ma1));
 
 	for (i = 0; i < ma1->n; ++i) {
-		ma1->pi = isl_aff_pullback_multi_aff(ma1->pi,
+		ma1->u.pi = isl_aff_pullback_multi_aff(ma1->u.pi,
 						    isl_multi_aff_copy(ma2));
-		if (!ma1->pi)
+		if (!ma1->u.pi)
 			goto error;
 	}
 
@@ -5282,41 +6001,46 @@
 	return NULL;
 }
 
-/* Compute the pullback of "ma1" by the function represented by "ma2".
- * In other words, plug in "ma2" in "ma1".
- */
-__isl_give isl_multi_aff *isl_multi_aff_pullback_multi_aff(
-	__isl_take isl_multi_aff *ma1, __isl_take isl_multi_aff *ma2)
-{
-	return isl_multi_aff_align_params_multi_multi_and(ma1, ma2,
-				&isl_multi_aff_pullback_multi_aff_aligned);
-}
-
 /* Extend the local space of "dst" to include the divs
  * in the local space of "src".
+ *
+ * If "src" does not have any divs or if the local spaces of "dst" and
+ * "src" are the same, then no extension is required.
  */
 __isl_give isl_aff *isl_aff_align_divs(__isl_take isl_aff *dst,
 	__isl_keep isl_aff *src)
 {
 	isl_ctx *ctx;
+	isl_size src_n_div, dst_n_div;
 	int *exp1 = NULL;
 	int *exp2 = NULL;
+	isl_bool equal;
 	isl_mat *div;
 
 	if (!src || !dst)
 		return isl_aff_free(dst);
 
 	ctx = isl_aff_get_ctx(src);
-	if (!isl_space_is_equal(src->ls->dim, dst->ls->dim))
+	equal = isl_local_space_has_equal_space(src->ls, dst->ls);
+	if (equal < 0)
+		return isl_aff_free(dst);
+	if (!equal)
 		isl_die(ctx, isl_error_invalid,
 			"spaces don't match", goto error);
 
-	if (src->ls->div->n_row == 0)
+	src_n_div = isl_aff_domain_dim(src, isl_dim_div);
+	dst_n_div = isl_aff_domain_dim(dst, isl_dim_div);
+	if (src_n_div == 0)
+		return dst;
+	equal = isl_local_space_is_equal(src->ls, dst->ls);
+	if (equal < 0 || src_n_div < 0 || dst_n_div < 0)
+		return isl_aff_free(dst);
+	if (equal)
 		return dst;
 
-	exp1 = isl_alloc_array(ctx, int, src->ls->div->n_row);
-	exp2 = isl_alloc_array(ctx, int, dst->ls->div->n_row);
-	if (!exp1 || (dst->ls->div->n_row && !exp2))
+	exp1 = isl_alloc_array(ctx, int, src_n_div);
+	exp2 = isl_alloc_array(ctx, int, dst_n_div);
+	if (!exp1 || (dst_n_div && !exp2))
 		goto error;
 
 	div = isl_merge_divs(src->ls->div, dst->ls->div, exp1, exp2);
@@ -5348,10 +6072,10 @@
 		return NULL;
 
 	for (i = 1; i < maff->n; ++i)
-		maff->p0 = isl_aff_align_divs(maff->p0, maff->pi);
+		maff->u.p0 = isl_aff_align_divs(maff->u.p0, maff->u.pi);
 	for (i = 1; i < maff->n; ++i) {
-		maff->pi = isl_aff_align_divs(maff->pi, maff->p0);
-		if (!maff->pi)
+		maff->u.pi = isl_aff_align_divs(maff->u.pi, maff->u.p0);
+		if (!maff->u.pi)
 			return isl_multi_aff_free(maff);
 	}
 
@@ -5381,7 +6105,7 @@
 {
 	int i;
 	isl_space *space;
-	unsigned n_div;
+	isl_size n_div;
 
 	if (ls)
 		*ls = NULL;
@@ -5404,7 +6128,9 @@
 	if (!maff)
 		return NULL;
 
-	n_div = isl_aff_dim(maff->p0, isl_dim_div);
+	n_div = isl_aff_dim(maff->u.p0, isl_dim_div);
+	if (n_div < 0)
+		return isl_multi_aff_free(maff);
 	space = isl_multi_aff_get_space(maff);
 	space = isl_space_lift(isl_space_domain(space), n_div);
 	space = isl_space_extend_domain_with_range(space,
@@ -5415,14 +6141,14 @@
 	maff->space = space;
 
 	if (ls) {
-		*ls = isl_aff_get_domain_local_space(maff->p0);
+		*ls = isl_aff_get_domain_local_space(maff->u.p0);
 		if (!*ls)
 			return isl_multi_aff_free(maff);
 	}
 
 	for (i = 0; i < maff->n; ++i) {
-		maff->pi = isl_aff_lift(maff->pi);
-		if (!maff->pi)
+		maff->u.pi = isl_aff_lift(maff->u.pi);
+		if (!maff->u.pi)
 			goto error;
 	}
 
@@ -5433,24 +6159,27 @@
 	return isl_multi_aff_free(maff);
 }
 
+#undef TYPE
+#define TYPE	isl_pw_multi_aff
+static
+#include "check_type_range_templ.c"
 
 /* Extract an isl_pw_aff corresponding to output dimension "pos" of "pma".
  */
-__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
+__isl_give isl_pw_aff *isl_pw_multi_aff_get_at(
 	__isl_keep isl_pw_multi_aff *pma, int pos)
 {
 	int i;
-	int n_out;
+	isl_size n_out;
 	isl_space *space;
 	isl_pw_aff *pa;
 
-	if (!pma)
+	if (isl_pw_multi_aff_check_range(pma, isl_dim_out, pos, 1) < 0)
 		return NULL;
 
 	n_out = isl_pw_multi_aff_dim(pma, isl_dim_out);
-	if (pos < 0 || pos >= n_out)
-		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
-			"index out of bounds", return NULL);
+	if (n_out < 0)
+		return NULL;
 
 	space = isl_pw_multi_aff_get_space(pma);
 	space = isl_space_drop_dims(space, isl_dim_out,
@@ -5467,6 +6196,14 @@
 	return pa;
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_pw_aff *isl_pw_multi_aff_get_pw_aff(
+	__isl_keep isl_pw_multi_aff *pma, int pos)
+{
+	return isl_pw_multi_aff_get_at(pma, pos);
+}
+
 /* Return an isl_pw_multi_aff with the given "set" as domain and
  * an unnamed zero-dimensional range.
  */
@@ -5485,7 +6222,8 @@
 /* Add an isl_pw_multi_aff with the given "set" as domain and
  * an unnamed zero-dimensional range to *user.
  */
-static int add_pw_multi_aff_from_domain(__isl_take isl_set *set, void *user)
+static isl_stat add_pw_multi_aff_from_domain(__isl_take isl_set *set,
+	void *user)
 {
 	isl_union_pw_multi_aff **upma = user;
 	isl_pw_multi_aff *pma;
@@ -5493,7 +6231,7 @@
 	pma = isl_pw_multi_aff_from_domain(set);
 	*upma = isl_union_pw_multi_aff_add_pw_multi_aff(*upma, pma);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Return an isl_union_pw_multi_aff with the given "uset" as domain and
@@ -5523,70 +6261,29 @@
 	return NULL;
 }
 
-/* Convert "pma" to an isl_map and add it to *umap.
- */
-static int map_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma, void *user)
-{
-	isl_union_map **umap = user;
-	isl_map *map;
-
-	map = isl_map_from_pw_multi_aff(pma);
-	*umap = isl_union_map_add_map(*umap, map);
-
-	return 0;
-}
-
-/* Construct a union map mapping the domain of the union
- * piecewise multi-affine expression to its range, with each dimension
- * in the range equated to the corresponding affine expression on its cell.
- */
-__isl_give isl_union_map *isl_union_map_from_union_pw_multi_aff(
-	__isl_take isl_union_pw_multi_aff *upma)
-{
-	isl_space *space;
-	isl_union_map *umap;
-
-	if (!upma)
-		return NULL;
-
-	space = isl_union_pw_multi_aff_get_space(upma);
-	umap = isl_union_map_empty(space);
-
-	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
-					&map_from_pw_multi_aff, &umap) < 0)
-		goto error;
-
-	isl_union_pw_multi_aff_free(upma);
-	return umap;
-error:
-	isl_union_pw_multi_aff_free(upma);
-	isl_union_map_free(umap);
-	return NULL;
-}
-
 /* Local data for bin_entry and the callback "fn".
  */
 struct isl_union_pw_multi_aff_bin_data {
 	isl_union_pw_multi_aff *upma2;
 	isl_union_pw_multi_aff *res;
 	isl_pw_multi_aff *pma;
-	int (*fn)(void **entry, void *user);
+	isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma, void *user);
 };
 
 /* Given an isl_pw_multi_aff from upma1, store it in data->pma
  * and call data->fn for each isl_pw_multi_aff in data->upma2.
  */
-static int bin_entry(void **entry, void *user)
+static isl_stat bin_entry(__isl_take isl_pw_multi_aff *pma, void *user)
 {
 	struct isl_union_pw_multi_aff_bin_data *data = user;
-	isl_pw_multi_aff *pma = *entry;
+	isl_stat r;
 
 	data->pma = pma;
-	if (isl_hash_table_foreach(data->upma2->dim->ctx, &data->upma2->table,
-				   data->fn, data) < 0)
-		return -1;
+	r = isl_union_pw_multi_aff_foreach_pw_multi_aff(data->upma2,
+				   data->fn, data);
+	isl_pw_multi_aff_free(pma);
 
-	return 0;
+	return r;
 }
 
 /* Call "fn" on each pair of isl_pw_multi_affs in "upma1" and "upma2".
@@ -5597,7 +6294,7 @@
 static __isl_give isl_union_pw_multi_aff *bin_op(
 	__isl_take isl_union_pw_multi_aff *upma1,
 	__isl_take isl_union_pw_multi_aff *upma2,
-	int (*fn)(void **entry, void *user))
+	isl_stat (*fn)(__isl_take isl_pw_multi_aff *pma, void *user))
 {
 	isl_space *space;
 	struct isl_union_pw_multi_aff_bin_data data = { NULL, NULL, NULL, fn };
@@ -5611,9 +6308,8 @@
 		goto error;
 
 	data.upma2 = upma2;
-	data.res = isl_union_pw_multi_aff_alloc(isl_space_copy(upma1->dim),
-				       upma1->table.n);
-	if (isl_hash_table_foreach(upma1->dim->ctx, &upma1->table,
+	data.res = isl_union_pw_multi_aff_alloc_same_size(upma1);
+	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma1,
 				   &bin_entry, &data) < 0)
 		goto error;
 
@@ -5627,14 +6323,15 @@
 	return NULL;
 }
 
-/* Given two aligned isl_pw_multi_affs A -> B and C -> D,
+/* Given two isl_pw_multi_affs A -> B and C -> D,
  * construct an isl_pw_multi_aff (A * C) -> B -> D.
  */
-static __isl_give isl_pw_multi_aff *pw_multi_aff_range_product(
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
 	isl_space *space;
 
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
 	space = isl_space_range_product(isl_pw_multi_aff_get_space(pma1),
 					isl_pw_multi_aff_get_space(pma2));
 	return isl_pw_multi_aff_on_shared_domain_in(pma1, pma2, space,
@@ -5642,23 +6339,14 @@
 }
 
 /* Given two isl_pw_multi_affs A -> B and C -> D,
- * construct an isl_pw_multi_aff (A * C) -> B -> D.
- */
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_range_product(
-	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
-{
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-					    &pw_multi_aff_range_product);
-}
-
-/* Given two aligned isl_pw_multi_affs A -> B and C -> D,
  * construct an isl_pw_multi_aff (A * C) -> (B, D).
  */
-static __isl_give isl_pw_multi_aff *pw_multi_aff_flat_range_product(
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_flat_range_product(
 	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
 {
 	isl_space *space;
 
+	isl_pw_multi_aff_align_params_bin(&pma1, &pma2);
 	space = isl_space_range_product(isl_pw_multi_aff_get_space(pma1),
 					isl_pw_multi_aff_get_space(pma2));
 	space = isl_space_flatten_range(space);
@@ -5666,35 +6354,43 @@
 					    &isl_multi_aff_flat_range_product);
 }
 
-/* Given two isl_pw_multi_affs A -> B and C -> D,
- * construct an isl_pw_multi_aff (A * C) -> (B, D).
- */
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_flat_range_product(
-	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
-{
-	return isl_pw_multi_aff_align_params_pw_pw_and(pma1, pma2,
-					    &pw_multi_aff_flat_range_product);
-}
-
-/* If data->pma and *entry have the same domain space, then compute
- * their flat range product and the result to data->res.
+/* If data->pma and "pma2" have the same domain space, then use "range_product"
+ * to compute some form of range product and add the result to data->res.
  */
-static int flat_range_product_entry(void **entry, void *user)
+static isl_stat gen_range_product_entry(__isl_take isl_pw_multi_aff *pma2,
+	__isl_give isl_pw_multi_aff *(*range_product)(
+		__isl_take isl_pw_multi_aff *pma1,
+		__isl_take isl_pw_multi_aff *pma2),
+	void *user)
 {
 	struct isl_union_pw_multi_aff_bin_data *data = user;
-	isl_pw_multi_aff *pma2 = *entry;
+	isl_bool match;
+	isl_space *space1, *space2;
 
-	if (!isl_space_tuple_is_equal(data->pma->dim, isl_dim_in,
-				 pma2->dim, isl_dim_in))
-		return 0;
+	space1 = isl_pw_multi_aff_peek_space(data->pma);
+	space2 = isl_pw_multi_aff_peek_space(pma2);
+	match = isl_space_tuple_is_equal(space1, isl_dim_in,
+					space2, isl_dim_in);
+	if (match < 0 || !match) {
+		isl_pw_multi_aff_free(pma2);
+		return match < 0 ? isl_stat_error : isl_stat_ok;
+	}
 
-	pma2 = isl_pw_multi_aff_flat_range_product(
-					isl_pw_multi_aff_copy(data->pma),
-					isl_pw_multi_aff_copy(pma2));
+	pma2 = range_product(isl_pw_multi_aff_copy(data->pma), pma2);
 
 	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma2);
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* If data->pma and "pma2" have the same domain space, then compute
+ * their flat range product and add the result to data->res.
+ */
+static isl_stat flat_range_product_entry(__isl_take isl_pw_multi_aff *pma2,
+	void *user)
+{
+	return gen_range_product_entry(pma2,
+				&isl_pw_multi_aff_flat_range_product, user);
 }
 
 /* Given two isl_union_pw_multi_affs A -> B and C -> D,
@@ -5707,6 +6403,26 @@
 	return bin_op(upma1, upma2, &flat_range_product_entry);
 }
 
+/* If data->pma and "pma2" have the same domain space, then compute
+ * their range product and add the result to data->res.
+ */
+static isl_stat range_product_entry(__isl_take isl_pw_multi_aff *pma2,
+	void *user)
+{
+	return gen_range_product_entry(pma2,
+				&isl_pw_multi_aff_range_product, user);
+}
+
+/* Given two isl_union_pw_multi_affs A -> B and C -> D,
+ * construct an isl_union_pw_multi_aff (A * C) -> B -> D.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_product(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2)
+{
+	return bin_op(upma1, upma2, &range_product_entry);
+}
+
 /* Replace the affine expressions at position "pos" in "pma" by "pa".
  * The parameters are assumed to have been aligned.
  *
@@ -5727,9 +6443,8 @@
 					pa->dim, isl_dim_in))
 		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
 			"domains don't match", goto error);
-	if (pos >= isl_pw_multi_aff_dim(pma, isl_dim_out))
-		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_pw_multi_aff_check_range(pma, isl_dim_out, pos, 1) < 0)
+		goto error;
 
 	n = pma->n * pa->n;
 	res = isl_pw_multi_aff_alloc_size(isl_pw_multi_aff_get_space(pma), n);
@@ -5775,14 +6490,18 @@
 	__isl_take isl_pw_multi_aff *pma, unsigned pos,
 	__isl_take isl_pw_aff *pa)
 {
+	isl_bool equal_params;
+
 	if (!pma || !pa)
 		goto error;
-	if (isl_space_match(pma->dim, isl_dim_param, pa->dim, isl_dim_param))
+	equal_params = isl_space_has_equal_params(pma->dim, pa->dim);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return pw_multi_aff_set_pw_aff(pma, pos, pa);
-	if (!isl_space_has_named_params(pma->dim) ||
-	    !isl_space_has_named_params(pa->dim))
-		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
+	if (isl_pw_multi_aff_check_named_params(pma) < 0 ||
+	    isl_pw_aff_check_named_params(pa) < 0)
+		goto error;
 	pma = isl_pw_multi_aff_align_params(pma, isl_pw_aff_get_space(pa));
 	pa = isl_pw_aff_align_params(pa, isl_pw_multi_aff_get_space(pma));
 	return pw_multi_aff_set_pw_aff(pma, pos, pa);
@@ -5794,39 +6513,37 @@
 
 /* Do the parameters of "pa" match those of "space"?
  */
-int isl_pw_aff_matching_params(__isl_keep isl_pw_aff *pa,
+isl_bool isl_pw_aff_matching_params(__isl_keep isl_pw_aff *pa,
 	__isl_keep isl_space *space)
 {
 	isl_space *pa_space;
-	int match;
+	isl_bool match;
 
 	if (!pa || !space)
-		return -1;
+		return isl_bool_error;
 
 	pa_space = isl_pw_aff_get_space(pa);
 
-	match = isl_space_match(space, isl_dim_param, pa_space, isl_dim_param);
+	match = isl_space_has_equal_params(space, pa_space);
 
 	isl_space_free(pa_space);
 	return match;
 }
 
 /* Check that the domain space of "pa" matches "space".
- *
- * Return 0 on success and -1 on error.
  */
-int isl_pw_aff_check_match_domain_space(__isl_keep isl_pw_aff *pa,
+isl_stat isl_pw_aff_check_match_domain_space(__isl_keep isl_pw_aff *pa,
 	__isl_keep isl_space *space)
 {
 	isl_space *pa_space;
-	int match;
+	isl_bool match;
 
 	if (!pa || !space)
-		return -1;
+		return isl_stat_error;
 
 	pa_space = isl_pw_aff_get_space(pa);
 
-	match = isl_space_match(space, isl_dim_param, pa_space, isl_dim_param);
+	match = isl_space_has_equal_params(space, pa_space);
 	if (match < 0)
 		goto error;
 	if (!match)
@@ -5840,16 +6557,129 @@
 		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
 			"domains don't match", goto error);
 	isl_space_free(pa_space);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_space_free(pa_space);
-	return -1;
+	return isl_stat_error;
 }
 
 #undef BASE
 #define BASE pw_aff
+#undef DOMBASE
+#define DOMBASE set
 
+#include <isl_multi_explicit_domain.c>
+#include <isl_multi_pw_aff_explicit_domain.c>
 #include <isl_multi_templ.c>
+#include <isl_multi_add_constant_templ.c>
+#include <isl_multi_apply_set.c>
+#include <isl_multi_arith_templ.c>
+#include <isl_multi_bind_templ.c>
+#include <isl_multi_bind_domain_templ.c>
+#include <isl_multi_coalesce.c>
+#include <isl_multi_domain_templ.c>
+#include <isl_multi_dim_id_templ.c>
+#include <isl_multi_dims.c>
+#include <isl_multi_from_base_templ.c>
+#include <isl_multi_gist.c>
+#include <isl_multi_hash.c>
+#include <isl_multi_identity_templ.c>
+#include <isl_multi_align_set.c>
+#include <isl_multi_insert_domain_templ.c>
+#include <isl_multi_intersect.c>
+#include <isl_multi_min_max_templ.c>
+#include <isl_multi_move_dims_templ.c>
+#include <isl_multi_nan_templ.c>
+#include <isl_multi_param_templ.c>
+#include <isl_multi_product_templ.c>
+#include <isl_multi_splice_templ.c>
+#include <isl_multi_tuple_id_templ.c>
+#include <isl_multi_union_add_templ.c>
+#include <isl_multi_zero_templ.c>
+#include <isl_multi_unbind_params_templ.c>
+
+/* If "mpa" has an explicit domain, then intersect the domain of "map"
+ * with this explicit domain.
+ */
+__isl_give isl_map *isl_map_intersect_multi_pw_aff_explicit_domain(
+	__isl_take isl_map *map, __isl_keep isl_multi_pw_aff *mpa)
+{
+	isl_set *dom;
+
+	if (!isl_multi_pw_aff_has_explicit_domain(mpa))
+		return map;
+
+	dom = isl_multi_pw_aff_domain(isl_multi_pw_aff_copy(mpa));
+	map = isl_map_intersect_domain(map, dom);
+
+	return map;
+}
+
+/* Are all elements of "mpa" piecewise constants?
+ */
+isl_bool isl_multi_pw_aff_is_cst(__isl_keep isl_multi_pw_aff *mpa)
+{
+	return isl_multi_pw_aff_every(mpa, &isl_pw_aff_is_cst);
+}
+
+/* Does "mpa" have a non-trivial explicit domain?
+ *
+ * The explicit domain, if present, is trivial if it represents
+ * an (obviously) universe set.
+ */
+isl_bool isl_multi_pw_aff_has_non_trivial_domain(
+	__isl_keep isl_multi_pw_aff *mpa)
+{
+	if (!mpa)
+		return isl_bool_error;
+	if (!isl_multi_pw_aff_has_explicit_domain(mpa))
+		return isl_bool_false;
+	return isl_bool_not(isl_set_plain_is_universe(mpa->u.dom));
+}
+
+#undef BASE
+#define BASE	set
+
+#include "isl_opt_mpa_templ.c"
+
+/* Compute the minima of the set dimensions as a function of the
+ * parameters, but independently of the other set dimensions.
+ */
+__isl_give isl_multi_pw_aff *isl_set_min_multi_pw_aff(__isl_take isl_set *set)
+{
+	return set_opt_mpa(set, &isl_set_dim_min);
+}
+
+/* Compute the maxima of the set dimensions as a function of the
+ * parameters, but independently of the other set dimensions.
+ */
+__isl_give isl_multi_pw_aff *isl_set_max_multi_pw_aff(__isl_take isl_set *set)
+{
+	return set_opt_mpa(set, &isl_set_dim_max);
+}
+
+#undef BASE
+#define BASE	map
+
+#include "isl_opt_mpa_templ.c"
+
+/* Compute the minima of the output dimensions as a function of the
+ * parameters and input dimensions, but independently of
+ * the other output dimensions.
+ */
+__isl_give isl_multi_pw_aff *isl_map_min_multi_pw_aff(__isl_take isl_map *map)
+{
+	return map_opt_mpa(map, &isl_map_dim_min);
+}
+
+/* Compute the maxima of the output dimensions as a function of the
+ * parameters and input dimensions, but independently of
+ * the other output dimensions.
+ */
+__isl_give isl_multi_pw_aff *isl_map_max_multi_pw_aff(__isl_take isl_map *map)
+{
+	return map_opt_mpa(map, &isl_map_dim_max);
+}
 
 /* Scale the elements of "pma" by the corresponding elements of "mv".
  */
@@ -5857,6 +6687,7 @@
 	__isl_take isl_pw_multi_aff *pma, __isl_take isl_multi_val *mv)
 {
 	int i;
+	isl_bool equal_params;
 
 	pma = isl_pw_multi_aff_cow(pma);
 	if (!pma || !mv)
@@ -5865,8 +6696,10 @@
 					mv->space, isl_dim_set))
 		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
 			"spaces don't match", goto error);
-	if (!isl_space_match(pma->dim, isl_dim_param,
-					mv->space, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(pma->dim, mv->space);
+	if (equal_params < 0)
+		goto error;
+	if (!equal_params) {
 		pma = isl_pw_multi_aff_align_params(pma,
 					    isl_multi_val_get_space(mv));
 		mv = isl_multi_val_align_params(mv,
@@ -5890,39 +6723,26 @@
 	return NULL;
 }
 
-/* Internal data structure for isl_union_pw_multi_aff_scale_multi_val.
- * mv contains the mv argument.
- * res collects the results.
- */
-struct isl_union_pw_multi_aff_scale_multi_val_data {
-	isl_multi_val *mv;
-	isl_union_pw_multi_aff *res;
-};
-
 /* This function is called for each entry of an isl_union_pw_multi_aff.
  * If the space of the entry matches that of data->mv,
- * then apply isl_pw_multi_aff_scale_multi_val and add the result
- * to data->res.
+ * then apply isl_pw_multi_aff_scale_multi_val and return the result.
+ * Otherwise, return an empty isl_pw_multi_aff.
  */
-static int union_pw_multi_aff_scale_multi_val_entry(void **entry, void *user)
+static __isl_give isl_pw_multi_aff *union_pw_multi_aff_scale_multi_val_entry(
+	__isl_take isl_pw_multi_aff *pma, void *user)
 {
-	struct isl_union_pw_multi_aff_scale_multi_val_data *data = user;
-	isl_pw_multi_aff *pma = *entry;
+	isl_multi_val *mv = user;
 
 	if (!pma)
-		return -1;
+		return NULL;
 	if (!isl_space_tuple_is_equal(pma->dim, isl_dim_out,
-				    data->mv->space, isl_dim_set))
-		return 0;
-
-	pma = isl_pw_multi_aff_copy(pma);
-	pma = isl_pw_multi_aff_scale_multi_val(pma,
-						isl_multi_val_copy(data->mv));
-	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma);
-	if (!data->res)
-		return -1;
+				    mv->space, isl_dim_set)) {
+		isl_space *space = isl_pw_multi_aff_get_space(pma);
+		isl_pw_multi_aff_free(pma);
+		return isl_pw_multi_aff_empty(space);
+	}
 
-	return 0;
+	return isl_pw_multi_aff_scale_multi_val(pma, isl_multi_val_copy(mv));
 }
 
 /* Scale the elements of "upma" by the corresponding elements of "mv",
@@ -5931,7 +6751,10 @@
 __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_scale_multi_val(
 	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_multi_val *mv)
 {
-	struct isl_union_pw_multi_aff_scale_multi_val_data data;
+	struct isl_union_pw_multi_aff_transform_control control = {
+		.fn = &union_pw_multi_aff_scale_multi_val_entry,
+		.fn_user = mv,
+	};
 
 	upma = isl_union_pw_multi_aff_align_params(upma,
 						isl_multi_val_get_space(mv));
@@ -5940,16 +6763,10 @@
 	if (!upma || !mv)
 		goto error;
 
-	data.mv = mv;
-	data.res = isl_union_pw_multi_aff_alloc(isl_space_copy(upma->dim),
-						upma->table.n);
-	if (isl_hash_table_foreach(upma->dim->ctx, &upma->table,
-		       &union_pw_multi_aff_scale_multi_val_entry, &data) < 0)
-		goto error;
+	return isl_union_pw_multi_aff_transform(upma, &control);
 
 	isl_multi_val_free(mv);
-	isl_union_pw_multi_aff_free(upma);
-	return data.res;
+	return upma;
 error:
 	isl_multi_val_free(mv);
 	isl_union_pw_multi_aff_free(upma);
@@ -5994,83 +6811,27 @@
 	return pma;
 }
 
-/* Construct a set or map mapping the shared (parameter) domain
- * of the piecewise affine expressions to the range of "mpa"
- * with each dimension in the range equated to the
- * corresponding piecewise affine expression.
+/* Construct and return a piecewise multi affine expression
+ * that is equal to the given multi piecewise affine expression
+ * on the shared domain of the piecewise affine expressions,
+ * in the special case of a 0D multi piecewise affine expression.
+ *
+ * Create a piecewise multi affine expression with the explicit domain of
+ * the 0D multi piecewise affine expression as domain.
  */
-static __isl_give isl_map *map_from_multi_pw_aff(
+static __isl_give isl_pw_multi_aff *isl_pw_multi_aff_from_multi_pw_aff_0D(
 	__isl_take isl_multi_pw_aff *mpa)
 {
-	int i;
 	isl_space *space;
-	isl_map *map;
-
-	if (!mpa)
-		return NULL;
-
-	if (isl_space_dim(mpa->space, isl_dim_out) != mpa->n)
-		isl_die(isl_multi_pw_aff_get_ctx(mpa), isl_error_internal,
-			"invalid space", goto error);
-
-	space = isl_multi_pw_aff_get_domain_space(mpa);
-	map = isl_map_universe(isl_space_from_domain(space));
-
-	for (i = 0; i < mpa->n; ++i) {
-		isl_pw_aff *pa;
-		isl_map *map_i;
-
-		pa = isl_pw_aff_copy(mpa->pi);
-		map_i = map_from_pw_aff(pa);
-
-		map = isl_map_flat_range_product(map, map_i);
-	}
-
-	map = isl_map_reset_space(map, isl_multi_pw_aff_get_space(mpa));
+	isl_set *dom;
+	isl_multi_aff *ma;
 
+	space = isl_multi_pw_aff_get_space(mpa);
+	dom = isl_multi_pw_aff_get_explicit_domain(mpa);
 	isl_multi_pw_aff_free(mpa);
-	return map;
-error:
-	isl_multi_pw_aff_free(mpa);
-	return NULL;
-}
 
-/* Construct a map mapping the shared domain
- * of the piecewise affine expressions to the range of "mpa"
- * with each dimension in the range equated to the
- * corresponding piecewise affine expression.
- */
-__isl_give isl_map *isl_map_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa)
-{
-	if (!mpa)
-		return NULL;
-	if (isl_space_is_set(mpa->space))
-		isl_die(isl_multi_pw_aff_get_ctx(mpa), isl_error_internal,
-			"space of input is not a map", goto error);
-
-	return map_from_multi_pw_aff(mpa);
-error:
-	isl_multi_pw_aff_free(mpa);
-	return NULL;
-}
-
-/* Construct a set mapping the shared parameter domain
- * of the piecewise affine expressions to the space of "mpa"
- * with each dimension in the range equated to the
- * corresponding piecewise affine expression.
- */
-__isl_give isl_set *isl_set_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa)
-{
-	if (!mpa)
-		return NULL;
-	if (!isl_space_is_set(mpa->space))
-		isl_die(isl_multi_pw_aff_get_ctx(mpa), isl_error_internal,
-			"space of input is not a set", goto error);
-
-	return map_from_multi_pw_aff(mpa);
-error:
-	isl_multi_pw_aff_free(mpa);
-	return NULL;
+	ma = isl_multi_aff_zero(space);
+	return isl_pw_multi_aff_alloc(dom, ma);
 }
 
 /* Construct and return a piecewise multi affine expression
@@ -6088,13 +6849,10 @@
 	if (!mpa)
 		return NULL;
 
-	space = isl_multi_pw_aff_get_space(mpa);
-
-	if (mpa->n == 0) {
-		isl_multi_pw_aff_free(mpa);
-		return isl_pw_multi_aff_zero(space);
-	}
+	if (mpa->n == 0)
+		return isl_pw_multi_aff_from_multi_pw_aff_0D(mpa);
 
+	space = isl_multi_pw_aff_get_space(mpa);
 	pa = isl_multi_pw_aff_get_pw_aff(mpa, 0);
 	pma = isl_pw_multi_aff_from_pw_aff(pa);
 
@@ -6112,19 +6870,30 @@
 	return pma;
 }
 
+/* Convenience function that constructs an isl_multi_pw_aff
+ * directly from an isl_aff.
+ */
+__isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_aff(__isl_take isl_aff *aff)
+{
+	return isl_multi_pw_aff_from_pw_aff(isl_pw_aff_from_aff(aff));
+}
+
 /* Construct and return a multi piecewise affine expression
  * that is equal to the given multi affine expression.
  */
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_multi_aff(
 	__isl_take isl_multi_aff *ma)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_multi_pw_aff *mpa;
 
+	n = isl_multi_aff_dim(ma, isl_dim_out);
+	if (n < 0)
+		ma = isl_multi_aff_free(ma);
 	if (!ma)
 		return NULL;
 
-	n = isl_multi_aff_dim(ma, isl_dim_out);
 	mpa = isl_multi_pw_aff_alloc(isl_multi_aff_get_space(ma));
 
 	for (i = 0; i < n; ++i) {
@@ -6138,20 +6907,33 @@
 	return mpa;
 }
 
+/* This function performs the same operation as isl_multi_pw_aff_from_multi_aff,
+ * but is considered as a function on an isl_multi_aff when exported.
+ */
+__isl_give isl_multi_pw_aff *isl_multi_aff_to_multi_pw_aff(
+	__isl_take isl_multi_aff *ma)
+{
+	return isl_multi_pw_aff_from_multi_aff(ma);
+}
+
 /* Construct and return a multi piecewise affine expression
  * that is equal to the given piecewise multi affine expression.
+ *
+ * If the resulting multi piecewise affine expression has
+ * an explicit domain, then assign it the domain of the input.
+ * In other cases, the domain is stored in the individual elements.
  */
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_from_pw_multi_aff(
 	__isl_take isl_pw_multi_aff *pma)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_space *space;
 	isl_multi_pw_aff *mpa;
 
-	if (!pma)
-		return NULL;
-
 	n = isl_pw_multi_aff_dim(pma, isl_dim_out);
+	if (n < 0)
+		pma = isl_pw_multi_aff_free(pma);
 	space = isl_pw_multi_aff_get_space(pma);
 	mpa = isl_multi_pw_aff_alloc(space);
 
@@ -6161,30 +6943,57 @@
 		pa = isl_pw_multi_aff_get_pw_aff(pma, i);
 		mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
 	}
+	if (isl_multi_pw_aff_has_explicit_domain(mpa)) {
+		isl_set *dom;
+
+		dom = isl_pw_multi_aff_domain(isl_pw_multi_aff_copy(pma));
+		mpa = isl_multi_pw_aff_intersect_domain(mpa, dom);
+	}
 
 	isl_pw_multi_aff_free(pma);
 	return mpa;
 }
 
+/* This function performs the same operation as
+ * isl_multi_pw_aff_from_pw_multi_aff,
+ * but is considered as a function on an isl_pw_multi_aff when exported.
+ */
+__isl_give isl_multi_pw_aff *isl_pw_multi_aff_to_multi_pw_aff(
+	__isl_take isl_pw_multi_aff *pma)
+{
+	return isl_multi_pw_aff_from_pw_multi_aff(pma);
+}
+
 /* Do "pa1" and "pa2" represent the same function?
  *
  * We first check if they are obviously equal.
  * If not, we convert them to maps and check if those are equal.
+ *
+ * If "pa1" or "pa2" contain any NaNs, then they are considered
+ * not to be the same.  A NaN is not equal to anything, not even
+ * to another NaN.
  */
-int isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1, __isl_keep isl_pw_aff *pa2)
+isl_bool isl_pw_aff_is_equal(__isl_keep isl_pw_aff *pa1,
+	__isl_keep isl_pw_aff *pa2)
 {
-	int equal;
+	isl_bool equal;
+	isl_bool has_nan;
 	isl_map *map1, *map2;
 
 	if (!pa1 || !pa2)
-		return -1;
+		return isl_bool_error;
 
 	equal = isl_pw_aff_plain_is_equal(pa1, pa2);
 	if (equal < 0 || equal)
 		return equal;
+	has_nan = either_involves_nan(pa1, pa2);
+	if (has_nan < 0)
+		return isl_bool_error;
+	if (has_nan)
+		return isl_bool_false;
 
-	map1 = map_from_pw_aff(isl_pw_aff_copy(pa1));
-	map2 = map_from_pw_aff(isl_pw_aff_copy(pa2));
+	map1 = isl_map_from_pw_aff_internal(isl_pw_aff_copy(pa1));
+	map2 = isl_map_from_pw_aff_internal(isl_pw_aff_copy(pa2));
 	equal = isl_map_is_equal(map1, map2);
 	isl_map_free(map1);
 	isl_map_free(map2);
@@ -6198,21 +7007,23 @@
  * to a map because the domains of the piecewise affine expressions
  * may not be the same.
  */
-int isl_multi_pw_aff_is_equal(__isl_keep isl_multi_pw_aff *mpa1,
+isl_bool isl_multi_pw_aff_is_equal(__isl_keep isl_multi_pw_aff *mpa1,
 	__isl_keep isl_multi_pw_aff *mpa2)
 {
 	int i;
-	int equal;
+	isl_bool equal, equal_params;
 
 	if (!mpa1 || !mpa2)
-		return -1;
+		return isl_bool_error;
 
-	if (!isl_space_match(mpa1->space, isl_dim_param,
-			     mpa2->space, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(mpa1->space, mpa2->space);
+	if (equal_params < 0)
+		return isl_bool_error;
+	if (!equal_params) {
 		if (!isl_space_has_named_params(mpa1->space))
-			return 0;
+			return isl_bool_false;
 		if (!isl_space_has_named_params(mpa2->space))
-			return 0;
+			return isl_bool_false;
 		mpa1 = isl_multi_pw_aff_copy(mpa1);
 		mpa2 = isl_multi_pw_aff_copy(mpa2);
 		mpa1 = isl_multi_pw_aff_align_params(mpa1,
@@ -6230,44 +7041,58 @@
 		return equal;
 
 	for (i = 0; i < mpa1->n; ++i) {
-		equal = isl_pw_aff_is_equal(mpa1->pi, mpa2->pi);
+		equal = isl_pw_aff_is_equal(mpa1->u.pi, mpa2->u.pi);
 		if (equal < 0 || !equal)
 			return equal;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-/* Coalesce the elements of "mpa".
+/* Do "pma1" and "pma2" represent the same function?
+ *
+ * First check if they are obviously equal.
+ * If not, then convert them to maps and check if those are equal.
  *
- * Note that such coalescing does not change the meaning of "mpa"
- * so there is no need to cow.  We do need to be careful not to
- * destroy any other copies of "mpa" in case of failure.
+ * If "pa1" or "pa2" contain any NaNs, then they are considered
+ * not to be the same.  A NaN is not equal to anything, not even
+ * to another NaN.
  */
-__isl_give isl_multi_pw_aff *isl_multi_pw_aff_coalesce(
-	__isl_take isl_multi_pw_aff *mpa)
+isl_bool isl_pw_multi_aff_is_equal(__isl_keep isl_pw_multi_aff *pma1,
+	__isl_keep isl_pw_multi_aff *pma2)
 {
-	int i;
+	isl_bool equal;
+	isl_bool has_nan;
+	isl_map *map1, *map2;
 
-	if (!mpa)
-		return NULL;
+	if (!pma1 || !pma2)
+		return isl_bool_error;
 
-	for (i = 0; i < mpa->n; ++i) {
-		isl_pw_aff *pa = isl_pw_aff_copy(mpa->pi);
-		pa = isl_pw_aff_coalesce(pa);
-		if (!pa)
-			return isl_multi_pw_aff_free(mpa);
-		isl_pw_aff_free(mpa->pi);
-		mpa->pi = pa;
-	}
+	equal = isl_pw_multi_aff_plain_is_equal(pma1, pma2);
+	if (equal < 0 || equal)
+		return equal;
+	has_nan = isl_pw_multi_aff_involves_nan(pma1);
+	if (has_nan >= 0 && !has_nan)
+		has_nan = isl_pw_multi_aff_involves_nan(pma2);
+	if (has_nan < 0 || has_nan)
+		return isl_bool_not(has_nan);
 
-	return mpa;
+	map1 = isl_map_from_pw_multi_aff_internal(isl_pw_multi_aff_copy(pma1));
+	map2 = isl_map_from_pw_multi_aff_internal(isl_pw_multi_aff_copy(pma2));
+	equal = isl_map_is_equal(map1, map2);
+	isl_map_free(map1);
+	isl_map_free(map2);
+
+	return equal;
 }
 
 /* Compute the pullback of "mpa" by the function represented by "ma".
  * In other words, plug in "ma" in "mpa".
  *
  * The parameters of "mpa" and "ma" are assumed to have been aligned.
+ *
+ * If "mpa" has an explicit domain, then it is this domain
+ * that needs to undergo a pullback, i.e., a preimage.
  */
 static __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_aff_aligned(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_multi_aff *ma)
@@ -6285,9 +7110,15 @@
 		goto error;
 
 	for (i = 0; i < mpa->n; ++i) {
-		mpa->pi = isl_pw_aff_pullback_multi_aff(mpa->pi,
+		mpa->u.pi = isl_pw_aff_pullback_multi_aff(mpa->u.pi,
 						    isl_multi_aff_copy(ma));
-		if (!mpa->pi)
+		if (!mpa->u.pi)
+			goto error;
+	}
+	if (isl_multi_pw_aff_has_explicit_domain(mpa)) {
+		mpa->u.dom = isl_set_preimage_multi_aff(mpa->u.dom,
+							isl_multi_aff_copy(ma));
+		if (!mpa->u.dom)
 			goto error;
 	}
 
@@ -6308,10 +7139,14 @@
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_multi_aff *ma)
 {
+	isl_bool equal_params;
+
 	if (!mpa || !ma)
 		goto error;
-	if (isl_space_match(mpa->space, isl_dim_param,
-			    ma->space, isl_dim_param))
+	equal_params = isl_space_has_equal_params(mpa->space, ma->space);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return isl_multi_pw_aff_pullback_multi_aff_aligned(mpa, ma);
 	mpa = isl_multi_pw_aff_align_params(mpa, isl_multi_aff_get_space(ma));
 	ma = isl_multi_aff_align_params(ma, isl_multi_pw_aff_get_space(mpa));
@@ -6326,6 +7161,9 @@
  * In other words, plug in "pma" in "mpa".
  *
  * The parameters of "mpa" and "mpa" are assumed to have been aligned.
+ *
+ * If "mpa" has an explicit domain, then it is this domain
+ * that needs to undergo a pullback, i.e., a preimage.
  */
 static __isl_give isl_multi_pw_aff *
 isl_multi_pw_aff_pullback_pw_multi_aff_aligned(
@@ -6342,9 +7180,15 @@
 				isl_multi_pw_aff_get_space(mpa));
 
 	for (i = 0; i < mpa->n; ++i) {
-		mpa->pi = isl_pw_aff_pullback_pw_multi_aff_aligned(mpa->pi,
+		mpa->u.pi = isl_pw_aff_pullback_pw_multi_aff_aligned(
+				    mpa->u.pi, isl_pw_multi_aff_copy(pma));
+		if (!mpa->u.pi)
+			goto error;
+	}
+	if (isl_multi_pw_aff_has_explicit_domain(mpa)) {
+		mpa->u.dom = isl_set_preimage_pw_multi_aff(mpa->u.dom,
 						    isl_pw_multi_aff_copy(pma));
-		if (!mpa->pi)
+		if (!mpa->u.dom)
 			goto error;
 	}
 
@@ -6365,9 +7209,14 @@
 __isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_pw_multi_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_pw_multi_aff *pma)
 {
+	isl_bool equal_params;
+
 	if (!mpa || !pma)
 		goto error;
-	if (isl_space_match(mpa->space, isl_dim_param, pma->dim, isl_dim_param))
+	equal_params = isl_space_has_equal_params(mpa->space, pma->dim);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return isl_multi_pw_aff_pullback_pw_multi_aff_aligned(mpa, pma);
 	mpa = isl_multi_pw_aff_align_params(mpa,
 					    isl_pw_multi_aff_get_space(pma));
@@ -6393,22 +7242,24 @@
 static __isl_give isl_pw_aff *isl_multi_pw_aff_apply_aff_aligned(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_aff *aff)
 {
-	int i, n_param, n_in, n_div;
+	int i;
+	isl_size n_in, n_div, n_mpa_in;
 	isl_space *space;
 	isl_val *v;
 	isl_pw_aff *pa;
 	isl_aff *tmp;
 
-	n_param = isl_aff_dim(aff, isl_dim_param);
 	n_in = isl_aff_dim(aff, isl_dim_in);
 	n_div = isl_aff_dim(aff, isl_dim_div);
+	n_mpa_in = isl_multi_pw_aff_dim(mpa, isl_dim_in);
+	if (n_in < 0 || n_div < 0 || n_mpa_in < 0)
+		goto error;
 
 	space = isl_space_domain(isl_multi_pw_aff_get_space(mpa));
 	tmp = isl_aff_copy(aff);
 	tmp = isl_aff_drop_dims(tmp, isl_dim_div, 0, n_div);
 	tmp = isl_aff_drop_dims(tmp, isl_dim_in, 0, n_in);
-	tmp = isl_aff_add_dims(tmp, isl_dim_in,
-				isl_space_dim(space, isl_dim_set));
+	tmp = isl_aff_add_dims(tmp, isl_dim_in, n_mpa_in);
 	tmp = isl_aff_reset_domain_space(tmp, space);
 	pa = isl_pw_aff_from_aff(tmp);
 
@@ -6442,6 +7293,10 @@
 	isl_aff_free(aff);
 
 	return pa;
+error:
+	isl_multi_pw_aff_free(mpa);
+	isl_aff_free(aff);
+	return NULL;
 }
 
 /* Apply "aff" to "mpa".  The range of "mpa" needs to be compatible
@@ -6451,10 +7306,14 @@
 __isl_give isl_pw_aff *isl_multi_pw_aff_apply_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_aff *aff)
 {
+	isl_bool equal_params;
+
 	if (!aff || !mpa)
 		goto error;
-	if (isl_space_match(aff->ls->dim, isl_dim_param,
-				mpa->space, isl_dim_param))
+	equal_params = isl_space_has_equal_params(aff->ls->dim, mpa->space);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return isl_multi_pw_aff_apply_aff_aligned(mpa, aff);
 
 	aff = isl_aff_align_params(aff, isl_multi_pw_aff_get_space(mpa));
@@ -6520,9 +7379,14 @@
 __isl_give isl_pw_aff *isl_multi_pw_aff_apply_pw_aff(
 	__isl_take isl_multi_pw_aff *mpa, __isl_take isl_pw_aff *pa)
 {
+	isl_bool equal_params;
+
 	if (!pa || !mpa)
 		goto error;
-	if (isl_space_match(pa->dim, isl_dim_param, mpa->space, isl_dim_param))
+	equal_params = isl_space_has_equal_params(pa->dim, mpa->space);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return isl_multi_pw_aff_apply_pw_aff_aligned(mpa, pa);
 
 	pa = isl_pw_aff_align_params(pa, isl_multi_pw_aff_get_space(mpa));
@@ -6561,17 +7425,18 @@
 /* Compute the pullback of "mpa1" by the function represented by "mpa2".
  * In other words, plug in "mpa2" in "mpa1".
  *
- * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
- *
  * We pullback each member of "mpa1" in turn.
+ *
+ * If "mpa1" has an explicit domain, then it is this domain
+ * that needs to undergo a pullback instead, i.e., a preimage.
  */
-static __isl_give isl_multi_pw_aff *
-isl_multi_pw_aff_pullback_multi_pw_aff_aligned(
+__isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_pw_aff(
 	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2)
 {
 	int i;
 	isl_space *space = NULL;
 
+	isl_multi_pw_aff_align_params_bin(&mpa1, &mpa2);
 	mpa1 = isl_multi_pw_aff_cow(mpa1);
 	if (!mpa1 || !mpa2)
 		goto error;
@@ -6580,12 +7445,18 @@
 				isl_multi_pw_aff_get_space(mpa1));
 
 	for (i = 0; i < mpa1->n; ++i) {
-		mpa1->pi = isl_pw_aff_pullback_multi_pw_aff_aligned(
-				mpa1->pi, isl_multi_pw_aff_copy(mpa2));
-		if (!mpa1->pi)
+		mpa1->u.pi = isl_pw_aff_pullback_multi_pw_aff_aligned(
+				mpa1->u.pi, isl_multi_pw_aff_copy(mpa2));
+		if (!mpa1->u.pi)
 			goto error;
 	}
 
+	if (isl_multi_pw_aff_has_explicit_domain(mpa1)) {
+		mpa1->u.dom = isl_set_preimage_multi_pw_aff(mpa1->u.dom,
+						isl_multi_pw_aff_copy(mpa2));
+		if (!mpa1->u.dom)
+			goto error;
+	}
 	mpa1 = isl_multi_pw_aff_reset_space(mpa1, space);
 
 	isl_multi_pw_aff_free(mpa2);
@@ -6597,16 +7468,194 @@
 	return NULL;
 }
 
-/* Compute the pullback of "mpa1" by the function represented by "mpa2".
- * In other words, plug in "mpa2" in "mpa1".
+/* Align the parameters of "mpa1" and "mpa2", check that the ranges
+ * of "mpa1" and "mpa2" live in the same space, construct map space
+ * between the domain spaces of "mpa1" and "mpa2" and call "order"
+ * with this map space as extract argument.
+ */
+static __isl_give isl_map *isl_multi_pw_aff_order_map(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2,
+	__isl_give isl_map *(*order)(__isl_keep isl_multi_pw_aff *mpa1,
+		__isl_keep isl_multi_pw_aff *mpa2, __isl_take isl_space *space))
+{
+	int match;
+	isl_space *space1, *space2;
+	isl_map *res;
+
+	mpa1 = isl_multi_pw_aff_align_params(mpa1,
+					    isl_multi_pw_aff_get_space(mpa2));
+	mpa2 = isl_multi_pw_aff_align_params(mpa2,
+					    isl_multi_pw_aff_get_space(mpa1));
+	if (!mpa1 || !mpa2)
+		goto error;
+	match = isl_space_tuple_is_equal(mpa1->space, isl_dim_out,
+					mpa2->space, isl_dim_out);
+	if (match < 0)
+		goto error;
+	if (!match)
+		isl_die(isl_multi_pw_aff_get_ctx(mpa1), isl_error_invalid,
+			"range spaces don't match", goto error);
+	space1 = isl_space_domain(isl_multi_pw_aff_get_space(mpa1));
+	space2 = isl_space_domain(isl_multi_pw_aff_get_space(mpa2));
+	space1 = isl_space_map_from_domain_and_range(space1, space2);
+
+	res = order(mpa1, mpa2, space1);
+	isl_multi_pw_aff_free(mpa1);
+	isl_multi_pw_aff_free(mpa2);
+	return res;
+error:
+	isl_multi_pw_aff_free(mpa1);
+	isl_multi_pw_aff_free(mpa2);
+	return NULL;
+}
+
+/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
+ * where the function values are equal.  "space" is the space of the result.
+ * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
+ *
+ * "mpa1" and "mpa2" are equal when each of the pairs of elements
+ * in the sequences are equal.
  */
-__isl_give isl_multi_pw_aff *isl_multi_pw_aff_pullback_multi_pw_aff(
-	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2)
+static __isl_give isl_map *isl_multi_pw_aff_eq_map_on_space(
+	__isl_keep isl_multi_pw_aff *mpa1, __isl_keep isl_multi_pw_aff *mpa2,
+	__isl_take isl_space *space)
 {
-	return isl_multi_pw_aff_align_params_multi_multi_and(mpa1, mpa2,
-			&isl_multi_pw_aff_pullback_multi_pw_aff_aligned);
+	int i;
+	isl_size n;
+	isl_map *res;
+
+	n = isl_multi_pw_aff_dim(mpa1, isl_dim_out);
+	if (n < 0)
+		space = isl_space_free(space);
+	res = isl_map_universe(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_pw_aff *pa1, *pa2;
+		isl_map *map;
+
+		pa1 = isl_multi_pw_aff_get_pw_aff(mpa1, i);
+		pa2 = isl_multi_pw_aff_get_pw_aff(mpa2, i);
+		map = isl_pw_aff_eq_map(pa1, pa2);
+		res = isl_map_intersect(res, map);
+	}
+
+	return res;
 }
 
+/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
+ * where the function values are equal.
+ */
+__isl_give isl_map *isl_multi_pw_aff_eq_map(__isl_take isl_multi_pw_aff *mpa1,
+	__isl_take isl_multi_pw_aff *mpa2)
+{
+	return isl_multi_pw_aff_order_map(mpa1, mpa2,
+					    &isl_multi_pw_aff_eq_map_on_space);
+}
+
+/* Intersect "map" with the result of applying "order"
+ * on two copies of "mpa".
+ */
+static __isl_give isl_map *isl_map_order_at_multi_pw_aff(
+	__isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa,
+	__isl_give isl_map *(*order)(__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2))
+{
+	return isl_map_intersect(map, order(mpa, isl_multi_pw_aff_copy(mpa)));
+}
+
+/* Return the subset of "map" where the domain and the range
+ * have equal "mpa" values.
+ */
+__isl_give isl_map *isl_map_eq_at_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *mpa)
+{
+	return isl_map_order_at_multi_pw_aff(map, mpa,
+						&isl_multi_pw_aff_eq_map);
+}
+
+/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
+ * where the function values of "mpa1" lexicographically satisfies
+ * "strict_base"/"base" compared to that of "mpa2".
+ * "space" is the space of the result.
+ * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
+ *
+ * "mpa1" lexicographically satisfies "strict_base"/"base" compared to "mpa2"
+ * if, for some i, the i-th element of "mpa1" satisfies "strict_base"/"base"
+ * when compared to the i-th element of "mpa2" while all previous elements are
+ * pairwise equal.
+ * In particular, if i corresponds to the final elements
+ * then they need to satisfy "base", while "strict_base" needs to be satisfied
+ * for other values of i.
+ * If "base" is a strict order, then "base" and "strict_base" are the same.
+ */
+static __isl_give isl_map *isl_multi_pw_aff_lex_map_on_space(
+	__isl_keep isl_multi_pw_aff *mpa1, __isl_keep isl_multi_pw_aff *mpa2,
+	__isl_give isl_map *(*strict_base)(__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2),
+	__isl_give isl_map *(*base)(__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2),
+	__isl_take isl_space *space)
+{
+	int i;
+	isl_size n;
+	isl_map *res, *rest;
+
+	n = isl_multi_pw_aff_dim(mpa1, isl_dim_out);
+	if (n < 0)
+		space = isl_space_free(space);
+	res = isl_map_empty(isl_space_copy(space));
+	rest = isl_map_universe(space);
+
+	for (i = 0; i < n; ++i) {
+		int last;
+		isl_pw_aff *pa1, *pa2;
+		isl_map *map;
+
+		last = i == n - 1;
+
+		pa1 = isl_multi_pw_aff_get_pw_aff(mpa1, i);
+		pa2 = isl_multi_pw_aff_get_pw_aff(mpa2, i);
+		map = last ? base(pa1, pa2) : strict_base(pa1, pa2);
+		map = isl_map_intersect(map, isl_map_copy(rest));
+		res = isl_map_union(res, map);
+
+		if (last)
+			continue;
+
+		pa1 = isl_multi_pw_aff_get_pw_aff(mpa1, i);
+		pa2 = isl_multi_pw_aff_get_pw_aff(mpa2, i);
+		map = isl_pw_aff_eq_map(pa1, pa2);
+		rest = isl_map_intersect(rest, map);
+	}
+
+	isl_map_free(rest);
+	return res;
+}
+
+#undef ORDER
+#define ORDER		le
+#undef STRICT_ORDER
+#define STRICT_ORDER	lt
+#include "isl_aff_lex_templ.c"
+
+#undef ORDER
+#define ORDER		lt
+#undef STRICT_ORDER
+#define STRICT_ORDER	lt
+#include "isl_aff_lex_templ.c"
+
+#undef ORDER
+#define ORDER		ge
+#undef STRICT_ORDER
+#define STRICT_ORDER	gt
+#include "isl_aff_lex_templ.c"
+
+#undef ORDER
+#define ORDER		gt
+#undef STRICT_ORDER
+#define STRICT_ORDER	gt
+#include "isl_aff_lex_templ.c"
+
 /* Compare two isl_affs.
  *
  * Return -1 if "aff1" is "smaller" than "aff2", 1 if "aff1" is "greater"
@@ -6680,3 +7729,2322 @@
 
 	return 0;
 }
+
+/* Return a piecewise affine expression that is equal to "v" on "domain".
+ */
+__isl_give isl_pw_aff *isl_pw_aff_val_on_domain(__isl_take isl_set *domain,
+	__isl_take isl_val *v)
+{
+	isl_space *space;
+	isl_local_space *ls;
+	isl_aff *aff;
+
+	space = isl_set_get_space(domain);
+	ls = isl_local_space_from_space(space);
+	aff = isl_aff_val_on_domain(ls, v);
+
+	return isl_pw_aff_alloc(domain, aff);
+}
+
+/* Return a piecewise affine expression that is equal to the parameter
+ * with identifier "id" on "domain".
+ */
+__isl_give isl_pw_aff *isl_pw_aff_param_on_domain_id(
+	__isl_take isl_set *domain, __isl_take isl_id *id)
+{
+	isl_space *space;
+	isl_aff *aff;
+
+	space = isl_set_get_space(domain);
+	space = isl_space_add_param_id(space, isl_id_copy(id));
+	domain = isl_set_align_params(domain, isl_space_copy(space));
+	aff = isl_aff_param_on_domain_space_id(space, id);
+
+	return isl_pw_aff_alloc(domain, aff);
+}
+
+/* Return a multi affine expression that is equal to "mv" on domain
+ * space "space".
+ */
+__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_domain_space(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv)
+{
+	int i;
+	isl_size n;
+	isl_space *space2;
+	isl_local_space *ls;
+	isl_multi_aff *ma;
+
+	n = isl_multi_val_dim(mv, isl_dim_set);
+	if (!space || n < 0)
+		goto error;
+
+	space2 = isl_multi_val_get_space(mv);
+	space2 = isl_space_align_params(space2, isl_space_copy(space));
+	space = isl_space_align_params(space, isl_space_copy(space2));
+	space = isl_space_map_from_domain_and_range(space, space2);
+	ma = isl_multi_aff_alloc(isl_space_copy(space));
+	ls = isl_local_space_from_space(isl_space_domain(space));
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
+		isl_aff *aff;
+
+		v = isl_multi_val_get_val(mv, i);
+		aff = isl_aff_val_on_domain(isl_local_space_copy(ls), v);
+		ma = isl_multi_aff_set_aff(ma, i, aff);
+	}
+	isl_local_space_free(ls);
+
+	isl_multi_val_free(mv);
+	return ma;
+error:
+	isl_space_free(space);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_multi_aff *isl_multi_aff_multi_val_on_space(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv)
+{
+	return isl_multi_aff_multi_val_on_domain_space(space, mv);
+}
+
+/* This function performs the same operation as
+ * isl_multi_aff_multi_val_on_domain_space,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_multi_aff *isl_space_multi_aff_on_domain_multi_val(
+	__isl_take isl_space *space, __isl_take isl_multi_val *mv)
+{
+	return isl_multi_aff_multi_val_on_domain_space(space, mv);
+}
+
+/* Return a piecewise multi-affine expression
+ * that is equal to "mv" on "domain".
+ */
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_multi_val_on_domain(
+	__isl_take isl_set *domain, __isl_take isl_multi_val *mv)
+{
+	isl_space *space;
+	isl_multi_aff *ma;
+
+	space = isl_set_get_space(domain);
+	ma = isl_multi_aff_multi_val_on_space(space, mv);
+
+	return isl_pw_multi_aff_alloc(domain, ma);
+}
+
+/* This function performs the same operation as
+ * isl_pw_multi_aff_multi_val_on_domain,
+ * but is considered as a function on an isl_set when exported.
+ */
+__isl_give isl_pw_multi_aff *isl_set_pw_multi_aff_on_domain_multi_val(
+	__isl_take isl_set *domain, __isl_take isl_multi_val *mv)
+{
+	return isl_pw_multi_aff_multi_val_on_domain(domain, mv);
+}
+
+/* Internal data structure for isl_union_pw_multi_aff_multi_val_on_domain.
+ * mv is the value that should be attained on each domain set
+ * res collects the results
+ */
+struct isl_union_pw_multi_aff_multi_val_on_domain_data {
+	isl_multi_val *mv;
+	isl_union_pw_multi_aff *res;
+};
+
+/* Create an isl_pw_multi_aff equal to data->mv on "domain"
+ * and add it to data->res.
+ */
+static isl_stat pw_multi_aff_multi_val_on_domain(__isl_take isl_set *domain,
+	void *user)
+{
+	struct isl_union_pw_multi_aff_multi_val_on_domain_data *data = user;
+	isl_pw_multi_aff *pma;
+	isl_multi_val *mv;
+
+	mv = isl_multi_val_copy(data->mv);
+	pma = isl_pw_multi_aff_multi_val_on_domain(domain, mv);
+	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Return a union piecewise multi-affine expression
+ * that is equal to "mv" on "domain".
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_multi_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
+{
+	struct isl_union_pw_multi_aff_multi_val_on_domain_data data;
+	isl_space *space;
+
+	space = isl_union_set_get_space(domain);
+	data.res = isl_union_pw_multi_aff_empty(space);
+	data.mv = mv;
+	if (isl_union_set_foreach_set(domain,
+			&pw_multi_aff_multi_val_on_domain, &data) < 0)
+		data.res = isl_union_pw_multi_aff_free(data.res);
+	isl_union_set_free(domain);
+	isl_multi_val_free(mv);
+	return data.res;
+}
+
+/* Compute the pullback of data->pma by the function represented by "pma2",
+ * provided the spaces match, and add the results to data->res.
+ */
+static isl_stat pullback_entry(__isl_take isl_pw_multi_aff *pma2, void *user)
+{
+	struct isl_union_pw_multi_aff_bin_data *data = user;
+
+	if (!isl_space_tuple_is_equal(data->pma->dim, isl_dim_in,
+				 pma2->dim, isl_dim_out)) {
+		isl_pw_multi_aff_free(pma2);
+		return isl_stat_ok;
+	}
+
+	pma2 = isl_pw_multi_aff_pullback_pw_multi_aff(
+					isl_pw_multi_aff_copy(data->pma), pma2);
+
+	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma2);
+	if (!data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Compute the pullback of "upma1" by the function represented by "upma2".
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2)
+{
+	return bin_op(upma1, upma2, &pullback_entry);
+}
+
+/* Apply "upma2" to "upma1".
+ *
+ * That is, compute the pullback of "upma2" by "upma1".
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_apply_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2)
+{
+	return isl_union_pw_multi_aff_pullback_union_pw_multi_aff(upma2, upma1);
+}
+
+#undef TYPE
+#define TYPE isl_pw_multi_aff
+static
+#include "isl_copy_tuple_id_templ.c"
+
+/* Given a function "pma1" of the form AB -> C -> D and
+ * a function "pma2" of the form E -> B,
+ * replace the domain of the wrapped relation inside the domain of "pma1"
+ * by the preimage with respect to "pma2".
+ * In other words, plug in "pma2" in this nested domain.
+ * The result is of the form AE -> C -> D.
+ *
+ * In particular, extend E -> B to AE -> C -> AB -> C and
+ * plug that into "pma1".
+ */
+__isl_give isl_pw_multi_aff *
+isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
+	__isl_take isl_pw_multi_aff *pma1, __isl_take isl_pw_multi_aff *pma2)
+{
+	isl_space *pma1_space, *pma2_space;
+	isl_space *space;
+	isl_pw_multi_aff *id;
+
+	pma1_space = isl_pw_multi_aff_peek_space(pma1);
+	pma2_space = isl_pw_multi_aff_peek_space(pma2);
+
+	if (isl_space_check_domain_is_wrapping(pma1_space) < 0)
+		goto error;
+	if (isl_space_check_wrapped_tuple_is_equal(pma1_space,
+			isl_dim_in, isl_dim_in, pma2_space, isl_dim_out) < 0)
+		goto error;
+
+	space = isl_space_domain(isl_space_copy(pma1_space));
+	space = isl_space_range(isl_space_unwrap(space));
+	id = isl_pw_multi_aff_identity_on_domain_space(space);
+	pma2 = isl_pw_multi_aff_product(pma2, id);
+
+	pma2 = isl_pw_multi_aff_copy_tuple_id(pma2, isl_dim_in,
+						pma1_space, isl_dim_in);
+	pma2 = isl_pw_multi_aff_copy_tuple_id(pma2, isl_dim_out,
+						pma1_space, isl_dim_in);
+
+	return isl_pw_multi_aff_pullback_pw_multi_aff(pma1, pma2);
+error:
+	isl_pw_multi_aff_free(pma1);
+	isl_pw_multi_aff_free(pma2);
+	return NULL;
+}
+
+/* If data->pma and "pma2" are such that
+ * data->pma is of the form AB -> C -> D and
+ * "pma2" is of the form E -> B,
+ * then replace the domain of the wrapped relation
+ * inside the domain of data->pma by the preimage with respect to "pma2" and
+ * add the result to data->res.
+ */
+static isl_stat preimage_domain_wrapped_domain_entry(
+	__isl_take isl_pw_multi_aff *pma2, void *user)
+{
+	struct isl_union_pw_multi_aff_bin_data *data = user;
+	isl_space *pma1_space, *pma2_space;
+	isl_bool match;
+
+	pma1_space = isl_pw_multi_aff_peek_space(data->pma);
+	pma2_space = isl_pw_multi_aff_peek_space(pma2);
+
+	match = isl_space_domain_is_wrapping(pma1_space);
+	if (match >= 0 && match)
+		match = isl_space_wrapped_tuple_is_equal(pma1_space, isl_dim_in,
+					isl_dim_in, pma2_space, isl_dim_out);
+	if (match < 0 || !match) {
+		isl_pw_multi_aff_free(pma2);
+		return match < 0 ? isl_stat_error : isl_stat_ok;
+	}
+
+	pma2 = isl_pw_multi_aff_preimage_domain_wrapped_domain_pw_multi_aff(
+		isl_pw_multi_aff_copy(data->pma), pma2);
+
+	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma2);
+
+	return isl_stat_non_null(data->res);
+}
+
+/* For each pair of functions AB -> C -> D in "upma1" and
+ * E -> B in "upma2",
+ * replace the domain of the wrapped relation inside the domain of the first
+ * by the preimage with respect to the second and collect the results.
+ * In other words, plug in the second function in this nested domain.
+ * The results are of the form AE -> C -> D.
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma1,
+	__isl_take isl_union_pw_multi_aff *upma2)
+{
+	return bin_op(upma1, upma2, &preimage_domain_wrapped_domain_entry);
+}
+
+/* Check that the domain space of "upa" matches "space".
+ *
+ * This function is called from isl_multi_union_pw_aff_set_union_pw_aff and
+ * can in principle never fail since the space "space" is that
+ * of the isl_multi_union_pw_aff and is a set space such that
+ * there is no domain space to match.
+ *
+ * We check the parameters and double-check that "space" is
+ * indeed that of a set.
+ */
+static isl_stat isl_union_pw_aff_check_match_domain_space(
+	__isl_keep isl_union_pw_aff *upa, __isl_keep isl_space *space)
+{
+	isl_space *upa_space;
+	isl_bool match;
+
+	if (!upa || !space)
+		return isl_stat_error;
+
+	match = isl_space_is_set(space);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting set space", return isl_stat_error);
+
+	upa_space = isl_union_pw_aff_get_space(upa);
+	match = isl_space_has_equal_params(space, upa_space);
+	if (match < 0)
+		goto error;
+	if (!match)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"parameters don't match", goto error);
+
+	isl_space_free(upa_space);
+	return isl_stat_ok;
+error:
+	isl_space_free(upa_space);
+	return isl_stat_error;
+}
+
+/* Do the parameters of "upa" match those of "space"?
+ */
+static isl_bool isl_union_pw_aff_matching_params(
+	__isl_keep isl_union_pw_aff *upa, __isl_keep isl_space *space)
+{
+	isl_space *upa_space;
+	isl_bool match;
+
+	if (!upa || !space)
+		return isl_bool_error;
+
+	upa_space = isl_union_pw_aff_get_space(upa);
+
+	match = isl_space_has_equal_params(space, upa_space);
+
+	isl_space_free(upa_space);
+	return match;
+}
+
+/* Internal data structure for isl_union_pw_aff_reset_domain_space.
+ * space represents the new parameters.
+ * res collects the results.
+ */
+struct isl_union_pw_aff_reset_params_data {
+	isl_space *space;
+	isl_union_pw_aff *res;
+};
+
+/* Replace the parameters of "pa" by data->space and
+ * add the result to data->res.
+ */
+static isl_stat reset_params(__isl_take isl_pw_aff *pa, void *user)
+{
+	struct isl_union_pw_aff_reset_params_data *data = user;
+	isl_space *space;
+
+	space = isl_pw_aff_get_space(pa);
+	space = isl_space_replace_params(space, data->space);
+	pa = isl_pw_aff_reset_space(pa, space);
+	data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Replace the domain space of "upa" by "space".
+ * Since a union expression does not have a (single) domain space,
+ * "space" is necessarily a parameter space.
+ *
+ * Since the order and the names of the parameters determine
+ * the hash value, we need to create a new hash table.
+ */
+static __isl_give isl_union_pw_aff *isl_union_pw_aff_reset_domain_space(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_space *space)
+{
+	struct isl_union_pw_aff_reset_params_data data = { space };
+	isl_bool match;
+
+	match = isl_union_pw_aff_matching_params(upa, space);
+	if (match < 0)
+		upa = isl_union_pw_aff_free(upa);
+	else if (match) {
+		isl_space_free(space);
+		return upa;
+	}
+
+	data.res = isl_union_pw_aff_empty(isl_space_copy(space));
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &reset_params, &data) < 0)
+		data.res = isl_union_pw_aff_free(data.res);
+
+	isl_union_pw_aff_free(upa);
+	isl_space_free(space);
+	return data.res;
+}
+
+/* Return the floor of "pa".
+ */
+static __isl_give isl_pw_aff *floor_entry(__isl_take isl_pw_aff *pa, void *user)
+{
+	return isl_pw_aff_floor(pa);
+}
+
+/* Given f, return floor(f).
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_floor(
+	__isl_take isl_union_pw_aff *upa)
+{
+	return isl_union_pw_aff_transform_inplace(upa, &floor_entry, NULL);
+}
+
+/* Compute
+ *
+ *	upa mod m = upa - m * floor(upa/m)
+ *
+ * with m an integer value.
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_mod_val(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_val *m)
+{
+	isl_union_pw_aff *res;
+
+	if (!upa || !m)
+		goto error;
+
+	if (!isl_val_is_int(m))
+		isl_die(isl_val_get_ctx(m), isl_error_invalid,
+			"expecting integer modulo", goto error);
+	if (!isl_val_is_pos(m))
+		isl_die(isl_val_get_ctx(m), isl_error_invalid,
+			"expecting positive modulo", goto error);
+
+	res = isl_union_pw_aff_copy(upa);
+	upa = isl_union_pw_aff_scale_down_val(upa, isl_val_copy(m));
+	upa = isl_union_pw_aff_floor(upa);
+	upa = isl_union_pw_aff_scale_val(upa, m);
+	res = isl_union_pw_aff_sub(res, upa);
+
+	return res;
+error:
+	isl_val_free(m);
+	isl_union_pw_aff_free(upa);
+	return NULL;
+}
+
+/* Internal data structure for isl_union_pw_multi_aff_get_union_pw_aff.
+ * pos is the output position that needs to be extracted.
+ * res collects the results.
+ */
+struct isl_union_pw_multi_aff_get_union_pw_aff_data {
+	int pos;
+	isl_union_pw_aff *res;
+};
+
+/* Extract an isl_pw_aff corresponding to output dimension "pos" of "pma"
+ * (assuming it has such a dimension) and add it to data->res.
+ */
+static isl_stat get_union_pw_aff(__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	struct isl_union_pw_multi_aff_get_union_pw_aff_data *data = user;
+	isl_size n_out;
+	isl_pw_aff *pa;
+
+	n_out = isl_pw_multi_aff_dim(pma, isl_dim_out);
+	if (n_out < 0)
+		return isl_stat_error;
+	if (data->pos >= n_out) {
+		isl_pw_multi_aff_free(pma);
+		return isl_stat_ok;
+	}
+
+	pa = isl_pw_multi_aff_get_pw_aff(pma, data->pos);
+	isl_pw_multi_aff_free(pma);
+
+	data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Extract an isl_union_pw_aff corresponding to
+ * output dimension "pos" of "upma".
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_multi_aff_get_union_pw_aff(
+	__isl_keep isl_union_pw_multi_aff *upma, int pos)
+{
+	struct isl_union_pw_multi_aff_get_union_pw_aff_data data;
+	isl_space *space;
+
+	if (!upma)
+		return NULL;
+
+	if (pos < 0)
+		isl_die(isl_union_pw_multi_aff_get_ctx(upma), isl_error_invalid,
+			"cannot extract at negative position", return NULL);
+
+	space = isl_union_pw_multi_aff_get_space(upma);
+	data.res = isl_union_pw_aff_empty(space);
+	data.pos = pos;
+	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
+						&get_union_pw_aff, &data) < 0)
+		data.res = isl_union_pw_aff_free(data.res);
+
+	return data.res;
+}
+
+/* Return a union piecewise affine expression
+ * that is equal to "aff" on "domain".
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_aff *aff)
+{
+	isl_pw_aff *pa;
+
+	pa = isl_pw_aff_from_aff(aff);
+	return isl_union_pw_aff_pw_aff_on_domain(domain, pa);
+}
+
+/* Return a union piecewise affine expression
+ * that is equal to the parameter identified by "id" on "domain".
+ *
+ * Make sure the parameter appears in the space passed to
+ * isl_aff_param_on_domain_space_id.
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_param_on_domain_id(
+	__isl_take isl_union_set *domain, __isl_take isl_id *id)
+{
+	isl_space *space;
+	isl_aff *aff;
+
+	space = isl_union_set_get_space(domain);
+	space = isl_space_add_param_id(space, isl_id_copy(id));
+	aff = isl_aff_param_on_domain_space_id(space, id);
+	return isl_union_pw_aff_aff_on_domain(domain, aff);
+}
+
+/* Internal data structure for isl_union_pw_aff_pw_aff_on_domain.
+ * "pa" is the piecewise symbolic value that the resulting isl_union_pw_aff
+ * needs to attain.
+ * "res" collects the results.
+ */
+struct isl_union_pw_aff_pw_aff_on_domain_data {
+	isl_pw_aff *pa;
+	isl_union_pw_aff *res;
+};
+
+/* Construct a piecewise affine expression that is equal to data->pa
+ * on "domain" and add the result to data->res.
+ */
+static isl_stat pw_aff_on_domain(__isl_take isl_set *domain, void *user)
+{
+	struct isl_union_pw_aff_pw_aff_on_domain_data *data = user;
+	isl_pw_aff *pa;
+	isl_size dim;
+
+	pa = isl_pw_aff_copy(data->pa);
+	dim = isl_set_dim(domain, isl_dim_set);
+	if (dim < 0)
+		pa = isl_pw_aff_free(pa);
+	pa = isl_pw_aff_from_range(pa);
+	pa = isl_pw_aff_add_dims(pa, isl_dim_in, dim);
+	pa = isl_pw_aff_reset_domain_space(pa, isl_set_get_space(domain));
+	pa = isl_pw_aff_intersect_domain(pa, domain);
+	data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Return a union piecewise affine expression
+ * that is equal to "pa" on "domain", assuming "domain" and "pa"
+ * have been aligned.
+ *
+ * Construct an isl_pw_aff on each of the sets in "domain" and
+ * collect the results.
+ */
+static __isl_give isl_union_pw_aff *isl_union_pw_aff_pw_aff_on_domain_aligned(
+	__isl_take isl_union_set *domain, __isl_take isl_pw_aff *pa)
+{
+	struct isl_union_pw_aff_pw_aff_on_domain_data data;
+	isl_space *space;
+
+	space = isl_union_set_get_space(domain);
+	data.res = isl_union_pw_aff_empty(space);
+	data.pa = pa;
+	if (isl_union_set_foreach_set(domain, &pw_aff_on_domain, &data) < 0)
+		data.res = isl_union_pw_aff_free(data.res);
+	isl_union_set_free(domain);
+	isl_pw_aff_free(pa);
+	return data.res;
+}
+
+/* Return a union piecewise affine expression
+ * that is equal to "pa" on "domain".
+ *
+ * Check that "pa" is a parametric expression,
+ * align the parameters if needed and call
+ * isl_union_pw_aff_pw_aff_on_domain_aligned.
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_pw_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_pw_aff *pa)
+{
+	isl_bool is_set;
+	isl_bool equal_params;
+	isl_space *domain_space, *pa_space;
+
+	pa_space = isl_pw_aff_peek_space(pa);
+	is_set = isl_space_is_set(pa_space);
+	if (is_set < 0)
+		goto error;
+	if (!is_set)
+		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
+			"expecting parametric expression", goto error);
+
+	domain_space = isl_union_set_get_space(domain);
+	pa_space = isl_pw_aff_get_space(pa);
+	equal_params = isl_space_has_equal_params(domain_space, pa_space);
+	if (equal_params >= 0 && !equal_params) {
+		isl_space *space;
+
+		space = isl_space_align_params(domain_space, pa_space);
+		pa = isl_pw_aff_align_params(pa, isl_space_copy(space));
+		domain = isl_union_set_align_params(domain, space);
+	} else {
+		isl_space_free(domain_space);
+		isl_space_free(pa_space);
+	}
+
+	if (equal_params < 0)
+		goto error;
+	return isl_union_pw_aff_pw_aff_on_domain_aligned(domain, pa);
+error:
+	isl_union_set_free(domain);
+	isl_pw_aff_free(pa);
+	return NULL;
+}
+
+/* Internal data structure for isl_union_pw_aff_val_on_domain.
+ * "v" is the value that the resulting isl_union_pw_aff needs to attain.
+ * "res" collects the results.
+ */
+struct isl_union_pw_aff_val_on_domain_data {
+	isl_val *v;
+	isl_union_pw_aff *res;
+};
+
+/* Construct a piecewise affine expression that is equal to data->v
+ * on "domain" and add the result to data->res.
+ */
+static isl_stat pw_aff_val_on_domain(__isl_take isl_set *domain, void *user)
+{
+	struct isl_union_pw_aff_val_on_domain_data *data = user;
+	isl_pw_aff *pa;
+	isl_val *v;
+
+	v = isl_val_copy(data->v);
+	pa = isl_pw_aff_val_on_domain(domain, v);
+	data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Return a union piecewise affine expression
+ * that is equal to "v" on "domain".
+ *
+ * Construct an isl_pw_aff on each of the sets in "domain" and
+ * collect the results.
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_val *v)
+{
+	struct isl_union_pw_aff_val_on_domain_data data;
+	isl_space *space;
+
+	space = isl_union_set_get_space(domain);
+	data.res = isl_union_pw_aff_empty(space);
+	data.v = v;
+	if (isl_union_set_foreach_set(domain, &pw_aff_val_on_domain, &data) < 0)
+		data.res = isl_union_pw_aff_free(data.res);
+	isl_union_set_free(domain);
+	isl_val_free(v);
+	return data.res;
+}
+
+/* Construct a piecewise multi affine expression
+ * that is equal to "pa" and add it to upma.
+ */
+static isl_stat pw_multi_aff_from_pw_aff_entry(__isl_take isl_pw_aff *pa,
+	void *user)
+{
+	isl_union_pw_multi_aff **upma = user;
+	isl_pw_multi_aff *pma;
+
+	pma = isl_pw_multi_aff_from_pw_aff(pa);
+	*upma = isl_union_pw_multi_aff_add_pw_multi_aff(*upma, pma);
+
+	return *upma ? isl_stat_ok : isl_stat_error;
+}
+
+/* Construct and return a union piecewise multi affine expression
+ * that is equal to the given union piecewise affine expression.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_from_union_pw_aff(
+	__isl_take isl_union_pw_aff *upa)
+{
+	isl_space *space;
+	isl_union_pw_multi_aff *upma;
+
+	if (!upa)
+		return NULL;
+
+	space = isl_union_pw_aff_get_space(upa);
+	upma = isl_union_pw_multi_aff_empty(space);
+
+	if (isl_union_pw_aff_foreach_pw_aff(upa,
+				&pw_multi_aff_from_pw_aff_entry, &upma) < 0)
+		upma = isl_union_pw_multi_aff_free(upma);
+
+	isl_union_pw_aff_free(upa);
+	return upma;
+}
+
+/* Compute the set of elements in the domain of "pa" where it is zero and
+ * add this set to "uset".
+ */
+static isl_stat zero_union_set(__isl_take isl_pw_aff *pa, void *user)
+{
+	isl_union_set **uset = (isl_union_set **)user;
+
+	*uset = isl_union_set_add_set(*uset, isl_pw_aff_zero_set(pa));
+
+	return *uset ? isl_stat_ok : isl_stat_error;
+}
+
+/* Return a union set containing those elements in the domain
+ * of "upa" where it is zero.
+ */
+__isl_give isl_union_set *isl_union_pw_aff_zero_union_set(
+	__isl_take isl_union_pw_aff *upa)
+{
+	isl_union_set *zero;
+
+	zero = isl_union_set_empty(isl_union_pw_aff_get_space(upa));
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &zero_union_set, &zero) < 0)
+		zero = isl_union_set_free(zero);
+
+	isl_union_pw_aff_free(upa);
+	return zero;
+}
+
+/* Internal data structure for isl_union_pw_aff_bind_id,
+ * storing the parameter that needs to be bound and
+ * the accumulated results.
+ */
+struct isl_bind_id_data {
+	isl_id *id;
+	isl_union_set *bound;
+};
+
+/* Bind the piecewise affine function "pa" to the parameter data->id,
+ * adding the resulting elements in the domain where the expression
+ * is equal to the parameter to data->bound.
+ */
+static isl_stat bind_id(__isl_take isl_pw_aff *pa, void *user)
+{
+	struct isl_bind_id_data *data = user;
+	isl_set *bound;
+
+	bound = isl_pw_aff_bind_id(pa, isl_id_copy(data->id));
+	data->bound = isl_union_set_add_set(data->bound, bound);
+
+	return data->bound ? isl_stat_ok : isl_stat_error;
+}
+
+/* Bind the union piecewise affine function "upa" to the parameter "id",
+ * returning the elements in the domain where the expression
+ * is equal to the parameter.
+ */
+__isl_give isl_union_set *isl_union_pw_aff_bind_id(
+	__isl_take isl_union_pw_aff *upa, __isl_take isl_id *id)
+{
+	struct isl_bind_id_data data = { id };
+
+	data.bound = isl_union_set_empty(isl_union_pw_aff_get_space(upa));
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &bind_id, &data) < 0)
+		data.bound = isl_union_set_free(data.bound);
+
+	isl_union_pw_aff_free(upa);
+	isl_id_free(id);
+	return data.bound;
+}
+
+/* Internal data structure for isl_union_pw_aff_pullback_union_pw_multi_aff.
+ * upma is the function that is plugged in.
+ * pa is the current part of the function in which upma is plugged in.
+ * res collects the results.
+ */
+struct isl_union_pw_aff_pullback_upma_data {
+	isl_union_pw_multi_aff *upma;
+	isl_pw_aff *pa;
+	isl_union_pw_aff *res;
+};
+
+/* Check if "pma" can be plugged into data->pa.
+ * If so, perform the pullback and add the result to data->res.
+ */
+static isl_stat pa_pb_pma(__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	struct isl_union_pw_aff_pullback_upma_data *data = user;
+	isl_pw_aff *pa;
+
+	if (!isl_space_tuple_is_equal(data->pa->dim, isl_dim_in,
+				 pma->dim, isl_dim_out)) {
+		isl_pw_multi_aff_free(pma);
+		return isl_stat_ok;
+	}
+
+	pa = isl_pw_aff_copy(data->pa);
+	pa = isl_pw_aff_pullback_pw_multi_aff(pa, pma);
+
+	data->res = isl_union_pw_aff_add_pw_aff(data->res, pa);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Check if any of the elements of data->upma can be plugged into pa,
+ * add if so add the result to data->res.
+ */
+static isl_stat upa_pb_upma(__isl_take isl_pw_aff *pa, void *user)
+{
+	struct isl_union_pw_aff_pullback_upma_data *data = user;
+	isl_stat r;
+
+	data->pa = pa;
+	r = isl_union_pw_multi_aff_foreach_pw_multi_aff(data->upma,
+				   &pa_pb_pma, data);
+	isl_pw_aff_free(pa);
+
+	return r;
+}
+
+/* Compute the pullback of "upa" by the function represented by "upma".
+ * In other words, plug in "upma" in "upa".  The result contains
+ * expressions defined over the domain space of "upma".
+ *
+ * Run over all pairs of elements in "upa" and "upma", perform
+ * the pullback when appropriate and collect the results.
+ * If the hash value were based on the domain space rather than
+ * the function space, then we could run through all elements
+ * of "upma" and directly pick out the corresponding element of "upa".
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_union_pw_aff *upa,
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	struct isl_union_pw_aff_pullback_upma_data data = { NULL, NULL };
+	isl_space *space;
+
+	space = isl_union_pw_multi_aff_get_space(upma);
+	upa = isl_union_pw_aff_align_params(upa, space);
+	space = isl_union_pw_aff_get_space(upa);
+	upma = isl_union_pw_multi_aff_align_params(upma, space);
+
+	if (!upa || !upma)
+		goto error;
+
+	data.upma = upma;
+	data.res = isl_union_pw_aff_alloc_same_size(upa);
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &upa_pb_upma, &data) < 0)
+		data.res = isl_union_pw_aff_free(data.res);
+
+	isl_union_pw_aff_free(upa);
+	isl_union_pw_multi_aff_free(upma);
+	return data.res;
+error:
+	isl_union_pw_aff_free(upa);
+	isl_union_pw_multi_aff_free(upma);
+	return NULL;
+}
+
+#undef BASE
+#define BASE union_pw_aff
+#undef DOMBASE
+#define DOMBASE union_set
+
+#include <isl_multi_explicit_domain.c>
+#include <isl_multi_union_pw_aff_explicit_domain.c>
+#include <isl_multi_templ.c>
+#include <isl_multi_apply_set.c>
+#include <isl_multi_apply_union_set.c>
+#include <isl_multi_arith_templ.c>
+#include <isl_multi_bind_templ.c>
+#include <isl_multi_coalesce.c>
+#include <isl_multi_dim_id_templ.c>
+#include <isl_multi_floor.c>
+#include <isl_multi_from_base_templ.c>
+#include <isl_multi_gist.c>
+#include <isl_multi_align_set.c>
+#include <isl_multi_align_union_set.c>
+#include <isl_multi_intersect.c>
+#include <isl_multi_nan_templ.c>
+#include <isl_multi_tuple_id_templ.c>
+#include <isl_multi_union_add_templ.c>
+#include <isl_multi_zero_space_templ.c>
+
+/* Does "mupa" have a non-trivial explicit domain?
+ *
+ * The explicit domain, if present, is trivial if it represents
+ * an (obviously) universe parameter set.
+ */
+isl_bool isl_multi_union_pw_aff_has_non_trivial_domain(
+	__isl_keep isl_multi_union_pw_aff *mupa)
+{
+	isl_bool is_params, trivial;
+	isl_set *set;
+
+	if (!mupa)
+		return isl_bool_error;
+	if (!isl_multi_union_pw_aff_has_explicit_domain(mupa))
+		return isl_bool_false;
+	is_params = isl_union_set_is_params(mupa->u.dom);
+	if (is_params < 0 || !is_params)
+		return isl_bool_not(is_params);
+	set = isl_set_from_union_set(isl_union_set_copy(mupa->u.dom));
+	trivial = isl_set_plain_is_universe(set);
+	isl_set_free(set);
+	return isl_bool_not(trivial);
+}
+
+/* Construct a multiple union piecewise affine expression
+ * in the given space with value zero in each of the output dimensions.
+ *
+ * Since there is no canonical zero value for
+ * a union piecewise affine expression, we can only construct
+ * a zero-dimensional "zero" value.
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_zero(
+	__isl_take isl_space *space)
+{
+	isl_bool params;
+	isl_size dim;
+
+	if (!space)
+		return NULL;
+
+	params = isl_space_is_params(space);
+	if (params < 0)
+		goto error;
+	if (params)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting proper set space", goto error);
+	if (!isl_space_is_set(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting set space", goto error);
+	dim = isl_space_dim(space, isl_dim_out);
+	if (dim < 0)
+		goto error;
+	if (dim != 0)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting 0D space", goto error);
+
+	return isl_multi_union_pw_aff_alloc(space);
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Construct and return a multi union piecewise affine expression
+ * that is equal to the given multi affine expression.
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_aff(
+	__isl_take isl_multi_aff *ma)
+{
+	isl_multi_pw_aff *mpa;
+
+	mpa = isl_multi_pw_aff_from_multi_aff(ma);
+	return isl_multi_union_pw_aff_from_multi_pw_aff(mpa);
+}
+
+/* This function performs the same operation as
+ * isl_multi_union_pw_aff_from_multi_aff, but is considered as a function on an
+ * isl_multi_aff when exported.
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_aff_to_multi_union_pw_aff(
+        __isl_take isl_multi_aff *ma)
+{
+        return isl_multi_union_pw_aff_from_multi_aff(ma);
+}
+
+/* Construct and return a multi union piecewise affine expression
+ * that is equal to the given multi piecewise affine expression.
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_multi_pw_aff(
+	__isl_take isl_multi_pw_aff *mpa)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_union_pw_aff *mupa;
+
+	n = isl_multi_pw_aff_dim(mpa, isl_dim_out);
+	if (n < 0)
+		mpa = isl_multi_pw_aff_free(mpa);
+	if (!mpa)
+		return NULL;
+
+	space = isl_multi_pw_aff_get_space(mpa);
+	space = isl_space_range(space);
+	mupa = isl_multi_union_pw_aff_alloc(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_pw_aff *pa;
+		isl_union_pw_aff *upa;
+
+		pa = isl_multi_pw_aff_get_pw_aff(mpa, i);
+		upa = isl_union_pw_aff_from_pw_aff(pa);
+		mupa = isl_multi_union_pw_aff_restore_check_space(mupa, i, upa);
+	}
+
+	isl_multi_pw_aff_free(mpa);
+
+	return mupa;
+}
+
+/* Extract the range space of "pma" and assign it to *space.
+ * If *space has already been set (through a previous call to this function),
+ * then check that the range space is the same.
+ */
+static isl_stat extract_space(__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	isl_space **space = user;
+	isl_space *pma_space;
+	isl_bool equal;
+
+	pma_space = isl_space_range(isl_pw_multi_aff_get_space(pma));
+	isl_pw_multi_aff_free(pma);
+
+	if (!pma_space)
+		return isl_stat_error;
+	if (!*space) {
+		*space = pma_space;
+		return isl_stat_ok;
+	}
+
+	equal = isl_space_is_equal(pma_space, *space);
+	isl_space_free(pma_space);
+
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_space_get_ctx(*space), isl_error_invalid,
+			"range spaces not the same", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Construct and return a multi union piecewise affine expression
+ * that is equal to the given union piecewise multi affine expression.
+ *
+ * In order to be able to perform the conversion, the input
+ * needs to be non-empty and may only involve a single range space.
+ *
+ * If the resulting multi union piecewise affine expression has
+ * an explicit domain, then assign it the domain of the input.
+ * In other cases, the domain is stored in the individual elements.
+ */
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_from_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	isl_space *space = NULL;
+	isl_multi_union_pw_aff *mupa;
+	int i;
+	isl_size n;
+
+	n = isl_union_pw_multi_aff_n_pw_multi_aff(upma);
+	if (n < 0)
+		goto error;
+	if (n == 0)
+		isl_die(isl_union_pw_multi_aff_get_ctx(upma), isl_error_invalid,
+			"cannot extract range space from empty input",
+			goto error);
+	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma, &extract_space,
+							&space) < 0)
+		goto error;
+
+	if (!space)
+		goto error;
+
+	n = isl_space_dim(space, isl_dim_set);
+	if (n < 0)
+		space = isl_space_free(space);
+	mupa = isl_multi_union_pw_aff_alloc(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_union_pw_aff *upa;
+
+		upa = isl_union_pw_multi_aff_get_union_pw_aff(upma, i);
+		mupa = isl_multi_union_pw_aff_set_union_pw_aff(mupa, i, upa);
+	}
+	if (isl_multi_union_pw_aff_has_explicit_domain(mupa)) {
+		isl_union_set *dom;
+		isl_union_pw_multi_aff *copy;
+
+		copy = isl_union_pw_multi_aff_copy(upma);
+		dom = isl_union_pw_multi_aff_domain(copy);
+		mupa = isl_multi_union_pw_aff_intersect_domain(mupa, dom);
+	}
+
+	isl_union_pw_multi_aff_free(upma);
+	return mupa;
+error:
+	isl_space_free(space);
+	isl_union_pw_multi_aff_free(upma);
+	return NULL;
+}
+
+/* This function performs the same operation as
+ * isl_multi_union_pw_aff_from_union_pw_multi_aff,
+ * but is considered as a function on an isl_union_pw_multi_aff when exported.
+ */
+__isl_give isl_multi_union_pw_aff *
+isl_union_pw_multi_aff_as_multi_union_pw_aff(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	return isl_multi_union_pw_aff_from_union_pw_multi_aff(upma);
+}
+
+/* Try and create an isl_multi_union_pw_aff that is equivalent
+ * to the given isl_union_map.
+ * The isl_union_map is required to be single-valued in each space.
+ * Moreover, it cannot be empty and all range spaces need to be the same.
+ * Otherwise, an error is produced.
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_from_union_map(
+	__isl_take isl_union_map *umap)
+{
+	isl_union_pw_multi_aff *upma;
+
+	upma = isl_union_pw_multi_aff_from_union_map(umap);
+	return isl_multi_union_pw_aff_from_union_pw_multi_aff(upma);
+}
+
+/* This function performs the same operation as
+ * isl_multi_union_pw_aff_from_union_map,
+ * but is considered as a function on an isl_union_map when exported.
+ */
+__isl_give isl_multi_union_pw_aff *isl_union_map_as_multi_union_pw_aff(
+	__isl_take isl_union_map *umap)
+{
+	return isl_multi_union_pw_aff_from_union_map(umap);
+}
+
+/* Return a multiple union piecewise affine expression
+ * that is equal to "mv" on "domain", assuming "domain" and "mv"
+ * have been aligned.
+ *
+ * If the resulting multi union piecewise affine expression has
+ * an explicit domain, then assign it the input domain.
+ * In other cases, the domain is stored in the individual elements.
+ */
+static __isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_multi_val_on_domain_aligned(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_union_pw_aff *mupa;
+
+	n = isl_multi_val_dim(mv, isl_dim_set);
+	if (!domain || n < 0)
+		goto error;
+
+	space = isl_multi_val_get_space(mv);
+	mupa = isl_multi_union_pw_aff_alloc(space);
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
+		isl_union_pw_aff *upa;
+
+		v = isl_multi_val_get_val(mv, i);
+		upa = isl_union_pw_aff_val_on_domain(isl_union_set_copy(domain),
+							v);
+		mupa = isl_multi_union_pw_aff_set_union_pw_aff(mupa, i, upa);
+	}
+	if (isl_multi_union_pw_aff_has_explicit_domain(mupa))
+		mupa = isl_multi_union_pw_aff_intersect_domain(mupa,
+						    isl_union_set_copy(domain));
+
+	isl_union_set_free(domain);
+	isl_multi_val_free(mv);
+	return mupa;
+error:
+	isl_union_set_free(domain);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Return a multiple union piecewise affine expression
+ * that is equal to "mv" on "domain".
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_val_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_val *mv)
+{
+	isl_bool equal_params;
+
+	if (!domain || !mv)
+		goto error;
+	equal_params = isl_space_has_equal_params(domain->dim, mv->space);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
+		return isl_multi_union_pw_aff_multi_val_on_domain_aligned(
+								    domain, mv);
+	domain = isl_union_set_align_params(domain,
+						isl_multi_val_get_space(mv));
+	mv = isl_multi_val_align_params(mv, isl_union_set_get_space(domain));
+	return isl_multi_union_pw_aff_multi_val_on_domain_aligned(domain, mv);
+error:
+	isl_union_set_free(domain);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Return a multiple union piecewise affine expression
+ * that is equal to "ma" on "domain".
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_multi_aff_on_domain(
+	__isl_take isl_union_set *domain, __isl_take isl_multi_aff *ma)
+{
+	isl_pw_multi_aff *pma;
+
+	pma = isl_pw_multi_aff_from_multi_aff(ma);
+	return isl_multi_union_pw_aff_pw_multi_aff_on_domain(domain, pma);
+}
+
+/* Return a multiple union piecewise affine expression
+ * that is equal to "pma" on "domain", assuming "domain" and "pma"
+ * have been aligned.
+ *
+ * If the resulting multi union piecewise affine expression has
+ * an explicit domain, then assign it the input domain.
+ * In other cases, the domain is stored in the individual elements.
+ */
+static __isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(
+	__isl_take isl_union_set *domain, __isl_take isl_pw_multi_aff *pma)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_union_pw_aff *mupa;
+
+	n = isl_pw_multi_aff_dim(pma, isl_dim_set);
+	if (!domain || n < 0)
+		goto error;
+	space = isl_pw_multi_aff_get_space(pma);
+	mupa = isl_multi_union_pw_aff_alloc(space);
+	for (i = 0; i < n; ++i) {
+		isl_pw_aff *pa;
+		isl_union_pw_aff *upa;
+
+		pa = isl_pw_multi_aff_get_pw_aff(pma, i);
+		upa = isl_union_pw_aff_pw_aff_on_domain(
+					    isl_union_set_copy(domain), pa);
+		mupa = isl_multi_union_pw_aff_set_union_pw_aff(mupa, i, upa);
+	}
+	if (isl_multi_union_pw_aff_has_explicit_domain(mupa))
+		mupa = isl_multi_union_pw_aff_intersect_domain(mupa,
+						    isl_union_set_copy(domain));
+
+	isl_union_set_free(domain);
+	isl_pw_multi_aff_free(pma);
+	return mupa;
+error:
+	isl_union_set_free(domain);
+	isl_pw_multi_aff_free(pma);
+	return NULL;
+}
+
+/* Return a multiple union piecewise affine expression
+ * that is equal to "pma" on "domain".
+ */
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_pw_multi_aff_on_domain(__isl_take isl_union_set *domain,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	isl_bool equal_params;
+	isl_space *space;
+
+	space = isl_pw_multi_aff_peek_space(pma);
+	equal_params = isl_union_set_space_has_equal_params(domain, space);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
+		return isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(
+								domain, pma);
+	domain = isl_union_set_align_params(domain,
+					    isl_pw_multi_aff_get_space(pma));
+	pma = isl_pw_multi_aff_align_params(pma,
+					    isl_union_set_get_space(domain));
+	return isl_multi_union_pw_aff_pw_multi_aff_on_domain_aligned(domain,
+									pma);
+error:
+	isl_union_set_free(domain);
+	isl_pw_multi_aff_free(pma);
+	return NULL;
+}
+
+/* Return a union set containing those elements in the domains
+ * of the elements of "mupa" where they are all zero.
+ *
+ * If there are no elements, then simply return the entire domain.
+ */
+__isl_give isl_union_set *isl_multi_union_pw_aff_zero_union_set(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	int i;
+	isl_size n;
+	isl_union_pw_aff *upa;
+	isl_union_set *zero;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0)
+		mupa = isl_multi_union_pw_aff_free(mupa);
+	if (!mupa)
+		return NULL;
+
+	if (n == 0)
+		return isl_multi_union_pw_aff_domain(mupa);
+
+	upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, 0);
+	zero = isl_union_pw_aff_zero_union_set(upa);
+
+	for (i = 1; i < n; ++i) {
+		isl_union_set *zero_i;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		zero_i = isl_union_pw_aff_zero_union_set(upa);
+
+		zero = isl_union_set_intersect(zero, zero_i);
+	}
+
+	isl_multi_union_pw_aff_free(mupa);
+	return zero;
+}
+
+/* Construct a union map mapping the shared domain
+ * of the union piecewise affine expressions to the range of "mupa"
+ * in the special case of a 0D multi union piecewise affine expression.
+ *
+ * Construct a map between the explicit domain of "mupa" and
+ * the range space.
+ * Note that this assumes that the domain consists of explicit elements.
+ */
+static __isl_give isl_union_map *isl_union_map_from_multi_union_pw_aff_0D(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	isl_bool is_params;
+	isl_space *space;
+	isl_union_set *dom, *ran;
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	dom = isl_multi_union_pw_aff_domain(mupa);
+	ran = isl_union_set_from_set(isl_set_universe(space));
+
+	is_params = isl_union_set_is_params(dom);
+	if (is_params < 0)
+		dom = isl_union_set_free(dom);
+	else if (is_params)
+		isl_die(isl_union_set_get_ctx(dom), isl_error_invalid,
+			"cannot create union map from expression without "
+			"explicit domain elements",
+			dom = isl_union_set_free(dom));
+
+	return isl_union_map_from_domain_and_range(dom, ran);
+}
+
+/* Construct a union map mapping the shared domain
+ * of the union piecewise affine expressions to the range of "mupa"
+ * with each dimension in the range equated to the
+ * corresponding union piecewise affine expression.
+ *
+ * If the input is zero-dimensional, then construct a mapping
+ * from its explicit domain.
+ */
+__isl_give isl_union_map *isl_union_map_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_union_map *umap;
+	isl_union_pw_aff *upa;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0)
+		mupa = isl_multi_union_pw_aff_free(mupa);
+	if (!mupa)
+		return NULL;
+
+	if (n == 0)
+		return isl_union_map_from_multi_union_pw_aff_0D(mupa);
+
+	upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, 0);
+	umap = isl_union_map_from_union_pw_aff(upa);
+
+	for (i = 1; i < n; ++i) {
+		isl_union_map *umap_i;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		umap_i = isl_union_map_from_union_pw_aff(upa);
+		umap = isl_union_map_flat_range_product(umap, umap_i);
+	}
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	umap = isl_union_map_reset_range_space(umap, space);
+
+	isl_multi_union_pw_aff_free(mupa);
+	return umap;
+}
+
+/* Internal data structure for isl_union_pw_multi_aff_reset_range_space.
+ * "range" is the space from which to set the range space.
+ * "res" collects the results.
+ */
+struct isl_union_pw_multi_aff_reset_range_space_data {
+	isl_space *range;
+	isl_union_pw_multi_aff *res;
+};
+
+/* Replace the range space of "pma" by the range space of data->range and
+ * add the result to data->res.
+ */
+static isl_stat reset_range_space(__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	struct isl_union_pw_multi_aff_reset_range_space_data *data = user;
+	isl_space *space;
+
+	space = isl_pw_multi_aff_get_space(pma);
+	space = isl_space_domain(space);
+	space = isl_space_extend_domain_with_range(space,
+						isl_space_copy(data->range));
+	pma = isl_pw_multi_aff_reset_space(pma, space);
+	data->res = isl_union_pw_multi_aff_add_pw_multi_aff(data->res, pma);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Replace the range space of all the piecewise affine expressions in "upma" by
+ * the range space of "space".
+ *
+ * This assumes that all these expressions have the same output dimension.
+ *
+ * Since the spaces of the expressions change, so do their hash values.
+ * We therefore need to create a new isl_union_pw_multi_aff.
+ * Note that the hash value is currently computed based on the entire
+ * space even though there can only be a single expression with a given
+ * domain space.
+ */
+static __isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_reset_range_space(
+	__isl_take isl_union_pw_multi_aff *upma, __isl_take isl_space *space)
+{
+	struct isl_union_pw_multi_aff_reset_range_space_data data = { space };
+	isl_space *space_upma;
+
+	space_upma = isl_union_pw_multi_aff_get_space(upma);
+	data.res = isl_union_pw_multi_aff_empty(space_upma);
+	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
+					&reset_range_space, &data) < 0)
+		data.res = isl_union_pw_multi_aff_free(data.res);
+
+	isl_space_free(space);
+	isl_union_pw_multi_aff_free(upma);
+	return data.res;
+}
+
+/* Construct and return a union piecewise multi affine expression
+ * that is equal to the given multi union piecewise affine expression,
+ * in the special case of a 0D multi union piecewise affine expression.
+ *
+ * Construct a union piecewise multi affine expression
+ * on top of the explicit domain of the input.
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_from_multi_union_pw_aff_0D(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	isl_space *space;
+	isl_multi_val *mv;
+	isl_union_set *domain;
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	mv = isl_multi_val_zero(space);
+	domain = isl_multi_union_pw_aff_domain(mupa);
+	return isl_union_pw_multi_aff_multi_val_on_domain(domain, mv);
+}
+
+/* Construct and return a union piecewise multi affine expression
+ * that is equal to the given multi union piecewise affine expression.
+ *
+ * If the input is zero-dimensional, then
+ * construct a union piecewise multi affine expression
+ * on top of the explicit domain of the input.
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_union_pw_multi_aff_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_union_pw_multi_aff *upma;
+	isl_union_pw_aff *upa;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0)
+		mupa = isl_multi_union_pw_aff_free(mupa);
+	if (!mupa)
+		return NULL;
+
+	if (n == 0)
+		return isl_union_pw_multi_aff_from_multi_union_pw_aff_0D(mupa);
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, 0);
+	upma = isl_union_pw_multi_aff_from_union_pw_aff(upa);
+
+	for (i = 1; i < n; ++i) {
+		isl_union_pw_multi_aff *upma_i;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		upma_i = isl_union_pw_multi_aff_from_union_pw_aff(upa);
+		upma = isl_union_pw_multi_aff_flat_range_product(upma, upma_i);
+	}
+
+	upma = isl_union_pw_multi_aff_reset_range_space(upma, space);
+
+	isl_multi_union_pw_aff_free(mupa);
+	return upma;
+}
+
+/* Intersect the range of "mupa" with "range",
+ * in the special case where "mupa" is 0D.
+ *
+ * Intersect the domain of "mupa" with the constraints on the parameters
+ * of "range".
+ */
+static __isl_give isl_multi_union_pw_aff *mupa_intersect_range_0D(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *range)
+{
+	range = isl_set_params(range);
+	mupa = isl_multi_union_pw_aff_intersect_params(mupa, range);
+	return mupa;
+}
+
+/* Intersect the range of "mupa" with "range".
+ * That is, keep only those domain elements that have a function value
+ * in "range".
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_intersect_range(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_set *range)
+{
+	isl_union_pw_multi_aff *upma;
+	isl_union_set *domain;
+	isl_space *space;
+	isl_size n;
+	int match;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0 || !range)
+		goto error;
+
+	space = isl_set_get_space(range);
+	match = isl_space_tuple_is_equal(mupa->space, isl_dim_set,
+					space, isl_dim_set);
+	isl_space_free(space);
+	if (match < 0)
+		goto error;
+	if (!match)
+		isl_die(isl_multi_union_pw_aff_get_ctx(mupa), isl_error_invalid,
+			"space don't match", goto error);
+	if (n == 0)
+		return mupa_intersect_range_0D(mupa, range);
+
+	upma = isl_union_pw_multi_aff_from_multi_union_pw_aff(
+					isl_multi_union_pw_aff_copy(mupa));
+	domain = isl_union_set_from_set(range);
+	domain = isl_union_set_preimage_union_pw_multi_aff(domain, upma);
+	mupa = isl_multi_union_pw_aff_intersect_domain(mupa, domain);
+
+	return mupa;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_set_free(range);
+	return NULL;
+}
+
+/* Return the shared domain of the elements of "mupa",
+ * in the special case where "mupa" is zero-dimensional.
+ *
+ * Return the explicit domain of "mupa".
+ * Note that this domain may be a parameter set, either
+ * because "mupa" is meant to live in a set space or
+ * because no explicit domain has been set.
+ */
+__isl_give isl_union_set *isl_multi_union_pw_aff_domain_0D(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	isl_union_set *dom;
+
+	dom = isl_multi_union_pw_aff_get_explicit_domain(mupa);
+	isl_multi_union_pw_aff_free(mupa);
+
+	return dom;
+}
+
+/* Return the shared domain of the elements of "mupa".
+ *
+ * If "mupa" is zero-dimensional, then return its explicit domain.
+ */
+__isl_give isl_union_set *isl_multi_union_pw_aff_domain(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	int i;
+	isl_size n;
+	isl_union_pw_aff *upa;
+	isl_union_set *dom;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0)
+		mupa = isl_multi_union_pw_aff_free(mupa);
+	if (!mupa)
+		return NULL;
+
+	if (n == 0)
+		return isl_multi_union_pw_aff_domain_0D(mupa);
+
+	upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, 0);
+	dom = isl_union_pw_aff_domain(upa);
+	for (i = 1; i < n; ++i) {
+		isl_union_set *dom_i;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		dom_i = isl_union_pw_aff_domain(upa);
+		dom = isl_union_set_intersect(dom, dom_i);
+	}
+
+	isl_multi_union_pw_aff_free(mupa);
+	return dom;
+}
+
+/* Apply "aff" to "mupa".  The space of "mupa" is equal to the domain of "aff".
+ * In particular, the spaces have been aligned.
+ * The result is defined over the shared domain of the elements of "mupa"
+ *
+ * We first extract the parametric constant part of "aff" and
+ * define that over the shared domain.
+ * Then we iterate over all input dimensions of "aff" and add the corresponding
+ * multiples of the elements of "mupa".
+ * Finally, we consider the integer divisions, calling the function
+ * recursively to obtain an isl_union_pw_aff corresponding to the
+ * integer division argument.
+ */
+static __isl_give isl_union_pw_aff *multi_union_pw_aff_apply_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff)
+{
+	int i;
+	isl_size n_in, n_div;
+	isl_union_pw_aff *upa;
+	isl_union_set *uset;
+	isl_val *v;
+	isl_aff *cst;
+
+	n_in = isl_aff_dim(aff, isl_dim_in);
+	n_div = isl_aff_dim(aff, isl_dim_div);
+	if (n_in < 0 || n_div < 0)
+		goto error;
+
+	uset = isl_multi_union_pw_aff_domain(isl_multi_union_pw_aff_copy(mupa));
+	cst = isl_aff_copy(aff);
+	cst = isl_aff_drop_dims(cst, isl_dim_div, 0, n_div);
+	cst = isl_aff_drop_dims(cst, isl_dim_in, 0, n_in);
+	cst = isl_aff_project_domain_on_params(cst);
+	upa = isl_union_pw_aff_aff_on_domain(uset, cst);
+
+	for (i = 0; i < n_in; ++i) {
+		isl_union_pw_aff *upa_i;
+
+		if (!isl_aff_involves_dims(aff, isl_dim_in, i, 1))
+			continue;
+		v = isl_aff_get_coefficient_val(aff, isl_dim_in, i);
+		upa_i = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		upa_i = isl_union_pw_aff_scale_val(upa_i, v);
+		upa = isl_union_pw_aff_add(upa, upa_i);
+	}
+
+	for (i = 0; i < n_div; ++i) {
+		isl_aff *div;
+		isl_union_pw_aff *upa_i;
+
+		if (!isl_aff_involves_dims(aff, isl_dim_div, i, 1))
+			continue;
+		div = isl_aff_get_div(aff, i);
+		upa_i = multi_union_pw_aff_apply_aff(
+					isl_multi_union_pw_aff_copy(mupa), div);
+		upa_i = isl_union_pw_aff_floor(upa_i);
+		v = isl_aff_get_coefficient_val(aff, isl_dim_div, i);
+		upa_i = isl_union_pw_aff_scale_val(upa_i, v);
+		upa = isl_union_pw_aff_add(upa, upa_i);
+	}
+
+	isl_multi_union_pw_aff_free(mupa);
+	isl_aff_free(aff);
+
+	return upa;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_aff_free(aff);
+	return NULL;
+}
+
+/* Apply "aff" to "mupa".  The space of "mupa" needs to be compatible
+ * with the domain of "aff".
+ * Furthermore, the dimension of this space needs to be greater than zero.
+ * The result is defined over the shared domain of the elements of "mupa"
+ *
+ * We perform these checks and then hand over control to
+ * multi_union_pw_aff_apply_aff.
+ */
+__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_aff *aff)
+{
+	isl_size dim;
+	isl_space *space1, *space2;
+	isl_bool equal;
+
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+						isl_aff_get_space(aff));
+	aff = isl_aff_align_params(aff, isl_multi_union_pw_aff_get_space(mupa));
+	if (!mupa || !aff)
+		goto error;
+
+	space1 = isl_multi_union_pw_aff_get_space(mupa);
+	space2 = isl_aff_get_domain_space(aff);
+	equal = isl_space_is_equal(space1, space2);
+	isl_space_free(space1);
+	isl_space_free(space2);
+	if (equal < 0)
+		goto error;
+	if (!equal)
+		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
+			"spaces don't match", goto error);
+	dim = isl_aff_dim(aff, isl_dim_in);
+	if (dim < 0)
+		goto error;
+	if (dim == 0)
+		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
+			"cannot determine domains", goto error);
+
+	return multi_union_pw_aff_apply_aff(mupa, aff);
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_aff_free(aff);
+	return NULL;
+}
+
+/* Apply "ma" to "mupa", in the special case where "mupa" is 0D.
+ * The space of "mupa" is known to be compatible with the domain of "ma".
+ *
+ * Construct an isl_multi_union_pw_aff that is equal to "ma"
+ * on the domain of "mupa".
+ */
+static __isl_give isl_multi_union_pw_aff *mupa_apply_multi_aff_0D(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma)
+{
+	isl_union_set *dom;
+
+	dom = isl_multi_union_pw_aff_domain(mupa);
+	ma = isl_multi_aff_project_domain_on_params(ma);
+
+	return isl_multi_union_pw_aff_multi_aff_on_domain(dom, ma);
+}
+
+/* Apply "ma" to "mupa".  The space of "mupa" needs to be compatible
+ * with the domain of "ma".
+ * The result is defined over the shared domain of the elements of "mupa"
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_multi_aff *ma)
+{
+	isl_space *space1, *space2;
+	isl_multi_union_pw_aff *res;
+	isl_bool equal;
+	int i;
+	isl_size n_in, n_out;
+
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+						isl_multi_aff_get_space(ma));
+	ma = isl_multi_aff_align_params(ma,
+					isl_multi_union_pw_aff_get_space(mupa));
+	n_in = isl_multi_aff_dim(ma, isl_dim_in);
+	n_out = isl_multi_aff_dim(ma, isl_dim_out);
+	if (!mupa || n_in < 0 || n_out < 0)
+		goto error;
+
+	space1 = isl_multi_union_pw_aff_get_space(mupa);
+	space2 = isl_multi_aff_get_domain_space(ma);
+	equal = isl_space_is_equal(space1, space2);
+	isl_space_free(space1);
+	isl_space_free(space2);
+	if (equal < 0)
+		goto error;
+	if (!equal)
+		isl_die(isl_multi_aff_get_ctx(ma), isl_error_invalid,
+			"spaces don't match", goto error);
+	if (n_in == 0)
+		return mupa_apply_multi_aff_0D(mupa, ma);
+
+	space1 = isl_space_range(isl_multi_aff_get_space(ma));
+	res = isl_multi_union_pw_aff_alloc(space1);
+
+	for (i = 0; i < n_out; ++i) {
+		isl_aff *aff;
+		isl_union_pw_aff *upa;
+
+		aff = isl_multi_aff_get_aff(ma, i);
+		upa = multi_union_pw_aff_apply_aff(
+					isl_multi_union_pw_aff_copy(mupa), aff);
+		res = isl_multi_union_pw_aff_set_union_pw_aff(res, i, upa);
+	}
+
+	isl_multi_aff_free(ma);
+	isl_multi_union_pw_aff_free(mupa);
+	return res;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_multi_aff_free(ma);
+	return NULL;
+}
+
+/* Apply "pa" to "mupa", in the special case where "mupa" is 0D.
+ * The space of "mupa" is known to be compatible with the domain of "pa".
+ *
+ * Construct an isl_multi_union_pw_aff that is equal to "pa"
+ * on the domain of "mupa".
+ */
+static __isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff_0D(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa)
+{
+	isl_union_set *dom;
+
+	dom = isl_multi_union_pw_aff_domain(mupa);
+	pa = isl_pw_aff_project_domain_on_params(pa);
+
+	return isl_union_pw_aff_pw_aff_on_domain(dom, pa);
+}
+
+/* Apply "pa" to "mupa".  The space of "mupa" needs to be compatible
+ * with the domain of "pa".
+ * Furthermore, the dimension of this space needs to be greater than zero.
+ * The result is defined over the shared domain of the elements of "mupa"
+ */
+__isl_give isl_union_pw_aff *isl_multi_union_pw_aff_apply_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa, __isl_take isl_pw_aff *pa)
+{
+	int i;
+	isl_bool equal;
+	isl_size n_in;
+	isl_space *space, *space2;
+	isl_union_pw_aff *upa;
+
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+						isl_pw_aff_get_space(pa));
+	pa = isl_pw_aff_align_params(pa,
+				    isl_multi_union_pw_aff_get_space(mupa));
+	if (!mupa || !pa)
+		goto error;
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	space2 = isl_pw_aff_get_domain_space(pa);
+	equal = isl_space_is_equal(space, space2);
+	isl_space_free(space);
+	isl_space_free(space2);
+	if (equal < 0)
+		goto error;
+	if (!equal)
+		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
+			"spaces don't match", goto error);
+	n_in = isl_pw_aff_dim(pa, isl_dim_in);
+	if (n_in < 0)
+		goto error;
+	if (n_in == 0)
+		return isl_multi_union_pw_aff_apply_pw_aff_0D(mupa, pa);
+
+	space = isl_space_params(isl_multi_union_pw_aff_get_space(mupa));
+	upa = isl_union_pw_aff_empty(space);
+
+	for (i = 0; i < pa->n; ++i) {
+		isl_aff *aff;
+		isl_set *domain;
+		isl_multi_union_pw_aff *mupa_i;
+		isl_union_pw_aff *upa_i;
+
+		mupa_i = isl_multi_union_pw_aff_copy(mupa);
+		domain = isl_set_copy(pa->pi.set);
+		mupa_i = isl_multi_union_pw_aff_intersect_range(mupa_i, domain);
+		aff = isl_aff_copy(pa->pi.aff);
+		upa_i = multi_union_pw_aff_apply_aff(mupa_i, aff);
+		upa = isl_union_pw_aff_union_add(upa, upa_i);
+	}
+
+	isl_multi_union_pw_aff_free(mupa);
+	isl_pw_aff_free(pa);
+	return upa;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_pw_aff_free(pa);
+	return NULL;
+}
+
+/* Apply "pma" to "mupa", in the special case where "mupa" is 0D.
+ * The space of "mupa" is known to be compatible with the domain of "pma".
+ *
+ * Construct an isl_multi_union_pw_aff that is equal to "pma"
+ * on the domain of "mupa".
+ */
+static __isl_give isl_multi_union_pw_aff *mupa_apply_pw_multi_aff_0D(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	isl_union_set *dom;
+
+	dom = isl_multi_union_pw_aff_domain(mupa);
+	pma = isl_pw_multi_aff_project_domain_on_params(pma);
+
+	return isl_multi_union_pw_aff_pw_multi_aff_on_domain(dom, pma);
+}
+
+/* Apply "pma" to "mupa".  The space of "mupa" needs to be compatible
+ * with the domain of "pma".
+ * The result is defined over the shared domain of the elements of "mupa"
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_apply_pw_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	isl_space *space1, *space2;
+	isl_multi_union_pw_aff *res;
+	isl_bool equal;
+	int i;
+	isl_size n_in, n_out;
+
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+					isl_pw_multi_aff_get_space(pma));
+	pma = isl_pw_multi_aff_align_params(pma,
+					isl_multi_union_pw_aff_get_space(mupa));
+	if (!mupa || !pma)
+		goto error;
+
+	space1 = isl_multi_union_pw_aff_get_space(mupa);
+	space2 = isl_pw_multi_aff_get_domain_space(pma);
+	equal = isl_space_is_equal(space1, space2);
+	isl_space_free(space1);
+	isl_space_free(space2);
+	if (equal < 0)
+		goto error;
+	if (!equal)
+		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_invalid,
+			"spaces don't match", goto error);
+	n_in = isl_pw_multi_aff_dim(pma, isl_dim_in);
+	n_out = isl_pw_multi_aff_dim(pma, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		goto error;
+	if (n_in == 0)
+		return mupa_apply_pw_multi_aff_0D(mupa, pma);
+
+	space1 = isl_space_range(isl_pw_multi_aff_get_space(pma));
+	res = isl_multi_union_pw_aff_alloc(space1);
+
+	for (i = 0; i < n_out; ++i) {
+		isl_pw_aff *pa;
+		isl_union_pw_aff *upa;
+
+		pa = isl_pw_multi_aff_get_pw_aff(pma, i);
+		upa = isl_multi_union_pw_aff_apply_pw_aff(
+					isl_multi_union_pw_aff_copy(mupa), pa);
+		res = isl_multi_union_pw_aff_set_union_pw_aff(res, i, upa);
+	}
+
+	isl_pw_multi_aff_free(pma);
+	isl_multi_union_pw_aff_free(mupa);
+	return res;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_pw_multi_aff_free(pma);
+	return NULL;
+}
+
+/* Replace the explicit domain of "mupa" by its preimage under "upma".
+ * If the explicit domain only keeps track of constraints on the parameters,
+ * then only update those constraints.
+ */
+static __isl_give isl_multi_union_pw_aff *preimage_explicit_domain(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_keep isl_union_pw_multi_aff *upma)
+{
+	isl_bool is_params;
+
+	if (isl_multi_union_pw_aff_check_has_explicit_domain(mupa) < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+
+	mupa = isl_multi_union_pw_aff_cow(mupa);
+	if (!mupa)
+		return NULL;
+
+	is_params = isl_union_set_is_params(mupa->u.dom);
+	if (is_params < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+
+	upma = isl_union_pw_multi_aff_copy(upma);
+	if (is_params)
+		mupa->u.dom = isl_union_set_intersect_params(mupa->u.dom,
+		    isl_union_set_params(isl_union_pw_multi_aff_domain(upma)));
+	else
+		mupa->u.dom = isl_union_set_preimage_union_pw_multi_aff(
+							    mupa->u.dom, upma);
+	if (!mupa->u.dom)
+		return isl_multi_union_pw_aff_free(mupa);
+	return mupa;
+}
+
+/* Compute the pullback of "mupa" by the function represented by "upma".
+ * In other words, plug in "upma" in "mupa".  The result contains
+ * expressions defined over the domain space of "upma".
+ *
+ * Run over all elements of "mupa" and plug in "upma" in each of them.
+ *
+ * If "mupa" has an explicit domain, then it is this domain
+ * that needs to undergo a pullback instead, i.e., a preimage.
+ */
+__isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_pullback_union_pw_multi_aff(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	int i;
+	isl_size n;
+
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+				    isl_union_pw_multi_aff_get_space(upma));
+	upma = isl_union_pw_multi_aff_align_params(upma,
+				    isl_multi_union_pw_aff_get_space(mupa));
+	mupa = isl_multi_union_pw_aff_cow(mupa);
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0 || !upma)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		isl_union_pw_aff *upa;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		upa = isl_union_pw_aff_pullback_union_pw_multi_aff(upa,
+					    isl_union_pw_multi_aff_copy(upma));
+		mupa = isl_multi_union_pw_aff_set_union_pw_aff(mupa, i, upa);
+	}
+
+	if (isl_multi_union_pw_aff_has_explicit_domain(mupa))
+		mupa = preimage_explicit_domain(mupa, upma);
+
+	isl_union_pw_multi_aff_free(upma);
+	return mupa;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	isl_union_pw_multi_aff_free(upma);
+	return NULL;
+}
+
+/* Extract the sequence of elements in "mupa" with domain space "space"
+ * (ignoring parameters).
+ *
+ * For the elements of "mupa" that are not defined on the specified space,
+ * the corresponding element in the result is empty.
+ */
+__isl_give isl_multi_pw_aff *isl_multi_union_pw_aff_extract_multi_pw_aff(
+	__isl_keep isl_multi_union_pw_aff *mupa, __isl_take isl_space *space)
+{
+	int i;
+	isl_size n;
+	isl_space *space_mpa;
+	isl_multi_pw_aff *mpa;
+
+	n = isl_multi_union_pw_aff_dim(mupa, isl_dim_set);
+	if (n < 0 || !space)
+		goto error;
+
+	space_mpa = isl_multi_union_pw_aff_get_space(mupa);
+	space = isl_space_replace_params(space, space_mpa);
+	space_mpa = isl_space_map_from_domain_and_range(isl_space_copy(space),
+							space_mpa);
+	mpa = isl_multi_pw_aff_alloc(space_mpa);
+
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
+	for (i = 0; i < n; ++i) {
+		isl_union_pw_aff *upa;
+		isl_pw_aff *pa;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		pa = isl_union_pw_aff_extract_pw_aff(upa,
+							isl_space_copy(space));
+		mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
+		isl_union_pw_aff_free(upa);
+	}
+
+	isl_space_free(space);
+	return mpa;
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Data structure that specifies how isl_union_pw_multi_aff_un_op
+ * should modify the base expressions in the input.
+ *
+ * If "filter" is not NULL, then only the base expressions that satisfy "filter"
+ * are taken into account.
+ * "fn" is applied to each entry in the input.
+ */
+struct isl_union_pw_multi_aff_un_op_control {
+	isl_bool (*filter)(__isl_keep isl_pw_multi_aff *part);
+	__isl_give isl_pw_multi_aff *(*fn)(__isl_take isl_pw_multi_aff *pma);
+};
+
+/* Wrapper for isl_union_pw_multi_aff_un_op filter functions (which do not take
+ * a second argument) for use as an isl_union_pw_multi_aff_transform
+ * filter function (which does take a second argument).
+ * Simply call control->filter without the second argument.
+ */
+static isl_bool isl_union_pw_multi_aff_un_op_filter_drop_user(
+	__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	struct isl_union_pw_multi_aff_un_op_control *control = user;
+
+	return control->filter(pma);
+}
+
+/* Wrapper for isl_union_pw_multi_aff_un_op base functions (which do not take
+ * a second argument) for use as an isl_union_pw_multi_aff_transform
+ * base function (which does take a second argument).
+ * Simply call control->fn without the second argument.
+ */
+static __isl_give isl_pw_multi_aff *isl_union_pw_multi_aff_un_op_drop_user(
+	__isl_take isl_pw_multi_aff *pma, void *user)
+{
+	struct isl_union_pw_multi_aff_un_op_control *control = user;
+
+	return control->fn(pma);
+}
+
+/* Construct an isl_union_pw_multi_aff that is obtained by
+ * modifying "upma" according to "control".
+ *
+ * isl_union_pw_multi_aff_transform performs essentially
+ * the same operation, but takes a filter and a callback function
+ * of a different form (with an extra argument).
+ * Call isl_union_pw_multi_aff_transform with wrappers
+ * that remove this extra argument.
+ */
+static __isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_un_op(
+	__isl_take isl_union_pw_multi_aff *upma,
+	struct isl_union_pw_multi_aff_un_op_control *control)
+{
+	struct isl_union_pw_multi_aff_transform_control t_control = {
+		.filter = &isl_union_pw_multi_aff_un_op_filter_drop_user,
+		.filter_user = control,
+		.fn = &isl_union_pw_multi_aff_un_op_drop_user,
+		.fn_user = control,
+	};
+
+	return isl_union_pw_multi_aff_transform(upma, &t_control);
+}
+
+/* For each function in "upma" of the form A -> B -> C,
+ * extract the function A -> B and collect the results.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_domain(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	struct isl_union_pw_multi_aff_un_op_control control = {
+		.filter = &isl_pw_multi_aff_range_is_wrapping,
+		.fn = &isl_pw_multi_aff_range_factor_domain,
+	};
+	return isl_union_pw_multi_aff_un_op(upma, &control);
+}
+
+/* For each function in "upma" of the form A -> B -> C,
+ * extract the function A -> C and collect the results.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_pw_multi_aff_range_factor_range(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	struct isl_union_pw_multi_aff_un_op_control control = {
+		.filter = &isl_pw_multi_aff_range_is_wrapping,
+		.fn = &isl_pw_multi_aff_range_factor_range,
+	};
+	return isl_union_pw_multi_aff_un_op(upma, &control);
+}
+
+/* Evaluate the affine function "aff" in the void point "pnt".
+ * In particular, return the value NaN.
+ */
+static __isl_give isl_val *eval_void(__isl_take isl_aff *aff,
+	__isl_take isl_point *pnt)
+{
+	isl_ctx *ctx;
+
+	ctx = isl_point_get_ctx(pnt);
+	isl_aff_free(aff);
+	isl_point_free(pnt);
+	return isl_val_nan(ctx);
+}
+
+/* Evaluate the affine expression "aff"
+ * in the coordinates (with denominator) "pnt".
+ */
+static __isl_give isl_val *eval(__isl_keep isl_vec *aff,
+	__isl_keep isl_vec *pnt)
+{
+	isl_int n, d;
+	isl_ctx *ctx;
+	isl_val *v;
+
+	if (!aff || !pnt)
+		return NULL;
+
+	ctx = isl_vec_get_ctx(aff);
+	isl_int_init(n);
+	isl_int_init(d);
+	isl_seq_inner_product(aff->el + 1, pnt->el, pnt->size, &n);
+	isl_int_mul(d, aff->el0, pnt->el0);
+	v = isl_val_rat_from_isl_int(ctx, n, d);
+	v = isl_val_normalize(v);
+	isl_int_clear(n);
+	isl_int_clear(d);
+
+	return v;
+}
+
+/* Check that the domain space of "aff" is equal to "space".
+ */
+static isl_stat isl_aff_check_has_domain_space(__isl_keep isl_aff *aff,
+	__isl_keep isl_space *space)
+{
+	isl_bool ok;
+
+	ok = isl_space_is_equal(isl_aff_peek_domain_space(aff), space);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Evaluate the affine function "aff" in "pnt".
+ */
+__isl_give isl_val *isl_aff_eval(__isl_take isl_aff *aff,
+	__isl_take isl_point *pnt)
+{
+	isl_bool is_void;
+	isl_val *v;
+	isl_local_space *ls;
+
+	if (isl_aff_check_has_domain_space(aff, isl_point_peek_space(pnt)) < 0)
+		goto error;
+	is_void = isl_point_is_void(pnt);
+	if (is_void < 0)
+		goto error;
+	if (is_void)
+		return eval_void(aff, pnt);
+
+	ls = isl_aff_get_domain_local_space(aff);
+	pnt = isl_local_space_lift_point(ls, pnt);
+
+	v = eval(aff->v, isl_point_peek_vec(pnt));
+
+	isl_aff_free(aff);
+	isl_point_free(pnt);
+
+	return v;
+error:
+	isl_aff_free(aff);
+	isl_point_free(pnt);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_aff_lex_templ.c Added

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2014      INRIA Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ */
+
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
+ * where the function value of "mpa1" lexicographically compares as "ORDER"
+ * to that of "mpa2".  "space" is the space of the result.
+ * The parameters of "mpa1" and "mpa2" are assumed to have been aligned.
+ *
+ * "mpa1" is in the given lexicographic order compared to "mpa2"
+ * if, for some i, the i-th element of "mpa1" is in that order compared to
+ * the i-th element of "mpa2" while all previous elements are
+ * pairwise equal, where the order needs to be strict (not-equal)
+ * if i corresponds to anything but the last element.
+ * The strict version of "ORDER" is defined by "STRICT_ORDER",
+ * which is the same if "ORDER" itself is strict.
+ */
+static __isl_give isl_map *FN(FN(isl_multi_pw_aff_lex,ORDER),map_on_space)(
+	__isl_keep isl_multi_pw_aff *mpa1, __isl_keep isl_multi_pw_aff *mpa2,
+	__isl_take isl_space *space)
+{
+	return isl_multi_pw_aff_lex_map_on_space(mpa1, mpa2,
+					&FN(FN(isl_pw_aff,STRICT_ORDER),map),
+					&FN(FN(isl_pw_aff,ORDER),map), space);
+}
+
+/* Return a map containing pairs of elements in the domains of "mpa1" and "mpa2"
+ * where the function value of "mpa1" lexicographically compares as "ORDER"
+ * to that of "mpa2".
+ */
+__isl_give isl_map *FN(FN(isl_multi_pw_aff_lex,ORDER),map)(
+	__isl_take isl_multi_pw_aff *mpa1, __isl_take isl_multi_pw_aff *mpa2)
+{
+	return isl_multi_pw_aff_order_map(mpa1, mpa2,
+			&FN(FN(isl_multi_pw_aff_lex,ORDER),map_on_space));
+}
+
+/* Return the subset of "map" where the domain and the range
+ * have "mpa" values that lexicographically compare as "ORDER".
+ */
+__isl_give isl_map *FN(FN(isl_map_lex,ORDER),at_multi_pw_aff)(
+	__isl_take isl_map *map, __isl_take isl_multi_pw_aff *mpa)
+{
+	return isl_map_order_at_multi_pw_aff(map, mpa,
+				&FN(FN(isl_multi_pw_aff_lex,ORDER),map));
+}

_service:tar_scm:isl-0.24.tar.gz/isl_aff_map.c Added

@@ -0,0 +1,596 @@
+/*
+ * Copyright 2011      INRIA Saclay
+ * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2016      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/ctx.h>
+#include <isl/space.h>
+#include <isl/local_space.h>
+#include <isl/union_map.h>
+#include <isl_map_private.h>
+#include <isl_aff_private.h>
+#include <isl_vec_private.h>
+#include <isl_seq.h>
+
+#include <bset_from_bmap.c>
+#include <set_from_map.c>
+
+/* Check that the input living in "space" lives in a map space.
+ * That is, check that "space" is a map space.
+ */
+static isl_stat check_input_is_map(__isl_keep isl_space *space)
+{
+	isl_bool is_set;
+
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_stat_error;
+	if (is_set)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"space of input is not a map", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that the input living in "space" lives in a set space.
+ * That is, check that "space" is a set space.
+ */
+static isl_stat check_input_is_set(__isl_keep isl_space *space)
+{
+	isl_bool is_set;
+
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_stat_error;
+	if (!is_set)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"space of input is not a set", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Construct a basic map mapping the domain of the affine expression
+ * to a one-dimensional range prescribed by the affine expression.
+ * If "rational" is set, then construct a rational basic map.
+ *
+ * A NaN affine expression cannot be converted to a basic map.
+ */
+static __isl_give isl_basic_map *isl_basic_map_from_aff2(
+	__isl_take isl_aff *aff, int rational)
+{
+	int k;
+	int pos;
+	isl_bool is_nan;
+	isl_local_space *ls;
+	isl_basic_map *bmap = NULL;
+
+	if (!aff)
+		return NULL;
+	is_nan = isl_aff_is_nan(aff);
+	if (is_nan < 0)
+		goto error;
+	if (is_nan)
+		isl_die(isl_aff_get_ctx(aff), isl_error_invalid,
+			"cannot convert NaN", goto error);
+
+	ls = isl_aff_get_local_space(aff);
+	bmap = isl_basic_map_from_local_space(ls);
+	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
+	k = isl_basic_map_alloc_equality(bmap);
+	if (k < 0)
+		goto error;
+
+	pos = isl_basic_map_offset(bmap, isl_dim_out);
+	isl_seq_cpy(bmap->eqk, aff->v->el + 1, pos);
+	isl_int_neg(bmap->eqkpos, aff->v->el0);
+	isl_seq_cpy(bmap->eqk + pos + 1, aff->v->el + 1 + pos,
+		    aff->v->size - (pos + 1));
+
+	isl_aff_free(aff);
+	if (rational)
+		bmap = isl_basic_map_set_rational(bmap);
+	bmap = isl_basic_map_gauss(bmap, NULL);
+	bmap = isl_basic_map_finalize(bmap);
+	return bmap;
+error:
+	isl_aff_free(aff);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Construct a basic map mapping the domain of the affine expression
+ * to a one-dimensional range prescribed by the affine expression.
+ */
+__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff)
+{
+	return isl_basic_map_from_aff2(aff, 0);
+}
+
+/* Construct a map mapping the domain of the affine expression
+ * to a one-dimensional range prescribed by the affine expression.
+ */
+__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
+{
+	isl_basic_map *bmap;
+
+	bmap = isl_basic_map_from_aff(aff);
+	return isl_map_from_basic_map(bmap);
+}
+
+/* Construct a basic map mapping the domain of the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ * If "rational" is set, then construct a rational basic map.
+ */
+__isl_give isl_basic_map *isl_basic_map_from_multi_aff2(
+	__isl_take isl_multi_aff *maff, int rational)
+{
+	int i;
+	isl_size dim;
+	isl_space *space;
+	isl_basic_map *bmap;
+
+	dim = isl_multi_aff_dim(maff, isl_dim_out);
+	if (dim < 0)
+		goto error;
+
+	if (dim != maff->n)
+		isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,
+			"invalid space", goto error);
+
+	space = isl_space_domain(isl_multi_aff_get_space(maff));
+	bmap = isl_basic_map_universe(isl_space_from_domain(space));
+	if (rational)
+		bmap = isl_basic_map_set_rational(bmap);
+
+	for (i = 0; i < maff->n; ++i) {
+		isl_aff *aff;
+		isl_basic_map *bmap_i;
+
+		aff = isl_aff_copy(maff->u.pi);
+		bmap_i = isl_basic_map_from_aff2(aff, rational);
+
+		bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
+	}
+
+	bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
+
+	isl_multi_aff_free(maff);
+	return bmap;
+error:
+	isl_multi_aff_free(maff);
+	return NULL;
+}
+
+/* Construct a basic map mapping the domain of the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ * If "ma" lives in a set space, then the result is actually a set.
+ */
+static __isl_give isl_basic_map *basic_map_from_multi_aff(
+	__isl_take isl_multi_aff *ma)
+{
+	return isl_basic_map_from_multi_aff2(ma, 0);
+}
+
+/* Construct a basic map mapping the domain of the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ */
+__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
+	__isl_take isl_multi_aff *ma)
+{
+	if (check_input_is_map(isl_multi_aff_peek_space(ma)) < 0)
+		ma = isl_multi_aff_free(ma);
+	return basic_map_from_multi_aff(ma);
+}
+
+/* Construct a basic set mapping the parameter domain
+ * of the multi-affine expression to its space, with each dimension
+ * in the space equated to the corresponding affine expression.
+ */
+__isl_give isl_basic_set *isl_basic_set_from_multi_aff(
+	__isl_take isl_multi_aff *ma)
+{
+	if (check_input_is_set(isl_multi_aff_peek_space(ma)) < 0)
+		ma = isl_multi_aff_free(ma);
+	return bset_from_bmap(basic_map_from_multi_aff(ma));
+}
+
+/* Construct a map mapping the domain of the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ * If "maff" lives in a set space, then the result is actually a set.
+ */
+__isl_give isl_map *isl_map_from_multi_aff_internal(
+	__isl_take isl_multi_aff *maff)
+{
+	isl_basic_map *bmap;
+
+	bmap = basic_map_from_multi_aff(maff);
+	return isl_map_from_basic_map(bmap);
+}
+
+/* Construct a map mapping the domain the multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression.
+ */
+__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *ma)
+{
+	if (check_input_is_map(isl_multi_aff_peek_space(ma)) < 0)
+		ma = isl_multi_aff_free(ma);
+	return isl_map_from_multi_aff_internal(ma);
+}
+
+/* This function performs the same operation as isl_map_from_multi_aff,
+ * but is considered as a function on an isl_multi_aff when exported.
+ */
+__isl_give isl_map *isl_multi_aff_as_map(__isl_take isl_multi_aff *ma)
+{
+	return isl_map_from_multi_aff(ma);
+}
+
+/* Construct a set mapping the parameter domain the multi-affine expression
+ * to its space, with each dimension in the space equated to the
+ * corresponding affine expression.
+ */
+__isl_give isl_set *isl_set_from_multi_aff(__isl_take isl_multi_aff *ma)
+{
+	if (check_input_is_set(isl_multi_aff_peek_space(ma)) < 0)
+		ma = isl_multi_aff_free(ma);
+	return isl_map_from_multi_aff_internal(ma);
+}
+
+/* This function performs the same operation as isl_set_from_multi_aff,
+ * but is considered as a function on an isl_multi_aff when exported.
+ */
+__isl_give isl_set *isl_multi_aff_as_set(__isl_take isl_multi_aff *ma)
+{
+	return isl_set_from_multi_aff(ma);
+}
+
+/* Construct a basic map mapping a domain in the given space to
+ * to an n-dimensional range, with n the number of elements in the list,
+ * where each coordinate in the range is prescribed by the
+ * corresponding affine expression.
+ * The domains of all affine expressions in the list are assumed to match
+ * domain_space.
+ */
+__isl_give isl_basic_map *isl_basic_map_from_aff_list(
+	__isl_take isl_space *domain_space, __isl_take isl_aff_list *list)
+{
+	int i;
+	isl_space *space;
+	isl_basic_map *bmap;
+
+	if (!list)
+		return NULL;
+
+	space = isl_space_from_domain(domain_space);
+	bmap = isl_basic_map_universe(space);
+
+	for (i = 0; i < list->n; ++i) {
+		isl_aff *aff;
+		isl_basic_map *bmap_i;
+
+		aff = isl_aff_copy(list->pi);
+		bmap_i = isl_basic_map_from_aff(aff);
+
+		bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
+	}
+
+	isl_aff_list_free(list);
+	return bmap;
+}
+
+/* Construct a map with as domain the domain of pwaff and
+ * one-dimensional range corresponding to the affine expressions.
+ * If "pwaff" lives in a set space, then the result is actually a set.
+ */
+__isl_give isl_map *isl_map_from_pw_aff_internal(__isl_take isl_pw_aff *pwaff)
+{
+	int i;
+	isl_space *space;
+	isl_map *map;
+
+	if (!pwaff)
+		return NULL;
+
+	space = isl_pw_aff_get_space(pwaff);
+	map = isl_map_empty(space);
+
+	for (i = 0; i < pwaff->n; ++i) {
+		isl_basic_map *bmap;
+		isl_map *map_i;
+
+		bmap = isl_basic_map_from_aff(isl_aff_copy(pwaff->pi.aff));
+		map_i = isl_map_from_basic_map(bmap);
+		map_i = isl_map_intersect_domain(map_i,
+						isl_set_copy(pwaff->pi.set));
+		map = isl_map_union_disjoint(map, map_i);
+	}
+
+	isl_pw_aff_free(pwaff);
+
+	return map;
+}
+
+/* Construct a map with as domain the domain of pwaff and
+ * one-dimensional range corresponding to the affine expressions.
+ */
+__isl_give isl_map *isl_map_from_pw_aff(__isl_take isl_pw_aff *pwaff)
+{
+	if (check_input_is_map(isl_pw_aff_peek_space(pwaff)) < 0)
+		pwaff = isl_pw_aff_free(pwaff);
+	return isl_map_from_pw_aff_internal(pwaff);
+}
+
+/* This function performs the same operation as isl_map_from_pw_aff,
+ * but is considered as a function on an isl_pw_aff when exported.
+ */
+__isl_give isl_map *isl_pw_aff_as_map(__isl_take isl_pw_aff *pa)
+{
+	return isl_map_from_pw_aff(pa);
+}
+
+/* Construct a one-dimensional set with as parameter domain
+ * the domain of pwaff and the single set dimension
+ * corresponding to the affine expressions.
+ */
+__isl_give isl_set *isl_set_from_pw_aff(__isl_take isl_pw_aff *pwaff)
+{
+	if (check_input_is_set(isl_pw_aff_peek_space(pwaff)) < 0)
+		pwaff = isl_pw_aff_free(pwaff);
+	return set_from_map(isl_map_from_pw_aff_internal(pwaff));
+}
+
+/* Construct a map mapping the domain of the piecewise multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression on its cell.
+ * If "pma" lives in a set space, then the result is actually a set.
+ *
+ * If the domain of "pma" is rational, then so is the constructed "map".
+ */
+__isl_give isl_map *isl_map_from_pw_multi_aff_internal(
+	__isl_take isl_pw_multi_aff *pma)
+{
+	int i;
+	isl_map *map;
+
+	if (!pma)
+		return NULL;
+
+	map = isl_map_empty(isl_pw_multi_aff_get_space(pma));
+
+	for (i = 0; i < pma->n; ++i) {
+		isl_bool rational;
+		isl_multi_aff *maff;
+		isl_basic_map *bmap;
+		isl_map *map_i;
+
+		rational = isl_set_is_rational(pma->pi.set);
+		if (rational < 0)
+			map = isl_map_free(map);
+		maff = isl_multi_aff_copy(pma->pi.maff);
+		bmap = isl_basic_map_from_multi_aff2(maff, rational);
+		map_i = isl_map_from_basic_map(bmap);
+		map_i = isl_map_intersect_domain(map_i,
+						isl_set_copy(pma->pi.set));
+		map = isl_map_union_disjoint(map, map_i);
+	}
+
+	isl_pw_multi_aff_free(pma);
+	return map;
+}
+
+/* Construct a map mapping the domain of the piecewise multi-affine expression
+ * to its range, with each dimension in the range equated to the
+ * corresponding affine expression on its cell.
+ */
+__isl_give isl_map *isl_map_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma)
+{
+	if (check_input_is_map(isl_pw_multi_aff_peek_space(pma)) < 0)
+		pma = isl_pw_multi_aff_free(pma);
+	return isl_map_from_pw_multi_aff_internal(pma);
+}
+
+/* This function performs the same operation as isl_map_from_pw_multi_aff,
+ * but is considered as a function on an isl_pw_multi_aff when exported.
+ */
+__isl_give isl_map *isl_pw_multi_aff_as_map(__isl_take isl_pw_multi_aff *pma)
+{
+	return isl_map_from_pw_multi_aff(pma);
+}
+
+__isl_give isl_set *isl_set_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma)
+{
+	if (check_input_is_set(isl_pw_multi_aff_peek_space(pma)) < 0)
+		pma = isl_pw_multi_aff_free(pma);
+	return set_from_map(isl_map_from_pw_multi_aff_internal(pma));
+}
+
+/* This function performs the same operation as isl_set_from_pw_multi_aff,
+ * but is considered as a function on an isl_pw_multi_aff when exported.
+ */
+__isl_give isl_set *isl_pw_multi_aff_as_set(__isl_take isl_pw_multi_aff *pma)
+{
+	return isl_set_from_pw_multi_aff(pma);
+}
+
+/* Construct a set or map mapping the shared (parameter) domain
+ * of the piecewise affine expressions to the range of "mpa"
+ * with each dimension in the range equated to the
+ * corresponding piecewise affine expression.
+ */
+static __isl_give isl_map *map_from_multi_pw_aff(
+	__isl_take isl_multi_pw_aff *mpa)
+{
+	int i;
+	isl_size dim;
+	isl_space *space;
+	isl_map *map;
+
+	dim = isl_multi_pw_aff_dim(mpa, isl_dim_out);
+	if (dim < 0)
+		goto error;
+
+	if (isl_space_dim(mpa->space, isl_dim_out) != mpa->n)
+		isl_die(isl_multi_pw_aff_get_ctx(mpa), isl_error_internal,
+			"invalid space", goto error);
+
+	space = isl_multi_pw_aff_get_domain_space(mpa);
+	map = isl_map_universe(isl_space_from_domain(space));
+
+	for (i = 0; i < mpa->n; ++i) {
+		isl_pw_aff *pa;
+		isl_map *map_i;
+
+		pa = isl_pw_aff_copy(mpa->u.pi);
+		map_i = isl_map_from_pw_aff_internal(pa);
+
+		map = isl_map_flat_range_product(map, map_i);
+	}
+
+	map = isl_map_reset_space(map, isl_multi_pw_aff_get_space(mpa));
+
+	isl_multi_pw_aff_free(mpa);
+	return map;
+error:
+	isl_multi_pw_aff_free(mpa);
+	return NULL;
+}
+
+/* Construct a map mapping the shared domain
+ * of the piecewise affine expressions to the range of "mpa"
+ * with each dimension in the range equated to the
+ * corresponding piecewise affine expression.
+ */
+__isl_give isl_map *isl_map_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa)
+{
+	if (check_input_is_map(isl_multi_pw_aff_peek_space(mpa)) < 0)
+		mpa = isl_multi_pw_aff_free(mpa);
+	return map_from_multi_pw_aff(mpa);
+}
+
+/* This function performs the same operation as isl_map_from_multi_pw_aff,
+ * but is considered as a function on an isl_multi_pw_aff when exported.
+ */
+__isl_give isl_map *isl_multi_pw_aff_as_map(__isl_take isl_multi_pw_aff *mpa)
+{
+	return isl_map_from_multi_pw_aff(mpa);
+}
+
+/* Construct a set mapping the shared parameter domain
+ * of the piecewise affine expressions to the space of "mpa"
+ * with each dimension in the range equated to the
+ * corresponding piecewise affine expression.
+ */
+__isl_give isl_set *isl_set_from_multi_pw_aff(__isl_take isl_multi_pw_aff *mpa)
+{
+	if (check_input_is_set(isl_multi_pw_aff_peek_space(mpa)) < 0)
+		mpa = isl_multi_pw_aff_free(mpa);
+	return set_from_map(map_from_multi_pw_aff(mpa));
+}
+
+/* This function performs the same operation as isl_set_from_multi_pw_aff,
+ * but is considered as a function on an isl_multi_pw_aff when exported.
+ */
+__isl_give isl_set *isl_multi_pw_aff_as_set(__isl_take isl_multi_pw_aff *mpa)
+{
+	return isl_set_from_multi_pw_aff(mpa);
+}
+
+/* Convert "pa" to an isl_map and add it to *umap.
+ */
+static isl_stat map_from_pw_aff_entry(__isl_take isl_pw_aff *pa, void *user)
+{
+	isl_union_map **umap = user;
+	isl_map *map;
+
+	map = isl_map_from_pw_aff(pa);
+	*umap = isl_union_map_add_map(*umap, map);
+
+	return *umap ? isl_stat_ok : isl_stat_error;
+}
+
+/* Construct a union map mapping the domain of the union
+ * piecewise affine expression to its range, with the single output dimension
+ * equated to the corresponding affine expressions on their cells.
+ */
+__isl_give isl_union_map *isl_union_map_from_union_pw_aff(
+	__isl_take isl_union_pw_aff *upa)
+{
+	isl_space *space;
+	isl_union_map *umap;
+
+	if (!upa)
+		return NULL;
+
+	space = isl_union_pw_aff_get_space(upa);
+	umap = isl_union_map_empty(space);
+
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &map_from_pw_aff_entry,
+						&umap) < 0)
+		umap = isl_union_map_free(umap);
+
+	isl_union_pw_aff_free(upa);
+	return umap;
+}
+
+/* Convert "pma" to an isl_map and add it to *umap.
+ */
+static isl_stat map_from_pw_multi_aff(__isl_take isl_pw_multi_aff *pma,
+	void *user)
+{
+	isl_union_map **umap = user;
+	isl_map *map;
+
+	map = isl_map_from_pw_multi_aff(pma);
+	*umap = isl_union_map_add_map(*umap, map);
+
+	return isl_stat_ok;
+}
+
+/* Construct a union map mapping the domain of the union
+ * piecewise multi-affine expression to its range, with each dimension
+ * in the range equated to the corresponding affine expression on its cell.
+ */
+__isl_give isl_union_map *isl_union_map_from_union_pw_multi_aff(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	isl_space *space;
+	isl_union_map *umap;
+
+	if (!upma)
+		return NULL;
+
+	space = isl_union_pw_multi_aff_get_space(upma);
+	umap = isl_union_map_empty(space);
+
+	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
+					&map_from_pw_multi_aff, &umap) < 0)
+		goto error;
+
+	isl_union_pw_multi_aff_free(upma);
+	return umap;
+error:
+	isl_union_pw_multi_aff_free(upma);
+	isl_union_map_free(umap);
+	return NULL;
+}
+
+/* This function performs the same operation as
+ * isl_union_map_from_union_pw_multi_aff,
+ * but is considered as a function on an isl_union_pw_multi_aff when exported.
+ */
+__isl_give isl_union_map *isl_union_pw_multi_aff_as_union_map(
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	return isl_union_map_from_union_pw_multi_aff(upma);
+}

_service:tar_scm:isl-0.14.tar.xz/isl_aff_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_aff_private.h Changed

@@ -41,6 +41,11 @@
 	struct isl_pw_aff_piece p1;
 };
 
+#undef PW
+#define PW isl_pw_aff
+
+#include <isl_pw_templ.h>
+
 #undef EL
 #define EL isl_pw_aff
 
@@ -62,23 +67,35 @@
 	struct isl_pw_multi_aff_piece p1;
 };
 
+#undef PW
+#define PW isl_pw_multi_aff
+
+#include <isl_pw_templ.h>
+
 __isl_give isl_aff *isl_aff_alloc_vec(__isl_take isl_local_space *ls,
 	__isl_take isl_vec *v);
 __isl_give isl_aff *isl_aff_alloc(__isl_take isl_local_space *ls);
 
+isl_size isl_aff_domain_dim(__isl_keep isl_aff *aff, enum isl_dim_type type);
+isl_size isl_aff_domain_offset(__isl_keep isl_aff *aff, enum isl_dim_type type);
+
 __isl_give isl_aff *isl_aff_reset_space_and_domain(__isl_take isl_aff *aff,
 	__isl_take isl_space *space, __isl_take isl_space *domain);
 __isl_give isl_aff *isl_aff_reset_domain_space(__isl_take isl_aff *aff,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 __isl_give isl_aff *isl_aff_realign_domain(__isl_take isl_aff *aff,
 	__isl_take isl_reordering *r);
 
-int isl_aff_get_constant(__isl_keep isl_aff *aff, isl_int *v);
 __isl_give isl_aff *isl_aff_set_constant(__isl_take isl_aff *aff, isl_int v);
 __isl_give isl_aff *isl_aff_set_coefficient(__isl_take isl_aff *aff,
 	enum isl_dim_type type, int pos, isl_int v);
 __isl_give isl_aff *isl_aff_add_constant(__isl_take isl_aff *aff, isl_int v);
 
+__isl_give isl_aff *isl_aff_domain_factor_domain(__isl_take isl_aff *aff);
+
+int isl_aff_plain_cmp(__isl_keep isl_aff *aff1, __isl_keep isl_aff *aff2);
+
+__isl_give isl_aff *isl_aff_remove_unused_divs(__isl_take isl_aff *aff);
 __isl_give isl_aff *isl_aff_normalize(__isl_take isl_aff *aff);
 
 __isl_give isl_aff *isl_aff_expand_divs( __isl_take isl_aff *aff,
@@ -87,12 +104,15 @@
 __isl_give isl_pw_aff *isl_pw_aff_alloc_size(__isl_take isl_space *space,
 	int n);
 __isl_give isl_pw_aff *isl_pw_aff_reset_space(__isl_take isl_pw_aff *pwaff,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 __isl_give isl_pw_aff *isl_pw_aff_reset_domain_space(
 	__isl_take isl_pw_aff *pwaff, __isl_take isl_space *space);
 __isl_give isl_pw_aff *isl_pw_aff_add_disjoint(
 	__isl_take isl_pw_aff *pwaff1, __isl_take isl_pw_aff *pwaff2);
 
+__isl_give isl_pw_aff *isl_pw_aff_domain_factor_domain(
+	__isl_take isl_pw_aff *pa);
+
 __isl_give isl_pw_aff *isl_pw_aff_union_opt(__isl_take isl_pw_aff *pwaff1,
 	__isl_take isl_pw_aff *pwaff2, int max);
 
@@ -100,14 +120,15 @@
 __isl_give isl_pw_aff_list *isl_pw_aff_list_set_rational(
 	__isl_take isl_pw_aff_list *list);
 
+__isl_give isl_aff *isl_aff_scale_down(__isl_take isl_aff *aff, isl_int f);
 __isl_give isl_pw_aff *isl_pw_aff_scale(__isl_take isl_pw_aff *pwaff,
 	isl_int f);
 __isl_give isl_pw_aff *isl_pw_aff_scale_down(__isl_take isl_pw_aff *pwaff,
 	isl_int f);
 
-int isl_aff_matching_params(__isl_keep isl_aff *aff,
+isl_bool isl_aff_matching_params(__isl_keep isl_aff *aff,
 	__isl_keep isl_space *space);
-int isl_aff_check_match_domain_space(__isl_keep isl_aff *aff,
+isl_stat isl_aff_check_match_domain_space(__isl_keep isl_aff *aff,
 	__isl_keep isl_space *space);
 
 #undef BASE
@@ -123,6 +144,19 @@
 __isl_give isl_multi_aff *isl_multi_aff_from_basic_set_equalities(
 	__isl_take isl_basic_set *bset);
 
+__isl_give isl_multi_aff *isl_multi_aff_from_aff_mat(
+	__isl_take isl_space *space, __isl_take isl_mat *mat);
+
+#undef EL
+#define EL isl_pw_multi_aff
+
+#include <isl_list_templ.h>
+
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_move_dims(
+	__isl_take isl_pw_multi_aff *pma,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n);
+
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_domain_space(
 	__isl_take isl_pw_multi_aff *pwmaff, __isl_take isl_space *space);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_reset_space(
@@ -134,25 +168,59 @@
 	__isl_take isl_pw_multi_aff *pma,
 	enum isl_dim_type type, unsigned first, unsigned n);
 
-void isl_seq_substitute(isl_int *p, int pos, isl_int *subs,
-	int p_len, int subs_len, isl_int v);
-void isl_seq_preimage(isl_int *dst, isl_int *src,
+isl_stat isl_seq_preimage(isl_int *dst, isl_int *src,
 	__isl_keep isl_multi_aff *ma, int n_before, int n_after,
 	int n_div_ma, int n_div_bmap,
 	isl_int f, isl_int c1, isl_int c2, isl_int g, int has_denom);
 
+__isl_give isl_aff *isl_aff_substitute_equalities(__isl_take isl_aff *aff,
+	__isl_take isl_basic_set *eq);
 __isl_give isl_pw_multi_aff *isl_pw_multi_aff_substitute(
 	__isl_take isl_pw_multi_aff *pma, enum isl_dim_type type, unsigned pos,
 	__isl_keep isl_pw_aff *subs);
 
-int isl_pw_aff_matching_params(__isl_keep isl_pw_aff *pa,
+isl_stat isl_pw_aff_check_named_params(__isl_keep isl_pw_aff *pa);
+isl_stat isl_multi_aff_check_named_params(__isl_keep isl_multi_aff *ma);
+isl_stat isl_pw_multi_aff_check_named_params(__isl_keep isl_pw_multi_aff *pma);
+
+isl_bool isl_pw_aff_matching_params(__isl_keep isl_pw_aff *pa,
 	__isl_keep isl_space *space);
-int isl_pw_aff_check_match_domain_space(__isl_keep isl_pw_aff *pa,
+isl_stat isl_pw_aff_check_match_domain_space(__isl_keep isl_pw_aff *pa,
 	__isl_keep isl_space *space);
 
+__isl_give isl_basic_set *isl_aff_pos_basic_set(__isl_take isl_aff *aff);
+
 #undef BASE
 #define BASE pw_aff
+#undef DOMBASE
+#define DOMBASE set
+#define EXPLICIT_DOMAIN
+
+#include <isl_multi_templ.h>
+
+#undef EXPLICIT_DOMAIN
+
+__isl_give isl_map *isl_map_intersect_multi_pw_aff_explicit_domain(
+	__isl_take isl_map *map, __isl_keep isl_multi_pw_aff *mpa);
+
+#undef EL
+#define EL isl_union_pw_aff
+
+#include <isl_list_templ.h>
+
+#undef BASE
+#define BASE union_pw_aff
+#undef DOMBASE
+#define DOMBASE union_set
+#define EXPLICIT_DOMAIN
 
 #include <isl_multi_templ.h>
 
+#undef EXPLICIT_DOMAIN
+
+#undef EL
+#define EL isl_union_pw_multi_aff
+
+#include <isl_list_templ.h>
+
 #endif

_service:tar_scm:isl-0.14.tar.xz/isl_affine_hull.c -> _service:tar_scm:isl-0.24.tar.gz/isl_affine_hull.c Changed

@@ -24,8 +24,13 @@
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 
-struct isl_basic_map *isl_basic_map_implicit_equalities(
-						struct isl_basic_map *bmap)
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
+#include <set_from_map.c>
+
+__isl_give isl_basic_map *isl_basic_map_implicit_equalities(
+	__isl_take isl_basic_map *bmap)
 {
 	struct isl_tab *tab;
 
@@ -54,30 +59,11 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_implicit_equalities(
-						struct isl_basic_set *bset)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_implicit_equalities((struct isl_basic_map*)bset);
-}
-
-struct isl_map *isl_map_implicit_equalities(struct isl_map *map)
+__isl_give isl_basic_set *isl_basic_set_implicit_equalities(
+	__isl_take isl_basic_set *bset)
 {
-	int i;
-
-	if (!map)
-		return map;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_implicit_equalities(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return bset_from_bmap(
+		isl_basic_map_implicit_equalities(bset_to_bmap(bset)));
 }
 
 /* Make eqrowcol of both bmaps equal so we can add the row
@@ -107,7 +93,7 @@
 
 /* Delete a given equality, moving all the following equalities one up.
  */
-static void delete_row(struct isl_basic_set *bset, unsigned row)
+static void delete_row(__isl_keep isl_basic_set *bset, unsigned row)
 {
 	isl_int *t;
 	int r;
@@ -128,18 +114,21 @@
  * so that
  *		Aicol = Bicol = a * old(Bicol)
  */
-static void construct_column(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2,
+static isl_stat construct_column(
+	__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
 	unsigned row, unsigned col)
 {
 	int r;
 	isl_int a;
 	isl_int b;
-	unsigned total;
+	isl_size total;
+
+	total = isl_basic_set_dim(bset1, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
 
 	isl_int_init(a);
 	isl_int_init(b);
-	total = 1 + isl_basic_set_n_dim(bset1);
 	for (r = 0; r < row; ++r) {
 		if (isl_int_is_zero(bset2->eqrcol))
 			continue;
@@ -147,12 +136,14 @@
 		isl_int_divexact(a, bset1->eqrowcol, b);
 		isl_int_divexact(b, bset2->eqrcol, b);
 		isl_seq_combine(bset1->eqr, a, bset1->eqr,
-					      b, bset1->eqrow, total);
-		isl_seq_scale(bset2->eqr, bset2->eqr, a, total);
+					      b, bset1->eqrow, 1 + total);
+		isl_seq_scale(bset2->eqr, bset2->eqr, a, 1 + total);
 	}
 	isl_int_clear(a);
 	isl_int_clear(b);
 	delete_row(bset1, row);
+
+	return isl_stat_ok;
 }
 
 /* Make first row entries in column col of bset1 identical to
@@ -164,21 +155,23 @@
  * so that
  *	Aicol = Bicol = old(Atcol*Bicol-Aicol*Btcol)
  */
-static int transform_column(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2,
+static isl_bool transform_column(
+	__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
 	unsigned row, unsigned col)
 {
 	int i, t;
 	isl_int a, b, g;
-	unsigned total;
+	isl_size total;
 
 	for (t = row-1; t >= 0; --t)
 		if (isl_int_ne(bset1->eqtcol, bset2->eqtcol))
 			break;
 	if (t < 0)
-		return 0;
+		return isl_bool_false;
 
-	total = 1 + isl_basic_set_n_dim(bset1);
+	total = isl_basic_set_dim(bset1, isl_dim_set);
+	if (total < 0)
+		return isl_bool_error;
 	isl_int_init(a);
 	isl_int_init(b);
 	isl_int_init(g);
@@ -189,16 +182,16 @@
 		isl_int_divexact(a, a, g);
 		isl_int_divexact(g, b, g);
 		isl_seq_combine(bset1->eqi, g, bset1->eqi, a, bset1->eqt,
-				total);
+				1 + total);
 		isl_seq_combine(bset2->eqi, g, bset2->eqi, a, bset2->eqt,
-				total);
+				1 + total);
 	}
 	isl_int_clear(a);
 	isl_int_clear(b);
 	isl_int_clear(g);
 	delete_row(bset1, t);
 	delete_row(bset2, t);
-	return 1;
+	return isl_bool_true;
 }
 
 /* The implementation is based on Section 5.2 of Michael Karr,
@@ -206,17 +199,19 @@
  * except that the echelon form we use starts from the last column
  * and that we are dealing with integer coefficients.
  */
-static struct isl_basic_set *affine_hull(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *affine_hull(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
+	isl_size dim;
 	unsigned total;
 	int col;
 	int row;
 
-	if (!bset1 || !bset2)
+	dim = isl_basic_set_dim(bset1, isl_dim_set);
+	if (dim < 0 || !bset2)
 		goto error;
 
-	total = 1 + isl_basic_set_n_dim(bset1);
+	total = 1 + dim;
 
 	row = 0;
 	for (col = total-1; col >= 0; --col) {
@@ -228,11 +223,18 @@
 			set_common_multiple(bset1, bset2, row, col);
 			++row;
 		} else if (!is_zero1 && is_zero2) {
-			construct_column(bset1, bset2, row, col);
+			if (construct_column(bset1, bset2, row, col) < 0)
+				goto error;
 		} else if (is_zero1 && !is_zero2) {
-			construct_column(bset2, bset1, row, col);
+			if (construct_column(bset2, bset1, row, col) < 0)
+				goto error;
 		} else {
-			if (transform_column(bset1, bset2, row, col))
+			isl_bool transform;
+
+			transform = transform_column(bset1, bset2, row, col);
+			if (transform < 0)
+				goto error;
+			if (transform)
 				--row;
 		}
 	}
@@ -261,7 +263,8 @@
  * The caller of this function ensures that the tableau is bounded or
  * that tab->basis and tab->n_unbounded have been set appropriately.
  */
-static struct isl_vec *outside_point(struct isl_tab *tab, isl_int *eq, int up)
+static __isl_give isl_vec *outside_point(struct isl_tab *tab, isl_int *eq,
+	int up)
 {
 	struct isl_ctx *ctx;
 	struct isl_vec *sample = NULL;
@@ -311,14 +314,21 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_recession_cone(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_recession_cone(
+	__isl_take isl_basic_set *bset)
 {
 	int i;
+	isl_bool empty;
+
+	empty = isl_basic_set_plain_is_empty(bset);
+	if (empty < 0)
+		return isl_basic_set_free(bset);
+	if (empty)
+		return bset;
 
 	bset = isl_basic_set_cow(bset);
-	if (!bset)
-		return NULL;
-	isl_assert(bset->ctx, bset->n_div == 0, goto error);
+	if (isl_basic_set_check_no_locals(bset) < 0)
+		return isl_basic_set_free(bset);
 
 	for (i = 0; i < bset->n_eq; ++i)
 		isl_int_set_si(bset->eqi0, 0);
@@ -328,35 +338,6 @@
 
 	ISL_F_CLR(bset, ISL_BASIC_SET_NO_IMPLICIT);
 	return isl_basic_set_implicit_equalities(bset);
-error:
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
-__isl_give isl_set *isl_set_recession_cone(__isl_take isl_set *set)
-{
-	int i;
-
-	if (!set)
-		return NULL;
-	if (set->n == 0)
-		return set;
-
-	set = isl_set_remove_divs(set);
-	set = isl_set_cow(set);
-	if (!set)
-		return NULL;
-
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_recession_cone(set->pi);
-		if (!set->pi)
-			goto error;
-	}
-
-	return set;
-error:
-	isl_set_free(set);
-	return NULL;
 }
 
 /* Move "sample" to a point that is one up (or down) from the original
@@ -382,12 +363,11 @@
 	__isl_keep isl_basic_set *bset)
 {
 	int i, up;
-	int dim;
-
-	if (!sample)
-		goto error;
+	isl_size dim;
 
 	dim = isl_basic_set_dim(hull, isl_dim_set);
+	if (!sample || dim < 0)
+		goto error;
 
 	for (i = 0; i < dim; ++i) {
 		for (up = 0; up <= 1; ++up) {
@@ -492,180 +472,7 @@
 	return NULL;
 }
 
-/* Drop all constraints in bmap that involve any of the dimensions
- * first to first+n-1.
- */
-static __isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
-	__isl_take isl_basic_map *bmap, unsigned first, unsigned n)
-{
-	int i;
-
-	if (n == 0)
-		return bmap;
-
-	bmap = isl_basic_map_cow(bmap);
-
-	if (!bmap)
-		return NULL;
-
-	for (i = bmap->n_eq - 1; i >= 0; --i) {
-		if (isl_seq_first_non_zero(bmap->eqi + 1 + first, n) == -1)
-			continue;
-		isl_basic_map_drop_equality(bmap, i);
-	}
-
-	for (i = bmap->n_ineq - 1; i >= 0; --i) {
-		if (isl_seq_first_non_zero(bmap->ineqi + 1 + first, n) == -1)
-			continue;
-		isl_basic_map_drop_inequality(bmap, i);
-	}
-
-	bmap = isl_basic_map_add_known_div_constraints(bmap);
-	return bmap;
-}
-
-/* Drop all constraints in bset that involve any of the dimensions
- * first to first+n-1.
- */
-__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving(
-	__isl_take isl_basic_set *bset, unsigned first, unsigned n)
-{
-	return isl_basic_map_drop_constraints_involving(bset, first, n);
-}
-
-/* Drop all constraints in bmap that do not involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
-	__isl_take isl_basic_map *bmap,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	int i;
-	unsigned dim;
-
-	if (n == 0) {
-		isl_space *space = isl_basic_map_get_space(bmap);
-		isl_basic_map_free(bmap);
-		return isl_basic_map_universe(space);
-	}
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
-	dim = isl_basic_map_dim(bmap, type);
-	if (first + n > dim || first + n < first)
-		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
-			"index out of bounds", return isl_basic_map_free(bmap));
-
-	first += isl_basic_map_offset(bmap, type) - 1;
-
-	for (i = bmap->n_eq - 1; i >= 0; --i) {
-		if (isl_seq_first_non_zero(bmap->eqi + 1 + first, n) != -1)
-			continue;
-		isl_basic_map_drop_equality(bmap, i);
-	}
-
-	for (i = bmap->n_ineq - 1; i >= 0; --i) {
-		if (isl_seq_first_non_zero(bmap->ineqi + 1 + first, n) != -1)
-			continue;
-		isl_basic_map_drop_inequality(bmap, i);
-	}
-
-	bmap = isl_basic_map_add_known_div_constraints(bmap);
-	return bmap;
-}
-
-/* Drop all constraints in bset that do not involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_basic_set *isl_basic_set_drop_constraints_not_involving_dims(
-	__isl_take isl_basic_set *bset,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return isl_basic_map_drop_constraints_not_involving_dims(bset,
-							    type, first, n);
-}
-
-/* Drop all constraints in bmap that involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
-	__isl_take isl_basic_map *bmap,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	unsigned dim;
-
-	if (!bmap)
-		return NULL;
-	if (n == 0)
-		return bmap;
-
-	dim = isl_basic_map_dim(bmap, type);
-	if (first + n > dim || first + n < first)
-		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
-			"index out of bounds", return isl_basic_map_free(bmap));
-
-	bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
-	first += isl_basic_map_offset(bmap, type) - 1;
-	return isl_basic_map_drop_constraints_involving(bmap, first, n);
-}
-
-/* Drop all constraints in bset that involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_dims(
-	__isl_take isl_basic_set *bset,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return isl_basic_map_drop_constraints_involving_dims(bset,
-							    type, first, n);
-}
-
-/* Drop all constraints in map that involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_map *isl_map_drop_constraints_involving_dims(
-	__isl_take isl_map *map,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	int i;
-	unsigned dim;
-
-	if (!map)
-		return NULL;
-	if (n == 0)
-		return map;
-
-	dim = isl_map_dim(map, type);
-	if (first + n > dim || first + n < first)
-		isl_die(isl_map_get_ctx(map), isl_error_invalid,
-			"index out of bounds", return isl_map_free(map));
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_drop_constraints_involving_dims(
-						    map->pi, type, first, n);
-		if (!map->pi)
-			return isl_map_free(map);
-	}
-
-	return map;
-}
-
-/* Drop all constraints in set that involve any of the dimensions
- * first to first + n - 1 of the given type.
- */
-__isl_give isl_set *isl_set_drop_constraints_involving_dims(
-	__isl_take isl_set *set,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return isl_map_drop_constraints_involving_dims(set, type, first, n);
-}
-
-/* Construct an initial underapproximatino of the hull of "bset"
+/* Construct an initial underapproximation of the hull of "bset"
  * from "sample" and any of its adjacent points that also belong to "bset".
  */
 static __isl_give isl_basic_set *initialize_hull(__isl_keep isl_basic_set *bset,
@@ -688,17 +495,20 @@
  * we check if there is any point on a hyperplane parallel to the
  * corresponding hyperplane shifted by at least one (in either direction).
  */
-static struct isl_basic_set *uset_affine_hull_bounded(struct isl_basic_set *bset)
+static __isl_give isl_basic_set *uset_affine_hull_bounded(
+	__isl_take isl_basic_set *bset)
 {
 	struct isl_vec *sample = NULL;
 	struct isl_basic_set *hull;
 	struct isl_tab *tab = NULL;
-	unsigned dim;
+	isl_size dim;
 
 	if (isl_basic_set_plain_is_empty(bset))
 		return bset;
 
-	dim = isl_basic_set_n_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		return isl_basic_set_free(bset);
 
 	if (bset->sample && bset->sample->size == 1 + dim) {
 		int contains = isl_basic_set_contains(bset, bset->sample);
@@ -769,7 +579,7 @@
 	int k;
 	struct isl_basic_set *bset = NULL;
 	struct isl_ctx *ctx;
-	unsigned dim;
+	isl_size dim;
 
 	if (!vec || !tab)
 		return NULL;
@@ -777,9 +587,10 @@
 	isl_assert(ctx, vec->size != 0, goto error);
 
 	bset = isl_basic_set_alloc(ctx, 0, vec->size - 1, 0, vec->size - 1, 0);
-	if (!bset)
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
 		goto error;
-	dim = isl_basic_set_n_dim(bset) - tab->n_unbounded;
+	dim -= tab->n_unbounded;
 	for (i = 0; i < dim; ++i) {
 		k = isl_basic_set_alloc_equality(bset);
 		if (k < 0)
@@ -916,18 +727,18 @@
  * The affine hull in the original space is then obtained as
  * A = preimage(A'', Q_1).
  */
-static struct isl_basic_set *affine_hull_with_cone(struct isl_basic_set *bset,
-	struct isl_basic_set *cone)
+static __isl_give isl_basic_set *affine_hull_with_cone(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *cone)
 {
-	unsigned total;
+	isl_size total;
 	unsigned cone_dim;
 	struct isl_basic_set *hull;
 	struct isl_mat *M, *U, *Q;
 
-	if (!bset || !cone)
+	total = isl_basic_set_dim(cone, isl_dim_all);
+	if (!bset || total < 0)
 		goto error;
 
-	total = isl_basic_set_total_dim(cone);
 	cone_dim = total - cone->n_eq;
 
 	M = isl_mat_sub_alloc6(bset->ctx, cone->eq, 0, cone->n_eq, 1, total);
@@ -994,9 +805,11 @@
  * In particular, if the recession cone is full-dimensional, then
  * the affine hull is simply the whole universe.
  */
-static struct isl_basic_set *uset_affine_hull(struct isl_basic_set *bset)
+static __isl_give isl_basic_set *uset_affine_hull(
+	__isl_take isl_basic_set *bset)
 {
 	struct isl_basic_set *cone;
+	isl_size total;
 
 	if (isl_basic_set_plain_is_empty(bset))
 		return bset;
@@ -1005,14 +818,17 @@
 	if (!cone)
 		goto error;
 	if (cone->n_eq == 0) {
-		struct isl_basic_set *hull;
+		isl_space *space;
+		space = isl_basic_set_get_space(bset);
 		isl_basic_set_free(cone);
-		hull = isl_basic_set_universe_like(bset);
 		isl_basic_set_free(bset);
-		return hull;
+		return isl_basic_set_universe(space);
 	}
 
-	if (cone->n_eq < isl_basic_set_total_dim(cone))
+	total = isl_basic_set_dim(cone, isl_dim_all);
+	if (total < 0)
+		bset = isl_basic_set_free(bset);
+	if (cone->n_eq < total)
 		return affine_hull_with_cone(bset, cone);
 
 	isl_basic_set_free(cone);
@@ -1035,8 +851,8 @@
  * In particular, dimensions that correspond to existential variables
  * in bmap and that are found to be fixed are not removed.
  */
-static struct isl_basic_set *equalities_in_underlying_set(
-						struct isl_basic_map *bmap)
+static __isl_give isl_basic_set *equalities_in_underlying_set(
+	__isl_take isl_basic_map *bmap)
 {
 	struct isl_mat *T1 = NULL;
 	struct isl_mat *T2 = NULL;
@@ -1084,10 +900,11 @@
 /* Detect and make explicit all equalities satisfied by the (integer)
  * points in bmap.
  */
-struct isl_basic_map *isl_basic_map_detect_equalities(
-						struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_detect_equalities(
+	__isl_take isl_basic_map *bmap)
 {
 	int i, j;
+	isl_size total;
 	struct isl_basic_set *hull = NULL;
 
 	if (!bmap)
@@ -1108,14 +925,15 @@
 		isl_basic_set_free(hull);
 		return isl_basic_map_set_to_empty(bmap);
 	}
-	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim), 0,
-					hull->n_eq, 0);
+	bmap = isl_basic_map_extend(bmap, 0, hull->n_eq, 0);
+	total = isl_basic_set_dim(hull, isl_dim_all);
+	if (total < 0)
+		goto error;
 	for (i = 0; i < hull->n_eq; ++i) {
 		j = isl_basic_map_alloc_equality(bmap);
 		if (j < 0)
 			goto error;
-		isl_seq_cpy(bmap->eqj, hull->eqi,
-				1 + isl_basic_set_total_dim(hull));
+		isl_seq_cpy(bmap->eqj, hull->eqi, 1 + total);
 	}
 	isl_vec_free(bmap->sample);
 	bmap->sample = isl_vec_copy(hull->sample);
@@ -1132,8 +950,8 @@
 __isl_give isl_basic_set *isl_basic_set_detect_equalities(
 						__isl_take isl_basic_set *bset)
 {
-	return (isl_basic_set *)
-		isl_basic_map_detect_equalities((isl_basic_map *)bset);
+	return bset_from_bmap(
+		isl_basic_map_detect_equalities(bset_to_bmap(bset)));
 }
 
 __isl_give isl_map *isl_map_detect_equalities(__isl_take isl_map *map)
@@ -1144,16 +962,15 @@
 
 __isl_give isl_set *isl_set_detect_equalities(__isl_take isl_set *set)
 {
-	return (isl_set *)isl_map_detect_equalities((isl_map *)set);
+	return set_from_map(isl_map_detect_equalities(set_to_map(set)));
 }
 
-/* After computing the rational affine hull (by detecting the implicit
- * equalities), we compute the additional equalities satisfied by
- * the integer points (if any) and add the original equalities back in.
+/* Return the superset of "bmap" described by the equalities
+ * satisfied by "bmap" that are already known.
  */
-struct isl_basic_map *isl_basic_map_affine_hull(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_plain_affine_hull(
+	__isl_take isl_basic_map *bmap)
 {
-	bmap = isl_basic_map_detect_equalities(bmap);
 	bmap = isl_basic_map_cow(bmap);
 	if (bmap)
 		isl_basic_map_free_inequality(bmap, bmap->n_ineq);
@@ -1161,10 +978,31 @@
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_affine_hull(struct isl_basic_set *bset)
+/* Return the superset of "bset" described by the equalities
+ * satisfied by "bset" that are already known.
+ */
+__isl_give isl_basic_set *isl_basic_set_plain_affine_hull(
+	__isl_take isl_basic_set *bset)
+{
+	return isl_basic_map_plain_affine_hull(bset);
+}
+
+/* After computing the rational affine hull (by detecting the implicit
+ * equalities), we compute the additional equalities satisfied by
+ * the integer points (if any) and add the original equalities back in.
+ */
+__isl_give isl_basic_map *isl_basic_map_affine_hull(
+	__isl_take isl_basic_map *bmap)
+{
+	bmap = isl_basic_map_detect_equalities(bmap);
+	bmap = isl_basic_map_plain_affine_hull(bmap);
+	return bmap;
+}
+
+__isl_give isl_basic_set *isl_basic_set_affine_hull(
+	__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_affine_hull((struct isl_basic_map *)bset);
+	return bset_from_bmap(isl_basic_map_affine_hull(bset_to_bmap(bset)));
 }
 
 /* Given a rational affine matrix "M", add stride constraints to "bmap"
@@ -1194,8 +1032,7 @@
 	if (isl_int_is_one(M->row00))
 		return bmap;
 
-	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
-					M->n_row - 1, M->n_row - 1, 0);
+	bmap = isl_basic_map_extend(bmap, M->n_row - 1, M->n_row - 1, 0);
 
 	isl_int_init(gcd);
 	for (i = 1; i < M->n_row; ++i) {
@@ -1253,10 +1090,10 @@
 static __isl_give isl_basic_map *isl_basic_map_make_strides_explicit(
 	__isl_take isl_basic_map *bmap)
 {
-	int known;
+	isl_bool known;
 	int n_known;
 	int n, n_col;
-	int total;
+	isl_size v_div;
 	isl_ctx *ctx;
 	isl_mat *A, *B, *M;
 
@@ -1273,17 +1110,19 @@
 	for (n_known = 0; n_known < bmap->n_div; ++n_known)
 		if (isl_int_is_zero(bmap->divn_known0))
 			break;
-	ctx = isl_basic_map_get_ctx(bmap);
-	total = isl_space_dim(bmap->dim, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
 	for (n = 0; n < bmap->n_eq; ++n)
-		if (isl_seq_first_non_zero(bmap->eqn + 1 + total + n_known,
+		if (isl_seq_first_non_zero(bmap->eqn + 1 + v_div + n_known,
 					    bmap->n_div - n_known) == -1)
 			break;
 	if (n == 0)
 		return bmap;
-	B = isl_mat_sub_alloc6(ctx, bmap->eq, 0, n, 0, 1 + total + n_known);
+	ctx = isl_basic_map_get_ctx(bmap);
+	B = isl_mat_sub_alloc6(ctx, bmap->eq, 0, n, 0, 1 + v_div + n_known);
 	n_col = bmap->n_div - n_known;
-	A = isl_mat_sub_alloc6(ctx, bmap->eq, 0, n, 1 + total + n_known, n_col);
+	A = isl_mat_sub_alloc6(ctx, bmap->eq, 0, n, 1 + v_div + n_known, n_col);
 	A = isl_mat_left_hermite(A, 0, NULL, NULL);
 	A = isl_mat_drop_cols(A, n, n_col - n);
 	A = isl_mat_lin_to_aff(A);
@@ -1336,6 +1175,18 @@
 	return isl_map_local_affine_hull(set);
 }
 
+/* Return an empty basic map living in the same space as "map".
+ */
+static __isl_give isl_basic_map *replace_map_by_empty_basic_map(
+	__isl_take isl_map *map)
+{
+	isl_space *space;
+
+	space = isl_map_get_space(map);
+	isl_map_free(map);
+	return isl_basic_map_empty(space);
+}
+
 /* Compute the affine hull of "map".
  *
  * We first compute the affine hull of each basic map separately.
@@ -1366,16 +1217,13 @@
 	map = isl_map_local_affine_hull(map);
 	map = isl_map_remove_empty_parts(map);
 	map = isl_map_remove_unknown_divs(map);
-	map = isl_map_align_divs(map);
+	map = isl_map_align_divs_internal(map);
 
 	if (!map)
 		return NULL;
 
-	if (map->n == 0) {
-		hull = isl_basic_map_empty_like_map(map);
-		isl_map_free(map);
-		return hull;
-	}
+	if (map->n == 0)
+		return replace_map_by_empty_basic_map(map);
 
 	model = isl_basic_map_copy(map->p0);
 	set = isl_map_underlying_set(map);
@@ -1398,8 +1246,7 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_set_affine_hull(struct isl_set *set)
+__isl_give isl_basic_set *isl_set_affine_hull(__isl_take isl_set *set)
 {
-	return (struct isl_basic_set *)
-		isl_map_affine_hull((struct isl_map *)set);
+	return bset_from_bmap(isl_map_affine_hull(set_to_map(set)));
 }

_service:tar_scm:isl-0.24.tar.gz/isl_align_params_bin_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_align_params_templ.c Added

@@ -0,0 +1,40 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege
+ */
+
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Align the parameters of the two arguments of type ARG1 and ARG2
+ * (if needed).
+ */
+isl_stat FN(FN(ARG1,align_params),SUFFIX)(__isl_keep ARG1 **obj1,
+	__isl_keep ARG2 **obj2)
+{
+	isl_space *space1, *space2;
+	isl_bool equal_params;
+
+	space1 = FN(ARG1,peek_space)(*obj1);
+	space2 = FN(ARG2,peek_space)(*obj2);
+	equal_params = isl_space_has_equal_params(space1, space2);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
+		return isl_stat_ok;
+	if (FN(ARG1,check_named_params)(*obj1) < 0 ||
+	    FN(ARG2,check_named_params)(*obj2) < 0)
+		goto error;
+	*obj1 = FN(ARG1,align_params)(*obj1, FN(ARG2,get_space)(*obj2));
+	*obj2 = FN(ARG2,align_params)(*obj2, FN(ARG1,get_space)(*obj1));
+	if (!*obj1 || !*obj2)
+		goto error;
+	return isl_stat_ok;
+error:
+	*obj1 = FN(ARG1,free)(*obj1);
+	*obj2 = FN(ARG2,free)(*obj2);
+	return isl_stat_error;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_arg.c -> _service:tar_scm:isl-0.24.tar.gz/isl_arg.c Changed

@@ -13,13 +13,17 @@
 
 #include <isl/arg.h>
 #include <isl/ctx.h>
+#include <isl_config.h>
 
 static struct isl_arg help_arg = {
 ISL_ARG_PHANTOM_BOOL('h', "help", NULL, "print this help, then exit")
+{ isl_arg_end }
 };
 
 static void set_default_choice(struct isl_arg *arg, void *opt)
 {
+	if (arg->offset == ISL_ARG_OFFSET_NONE)
+		return;
 	*(unsigned *)(((char *)opt) + arg->offset) = arg->u.choice.default_value;
 }
 
@@ -30,7 +34,7 @@
 
 static void set_default_bool(struct isl_arg *arg, void *opt)
 {
-	if (arg->offset == (size_t) -1)
+	if (arg->offset == ISL_ARG_OFFSET_NONE)
 		return;
 	*(unsigned *)(((char *)opt) + arg->offset) = arg->u.b.default_value;
 }
@@ -39,7 +43,7 @@
 {
 	void *child;
 
-	if (arg->offset == (size_t) -1)
+	if (arg->offset == ISL_ARG_OFFSET_NONE)
 		child = opt;
 	else {
 		child = calloc(1, arg->u.child.child->options_size);
@@ -134,7 +138,7 @@
 
 static void free_child(struct isl_arg *arg, void *opt)
 {
-	if (arg->offset == (size_t) -1)
+	if (arg->offset == ISL_ARG_OFFSET_NONE)
 		free_args(arg->u.child.child->args, opt);
 	else
 		isl_args_free(arg->u.child.child,
@@ -386,7 +390,6 @@
 			printf("\n%30s", "");
 		else
 			printf("%*s", 30 - pos, "");
-		pos = 0;
 	} else {
 		if (pos + len >= 48)
 			printf("\n%30s", "");
@@ -456,7 +459,6 @@
 			printf("\n%30s", "");
 		else
 			printf("%*s", 30 - pos, "");
-		pos = 0;
 	} else {
 		if (pos + len >= 48)
 			printf("\n%30s", "");
@@ -519,7 +521,7 @@
 	int no = p ? *p == 1 : 0;
 	pos = print_arg_help(decl, prefixes, no);
 	pos = print_help_msg(decl, pos);
-	if (decl->offset != (size_t) -1)
+	if (decl->offset != ISL_ARG_OFFSET_NONE)
 		print_default(decl, no ? "yes" : "no", pos);
 	printf("\n");
 }
@@ -666,7 +668,7 @@
 			printf("\n");
 		if (argi.help_msg)
 			printf(" %s\n", argi.help_msg);
-		if (argi.offset == (size_t) -1)
+		if (argi.offset == ISL_ARG_OFFSET_NONE)
 			child = opt;
 		else
 			child = *(void **)(((char *) opt) + argi.offset);
@@ -811,7 +813,8 @@
 
 	if (!has_argument && (!arg1 || arg10 == '-')) {
 		unsigned u = decl->u.choice.default_selected;
-		*(unsigned *)(((char *)opt) + decl->offset) = u;
+		if (decl->offset != ISL_ARG_OFFSET_NONE)
+			*(unsigned *)(((char *)opt) + decl->offset) = u;
 		if (decl->u.choice.set)
 			decl->u.choice.set(opt, u);
 
@@ -828,7 +831,8 @@
 			continue;
 
 		u = decl->u.choice.choicei.value;
-		*(unsigned *)(((char *)opt) + decl->offset) = u;
+		if (decl->offset != ISL_ARG_OFFSET_NONE)
+			*(unsigned *)(((char *)opt) + decl->offset) = u;
 		if (decl->u.choice.set)
 			decl->u.choice.set(opt, u);
 
@@ -901,14 +905,14 @@
 			char *endptr;
 			int val = strtol(arg1, &endptr, 0);
 			if (*endptr == '\0' && (val == 0 || val == 1)) {
-				if (decl->offset != (size_t) -1)
+				if (decl->offset != ISL_ARG_OFFSET_NONE)
 					*p = val;
 				if (decl->u.b.set)
 					decl->u.b.set(opt, val);
 				return 2;
 			}
 		}
-		if (decl->offset != (size_t) -1)
+		if (decl->offset != ISL_ARG_OFFSET_NONE)
 			*p = 1;
 		if (decl->u.b.set)
 			decl->u.b.set(opt, 1);
@@ -933,7 +937,7 @@
 	name = skip_prefixes(name, prefixes, &next_prefix);
 
 	if (match_long_name(decl, name, name + strlen(name))) {
-		if (decl->offset != (size_t) -1)
+		if (decl->offset != ISL_ARG_OFFSET_NONE)
 			*p = 0;
 		if (decl->u.b.set)
 			decl->u.b.set(opt, 0);
@@ -1113,7 +1117,7 @@
 	void *child;
 	int first, parsed;
 
-	if (decl->offset == (size_t) -1)
+	if (decl->offset == ISL_ARG_OFFSET_NONE)
 		child = opt;
 	else
 		child = *(void **)(((char *)opt) + decl->offset);
@@ -1237,7 +1241,7 @@
 }
 
 /* Unless ISL_ARG_SKIP_HELP is set, check if "arg" is
- * equal to "--help" and if so call print_help_and_exit.
+ * equal to "--help" or "-h" and if so call print_help_and_exit.
  */
 static void check_help(struct isl_args *args, char *arg, char *prog, void *opt,
 	unsigned flags)
@@ -1245,7 +1249,7 @@
 	if (ISL_FL_ISSET(flags, ISL_ARG_SKIP_HELP))
 		return;
 
-	if (strcmp(arg, "--help") == 0)
+	if (strcmp(arg, "--help") == 0 || strcmp(arg, "-h") == 0)
 		print_help_and_exit(args->args, prog, opt);
 }

_service:tar_scm:isl-0.14.tar.xz/isl_ast.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ast.c Changed

@@ -7,15 +7,19 @@
  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  */
 
+#include <string.h>
+
+#include <isl/id.h>
+#include <isl/val.h>
 #include <isl_ast_private.h>
 
-#undef BASE
-#define BASE ast_expr
+#undef EL_BASE
+#define EL_BASE ast_expr
 
 #include <isl_list_templ.c>
 
-#undef BASE
-#define BASE ast_node
+#undef EL_BASE
+#define EL_BASE ast_node
 
 #include <isl_list_templ.c>
 
@@ -101,7 +105,7 @@
 
 /* Set the print_user callback of "options" to "print_user".
  *
- * If this callback is set, then it used to print user nodes in the AST.
+ * If this callback is set, then it is used to print user nodes in the AST.
  * Otherwise, the expression associated to the user node is printed.
  */
 __isl_give isl_ast_print_options *isl_ast_print_options_set_print_user(
@@ -243,7 +247,7 @@
 
 /* Return the integer value represented by "expr".
  */
-__isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr)
+__isl_give isl_val *isl_ast_expr_int_get_val(__isl_keep isl_ast_expr *expr)
 {
 	if (!expr)
 		return NULL;
@@ -253,7 +257,14 @@
 	return isl_val_copy(expr->u.v);
 }
 
-__isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr)
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_val *isl_ast_expr_get_val(__isl_keep isl_ast_expr *expr)
+{
+	return isl_ast_expr_int_get_val(expr);
+}
+
+__isl_give isl_id *isl_ast_expr_id_get_id(__isl_keep isl_ast_expr *expr)
 {
 	if (!expr)
 		return NULL;
@@ -264,27 +275,57 @@
 	return isl_id_copy(expr->u.id);
 }
 
-enum isl_ast_op_type isl_ast_expr_get_op_type(__isl_keep isl_ast_expr *expr)
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_id *isl_ast_expr_get_id(__isl_keep isl_ast_expr *expr)
+{
+	return isl_ast_expr_id_get_id(expr);
+}
+
+/* Return the type of operation represented by "expr".
+ */
+enum isl_ast_expr_op_type isl_ast_expr_op_get_type(
+	__isl_keep isl_ast_expr *expr)
 {
 	if (!expr)
-		return isl_ast_op_error;
+		return isl_ast_expr_op_error;
 	if (expr->type != isl_ast_expr_op)
 		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,
-			"expression not an operation", return isl_ast_op_error);
+			"expression not an operation",
+			return isl_ast_expr_op_error);
 	return expr->u.op.op;
 }
 
-int isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr)
+/* This is an alternative name for the function above.
+ */
+enum isl_ast_expr_op_type isl_ast_expr_get_op_type(
+	__isl_keep isl_ast_expr *expr)
+{
+	return isl_ast_expr_op_get_type(expr);
+}
+
+/* Return the number of arguments of the operation represented by "expr".
+ */
+isl_size isl_ast_expr_op_get_n_arg(__isl_keep isl_ast_expr *expr)
 {
 	if (!expr)
-		return -1;
+		return isl_size_error;
 	if (expr->type != isl_ast_expr_op)
 		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,
-			"expression not an operation", return -1);
+			"expression not an operation", return isl_size_error);
 	return expr->u.op.n_arg;
 }
 
-__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr,
+/* This is an alternative name for the function above.
+ */
+isl_size isl_ast_expr_get_op_n_arg(__isl_keep isl_ast_expr *expr)
+{
+	return isl_ast_expr_op_get_n_arg(expr);
+}
+
+/* Return the argument at position "pos" of the operation represented by "expr".
+ */
+__isl_give isl_ast_expr *isl_ast_expr_op_get_arg(__isl_keep isl_ast_expr *expr,
 	int pos)
 {
 	if (!expr)
@@ -299,6 +340,14 @@
 	return isl_ast_expr_copy(expr->u.op.argspos);
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_ast_expr *isl_ast_expr_get_op_arg(__isl_keep isl_ast_expr *expr,
+	int pos)
+{
+	return isl_ast_expr_op_get_arg(expr, pos);
+}
+
 /* Replace the argument at position "pos" of "expr" by "arg".
  */
 __isl_give isl_ast_expr *isl_ast_expr_set_op_arg(__isl_take isl_ast_expr *expr,
@@ -325,47 +374,49 @@
 
 /* Is "expr1" equal to "expr2"?
  */
-int isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
+isl_bool isl_ast_expr_is_equal(__isl_keep isl_ast_expr *expr1,
 	__isl_keep isl_ast_expr *expr2)
 {
 	int i;
 
 	if (!expr1 || !expr2)
-		return -1;
+		return isl_bool_error;
 
 	if (expr1 == expr2)
-		return 1;
+		return isl_bool_true;
 	if (expr1->type != expr2->type)
-		return 0;
+		return isl_bool_false;
 	switch (expr1->type) {
 	case isl_ast_expr_int:
 		return isl_val_eq(expr1->u.v, expr2->u.v);
 	case isl_ast_expr_id:
-		return expr1->u.id == expr2->u.id;
+		return isl_bool_ok(expr1->u.id == expr2->u.id);
 	case isl_ast_expr_op:
 		if (expr1->u.op.op != expr2->u.op.op)
-			return 0;
+			return isl_bool_false;
 		if (expr1->u.op.n_arg != expr2->u.op.n_arg)
-			return 0;
+			return isl_bool_false;
 		for (i = 0; i < expr1->u.op.n_arg; ++i) {
-			int equal;
+			isl_bool equal;
 			equal = isl_ast_expr_is_equal(expr1->u.op.argsi,
 							expr2->u.op.argsi);
-				return 0;
 			if (equal < 0 || !equal)
 				return equal;
 		}
-		return 1;
+		return isl_bool_true;
 	case isl_ast_expr_error:
-		return -1;
+		return isl_bool_error;
 	}
+
+	isl_die(isl_ast_expr_get_ctx(expr1), isl_error_internal,
+		"unhandled case", return isl_bool_error);
 }
 
 /* Create a new operation expression of operation type "op",
  * with "n_arg" as yet unspecified arguments.
  */
 __isl_give isl_ast_expr *isl_ast_expr_alloc_op(isl_ctx *ctx,
-	enum isl_ast_op_type op, int n_arg)
+	enum isl_ast_expr_op_type op, int n_arg)
 {
 	isl_ast_expr *expr;
 
@@ -468,8 +519,8 @@
 /* Create an expression representing the unary operation "type" applied to
  * "arg".
  */
-__isl_give isl_ast_expr *isl_ast_expr_alloc_unary(enum isl_ast_op_type type,
-	__isl_take isl_ast_expr *arg)
+__isl_give isl_ast_expr *isl_ast_expr_alloc_unary(
+	enum isl_ast_expr_op_type type, __isl_take isl_ast_expr *arg)
 {
 	isl_ctx *ctx;
 	isl_ast_expr *expr = NULL;
@@ -494,7 +545,7 @@
  */
 __isl_give isl_ast_expr *isl_ast_expr_neg(__isl_take isl_ast_expr *arg)
 {
-	return isl_ast_expr_alloc_unary(isl_ast_op_minus, arg);
+	return isl_ast_expr_alloc_unary(isl_ast_expr_op_minus, arg);
 }
 
 /* Create an expression representing the address of "expr".
@@ -505,18 +556,19 @@
 		return NULL;
 
 	if (isl_ast_expr_get_type(expr) != isl_ast_expr_op ||
-	    isl_ast_expr_get_op_type(expr) != isl_ast_op_access)
+	    isl_ast_expr_get_op_type(expr) != isl_ast_expr_op_access)
 		isl_die(isl_ast_expr_get_ctx(expr), isl_error_invalid,
 			"can only take address of access expressions",
 			return isl_ast_expr_free(expr));
 
-	return isl_ast_expr_alloc_unary(isl_ast_op_address_of, expr);
+	return isl_ast_expr_alloc_unary(isl_ast_expr_op_address_of, expr);
 }
 
 /* Create an expression representing the binary operation "type"
  * applied to "expr1" and "expr2".
  */
-__isl_give isl_ast_expr *isl_ast_expr_alloc_binary(enum isl_ast_op_type type,
+__isl_give isl_ast_expr *isl_ast_expr_alloc_binary(
+	enum isl_ast_expr_op_type type,
 	__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2)
 {
 	isl_ctx *ctx;
@@ -545,7 +597,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_add(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_add, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_add, expr1, expr2);
 }
 
 /* Create an expression representing the difference of "expr1" and "expr2".
@@ -553,7 +605,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_sub(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_sub, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_sub, expr1, expr2);
 }
 
 /* Create an expression representing the product of "expr1" and "expr2".
@@ -561,7 +613,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_mul(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_mul, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_mul, expr1, expr2);
 }
 
 /* Create an expression representing the quotient of "expr1" and "expr2".
@@ -569,7 +621,27 @@
 __isl_give isl_ast_expr *isl_ast_expr_div(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_div, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_div, expr1, expr2);
+}
+
+/* Create an expression representing the quotient of the integer
+ * division of "expr1" by "expr2", where "expr1" is known to be
+ * non-negative.
+ */
+__isl_give isl_ast_expr *isl_ast_expr_pdiv_q(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2)
+{
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_pdiv_q, expr1, expr2);
+}
+
+/* Create an expression representing the remainder of the integer
+ * division of "expr1" by "expr2", where "expr1" is known to be
+ * non-negative.
+ */
+__isl_give isl_ast_expr *isl_ast_expr_pdiv_r(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2)
+{
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_pdiv_r, expr1, expr2);
 }
 
 /* Create an expression representing the conjunction of "expr1" and "expr2".
@@ -577,7 +649,16 @@
 __isl_give isl_ast_expr *isl_ast_expr_and(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_and, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_and, expr1, expr2);
+}
+
+/* Create an expression representing the conjunction of "expr1" and "expr2",
+ * where "expr2" is evaluated only if "expr1" is evaluated to true.
+ */
+__isl_give isl_ast_expr *isl_ast_expr_and_then(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2)
+{
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_and_then, expr1, expr2);
 }
 
 /* Create an expression representing the disjunction of "expr1" and "expr2".
@@ -585,7 +666,16 @@
 __isl_give isl_ast_expr *isl_ast_expr_or(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_or, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_or, expr1, expr2);
+}
+
+/* Create an expression representing the disjunction of "expr1" and "expr2",
+ * where "expr2" is evaluated only if "expr1" is evaluated to false.
+ */
+__isl_give isl_ast_expr *isl_ast_expr_or_else(__isl_take isl_ast_expr *expr1,
+	__isl_take isl_ast_expr *expr2)
+{
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_or_else, expr1, expr2);
 }
 
 /* Create an expression representing "expr1" less than or equal to "expr2".
@@ -593,7 +683,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_le(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_le, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_le, expr1, expr2);
 }
 
 /* Create an expression representing "expr1" less than "expr2".
@@ -601,7 +691,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_lt(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_lt, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_lt, expr1, expr2);
 }
 
 /* Create an expression representing "expr1" greater than or equal to "expr2".
@@ -609,7 +699,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_ge(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_ge, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_ge, expr1, expr2);
 }
 
 /* Create an expression representing "expr1" greater than "expr2".
@@ -617,7 +707,7 @@
 __isl_give isl_ast_expr *isl_ast_expr_gt(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_gt, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_gt, expr1, expr2);
 }
 
 /* Create an expression representing "expr1" equal to "expr2".
@@ -625,45 +715,67 @@
 __isl_give isl_ast_expr *isl_ast_expr_eq(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
 {
-	return isl_ast_expr_alloc_binary(isl_ast_op_eq, expr1, expr2);
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_eq, expr1, expr2);
 }
 
-/* Create an expression representing an access to "array" with index
- * expressions "indices".
+/* Create an expression of type "type" with as arguments "arg0" followed
+ * by "arguments".
  */
-__isl_give isl_ast_expr *isl_ast_expr_access(__isl_take isl_ast_expr *array,
-	__isl_take isl_ast_expr_list *indices)
+static __isl_give isl_ast_expr *ast_expr_with_arguments(
+	enum isl_ast_expr_op_type type, __isl_take isl_ast_expr *arg0,
+	__isl_take isl_ast_expr_list *arguments)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
-	isl_ast_expr *access = NULL;
+	isl_ast_expr *res = NULL;
 
-	if (!array || !indices)
+	if (!arg0 || !arguments)
 		goto error;
 
-	ctx = isl_ast_expr_get_ctx(array);
-	n = isl_ast_expr_list_n_ast_expr(indices);
-	access = isl_ast_expr_alloc_op(ctx, isl_ast_op_access, 1 + n);
-	if (!access)
+	ctx = isl_ast_expr_get_ctx(arg0);
+	n = isl_ast_expr_list_n_ast_expr(arguments);
+	if (n < 0)
+		goto error;
+	res = isl_ast_expr_alloc_op(ctx, type, 1 + n);
+	if (!res)
 		goto error;
 	for (i = 0; i < n; ++i) {
-		isl_ast_expr *index;
-		index = isl_ast_expr_list_get_ast_expr(indices, i);
-		access->u.op.args1 + i = index;
-		if (!index)
+		isl_ast_expr *arg;
+		arg = isl_ast_expr_list_get_ast_expr(arguments, i);
+		res->u.op.args1 + i = arg;
+		if (!arg)
 			goto error;
 	}
-	access->u.op.args0 = array;
+	res->u.op.args0 = arg0;
 
-	isl_ast_expr_list_free(indices);
-	return access;
+	isl_ast_expr_list_free(arguments);
+	return res;
 error:
-	isl_ast_expr_free(array);
-	isl_ast_expr_list_free(indices);
-	isl_ast_expr_free(access);
+	isl_ast_expr_free(arg0);
+	isl_ast_expr_list_free(arguments);
+	isl_ast_expr_free(res);
 	return NULL;
 }
 
+/* Create an expression representing an access to "array" with index
+ * expressions "indices".
+ */
+__isl_give isl_ast_expr *isl_ast_expr_access(__isl_take isl_ast_expr *array,
+	__isl_take isl_ast_expr_list *indices)
+{
+	return ast_expr_with_arguments(isl_ast_expr_op_access, array, indices);
+}
+
+/* Create an expression representing a call to "function" with argument
+ * expressions "arguments".
+ */
+__isl_give isl_ast_expr *isl_ast_expr_call(__isl_take isl_ast_expr *function,
+	__isl_take isl_ast_expr_list *arguments)
+{
+	return ast_expr_with_arguments(isl_ast_expr_op_call, function, arguments);
+}
+
 /* For each subexpression of "expr" of type isl_ast_expr_id,
  * if it appears in "id2expr", then replace it by the corresponding
  * expression.
@@ -672,7 +784,7 @@
 	__isl_take isl_ast_expr *expr, __isl_take isl_id_to_ast_expr *id2expr)
 {
 	int i;
-	isl_id *id;
+	isl_maybe_isl_ast_expr m;
 
 	if (!expr || !id2expr)
 		goto error;
@@ -681,11 +793,13 @@
 	case isl_ast_expr_int:
 		break;
 	case isl_ast_expr_id:
-		if (!isl_id_to_ast_expr_has(id2expr, expr->u.id))
+		m = isl_id_to_ast_expr_try_get(id2expr, expr->u.id);
+		if (m.valid < 0)
+			goto error;
+		if (!m.valid)
 			break;
-		id = isl_id_copy(expr->u.id);
 		isl_ast_expr_free(expr);
-		expr = isl_id_to_ast_expr_get(id2expr, id);
+		expr = m.value;
 		break;
 	case isl_ast_expr_op:
 		for (i = 0; i < expr->u.op.n_arg; ++i) {
@@ -797,6 +911,32 @@
 	return NULL;
 }
 
+/* Create a mark node, marking "node" with "id".
+ */
+__isl_give isl_ast_node *isl_ast_node_alloc_mark(__isl_take isl_id *id,
+	__isl_take isl_ast_node *node)
+{
+	isl_ctx *ctx;
+	isl_ast_node *mark;
+
+	if (!id || !node)
+		goto error;
+
+	ctx = isl_id_get_ctx(id);
+	mark = isl_ast_node_alloc(ctx, isl_ast_node_mark);
+	if (!mark)
+		goto error;
+
+	mark->u.m.mark = id;
+	mark->u.m.node = node;
+
+	return mark;
+error:
+	isl_id_free(id);
+	isl_ast_node_free(node);
+	return NULL;
+}
+
 /* Create a user node evaluating "expr".
  */
 __isl_give isl_ast_node *isl_ast_node_alloc_user(__isl_take isl_ast_expr *expr)
@@ -851,15 +991,22 @@
 __isl_give isl_ast_node *isl_ast_node_from_ast_node_list(
 	__isl_take isl_ast_node_list *list)
 {
+	isl_size n;
 	isl_ast_node *node;
 
-	if (isl_ast_node_list_n_ast_node(list) != 1)
+	n = isl_ast_node_list_n_ast_node(list);
+	if (n < 0)
+		goto error;
+	if (n != 1)
 		return isl_ast_node_alloc_block(list);
 
 	node = isl_ast_node_list_get_ast_node(list, 0);
 	isl_ast_node_list_free(list);
 
 	return node;
+error:
+	isl_ast_node_list_free(list);
+	return NULL;
 }
 
 __isl_give isl_ast_node *isl_ast_node_copy(__isl_keep isl_ast_node *node)
@@ -906,6 +1053,12 @@
 		if (!dup->u.b.children)
 			return isl_ast_node_free(dup);
 		break;
+	case isl_ast_node_mark:
+		dup->u.m.mark = isl_id_copy(node->u.m.mark);
+		dup->u.m.node = isl_ast_node_copy(node->u.m.node);
+		if (!dup->u.m.mark || !dup->u.m.node)
+			return isl_ast_node_free(dup);
+		break;
 	case isl_ast_node_user:
 		dup->u.e.expr = isl_ast_expr_copy(node->u.e.expr);
 		if (!dup->u.e.expr)
@@ -953,6 +1106,10 @@
 	case isl_ast_node_block:
 		isl_ast_node_list_free(node->u.b.children);
 		break;
+	case isl_ast_node_mark:
+		isl_id_free(node->u.m.mark);
+		isl_ast_node_free(node->u.m.node);
+		break;
 	case isl_ast_node_user:
 		isl_ast_expr_free(node->u.e.expr);
 		break;
@@ -1012,14 +1169,14 @@
 	return node;
 }
 
-int isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node)
+isl_bool isl_ast_node_for_is_degenerate(__isl_keep isl_ast_node *node)
 {
 	if (!node)
-		return -1;
+		return isl_bool_error;
 	if (node->type != isl_ast_node_for)
 		isl_die(isl_ast_node_get_ctx(node), isl_error_invalid,
-			"not a for node", return -1);
-	return node->u.f.degenerate;
+			"not a for node", return isl_bool_error);
+	return isl_bool_ok(node->u.f.degenerate);
 }
 
 __isl_give isl_ast_expr *isl_ast_node_for_get_iterator(
@@ -1062,7 +1219,7 @@
 	if (!node->u.f.degenerate)
 		return isl_ast_expr_copy(node->u.f.cond);
 
-	return isl_ast_expr_alloc_binary(isl_ast_op_le,
+	return isl_ast_expr_alloc_binary(isl_ast_expr_op_le,
 				isl_ast_expr_copy(node->u.f.iterator),
 				isl_ast_expr_copy(node->u.f.init));
 }
@@ -1107,7 +1264,9 @@
 	return NULL;
 }
 
-__isl_give isl_ast_node *isl_ast_node_if_get_then(
+/* Return the then-node of the given if-node.
+ */
+__isl_give isl_ast_node *isl_ast_node_if_get_then_node(
 	__isl_keep isl_ast_node *node)
 {
 	if (!node)
@@ -1118,18 +1277,37 @@
 	return isl_ast_node_copy(node->u.i.then);
 }
 
-int isl_ast_node_if_has_else(
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_ast_node *isl_ast_node_if_get_then(
 	__isl_keep isl_ast_node *node)
 {
+	return isl_ast_node_if_get_then_node(node);
+}
+
+/* Does the given if-node have an else-node?
+ */
+isl_bool isl_ast_node_if_has_else_node(__isl_keep isl_ast_node *node)
+{
 	if (!node)
-		return -1;
+		return isl_bool_error;
 	if (node->type != isl_ast_node_if)
 		isl_die(isl_ast_node_get_ctx(node), isl_error_invalid,
-			"not an if node", return -1);
-	return node->u.i.else_node != NULL;
+			"not an if node", return isl_bool_error);
+	return isl_bool_ok(node->u.i.else_node != NULL);
 }
 
-__isl_give isl_ast_node *isl_ast_node_if_get_else(
+/* This is an alternative name for the function above.
+ */
+isl_bool isl_ast_node_if_has_else(__isl_keep isl_ast_node *node)
+{
+	return isl_ast_node_if_has_else_node(node);
+}
+
+/* Return the else-node of the given if-node,
+ * assuming there is one.
+ */
+__isl_give isl_ast_node *isl_ast_node_if_get_else_node(
 	__isl_keep isl_ast_node *node)
 {
 	if (!node)
@@ -1140,6 +1318,14 @@
 	return isl_ast_node_copy(node->u.i.else_node);
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_ast_node *isl_ast_node_if_get_else(
+	__isl_keep isl_ast_node *node)
+{
+	return isl_ast_node_if_get_else_node(node);
+}
+
 __isl_give isl_ast_expr *isl_ast_node_if_get_cond(
 	__isl_keep isl_ast_node *node)
 {
@@ -1174,6 +1360,33 @@
 	return isl_ast_expr_copy(node->u.e.expr);
 }
 
+/* Return the mark identifier of the mark node "node".
+ */
+__isl_give isl_id *isl_ast_node_mark_get_id(__isl_keep isl_ast_node *node)
+{
+	if (!node)
+		return NULL;
+	if (node->type != isl_ast_node_mark)
+		isl_die(isl_ast_node_get_ctx(node), isl_error_invalid,
+			"not a mark node", return NULL);
+
+	return isl_id_copy(node->u.m.mark);
+}
+
+/* Return the node marked by mark node "node".
+ */
+__isl_give isl_ast_node *isl_ast_node_mark_get_node(
+	__isl_keep isl_ast_node *node)
+{
+	if (!node)
+		return NULL;
+	if (node->type != isl_ast_node_mark)
+		isl_die(isl_ast_node_get_ctx(node), isl_error_invalid,
+			"not a mark node", return NULL);
+
+	return isl_ast_node_copy(node->u.m.node);
+}
+
 __isl_give isl_id *isl_ast_node_get_annotation(__isl_keep isl_ast_node *node)
 {
 	return node ? isl_id_copy(node->annotation) : NULL;
@@ -1197,29 +1410,109 @@
 	return isl_ast_node_free(node);
 }
 
+/* Traverse the elements of "list" and all their descendants
+ * in depth first preorder.
+ *
+ * Return isl_stat_ok on success and isl_stat_error on failure.
+ */
+static isl_stat nodelist_foreach(__isl_keep isl_ast_node_list *list,
+	isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user), void *user)
+{
+	int i;
+
+	if (!list)
+		return isl_stat_error;
+
+	for (i = 0; i < list->n; ++i) {
+		isl_stat ok;
+		isl_ast_node *node = list->pi;
+
+		ok = isl_ast_node_foreach_descendant_top_down(node, fn, user);
+		if (ok < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Traverse the descendants of "node" (including the node itself)
+ * in depth first preorder.
+ *
+ * If "fn" returns isl_bool_error on any of the nodes, then the traversal
+ * is aborted.
+ * If "fn" returns isl_bool_false on any of the nodes, then the subtree rooted
+ * at that node is skipped.
+ *
+ * Return isl_stat_ok on success and isl_stat_error on failure.
+ */
+isl_stat isl_ast_node_foreach_descendant_top_down(
+	__isl_keep isl_ast_node *node,
+	isl_bool (*fn)(__isl_keep isl_ast_node *node, void *user), void *user)
+{
+	isl_bool more;
+	isl_stat ok;
+
+	if (!node)
+		return isl_stat_error;
+
+	more = fn(node, user);
+	if (more < 0)
+		return isl_stat_error;
+	if (!more)
+		return isl_stat_ok;
+
+	switch (node->type) {
+	case isl_ast_node_for:
+		node = node->u.f.body;
+		return isl_ast_node_foreach_descendant_top_down(node, fn, user);
+	case isl_ast_node_if:
+		ok = isl_ast_node_foreach_descendant_top_down(node->u.i.then,
+								fn, user);
+		if (ok < 0)
+			return isl_stat_error;
+		if (!node->u.i.else_node)
+			return isl_stat_ok;
+		node = node->u.i.else_node;
+		return isl_ast_node_foreach_descendant_top_down(node, fn, user);
+	case isl_ast_node_block:
+		return nodelist_foreach(node->u.b.children, fn, user);
+	case isl_ast_node_mark:
+		node = node->u.m.node;
+		return isl_ast_node_foreach_descendant_top_down(node, fn, user);
+	case isl_ast_node_user:
+		break;
+	case isl_ast_node_error:
+		return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
 /* Textual C representation of the various operators.
  */
-static char *op_str = {
-	isl_ast_op_and = "&&",
-	isl_ast_op_and_then = "&&",
-	isl_ast_op_or = "||",
-	isl_ast_op_or_else = "||",
-	isl_ast_op_max = "max",
-	isl_ast_op_min = "min",
-	isl_ast_op_minus = "-",
-	isl_ast_op_add = "+",
-	isl_ast_op_sub = "-",
-	isl_ast_op_mul = "*",
-	isl_ast_op_pdiv_q = "/",
-	isl_ast_op_pdiv_r = "%",
-	isl_ast_op_div = "/",
-	isl_ast_op_eq = "==",
-	isl_ast_op_le = "<=",
-	isl_ast_op_ge = ">=",
-	isl_ast_op_lt = "<",
-	isl_ast_op_gt = ">",
-	isl_ast_op_member = ".",
-	isl_ast_op_address_of = "&"
+static char *op_str_c = {
+	isl_ast_expr_op_and = "&&",
+	isl_ast_expr_op_and_then = "&&",
+	isl_ast_expr_op_or = "||",
+	isl_ast_expr_op_or_else = "||",
+	isl_ast_expr_op_max = "max",
+	isl_ast_expr_op_min = "min",
+	isl_ast_expr_op_minus = "-",
+	isl_ast_expr_op_add = "+",
+	isl_ast_expr_op_sub = "-",
+	isl_ast_expr_op_mul = "*",
+	isl_ast_expr_op_fdiv_q = "floord",
+	isl_ast_expr_op_pdiv_q = "/",
+	isl_ast_expr_op_pdiv_r = "%",
+	isl_ast_expr_op_zdiv_r = "%",
+	isl_ast_expr_op_div = "/",
+	isl_ast_expr_op_eq = "==",
+	isl_ast_expr_op_le = "<=",
+	isl_ast_expr_op_ge = ">=",
+	isl_ast_expr_op_lt = "<",
+	isl_ast_expr_op_gt = ">",
+	isl_ast_expr_op_member = ".",
+	isl_ast_expr_op_address_of = "&"
 };
 
 /* Precedence in C of the various operators.
@@ -1227,83 +1520,90 @@
  * Lowest value means highest precedence.
  */
 static int op_prec = {
-	isl_ast_op_and = 13,
-	isl_ast_op_and_then = 13,
-	isl_ast_op_or = 14,
-	isl_ast_op_or_else = 14,
-	isl_ast_op_max = 2,
-	isl_ast_op_min = 2,
-	isl_ast_op_minus = 3,
-	isl_ast_op_add = 6,
-	isl_ast_op_sub = 6,
-	isl_ast_op_mul = 5,
-	isl_ast_op_div = 5,
-	isl_ast_op_fdiv_q = 2,
-	isl_ast_op_pdiv_q = 5,
-	isl_ast_op_pdiv_r = 5,
-	isl_ast_op_cond = 15,
-	isl_ast_op_select = 15,
-	isl_ast_op_eq = 9,
-	isl_ast_op_le = 8,
-	isl_ast_op_ge = 8,
-	isl_ast_op_lt = 8,
-	isl_ast_op_gt = 8,
-	isl_ast_op_call = 2,
-	isl_ast_op_access = 2,
-	isl_ast_op_member = 2,
-	isl_ast_op_address_of = 3
+	isl_ast_expr_op_and = 13,
+	isl_ast_expr_op_and_then = 13,
+	isl_ast_expr_op_or = 14,
+	isl_ast_expr_op_or_else = 14,
+	isl_ast_expr_op_max = 2,
+	isl_ast_expr_op_min = 2,
+	isl_ast_expr_op_minus = 3,
+	isl_ast_expr_op_add = 6,
+	isl_ast_expr_op_sub = 6,
+	isl_ast_expr_op_mul = 5,
+	isl_ast_expr_op_div = 5,
+	isl_ast_expr_op_fdiv_q = 2,
+	isl_ast_expr_op_pdiv_q = 5,
+	isl_ast_expr_op_pdiv_r = 5,
+	isl_ast_expr_op_zdiv_r = 5,
+	isl_ast_expr_op_cond = 15,
+	isl_ast_expr_op_select = 15,
+	isl_ast_expr_op_eq = 9,
+	isl_ast_expr_op_le = 8,
+	isl_ast_expr_op_ge = 8,
+	isl_ast_expr_op_lt = 8,
+	isl_ast_expr_op_gt = 8,
+	isl_ast_expr_op_call = 2,
+	isl_ast_expr_op_access = 2,
+	isl_ast_expr_op_member = 2,
+	isl_ast_expr_op_address_of = 3
 };
 
 /* Is the operator left-to-right associative?
  */
 static int op_left = {
-	isl_ast_op_and = 1,
-	isl_ast_op_and_then = 1,
-	isl_ast_op_or = 1,
-	isl_ast_op_or_else = 1,
-	isl_ast_op_max = 1,
-	isl_ast_op_min = 1,
-	isl_ast_op_minus = 0,
-	isl_ast_op_add = 1,
-	isl_ast_op_sub = 1,
-	isl_ast_op_mul = 1,
-	isl_ast_op_div = 1,
-	isl_ast_op_fdiv_q = 1,
-	isl_ast_op_pdiv_q = 1,
-	isl_ast_op_pdiv_r = 1,
-	isl_ast_op_cond = 0,
-	isl_ast_op_select = 0,
-	isl_ast_op_eq = 1,
-	isl_ast_op_le = 1,
-	isl_ast_op_ge = 1,
-	isl_ast_op_lt = 1,
-	isl_ast_op_gt = 1,
-	isl_ast_op_call = 1,
-	isl_ast_op_access = 1,
-	isl_ast_op_member = 1,
-	isl_ast_op_address_of = 0
+	isl_ast_expr_op_and = 1,
+	isl_ast_expr_op_and_then = 1,
+	isl_ast_expr_op_or = 1,
+	isl_ast_expr_op_or_else = 1,
+	isl_ast_expr_op_max = 1,
+	isl_ast_expr_op_min = 1,
+	isl_ast_expr_op_minus = 0,
+	isl_ast_expr_op_add = 1,
+	isl_ast_expr_op_sub = 1,
+	isl_ast_expr_op_mul = 1,
+	isl_ast_expr_op_div = 1,
+	isl_ast_expr_op_fdiv_q = 1,
+	isl_ast_expr_op_pdiv_q = 1,
+	isl_ast_expr_op_pdiv_r = 1,
+	isl_ast_expr_op_zdiv_r = 1,
+	isl_ast_expr_op_cond = 0,
+	isl_ast_expr_op_select = 0,
+	isl_ast_expr_op_eq = 1,
+	isl_ast_expr_op_le = 1,
+	isl_ast_expr_op_ge = 1,
+	isl_ast_expr_op_lt = 1,
+	isl_ast_expr_op_gt = 1,
+	isl_ast_expr_op_call = 1,
+	isl_ast_expr_op_access = 1,
+	isl_ast_expr_op_member = 1,
+	isl_ast_expr_op_address_of = 0
 };
 
-static int is_and(enum isl_ast_op_type op)
+static int is_and(enum isl_ast_expr_op_type op)
 {
-	return op == isl_ast_op_and || op == isl_ast_op_and_then;
+	return op == isl_ast_expr_op_and || op == isl_ast_expr_op_and_then;
 }
 
-static int is_or(enum isl_ast_op_type op)
+static int is_or(enum isl_ast_expr_op_type op)
 {
-	return op == isl_ast_op_or || op == isl_ast_op_or_else;
+	return op == isl_ast_expr_op_or || op == isl_ast_expr_op_or_else;
 }
 
-static int is_add_sub(enum isl_ast_op_type op)
+static int is_add_sub(enum isl_ast_expr_op_type op)
 {
-	return op == isl_ast_op_add || op == isl_ast_op_sub;
+	return op == isl_ast_expr_op_add || op == isl_ast_expr_op_sub;
 }
 
-static int is_div_mod(enum isl_ast_op_type op)
+static int is_div_mod(enum isl_ast_expr_op_type op)
 {
-	return op == isl_ast_op_div || op == isl_ast_op_pdiv_r;
+	return op == isl_ast_expr_op_div ||
+	       op == isl_ast_expr_op_pdiv_r ||
+	       op == isl_ast_expr_op_zdiv_r;
 }
 
+static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p,
+	__isl_keep isl_ast_expr *expr);
+
 /* Do we need/want parentheses around "expr" as a subexpression of
  * an "op" operation?  If "left" is set, then "expr" is the left-most
  * operand.
@@ -1322,7 +1622,7 @@
  * Computations such as "a / b * c" and "a % b + c" can be somewhat
  * difficult to read, so we add parentheses for those as well.
  */
-static int sub_expr_need_parens(enum isl_ast_op_type op,
+static int sub_expr_need_parens(enum isl_ast_expr_op_type op,
 	__isl_keep isl_ast_expr *expr, int left)
 {
 	if (expr->type != isl_ast_expr_op)
@@ -1335,7 +1635,7 @@
 
 	if (is_or(op) && is_and(expr->u.op.op))
 		return 1;
-	if (op == isl_ast_op_mul && expr->u.op.op != isl_ast_op_mul &&
+	if (op == isl_ast_expr_op_mul && expr->u.op.op != isl_ast_expr_op_mul &&
 	    op_precexpr->u.op.op == op_precop)
 		return 1;
 	if (is_add_sub(op) && is_div_mod(expr->u.op.op))
@@ -1344,11 +1644,11 @@
 	return 0;
 }
 
-/* Print "expr" as a subexpression of an "op" operation.
+/* Print "expr" as a subexpression of an "op" operation in C format.
  * If "left" is set, then "expr" is the left-most operand.
  */
-static __isl_give isl_printer *print_sub_expr(__isl_take isl_printer *p,
-	enum isl_ast_op_type op, __isl_keep isl_ast_expr *expr, int left)
+static __isl_give isl_printer *print_sub_expr_c(__isl_take isl_printer *p,
+	enum isl_ast_expr_op_type op, __isl_keep isl_ast_expr *expr, int left)
 {
 	int need_parens;
 
@@ -1356,79 +1656,236 @@
 
 	if (need_parens)
 		p = isl_printer_print_str(p, "(");
-	p = isl_printer_print_ast_expr(p, expr);
+	p = print_ast_expr_c(p, expr);
 	if (need_parens)
 		p = isl_printer_print_str(p, ")");
 	return p;
 }
 
-/* Print a min or max reduction "expr".
+#define isl_ast_expr_op_last	isl_ast_expr_op_address_of
+
+/* Data structure that holds the user-specified textual
+ * representations for the operators in C format.
+ * The entries are either NULL or copies of strings.
+ * A NULL entry means that the default name should be used.
+ */
+struct isl_ast_expr_op_names {
+	char *op_strisl_ast_expr_op_last + 1;
+};
+
+/* Create an empty struct isl_ast_expr_op_names.
+ */
+static void *create_names(isl_ctx *ctx)
+{
+	return isl_calloc_type(ctx, struct isl_ast_expr_op_names);
+}
+
+/* Free a struct isl_ast_expr_op_names along with all memory
+ * owned by the struct.
+ */
+static void free_names(void *user)
+{
+	int i;
+	struct isl_ast_expr_op_names *names = user;
+
+	if (!user)
+		return;
+
+	for (i = 0; i <= isl_ast_expr_op_last; ++i)
+		free(names->op_stri);
+	free(user);
+}
+
+/* Create an identifier that is used to store
+ * an isl_ast_expr_op_names note.
+ */
+static __isl_give isl_id *names_id(isl_ctx *ctx)
+{
+	return isl_id_alloc(ctx, "isl_ast_expr_op_type_names", NULL);
+}
+
+/* Ensure that "p" has a note identified by "id".
+ * If there is no such note yet, then it is created by "note_create" and
+ * scheduled do be freed by "note_free".
+ */
+static __isl_give isl_printer *alloc_note(__isl_take isl_printer *p,
+	__isl_keep isl_id *id, void *(*note_create)(isl_ctx *),
+	void (*note_free)(void *))
+{
+	isl_ctx *ctx;
+	isl_id *note_id;
+	isl_bool has_note;
+	void *note;
+
+	has_note = isl_printer_has_note(p, id);
+	if (has_note < 0)
+		return isl_printer_free(p);
+	if (has_note)
+		return p;
+
+	ctx = isl_printer_get_ctx(p);
+	note = note_create(ctx);
+	if (!note)
+		return isl_printer_free(p);
+	note_id = isl_id_alloc(ctx, NULL, note);
+	if (!note_id)
+		note_free(note);
+	else
+		note_id = isl_id_set_free_user(note_id, note_free);
+
+	p = isl_printer_set_note(p, isl_id_copy(id), note_id);
+
+	return p;
+}
+
+/* Ensure that "p" has an isl_ast_expr_op_names note identified by "id".
+ */
+static __isl_give isl_printer *alloc_names(__isl_take isl_printer *p,
+	__isl_keep isl_id *id)
+{
+	return alloc_note(p, id, &create_names, &free_names);
+}
+
+/* Retrieve the note identified by "id" from "p".
+ * The note is assumed to exist.
+ */
+static void *get_note(__isl_keep isl_printer *p, __isl_keep isl_id *id)
+{
+	void *note;
+
+	id = isl_printer_get_note(p, isl_id_copy(id));
+	note = isl_id_get_user(id);
+	isl_id_free(id);
+
+	return note;
+}
+
+/* Use "name" to print operations of type "type" to "p".
+ *
+ * Store the name in an isl_ast_expr_op_names note attached to "p", such that
+ * it can be retrieved by get_op_str.
+ */
+__isl_give isl_printer *isl_ast_expr_op_type_set_print_name(
+	__isl_take isl_printer *p, enum isl_ast_expr_op_type type,
+	__isl_keep const char *name)
+{
+	isl_id *id;
+	struct isl_ast_expr_op_names *names;
+
+	if (!p)
+		return NULL;
+	if (type > isl_ast_expr_op_last)
+		isl_die(isl_printer_get_ctx(p), isl_error_invalid,
+			"invalid type", return isl_printer_free(p));
+
+	id = names_id(isl_printer_get_ctx(p));
+	p = alloc_names(p, id);
+	names = get_note(p, id);
+	isl_id_free(id);
+	if (!names)
+		return isl_printer_free(p);
+	free(names->op_strtype);
+	names->op_strtype = strdup(name);
+
+	return p;
+}
+
+/* This is an alternative name for the function above.
  */
-static __isl_give isl_printer *print_min_max(__isl_take isl_printer *p,
+__isl_give isl_printer *isl_ast_op_type_set_print_name(
+	__isl_take isl_printer *p, enum isl_ast_expr_op_type type,
+	__isl_keep const char *name)
+{
+	return isl_ast_expr_op_type_set_print_name(p, type, name);
+}
+
+/* Return the textual representation of "type" in C format.
+ *
+ * If there is a user-specified name in an isl_ast_expr_op_names note
+ * associated to "p", then return that.
+ * Otherwise, return the default name in op_str_c.
+ */
+static const char *get_op_str_c(__isl_keep isl_printer *p,
+	enum isl_ast_expr_op_type type)
+{
+	isl_id *id;
+	isl_bool has_names;
+	struct isl_ast_expr_op_names *names = NULL;
+
+	id = names_id(isl_printer_get_ctx(p));
+	has_names = isl_printer_has_note(p, id);
+	if (has_names >= 0 && has_names)
+		names = get_note(p, id);
+	isl_id_free(id);
+	if (names && names->op_strtype)
+		return names->op_strtype;
+	return op_str_ctype;
+}
+
+/* Print a min or max reduction "expr" in C format.
+ */
+static __isl_give isl_printer *print_min_max_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_expr *expr)
 {
 	int i = 0;
 
 	for (i = 1; i < expr->u.op.n_arg; ++i) {
-		p = isl_printer_print_str(p, op_strexpr->u.op.op);
+		p = isl_printer_print_str(p, get_op_str_c(p, expr->u.op.op));
 		p = isl_printer_print_str(p, "(");
 	}
 	p = isl_printer_print_ast_expr(p, expr->u.op.args0);
 	for (i = 1; i < expr->u.op.n_arg; ++i) {
 		p = isl_printer_print_str(p, ", ");
-		p = isl_printer_print_ast_expr(p, expr->u.op.argsi);
+		p = print_ast_expr_c(p, expr->u.op.argsi);
 		p = isl_printer_print_str(p, ")");
 	}
 
 	return p;
 }
 
-/* Print a function call "expr".
+/* Print a function call "expr" in C format.
  *
  * The first argument represents the function to be called.
  */
-static __isl_give isl_printer *print_call(__isl_take isl_printer *p,
+static __isl_give isl_printer *print_call_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_expr *expr)
 {
 	int i = 0;
 
-	p = isl_printer_print_ast_expr(p, expr->u.op.args0);
+	p = print_ast_expr_c(p, expr->u.op.args0);
 	p = isl_printer_print_str(p, "(");
 	for (i = 1; i < expr->u.op.n_arg; ++i) {
 		if (i != 1)
 			p = isl_printer_print_str(p, ", ");
-		p = isl_printer_print_ast_expr(p, expr->u.op.argsi);
+		p = print_ast_expr_c(p, expr->u.op.argsi);
 	}
 	p = isl_printer_print_str(p, ")");
 
 	return p;
 }
 
-/* Print an array access "expr".
+/* Print an array access "expr" in C format.
  *
  * The first argument represents the array being accessed.
  */
-static __isl_give isl_printer *print_access(__isl_take isl_printer *p,
+static __isl_give isl_printer *print_access_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_expr *expr)
 {
 	int i = 0;
 
-	p = isl_printer_print_ast_expr(p, expr->u.op.args0);
+	p = print_ast_expr_c(p, expr->u.op.args0);
 	for (i = 1; i < expr->u.op.n_arg; ++i) {
 		p = isl_printer_print_str(p, "");
-		p = isl_printer_print_ast_expr(p, expr->u.op.argsi);
+		p = print_ast_expr_c(p, expr->u.op.argsi);
 		p = isl_printer_print_str(p, "");
 	}
 
 	return p;
 }
 
-/* Print "expr" to "p".
- *
- * If we are printing in isl format, then we also print an indication
- * of the size of the expression (if it was computed).
+/* Print "expr" to "p" in C format.
  */
-__isl_give isl_printer *isl_printer_print_ast_expr(__isl_take isl_printer *p,
+static __isl_give isl_printer *print_ast_expr_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_expr *expr)
 {
 	if (!p)
@@ -1438,53 +1895,58 @@
 
 	switch (expr->type) {
 	case isl_ast_expr_op:
-		if (expr->u.op.op == isl_ast_op_call) {
-			p = print_call(p, expr);
+		if (expr->u.op.op == isl_ast_expr_op_call) {
+			p = print_call_c(p, expr);
 			break;
 		}
-		if (expr->u.op.op == isl_ast_op_access) {
-			p = print_access(p, expr);
+		if (expr->u.op.op == isl_ast_expr_op_access) {
+			p = print_access_c(p, expr);
 			break;
 		}
 		if (expr->u.op.n_arg == 1) {
-			p = isl_printer_print_str(p, op_strexpr->u.op.op);
-			p = print_sub_expr(p, expr->u.op.op,
+			p = isl_printer_print_str(p,
+						get_op_str_c(p, expr->u.op.op));
+			p = print_sub_expr_c(p, expr->u.op.op,
 						expr->u.op.args0, 0);
 			break;
 		}
-		if (expr->u.op.op == isl_ast_op_fdiv_q) {
-			p = isl_printer_print_str(p, "floord(");
-			p = isl_printer_print_ast_expr(p, expr->u.op.args0);
+		if (expr->u.op.op == isl_ast_expr_op_fdiv_q) {
+			const char *name;
+
+			name = get_op_str_c(p, isl_ast_expr_op_fdiv_q);
+			p = isl_printer_print_str(p, name);
+			p = isl_printer_print_str(p, "(");
+			p = print_ast_expr_c(p, expr->u.op.args0);
 			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_ast_expr(p, expr->u.op.args1);
+			p = print_ast_expr_c(p, expr->u.op.args1);
 			p = isl_printer_print_str(p, ")");
 			break;
 		}
-		if (expr->u.op.op == isl_ast_op_max ||
-		    expr->u.op.op == isl_ast_op_min) {
-			p = print_min_max(p, expr);
+		if (expr->u.op.op == isl_ast_expr_op_max ||
+		    expr->u.op.op == isl_ast_expr_op_min) {
+			p = print_min_max_c(p, expr);
 			break;
 		}
-		if (expr->u.op.op == isl_ast_op_cond ||
-		    expr->u.op.op == isl_ast_op_select) {
-			p = isl_printer_print_ast_expr(p, expr->u.op.args0);
+		if (expr->u.op.op == isl_ast_expr_op_cond ||
+		    expr->u.op.op == isl_ast_expr_op_select) {
+			p = print_ast_expr_c(p, expr->u.op.args0);
 			p = isl_printer_print_str(p, " ? ");
-			p = isl_printer_print_ast_expr(p, expr->u.op.args1);
+			p = print_ast_expr_c(p, expr->u.op.args1);
 			p = isl_printer_print_str(p, " : ");
-			p = isl_printer_print_ast_expr(p, expr->u.op.args2);
+			p = print_ast_expr_c(p, expr->u.op.args2);
 			break;
 		}
 		if (expr->u.op.n_arg != 2)
 			isl_die(isl_printer_get_ctx(p), isl_error_internal,
 				"operation should have two arguments",
-				goto error);
-		p = print_sub_expr(p, expr->u.op.op, expr->u.op.args0, 1);
-		if (expr->u.op.op != isl_ast_op_member)
+				return isl_printer_free(p));
+		p = print_sub_expr_c(p, expr->u.op.op, expr->u.op.args0, 1);
+		if (expr->u.op.op != isl_ast_expr_op_member)
 			p = isl_printer_print_str(p, " ");
-		p = isl_printer_print_str(p, op_strexpr->u.op.op);
-		if (expr->u.op.op != isl_ast_op_member)
+		p = isl_printer_print_str(p, get_op_str_c(p, expr->u.op.op));
+		if (expr->u.op.op != isl_ast_expr_op_member)
 			p = isl_printer_print_str(p, " ");
-		p = print_sub_expr(p, expr->u.op.op, expr->u.op.args1, 0);
+		p = print_sub_expr_c(p, expr->u.op.op, expr->u.op.args1, 0);
 		break;
 	case isl_ast_expr_id:
 		p = isl_printer_print_str(p, isl_id_get_name(expr->u.id));
@@ -1497,61 +1959,269 @@
 	}
 
 	return p;
-error:
-	isl_printer_free(p);
-	return NULL;
+}
+
+/* Textual representation of the isl_ast_expr_op_type elements
+ * for use in a YAML representation of an isl_ast_expr.
+ */
+static char *op_str = {
+	isl_ast_expr_op_and = "and",
+	isl_ast_expr_op_and_then = "and_then",
+	isl_ast_expr_op_or = "or",
+	isl_ast_expr_op_or_else = "or_else",
+	isl_ast_expr_op_max = "max",
+	isl_ast_expr_op_min = "min",
+	isl_ast_expr_op_minus = "minus",
+	isl_ast_expr_op_add = "add",
+	isl_ast_expr_op_sub = "sub",
+	isl_ast_expr_op_mul = "mul",
+	isl_ast_expr_op_div = "div",
+	isl_ast_expr_op_fdiv_q = "fdiv_q",
+	isl_ast_expr_op_pdiv_q = "pdiv_q",
+	isl_ast_expr_op_pdiv_r = "pdiv_r",
+	isl_ast_expr_op_zdiv_r = "zdiv_r",
+	isl_ast_expr_op_cond = "cond",
+	isl_ast_expr_op_select = "select",
+	isl_ast_expr_op_eq = "eq",
+	isl_ast_expr_op_le = "le",
+	isl_ast_expr_op_lt = "lt",
+	isl_ast_expr_op_ge = "ge",
+	isl_ast_expr_op_gt = "gt",
+	isl_ast_expr_op_call = "call",
+	isl_ast_expr_op_access = "access",
+	isl_ast_expr_op_member = "member",
+	isl_ast_expr_op_address_of = "address_of"
+};
+
+static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p,
+	__isl_keep isl_ast_expr *expr);
+
+/* Print the arguments of "expr" to "p" in isl format.
+ *
+ * If there are no arguments, then nothing needs to be printed.
+ * Otherwise add an "args" key to the current mapping with as value
+ * the list of arguments of "expr".
+ */
+static __isl_give isl_printer *print_arguments(__isl_take isl_printer *p,
+	__isl_keep isl_ast_expr *expr)
+{
+	int i;
+	isl_size n;
+
+	n = isl_ast_expr_get_op_n_arg(expr);
+	if (n < 0)
+		return isl_printer_free(p);
+	if (n == 0)
+		return p;
+
+	p = isl_printer_print_str(p, "args");
+	p = isl_printer_yaml_next(p);
+	p = isl_printer_yaml_start_sequence(p);
+	for (i = 0; i < n; ++i) {
+		isl_ast_expr *arg;
+
+		arg = isl_ast_expr_get_op_arg(expr, i);
+		p = print_ast_expr_isl(p, arg);
+		isl_ast_expr_free(arg);
+		p = isl_printer_yaml_next(p);
+	}
+	p = isl_printer_yaml_end_sequence(p);
+
+	return p;
+}
+
+/* Print "expr" to "p" in isl format.
+ *
+ * In particular, print the isl_ast_expr as a YAML document.
+ */
+static __isl_give isl_printer *print_ast_expr_isl(__isl_take isl_printer *p,
+	__isl_keep isl_ast_expr *expr)
+{
+	enum isl_ast_expr_type type;
+	enum isl_ast_expr_op_type op;
+	isl_id *id;
+	isl_val *v;
+
+	if (!expr)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_mapping(p);
+	type = isl_ast_expr_get_type(expr);
+	switch (type) {
+	case isl_ast_expr_error:
+		return isl_printer_free(p);
+	case isl_ast_expr_op:
+		op = isl_ast_expr_get_op_type(expr);
+		if (op == isl_ast_expr_op_error)
+			return isl_printer_free(p);
+		p = isl_printer_print_str(p, "op");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, op_strop);
+		p = isl_printer_yaml_next(p);
+		p = print_arguments(p, expr);
+		break;
+	case isl_ast_expr_id:
+		p = isl_printer_print_str(p, "id");
+		p = isl_printer_yaml_next(p);
+		id = isl_ast_expr_get_id(expr);
+		p = isl_printer_print_id(p, id);
+		isl_id_free(id);
+		break;
+	case isl_ast_expr_int:
+		p = isl_printer_print_str(p, "val");
+		p = isl_printer_yaml_next(p);
+		v = isl_ast_expr_get_val(expr);
+		p = isl_printer_print_val(p, v);
+		isl_val_free(v);
+		break;
+	}
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+/* Print "expr" to "p".
+ *
+ * Only an isl and a C format are supported.
+ */
+__isl_give isl_printer *isl_printer_print_ast_expr(__isl_take isl_printer *p,
+	__isl_keep isl_ast_expr *expr)
+{
+	int format;
+
+	if (!p)
+		return NULL;
+
+	format = isl_printer_get_output_format(p);
+	switch (format) {
+	case ISL_FORMAT_ISL:
+		p = print_ast_expr_isl(p, expr);
+		break;
+	case ISL_FORMAT_C:
+		p = print_ast_expr_c(p, expr);
+		break;
+	default:
+		isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
+			"output format not supported for ast_expr",
+			return isl_printer_free(p));
+	}
+
+	return p;
+}
+
+static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p,
+	__isl_keep isl_ast_node *node);
+
+/* Print a YAML sequence containing the entries in "list" to "p".
+ */
+static __isl_give isl_printer *print_ast_node_list(__isl_take isl_printer *p,
+	__isl_keep isl_ast_node_list *list)
+{
+	int i;
+	isl_size n;
+
+	n = isl_ast_node_list_n_ast_node(list);
+	if (n < 0)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_sequence(p);
+	for (i = 0; i < n; ++i) {
+		isl_ast_node *node;
+
+		node = isl_ast_node_list_get_ast_node(list, i);
+		p = print_ast_node_isl(p, node);
+		isl_ast_node_free(node);
+		p = isl_printer_yaml_next(p);
+	}
+	p = isl_printer_yaml_end_sequence(p);
+
+	return p;
 }
 
 /* Print "node" to "p" in "isl format".
+ *
+ * In particular, print the isl_ast_node as a YAML document.
  */
 static __isl_give isl_printer *print_ast_node_isl(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node)
 {
-	p = isl_printer_print_str(p, "(");
 	switch (node->type) {
 	case isl_ast_node_for:
+		p = isl_printer_yaml_start_mapping(p);
+		p = isl_printer_print_str(p, "iterator");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_ast_expr(p, node->u.f.iterator);
+		p = isl_printer_yaml_next(p);
 		if (node->u.f.degenerate) {
+			p = isl_printer_print_str(p, "value");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_expr(p, node->u.f.init);
+			p = isl_printer_yaml_next(p);
 		} else {
-			p = isl_printer_print_str(p, "init: ");
+			p = isl_printer_print_str(p, "init");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_expr(p, node->u.f.init);
-			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_str(p, "cond: ");
+			p = isl_printer_yaml_next(p);
+			p = isl_printer_print_str(p, "cond");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_expr(p, node->u.f.cond);
-			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_str(p, "inc: ");
+			p = isl_printer_yaml_next(p);
+			p = isl_printer_print_str(p, "inc");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_expr(p, node->u.f.inc);
+			p = isl_printer_yaml_next(p);
 		}
 		if (node->u.f.body) {
-			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_str(p, "body: ");
+			p = isl_printer_print_str(p, "body");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_node(p, node->u.f.body);
+			p = isl_printer_yaml_next(p);
 		}
+		p = isl_printer_yaml_end_mapping(p);
+		break;
+	case isl_ast_node_mark:
+		p = isl_printer_yaml_start_mapping(p);
+		p = isl_printer_print_str(p, "mark");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_id(p, node->u.m.mark);
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, "node");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_ast_node(p, node->u.m.node);
+		p = isl_printer_yaml_end_mapping(p);
 		break;
 	case isl_ast_node_user:
+		p = isl_printer_yaml_start_mapping(p);
+		p = isl_printer_print_str(p, "user");
+		p = isl_printer_yaml_next(p);
 		p = isl_printer_print_ast_expr(p, node->u.e.expr);
+		p = isl_printer_yaml_end_mapping(p);
 		break;
 	case isl_ast_node_if:
-		p = isl_printer_print_str(p, "guard: ");
+		p = isl_printer_yaml_start_mapping(p);
+		p = isl_printer_print_str(p, "guard");
+		p = isl_printer_yaml_next(p);
 		p = isl_printer_print_ast_expr(p, node->u.i.guard);
+		p = isl_printer_yaml_next(p);
 		if (node->u.i.then) {
-			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_str(p, "then: ");
+			p = isl_printer_print_str(p, "then");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_node(p, node->u.i.then);
+			p = isl_printer_yaml_next(p);
 		}
 		if (node->u.i.else_node) {
-			p = isl_printer_print_str(p, ", ");
-			p = isl_printer_print_str(p, "else: ");
+			p = isl_printer_print_str(p, "else");
+			p = isl_printer_yaml_next(p);
 			p = isl_printer_print_ast_node(p, node->u.i.else_node);
 		}
+		p = isl_printer_yaml_end_mapping(p);
 		break;
 	case isl_ast_node_block:
-		p = isl_printer_print_ast_node_list(p, node->u.b.children);
+		p = print_ast_node_list(p, node->u.b.children);
 		break;
-	default:
+	case isl_ast_node_error:
 		break;
 	}
-	p = isl_printer_print_str(p, ")");
 	return p;
 }
 
@@ -1563,6 +2233,10 @@
  * as well.
  * If the node is an if node with an else, then we print a block
  * to avoid spurious dangling else warnings emitted by some compilers.
+ * If the node is a mark, then in principle, we would have to check
+ * the child of the mark node.  However, even if the child would not
+ * require us to print a block, for readability it is probably best
+ * to print a block anyway.
  * If the ast_always_print_block option has been set, then we print a block.
  */
 static int need_block(__isl_keep isl_ast_node *node)
@@ -1575,6 +2249,8 @@
 		return 1;
 	if (node->type == isl_ast_node_if && node->u.i.else_node)
 		return 1;
+	if (node->type == isl_ast_node_mark)
+		return 1;
 
 	ctx = isl_ast_node_get_ctx(node);
 	return isl_options_get_ast_always_print_block(ctx);
@@ -1585,32 +2261,37 @@
 	__isl_keep isl_ast_print_options *options, int in_block, int in_list);
 static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node,
-	__isl_keep isl_ast_print_options *options, int new_line);
+	__isl_keep isl_ast_print_options *options, int new_line,
+	int force_block);
 
 /* Print the body "node" of a for or if node.
  * If "else_node" is set, then it is printed as well.
+ * If "force_block" is set, then print out the body as a block.
  *
  * We first check if we need to print out a block.
  * We always print out a block if there is an else node to make
  * sure that the else node is matched to the correct if node.
+ * For consistency, the corresponding else node is also printed as a block.
  *
  * If the else node is itself an if, then we print it as
  *
- *	} else if (..)
+ *	} else if (..) {
+ *	}
  *
  * Otherwise the else node is printed as
  *
- *	} else
+ *	} else {
  *	  node
+ *	}
  */
 static __isl_give isl_printer *print_body_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node, __isl_keep isl_ast_node *else_node,
-	__isl_keep isl_ast_print_options *options)
+	__isl_keep isl_ast_print_options *options, int force_block)
 {
 	if (!node)
 		return isl_printer_free(p);
 
-	if (!else_node && !need_block(node)) {
+	if (!force_block && !else_node && !need_block(node)) {
 		p = isl_printer_end_line(p);
 		p = isl_printer_indent(p, 2);
 		p = isl_ast_node_print(node, p,
@@ -1629,10 +2310,10 @@
 	if (else_node) {
 		if (else_node->type == isl_ast_node_if) {
 			p = isl_printer_print_str(p, " else ");
-			p = print_if_c(p, else_node, options, 0);
+			p = print_if_c(p, else_node, options, 0, 1);
 		} else {
 			p = isl_printer_print_str(p, " else");
-			p = print_body_c(p, else_node, NULL, options);
+			p = print_body_c(p, else_node, NULL, options, 1);
 		}
 	} else
 		p = isl_printer_end_line(p);
@@ -1710,7 +2391,7 @@
 		p = isl_printer_print_str(p, " += ");
 		p = isl_printer_print_ast_expr(p, node->u.f.inc);
 		p = isl_printer_print_str(p, ")");
-		p = print_body_c(p, node->u.f.body, NULL, options);
+		p = print_body_c(p, node->u.f.body, NULL, options, 0);
 	} else {
 		id = isl_ast_expr_get_id(node->u.f.iterator);
 		name = isl_id_get_name(id);
@@ -1735,17 +2416,20 @@
 
 /* Print the if node "node".
  * If "new_line" is set then the if node should be printed on a new line.
+ * If "force_block" is set, then print out the body as a block.
  */
 static __isl_give isl_printer *print_if_c(__isl_take isl_printer *p,
 	__isl_keep isl_ast_node *node,
-	__isl_keep isl_ast_print_options *options, int new_line)
+	__isl_keep isl_ast_print_options *options, int new_line,
+	int force_block)
 {
 	if (new_line)
 		p = isl_printer_start_line(p);
 	p = isl_printer_print_str(p, "if (");
 	p = isl_printer_print_ast_expr(p, node->u.i.guard);
 	p = isl_printer_print_str(p, ")");
-	p = print_body_c(p, node->u.i.then, node->u.i.else_node, options);
+	p = print_body_c(p, node->u.i.then, node->u.i.else_node, options,
+			force_block);
 
 	return p;
 }
@@ -1772,7 +2456,7 @@
 		p = print_for_c(p, node, options, in_block, in_list);
 		break;
 	case isl_ast_node_if:
-		p = print_if_c(p, node, options, 1);
+		p = print_if_c(p, node, options, 1, 0);
 		break;
 	case isl_ast_node_block:
 		if (!in_block)
@@ -1781,6 +2465,13 @@
 		if (!in_block)
 			p = end_block(p);
 		break;
+	case isl_ast_node_mark:
+		p = isl_printer_start_line(p);
+		p = isl_printer_print_str(p, "// ");
+		p = isl_printer_print_str(p, isl_id_get_name(node->u.m.mark));
+		p = isl_printer_end_line(p);
+		p = print_ast_node_c(p, node->u.m.node, options, 0, in_list);
+		break;
 	case isl_ast_node_user:
 		if (options->print_user)
 			return options->print_user(p,
@@ -1826,7 +2517,7 @@
 	if (node->type != isl_ast_node_if)
 		isl_die(isl_ast_node_get_ctx(node), isl_error_invalid,
 			"not an if node", goto error);
-	p = print_if_c(p, node, options, 1);
+	p = print_if_c(p, node, options, 1, 0);
 	isl_ast_print_options_free(options);
 	return p;
 error:
@@ -1836,13 +2527,28 @@
 }
 
 /* Print "node" to "p".
+ *
+ * "node" is assumed to be either the outermost node in an AST or
+ * a node that is known not to be a block.
+ * If "node" is a block (and is therefore outermost) and
+ * if the ast_print_outermost_block options is not set,
+ * then act as if the printing occurs inside a block, such
+ * that no "extra" block will get printed.
  */
 __isl_give isl_printer *isl_ast_node_print(__isl_keep isl_ast_node *node,
 	__isl_take isl_printer *p, __isl_take isl_ast_print_options *options)
 {
+	int in_block = 0;
+
 	if (!options || !node)
 		goto error;
-	p = print_ast_node_c(p, node, options, 0, 0);
+	if (node->type == isl_ast_node_block) {
+		isl_ctx *ctx;
+
+		ctx = isl_ast_node_get_ctx(node);
+		in_block = !isl_options_get_ast_print_outermost_block(ctx);
+	}
+	p = print_ast_node_c(p, node, options, in_block, 0);
 	isl_ast_print_options_free(options);
 	return p;
 error:
@@ -1897,15 +2603,15 @@
 	return p;
 }
 
-#define ISL_AST_MACRO_FLOORD	(1 << 0)
+#define ISL_AST_MACRO_FDIV_Q	(1 << 0)
 #define ISL_AST_MACRO_MIN	(1 << 1)
 #define ISL_AST_MACRO_MAX	(1 << 2)
-#define ISL_AST_MACRO_ALL	(ISL_AST_MACRO_FLOORD | \
+#define ISL_AST_MACRO_ALL	(ISL_AST_MACRO_FDIV_Q | \
 				 ISL_AST_MACRO_MIN | \
 				 ISL_AST_MACRO_MAX)
 
-/* If "expr" contains an isl_ast_op_min, isl_ast_op_max or isl_ast_op_fdiv_q
- * then set the corresponding bit in "macros".
+/* If "expr" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
+ * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
  */
 static int ast_expr_required_macros(__isl_keep isl_ast_expr *expr, int macros)
 {
@@ -1917,12 +2623,12 @@
 	if (expr->type != isl_ast_expr_op)
 		return macros;
 
-	if (expr->u.op.op == isl_ast_op_min)
+	if (expr->u.op.op == isl_ast_expr_op_min)
 		macros |= ISL_AST_MACRO_MIN;
-	if (expr->u.op.op == isl_ast_op_max)
+	if (expr->u.op.op == isl_ast_expr_op_max)
 		macros |= ISL_AST_MACRO_MAX;
-	if (expr->u.op.op == isl_ast_op_fdiv_q)
-		macros |= ISL_AST_MACRO_FLOORD;
+	if (expr->u.op.op == isl_ast_expr_op_fdiv_q)
+		macros |= ISL_AST_MACRO_FDIV_Q;
 
 	for (i = 0; i < expr->u.op.n_arg; ++i)
 		macros = ast_expr_required_macros(expr->u.op.argsi, macros);
@@ -1933,8 +2639,8 @@
 static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list,
 	int macros);
 
-/* If "node" contains an isl_ast_op_min, isl_ast_op_max or isl_ast_op_fdiv_q
- * then set the corresponding bit in "macros".
+/* If "node" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
+ * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
  */
 static int ast_node_required_macros(__isl_keep isl_ast_node *node, int macros)
 {
@@ -1963,6 +2669,9 @@
 		macros = ast_node_list_required_macros(node->u.b.children,
 							macros);
 		break;
+	case isl_ast_node_mark:
+		macros = ast_node_required_macros(node->u.m.node, macros);
+		break;
 	case isl_ast_node_user:
 		macros = ast_expr_required_macros(node->u.e.expr, macros);
 		break;
@@ -1973,8 +2682,8 @@
 	return macros;
 }
 
-/* If "list" contains an isl_ast_op_min, isl_ast_op_max or isl_ast_op_fdiv_q
- * then set the corresponding bit in "macros".
+/* If "list" contains an isl_ast_expr_op_min, isl_ast_expr_op_max or
+ * isl_ast_expr_op_fdiv_q then set the corresponding bit in "macros".
  */
 static int ast_node_list_required_macros(__isl_keep isl_ast_node_list *list,
 	int macros)
@@ -1987,28 +2696,124 @@
 	return macros;
 }
 
+/* Data structure for keeping track of whether a macro definition
+ * for a given type has already been printed.
+ * The value is zero if no definition has been printed and non-zero otherwise.
+ */
+struct isl_ast_expr_op_printed {
+	char printedisl_ast_expr_op_last + 1;
+};
+
+/* Create an empty struct isl_ast_expr_op_printed.
+ */
+static void *create_printed(isl_ctx *ctx)
+{
+	return isl_calloc_type(ctx, struct isl_ast_expr_op_printed);
+}
+
+/* Free a struct isl_ast_expr_op_printed.
+ */
+static void free_printed(void *user)
+{
+	free(user);
+}
+
+/* Ensure that "p" has an isl_ast_expr_op_printed note identified by "id".
+ */
+static __isl_give isl_printer *alloc_printed(__isl_take isl_printer *p,
+	__isl_keep isl_id *id)
+{
+	return alloc_note(p, id, &create_printed, &free_printed);
+}
+
+/* Create an identifier that is used to store
+ * an isl_ast_expr_op_printed note.
+ */
+static __isl_give isl_id *printed_id(isl_ctx *ctx)
+{
+	return isl_id_alloc(ctx, "isl_ast_expr_op_type_printed", NULL);
+}
+
+/* Did the user specify that a macro definition should only be
+ * printed once and has a macro definition for "type" already
+ * been printed to "p"?
+ * If definitions should only be printed once, but a definition
+ * for "p" has not yet been printed, then mark it as having been
+ * printed so that it will not printed again.
+ * The actual printing is taken care of by the caller.
+ */
+static isl_bool already_printed_once(__isl_keep isl_printer *p,
+	enum isl_ast_expr_op_type type)
+{
+	isl_ctx *ctx;
+	isl_id *id;
+	struct isl_ast_expr_op_printed *printed;
+
+	if (!p)
+		return isl_bool_error;
+
+	ctx = isl_printer_get_ctx(p);
+	if (!isl_options_get_ast_print_macro_once(ctx))
+		return isl_bool_false;
+
+	if (type > isl_ast_expr_op_last)
+		isl_die(isl_printer_get_ctx(p), isl_error_invalid,
+			"invalid type", return isl_bool_error);
+
+	id = printed_id(isl_printer_get_ctx(p));
+	p = alloc_printed(p, id);
+	printed = get_note(p, id);
+	isl_id_free(id);
+	if (!printed)
+		return isl_bool_error;
+
+	if (printed->printedtype)
+		return isl_bool_true;
+
+	printed->printedtype = 1;
+	return isl_bool_false;
+}
+
 /* Print a macro definition for the operator "type".
+ *
+ * If the user has specified that a macro definition should
+ * only be printed once to any given printer and if the macro definition
+ * has already been printed to "p", then do not print the definition.
  */
-__isl_give isl_printer *isl_ast_op_type_print_macro(
-	enum isl_ast_op_type type, __isl_take isl_printer *p)
+__isl_give isl_printer *isl_ast_expr_op_type_print_macro(
+	enum isl_ast_expr_op_type type, __isl_take isl_printer *p)
 {
+	isl_bool skip;
+
+	skip = already_printed_once(p, type);
+	if (skip < 0)
+		return isl_printer_free(p);
+	if (skip)
+		return p;
+
 	switch (type) {
-	case isl_ast_op_min:
+	case isl_ast_expr_op_min:
 		p = isl_printer_start_line(p);
+		p = isl_printer_print_str(p, "#define ");
+		p = isl_printer_print_str(p, get_op_str_c(p, type));
 		p = isl_printer_print_str(p,
-			"#define min(x,y)    ((x) < (y) ? (x) : (y))");
+			"(x,y)    ((x) < (y) ? (x) : (y))");
 		p = isl_printer_end_line(p);
 		break;
-	case isl_ast_op_max:
+	case isl_ast_expr_op_max:
 		p = isl_printer_start_line(p);
+		p = isl_printer_print_str(p, "#define ");
+		p = isl_printer_print_str(p, get_op_str_c(p, type));
 		p = isl_printer_print_str(p,
-			"#define max(x,y)    ((x) > (y) ? (x) : (y))");
+			"(x,y)    ((x) > (y) ? (x) : (y))");
 		p = isl_printer_end_line(p);
 		break;
-	case isl_ast_op_fdiv_q:
+	case isl_ast_expr_op_fdiv_q:
 		p = isl_printer_start_line(p);
+		p = isl_printer_print_str(p, "#define ");
+		p = isl_printer_print_str(p, get_op_str_c(p, type));
 		p = isl_printer_print_str(p,
-			"#define floord(n,d) "
+			"(n,d) "
 			"(((n)<0) ? -((-(n)+(d)-1)/(d)) : (n)/(d))");
 		p = isl_printer_end_line(p);
 		break;
@@ -2019,46 +2824,149 @@
 	return p;
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_printer *isl_ast_op_type_print_macro(
+	enum isl_ast_expr_op_type type, __isl_take isl_printer *p)
+{
+	return isl_ast_expr_op_type_print_macro(type, p);
+}
+
+/* Call "fn" for each type of operation represented in the "macros"
+ * bit vector.
+ */
+static isl_stat foreach_ast_expr_op_type(int macros,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
+{
+	if (macros & ISL_AST_MACRO_MIN && fn(isl_ast_expr_op_min, user) < 0)
+		return isl_stat_error;
+	if (macros & ISL_AST_MACRO_MAX && fn(isl_ast_expr_op_max, user) < 0)
+		return isl_stat_error;
+	if (macros & ISL_AST_MACRO_FDIV_Q &&
+	    fn(isl_ast_expr_op_fdiv_q, user) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Call "fn" for each type of operation that appears in "expr"
+ * and that requires a macro definition.
+ */
+isl_stat isl_ast_expr_foreach_ast_expr_op_type(__isl_keep isl_ast_expr *expr,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
+{
+	int macros;
+
+	if (!expr)
+		return isl_stat_error;
+
+	macros = ast_expr_required_macros(expr, 0);
+	return foreach_ast_expr_op_type(macros, fn, user);
+}
+
+/* This is an alternative name for the function above.
+ */
+isl_stat isl_ast_expr_foreach_ast_op_type(__isl_keep isl_ast_expr *expr,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
+{
+	return isl_ast_expr_foreach_ast_expr_op_type(expr, fn, user);
+}
+
 /* Call "fn" for each type of operation that appears in "node"
  * and that requires a macro definition.
  */
-int isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node,
-	int (*fn)(enum isl_ast_op_type type, void *user), void *user)
+isl_stat isl_ast_node_foreach_ast_expr_op_type(__isl_keep isl_ast_node *node,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
 {
 	int macros;
 
 	if (!node)
-		return -1;
+		return isl_stat_error;
 
 	macros = ast_node_required_macros(node, 0);
+	return foreach_ast_expr_op_type(macros, fn, user);
+}
 
-	if (macros & ISL_AST_MACRO_MIN && fn(isl_ast_op_min, user) < 0)
-		return -1;
-	if (macros & ISL_AST_MACRO_MAX && fn(isl_ast_op_max, user) < 0)
-		return -1;
-	if (macros & ISL_AST_MACRO_FLOORD && fn(isl_ast_op_fdiv_q, user) < 0)
-		return -1;
-
-	return 0;
+/* This is an alternative name for the function above.
+ */
+isl_stat isl_ast_node_foreach_ast_op_type(__isl_keep isl_ast_node *node,
+	isl_stat (*fn)(enum isl_ast_expr_op_type type, void *user), void *user)
+{
+	return isl_ast_node_foreach_ast_expr_op_type(node, fn, user);
 }
 
-static int ast_op_type_print_macro(enum isl_ast_op_type type, void *user)
+static isl_stat ast_op_type_print_macro(enum isl_ast_expr_op_type type,
+	void *user)
 {
 	isl_printer **p = user;
 
-	*p = isl_ast_op_type_print_macro(type, *p);
+	*p = isl_ast_expr_op_type_print_macro(type, *p);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Print macro definitions for all the macros used in the result
- * of printing "node.
+ * of printing "expr".
+ */
+__isl_give isl_printer *isl_ast_expr_print_macros(
+	__isl_keep isl_ast_expr *expr, __isl_take isl_printer *p)
+{
+	if (isl_ast_expr_foreach_ast_expr_op_type(expr,
+					    &ast_op_type_print_macro, &p) < 0)
+		return isl_printer_free(p);
+	return p;
+}
+
+/* Print macro definitions for all the macros used in the result
+ * of printing "node".
  */
 __isl_give isl_printer *isl_ast_node_print_macros(
 	__isl_keep isl_ast_node *node, __isl_take isl_printer *p)
 {
-	if (isl_ast_node_foreach_ast_op_type(node,
+	if (isl_ast_node_foreach_ast_expr_op_type(node,
 					    &ast_op_type_print_macro, &p) < 0)
 		return isl_printer_free(p);
 	return p;
 }
+
+/* Return a string containing C code representing this isl_ast_expr.
+ */
+__isl_give char *isl_ast_expr_to_C_str(__isl_keep isl_ast_expr *expr)
+{
+	isl_printer *p;
+	char *str;
+
+	if (!expr)
+		return NULL;
+
+	p = isl_printer_to_str(isl_ast_expr_get_ctx(expr));
+	p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+	p = isl_printer_print_ast_expr(p, expr);
+
+	str = isl_printer_get_str(p);
+
+	isl_printer_free(p);
+
+	return str;
+}
+
+/* Return a string containing C code representing this isl_ast_node.
+ */
+__isl_give char *isl_ast_node_to_C_str(__isl_keep isl_ast_node *node)
+{
+	isl_printer *p;
+	char *str;
+
+	if (!node)
+		return NULL;
+
+	p = isl_printer_to_str(isl_ast_node_get_ctx(node));
+	p = isl_printer_set_output_format(p, ISL_FORMAT_C);
+	p = isl_printer_print_ast_node(p, node);
+
+	str = isl_printer_get_str(p);
+
+	isl_printer_free(p);
+
+	return str;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_ast_build.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_build.c Changed

@@ -1,5 +1,5 @@
 /*
- * Copyright 2012      Ecole Normale Superieure
+ * Copyright 2012-2013 Ecole Normale Superieure
  * Copyright 2014      INRIA Rocquencourt
  *
  * Use of this software is governed by the MIT license
@@ -10,11 +10,18 @@
  * B.P. 105 - 78153 Le Chesnay, France
  */
 
+#include <isl/id.h>
+#include <isl/val.h>
+#include <isl/space.h>
 #include <isl/map.h>
 #include <isl/aff.h>
+#include <isl/constraint.h>
 #include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
 #include <isl_ast_build_private.h>
 #include <isl_ast_private.h>
+#include <isl_config.h>
 
 /* Construct a map that isolates the current dimension.
  *
@@ -50,13 +57,17 @@
 {
 	isl_ctx *ctx;
 	isl_vec *strides;
+	isl_size dim;
 
 	build = isl_ast_build_cow(build);
 	if (!build || !build->domain)
 		goto error;
 
 	ctx = isl_ast_build_get_ctx(build);
-	strides = isl_vec_alloc(ctx, isl_space_dim(space, isl_dim_set));
+	dim = isl_space_dim(space, isl_dim_set);
+	if (dim < 0)
+		goto error;
+	strides = isl_vec_alloc(ctx, dim);
 	strides = isl_vec_set_si(strides, 1);
 
 	isl_vec_free(build->strides);
@@ -66,10 +77,12 @@
 	isl_multi_aff_free(build->offsets);
 	build->offsets = isl_multi_aff_zero(isl_space_copy(space));
 	isl_multi_aff_free(build->values);
-	build->values = isl_multi_aff_identity(space);
+	build->values = isl_multi_aff_identity(isl_space_copy(space));
+	isl_multi_aff_free(build->internal2input);
+	build->internal2input = isl_multi_aff_identity(space);
 
 	if (!build->iterators || !build->domain || !build->generated ||
-	    !build->pending || !build->values ||
+	    !build->pending || !build->values || !build->internal2input ||
 	    !build->strides || !build->offsets || !build->options)
 		return isl_ast_build_free(build);
 
@@ -87,7 +100,7 @@
 	__isl_keep isl_ast_build *build)
 {
 	int j;
-	char name16;
+	char name23;
 	isl_set *dom = build->domain;
 
 	snprintf(name, sizeof(name), "c%d", i);
@@ -105,14 +118,16 @@
  */
 __isl_give isl_ast_build *isl_ast_build_from_context(__isl_take isl_set *set)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_space *space;
 	isl_ast_build *build;
 
 	set = isl_set_compute_divs(set);
-	if (!set)
-		return NULL;
+	n = isl_set_dim(set, isl_dim_set);
+	if (n < 0)
+		goto error;
 
 	ctx = isl_set_get_ctx(set);
 
@@ -125,7 +140,6 @@
 	build->generated = isl_set_copy(build->domain);
 	build->pending = isl_set_universe(isl_set_get_space(build->domain));
 	build->options = isl_union_map_empty(isl_space_params_alloc(ctx, 0));
-	n = isl_set_dim(set, isl_dim_set);
 	build->depth = n;
 	build->iterators = isl_id_list_alloc(ctx, n);
 	for (i = 0; i < n; ++i) {
@@ -146,6 +160,19 @@
 	return NULL;
 }
 
+/* Create an isl_ast_build with a universe (parametric) context.
+ */
+__isl_give isl_ast_build *isl_ast_build_alloc(isl_ctx *ctx)
+{
+	isl_space *space;
+	isl_set *context;
+
+	space = isl_space_params_alloc(ctx, 0);
+	context = isl_set_universe(space);
+
+	return isl_ast_build_from_context(context);
+}
+
 __isl_give isl_ast_build *isl_ast_build_copy(__isl_keep isl_ast_build *build)
 {
 	if (!build)
@@ -176,6 +203,7 @@
 	dup->generated = isl_set_copy(build->generated);
 	dup->pending = isl_set_copy(build->pending);
 	dup->values = isl_multi_aff_copy(build->values);
+	dup->internal2input = isl_multi_aff_copy(build->internal2input);
 	dup->value = isl_pw_aff_copy(build->value);
 	dup->strides = isl_vec_copy(build->strides);
 	dup->offsets = isl_multi_aff_copy(build->offsets);
@@ -188,14 +216,32 @@
 	dup->before_each_for_user = build->before_each_for_user;
 	dup->after_each_for = build->after_each_for;
 	dup->after_each_for_user = build->after_each_for_user;
+	dup->before_each_mark = build->before_each_mark;
+	dup->before_each_mark_user = build->before_each_mark_user;
+	dup->after_each_mark = build->after_each_mark;
+	dup->after_each_mark_user = build->after_each_mark_user;
 	dup->create_leaf = build->create_leaf;
 	dup->create_leaf_user = build->create_leaf_user;
+	dup->node = isl_schedule_node_copy(build->node);
+	if (build->loop_type) {
+		int i;
+
+		dup->n = build->n;
+		dup->loop_type = isl_alloc_array(ctx,
+						enum isl_ast_loop_type, dup->n);
+		if (dup->n && !dup->loop_type)
+			return isl_ast_build_free(dup);
+		for (i = 0; i < dup->n; ++i)
+			dup->loop_typei = build->loop_typei;
+	}
 
 	if (!dup->iterators || !dup->domain || !dup->generated ||
 	    !dup->pending || !dup->values ||
 	    !dup->strides || !dup->offsets || !dup->options ||
+	    (build->internal2input && !dup->internal2input) ||
 	    (build->executed && !dup->executed) ||
-	    (build->value && !dup->value))
+	    (build->value && !dup->value) ||
+	    (build->node && !dup->node))
 		return isl_ast_build_free(dup);
 
 	return dup;
@@ -223,7 +269,15 @@
 						isl_space_copy(model));
 	build->options = isl_union_map_align_params(build->options,
 						isl_space_copy(model));
-	isl_space_free(model);
+	if (build->internal2input) {
+		build->internal2input =
+			isl_multi_aff_align_params(build->internal2input,
+						model);
+		if (!build->internal2input)
+			return isl_ast_build_free(build);
+	} else {
+		isl_space_free(model);
+	}
 
 	if (!build->domain || !build->values || !build->offsets ||
 	    !build->options)
@@ -260,12 +314,16 @@
 	isl_set_free(build->generated);
 	isl_set_free(build->pending);
 	isl_multi_aff_free(build->values);
+	isl_multi_aff_free(build->internal2input);
 	isl_pw_aff_free(build->value);
 	isl_vec_free(build->strides);
 	isl_multi_aff_free(build->offsets);
 	isl_multi_aff_free(build->schedule_map);
 	isl_union_map_free(build->executed);
 	isl_union_map_free(build->options);
+	isl_schedule_node_free(build->node);
+	free(build->loop_type);
+	isl_set_free(build->isolated);
 
 	free(build);
 
@@ -305,14 +363,16 @@
 __isl_give isl_ast_build *isl_ast_build_set_iterators(
 	__isl_take isl_ast_build *build, __isl_take isl_id_list *iterators)
 {
-	int dim, n_it;
+	isl_size dim, n_it;
 
 	build = isl_ast_build_cow(build);
 	if (!build)
 		goto error;
 
-	dim = isl_set_dim(build->domain, isl_dim_set);
+	dim = isl_ast_build_dim(build, isl_dim_set);
 	n_it = isl_id_list_n_id(build->iterators);
+	if (dim < 0 || n_it < 0)
+		goto error;
 	if (n_it < dim)
 		isl_die(isl_ast_build_get_ctx(build), isl_error_internal,
 			"isl_ast_build in inconsistent state", goto error);
@@ -383,6 +443,42 @@
 	return build;
 }
 
+/* Set the "before_each_mark" callback of "build" to "fn".
+ */
+__isl_give isl_ast_build *isl_ast_build_set_before_each_mark(
+	__isl_take isl_ast_build *build,
+	isl_stat (*fn)(__isl_keep isl_id *mark, __isl_keep isl_ast_build *build,
+		void *user), void *user)
+{
+	build = isl_ast_build_cow(build);
+
+	if (!build)
+		return NULL;
+
+	build->before_each_mark = fn;
+	build->before_each_mark_user = user;
+
+	return build;
+}
+
+/* Set the "after_each_mark" callback of "build" to "fn".
+ */
+__isl_give isl_ast_build *isl_ast_build_set_after_each_mark(
+	__isl_take isl_ast_build *build,
+	__isl_give isl_ast_node *(*fn)(__isl_take isl_ast_node *node,
+		__isl_keep isl_ast_build *build, void *user), void *user)
+{
+	build = isl_ast_build_cow(build);
+
+	if (!build)
+		return NULL;
+
+	build->after_each_mark = fn;
+	build->after_each_mark_user = user;
+
+	return build;
+}
+
 /* Set the "create_leaf" callback of "build" to "fn".
  */
 __isl_give isl_ast_build *isl_ast_build_set_create_leaf(
@@ -423,6 +519,10 @@
 	build->before_each_for_user = NULL;
 	build->after_each_for = NULL;
 	build->after_each_for_user = NULL;
+	build->before_each_mark = NULL;
+	build->before_each_mark_user = NULL;
+	build->after_each_mark = NULL;
+	build->after_each_mark_user = NULL;
 	build->create_leaf = NULL;
 	build->create_leaf_user = NULL;
 
@@ -469,15 +569,14 @@
  * if code has been generated for the entire schedule and if none
  * of the loops have been eliminated.
  */
-__isl_give int isl_ast_build_need_schedule_map(__isl_keep isl_ast_build *build)
+isl_bool isl_ast_build_need_schedule_map(__isl_keep isl_ast_build *build)
 {
-	int dim;
+	isl_size dim;
 
-	if (!build)
-		return -1;
-
-	dim = isl_set_dim(build->domain, isl_dim_set);
-	return build->depth != dim || any_eliminated(build);
+	dim = isl_ast_build_dim(build, isl_dim_set);
+	if (dim < 0)
+		return isl_bool_error;
+	return isl_bool_ok(build->depth != dim || any_eliminated(build));
 }
 
 /* Return a mapping from the internal schedule space to the external
@@ -501,6 +600,7 @@
 __isl_give isl_multi_aff *isl_ast_build_get_schedule_map_multi_aff(
 	__isl_keep isl_ast_build *build)
 {
+	isl_bool needs_map;
 	isl_space *space;
 	isl_multi_aff *ma;
 
@@ -508,13 +608,19 @@
 		return NULL;
 	if (build->schedule_map)
 		return isl_multi_aff_copy(build->schedule_map);
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0)
+		return NULL;
 
 	space = isl_ast_build_get_space(build, 1);
 	space = isl_space_map_from_set(space);
 	ma = isl_multi_aff_identity(space);
-	if (isl_ast_build_need_schedule_map(build)) {
+	if (needs_map) {
 		int i;
-		int dim = isl_set_dim(build->domain, isl_dim_set);
+		isl_size dim = isl_ast_build_dim(build, isl_dim_set);
+
+		if (dim < 0)
+			ma = isl_multi_aff_free(ma);
 		ma = isl_multi_aff_drop_dims(ma, isl_dim_out,
 					build->depth, dim - build->depth);
 		for (i = build->depth - 1; i >= 0; --i)
@@ -586,6 +692,8 @@
 	isl_vec_dump(build->strides);
 	fprintf(stderr, "offsets: ");
 	isl_multi_aff_dump(build->offsets);
+	fprintf(stderr, "internal2input: ");
+	isl_multi_aff_dump(build->internal2input);
 }
 
 /* Initialize "build" for AST construction in schedule space "space"
@@ -620,7 +728,7 @@
  * the first (and presumably only) affine expression in the isl_pw_aff
  * on which this function is used.
  */
-static int extract_single_piece(__isl_take isl_set *set,
+static isl_stat extract_single_piece(__isl_take isl_set *set,
 	__isl_take isl_aff *aff, void *user)
 {
 	isl_aff **p = user;
@@ -628,7 +736,7 @@
 	*p = aff;
 	isl_set_free(set);
 
-	return -1;
+	return isl_stat_error;
 }
 
 /* Intersect "set" with the stride constraint of "build", if any.
@@ -667,7 +775,8 @@
 static __isl_give isl_ast_build *update_values(
 	__isl_take isl_ast_build *build, __isl_take isl_basic_set *bounds)
 {
-	int sv;
+	isl_bool sv;
+	isl_size n;
 	isl_pw_multi_aff *pma;
 	isl_aff *aff = NULL;
 	isl_map *it_map;
@@ -692,10 +801,10 @@
 	build->value = isl_pw_aff_coalesce(build->value);
 	isl_pw_multi_aff_free(pma);
 
-	if (!build->value)
+	n = isl_pw_aff_n_piece(build->value);
+	if (n < 0)
 		return isl_ast_build_free(build);
-
-	if (isl_pw_aff_n_piece(build->value) != 1)
+	if (n != 1)
 		return build;
 
 	isl_pw_aff_foreach_piece(build->value, &extract_single_piece, &aff);
@@ -733,6 +842,10 @@
  * Otherwise, we would indirectly intersect the build domain with itself,
  * which can lead to inefficiencies, in particular if the build domain
  * contains any unknown divs.
+ *
+ * The pending and generated sets are not updated by this function to
+ * match the updated domain.
+ * The caller still needs to call isl_ast_build_set_pending_generated.
  */
 __isl_give isl_ast_build *isl_ast_build_set_loop_bounds(
 	__isl_take isl_ast_build *build, __isl_take isl_basic_set *bounds)
@@ -743,8 +856,6 @@
 	if (!build)
 		goto error;
 
-	bounds = isl_basic_set_preimage_multi_aff(bounds,
-					isl_multi_aff_copy(build->values));
 	build = update_values(build, isl_basic_set_copy(bounds));
 	if (!build)
 		goto error;
@@ -756,18 +867,6 @@
 							isl_set_copy(set));
 		build->domain = isl_set_intersect(build->domain, set);
 	} else {
-		isl_basic_set *generated, *pending;
-
-		pending = isl_basic_set_copy(bounds);
-		pending = isl_basic_set_drop_constraints_involving_dims(pending,
-					isl_dim_set, build->depth, 1);
-		build->pending = isl_set_intersect(build->pending,
-					isl_set_from_basic_set(pending));
-		generated = isl_basic_set_copy(bounds);
-		generated = isl_basic_set_drop_constraints_not_involving_dims(
-				    generated, isl_dim_set, build->depth, 1);
-		build->generated = isl_set_intersect(build->generated,
-					isl_set_from_basic_set(generated));
 		build->domain = isl_set_intersect(build->domain, set);
 		build = isl_ast_build_include_stride(build);
 		if (!build)
@@ -785,6 +884,49 @@
 	return NULL;
 }
 
+/* Update the pending and generated sets of "build" according to "bounds".
+ * If the build has an affine value at the current depth,
+ * then isl_ast_build_set_loop_bounds has already set the pending set.
+ * Otherwise, do it here.
+ */
+__isl_give isl_ast_build *isl_ast_build_set_pending_generated(
+	__isl_take isl_ast_build *build, __isl_take isl_basic_set *bounds)
+{
+	isl_basic_set *generated, *pending;
+
+	if (!build)
+		goto error;
+
+	if (isl_ast_build_has_affine_value(build, build->depth)) {
+		isl_basic_set_free(bounds);
+		return build;
+	}
+
+	build = isl_ast_build_cow(build);
+	if (!build)
+		goto error;
+
+	pending = isl_basic_set_copy(bounds);
+	pending = isl_basic_set_drop_constraints_involving_dims(pending,
+				isl_dim_set, build->depth, 1);
+	build->pending = isl_set_intersect(build->pending,
+				isl_set_from_basic_set(pending));
+	generated = bounds;
+	generated = isl_basic_set_drop_constraints_not_involving_dims(
+			    generated, isl_dim_set, build->depth, 1);
+	build->generated = isl_set_intersect(build->generated,
+				isl_set_from_basic_set(generated));
+
+	if (!build->pending || !build->generated)
+		return isl_ast_build_free(build);
+
+	return build;
+error:
+	isl_ast_build_free(build);
+	isl_basic_set_free(bounds);
+	return NULL;
+}
+
 /* Intersect build->domain with "set", where "set" is specified
  * in terms of the internal schedule domain.
  */
@@ -858,46 +1000,30 @@
 	return build;
 }
 
-/* Intersect build->pending and build->domain with "set",
- * where "set" is specified in terms of the internal schedule domain.
- */
-__isl_give isl_ast_build *isl_ast_build_restrict_pending(
-	__isl_take isl_ast_build *build, __isl_take isl_set *set)
-{
-	set = isl_set_compute_divs(set);
-	build = isl_ast_build_restrict_internal(build, isl_set_copy(set));
-	build = isl_ast_build_cow(build);
-	if (!build)
-		goto error;
-
-	build->pending = isl_set_intersect(build->pending, set);
-	build->pending = isl_set_coalesce(build->pending);
-
-	if (!build->pending)
-		return isl_ast_build_free(build);
-
-	return build;
-error:
-	isl_ast_build_free(build);
-	isl_set_free(set);
-	return NULL;
-}
-
 /* Intersect build->domain with "set", where "set" is specified
  * in terms of the external schedule domain.
  */
 __isl_give isl_ast_build *isl_ast_build_restrict(
 	__isl_take isl_ast_build *build, __isl_take isl_set *set)
 {
+	isl_bool needs_map;
+
 	if (isl_set_is_params(set))
 		return isl_ast_build_restrict_generated(build, set);
 
-	if (isl_ast_build_need_schedule_map(build)) {
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0)
+		goto error;
+	if (needs_map) {
 		isl_multi_aff *ma;
 		ma = isl_ast_build_get_schedule_map_multi_aff(build);
 		set = isl_set_preimage_multi_aff(set, ma);
 	}
 	return isl_ast_build_restrict_generated(build, set);
+error:
+	isl_ast_build_free(build);
+	isl_set_free(set);
+	return NULL;
 }
 
 /* Replace build->executed by "executed".
@@ -919,6 +1045,99 @@
 	return NULL;
 }
 
+/* Does "build" point to a band node?
+ * That is, are we currently handling a band node inside a schedule tree?
+ */
+int isl_ast_build_has_schedule_node(__isl_keep isl_ast_build *build)
+{
+	if (!build)
+		return -1;
+	return build->node != NULL;
+}
+
+/* Return a copy of the band node that "build" refers to.
+ */
+__isl_give isl_schedule_node *isl_ast_build_get_schedule_node(
+	__isl_keep isl_ast_build *build)
+{
+	if (!build)
+		return NULL;
+	return isl_schedule_node_copy(build->node);
+}
+
+/* Extract the loop AST generation types for the members of build->node
+ * and store them in build->loop_type.
+ */
+static __isl_give isl_ast_build *extract_loop_types(
+	__isl_take isl_ast_build *build)
+{
+	int i;
+	isl_size n;
+	isl_ctx *ctx;
+	isl_schedule_node *node;
+
+	if (!build)
+		return NULL;
+	n = isl_schedule_node_band_n_member(build->node);
+	if (n < 0)
+		return isl_ast_build_free(build);
+	ctx = isl_ast_build_get_ctx(build);
+	if (!build->node)
+		isl_die(ctx, isl_error_internal, "missing AST node",
+			return isl_ast_build_free(build));
+
+	free(build->loop_type);
+	build->n = n;
+	build->loop_type = isl_alloc_array(ctx,
+					    enum isl_ast_loop_type, build->n);
+	if (build->n && !build->loop_type)
+		return isl_ast_build_free(build);
+	node = build->node;
+	for (i = 0; i < build->n; ++i)
+		build->loop_typei =
+		    isl_schedule_node_band_member_get_ast_loop_type(node, i);
+
+	return build;
+}
+
+/* Replace the band node that "build" refers to by "node" and
+ * extract the corresponding loop AST generation types.
+ */
+__isl_give isl_ast_build *isl_ast_build_set_schedule_node(
+	__isl_take isl_ast_build *build,
+	__isl_take isl_schedule_node *node)
+{
+	build = isl_ast_build_cow(build);
+	if (!build || !node)
+		goto error;
+
+	isl_schedule_node_free(build->node);
+	build->node = node;
+
+	build = extract_loop_types(build);
+
+	return build;
+error:
+	isl_ast_build_free(build);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Remove any reference to a band node from "build".
+ */
+__isl_give isl_ast_build *isl_ast_build_reset_schedule_node(
+	__isl_take isl_ast_build *build)
+{
+	build = isl_ast_build_cow(build);
+	if (!build)
+		return NULL;
+
+	isl_schedule_node_free(build->node);
+	build->node = NULL;
+
+	return build;
+}
+
 /* Return a copy of the current schedule domain.
  */
 __isl_give isl_set *isl_ast_build_get_domain(__isl_keep isl_ast_build *build)
@@ -942,14 +1161,23 @@
 	return build ? isl_set_copy(build->generated) : NULL;
 }
 
+/* Return a copy of the map from the internal schedule domain
+ * to the original input schedule domain.
+ */
+__isl_give isl_multi_aff *isl_ast_build_get_internal2input(
+	__isl_keep isl_ast_build *build)
+{
+	return build ? isl_multi_aff_copy(build->internal2input) : NULL;
+}
+
 /* Return the number of variables of the given type
  * in the (internal) schedule space.
  */
-unsigned isl_ast_build_dim(__isl_keep isl_ast_build *build,
+isl_size isl_ast_build_dim(__isl_keep isl_ast_build *build,
 	enum isl_dim_type type)
 {
 	if (!build)
-		return 0;
+		return isl_size_error;
 	return isl_set_dim(build->domain, type);
 }
 
@@ -966,7 +1194,8 @@
 	int internal)
 {
 	int i;
-	int dim;
+	isl_size dim;
+	isl_bool needs_map;
 	isl_space *space;
 
 	if (!build)
@@ -976,15 +1205,25 @@
 	if (internal)
 		return space;
 
-	if (!isl_ast_build_need_schedule_map(build))
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0)
+		return isl_space_free(space);
+	if (!needs_map)
 		return space;
 
-	dim = isl_set_dim(build->domain, isl_dim_set);
+	dim = isl_ast_build_dim(build, isl_dim_set);
+	if (dim < 0)
+		return isl_space_free(space);
 	space = isl_space_drop_dims(space, isl_dim_set,
 				    build->depth, dim - build->depth);
-	for (i = build->depth - 1; i >= 0; --i)
-		if (isl_ast_build_has_affine_value(build, i))
+	for (i = build->depth - 1; i >= 0; --i) {
+		isl_bool affine = isl_ast_build_has_affine_value(build, i);
+
+		if (affine < 0)
+			return isl_space_free(space);
+		if (affine)
 			space = isl_space_drop_dims(space, isl_dim_set, i, 1);
+	}
 
 	return space;
 }
@@ -1026,14 +1265,16 @@
 __isl_give isl_union_map *isl_ast_build_get_schedule(
 	__isl_keep isl_ast_build *build)
 {
+	isl_bool needs_map;
 	isl_union_map *executed;
 	isl_union_map *schedule;
 
-	if (!build)
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0)
 		return NULL;
 
 	executed = isl_union_map_copy(build->executed);
-	if (isl_ast_build_need_schedule_map(build)) {
+	if (needs_map) {
 		isl_map *proj = isl_ast_build_get_schedule_map(build);
 		executed = isl_union_map_apply_domain(executed,
 					isl_union_map_from_map(proj));
@@ -1056,30 +1297,6 @@
 
 /* Set the stride and offset of the current dimension to the given
  * value and expression.
- *
- * If we had already found a stride before, then the two strides
- * are combined into a single stride.
- *
- * In particular, if the new stride information is of the form
- *
- *	i = f + s (...)
- *
- * and the old stride information is of the form
- *
- *	i = f2 + s2 (...)
- *
- * then we compute the extended gcd of s and s2
- *
- *	a s + b s2 = g,
- *
- * with g = gcd(s,s2), multiply the first equation with t1 = b s2/g
- * and the second with t2 = a s1/g.
- * This results in
- *
- *	i = (b s2 + a s1)/g i = t1 f + t2 f2 + (s s2)/g (...)
- *
- * so that t1 f + t2 f2 is the combined offset and (s s2)/g = lcm(s,s2)
- * is the combined stride.
  */
 static __isl_give isl_ast_build *set_stride(__isl_take isl_ast_build *build,
 	__isl_take isl_val *stride, __isl_take isl_aff *offset)
@@ -1092,25 +1309,6 @@
 
 	pos = build->depth;
 
-	if (isl_ast_build_has_stride(build, pos)) {
-		isl_val *stride2, *a, *b, *g;
-		isl_aff *offset2;
-
-		stride2 = isl_vec_get_element_val(build->strides, pos);
-		g = isl_val_gcdext(isl_val_copy(stride), isl_val_copy(stride2),
-					&a, &b);
-		a = isl_val_mul(a, isl_val_copy(stride));
-		a = isl_val_div(a, isl_val_copy(g));
-		stride2 = isl_val_div(stride2, g);
-		b = isl_val_mul(b, isl_val_copy(stride2));
-		stride = isl_val_mul(stride, stride2);
-
-		offset2 = isl_multi_aff_get_aff(build->offsets, pos);
-		offset2 = isl_aff_scale_val(offset2, a);
-		offset = isl_aff_scale_val(offset, b);
-		offset = isl_aff_add(offset, offset2);
-	}
-
 	build->strides = isl_vec_set_element_val(build->strides, pos, stride);
 	build->offsets = isl_multi_aff_set_aff(build->offsets, pos, offset);
 	if (!build->strides || !build->offsets)
@@ -1226,177 +1424,70 @@
 	return build;
 }
 
-/* Information used inside detect_stride.
- *
- * "build" may be updated by detect_stride to include stride information.
- * "pos" is equal to build->depth.
- */
-struct isl_detect_stride_data {
-	isl_ast_build *build;
-	int pos;
-};
-
-/* Check if constraint "c" imposes any stride on dimension data->pos
- * and, if so, update the stride information in data->build.
- *
- * In order to impose a stride on the dimension, "c" needs to be an equality
- * and it needs to involve the dimension.  Note that "c" may also be
- * a div constraint and thus an inequality that we cannot use.
- *
- * Let c be of the form
- *
- *	h(p) + g * v * i + g * stride * f(alpha) = 0
- *
- * with h(p) an expression in terms of the parameters and outer dimensions
- * and f(alpha) an expression in terms of the existentially quantified
- * variables.  Note that the inner dimensions have been eliminated so
- * they do not appear in "c".
- *
- * If "stride" is not zero and not one, then it represents a non-trivial stride
- * on "i".  We compute a and b such that
- *
- *	a v + b stride = 1
- *
- * We have
- *
- *	g v i = -h(p) + g stride f(alpha)
- *
- *	a g v i = -a h(p) + g stride f(alpha)
- *
- *	a g v i + b g stride i = -a h(p) + g stride * (...)
- *
- *	g i = -a h(p) + g stride * (...)
- *
- *	i = -a h(p)/g + stride * (...)
- *
- * The expression "-a h(p)/g" can therefore be used as offset.
- */
-static int detect_stride(__isl_take isl_constraint *c, void *user)
-{
-	struct isl_detect_stride_data *data = user;
-	int i, n_div;
-	isl_ctx *ctx;
-	isl_val *v, *stride, *m;
-
-	if (!isl_constraint_is_equality(c) ||
-	    !isl_constraint_involves_dims(c, isl_dim_set, data->pos, 1)) {
-		isl_constraint_free(c);
-		return 0;
-	}
-
-	ctx = isl_constraint_get_ctx(c);
-	stride = isl_val_zero(ctx);
-	n_div = isl_constraint_dim(c, isl_dim_div);
-	for (i = 0; i < n_div; ++i) {
-		v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
-		stride = isl_val_gcd(stride, v);
-	}
-
-	v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->pos);
-	m = isl_val_gcd(isl_val_copy(stride), isl_val_copy(v));
-	stride = isl_val_div(stride, isl_val_copy(m));
-	v = isl_val_div(v, isl_val_copy(m));
-
-	if (!isl_val_is_zero(stride) && !isl_val_is_one(stride)) {
-		isl_aff *aff;
-		isl_val *gcd, *a, *b;
-
-		gcd = isl_val_gcdext(v, isl_val_copy(stride), &a, &b);
-		isl_val_free(gcd);
-		isl_val_free(b);
-
-		aff = isl_constraint_get_aff(c);
-		for (i = 0; i < n_div; ++i)
-			aff = isl_aff_set_coefficient_si(aff,
-							 isl_dim_div, i, 0);
-		aff = isl_aff_set_coefficient_si(aff, isl_dim_in, data->pos, 0);
-		a = isl_val_neg(a);
-		aff = isl_aff_scale_val(aff, a);
-		aff = isl_aff_scale_down_val(aff, m);
-		data->build = set_stride(data->build, stride, aff);
-	} else {
-		isl_val_free(stride);
-		isl_val_free(m);
-		isl_val_free(v);
-	}
-
-	isl_constraint_free(c);
-	return 0;
-}
-
 /* Check if the constraints in "set" imply any stride on the current
  * dimension and, if so, record the stride information in "build"
  * and return the updated "build".
  *
- * We compute the affine hull and then check if any of the constraints
- * in the hull imposes any stride on the current dimension.
- *
  * We assume that inner dimensions have been eliminated from "set"
  * by the caller.  This is needed because the common stride
  * may be imposed by different inner dimensions on different parts of
  * the domain.
+ * The assumption ensures that the lower bound does not depend
+ * on inner dimensions.
  */
 __isl_give isl_ast_build *isl_ast_build_detect_strides(
 	__isl_take isl_ast_build *build, __isl_take isl_set *set)
 {
-	isl_basic_set *hull;
-	struct isl_detect_stride_data data;
+	int pos;
+	isl_bool no_stride;
+	isl_val *stride;
+	isl_aff *offset;
+	isl_stride_info *si;
 
 	if (!build)
 		goto error;
 
-	data.build = build;
-	data.pos = isl_ast_build_get_depth(build);
-	hull = isl_set_affine_hull(set);
-
-	if (isl_basic_set_foreach_constraint(hull, &detect_stride, &data) < 0)
-		data.build = isl_ast_build_free(data.build);
+	pos = isl_ast_build_get_depth(build);
+	si = isl_set_get_stride_info(set, pos);
+	stride = isl_stride_info_get_stride(si);
+	offset = isl_stride_info_get_offset(si);
+	isl_stride_info_free(si);
+	isl_set_free(set);
 
-	isl_basic_set_free(hull);
-	return data.build;
+	no_stride = isl_val_is_one(stride);
+	if (no_stride >= 0 && !no_stride)
+		return set_stride(build, stride, offset);
+	isl_val_free(stride);
+	isl_aff_free(offset);
+	if (no_stride < 0)
+		return isl_ast_build_free(build);
+	return build;
 error:
 	isl_set_free(set);
 	return NULL;
 }
 
-struct isl_ast_build_involves_data {
-	int depth;
-	int involves;
-};
-
-/* Check if "map" involves the input dimension data->depth.
+/* Does "map" not involve the input dimension data->depth?
  */
-static int involves_depth(__isl_take isl_map *map, void *user)
+static isl_bool free_of_depth(__isl_keep isl_map *map, void *user)
 {
-	struct isl_ast_build_involves_data *data = user;
+	int *depth = user;
 
-	data->involves = isl_map_involves_dims(map, isl_dim_in, data->depth, 1);
-	isl_map_free(map);
-
-	if (data->involves < 0 || data->involves)
-		return -1;
-	return 0;
+	return isl_bool_not(isl_map_involves_dims(map, isl_dim_in, *depth, 1));
 }
 
 /* Do any options depend on the value of the dimension at the current depth?
  */
 int isl_ast_build_options_involve_depth(__isl_keep isl_ast_build *build)
 {
-	struct isl_ast_build_involves_data data;
+	isl_bool free;
 
 	if (!build)
 		return -1;
 
-	data.depth = build->depth;
-	data.involves = 0;
-
-	if (isl_union_map_foreach_map(build->options,
-					&involves_depth, &data) < 0) {
-		if (data.involves < 0 || !data.involves)
-			return -1;
-	}
-
-	return data.involves;
+	free = isl_union_map_every_map(build->options, &free_of_depth,
+					&build->depth);
+	return isl_bool_not(free);
 }
 
 /* Construct the map
@@ -1414,7 +1505,7 @@
 	space = isl_space_set_from_params(space);
 	space = isl_space_add_dims(space, isl_dim_set, 1);
 	space = isl_space_map_from_set(space);
-	c = isl_equality_alloc(isl_local_space_from_space(space));
+	c = isl_constraint_alloc_equality(isl_local_space_from_space(space));
 	c = isl_constraint_set_coefficient_si(c, isl_dim_in, 0, 1);
 	c = isl_constraint_set_coefficient_si(c, isl_dim_out, 0, -1);
 	bmap1 = isl_basic_map_from_constraint(isl_constraint_copy(c));
@@ -1428,9 +1519,9 @@
 }
 
 static const char *option_str = {
-	atomic = "atomic",
-	unroll = "unroll",
-	separate = "separate"
+	isl_ast_loop_atomic = "atomic",
+	isl_ast_loop_unroll = "unroll",
+	isl_ast_loop_separate = "separate"
 };
 
 /* Update the "options" to reflect the insertion of a dimension
@@ -1459,7 +1550,7 @@
 {
 	isl_map *map;
 	isl_union_map *insertion;
-	enum isl_ast_build_domain_type type;
+	enum isl_ast_loop_type type;
 	const char *name = "separation_class";
 
 	space = isl_space_map_from_set(space);
@@ -1475,7 +1566,8 @@
 
 	insertion = isl_union_map_empty(isl_union_map_get_space(options));
 
-	for (type = atomic; type <= separate; ++type) {
+	for (type = isl_ast_loop_atomic;
+	    type <= isl_ast_loop_separate; ++type) {
 		isl_map *map_type = isl_map_copy(map);
 		const char *name = option_strtype;
 		map_type = isl_map_set_tuple_name(map_type, isl_dim_in, name);
@@ -1493,6 +1585,42 @@
 	return options;
 }
 
+/* If we are generating an AST from a schedule tree (build->node is set),
+ * then update the loop AST generation types
+ * to reflect the insertion of a dimension at (global) position "pos"
+ * in the schedule domain space.
+ * We do not need to adjust any isolate option since we would not be inserting
+ * any dimensions if there were any isolate option.
+ */
+static __isl_give isl_ast_build *node_insert_dim(
+	__isl_take isl_ast_build *build, int pos)
+{
+	int i;
+	int local_pos;
+	enum isl_ast_loop_type *loop_type;
+	isl_ctx *ctx;
+
+	build = isl_ast_build_cow(build);
+	if (!build)
+		return NULL;
+	if (!build->node)
+		return build;
+
+	ctx = isl_ast_build_get_ctx(build);
+	local_pos = pos - build->outer_pos;
+	loop_type = isl_realloc_array(ctx, build->loop_type,
+					enum isl_ast_loop_type, build->n + 1);
+	if (!loop_type)
+		return isl_ast_build_free(build);
+	build->loop_type = loop_type;
+	for (i = build->n - 1; i >= local_pos; --i)
+		loop_typei + 1 = loop_typei;
+	loop_typelocal_pos = isl_ast_loop_default;
+	build->n++;
+
+	return build;
+}
+
 /* Insert a single dimension in the schedule domain at position "pos".
  * The new dimension is given an isl_id with the empty string as name.
  *
@@ -1504,6 +1632,12 @@
  * However, the original schedule domain space may be named and/or
  * structured, so we have to take this possibility into account
  * while performing the transformations.
+ *
+ * Since the inserted schedule dimension is used by the caller
+ * to differentiate between different domain spaces, there is
+ * no longer a uniform mapping from the internal schedule space
+ * to the input schedule space.  The internal2input mapping is
+ * therefore removed.
  */
 __isl_give isl_ast_build *isl_ast_build_insert_dim(
 	__isl_take isl_ast_build *build, int pos)
@@ -1519,7 +1653,8 @@
 
 	ctx = isl_ast_build_get_ctx(build);
 	id = isl_id_alloc(ctx, "", NULL);
-	space = isl_ast_build_get_space(build, 1);
+	if (!build->node)
+		space = isl_ast_build_get_space(build, 1);
 	build->iterators = isl_id_list_insert(build->iterators, pos, id);
 	build->domain = isl_set_insert_dims(build->domain,
 						isl_dim_set, pos, 1);
@@ -1537,13 +1672,17 @@
 	build->offsets = isl_multi_aff_splice(build->offsets, pos, pos, ma);
 	ma = isl_multi_aff_identity(ma_space);
 	build->values = isl_multi_aff_splice(build->values, pos, pos, ma);
-	build->options = options_insert_dim(build->options, space, pos);
+	if (!build->node)
+		build->options = options_insert_dim(build->options, space, pos);
+	build->internal2input = isl_multi_aff_free(build->internal2input);
 
 	if (!build->iterators || !build->domain || !build->generated ||
 	    !build->pending || !build->values ||
 	    !build->strides || !build->offsets || !build->options)
 		return isl_ast_build_free(build);
 
+	build = node_insert_dim(build, pos);
+
 	return build;
 }
 
@@ -1556,7 +1695,11 @@
  * This function is called right after the strides have been
  * detected, but before any constraints on the current dimension
  * have been included in build->domain.
- * We therefore only need to update stride, offset and the options.
+ * We therefore only need to update stride, offset, the options and
+ * the mapping from internal schedule space to the original schedule
+ * space, if we are still keeping track of such a mapping.
+ * The latter mapping is updated by plugging in
+ * { ... i ... -> ... m i ...  }.
  */
 __isl_give isl_ast_build *isl_ast_build_scale_down(
 	__isl_take isl_ast_build *build, __isl_take isl_val *m,
@@ -1572,6 +1715,23 @@
 
 	depth = build->depth;
 
+	if (build->internal2input) {
+		isl_space *space;
+		isl_multi_aff *ma;
+		isl_aff *aff;
+
+		space = isl_multi_aff_get_space(build->internal2input);
+		space = isl_space_map_from_set(isl_space_domain(space));
+		ma = isl_multi_aff_identity(space);
+		aff = isl_multi_aff_get_aff(ma, depth);
+		aff = isl_aff_scale_val(aff, isl_val_copy(m));
+		ma = isl_multi_aff_set_aff(ma, depth, aff);
+		build->internal2input =
+		    isl_multi_aff_pullback_multi_aff(build->internal2input, ma);
+		if (!build->internal2input)
+			goto error;
+	}
+
 	v = isl_vec_get_element_val(build->strides, depth);
 	v = isl_val_div(v, isl_val_copy(m));
 	build->strides = isl_vec_set_element_val(build->strides, depth, v);
@@ -1614,7 +1774,7 @@
 /* Embed "options" into the given isl_ast_build space.
  *
  * This function is called from within a nested call to
- * isl_ast_build_ast_from_schedule.
+ * isl_ast_build_node_from_schedule_map.
  * "options" refers to the additional schedule,
  * while space refers to both the space of the outer isl_ast_build and
  * that of the additional schedule.
@@ -1678,7 +1838,7 @@
 	isl_vec *strides;
 	isl_set *set;
 	isl_multi_aff *embedding;
-	int dim, n_it;
+	isl_size dim, space_dim, n_it;
 
 	build = isl_ast_build_cow(build);
 	if (!build)
@@ -1687,9 +1847,12 @@
 	build->outer_pos = build->depth;
 
 	ctx = isl_ast_build_get_ctx(build);
-	dim = isl_set_dim(build->domain, isl_dim_set);
-	dim += isl_space_dim(space, isl_dim_set);
+	dim = isl_ast_build_dim(build, isl_dim_set);
+	space_dim = isl_space_dim(space, isl_dim_set);
 	n_it = isl_id_list_n_id(build->iterators);
+	if (dim < 0 || space_dim < 0 || n_it < 0)
+		goto error;
+	dim += space_dim;
 	if (n_it < dim) {
 		isl_id_list *l;
 		l = generate_names(ctx, dim - n_it, n_it, build);
@@ -1704,7 +1867,7 @@
 	build->pending = isl_set_product(build->pending, isl_set_copy(set));
 	build->generated = isl_set_product(build->generated, set);
 
-	strides = isl_vec_alloc(ctx, isl_space_dim(space, isl_dim_set));
+	strides = isl_vec_alloc(ctx, space_dim);
 	strides = isl_vec_set_si(strides, 1);
 	build->strides = isl_vec_concat(build->strides, strides);
 
@@ -1716,7 +1879,18 @@
 	build->values = isl_multi_aff_align_params(build->values,
 						    isl_space_copy(space));
 	embedding = isl_multi_aff_identity(space);
-	build->values = isl_multi_aff_product(build->values, embedding);
+	build->values = isl_multi_aff_product(build->values,
+					isl_multi_aff_copy(embedding));
+	if (build->internal2input) {
+		build->internal2input =
+			isl_multi_aff_product(build->internal2input, embedding);
+		build->internal2input =
+			isl_multi_aff_flatten_range(build->internal2input);
+		if (!build->internal2input)
+			return isl_ast_build_free(build);
+	} else {
+		isl_multi_aff_free(embedding);
+	}
 
 	space = isl_ast_build_get_space(build, 1);
 	build->options = embed_options(build->options, space);
@@ -1756,18 +1930,16 @@
 
 /* Does the dimension at (internal) position "pos" have a non-trivial stride?
  */
-int isl_ast_build_has_stride(__isl_keep isl_ast_build *build, int pos)
+isl_bool isl_ast_build_has_stride(__isl_keep isl_ast_build *build, int pos)
 {
 	isl_val *v;
-	int has_stride;
+	isl_bool has_stride;
 
 	if (!build)
-		return -1;
+		return isl_bool_error;
 
 	v = isl_vec_get_element_val(build->strides, pos);
-	if (!v)
-		return -1;
-	has_stride = !isl_val_is_one(v);
+	has_stride = isl_bool_not(isl_val_is_one(v));
 	isl_val_free(v);
 
 	return has_stride;
@@ -1807,28 +1979,25 @@
  * value that, moreover, can be described by a single affine expression
  * in terms of the outer dimensions and parameters?
  *
- * If not, then the correponding affine expression in build->values
+ * If not, then the corresponding affine expression in build->values
  * is set to be equal to the same input dimension.
  * Otherwise, it is set to the requested expression in terms of
  * outer dimensions and parameters.
  */
-int isl_ast_build_has_affine_value(__isl_keep isl_ast_build *build,
+isl_bool isl_ast_build_has_affine_value(__isl_keep isl_ast_build *build,
 	int pos)
 {
 	isl_aff *aff;
-	int involves;
+	isl_bool involves;
 
 	if (!build)
-		return -1;
+		return isl_bool_error;
 
 	aff = isl_multi_aff_get_aff(build->values, pos);
 	involves = isl_aff_involves_dims(aff, isl_dim_in, pos, 1);
 	isl_aff_free(aff);
 
-	if (involves < 0)
-		return -1;
-
-	return !involves;
+	return isl_bool_not(involves);
 }
 
 /* Plug in the known values (fixed affine expressions in terms of
@@ -1894,7 +2063,8 @@
 	if (!build)
 		goto error;
 
-	set = isl_set_preimage_multi_aff(set,
+	if (!isl_set_is_params(set))
+		set = isl_set_preimage_multi_aff(set,
 					isl_multi_aff_copy(build->values));
 	set = isl_set_gist(set, isl_set_copy(build->domain));
 
@@ -1922,6 +2092,18 @@
 					isl_multi_aff_copy(build->values));
 }
 
+/* Plug in the known affine values of outer loop iterators in "bset".
+ */
+__isl_give isl_basic_set *isl_ast_build_specialize_basic_set(
+	__isl_keep isl_ast_build *build, __isl_take isl_basic_set *bset)
+{
+	if (!build)
+		return isl_basic_set_free(bset);
+
+	return isl_basic_set_preimage_multi_aff(bset,
+					isl_multi_aff_copy(build->values));
+}
+
 /* Simplify the map "map" based on what we know about
  * the iterators of already generated loops.
  *
@@ -2019,8 +2201,7 @@
  * but the position is still that within the current code generation.
  */
 __isl_give isl_set *isl_ast_build_get_option_domain(
-	__isl_keep isl_ast_build *build,
-	enum isl_ast_build_domain_type type)
+	__isl_keep isl_ast_build *build, enum isl_ast_loop_type type)
 {
 	const char *name;
 	isl_space *space;
@@ -2048,6 +2229,122 @@
 	return domain;
 }
 
+/* How does the user want the current schedule dimension to be generated?
+ * These choices have been extracted from the schedule node
+ * in extract_loop_types and stored in build->loop_type.
+ * They have been updated to reflect any dimension insertion in
+ * node_insert_dim.
+ * Return isl_ast_domain_error on error.
+ *
+ * If "isolated" is set, then we get the loop AST generation type
+ * directly from the band node since node_insert_dim cannot have been
+ * called on a band with the isolate option.
+ */
+enum isl_ast_loop_type isl_ast_build_get_loop_type(
+	__isl_keep isl_ast_build *build, int isolated)
+{
+	int local_pos;
+	isl_ctx *ctx;
+
+	if (!build)
+		return isl_ast_loop_error;
+	ctx = isl_ast_build_get_ctx(build);
+	if (!build->node)
+		isl_die(ctx, isl_error_internal,
+			"only works for schedule tree based AST generation",
+			return isl_ast_loop_error);
+
+	local_pos = build->depth - build->outer_pos;
+	if (!isolated)
+		return build->loop_typelocal_pos;
+	return isl_schedule_node_band_member_get_isolate_ast_loop_type(
+							build->node, local_pos);
+}
+
+/* Extract the isolated set from the isolate option, if any,
+ * and store in the build.
+ * If there is no isolate option, then the isolated set is
+ * set to the empty set.
+ *
+ * The isolate option is of the form
+ *
+ *	isolateouter bands -> current_band
+ *
+ * We flatten this set and then map it back to the internal
+ * schedule space.
+ *
+ * If we have already extracted the isolated set
+ * or if internal2input is no longer set, then we do not
+ * need to do anything.  In the latter case, we know
+ * that the current band cannot have any isolate option.
+ */
+__isl_give isl_ast_build *isl_ast_build_extract_isolated(
+	__isl_take isl_ast_build *build)
+{
+	isl_set *isolated;
+
+	if (!build)
+		return NULL;
+	if (!build->internal2input)
+		return build;
+	if (build->isolated)
+		return build;
+
+	build = isl_ast_build_cow(build);
+	if (!build)
+		return NULL;
+
+	isolated = isl_schedule_node_band_get_ast_isolate_option(build->node);
+	isolated = isl_set_flatten(isolated);
+	isolated = isl_set_preimage_multi_aff(isolated,
+				    isl_multi_aff_copy(build->internal2input));
+
+	build->isolated = isolated;
+	if (!build->isolated)
+		return isl_ast_build_free(build);
+
+	return build;
+}
+
+/* Does "build" have a non-empty isolated set?
+ *
+ * The caller is assumed to have called isl_ast_build_extract_isolated first.
+ */
+int isl_ast_build_has_isolated(__isl_keep isl_ast_build *build)
+{
+	int empty;
+
+	if (!build)
+		return -1;
+	if (!build->internal2input)
+		return 0;
+	if (!build->isolated)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_internal,
+			"isolated set not extracted yet", return -1);
+
+	empty = isl_set_plain_is_empty(build->isolated);
+	return empty < 0 ? -1 : !empty;
+}
+
+/* Return a copy of the isolated set of "build".
+ *
+ * The caller is assume to have called isl_ast_build_has_isolated first,
+ * with this function returning true.
+ * In particular, this function should not be called if we are no
+ * longer keeping track of internal2input (and there therefore could
+ * not possibly be any isolated set).
+ */
+__isl_give isl_set *isl_ast_build_get_isolated(__isl_keep isl_ast_build *build)
+{
+	if (!build)
+		return NULL;
+	if (!build->internal2input)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_internal,
+			"build cannot have isolated set", return NULL);
+
+	return isl_set_copy(build->isolated);
+}
+
 /* Extract the separation class mapping at the current depth.
  *
  * In particular, find and return the subset of build->options that is of

_service:tar_scm:isl-0.14.tar.xz/isl_ast_build_expr.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_build_expr.c Changed

@@ -1,19 +1,27 @@
 /*
  * Copyright 2012-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege,
  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
  */
 
+#include <isl/id.h>
+#include <isl/space.h>
+#include <isl/constraint.h>
 #include <isl/ilp.h>
+#include <isl/val.h>
 #include <isl_ast_build_expr.h>
 #include <isl_ast_private.h>
 #include <isl_ast_build_private.h>
+#include <isl_sort.h>
 
 /* Compute the "opposite" of the (numerator of the) argument of a div
- * with denonimator "d".
+ * with denominator "d".
  *
  * In particular, compute
  *
@@ -29,11 +37,120 @@
 	return aff;
 }
 
+/* Internal data structure used inside isl_ast_expr_add_term.
+ * The domain of "build" is used to simplify the expressions.
+ * "build" needs to be set by the caller of isl_ast_expr_add_term.
+ * "cst" is the constant term of the expression in which the added term
+ * appears.  It may be modified by isl_ast_expr_add_term.
+ *
+ * "v" is the coefficient of the term that is being constructed and
+ * is set internally by isl_ast_expr_add_term.
+ */
+struct isl_ast_add_term_data {
+	isl_ast_build *build;
+	isl_val *cst;
+	isl_val *v;
+};
+
+/* Given the numerator "aff" of the argument of an integer division
+ * with denominator "d", check if it can be made non-negative over
+ * data->build->domain by stealing part of the constant term of
+ * the expression in which the integer division appears.
+ *
+ * In particular, the outer expression is of the form
+ *
+ *	v * floor(aff/d) + cst
+ *
+ * We already know that "aff" itself may attain negative values.
+ * Here we check if aff + d*floor(cst/v) is non-negative, such
+ * that we could rewrite the expression to
+ *
+ *	v * floor((aff + d*floor(cst/v))/d) + cst - v*floor(cst/v)
+ *
+ * Note that aff + d*floor(cst/v) can only possibly be non-negative
+ * if data->cst and data->v have the same sign.
+ * Similarly, if floor(cst/v) is zero, then there is no point in
+ * checking again.
+ */
+static int is_non_neg_after_stealing(__isl_keep isl_aff *aff,
+	__isl_keep isl_val *d, struct isl_ast_add_term_data *data)
+{
+	isl_aff *shifted;
+	isl_val *shift;
+	int is_zero;
+	int non_neg;
+
+	if (isl_val_sgn(data->cst) != isl_val_sgn(data->v))
+		return 0;
+
+	shift = isl_val_div(isl_val_copy(data->cst), isl_val_copy(data->v));
+	shift = isl_val_floor(shift);
+	is_zero = isl_val_is_zero(shift);
+	if (is_zero < 0 || is_zero) {
+		isl_val_free(shift);
+		return is_zero < 0 ? -1 : 0;
+	}
+	shift = isl_val_mul(shift, isl_val_copy(d));
+	shifted = isl_aff_copy(aff);
+	shifted = isl_aff_add_constant_val(shifted, shift);
+	non_neg = isl_ast_build_aff_is_nonneg(data->build, shifted);
+	isl_aff_free(shifted);
+
+	return non_neg;
+}
+
+/* Given the numerator "aff' of the argument of an integer division
+ * with denominator "d", steal part of the constant term of
+ * the expression in which the integer division appears to make it
+ * non-negative over data->build->domain.
+ *
+ * In particular, the outer expression is of the form
+ *
+ *	v * floor(aff/d) + cst
+ *
+ * We know that "aff" itself may attain negative values,
+ * but that aff + d*floor(cst/v) is non-negative.
+ * Find the minimal positive value that we need to add to "aff"
+ * to make it positive and adjust data->cst accordingly.
+ * That is, compute the minimal value "m" of "aff" over
+ * data->build->domain and take
+ *
+ *	s = ceil(m/d)
+ *
+ * such that
+ *
+ *	aff + d * s >= 0
+ *
+ * and rewrite the expression to
+ *
+ *	v * floor((aff + s*d)/d) + (cst - v*s)
+ */
+static __isl_give isl_aff *steal_from_cst(__isl_take isl_aff *aff,
+	__isl_keep isl_val *d, struct isl_ast_add_term_data *data)
+{
+	isl_set *domain;
+	isl_val *shift, *t;
+
+	domain = isl_ast_build_get_domain(data->build);
+	shift = isl_set_min_val(domain, aff);
+	isl_set_free(domain);
+
+	shift = isl_val_neg(shift);
+	shift = isl_val_div(shift, isl_val_copy(d));
+	shift = isl_val_ceil(shift);
+
+	t = isl_val_copy(shift);
+	t = isl_val_mul(t, isl_val_copy(data->v));
+	data->cst = isl_val_sub(data->cst, t);
+
+	shift = isl_val_mul(shift, isl_val_copy(d));
+	return isl_aff_add_constant_val(aff, shift);
+}
+
 /* Create an isl_ast_expr evaluating the div at position "pos" in "ls".
- * The result is simplified in terms of build->domain.
+ * The result is simplified in terms of data->build->domain.
+ * This function may change (the sign of) data->v.
  *
- * *change_sign is set by this function if the sign of
- * the expression has changed.
  * "ls" is known to be non-NULL.
  *
  * Let the div be of the form floor(e/d).
@@ -52,71 +169,82 @@
  *
  *	floor(e/d) = -ceil(-e/d) = -floor((-e + d - 1)/d)
  *
- * and still use pdiv_q.
+ * and still use pdiv_q, while changing the sign of data->v.
+ *
+ * Otherwise, we check if
+ *
+ *	e + d*floor(cst/v)
+ *
+ * is non-negative and if so, replace floor(e/d) by
+ *
+ *	floor((e + s*d)/d) - s
+ *
+ * with s the minimal shift that makes the argument non-negative.
  */
-static __isl_give isl_ast_expr *var_div(int *change_sign,
-	__isl_keep isl_local_space *ls,
-	int pos, __isl_keep isl_ast_build *build)
+static __isl_give isl_ast_expr *var_div(struct isl_ast_add_term_data *data,
+	__isl_keep isl_local_space *ls, int pos)
 {
 	isl_ctx *ctx = isl_local_space_get_ctx(ls);
 	isl_aff *aff;
 	isl_ast_expr *num, *den;
 	isl_val *d;
-	enum isl_ast_op_type type;
+	enum isl_ast_expr_op_type type;
 
 	aff = isl_local_space_get_div(ls, pos);
 	d = isl_aff_get_denominator_val(aff);
 	aff = isl_aff_scale_val(aff, isl_val_copy(d));
 	den = isl_ast_expr_from_val(isl_val_copy(d));
 
-	type = isl_ast_op_fdiv_q;
+	type = isl_ast_expr_op_fdiv_q;
 	if (isl_options_get_ast_build_prefer_pdiv(ctx)) {
-		int non_neg = isl_ast_build_aff_is_nonneg(build, aff);
+		int non_neg = isl_ast_build_aff_is_nonneg(data->build, aff);
 		if (non_neg >= 0 && !non_neg) {
 			isl_aff *opp = oppose_div_arg(isl_aff_copy(aff),
 							isl_val_copy(d));
-			non_neg = isl_ast_build_aff_is_nonneg(build, opp);
+			non_neg = isl_ast_build_aff_is_nonneg(data->build, opp);
 			if (non_neg >= 0 && non_neg) {
-				*change_sign = 1;
+				data->v = isl_val_neg(data->v);
 				isl_aff_free(aff);
 				aff = opp;
 			} else
 				isl_aff_free(opp);
 		}
+		if (non_neg >= 0 && !non_neg) {
+			non_neg = is_non_neg_after_stealing(aff, d, data);
+			if (non_neg >= 0 && non_neg)
+				aff = steal_from_cst(aff, d, data);
+		}
 		if (non_neg < 0)
 			aff = isl_aff_free(aff);
 		else if (non_neg)
-			type = isl_ast_op_pdiv_q;
+			type = isl_ast_expr_op_pdiv_q;
 	}
 
 	isl_val_free(d);
-	num = isl_ast_expr_from_aff(aff, build);
+	num = isl_ast_expr_from_aff(aff, data->build);
 	return isl_ast_expr_alloc_binary(type, num, den);
 }
 
 /* Create an isl_ast_expr evaluating the specified dimension of "ls".
- * The result is simplified in terms of build->domain.
- *
- * *change_sign is set by this function if the sign of
- * the expression has changed.
+ * The result is simplified in terms of data->build->domain.
+ * This function may change (the sign of) data->v.
  *
  * The isl_ast_expr is constructed based on the type of the dimension.
  * - divs are constructed by var_div
- * - set variables are constructed from the iterator isl_ids in "build"
+ * - set variables are constructed from the iterator isl_ids in data->build
  * - parameters are constructed from the isl_ids in "ls"
  */
-static __isl_give isl_ast_expr *var(int *change_sign,
-	__isl_keep isl_local_space *ls,
-	enum isl_dim_type type, int pos, __isl_keep isl_ast_build *build)
+static __isl_give isl_ast_expr *var(struct isl_ast_add_term_data *data,
+	__isl_keep isl_local_space *ls, enum isl_dim_type type, int pos)
 {
 	isl_ctx *ctx = isl_local_space_get_ctx(ls);
 	isl_id *id;
 
 	if (type == isl_dim_div)
-		return var_div(change_sign, ls, pos, build);
+		return var_div(data, ls, pos);
 
 	if (type == isl_dim_set) {
-		id = isl_ast_build_get_iterator_id(build, pos);
+		id = isl_ast_build_get_iterator_id(data->build, pos);
 		return isl_ast_expr_from_id(id);
 	}
 
@@ -169,11 +297,11 @@
  * If expr2 is zero, we simply return expr1.
  * If expr1 is zero, we return
  *
- *	(isl_ast_op_minus, expr2)
+ *	(isl_ast_expr_op_minus, expr2)
  *
  * Otherwise, we return
  *
- *	(isl_ast_op_sub, expr1, expr2)
+ *	(isl_ast_expr_op_sub, expr1, expr2)
  */
 static __isl_give isl_ast_expr *ast_expr_sub(__isl_take isl_ast_expr *expr1,
 	__isl_take isl_ast_expr *expr2)
@@ -209,18 +337,16 @@
 	__isl_keep isl_aff *aff, __isl_keep isl_val *d,
 	__isl_keep isl_ast_build *build)
 {
-	isl_ctx *ctx;
 	isl_ast_expr *expr;
 	isl_ast_expr *c;
 
 	if (!aff)
 		return NULL;
 
-	ctx = isl_aff_get_ctx(aff);
 	expr = isl_ast_expr_from_aff(isl_aff_copy(aff), build);
 
 	c = isl_ast_expr_from_val(isl_val_copy(d));
-	expr = isl_ast_expr_alloc_binary(isl_ast_op_pdiv_r, expr, c);
+	expr = isl_ast_expr_alloc_binary(isl_ast_expr_op_pdiv_r, expr, c);
 
 	if (!isl_val_is_one(v)) {
 		c = isl_ast_expr_from_val(isl_val_copy(v));
@@ -235,11 +361,11 @@
  * If v is 1, we simply return expr.
  * If v is -1, we return
  *
- *	(isl_ast_op_minus, expr)
+ *	(isl_ast_expr_op_minus, expr)
  *
  * Otherwise, we return
  *
- *	(isl_ast_op_mul, expr(v), expr)
+ *	(isl_ast_expr_op_mul, expr(v), expr)
  */
 static __isl_give isl_ast_expr *scale(__isl_take isl_ast_expr *expr,
 	__isl_take isl_val *v)
@@ -270,39 +396,40 @@
 
 /* Add an expression for "*v" times the specified dimension of "ls"
  * to expr.
+ * If the dimension is an integer division, then this function
+ * may modify data->cst in order to make the numerator non-negative.
+ * The result is simplified in terms of data->build->domain.
  *
  * Let e be the expression for the specified dimension,
  * multiplied by the absolute value of "*v".
  * If "*v" is negative, we create
  *
- *	(isl_ast_op_sub, expr, e)
+ *	(isl_ast_expr_op_sub, expr, e)
  *
  * except when expr is trivially zero, in which case we create
  *
- *	(isl_ast_op_minus, e)
+ *	(isl_ast_expr_op_minus, e)
  *
  * instead.
  *
  * If "*v" is positive, we simply create
  *
- *	(isl_ast_op_add, expr, e)
+ *	(isl_ast_expr_op_add, expr, e)
  *
  */
 static __isl_give isl_ast_expr *isl_ast_expr_add_term(
 	__isl_take isl_ast_expr *expr,
 	__isl_keep isl_local_space *ls, enum isl_dim_type type, int pos,
-	__isl_take isl_val *v, __isl_keep isl_ast_build *build)
+	__isl_take isl_val *v, struct isl_ast_add_term_data *data)
 {
 	isl_ast_expr *term;
-	int change_sign;
 
 	if (!expr)
 		return NULL;
 
-	change_sign = 0;
-	term = var(&change_sign, ls, type, pos, build);
-	if (change_sign)
-		v = isl_val_neg(v);
+	data->v = v;
+	term = var(data, ls, type, pos);
+	v = data->v;
 
 	if (isl_val_is_neg(v) && !ast_expr_is_zero(expr)) {
 		v = isl_val_neg(v);
@@ -319,7 +446,6 @@
 static __isl_give isl_ast_expr *isl_ast_expr_add_int(
 	__isl_take isl_ast_expr *expr, __isl_take isl_val *v)
 {
-	isl_ctx *ctx;
 	isl_ast_expr *expr_int;
 
 	if (!expr || !v)
@@ -330,7 +456,6 @@
 		return expr;
 	}
 
-	ctx = isl_ast_expr_get_ctx(expr);
 	if (isl_val_is_neg(v) && !ast_expr_is_zero(expr)) {
 		v = isl_val_neg(v);
 		expr_int = isl_ast_expr_from_val(v);
@@ -385,11 +510,41 @@
 	int sign;
 };
 
+/* Does
+ *
+ *	arg mod data->d
+ *
+ * represent (a special case of) a test for some linear expression
+ * being even?
+ *
+ * In particular, is it of the form
+ *
+ *	(lin - 1) mod 2
+ *
+ * ?
+ */
+static isl_bool is_even_test(struct isl_extract_mod_data *data,
+	__isl_keep isl_aff *arg)
+{
+	isl_bool res;
+	isl_val *cst;
+
+	res = isl_val_eq_si(data->d, 2);
+	if (res < 0 || !res)
+		return res;
+
+	cst = isl_aff_get_constant_val(arg);
+	res = isl_val_eq_si(cst, -1);
+	isl_val_free(cst);
+
+	return res;
+}
+
 /* Given that data->v * div_i in data->aff is equal to
  *
  *	f * (term - (arg mod d))
  *
- * with data->d * f = data->v, add
+ * with data->d * f = data->v and "arg" non-negative on data->build, add
  *
  *	f * term
  *
@@ -398,13 +553,38 @@
  *	abs(f) * (arg mod d)
  *
  * to data->neg or data->pos depending on the sign of -f.
+ *
+ * In the special case that "arg mod d" is of the form "(lin - 1) mod 2",
+ * with "lin" some linear expression, first replace
+ *
+ *	f * (term - ((lin - 1) mod 2))
+ *
+ * by
+ *
+ *	-f * (1 - term - (lin mod 2))
+ *
+ * These two are equal because
+ *
+ *	((lin - 1) mod 2) + (lin mod 2) = 1
+ *
+ * Also, if "lin - 1" is non-negative, then "lin" is non-negative too.
  */
 static int extract_term_and_mod(struct isl_extract_mod_data *data,
 	__isl_take isl_aff *term, __isl_take isl_aff *arg)
 {
+	isl_bool even;
 	isl_ast_expr *expr;
 	int s;
 
+	even = is_even_test(data, arg);
+	if (even < 0) {
+		arg = isl_aff_free(arg);
+	} else if (even) {
+		term = oppose_div_arg(term, isl_val_copy(data->d));
+		data->v = isl_val_neg(data->v);
+		arg = isl_aff_set_constant_si(arg, 0);
+	}
+
 	data->v = isl_val_div(data->v, isl_val_copy(data->d));
 	s = isl_val_sgn(data->v);
 	data->v = isl_val_abs(data->v);
@@ -418,7 +598,7 @@
 						isl_dim_div, data->i, 0);
 	if (s < 0)
 		data->v = isl_val_neg(data->v);
-	term = isl_aff_scale_val(data->div, isl_val_copy(data->v));
+	term = isl_aff_scale_val(term, isl_val_copy(data->v));
 
 	if (!data->add)
 		data->add = term;
@@ -540,18 +720,27 @@
  * not to involve any coefficients that are multiples of d, "c" may
  * very well involve such coefficients.  This means that we may actually
  * miss some cases.
+ *
+ * If the constant term is "too large", then the constraint is rejected,
+ * where "too large" is fairly arbitrarily set to 1 << 15.
+ * We do this to avoid picking up constraints that bound a variable
+ * by a very large number, say the largest or smallest possible
+ * variable in the representation of some integer type.
  */
-static int check_parallel_or_opposite(__isl_take isl_constraint *c, void *user)
+static isl_stat check_parallel_or_opposite(__isl_take isl_constraint *c,
+	void *user)
 {
 	struct isl_extract_mod_data *data = user;
 	enum isl_dim_type c_type2 = { isl_dim_param, isl_dim_set };
 	enum isl_dim_type a_type2 = { isl_dim_param, isl_dim_in };
 	int i, t;
-	int n2;
+	isl_size n2;
 	int parallel = 1, opposite = 1;
 
 	for (t = 0; t < 2; ++t) {
 		nt = isl_constraint_dim(c, c_typet);
+		if (nt < 0)
+			return isl_stat_error;
 		for (i = 0; i < nt; ++i) {
 			int a, b;
 
@@ -562,6 +751,15 @@
 		}
 	}
 
+	if (parallel || opposite) {
+		isl_val *v;
+
+		v = isl_val_abs(isl_constraint_get_constant_val(c));
+		if (isl_val_cmp_si(v, 1 << 15) > 0)
+			parallel = opposite = 0;
+		isl_val_free(v);
+	}
+
 	for (t = 0; t < 2; ++t) {
 		for (i = 0; i < nt; ++i) {
 			isl_val *v1, *v2;
@@ -595,9 +793,9 @@
 	isl_constraint_free(c);
 
 	if (data->sign != 0 && data->nonneg == NULL)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Given that data->v * div_i in data->aff is of the form
@@ -683,12 +881,15 @@
 {
 	isl_basic_set *hull;
 	isl_val *v1, *v2;
-	int r;
+	isl_stat r;
+	isl_size n;
 
 	if (!data->build)
 		goto error;
 
-	int n = isl_aff_dim(data->div, isl_dim_div);
+	n = isl_aff_dim(data->div, isl_dim_div);
+	if (n < 0)
+		goto error;
 
 	if (isl_aff_involves_dims(data->div, isl_dim_div, 0, n))
 		return extract_nonneg_mod(data);
@@ -760,7 +961,7 @@
  *
  * Note that in order to represent "a mod m" as
  *
- *	(isl_ast_op_pdiv_r, a, m)
+ *	(isl_ast_expr_op_pdiv_r, a, m)
  *
  * we need to make sure that a is non-negative.
  * If not, we check if "-a + m - 1" is non-negative.
@@ -813,7 +1014,7 @@
 {
 	struct isl_extract_mod_data data = { build, aff, *pos, *neg };
 	isl_ctx *ctx;
-	int n;
+	isl_size n;
 
 	if (!aff)
 		return NULL;
@@ -823,6 +1024,8 @@
 		return aff;
 
 	n = isl_aff_dim(data.aff, isl_dim_div);
+	if (n < 0)
+		return isl_aff_free(aff);
 	for (data.i = 0; data.i < n; ++data.i) {
 		data.v = isl_aff_get_coefficient_val(data.aff,
 							isl_dim_div, data.i);
@@ -859,7 +1062,8 @@
 static __isl_give isl_aff *extract_rational(__isl_take isl_aff *aff,
 	__isl_keep isl_ast_expr **expr, __isl_keep isl_ast_build *build)
 {
-	int i, j, n;
+	int i, j;
+	isl_size n;
 	isl_aff *rat = NULL;
 	isl_local_space *ls = NULL;
 	isl_ast_expr *rat_expr;
@@ -884,6 +1088,8 @@
 
 	for (i = 0; i < 3; ++i) {
 		n = isl_aff_dim(aff, ti);
+		if (n < 0)
+			goto error;
 		for (j = 0; j < n; ++j) {
 			isl_aff *rat_j;
 
@@ -941,13 +1147,14 @@
 	__isl_keep isl_ast_build *build)
 {
 	int i, j;
-	int n;
+	isl_size n;
 	isl_val *v;
 	isl_ctx *ctx = isl_aff_get_ctx(aff);
 	isl_ast_expr *expr, *expr_neg;
 	enum isl_dim_type t = { isl_dim_param, isl_dim_in, isl_dim_div };
 	enum isl_dim_type l = { isl_dim_param, isl_dim_set, isl_dim_div };
 	isl_local_space *ls;
+	struct isl_ast_add_term_data data;
 
 	if (!aff)
 		return NULL;
@@ -962,8 +1169,12 @@
 
 	ls = isl_aff_get_domain_local_space(aff);
 
+	data.build = build;
+	data.cst = isl_aff_get_constant_val(aff);
 	for (i = 0; i < 3; ++i) {
 		n = isl_aff_dim(aff, ti);
+		if (n < 0)
+			expr = isl_ast_expr_free(expr);
 		for (j = 0; j < n; ++j) {
 			v = isl_aff_get_coefficient_val(aff, ti, j);
 			if (!v)
@@ -973,12 +1184,11 @@
 				continue;
 			}
 			expr = isl_ast_expr_add_term(expr,
-							ls, li, j, v, build);
+							ls, li, j, v, &data);
 		}
 	}
 
-	v = isl_aff_get_constant_val(aff);
-	expr = isl_ast_expr_add_int(expr, v);
+	expr = isl_ast_expr_add_int(expr, data.cst);
 
 	isl_local_space_free(ls);
 	isl_aff_free(aff);
@@ -987,10 +1197,10 @@
 
 /* Add terms to "expr" for each variable in "aff" with a coefficient
  * with sign equal to "sign".
- * The result is simplified in terms of build->domain.
+ * The result is simplified in terms of data->build->domain.
  */
 static __isl_give isl_ast_expr *add_signed_terms(__isl_take isl_ast_expr *expr,
-	__isl_keep isl_aff *aff, int sign, __isl_keep isl_ast_build *build)
+	__isl_keep isl_aff *aff, int sign, struct isl_ast_add_term_data *data)
 {
 	int i, j;
 	isl_val *v;
@@ -1001,7 +1211,9 @@
 	ls = isl_aff_get_domain_local_space(aff);
 
 	for (i = 0; i < 3; ++i) {
-		int n = isl_aff_dim(aff, ti);
+		isl_size n = isl_aff_dim(aff, ti);
+		if (n < 0)
+			expr = isl_ast_expr_free(expr);
 		for (j = 0; j < n; ++j) {
 			v = isl_aff_get_coefficient_val(aff, ti, j);
 			if (sign * isl_val_sgn(v) <= 0) {
@@ -1010,7 +1222,7 @@
 			}
 			v = isl_val_abs(v);
 			expr = isl_ast_expr_add_term(expr,
-						ls, li, j, v, build);
+						ls, li, j, v, data);
 		}
 	}
 
@@ -1038,21 +1250,163 @@
 	return isl_val_is_pos(v);
 }
 
+/* Check if the equality
+ *
+ *	aff = 0
+ *
+ * represents a stride constraint on the integer division "pos".
+ *
+ * In particular, if the integer division "pos" is equal to
+ *
+ *	floor(e/d)
+ *
+ * then check if aff is equal to
+ *
+ *	e - d floor(e/d)
+ *
+ * or its opposite.
+ *
+ * If so, the equality is exactly
+ *
+ *	e mod d = 0
+ *
+ * Note that in principle we could also accept
+ *
+ *	e - d floor(e'/d)
+ *
+ * where e and e' differ by a constant.
+ */
+static int is_stride_constraint(__isl_keep isl_aff *aff, int pos)
+{
+	isl_aff *div;
+	isl_val *c, *d;
+	int eq;
+
+	div = isl_aff_get_div(aff, pos);
+	c = isl_aff_get_coefficient_val(aff, isl_dim_div, pos);
+	d = isl_aff_get_denominator_val(div);
+	eq = isl_val_abs_eq(c, d);
+	if (eq >= 0 && eq) {
+		aff = isl_aff_copy(aff);
+		aff = isl_aff_set_coefficient_si(aff, isl_dim_div, pos, 0);
+		div = isl_aff_scale_val(div, d);
+		if (isl_val_is_pos(c))
+			div = isl_aff_neg(div);
+		eq = isl_aff_plain_is_equal(div, aff);
+		isl_aff_free(aff);
+	} else
+		isl_val_free(d);
+	isl_val_free(c);
+	isl_aff_free(div);
+
+	return eq;
+}
+
+/* Are all coefficients of "aff" (zero or) negative?
+ */
+static isl_bool all_negative_coefficients(__isl_keep isl_aff *aff)
+{
+	int i;
+	isl_size n;
+
+	n = isl_aff_dim(aff, isl_dim_param);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 0; i < n; ++i)
+		if (isl_aff_coefficient_sgn(aff, isl_dim_param, i) > 0)
+			return isl_bool_false;
+
+	n = isl_aff_dim(aff, isl_dim_in);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 0; i < n; ++i)
+		if (isl_aff_coefficient_sgn(aff, isl_dim_in, i) > 0)
+			return isl_bool_false;
+
+	return isl_bool_true;
+}
+
+/* Give an equality of the form
+ *
+ *	aff = e - d floor(e/d) = 0
+ *
+ * or
+ *
+ *	aff = -e + d floor(e/d) = 0
+ *
+ * with the integer division "pos" equal to floor(e/d),
+ * construct the AST expression
+ *
+ *	(isl_ast_expr_op_eq,
+ *		(isl_ast_expr_op_zdiv_r, expr(e), expr(d)), expr(0))
+ *
+ * If e only has negative coefficients, then construct
+ *
+ *	(isl_ast_expr_op_eq,
+ *		(isl_ast_expr_op_zdiv_r, expr(-e), expr(d)), expr(0))
+ *
+ * instead.
+ */
+static __isl_give isl_ast_expr *extract_stride_constraint(
+	__isl_take isl_aff *aff, int pos, __isl_keep isl_ast_build *build)
+{
+	isl_bool all_neg;
+	isl_ctx *ctx;
+	isl_val *c;
+	isl_ast_expr *expr, *cst;
+
+	if (!aff)
+		return NULL;
+
+	ctx = isl_aff_get_ctx(aff);
+
+	c = isl_aff_get_coefficient_val(aff, isl_dim_div, pos);
+	aff = isl_aff_set_coefficient_si(aff, isl_dim_div, pos, 0);
+
+	all_neg = all_negative_coefficients(aff);
+	if (all_neg < 0)
+		aff = isl_aff_free(aff);
+	else if (all_neg)
+		aff = isl_aff_neg(aff);
+
+	cst = isl_ast_expr_from_val(isl_val_abs(c));
+	expr = isl_ast_expr_from_aff(aff, build);
+
+	expr = isl_ast_expr_alloc_binary(isl_ast_expr_op_zdiv_r, expr, cst);
+	cst = isl_ast_expr_alloc_int_si(ctx, 0);
+	expr = isl_ast_expr_alloc_binary(isl_ast_expr_op_eq, expr, cst);
+
+	return expr;
+}
+
 /* Construct an isl_ast_expr that evaluates the condition "constraint",
  * The result is simplified in terms of build->domain.
  *
- * Let the constraint by either "a >= 0" or "a == 0".
+ * We first check if the constraint is an equality of the form
+ *
+ *	e - d floor(e/d) = 0
+ *
+ * i.e.,
+ *
+ *	e mod d = 0
+ *
+ * If so, we convert it to
+ *
+ *	(isl_ast_expr_op_eq,
+ *		(isl_ast_expr_op_zdiv_r, expr(e), expr(d)), expr(0))
+ *
+ * Otherwise, let the constraint by either "a >= 0" or "a == 0".
  * We first extract hidden modulo computations from "a"
  * and then collect all the terms with a positive coefficient in cons_pos
  * and the terms with a negative coefficient in cons_neg.
  *
  * The result is then of the form
  *
- *	(isl_ast_op_ge, expr(pos), expr(-neg)))
+ *	(isl_ast_expr_op_ge, expr(pos), expr(-neg)))
  *
  * or
  *
- *	(isl_ast_op_eq, expr(pos), expr(-neg)))
+ *	(isl_ast_expr_op_eq, expr(pos), expr(-neg)))
  *
  * However, if the first expression is an integer constant (and the second
  * is not), then we swap the two expressions.  This ensures that we construct,
@@ -1065,51 +1419,71 @@
 static __isl_give isl_ast_expr *isl_ast_expr_from_constraint(
 	__isl_take isl_constraint *constraint, __isl_keep isl_ast_build *build)
 {
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_ast_expr *expr_pos;
 	isl_ast_expr *expr_neg;
 	isl_ast_expr *expr;
 	isl_aff *aff;
-	isl_val *v;
 	int eq;
-	enum isl_ast_op_type type;
+	enum isl_ast_expr_op_type type;
+	struct isl_ast_add_term_data data;
 
 	if (!constraint)
 		return NULL;
 
 	aff = isl_constraint_get_aff(constraint);
+	eq = isl_constraint_is_equality(constraint);
+	isl_constraint_free(constraint);
+
+	n = isl_aff_dim(aff, isl_dim_div);
+	if (n < 0)
+		aff = isl_aff_free(aff);
+	if (eq && n > 0)
+		for (i = 0; i < n; ++i) {
+			int is_stride;
+			is_stride = is_stride_constraint(aff, i);
+			if (is_stride < 0)
+				goto error;
+			if (is_stride)
+				return extract_stride_constraint(aff, i, build);
+		}
 
-	ctx = isl_constraint_get_ctx(constraint);
+	ctx = isl_aff_get_ctx(aff);
 	expr_pos = isl_ast_expr_alloc_int_si(ctx, 0);
 	expr_neg = isl_ast_expr_alloc_int_si(ctx, 0);
 
 	aff = extract_modulos(aff, &expr_pos, &expr_neg, build);
 
-	expr_pos = add_signed_terms(expr_pos, aff, 1, build);
-	expr_neg = add_signed_terms(expr_neg, aff, -1, build);
-
-	v = isl_aff_get_constant_val(aff);
-	if (constant_is_considered_positive(v, expr_pos, expr_neg)) {
-		expr_pos = isl_ast_expr_add_int(expr_pos, v);
+	data.build = build;
+	data.cst = isl_aff_get_constant_val(aff);
+	expr_pos = add_signed_terms(expr_pos, aff, 1, &data);
+	data.cst = isl_val_neg(data.cst);
+	expr_neg = add_signed_terms(expr_neg, aff, -1, &data);
+	data.cst = isl_val_neg(data.cst);
+
+	if (constant_is_considered_positive(data.cst, expr_pos, expr_neg)) {
+		expr_pos = isl_ast_expr_add_int(expr_pos, data.cst);
 	} else {
-		v = isl_val_neg(v);
-		expr_neg = isl_ast_expr_add_int(expr_neg, v);
+		data.cst = isl_val_neg(data.cst);
+		expr_neg = isl_ast_expr_add_int(expr_neg, data.cst);
 	}
 
-	eq = isl_constraint_is_equality(constraint);
-
 	if (isl_ast_expr_get_type(expr_pos) == isl_ast_expr_int &&
 	    isl_ast_expr_get_type(expr_neg) != isl_ast_expr_int) {
-		type = eq ? isl_ast_op_eq : isl_ast_op_le;
+		type = eq ? isl_ast_expr_op_eq : isl_ast_expr_op_le;
 		expr = isl_ast_expr_alloc_binary(type, expr_neg, expr_pos);
 	} else {
-		type = eq ? isl_ast_op_eq : isl_ast_op_ge;
+		type = eq ? isl_ast_expr_op_eq : isl_ast_expr_op_ge;
 		expr = isl_ast_expr_alloc_binary(type, expr_pos, expr_neg);
 	}
 
-	isl_constraint_free(constraint);
 	isl_aff_free(aff);
 	return expr;
+error:
+	isl_aff_free(aff);
+	return NULL;
 }
 
 /* Wrapper around isl_constraint_cmp_last_non_zero for use
@@ -1131,7 +1505,7 @@
 /* Construct an isl_ast_expr that evaluates the conditions defining "bset".
  * The result is simplified in terms of build->domain.
  *
- * If "bset" is not bounded by any constraint, then we contruct
+ * If "bset" is not bounded by any constraint, then we construct
  * the expression "1", i.e., "true".
  *
  * Otherwise, we sort the constraints, putting constraints that involve
@@ -1151,7 +1525,8 @@
 __isl_give isl_ast_expr *isl_ast_build_expr_from_basic_set(
 	 __isl_keep isl_ast_build *build, __isl_take isl_basic_set *bset)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_constraint *c;
 	isl_constraint_list *list;
 	isl_ast_expr *res;
@@ -1160,11 +1535,11 @@
 	list = isl_basic_set_get_constraint_list(bset);
 	isl_basic_set_free(bset);
 	list = isl_constraint_list_sort(list, &cmp_constraint, NULL);
-	if (!list)
-		return NULL;
 	n = isl_constraint_list_n_constraint(list);
+	if (n < 0)
+		build = NULL;
 	if (n == 0) {
-		isl_ctx *ctx = isl_basic_set_get_ctx(bset);
+		isl_ctx *ctx = isl_constraint_list_get_ctx(list);
 		isl_constraint_list_free(list);
 		return isl_ast_expr_alloc_int_si(ctx, 1);
 	}
@@ -1193,116 +1568,703 @@
 	return res;
 }
 
-struct isl_expr_from_set_data {
-	isl_ast_build *build;
-	int first;
-	isl_ast_expr *res;
-};
-
-/* Construct an isl_ast_expr that evaluates the conditions defining "bset"
- * and add it to data->res.
- * The result is simplified in terms of data->build->domain.
+/* Construct an isl_ast_expr that evaluates the conditions defining "set".
+ * The result is simplified in terms of build->domain.
+ *
+ * If "set" is an (obviously) empty set, then return the expression "0".
+ *
+ * If there are multiple disjuncts in the description of the set,
+ * then subsequent disjuncts are simplified in a context where
+ * the previous disjuncts have been removed from build->domain.
+ * In particular, constraints that ensure that there is no overlap
+ * with these previous disjuncts, can be removed.
+ * This is mostly useful for disjuncts that are only defined by
+ * a single constraint (relative to the build domain) as the opposite
+ * of that single constraint can then be removed from the other disjuncts.
+ * In order not to increase the number of disjuncts in the build domain
+ * after subtracting the previous disjuncts of "set", the simple hull
+ * is computed after taking the difference with each of these disjuncts.
+ * This means that constraints that prevent overlap with a union
+ * of multiple previous disjuncts are not removed.
+ *
+ * "set" lives in the internal schedule space.
  */
-static int expr_from_set(__isl_take isl_basic_set *bset, void *user)
+__isl_give isl_ast_expr *isl_ast_build_expr_from_set_internal(
+	__isl_keep isl_ast_build *build, __isl_take isl_set *set)
 {
-	struct isl_expr_from_set_data *data = user;
-	isl_ast_expr *expr;
+	int i;
+	isl_size n;
+	isl_basic_set *bset;
+	isl_basic_set_list *list;
+	isl_set *domain;
+	isl_ast_expr *res;
 
-	expr = isl_ast_build_expr_from_basic_set(data->build, bset);
-	if (data->first)
-		data->res = expr;
-	else
-		data->res = isl_ast_expr_or(data->res, expr);
+	list = isl_set_get_basic_set_list(set);
+	isl_set_free(set);
+
+	n = isl_basic_set_list_n_basic_set(list);
+	if (n < 0)
+		build = NULL;
+	if (n == 0) {
+		isl_ctx *ctx = isl_ast_build_get_ctx(build);
+		isl_basic_set_list_free(list);
+		return isl_ast_expr_from_val(isl_val_zero(ctx));
+	}
 
-	data->first = 0;
+	domain = isl_ast_build_get_domain(build);
 
-	if (!data->res)
-		return -1;
-	return 0;
+	bset = isl_basic_set_list_get_basic_set(list, 0);
+	set = isl_set_from_basic_set(isl_basic_set_copy(bset));
+	res = isl_ast_build_expr_from_basic_set(build, bset);
+
+	for (i = 1; i < n; ++i) {
+		isl_ast_expr *expr;
+		isl_set *rest;
+
+		rest = isl_set_subtract(isl_set_copy(domain), set);
+		rest = isl_set_from_basic_set(isl_set_simple_hull(rest));
+		domain = isl_set_intersect(domain, rest);
+		bset = isl_basic_set_list_get_basic_set(list, i);
+		set = isl_set_from_basic_set(isl_basic_set_copy(bset));
+		bset = isl_basic_set_gist(bset,
+				isl_set_simple_hull(isl_set_copy(domain)));
+		expr = isl_ast_build_expr_from_basic_set(build, bset);
+		res = isl_ast_expr_or(res, expr);
+	}
+
+	isl_set_free(domain);
+	isl_set_free(set);
+	isl_basic_set_list_free(list);
+	return res;
 }
 
 /* Construct an isl_ast_expr that evaluates the conditions defining "set".
  * The result is simplified in terms of build->domain.
  *
  * If "set" is an (obviously) empty set, then return the expression "0".
+ *
+ * "set" lives in the external schedule space.
+ *
+ * The internal AST expression generation assumes that there are
+ * no unknown divs, so make sure an explicit representation is available.
+ * Since the set comes from the outside, it may have constraints that
+ * are redundant with respect to the build domain.  Remove them first.
  */
 __isl_give isl_ast_expr *isl_ast_build_expr_from_set(
 	__isl_keep isl_ast_build *build, __isl_take isl_set *set)
 {
-	struct isl_expr_from_set_data data = { build, 1, NULL };
+	isl_bool needs_map;
 
-	if (isl_set_foreach_basic_set(set, &expr_from_set, &data) < 0)
-		data.res = isl_ast_expr_free(data.res);
-	else if (data.first) {
-		isl_ctx *ctx = isl_ast_build_get_ctx(build);
-		data.res = isl_ast_expr_from_val(isl_val_zero(ctx));
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0) {
+		set = isl_set_free(set);
+	} else if (needs_map) {
+		isl_multi_aff *ma;
+		ma = isl_ast_build_get_schedule_map_multi_aff(build);
+		set = isl_set_preimage_multi_aff(set, ma);
 	}
 
-	isl_set_free(set);
-	return data.res;
+	set = isl_set_compute_divs(set);
+	set = isl_ast_build_compute_gist(build, set);
+	return isl_ast_build_expr_from_set_internal(build, set);
 }
 
+/* State of data about previous pieces in
+ * isl_ast_build_expr_from_pw_aff_internal.
+ *
+ * isl_state_none: no data about previous pieces
+ * isl_state_single: data about a single previous piece
+ * isl_state_min: data represents minimum of several pieces
+ * isl_state_max: data represents maximum of several pieces
+ */
+enum isl_from_pw_aff_state {
+	isl_state_none,
+	isl_state_single,
+	isl_state_min,
+	isl_state_max
+};
+
+/* Internal date structure representing a single piece in the input of
+ * isl_ast_build_expr_from_pw_aff_internal.
+ *
+ * If "state" is isl_state_none, then "set_list" and "aff_list" are not used.
+ * If "state" is isl_state_single, then "set_list" and "aff_list" contain the
+ * single previous subpiece.
+ * If "state" is isl_state_min, then "set_list" and "aff_list" contain
+ * a sequence of several previous subpieces that are equal to the minimum
+ * of the entries in "aff_list" over the union of "set_list"
+ * If "state" is isl_state_max, then "set_list" and "aff_list" contain
+ * a sequence of several previous subpieces that are equal to the maximum
+ * of the entries in "aff_list" over the union of "set_list"
+ *
+ * During the construction of the pieces, "set" is NULL.
+ * After the construction, "set" is set to the union of the elements
+ * in "set_list", at which point "set_list" is set to NULL.
+ */
+struct isl_from_pw_aff_piece {
+	enum isl_from_pw_aff_state state;
+	isl_set *set;
+	isl_set_list *set_list;
+	isl_aff_list *aff_list;
+};
+
+/* Internal data structure for isl_ast_build_expr_from_pw_aff_internal.
+ *
+ * "build" specifies the domain against which the result is simplified.
+ * "dom" is the domain of the entire isl_pw_aff.
+ *
+ * "n" is the number of pieces constructed already.
+ * In particular, during the construction of the pieces, "n" points to
+ * the piece that is being constructed.  After the construction of the
+ * pieces, "n" is set to the total number of pieces.
+ * "max" is the total number of allocated entries.
+ * "p" contains the individual pieces.
+ */
 struct isl_from_pw_aff_data {
 	isl_ast_build *build;
-	int n;
-	isl_ast_expr **next;
 	isl_set *dom;
+
+	int n;
+	int max;
+	struct isl_from_pw_aff_piece *p;
 };
 
-/* This function is called during the construction of an isl_ast_expr
- * that evaluates an isl_pw_aff.
- * Adjust data->next to take into account this piece.
- *
- * data->n is the number of pairs of set and aff to go.
- * data->dom is the domain of the entire isl_pw_aff.
+/* Initialize "data" based on "build" and "pa".
+ */
+static isl_stat isl_from_pw_aff_data_init(struct isl_from_pw_aff_data *data,
+	__isl_keep isl_ast_build *build, __isl_keep isl_pw_aff *pa)
+{
+	isl_size n;
+	isl_ctx *ctx;
+
+	ctx = isl_pw_aff_get_ctx(pa);
+	n = isl_pw_aff_n_piece(pa);
+	if (n < 0)
+		return isl_stat_error;
+	if (n == 0)
+		isl_die(ctx, isl_error_invalid,
+			"cannot handle void expression", return isl_stat_error);
+	data->max = n;
+	data->p = isl_calloc_array(ctx, struct isl_from_pw_aff_piece, n);
+	if (!data->p)
+		return isl_stat_error;
+	data->build = build;
+	data->dom = isl_pw_aff_domain(isl_pw_aff_copy(pa));
+	data->n = 0;
+
+	return isl_stat_ok;
+}
+
+/* Free all memory allocated for "data".
+ */
+static void isl_from_pw_aff_data_clear(struct isl_from_pw_aff_data *data)
+{
+	int i;
+
+	isl_set_free(data->dom);
+	if (!data->p)
+		return;
+
+	for (i = 0; i < data->max; ++i) {
+		isl_set_free(data->pi.set);
+		isl_set_list_free(data->pi.set_list);
+		isl_aff_list_free(data->pi.aff_list);
+	}
+	free(data->p);
+}
+
+/* Initialize the current entry of "data" to an unused piece.
+ */
+static void set_none(struct isl_from_pw_aff_data *data)
+{
+	data->pdata->n.state = isl_state_none;
+	data->pdata->n.set_list = NULL;
+	data->pdata->n.aff_list = NULL;
+}
+
+/* Store "set" and "aff" in the current entry of "data" as a single subpiece.
+ */
+static void set_single(struct isl_from_pw_aff_data *data,
+	__isl_take isl_set *set, __isl_take isl_aff *aff)
+{
+	data->pdata->n.state = isl_state_single;
+	data->pdata->n.set_list = isl_set_list_from_set(set);
+	data->pdata->n.aff_list = isl_aff_list_from_aff(aff);
+}
+
+/* Extend the current entry of "data" with "set" and "aff"
+ * as a minimum expression.
+ */
+static isl_stat extend_min(struct isl_from_pw_aff_data *data,
+	__isl_take isl_set *set, __isl_take isl_aff *aff)
+{
+	int n = data->n;
+	data->pn.state = isl_state_min;
+	data->pn.set_list = isl_set_list_add(data->pn.set_list, set);
+	data->pn.aff_list = isl_aff_list_add(data->pn.aff_list, aff);
+
+	if (!data->pn.set_list || !data->pn.aff_list)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Extend the current entry of "data" with "set" and "aff"
+ * as a maximum expression.
+ */
+static isl_stat extend_max(struct isl_from_pw_aff_data *data,
+	__isl_take isl_set *set, __isl_take isl_aff *aff)
+{
+	int n = data->n;
+	data->pn.state = isl_state_max;
+	data->pn.set_list = isl_set_list_add(data->pn.set_list, set);
+	data->pn.aff_list = isl_aff_list_add(data->pn.aff_list, aff);
+
+	if (!data->pn.set_list || !data->pn.aff_list)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Extend the domain of the current entry of "data", which is assumed
+ * to contain a single subpiece, with "set".  If "replace" is set,
+ * then also replace the affine function by "aff".  Otherwise,
+ * simply free "aff".
+ */
+static isl_stat extend_domain(struct isl_from_pw_aff_data *data,
+	__isl_take isl_set *set, __isl_take isl_aff *aff, int replace)
+{
+	int n = data->n;
+	isl_set *set_n;
+
+	set_n = isl_set_list_get_set(data->pn.set_list, 0);
+	set_n = isl_set_union(set_n, set);
+	data->pn.set_list =
+		isl_set_list_set_set(data->pn.set_list, 0, set_n);
+
+	if (replace)
+		data->pn.aff_list =
+			isl_aff_list_set_aff(data->pn.aff_list, 0, aff);
+	else
+		isl_aff_free(aff);
+
+	if (!data->pn.set_list || !data->pn.aff_list)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Construct an isl_ast_expr from "list" within "build".
+ * If "state" is isl_state_single, then "list" contains a single entry and
+ * an isl_ast_expr is constructed for that entry.
+ * Otherwise a min or max expression is constructed from "list"
+ * depending on "state".
+ */
+static __isl_give isl_ast_expr *ast_expr_from_aff_list(
+	__isl_take isl_aff_list *list, enum isl_from_pw_aff_state state,
+	__isl_keep isl_ast_build *build)
+{
+	int i;
+	isl_size n;
+	isl_aff *aff;
+	isl_ast_expr *expr = NULL;
+	enum isl_ast_expr_op_type op_type;
+
+	if (state == isl_state_single) {
+		aff = isl_aff_list_get_aff(list, 0);
+		isl_aff_list_free(list);
+		return isl_ast_expr_from_aff(aff, build);
+	}
+	n = isl_aff_list_n_aff(list);
+	if (n < 0)
+		goto error;
+	op_type = state == isl_state_min ? isl_ast_expr_op_min
+					 : isl_ast_expr_op_max;
+	expr = isl_ast_expr_alloc_op(isl_ast_build_get_ctx(build), op_type, n);
+	if (!expr)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		isl_ast_expr *expr_i;
+
+		aff = isl_aff_list_get_aff(list, i);
+		expr_i = isl_ast_expr_from_aff(aff, build);
+		if (!expr_i)
+			goto error;
+		expr->u.op.argsi = expr_i;
+	}
+
+	isl_aff_list_free(list);
+	return expr;
+error:
+	isl_aff_list_free(list);
+	isl_ast_expr_free(expr);
+	return NULL;
+}
+
+/* Extend the expression in "next" to take into account
+ * the piece at position "pos" in "data", allowing for a further extension
+ * for the next piece(s).
+ * In particular, "next" is set to a select operation that selects
+ * an isl_ast_expr corresponding to data->aff_list on data->set and
+ * to an expression that will be filled in by later calls.
+ * Return a pointer to this location.
+ * Afterwards, the state of "data" is set to isl_state_none.
  *
- * If this is the last pair, then data->next is set to evaluate aff
+ * The constraints of data->set are added to the generated
+ * constraints of the build such that they can be exploited to simplify
+ * the AST expression constructed from data->aff_list.
+ */
+static isl_ast_expr **add_intermediate_piece(struct isl_from_pw_aff_data *data,
+	int pos, isl_ast_expr **next)
+{
+	isl_ctx *ctx;
+	isl_ast_build *build;
+	isl_ast_expr *ternary, *arg;
+	isl_set *set, *gist;
+
+	set = data->ppos.set;
+	data->ppos.set = NULL;
+	ctx = isl_ast_build_get_ctx(data->build);
+	ternary = isl_ast_expr_alloc_op(ctx, isl_ast_expr_op_select, 3);
+	gist = isl_set_gist(isl_set_copy(set), isl_set_copy(data->dom));
+	arg = isl_ast_build_expr_from_set_internal(data->build, gist);
+	ternary = isl_ast_expr_set_op_arg(ternary, 0, arg);
+	build = isl_ast_build_copy(data->build);
+	build = isl_ast_build_restrict_generated(build, set);
+	arg = ast_expr_from_aff_list(data->ppos.aff_list,
+					data->ppos.state, build);
+	data->ppos.aff_list = NULL;
+	isl_ast_build_free(build);
+	ternary = isl_ast_expr_set_op_arg(ternary, 1, arg);
+	data->ppos.state = isl_state_none;
+	if (!ternary)
+		return NULL;
+
+	*next = ternary;
+	return &ternary->u.op.args2;
+}
+
+/* Extend the expression in "next" to take into account
+ * the final piece, located at position "pos" in "data".
+ * In particular, "next" is set to evaluate data->aff_list
  * and the domain is ignored.
- * Otherwise, data->next is set to a select operation that selects
- * an isl_ast_expr correponding to "aff" on "set" and to an expression
- * that will be filled in by later calls otherwise.
+ * Return isl_stat_ok on success and isl_stat_error on failure.
  *
- * In both cases, the constraints of "set" are added to the generated
+ * The constraints of data->set are however added to the generated
  * constraints of the build such that they can be exploited to simplify
- * the AST expression constructed from "aff".
+ * the AST expression constructed from data->aff_list.
  */
-static int ast_expr_from_pw_aff(__isl_take isl_set *set,
-	__isl_take isl_aff *aff, void *user)
+static isl_stat add_last_piece(struct isl_from_pw_aff_data *data,
+	int pos, isl_ast_expr **next)
 {
-	struct isl_from_pw_aff_data *data = user;
-	isl_ctx *ctx;
 	isl_ast_build *build;
 
-	ctx = isl_set_get_ctx(set);
-	data->n--;
-	if (data->n == 0) {
-		build = isl_ast_build_copy(data->build);
-		build = isl_ast_build_restrict_generated(build, set);
-		*data->next = isl_ast_expr_from_aff(aff, build);
-		isl_ast_build_free(build);
-		if (!*data->next)
-			return -1;
-	} else {
-		isl_ast_expr *ternary, *arg;
-		isl_set *gist;
-
-		ternary = isl_ast_expr_alloc_op(ctx, isl_ast_op_select, 3);
-		gist = isl_set_gist(isl_set_copy(set), isl_set_copy(data->dom));
-		arg = isl_ast_build_expr_from_set(data->build, gist);
-		ternary = isl_ast_expr_set_op_arg(ternary, 0, arg);
-		build = isl_ast_build_copy(data->build);
-		build = isl_ast_build_restrict_generated(build, set);
-		arg = isl_ast_expr_from_aff(aff, build);
-		isl_ast_build_free(build);
-		ternary = isl_ast_expr_set_op_arg(ternary, 1, arg);
-		if (!ternary)
-			return -1;
-
-		*data->next = ternary;
-		data->next = &ternary->u.op.args2;
+	if (data->ppos.state == isl_state_none)
+		isl_die(isl_ast_build_get_ctx(data->build), isl_error_invalid,
+			"cannot handle void expression", return isl_stat_error);
+
+	build = isl_ast_build_copy(data->build);
+	build = isl_ast_build_restrict_generated(build, data->ppos.set);
+	data->ppos.set = NULL;
+	*next = ast_expr_from_aff_list(data->ppos.aff_list,
+						data->ppos.state, build);
+	data->ppos.aff_list = NULL;
+	isl_ast_build_free(build);
+	data->ppos.state = isl_state_none;
+	if (!*next)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Return -1 if the piece "p1" should be sorted before "p2"
+ * and 1 if it should be sorted after "p2".
+ * Return 0 if they do not need to be sorted in a specific order.
+ *
+ * Pieces are sorted according to the number of disjuncts
+ * in their domains.
+ */
+static int sort_pieces_cmp(const void *p1, const void *p2, void *arg)
+{
+	const struct isl_from_pw_aff_piece *piece1 = p1;
+	const struct isl_from_pw_aff_piece *piece2 = p2;
+	isl_size n1, n2;
+
+	n1 = isl_set_n_basic_set(piece1->set);
+	n2 = isl_set_n_basic_set(piece2->set);
+
+	return n1 - n2;
+}
+
+/* Construct an isl_ast_expr from the pieces in "data".
+ * Return the result or NULL on failure.
+ *
+ * When this function is called, data->n points to the current piece.
+ * If this is an effective piece, then first increment data->n such
+ * that data->n contains the number of pieces.
+ * The "set_list" fields are subsequently replaced by the corresponding
+ * "set" fields, after which the pieces are sorted according to
+ * the number of disjuncts in these "set" fields.
+ *
+ * Construct intermediate AST expressions for the initial pieces and
+ * finish off with the final pieces.
+ */
+static isl_ast_expr *build_pieces(struct isl_from_pw_aff_data *data)
+{
+	int i;
+	isl_ast_expr *res = NULL;
+	isl_ast_expr **next = &res;
+
+	if (data->pdata->n.state != isl_state_none)
+		data->n++;
+	if (data->n == 0)
+		isl_die(isl_ast_build_get_ctx(data->build), isl_error_invalid,
+			"cannot handle void expression", return NULL);
+
+	for (i = 0; i < data->n; ++i) {
+		data->pi.set = isl_set_list_union(data->pi.set_list);
+		if (data->pi.state != isl_state_single)
+			data->pi.set = isl_set_coalesce(data->pi.set);
+		data->pi.set_list = NULL;
 	}
 
-	return 0;
+	if (isl_sort(data->p, data->n, sizeof(data->p0),
+			&sort_pieces_cmp, NULL) < 0)
+		return isl_ast_expr_free(res);
+
+	for (i = 0; i + 1 < data->n; ++i) {
+		next = add_intermediate_piece(data, i, next);
+		if (!next)
+			return isl_ast_expr_free(res);
+	}
+
+	if (add_last_piece(data, data->n - 1, next) < 0)
+		return isl_ast_expr_free(res);
+
+	return res;
+}
+
+/* Is the domain of the current entry of "data", which is assumed
+ * to contain a single subpiece, a subset of "set"?
+ */
+static isl_bool single_is_subset(struct isl_from_pw_aff_data *data,
+	__isl_keep isl_set *set)
+{
+	isl_bool subset;
+	isl_set *set_n;
+
+	set_n = isl_set_list_get_set(data->pdata->n.set_list, 0);
+	subset = isl_set_is_subset(set_n, set);
+	isl_set_free(set_n);
+
+	return subset;
+}
+
+/* Is "aff" a rational expression, i.e., does it have a denominator
+ * different from one?
+ */
+static isl_bool aff_is_rational(__isl_keep isl_aff *aff)
+{
+	isl_bool rational;
+	isl_val *den;
+
+	den = isl_aff_get_denominator_val(aff);
+	rational = isl_bool_not(isl_val_is_one(den));
+	isl_val_free(den);
+
+	return rational;
+}
+
+/* Does "list" consist of a single rational affine expression?
+ */
+static isl_bool is_single_rational_aff(__isl_keep isl_aff_list *list)
+{
+	isl_size n;
+	isl_bool rational;
+	isl_aff *aff;
+
+	n = isl_aff_list_n_aff(list);
+	if (n < 0)
+		return isl_bool_error;
+	if (n != 1)
+		return isl_bool_false;
+	aff = isl_aff_list_get_aff(list, 0);
+	rational = aff_is_rational(aff);
+	isl_aff_free(aff);
+
+	return rational;
+}
+
+/* Can the list of subpieces in the last piece of "data" be extended with
+ * "set" and "aff" based on "test"?
+ * In particular, is it the case for each entry (set_i, aff_i) that
+ *
+ *	test(aff, aff_i) holds on set_i, and
+ *	test(aff_i, aff) holds on set?
+ *
+ * "test" returns the set of elements where the tests holds, meaning
+ * that test(aff_i, aff) holds on set if set is a subset of test(aff_i, aff).
+ *
+ * This function is used to detect min/max expressions.
+ * If the ast_build_detect_min_max option is turned off, then
+ * do not even try and perform any detection and return false instead.
+ *
+ * Rational affine expressions are not considered for min/max expressions
+ * since the combined expression will be defined on the union of the domains,
+ * while a rational expression may only yield integer values
+ * on its own definition domain.
+ */
+static isl_bool extends(struct isl_from_pw_aff_data *data,
+	__isl_keep isl_set *set, __isl_keep isl_aff *aff,
+	__isl_give isl_basic_set *(*test)(__isl_take isl_aff *aff1,
+		__isl_take isl_aff *aff2))
+{
+	int i;
+	isl_size n;
+	isl_bool is_rational;
+	isl_ctx *ctx;
+	isl_set *dom;
+
+	is_rational = aff_is_rational(aff);
+	if (is_rational >= 0 && !is_rational)
+		is_rational = is_single_rational_aff(data->pdata->n.aff_list);
+	if (is_rational < 0 || is_rational)
+		return isl_bool_not(is_rational);
+
+	ctx = isl_ast_build_get_ctx(data->build);
+	if (!isl_options_get_ast_build_detect_min_max(ctx))
+		return isl_bool_false;
+
+	n = isl_set_list_n_set(data->pdata->n.set_list);
+	if (n < 0)
+		return isl_bool_error;
+
+	dom = isl_ast_build_get_domain(data->build);
+	set = isl_set_intersect(dom, isl_set_copy(set));
+
+	for (i = 0; i < n ; ++i) {
+		isl_aff *aff_i;
+		isl_set *valid;
+		isl_set *dom, *required;
+		isl_bool is_valid;
+
+		aff_i = isl_aff_list_get_aff(data->pdata->n.aff_list, i);
+		valid = isl_set_from_basic_set(test(isl_aff_copy(aff), aff_i));
+		required = isl_set_list_get_set(data->pdata->n.set_list, i);
+		dom = isl_ast_build_get_domain(data->build);
+		required = isl_set_intersect(dom, required);
+		is_valid = isl_set_is_subset(required, valid);
+		isl_set_free(required);
+		isl_set_free(valid);
+		if (is_valid < 0 || !is_valid) {
+			isl_set_free(set);
+			return is_valid;
+		}
+
+		aff_i = isl_aff_list_get_aff(data->pdata->n.aff_list, i);
+		valid = isl_set_from_basic_set(test(aff_i, isl_aff_copy(aff)));
+		is_valid = isl_set_is_subset(set, valid);
+		isl_set_free(valid);
+		if (is_valid < 0 || !is_valid) {
+			isl_set_free(set);
+			return is_valid;
+		}
+	}
+
+	isl_set_free(set);
+	return isl_bool_true;
+}
+
+/* Can the list of pieces in "data" be extended with "set" and "aff"
+ * to form/preserve a minimum expression?
+ * In particular, is it the case for each entry (set_i, aff_i) that
+ *
+ *	aff >= aff_i on set_i, and
+ *	aff_i >= aff on set?
+ */
+static isl_bool extends_min(struct isl_from_pw_aff_data *data,
+	__isl_keep isl_set *set,  __isl_keep isl_aff *aff)
+{
+	return extends(data, set, aff, &isl_aff_ge_basic_set);
+}
+
+/* Can the list of pieces in "data" be extended with "set" and "aff"
+ * to form/preserve a maximum expression?
+ * In particular, is it the case for each entry (set_i, aff_i) that
+ *
+ *	aff <= aff_i on set_i, and
+ *	aff_i <= aff on set?
+ */
+static isl_bool extends_max(struct isl_from_pw_aff_data *data,
+	__isl_keep isl_set *set,  __isl_keep isl_aff *aff)
+{
+	return extends(data, set, aff, &isl_aff_le_basic_set);
+}
+
+/* This function is called during the construction of an isl_ast_expr
+ * that evaluates an isl_pw_aff.
+ * If the last piece of "data" contains a single subpiece and
+ * if its affine function is equal to "aff" on a part of the domain
+ * that includes either "set" or the domain of that single subpiece,
+ * then extend the domain of that single subpiece with "set".
+ * If it was the original domain of the single subpiece where
+ * the two affine functions are equal, then also replace
+ * the affine function of the single subpiece by "aff".
+ * If the last piece of "data" contains either a single subpiece
+ * or a minimum, then check if this minimum expression can be extended
+ * with (set, aff).
+ * If so, extend the sequence and return.
+ * Perform the same operation for maximum expressions.
+ * If no such extension can be performed, then move to the next piece
+ * in "data" (if the current piece contains any data), and then store
+ * the current subpiece in the current piece of "data" for later handling.
+ */
+static isl_stat ast_expr_from_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_aff *aff, void *user)
+{
+	struct isl_from_pw_aff_data *data = user;
+	isl_bool test;
+	enum isl_from_pw_aff_state state;
+
+	state = data->pdata->n.state;
+	if (state == isl_state_single) {
+		isl_aff *aff0;
+		isl_set *eq;
+		isl_bool subset1, subset2 = isl_bool_false;
+		aff0 = isl_aff_list_get_aff(data->pdata->n.aff_list, 0);
+		eq = isl_aff_eq_set(isl_aff_copy(aff), aff0);
+		subset1 = isl_set_is_subset(set, eq);
+		if (subset1 >= 0 && !subset1)
+			subset2 = single_is_subset(data, eq);
+		isl_set_free(eq);
+		if (subset1 < 0 || subset2 < 0)
+			goto error;
+		if (subset1)
+			return extend_domain(data, set, aff, 0);
+		if (subset2)
+			return extend_domain(data, set, aff, 1);
+	}
+	if (state == isl_state_single || state == isl_state_min) {
+		test = extends_min(data, set, aff);
+		if (test < 0)
+			goto error;
+		if (test)
+			return extend_min(data, set, aff);
+	}
+	if (state == isl_state_single || state == isl_state_max) {
+		test = extends_max(data, set, aff);
+		if (test < 0)
+			goto error;
+		if (test)
+			return extend_max(data, set, aff);
+	}
+	if (state != isl_state_none)
+		data->n++;
+	set_single(data, set, aff);
+
+	return isl_stat_ok;
+error:
+	isl_set_free(set);
+	isl_aff_free(aff);
+	return isl_stat_error;
 }
 
 /* Construct an isl_ast_expr that evaluates "pa".
@@ -1313,7 +2275,7 @@
 __isl_give isl_ast_expr *isl_ast_build_expr_from_pw_aff_internal(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_aff *pa)
 {
-	struct isl_from_pw_aff_data data;
+	struct isl_from_pw_aff_data data = { NULL };
 	isl_ast_expr *res = NULL;
 
 	pa = isl_ast_build_compute_gist_pw_aff(build, pa);
@@ -1321,20 +2283,20 @@
 	if (!pa)
 		return NULL;
 
-	data.build = build;
-	data.n = isl_pw_aff_n_piece(pa);
-	data.next = &res;
-	data.dom = isl_pw_aff_domain(isl_pw_aff_copy(pa));
+	if (isl_from_pw_aff_data_init(&data, build, pa) < 0)
+		goto error;
+	set_none(&data);
 
-	if (isl_pw_aff_foreach_piece(pa, &ast_expr_from_pw_aff, &data) < 0)
-		res = isl_ast_expr_free(res);
-	else if (!res)
-		isl_die(isl_pw_aff_get_ctx(pa), isl_error_invalid,
-			"cannot handle void expression", res = NULL);
+	if (isl_pw_aff_foreach_piece(pa, &ast_expr_from_pw_aff, &data) >= 0)
+		res = build_pieces(&data);
 
 	isl_pw_aff_free(pa);
-	isl_set_free(data.dom);
+	isl_from_pw_aff_data_clear(&data);
 	return res;
+error:
+	isl_pw_aff_free(pa);
+	isl_from_pw_aff_data_clear(&data);
+	return NULL;
 }
 
 /* Construct an isl_ast_expr that evaluates "pa".
@@ -1346,8 +2308,12 @@
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_aff *pa)
 {
 	isl_ast_expr *expr;
+	isl_bool needs_map;
 
-	if (isl_ast_build_need_schedule_map(build)) {
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0) {
+		pa = isl_pw_aff_free(pa);
+	} else if (needs_map) {
 		isl_multi_aff *ma;
 		ma = isl_ast_build_get_schedule_map_multi_aff(build);
 		pa = isl_pw_aff_pullback_multi_aff(pa, ma);
@@ -1364,9 +2330,12 @@
 static __isl_give isl_multi_pw_aff *set_iterator_names(
 	__isl_keep isl_ast_build *build, __isl_take isl_multi_pw_aff *mpa)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
 	n = isl_multi_pw_aff_dim(mpa, isl_dim_in);
+	if (n < 0)
+		return isl_multi_pw_aff_free(mpa);
 	for (i = 0; i < n; ++i) {
 		isl_id *id;
 
@@ -1383,17 +2352,18 @@
  * with arguments/indices specified by "mpa".
  */
 static __isl_give isl_ast_expr *isl_ast_build_with_arguments(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_ast_expr *arg0, __isl_take isl_multi_pw_aff *mpa)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_ast_expr *expr;
 
 	ctx = isl_ast_build_get_ctx(build);
 
 	n = isl_multi_pw_aff_dim(mpa, isl_dim_out);
-	expr = isl_ast_expr_alloc_op(ctx, type, 1 + n);
+	expr = n >= 0 ? isl_ast_expr_alloc_op(ctx, type, 1 + n) : NULL;
 	expr = isl_ast_expr_set_op_arg(expr, 0, arg0);
 	for (i = 0; i < n; ++i) {
 		isl_pw_aff *pa;
@@ -1409,7 +2379,7 @@
 }
 
 static __isl_give isl_ast_expr *isl_ast_build_from_multi_pw_aff_internal(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_multi_pw_aff *mpa);
 
 /* Construct an isl_ast_expr that accesses the member specified by "mpa".
@@ -1426,7 +2396,7 @@
 	isl_id *id;
 	isl_multi_pw_aff *domain;
 	isl_ast_expr *domain_expr, *expr;
-	enum isl_ast_op_type type = isl_ast_op_access;
+	enum isl_ast_expr_op_type type = isl_ast_expr_op_access;
 
 	domain = isl_multi_pw_aff_copy(mpa);
 	domain = isl_multi_pw_aff_range_factor_domain(domain);
@@ -1438,7 +2408,8 @@
 			"missing field name", goto error);
 	id = isl_multi_pw_aff_get_tuple_id(mpa, isl_dim_out);
 	expr = isl_ast_expr_from_id(id);
-	expr = isl_ast_expr_alloc_binary(isl_ast_op_member, domain_expr, expr);
+	expr = isl_ast_expr_alloc_binary(isl_ast_expr_op_member,
+					domain_expr, expr);
 	return isl_ast_build_with_arguments(build, type, expr, mpa);
 error:
 	isl_multi_pw_aff_free(mpa);
@@ -1456,7 +2427,7 @@
  * The domain of "mpa" is assumed to live in the internal schedule domain.
  */
 static __isl_give isl_ast_expr *isl_ast_build_from_multi_pw_aff_internal(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_multi_pw_aff *mpa)
 {
 	isl_ctx *ctx;
@@ -1466,7 +2437,7 @@
 	if (!mpa)
 		goto error;
 
-	if (type == isl_ast_op_access &&
+	if (type == isl_ast_expr_op_access &&
 	    isl_multi_pw_aff_range_is_wrapping(mpa))
 		return isl_ast_build_from_multi_pw_aff_member(build, mpa);
 
@@ -1496,7 +2467,7 @@
  * The domain of "pma" is assumed to live in the internal schedule domain.
  */
 static __isl_give isl_ast_expr *isl_ast_build_from_pw_multi_aff_internal(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_pw_multi_aff *pma)
 {
 	isl_multi_pw_aff *mpa;
@@ -1513,10 +2484,11 @@
  * The domain of "mpa" is assumed to live in the external schedule domain.
  */
 static __isl_give isl_ast_expr *isl_ast_build_from_multi_pw_aff(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_multi_pw_aff *mpa)
 {
-	int is_domain;
+	isl_bool is_domain;
+	isl_bool needs_map;
 	isl_ast_expr *expr;
 	isl_space *space_build, *space_mpa;
 
@@ -1532,7 +2504,10 @@
 		isl_die(isl_ast_build_get_ctx(build), isl_error_invalid,
 			"spaces don't match", goto error);
 
-	if (isl_ast_build_need_schedule_map(build)) {
+	needs_map = isl_ast_build_need_schedule_map(build);
+	if (needs_map < 0)
+		goto error;
+	if (needs_map) {
 		isl_multi_aff *ma;
 		ma = isl_ast_build_get_schedule_map_multi_aff(build);
 		mpa = isl_multi_pw_aff_pullback_multi_aff(mpa, ma);
@@ -1554,7 +2529,8 @@
 __isl_give isl_ast_expr *isl_ast_build_call_from_multi_pw_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_multi_pw_aff *mpa)
 {
-	return isl_ast_build_from_multi_pw_aff(build, isl_ast_op_call, mpa);
+	return isl_ast_build_from_multi_pw_aff(build,
+						isl_ast_expr_op_call, mpa);
 }
 
 /* Construct an isl_ast_expr that accesses the array element specified by "mpa".
@@ -1566,7 +2542,8 @@
 __isl_give isl_ast_expr *isl_ast_build_access_from_multi_pw_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_multi_pw_aff *mpa)
 {
-	return isl_ast_build_from_multi_pw_aff(build, isl_ast_op_access, mpa);
+	return isl_ast_build_from_multi_pw_aff(build,
+						isl_ast_expr_op_access, mpa);
 }
 
 /* Construct an isl_ast_expr of type "type" that calls or accesses
@@ -1577,7 +2554,7 @@
  * The domain of "pma" is assumed to live in the external schedule domain.
  */
 static __isl_give isl_ast_expr *isl_ast_build_from_pw_multi_aff(
-	__isl_keep isl_ast_build *build, enum isl_ast_op_type type,
+	__isl_keep isl_ast_build *build, enum isl_ast_expr_op_type type,
 	__isl_take isl_pw_multi_aff *pma)
 {
 	isl_multi_pw_aff *mpa;
@@ -1595,7 +2572,8 @@
 __isl_give isl_ast_expr *isl_ast_build_call_from_pw_multi_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_multi_aff *pma)
 {
-	return isl_ast_build_from_pw_multi_aff(build, isl_ast_op_call, pma);
+	return isl_ast_build_from_pw_multi_aff(build,
+						isl_ast_expr_op_call, pma);
 }
 
 /* Construct an isl_ast_expr that accesses the array element specified by "pma".
@@ -1607,7 +2585,8 @@
 __isl_give isl_ast_expr *isl_ast_build_access_from_pw_multi_aff(
 	__isl_keep isl_ast_build *build, __isl_take isl_pw_multi_aff *pma)
 {
-	return isl_ast_build_from_pw_multi_aff(build, isl_ast_op_access, pma);
+	return isl_ast_build_from_pw_multi_aff(build,
+						isl_ast_expr_op_access, pma);
 }
 
 /* Construct an isl_ast_expr that calls the domain element
@@ -1626,7 +2605,7 @@
 	iteration = isl_ast_build_compute_gist_pw_multi_aff(build, iteration);
 	iteration = isl_pw_multi_aff_intersect_domain(iteration,
 					isl_ast_build_get_domain(build));
-	expr = isl_ast_build_from_pw_multi_aff_internal(build, isl_ast_op_call,
-							iteration);
+	expr = isl_ast_build_from_pw_multi_aff_internal(build,
+					isl_ast_expr_op_call, iteration);
 	return isl_ast_node_alloc_user(expr);
 }

_service:tar_scm:isl-0.14.tar.xz/isl_ast_build_expr.h -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_build_expr.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_ast_build_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_build_private.h Changed

@@ -6,12 +6,7 @@
 #include <isl/ast_build.h>
 #include <isl/set.h>
 #include <isl/list.h>
-
-enum isl_ast_build_domain_type {
-	atomic,
-	unroll,
-	separate
-};
+#include <isl/schedule_node.h>
 
 /* An isl_ast_build represents the context in which AST is being
  * generated.  That is, it (mostly) contains information about outer
@@ -55,7 +50,7 @@
  *
  * "strides" contains the stride of each loop.  The number of elements
  * is equal to the number of dimensions in "domain".
- * "offsets" constains the offsets of strided loops.  If s is the stride
+ * "offsets" contains the offsets of strided loops.  If s is the stride
  * for a given dimension and f is the corresponding offset, then the
  * dimension takes on values
  *
@@ -89,6 +84,17 @@
  * domain.  It may be NULL if it hasn't been computed yet.
  * See isl_ast_build_get_schedule_map_multi_aff.
  *
+ * "internal2input" maps the internal schedule domain to the original
+ * input schedule domain.  In case of a schedule tree input, the original
+ * input schedule domain consist of the flat product of all outer
+ * band node spaces, including the current band node.
+ * It may be NULL if there no longer is such a uniform mapping
+ * (because different iterations have been rescheduled differently).
+ *
+ * "options" contains the AST build options in case we are generating
+ * an AST from a flat schedule map.  When creating an AST from a schedule
+ * tree, this field is ignored.
+ *
  * The "create_leaf" callback is called for every leaf in the generated AST.
  * The callback is responsible for creating the node to be placed at those
  * leaves.  If this callback is not set, then isl will generated user
@@ -104,6 +110,12 @@
  * The "after_each_for" callback is called on each for node after
  * its children have been created.
  *
+ * The "before_each_mark" callback is called before we handle the subtree
+ * of an isl_schedule_node_mark node.
+ *
+ * The "after_each_mark" callback is called after we have handled the subtree
+ * of an isl_schedule_node_mark node.
+ *
  * "executed" contains the inverse schedule at this point
  * of the AST generation.
  * It is currently only used in isl_ast_build_get_schedule, which is
@@ -116,6 +128,19 @@
  * is extended to a single valued inverse schedule.  This is mainly used
  * to avoid an infinite recursion when we fail to detect later on that
  * the extended inverse schedule is single valued.
+ *
+ * "node" points to the current band node in case we are generating
+ * an AST from a schedule tree.  It may be NULL if we are not generating
+ * an AST from a schedule tree or if we are not inside a band node.
+ *
+ * "loop_type" originally contains loop AST generation types for
+ * the "n" members of "node" and it is updated (along with "n") when
+ * a schedule dimension is inserted.
+ * It is NULL if "node" is NULL.
+ *
+ * "isolated" is the piece of the schedule domain isolated by the isolate
+ * option on the current band.  This set may be NULL if we have not checked
+ * for the isolate option yet.
  */
 struct isl_ast_build {
 	int ref;
@@ -136,6 +161,7 @@
 	isl_multi_aff *offsets;
 
 	isl_multi_aff *schedule_map;
+	isl_multi_aff *internal2input;
 
 	isl_union_map *options;
 
@@ -152,12 +178,25 @@
 		__isl_keep isl_ast_build *context, void *user);
 	void *after_each_for_user;
 
+	isl_stat (*before_each_mark)(__isl_keep isl_id *mark,
+		__isl_keep isl_ast_build *build, void *user);
+	void *before_each_mark_user;
+	__isl_give isl_ast_node *(*after_each_mark)(
+		__isl_take isl_ast_node *node,
+		__isl_keep isl_ast_build *context, void *user);
+	void *after_each_mark_user;
+
 	__isl_give isl_ast_node *(*create_leaf)(
 		__isl_take isl_ast_build *build, void *user);
 	void *create_leaf_user;
 
 	isl_union_map *executed;
 	int single_valued;
+
+	isl_schedule_node *node;
+	int n;
+	enum isl_ast_loop_type *loop_type;
+	isl_set *isolated;
 };
 
 __isl_give isl_ast_build *isl_ast_build_clear_local_info(
@@ -165,7 +204,7 @@
 __isl_give isl_ast_build *isl_ast_build_increase_depth(
 	__isl_take isl_ast_build *build);
 int isl_ast_build_get_depth(__isl_keep isl_ast_build *build);
-unsigned isl_ast_build_dim(__isl_keep isl_ast_build *build,
+isl_size isl_ast_build_dim(__isl_keep isl_ast_build *build,
 	enum isl_dim_type type);
 __isl_give isl_space *isl_ast_build_get_space(
 	__isl_keep isl_ast_build *build, int internal);
@@ -182,6 +221,8 @@
 	__isl_take isl_ast_build *build, __isl_take isl_space *embedding);
 __isl_give isl_ast_build *isl_ast_build_set_loop_bounds(
 	__isl_take isl_ast_build *build, __isl_take isl_basic_set *bounds);
+__isl_give isl_ast_build *isl_ast_build_set_pending_generated(
+	__isl_take isl_ast_build *build, __isl_take isl_basic_set *bounds);
 __isl_give isl_ast_build *isl_ast_build_detect_strides(
 	__isl_take isl_ast_build *build, __isl_take isl_set *set);
 __isl_give isl_ast_build *isl_ast_build_include_stride(
@@ -191,6 +232,8 @@
 	__isl_take isl_union_map *executed);
 __isl_give isl_ast_build *isl_ast_build_set_single_valued(
 	__isl_take isl_ast_build *build, int sv);
+__isl_give isl_multi_aff *isl_ast_build_get_internal2input(
+	__isl_keep isl_ast_build *build);
 __isl_give isl_set *isl_ast_build_get_domain(
 	__isl_keep isl_ast_build *build);
 __isl_give isl_set *isl_ast_build_get_pending(
@@ -201,19 +244,34 @@
 	__isl_take isl_ast_build *build, __isl_take isl_set *set);
 __isl_give isl_ast_build *isl_ast_build_replace_pending_by_guard(
 	__isl_take isl_ast_build *build, __isl_take isl_set *guard);
-__isl_give isl_ast_build *isl_ast_build_restrict_pending(
-	__isl_take isl_ast_build *build, __isl_take isl_set *set);
-__isl_give int isl_ast_build_need_schedule_map(
-	__isl_keep isl_ast_build *build);
+isl_bool isl_ast_build_need_schedule_map(__isl_keep isl_ast_build *build);
 __isl_give isl_multi_aff *isl_ast_build_get_schedule_map_multi_aff(
 	__isl_keep isl_ast_build *build);
 __isl_give isl_map *isl_ast_build_get_schedule_map(
 	__isl_keep isl_ast_build *build);
-int isl_ast_build_has_affine_value(__isl_keep isl_ast_build *build, int pos);
+isl_bool isl_ast_build_has_affine_value(__isl_keep isl_ast_build *build,
+	int pos);
 int isl_ast_build_has_value(__isl_keep isl_ast_build *build);
 __isl_give isl_id *isl_ast_build_get_iterator_id(
 	__isl_keep isl_ast_build *build, int pos);
 
+int isl_ast_build_has_schedule_node(__isl_keep isl_ast_build *build);
+__isl_give isl_schedule_node *isl_ast_build_get_schedule_node(
+	__isl_keep isl_ast_build *build);
+__isl_give isl_ast_build *isl_ast_build_set_schedule_node(
+	__isl_take isl_ast_build *build,
+	__isl_take isl_schedule_node *node);
+__isl_give isl_ast_build *isl_ast_build_reset_schedule_node(
+	__isl_take isl_ast_build *build);
+
+__isl_give isl_ast_build *isl_ast_build_extract_isolated(
+	__isl_take isl_ast_build *build);
+int isl_ast_build_has_isolated(__isl_keep isl_ast_build *build);
+__isl_give isl_set *isl_ast_build_get_isolated(
+	__isl_keep isl_ast_build *build);
+
+__isl_give isl_basic_set *isl_ast_build_specialize_basic_set(
+	__isl_keep isl_ast_build *build, __isl_take isl_basic_set *bset);
 __isl_give isl_basic_set *isl_ast_build_compute_gist_basic_set(
 	__isl_keep isl_ast_build *build, __isl_take isl_basic_set *bset);
 __isl_give isl_set *isl_ast_build_specialize(__isl_keep isl_ast_build *build,
@@ -235,7 +293,7 @@
 int isl_ast_build_aff_is_nonneg(__isl_keep isl_ast_build *build,
 	__isl_keep isl_aff *aff);
 
-int isl_ast_build_has_stride(__isl_keep isl_ast_build *build, int pos);
+isl_bool isl_ast_build_has_stride(__isl_keep isl_ast_build *build, int pos);
 __isl_give isl_aff *isl_ast_build_get_offset(__isl_keep isl_ast_build *build,
 	int pos);
 __isl_give isl_val *isl_ast_build_get_stride(__isl_keep isl_ast_build *build,
@@ -248,8 +306,7 @@
 void isl_ast_build_dump(__isl_keep isl_ast_build *build);
 
 __isl_give isl_set *isl_ast_build_get_option_domain(
-	__isl_keep isl_ast_build *build,
-	enum isl_ast_build_domain_type type);
+	__isl_keep isl_ast_build *build, enum isl_ast_loop_type type);
 __isl_give isl_map *isl_ast_build_get_separation_class(
 	__isl_keep isl_ast_build *build);
 __isl_give isl_set *isl_ast_build_eliminate(
@@ -259,6 +316,9 @@
 __isl_give isl_set *isl_ast_build_eliminate_divs(
 	__isl_keep isl_ast_build *build, __isl_take isl_set *set);
 
+enum isl_ast_loop_type isl_ast_build_get_loop_type(
+	__isl_keep isl_ast_build *build, int isolated);
+
 __isl_give isl_map *isl_ast_build_map_to_iterator(
 	__isl_keep isl_ast_build *build, __isl_take isl_set *set);

_service:tar_scm:isl-0.14.tar.xz/isl_ast_codegen.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_codegen.c Changed

@@ -11,10 +11,17 @@
  */
 
 #include <limits.h>
+#include <isl/id.h>
+#include <isl/val.h>
+#include <isl/space.h>
 #include <isl/aff.h>
+#include <isl/constraint.h>
 #include <isl/set.h>
 #include <isl/ilp.h>
+#include <isl/union_set.h>
 #include <isl/union_map.h>
+#include <isl/schedule_node.h>
+#include <isl/options.h>
 #include <isl_sort.h>
 #include <isl_tarjan.h>
 #include <isl_ast_private.h>
@@ -22,6 +29,25 @@
 #include <isl_ast_build_private.h>
 #include <isl_ast_graft_private.h>
 
+/* Try and reduce the number of disjuncts in the representation of "set",
+ * without dropping explicit representations of local variables.
+ */
+static __isl_give isl_set *isl_set_coalesce_preserve(__isl_take isl_set *set)
+{
+	isl_ctx *ctx;
+	int save_preserve;
+
+	if (!set)
+		return NULL;
+
+	ctx = isl_set_get_ctx(set);
+	save_preserve = isl_options_get_coalesce_preserve_locals(ctx);
+	isl_options_set_coalesce_preserve_locals(ctx, 1);
+	set = isl_set_coalesce(set);
+	isl_options_set_coalesce_preserve_locals(ctx, save_preserve);
+	return set;
+}
+
 /* Data used in generate_domain.
  *
  * "build" is the input build.
@@ -59,7 +85,7 @@
  * but will instead create calls to all elements of D that need
  * to be executed from the current schedule domain.
  */
-static int generate_non_single_valued(__isl_take isl_map *executed,
+static isl_stat generate_non_single_valued(__isl_take isl_map *executed,
 	struct isl_generate_domain_data *data)
 {
 	isl_map *identity;
@@ -76,7 +102,7 @@
 
 	data->list = isl_ast_graft_list_concat(data->list, list);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Call the at_each_domain callback, if requested by the user,
@@ -106,6 +132,54 @@
 	return graft;
 }
 
+/* Generate a call expression for the single executed
+ * domain element "map" and put a guard around it based its (simplified)
+ * domain.  "executed" is the original inverse schedule from which "map"
+ * has been derived.  In particular, "map" is either identical to "executed"
+ * or it is the result of gisting "executed" with respect to the build domain.
+ * "executed" is only used if there is an at_each_domain callback.
+ *
+ * At this stage, any pending constraints in the build can no longer
+ * be simplified with respect to any enforced constraints since
+ * the call node does not have any enforced constraints.
+ * Since all pending constraints not covered by any enforced constraints
+ * will be added as a guard to the graft in create_node_scaled,
+ * even in the eliminated case, the pending constraints
+ * can be considered to have been generated by outer constructs.
+ *
+ * If the user has set an at_each_domain callback, it is called
+ * on the constructed call expression node.
+ */
+static isl_stat add_domain(__isl_take isl_map *executed,
+	__isl_take isl_map *map, struct isl_generate_domain_data *data)
+{
+	isl_ast_build *build;
+	isl_ast_graft *graft;
+	isl_ast_graft_list *list;
+	isl_set *guard, *pending;
+
+	build = isl_ast_build_copy(data->build);
+	pending = isl_ast_build_get_pending(build);
+	build = isl_ast_build_replace_pending_by_guard(build, pending);
+
+	guard = isl_map_domain(isl_map_copy(map));
+	guard = isl_set_compute_divs(guard);
+	guard = isl_set_coalesce_preserve(guard);
+	guard = isl_set_gist(guard, isl_ast_build_get_generated(build));
+	guard = isl_ast_build_specialize(build, guard);
+
+	graft = isl_ast_graft_alloc_domain(map, build);
+	graft = at_each_domain(graft, executed, build);
+	isl_ast_build_free(build);
+	isl_map_free(executed);
+	graft = isl_ast_graft_add_guard(graft, guard, data->build);
+
+	list = isl_ast_graft_list_from_ast_graft(graft);
+	data->list = isl_ast_graft_list_concat(data->list, list);
+
+	return isl_stat_ok;
+}
+
 /* Generate an AST for a single domain based on
  * the inverse schedule "executed" and add it to data->list.
  *
@@ -124,7 +198,11 @@
  * On the other hand, we only perform the test after having taken the gist
  * of the domain as the resulting map is the one from which the call
  * expression is constructed.  Using this map to construct the call
- * expression usually yields simpler results.
+ * expression usually yields simpler results in cases where the original
+ * map is not obviously single-valued.
+ * If the original map is obviously single-valued, then the gist
+ * operation is skipped.
+ *
  * Because we perform the single-valuedness test on the gisted map,
  * we may in rare cases fail to recognize that the inverse schedule
  * is single-valued.  This becomes problematic if this happens
@@ -134,29 +212,13 @@
  * and revert to the ungisted map if the gisted map turns out not to be
  * single-valued.
  *
- * Otherwise, we generate a call expression for the single executed
- * domain element and put a guard around it based on the (simplified)
- * domain of "executed".
- *
- * At this stage, any pending constraints in the build can no longer
- * be simplified with respect to any enforced constraints since
- * the call node does not have any enforced constraints.
- * We therefore turn all pending constraints into guards
- * (after simplifying them with respect to the already generated
- * constraints) and add them to both the generated constraints
- * and the guard of the constructed graft.  This guard will ensure
- * that the constraints are effectively generated.
- *
- * If the user has set an at_each_domain callback, it is called
- * on the constructed call expression node.
+ * Otherwise, call add_domain to generate a call expression (with guard) and
+ * to call the at_each_domain callback, if any.
  */
-static int generate_domain(__isl_take isl_map *executed, void *user)
+static isl_stat generate_domain(__isl_take isl_map *executed, void *user)
 {
 	struct isl_generate_domain_data *data = user;
-	isl_ast_build *build;
-	isl_ast_graft *graft;
-	isl_ast_graft_list *list;
-	isl_set *guard, *domain;
+	isl_set *domain;
 	isl_map *map = NULL;
 	int empty, sv;
 
@@ -168,9 +230,15 @@
 		goto error;
 	if (empty) {
 		isl_map_free(executed);
-		return 0;
+		return isl_stat_ok;
 	}
 
+	sv = isl_map_plain_is_single_valued(executed);
+	if (sv < 0)
+		goto error;
+	if (sv)
+		return add_domain(executed, isl_map_copy(executed), data);
+
 	executed = isl_map_coalesce(executed);
 	map = isl_map_copy(executed);
 	map = isl_ast_build_compute_gist_map_domain(data->build, map);
@@ -184,31 +252,12 @@
 		else
 			return generate_non_single_valued(executed, data);
 	}
-	guard = isl_map_domain(isl_map_copy(map));
-	guard = isl_set_compute_divs(guard);
-	guard = isl_set_intersect(guard,
-				    isl_ast_build_get_pending(data->build));
-	guard = isl_set_coalesce(guard);
-	guard = isl_ast_build_specialize(data->build, guard);
-	guard = isl_set_gist(guard, isl_ast_build_get_generated(data->build));
 
-	build = isl_ast_build_copy(data->build);
-	build = isl_ast_build_replace_pending_by_guard(build,
-							isl_set_copy(guard));
-	graft = isl_ast_graft_alloc_domain(map, build);
-	graft = at_each_domain(graft, executed, build);
-	isl_ast_build_free(build);
-	isl_map_free(executed);
-	graft = isl_ast_graft_add_guard(graft, guard, data->build);
-
-	list = isl_ast_graft_list_from_ast_graft(graft);
-	data->list = isl_ast_graft_list_concat(data->list, list);
-
-	return 0;
+	return add_domain(executed, map, data);
 error:
 	isl_map_free(map);
 	isl_map_free(executed);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Call build->create_leaf to a create "leaf" node in the AST,
@@ -251,8 +300,15 @@
 	return isl_ast_graft_list_from_ast_graft(graft);
 }
 
+static __isl_give isl_ast_graft_list *build_ast_from_child(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed);
+
 /* Generate an AST after having handled the complete schedule
- * of this call to the code generator.
+ * of this call to the code generator or the complete band
+ * if we are generating an AST from a schedule tree.
+ *
+ * If we are inside a band node, then move on to the child of the band.
  *
  * If the user has specified a create_leaf callback, control
  * is passed to the user in call_create_leaf.
@@ -269,6 +325,13 @@
 	if (!build || !executed)
 		goto error;
 
+	if (isl_ast_build_has_schedule_node(build)) {
+		isl_schedule_node *node;
+		node = isl_ast_build_get_schedule_node(build);
+		build = isl_ast_build_reset_schedule_node(build);
+		return build_ast_from_child(build, node, executed);
+	}
+
 	if (build->create_leaf)
 		return call_create_leaf(executed, build);
 
@@ -466,14 +529,15 @@
 static __isl_give isl_pw_aff_list *remove_redundant_lower_bounds(
 	__isl_take isl_pw_aff_list *list, __isl_keep isl_ast_build *build)
 {
-	int i, j, n;
+	int i, j;
+	isl_size n;
 	isl_set *domain;
 
 	list = isl_pw_aff_list_sort(list, &reduce_list_cmp, NULL);
-	if (!list)
-		return NULL;
 
 	n = isl_pw_aff_list_n_pw_aff(list);
+	if (n < 0)
+		return isl_pw_aff_list_free(list);
 	if (n <= 1)
 		return list;
 
@@ -537,12 +601,15 @@
 {
 	isl_ctx *ctx;
 	isl_pw_aff_list *list;
-	int i, n;
+	int i;
+	isl_size n;
 
 	if (!build)
 		return NULL;
 
 	n = isl_constraint_list_n_constraint(constraints);
+	if (n < 0)
+		return NULL;
 	if (n == 0) {
 		isl_pw_aff *pa;
 		pa = exact_bound(domain, build, 0);
@@ -579,9 +646,12 @@
 {
 	isl_ctx *ctx;
 	isl_pw_aff_list *list;
-	int i, n;
+	int i;
+	isl_size n;
 
 	n = isl_constraint_list_n_constraint(constraints);
+	if (n < 0)
+		return NULL;
 	if (n == 0) {
 		isl_pw_aff *pa;
 		pa = exact_bound(domain, build, 1);
@@ -612,19 +682,19 @@
  * If the list contains exactly one element, then the returned isl_ast_expr
  * simply computes that affine expression.
  * If the list contains more than one element, then we sort it
- * using a fairly abitrary but hopefully reasonably stable order.
+ * using a fairly arbitrary but hopefully reasonably stable order.
  */
-static __isl_give isl_ast_expr *reduce_list(enum isl_ast_op_type type,
+static __isl_give isl_ast_expr *reduce_list(enum isl_ast_expr_op_type type,
 	__isl_keep isl_pw_aff_list *list, __isl_keep isl_ast_build *build)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_ast_expr *expr;
 
-	if (!list)
-		return NULL;
-
 	n = isl_pw_aff_list_n_pw_aff(list);
+	if (n < 0)
+		return NULL;
 
 	if (n == 1)
 		return isl_ast_build_expr_from_pw_aff_internal(build,
@@ -665,36 +735,43 @@
  * If we have generated a degenerate loop, then add the guard
  * implied by "bounds" on the outer dimensions, i.e., the guard
  * that ensures that the single value actually exists.
+ * Since there may also be guards implied by a combination
+ * of these constraints, we first combine them before
+ * deriving the implied constraints.
  */
 static __isl_give isl_set *add_implied_guards(__isl_take isl_set *guard,
 	int degenerate, __isl_keep isl_basic_set *bounds,
 	__isl_keep isl_ast_build *build)
 {
 	int depth, has_stride;
-	isl_set *dom;
+	isl_space *space;
+	isl_set *dom, *set;
 
 	depth = isl_ast_build_get_depth(build);
 	has_stride = isl_ast_build_has_stride(build, depth);
 	if (!has_stride && !degenerate)
 		return guard;
 
+	space = isl_basic_set_get_space(bounds);
+	dom = isl_set_universe(space);
+
 	if (degenerate) {
 		bounds = isl_basic_set_copy(bounds);
 		bounds = isl_basic_set_drop_constraints_not_involving_dims(
 					bounds, isl_dim_set, depth, 1);
-		dom = isl_set_from_basic_set(bounds);
-		dom = isl_set_eliminate(dom, isl_dim_set, depth, 1);
-		dom = isl_ast_build_compute_gist(build, dom);
-		guard = isl_set_intersect(guard, dom);
+		set = isl_set_from_basic_set(bounds);
+		dom = isl_set_intersect(dom, set);
 	}
 
 	if (has_stride) {
-		dom = isl_ast_build_get_stride_constraint(build);
-		dom = isl_set_eliminate(dom, isl_dim_set, depth, 1);
-		dom = isl_ast_build_compute_gist(build, dom);
-		guard = isl_set_intersect(guard, dom);
+		set = isl_ast_build_get_stride_constraint(build);
+		dom = isl_set_intersect(dom, set);
 	}
 
+	dom = isl_set_eliminate(dom, isl_dim_set, depth, 1);
+	dom = isl_ast_build_compute_gist(build, dom);
+	guard = isl_set_intersect(guard, dom);
+
 	return guard;
 }
 
@@ -733,10 +810,13 @@
 static __isl_give isl_set *intersect_constraints(
 	__isl_keep isl_constraint_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_basic_set *bset;
 
 	n = isl_constraint_list_n_constraint(list);
+	if (n < 0)
+		return NULL;
 	if (n < 1)
 		isl_die(isl_constraint_list_get_ctx(list), isl_error_internal,
 			"expecting at least one constraint", return NULL);
@@ -789,9 +869,11 @@
 	isl_space *space;
 	isl_basic_set *enforced;
 	isl_pw_multi_aff *pma;
-	int i, n;
+	int i;
+	isl_size n;
 
-	if (!graft || !lower)
+	n = isl_pw_aff_list_n_pw_aff(lower);
+	if (!graft || n < 0)
 		return isl_ast_graft_free(graft);
 
 	space = isl_set_get_space(upper);
@@ -800,7 +882,6 @@
 	space = isl_space_map_from_set(space);
 	pma = isl_pw_multi_aff_identity(space);
 
-	n = isl_pw_aff_list_n_pw_aff(lower);
 	for (i = 0; i < n; ++i) {
 		isl_pw_aff *pa;
 		isl_set *enforced_i;
@@ -850,48 +931,32 @@
 
 /* Does "aff" have a negative constant term?
  */
-static int aff_constant_is_negative(__isl_take isl_set *set,
-	__isl_take isl_aff *aff, void *user)
+static isl_bool aff_constant_is_negative(__isl_keep isl_set *set,
+	__isl_keep isl_aff *aff, void *user)
 {
-	int *neg = user;
+	isl_bool is_neg;
 	isl_val *v;
 
 	v = isl_aff_get_constant_val(aff);
-	*neg = isl_val_is_neg(v);
+	is_neg = isl_val_is_neg(v);
 	isl_val_free(v);
-	isl_set_free(set);
-	isl_aff_free(aff);
 
-	return *neg ? 0 : -1;
+	return is_neg;
 }
 
 /* Does "pa" have a negative constant term over its entire domain?
  */
-static int pw_aff_constant_is_negative(__isl_take isl_pw_aff *pa, void *user)
+static isl_bool pw_aff_constant_is_negative(__isl_keep isl_pw_aff *pa,
+	void *user)
 {
-	int r;
-	int *neg = user;
-
-	r = isl_pw_aff_foreach_piece(pa, &aff_constant_is_negative, user);
-	isl_pw_aff_free(pa);
-
-	return *neg ? 0 : -1;
+	return isl_pw_aff_every_piece(pa, &aff_constant_is_negative, NULL);
 }
 
 /* Does each element in "list" have a negative constant term?
- *
- * The callback terminates the iteration as soon an element has been
- * found that does not have a negative constant term.
  */
 static int list_constant_is_negative(__isl_keep isl_pw_aff_list *list)
 {
-	int neg = 1;
-
-	if (isl_pw_aff_list_foreach(list,
-				&pw_aff_constant_is_negative, &neg) < 0 && neg)
-		return -1;
-
-	return neg;
+	return isl_pw_aff_list_every(list, &pw_aff_constant_is_negative, NULL);
 }
 
 /* Add 1 to each of the elements in "list", where each of these elements
@@ -900,17 +965,21 @@
 static __isl_give isl_pw_aff_list *list_add_one(
 	__isl_take isl_pw_aff_list *list, __isl_keep isl_ast_build *build)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_space *space;
 	isl_aff *aff;
 	isl_pw_aff *one;
 
+	n = isl_pw_aff_list_n_pw_aff(list);
+	if (n < 0)
+		return isl_pw_aff_list_free(list);
+
 	space = isl_ast_build_get_space(build, 1);
 	aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
 	aff = isl_aff_add_constant_si(aff, 1);
 	one = isl_pw_aff_from_aff(aff);
 
-	n = isl_pw_aff_list_n_pw_aff(list);
 	for (i = 0; i < n; ++i) {
 		isl_pw_aff *pa;
 		pa = isl_pw_aff_list_get_pw_aff(list, i);
@@ -942,7 +1011,7 @@
 {
 	int neg;
 	isl_ast_expr *bound, *iterator, *cond;
-	enum isl_ast_op_type type = isl_ast_op_le;
+	enum isl_ast_expr_op_type type = isl_ast_expr_op_le;
 
 	if (!graft || !list)
 		return isl_ast_graft_free(graft);
@@ -953,10 +1022,10 @@
 	list = isl_pw_aff_list_copy(list);
 	if (neg) {
 		list = list_add_one(list, build);
-		type = isl_ast_op_lt;
+		type = isl_ast_expr_op_lt;
 	}
 
-	bound = reduce_list(isl_ast_op_min, list, build);
+	bound = reduce_list(isl_ast_expr_op_min, list, build);
 	iterator = isl_ast_expr_copy(graft->node->u.f.iterator);
 	cond = isl_ast_expr_alloc_binary(type, iterator, bound);
 	graft->node->u.f.cond = cond;
@@ -979,7 +1048,7 @@
 	if (!graft)
 		return NULL;
 
-	cond = isl_ast_build_expr_from_set(build, isl_set_copy(set));
+	cond = isl_ast_build_expr_from_set_internal(build, isl_set_copy(set));
 	graft->node->u.f.cond = cond;
 	if (!graft->node->u.f.cond)
 		return isl_ast_graft_free(graft);
@@ -1056,9 +1125,12 @@
 	build = isl_ast_build_copy(build);
 
 	node = graft->node;
-	node->u.f.init = reduce_list(isl_ast_op_max, lower, build);
+	node->u.f.init = reduce_list(isl_ast_expr_op_max, lower, build);
 	node->u.f.inc = for_inc(build);
 
+	if (!node->u.f.init || !node->u.f.inc)
+		graft = isl_ast_graft_free(graft);
+
 	if (use_list)
 		graft = set_for_cond_from_list(graft, upper_list, build);
 	else
@@ -1066,10 +1138,6 @@
 
 	isl_ast_build_free(build);
 
-	if (!node->u.f.iterator || !node->u.f.init ||
-	    !node->u.f.cond || !node->u.f.inc)
-		return isl_ast_graft_free(graft);
-
 	return graft;
 }
 
@@ -1116,7 +1184,7 @@
 	int use_list;
 	isl_set *upper_set = NULL;
 	isl_pw_aff_list *upper_list = NULL;
-	int n_lower, n_upper;
+	isl_size n_lower, n_upper;
 
 	if (!graft || !c_lower || !c_upper || !build)
 		goto error;
@@ -1126,6 +1194,8 @@
 
 	n_lower = isl_constraint_list_n_constraint(c_lower);
 	n_upper = isl_constraint_list_n_constraint(c_upper);
+	if (n_lower < 0 || n_upper < 0)
+		goto error;
 
 	use_list = use_upper_bound_list(ctx, n_upper, domain, depth);
 
@@ -1177,7 +1247,7 @@
  * on whether "c" is independenct of dimensions data->pos,
  * a lower bound or an upper bound.
  */
-static int count_constraints(__isl_take isl_constraint *c, void *user)
+static isl_stat count_constraints(__isl_take isl_constraint *c, void *user)
 {
 	struct isl_ast_count_constraints_data *data = user;
 
@@ -1190,7 +1260,7 @@
 
 	isl_constraint_free(c);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Update "graft" based on "bounds" and "domain" for the generic,
@@ -1406,7 +1476,9 @@
 	__isl_take isl_ast_build *build)
 {
 	int depth;
-	int degenerate, eliminated;
+	int degenerate;
+	isl_bool eliminated;
+	isl_size n;
 	isl_basic_set *hull;
 	isl_basic_set *enforced;
 	isl_set *guard, *hoisted;
@@ -1424,12 +1496,18 @@
 
 	depth = isl_ast_build_get_depth(build);
 	sub_build = isl_ast_build_copy(build);
+	bounds = isl_basic_set_remove_redundancies(bounds);
+	bounds = isl_ast_build_specialize_basic_set(sub_build, bounds);
 	sub_build = isl_ast_build_set_loop_bounds(sub_build,
 						isl_basic_set_copy(bounds));
 	degenerate = isl_ast_build_has_value(sub_build);
 	eliminated = isl_ast_build_has_affine_value(sub_build, depth);
 	if (degenerate < 0 || eliminated < 0)
 		executed = isl_union_map_free(executed);
+	if (!degenerate)
+		bounds = isl_ast_build_compute_gist_basic_set(build, bounds);
+	sub_build = isl_ast_build_set_pending_generated(sub_build,
+						isl_basic_set_copy(bounds));
 	if (eliminated)
 		executed = plug_in_values(executed, sub_build);
 	else
@@ -1445,7 +1523,10 @@
 	enforced = extract_shared_enforced(children, build);
 	guard = extract_pending(sub_build, enforced);
 	hoisted = isl_ast_graft_list_extract_hoistable_guard(children, build);
-	if (isl_set_n_basic_set(hoisted) > 1)
+	n = isl_set_n_basic_set(hoisted);
+	if (n < 0)
+		children = isl_ast_graft_list_free(children);
+	if (n > 1)
 		children = isl_ast_graft_list_gist_guards(children,
 						    isl_set_copy(hoisted));
 	guard = isl_set_intersect(guard, hoisted);
@@ -1455,8 +1536,6 @@
 	graft = isl_ast_graft_alloc_from_children(children,
 			    isl_set_copy(guard), enforced, build, sub_build);
 
-	if (!degenerate)
-		bounds = isl_ast_build_compute_gist_basic_set(build, bounds);
 	if (!eliminated) {
 		isl_ast_build *for_build;
 
@@ -1500,20 +1579,24 @@
  * reducing data->m if needed.
  * Break out of the iteration if data->m has become equal to "1".
  */
-static int constraint_check_scaled(__isl_take isl_constraint *c, void *user)
+static isl_stat constraint_check_scaled(__isl_take isl_constraint *c,
+	void *user)
 {
 	struct isl_check_scaled_data *data = user;
-	int i, j, n;
+	int i, j;
+	isl_size n;
 	enum isl_dim_type t = { isl_dim_param, isl_dim_in, isl_dim_out,
 				    isl_dim_div };
 
 	if (!isl_constraint_involves_dims(c, isl_dim_in, data->depth, 1)) {
 		isl_constraint_free(c);
-		return 0;
+		return isl_stat_ok;
 	}
 
 	for (i = 0; i < 4; ++i) {
 		n = isl_constraint_dim(c, ti);
+		if (n < 0)
+			break;
 		for (j = 0; j < n; ++j) {
 			isl_val *d;
 
@@ -1532,7 +1615,7 @@
 
 	isl_constraint_free(c);
 
-	return i < 4 ? -1 : 0;
+	return i < 4 ? isl_stat_error : isl_stat_ok;
 }
 
 /* For each constraint of "bmap" that involves the input dimension data->depth,
@@ -1540,9 +1623,10 @@
  * reducing data->m if needed.
  * Break out of the iteration if data->m has become equal to "1".
  */
-static int basic_map_check_scaled(__isl_take isl_basic_map *bmap, void *user)
+static isl_stat basic_map_check_scaled(__isl_take isl_basic_map *bmap,
+	void *user)
 {
-	int r;
+	isl_stat r;
 
 	r = isl_basic_map_foreach_constraint(bmap,
 						&constraint_check_scaled, user);
@@ -1556,9 +1640,9 @@
  * reducing data->m if needed.
  * Break out of the iteration if data->m has become equal to "1".
  */
-static int map_check_scaled(__isl_take isl_map *map, void *user)
+static isl_stat map_check_scaled(__isl_take isl_map *map, void *user)
 {
-	int r;
+	isl_stat r;
 
 	r = isl_map_foreach_basic_map(map, &basic_map_check_scaled, user);
 	isl_map_free(map);
@@ -1679,13 +1763,13 @@
 
 /* Add the basic set to the list that "user" points to.
  */
-static int collect_basic_set(__isl_take isl_basic_set *bset, void *user)
+static isl_stat collect_basic_set(__isl_take isl_basic_set *bset, void *user)
 {
 	isl_basic_set_list **list = user;
 
 	*list = isl_basic_set_list_add(*list, bset);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Extract the basic sets of "set" and collect them in an isl_basic_set_list.
@@ -1693,16 +1777,18 @@
 static __isl_give isl_basic_set_list *isl_basic_set_list_from_set(
 	__isl_take isl_set *set)
 {
-	int n;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_basic_set_list *list;
 
+	n = isl_set_n_basic_set(set);
+	if (n < 0)
+		set = isl_set_free(set);
 	if (!set)
 		return NULL;
 
 	ctx = isl_set_get_ctx(set);
 
-	n = isl_set_n_basic_set(set);
 	list = isl_basic_set_list_alloc(ctx, n);
 	if (isl_set_foreach_basic_set(set, &collect_basic_set, &list) < 0)
 		list = isl_basic_set_list_free(list);
@@ -1774,12 +1860,12 @@
 /* Does any element of i follow or coincide with any element of j
  * at the current depth for equal values of the outer dimensions?
  */
-static int domain_follows_at_depth(__isl_keep isl_basic_set *i,
+static isl_bool domain_follows_at_depth(__isl_keep isl_basic_set *i,
 	__isl_keep isl_basic_set *j, void *user)
 {
 	int depth = *(int *) user;
 	isl_basic_map *test;
-	int empty;
+	isl_bool empty;
 	int l;
 
 	test = isl_basic_map_from_domain_and_range(isl_basic_set_copy(i),
@@ -1792,7 +1878,7 @@
 	empty = isl_basic_map_is_empty(test);
 	isl_basic_map_free(test);
 
-	return empty < 0 ? -1 : !empty;
+	return isl_bool_not(empty);
 }
 
 /* Split up each element of "list" into a part that is related to "bset"
@@ -1803,15 +1889,16 @@
 	__isl_take isl_basic_set_list *list, __isl_take isl_basic_set *bset,
 	__isl_keep isl_basic_map *gt)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_basic_set_list *res;
 
-	if (!list)
+	n = isl_basic_set_list_n_basic_set(list);
+	if (n < 0)
 		bset = isl_basic_set_free(bset);
 
 	gt = isl_basic_map_copy(gt);
 	gt = isl_basic_map_intersect_domain(gt, isl_basic_set_copy(bset));
-	n = isl_basic_set_list_n_basic_set(list);
 	res = isl_basic_set_list_from_basic_set(bset);
 	for (i = 0; res && i < n; ++i) {
 		isl_basic_set *bset;
@@ -1896,23 +1983,26 @@
  * this property to avoid running into an infinite recursion in case
  * they intersect due to some internal error.
  */
-static int add_nodes(__isl_take isl_basic_set_list *scc, void *user)
+static isl_stat add_nodes(__isl_take isl_basic_set_list *scc, void *user)
 {
 	struct isl_add_nodes_data *data = user;
-	int i, n, depth;
+	int i, depth;
+	isl_size n;
 	isl_basic_set *bset, *first;
 	isl_basic_set_list *list;
 	isl_space *space;
 	isl_basic_map *gt;
 
 	n = isl_basic_set_list_n_basic_set(scc);
+	if (n < 0)
+		goto error;
 	bset = isl_basic_set_list_get_basic_set(scc, 0);
 	if (n == 1) {
 		isl_basic_set_list_free(scc);
 		data->list = add_node(data->list,
 				isl_union_map_copy(data->executed), bset,
 				isl_ast_build_copy(data->build));
-		return data->list ? 0 : -1;
+		return data->list ? isl_stat_ok : isl_stat_error;
 	}
 
 	depth = isl_ast_build_get_depth(data->build);
@@ -1949,7 +2039,10 @@
 		    generate_sorted_domains(scc, data->executed, data->build));
 	isl_basic_set_list_free(scc);
 
-	return data->list ? 0 : -1;
+	return data->list ? isl_stat_ok : isl_stat_error;
+error:
+	isl_basic_set_list_free(scc);
+	return isl_stat_error;
 }
 
 /* Sort the domains in "domain_list" according to the execution order
@@ -1972,13 +2065,13 @@
 	isl_ctx *ctx;
 	struct isl_add_nodes_data data;
 	int depth;
-	int n;
+	isl_size n;
 
-	if (!domain_list)
+	n = isl_basic_set_list_n_basic_set(domain_list);
+	if (n < 0)
 		return NULL;
 
 	ctx = isl_basic_set_list_get_ctx(domain_list);
-	n = isl_basic_set_list_n_basic_set(domain_list);
 	data.list = isl_ast_graft_list_alloc(ctx, n);
 	if (n == 0)
 		return data.list;
@@ -2000,12 +2093,12 @@
 
 /* Do i and j share any values for the outer dimensions?
  */
-static int shared_outer(__isl_keep isl_basic_set *i,
+static isl_bool shared_outer(__isl_keep isl_basic_set *i,
 	__isl_keep isl_basic_set *j, void *user)
 {
 	int depth = *(int *) user;
 	isl_basic_map *test;
-	int empty;
+	isl_bool empty;
 	int l;
 
 	test = isl_basic_map_from_domain_and_range(isl_basic_set_copy(i),
@@ -2016,7 +2109,7 @@
 	empty = isl_basic_map_is_empty(test);
 	isl_basic_map_free(test);
 
-	return empty < 0 ? -1 : !empty;
+	return isl_bool_not(empty);
 }
 
 /* Internal data structure for generate_sorted_domains_wrap.
@@ -2030,7 +2123,7 @@
  * "list" collects the results.
  */
 struct isl_ast_generate_parallel_domains_data {
-	int n;
+	isl_size n;
 	isl_union_map *executed;
 	isl_ast_build *build;
 
@@ -2047,14 +2140,18 @@
  * then data->single is set to 1 and the result of generate_sorted_domains
  * is not fused.
  */
-static int generate_sorted_domains_wrap(__isl_take isl_basic_set_list *scc,
+static isl_stat generate_sorted_domains_wrap(__isl_take isl_basic_set_list *scc,
 	void *user)
 {
 	struct isl_ast_generate_parallel_domains_data *data = user;
 	isl_ast_graft_list *list;
+	isl_size n;
 
+	n = isl_basic_set_list_n_basic_set(scc);
+	if (n < 0)
+		scc = isl_basic_set_list_free(scc);
 	list = generate_sorted_domains(scc, data->executed, data->build);
-	data->single = isl_basic_set_list_n_basic_set(scc) == data->n;
+	data->single = n == data->n;
 	if (!data->single)
 		list = isl_ast_graft_list_fuse(list, data->build);
 	if (!data->list)
@@ -2064,9 +2161,9 @@
 
 	isl_basic_set_list_free(scc);
 	if (!data->list)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Look for any (weakly connected) components in the "domain_list"
@@ -2092,10 +2189,10 @@
 	int depth;
 	struct isl_ast_generate_parallel_domains_data data;
 
-	if (!domain_list)
+	data.n = isl_basic_set_list_n_basic_set(domain_list);
+	if (data.n < 0)
 		return NULL;
 
-	data.n = isl_basic_set_list_n_basic_set(domain_list);
 	if (data.n <= 1)
 		return generate_sorted_domains(domain_list, executed, build);
 
@@ -2155,9 +2252,12 @@
 	__isl_keep isl_ast_build *build)
 {
 	isl_set *domain;
-	int depth, dim;
+	int depth;
+	isl_size dim;
 
 	dim = isl_map_dim(map, isl_dim_out);
+	if (dim < 0)
+		return isl_map_domain(isl_map_free(map));
 	map = isl_map_drop_constraints_involving_dims(map, isl_dim_out, 0, dim);
 
 	domain = isl_map_domain(map);
@@ -2178,7 +2278,7 @@
  * and then add that part of the range of "map" that does not intersect
  * with data->domain.
  */
-static int separate_domain(__isl_take isl_map *map, void *user)
+static isl_stat separate_domain(__isl_take isl_map *map, void *user)
 {
 	struct isl_separate_domain_data *data = user;
 	isl_set *domain;
@@ -2197,7 +2297,7 @@
 	data->domain = isl_set_union(data->domain, d1);
 	data->domain = isl_set_union(data->domain, d2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Separate the schedule domains of "executed".
@@ -2228,22 +2328,143 @@
 
 /* Temporary data used during the search for a lower bound for unrolling.
  *
+ * "build" is the build in which the unrolling will be performed
  * "domain" is the original set for which to find a lower bound
  * "depth" is the dimension for which to find a lower boudn
+ * "expansion" is the expansion that needs to be applied to "domain"
+ * in the unrolling that will be performed
  *
  * "lower" is the best lower bound found so far.  It is NULL if we have not
  * found any yet.
  * "n" is the corresponding size.  If lower is NULL, then the value of n
  * is undefined.
+ * "n_div" is the maximal number of integer divisions in the first
+ * unrolled iteration (after expansion).  It is set to -1 if it hasn't
+ * been computed yet.
  */
 struct isl_find_unroll_data {
+	isl_ast_build *build;
 	isl_set *domain;
 	int depth;
+	isl_basic_map *expansion;
 
 	isl_aff *lower;
 	int *n;
+	int n_div;
 };
 
+/* Return the constraint
+ *
+ *	i_"depth" = aff + offset
+ */
+static __isl_give isl_constraint *at_offset(int depth, __isl_keep isl_aff *aff,
+	int offset)
+{
+	aff = isl_aff_copy(aff);
+	aff = isl_aff_add_coefficient_si(aff, isl_dim_in, depth, -1);
+	aff = isl_aff_add_constant_si(aff, offset);
+	return isl_equality_from_aff(aff);
+}
+
+/* Update *user to the number of integer divisions in the first element
+ * of "ma", if it is larger than the current value.
+ */
+static isl_stat update_n_div(__isl_take isl_set *set,
+	__isl_take isl_multi_aff *ma, void *user)
+{
+	isl_aff *aff;
+	int *n = user;
+	isl_size n_div;
+
+	aff = isl_multi_aff_get_aff(ma, 0);
+	n_div = isl_aff_dim(aff, isl_dim_div);
+	isl_aff_free(aff);
+	isl_multi_aff_free(ma);
+	isl_set_free(set);
+
+	if (n_div > *n)
+		*n = n_div;
+
+	return n_div >= 0 ? isl_stat_ok : isl_stat_error;
+}
+
+/* Get the number of integer divisions in the expression for the iterator
+ * value at the first slice in the unrolling based on lower bound "lower",
+ * taking into account the expansion that needs to be performed on this slice.
+ */
+static int get_expanded_n_div(struct isl_find_unroll_data *data,
+	__isl_keep isl_aff *lower)
+{
+	isl_constraint *c;
+	isl_set *set;
+	isl_map *it_map, *expansion;
+	isl_pw_multi_aff *pma;
+	int n;
+
+	c = at_offset(data->depth, lower, 0);
+	set = isl_set_copy(data->domain);
+	set = isl_set_add_constraint(set, c);
+	expansion = isl_map_from_basic_map(isl_basic_map_copy(data->expansion));
+	set = isl_set_apply(set, expansion);
+	it_map = isl_ast_build_map_to_iterator(data->build, set);
+	pma = isl_pw_multi_aff_from_map(it_map);
+	n = 0;
+	if (isl_pw_multi_aff_foreach_piece(pma, &update_n_div, &n) < 0)
+		n = -1;
+	isl_pw_multi_aff_free(pma);
+
+	return n;
+}
+
+/* Is the lower bound "lower" with corresponding iteration count "n"
+ * better than the one stored in "data"?
+ * If there is no upper bound on the iteration count ("n" is infinity) or
+ * if the count is too large, then we cannot use this lower bound.
+ * Otherwise, if there was no previous lower bound or
+ * if the iteration count of the new lower bound is smaller than
+ * the iteration count of the previous lower bound, then we consider
+ * the new lower bound to be better.
+ * If the iteration count is the same, then compare the number
+ * of integer divisions that would be needed to express
+ * the iterator value at the first slice in the unrolling
+ * according to the lower bound.  If we end up computing this
+ * number, then store the lowest value in data->n_div.
+ */
+static int is_better_lower_bound(struct isl_find_unroll_data *data,
+	__isl_keep isl_aff *lower, __isl_keep isl_val *n)
+{
+	int cmp;
+	int n_div;
+
+	if (!n)
+		return -1;
+	if (isl_val_is_infty(n))
+		return 0;
+	if (isl_val_cmp_si(n, INT_MAX) > 0)
+		return 0;
+	if (!data->lower)
+		return 1;
+	cmp = isl_val_cmp_si(n, *data->n);
+	if (cmp < 0)
+		return 1;
+	if (cmp > 0)
+		return 0;
+	if (data->n_div < 0)
+		data->n_div = get_expanded_n_div(data, data->lower);
+	if (data->n_div < 0)
+		return -1;
+	if (data->n_div == 0)
+		return 0;
+	n_div = get_expanded_n_div(data, lower);
+	if (n_div < 0)
+		return -1;
+	if (n_div >= data->n_div)
+		return 0;
+	data->n_div = n_div;
+
+	return 1;
+}
+
 /* Check if we can use "c" as a lower bound and if it is better than
  * any previously found lower bound.
  *
@@ -2267,17 +2488,18 @@
  *
  * meaning that we can use ceil(f(j)/a)) as a lower bound for unrolling.
  * We just need to check if we have found any lower bound before and
- * if the new lower bound is better (smaller n) than the previously found
- * lower bounds.
+ * if the new lower bound is better (smaller n or fewer integer divisions)
+ * than the previously found lower bounds.
  */
-static int update_unrolling_lower_bound(struct isl_find_unroll_data *data,
+static isl_stat update_unrolling_lower_bound(struct isl_find_unroll_data *data,
 	__isl_keep isl_constraint *c)
 {
 	isl_aff *aff, *lower;
 	isl_val *max;
+	int better;
 
 	if (!isl_constraint_is_lower_bound(c, isl_dim_set, data->depth))
-		return 0;
+		return isl_stat_ok;
 
 	lower = isl_constraint_get_bound(c, isl_dim_set, data->depth);
 	lower = isl_aff_ceil(lower);
@@ -2288,36 +2510,28 @@
 	max = isl_set_max_val(data->domain, aff);
 	isl_aff_free(aff);
 
-	if (!max)
-		goto error;
-	if (isl_val_is_infty(max)) {
+	better = is_better_lower_bound(data, lower, max);
+	if (better < 0 || !better) {
 		isl_val_free(max);
 		isl_aff_free(lower);
-		return 0;
+		return better < 0 ? isl_stat_error : isl_stat_ok;
 	}
 
-	if (isl_val_cmp_si(max, INT_MAX) <= 0 &&
-	    (!data->lower || isl_val_cmp_si(max, *data->n) < 0)) {
-		isl_aff_free(data->lower);
-		data->lower = lower;
-		*data->n = isl_val_get_num_si(max);
-	} else
-		isl_aff_free(lower);
+	isl_aff_free(data->lower);
+	data->lower = lower;
+	*data->n = isl_val_get_num_si(max);
 	isl_val_free(max);
 
-	return 1;
-error:
-	isl_aff_free(lower);
-	return -1;
+	return isl_stat_ok;
 }
 
 /* Check if we can use "c" as a lower bound and if it is better than
  * any previously found lower bound.
  */
-static int constraint_find_unroll(__isl_take isl_constraint *c, void *user)
+static isl_stat constraint_find_unroll(__isl_take isl_constraint *c, void *user)
 {
 	struct isl_find_unroll_data *data;
-	int r;
+	isl_stat r;
 
 	data = (struct isl_find_unroll_data *) user;
 	r = update_unrolling_lower_bound(data, c);
@@ -2334,6 +2548,9 @@
  * where d is "depth" and l(i) depends only on earlier dimensions.
  * Furthermore, try and find a lower bound such that n is as small as possible.
  * In particular, "n" needs to be finite.
+ * "build" is the build in which the unrolling will be performed.
+ * "expansion" is the expansion that needs to be applied to "domain"
+ * in the unrolling that will be performed.
  *
  * Inner dimensions have been eliminated from "domain" by the caller.
  *
@@ -2347,10 +2564,12 @@
  * If we cannot find a suitable lower bound, then we consider that
  * to be an error.
  */
-static __isl_give isl_aff *find_unroll_lower_bound(__isl_keep isl_set *domain,
-	int depth, int *n)
+static __isl_give isl_aff *find_unroll_lower_bound(
+	__isl_keep isl_ast_build *build, __isl_keep isl_set *domain,
+	int depth, __isl_keep isl_basic_map *expansion, int *n)
 {
-	struct isl_find_unroll_data data = { domain, depth, NULL, n };
+	struct isl_find_unroll_data data =
+			{ build, domain, depth, expansion, NULL, n, -1 };
 	isl_basic_set *hull;
 
 	hull = isl_set_simple_hull(isl_set_copy(domain));
@@ -2371,56 +2590,10 @@
 	return isl_aff_free(data.lower);
 }
 
-/* Return the constraint
- *
- *	i_"depth" = aff + offset
- */
-static __isl_give isl_constraint *at_offset(int depth, __isl_keep isl_aff *aff,
-	int offset)
-{
-	aff = isl_aff_copy(aff);
-	aff = isl_aff_add_coefficient_si(aff, isl_dim_in, depth, -1);
-	aff = isl_aff_add_constant_si(aff, offset);
-	return isl_equality_from_aff(aff);
-}
-
-/* Data structure for storing the results and the intermediate objects
- * of compute_domains.
- *
- * "list" is the main result of the function and contains a list
- * of disjoint basic sets for which code should be generated.
- *
- * "executed" and "build" are inputs to compute_domains.
- * "schedule_domain" is the domain of "executed".
- *
- * "option" constains the domains at the current depth that should by
- * atomic, separated or unrolled.  These domains are as specified by
- * the user, except that inner dimensions have been eliminated and
- * that they have been made pair-wise disjoint.
- *
- * "sep_class" contains the user-specified split into separation classes
- * specialized to the current depth.
- * "done" contains the union of the separation domains that have already
- * been handled.
- */
-struct isl_codegen_domains {
-	isl_basic_set_list *list;
-
-	isl_union_map *executed;
-	isl_ast_build *build;
-	isl_set *schedule_domain;
-
-	isl_set *option3;
-
-	isl_map *sep_class;
-	isl_set *done;
-};
-
-/* Extend domains->list with a list of basic sets, one for each value
- * of the current dimension in "domain" and remove the corresponding
- * sets from the class domain.  Return the updated class domain.
- * The divs that involve the current dimension have not been projected out
- * from this domain.
+/* Call "fn" on each iteration of the current dimension of "domain".
+ * If "init" is not NULL, then it is called with the number of
+ * iterations before any call to "fn".
+ * Return -1 on failure.
  *
  * Since we are going to be iterating over the individual values,
  * we first check if there are any strides on the current dimension.
@@ -2448,53 +2621,52 @@
  * will be taken into account at the next level, as in the case of the
  * atomic option.
  *
- * Finally, we map i' back to i and add each basic set to the list.
- * Since we may have dropped some constraints, we intersect with
- * the class domain again to ensure that each element in the list
- * is disjoint from the other class domains.
+ * Finally, we map i' back to i and call "fn".
  */
-static __isl_give isl_set *do_unroll(struct isl_codegen_domains *domains,
-	__isl_take isl_set *domain, __isl_take isl_set *class_domain)
+static int foreach_iteration(__isl_take isl_set *domain,
+	__isl_keep isl_ast_build *build, int (*init)(int n, void *user),
+	int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
 {
 	int i, n;
+	int empty;
 	int depth;
-	isl_ctx *ctx;
-	isl_aff *lower;
 	isl_multi_aff *expansion;
 	isl_basic_map *bmap;
-	isl_set *unroll_domain;
-	isl_ast_build *build;
+	isl_aff *lower = NULL;
+	isl_ast_build *stride_build;
 
-	if (!domain)
-		return isl_set_free(class_domain);
+	depth = isl_ast_build_get_depth(build);
 
-	ctx = isl_set_get_ctx(domain);
-	depth = isl_ast_build_get_depth(domains->build);
-	build = isl_ast_build_copy(domains->build);
 	domain = isl_ast_build_eliminate_inner(build, domain);
 	domain = isl_set_intersect(domain, isl_ast_build_get_domain(build));
-	build = isl_ast_build_detect_strides(build, isl_set_copy(domain));
-	expansion = isl_ast_build_get_stride_expansion(build);
+	stride_build = isl_ast_build_copy(build);
+	stride_build = isl_ast_build_detect_strides(stride_build,
+							isl_set_copy(domain));
+	expansion = isl_ast_build_get_stride_expansion(stride_build);
 
 	domain = isl_set_preimage_multi_aff(domain,
 					    isl_multi_aff_copy(expansion));
-	domain = isl_ast_build_eliminate_divs(build, domain);
-
-	isl_ast_build_free(build);
-
-	lower = find_unroll_lower_bound(domain, depth, &n);
-	if (!lower)
-		class_domain = isl_set_free(class_domain);
+	domain = isl_ast_build_eliminate_divs(stride_build, domain);
+	isl_ast_build_free(stride_build);
 
 	bmap = isl_basic_map_from_multi_aff(expansion);
 
-	unroll_domain = isl_set_empty(isl_set_get_space(domain));
-
-	for (i = 0; class_domain && i < n; ++i) {
+	empty = isl_set_is_empty(domain);
+	if (empty < 0) {
+		n = -1;
+	} else if (empty) {
+		n = 0;
+	} else {
+		lower = find_unroll_lower_bound(build, domain, depth, bmap, &n);
+		if (!lower)
+			n = -1;
+	}
+	if (n >= 0 && init && init(n, user) < 0)
+		n = -1;
+	for (i = 0; i < n; ++i) {
 		isl_set *set;
 		isl_basic_set *bset;
 		isl_constraint *slice;
-		isl_basic_set_list *list;
 
 		slice = at_offset(depth, lower, i);
 		set = isl_set_copy(domain);
@@ -2502,20 +2674,117 @@
 		bset = isl_set_unshifted_simple_hull(set);
 		bset = isl_basic_set_add_constraint(bset, slice);
 		bset = isl_basic_set_apply(bset, isl_basic_map_copy(bmap));
-		set = isl_set_from_basic_set(bset);
-		unroll_domain = isl_set_union(unroll_domain, isl_set_copy(set));
-		set = isl_set_intersect(set, isl_set_copy(class_domain));
-		set = isl_set_make_disjoint(set);
-		list = isl_basic_set_list_from_set(set);
-		domains->list = isl_basic_set_list_concat(domains->list, list);
-	}
 
-	class_domain = isl_set_subtract(class_domain, unroll_domain);
+		if (fn(bset, user) < 0)
+			break;
+	}
 
 	isl_aff_free(lower);
 	isl_set_free(domain);
 	isl_basic_map_free(bmap);
 
+	return n < 0 || i < n ? -1 : 0;
+}
+
+/* Data structure for storing the results and the intermediate objects
+ * of compute_domains.
+ *
+ * "list" is the main result of the function and contains a list
+ * of disjoint basic sets for which code should be generated.
+ *
+ * "executed" and "build" are inputs to compute_domains.
+ * "schedule_domain" is the domain of "executed".
+ *
+ * "option" contains the domains at the current depth that should by
+ * atomic, separated or unrolled.  These domains are as specified by
+ * the user, except that inner dimensions have been eliminated and
+ * that they have been made pair-wise disjoint.
+ *
+ * "sep_class" contains the user-specified split into separation classes
+ * specialized to the current depth.
+ * "done" contains the union of the separation domains that have already
+ * been handled.
+ */
+struct isl_codegen_domains {
+	isl_basic_set_list *list;
+
+	isl_union_map *executed;
+	isl_ast_build *build;
+	isl_set *schedule_domain;
+
+	isl_set *option4;
+
+	isl_map *sep_class;
+	isl_set *done;
+};
+
+/* Internal data structure for do_unroll.
+ *
+ * "domains" stores the results of compute_domains.
+ * "class_domain" is the original class domain passed to do_unroll.
+ * "unroll_domain" collects the unrolled iterations.
+ */
+struct isl_ast_unroll_data {
+	struct isl_codegen_domains *domains;
+	isl_set *class_domain;
+	isl_set *unroll_domain;
+};
+
+/* Given an iteration of an unrolled domain represented by "bset",
+ * add it to data->domains->list.
+ * Since we may have dropped some constraints, we intersect with
+ * the class domain again to ensure that each element in the list
+ * is disjoint from the other class domains.
+ */
+static int do_unroll_iteration(__isl_take isl_basic_set *bset, void *user)
+{
+	struct isl_ast_unroll_data *data = user;
+	isl_set *set;
+	isl_basic_set_list *list;
+
+	set = isl_set_from_basic_set(bset);
+	data->unroll_domain = isl_set_union(data->unroll_domain,
+					    isl_set_copy(set));
+	set = isl_set_intersect(set, isl_set_copy(data->class_domain));
+	set = isl_set_make_disjoint(set);
+	list = isl_basic_set_list_from_set(set);
+	data->domains->list = isl_basic_set_list_concat(data->domains->list,
+							list);
+
+	return 0;
+}
+
+/* Extend domains->list with a list of basic sets, one for each value
+ * of the current dimension in "domain" and remove the corresponding
+ * sets from the class domain.  Return the updated class domain.
+ * The divs that involve the current dimension have not been projected out
+ * from this domain.
+ *
+ * We call foreach_iteration to iterate over the individual values and
+ * in do_unroll_iteration we collect the individual basic sets in
+ * domains->list and their union in data->unroll_domain, which is then
+ * used to update the class domain.
+ */
+static __isl_give isl_set *do_unroll(struct isl_codegen_domains *domains,
+	__isl_take isl_set *domain, __isl_take isl_set *class_domain)
+{
+	struct isl_ast_unroll_data data;
+
+	if (!domain)
+		return isl_set_free(class_domain);
+	if (!class_domain)
+		return isl_set_free(domain);
+
+	data.domains = domains;
+	data.class_domain = class_domain;
+	data.unroll_domain = isl_set_empty(isl_set_get_space(domain));
+
+	if (foreach_iteration(domain, domains->build, NULL,
+				&do_unroll_iteration, &data) < 0)
+		data.unroll_domain = isl_set_free(data.unroll_domain);
+
+	class_domain = isl_set_subtract(class_domain, data.unroll_domain);
+
 	return class_domain;
 }
 
@@ -2540,19 +2809,22 @@
 {
 	isl_set *unroll_domain;
 	isl_basic_set_list *unroll_list;
-	int i, n;
-	int empty;
+	int i;
+	isl_size n;
+	isl_bool empty;
 
-	empty = isl_set_is_empty(domains->optionunroll);
+	empty = isl_set_is_empty(domains->optionisl_ast_loop_unroll);
 	if (empty < 0)
 		return isl_set_free(class_domain);
 	if (empty)
 		return class_domain;
 
-	unroll_domain = isl_set_copy(domains->optionunroll);
+	unroll_domain = isl_set_copy(domains->optionisl_ast_loop_unroll);
 	unroll_list = isl_basic_set_list_from_set(unroll_domain);
 
 	n = isl_basic_set_list_n_basic_set(unroll_list);
+	if (n < 0)
+		class_domain = isl_set_free(class_domain);
 	for (i = 0; i < n; ++i) {
 		isl_basic_set *bset;
 
@@ -2602,7 +2874,7 @@
 	isl_set *domain, *atomic_domain;
 	int empty;
 
-	domain = isl_set_copy(domains->optionatomic);
+	domain = isl_set_copy(domains->optionisl_ast_loop_atomic);
 	domain = isl_set_intersect(domain, isl_set_copy(class_domain));
 	domain = isl_set_intersect(domain,
 				isl_set_copy(domains->schedule_domain));
@@ -2615,7 +2887,7 @@
 	}
 
 	domain = isl_ast_build_eliminate(domains->build, domain);
-	domain = isl_set_coalesce(domain);
+	domain = isl_set_coalesce_preserve(domain);
 	bset = isl_set_unshifted_simple_hull(domain);
 	domain = isl_set_from_basic_set(bset);
 	atomic_domain = isl_set_copy(domain);
@@ -2649,7 +2921,7 @@
 	isl_basic_set_list *list;
 	int empty;
 
-	domain = isl_set_copy(domains->optionseparate);
+	domain = isl_set_copy(domains->optionisl_ast_loop_separate);
 	domain = isl_set_intersect(domain, isl_set_copy(class_domain));
 	executed = isl_union_map_copy(domains->executed);
 	executed = isl_union_map_intersect_domain(executed,
@@ -2706,7 +2978,7 @@
  * If anything is left after handling separate, unroll and atomic,
  * we split it up into basic sets and append the basic sets to domains->list.
  */
-static int compute_partial_domains(struct isl_codegen_domains *domains,
+static isl_stat compute_partial_domains(struct isl_codegen_domains *domains,
 	__isl_take isl_set *class_domain)
 {
 	isl_basic_set_list *list;
@@ -2725,7 +2997,7 @@
 	if (compute_separate_domain(domains, domain) < 0)
 		goto error;
 	domain = isl_set_subtract(domain,
-				    isl_set_copy(domains->optionseparate));
+			isl_set_copy(domains->optionisl_ast_loop_separate));
 
 	domain = isl_set_intersect(domain,
 				isl_set_copy(domains->schedule_domain));
@@ -2733,7 +3005,7 @@
 	domain = isl_ast_build_eliminate(domains->build, domain);
 	domain = isl_set_intersect(domain, isl_set_copy(class_domain));
 
-	domain = isl_set_coalesce(domain);
+	domain = isl_set_coalesce_preserve(domain);
 	domain = isl_set_make_disjoint(domain);
 
 	list = isl_basic_set_list_from_set(domain);
@@ -2741,11 +3013,11 @@
 
 	isl_set_free(class_domain);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(domain);
 	isl_set_free(class_domain);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Split up the domain at the current depth into disjoint
@@ -2755,7 +3027,7 @@
  * We extract the corresponding class domain from domains->sep_class,
  * eliminate inner dimensions and pass control to compute_partial_domains.
  */
-static int compute_class_domains(__isl_take isl_point *pnt, void *user)
+static isl_stat compute_class_domains(__isl_take isl_point *pnt, void *user)
 {
 	struct isl_codegen_domains *domains = user;
 	isl_set *class_set;
@@ -2770,10 +3042,10 @@
 
 	disjoint = isl_set_plain_is_disjoint(domain, domains->schedule_domain);
 	if (disjoint < 0)
-		return -1;
+		return isl_stat_error;
 	if (disjoint) {
 		isl_set_free(domain);
-		return 0;
+		return isl_stat_ok;
 	}
 
 	return compute_partial_domains(domains, domain);
@@ -2785,20 +3057,24 @@
  * The domains specified by the user might overlap, so we make
  * them disjoint by subtracting earlier domains from later domains.
  */
-static void compute_domains_init_options(isl_set *option3,
+static void compute_domains_init_options(isl_set *option4,
 	__isl_keep isl_ast_build *build)
 {
-	enum isl_ast_build_domain_type type, type2;
+	enum isl_ast_loop_type type, type2;
+	isl_set *unroll;
 
-	for (type = atomic; type <= separate; ++type) {
+	for (type = isl_ast_loop_atomic;
+	    type <= isl_ast_loop_separate; ++type) {
 		optiontype = isl_ast_build_get_option_domain(build, type);
-		for (type2 = atomic; type2 < type; ++type2)
+		for (type2 = isl_ast_loop_atomic; type2 < type; ++type2)
 			optiontype = isl_set_subtract(optiontype,
 						isl_set_copy(optiontype2));
 	}
 
-	optionunroll = isl_set_coalesce(optionunroll);
-	optionunroll = isl_set_make_disjoint(optionunroll);
+	unroll = optionisl_ast_loop_unroll;
+	unroll = isl_set_coalesce(unroll);
+	unroll = isl_set_make_disjoint(unroll);
+	optionisl_ast_loop_unroll = unroll;
 }
 
 /* Split up the domain at the current depth into disjoint
@@ -2832,8 +3108,8 @@
 	isl_set *classes;
 	isl_space *space;
 	int n_param;
-	enum isl_ast_build_domain_type type;
-	int empty;
+	enum isl_ast_loop_type type;
+	isl_bool empty;
 
 	if (!executed)
 		return NULL;
@@ -2849,6 +3125,8 @@
 	domains.sep_class = isl_ast_build_get_separation_class(build);
 	classes = isl_map_range(isl_map_copy(domains.sep_class));
 	n_param = isl_set_dim(classes, isl_dim_param);
+	if (n_param < 0)
+		classes = isl_set_free(classes);
 	classes = isl_set_project_out(classes, isl_dim_param, 0, n_param);
 
 	space = isl_set_get_space(domain);
@@ -2877,20 +3155,20 @@
 	isl_set_free(domains.schedule_domain);
 	isl_set_free(domains.done);
 	isl_map_free(domains.sep_class);
-	for (type = atomic; type <= separate; ++type)
+	for (type = isl_ast_loop_atomic; type <= isl_ast_loop_separate; ++type)
 		isl_set_free(domains.optiontype);
 
 	return domains.list;
 }
 
 /* Generate code for a single component, after shifting (if any)
- * has been applied.
+ * has been applied, in case the schedule was specified as a union map.
  *
  * We first split up the domain at the current depth into disjoint
  * basic sets based on the user-specified options.
  * Then we generated code for each of them and concatenate the results.
  */
-static __isl_give isl_ast_graft_list *generate_shifted_component(
+static __isl_give isl_ast_graft_list *generate_shifted_component_flat(
 	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
 {
 	isl_basic_set_list *domain_list;
@@ -2906,6 +3184,512 @@
 	return list;
 }
 
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree
+ * and the separate option was specified.
+ *
+ * We perform separation on the domain of "executed" and then generate
+ * an AST for each of the resulting disjoint basic sets.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_tree_separate(
+	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
+{
+	isl_space *space;
+	isl_set *domain;
+	isl_basic_set_list *domain_list;
+	isl_ast_graft_list *list;
+
+	space = isl_ast_build_get_space(build, 1);
+	domain = separate_schedule_domains(space,
+					isl_union_map_copy(executed), build);
+	domain_list = isl_basic_set_list_from_set(domain);
+
+	list = generate_parallel_domains(domain_list, executed, build);
+
+	isl_basic_set_list_free(domain_list);
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+
+	return list;
+}
+
+/* Internal data structure for generate_shifted_component_tree_unroll.
+ *
+ * "executed" and "build" are inputs to generate_shifted_component_tree_unroll.
+ * "list" collects the constructs grafts.
+ */
+struct isl_ast_unroll_tree_data {
+	isl_union_map *executed;
+	isl_ast_build *build;
+	isl_ast_graft_list *list;
+};
+
+/* Initialize data->list to a list of "n" elements.
+ */
+static int init_unroll_tree(int n, void *user)
+{
+	struct isl_ast_unroll_tree_data *data = user;
+	isl_ctx *ctx;
+
+	ctx = isl_ast_build_get_ctx(data->build);
+	data->list = isl_ast_graft_list_alloc(ctx, n);
+
+	return 0;
+}
+
+/* Given an iteration of an unrolled domain represented by "bset",
+ * generate the corresponding AST and add the result to data->list.
+ */
+static int do_unroll_tree_iteration(__isl_take isl_basic_set *bset, void *user)
+{
+	struct isl_ast_unroll_tree_data *data = user;
+
+	data->list = add_node(data->list, isl_union_map_copy(data->executed),
+				bset, isl_ast_build_copy(data->build));
+
+	return 0;
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree
+ * and the unroll option was specified.
+ *
+ * We call foreach_iteration to iterate over the individual values and
+ * construct and collect the corresponding grafts in do_unroll_tree_iteration.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_tree_unroll(
+	__isl_take isl_union_map *executed, __isl_take isl_set *domain,
+	__isl_take isl_ast_build *build)
+{
+	struct isl_ast_unroll_tree_data data = { executed, build, NULL };
+
+	if (foreach_iteration(domain, build, &init_unroll_tree,
+				&do_unroll_tree_iteration, &data) < 0)
+		data.list = isl_ast_graft_list_free(data.list);
+
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+
+	return data.list;
+}
+
+/* Does "domain" involve a disjunction that is purely based on
+ * constraints involving only outer dimension?
+ *
+ * In particular, is there a disjunction such that the constraints
+ * involving the current and later dimensions are the same over
+ * all the disjuncts?
+ */
+static isl_bool has_pure_outer_disjunction(__isl_keep isl_set *domain,
+	__isl_keep isl_ast_build *build)
+{
+	isl_basic_set *hull;
+	isl_set *shared, *inner;
+	isl_bool equal;
+	int depth;
+	isl_size n;
+	isl_size dim;
+
+	n = isl_set_n_basic_set(domain);
+	if (n < 0)
+		return isl_bool_error;
+	if (n <= 1)
+		return isl_bool_false;
+	dim = isl_set_dim(domain, isl_dim_set);
+	if (dim < 0)
+		return isl_bool_error;
+
+	inner = isl_set_copy(domain);
+	depth = isl_ast_build_get_depth(build);
+	inner = isl_set_drop_constraints_not_involving_dims(inner,
+					    isl_dim_set, depth, dim - depth);
+	hull = isl_set_plain_unshifted_simple_hull(isl_set_copy(inner));
+	shared = isl_set_from_basic_set(hull);
+	equal = isl_set_plain_is_equal(inner, shared);
+	isl_set_free(inner);
+	isl_set_free(shared);
+
+	return equal;
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree.
+ * In particular, handle the base case where there is either no isolated
+ * set or we are within the isolated set (in which case "isolated" is set)
+ * or the iterations that precede or follow the isolated set.
+ *
+ * The schedule domain is broken up or combined into basic sets
+ * according to the AST generation option specified in the current
+ * schedule node, which may be either atomic, separate, unroll or
+ * unspecified.  If the option is unspecified, then we currently simply
+ * split the schedule domain into disjoint basic sets.
+ *
+ * In case the separate option is specified, the AST generation is
+ * handled by generate_shifted_component_tree_separate.
+ * In the other cases, we need the global schedule domain.
+ * In the unroll case, the AST generation is then handled by
+ * generate_shifted_component_tree_unroll which needs the actual
+ * schedule domain (with divs that may refer to the current dimension)
+ * so that stride detection can be performed.
+ * In the atomic or unspecified case, inner dimensions and divs involving
+ * the current dimensions should be eliminated.
+ * The result is then either combined into a single basic set or
+ * split up into disjoint basic sets.
+ * Finally an AST is generated for each basic set and the results are
+ * concatenated.
+ *
+ * If the schedule domain involves a disjunction that is purely based on
+ * constraints involving only outer dimension, then it is treated as
+ * if atomic was specified.  This ensures that only a single loop
+ * is generated instead of a sequence of identical loops with
+ * different guards.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_tree_base(
+	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build,
+	int isolated)
+{
+	isl_bool outer_disjunction;
+	isl_union_set *schedule_domain;
+	isl_set *domain;
+	isl_basic_set_list *domain_list;
+	isl_ast_graft_list *list;
+	enum isl_ast_loop_type type;
+
+	type = isl_ast_build_get_loop_type(build, isolated);
+	if (type < 0)
+		goto error;
+
+	if (type == isl_ast_loop_separate)
+		return generate_shifted_component_tree_separate(executed,
+								build);
+
+	schedule_domain = isl_union_map_domain(isl_union_map_copy(executed));
+	domain = isl_set_from_union_set(schedule_domain);
+
+	if (type == isl_ast_loop_unroll)
+		return generate_shifted_component_tree_unroll(executed, domain,
+								build);
+
+	domain = isl_ast_build_eliminate(build, domain);
+	domain = isl_set_coalesce_preserve(domain);
+
+	outer_disjunction = has_pure_outer_disjunction(domain, build);
+	if (outer_disjunction < 0)
+		domain = isl_set_free(domain);
+
+	if (outer_disjunction || type == isl_ast_loop_atomic) {
+		isl_basic_set *hull;
+		hull = isl_set_unshifted_simple_hull(domain);
+		domain_list = isl_basic_set_list_from_basic_set(hull);
+	} else {
+		domain = isl_set_make_disjoint(domain);
+		domain_list = isl_basic_set_list_from_set(domain);
+	}
+
+	list = generate_parallel_domains(domain_list, executed, build);
+
+	isl_basic_set_list_free(domain_list);
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+
+	return list;
+error:
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+	return NULL;
+}
+
+/* Extract out the disjunction imposed by "domain" on the outer
+ * schedule dimensions.
+ *
+ * In particular, remove all inner dimensions from "domain" (including
+ * the current dimension) and then remove the constraints that are shared
+ * by all disjuncts in the result.
+ */
+static __isl_give isl_set *extract_disjunction(__isl_take isl_set *domain,
+	__isl_keep isl_ast_build *build)
+{
+	isl_set *hull;
+	int depth;
+	isl_size dim;
+
+	domain = isl_ast_build_specialize(build, domain);
+	depth = isl_ast_build_get_depth(build);
+	dim = isl_set_dim(domain, isl_dim_set);
+	if (dim < 0)
+		return isl_set_free(domain);
+	domain = isl_set_eliminate(domain, isl_dim_set, depth, dim - depth);
+	domain = isl_set_remove_unknown_divs(domain);
+	hull = isl_set_copy(domain);
+	hull = isl_set_from_basic_set(isl_set_unshifted_simple_hull(hull));
+	domain = isl_set_gist(domain, hull);
+
+	return domain;
+}
+
+/* Add "guard" to the grafts in "list".
+ * "build" is the outer AST build, while "sub_build" includes "guard"
+ * in its generated domain.
+ *
+ * First combine the grafts into a single graft and then add the guard.
+ * If the list is empty, or if some error occurred, then simply return
+ * the list.
+ */
+static __isl_give isl_ast_graft_list *list_add_guard(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_set *guard,
+	__isl_keep isl_ast_build *build, __isl_keep isl_ast_build *sub_build)
+{
+	isl_ast_graft *graft;
+	isl_size n;
+
+	list = isl_ast_graft_list_fuse(list, sub_build);
+
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return isl_ast_graft_list_free(list);
+	if (n != 1)
+		return list;
+
+	graft = isl_ast_graft_list_get_ast_graft(list, 0);
+	graft = isl_ast_graft_add_guard(graft, isl_set_copy(guard), build);
+	list = isl_ast_graft_list_set_ast_graft(list, 0, graft);
+
+	return list;
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree.
+ * In particular, do so for the specified subset of the schedule domain.
+ *
+ * If we are outside of the isolated part, then "domain" may include
+ * a disjunction.  Explicitly generate this disjunction at this point
+ * instead of relying on the disjunction getting hoisted back up
+ * to this level.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_tree_part(
+	__isl_keep isl_union_map *executed, __isl_take isl_set *domain,
+	__isl_keep isl_ast_build *build, int isolated)
+{
+	isl_union_set *uset;
+	isl_ast_graft_list *list;
+	isl_ast_build *sub_build;
+	int empty;
+
+	uset = isl_union_set_from_set(isl_set_copy(domain));
+	executed = isl_union_map_copy(executed);
+	executed = isl_union_map_intersect_domain(executed, uset);
+	empty = isl_union_map_is_empty(executed);
+	if (empty < 0)
+		goto error;
+	if (empty) {
+		isl_ctx *ctx;
+		isl_union_map_free(executed);
+		isl_set_free(domain);
+		ctx = isl_ast_build_get_ctx(build);
+		return isl_ast_graft_list_alloc(ctx, 0);
+	}
+
+	sub_build = isl_ast_build_copy(build);
+	if (!isolated) {
+		domain = extract_disjunction(domain, build);
+		sub_build = isl_ast_build_restrict_generated(sub_build,
+							isl_set_copy(domain));
+	}
+	list = generate_shifted_component_tree_base(executed,
+				isl_ast_build_copy(sub_build), isolated);
+	if (!isolated)
+		list = list_add_guard(list, domain, build, sub_build);
+	isl_ast_build_free(sub_build);
+	isl_set_free(domain);
+	return list;
+error:
+	isl_union_map_free(executed);
+	isl_set_free(domain);
+	return NULL;
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree.
+ * In particular, do so for the specified sequence of subsets
+ * of the schedule domain, "before", "isolated", "after" and "other",
+ * where only the "isolated" part is considered to be isolated.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_parts(
+	__isl_take isl_union_map *executed, __isl_take isl_set *before,
+	__isl_take isl_set *isolated, __isl_take isl_set *after,
+	__isl_take isl_set *other, __isl_take isl_ast_build *build)
+{
+	isl_ast_graft_list *list, *res;
+
+	res = generate_shifted_component_tree_part(executed, before, build, 0);
+	list = generate_shifted_component_tree_part(executed, isolated,
+						    build, 1);
+	res = isl_ast_graft_list_concat(res, list);
+	list = generate_shifted_component_tree_part(executed, after, build, 0);
+	res = isl_ast_graft_list_concat(res, list);
+	list = generate_shifted_component_tree_part(executed, other, build, 0);
+	res = isl_ast_graft_list_concat(res, list);
+
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+
+	return res;
+}
+
+/* Does "set" intersect "first", but not "second"?
+ */
+static isl_bool only_intersects_first(__isl_keep isl_set *set,
+	__isl_keep isl_set *first, __isl_keep isl_set *second)
+{
+	isl_bool disjoint;
+
+	disjoint = isl_set_is_disjoint(set, first);
+	if (disjoint < 0)
+		return isl_bool_error;
+	if (disjoint)
+		return isl_bool_false;
+
+	return isl_set_is_disjoint(set, second);
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree.
+ * In particular, do so in case of isolation where there is
+ * only an "isolated" part and an "after" part.
+ * "dead1" and "dead2" are freed by this function in order to simplify
+ * the caller.
+ *
+ * The "before" and "other" parts are set to empty sets.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_only_after(
+	__isl_take isl_union_map *executed, __isl_take isl_set *isolated,
+	__isl_take isl_set *after, __isl_take isl_ast_build *build,
+	__isl_take isl_set *dead1, __isl_take isl_set *dead2)
+{
+	isl_set *empty;
+
+	empty = isl_set_empty(isl_set_get_space(after));
+	isl_set_free(dead1);
+	isl_set_free(dead2);
+	return generate_shifted_component_parts(executed, isl_set_copy(empty),
+						isolated, after, empty, build);
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied, in case the schedule was specified as a schedule tree.
+ *
+ * We first check if the user has specified an isolated schedule domain
+ * and that we are not already outside of this isolated schedule domain.
+ * If so, we break up the schedule domain into iterations that
+ * precede the isolated domain, the isolated domain itself,
+ * the iterations that follow the isolated domain and
+ * the remaining iterations (those that are incomparable
+ * to the isolated domain).
+ * We generate an AST for each piece and concatenate the results.
+ *
+ * If the isolated domain is not convex, then it is replaced
+ * by a convex superset to ensure that the sets of preceding and
+ * following iterations are properly defined and, in particular,
+ * that there are no intermediate iterations that do not belong
+ * to the isolated domain.
+ *
+ * In the special case where at least one element of the schedule
+ * domain that does not belong to the isolated domain needs
+ * to be scheduled after this isolated domain, but none of those
+ * elements need to be scheduled before, break up the schedule domain
+ * in only two parts, the isolated domain, and a part that will be
+ * scheduled after the isolated domain.
+ *
+ * If no isolated set has been specified, then we generate an
+ * AST for the entire inverse schedule.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component_tree(
+	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
+{
+	int i, depth;
+	int empty, has_isolate;
+	isl_space *space;
+	isl_union_set *schedule_domain;
+	isl_set *domain;
+	isl_basic_set *hull;
+	isl_set *isolated, *before, *after, *test;
+	isl_map *gt, *lt;
+	isl_bool pure;
+
+	build = isl_ast_build_extract_isolated(build);
+	has_isolate = isl_ast_build_has_isolated(build);
+	if (has_isolate < 0)
+		executed = isl_union_map_free(executed);
+	else if (!has_isolate)
+		return generate_shifted_component_tree_base(executed, build, 0);
+
+	schedule_domain = isl_union_map_domain(isl_union_map_copy(executed));
+	domain = isl_set_from_union_set(schedule_domain);
+
+	isolated = isl_ast_build_get_isolated(build);
+	isolated = isl_set_intersect(isolated, isl_set_copy(domain));
+	test = isl_ast_build_specialize(build, isl_set_copy(isolated));
+	empty = isl_set_is_empty(test);
+	isl_set_free(test);
+	if (empty < 0)
+		goto error;
+	if (empty) {
+		isl_set_free(isolated);
+		isl_set_free(domain);
+		return generate_shifted_component_tree_base(executed, build, 0);
+	}
+	isolated = isl_ast_build_eliminate(build, isolated);
+	hull = isl_set_unshifted_simple_hull(isolated);
+	isolated = isl_set_from_basic_set(hull);
+
+	depth = isl_ast_build_get_depth(build);
+	space = isl_space_map_from_set(isl_set_get_space(isolated));
+	gt = isl_map_universe(space);
+	for (i = 0; i < depth; ++i)
+		gt = isl_map_equate(gt, isl_dim_in, i, isl_dim_out, i);
+	gt = isl_map_order_gt(gt, isl_dim_in, depth, isl_dim_out, depth);
+	lt = isl_map_reverse(isl_map_copy(gt));
+	before = isl_set_apply(isl_set_copy(isolated), gt);
+	after = isl_set_apply(isl_set_copy(isolated), lt);
+
+	domain = isl_set_subtract(domain, isl_set_copy(isolated));
+	pure = only_intersects_first(domain, after, before);
+	if (pure < 0)
+		executed = isl_union_map_free(executed);
+	else if (pure)
+		return generate_shifted_component_only_after(executed, isolated,
+						domain, build, before, after);
+	domain = isl_set_subtract(domain, isl_set_copy(before));
+	domain = isl_set_subtract(domain, isl_set_copy(after));
+	after = isl_set_subtract(after, isl_set_copy(isolated));
+	after = isl_set_subtract(after, isl_set_copy(before));
+	before = isl_set_subtract(before, isl_set_copy(isolated));
+
+	return generate_shifted_component_parts(executed, before, isolated,
+						after, domain, build);
+error:
+	isl_set_free(domain);
+	isl_set_free(isolated);
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+	return NULL;
+}
+
+/* Generate code for a single component, after shifting (if any)
+ * has been applied.
+ *
+ * Call generate_shifted_component_tree or generate_shifted_component_flat
+ * depending on whether the schedule was specified as a schedule tree.
+ */
+static __isl_give isl_ast_graft_list *generate_shifted_component(
+	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
+{
+	if (isl_ast_build_has_schedule_node(build))
+		return generate_shifted_component_tree(executed, build);
+	else
+		return generate_shifted_component_flat(executed, build);
+}
+
 struct isl_set_map_pair {
 	isl_set *set;
 	isl_map *map;
@@ -3159,7 +3943,7 @@
  * with "<<" the lexicographic order, proving that the order is preserved
  * in all cases.
  */
-static __isl_give isl_union_map *contruct_shifted_executed(
+static __isl_give isl_union_map *construct_shifted_executed(
 	struct isl_set_map_pair *domain, int *order, int n,
 	__isl_keep isl_val *stride, __isl_keep isl_multi_val *offset,
 	__isl_take isl_ast_build *build)
@@ -3180,7 +3964,7 @@
 	map = isl_map_insert_dims(map, isl_dim_out, depth + 1, 1);
 	space = isl_space_insert_dims(space, isl_dim_out, depth + 1, 1);
 
-	c = isl_equality_alloc(isl_local_space_from_space(space));
+	c = isl_constraint_alloc_equality(isl_local_space_from_space(space));
 	c = isl_constraint_set_coefficient_si(c, isl_dim_in, depth, 1);
 	c = isl_constraint_set_coefficient_si(c, isl_dim_out, depth, -1);
 
@@ -3230,9 +4014,9 @@
  * domain is equal to zero.  The other offsets are reduced modulo stride.
  *
  * Based on this information, we construct a new inverse schedule in
- * contruct_shifted_executed that exposes the stride.
+ * construct_shifted_executed that exposes the stride.
  * Since this involves the introduction of a new schedule dimension,
- * the build needs to be changed accodingly.
+ * the build needs to be changed accordingly.
  * After computing the AST, the newly introduced dimension needs
  * to be removed again from the list of grafts.  We do this by plugging
  * in a mapping that represents the new schedule domain in terms of the
@@ -3246,14 +4030,12 @@
 	isl_ast_graft_list *list;
 	int first;
 	int depth;
-	isl_ctx *ctx;
 	isl_val *val;
 	isl_multi_val *mv;
 	isl_space *space;
 	isl_multi_aff *ma, *zero;
 	isl_union_map *executed;
 
-	ctx = isl_ast_build_get_ctx(build);
 	depth = isl_ast_build_get_depth(build);
 
 	first = first_offset(domain, order, n, build);
@@ -3266,7 +4048,7 @@
 	mv = isl_multi_val_add_val(mv, val);
 	mv = isl_multi_val_mod_val(mv, isl_val_copy(stride));
 
-	executed = contruct_shifted_executed(domain, order, n, stride, mv,
+	executed = construct_shifted_executed(domain, order, n, stride, mv,
 						build);
 	space = isl_ast_build_get_space(build, 1);
 	space = isl_space_map_from_set(space);
@@ -3288,6 +4070,21 @@
 	return NULL;
 }
 
+/* Does any node in the schedule tree rooted at the current schedule node
+ * of "build" depend on outer schedule nodes?
+ */
+static int has_anchored_subtree(__isl_keep isl_ast_build *build)
+{
+	isl_schedule_node *node;
+	int dependent = 0;
+
+	node = isl_ast_build_get_schedule_node(build);
+	dependent = isl_schedule_node_is_subtree_anchored(node);
+	isl_schedule_node_free(node);
+
+	return dependent;
+}
+
 /* Generate code for a single component.
  *
  * The component inverse schedule is specified as the "map" fields
@@ -3319,11 +4116,15 @@
  * a fixed value for almost all domains then there is nothing to be done.
  * In particular, we need at least two domains where the current schedule
  * dimension does not have a fixed value.
- * Finally, if any of the options refer to the current schedule dimension,
+ * Finally, in case of a schedule map input,
+ * if any of the options refer to the current schedule dimension,
  * then we bail out as well.  It would be possible to reformulate the options
  * in terms of the new schedule domain, but that would introduce constraints
  * that separate the domains in the options and that is something we would
  * like to avoid.
+ * In the case of a schedule tree input, we bail out if any of
+ * the descendants of the current schedule node refer to outer
+ * schedule nodes in any way.
  *
  *
  * To see if there is any shifted stride, we look at the differences
@@ -3375,8 +4176,12 @@
 	skip = n == 1;
 	if (skip >= 0 && !skip)
 		skip = at_most_one_non_fixed(domain, order, n, depth);
-	if (skip >= 0 && !skip)
-		skip = isl_ast_build_options_involve_depth(build);
+	if (skip >= 0 && !skip) {
+		if (isl_ast_build_has_schedule_node(build))
+			skip = has_anchored_subtree(build);
+		else
+			skip = isl_ast_build_options_involve_depth(build);
+	}
 	if (skip < 0)
 		goto error;
 	if (skip)
@@ -3457,7 +4262,7 @@
 /* Store both "map" itself and its domain in the
  * structure pointed to by *next and advance to the next array element.
  */
-static int extract_domain(__isl_take isl_map *map, void *user)
+static isl_stat extract_domain(__isl_take isl_map *map, void *user)
 {
 	struct isl_set_map_pair **next = user;
 
@@ -3465,11 +4270,400 @@
 	(*next)->set = isl_map_domain(map);
 	(*next)++;
 
-	return 0;
+	return isl_stat_ok;
+}
+
+static isl_bool after_in_tree(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node);
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the child of "node"?
+ */
+static isl_bool after_in_child(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_schedule_node *child;
+	isl_bool after;
+
+	child = isl_schedule_node_get_child(node, 0);
+	after = after_in_tree(umap, child);
+	isl_schedule_node_free(child);
+
+	return after;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the band node "node"?
+ *
+ * We first check if any domain element is scheduled after any
+ * of the corresponding image elements by the band node itself.
+ * If not, we restrict "map" to those pairs of element that
+ * are scheduled together by the band node and continue with
+ * the child of the band node.
+ * If there are no such pairs then the map passed to after_in_child
+ * will be empty causing it to return 0.
+ */
+static isl_bool after_in_band(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_multi_union_pw_aff *mupa;
+	isl_union_map *partial, *test, *gt, *universe, *umap1, *umap2;
+	isl_union_set *domain, *range;
+	isl_space *space;
+	isl_bool empty;
+	isl_bool after;
+	isl_size n;
+
+	n = isl_schedule_node_band_n_member(node);
+	if (n < 0)
+		return isl_bool_error;
+	if (n == 0)
+		return after_in_child(umap, node);
+
+	mupa = isl_schedule_node_band_get_partial_schedule(node);
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	partial = isl_union_map_from_multi_union_pw_aff(mupa);
+	test = isl_union_map_copy(umap);
+	test = isl_union_map_apply_domain(test, isl_union_map_copy(partial));
+	test = isl_union_map_apply_range(test, isl_union_map_copy(partial));
+	gt = isl_union_map_from_map(isl_map_lex_gt(space));
+	test = isl_union_map_intersect(test, gt);
+	empty = isl_union_map_is_empty(test);
+	isl_union_map_free(test);
+
+	if (empty < 0 || !empty) {
+		isl_union_map_free(partial);
+		return isl_bool_not(empty);
+	}
+
+	universe = isl_union_map_universe(isl_union_map_copy(umap));
+	domain = isl_union_map_domain(isl_union_map_copy(universe));
+	range = isl_union_map_range(universe);
+	umap1 = isl_union_map_copy(partial);
+	umap1 = isl_union_map_intersect_domain(umap1, domain);
+	umap2 = isl_union_map_intersect_domain(partial, range);
+	test = isl_union_map_apply_range(umap1, isl_union_map_reverse(umap2));
+	test = isl_union_map_intersect(test, isl_union_map_copy(umap));
+	after = after_in_child(test, node);
+	isl_union_map_free(test);
+	return after;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the context node "node"?
+ *
+ * The context constraints apply to the schedule domain,
+ * so we cannot apply them directly to "umap", which contains
+ * pairs of statement instances.  Instead, we add them
+ * to the range of the prefix schedule for both domain and
+ * range of "umap".
+ */
+static isl_bool after_in_context(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_union_map *prefix, *universe, *umap1, *umap2;
+	isl_union_set *domain, *range;
+	isl_set *context;
+	isl_bool after;
+
+	umap = isl_union_map_copy(umap);
+	context = isl_schedule_node_context_get_context(node);
+	prefix = isl_schedule_node_get_prefix_schedule_union_map(node);
+	universe = isl_union_map_universe(isl_union_map_copy(umap));
+	domain = isl_union_map_domain(isl_union_map_copy(universe));
+	range = isl_union_map_range(universe);
+	umap1 = isl_union_map_copy(prefix);
+	umap1 = isl_union_map_intersect_domain(umap1, domain);
+	umap2 = isl_union_map_intersect_domain(prefix, range);
+	umap1 = isl_union_map_intersect_range(umap1,
+					    isl_union_set_from_set(context));
+	umap1 = isl_union_map_apply_range(umap1, isl_union_map_reverse(umap2));
+	umap = isl_union_map_intersect(umap, umap1);
+
+	after = after_in_child(umap, node);
+
+	isl_union_map_free(umap);
+
+	return after;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the expansion node "node"?
+ *
+ * We apply the expansion to domain and range of "umap" and
+ * continue with its child.
+ */
+static isl_bool after_in_expansion(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_union_map *expansion;
+	isl_bool after;
+
+	expansion = isl_schedule_node_expansion_get_expansion(node);
+	umap = isl_union_map_copy(umap);
+	umap = isl_union_map_apply_domain(umap, isl_union_map_copy(expansion));
+	umap = isl_union_map_apply_range(umap, expansion);
+
+	after = after_in_child(umap, node);
+
+	isl_union_map_free(umap);
+
+	return after;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the extension node "node"?
+ *
+ * Since the extension node may add statement instances before or
+ * after the pairs of statement instances in "umap", we return isl_bool_true
+ * to ensure that these pairs are not broken up.
+ */
+static isl_bool after_in_extension(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	return isl_bool_true;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the filter node "node"?
+ *
+ * We intersect domain and range of "umap" with the filter and
+ * continue with its child.
+ */
+static isl_bool after_in_filter(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_union_set *filter;
+	isl_bool after;
+
+	umap = isl_union_map_copy(umap);
+	filter = isl_schedule_node_filter_get_filter(node);
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(filter));
+	umap = isl_union_map_intersect_range(umap, filter);
+
+	after = after_in_child(umap, node);
+
+	isl_union_map_free(umap);
+
+	return after;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the set node "node"?
+ *
+ * This is only the case if this condition holds in any
+ * of the (filter) children of the set node.
+ * In particular, if the domain and the range of "umap"
+ * are contained in different children, then the condition
+ * does not hold.
+ */
+static isl_bool after_in_set(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	int i;
+	isl_size n;
+
+	n = isl_schedule_node_n_children(node);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 0; i < n; ++i) {
+		isl_schedule_node *child;
+		isl_bool after;
+
+		child = isl_schedule_node_get_child(node, i);
+		after = after_in_tree(umap, child);
+		isl_schedule_node_free(child);
+
+		if (after < 0 || after)
+			return after;
+	}
+
+	return isl_bool_false;
+}
+
+/* Return the filter of child "i" of "node".
+ */
+static __isl_give isl_union_set *child_filter(
+	__isl_keep isl_schedule_node *node, int i)
+{
+	isl_schedule_node *child;
+	isl_union_set *filter;
+
+	child = isl_schedule_node_get_child(node, i);
+	filter = isl_schedule_node_filter_get_filter(child);
+	isl_schedule_node_free(child);
+
+	return filter;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at
+ * the sequence node "node"?
+ *
+ * This happens in particular if any domain element is
+ * contained in a later child than one containing a range element or
+ * if the condition holds within a given child in the sequence.
+ * The later part of the condition is checked by after_in_set.
+ */
+static isl_bool after_in_sequence(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	int i, j;
+	isl_size n;
+	isl_union_map *umap_i;
+	isl_bool empty;
+	isl_bool after = isl_bool_false;
+
+	n = isl_schedule_node_n_children(node);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 1; i < n; ++i) {
+		isl_union_set *filter_i;
+
+		umap_i = isl_union_map_copy(umap);
+		filter_i = child_filter(node, i);
+		umap_i = isl_union_map_intersect_domain(umap_i, filter_i);
+		empty = isl_union_map_is_empty(umap_i);
+		if (empty < 0)
+			goto error;
+		if (empty) {
+			isl_union_map_free(umap_i);
+			continue;
+		}
+
+		for (j = 0; j < i; ++j) {
+			isl_union_set *filter_j;
+			isl_union_map *umap_ij;
+
+			umap_ij = isl_union_map_copy(umap_i);
+			filter_j = child_filter(node, j);
+			umap_ij = isl_union_map_intersect_range(umap_ij,
+								filter_j);
+			empty = isl_union_map_is_empty(umap_ij);
+			isl_union_map_free(umap_ij);
+
+			if (empty < 0)
+				goto error;
+			if (!empty)
+				after = isl_bool_true;
+			if (after)
+				break;
+		}
+
+		isl_union_map_free(umap_i);
+		if (after)
+			break;
+	}
+
+	if (after < 0 || after)
+		return after;
+
+	return after_in_set(umap, node);
+error:
+	isl_union_map_free(umap_i);
+	return isl_bool_error;
+}
+
+/* Is any domain element of "umap" scheduled after any of
+ * the corresponding image elements by the tree rooted at "node"?
+ *
+ * If "umap" is empty, then clearly there is no such element.
+ * Otherwise, consider the different types of nodes separately.
+ */
+static isl_bool after_in_tree(__isl_keep isl_union_map *umap,
+	__isl_keep isl_schedule_node *node)
+{
+	isl_bool empty;
+	enum isl_schedule_node_type type;
+
+	empty = isl_union_map_is_empty(umap);
+	if (empty < 0)
+		return isl_bool_error;
+	if (empty)
+		return isl_bool_false;
+	if (!node)
+		return isl_bool_error;
+
+	type = isl_schedule_node_get_type(node);
+	switch (type) {
+	case isl_schedule_node_error:
+		return isl_bool_error;
+	case isl_schedule_node_leaf:
+		return isl_bool_false;
+	case isl_schedule_node_band:
+		return after_in_band(umap, node);
+	case isl_schedule_node_domain:
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_internal,
+			"unexpected internal domain node",
+			return isl_bool_error);
+	case isl_schedule_node_context:
+		return after_in_context(umap, node);
+	case isl_schedule_node_expansion:
+		return after_in_expansion(umap, node);
+	case isl_schedule_node_extension:
+		return after_in_extension(umap, node);
+	case isl_schedule_node_filter:
+		return after_in_filter(umap, node);
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+		return after_in_child(umap, node);
+	case isl_schedule_node_set:
+		return after_in_set(umap, node);
+	case isl_schedule_node_sequence:
+		return after_in_sequence(umap, node);
+	}
+
+	return isl_bool_true;
+}
+
+/* Is any domain element of "map1" scheduled after any domain
+ * element of "map2" by the subtree underneath the current band node,
+ * while at the same time being scheduled together by the current
+ * band node, i.e., by "map1" and "map2?
+ *
+ * If the child of the current band node is a leaf, then
+ * no element can be scheduled after any other element.
+ *
+ * Otherwise, we construct a relation between domain elements
+ * of "map1" and domain elements of "map2" that are scheduled
+ * together and then check if the subtree underneath the current
+ * band node determines their relative order.
+ */
+static isl_bool after_in_subtree(__isl_keep isl_ast_build *build,
+	__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+{
+	isl_schedule_node *node;
+	isl_map *map;
+	isl_union_map *umap;
+	isl_bool after;
+
+	node = isl_ast_build_get_schedule_node(build);
+	if (!node)
+		return isl_bool_error;
+	node = isl_schedule_node_child(node, 0);
+	if (isl_schedule_node_get_type(node) == isl_schedule_node_leaf) {
+		isl_schedule_node_free(node);
+		return isl_bool_false;
+	}
+	map = isl_map_copy(map2);
+	map = isl_map_apply_domain(map, isl_map_copy(map1));
+	umap = isl_union_map_from_map(map);
+	after = after_in_tree(umap, node);
+	isl_union_map_free(umap);
+	isl_schedule_node_free(node);
+	return after;
 }
 
 /* Internal data for any_scheduled_after.
  *
+ * "build" is the build in which the AST is constructed.
  * "depth" is the number of loops that have already been generated
  * "group_coscheduled" is a local copy of options->ast_build_group_coscheduled
  * "domain" is an array of set-map pairs corresponding to the different
@@ -3477,6 +4671,7 @@
  * of the inverse schedule, while the map is the inverse schedule itself.
  */
 struct isl_any_scheduled_after_data {
+	isl_ast_build *build;
 	int depth;
 	int group_coscheduled;
 	struct isl_set_map_pair *domain;
@@ -3488,15 +4683,23 @@
  * data->domaini.set contains the domain of the inverse schedule
  * for domain "i", i.e., elements in the schedule domain.
  *
+ * If we are inside a band of a schedule tree and there is a pair
+ * of elements in the two domains that is schedule together by
+ * the current band, then we check if any element of "i" may be schedule
+ * after element of "j" by the descendants of the band node.
+ *
  * If data->group_coscheduled is set, then we also return 1 if there
  * is any pair of elements in the two domains that are scheduled together.
  */
-static int any_scheduled_after(int i, int j, void *user)
+static isl_bool any_scheduled_after(int i, int j, void *user)
 {
 	struct isl_any_scheduled_after_data *data = user;
-	int dim = isl_set_dim(data->domaini.set, isl_dim_set);
+	isl_size dim = isl_set_dim(data->domaini.set, isl_dim_set);
 	int pos;
 
+	if (dim < 0)
+		return isl_bool_error;
+
 	for (pos = data->depth; pos < dim; ++pos) {
 		int follows;
 
@@ -3504,14 +4707,23 @@
 						data->domainj.set, pos);
 
 		if (follows < -1)
-			return -1;
+			return isl_bool_error;
 		if (follows > 0)
-			return 1;
+			return isl_bool_true;
 		if (follows < 0)
-			return 0;
+			return isl_bool_false;
+	}
+
+	if (isl_ast_build_has_schedule_node(data->build)) {
+		isl_bool after;
+
+		after = after_in_subtree(data->build, data->domaini.map,
+					    data->domainj.map);
+		if (after < 0 || after)
+			return after;
 	}
 
-	return data->group_coscheduled;
+	return isl_bool_ok(data->group_coscheduled);
 }
 
 /* Look for independent components at the current depth and generate code
@@ -3539,13 +4751,16 @@
 {
 	int i;
 	isl_ctx *ctx = isl_ast_build_get_ctx(build);
-	int n = isl_union_map_n_map(executed);
+	isl_size n = isl_union_map_n_map(executed);
 	struct isl_any_scheduled_after_data data;
 	struct isl_set_map_pair *next;
 	struct isl_tarjan_graph *g = NULL;
 	isl_ast_graft_list *list = NULL;
 	int n_domain = 0;
 
+	data.domain = NULL;
+	if (n < 0)
+		goto error;
 	data.domain = isl_calloc_array(ctx, struct isl_set_map_pair, n);
 	if (!data.domain)
 		goto error;
@@ -3557,6 +4772,7 @@
 
 	if (!build)
 		goto error;
+	data.build = build;
 	data.depth = isl_ast_build_get_depth(build);
 	data.group_coscheduled = isl_options_get_ast_build_group_coscheduled(ctx);
 	g = isl_tarjan_graph_init(ctx, n, &any_scheduled_after, &data);
@@ -3618,6 +4834,8 @@
 	__isl_take isl_union_map *executed, __isl_take isl_ast_build *build)
 {
 	int depth;
+	isl_size dim;
+	isl_size n;
 
 	if (!build || !executed)
 		goto error;
@@ -3630,10 +4848,16 @@
 	}
 
 	depth = isl_ast_build_get_depth(build);
-	if (depth >= isl_ast_build_dim(build, isl_dim_set))
+	dim = isl_ast_build_dim(build, isl_dim_set);
+	if (dim < 0)
+		goto error;
+	if (depth >= dim)
 		return generate_inner_level(executed, build);
 
-	if (isl_union_map_n_map(executed) == 1)
+	n = isl_union_map_n_map(executed);
+	if (n < 0)
+		goto error;
+	if (n == 1)
 		return generate_shifted_component(executed, build);
 
 	return generate_components(executed, build);
@@ -3643,7 +4867,7 @@
 	return NULL;
 }
 
-/* Internal data structure used by isl_ast_build_ast_from_schedule.
+/* Internal data structure used by isl_ast_build_node_from_schedule_map.
  * internal, executed and build are the inputs to generate_code.
  * list collects the output.
  */
@@ -3701,7 +4925,8 @@
  * It is equal to the space of "set" if build->domain is parametric.
  * Otherwise, it is equal to the range of the wrapped space of "set".
  *
- * If the build space is not parametric and if isl_ast_build_ast_from_schedule
+ * If the build space is not parametric and
+ * if isl_ast_build_node_from_schedule_map
  * was called from an outside user (data->internal not set), then
  * the (inverse) schedule refers to the external build domain and needs to
  * be transformed to refer to the internal build domain.
@@ -3727,7 +4952,7 @@
  * on the resulting isl_ast_node_list so that it can be used within
  * the outer AST build.
  */
-static int generate_code_in_space(struct isl_generate_code_data *data,
+static isl_stat generate_code_in_space(struct isl_generate_code_data *data,
 	__isl_take isl_set *set, __isl_take isl_space *space)
 {
 	isl_union_map *executed;
@@ -3758,7 +4983,7 @@
 
 	data->list = isl_ast_graft_list_concat(data->list, list);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Generate an AST that visits the elements in the range of data->executed
@@ -3778,7 +5003,7 @@
  * passing along T.
  * If the build space is not parametric, then T is the space of "set".
  */
-static int generate_code_set(__isl_take isl_set *set, void *user)
+static isl_stat generate_code_set(__isl_take isl_set *set, void *user)
 {
 	struct isl_generate_code_data *data = user;
 	isl_space *space, *build_space;
@@ -3805,7 +5030,7 @@
 error:
 	isl_set_free(set);
 	isl_space_free(space);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Generate an AST that visits the elements in the range of "executed"
@@ -3902,7 +5127,7 @@
  * the schedule domain in the domain and the elements to be executed
  * in the range) called "executed".
  */
-__isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
+__isl_give isl_ast_node *isl_ast_build_node_from_schedule_map(
 	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule)
 {
 	isl_ast_graft_list *list;
@@ -3912,6 +5137,7 @@
 	build = isl_ast_build_copy(build);
 	build = isl_ast_build_set_single_valued(build, 0);
 	schedule = isl_union_map_coalesce(schedule);
+	schedule = isl_union_map_remove_redundancies(schedule);
 	executed = isl_union_map_reverse(schedule);
 	list = generate_code(executed, isl_ast_build_copy(build), 0);
 	node = isl_ast_node_from_graft_list(list, build);
@@ -3919,3 +5145,778 @@
 
 	return node;
 }
+
+/* The old name for isl_ast_build_node_from_schedule_map.
+ * It is being kept for backward compatibility, but
+ * it will be removed in the future.
+ */
+__isl_give isl_ast_node *isl_ast_build_ast_from_schedule(
+	__isl_keep isl_ast_build *build, __isl_take isl_union_map *schedule)
+{
+	return isl_ast_build_node_from_schedule_map(build, schedule);
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the leaf node "node".
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * Simply pass control to generate_inner_level.
+ * Note that the current build does not refer to any band node, so
+ * that generate_inner_level will not try to visit the child of
+ * the leaf node.
+ *
+ * If multiple statement instances reach a leaf,
+ * then they can be executed in any order.
+ * Group the list of grafts based on shared guards
+ * such that identical guards are only generated once
+ * when the list is eventually passed on to isl_ast_graft_list_fuse.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_leaf(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_ast_graft_list *list;
+
+	isl_schedule_node_free(node);
+	list = generate_inner_level(executed, isl_ast_build_copy(build));
+	list = isl_ast_graft_list_group_on_guard(list, build);
+	isl_ast_build_free(build);
+
+	return list;
+}
+
+/* Check that the band partial schedule "partial" does not filter out
+ * any statement instances, as specified by the range of "executed".
+ */
+static isl_stat check_band_schedule_total_on_instances(
+	__isl_keep isl_multi_union_pw_aff *partial,
+	__isl_keep isl_union_map *executed)
+{
+	isl_bool subset;
+	isl_union_set *domain, *instances;
+
+	instances = isl_union_map_range(isl_union_map_copy(executed));
+	partial = isl_multi_union_pw_aff_copy(partial);
+	domain = isl_multi_union_pw_aff_domain(partial);
+	subset = isl_union_set_is_subset(instances, domain);
+	isl_union_set_free(domain);
+	isl_union_set_free(instances);
+
+	if (subset < 0)
+		return isl_stat_error;
+	if (!subset)
+		isl_die(isl_union_map_get_ctx(executed), isl_error_invalid,
+			"band node is not allowed to drop statement instances",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the band node "node" and its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * If the band is empty, we continue with its descendants.
+ * Otherwise, we extend the build and the inverse schedule with
+ * the additional space/partial schedule and continue generating
+ * an AST in generate_next_level.
+ * As soon as we have extended the inverse schedule with the additional
+ * partial schedule, we look for equalities that may exists between
+ * the old and the new part.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_band(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_space *space;
+	isl_multi_union_pw_aff *extra;
+	isl_union_map *extra_umap;
+	isl_ast_graft_list *list;
+	isl_size n1, n2;
+	isl_size n;
+
+	n = isl_schedule_node_band_n_member(node);
+	if (!build || n < 0 || !executed)
+		goto error;
+
+	if (n == 0)
+		return build_ast_from_child(build, node, executed);
+
+	extra = isl_schedule_node_band_get_partial_schedule(node);
+	extra = isl_multi_union_pw_aff_align_params(extra,
+				isl_ast_build_get_space(build, 1));
+	space = isl_multi_union_pw_aff_get_space(extra);
+
+	if (check_band_schedule_total_on_instances(extra, executed) < 0)
+		executed = isl_union_map_free(executed);
+
+	extra_umap = isl_union_map_from_multi_union_pw_aff(extra);
+	extra_umap = isl_union_map_reverse(extra_umap);
+
+	executed = isl_union_map_domain_product(executed, extra_umap);
+	executed = isl_union_map_detect_equalities(executed);
+
+	n1 = isl_ast_build_dim(build, isl_dim_param);
+	build = isl_ast_build_product(build, space);
+	n2 = isl_ast_build_dim(build, isl_dim_param);
+	if (n1 < 0 || n2 < 0)
+		build = isl_ast_build_free(build);
+	else if (n2 > n1)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_invalid,
+			"band node is not allowed to introduce new parameters",
+			build = isl_ast_build_free(build));
+	build = isl_ast_build_set_schedule_node(build, node);
+
+	list = generate_next_level(executed, build);
+
+	list = isl_ast_graft_list_unembed(list, 1);
+
+	return list;
+error:
+	isl_schedule_node_free(node);
+	isl_union_map_free(executed);
+	isl_ast_build_free(build);
+	return NULL;
+}
+
+/* Hoist a list of grafts (in practice containing a single graft)
+ * from "sub_build" (which includes extra context information)
+ * to "build".
+ *
+ * In particular, project out all additional parameters introduced
+ * by the context node from the enforced constraints and the guard
+ * of the single graft.
+ */
+static __isl_give isl_ast_graft_list *hoist_out_of_context(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build,
+	__isl_keep isl_ast_build *sub_build)
+{
+	isl_ast_graft *graft;
+	isl_basic_set *enforced;
+	isl_set *guard;
+	isl_size n_param, extra_param;
+
+	n_param = isl_ast_build_dim(build, isl_dim_param);
+	extra_param = isl_ast_build_dim(sub_build, isl_dim_param);
+	if (n_param < 0 || extra_param < 0)
+		return isl_ast_graft_list_free(list);
+
+	if (extra_param == n_param)
+		return list;
+
+	extra_param -= n_param;
+	enforced = isl_ast_graft_list_extract_shared_enforced(list, sub_build);
+	enforced = isl_basic_set_project_out(enforced, isl_dim_param,
+							n_param, extra_param);
+	enforced = isl_basic_set_remove_unknown_divs(enforced);
+	guard = isl_ast_graft_list_extract_hoistable_guard(list, sub_build);
+	guard = isl_set_remove_divs_involving_dims(guard, isl_dim_param,
+							n_param, extra_param);
+	guard = isl_set_project_out(guard, isl_dim_param, n_param, extra_param);
+	guard = isl_set_compute_divs(guard);
+	graft = isl_ast_graft_alloc_from_children(list, guard, enforced,
+							build, sub_build);
+	list = isl_ast_graft_list_from_ast_graft(graft);
+
+	return list;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the context node "node"
+ * and its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * The context node may introduce additional parameters as well as
+ * constraints on the outer schedule dimensions or original parameters.
+ *
+ * We add the extra parameters to a new build and the context
+ * constraints to both the build and (as a single disjunct)
+ * to the domain of "executed".  Since the context constraints
+ * are specified in terms of the input schedule, we first need
+ * to map them to the internal schedule domain.
+ *
+ * After constructing the AST from the descendants of "node",
+ * we combine the list of grafts into a single graft within
+ * the new build, in order to be able to exploit the additional
+ * context constraints during this combination.
+ *
+ * Additionally, if the current node is the outermost node in
+ * the schedule tree (apart from the root domain node), we generate
+ * all pending guards, again to be able to exploit the additional
+ * context constraints.  We currently do not do this for internal
+ * context nodes since we may still want to hoist conditions
+ * to outer AST nodes.
+ *
+ * If the context node introduced any new parameters, then they
+ * are removed from the set of enforced constraints and guard
+ * in hoist_out_of_context.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_context(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_set *context;
+	isl_space *space;
+	isl_multi_aff *internal2input;
+	isl_ast_build *sub_build;
+	isl_ast_graft_list *list;
+	isl_size n;
+	isl_size depth;
+
+	depth = isl_schedule_node_get_tree_depth(node);
+	if (depth < 0)
+		build = isl_ast_build_free(build);
+	space = isl_ast_build_get_space(build, 1);
+	context = isl_schedule_node_context_get_context(node);
+	context = isl_set_align_params(context, space);
+	sub_build = isl_ast_build_copy(build);
+	space = isl_set_get_space(context);
+	sub_build = isl_ast_build_align_params(sub_build, space);
+	internal2input = isl_ast_build_get_internal2input(sub_build);
+	context = isl_set_preimage_multi_aff(context, internal2input);
+	sub_build = isl_ast_build_restrict_generated(sub_build,
+					isl_set_copy(context));
+	context = isl_set_from_basic_set(isl_set_simple_hull(context));
+	executed = isl_union_map_intersect_domain(executed,
+					isl_union_set_from_set(context));
+
+	list = build_ast_from_child(isl_ast_build_copy(sub_build),
+						node, executed);
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		list = isl_ast_graft_list_free(list);
+
+	list = isl_ast_graft_list_fuse(list, sub_build);
+	if (depth == 1)
+		list = isl_ast_graft_list_insert_pending_guard_nodes(list,
+								sub_build);
+	if (n >= 1)
+		list = hoist_out_of_context(list, build, sub_build);
+
+	isl_ast_build_free(build);
+	isl_ast_build_free(sub_build);
+
+	return list;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the expansion node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * We expand the domain elements by the expansion and
+ * continue with the descendants of the node.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_expansion(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_union_map *expansion;
+	isl_size n1, n2;
+
+	expansion = isl_schedule_node_expansion_get_expansion(node);
+	expansion = isl_union_map_align_params(expansion,
+				isl_union_map_get_space(executed));
+
+	n1 = isl_union_map_dim(executed, isl_dim_param);
+	executed = isl_union_map_apply_range(executed, expansion);
+	n2 = isl_union_map_dim(executed, isl_dim_param);
+	if (n1 < 0 || n2 < 0)
+		goto error;
+	if (n2 > n1)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_invalid,
+			"expansion node is not allowed to introduce "
+			"new parameters", goto error);
+
+	return build_ast_from_child(build, node, executed);
+error:
+	isl_ast_build_free(build);
+	isl_schedule_node_free(node);
+	isl_union_map_free(executed);
+	return NULL;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the extension node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * Extend the inverse schedule with the extension applied to current
+ * set of generated constraints.  Since the extension if formulated
+ * in terms of the input schedule, it first needs to be transformed
+ * to refer to the internal schedule.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_extension(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_union_set *schedule_domain;
+	isl_union_map *extension;
+	isl_set *set;
+
+	set = isl_ast_build_get_generated(build);
+	set = isl_set_from_basic_set(isl_set_simple_hull(set));
+	schedule_domain = isl_union_set_from_set(set);
+
+	extension = isl_schedule_node_extension_get_extension(node);
+
+	extension = isl_union_map_preimage_domain_multi_aff(extension,
+			isl_multi_aff_copy(build->internal2input));
+	extension = isl_union_map_intersect_domain(extension, schedule_domain);
+	extension = isl_ast_build_substitute_values_union_map_domain(build,
+								    extension);
+	executed = isl_union_map_union(executed, extension);
+
+	return build_ast_from_child(build, node, executed);
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the filter node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * We simply intersect the iteration domain (i.e., the range of "executed")
+ * with the filter and continue with the descendants of the node,
+ * unless the resulting inverse schedule is empty, in which
+ * case we return an empty list.
+ *
+ * If the result of the intersection is equal to the original "executed"
+ * relation, then keep the original representation since the intersection
+ * may have unnecessarily broken up the relation into a greater number
+ * of disjuncts.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_filter(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_ctx *ctx;
+	isl_union_set *filter;
+	isl_union_map *orig;
+	isl_ast_graft_list *list;
+	int empty;
+	isl_bool unchanged;
+	isl_size n1, n2;
+
+	orig = isl_union_map_copy(executed);
+	if (!build || !node || !executed)
+		goto error;
+
+	filter = isl_schedule_node_filter_get_filter(node);
+	filter = isl_union_set_align_params(filter,
+				isl_union_map_get_space(executed));
+	n1 = isl_union_map_dim(executed, isl_dim_param);
+	executed = isl_union_map_intersect_range(executed, filter);
+	n2 = isl_union_map_dim(executed, isl_dim_param);
+	if (n1 < 0 || n2 < 0)
+		goto error;
+	if (n2 > n1)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_invalid,
+			"filter node is not allowed to introduce "
+			"new parameters", goto error);
+
+	unchanged = isl_union_map_is_subset(orig, executed);
+	empty = isl_union_map_is_empty(executed);
+	if (unchanged < 0 || empty < 0)
+		goto error;
+	if (unchanged) {
+		isl_union_map_free(executed);
+		return build_ast_from_child(build, node, orig);
+	}
+	isl_union_map_free(orig);
+	if (!empty)
+		return build_ast_from_child(build, node, executed);
+
+	ctx = isl_ast_build_get_ctx(build);
+	list = isl_ast_graft_list_alloc(ctx, 0);
+	isl_ast_build_free(build);
+	isl_schedule_node_free(node);
+	isl_union_map_free(executed);
+	return list;
+error:
+	isl_ast_build_free(build);
+	isl_schedule_node_free(node);
+	isl_union_map_free(executed);
+	isl_union_map_free(orig);
+	return NULL;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the guard node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * Ensure that the associated guard is enforced by the outer AST
+ * constructs by adding it to the guard of the graft.
+ * Since we know that we will enforce the guard, we can also include it
+ * in the generated constraints used to construct an AST for
+ * the descendant nodes.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_guard(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_space *space;
+	isl_set *guard, *hoisted;
+	isl_basic_set *enforced;
+	isl_ast_build *sub_build;
+	isl_ast_graft *graft;
+	isl_ast_graft_list *list;
+	isl_size n1, n2, n;
+
+	space = isl_ast_build_get_space(build, 1);
+	guard = isl_schedule_node_guard_get_guard(node);
+	n1 = isl_space_dim(space, isl_dim_param);
+	guard = isl_set_align_params(guard, space);
+	n2 = isl_set_dim(guard, isl_dim_param);
+	if (n1 < 0 || n2 < 0)
+		guard = isl_set_free(guard);
+	else if (n2 > n1)
+		isl_die(isl_ast_build_get_ctx(build), isl_error_invalid,
+			"guard node is not allowed to introduce "
+			"new parameters", guard = isl_set_free(guard));
+	guard = isl_set_preimage_multi_aff(guard,
+			isl_multi_aff_copy(build->internal2input));
+	guard = isl_ast_build_specialize(build, guard);
+	guard = isl_set_gist(guard, isl_set_copy(build->generated));
+
+	sub_build = isl_ast_build_copy(build);
+	sub_build = isl_ast_build_restrict_generated(sub_build,
+							isl_set_copy(guard));
+
+	list = build_ast_from_child(isl_ast_build_copy(sub_build),
+							node, executed);
+
+	hoisted = isl_ast_graft_list_extract_hoistable_guard(list, sub_build);
+	n = isl_set_n_basic_set(hoisted);
+	if (n < 0)
+		list = isl_ast_graft_list_free(list);
+	if (n > 1)
+		list = isl_ast_graft_list_gist_guards(list,
+						    isl_set_copy(hoisted));
+	guard = isl_set_intersect(guard, hoisted);
+	enforced = extract_shared_enforced(list, build);
+	graft = isl_ast_graft_alloc_from_children(list, guard, enforced,
+						    build, sub_build);
+
+	isl_ast_build_free(sub_build);
+	isl_ast_build_free(build);
+	return isl_ast_graft_list_from_ast_graft(graft);
+}
+
+/* Call the before_each_mark callback, if requested by the user.
+ *
+ * Return 0 on success and -1 on error.
+ *
+ * The caller is responsible for recording the current inverse schedule
+ * in "build".
+ */
+static isl_stat before_each_mark(__isl_keep isl_id *mark,
+	__isl_keep isl_ast_build *build)
+{
+	if (!build)
+		return isl_stat_error;
+	if (!build->before_each_mark)
+		return isl_stat_ok;
+	return build->before_each_mark(mark, build,
+					build->before_each_mark_user);
+}
+
+/* Call the after_each_mark callback, if requested by the user.
+ *
+ * The caller is responsible for recording the current inverse schedule
+ * in "build".
+ */
+static __isl_give isl_ast_graft *after_each_mark(
+	__isl_take isl_ast_graft *graft, __isl_keep isl_ast_build *build)
+{
+	if (!graft || !build)
+		return isl_ast_graft_free(graft);
+	if (!build->after_each_mark)
+		return graft;
+	graft->node = build->after_each_mark(graft->node, build,
+						build->after_each_mark_user);
+	if (!graft->node)
+		return isl_ast_graft_free(graft);
+	return graft;
+}
+
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the mark node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+
+ * Since we may be calling before_each_mark and after_each_mark
+ * callbacks, we record the current inverse schedule in the build.
+ *
+ * We generate an AST for the child of the mark node, combine
+ * the graft list into a single graft and then insert the mark
+ * in the AST of that single graft.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_mark(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	isl_id *mark;
+	isl_ast_graft *graft;
+	isl_ast_graft_list *list;
+	isl_size n;
+
+	build = isl_ast_build_set_executed(build, isl_union_map_copy(executed));
+
+	mark = isl_schedule_node_mark_get_id(node);
+	if (before_each_mark(mark, build) < 0)
+		node = isl_schedule_node_free(node);
+
+	list = build_ast_from_child(isl_ast_build_copy(build), node, executed);
+	list = isl_ast_graft_list_fuse(list, build);
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		list = isl_ast_graft_list_free(list);
+	if (n == 0) {
+		isl_id_free(mark);
+	} else {
+		graft = isl_ast_graft_list_get_ast_graft(list, 0);
+		graft = isl_ast_graft_insert_mark(graft, mark);
+		graft = after_each_mark(graft, build);
+		list = isl_ast_graft_list_set_ast_graft(list, 0, graft);
+	}
+	isl_ast_build_free(build);
+
+	return list;
+}
+
+static __isl_give isl_ast_graft_list *build_ast_from_schedule_node(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed);
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the sequence (or set) node "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * We simply generate an AST for each of the children and concatenate
+ * the results.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_sequence(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	int i;
+	isl_size n;
+	isl_ctx *ctx;
+	isl_ast_graft_list *list;
+
+	ctx = isl_ast_build_get_ctx(build);
+	list = isl_ast_graft_list_alloc(ctx, 0);
+
+	n = isl_schedule_node_n_children(node);
+	if (n < 0)
+		list = isl_ast_graft_list_free(list);
+	for (i = 0; i < n; ++i) {
+		isl_schedule_node *child;
+		isl_ast_graft_list *list_i;
+
+		child = isl_schedule_node_get_child(node, i);
+		list_i = build_ast_from_schedule_node(isl_ast_build_copy(build),
+					child, isl_union_map_copy(executed));
+		list = isl_ast_graft_list_concat(list, list_i);
+	}
+	isl_ast_build_free(build);
+	isl_schedule_node_free(node);
+	isl_union_map_free(executed);
+
+	return list;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the node "node" and its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * The node types are handled in separate functions.
+ * Set nodes are currently treated in the same way as sequence nodes.
+ * The children of a set node may be executed in any order,
+ * including the order of the children.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_schedule_node(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	enum isl_schedule_node_type type;
+
+	type = isl_schedule_node_get_type(node);
+
+	switch (type) {
+	case isl_schedule_node_error:
+		goto error;
+	case isl_schedule_node_leaf:
+		return build_ast_from_leaf(build, node, executed);
+	case isl_schedule_node_band:
+		return build_ast_from_band(build, node, executed);
+	case isl_schedule_node_context:
+		return build_ast_from_context(build, node, executed);
+	case isl_schedule_node_domain:
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_unsupported,
+			"unexpected internal domain node", goto error);
+	case isl_schedule_node_expansion:
+		return build_ast_from_expansion(build, node, executed);
+	case isl_schedule_node_extension:
+		return build_ast_from_extension(build, node, executed);
+	case isl_schedule_node_filter:
+		return build_ast_from_filter(build, node, executed);
+	case isl_schedule_node_guard:
+		return build_ast_from_guard(build, node, executed);
+	case isl_schedule_node_mark:
+		return build_ast_from_mark(build, node, executed);
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		return build_ast_from_sequence(build, node, executed);
+	}
+
+	isl_die(isl_ast_build_get_ctx(build), isl_error_internal,
+		"unhandled type", goto error);
+error:
+	isl_union_map_free(executed);
+	isl_schedule_node_free(node);
+	isl_ast_build_free(build);
+
+	return NULL;
+}
+
+/* Generate an AST that visits the elements in the domain of "executed"
+ * in the relative order specified by the (single) child of "node" and
+ * its descendants.
+ *
+ * The relation "executed" maps the outer generated loop iterators
+ * to the domain elements executed by those iterations.
+ *
+ * This function is never called on a leaf, set or sequence node,
+ * so the node always has exactly one child.
+ */
+static __isl_give isl_ast_graft_list *build_ast_from_child(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *executed)
+{
+	node = isl_schedule_node_child(node, 0);
+	return build_ast_from_schedule_node(build, node, executed);
+}
+
+/* Generate an AST that visits the elements in the domain of the domain
+ * node "node" in the relative order specified by its descendants.
+ *
+ * An initial inverse schedule is created that maps a zero-dimensional
+ * schedule space to the node domain.
+ * The input "build" is assumed to have a parametric domain and
+ * is replaced by the same zero-dimensional schedule space.
+ *
+ * We also add some of the parameter constraints in the build domain
+ * to the executed relation.  Adding these constraints
+ * allows for an earlier detection of conflicts in some cases.
+ * However, we do not want to divide the executed relation into
+ * more disjuncts than necessary.  We therefore approximate
+ * the constraints on the parameters by a single disjunct set.
+ */
+static __isl_give isl_ast_node *build_ast_from_domain(
+	__isl_take isl_ast_build *build, __isl_take isl_schedule_node *node)
+{
+	isl_ctx *ctx;
+	isl_union_set *domain, *schedule_domain;
+	isl_union_map *executed;
+	isl_space *space;
+	isl_set *set;
+	isl_ast_graft_list *list;
+	isl_ast_node *ast;
+	int is_params;
+
+	if (!build)
+		goto error;
+
+	ctx = isl_ast_build_get_ctx(build);
+	space = isl_ast_build_get_space(build, 1);
+	is_params = isl_space_is_params(space);
+	isl_space_free(space);
+	if (is_params < 0)
+		goto error;
+	if (!is_params)
+		isl_die(ctx, isl_error_unsupported,
+			"expecting parametric initial context", goto error);
+
+	domain = isl_schedule_node_domain_get_domain(node);
+	domain = isl_union_set_coalesce(domain);
+
+	space = isl_union_set_get_space(domain);
+	space = isl_space_set_from_params(space);
+	build = isl_ast_build_product(build, space);
+
+	set = isl_ast_build_get_domain(build);
+	set = isl_set_from_basic_set(isl_set_simple_hull(set));
+	schedule_domain = isl_union_set_from_set(set);
+
+	executed = isl_union_map_from_domain_and_range(schedule_domain, domain);
+	list = build_ast_from_child(isl_ast_build_copy(build), node, executed);
+	ast = isl_ast_node_from_graft_list(list, build);
+	isl_ast_build_free(build);
+
+	return ast;
+error:
+	isl_schedule_node_free(node);
+	isl_ast_build_free(build);
+	return NULL;
+}
+
+/* Generate an AST that visits the elements in the domain of "schedule"
+ * in the relative order specified by the schedule tree.
+ *
+ * "build" is an isl_ast_build that has been created using
+ * isl_ast_build_alloc or isl_ast_build_from_context based
+ * on a parametric set.
+ *
+ * The construction starts at the root node of the schedule,
+ * which is assumed to be a domain node.
+ */
+__isl_give isl_ast_node *isl_ast_build_node_from_schedule(
+	__isl_keep isl_ast_build *build, __isl_take isl_schedule *schedule)
+{
+	isl_ctx *ctx;
+	isl_schedule_node *node;
+
+	if (!build || !schedule)
+		goto error;
+
+	ctx = isl_ast_build_get_ctx(build);
+
+	node = isl_schedule_get_root(schedule);
+	if (!node)
+		goto error;
+	isl_schedule_free(schedule);
+
+	build = isl_ast_build_copy(build);
+	build = isl_ast_build_set_single_valued(build, 0);
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_domain)
+		isl_die(ctx, isl_error_unsupported,
+			"expecting root domain node",
+			build = isl_ast_build_free(build));
+	return build_ast_from_domain(build, node);
+error:
+	isl_schedule_free(schedule);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_ast_graft.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_graft.c Changed

@@ -1,6 +1,7 @@
 /*
  * Copyright 2012      Ecole Normale Superieure
  * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2019      Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -8,18 +9,22 @@
  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
  * B.P. 105 - 78153 Le Chesnay, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
+#include <isl/id.h>
+#include <isl/space.h>
 #include <isl_ast_private.h>
 #include <isl_ast_build_expr.h>
 #include <isl_ast_build_private.h>
 #include <isl_ast_graft_private.h>
+#include "isl_set_to_ast_graft_list.h"
 
 static __isl_give isl_ast_graft *isl_ast_graft_copy(
 	__isl_keep isl_ast_graft *graft);
 
-#undef BASE
-#define BASE ast_graft
+#undef EL_BASE
+#define EL_BASE ast_graft
 
 #include <isl_list_templ.c>
 
@@ -100,32 +105,43 @@
 /* Do all the grafts in "list" have the same guard and is this guard
  * independent of the current depth?
  */
-static int equal_independent_guards(__isl_keep isl_ast_graft_list *list,
+static isl_bool equal_independent_guards(__isl_keep isl_ast_graft_list *list,
 	__isl_keep isl_ast_build *build)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	int depth;
+	isl_size dim;
 	isl_ast_graft *graft_0;
-	int equal = 1;
-	int skip;
+	isl_bool equal = isl_bool_true;
+	isl_bool skip;
 
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return isl_bool_error;
 	graft_0 = isl_ast_graft_list_get_ast_graft(list, 0);
 	if (!graft_0)
-		return -1;
+		return isl_bool_error;
 
 	depth = isl_ast_build_get_depth(build);
-	skip = isl_set_involves_dims(graft_0->guard, isl_dim_set, depth, 1);
+	dim = isl_set_dim(graft_0->guard, isl_dim_set);
+	if (dim < 0)
+		return isl_bool_error;
+	if (dim <= depth)
+		skip = isl_bool_false;
+	else
+		skip = isl_set_involves_dims(graft_0->guard,
+						isl_dim_set, depth, 1);
 	if (skip < 0 || skip) {
 		isl_ast_graft_free(graft_0);
-		return skip < 0 ? -1 : 0;
+		return isl_bool_not(skip);
 	}
 
-	n = isl_ast_graft_list_n_ast_graft(list);
 	for (i = 1; i < n; ++i) {
 		isl_ast_graft *graft;
 		graft = isl_ast_graft_list_get_ast_graft(list, i);
 		if (!graft)
-			equal = -1;
+			equal = isl_bool_error;
 		else
 			equal = isl_set_is_equal(graft_0->guard, graft->guard);
 		isl_ast_graft_free(graft);
@@ -146,9 +162,13 @@
 	__isl_keep isl_ast_build *build)
 {
 	int depth;
+	isl_size dim;
 
 	depth = isl_ast_build_get_depth(build);
-	if (depth < isl_set_dim(guard, isl_dim_set)) {
+	dim = isl_set_dim(guard, isl_dim_set);
+	if (dim < 0)
+		return isl_set_free(guard);
+	if (depth < dim) {
 		guard = isl_set_remove_divs_involving_dims(guard,
 						isl_dim_set, depth, 1);
 		guard = isl_set_eliminate(guard, isl_dim_set, depth, 1);
@@ -187,8 +207,9 @@
 __isl_give isl_set *isl_ast_graft_list_extract_hoistable_guard(
 	__isl_keep isl_ast_graft_list *list, __isl_keep isl_ast_build *build)
 {
-	int i, n;
-	int equal;
+	int i;
+	isl_size n;
+	isl_bool equal;
 	isl_ctx *ctx;
 	isl_set *guard;
 	isl_set_list *set_list;
@@ -198,6 +219,8 @@
 		return NULL;
 
 	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return NULL;
 	if (n == 0)
 		return isl_set_universe(isl_ast_build_get_space(build, 1));
 
@@ -254,7 +277,7 @@
 	isl_ast_build *build;
 };
 
-static int insert_if(__isl_take isl_basic_set *bset, void *user);
+static isl_stat insert_if(__isl_take isl_basic_set *bset, void *user);
 
 /* Insert an if node around "node" testing the condition encoded
  * in guard "guard".
@@ -271,14 +294,17 @@
 {
 	struct isl_insert_if_data data;
 	isl_ctx *ctx;
+	isl_size n;
 
+	n = isl_set_n_basic_set(guard);
+	if (n < 0)
+		goto error;
 	ctx = isl_ast_build_get_ctx(build);
-	if (isl_options_get_ast_build_allow_or(ctx) ||
-	    isl_set_n_basic_set(guard) <= 1) {
+	if (isl_options_get_ast_build_allow_or(ctx) || n <= 1) {
 		isl_ast_node *if_node;
 		isl_ast_expr *expr;
 
-		expr = isl_ast_build_expr_from_set(build, guard);
+		expr = isl_ast_build_expr_from_set_internal(build, guard);
 
 		if_node = isl_ast_node_alloc_if(expr);
 		return isl_ast_node_if_set_then(if_node, node);
@@ -295,12 +321,16 @@
 	isl_set_free(guard);
 	isl_ast_node_free(data.node);
 	return isl_ast_node_alloc_block(data.list);
+error:
+	isl_set_free(guard);
+	isl_ast_node_free(node);
+	return NULL;
 }
 
 /* Insert an if node around a copy of "data->node" testing the condition
  * encoded in guard "bset" and add the result to data->list.
  */
-static int insert_if(__isl_take isl_basic_set *bset, void *user)
+static isl_stat insert_if(__isl_take isl_basic_set *bset, void *user)
 {
 	struct isl_insert_if_data *data = user;
 	isl_ast_node *node;
@@ -311,7 +341,7 @@
 	node = ast_node_insert_if(node, set, data->build);
 	data->list = isl_ast_node_list_add(data->list, node);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Insert an if node around graft->node testing the condition encoded
@@ -383,10 +413,14 @@
 	__isl_take isl_basic_set *enforced, __isl_keep isl_ast_graft *graft,
 	int depth)
 {
+	isl_size dim;
 	isl_basic_set *enforced_g;
 
 	enforced_g = isl_ast_graft_get_enforced(graft);
-	if (depth < isl_basic_set_dim(enforced_g, isl_dim_set))
+	dim = isl_basic_set_dim(enforced_g, isl_dim_set);
+	if (dim < 0)
+		enforced_g = isl_basic_set_free(enforced_g);
+	if (depth < dim)
 		enforced_g = isl_basic_set_eliminate(enforced_g,
 							isl_dim_set, depth, 1);
 	enforced_g = isl_basic_set_remove_unknown_divs(enforced_g);
@@ -438,19 +472,19 @@
 	__isl_keep isl_ast_node **body, __isl_take isl_ast_graft *graft,
 	__isl_keep isl_ast_build *build)
 {
-	int n;
+	isl_size n;
 	int depth;
 	isl_ast_graft *last;
 	isl_space *space;
 	isl_basic_set *enforced;
 
-	if (!list || !graft)
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0 || !graft)
 		goto error;
 	extend_body(body, isl_ast_node_copy(graft->node));
 	if (!*body)
 		goto error;
 
-	n = isl_ast_graft_list_n_ast_graft(list);
 	last = isl_ast_graft_list_get_ast_graft(list, n - 1);
 
 	depth = isl_ast_build_get_depth(build);
@@ -537,17 +571,18 @@
 	__isl_take isl_ast_graft_list *list,
 	__isl_keep isl_ast_build *build)
 {
-	int i, j, n, n_if;
+	int i, j, n_if;
+	isl_size n;
 	int allow_else;
 	isl_ctx *ctx;
 	isl_ast_graft_list *res;
 	struct isl_if_node *if_node = NULL;
 
-	if (!build || !list)
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (!build || n < 0)
 		return isl_ast_graft_list_free(list);
 
 	ctx = isl_ast_build_get_ctx(build);
-	n = isl_ast_graft_list_n_ast_graft(list);
 
 	allow_else = isl_options_get_ast_build_allow_else(ctx);
 
@@ -649,19 +684,57 @@
 	return res;
 }
 
+/* For each graft in "list",
+ * insert an if node around graft->node testing the condition encoded
+ * in graft->guard, assuming graft->guard involves any conditions.
+ * Subsequently remove the guards from the grafts.
+ */
+__isl_give isl_ast_graft_list *isl_ast_graft_list_insert_pending_guard_nodes(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build)
+{
+	int i;
+	isl_size n;
+	isl_set *universe;
+
+	list = insert_pending_guard_nodes(list, build);
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return isl_ast_graft_list_free(list);
+
+	universe = isl_set_universe(isl_ast_build_get_space(build, 1));
+	for (i = 0; i < n; ++i) {
+		isl_ast_graft *graft;
+
+		graft = isl_ast_graft_list_get_ast_graft(list, i);
+		if (!graft)
+			break;
+		isl_set_free(graft->guard);
+		graft->guard = isl_set_copy(universe);
+		if (!graft->guard)
+			graft = isl_ast_graft_free(graft);
+		list = isl_ast_graft_list_set_ast_graft(list, i, graft);
+	}
+	isl_set_free(universe);
+	if (i < n)
+		return isl_ast_graft_list_free(list);
+
+	return list;
+}
+
 /* Collect the nodes contained in the grafts in "list" in a node list.
  */
 static __isl_give isl_ast_node_list *extract_node_list(
 	__isl_keep isl_ast_graft_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_ast_node_list *node_list;
 
-	if (!list)
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
 		return NULL;
 	ctx = isl_ast_graft_list_get_ctx(list);
-	n = isl_ast_graft_list_n_ast_graft(list);
 	node_list = isl_ast_node_list_alloc(ctx, n);
 	for (i = 0; i < n; ++i) {
 		isl_ast_node *node;
@@ -679,25 +752,21 @@
 /* Look for shared enforced constraints by all the elements in "list"
  * on outer loops (with respect to the current depth) and return the result.
  *
- * We assume that the number of children is at least one.
+ * If there are no elements in "list", then return the empty set.
  */
 __isl_give isl_basic_set *isl_ast_graft_list_extract_shared_enforced(
 	__isl_keep isl_ast_graft_list *list,
 	__isl_keep isl_ast_build *build)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	int depth;
 	isl_space *space;
 	isl_basic_set *enforced;
 
-	if (!list)
-		return NULL;
-
 	n = isl_ast_graft_list_n_ast_graft(list);
-	if (n == 0)
-		isl_die(isl_ast_graft_list_get_ctx(list), isl_error_invalid,
-			"for node should have at least one child",
-			return NULL);
+	if (n < 0)
+		return NULL;
 
 	space = isl_ast_build_get_space(build, 1);
 	enforced = isl_basic_set_empty(space);
@@ -757,12 +826,13 @@
 static __isl_give isl_ast_graft_list *gist_guards(
 	__isl_take isl_ast_graft_list *list, __isl_keep isl_set *context)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
+	n = isl_ast_graft_list_n_ast_graft(list);
 	if (!list)
-		return NULL;
+		return isl_ast_graft_list_free(list);
 
-	n = isl_ast_graft_list_n_ast_graft(list);
 	for (i = 0; i < n; ++i) {
 		isl_ast_graft *graft;
 
@@ -872,11 +942,13 @@
 	__isl_take isl_ast_graft_list *list,
 	__isl_keep isl_ast_build *build)
 {
+	isl_size n;
 	isl_ast_graft *graft;
 
-	if (!list)
-		return NULL;
-	if (isl_ast_graft_list_n_ast_graft(list) <= 1)
+	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return isl_ast_graft_list_free(list);
+	if (n <= 1)
 		return list;
 	graft = ast_graft_list_fuse(list, build);
 	return isl_ast_graft_list_from_ast_graft(graft);
@@ -920,6 +992,25 @@
 	return NULL;
 }
 
+/* Insert a mark governing the current graft->node.
+ */
+__isl_give isl_ast_graft *isl_ast_graft_insert_mark(
+	__isl_take isl_ast_graft *graft, __isl_take isl_id *mark)
+{
+	if (!graft)
+		goto error;
+
+	graft->node = isl_ast_node_alloc_mark(mark, graft->node);
+	if (!graft->node)
+		return isl_ast_graft_free(graft);
+
+	return graft;
+error:
+	isl_id_free(mark);
+	isl_ast_graft_free(graft);
+	return NULL;
+}
+
 /* Represent the graft list as an AST node.
  * This operation drops the information about guards in the grafts, so
  * if there are any pending guards, then they are materialized as if nodes.
@@ -937,7 +1028,7 @@
 	return isl_ast_node_from_ast_node_list(node_list);
 }
 
-void *isl_ast_graft_free(__isl_take isl_ast_graft *graft)
+__isl_null isl_ast_graft *isl_ast_graft_free(__isl_take isl_ast_graft *graft)
 {
 	if (!graft)
 		return NULL;
@@ -1042,9 +1133,12 @@
 __isl_give isl_ast_graft_list *isl_ast_graft_list_unembed(
 	__isl_take isl_ast_graft_list *list, int product)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
 	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		return isl_ast_graft_list_free(list);
 	for (i = 0; i < n; ++i) {
 		isl_ast_graft *graft;
 
@@ -1084,9 +1178,12 @@
 __isl_give isl_ast_graft_list *isl_ast_graft_list_preimage_multi_aff(
 	__isl_take isl_ast_graft_list *list, __isl_take isl_multi_aff *ma)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
 	n = isl_ast_graft_list_n_ast_graft(list);
+	if (n < 0)
+		list = isl_ast_graft_list_free(list);
 	for (i = 0; i < n; ++i) {
 		isl_ast_graft *graft;
 
@@ -1176,6 +1273,7 @@
 				disjoint = isl_set_is_disjoint(graft->guard,
 							list1->pj - 1->guard);
 				if (disjoint < 0) {
+					isl_ast_graft_free(graft);
 					list1 = isl_ast_graft_list_free(list1);
 					break;
 				}
@@ -1199,10 +1297,12 @@
 			break;
 		}
 
-		if (j < 0)
+		if (j < 0) {
+			isl_ast_graft_free(graft);
 			isl_die(isl_ast_build_get_ctx(build),
 				isl_error_internal,
 				"element failed to get inserted", break);
+		}
 
 		first = j + 1;
 		if (!list1)
@@ -1219,6 +1319,130 @@
 	return NULL;
 }
 
+/* Internal data structure for split_on_guard.
+ *
+ * "guard2list" is the constructed associative array.
+ * "any_match" gets set if any guard was seen more than once.
+ */
+struct isl_split_on_guard_data {
+	isl_set_to_ast_graft_list *guard2list;
+	int *any_match;
+};
+
+/* Add "graft" to the list associated to its guard in data->guard2list.
+ * If some other graft was already associated to this guard,
+ * then set data->any_match.
+ */
+static isl_stat add_to_guard_list(__isl_take isl_ast_graft *graft, void *user)
+{
+	struct isl_split_on_guard_data *data = user;
+	isl_set *guard;
+	isl_maybe_isl_ast_graft_list m;
+
+	if (!graft)
+		return isl_stat_error;
+	m = isl_set_to_ast_graft_list_try_get(data->guard2list, graft->guard);
+	if (m.valid < 0)
+		return isl_stat_non_null(isl_ast_graft_free(graft));
+
+	if (m.valid) {
+		*data->any_match = 1;
+		m.value = isl_ast_graft_list_add(m.value, graft);
+	} else {
+		m.value = isl_ast_graft_list_from_ast_graft(graft);
+	}
+	guard = isl_set_copy(graft->guard);
+	data->guard2list =
+		isl_set_to_ast_graft_list_set(data->guard2list, guard, m.value);
+
+	return isl_stat_non_null(data->guard2list);
+}
+
+/* Construct an associative array that groups the elements
+ * of "list" based on their guards.
+ * If any guard appears more than once, then set "any_match".
+ */
+static __isl_give isl_set_to_ast_graft_list *split_on_guard(
+	__isl_keep isl_ast_graft_list *list, int *any_match)
+{
+	struct isl_split_on_guard_data data = { NULL, any_match };
+	isl_size n;
+	isl_ctx *ctx;
+
+	n = isl_ast_graft_list_size(list);
+	if (n < 0)
+		return NULL;
+
+	ctx = isl_ast_graft_list_get_ctx(list);
+	data.guard2list = isl_set_to_ast_graft_list_alloc(ctx, n);
+
+	if (isl_ast_graft_list_foreach(list, &add_to_guard_list, &data) < 0)
+		return isl_set_to_ast_graft_list_free(data.guard2list);
+
+	return data.guard2list;
+}
+
+/* Add the elements of "guard_list" to "list".
+ */
+static isl_stat add_same_guard(__isl_take isl_set *guard,
+	__isl_take isl_ast_graft_list *guard_list, void *user)
+{
+	isl_ast_graft_list **list = user;
+
+	isl_set_free(guard);
+	*list = isl_ast_graft_list_concat(*list, guard_list);
+
+	return isl_stat_non_null(*list);
+}
+
+/* Given an associative array "guard2list" containing the elements
+ * of "list" grouped on common guards, reconstruct "list"
+ * by placing elements with the same guard consecutively.
+ */
+static __isl_give isl_ast_graft_list *reconstruct(
+	__isl_take isl_ast_graft_list *list,
+	__isl_keep isl_set_to_ast_graft_list *guard2list,
+	__isl_keep isl_ast_build *build)
+{
+	list = isl_ast_graft_list_clear(list);
+	if (isl_set_to_ast_graft_list_foreach(guard2list,
+						&add_same_guard, &list) < 0)
+		list = isl_ast_graft_list_free(list);
+
+	return list;
+}
+
+/* Group the grafts in "list" based on identical guards.
+ *
+ * Note that there need to be a least three elements in the list
+ * for the elements not to be grouped already.
+ *
+ * Group the elements in an associative array based on their guards.
+ * If any guard was seen more than once, then reconstruct the list
+ * from the associative array.  Otherwise, simply return the original list.
+ */
+__isl_give isl_ast_graft_list *isl_ast_graft_list_group_on_guard(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build)
+{
+	int any_match = 0;
+	isl_size n;
+	isl_set_to_ast_graft_list *guard2list;
+
+	n = isl_ast_graft_list_size(list);
+	if (n < 0)
+		return isl_ast_graft_list_free(list);
+	if (n <= 2)
+		return list;
+
+	guard2list = split_on_guard(list, &any_match);
+	if (any_match)
+		list = reconstruct(list, guard2list, build);
+
+	isl_set_to_ast_graft_list_free(guard2list);
+
+	return list;
+}
+
 __isl_give isl_printer *isl_printer_print_ast_graft(__isl_take isl_printer *p,
 	__isl_keep isl_ast_graft *graft)
 {

_service:tar_scm:isl-0.14.tar.xz/isl_ast_graft_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_graft_private.h Changed

@@ -2,6 +2,7 @@
 #define ISL_AST_GRAFT_PRIVATE_H
 
 #include <isl/ast.h>
+#include <isl/ast_build.h>
 #include <isl/set.h>
 #include <isl/list.h>
 #include <isl/printer.h>
@@ -53,7 +54,7 @@
 	__isl_keep isl_ast_build *build);
 __isl_give isl_ast_graft *isl_ast_graft_alloc_domain(
 	__isl_take isl_map *schedule, __isl_keep isl_ast_build *build);
-void *isl_ast_graft_free(__isl_take isl_ast_graft *graft);
+__isl_null isl_ast_graft *isl_ast_graft_free(__isl_take isl_ast_graft *graft);
 __isl_give isl_ast_graft_list *isl_ast_graft_list_sort_guard(
 	__isl_take isl_ast_graft_list *list);
 
@@ -61,6 +62,8 @@
 	__isl_take isl_ast_graft_list *list1,
 	__isl_take isl_ast_graft_list *list2,
 	__isl_keep isl_ast_build *build);
+__isl_give isl_ast_graft_list *isl_ast_graft_list_group_on_guard(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build);
 
 __isl_give isl_ast_node *isl_ast_graft_get_node(
 	__isl_keep isl_ast_graft *graft);
@@ -76,10 +79,15 @@
 __isl_give isl_ast_graft *isl_ast_graft_enforce(
 	__isl_take isl_ast_graft *graft, __isl_take isl_basic_set *enforced);
 
+__isl_give isl_ast_graft *isl_ast_graft_insert_mark(
+	__isl_take isl_ast_graft *graft, __isl_take isl_id *mark);
+
 __isl_give isl_ast_graft_list *isl_ast_graft_list_unembed(
 	__isl_take isl_ast_graft_list *list, int product);
 __isl_give isl_ast_graft_list *isl_ast_graft_list_preimage_multi_aff(
 	__isl_take isl_ast_graft_list *list, __isl_take isl_multi_aff *ma);
+__isl_give isl_ast_graft_list *isl_ast_graft_list_insert_pending_guard_nodes(
+	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build);
 
 __isl_give isl_ast_node *isl_ast_node_from_graft_list(
 	__isl_take isl_ast_graft_list *list, __isl_keep isl_ast_build *build);

_service:tar_scm:isl-0.14.tar.xz/isl_ast_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_ast_private.h Changed

@@ -22,7 +22,7 @@
 		isl_val *v;
 		isl_id *id;
 		struct {
-			enum isl_ast_op_type op;
+			enum isl_ast_expr_op_type op;
 			unsigned n_arg;
 			isl_ast_expr **args;
 		} op;
@@ -36,8 +36,9 @@
 
 __isl_give isl_ast_expr *isl_ast_expr_alloc_int_si(isl_ctx *ctx, int i);
 __isl_give isl_ast_expr *isl_ast_expr_alloc_op(isl_ctx *ctx,
-	enum isl_ast_op_type op, int n_arg);
-__isl_give isl_ast_expr *isl_ast_expr_alloc_binary(enum isl_ast_op_type type,
+	enum isl_ast_expr_op_type op, int n_arg);
+__isl_give isl_ast_expr *isl_ast_expr_alloc_binary(
+	enum isl_ast_expr_op_type type,
 	__isl_take isl_ast_expr *expr1, __isl_take isl_ast_expr *expr2);
 
 #undef EL
@@ -45,9 +46,10 @@
 
 #include <isl_list_templ.h>
 
-/* A node is either a block, an if, a for or a user node.
+/* A node is either a block, an if, a for, a user node or a mark node.
  * "else_node" is NULL if the if node does not have an else branch.
  * "cond" and "inc" are NULL for degenerate for nodes.
+ * In case of a mark node, "mark" is the mark and "node" is the marked node.
  */
 struct isl_ast_node {
 	int ref;
@@ -75,6 +77,10 @@
 		struct {
 			isl_ast_expr *expr;
 		} e;
+		struct {
+			isl_id *mark;
+			isl_ast_node *node;
+		} m;
 	} u;
 
 	isl_id *annotation;
@@ -86,6 +92,8 @@
 __isl_give isl_ast_node *isl_ast_node_alloc_if(__isl_take isl_ast_expr *guard);
 __isl_give isl_ast_node *isl_ast_node_alloc_block(
 	__isl_take isl_ast_node_list *list);
+__isl_give isl_ast_node *isl_ast_node_alloc_mark(__isl_take isl_id *id,
+	__isl_take isl_ast_node *node);
 __isl_give isl_ast_node *isl_ast_node_from_ast_node_list(
 	__isl_take isl_ast_node_list *list);
 __isl_give isl_ast_node *isl_ast_node_for_set_body(

_service:tar_scm:isl-0.14.tar.xz/isl_bernstein.c -> _service:tar_scm:isl-0.24.tar.gz/isl_bernstein.c Changed

@@ -38,92 +38,112 @@
 	isl_pw_qpolynomial_fold *pwf_tight;
 };
 
-static int vertex_is_integral(__isl_keep isl_basic_set *vertex)
+static isl_bool vertex_is_integral(__isl_keep isl_basic_set *vertex)
 {
-	unsigned nvar;
-	unsigned nparam;
+	isl_size nvar;
+	isl_size nparam;
 	int i;
 
 	nvar = isl_basic_set_dim(vertex, isl_dim_set);
 	nparam = isl_basic_set_dim(vertex, isl_dim_param);
+	if (nvar < 0 || nparam < 0)
+		return isl_bool_error;
 	for (i = 0; i < nvar; ++i) {
 		int r = nvar - 1 - i;
 		if (!isl_int_is_one(vertex->eqr1 + nparam + i) &&
 		    !isl_int_is_negone(vertex->eqr1 + nparam + i))
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 static __isl_give isl_qpolynomial *vertex_coordinate(
-	__isl_keep isl_basic_set *vertex, int i, __isl_take isl_space *dim)
+	__isl_keep isl_basic_set *vertex, int i, __isl_take isl_space *space)
 {
-	unsigned nvar;
-	unsigned nparam;
+	isl_size nvar;
+	isl_size nparam;
+	isl_size total;
 	int r;
 	isl_int denom;
 	isl_qpolynomial *v;
 
+	isl_int_init(denom);
+
 	nvar = isl_basic_set_dim(vertex, isl_dim_set);
 	nparam = isl_basic_set_dim(vertex, isl_dim_param);
+	total = isl_basic_set_dim(vertex, isl_dim_all);
+	if (nvar < 0 || nparam < 0 || total < 0)
+		goto error;
 	r = nvar - 1 - i;
 
-	isl_int_init(denom);
 	isl_int_set(denom, vertex->eqr1 + nparam + i);
 	isl_assert(vertex->ctx, !isl_int_is_zero(denom), goto error);
 
 	if (isl_int_is_pos(denom))
-		isl_seq_neg(vertex->eqr, vertex->eqr,
-				1 + isl_basic_set_total_dim(vertex));
+		isl_seq_neg(vertex->eqr, vertex->eqr, 1 + total);
 	else
 		isl_int_neg(denom, denom);
 
-	v = isl_qpolynomial_from_affine(dim, vertex->eqr, denom);
+	v = isl_qpolynomial_from_affine(space, vertex->eqr, denom);
 	isl_int_clear(denom);
 
 	return v;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_int_clear(denom);
 	return NULL;
 }
 
 /* Check whether the bound associated to the selection "k" is tight,
- * which is the case if we select exactly one vertex and if that vertex
+ * which is the case if we select exactly one vertex (i.e., one of the
+ * exponents in "k" is exactly "d") and if that vertex
  * is integral for all values of the parameters.
+ *
+ * If the degree "d" is zero, then there are no exponents.
+ * Since the polynomial is a constant expression in this case,
+ * the bound is necessarily tight.
  */
-static int is_tight(int *k, int n, int d, isl_cell *cell)
+static isl_bool is_tight(int *k, int n, int d, isl_cell *cell)
 {
 	int i;
 
+	if (d == 0)
+		return isl_bool_true;
+
 	for (i = 0; i < n; ++i) {
 		int v;
-		if (ki != d) {
-			if (ki)
-				return 0;
+		if (!ki)
 			continue;
-		}
+		if (ki != d)
+			return isl_bool_false;
 		v = cell->idsn - 1 - i;
 		return vertex_is_integral(cell->vertices->vv.vertex);
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
-static void add_fold(__isl_take isl_qpolynomial *b, __isl_keep isl_set *dom,
+static isl_stat add_fold(__isl_take isl_qpolynomial *b, __isl_keep isl_set *dom,
 	int *k, int n, int d, struct bernstein_data *data)
 {
 	isl_qpolynomial_fold *fold;
+	isl_bool tight;
 
 	fold = isl_qpolynomial_fold_alloc(data->type, b);
 
-	if (data->check_tight && is_tight(k, n, d, data->cell))
+	tight = isl_bool_false;
+	if (data->check_tight)
+		tight = is_tight(k, n, d, data->cell);
+	if (tight < 0)
+		return isl_stat_error;
+	if (tight)
 		data->fold_tight = isl_qpolynomial_fold_fold_on_domain(dom,
 							data->fold_tight, fold);
 	else
 		data->fold = isl_qpolynomial_fold_fold_on_domain(dom,
 							data->fold, fold);
+	return isl_stat_ok;
 }
 
 /* Extract the coefficients of the Bernstein base polynomials and store
@@ -136,25 +156,25 @@
  * ci contains the coefficient of the selected powers of the first i+1 vars.
  * multinomi contains the partial multinomial coefficient.
  */
-static void extract_coefficients(isl_qpolynomial *poly,
+static isl_stat extract_coefficients(isl_qpolynomial *poly,
 	__isl_keep isl_set *dom, struct bernstein_data *data)
 {
 	int i;
 	int d;
-	int n;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_qpolynomial **c = NULL;
 	int *k = NULL;
 	int *left = NULL;
 	isl_vec *multinom = NULL;
 
-	if (!poly)
-		return;
+	n = isl_qpolynomial_dim(poly, isl_dim_in);
+	if (n < 0)
+		return isl_stat_error;
 
 	ctx = isl_qpolynomial_get_ctx(poly);
-	n = isl_qpolynomial_dim(poly, isl_dim_in);
 	d = isl_qpolynomial_degree(poly);
-	isl_assert(ctx, n >= 2, return);
+	isl_assert(ctx, n >= 2, return isl_stat_error);
 
 	c = isl_calloc_array(ctx, isl_qpolynomial *, n);
 	k = isl_alloc_array(ctx, int, n);
@@ -174,7 +194,7 @@
 		while (i > 0) {
 			if (i == n - 1) {
 				int j;
-				isl_space *dim;
+				isl_space *space;
 				isl_qpolynomial *b;
 				isl_qpolynomial *f;
 				for (j = 2; j <= lefti - 1; ++j)
@@ -183,12 +203,13 @@
 				b = isl_qpolynomial_coeff(ci - 1, isl_dim_in,
 					n - 1 - i, lefti - 1);
 				b = isl_qpolynomial_project_domain_on_params(b);
-				dim = isl_qpolynomial_get_domain_space(b);
-				f = isl_qpolynomial_rat_cst_on_domain(dim, ctx->one,
-					multinom->eli);
+				space = isl_qpolynomial_get_domain_space(b);
+				f = isl_qpolynomial_rat_cst_on_domain(space,
+					ctx->one, multinom->eli);
 				b = isl_qpolynomial_mul(b, f);
 				kn - 1 = leftn - 2;
-				add_fold(b, dom, k, n, d, data);
+				if (add_fold(b, dom, k, n, d, data) < 0)
+					goto error;
 				--i;
 				continue;
 			}
@@ -218,7 +239,7 @@
 	free(left);
 	free(k);
 	free(c);
-	return;
+	return isl_stat_ok;
 error:
 	isl_vec_free(multinom);
 	free(left);
@@ -227,7 +248,7 @@
 		for (i = 0; i < n; ++i)
 			isl_qpolynomial_free(ci);
 	free(c);
-	return;
+	return isl_stat_error;
 }
 
 /* Perform bernstein expansion on the parametric vertices that are active
@@ -242,13 +263,15 @@
  * and the constant "1 = \sum_i \alpha_i" for the homogeneous dimension.
  * Next, we extract the coefficients of the Bernstein base polynomials.
  */
-static int bernstein_coefficients_cell(__isl_take isl_cell *cell, void *user)
+static isl_stat bernstein_coefficients_cell(__isl_take isl_cell *cell,
+	void *user)
 {
 	int i, j;
 	struct bernstein_data *data = (struct bernstein_data *)user;
-	isl_space *dim_param;
-	isl_space *dim_dst;
+	isl_space *space_param;
+	isl_space *space_dst;
 	isl_qpolynomial *poly = data->poly;
+	isl_size n_in;
 	unsigned nvar;
 	int n_vertices;
 	isl_qpolynomial **subs;
@@ -256,10 +279,11 @@
 	isl_set *dom;
 	isl_ctx *ctx;
 
-	if (!poly)
+	n_in = isl_qpolynomial_dim(poly, isl_dim_in);
+	if (n_in < 0)
 		goto error;
 
-	nvar = isl_qpolynomial_dim(poly, isl_dim_in) - 1;
+	nvar = n_in - 1;
 	n_vertices = cell->n_vertices;
 
 	ctx = isl_qpolynomial_get_ctx(poly);
@@ -271,22 +295,23 @@
 	if (!subs)
 		goto error;
 
-	dim_param = isl_basic_set_get_space(cell->dom);
-	dim_dst = isl_qpolynomial_get_domain_space(poly);
-	dim_dst = isl_space_add_dims(dim_dst, isl_dim_set, n_vertices);
+	space_param = isl_basic_set_get_space(cell->dom);
+	space_dst = isl_qpolynomial_get_domain_space(poly);
+	space_dst = isl_space_add_dims(space_dst, isl_dim_set, n_vertices);
 
 	for (i = 0; i < 1 + nvar; ++i)
-		subsi = isl_qpolynomial_zero_on_domain(isl_space_copy(dim_dst));
+		subsi =
+		    isl_qpolynomial_zero_on_domain(isl_space_copy(space_dst));
 
 	for (i = 0; i < n_vertices; ++i) {
 		isl_qpolynomial *c;
-		c = isl_qpolynomial_var_on_domain(isl_space_copy(dim_dst), isl_dim_set,
-					1 + nvar + i);
+		c = isl_qpolynomial_var_on_domain(isl_space_copy(space_dst),
+					isl_dim_set, 1 + nvar + i);
 		for (j = 0; j < nvar; ++j) {
 			int k = cell->idsi;
 			isl_qpolynomial *v;
 			v = vertex_coordinate(cell->vertices->vk.vertex, j,
-						isl_space_copy(dim_param));
+						isl_space_copy(space_param));
 			v = isl_qpolynomial_add_dims(v, isl_dim_in,
 							1 + nvar + n_vertices);
 			v = isl_qpolynomial_mul(v, isl_qpolynomial_copy(c));
@@ -294,7 +319,7 @@
 		}
 		subs0 = isl_qpolynomial_add(subs0, c);
 	}
-	isl_space_free(dim_dst);
+	isl_space_free(space_dst);
 
 	poly = isl_qpolynomial_copy(poly);
 
@@ -304,9 +329,13 @@
 
 	data->cell = cell;
 	dom = isl_set_from_basic_set(isl_basic_set_copy(cell->dom));
-	data->fold = isl_qpolynomial_fold_empty(data->type, isl_space_copy(dim_param));
-	data->fold_tight = isl_qpolynomial_fold_empty(data->type, dim_param);
-	extract_coefficients(poly, dom, data);
+	data->fold = isl_qpolynomial_fold_empty(data->type,
+						isl_space_copy(space_param));
+	data->fold_tight = isl_qpolynomial_fold_empty(data->type, space_param);
+	if (extract_coefficients(poly, dom, data) < 0) {
+		data->fold = isl_qpolynomial_fold_free(data->fold);
+		data->fold_tight = isl_qpolynomial_fold_free(data->fold_tight);
+	}
 
 	pwf = isl_pw_qpolynomial_fold_alloc(data->type, isl_set_copy(dom),
 					    data->fold);
@@ -319,10 +348,10 @@
 	for (i = 0; i < 1 + nvar; ++i)
 		isl_qpolynomial_free(subsi);
 	free(subs);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_cell_free(cell);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Base case of applying bernstein expansion.
@@ -330,51 +359,47 @@
  * We compute the chamber decomposition of the parametric polytope "bset"
  * and then perform bernstein expansion on the parametric vertices
  * that are active on each chamber.
+ *
+ * If the polynomial does not depend on the set variables
+ * (and in particular if the number of set variables is zero)
+ * then the bound is equal to the polynomial and
+ * no actual bernstein expansion needs to be performed.
  */
 static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_base(
 	__isl_take isl_basic_set *bset,
-	__isl_take isl_qpolynomial *poly, struct bernstein_data *data, int *tight)
+	__isl_take isl_qpolynomial *poly, struct bernstein_data *data,
+	isl_bool *tight)
 {
-	unsigned nvar;
-	isl_space *dim;
-	isl_pw_qpolynomial_fold *pwf;
+	int degree;
+	isl_size nvar;
+	isl_space *space;
 	isl_vertices *vertices;
-	int covers;
+	isl_bool covers;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
-	if (nvar == 0) {
-		isl_set *dom;
-		isl_qpolynomial_fold *fold;
-
-		fold = isl_qpolynomial_fold_alloc(data->type, poly);
-		dom = isl_set_from_basic_set(bset);
-		if (tight)
-			*tight = 1;
-		pwf = isl_pw_qpolynomial_fold_alloc(data->type, dom, fold);
-		return isl_pw_qpolynomial_fold_project_domain_on_params(pwf);
-	}
-
-	if (isl_qpolynomial_is_zero(poly)) {
-		isl_set *dom;
-		isl_qpolynomial_fold *fold;
-		fold = isl_qpolynomial_fold_alloc(data->type, poly);
-		dom = isl_set_from_basic_set(bset);
-		pwf = isl_pw_qpolynomial_fold_alloc(data->type, dom, fold);
-		if (tight)
-			*tight = 1;
-		return isl_pw_qpolynomial_fold_project_domain_on_params(pwf);
-	}
-
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_params(dim);
-	dim = isl_space_from_domain(dim);
-	dim = isl_space_add_dims(dim, isl_dim_set, 1);
-	data->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim), data->type);
-	data->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, data->type);
+	if (nvar < 0)
+		bset = isl_basic_set_free(bset);
+	if (nvar == 0)
+		return isl_qpolynomial_cst_bound(bset, poly, data->type, tight);
+
+	degree = isl_qpolynomial_degree(poly);
+	if (degree < -1)
+		bset = isl_basic_set_free(bset);
+	if (degree <= 0)
+		return isl_qpolynomial_cst_bound(bset, poly, data->type, tight);
+
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_params(space);
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_set, 1);
+	data->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(space),
+						data->type);
+	data->pwf_tight = isl_pw_qpolynomial_fold_zero(space, data->type);
 	data->poly = isl_qpolynomial_homogenize(isl_qpolynomial_copy(poly));
 	vertices = isl_basic_set_compute_vertices(bset);
-	isl_vertices_foreach_disjoint_cell(vertices,
-		&bernstein_coefficients_cell, data);
+	if (isl_vertices_foreach_disjoint_cell(vertices,
+					&bernstein_coefficients_cell, data) < 0)
+		data->pwf = isl_pw_qpolynomial_fold_free(data->pwf);
 	isl_vertices_free(vertices);
 	isl_qpolynomial_free(data->poly);
 
@@ -407,18 +432,17 @@
  */
 static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_recursive(
 	__isl_take isl_pw_qpolynomial *pwqp,
-	int n_group, int *len, struct bernstein_data *data, int *tight)
+	int n_group, int *len, struct bernstein_data *data, isl_bool *tight)
 {
 	int i;
-	unsigned nparam;
-	unsigned nvar;
+	isl_size nparam;
+	isl_size nvar;
 	isl_pw_qpolynomial_fold *pwf;
 
-	if (!pwqp)
-		return NULL;
-
 	nparam = isl_pw_qpolynomial_dim(pwqp, isl_dim_param);
 	nvar = isl_pw_qpolynomial_dim(pwqp, isl_dim_in);
+	if (nparam < 0 || nvar < 0)
+		goto error;
 
 	pwqp = isl_pw_qpolynomial_move_dims(pwqp, isl_dim_param, nparam,
 					isl_dim_in, 0, nvar - lenn_group - 1);
@@ -426,6 +450,8 @@
 
 	for (i = n_group - 2; i >= 0; --i) {
 		nparam = isl_pw_qpolynomial_fold_dim(pwf, isl_dim_param);
+		if (nparam < 0)
+			return isl_pw_qpolynomial_fold_free(pwf);
 		pwf = isl_pw_qpolynomial_fold_move_dims(pwf, isl_dim_in, 0,
 				isl_dim_param, nparam - leni, leni);
 		if (tight && !*tight)
@@ -434,11 +460,15 @@
 	}
 
 	return pwf;
+error:
+	isl_pw_qpolynomial_free(pwqp);
+	return NULL;
 }
 
 static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_factors(
 	__isl_take isl_basic_set *bset,
-	__isl_take isl_qpolynomial *poly, struct bernstein_data *data, int *tight)
+	__isl_take isl_qpolynomial *poly, struct bernstein_data *data,
+	isl_bool *tight)
 {
 	isl_factorizer *f;
 	isl_set *set;
@@ -450,7 +480,7 @@
 		goto error;
 	if (f->n_group == 0) {
 		isl_factorizer_free(f);
-		return  bernstein_coefficients_base(bset, poly, data, tight);
+		return bernstein_coefficients_base(bset, poly, data, tight);
 	}
 
 	set = isl_set_from_basic_set(bset);
@@ -471,19 +501,19 @@
 
 static __isl_give isl_pw_qpolynomial_fold *bernstein_coefficients_full_recursive(
 	__isl_take isl_basic_set *bset,
-	__isl_take isl_qpolynomial *poly, struct bernstein_data *data, int *tight)
+	__isl_take isl_qpolynomial *poly, struct bernstein_data *data,
+	isl_bool *tight)
 {
 	int i;
 	int *len;
-	unsigned nvar;
+	isl_size nvar;
 	isl_pw_qpolynomial_fold *pwf;
 	isl_set *set;
 	isl_pw_qpolynomial *pwqp;
 
-	if (!bset || !poly)
-		goto error;
-
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0 || !poly)
+		goto error;
 	
 	len = isl_alloc_array(bset->ctx, int, nvar);
 	if (nvar && !len)
@@ -517,23 +547,23 @@
  * bernstein expansion recursively on each dimension.
  * Otherwise, we apply bernstein expansion on the entire polytope.
  */
-int isl_qpolynomial_bound_on_domain_bernstein(__isl_take isl_basic_set *bset,
-	__isl_take isl_qpolynomial *poly, struct isl_bound *bound)
+isl_stat isl_qpolynomial_bound_on_domain_bernstein(
+	__isl_take isl_basic_set *bset, __isl_take isl_qpolynomial *poly,
+	struct isl_bound *bound)
 {
 	struct bernstein_data data;
 	isl_pw_qpolynomial_fold *pwf;
-	unsigned nvar;
-	int tight = 0;
-	int *tp = bound->check_tight ? &tight : NULL;
+	isl_size nvar;
+	isl_bool tight = isl_bool_false;
+	isl_bool *tp = bound->check_tight ? &tight : NULL;
 
-	if (!bset || !poly)
+	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0 || !poly)
 		goto error;
 
 	data.type = bound->type;
 	data.check_tight = bound->check_tight;
 
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
-
 	if (bset->ctx->opt->bernstein_recurse & ISL_BERNSTEIN_FACTORS)
 		pwf = bernstein_coefficients_factors(bset, poly, &data, tp);
 	else if (nvar > 1 &&
@@ -543,13 +573,11 @@
 		pwf = bernstein_coefficients_base(bset, poly, &data, tp);
 
 	if (tight)
-		bound->pwf_tight = isl_pw_qpolynomial_fold_fold(bound->pwf_tight, pwf);
+		return isl_bound_add_tight(bound, pwf);
 	else
-		bound->pwf = isl_pw_qpolynomial_fold_fold(bound->pwf, pwf);
-
-	return 0;
+		return isl_bound_add(bound, pwf);
 error:
 	isl_basic_set_free(bset);
 	isl_qpolynomial_free(poly);
-	return -1;
+	return isl_stat_error;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_bernstein.h -> _service:tar_scm:isl-0.24.tar.gz/isl_bernstein.h Changed

_service:tar_scm:isl-0.24.tar.gz/isl_bind_domain_templ.c Added

@@ -0,0 +1,168 @@
+/*
+ * Copyright 2018      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#include <isl/space.h>
+
+/* Merge parameter "param" into the input dimension "i" of "obj".
+ *
+ * First plug in the parameter for the input dimension in "obj".
+ * The drop the (now defunct) input dimension and
+ * move the parameter in its original position.
+ * Since dimension manipulations destroy spaces, modify the space
+ * separately by only dropping the parameter.
+ */
+static __isl_give TYPE *FN(TYPE,merge_param)(__isl_take TYPE *obj, int i,
+	int param)
+{
+	isl_id *id;
+	isl_aff *aff;
+	isl_space *space;
+	isl_multi_aff *ma;
+
+	space = FN(TYPE,get_domain_space)(obj);
+	id = isl_space_get_dim_id(space, isl_dim_param, param);
+	aff = isl_aff_param_on_domain_space_id(isl_space_copy(space), id);
+	space = isl_space_map_from_set(space);
+	ma = isl_multi_aff_identity(space);
+	ma = isl_multi_aff_set_aff(ma, i, aff);
+	obj = FN(TYPE,pullback_multi_aff)(obj, ma);
+	space = FN(TYPE,get_domain_space)(obj);
+	obj = FN(TYPE,drop_dims)(obj, isl_dim_in, i, 1);
+	obj = FN(TYPE,move_dims)(obj, isl_dim_in, i, isl_dim_param, param, 1);
+	space = isl_space_drop_dims(space, isl_dim_param, param, 1);
+	obj = FN(TYPE,reset_domain_space)(obj, space);
+
+	return obj;
+}
+
+/* Given a tuple of identifiers "tuple" that correspond
+ * to the initial input dimensions of "obj",
+ * if any of those identifiers appear as parameters
+ * in "obj", then equate those parameters with the corresponding
+ * input dimensions and project out the parameters.
+ * The result therefore has no such parameters.
+ */
+static __isl_give TYPE *FN(TYPE,equate_initial_params)(__isl_take TYPE *obj,
+	__isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size n;
+
+	n = isl_multi_id_size(tuple);
+	if (n < 0)
+		return FN(TYPE,free)(obj);
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+		int pos;
+
+		id = isl_multi_id_get_at(tuple, i);
+		if (!id)
+			return FN(TYPE,free)(obj);
+		pos = FN(TYPE,find_dim_by_id)(obj, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos < 0)
+			continue;
+		obj = FN(TYPE,merge_param)(obj, i, pos);
+	}
+
+	return obj;
+}
+
+/* Given a tuple of identifiers "tuple" in a space that corresponds
+ * to the domain of "obj", if any of those identifiers appear as parameters
+ * in "obj", then equate those parameters with the corresponding
+ * input dimensions and project out the parameters.
+ * The result therefore has no such parameters.
+ */
+static __isl_give TYPE *FN(TYPE,equate_domain_params)(__isl_take TYPE *obj,
+	__isl_keep isl_multi_id *tuple)
+{
+	isl_stat r;
+	isl_space *obj_space, *tuple_space;
+
+	obj_space = FN(TYPE,get_space)(obj);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	r = isl_space_check_domain_tuples(tuple_space, obj_space);
+	isl_space_free(obj_space);
+	if (r < 0)
+		return FN(TYPE,free)(obj);
+
+	return FN(TYPE,equate_initial_params)(obj, tuple);
+}
+
+/* Bind the domain dimensions of the function "obj" to parameters
+ * with identifiers specified by "tuple", living in the same space
+ * as the domain of "obj".
+ *
+ * If no parameters with these identifiers appear in "obj" already,
+ * then the domain dimensions are simply reinterpreted as parameters.
+ * Otherwise, the parameters are first equated to the corresponding
+ * domain dimensions.
+ */
+__isl_give TYPE *FN(TYPE,bind_domain)(__isl_take TYPE *obj,
+	__isl_take isl_multi_id *tuple)
+{
+	isl_space *space;
+
+	obj = FN(TYPE,equate_domain_params)(obj, tuple);
+	space = FN(TYPE,get_space)(obj);
+	space = isl_space_bind_map_domain(space, tuple);
+	isl_multi_id_free(tuple);
+	obj = FN(TYPE,reset_space)(obj, space);
+
+	return obj;
+}
+
+/* Given a tuple of identifiers "tuple" in a space that corresponds
+ * to the domain of the wrapped relation in the domain of "obj",
+ * if any of those identifiers appear as parameters
+ * in "obj", then equate those parameters with the corresponding
+ * input dimensions and project out the parameters.
+ * The result therefore has no such parameters.
+ */
+static __isl_give TYPE *FN(TYPE,equate_domain_wrapped_domain_params)(
+	__isl_take TYPE *obj, __isl_keep isl_multi_id *tuple)
+{
+	isl_stat r;
+	isl_space *obj_space, *tuple_space;
+
+	obj_space = FN(TYPE,get_space)(obj);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	r = isl_space_check_domain_wrapped_domain_tuples(tuple_space,
+							obj_space);
+	isl_space_free(obj_space);
+	if (r < 0)
+		return FN(TYPE,free)(obj);
+
+	return FN(TYPE,equate_initial_params)(obj, tuple);
+}
+
+/* Given a function living in a space of the form A -> B -> C and
+ * a tuple of identifiers in A, bind the domain dimensions of the relation
+ * wrapped in the domain of "obj" with identifiers specified by "tuple",
+ * returning a function in the space B -> C.
+ *
+ * If no parameters with these identifiers appear in "obj" already,
+ * then the domain dimensions are simply reinterpreted as parameters.
+ * Otherwise, the parameters are first equated to the corresponding
+ * domain dimensions.
+ */
+__isl_give TYPE *FN(TYPE,bind_domain_wrapped_domain)(__isl_take TYPE *obj,
+	__isl_take isl_multi_id *tuple)
+{
+	isl_space *space;
+
+	obj = FN(TYPE,equate_domain_wrapped_domain_params)(obj, tuple);
+	space = FN(TYPE,get_space)(obj);
+	space = isl_space_bind_domain_wrapped_domain(space, tuple);
+	isl_multi_id_free(tuple);
+	obj = FN(TYPE,reset_space)(obj, space);
+
+	return obj;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_blk.c -> _service:tar_scm:isl-0.24.tar.gz/isl_blk.c Changed

@@ -39,6 +39,15 @@
 	return block.size == -1 && block.data == NULL;
 }
 
+static void isl_blk_free_force(struct isl_ctx *ctx, struct isl_blk block)
+{
+	int i;
+
+	for (i = 0; i < block.size; ++i)
+		isl_int_clear(block.datai);
+	free(block.data);
+}
+
 static struct isl_blk extend(struct isl_ctx *ctx, struct isl_blk block,
 				size_t new_n)
 {
@@ -48,12 +57,12 @@
 	if (block.size >= new_n)
 		return block;
 
-	p = block.data;
-	block.data = isl_realloc_array(ctx, block.data, isl_int, new_n);
-	if (!block.data) {
-		free(p);
+	p = isl_realloc_array(ctx, block.data, isl_int, new_n);
+	if (!p) {
+		isl_blk_free_force(ctx, block);
 		return isl_blk_error();
 	}
+	block.data = p;
 
 	for (i = block.size; i < new_n; ++i)
 		isl_int_init(block.datai);
@@ -62,15 +71,6 @@
 	return block;
 }
 
-static void isl_blk_free_force(struct isl_ctx *ctx, struct isl_blk block)
-{
-	int i;
-
-	for (i = 0; i < block.size; ++i)
-		isl_int_clear(block.datai);
-	free(block.data);
-}
-
 struct isl_blk isl_blk_alloc(struct isl_ctx *ctx, size_t n)
 {
 	int i;

_service:tar_scm:isl-0.14.tar.xz/isl_bound.c -> _service:tar_scm:isl-0.24.tar.gz/isl_bound.c Changed

@@ -16,23 +16,91 @@
 #include <isl_polynomial_private.h>
 #include <isl_options_private.h>
 
+/* Given a polynomial "poly" that is constant in terms
+ * of the domain variables, construct a polynomial reduction
+ * of type "type" that is equal to "poly" on "bset",
+ * with the domain projected onto the parameters.
+ */
+__isl_give isl_pw_qpolynomial_fold *isl_qpolynomial_cst_bound(
+	__isl_take isl_basic_set *bset, __isl_take isl_qpolynomial *poly,
+	enum isl_fold type, isl_bool *tight)
+{
+	isl_set *dom;
+	isl_qpolynomial_fold *fold;
+	isl_pw_qpolynomial_fold *pwf;
+
+	fold = isl_qpolynomial_fold_alloc(type, poly);
+	dom = isl_set_from_basic_set(bset);
+	if (tight)
+		*tight = isl_bool_true;
+	pwf = isl_pw_qpolynomial_fold_alloc(type, dom, fold);
+	return isl_pw_qpolynomial_fold_project_domain_on_params(pwf);
+}
+
+/* Add the bound "pwf", which is not known to be tight,
+ * to the output of "bound".
+ */
+isl_stat isl_bound_add(struct isl_bound *bound,
+	__isl_take isl_pw_qpolynomial_fold *pwf)
+{
+	bound->pwf = isl_pw_qpolynomial_fold_fold(bound->pwf, pwf);
+	return isl_stat_non_null(bound->pwf);
+}
+
+/* Add the bound "pwf", which is known to be tight,
+ * to the output of "bound".
+ */
+isl_stat isl_bound_add_tight(struct isl_bound *bound,
+	__isl_take isl_pw_qpolynomial_fold *pwf)
+{
+	bound->pwf_tight = isl_pw_qpolynomial_fold_fold(bound->pwf_tight, pwf);
+	return isl_stat_non_null(bound->pwf);
+}
+
+/* Given a polynomial "poly" that is constant in terms
+ * of the domain variables and the domain "bset",
+ * construct the corresponding polynomial reduction and
+ * add it to the tight bounds of "bound".
+ */
+static isl_stat add_constant_poly(__isl_take isl_basic_set *bset,
+	__isl_take isl_qpolynomial *poly, struct isl_bound *bound)
+{
+	isl_pw_qpolynomial_fold *pwf;
+
+	pwf = isl_qpolynomial_cst_bound(bset, poly, bound->type, NULL);
+	return isl_bound_add_tight(bound, pwf);
+}
+
 /* Compute a bound on the polynomial defined over the parametric polytope
  * using either range propagation or bernstein expansion and
  * store the result in bound->pwf and bound->pwf_tight.
  * Since bernstein expansion requires bounded domains, we apply
  * range propagation on unbounded domains.  Otherwise, we respect the choice
  * of the user.
+ *
+ * If the polynomial does not depend on the set variables
+ * then the bound is equal to the polynomial and
+ * it can be added to "bound" directly.
  */
-static int compressed_guarded_poly_bound(__isl_take isl_basic_set *bset,
+static isl_stat compressed_guarded_poly_bound(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
+	isl_ctx *ctx;
 	int bounded;
+	int degree;
 
 	if (!bset || !poly)
 		goto error;
 
-	if (bset->ctx->opt->bound == ISL_BOUND_RANGE)
+	degree = isl_qpolynomial_degree(poly);
+	if (degree < -1)
+		goto error;
+	if (degree <= 0)
+		return add_constant_poly(bset, poly, bound);
+
+	ctx = isl_basic_set_get_ctx(bset);
+	if (ctx->opt->bound == ISL_BOUND_RANGE)
 		return isl_qpolynomial_bound_on_domain_range(bset, poly, bound);
 
 	bounded = isl_basic_set_is_bounded(bset);
@@ -45,18 +113,18 @@
 error:
 	isl_basic_set_free(bset);
 	isl_qpolynomial_free(poly);
-	return -1;
+	return isl_stat_error;
 }
 
-static int unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset,
+static isl_stat unwrapped_guarded_poly_bound(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
 	isl_pw_qpolynomial_fold *top_pwf;
 	isl_pw_qpolynomial_fold *top_pwf_tight;
-	isl_space *dim;
+	isl_space *space;
 	isl_morph *morph;
-	int r;
+	isl_stat r;
 
 	bset = isl_basic_set_detect_equalities(bset);
 
@@ -71,17 +139,17 @@
 	bset = isl_morph_basic_set(isl_morph_copy(morph), bset);
 	poly = isl_qpolynomial_morph_domain(poly, isl_morph_copy(morph));
 
-	dim = isl_morph_get_ran_space(morph);
-	dim = isl_space_params(dim);
+	space = isl_morph_get_ran_space(morph);
+	space = isl_space_params(space);
 
 	top_pwf = bound->pwf;
 	top_pwf_tight = bound->pwf_tight;
 
-	dim = isl_space_from_domain(dim);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim),
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
+	bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(space),
 						  bound->type);
-	bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
+	bound->pwf_tight = isl_pw_qpolynomial_fold_zero(space, bound->type);
 
 	r = compressed_guarded_poly_bound(bset, poly, user);
 
@@ -94,50 +162,72 @@
 	bound->pwf_tight = isl_pw_qpolynomial_fold_morph_domain(
 						bound->pwf_tight, morph);
 
-	bound->pwf = isl_pw_qpolynomial_fold_fold(top_pwf, bound->pwf);
-	bound->pwf_tight = isl_pw_qpolynomial_fold_fold(top_pwf_tight,
-							bound->pwf_tight);
+	isl_bound_add(bound, top_pwf);
+	isl_bound_add_tight(bound, top_pwf_tight);
 
 	return r;
 error:
 	isl_basic_set_free(bset);
 	isl_qpolynomial_free(poly);
-	return -1;
+	return isl_stat_error;
 }
 
-static int guarded_poly_bound(__isl_take isl_basic_set *bset,
+/* Update bound->pwf and bound->pwf_tight with a bound
+ * of type bound->type on the polynomial "poly" over the domain "bset".
+ *
+ * If the original problem had a wrapped relation in the domain,
+ * meaning that the bound should be computed over the range
+ * of this relation, then temporarily treat the domain dimensions
+ * of this wrapped relation as parameters, compute a bound
+ * in terms of these and the original parameters,
+ * turn the parameters back into set dimensions and
+ * add the results to bound->pwf and bound->pwf_tight.
+ *
+ * Note that even though "bset" is known to live in the same space
+ * as the domain of "poly", the names of the set dimensions
+ * may be different (or missing).  Make sure the naming is exactly
+ * the same before turning these dimensions into parameters
+ * to ensure that the spaces are still the same after
+ * this operation.
+ */
+static isl_stat guarded_poly_bound(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
-	isl_space *dim;
+	isl_space *space;
 	isl_pw_qpolynomial_fold *top_pwf;
 	isl_pw_qpolynomial_fold *top_pwf_tight;
-	int nparam;
-	int n_in;
-	int r;
+	isl_size nparam;
+	isl_size n_in;
+	isl_stat r;
 
 	if (!bound->wrapping)
 		return unwrapped_guarded_poly_bound(bset, poly, user);
 
 	nparam = isl_space_dim(bound->dim, isl_dim_param);
 	n_in = isl_space_dim(bound->dim, isl_dim_in);
+	if (nparam < 0 || n_in < 0)
+		goto error;
+
+	space = isl_qpolynomial_get_domain_space(poly);
+	bset = isl_basic_set_reset_space(bset, space);
 
 	bset = isl_basic_set_move_dims(bset, isl_dim_param, nparam,
 					isl_dim_set, 0, n_in);
 	poly = isl_qpolynomial_move_dims(poly, isl_dim_param, nparam,
 					isl_dim_in, 0, n_in);
 
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_params(dim);
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_params(space);
 
 	top_pwf = bound->pwf;
 	top_pwf_tight = bound->pwf_tight;
 
-	dim = isl_space_from_domain(dim);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(dim),
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
+	bound->pwf = isl_pw_qpolynomial_fold_zero(isl_space_copy(space),
 						  bound->type);
-	bound->pwf_tight = isl_pw_qpolynomial_fold_zero(dim, bound->type);
+	bound->pwf_tight = isl_pw_qpolynomial_fold_zero(space, bound->type);
 
 	r = unwrapped_guarded_poly_bound(bset, poly, user);
 
@@ -146,17 +236,20 @@
 	bound->pwf_tight = isl_pw_qpolynomial_fold_reset_space(bound->pwf_tight,
 						    isl_space_copy(bound->dim));
 
-	bound->pwf = isl_pw_qpolynomial_fold_fold(top_pwf, bound->pwf);
-	bound->pwf_tight = isl_pw_qpolynomial_fold_fold(top_pwf_tight,
-							bound->pwf_tight);
+	isl_bound_add(bound, top_pwf);
+	isl_bound_add_tight(bound, top_pwf_tight);
 
 	return r;
+error:
+	isl_basic_set_free(bset);
+	isl_qpolynomial_free(poly);
+	return isl_stat_error;
 }
 
-static int guarded_qp(__isl_take isl_qpolynomial *qp, void *user)
+static isl_stat guarded_qp(__isl_take isl_qpolynomial *qp, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
-	int r;
+	isl_stat r;
 
 	r = isl_qpolynomial_as_polynomial_on_domain(qp, bound->bset,
 						    &guarded_poly_bound, user);
@@ -164,10 +257,10 @@
 	return r;
 }
 
-static int basic_guarded_fold(__isl_take isl_basic_set *bset, void *user)
+static isl_stat basic_guarded_fold(__isl_take isl_basic_set *bset, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
-	int r;
+	isl_stat r;
 
 	bound->bset = bset;
 	r = isl_qpolynomial_fold_foreach_qpolynomial(bound->fold,
@@ -176,7 +269,7 @@
 	return r;
 }
 
-static int guarded_fold(__isl_take isl_set *set,
+static isl_stat guarded_fold(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial_fold *fold, void *user)
 {
 	struct isl_bound *bound = (struct isl_bound *)user;
@@ -195,19 +288,19 @@
 	isl_set_free(set);
 	isl_qpolynomial_fold_free(fold);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(set);
 	isl_qpolynomial_fold_free(fold);
-	return -1;
+	return isl_stat_error;
 }
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_bound(
-	__isl_take isl_pw_qpolynomial_fold *pwf, int *tight)
+	__isl_take isl_pw_qpolynomial_fold *pwf, isl_bool *tight)
 {
-	unsigned nvar;
+	isl_size nvar;
 	struct isl_bound bound;
-	int covers;
+	isl_bool covers;
 
 	if (!pwf)
 		return NULL;
@@ -218,13 +311,15 @@
 	if (bound.wrapping)
 		bound.dim = isl_space_unwrap(bound.dim);
 	nvar = isl_space_dim(bound.dim, isl_dim_out);
+	if (nvar < 0)
+		bound.dim = isl_space_free(bound.dim);
 	bound.dim = isl_space_domain(bound.dim);
 	bound.dim = isl_space_from_domain(bound.dim);
 	bound.dim = isl_space_add_dims(bound.dim, isl_dim_out, 1);
 
 	if (nvar == 0) {
 		if (tight)
-			*tight = 1;
+			*tight = isl_bool_true;
 		return isl_pw_qpolynomial_fold_reset_space(pwf, bound.dim);
 	}
 
@@ -232,7 +327,7 @@
 		enum isl_fold type = pwf->type;
 		isl_pw_qpolynomial_fold_free(pwf);
 		if (tight)
-			*tight = 1;
+			*tight = isl_bool_true;
 		return isl_pw_qpolynomial_fold_zero(bound.dim, type);
 	}
 
@@ -273,7 +368,8 @@
 }
 
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_bound(
-	__isl_take isl_pw_qpolynomial *pwqp, enum isl_fold type, int *tight)
+	__isl_take isl_pw_qpolynomial *pwqp, enum isl_fold type,
+	isl_bool *tight)
 {
 	isl_pw_qpolynomial_fold *pwf;
 
@@ -283,11 +379,11 @@
 
 struct isl_union_bound_data {
 	enum isl_fold type;
-	int tight;
+	isl_bool tight;
 	isl_union_pw_qpolynomial_fold *res;
 };
 
-static int bound_pw(__isl_take isl_pw_qpolynomial *pwqp, void *user)
+static isl_stat bound_pw(__isl_take isl_pw_qpolynomial *pwqp, void *user)
 {
 	struct isl_union_bound_data *data = user;
 	isl_pw_qpolynomial_fold *pwf;
@@ -297,24 +393,24 @@
 	data->res = isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(
 								data->res, pwf);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_bound(
 	__isl_take isl_union_pw_qpolynomial *upwqp,
-	enum isl_fold type, int *tight)
+	enum isl_fold type, isl_bool *tight)
 {
-	isl_space *dim;
+	isl_space *space;
 	struct isl_union_bound_data data = { type, 1, NULL };
 
 	if (!upwqp)
 		return NULL;
 
 	if (!tight)
-		data.tight = 0;
+		data.tight = isl_bool_false;
 
-	dim = isl_union_pw_qpolynomial_get_space(upwqp);
-	data.res = isl_union_pw_qpolynomial_fold_zero(dim, type);
+	space = isl_union_pw_qpolynomial_get_space(upwqp);
+	data.res = isl_union_pw_qpolynomial_fold_zero(space, type);
 	if (isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp,
 						    &bound_pw, &data) < 0)
 		goto error;

_service:tar_scm:isl-0.14.tar.xz/isl_bound.h -> _service:tar_scm:isl-0.24.tar.gz/isl_bound.h Changed

_service:tar_scm:isl-0.24.tar.gz/isl_box.c Added

@@ -0,0 +1,462 @@
+/*
+ * Copyright 2010-2011 INRIA Saclay
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/val.h>
+#include <isl/space.h>
+#include <isl_map_private.h>
+#include <isl_aff_private.h>
+#include <isl/constraint.h>
+#include <isl/ilp.h>
+#include <isl/fixed_box.h>
+
+/* Representation of a box of fixed size containing the elements
+ * offset, offset + size).
+ * "size" lives in the target space of "offset".
+ *
+ * If any of the "offsets" is NaN, then the object represents
+ * the failure of finding a fixed-size box.
+ */
+struct isl_fixed_box {
+	isl_multi_aff *offset;
+	isl_multi_val *size;
+};
+
+/* Free "box" and return NULL.
+ */
+__isl_null isl_fixed_box *isl_fixed_box_free(__isl_take isl_fixed_box *box)
+{
+	if (!box)
+		return NULL;
+	isl_multi_aff_free(box->offset);
+	isl_multi_val_free(box->size);
+	free(box);
+	return NULL;
+}
+
+/* Construct an isl_fixed_box with the given offset and size.
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_alloc(
+	__isl_take isl_multi_aff *offset, __isl_take isl_multi_val *size)
+{
+	isl_ctx *ctx;
+	isl_fixed_box *box;
+
+	if (!offset || !size)
+		goto error;
+	ctx = isl_multi_aff_get_ctx(offset);
+	box = isl_alloc_type(ctx, struct isl_fixed_box);
+	if (!box)
+		goto error;
+	box->offset = offset;
+	box->size = size;
+
+	return box;
+error:
+	isl_multi_aff_free(offset);
+	isl_multi_val_free(size);
+	return NULL;
+}
+
+/* Construct an initial isl_fixed_box with zero offsets
+ * in the given space and zero corresponding sizes.
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_init(
+	__isl_take isl_space *space)
+{
+	isl_multi_aff *offset;
+	isl_multi_val *size;
+
+	offset = isl_multi_aff_zero(isl_space_copy(space));
+	space = isl_space_drop_all_params(isl_space_range(space));
+	size = isl_multi_val_zero(space);
+	return isl_fixed_box_alloc(offset, size);
+}
+
+/* Return a copy of "box".
+ */
+__isl_give isl_fixed_box *isl_fixed_box_copy(__isl_keep isl_fixed_box *box)
+{
+	isl_multi_aff *offset;
+	isl_multi_val *size;
+
+	offset = isl_fixed_box_get_offset(box);
+	size = isl_fixed_box_get_size(box);
+	return isl_fixed_box_alloc(offset, size);
+}
+
+/* Replace the offset and size in direction "pos" by "offset" and "size"
+ * (without checking whether "box" is a valid box).
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_set_extent(
+	__isl_take isl_fixed_box *box, int pos, __isl_keep isl_aff *offset,
+	__isl_keep isl_val *size)
+{
+	if (!box)
+		return NULL;
+	box->offset = isl_multi_aff_set_aff(box->offset, pos,
+							isl_aff_copy(offset));
+	box->size = isl_multi_val_set_val(box->size, pos, isl_val_copy(size));
+	if (!box->offset || !box->size)
+		return isl_fixed_box_free(box);
+	return box;
+}
+
+/* Replace the offset and size in direction "pos" by "offset" and "size",
+ * if "box" is a valid box.
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_set_valid_extent(
+	__isl_take isl_fixed_box *box, int pos, __isl_keep isl_aff *offset,
+	__isl_keep isl_val *size)
+{
+	isl_bool valid;
+
+	valid = isl_fixed_box_is_valid(box);
+	if (valid < 0 || !valid)
+		return box;
+	return isl_fixed_box_set_extent(box, pos, offset, size);
+}
+
+/* Replace "box" by an invalid box, by setting all offsets to NaN
+ * (and all sizes to infinity).
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_invalidate(
+	__isl_take isl_fixed_box *box)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_val *infty;
+	isl_aff *nan;
+
+	if (!box)
+		return NULL;
+	n = isl_multi_val_dim(box->size, isl_dim_set);
+	if (n < 0)
+		return isl_fixed_box_free(box);
+
+	infty = isl_val_infty(isl_fixed_box_get_ctx(box));
+	space = isl_space_domain(isl_fixed_box_get_space(box));
+	nan = isl_aff_nan_on_domain(isl_local_space_from_space(space));
+	for (i = 0; i < n; ++i)
+		box = isl_fixed_box_set_extent(box, i, nan, infty);
+	isl_aff_free(nan);
+	isl_val_free(infty);
+
+	if (!box->offset || !box->size)
+		return isl_fixed_box_free(box);
+	return box;
+}
+
+/* Project the domain of the fixed box onto its parameter space.
+ * In particular, project out the domain of the offset.
+ */
+static __isl_give isl_fixed_box *isl_fixed_box_project_domain_on_params(
+	__isl_take isl_fixed_box *box)
+{
+	isl_bool valid;
+
+	valid = isl_fixed_box_is_valid(box);
+	if (valid < 0)
+		return isl_fixed_box_free(box);
+	if (!valid)
+		return box;
+
+	box->offset = isl_multi_aff_project_domain_on_params(box->offset);
+	if (!box->offset)
+		return isl_fixed_box_free(box);
+
+	return box;
+}
+
+/* Return the isl_ctx to which "box" belongs.
+ */
+isl_ctx *isl_fixed_box_get_ctx(__isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return NULL;
+	return isl_multi_aff_get_ctx(box->offset);
+}
+
+/* Return the space in which "box" lives.
+ */
+__isl_give isl_space *isl_fixed_box_get_space(__isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return NULL;
+	return isl_multi_aff_get_space(box->offset);
+}
+
+/* Does "box" contain valid information?
+ */
+isl_bool isl_fixed_box_is_valid(__isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return isl_bool_error;
+	return isl_bool_not(isl_multi_aff_involves_nan(box->offset));
+}
+
+/* Return the offsets of the box "box".
+ */
+__isl_give isl_multi_aff *isl_fixed_box_get_offset(
+	__isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return NULL;
+	return isl_multi_aff_copy(box->offset);
+}
+
+/* Return the sizes of the box "box".
+ */
+__isl_give isl_multi_val *isl_fixed_box_get_size(__isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return NULL;
+	return isl_multi_val_copy(box->size);
+}
+
+/* Data used in set_dim_extent and compute_size_in_direction.
+ *
+ * "bset" is a wrapped copy of the basic map that has the selected
+ * output dimension as range.
+ * "pos" is the position of the variable representing the output dimension,
+ * i.e., the variable for which the size should be computed.  This variable
+ * is also the last variable in "bset".
+ * "size" is the best size found so far
+ * (infinity if no offset was found so far).
+ * "offset" is the offset corresponding to the best size
+ * (NULL if no offset was found so far).
+ */
+struct isl_size_info {
+	isl_basic_set *bset;
+	isl_size pos;
+	isl_val *size;
+	isl_aff *offset;
+};
+
+/* Is "c" a suitable bound on dimension "pos" for use as a lower bound
+ * of a fixed-size range.
+ * In particular, it needs to be a lower bound on "pos".
+ * In order for the final offset not to be too complicated,
+ * the constraint itself should also not involve any integer divisions.
+ */
+static isl_bool is_suitable_bound(__isl_keep isl_constraint *c, unsigned pos)
+{
+	isl_size n_div;
+	isl_bool is_bound, any_divs;
+
+	is_bound = isl_constraint_is_lower_bound(c, isl_dim_set, pos);
+	if (is_bound < 0 || !is_bound)
+		return is_bound;
+
+	n_div = isl_constraint_dim(c, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
+	any_divs = isl_constraint_involves_dims(c, isl_dim_div, 0, n_div);
+	return isl_bool_not(any_divs);
+}
+
+/* Given a constraint from the basic set describing the bounds on
+ * an array index, check if it is a lower bound, say m i >= b(x), and,
+ * if so, check whether the expression "i - ceil(b(x)/m) + 1" has a constant
+ * upper bound.  If so, and if this bound is smaller than any bound
+ * derived from earlier constraints, set the size to this bound on
+ * the expression and the lower bound to ceil(b(x)/m).
+ */
+static isl_stat compute_size_in_direction(__isl_take isl_constraint *c,
+	void *user)
+{
+	struct isl_size_info *info = user;
+	isl_val *v;
+	isl_aff *aff;
+	isl_aff *lb;
+	isl_bool is_bound, better;
+
+	is_bound = is_suitable_bound(c, info->pos);
+	if (is_bound < 0 || !is_bound) {
+		isl_constraint_free(c);
+		return is_bound < 0 ? isl_stat_error : isl_stat_ok;
+	}
+
+	aff = isl_constraint_get_bound(c, isl_dim_set, info->pos);
+	aff = isl_aff_ceil(aff);
+
+	lb = isl_aff_copy(aff);
+
+	aff = isl_aff_neg(aff);
+	aff = isl_aff_add_coefficient_si(aff, isl_dim_in, info->pos, 1);
+
+	v = isl_basic_set_max_val(info->bset, aff);
+	isl_aff_free(aff);
+
+	v = isl_val_add_ui(v, 1);
+	better = isl_val_lt(v, info->size);
+	if (better >= 0 && better) {
+		isl_val_free(info->size);
+		info->size = isl_val_copy(v);
+		lb = isl_aff_domain_factor_domain(lb);
+		isl_aff_free(info->offset);
+		info->offset = isl_aff_copy(lb);
+	}
+	isl_val_free(v);
+	isl_aff_free(lb);
+
+	isl_constraint_free(c);
+
+	return better < 0 ? isl_stat_error : isl_stat_ok;
+}
+
+/* Look for a fixed-size range of values for the output dimension "pos"
+ * of "map", by looking for a lower-bound expression in the parameters
+ * and input dimensions such that the range of the output dimension
+ * is a constant shifted by this expression.
+ *
+ * In particular, look through the explicit lower bounds on the output dimension
+ * for candidate expressions and pick the one that results in the smallest size.
+ * Initialize the size with infinity and if no better size is found
+ * then invalidate the box.  Otherwise, set the offset and size
+ * in the given direction by those that correspond to the smallest size.
+ *
+ * Note that while evaluating the size corresponding to a lower bound,
+ * an affine expression is constructed from the lower bound.
+ * This lower bound may therefore not have any unknown local variables.
+ * Eliminate any unknown local variables up front.
+ * No such restriction needs to be imposed on the set over which
+ * the size is computed.
+ */
+static __isl_give isl_fixed_box *set_dim_extent(__isl_take isl_fixed_box *box,
+	__isl_keep isl_map *map, int pos)
+{
+	struct isl_size_info info;
+	isl_bool valid;
+	isl_ctx *ctx;
+	isl_basic_set *bset;
+
+	if (!box || !map)
+		return isl_fixed_box_free(box);
+
+	ctx = isl_map_get_ctx(map);
+	map = isl_map_copy(map);
+	map = isl_map_project_onto(map, isl_dim_out, pos, 1);
+	info.size = isl_val_infty(ctx);
+	info.offset = NULL;
+	info.pos = isl_map_dim(map, isl_dim_in);
+	info.bset = isl_basic_map_wrap(isl_map_simple_hull(map));
+	bset = isl_basic_set_copy(info.bset);
+	bset = isl_basic_set_remove_unknown_divs(bset);
+	if (info.pos < 0)
+		bset = isl_basic_set_free(bset);
+	if (isl_basic_set_foreach_constraint(bset,
+					&compute_size_in_direction, &info) < 0)
+		box = isl_fixed_box_free(box);
+	isl_basic_set_free(bset);
+	valid = isl_val_is_int(info.size);
+	if (valid < 0)
+		box = isl_fixed_box_free(box);
+	else if (valid)
+		box = isl_fixed_box_set_valid_extent(box, pos,
+						     info.offset, info.size);
+	else
+		box = isl_fixed_box_invalidate(box);
+	isl_val_free(info.size);
+	isl_aff_free(info.offset);
+	isl_basic_set_free(info.bset);
+
+	return box;
+}
+
+/* Try and construct a fixed-size rectangular box with an offset
+ * in terms of the domain of "map" that contains the range of "map".
+ * If no such box can be constructed, then return an invalidated box,
+ * i.e., one where isl_fixed_box_is_valid returns false.
+ *
+ * Iterate over the dimensions in the range
+ * setting the corresponding offset and extent.
+ */
+__isl_give isl_fixed_box *isl_map_get_range_simple_fixed_box_hull(
+	__isl_keep isl_map *map)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_fixed_box *box;
+
+	n = isl_map_dim(map, isl_dim_out);
+	if (n < 0)
+		return NULL;
+	space = isl_map_get_space(map);
+	box = isl_fixed_box_init(space);
+
+	map = isl_map_detect_equalities(isl_map_copy(map));
+	for (i = 0; i < n; ++i) {
+		isl_bool valid;
+
+		box = set_dim_extent(box, map, i);
+		valid = isl_fixed_box_is_valid(box);
+		if (valid < 0 || !valid)
+			break;
+	}
+	isl_map_free(map);
+
+	return box;
+}
+
+/* Try and construct a fixed-size rectangular box with an offset
+ * in terms of the parameters of "set" that contains "set".
+ * If no such box can be constructed, then return an invalidated box,
+ * i.e., one where isl_fixed_box_is_valid returns false.
+ *
+ * Compute the box using isl_map_get_range_simple_fixed_box_hull
+ * by constructing a map from the set and
+ * project out the domain again from the result.
+ */
+__isl_give isl_fixed_box *isl_set_get_simple_fixed_box_hull(
+	__isl_keep isl_set *set)
+{
+	isl_map *map;
+	isl_fixed_box *box;
+
+	map = isl_map_from_range(isl_set_copy(set));
+	box = isl_map_get_range_simple_fixed_box_hull(map);
+	isl_map_free(map);
+	box = isl_fixed_box_project_domain_on_params(box);
+
+	return box;
+}
+
+#undef BASE
+#define BASE multi_val
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE multi_aff
+#include "print_yaml_field_templ.c"
+
+/* Print the information contained in "box" to "p".
+ * The information is printed as a YAML document.
+ */
+__isl_give isl_printer *isl_printer_print_fixed_box(
+	__isl_take isl_printer *p, __isl_keep isl_fixed_box *box)
+{
+	if (!box)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_mapping(p);
+	p = print_yaml_field_multi_aff(p, "offset", box->offset);
+	p = print_yaml_field_multi_val(p, "size", box->size);
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+#undef BASE
+#define BASE fixed_box
+#include <print_templ_yaml.c>

_service:tar_scm:isl-0.24.tar.gz/isl_check_named_params_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_coalesce.c -> _service:tar_scm:isl-0.24.tar.gz/isl_coalesce.c Changed

@@ -2,6 +2,9 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      INRIA Paris
+ * Copyright 2020      Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -10,15 +13,28 @@
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
+ * CS 42112, 75589 Paris Cedex 12, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
+#include <isl_ctx_private.h>
 #include "isl_map_private.h"
 #include <isl_seq.h>
 #include <isl/options.h>
 #include "isl_tab.h"
 #include <isl_mat_private.h>
 #include <isl_local_space_private.h>
+#include <isl_val_private.h>
 #include <isl_vec_private.h>
+#include <isl_aff_private.h>
+#include <isl_equalities.h>
+#include <isl_constraint_private.h>
+
+#include <set_to_map.c>
+#include <set_from_map.c>
 
 #define STATUS_ERROR		-1
 #define STATUS_REDUNDANT	 1
@@ -45,20 +61,24 @@
 /* Compute the position of the equalities of basic map "bmap_i"
  * with respect to the basic map represented by "tab_j".
  * The resulting array has twice as many entries as the number
- * of equalities corresponding to the two inequalties to which
+ * of equalities corresponding to the two inequalities to which
  * each equality corresponds.
  */
 static int *eq_status_in(__isl_keep isl_basic_map *bmap_i,
 	struct isl_tab *tab_j)
 {
 	int k, l;
-	int *eq = isl_calloc_array(bmap_i->ctx, int, 2 * bmap_i->n_eq);
-	unsigned dim;
+	int *eq;
+	isl_size dim;
+
+	dim = isl_basic_map_dim(bmap_i, isl_dim_all);
+	if (dim < 0)
+		return NULL;
 
+	eq = isl_calloc_array(bmap_i->ctx, int, 2 * bmap_i->n_eq);
 	if (!eq)
 		return NULL;
 
-	dim = isl_basic_map_total_dim(bmap_i);
 	for (k = 0; k < bmap_i->n_eq; ++k) {
 		for (l = 0; l < 2; ++l) {
 			isl_seq_neg(bmap_i->eqk, bmap_i->eqk, 1+dim);
@@ -66,9 +86,6 @@
 			if (eq2 * k + l == STATUS_ERROR)
 				goto error;
 		}
-		if (eq2 * k == STATUS_SEPARATE ||
-		    eq2 * k + 1 == STATUS_SEPARATE)
-			break;
 	}
 
 	return eq;
@@ -119,6 +136,19 @@
 	return 0;
 }
 
+/* Return the first position of "status" in the list "con" of length "len".
+ * Return -1 if there is no such entry.
+ */
+static int find(int *con, unsigned len, int status)
+{
+	int i;
+
+	for (i = 0; i < len ; ++i)
+		if (coni == status)
+			return i;
+	return -1;
+}
+
 static int count(int *con, unsigned len, int status)
 {
 	int i;
@@ -143,83 +173,381 @@
 	return 1;
 }
 
-static void drop(struct isl_map *map, int i, struct isl_tab **tabs)
+/* Internal information associated to a basic map in a map
+ * that is to be coalesced by isl_map_coalesce.
+ *
+ * "bmap" is the basic map itself (or NULL if "removed" is set)
+ * "tab" is the corresponding tableau (or NULL if "removed" is set)
+ * "hull_hash" identifies the affine space in which "bmap" lives.
+ * "modified" is set if this basic map may not be identical
+ * to any of the basic maps in the input.
+ * "removed" is set if this basic map has been removed from the map
+ * "simplify" is set if this basic map may have some unknown integer
+ * divisions that were not present in the input basic maps.  The basic
+ * map should then be simplified such that we may be able to find
+ * a definition among the constraints.
+ *
+ * "eq" and "ineq" are only set if we are currently trying to coalesce
+ * this basic map with another basic map, in which case they represent
+ * the position of the inequalities of this basic map with respect to
+ * the other basic map.  The number of elements in the "eq" array
+ * is twice the number of equalities in the "bmap", corresponding
+ * to the two inequalities that make up each equality.
+ */
+struct isl_coalesce_info {
+	isl_basic_map *bmap;
+	struct isl_tab *tab;
+	uint32_t hull_hash;
+	int modified;
+	int removed;
+	int simplify;
+	int *eq;
+	int *ineq;
+};
+
+/* Is there any (half of an) equality constraint in the description
+ * of the basic map represented by "info" that
+ * has position "status" with respect to the other basic map?
+ */
+static int any_eq(struct isl_coalesce_info *info, int status)
 {
-	isl_basic_map_free(map->pi);
-	isl_tab_free(tabsi);
+	isl_size n_eq;
 
-	if (i != map->n - 1) {
-		map->pi = map->pmap->n - 1;
-		tabsi = tabsmap->n - 1;
-	}
-	tabsmap->n - 1 = NULL;
-	map->n--;
+	n_eq = isl_basic_map_n_equality(info->bmap);
+	return any(info->eq, 2 * n_eq, status);
 }
 
-/* Replace the pair of basic maps i and j by the basic map bounded
- * by the valid constraints in both basic maps and the constraint
- * in extra (if not NULL).
+/* Is there any inequality constraint in the description
+ * of the basic map represented by "info" that
+ * has position "status" with respect to the other basic map?
  */
-static int fuse(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j,
-	__isl_keep isl_mat *extra)
+static int any_ineq(struct isl_coalesce_info *info, int status)
 {
-	int k, l;
-	struct isl_basic_map *fused = NULL;
-	struct isl_tab *fused_tab = NULL;
-	unsigned total = isl_basic_map_total_dim(map->pi);
-	unsigned extra_rows = extra ? extra->n_row : 0;
+	isl_size n_ineq;
 
-	fused = isl_basic_map_alloc_space(isl_space_copy(map->pi->dim),
-			map->pi->n_div,
-			map->pi->n_eq + map->pj->n_eq,
-			map->pi->n_ineq + map->pj->n_ineq + extra_rows);
-	if (!fused)
-		goto error;
+	n_ineq = isl_basic_map_n_inequality(info->bmap);
+	return any(info->ineq, n_ineq, status);
+}
+
+/* Return the position of the first half on an equality constraint
+ * in the description of the basic map represented by "info" that
+ * has position "status" with respect to the other basic map.
+ * The returned value is twice the position of the equality constraint
+ * plus zero for the negative half and plus one for the positive half.
+ * Return -1 if there is no such entry.
+ */
+static int find_eq(struct isl_coalesce_info *info, int status)
+{
+	isl_size n_eq;
+
+	n_eq = isl_basic_map_n_equality(info->bmap);
+	return find(info->eq, 2 * n_eq, status);
+}
+
+/* Return the position of the first inequality constraint in the description
+ * of the basic map represented by "info" that
+ * has position "status" with respect to the other basic map.
+ * Return -1 if there is no such entry.
+ */
+static int find_ineq(struct isl_coalesce_info *info, int status)
+{
+	isl_size n_ineq;
+
+	n_ineq = isl_basic_map_n_inequality(info->bmap);
+	return find(info->ineq, n_ineq, status);
+}
+
+/* Return the number of (halves of) equality constraints in the description
+ * of the basic map represented by "info" that
+ * have position "status" with respect to the other basic map.
+ */
+static int count_eq(struct isl_coalesce_info *info, int status)
+{
+	isl_size n_eq;
+
+	n_eq = isl_basic_map_n_equality(info->bmap);
+	return count(info->eq, 2 * n_eq, status);
+}
+
+/* Return the number of inequality constraints in the description
+ * of the basic map represented by "info" that
+ * have position "status" with respect to the other basic map.
+ */
+static int count_ineq(struct isl_coalesce_info *info, int status)
+{
+	isl_size n_ineq;
 
-	for (k = 0; k < map->pi->n_eq; ++k) {
-		if (eq_i && (eq_i2 * k != STATUS_VALID ||
-			     eq_i2 * k + 1 != STATUS_VALID))
+	n_ineq = isl_basic_map_n_inequality(info->bmap);
+	return count(info->ineq, n_ineq, status);
+}
+
+/* Are all non-redundant constraints of the basic map represented by "info"
+ * either valid or cut constraints with respect to the other basic map?
+ */
+static int all_valid_or_cut(struct isl_coalesce_info *info)
+{
+	int i;
+
+	for (i = 0; i < 2 * info->bmap->n_eq; ++i) {
+		if (info->eqi == STATUS_REDUNDANT)
 			continue;
-		l = isl_basic_map_alloc_equality(fused);
-		if (l < 0)
-			goto error;
-		isl_seq_cpy(fused->eql, map->pi->eqk, 1 + total);
+		if (info->eqi == STATUS_VALID)
+			continue;
+		if (info->eqi == STATUS_CUT)
+			continue;
+		return 0;
 	}
 
-	for (k = 0; k < map->pj->n_eq; ++k) {
-		if (eq_j && (eq_j2 * k != STATUS_VALID ||
-			     eq_j2 * k + 1 != STATUS_VALID))
+	for (i = 0; i < info->bmap->n_ineq; ++i) {
+		if (info->ineqi == STATUS_REDUNDANT)
 			continue;
-		l = isl_basic_map_alloc_equality(fused);
-		if (l < 0)
-			goto error;
-		isl_seq_cpy(fused->eql, map->pj->eqk, 1 + total);
+		if (info->ineqi == STATUS_VALID)
+			continue;
+		if (info->ineqi == STATUS_CUT)
+			continue;
+		return 0;
 	}
 
-	for (k = 0; k < map->pi->n_ineq; ++k) {
-		if (ineq_ik != STATUS_VALID)
-			continue;
-		l = isl_basic_map_alloc_inequality(fused);
-		if (l < 0)
-			goto error;
-		isl_seq_cpy(fused->ineql, map->pi->ineqk, 1 + total);
+	return 1;
+}
+
+/* Compute the hash of the (apparent) affine hull of info->bmap (with
+ * the existentially quantified variables removed) and store it
+ * in info->hash.
+ */
+static int coalesce_info_set_hull_hash(struct isl_coalesce_info *info)
+{
+	isl_basic_map *hull;
+	isl_size n_div;
+
+	hull = isl_basic_map_copy(info->bmap);
+	hull = isl_basic_map_plain_affine_hull(hull);
+	n_div = isl_basic_map_dim(hull, isl_dim_div);
+	if (n_div < 0)
+		hull = isl_basic_map_free(hull);
+	hull = isl_basic_map_drop_constraints_involving_dims(hull,
+							isl_dim_div, 0, n_div);
+	info->hull_hash = isl_basic_map_get_hash(hull);
+	isl_basic_map_free(hull);
+
+	return hull ? 0 : -1;
+}
+
+/* Free all the allocated memory in an array
+ * of "n" isl_coalesce_info elements.
+ */
+static void clear_coalesce_info(int n, struct isl_coalesce_info *info)
+{
+	int i;
+
+	if (!info)
+		return;
+
+	for (i = 0; i < n; ++i) {
+		isl_basic_map_free(infoi.bmap);
+		isl_tab_free(infoi.tab);
+	}
+
+	free(info);
+}
+
+/* Clear the memory associated to "info".
+ */
+static void clear(struct isl_coalesce_info *info)
+{
+	info->bmap = isl_basic_map_free(info->bmap);
+	isl_tab_free(info->tab);
+	info->tab = NULL;
+}
+
+/* Drop the basic map represented by "info".
+ * That is, clear the memory associated to the entry and
+ * mark it as having been removed.
+ */
+static void drop(struct isl_coalesce_info *info)
+{
+	clear(info);
+	info->removed = 1;
+}
+
+/* Exchange the information in "info1" with that in "info2".
+ */
+static void exchange(struct isl_coalesce_info *info1,
+	struct isl_coalesce_info *info2)
+{
+	struct isl_coalesce_info info;
+
+	info = *info1;
+	*info1 = *info2;
+	*info2 = info;
+}
+
+/* This type represents the kind of change that has been performed
+ * while trying to coalesce two basic maps.
+ *
+ * isl_change_none: nothing was changed
+ * isl_change_drop_first: the first basic map was removed
+ * isl_change_drop_second: the second basic map was removed
+ * isl_change_fuse: the two basic maps were replaced by a new basic map.
+ */
+enum isl_change {
+	isl_change_error = -1,
+	isl_change_none = 0,
+	isl_change_drop_first,
+	isl_change_drop_second,
+	isl_change_fuse,
+};
+
+/* Update "change" based on an interchange of the first and the second
+ * basic map.  That is, interchange isl_change_drop_first and
+ * isl_change_drop_second.
+ */
+static enum isl_change invert_change(enum isl_change change)
+{
+	switch (change) {
+	case isl_change_error:
+		return isl_change_error;
+	case isl_change_none:
+		return isl_change_none;
+	case isl_change_drop_first:
+		return isl_change_drop_second;
+	case isl_change_drop_second:
+		return isl_change_drop_first;
+	case isl_change_fuse:
+		return isl_change_fuse;
 	}
 
-	for (k = 0; k < map->pj->n_ineq; ++k) {
-		if (ineq_jk != STATUS_VALID)
+	return isl_change_error;
+}
+
+/* Add the valid constraints of the basic map represented by "info"
+ * to "bmap".  "len" is the size of the constraints.
+ * If only one of the pair of inequalities that make up an equality
+ * is valid, then add that inequality.
+ */
+static __isl_give isl_basic_map *add_valid_constraints(
+	__isl_take isl_basic_map *bmap, struct isl_coalesce_info *info,
+	unsigned len)
+{
+	int k, l;
+
+	if (!bmap)
+		return NULL;
+
+	for (k = 0; k < info->bmap->n_eq; ++k) {
+		if (info->eq2 * k == STATUS_VALID &&
+		    info->eq2 * k + 1 == STATUS_VALID) {
+			l = isl_basic_map_alloc_equality(bmap);
+			if (l < 0)
+				return isl_basic_map_free(bmap);
+			isl_seq_cpy(bmap->eql, info->bmap->eqk, len);
+		} else if (info->eq2 * k == STATUS_VALID) {
+			l = isl_basic_map_alloc_inequality(bmap);
+			if (l < 0)
+				return isl_basic_map_free(bmap);
+			isl_seq_neg(bmap->ineql, info->bmap->eqk, len);
+		} else if (info->eq2 * k + 1 == STATUS_VALID) {
+			l = isl_basic_map_alloc_inequality(bmap);
+			if (l < 0)
+				return isl_basic_map_free(bmap);
+			isl_seq_cpy(bmap->ineql, info->bmap->eqk, len);
+		}
+	}
+
+	for (k = 0; k < info->bmap->n_ineq; ++k) {
+		if (info->ineqk != STATUS_VALID)
 			continue;
-		l = isl_basic_map_alloc_inequality(fused);
+		l = isl_basic_map_alloc_inequality(bmap);
 		if (l < 0)
-			goto error;
-		isl_seq_cpy(fused->ineql, map->pj->ineqk, 1 + total);
+			return isl_basic_map_free(bmap);
+		isl_seq_cpy(bmap->ineql, info->bmap->ineqk, len);
 	}
 
-	for (k = 0; k < map->pi->n_div; ++k) {
+	return bmap;
+}
+
+/* Is "bmap" defined by a number of (non-redundant) constraints that
+ * is greater than the number of constraints of basic maps i and j combined?
+ * Equalities are counted as two inequalities.
+ */
+static int number_of_constraints_increases(int i, int j,
+	struct isl_coalesce_info *info,
+	__isl_keep isl_basic_map *bmap, struct isl_tab *tab)
+{
+	int k, n_old, n_new;
+
+	n_old = 2 * infoi.bmap->n_eq + infoi.bmap->n_ineq;
+	n_old += 2 * infoj.bmap->n_eq + infoj.bmap->n_ineq;
+
+	n_new = 2 * bmap->n_eq;
+	for (k = 0; k < bmap->n_ineq; ++k)
+		if (!isl_tab_is_redundant(tab, bmap->n_eq + k))
+			++n_new;
+
+	return n_new > n_old;
+}
+
+/* Replace the pair of basic maps i and j by the basic map bounded
+ * by the valid constraints in both basic maps and the constraints
+ * in extra (if not NULL).
+ * Place the fused basic map in the position that is the smallest of i and j.
+ *
+ * If "detect_equalities" is set, then look for equalities encoded
+ * as pairs of inequalities.
+ * If "check_number" is set, then the original basic maps are only
+ * replaced if the total number of constraints does not increase.
+ * While the number of integer divisions in the two basic maps
+ * is assumed to be the same, the actual definitions may be different.
+ * We only copy the definition from one of the basic map if it is
+ * the same as that of the other basic map.  Otherwise, we mark
+ * the integer division as unknown and simplify the basic map
+ * in an attempt to recover the integer division definition.
+ * If any extra constraints get introduced, then these may
+ * involve integer divisions with a unit coefficient.
+ * Eliminate those that do not appear with any other coefficient
+ * in other constraints, to ensure they get eliminated completely,
+ * improving the chances of further coalescing.
+ */
+static enum isl_change fuse(int i, int j, struct isl_coalesce_info *info,
+	__isl_keep isl_mat *extra, int detect_equalities, int check_number)
+{
+	int k, l;
+	struct isl_basic_map *fused = NULL;
+	struct isl_tab *fused_tab = NULL;
+	isl_size total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	unsigned extra_rows = extra ? extra->n_row : 0;
+	unsigned n_eq, n_ineq;
+	int simplify = 0;
+
+	if (total < 0)
+		return isl_change_error;
+	if (j < i)
+		return fuse(j, i, info, extra, detect_equalities, check_number);
+
+	n_eq = infoi.bmap->n_eq + infoj.bmap->n_eq;
+	n_ineq = infoi.bmap->n_ineq + infoj.bmap->n_ineq;
+	fused = isl_basic_map_alloc_space(isl_space_copy(infoi.bmap->dim),
+		    infoi.bmap->n_div, n_eq, n_eq + n_ineq + extra_rows);
+	fused = add_valid_constraints(fused, &infoi, 1 + total);
+	fused = add_valid_constraints(fused, &infoj, 1 + total);
+	if (!fused)
+		goto error;
+	if (ISL_F_ISSET(infoi.bmap, ISL_BASIC_MAP_RATIONAL) &&
+	    ISL_F_ISSET(infoj.bmap, ISL_BASIC_MAP_RATIONAL))
+		ISL_F_SET(fused, ISL_BASIC_MAP_RATIONAL);
+
+	for (k = 0; k < infoi.bmap->n_div; ++k) {
 		int l = isl_basic_map_alloc_div(fused);
 		if (l < 0)
 			goto error;
-		isl_seq_cpy(fused->divl, map->pi->divk, 1 + 1 + total);
+		if (isl_seq_eq(infoi.bmap->divk, infoj.bmap->divk,
+				1 + 1 + total)) {
+			isl_seq_cpy(fused->divl, infoi.bmap->divk,
+				1 + 1 + total);
+		} else {
+			isl_int_set_si(fused->divl0, 0);
+			simplify = 1;
+		}
 	}
 
 	for (k = 0; k < extra_rows; ++k) {
@@ -229,27 +557,39 @@
 		isl_seq_cpy(fused->ineql, extra->rowk, 1 + total);
 	}
 
+	if (detect_equalities)
+		fused = isl_basic_map_detect_inequality_pairs(fused, NULL);
 	fused = isl_basic_map_gauss(fused, NULL);
-	ISL_F_SET(fused, ISL_BASIC_MAP_FINAL);
-	if (ISL_F_ISSET(map->pi, ISL_BASIC_MAP_RATIONAL) &&
-	    ISL_F_ISSET(map->pj, ISL_BASIC_MAP_RATIONAL))
-		ISL_F_SET(fused, ISL_BASIC_MAP_RATIONAL);
+	if (simplify || infoj.simplify) {
+		fused = isl_basic_map_simplify(fused);
+		infoi.simplify = 0;
+	} else if (extra_rows > 0) {
+		fused = isl_basic_map_eliminate_pure_unit_divs(fused);
+	}
+	fused = isl_basic_map_finalize(fused);
 
 	fused_tab = isl_tab_from_basic_map(fused, 0);
 	if (isl_tab_detect_redundant(fused_tab) < 0)
 		goto error;
 
-	isl_basic_map_free(map->pi);
-	map->pi = fused;
-	isl_tab_free(tabsi);
-	tabsi = fused_tab;
-	drop(map, j, tabs);
+	if (check_number &&
+	    number_of_constraints_increases(i, j, info, fused, fused_tab)) {
+		isl_tab_free(fused_tab);
+		isl_basic_map_free(fused);
+		return isl_change_none;
+	}
+
+	clear(&infoi);
+	infoi.bmap = fused;
+	infoi.tab = fused_tab;
+	infoi.modified = 1;
+	drop(&infoj);
 
-	return 1;
+	return isl_change_fuse;
 error:
 	isl_tab_free(fused_tab);
 	isl_basic_map_free(fused);
-	return -1;
+	return isl_change_error;
 }
 
 /* Given a pair of basic maps i and j such that all constraints are either
@@ -257,89 +597,122 @@
  * constraints of i lie entirely within basic map j.
  * If so, replace the pair by the basic map consisting of the valid
  * constraints in both basic maps.
+ * Checking whether the facet lies entirely within basic map j
+ * is performed by checking whether the constraints of basic map j
+ * are valid for the facet.  These tests are performed on a rational
+ * tableau to avoid the theoretical possibility that a constraint
+ * that was considered to be a cut constraint for the entire basic map i
+ * happens to be considered to be a valid constraint for the facet,
+ * even though it cuts off the same rational points.
  *
  * To see that we are not introducing any extra points, call the
  * two basic maps A and B and the resulting map U and let x
  * be an element of U \setminus ( A \cup B ).
- * Then there is a pair of cut constraints c_1 and c_2 in A and B such that x
- * violates them.  Let X be the intersection of U with the opposites
- * of these constraints.  Then x \in X.
- * The facet corresponding to c_1 contains the corresponding facet of A.
- * This facet is entirely contained in B, so c_2 is valid on the facet.
- * However, since it is also (part of) a facet of X, -c_2 is also valid
- * on the facet.  This means c_2 is saturated on the facet, so c_1 and
- * c_2 must be opposites of each other, but then x could not violate
- * both of them.
+ * A line connecting x with an element of A \cup B meets a facet F
+ * of either A or B.  Assume it is a facet of B and let c_1 be
+ * the corresponding facet constraint.  We have c_1(x) < 0 and
+ * so c_1 is a cut constraint.  This implies that there is some
+ * (possibly rational) point x' satisfying the constraints of A
+ * and the opposite of c_1 as otherwise c_1 would have been marked
+ * valid for A.  The line connecting x and x' meets a facet of A
+ * in a (possibly rational) point that also violates c_1, but this
+ * is impossible since all cut constraints of B are valid for all
+ * cut facets of A.
+ * In case F is a facet of A rather than B, then we can apply the
+ * above reasoning to find a facet of B separating x from A \cup B first.
  */
-static int check_facets(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *ineq_i, int *ineq_j)
+static enum isl_change check_facets(int i, int j,
+	struct isl_coalesce_info *info)
 {
 	int k, l;
-	struct isl_tab_undo *snap;
-	unsigned n_eq = map->pi->n_eq;
+	struct isl_tab_undo *snap, *snap2;
+	unsigned n_eq = infoi.bmap->n_eq;
 
-	snap = isl_tab_snap(tabsi);
+	snap = isl_tab_snap(infoi.tab);
+	if (isl_tab_mark_rational(infoi.tab) < 0)
+		return isl_change_error;
+	snap2 = isl_tab_snap(infoi.tab);
 
-	for (k = 0; k < map->pi->n_ineq; ++k) {
-		if (ineq_ik != STATUS_CUT)
+	for (k = 0; k < infoi.bmap->n_ineq; ++k) {
+		if (infoi.ineqk != STATUS_CUT)
 			continue;
-		if (isl_tab_select_facet(tabsi, n_eq + k) < 0)
-			return -1;
-		for (l = 0; l < map->pj->n_ineq; ++l) {
+		if (isl_tab_select_facet(infoi.tab, n_eq + k) < 0)
+			return isl_change_error;
+		for (l = 0; l < infoj.bmap->n_ineq; ++l) {
 			int stat;
-			if (ineq_jl != STATUS_CUT)
+			if (infoj.ineql != STATUS_CUT)
 				continue;
-			stat = status_in(map->pj->ineql, tabsi);
+			stat = status_in(infoj.bmap->ineql, infoi.tab);
+			if (stat < 0)
+				return isl_change_error;
 			if (stat != STATUS_VALID)
 				break;
 		}
-		if (isl_tab_rollback(tabsi, snap) < 0)
-			return -1;
-		if (l < map->pj->n_ineq)
+		if (isl_tab_rollback(infoi.tab, snap2) < 0)
+			return isl_change_error;
+		if (l < infoj.bmap->n_ineq)
 			break;
 	}
 
-	if (k < map->pi->n_ineq)
-		/* BAD CUT PAIR */
-		return 0;
-	return fuse(map, i, j, tabs, NULL, ineq_i, NULL, ineq_j, NULL);
+	if (k < infoi.bmap->n_ineq) {
+		if (isl_tab_rollback(infoi.tab, snap) < 0)
+			return isl_change_error;
+		return isl_change_none;
+	}
+	return fuse(i, j, info, NULL, 0, 0);
 }
 
-/* Check if basic map "i" contains the basic map represented
+/* Check if info->bmap contains the basic map represented
  * by the tableau "tab".
+ * For each equality, we check both the constraint itself
+ * (as an inequality) and its negation.  Make sure the
+ * equality is returned to its original state before returning.
  */
-static int contains(struct isl_map *map, int i, int *ineq_i,
-	struct isl_tab *tab)
+static isl_bool contains(struct isl_coalesce_info *info, struct isl_tab *tab)
 {
-	int k, l;
-	unsigned dim;
+	int k;
+	isl_size dim;
+	isl_basic_map *bmap = info->bmap;
 
-	dim = isl_basic_map_total_dim(map->pi);
-	for (k = 0; k < map->pi->n_eq; ++k) {
-		for (l = 0; l < 2; ++l) {
-			int stat;
-			isl_seq_neg(map->pi->eqk, map->pi->eqk, 1+dim);
-			stat = status_in(map->pi->eqk, tab);
-			if (stat != STATUS_VALID)
-				return 0;
-		}
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	if (dim < 0)
+		return isl_bool_error;
+	for (k = 0; k < bmap->n_eq; ++k) {
+		int stat;
+		isl_seq_neg(bmap->eqk, bmap->eqk, 1 + dim);
+		stat = status_in(bmap->eqk, tab);
+		isl_seq_neg(bmap->eqk, bmap->eqk, 1 + dim);
+		if (stat < 0)
+			return isl_bool_error;
+		if (stat != STATUS_VALID)
+			return isl_bool_false;
+		stat = status_in(bmap->eqk, tab);
+		if (stat < 0)
+			return isl_bool_error;
+		if (stat != STATUS_VALID)
+			return isl_bool_false;
 	}
 
-	for (k = 0; k < map->pi->n_ineq; ++k) {
+	for (k = 0; k < bmap->n_ineq; ++k) {
 		int stat;
-		if (ineq_ik == STATUS_REDUNDANT)
+		if (info->ineqk == STATUS_REDUNDANT)
 			continue;
-		stat = status_in(map->pi->ineqk, tab);
+		stat = status_in(bmap->ineqk, tab);
+		if (stat < 0)
+			return isl_bool_error;
 		if (stat != STATUS_VALID)
-			return 0;
+			return isl_bool_false;
 	}
-	return 1;
+	return isl_bool_true;
 }
 
-/* Basic map "i" has an inequality (say "k") that is adjacent
+/* Basic map "i" has an inequality "k" that is adjacent
  * to some inequality of basic map "j".  All the other inequalities
  * are valid for "j".
- * Check if basic map "j" forms an extension of basic map "i".
+ * If not NULL, then "extra" contains extra wrapping constraints that are valid
+ * for both "i" and "j".
+ * Check if basic map "j" forms an extension of basic map "i",
+ * taking into account the extra constraints, if any.
  *
  * Note that this function is only called if some of the equalities or
  * inequalities of basic map "j" do cut basic map "i".  The function is
@@ -347,12 +720,17 @@
  * the additional checks performed by this function are overkill.
  *
  * In particular, we replace constraint k, say f >= 0, by constraint
- * f <= -1, add the inequalities of "j" that are valid for "i"
+ * f <= -1, add the inequalities of "j" that are valid for "i",
+ * as well as the "extra" constraints, if any,
  * and check if the result is a subset of basic map "j".
- * If so, then we know that this result is exactly equal to basic map "j"
- * since all its constraints are valid for basic map "j".
+ * To improve the chances of the subset relation being detected,
+ * any variable that only attains a single integer value
+ * in the tableau of "i" is first fixed to that value.
+ * If the result is a subset, then we know that this result is exactly equal
+ * to basic map "j" since all its constraints are valid for basic map "j".
  * By combining the valid constraints of "i" (all equalities and all
- * inequalities except "k") and the valid constraints of "j" we therefore
+ * inequalities except "k"), the valid constraints of "j" and
+ * the "extra" constraints, if any, we therefore
  * obtain a basic map that is equal to their union.
  * In this case, there is no need to perform a rollback of the tableau
  * since it is going to be destroyed in fuse().
@@ -372,215 +750,467 @@
  *	|  || \			|     \
  *	|  ||  |		|      |
  *	|__||_/			|_____/
+ *
+ *
+ *	_______			 _______
+ *     |       | __		|       \__
+ *     |       ||__|	=>	|        __|
+ *     |_______|		|_______/
  */
-static int is_adj_ineq_extension(__isl_keep isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change is_adj_ineq_extension_with_wraps(int i, int j, int k,
+	struct isl_coalesce_info *info, __isl_keep isl_mat *extra)
 {
-	int k;
 	struct isl_tab_undo *snap;
-	unsigned n_eq = map->pi->n_eq;
-	unsigned total = isl_basic_map_total_dim(map->pi);
-	int r;
+	isl_size n_eq_i, n_ineq_j, n_extra;
+	isl_size total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	isl_stat r;
+	isl_bool super;
+
+	if (total < 0)
+		return isl_change_error;
+
+	n_eq_i = isl_basic_map_n_equality(infoi.bmap);
+	n_ineq_j = isl_basic_map_n_inequality(infoj.bmap);
+	n_extra = isl_mat_rows(extra);
+	if (n_eq_i < 0 || n_ineq_j < 0 || n_extra < 0)
+		return isl_change_error;
+
+	if (isl_tab_extend_cons(infoi.tab, 1 + n_ineq_j + n_extra) < 0)
+		return isl_change_error;
+
+	snap = isl_tab_snap(infoi.tab);
+
+	if (isl_tab_unrestrict(infoi.tab, n_eq_i + k) < 0)
+		return isl_change_error;
+
+	isl_seq_neg(infoi.bmap->ineqk, infoi.bmap->ineqk, 1 + total);
+	isl_int_sub_ui(infoi.bmap->ineqk0, infoi.bmap->ineqk0, 1);
+	r = isl_tab_add_ineq(infoi.tab, infoi.bmap->ineqk);
+	isl_seq_neg(infoi.bmap->ineqk, infoi.bmap->ineqk, 1 + total);
+	isl_int_sub_ui(infoi.bmap->ineqk0, infoi.bmap->ineqk0, 1);
+	if (r < 0)
+		return isl_change_error;
 
-	if (isl_tab_extend_cons(tabsi, 1 + map->pj->n_ineq) < 0)
-		return -1;
+	for (k = 0; k < n_ineq_j; ++k) {
+		if (infoj.ineqk != STATUS_VALID)
+			continue;
+		if (isl_tab_add_ineq(infoi.tab, infoj.bmap->ineqk) < 0)
+			return isl_change_error;
+	}
+	for (k = 0; k < n_extra; ++k) {
+		if (isl_tab_add_ineq(infoi.tab, extra->rowk) < 0)
+			return isl_change_error;
+	}
+	if (isl_tab_detect_constants(infoi.tab) < 0)
+		return isl_change_error;
 
-	for (k = 0; k < map->pi->n_ineq; ++k)
-		if (ineq_ik == STATUS_ADJ_INEQ)
-			break;
-	if (k >= map->pi->n_ineq)
-		isl_die(isl_map_get_ctx(map), isl_error_internal,
-			"ineq_i should have exactly one STATUS_ADJ_INEQ",
-			return -1);
+	super = contains(&infoj, infoi.tab);
+	if (super < 0)
+		return isl_change_error;
+	if (super)
+		return fuse(i, j, info, extra, 0, 0);
 
-	snap = isl_tab_snap(tabsi);
+	if (isl_tab_rollback(infoi.tab, snap) < 0)
+		return isl_change_error;
 
-	if (isl_tab_unrestrict(tabsi, n_eq + k) < 0)
-		return -1;
+	return isl_change_none;
+}
 
-	isl_seq_neg(map->pi->ineqk, map->pi->ineqk, 1 + total);
-	isl_int_sub_ui(map->pi->ineqk0, map->pi->ineqk0, 1);
-	r = isl_tab_add_ineq(tabsi, map->pi->ineqk);
-	isl_seq_neg(map->pi->ineqk, map->pi->ineqk, 1 + total);
-	isl_int_sub_ui(map->pi->ineqk0, map->pi->ineqk0, 1);
-	if (r < 0)
-		return -1;
+/* Given an affine transformation matrix "T", does row "row" represent
+ * anything other than a unit vector (possibly shifted by a constant)
+ * that is not involved in any of the other rows?
+ *
+ * That is, if a constraint involves the variable corresponding to
+ * the row, then could its preimage by "T" have any coefficients
+ * that are different from those in the original constraint?
+ */
+static int not_unique_unit_row(__isl_keep isl_mat *T, int row)
+{
+	int i, j;
+	int len = T->n_col - 1;
 
-	for (k = 0; k < map->pj->n_ineq; ++k) {
-		if (ineq_jk != STATUS_VALID)
-			continue;
-		if (isl_tab_add_ineq(tabsi, map->pj->ineqk) < 0)
-			return -1;
-	}
+	i = isl_seq_first_non_zero(T->rowrow + 1, len);
+	if (i < 0)
+		return 1;
+	if (!isl_int_is_one(T->rowrow1 + i) &&
+	    !isl_int_is_negone(T->rowrow1 + i))
+		return 1;
 
-	if (contains(map, j, ineq_j, tabsi))
-		return fuse(map, i, j, tabs, eq_i, ineq_i, eq_j, ineq_j, NULL);
+	j = isl_seq_first_non_zero(T->rowrow + 1 + i + 1, len - (i + 1));
+	if (j >= 0)
+		return 1;
 
-	if (isl_tab_rollback(tabsi, snap) < 0)
-		return -1;
+	for (j = 1; j < T->n_row; ++j) {
+		if (j == row)
+			continue;
+		if (!isl_int_is_zero(T->rowj1 + i))
+			return 1;
+	}
 
 	return 0;
 }
 
+/* Does inequality constraint "ineq" of "bmap" involve any of
+ * the variables marked in "affected"?
+ * "total" is the total number of variables, i.e., the number
+ * of entries in "affected".
+ */
+static isl_bool is_affected(__isl_keep isl_basic_map *bmap, int ineq,
+	int *affected, int total)
+{
+	int i;
 
-/* Both basic maps have at least one inequality with and adjacent
- * (but opposite) inequality in the other basic map.
- * Check that there are no cut constraints and that there is only
- * a single pair of adjacent inequalities.
- * If so, we can replace the pair by a single basic map described
- * by all but the pair of adjacent inequalities.
- * Any additional points introduced lie strictly between the two
- * adjacent hyperplanes and can therefore be integral.
+	for (i = 0; i < total; ++i) {
+		if (!affectedi)
+			continue;
+		if (!isl_int_is_zero(bmap->ineqineq1 + i))
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* Given the compressed version of inequality constraint "ineq"
+ * of info->bmap in "v", check if the constraint can be tightened,
+ * where the compression is based on an equality constraint valid
+ * for info->tab.
+ * If so, add the tightened version of the inequality constraint
+ * to info->tab.  "v" may be modified by this function.
  *
- *        ____			  _____
- *       /    ||\		 /     \
- *      /     || \		/       \
- *      \     ||  \	=>	\        \
- *       \    ||  /		 \       /
- *        \___||_/		  \_____/
+ * That is, if the compressed constraint is of the form
  *
- * The test for a single pair of adjancent inequalities is important
- * for avoiding the combination of two basic maps like the following
+ *	m f() + c >= 0
  *
- *       /|
- *      / |
- *     /__|
- *         _____
- *         |   |
- *         |   |
- *         |___|
+ * with 0 < c < m, then it is equivalent to
  *
- * If there are some cut constraints on one side, then we may
- * still be able to fuse the two basic maps, but we need to perform
- * some additional checks in is_adj_ineq_extension.
+ *	f() >= 0
+ *
+ * This means that c can also be subtracted from the original,
+ * uncompressed constraint without affecting the integer points
+ * in info->tab.  Add this tightened constraint as an extra row
+ * to info->tab to make this information explicitly available.
  */
-static int check_adj_ineq(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static __isl_give isl_vec *try_tightening(struct isl_coalesce_info *info,
+	int ineq, __isl_take isl_vec *v)
 {
-	int count_i, count_j;
-	int cut_i, cut_j;
+	isl_ctx *ctx;
+	isl_stat r;
 
-	count_i = count(ineq_i, map->pi->n_ineq, STATUS_ADJ_INEQ);
-	count_j = count(ineq_j, map->pj->n_ineq, STATUS_ADJ_INEQ);
+	if (!v)
+		return NULL;
 
-	if (count_i != 1 && count_j != 1)
-		return 0;
+	ctx = isl_vec_get_ctx(v);
+	isl_seq_gcd(v->el + 1, v->size - 1, &ctx->normalize_gcd);
+	if (isl_int_is_zero(ctx->normalize_gcd) ||
+	    isl_int_is_one(ctx->normalize_gcd)) {
+		return v;
+	}
 
-	cut_i = any(eq_i, 2 * map->pi->n_eq, STATUS_CUT) ||
-		any(ineq_i, map->pi->n_ineq, STATUS_CUT);
-	cut_j = any(eq_j, 2 * map->pj->n_eq, STATUS_CUT) ||
-		any(ineq_j, map->pj->n_ineq, STATUS_CUT);
+	v = isl_vec_cow(v);
+	if (!v)
+		return NULL;
 
-	if (!cut_i && !cut_j && count_i == 1 && count_j == 1)
-		return fuse(map, i, j, tabs, NULL, ineq_i, NULL, ineq_j, NULL);
+	isl_int_fdiv_r(v->el0, v->el0, ctx->normalize_gcd);
+	if (isl_int_is_zero(v->el0))
+		return v;
+
+	if (isl_tab_extend_cons(info->tab, 1) < 0)
+		return isl_vec_free(v);
+
+	isl_int_sub(info->bmap->ineqineq0,
+		    info->bmap->ineqineq0, v->el0);
+	r = isl_tab_add_ineq(info->tab, info->bmap->ineqineq);
+	isl_int_add(info->bmap->ineqineq0,
+		    info->bmap->ineqineq0, v->el0);
 
-	if (count_i == 1 && !cut_i)
-		return is_adj_ineq_extension(map, i, j, tabs,
-						eq_i, ineq_i, eq_j, ineq_j);
+	if (r < 0)
+		return isl_vec_free(v);
 
-	if (count_j == 1 && !cut_j)
-		return is_adj_ineq_extension(map, j, i, tabs,
-						eq_j, ineq_j, eq_i, ineq_i);
+	return v;
+}
 
-	return 0;
+/* Tighten the (non-redundant) constraints on the facet represented
+ * by info->tab.
+ * In particular, on input, info->tab represents the result
+ * of relaxing the "n" inequality constraints of info->bmap in "relaxed"
+ * by one, i.e., replacing f_i >= 0 by f_i + 1 >= 0, and then
+ * replacing the one at index "l" by the corresponding equality,
+ * i.e., f_k + 1 = 0, with k = relaxedl.
+ *
+ * Compute a variable compression from the equality constraint f_k + 1 = 0
+ * and use it to tighten the other constraints of info->bmap
+ * (that is, all constraints that have not been relaxed),
+ * updating info->tab (and leaving info->bmap untouched).
+ * The compression handles essentially two cases, one where a variable
+ * is assigned a fixed value and can therefore be eliminated, and one
+ * where one variable is a shifted multiple of some other variable and
+ * can therefore be replaced by that multiple.
+ * Gaussian elimination would also work for the first case, but for
+ * the second case, the effectiveness would depend on the order
+ * of the variables.
+ * After compression, some of the constraints may have coefficients
+ * with a common divisor.  If this divisor does not divide the constant
+ * term, then the constraint can be tightened.
+ * The tightening is performed on the tableau info->tab by introducing
+ * extra (temporary) constraints.
+ *
+ * Only constraints that are possibly affected by the compression are
+ * considered.  In particular, if the constraint only involves variables
+ * that are directly mapped to a distinct set of other variables, then
+ * no common divisor can be introduced and no tightening can occur.
+ *
+ * It is important to only consider the non-redundant constraints
+ * since the facet constraint has been relaxed prior to the call
+ * to this function, meaning that the constraints that were redundant
+ * prior to the relaxation may no longer be redundant.
+ * These constraints will be ignored in the fused result, so
+ * the fusion detection should not exploit them.
+ */
+static isl_stat tighten_on_relaxed_facet(struct isl_coalesce_info *info,
+	int n, int *relaxed, int l)
+{
+	isl_size total;
+	isl_ctx *ctx;
+	isl_vec *v = NULL;
+	isl_mat *T;
+	int i;
+	int k;
+	int *affected;
+
+	k = relaxedl;
+	ctx = isl_basic_map_get_ctx(info->bmap);
+	total = isl_basic_map_dim(info->bmap, isl_dim_all);
+	if (total < 0)
+		return isl_stat_error;
+	isl_int_add_ui(info->bmap->ineqk0, info->bmap->ineqk0, 1);
+	T = isl_mat_sub_alloc6(ctx, info->bmap->ineq, k, 1, 0, 1 + total);
+	T = isl_mat_variable_compression(T, NULL);
+	isl_int_sub_ui(info->bmap->ineqk0, info->bmap->ineqk0, 1);
+	if (!T)
+		return isl_stat_error;
+	if (T->n_col == 0) {
+		isl_mat_free(T);
+		return isl_stat_ok;
+	}
+
+	affected = isl_alloc_array(ctx, int, total);
+	if (!affected)
+		goto error;
+
+	for (i = 0; i < total; ++i)
+		affectedi = not_unique_unit_row(T, 1 + i);
+
+	for (i = 0; i < info->bmap->n_ineq; ++i) {
+		isl_bool handle;
+		if (any(relaxed, n, i))
+			continue;
+		if (info->ineqi == STATUS_REDUNDANT)
+			continue;
+		handle = is_affected(info->bmap, i, affected, total);
+		if (handle < 0)
+			goto error;
+		if (!handle)
+			continue;
+		v = isl_vec_alloc(ctx, 1 + total);
+		if (!v)
+			goto error;
+		isl_seq_cpy(v->el, info->bmap->ineqi, 1 + total);
+		v = isl_vec_mat_product(v, isl_mat_copy(T));
+		v = try_tightening(info, i, v);
+		isl_vec_free(v);
+		if (!v)
+			goto error;
+	}
+
+	isl_mat_free(T);
+	free(affected);
+	return isl_stat_ok;
+error:
+	isl_mat_free(T);
+	free(affected);
+	return isl_stat_error;
 }
 
-/* Basic map "i" has an inequality "k" that is adjacent to some equality
- * of basic map "j".  All the other inequalities are valid for "j".
+/* Replace the basic maps "i" and "j" by an extension of "i"
+ * along the "n" inequality constraints in "relax" by one.
+ * The tableau infoi.tab has already been extended.
+ * Extend infoi.bmap accordingly by relaxing all constraints in "relax"
+ * by one.
+ * Each integer division that does not have exactly the same
+ * definition in "i" and "j" is marked unknown and the basic map
+ * is scheduled to be simplified in an attempt to recover
+ * the integer division definition.
+ * Place the extension in the position that is the smallest of i and j.
+ */
+static enum isl_change extend(int i, int j, int n, int *relax,
+	struct isl_coalesce_info *info)
+{
+	int l;
+	isl_size total;
+
+	infoi.bmap = isl_basic_map_cow(infoi.bmap);
+	total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	if (total < 0)
+		return isl_change_error;
+	for (l = 0; l < infoi.bmap->n_div; ++l)
+		if (!isl_seq_eq(infoi.bmap->divl,
+				infoj.bmap->divl, 1 + 1 + total)) {
+			isl_int_set_si(infoi.bmap->divl0, 0);
+			infoi.simplify = 1;
+		}
+	for (l = 0; l < n; ++l)
+		isl_int_add_ui(infoi.bmap->ineqrelaxl0,
+				infoi.bmap->ineqrelaxl0, 1);
+	ISL_F_CLR(infoi.bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+	ISL_F_SET(infoi.bmap, ISL_BASIC_MAP_FINAL);
+	drop(&infoj);
+	infoi.modified = 1;
+	if (j < i)
+		exchange(&infoi, &infoj);
+	return isl_change_fuse;
+}
+
+/* Basic map "i" has "n" inequality constraints (collected in "relax")
+ * that are such that they include basic map "j" if they are relaxed
+ * by one.  All the other inequalities are valid for "j".
  * Check if basic map "j" forms an extension of basic map "i".
  *
- * In particular, we relax constraint "k", compute the corresponding
- * facet and check whether it is included in the other basic map.
- * If so, we know that relaxing the constraint extends the basic
- * map with exactly the other basic map (we already know that this
- * other basic map is included in the extension, because there
- * were no "cut" inequalities in "i") and we can replace the
+ * In particular, relax the constraints in "relax", compute the corresponding
+ * facets one by one and check whether each of these is included
+ * in the other basic map.
+ * Before testing for inclusion, the constraints on each facet
+ * are tightened to increase the chance of an inclusion being detected.
+ * (Adding the valid constraints of "j" to the tableau of "i", as is done
+ * in is_adj_ineq_extension, may further increase those chances, but this
+ * is not currently done.)
+ * If each facet is included, we know that relaxing the constraints extends
+ * the basic map with exactly the other basic map (we already know that this
+ * other basic map is included in the extension, because all other
+ * inequality constraints are valid of "j") and we can replace the
  * two basic maps by this extension.
+ *
+ * If any of the relaxed constraints turn out to be redundant, then bail out.
+ * isl_tab_select_facet refuses to handle such constraints.  It may be
+ * possible to handle them anyway by making a distinction between
+ * redundant constraints with a corresponding facet that still intersects
+ * the set (allowing isl_tab_select_facet to handle them) and
+ * those where the facet does not intersect the set (which can be ignored
+ * because the empty facet is trivially included in the other disjunct).
+ * However, relaxed constraints that turn out to be redundant should
+ * be fairly rare and no such instance has been reported where
+ * coalescing would be successful.
  *        ____			  _____
  *       /    || 		 /     |
  *      /     ||  		/      |
  *      \     ||   	=>	\      |
  *       \    ||		 \     |
  *        \___||		  \____|
+ *
+ *
+ *	 \			|\
+ *	|\\			| \
+ *	| \\			|  \
+ *	|  |		=>	|  /
+ *	| /			| /
+ *	|/			|/
  */
-static int is_adj_eq_extension(struct isl_map *map, int i, int j, int k,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change is_relaxed_extension(int i, int j, int n, int *relax,
+	struct isl_coalesce_info *info)
 {
-	int changed = 0;
-	int super;
+	int l;
+	isl_bool super;
 	struct isl_tab_undo *snap, *snap2;
-	unsigned n_eq = map->pi->n_eq;
-
-	if (isl_tab_is_equality(tabsi, n_eq + k))
-		return 0;
+	unsigned n_eq = infoi.bmap->n_eq;
 
-	snap = isl_tab_snap(tabsi);
-	tabsi = isl_tab_relax(tabsi, n_eq + k);
-	snap2 = isl_tab_snap(tabsi);
-	if (isl_tab_select_facet(tabsi, n_eq + k) < 0)
-		return -1;
-	super = contains(map, j, ineq_j, tabsi);
-	if (super) {
-		if (isl_tab_rollback(tabsi, snap2) < 0)
-			return -1;
-		map->pi = isl_basic_map_cow(map->pi);
-		if (!map->pi)
-			return -1;
-		isl_int_add_ui(map->pi->ineqk0, map->pi->ineqk0, 1);
-		ISL_F_SET(map->pi, ISL_BASIC_MAP_FINAL);
-		drop(map, j, tabs);
-		changed = 1;
-	} else
-		if (isl_tab_rollback(tabsi, snap) < 0)
-			return -1;
+	for (l = 0; l < n; ++l)
+		if (isl_tab_is_equality(infoi.tab, n_eq + relaxl))
+			return isl_change_none;
+
+	snap = isl_tab_snap(infoi.tab);
+	for (l = 0; l < n; ++l)
+		if (isl_tab_relax(infoi.tab, n_eq + relaxl) < 0)
+			return isl_change_error;
+	for (l = 0; l < n; ++l) {
+		if (!isl_tab_is_redundant(infoi.tab, n_eq + relaxl))
+			continue;
+		if (isl_tab_rollback(infoi.tab, snap) < 0)
+			return isl_change_error;
+		return isl_change_none;
+	}
+	snap2 = isl_tab_snap(infoi.tab);
+	for (l = 0; l < n; ++l) {
+		if (isl_tab_rollback(infoi.tab, snap2) < 0)
+			return isl_change_error;
+		if (isl_tab_select_facet(infoi.tab, n_eq + relaxl) < 0)
+			return isl_change_error;
+		if (tighten_on_relaxed_facet(&infoi, n, relax, l) < 0)
+			return isl_change_error;
+		super = contains(&infoj, infoi.tab);
+		if (super < 0)
+			return isl_change_error;
+		if (super)
+			continue;
+		if (isl_tab_rollback(infoi.tab, snap) < 0)
+			return isl_change_error;
+		return isl_change_none;
+	}
 
-	return changed;
+	if (isl_tab_rollback(infoi.tab, snap2) < 0)
+		return isl_change_error;
+	return extend(i, j, n, relax, info);
 }
 
 /* Data structure that keeps track of the wrapping constraints
  * and of information to bound the coefficients of those constraints.
  *
+ * "failed" is set if wrapping has failed.
  * bound is set if we want to apply a bound on the coefficients
  * mat contains the wrapping constraints
  * max is the bound on the coefficients (if bound is set)
  */
 struct isl_wraps {
+	int failed;
 	int bound;
 	isl_mat *mat;
 	isl_int max;
 };
 
 /* Update wraps->max to be greater than or equal to the coefficients
- * in the equalities and inequalities of bmap that can be removed if we end up
- * applying wrapping.
+ * in the equalities and inequalities of info->bmap that can be removed
+ * if we end up applying wrapping.
  */
-static void wraps_update_max(struct isl_wraps *wraps,
-	__isl_keep isl_basic_map *bmap, int *eq, int *ineq)
+static isl_stat wraps_update_max(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info)
 {
 	int k;
 	isl_int max_k;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size total = isl_basic_map_dim(info->bmap, isl_dim_all);
 
+	if (total < 0)
+		return isl_stat_error;
 	isl_int_init(max_k);
 
-	for (k = 0; k < bmap->n_eq; ++k) {
-		if (eq2 * k == STATUS_VALID &&
-		    eq2 * k + 1 == STATUS_VALID)
+	for (k = 0; k < info->bmap->n_eq; ++k) {
+		if (info->eq2 * k == STATUS_VALID &&
+		    info->eq2 * k + 1 == STATUS_VALID)
 			continue;
-		isl_seq_abs_max(bmap->eqk + 1, total, &max_k);
+		isl_seq_abs_max(info->bmap->eqk + 1, total, &max_k);
 		if (isl_int_abs_gt(max_k, wraps->max))
 			isl_int_set(wraps->max, max_k);
 	}
 
-	for (k = 0; k < bmap->n_ineq; ++k) {
-		if (ineqk == STATUS_VALID || ineqk == STATUS_REDUNDANT)
+	for (k = 0; k < info->bmap->n_ineq; ++k) {
+		if (info->ineqk == STATUS_VALID ||
+		    info->ineqk == STATUS_REDUNDANT)
 			continue;
-		isl_seq_abs_max(bmap->ineqk + 1, total, &max_k);
+		isl_seq_abs_max(info->bmap->ineqk + 1, total, &max_k);
 		if (isl_int_abs_gt(max_k, wraps->max))
 			isl_int_set(wraps->max, max_k);
 	}
 
 	isl_int_clear(max_k);
+
+	return isl_stat_ok;
 }
 
 /* Initialize the isl_wraps data structure.
@@ -589,24 +1219,29 @@
  * in the equalities and inequalities that can be removed if we end up
  * applying wrapping.
  */
-static void wraps_init(struct isl_wraps *wraps, __isl_take isl_mat *mat,
-	__isl_keep isl_map *map, int i, int j,
-	int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static isl_stat wraps_init(struct isl_wraps *wraps, __isl_take isl_mat *mat,
+	struct isl_coalesce_info *info, int i, int j)
 {
 	isl_ctx *ctx;
 
+	wraps->failed = 0;
 	wraps->bound = 0;
 	wraps->mat = mat;
 	if (!mat)
-		return;
+		return isl_stat_error;
+	wraps->mat->n_row = 0;
 	ctx = isl_mat_get_ctx(mat);
 	wraps->bound = isl_options_get_coalesce_bounded_wrapping(ctx);
 	if (!wraps->bound)
-		return;
+		return isl_stat_ok;
 	isl_int_init(wraps->max);
 	isl_int_set_si(wraps->max, 0);
-	wraps_update_max(wraps, map->pi, eq_i, ineq_i);
-	wraps_update_max(wraps, map->pj, eq_j, ineq_j);
+	if (wraps_update_max(wraps, &infoi) < 0)
+		return isl_stat_error;
+	if (wraps_update_max(wraps, &infoj) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
 /* Free the contents of the isl_wraps data structure.
@@ -618,6 +1253,14 @@
 		isl_int_clear(wraps->max);
 }
 
+/* Mark the wrapping as failed.
+ */
+static isl_stat wraps_mark_failed(struct isl_wraps *wraps)
+{
+	wraps->failed = 1;
+	return isl_stat_ok;
+}
+
 /* Is the wrapping constraint in row "row" allowed?
  *
  * If wraps->bound is set, we check that none of the coefficients
@@ -637,104 +1280,180 @@
 	return 1;
 }
 
-/* For each non-redundant constraint in "bmap" (as determined by "tab"),
- * wrap the constraint around "bound" such that it includes the whole
+/* Wrap "ineq" (or its opposite if "negate" is set) around "bound"
+ * to include "set" and add the result in position "w" of "wraps".
+ * "len" is the total number of coefficients in "bound" and "ineq".
+ * Return 1 on success, 0 on failure and -1 on error.
+ * Wrapping can fail if the result of wrapping is equal to "bound"
+ * or if we want to bound the sizes of the coefficients and
+ * the wrapped constraint does not satisfy this bound.
+ */
+static int add_wrap(struct isl_wraps *wraps, int w, isl_int *bound,
+	isl_int *ineq, unsigned len, __isl_keep isl_set *set, int negate)
+{
+	isl_seq_cpy(wraps->mat->roww, bound, len);
+	if (negate) {
+		isl_seq_neg(wraps->mat->roww + 1, ineq, len);
+		ineq = wraps->mat->roww + 1;
+	}
+	if (!isl_set_wrap_facet(set, wraps->mat->roww, ineq))
+		return -1;
+	if (isl_seq_eq(wraps->mat->roww, bound, len))
+		return 0;
+	if (!allow_wrap(wraps, w))
+		return 0;
+	return 1;
+}
+
+/* This function has two modes of operations.
+ *
+ * If "add_valid" is set, then all the constraints of info->bmap
+ * (except the opposite of "bound") are valid for the other basic map.
+ * In this case, attempts are made to wrap some of these valid constraints
+ * to more tightly fit around "set".  Only successful wrappings are recorded
+ * and failed wrappings are ignored.
+ *
+ * If "add_valid" is not set, then some of the constraints of info->bmap
+ * are not valid for the other basic map, and only those are considered
+ * for wrapping.  In this case all attempted wrappings need to succeed.
+ * Otherwise "wraps" is marked as failed.
+ * Note that the constraints that are valid for the other basic map
+ * will be added to the combined basic map by default, so there is
+ * no need to wrap them.
+ * The caller wrap_in_facets even relies on this function not wrapping
+ * any constraints that are already valid.
+ *
+ * Only consider constraints that are not redundant (as determined
+ * by info->tab) and that are valid or invalid depending on "add_valid".
+ * Wrap each constraint around "bound" such that it includes the whole
  * set "set" and append the resulting constraint to "wraps".
  * "wraps" is assumed to have been pre-allocated to the appropriate size.
  * wraps->n_row is the number of actual wrapped constraints that have
  * been added.
  * If any of the wrapping problems results in a constraint that is
  * identical to "bound", then this means that "set" is unbounded in such
- * way that no wrapping is possible.  If this happens then wraps->n_row
- * is reset to zero.
+ * a way that no wrapping is possible.
  * Similarly, if we want to bound the coefficients of the wrapping
  * constraints and a newly added wrapping constraint does not
- * satisfy the bound, then wraps->n_row is also reset to zero.
+ * satisfy the bound, then the wrapping is considered to have failed.
+ * Note though that "wraps" is only marked failed if "add_valid" is not set.
  */
-static int add_wraps(struct isl_wraps *wraps, __isl_keep isl_basic_map *bmap,
-	struct isl_tab *tab, isl_int *bound, __isl_keep isl_set *set)
+static isl_stat add_selected_wraps(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info, isl_int *bound, __isl_keep isl_set *set,
+	int add_valid)
 {
-	int l;
+	int l, m;
 	int w;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	int added;
+	isl_basic_map *bmap = info->bmap;
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
+	unsigned len = 1 + total;
+
+	if (total < 0)
+		return isl_stat_error;
 
 	w = wraps->mat->n_row;
 
 	for (l = 0; l < bmap->n_ineq; ++l) {
-		if (isl_seq_is_neg(bound, bmap->ineql, 1 + total))
+		int is_valid = info->ineql == STATUS_VALID;
+		if ((!add_valid && is_valid) ||
+		    info->ineql == STATUS_REDUNDANT)
+			continue;
+		if (isl_seq_is_neg(bound, bmap->ineql, len))
 			continue;
-		if (isl_seq_eq(bound, bmap->ineql, 1 + total))
+		if (isl_seq_eq(bound, bmap->ineql, len))
 			continue;
-		if (isl_tab_is_redundant(tab, bmap->n_eq + l))
+		if (isl_tab_is_redundant(info->tab, bmap->n_eq + l))
 			continue;
 
-		isl_seq_cpy(wraps->mat->roww, bound, 1 + total);
-		if (!isl_set_wrap_facet(set, wraps->mat->roww, bmap->ineql))
-			return -1;
-		if (isl_seq_eq(wraps->mat->roww, bound, 1 + total))
-			goto unbounded;
-		if (!allow_wrap(wraps, w))
+		added = add_wrap(wraps, w, bound, bmap->ineql, len, set, 0);
+		if (added < 0)
+			return isl_stat_error;
+		if (!added && !is_valid)
 			goto unbounded;
-		++w;
+		if (added)
+			++w;
 	}
 	for (l = 0; l < bmap->n_eq; ++l) {
-		if (isl_seq_is_neg(bound, bmap->eql, 1 + total))
+		if (isl_seq_is_neg(bound, bmap->eql, len))
 			continue;
-		if (isl_seq_eq(bound, bmap->eql, 1 + total))
+		if (isl_seq_eq(bound, bmap->eql, len))
 			continue;
 
-		isl_seq_cpy(wraps->mat->roww, bound, 1 + total);
-		isl_seq_neg(wraps->mat->roww + 1, bmap->eql, 1 + total);
-		if (!isl_set_wrap_facet(set, wraps->mat->roww,
-					wraps->mat->roww + 1))
-			return -1;
-		if (isl_seq_eq(wraps->mat->roww, bound, 1 + total))
-			goto unbounded;
-		if (!allow_wrap(wraps, w))
-			goto unbounded;
-		++w;
-
-		isl_seq_cpy(wraps->mat->roww, bound, 1 + total);
-		if (!isl_set_wrap_facet(set, wraps->mat->roww, bmap->eql))
-			return -1;
-		if (isl_seq_eq(wraps->mat->roww, bound, 1 + total))
-			goto unbounded;
-		if (!allow_wrap(wraps, w))
-			goto unbounded;
-		++w;
+		for (m = 0; m < 2; ++m) {
+			if (info->eq2 * l + m == STATUS_VALID)
+				continue;
+			added = add_wrap(wraps, w, bound, bmap->eql, len,
+					set, !m);
+			if (added < 0)
+				return isl_stat_error;
+			if (!added)
+				goto unbounded;
+			++w;
+		}
 	}
 
 	wraps->mat->n_row = w;
-	return 0;
+	return isl_stat_ok;
 unbounded:
-	wraps->mat->n_row = 0;
-	return 0;
+	return wraps_mark_failed(wraps);
+}
+
+/* For each constraint in info->bmap that is not redundant (as determined
+ * by info->tab) and that is not a valid constraint for the other basic map,
+ * wrap the constraint around "bound" such that it includes the whole
+ * set "set" and append the resulting constraint to "wraps".
+ * Note that the constraints that are valid for the other basic map
+ * will be added to the combined basic map by default, so there is
+ * no need to wrap them.
+ * The caller wrap_in_facets even relies on this function not wrapping
+ * any constraints that are already valid.
+ * "wraps" is assumed to have been pre-allocated to the appropriate size.
+ * wraps->n_row is the number of actual wrapped constraints that have
+ * been added.
+ * If any of the wrapping problems results in a constraint that is
+ * identical to "bound", then this means that "set" is unbounded in such
+ * a way that no wrapping is possible.  If this happens then "wraps"
+ * is marked as failed.
+ * Similarly, if we want to bound the coefficients of the wrapping
+ * constraints and a newly added wrapping constraint does not
+ * satisfy the bound, then "wraps" is also marked as failed.
+ */
+static isl_stat add_wraps(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info, isl_int *bound, __isl_keep isl_set *set)
+{
+	return add_selected_wraps(wraps, info, bound, set, 0);
 }
 
 /* Check if the constraints in "wraps" from "first" until the last
- * are all valid for the basic set represented by "tab".
- * If not, wraps->n_row is set to zero.
+ * are all valid for the basic set represented by "tab",
+ * dropping the invalid constraints if "keep" is set and
+ * marking the wrapping as failed if "keep" is not set and
+ * any constraint turns out to be invalid.
  */
-static int check_wraps(__isl_keep isl_mat *wraps, int first,
-	struct isl_tab *tab)
+static isl_stat check_wraps(struct isl_wraps *wraps, int first,
+	struct isl_tab *tab, int keep)
 {
 	int i;
 
-	for (i = first; i < wraps->n_row; ++i) {
+	for (i = wraps->mat->n_row - 1; i >= first; --i) {
 		enum isl_ineq_type type;
-		type = isl_tab_ineq_type(tab, wraps->rowi);
+		type = isl_tab_ineq_type(tab, wraps->mat->rowi);
 		if (type == isl_ineq_error)
-			return -1;
+			return isl_stat_error;
 		if (type == isl_ineq_redundant)
 			continue;
-		wraps->n_row = 0;
-		return 0;
+		if (!keep)
+			return wraps_mark_failed(wraps);
+		wraps->mat = isl_mat_drop_rows(wraps->mat, i, 1);
+		if (!wraps->mat)
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
-/* Return a set that corresponds to the non-redudant constraints
+/* Return a set that corresponds to the non-redundant constraints
  * (as recorded in tab) of bmap.
  *
  * It's important to remove the redundant constraints as some
@@ -745,34 +1464,279 @@
  * and should therefore continue to be ignored ever after.
  * Otherwise, the relaxation might be thwarted by some of
  * these constraints.
+ *
+ * Update the underlying set to ensure that the dimension doesn't change.
+ * Otherwise the integer divisions could get dropped if the tab
+ * turns out to be empty.
  */
 static __isl_give isl_set *set_from_updated_bmap(__isl_keep isl_basic_map *bmap,
 	struct isl_tab *tab)
 {
+	isl_basic_set *bset;
+
 	bmap = isl_basic_map_copy(bmap);
-	bmap = isl_basic_map_cow(bmap);
-	bmap = isl_basic_map_update_from_tab(bmap, tab);
-	return isl_set_from_basic_set(isl_basic_map_underlying_set(bmap));
+	bset = isl_basic_map_underlying_set(bmap);
+	bset = isl_basic_set_cow(bset);
+	bset = isl_basic_set_update_from_tab(bset, tab);
+	return isl_set_from_basic_set(bset);
 }
 
-/* Given a basic set i with a constraint k that is adjacent to either the
- * whole of basic set j or a facet of basic set j, check if we can wrap
- * both the facet corresponding to k and the facet of j (or the whole of j)
- * around their ridges to include the other set.
- * If so, replace the pair of basic sets by their union.
+/* Does "info" have any cut constraints that are redundant?
+ */
+static isl_bool has_redundant_cuts(struct isl_coalesce_info *info)
+{
+	int l;
+	isl_size n_eq, n_ineq;
+
+	n_eq = isl_basic_map_n_equality(info->bmap);
+	n_ineq = isl_basic_map_n_inequality(info->bmap);
+	if (n_eq < 0 || n_ineq < 0)
+		return isl_bool_error;
+	for (l = 0; l < n_ineq; ++l) {
+		int red;
+
+		if (info->ineql != STATUS_CUT)
+			continue;
+		red = isl_tab_is_redundant(info->tab, n_eq + l);
+		if (red < 0)
+			return isl_bool_error;
+		if (red)
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* Wrap some constraints of info->bmap that bound the facet defined
+ * by inequality "k" around (the opposite of) this inequality to
+ * include "set".  "bound" may be used to store the negated inequality.
+ *
+ * If "add_valid" is set, then all ridges are already valid and
+ * the purpose is to wrap "set" more tightly.  In this case,
+ * wrapping doesn't fail, although it is possible that no constraint
+ * gets wrapped.
+ *
+ * If "add_valid" is not set, then some of the ridges are cut constraints
+ * and only those are wrapped around "set".
+ *
+ * Since the wrapped constraints are not guaranteed to contain the whole
+ * of info->bmap, we check them in check_wraps.
+ * If any of the wrapped constraints turn out to be invalid, then
+ * check_wraps will mark "wraps" as failed if "add_valid" is not set.
+ * If "add_valid" is set, then the offending constraints are
+ * simply removed.
+ *
+ * If any of the cut constraints of info->bmap turn out
+ * to be redundant with respect to other constraints
+ * then these will neither be wrapped nor added directly to the result.
+ * The result may therefore not be correct.
+ * Skip wrapping and mark "wraps" as failed in this case.
+ */
+static isl_stat add_selected_wraps_around_facet(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info, int k, isl_int *bound,
+	__isl_keep isl_set *set, int add_valid)
+{
+	isl_bool nowrap;
+	struct isl_tab_undo *snap;
+	int n;
+	isl_size total = isl_basic_map_dim(info->bmap, isl_dim_all);
+
+	if (total < 0)
+		return isl_stat_error;
+
+	snap = isl_tab_snap(info->tab);
+
+	if (isl_tab_select_facet(info->tab, info->bmap->n_eq + k) < 0)
+		return isl_stat_error;
+	if (isl_tab_detect_redundant(info->tab) < 0)
+		return isl_stat_error;
+	nowrap = has_redundant_cuts(info);
+	if (nowrap < 0)
+		return isl_stat_error;
+
+	n = wraps->mat->n_row;
+	if (!nowrap) {
+		isl_seq_neg(bound, info->bmap->ineqk, 1 + total);
+
+		if (add_selected_wraps(wraps, info, bound, set, add_valid) < 0)
+			return isl_stat_error;
+	}
+
+	if (isl_tab_rollback(info->tab, snap) < 0)
+		return isl_stat_error;
+	if (nowrap)
+		return wraps_mark_failed(wraps);
+	if (check_wraps(wraps, n, info->tab, add_valid) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Wrap the constraints of info->bmap that bound the facet defined
+ * by inequality "k" around (the opposite of) this inequality to
+ * include "set".  "bound" may be used to store the negated inequality.
+ * If any of the wrapped constraints turn out to be invalid for info->bmap
+ * itself, then mark "wraps" as failed.
+ */
+static isl_stat add_wraps_around_facet(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info, int k, isl_int *bound,
+	__isl_keep isl_set *set)
+{
+	return add_selected_wraps_around_facet(wraps, info, k, bound, set, 0);
+}
+
+/* Wrap the (valid) constraints of info->bmap that bound the facet defined
+ * by inequality "k" around (the opposite of) this inequality to
+ * include "set" more tightly.
+ * "bound" may be used to store the negated inequality.
+ * Remove any wrapping constraints that turn out to be invalid
+ * for info->bmap itself.
+ */
+static isl_stat add_valid_wraps_around_facet(struct isl_wraps *wraps,
+	struct isl_coalesce_info *info, int k, isl_int *bound,
+	__isl_keep isl_set *set)
+{
+	return add_selected_wraps_around_facet(wraps, info, k, bound, set, 1);
+}
+
+/* Basic map "i" has an inequality (say "k") that is adjacent
+ * to some inequality of basic map "j".  All the other inequalities
+ * are valid for "j".
+ * Check if basic map "j" forms an extension of basic map "i".
  *
- * All constraints of i (except k) are assumed to be valid for j.
+ * Note that this function is only called if some of the equalities or
+ * inequalities of basic map "j" do cut basic map "i".  The function is
+ * correct even if there are no such cut constraints, but in that case
+ * the additional checks performed by this function are overkill.
  *
- * However, the constraints of j may not be valid for i and so
- * we have to check that the wrapping constraints for j are valid for i.
+ * First try and wrap the ridges of "k" around "j".
+ * Note that those ridges are already valid for "j",
+ * but the wrapped versions may wrap "j" more tightly,
+ * increasing the chances of "j" being detected as an extension of "i"
+ */
+static enum isl_change is_adj_ineq_extension(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	int k;
+	enum isl_change change;
+	isl_size total;
+	isl_size n_eq_i, n_ineq_i;
+	struct isl_wraps wraps;
+	isl_ctx *ctx;
+	isl_mat *mat;
+	isl_vec *bound;
+	isl_set *set_j;
+	isl_stat r;
+
+	k = find_ineq(&infoi, STATUS_ADJ_INEQ);
+	if (k < 0)
+		isl_die(isl_basic_map_get_ctx(infoi.bmap), isl_error_internal,
+			"infoi.ineq should have exactly one STATUS_ADJ_INEQ",
+			return isl_change_error);
+
+	total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	n_eq_i = isl_basic_map_n_equality(infoi.bmap);
+	n_ineq_i = isl_basic_map_n_inequality(infoi.bmap);
+	if (total < 0 || n_eq_i < 0 || n_ineq_i < 0)
+		return isl_change_error;
+
+	set_j = set_from_updated_bmap(infoj.bmap, infoj.tab);
+	ctx = isl_basic_map_get_ctx(infoi.bmap);
+	bound = isl_vec_alloc(ctx, 1 + total);
+	mat = isl_mat_alloc(ctx, 2 * n_eq_i + n_ineq_i, 1 + total);
+	if (wraps_init(&wraps, mat, info, i, j) < 0)
+		goto error;
+	if (!bound || !set_j)
+		goto error;
+	r = add_valid_wraps_around_facet(&wraps, &infoi, k, bound->el, set_j);
+	if (r < 0)
+		goto error;
+
+	change = is_adj_ineq_extension_with_wraps(i, j, k, info, wraps.mat);
+
+	wraps_free(&wraps);
+	isl_vec_free(bound);
+	isl_set_free(set_j);
+
+	return change;
+error:
+	wraps_free(&wraps);
+	isl_vec_free(bound);
+	isl_set_free(set_j);
+	return isl_change_error;
+}
+
+/* Both basic maps have at least one inequality with and adjacent
+ * (but opposite) inequality in the other basic map.
+ * Check that there are no cut constraints and that there is only
+ * a single pair of adjacent inequalities.
+ * If so, we can replace the pair by a single basic map described
+ * by all but the pair of adjacent inequalities.
+ * Any additional points introduced lie strictly between the two
+ * adjacent hyperplanes and can therefore be integral.
  *
- * In the case where j has a facet adjacent to i, tabj is assumed
- * to have been restricted to this facet, so that the non-redundant
- * constraints in tabj are the ridges of the facet.
- * Note that for the purpose of wrapping, it does not matter whether
- * we wrap the ridges of i around the whole of j or just around
- * the facet since all the other constraints are assumed to be valid for j.
- * In practice, we wrap to include the whole of j.
+ *        ____			  _____
+ *       /    ||\		 /     \
+ *      /     || \		/       \
+ *      \     ||  \	=>	\        \
+ *       \    ||  /		 \       /
+ *        \___||_/		  \_____/
+ *
+ * The test for a single pair of adjacent inequalities is important
+ * for avoiding the combination of two basic maps like the following
+ *
+ *       /|
+ *      / |
+ *     /__|
+ *         _____
+ *         |   |
+ *         |   |
+ *         |___|
+ *
+ * If there are some cut constraints on one side, then we may
+ * still be able to fuse the two basic maps, but we need to perform
+ * some additional checks in is_adj_ineq_extension.
+ */
+static enum isl_change check_adj_ineq(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	int count_i, count_j;
+	int cut_i, cut_j;
+
+	count_i = count_ineq(&infoi, STATUS_ADJ_INEQ);
+	count_j = count_ineq(&infoj, STATUS_ADJ_INEQ);
+
+	if (count_i != 1 && count_j != 1)
+		return isl_change_none;
+
+	cut_i = any_eq(&infoi, STATUS_CUT) || any_ineq(&infoi, STATUS_CUT);
+	cut_j = any_eq(&infoj, STATUS_CUT) || any_ineq(&infoj, STATUS_CUT);
+
+	if (!cut_i && !cut_j && count_i == 1 && count_j == 1)
+		return fuse(i, j, info, NULL, 0, 0);
+
+	if (count_i == 1 && !cut_i)
+		return is_adj_ineq_extension(i, j, info);
+
+	if (count_j == 1 && !cut_j)
+		return is_adj_ineq_extension(j, i, info);
+
+	return isl_change_none;
+}
+
+/* Given a basic set i with a constraint k that is adjacent to
+ * basic set j, check if we can wrap
+ * both the facet corresponding to k (if "wrap_facet" is set) and basic map j
+ * (always) around their ridges to include the other set.
+ * If so, replace the pair of basic sets by their union.
+ *
+ * All constraints of i (except k) are assumed to be valid or
+ * cut constraints for j.
+ * Wrapping the cut constraints to include basic map j may result
+ * in constraints that are no longer valid of basic map i
+ * we have to check that the resulting wrapping constraints are valid for i.
+ * If "wrap_facet" is not set, then all constraints of i (except k)
+ * are assumed to be valid for j.
  *        ____			  _____
  *       /    | 		 /     \
  *      /     ||  		/      |
@@ -781,61 +1745,53 @@
  *        \___||		  \____|
  *
  */
-static int can_wrap_in_facet(struct isl_map *map, int i, int j, int k,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change can_wrap_in_facet(int i, int j, int k,
+	struct isl_coalesce_info *info, int wrap_facet)
 {
-	int changed = 0;
+	enum isl_change change = isl_change_none;
 	struct isl_wraps wraps;
+	isl_ctx *ctx;
 	isl_mat *mat;
 	struct isl_set *set_i = NULL;
 	struct isl_set *set_j = NULL;
 	struct isl_vec *bound = NULL;
-	unsigned total = isl_basic_map_total_dim(map->pi);
-	struct isl_tab_undo *snap;
-	int n;
+	isl_size total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
 
-	set_i = set_from_updated_bmap(map->pi, tabsi);
-	set_j = set_from_updated_bmap(map->pj, tabsj);
-	mat = isl_mat_alloc(map->ctx, 2 * (map->pi->n_eq + map->pj->n_eq) +
-					map->pi->n_ineq + map->pj->n_ineq,
-					1 + total);
-	wraps_init(&wraps, mat, map, i, j, eq_i, ineq_i, eq_j, ineq_j);
-	bound = isl_vec_alloc(map->ctx, 1 + total);
-	if (!set_i || !set_j || !wraps.mat || !bound)
+	if (total < 0)
+		return isl_change_error;
+	set_i = set_from_updated_bmap(infoi.bmap, infoi.tab);
+	set_j = set_from_updated_bmap(infoj.bmap, infoj.tab);
+	ctx = isl_basic_map_get_ctx(infoi.bmap);
+	mat = isl_mat_alloc(ctx, 2 * (infoi.bmap->n_eq + infoj.bmap->n_eq) +
+				    infoi.bmap->n_ineq + infoj.bmap->n_ineq,
+				    1 + total);
+	if (wraps_init(&wraps, mat, info, i, j) < 0)
+		goto error;
+	bound = isl_vec_alloc(ctx, 1 + total);
+	if (!set_i || !set_j || !bound)
 		goto error;
 
-	isl_seq_cpy(bound->el, map->pi->ineqk, 1 + total);
+	isl_seq_cpy(bound->el, infoi.bmap->ineqk, 1 + total);
 	isl_int_add_ui(bound->el0, bound->el0, 1);
+	isl_seq_normalize(ctx, bound->el, 1 + total);
 
 	isl_seq_cpy(wraps.mat->row0, bound->el, 1 + total);
 	wraps.mat->n_row = 1;
 
-	if (add_wraps(&wraps, map->pj, tabsj, bound->el, set_i) < 0)
+	if (add_wraps(&wraps, &infoj, bound->el, set_i) < 0)
 		goto error;
-	if (!wraps.mat->n_row)
+	if (wraps.failed)
 		goto unbounded;
 
-	snap = isl_tab_snap(tabsi);
-
-	if (isl_tab_select_facet(tabsi, map->pi->n_eq + k) < 0)
-		goto error;
-	if (isl_tab_detect_redundant(tabsi) < 0)
-		goto error;
-
-	isl_seq_neg(bound->el, map->pi->ineqk, 1 + total);
-
-	n = wraps.mat->n_row;
-	if (add_wraps(&wraps, map->pi, tabsi, bound->el, set_j) < 0)
-		goto error;
-
-	if (isl_tab_rollback(tabsi, snap) < 0)
-		goto error;
-	if (check_wraps(wraps.mat, n, tabsi) < 0)
-		goto error;
-	if (!wraps.mat->n_row)
-		goto unbounded;
+	if (wrap_facet) {
+		if (add_wraps_around_facet(&wraps, &infoi, k,
+					    bound->el, set_j) < 0)
+			goto error;
+		if (wraps.failed)
+			goto unbounded;
+	}
 
-	changed = fuse(map, i, j, tabs, eq_i, ineq_i, eq_j, ineq_j, wraps.mat);
+	change = fuse(i, j, info, wraps.mat, 0, 0);
 
 unbounded:
 	wraps_free(&wraps);
@@ -845,38 +1801,55 @@
 
 	isl_vec_free(bound);
 
-	return changed;
+	return change;
 error:
 	wraps_free(&wraps);
 	isl_vec_free(bound);
 	isl_set_free(set_i);
 	isl_set_free(set_j);
-	return -1;
+	return isl_change_error;
 }
 
-/* Set the is_redundant property of the "n" constraints in "cuts",
- * except "k" to "v".
- * This is a fairly tricky operation as it bypasses isl_tab.c.
- * The reason we want to temporarily mark some constraints redundant
- * is that we want to ignore them in add_wraps.
- *
- * Initially all cut constraints are non-redundant, but the
- * selection of a facet right before the call to this function
- * may have made some of them redundant.
- * Likewise, the same constraints are marked non-redundant
- * in the second call to this function, before they are officially
- * made non-redundant again in the subsequent rollback.
+/* Given a cut constraint t(x) >= 0 of basic map i, stored in row "w"
+ * of wrap.mat, replace it by its relaxed version t(x) + 1 >= 0, and
+ * add wrapping constraints to wrap.mat for all constraints
+ * of basic map j that bound the part of basic map j that sticks out
+ * of the cut constraint.
+ * "set_i" is the underlying set of basic map i.
+ * If any wrapping fails, then wraps->mat.n_row is reset to zero.
+ *
+ * In particular, we first intersect basic map j with t(x) + 1 = 0.
+ * If the result is empty, then t(x) >= 0 was actually a valid constraint
+ * (with respect to the integer points), so we add t(x) >= 0 instead.
+ * Otherwise, we wrap the constraints of basic map j that are not
+ * redundant in this intersection and that are not already valid
+ * for basic map i over basic map i.
+ * Note that it is sufficient to wrap the constraints to include
+ * basic map i, because we will only wrap the constraints that do
+ * not include basic map i already.  The wrapped constraint will
+ * therefore be more relaxed compared to the original constraint.
+ * Since the original constraint is valid for basic map j, so is
+ * the wrapped constraint.
  */
-static void set_is_redundant(struct isl_tab *tab, unsigned n_eq,
-	int *cuts, int n, int k, int v)
+static isl_stat wrap_in_facet(struct isl_wraps *wraps, int w,
+	struct isl_coalesce_info *info_j, __isl_keep isl_set *set_i,
+	struct isl_tab_undo *snap)
 {
-	int l;
+	isl_int_add_ui(wraps->mat->roww0, wraps->mat->roww0, 1);
+	if (isl_tab_add_eq(info_j->tab, wraps->mat->roww) < 0)
+		return isl_stat_error;
+	if (isl_tab_detect_redundant(info_j->tab) < 0)
+		return isl_stat_error;
+
+	if (info_j->tab->empty)
+		isl_int_sub_ui(wraps->mat->roww0, wraps->mat->roww0, 1);
+	else if (add_wraps(wraps, info_j, wraps->mat->roww, set_i) < 0)
+		return isl_stat_error;
 
-	for (l = 0; l < n; ++l) {
-		if (l == k)
-			continue;
-		tab->conn_eq + cutsl.is_redundant = v;
-	}
+	if (isl_tab_rollback(info_j->tab, snap) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
 /* Given a pair of basic maps i and j such that j sticks out
@@ -884,116 +1857,133 @@
  * try to compute wrapping constraints and replace the two
  * basic maps by a single basic map.
  * The other constraints of i are assumed to be valid for j.
+ * "set_i" is the underlying set of basic map i.
+ * "wraps" has been initialized to be of the right size.
  *
- * The facets of i corresponding to the cut constraints are
- * wrapped around their ridges, except those ridges determined
- * by any of the other cut constraints.
- * The intersections of cut constraints need to be ignored
- * as the result of wrapping one cut constraint around another
- * would result in a constraint cutting the union.
- * In each case, the facets are wrapped to include the union
- * of the two basic maps.
- *
- * The pieces of j that lie at an offset of exactly one from
- * one of the cut constraints of i are wrapped around their edges.
- * Here, there is no need to ignore intersections because we
- * are wrapping around the union of the two basic maps.
+ * For each cut constraint t(x) >= 0 of i, we add the relaxed version
+ * t(x) + 1 >= 0, along with wrapping constraints for all constraints
+ * of basic map j that bound the part of basic map j that sticks out
+ * of the cut constraint.
  *
  * If any wrapping fails, i.e., if we cannot wrap to touch
  * the union, then we give up.
  * Otherwise, the pair of basic maps is replaced by their union.
  */
-static int wrap_in_facets(struct isl_map *map, int i, int j,
-	int *cuts, int n, struct isl_tab **tabs,
-	int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change try_wrap_in_facets(int i, int j,
+	struct isl_coalesce_info *info, struct isl_wraps *wraps,
+	__isl_keep isl_set *set_i)
 {
-	int changed = 0;
-	struct isl_wraps wraps;
-	isl_mat *mat;
-	isl_set *set = NULL;
-	isl_vec *bound = NULL;
-	unsigned total = isl_basic_map_total_dim(map->pi);
-	int max_wrap;
-	int k;
-	struct isl_tab_undo *snap_i, *snap_j;
-
-	if (isl_tab_extend_cons(tabsj, 1) < 0)
-		goto error;
-
-	max_wrap = 2 * (map->pi->n_eq + map->pj->n_eq) +
-		    map->pi->n_ineq + map->pj->n_ineq;
-	max_wrap *= n;
+	int k, l, w;
+	isl_size total;
+	struct isl_tab_undo *snap;
 
-	set = isl_set_union(set_from_updated_bmap(map->pi, tabsi),
-			    set_from_updated_bmap(map->pj, tabsj));
-	mat = isl_mat_alloc(map->ctx, max_wrap, 1 + total);
-	wraps_init(&wraps, mat, map, i, j, eq_i, ineq_i, eq_j, ineq_j);
-	bound = isl_vec_alloc(map->ctx, 1 + total);
-	if (!set || !wraps.mat || !bound)
-		goto error;
+	total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	if (total < 0)
+		return isl_change_error;
 
-	snap_i = isl_tab_snap(tabsi);
-	snap_j = isl_tab_snap(tabsj);
+	snap = isl_tab_snap(infoj.tab);
 
-	wraps.mat->n_row = 0;
+	for (k = 0; k < infoi.bmap->n_eq; ++k) {
+		for (l = 0; l < 2; ++l) {
+			if (infoi.eq2 * k + l != STATUS_CUT)
+				continue;
+			w = wraps->mat->n_row++;
+			if (l == 0)
+				isl_seq_neg(wraps->mat->roww,
+					    infoi.bmap->eqk, 1 + total);
+			else
+				isl_seq_cpy(wraps->mat->roww,
+					    infoi.bmap->eqk, 1 + total);
+			if (wrap_in_facet(wraps, w, &infoj, set_i, snap) < 0)
+				return isl_change_error;
 
-	for (k = 0; k < n; ++k) {
-		if (isl_tab_select_facet(tabsi, map->pi->n_eq + cutsk) < 0)
-			goto error;
-		if (isl_tab_detect_redundant(tabsi) < 0)
-			goto error;
-		set_is_redundant(tabsi, map->pi->n_eq, cuts, n, k, 1);
+			if (wraps->failed)
+				return isl_change_none;
+		}
+	}
 
-		isl_seq_neg(bound->el, map->pi->ineqcutsk, 1 + total);
-		if (!tabsi->empty &&
-		    add_wraps(&wraps, map->pi, tabsi, bound->el, set) < 0)
-			goto error;
+	for (k = 0; k < infoi.bmap->n_ineq; ++k) {
+		if (infoi.ineqk != STATUS_CUT)
+			continue;
+		w = wraps->mat->n_row++;
+		isl_seq_cpy(wraps->mat->roww,
+			    infoi.bmap->ineqk, 1 + total);
+		if (wrap_in_facet(wraps, w, &infoj, set_i, snap) < 0)
+			return isl_change_error;
 
-		set_is_redundant(tabsi, map->pi->n_eq, cuts, n, k, 0);
-		if (isl_tab_rollback(tabsi, snap_i) < 0)
-			goto error;
+		if (wraps->failed)
+			return isl_change_none;
+	}
 
-		if (tabsi->empty)
-			break;
-		if (!wraps.mat->n_row)
-			break;
+	return fuse(i, j, info, wraps->mat, 0, 1);
+}
 
-		isl_seq_cpy(bound->el, map->pi->ineqcutsk, 1 + total);
-		isl_int_add_ui(bound->el0, bound->el0, 1);
-		if (isl_tab_add_eq(tabsj, bound->el) < 0)
-			goto error;
-		if (isl_tab_detect_redundant(tabsj) < 0)
-			goto error;
+/* Given a pair of basic maps i and j such that j sticks out
+ * of i at n cut constraints, each time by at most one,
+ * try to compute wrapping constraints and replace the two
+ * basic maps by a single basic map.
+ * The other constraints of i are assumed to be valid for j.
+ *
+ * The core computation is performed by try_wrap_in_facets.
+ * This function simply extracts an underlying set representation
+ * of basic map i and initializes the data structure for keeping
+ * track of wrapping constraints.
+ */
+static enum isl_change wrap_in_facets(int i, int j, int n,
+	struct isl_coalesce_info *info)
+{
+	enum isl_change change = isl_change_none;
+	struct isl_wraps wraps;
+	isl_ctx *ctx;
+	isl_mat *mat;
+	isl_set *set_i = NULL;
+	isl_size total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	int max_wrap;
 
-		if (!tabsj->empty &&
-		    add_wraps(&wraps, map->pj, tabsj, bound->el, set) < 0)
-			goto error;
+	if (total < 0)
+		return isl_change_error;
+	if (isl_tab_extend_cons(infoj.tab, 1) < 0)
+		return isl_change_error;
 
-		if (isl_tab_rollback(tabsj, snap_j) < 0)
-			goto error;
+	max_wrap = 1 + 2 * infoj.bmap->n_eq + infoj.bmap->n_ineq;
+	max_wrap *= n;
 
-		if (!wraps.mat->n_row)
-			break;
-	}
+	set_i = set_from_updated_bmap(infoi.bmap, infoi.tab);
+	ctx = isl_basic_map_get_ctx(infoi.bmap);
+	mat = isl_mat_alloc(ctx, max_wrap, 1 + total);
+	if (wraps_init(&wraps, mat, info, i, j) < 0)
+		goto error;
+	if (!set_i)
+		goto error;
 
-	if (k == n)
-		changed = fuse(map, i, j, tabs,
-				eq_i, ineq_i, eq_j, ineq_j, wraps.mat);
+	change = try_wrap_in_facets(i, j, info, &wraps, set_i);
 
-	isl_vec_free(bound);
 	wraps_free(&wraps);
-	isl_set_free(set);
+	isl_set_free(set_i);
 
-	return changed;
+	return change;
 error:
-	isl_vec_free(bound);
 	wraps_free(&wraps);
-	isl_set_free(set);
-	return -1;
+	isl_set_free(set_i);
+	return isl_change_error;
+}
+
+/* Return the effect of inequality "ineq" on the tableau "tab",
+ * after relaxing the constant term of "ineq" by one.
+ */
+static enum isl_ineq_type type_of_relaxed(struct isl_tab *tab, isl_int *ineq)
+{
+	enum isl_ineq_type type;
+
+	isl_int_add_ui(ineq0, ineq0, 1);
+	type = isl_tab_ineq_type(tab, ineq);
+	isl_int_sub_ui(ineq0, ineq0, 1);
+
+	return type;
 }
 
-/* Given two basic sets i and j such that i has no cut equalities,
- * check if relaxing all the cut inequalities of i by one turns
+/* Given two basic sets i and j,
+ * check if relaxing all the cut constraints of i by one turns
  * them into valid constraint for j and check if we can wrap in
  * the bits that are sticking out.
  * If so, replace the pair by their union.
@@ -1051,130 +2041,228 @@
  *	|
  *	 \______________________________________________________________________
  */
-static int can_wrap_in_set(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change can_wrap_in_set(int i, int j,
+	struct isl_coalesce_info *info)
 {
-	int changed = 0;
-	int k, m;
+	int k, l;
 	int n;
-	int *cuts = NULL;
+	isl_size total;
 
-	if (ISL_F_ISSET(map->pi, ISL_BASIC_MAP_RATIONAL) ||
-	    ISL_F_ISSET(map->pj, ISL_BASIC_MAP_RATIONAL))
-		return 0;
+	if (ISL_F_ISSET(infoi.bmap, ISL_BASIC_MAP_RATIONAL) ||
+	    ISL_F_ISSET(infoj.bmap, ISL_BASIC_MAP_RATIONAL))
+		return isl_change_none;
 
-	n = count(ineq_i, map->pi->n_ineq, STATUS_CUT);
+	n = count_eq(&infoi, STATUS_CUT) + count_ineq(&infoi, STATUS_CUT);
 	if (n == 0)
-		return 0;
+		return isl_change_none;
 
-	cuts = isl_alloc_array(map->ctx, int, n);
-	if (!cuts)
-		return -1;
+	total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
+	if (total < 0)
+		return isl_change_error;
+	for (k = 0; k < infoi.bmap->n_eq; ++k) {
+		for (l = 0; l < 2; ++l) {
+			enum isl_ineq_type type;
 
-	for (k = 0, m = 0; m < n; ++k) {
+			if (infoi.eq2 * k + l != STATUS_CUT)
+				continue;
+
+			if (l == 0)
+				isl_seq_neg(infoi.bmap->eqk,
+					    infoi.bmap->eqk, 1 + total);
+			type = type_of_relaxed(infoj.tab,
+					    infoi.bmap->eqk);
+			if (l == 0)
+				isl_seq_neg(infoi.bmap->eqk,
+					    infoi.bmap->eqk, 1 + total);
+			if (type == isl_ineq_error)
+				return isl_change_error;
+			if (type != isl_ineq_redundant)
+				return isl_change_none;
+		}
+	}
+
+	for (k = 0; k < infoi.bmap->n_ineq; ++k) {
 		enum isl_ineq_type type;
 
-		if (ineq_ik != STATUS_CUT)
+		if (infoi.ineqk != STATUS_CUT)
 			continue;
 
-		isl_int_add_ui(map->pi->ineqk0, map->pi->ineqk0, 1);
-		type = isl_tab_ineq_type(tabsj, map->pi->ineqk);
-		isl_int_sub_ui(map->pi->ineqk0, map->pi->ineqk0, 1);
+		type = type_of_relaxed(infoj.tab, infoi.bmap->ineqk);
 		if (type == isl_ineq_error)
-			goto error;
+			return isl_change_error;
 		if (type != isl_ineq_redundant)
-			break;
-		cutsm = k;
-		++m;
+			return isl_change_none;
 	}
 
-	if (m == n)
-		changed = wrap_in_facets(map, i, j, cuts, n, tabs,
-					 eq_i, ineq_i, eq_j, ineq_j);
-
-	free(cuts);
-
-	return changed;
-error:
-	free(cuts);
-	return -1;
+	return wrap_in_facets(i, j, n, info);
 }
 
-/* Check if either i or j has a single cut constraint that can
+/* Check if either i or j has only cut constraints that can
  * be used to wrap in (a facet of) the other basic set.
  * if so, replace the pair by their union.
  */
-static int check_wrap(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change check_wrap(int i, int j, struct isl_coalesce_info *info)
+{
+	enum isl_change change = isl_change_none;
+
+	change = can_wrap_in_set(i, j, info);
+	if (change != isl_change_none)
+		return change;
+
+	change = can_wrap_in_set(j, i, info);
+	return change;
+}
+
+/* Check if all inequality constraints of "i" that cut "j" cease
+ * to be cut constraints if they are relaxed by one.
+ * If so, collect the cut constraints in "list".
+ * The caller is responsible for allocating "list".
+ */
+static isl_bool all_cut_by_one(int i, int j, struct isl_coalesce_info *info,
+	int *list)
 {
-	int changed = 0;
+	int l, n;
+
+	n = 0;
+	for (l = 0; l < infoi.bmap->n_ineq; ++l) {
+		enum isl_ineq_type type;
+
+		if (infoi.ineql != STATUS_CUT)
+			continue;
+		type = type_of_relaxed(infoj.tab, infoi.bmap->ineql);
+		if (type == isl_ineq_error)
+			return isl_bool_error;
+		if (type != isl_ineq_redundant)
+			return isl_bool_false;
+		listn++ = l;
+	}
 
-	if (!any(eq_i, 2 * map->pi->n_eq, STATUS_CUT))
-		changed = can_wrap_in_set(map, i, j, tabs,
-					    eq_i, ineq_i, eq_j, ineq_j);
-	if (changed)
-		return changed;
-
-	if (!any(eq_j, 2 * map->pj->n_eq, STATUS_CUT))
-		changed = can_wrap_in_set(map, j, i, tabs,
-					    eq_j, ineq_j, eq_i, ineq_i);
-	return changed;
+	return isl_bool_true;
+}
+
+/* Given two basic maps such that "j" has at least one equality constraint
+ * that is adjacent to an inequality constraint of "i" and such that "i" has
+ * exactly one inequality constraint that is adjacent to an equality
+ * constraint of "j", check whether "i" can be extended to include "j" or
+ * whether "j" can be wrapped into "i".
+ * All remaining constraints of "i" and "j" are assumed to be valid
+ * or cut constraints of the other basic map.
+ * However, none of the equality constraints of "i" are cut constraints.
+ *
+ * If "i" has any "cut" inequality constraints, then check if relaxing
+ * each of them by one is sufficient for them to become valid.
+ * If so, check if the inequality constraint adjacent to an equality
+ * constraint of "j" along with all these cut constraints
+ * can be relaxed by one to contain exactly "j".
+ * Otherwise, or if this fails, check if "j" can be wrapped into "i".
+ */
+static enum isl_change check_single_adj_eq(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	enum isl_change change = isl_change_none;
+	int k;
+	int n_cut;
+	int *relax;
+	isl_ctx *ctx;
+	isl_bool try_relax;
+
+	n_cut = count_ineq(&infoi, STATUS_CUT);
+
+	k = find_ineq(&infoi, STATUS_ADJ_EQ);
+
+	if (n_cut > 0) {
+		ctx = isl_basic_map_get_ctx(infoi.bmap);
+		relax = isl_calloc_array(ctx, int, 1 + n_cut);
+		if (!relax)
+			return isl_change_error;
+		relax0 = k;
+		try_relax = all_cut_by_one(i, j, info, relax + 1);
+		if (try_relax < 0)
+			change = isl_change_error;
+	} else {
+		try_relax = isl_bool_true;
+		relax = &k;
+	}
+	if (try_relax && change == isl_change_none)
+		change = is_relaxed_extension(i, j, 1 + n_cut, relax, info);
+	if (n_cut > 0)
+		free(relax);
+	if (change != isl_change_none)
+		return change;
+
+	change = can_wrap_in_facet(i, j, k, info, n_cut > 0);
+
+	return change;
 }
 
 /* At least one of the basic maps has an equality that is adjacent
- * to inequality.  Make sure that only one of the basic maps has
+ * to an inequality.  Make sure that only one of the basic maps has
  * such an equality and that the other basic map has exactly one
  * inequality adjacent to an equality.
- * We call the basic map that has the inequality "i" and the basic
- * map that has the equality "j".
- * If "i" has any "cut" (in)equality, then relaxing the inequality
- * by one would not result in a basic map that contains the other
- * basic map.
+ * If the other basic map does not have such an inequality, then
+ * check if all its constraints are either valid or cut constraints
+ * and, if so, try wrapping in the first map into the second.
+ * Otherwise, try to extend one basic map with the other or
+ * wrap one basic map in the other.
  */
-static int check_adj_eq(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change check_adj_eq(int i, int j,
+	struct isl_coalesce_info *info)
 {
-	int changed = 0;
-	int k;
-
-	if (any(eq_i, 2 * map->pi->n_eq, STATUS_ADJ_INEQ) &&
-	    any(eq_j, 2 * map->pj->n_eq, STATUS_ADJ_INEQ))
+	if (any_eq(&infoi, STATUS_ADJ_INEQ) &&
+	    any_eq(&infoj, STATUS_ADJ_INEQ))
 		/* ADJ EQ TOO MANY */
-		return 0;
+		return isl_change_none;
 
-	if (any(eq_i, 2 * map->pi->n_eq, STATUS_ADJ_INEQ))
-		return check_adj_eq(map, j, i, tabs,
-					eq_j, ineq_j, eq_i, ineq_i);
+	if (any_eq(&infoi, STATUS_ADJ_INEQ))
+		return check_adj_eq(j, i, info);
 
 	/* j has an equality adjacent to an inequality in i */
 
-	if (any(eq_i, 2 * map->pi->n_eq, STATUS_CUT))
-		return 0;
-	if (any(ineq_i, map->pi->n_ineq, STATUS_CUT))
-		/* ADJ EQ CUT */
-		return 0;
-	if (count(ineq_i, map->pi->n_ineq, STATUS_ADJ_EQ) != 1 ||
-	    any(ineq_j, map->pj->n_ineq, STATUS_ADJ_EQ) ||
-	    any(ineq_i, map->pi->n_ineq, STATUS_ADJ_INEQ) ||
-	    any(ineq_j, map->pj->n_ineq, STATUS_ADJ_INEQ))
+	if (count_ineq(&infoi, STATUS_ADJ_EQ) != 1) {
+		if (all_valid_or_cut(&infoi))
+			return can_wrap_in_set(i, j, info);
+		return isl_change_none;
+	}
+	if (any_eq(&infoi, STATUS_CUT))
+		return isl_change_none;
+	if (any_ineq(&infoj, STATUS_ADJ_EQ) ||
+	    any_ineq(&infoi, STATUS_ADJ_INEQ) ||
+	    any_ineq(&infoj, STATUS_ADJ_INEQ))
 		/* ADJ EQ TOO MANY */
-		return 0;
+		return isl_change_none;
 
-	for (k = 0; k < map->pi->n_ineq; ++k)
-		if (ineq_ik == STATUS_ADJ_EQ)
-			break;
+	return check_single_adj_eq(i, j, info);
+}
 
-	changed = is_adj_eq_extension(map, i, j, k, tabs,
-					eq_i, ineq_i, eq_j, ineq_j);
-	if (changed)
-		return changed;
+/* Disjunct "j" lies on a hyperplane that is adjacent to disjunct "i".
+ * In particular, disjunct "i" has an inequality constraint that is adjacent
+ * to a (combination of) equality constraint(s) of disjunct "j",
+ * but disjunct "j" has no explicit equality constraint adjacent
+ * to an inequality constraint of disjunct "i".
+ *
+ * Disjunct "i" is already known not to have any equality constraints
+ * that are adjacent to an equality or inequality constraint.
+ * Check that, other than the inequality constraint mentioned above,
+ * all other constraints of disjunct "i" are valid for disjunct "j".
+ * If so, try and wrap in disjunct "j".
+ */
+static enum isl_change check_ineq_adj_eq(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	int k;
 
-	if (count(eq_j, 2 * map->pj->n_eq, STATUS_ADJ_INEQ) != 1)
-		return 0;
+	if (any_eq(&infoi, STATUS_CUT))
+		return isl_change_none;
+	if (any_ineq(&infoi, STATUS_CUT))
+		return isl_change_none;
+	if (any_ineq(&infoi, STATUS_ADJ_INEQ))
+		return isl_change_none;
+	if (count_ineq(&infoi, STATUS_ADJ_EQ) != 1)
+		return isl_change_none;
 
-	changed = can_wrap_in_facet(map, i, j, k, tabs, eq_i, ineq_i, eq_j, ineq_j);
+	k = find_ineq(&infoi, STATUS_ADJ_EQ);
 
-	return changed;
+	return can_wrap_in_facet(i, j, k, info, 0);
 }
 
 /* The two basic maps lie on adjacent hyperplanes.  In particular,
@@ -1189,62 +2277,57 @@
  *	 \\		=>	 \\
  *	  \			  \|
  *
- * We only allow one equality of "i" to be adjacent to an equality of "j"
- * to avoid coalescing
- *
- *	m, n -> { x, y -> x, 1 + y : x >= 1 and y >= 1 and
- *					    x <= 10 and y <= 10;
- *		    x, y -> 1 + x, y : x >= 1 and x <= 20 and
- *					    y >= 5 and y <= 15 }
- *
- * to
- *
- *	m, n -> { x, y -> x2, y2 : x >= 1 and 10y2 <= 20 - x + 10y and
- *					4y2 >= 5 + 3y and 5y2 <= 15 + 4y and
- *					y2 <= 1 + x + y - x2 and y2 >= y and
- *					y2 >= 1 + x + y - x2 }
+ * If there is more than one equality of "i" adjacent to an equality of "j",
+ * then the result will satisfy one or more equalities that are a linear
+ * combination of these equalities.  These will be encoded as pairs
+ * of inequalities in the wrapping constraints and need to be made
+ * explicit.
  */
-static int check_eq_adj_eq(struct isl_map *map, int i, int j,
-	struct isl_tab **tabs, int *eq_i, int *ineq_i, int *eq_j, int *ineq_j)
+static enum isl_change check_eq_adj_eq(int i, int j,
+	struct isl_coalesce_info *info)
 {
 	int k;
-	int changed = 0;
+	enum isl_change change = isl_change_none;
+	int detect_equalities = 0;
 	struct isl_wraps wraps;
+	isl_ctx *ctx;
 	isl_mat *mat;
 	struct isl_set *set_i = NULL;
 	struct isl_set *set_j = NULL;
 	struct isl_vec *bound = NULL;
-	unsigned total = isl_basic_map_total_dim(map->pi);
-
-	if (count(eq_i, 2 * map->pi->n_eq, STATUS_ADJ_EQ) != 1)
-		return 0;
-
-	for (k = 0; k < 2 * map->pi->n_eq ; ++k)
-		if (eq_ik == STATUS_ADJ_EQ)
-			break;
+	isl_size total = isl_basic_map_dim(infoi.bmap, isl_dim_all);
 
-	set_i = set_from_updated_bmap(map->pi, tabsi);
-	set_j = set_from_updated_bmap(map->pj, tabsj);
-	mat = isl_mat_alloc(map->ctx, 2 * (map->pi->n_eq + map->pj->n_eq) +
-					map->pi->n_ineq + map->pj->n_ineq,
-					1 + total);
-	wraps_init(&wraps, mat, map, i, j, eq_i, ineq_i, eq_j, ineq_j);
-	bound = isl_vec_alloc(map->ctx, 1 + total);
-	if (!set_i || !set_j || !wraps.mat || !bound)
+	if (total < 0)
+		return isl_change_error;
+	if (count_eq(&infoi, STATUS_ADJ_EQ) != 1)
+		detect_equalities = 1;
+
+	k = find_eq(&infoi, STATUS_ADJ_EQ);
+
+	set_i = set_from_updated_bmap(infoi.bmap, infoi.tab);
+	set_j = set_from_updated_bmap(infoj.bmap, infoj.tab);
+	ctx = isl_basic_map_get_ctx(infoi.bmap);
+	mat = isl_mat_alloc(ctx, 2 * (infoi.bmap->n_eq + infoj.bmap->n_eq) +
+				    infoi.bmap->n_ineq + infoj.bmap->n_ineq,
+				    1 + total);
+	if (wraps_init(&wraps, mat, info, i, j) < 0)
+		goto error;
+	bound = isl_vec_alloc(ctx, 1 + total);
+	if (!set_i || !set_j || !bound)
 		goto error;
 
 	if (k % 2 == 0)
-		isl_seq_neg(bound->el, map->pi->eqk / 2, 1 + total);
+		isl_seq_neg(bound->el, infoi.bmap->eqk / 2, 1 + total);
 	else
-		isl_seq_cpy(bound->el, map->pi->eqk / 2, 1 + total);
+		isl_seq_cpy(bound->el, infoi.bmap->eqk / 2, 1 + total);
 	isl_int_add_ui(bound->el0, bound->el0, 1);
 
 	isl_seq_cpy(wraps.mat->row0, bound->el, 1 + total);
 	wraps.mat->n_row = 1;
 
-	if (add_wraps(&wraps, map->pj, tabsj, bound->el, set_i) < 0)
+	if (add_wraps(&wraps, &infoj, bound->el, set_i) < 0)
 		goto error;
-	if (!wraps.mat->n_row)
+	if (wraps.failed)
 		goto unbounded;
 
 	isl_int_sub_ui(bound->el0, bound->el0, 1);
@@ -1253,15 +2336,15 @@
 	isl_seq_cpy(wraps.mat->rowwraps.mat->n_row, bound->el, 1 + total);
 	wraps.mat->n_row++;
 
-	if (add_wraps(&wraps, map->pi, tabsi, bound->el, set_j) < 0)
+	if (add_wraps(&wraps, &infoi, bound->el, set_j) < 0)
 		goto error;
-	if (!wraps.mat->n_row)
+	if (wraps.failed)
 		goto unbounded;
 
-	changed = fuse(map, i, j, tabs, eq_i, ineq_i, eq_j, ineq_j, wraps.mat);
+	change = fuse(i, j, info, wraps.mat, detect_equalities, 0);
 
 	if (0) {
-error:		changed = -1;
+error:		change = isl_change_error;
 	}
 unbounded:
 
@@ -1270,14 +2353,110 @@
 	isl_set_free(set_j);
 	isl_vec_free(bound);
 
-	return changed;
+	return change;
+}
+
+/* Initialize the "eq" and "ineq" fields of "info".
+ */
+static void init_status(struct isl_coalesce_info *info)
+{
+	info->eq = info->ineq = NULL;
+}
+
+/* Set info->eq to the positions of the equalities of info->bmap
+ * with respect to the basic map represented by "tab".
+ * If info->eq has already been computed, then do not compute it again.
+ */
+static void set_eq_status_in(struct isl_coalesce_info *info,
+	struct isl_tab *tab)
+{
+	if (info->eq)
+		return;
+	info->eq = eq_status_in(info->bmap, tab);
+}
+
+/* Set info->ineq to the positions of the inequalities of info->bmap
+ * with respect to the basic map represented by "tab".
+ * If info->ineq has already been computed, then do not compute it again.
+ */
+static void set_ineq_status_in(struct isl_coalesce_info *info,
+	struct isl_tab *tab)
+{
+	if (info->ineq)
+		return;
+	info->ineq = ineq_status_in(info->bmap, info->tab, tab);
+}
+
+/* Free the memory allocated by the "eq" and "ineq" fields of "info".
+ * This function assumes that init_status has been called on "info" first,
+ * after which the "eq" and "ineq" fields may or may not have been
+ * assigned a newly allocated array.
+ */
+static void clear_status(struct isl_coalesce_info *info)
+{
+	free(info->eq);
+	free(info->ineq);
+}
+
+/* Are all inequality constraints of the basic map represented by "info"
+ * valid for the other basic map, except for a single constraint
+ * that is adjacent to an inequality constraint of the other basic map?
+ */
+static int all_ineq_valid_or_single_adj_ineq(struct isl_coalesce_info *info)
+{
+	int i;
+	int k = -1;
+
+	for (i = 0; i < info->bmap->n_ineq; ++i) {
+		if (info->ineqi == STATUS_REDUNDANT)
+			continue;
+		if (info->ineqi == STATUS_VALID)
+			continue;
+		if (info->ineqi != STATUS_ADJ_INEQ)
+			return 0;
+		if (k != -1)
+			return 0;
+		k = i;
+	}
+
+	return k != -1;
+}
+
+/* Basic map "i" has one or more equality constraints that separate it
+ * from basic map "j".  Check if it happens to be an extension
+ * of basic map "j".
+ * In particular, check that all constraints of "j" are valid for "i",
+ * except for one inequality constraint that is adjacent
+ * to an inequality constraints of "i".
+ * If so, check for "i" being an extension of "j" by calling
+ * is_adj_ineq_extension.
+ *
+ * Clean up the memory allocated for keeping track of the status
+ * of the constraints before returning.
+ */
+static enum isl_change separating_equality(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	enum isl_change change = isl_change_none;
+
+	if (all(infoj.eq, 2 * infoj.bmap->n_eq, STATUS_VALID) &&
+	    all_ineq_valid_or_single_adj_ineq(&infoj))
+		change = is_adj_ineq_extension(j, i, info);
+
+	clear_status(&infoi);
+	clear_status(&infoj);
+	return change;
 }
 
 /* Check if the union of the given pair of basic maps
  * can be represented by a single basic map.
- * If so, replace the pair by the single basic map and return 1.
- * Otherwise, return 0;
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
  * The two basic maps are assumed to live in the same local space.
+ * The "eq" and "ineq" fields of infoi and infoj are assumed
+ * to have been initialized by the caller, either to NULL or
+ * to valid information.
  *
  * We first check the effect of each constraint of one basic map
  * on the other basic map.
@@ -1329,7 +2508,7 @@
  *		=> the pair can be replaced by the basic map containing
  *		   the inequality, with the inequality relaxed.
  *
- *	6. there is a single adjacent pair of an inequality and an equality,
+ *	6. there is a single inequality adjacent to an equality,
  *	   the other constraints of the basic map containing the inequality are
  *	   "valid".  Moreover, the facets corresponding to both
  *	   the inequality and the equality can be wrapped around their
@@ -1355,94 +2534,421 @@
  * corresponding to the basic maps.  When the basic maps are dropped
  * or combined, the tableaus are modified accordingly.
  */
-static int coalesce_local_pair(__isl_keep isl_map *map, int i, int j,
-	struct isl_tab **tabs)
+static enum isl_change coalesce_local_pair_reuse(int i, int j,
+	struct isl_coalesce_info *info)
 {
-	int changed = 0;
-	int *eq_i = NULL;
-	int *eq_j = NULL;
-	int *ineq_i = NULL;
-	int *ineq_j = NULL;
+	enum isl_change change = isl_change_none;
 
-	eq_i = eq_status_in(map->pi, tabsj);
-	if (map->pi->n_eq && !eq_i)
+	set_ineq_status_in(&infoi, infoj.tab);
+	if (infoi.bmap->n_ineq && !infoi.ineq)
 		goto error;
-	if (any(eq_i, 2 * map->pi->n_eq, STATUS_ERROR))
+	if (any_ineq(&infoi, STATUS_ERROR))
 		goto error;
-	if (any(eq_i, 2 * map->pi->n_eq, STATUS_SEPARATE))
+	if (any_ineq(&infoi, STATUS_SEPARATE))
 		goto done;
 
-	eq_j = eq_status_in(map->pj, tabsi);
-	if (map->pj->n_eq && !eq_j)
+	set_ineq_status_in(&infoj, infoi.tab);
+	if (infoj.bmap->n_ineq && !infoj.ineq)
 		goto error;
-	if (any(eq_j, 2 * map->pj->n_eq, STATUS_ERROR))
+	if (any_ineq(&infoj, STATUS_ERROR))
 		goto error;
-	if (any(eq_j, 2 * map->pj->n_eq, STATUS_SEPARATE))
+	if (any_ineq(&infoj, STATUS_SEPARATE))
 		goto done;
 
-	ineq_i = ineq_status_in(map->pi, tabsi, tabsj);
-	if (map->pi->n_ineq && !ineq_i)
+	set_eq_status_in(&infoi, infoj.tab);
+	if (infoi.bmap->n_eq && !infoi.eq)
 		goto error;
-	if (any(ineq_i, map->pi->n_ineq, STATUS_ERROR))
+	if (any_eq(&infoi, STATUS_ERROR))
 		goto error;
-	if (any(ineq_i, map->pi->n_ineq, STATUS_SEPARATE))
-		goto done;
 
-	ineq_j = ineq_status_in(map->pj, tabsj, tabsi);
-	if (map->pj->n_ineq && !ineq_j)
+	set_eq_status_in(&infoj, infoi.tab);
+	if (infoj.bmap->n_eq && !infoj.eq)
 		goto error;
-	if (any(ineq_j, map->pj->n_ineq, STATUS_ERROR))
+	if (any_eq(&infoj, STATUS_ERROR))
 		goto error;
-	if (any(ineq_j, map->pj->n_ineq, STATUS_SEPARATE))
-		goto done;
 
-	if (all(eq_i, 2 * map->pi->n_eq, STATUS_VALID) &&
-	    all(ineq_i, map->pi->n_ineq, STATUS_VALID)) {
-		drop(map, j, tabs);
-		changed = 1;
-	} else if (all(eq_j, 2 * map->pj->n_eq, STATUS_VALID) &&
-		   all(ineq_j, map->pj->n_ineq, STATUS_VALID)) {
-		drop(map, i, tabs);
-		changed = 1;
-	} else if (any(eq_i, 2 * map->pi->n_eq, STATUS_ADJ_EQ)) {
-		changed = check_eq_adj_eq(map, i, j, tabs,
-					eq_i, ineq_i, eq_j, ineq_j);
-	} else if (any(eq_j, 2 * map->pj->n_eq, STATUS_ADJ_EQ)) {
-		changed = check_eq_adj_eq(map, j, i, tabs,
-					eq_j, ineq_j, eq_i, ineq_i);
-	} else if (any(eq_i, 2 * map->pi->n_eq, STATUS_ADJ_INEQ) ||
-		   any(eq_j, 2 * map->pj->n_eq, STATUS_ADJ_INEQ)) {
-		changed = check_adj_eq(map, i, j, tabs,
-					eq_i, ineq_i, eq_j, ineq_j);
-	} else if (any(ineq_i, map->pi->n_ineq, STATUS_ADJ_EQ) ||
-		   any(ineq_j, map->pj->n_ineq, STATUS_ADJ_EQ)) {
-		/* Can't happen */
-		/* BAD ADJ INEQ */
-	} else if (any(ineq_i, map->pi->n_ineq, STATUS_ADJ_INEQ) ||
-		   any(ineq_j, map->pj->n_ineq, STATUS_ADJ_INEQ)) {
-		changed = check_adj_ineq(map, i, j, tabs,
-					eq_i, ineq_i, eq_j, ineq_j);
+	if (any_eq(&infoi, STATUS_SEPARATE))
+		return separating_equality(i, j, info);
+	if (any_eq(&infoj, STATUS_SEPARATE))
+		return separating_equality(j, i, info);
+
+	if (all(infoi.eq, 2 * infoi.bmap->n_eq, STATUS_VALID) &&
+	    all(infoi.ineq, infoi.bmap->n_ineq, STATUS_VALID)) {
+		drop(&infoj);
+		change = isl_change_drop_second;
+	} else if (all(infoj.eq, 2 * infoj.bmap->n_eq, STATUS_VALID) &&
+		   all(infoj.ineq, infoj.bmap->n_ineq, STATUS_VALID)) {
+		drop(&infoi);
+		change = isl_change_drop_first;
+	} else if (any_eq(&infoi, STATUS_ADJ_EQ)) {
+		change = check_eq_adj_eq(i, j, info);
+	} else if (any_eq(&infoj, STATUS_ADJ_EQ)) {
+		change = check_eq_adj_eq(j, i, info);
+	} else if (any_eq(&infoi, STATUS_ADJ_INEQ) ||
+		   any_eq(&infoj, STATUS_ADJ_INEQ)) {
+		change = check_adj_eq(i, j, info);
+	} else if (any_ineq(&infoi, STATUS_ADJ_EQ)) {
+		change = check_ineq_adj_eq(i, j, info);
+	} else if (any_ineq(&infoj, STATUS_ADJ_EQ)) {
+		change = check_ineq_adj_eq(j, i, info);
+	} else if (any_ineq(&infoi, STATUS_ADJ_INEQ) ||
+		   any_ineq(&infoj, STATUS_ADJ_INEQ)) {
+		change = check_adj_ineq(i, j, info);
 	} else {
-		if (!any(eq_i, 2 * map->pi->n_eq, STATUS_CUT) &&
-		    !any(eq_j, 2 * map->pj->n_eq, STATUS_CUT))
-			changed = check_facets(map, i, j, tabs, ineq_i, ineq_j);
-		if (!changed)
-			changed = check_wrap(map, i, j, tabs,
-						eq_i, ineq_i, eq_j, ineq_j);
+		if (!any_eq(&infoi, STATUS_CUT) &&
+		    !any_eq(&infoj, STATUS_CUT))
+			change = check_facets(i, j, info);
+		if (change == isl_change_none)
+			change = check_wrap(i, j, info);
 	}
 
 done:
-	free(eq_i);
-	free(eq_j);
-	free(ineq_i);
-	free(ineq_j);
-	return changed;
+	clear_status(&infoi);
+	clear_status(&infoj);
+	return change;
 error:
-	free(eq_i);
-	free(eq_j);
-	free(ineq_i);
-	free(ineq_j);
-	return -1;
+	clear_status(&infoi);
+	clear_status(&infoj);
+	return isl_change_error;
+}
+
+/* Check if the union of the given pair of basic maps
+ * can be represented by a single basic map.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ * The two basic maps are assumed to live in the same local space.
+ */
+static enum isl_change coalesce_local_pair(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	init_status(&infoi);
+	init_status(&infoj);
+	return coalesce_local_pair_reuse(i, j, info);
+}
+
+/* Shift the integer division at position "div" of the basic map
+ * represented by "info" by "shift".
+ *
+ * That is, if the integer division has the form
+ *
+ *	floor(f(x)/d)
+ *
+ * then replace it by
+ *
+ *	floor((f(x) + shift * d)/d) - shift
+ */
+static isl_stat shift_div(struct isl_coalesce_info *info, int div,
+	isl_int shift)
+{
+	isl_size total, n_div;
+
+	info->bmap = isl_basic_map_shift_div(info->bmap, div, 0, shift);
+	if (!info->bmap)
+		return isl_stat_error;
+
+	total = isl_basic_map_dim(info->bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(info->bmap, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return isl_stat_error;
+	total -= n_div;
+	if (isl_tab_shift_var(info->tab, total + div, shift) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* If the integer division at position "div" is defined by an equality,
+ * i.e., a stride constraint, then change the integer division expression
+ * to have a constant term equal to zero.
+ *
+ * Let the equality constraint be
+ *
+ *	c + f + m a = 0
+ *
+ * The integer division expression is then typically of the form
+ *
+ *	a = floor((-f - c')/m)
+ *
+ * The integer division is first shifted by t = floor(c/m),
+ * turning the equality constraint into
+ *
+ *	c - m floor(c/m) + f + m a' = 0
+ *
+ * i.e.,
+ *
+ *	(c mod m) + f + m a' = 0
+ *
+ * That is,
+ *
+ *	a' = (-f - (c mod m))/m = floor((-f)/m)
+ *
+ * because a' is an integer and 0 <= (c mod m) < m.
+ * The constant term of a' can therefore be zeroed out,
+ * but only if the integer division expression is of the expected form.
+ */
+static isl_stat normalize_stride_div(struct isl_coalesce_info *info, int div)
+{
+	isl_bool defined, valid;
+	isl_stat r;
+	isl_constraint *c;
+	isl_int shift, stride;
+
+	defined = isl_basic_map_has_defining_equality(info->bmap, isl_dim_div,
+							div, &c);
+	if (defined < 0)
+		return isl_stat_error;
+	if (!defined)
+		return isl_stat_ok;
+	if (!c)
+		return isl_stat_error;
+	valid = isl_constraint_is_div_equality(c, div);
+	isl_int_init(shift);
+	isl_int_init(stride);
+	isl_constraint_get_constant(c, &shift);
+	isl_constraint_get_coefficient(c, isl_dim_div, div, &stride);
+	isl_int_fdiv_q(shift, shift, stride);
+	r = shift_div(info, div, shift);
+	isl_int_clear(stride);
+	isl_int_clear(shift);
+	isl_constraint_free(c);
+	if (r < 0 || valid < 0)
+		return isl_stat_error;
+	if (!valid)
+		return isl_stat_ok;
+	info->bmap = isl_basic_map_set_div_expr_constant_num_si_inplace(
+							    info->bmap, div, 0);
+	if (!info->bmap)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* The basic maps represented by "info1" and "info2" are known
+ * to have the same number of integer divisions.
+ * Check if pairs of integer divisions are equal to each other
+ * despite the fact that they differ by a rational constant.
+ *
+ * In particular, look for any pair of integer divisions that
+ * only differ in their constant terms.
+ * If either of these integer divisions is defined
+ * by stride constraints, then modify it to have a zero constant term.
+ * If both are defined by stride constraints then in the end they will have
+ * the same (zero) constant term.
+ */
+static isl_stat harmonize_stride_divs(struct isl_coalesce_info *info1,
+	struct isl_coalesce_info *info2)
+{
+	int i;
+	isl_size n;
+
+	n = isl_basic_map_dim(info1->bmap, isl_dim_div);
+	if (n < 0)
+		return isl_stat_error;
+	for (i = 0; i < n; ++i) {
+		isl_bool known, harmonize;
+
+		known = isl_basic_map_div_is_known(info1->bmap, i);
+		if (known >= 0 && known)
+			known = isl_basic_map_div_is_known(info2->bmap, i);
+		if (known < 0)
+			return isl_stat_error;
+		if (!known)
+			continue;
+		harmonize = isl_basic_map_equal_div_expr_except_constant(
+					    info1->bmap, i, info2->bmap, i);
+		if (harmonize < 0)
+			return isl_stat_error;
+		if (!harmonize)
+			continue;
+		if (normalize_stride_div(info1, i) < 0)
+			return isl_stat_error;
+		if (normalize_stride_div(info2, i) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* If "shift" is an integer constant, then shift the integer division
+ * at position "div" of the basic map represented by "info" by "shift".
+ * If "shift" is not an integer constant, then do nothing.
+ * If "shift" is equal to zero, then no shift needs to be performed either.
+ *
+ * That is, if the integer division has the form
+ *
+ *	floor(f(x)/d)
+ *
+ * then replace it by
+ *
+ *	floor((f(x) + shift * d)/d) - shift
+ */
+static isl_stat shift_if_cst_int(struct isl_coalesce_info *info, int div,
+	__isl_keep isl_aff *shift)
+{
+	isl_bool cst;
+	isl_stat r;
+	isl_int d;
+	isl_val *c;
+
+	cst = isl_aff_is_cst(shift);
+	if (cst < 0 || !cst)
+		return cst < 0 ? isl_stat_error : isl_stat_ok;
+
+	c = isl_aff_get_constant_val(shift);
+	cst = isl_val_is_int(c);
+	if (cst >= 0 && cst)
+		cst = isl_bool_not(isl_val_is_zero(c));
+	if (cst < 0 || !cst) {
+		isl_val_free(c);
+		return cst < 0 ? isl_stat_error : isl_stat_ok;
+	}
+
+	isl_int_init(d);
+	r = isl_val_get_num_isl_int(c, &d);
+	if (r >= 0)
+		r = shift_div(info, div, d);
+	isl_int_clear(d);
+
+	isl_val_free(c);
+
+	return r;
+}
+
+/* Check if some of the divs in the basic map represented by "info1"
+ * are shifts of the corresponding divs in the basic map represented
+ * by "info2", taking into account the equality constraints "eq1" of "info1"
+ * and "eq2" of "info2".  If so, align them with those of "info2".
+ * "info1" and "info2" are assumed to have the same number
+ * of integer divisions.
+ *
+ * An integer division is considered to be a shift of another integer
+ * division if, after simplification with respect to the equality
+ * constraints of the other basic map, one is equal to the other
+ * plus a constant.
+ *
+ * In particular, for each pair of integer divisions, if both are known,
+ * have the same denominator and are not already equal to each other,
+ * simplify each with respect to the equality constraints
+ * of the other basic map.  If the difference is an integer constant,
+ * then move this difference outside.
+ * That is, if, after simplification, one integer division is of the form
+ *
+ *	floor((f(x) + c_1)/d)
+ *
+ * while the other is of the form
+ *
+ *	floor((f(x) + c_2)/d)
+ *
+ * and n = (c_2 - c_1)/d is an integer, then replace the first
+ * integer division by
+ *
+ *	floor((f_1(x) + c_1 + n * d)/d) - n,
+ *
+ * where floor((f_1(x) + c_1 + n * d)/d) = floor((f2(x) + c_2)/d)
+ * after simplification with respect to the equality constraints.
+ */
+static isl_stat harmonize_divs_with_hulls(struct isl_coalesce_info *info1,
+	struct isl_coalesce_info *info2, __isl_keep isl_basic_set *eq1,
+	__isl_keep isl_basic_set *eq2)
+{
+	int i;
+	isl_size total;
+	isl_local_space *ls1, *ls2;
+
+	total = isl_basic_map_dim(info1->bmap, isl_dim_all);
+	if (total < 0)
+		return isl_stat_error;
+	ls1 = isl_local_space_wrap(isl_basic_map_get_local_space(info1->bmap));
+	ls2 = isl_local_space_wrap(isl_basic_map_get_local_space(info2->bmap));
+	for (i = 0; i < info1->bmap->n_div; ++i) {
+		isl_stat r;
+		isl_aff *div1, *div2;
+
+		if (!isl_local_space_div_is_known(ls1, i) ||
+		    !isl_local_space_div_is_known(ls2, i))
+			continue;
+		if (isl_int_ne(info1->bmap->divi0, info2->bmap->divi0))
+			continue;
+		if (isl_seq_eq(info1->bmap->divi + 1,
+				info2->bmap->divi + 1, 1 + total))
+			continue;
+		div1 = isl_local_space_get_div(ls1, i);
+		div2 = isl_local_space_get_div(ls2, i);
+		div1 = isl_aff_substitute_equalities(div1,
+						    isl_basic_set_copy(eq2));
+		div2 = isl_aff_substitute_equalities(div2,
+						    isl_basic_set_copy(eq1));
+		div2 = isl_aff_sub(div2, div1);
+		r = shift_if_cst_int(info1, i, div2);
+		isl_aff_free(div2);
+		if (r < 0)
+			break;
+	}
+	isl_local_space_free(ls1);
+	isl_local_space_free(ls2);
+
+	if (i < info1->bmap->n_div)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Check if some of the divs in the basic map represented by "info1"
+ * are shifts of the corresponding divs in the basic map represented
+ * by "info2".  If so, align them with those of "info2".
+ * Only do this if "info1" and "info2" have the same number
+ * of integer divisions.
+ *
+ * An integer division is considered to be a shift of another integer
+ * division if, after simplification with respect to the equality
+ * constraints of the other basic map, one is equal to the other
+ * plus a constant.
+ *
+ * First check if pairs of integer divisions are equal to each other
+ * despite the fact that they differ by a rational constant.
+ * If so, try and arrange for them to have the same constant term.
+ *
+ * Then, extract the equality constraints and continue with
+ * harmonize_divs_with_hulls.
+ *
+ * If the equality constraints of both basic maps are the same,
+ * then there is no need to perform any shifting since
+ * the coefficients of the integer divisions should have been
+ * reduced in the same way.
+ */
+static isl_stat harmonize_divs(struct isl_coalesce_info *info1,
+	struct isl_coalesce_info *info2)
+{
+	isl_bool equal;
+	isl_basic_map *bmap1, *bmap2;
+	isl_basic_set *eq1, *eq2;
+	isl_stat r;
+
+	if (!info1->bmap || !info2->bmap)
+		return isl_stat_error;
+
+	if (info1->bmap->n_div != info2->bmap->n_div)
+		return isl_stat_ok;
+	if (info1->bmap->n_div == 0)
+		return isl_stat_ok;
+
+	if (harmonize_stride_divs(info1, info2) < 0)
+		return isl_stat_error;
+
+	bmap1 = isl_basic_map_copy(info1->bmap);
+	bmap2 = isl_basic_map_copy(info2->bmap);
+	eq1 = isl_basic_map_wrap(isl_basic_map_plain_affine_hull(bmap1));
+	eq2 = isl_basic_map_wrap(isl_basic_map_plain_affine_hull(bmap2));
+	equal = isl_basic_set_plain_is_equal(eq1, eq2);
+	if (equal < 0)
+		r = isl_stat_error;
+	else if (equal)
+		r = isl_stat_ok;
+	else
+		r = harmonize_divs_with_hulls(info1, info2, eq1, eq2);
+	isl_basic_set_free(eq1);
+	isl_basic_set_free(eq2);
+
+	return r;
 }
 
 /* Do the two basic maps live in the same local space, i.e.,
@@ -1450,20 +2956,20 @@
  * If either basic map has any unknown divs, then we can only assume
  * that they do not live in the same local space.
  */
-static int same_divs(__isl_keep isl_basic_map *bmap1,
+static isl_bool same_divs(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2)
 {
 	int i;
-	int known;
-	int total;
+	isl_bool known;
+	isl_size total;
 
 	if (!bmap1 || !bmap2)
-		return -1;
+		return isl_bool_error;
 	if (bmap1->n_div != bmap2->n_div)
-		return 0;
+		return isl_bool_false;
 
 	if (bmap1->n_div == 0)
-		return 1;
+		return isl_bool_true;
 
 	known = isl_basic_map_divs_known(bmap1);
 	if (known < 0 || !known)
@@ -1472,105 +2978,462 @@
 	if (known < 0 || !known)
 		return known;
 
-	total = isl_basic_map_total_dim(bmap1);
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	for (i = 0; i < bmap1->n_div; ++i)
 		if (!isl_seq_eq(bmap1->divi, bmap2->divi, 2 + total))
-			return 0;
+			return isl_bool_false;
 
-	return 1;
+	return isl_bool_true;
 }
 
-/* Given two basic maps "i" and "j", where the divs of "i" form a subset
- * of those of "j", check if basic map "j" is a subset of basic map "i"
- * and, if so, drop basic map "j".
- *
- * We first expand the divs of basic map "i" to match those of basic map "j",
- * using the divs and expansion computed by the caller.
- * Then we check if all constraints of the expanded "i" are valid for "j".
+/* Assuming that "tab" contains the equality constraints and
+ * the initial inequality constraints of "bmap", copy the remaining
+ * inequality constraints of "bmap" to "Tab".
  */
-static int coalesce_subset(__isl_keep isl_map *map, int i, int j,
-	struct isl_tab **tabs, __isl_keep isl_mat *div, int *exp)
+static isl_stat copy_ineq(struct isl_tab *tab, __isl_keep isl_basic_map *bmap)
 {
-	isl_basic_map *bmap;
-	int changed = 0;
-	int *eq_i = NULL;
-	int *ineq_i = NULL;
+	int i, n_ineq;
+
+	if (!bmap)
+		return isl_stat_error;
+
+	n_ineq = tab->n_con - tab->n_eq;
+	for (i = n_ineq; i < bmap->n_ineq; ++i)
+		if (isl_tab_add_ineq(tab, bmap->ineqi) < 0)
+			return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Description of an integer division that is added
+ * during an expansion.
+ * "pos" is the position of the corresponding variable.
+ * "cst" indicates whether this integer division has a fixed value.
+ * "val" contains the fixed value, if the value is fixed.
+ */
+struct isl_expanded {
+	int pos;
+	isl_bool cst;
+	isl_int val;
+};
+
+/* For each of the "n" integer division variables "expanded",
+ * if the variable has a fixed value, then add two inequality
+ * constraints expressing the fixed value.
+ * Otherwise, add the corresponding div constraints.
+ * The caller is responsible for removing the div constraints
+ * that it added for all these "n" integer divisions.
+ *
+ * The div constraints and the pair of inequality constraints
+ * forcing the fixed value cannot both be added for a given variable
+ * as the combination may render some of the original constraints redundant.
+ * These would then be ignored during the coalescing detection,
+ * while they could remain in the fused result.
+ *
+ * The two added inequality constraints are
+ *
+ *	-a + v >= 0
+ *	a - v >= 0
+ *
+ * with "a" the variable and "v" its fixed value.
+ * The facet corresponding to one of these two constraints is selected
+ * in the tableau to ensure that the pair of inequality constraints
+ * is treated as an equality constraint.
+ *
+ * The information in info->ineq is thrown away because it was
+ * computed in terms of div constraints, while some of those
+ * have now been replaced by these pairs of inequality constraints.
+ */
+static isl_stat fix_constant_divs(struct isl_coalesce_info *info,
+	int n, struct isl_expanded *expanded)
+{
+	unsigned o_div;
+	int i;
+	isl_vec *ineq;
+
+	o_div = isl_basic_map_offset(info->bmap, isl_dim_div) - 1;
+	ineq = isl_vec_alloc(isl_tab_get_ctx(info->tab), 1 + info->tab->n_var);
+	if (!ineq)
+		return isl_stat_error;
+	isl_seq_clr(ineq->el + 1, info->tab->n_var);
+
+	for (i = 0; i < n; ++i) {
+		if (!expandedi.cst) {
+			info->bmap = isl_basic_map_extend_constraints(
+						info->bmap, 0, 2);
+			info->bmap = isl_basic_map_add_div_constraints(
+					info->bmap, expandedi.pos - o_div);
+		} else {
+			isl_int_set_si(ineq->el1 + expandedi.pos, -1);
+			isl_int_set(ineq->el0, expandedi.val);
+			info->bmap = isl_basic_map_add_ineq(info->bmap,
+								ineq->el);
+			isl_int_set_si(ineq->el1 + expandedi.pos, 1);
+			isl_int_neg(ineq->el0, expandedi.val);
+			info->bmap = isl_basic_map_add_ineq(info->bmap,
+								ineq->el);
+			isl_int_set_si(ineq->el1 + expandedi.pos, 0);
+		}
+		if (copy_ineq(info->tab, info->bmap) < 0)
+			break;
+		if (expandedi.cst &&
+		    isl_tab_select_facet(info->tab, info->tab->n_con - 1) < 0)
+			break;
+	}
+
+	isl_vec_free(ineq);
+
+	clear_status(info);
+	init_status(info);
 
-	bmap = isl_basic_map_copy(map->pi);
-	bmap = isl_basic_set_expand_divs(bmap, isl_mat_copy(div), exp);
+	return i < n ? isl_stat_error : isl_stat_ok;
+}
+
+/* Insert the "n" integer division variables "expanded"
+ * into info->tab and info->bmap and
+ * update info->ineq with respect to the redundant constraints
+ * in the resulting tableau.
+ * "bmap" contains the result of this insertion in info->bmap,
+ * while info->bmap is the original version
+ * of "bmap", i.e., the one that corresponds to the current
+ * state of info->tab.  The number of constraints in info->bmap
+ * is assumed to be the same as the number of constraints
+ * in info->tab.  This is required to be able to detect
+ * the extra constraints in "bmap".
+ *
+ * In particular, introduce extra variables corresponding
+ * to the extra integer divisions and add the div constraints
+ * that were added to "bmap" after info->tab was created
+ * from info->bmap.
+ * Furthermore, check if these extra integer divisions happen
+ * to attain a fixed integer value in info->tab.
+ * If so, replace the corresponding div constraints by pairs
+ * of inequality constraints that fix these
+ * integer divisions to their single integer values.
+ * Replace info->bmap by "bmap" to match the changes to info->tab.
+ * info->ineq was computed without a tableau and therefore
+ * does not take into account the redundant constraints
+ * in the tableau.  Mark them here.
+ * There is no need to check the newly added div constraints
+ * since they cannot be redundant.
+ * The redundancy check is not performed when constants have been discovered
+ * since info->ineq is completely thrown away in this case.
+ */
+static isl_stat tab_insert_divs(struct isl_coalesce_info *info,
+	int n, struct isl_expanded *expanded, __isl_take isl_basic_map *bmap)
+{
+	int i, n_ineq;
+	unsigned n_eq;
+	struct isl_tab_undo *snap;
+	int any;
+
+	if (!bmap)
+		return isl_stat_error;
+	if (info->bmap->n_eq + info->bmap->n_ineq != info->tab->n_con)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_internal,
+			"original tableau does not correspond "
+			"to original basic map", goto error);
+
+	if (isl_tab_extend_vars(info->tab, n) < 0)
+		goto error;
+	if (isl_tab_extend_cons(info->tab, 2 * n) < 0)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		if (isl_tab_insert_var(info->tab, expandedi.pos) < 0)
+			goto error;
+	}
+
+	snap = isl_tab_snap(info->tab);
+
+	n_ineq = info->tab->n_con - info->tab->n_eq;
+	if (copy_ineq(info->tab, bmap) < 0)
+		goto error;
+
+	isl_basic_map_free(info->bmap);
+	info->bmap = bmap;
+
+	any = 0;
+	for (i = 0; i < n; ++i) {
+		expandedi.cst = isl_tab_is_constant(info->tab,
+					    expandedi.pos, &expandedi.val);
+		if (expandedi.cst < 0)
+			return isl_stat_error;
+		if (expandedi.cst)
+			any = 1;
+	}
+
+	if (any) {
+		if (isl_tab_rollback(info->tab, snap) < 0)
+			return isl_stat_error;
+		info->bmap = isl_basic_map_cow(info->bmap);
+		info->bmap = isl_basic_map_free_inequality(info->bmap, 2 * n);
+		if (info->bmap < 0)
+			return isl_stat_error;
+
+		return fix_constant_divs(info, n, expanded);
+	}
+
+	n_eq = info->bmap->n_eq;
+	for (i = 0; i < n_ineq; ++i) {
+		if (isl_tab_is_redundant(info->tab, n_eq + i))
+			info->ineqi = STATUS_REDUNDANT;
+	}
+
+	return isl_stat_ok;
+error:
+	isl_basic_map_free(bmap);
+	return isl_stat_error;
+}
+
+/* Expand info->tab and info->bmap in the same way "bmap" was expanded
+ * in isl_basic_map_expand_divs using the expansion "exp" and
+ * update info->ineq with respect to the redundant constraints
+ * in the resulting tableau. info->bmap is the original version
+ * of "bmap", i.e., the one that corresponds to the current
+ * state of info->tab.  The number of constraints in info->bmap
+ * is assumed to be the same as the number of constraints
+ * in info->tab.  This is required to be able to detect
+ * the extra constraints in "bmap".
+ *
+ * Extract the positions where extra local variables are introduced
+ * from "exp" and call tab_insert_divs.
+ */
+static isl_stat expand_tab(struct isl_coalesce_info *info, int *exp,
+	__isl_take isl_basic_map *bmap)
+{
+	isl_ctx *ctx;
+	struct isl_expanded *expanded;
+	int i, j, k, n;
+	int extra_var;
+	isl_size total, n_div;
+	unsigned pos;
+	isl_stat r;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return isl_stat_error;
+	pos = total - n_div;
+	extra_var = total - info->tab->n_var;
+	n = n_div - extra_var;
+
+	ctx = isl_basic_map_get_ctx(bmap);
+	expanded = isl_calloc_array(ctx, struct isl_expanded, extra_var);
+	if (extra_var && !expanded)
+		goto error;
+
+	i = 0;
+	k = 0;
+	for (j = 0; j < n_div; ++j) {
+		if (i < n && expi == j) {
+			++i;
+			continue;
+		}
+		expandedk++.pos = pos + j;
+	}
+
+	for (k = 0; k < extra_var; ++k)
+		isl_int_init(expandedk.val);
+
+	r = tab_insert_divs(info, extra_var, expanded, bmap);
+
+	for (k = 0; k < extra_var; ++k)
+		isl_int_clear(expandedk.val);
+	free(expanded);
+
+	return r;
+error:
+	isl_basic_map_free(bmap);
+	return isl_stat_error;
+}
+
+/* Check if the union of the basic maps represented by infoi and infoj
+ * can be represented by a single basic map,
+ * after expanding the divs of infoi to match those of infoj.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ *
+ * The caller has already checked for infoj being a subset of infoi.
+ * If some of the divs of infoj are unknown, then the expanded infoi
+ * will not have the corresponding div constraints.  The other patterns
+ * therefore cannot apply.  Skip the computation in this case.
+ *
+ * The expansion is performed using the divs "div" and expansion "exp"
+ * computed by the caller.
+ * infoi.bmap has already been expanded and the result is passed in
+ * as "bmap".
+ * The "eq" and "ineq" fields of infoi reflect the status of
+ * the constraints of the expanded "bmap" with respect to infoj.tab.
+ * However, inequality constraints that are redundant in infoi.tab
+ * have not yet been marked as such because no tableau was available.
+ *
+ * Replace infoi.bmap by "bmap" and expand infoi.tab as well,
+ * updating infoi.ineq with respect to the redundant constraints.
+ * Then try and coalesce the expanded infoi with infoj,
+ * reusing the information in infoi.eq and infoi.ineq.
+ * If this does not result in any coalescing or if it results in infoj
+ * getting dropped (which should not happen in practice, since the case
+ * of infoj being a subset of infoi has already been checked by
+ * the caller), then revert infoi to its original state.
+ */
+static enum isl_change coalesce_expand_tab_divs(__isl_take isl_basic_map *bmap,
+	int i, int j, struct isl_coalesce_info *info, __isl_keep isl_mat *div,
+	int *exp)
+{
+	isl_bool known;
+	isl_basic_map *bmap_i;
+	struct isl_tab_undo *snap;
+	enum isl_change change = isl_change_none;
+
+	known = isl_basic_map_divs_known(infoj.bmap);
+	if (known < 0 || !known) {
+		clear_status(&infoi);
+		isl_basic_map_free(bmap);
+		return known < 0 ? isl_change_error : isl_change_none;
+	}
+
+	bmap_i = isl_basic_map_copy(infoi.bmap);
+	snap = isl_tab_snap(infoi.tab);
+	if (expand_tab(&infoi, exp, bmap) < 0)
+		change = isl_change_error;
+
+	init_status(&infoj);
+	if (change == isl_change_none)
+		change = coalesce_local_pair_reuse(i, j, info);
+	else
+		clear_status(&infoi);
+	if (change != isl_change_none && change != isl_change_drop_second) {
+		isl_basic_map_free(bmap_i);
+	} else {
+		isl_basic_map_free(infoi.bmap);
+		infoi.bmap = bmap_i;
+
+		if (isl_tab_rollback(infoi.tab, snap) < 0)
+			change = isl_change_error;
+	}
+
+	return change;
+}
+
+/* Check if the union of "bmap" and the basic map represented by infoj
+ * can be represented by a single basic map,
+ * after expanding the divs of "bmap" to match those of infoj.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ *
+ * In particular, check if the expanded "bmap" contains the basic map
+ * represented by the tableau infoj.tab.
+ * The expansion is performed using the divs "div" and expansion "exp"
+ * computed by the caller.
+ * Then we check if all constraints of the expanded "bmap" are valid for
+ * infoj.tab.
+ *
+ * If "i" is not equal to -1, then "bmap" is equal to infoi.bmap.
+ * In this case, the positions of the constraints of infoi.bmap
+ * with respect to the basic map represented by infoj are stored
+ * in infoi.
+ *
+ * If the expanded "bmap" does not contain the basic map
+ * represented by the tableau infoj.tab and if "i" is not -1,
+ * i.e., if the original "bmap" is infoi.bmap, then expand infoi.tab
+ * as well and check if that results in coalescing.
+ */
+static enum isl_change coalesce_with_expanded_divs(
+	__isl_keep isl_basic_map *bmap, int i, int j,
+	struct isl_coalesce_info *info, __isl_keep isl_mat *div, int *exp)
+{
+	enum isl_change change = isl_change_none;
+	struct isl_coalesce_info info_local, *info_i;
+
+	info_i = i >= 0 ? &infoi : &info_local;
+	init_status(info_i);
+	bmap = isl_basic_map_copy(bmap);
+	bmap = isl_basic_map_expand_divs(bmap, isl_mat_copy(div), exp);
+	bmap = isl_basic_map_mark_final(bmap);
 
 	if (!bmap)
 		goto error;
 
-	eq_i = eq_status_in(bmap, tabsj);
-	if (bmap->n_eq && !eq_i)
+	info_local.bmap = bmap;
+	info_i->eq = eq_status_in(bmap, infoj.tab);
+	if (bmap->n_eq && !info_i->eq)
 		goto error;
-	if (any(eq_i, 2 * bmap->n_eq, STATUS_ERROR))
+	if (any_eq(info_i, STATUS_ERROR))
 		goto error;
-	if (any(eq_i, 2 * bmap->n_eq, STATUS_SEPARATE))
+	if (any_eq(info_i, STATUS_SEPARATE))
 		goto done;
 
-	ineq_i = ineq_status_in(bmap, NULL, tabsj);
-	if (bmap->n_ineq && !ineq_i)
+	info_i->ineq = ineq_status_in(bmap, NULL, infoj.tab);
+	if (bmap->n_ineq && !info_i->ineq)
 		goto error;
-	if (any(ineq_i, bmap->n_ineq, STATUS_ERROR))
+	if (any_ineq(info_i, STATUS_ERROR))
 		goto error;
-	if (any(ineq_i, bmap->n_ineq, STATUS_SEPARATE))
+	if (any_ineq(info_i, STATUS_SEPARATE))
 		goto done;
 
-	if (all(eq_i, 2 * map->pi->n_eq, STATUS_VALID) &&
-	    all(ineq_i, map->pi->n_ineq, STATUS_VALID)) {
-		drop(map, j, tabs);
-		changed = 1;
+	if (all(info_i->eq, 2 * bmap->n_eq, STATUS_VALID) &&
+	    all(info_i->ineq, bmap->n_ineq, STATUS_VALID)) {
+		drop(&infoj);
+		change = isl_change_drop_second;
 	}
 
+	if (change == isl_change_none && i != -1)
+		return coalesce_expand_tab_divs(bmap, i, j, info, div, exp);
+
 done:
 	isl_basic_map_free(bmap);
-	free(eq_i);
-	free(ineq_i);
-	return 0;
+	clear_status(info_i);
+	return change;
 error:
 	isl_basic_map_free(bmap);
-	free(eq_i);
-	free(ineq_i);
-	return -1;
+	clear_status(info_i);
+	return isl_change_error;
 }
 
-/* Check if the basic map "j" is a subset of basic map "i",
- * assuming that "i" has fewer divs that "j".
- * If not, then we change the order.
- *
- * If the two basic maps have the same number of divs, then
- * they must necessarily be different.  Otherwise, we would have
- * called coalesce_local_pair.  We therefore don't try anything
- * in this case.
+/* Check if the union of "bmap_i" and the basic map represented by infoj
+ * can be represented by a single basic map,
+ * after aligning the divs of "bmap_i" to match those of infoj.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ *
+ * In particular, check if "bmap_i" contains the basic map represented by
+ * infoj after aligning the divs of "bmap_i" to those of infoj.
+ * Note that this can only succeed if the number of divs of "bmap_i"
+ * is smaller than (or equal to) the number of divs of infoj.
+ *
+ * We first check if the divs of "bmap_i" are all known and form a subset
+ * of those of infoj.bmap.  If so, we pass control over to
+ * coalesce_with_expanded_divs.
  *
- * We first check if the divs of "i" are all known and form a subset
- * of those of "j".  If so, we pass control over to coalesce_subset.
+ * If "i" is not equal to -1, then "bmap" is equal to infoi.bmap.
  */
-static int check_coalesce_subset(__isl_keep isl_map *map, int i, int j,
-	struct isl_tab **tabs)
+static enum isl_change coalesce_after_aligning_divs(
+	__isl_keep isl_basic_map *bmap_i, int i, int j,
+	struct isl_coalesce_info *info)
 {
-	int known;
+	isl_bool known;
 	isl_mat *div_i, *div_j, *div;
 	int *exp1 = NULL;
 	int *exp2 = NULL;
 	isl_ctx *ctx;
-	int subset;
+	enum isl_change change;
 
-	if (map->pi->n_div == map->pj->n_div)
-		return 0;
-	if (map->pj->n_div < map->pi->n_div)
-		return check_coalesce_subset(map, j, i, tabs);
-
-	known = isl_basic_map_divs_known(map->pi);
-	if (known < 0 || !known)
-		return known;
+	known = isl_basic_map_divs_known(bmap_i);
+	if (known < 0)
+		return isl_change_error;
+	if (!known)
+		return isl_change_none;
 
-	ctx = isl_map_get_ctx(map);
+	ctx = isl_basic_map_get_ctx(bmap_i);
 
-	div_i = isl_basic_map_get_divs(map->pi);
-	div_j = isl_basic_map_get_divs(map->pj);
+	div_i = isl_basic_map_get_divs(bmap_i);
+	div_j = isl_basic_map_get_divs(infoj.bmap);
 
 	if (!div_i || !div_j)
 		goto error;
@@ -1585,9 +3448,10 @@
 		goto error;
 
 	if (div->n_row == div_j->n_row)
-		subset = coalesce_subset(map, i, j, tabs, div, exp1);
+		change = coalesce_with_expanded_divs(bmap_i,
+							i, j, info, div, exp1);
 	else
-		subset = 0;
+		change = isl_change_none;
 
 	isl_mat_free(div);
 
@@ -1597,77 +3461,727 @@
 	free(exp2);
 	free(exp1);
 
-	return subset;
+	return change;
 error:
 	isl_mat_free(div_i);
 	isl_mat_free(div_j);
 	free(exp1);
 	free(exp2);
-	return -1;
+	return isl_change_error;
+}
+
+/* Check if basic map "j" is a subset of basic map "i" after
+ * exploiting the extra equalities of "j" to simplify the divs of "i".
+ * If so, remove basic map "j" and return isl_change_drop_second.
+ *
+ * If "j" does not have any equalities or if they are the same
+ * as those of "i", then we cannot exploit them to simplify the divs.
+ * Similarly, if there are no divs in "i", then they cannot be simplified.
+ * If, on the other hand, the affine hulls of "i" and "j" do not intersect,
+ * then "j" cannot be a subset of "i".
+ *
+ * Otherwise, we intersect "i" with the affine hull of "j" and then
+ * check if "j" is a subset of the result after aligning the divs.
+ * If so, then "j" is definitely a subset of "i" and can be removed.
+ * Note that if after intersection with the affine hull of "j".
+ * "i" still has more divs than "j", then there is no way we can
+ * align the divs of "i" to those of "j".
+ */
+static enum isl_change coalesce_subset_with_equalities(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	isl_basic_map *hull_i, *hull_j, *bmap_i;
+	int equal, empty;
+	enum isl_change change;
+
+	if (infoj.bmap->n_eq == 0)
+		return isl_change_none;
+	if (infoi.bmap->n_div == 0)
+		return isl_change_none;
+
+	hull_i = isl_basic_map_copy(infoi.bmap);
+	hull_i = isl_basic_map_plain_affine_hull(hull_i);
+	hull_j = isl_basic_map_copy(infoj.bmap);
+	hull_j = isl_basic_map_plain_affine_hull(hull_j);
+
+	hull_j = isl_basic_map_intersect(hull_j, isl_basic_map_copy(hull_i));
+	equal = isl_basic_map_plain_is_equal(hull_i, hull_j);
+	empty = isl_basic_map_plain_is_empty(hull_j);
+	isl_basic_map_free(hull_i);
+
+	if (equal < 0 || equal || empty < 0 || empty) {
+		isl_basic_map_free(hull_j);
+		if (equal < 0 || empty < 0)
+			return isl_change_error;
+		return isl_change_none;
+	}
+
+	bmap_i = isl_basic_map_copy(infoi.bmap);
+	bmap_i = isl_basic_map_intersect(bmap_i, hull_j);
+	if (!bmap_i)
+		return isl_change_error;
+
+	if (bmap_i->n_div > infoj.bmap->n_div) {
+		isl_basic_map_free(bmap_i);
+		return isl_change_none;
+	}
+
+	change = coalesce_after_aligning_divs(bmap_i, -1, j, info);
+
+	isl_basic_map_free(bmap_i);
+
+	return change;
+}
+
+/* Check if the union of and the basic maps represented by infoi and infoj
+ * can be represented by a single basic map, by aligning or equating
+ * their integer divisions.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ *
+ * Note that we only perform any test if the number of divs is different
+ * in the two basic maps.  In case the number of divs is the same,
+ * we have already established that the divs are different
+ * in the two basic maps.
+ * In particular, if the number of divs of basic map i is smaller than
+ * the number of divs of basic map j, then we check if j is a subset of i
+ * and vice versa.
+ */
+static enum isl_change coalesce_divs(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	enum isl_change change = isl_change_none;
+
+	if (infoi.bmap->n_div < infoj.bmap->n_div)
+		change = coalesce_after_aligning_divs(infoi.bmap, i, j, info);
+	if (change != isl_change_none)
+		return change;
+
+	if (infoj.bmap->n_div < infoi.bmap->n_div)
+		change = coalesce_after_aligning_divs(infoj.bmap, j, i, info);
+	if (change != isl_change_none)
+		return invert_change(change);
+
+	change = coalesce_subset_with_equalities(i, j, info);
+	if (change != isl_change_none)
+		return change;
+
+	change = coalesce_subset_with_equalities(j, i, info);
+	if (change != isl_change_none)
+		return invert_change(change);
+
+	return isl_change_none;
+}
+
+/* Does "bmap" involve any divs that themselves refer to divs?
+ */
+static isl_bool has_nested_div(__isl_keep isl_basic_map *bmap)
+{
+	int i;
+	isl_size total;
+	isl_size n_div;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return isl_bool_error;
+	total -= n_div;
+
+	for (i = 0; i < n_div; ++i)
+		if (isl_seq_first_non_zero(bmap->divi + 2 + total,
+					    n_div) != -1)
+			return isl_bool_true;
+
+	return isl_bool_false;
+}
+
+/* Return a list of affine expressions, one for each integer division
+ * in "bmap_i".  For each integer division that also appears in "bmap_j",
+ * the affine expression is set to NaN.  The number of NaNs in the list
+ * is equal to the number of integer divisions in "bmap_j".
+ * For the other integer divisions of "bmap_i", the corresponding
+ * element in the list is a purely affine expression equal to the integer
+ * division in "hull".
+ * If no such list can be constructed, then the number of elements
+ * in the returned list is smaller than the number of integer divisions
+ * in "bmap_i".
+ */
+static __isl_give isl_aff_list *set_up_substitutions(
+	__isl_keep isl_basic_map *bmap_i, __isl_keep isl_basic_map *bmap_j,
+	__isl_take isl_basic_map *hull)
+{
+	isl_size n_div_i, n_div_j, total;
+	isl_ctx *ctx;
+	isl_local_space *ls;
+	isl_basic_set *wrap_hull;
+	isl_aff *aff_nan;
+	isl_aff_list *list;
+	int i, j;
+
+	n_div_i = isl_basic_map_dim(bmap_i, isl_dim_div);
+	n_div_j = isl_basic_map_dim(bmap_j, isl_dim_div);
+	total = isl_basic_map_dim(bmap_i, isl_dim_all);
+	if (!hull || n_div_i < 0 || n_div_j < 0 || total < 0)
+		return NULL;
+
+	ctx = isl_basic_map_get_ctx(hull);
+	total -= n_div_i;
+
+	ls = isl_basic_map_get_local_space(bmap_i);
+	ls = isl_local_space_wrap(ls);
+	wrap_hull = isl_basic_map_wrap(hull);
+
+	aff_nan = isl_aff_nan_on_domain(isl_local_space_copy(ls));
+	list = isl_aff_list_alloc(ctx, n_div_i);
+
+	j = 0;
+	for (i = 0; i < n_div_i; ++i) {
+		isl_aff *aff;
+		isl_size n_div;
+
+		if (j < n_div_j &&
+		    isl_basic_map_equal_div_expr_part(bmap_i, i, bmap_j, j,
+						    0, 2 + total)) {
+			++j;
+			list = isl_aff_list_add(list, isl_aff_copy(aff_nan));
+			continue;
+		}
+		if (n_div_i - i <= n_div_j - j)
+			break;
+
+		aff = isl_local_space_get_div(ls, i);
+		aff = isl_aff_substitute_equalities(aff,
+						isl_basic_set_copy(wrap_hull));
+		aff = isl_aff_floor(aff);
+		n_div = isl_aff_dim(aff, isl_dim_div);
+		if (n_div < 0)
+			goto error;
+		if (n_div != 0) {
+			isl_aff_free(aff);
+			break;
+		}
+
+		list = isl_aff_list_add(list, aff);
+	}
+
+	isl_aff_free(aff_nan);
+	isl_local_space_free(ls);
+	isl_basic_set_free(wrap_hull);
+
+	return list;
+error:
+	isl_aff_free(aff_nan);
+	isl_local_space_free(ls);
+	isl_basic_set_free(wrap_hull);
+	isl_aff_list_free(list);
+	return NULL;
+}
+
+/* Add variables to info->bmap and info->tab corresponding to the elements
+ * in "list" that are not set to NaN.
+ * "extra_var" is the number of these elements.
+ * "dim" is the offset in the variables of "tab" where we should
+ * start considering the elements in "list".
+ * When this function returns, the total number of variables in "tab"
+ * is equal to "dim" plus the number of elements in "list".
+ *
+ * The newly added existentially quantified variables are not given
+ * an explicit representation because the corresponding div constraints
+ * do not appear in info->bmap.  These constraints are not added
+ * to info->bmap because for internal consistency, they would need to
+ * be added to info->tab as well, where they could combine with the equality
+ * that is added later to result in constraints that do not hold
+ * in the original input.
+ */
+static isl_stat add_sub_vars(struct isl_coalesce_info *info,
+	__isl_keep isl_aff_list *list, int dim, int extra_var)
+{
+	int i, j, d;
+	isl_size n;
+
+	info->bmap = isl_basic_map_cow(info->bmap);
+	info->bmap = isl_basic_map_extend(info->bmap, extra_var, 0, 0);
+	n = isl_aff_list_n_aff(list);
+	if (!info->bmap || n < 0)
+		return isl_stat_error;
+	for (i = 0; i < n; ++i) {
+		int is_nan;
+		isl_aff *aff;
+
+		aff = isl_aff_list_get_aff(list, i);
+		is_nan = isl_aff_is_nan(aff);
+		isl_aff_free(aff);
+		if (is_nan < 0)
+			return isl_stat_error;
+		if (is_nan)
+			continue;
+
+		if (isl_tab_insert_var(info->tab, dim + i) < 0)
+			return isl_stat_error;
+		d = isl_basic_map_alloc_div(info->bmap);
+		if (d < 0)
+			return isl_stat_error;
+		info->bmap = isl_basic_map_mark_div_unknown(info->bmap, d);
+		for (j = d; j > i; --j)
+			info->bmap = isl_basic_map_swap_div(info->bmap,
+							    j - 1, j);
+		if (!info->bmap)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* For each element in "list" that is not set to NaN, fix the corresponding
+ * variable in "tab" to the purely affine expression defined by the element.
+ * "dim" is the offset in the variables of "tab" where we should
+ * start considering the elements in "list".
+ *
+ * This function assumes that a sufficient number of rows and
+ * elements in the constraint array are available in the tableau.
+ */
+static isl_stat add_sub_equalities(struct isl_tab *tab,
+	__isl_keep isl_aff_list *list, int dim)
+{
+	int i;
+	isl_size n;
+	isl_ctx *ctx;
+	isl_vec *sub;
+	isl_aff *aff;
+
+	n = isl_aff_list_n_aff(list);
+	if (n < 0)
+		return isl_stat_error;
+
+	ctx = isl_tab_get_ctx(tab);
+	sub = isl_vec_alloc(ctx, 1 + dim + n);
+	if (!sub)
+		return isl_stat_error;
+	isl_seq_clr(sub->el + 1 + dim, n);
+
+	for (i = 0; i < n; ++i) {
+		aff = isl_aff_list_get_aff(list, i);
+		if (!aff)
+			goto error;
+		if (isl_aff_is_nan(aff)) {
+			isl_aff_free(aff);
+			continue;
+		}
+		isl_seq_cpy(sub->el, aff->v->el + 1, 1 + dim);
+		isl_int_neg(sub->el1 + dim + i, aff->v->el0);
+		if (isl_tab_add_eq(tab, sub->el) < 0)
+			goto error;
+		isl_int_set_si(sub->el1 + dim + i, 0);
+		isl_aff_free(aff);
+	}
+
+	isl_vec_free(sub);
+	return isl_stat_ok;
+error:
+	isl_aff_free(aff);
+	isl_vec_free(sub);
+	return isl_stat_error;
+}
+
+/* Add variables to info->tab and info->bmap corresponding to the elements
+ * in "list" that are not set to NaN.  The value of the added variable
+ * in info->tab is fixed to the purely affine expression defined by the element.
+ * "dim" is the offset in the variables of info->tab where we should
+ * start considering the elements in "list".
+ * When this function returns, the total number of variables in info->tab
+ * is equal to "dim" plus the number of elements in "list".
+ */
+static isl_stat add_subs(struct isl_coalesce_info *info,
+	__isl_keep isl_aff_list *list, int dim)
+{
+	int extra_var;
+	isl_size n;
+
+	n = isl_aff_list_n_aff(list);
+	if (n < 0)
+		return isl_stat_error;
+
+	extra_var = n - (info->tab->n_var - dim);
+
+	if (isl_tab_extend_vars(info->tab, extra_var) < 0)
+		return isl_stat_error;
+	if (isl_tab_extend_cons(info->tab, 2 * extra_var) < 0)
+		return isl_stat_error;
+	if (add_sub_vars(info, list, dim, extra_var) < 0)
+		return isl_stat_error;
+
+	return add_sub_equalities(info->tab, list, dim);
+}
+
+/* Coalesce basic map "j" into basic map "i" after adding the extra integer
+ * divisions in "i" but not in "j" to basic map "j", with values
+ * specified by "list".  The total number of elements in "list"
+ * is equal to the number of integer divisions in "i", while the number
+ * of NaN elements in the list is equal to the number of integer divisions
+ * in "j".
+ *
+ * If no coalescing can be performed, then we need to revert basic map "j"
+ * to its original state.  We do the same if basic map "i" gets dropped
+ * during the coalescing, even though this should not happen in practice
+ * since we have already checked for "j" being a subset of "i"
+ * before we reach this stage.
+ */
+static enum isl_change coalesce_with_subs(int i, int j,
+	struct isl_coalesce_info *info, __isl_keep isl_aff_list *list)
+{
+	isl_basic_map *bmap_j;
+	struct isl_tab_undo *snap;
+	isl_size dim, n_div;
+	enum isl_change change;
+
+	bmap_j = isl_basic_map_copy(infoj.bmap);
+	snap = isl_tab_snap(infoj.tab);
+
+	dim = isl_basic_map_dim(bmap_j, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap_j, isl_dim_div);
+	if (dim < 0 || n_div < 0)
+		goto error;
+	dim -= n_div;
+	if (add_subs(&infoj, list, dim) < 0)
+		goto error;
+
+	change = coalesce_local_pair(i, j, info);
+	if (change != isl_change_none && change != isl_change_drop_first) {
+		isl_basic_map_free(bmap_j);
+	} else {
+		isl_basic_map_free(infoj.bmap);
+		infoj.bmap = bmap_j;
+
+		if (isl_tab_rollback(infoj.tab, snap) < 0)
+			return isl_change_error;
+	}
+
+	return change;
+error:
+	isl_basic_map_free(bmap_j);
+	return isl_change_error;
+}
+
+/* Check if we can coalesce basic map "j" into basic map "i" after copying
+ * those extra integer divisions in "i" that can be simplified away
+ * using the extra equalities in "j".
+ * All divs are assumed to be known and not contain any nested divs.
+ *
+ * We first check if there are any extra equalities in "j" that we
+ * can exploit.  Then we check if every integer division in "i"
+ * either already appears in "j" or can be simplified using the
+ * extra equalities to a purely affine expression.
+ * If these tests succeed, then we try to coalesce the two basic maps
+ * by introducing extra dimensions in "j" corresponding to
+ * the extra integer divisions "i" fixed to the corresponding
+ * purely affine expression.
+ */
+static enum isl_change check_coalesce_into_eq(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	isl_size n_div_i, n_div_j, n;
+	isl_basic_map *hull_i, *hull_j;
+	isl_bool equal, empty;
+	isl_aff_list *list;
+	enum isl_change change;
+
+	n_div_i = isl_basic_map_dim(infoi.bmap, isl_dim_div);
+	n_div_j = isl_basic_map_dim(infoj.bmap, isl_dim_div);
+	if (n_div_i < 0 || n_div_j < 0)
+		return isl_change_error;
+	if (n_div_i <= n_div_j)
+		return isl_change_none;
+	if (infoj.bmap->n_eq == 0)
+		return isl_change_none;
+
+	hull_i = isl_basic_map_copy(infoi.bmap);
+	hull_i = isl_basic_map_plain_affine_hull(hull_i);
+	hull_j = isl_basic_map_copy(infoj.bmap);
+	hull_j = isl_basic_map_plain_affine_hull(hull_j);
+
+	hull_j = isl_basic_map_intersect(hull_j, isl_basic_map_copy(hull_i));
+	equal = isl_basic_map_plain_is_equal(hull_i, hull_j);
+	empty = isl_basic_map_plain_is_empty(hull_j);
+	isl_basic_map_free(hull_i);
+
+	if (equal < 0 || empty < 0)
+		goto error;
+	if (equal || empty) {
+		isl_basic_map_free(hull_j);
+		return isl_change_none;
+	}
+
+	list = set_up_substitutions(infoi.bmap, infoj.bmap, hull_j);
+	if (!list)
+		return isl_change_error;
+	n = isl_aff_list_n_aff(list);
+	if (n < 0)
+		change = isl_change_error;
+	else if (n < n_div_i)
+		change = isl_change_none;
+	else
+		change = coalesce_with_subs(i, j, info, list);
+
+	isl_aff_list_free(list);
+
+	return change;
+error:
+	isl_basic_map_free(hull_j);
+	return isl_change_error;
+}
+
+/* Check if we can coalesce basic maps "i" and "j" after copying
+ * those extra integer divisions in one of the basic maps that can
+ * be simplified away using the extra equalities in the other basic map.
+ * We require all divs to be known in both basic maps.
+ * Furthermore, to simplify the comparison of div expressions,
+ * we do not allow any nested integer divisions.
+ */
+static enum isl_change check_coalesce_eq(int i, int j,
+	struct isl_coalesce_info *info)
+{
+	isl_bool known, nested;
+	enum isl_change change;
+
+	known = isl_basic_map_divs_known(infoi.bmap);
+	if (known < 0 || !known)
+		return known < 0 ? isl_change_error : isl_change_none;
+	known = isl_basic_map_divs_known(infoj.bmap);
+	if (known < 0 || !known)
+		return known < 0 ? isl_change_error : isl_change_none;
+	nested = has_nested_div(infoi.bmap);
+	if (nested < 0 || nested)
+		return nested < 0 ? isl_change_error : isl_change_none;
+	nested = has_nested_div(infoj.bmap);
+	if (nested < 0 || nested)
+		return nested < 0 ? isl_change_error : isl_change_none;
+
+	change = check_coalesce_into_eq(i, j, info);
+	if (change != isl_change_none)
+		return change;
+	change = check_coalesce_into_eq(j, i, info);
+	if (change != isl_change_none)
+		return invert_change(change);
+
+	return isl_change_none;
 }
 
 /* Check if the union of the given pair of basic maps
  * can be represented by a single basic map.
- * If so, replace the pair by the single basic map and return 1.
- * Otherwise, return 0;
- *
- * We first check if the two basic maps live in the same local space.
- * If so, we do the complete check.  Otherwise, we check if one is
- * an obvious subset of the other.
+ * If so, replace the pair by the single basic map and return
+ * isl_change_drop_first, isl_change_drop_second or isl_change_fuse.
+ * Otherwise, return isl_change_none.
+ *
+ * We first check if the two basic maps live in the same local space,
+ * after aligning the divs that differ by only an integer constant.
+ * If so, we do the complete check.  Otherwise, we check if they have
+ * the same number of integer divisions and can be coalesced, if one is
+ * an obvious subset of the other or if the extra integer divisions
+ * of one basic map can be simplified away using the extra equalities
+ * of the other basic map.
+ *
+ * Note that trying to coalesce pairs of disjuncts with the same
+ * number, but different local variables may drop the explicit
+ * representation of some of these local variables.
+ * This operation is therefore not performed when
+ * the "coalesce_preserve_locals" option is set.
  */
-static int coalesce_pair(__isl_keep isl_map *map, int i, int j,
-	struct isl_tab **tabs)
+static enum isl_change coalesce_pair(int i, int j,
+	struct isl_coalesce_info *info)
 {
-	int same;
+	int preserve;
+	isl_bool same;
+	enum isl_change change;
+	isl_ctx *ctx;
 
-	same = same_divs(map->pi, map->pj);
+	if (harmonize_divs(&infoi, &infoj) < 0)
+		return isl_change_error;
+	same = same_divs(infoi.bmap, infoj.bmap);
 	if (same < 0)
-		return -1;
+		return isl_change_error;
 	if (same)
-		return coalesce_local_pair(map, i, j, tabs);
+		return coalesce_local_pair(i, j, info);
 
-	return check_coalesce_subset(map, i, j, tabs);
+	ctx = isl_basic_map_get_ctx(infoi.bmap);
+	preserve = isl_options_get_coalesce_preserve_locals(ctx);
+	if (!preserve && infoi.bmap->n_div == infoj.bmap->n_div) {
+		change = coalesce_local_pair(i, j, info);
+		if (change != isl_change_none)
+			return change;
+	}
+
+	change = coalesce_divs(i, j, info);
+	if (change != isl_change_none)
+		return change;
+
+	return check_coalesce_eq(i, j, info);
+}
+
+/* Return the maximum of "a" and "b".
+ */
+static int isl_max(int a, int b)
+{
+	return a > b ? a : b;
 }
 
-static struct isl_map *coalesce(struct isl_map *map, struct isl_tab **tabs)
+/* Pairwise coalesce the basic maps in the range start1, end1 of "info"
+ * with those in the range start2, end2, skipping basic maps
+ * that have been removed (either before or within this function).
+ *
+ * For each basic map i in the first range, we check if it can be coalesced
+ * with respect to any previously considered basic map j in the second range.
+ * If i gets dropped (because it was a subset of some j), then
+ * we can move on to the next basic map.
+ * If j gets dropped, we need to continue checking against the other
+ * previously considered basic maps.
+ * If the two basic maps got fused, then we recheck the fused basic map
+ * against the previously considered basic maps, starting at i + 1
+ * (even if start2 is greater than i + 1).
+ */
+static int coalesce_range(isl_ctx *ctx, struct isl_coalesce_info *info,
+	int start1, int end1, int start2, int end2)
 {
 	int i, j;
 
-	for (i = map->n - 2; i >= 0; --i)
-restart:
-		for (j = i + 1; j < map->n; ++j) {
-			int changed;
-			changed = coalesce_pair(map, i, j, tabs);
-			if (changed < 0)
-				goto error;
-			if (changed)
-				goto restart;
+	for (i = end1 - 1; i >= start1; --i) {
+		if (infoi.removed)
+			continue;
+		for (j = isl_max(i + 1, start2); j < end2; ++j) {
+			enum isl_change changed;
+
+			if (infoj.removed)
+				continue;
+			if (infoi.removed)
+				isl_die(ctx, isl_error_internal,
+					"basic map unexpectedly removed",
+					return -1);
+			changed = coalesce_pair(i, j, info);
+			switch (changed) {
+			case isl_change_error:
+				return -1;
+			case isl_change_none:
+			case isl_change_drop_second:
+				continue;
+			case isl_change_drop_first:
+				j = end2;
+				break;
+			case isl_change_fuse:
+				j = i;
+				break;
+			}
 		}
+	}
+
+	return 0;
+}
+
+/* Pairwise coalesce the basic maps described by the "n" elements of "info".
+ *
+ * We consider groups of basic maps that live in the same apparent
+ * affine hull and we first coalesce within such a group before we
+ * coalesce the elements in the group with elements of previously
+ * considered groups.  If a fuse happens during the second phase,
+ * then we also reconsider the elements within the group.
+ */
+static int coalesce(isl_ctx *ctx, int n, struct isl_coalesce_info *info)
+{
+	int start, end;
+
+	for (end = n; end > 0; end = start) {
+		start = end - 1;
+		while (start >= 1 &&
+		    infostart - 1.hull_hash == infostart.hull_hash)
+			start--;
+		if (coalesce_range(ctx, info, start, end, start, end) < 0)
+			return -1;
+		if (coalesce_range(ctx, info, start, end, end, n) < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
+/* Update the basic maps in "map" based on the information in "info".
+ * In particular, remove the basic maps that have been marked removed and
+ * update the others based on the information in the corresponding tableau.
+ * Since we detected implicit equalities without calling
+ * isl_basic_map_gauss, we need to do it now.
+ * Also call isl_basic_map_simplify if we may have lost the definition
+ * of one or more integer divisions.
+ * If a basic map is still equal to the one from which the corresponding "info"
+ * entry was created, then redundant constraint and
+ * implicit equality constraint detection have been performed
+ * on the corresponding tableau and the basic map can be marked as such.
+ */
+static __isl_give isl_map *update_basic_maps(__isl_take isl_map *map,
+	int n, struct isl_coalesce_info *info)
+{
+	int i;
+
+	if (!map)
+		return NULL;
+
+	for (i = n - 1; i >= 0; --i) {
+		if (infoi.removed) {
+			isl_basic_map_free(map->pi);
+			if (i != map->n - 1)
+				map->pi = map->pmap->n - 1;
+			map->n--;
+			continue;
+		}
+
+		infoi.bmap = isl_basic_map_update_from_tab(infoi.bmap,
+							infoi.tab);
+		infoi.bmap = isl_basic_map_gauss(infoi.bmap, NULL);
+		if (infoi.simplify)
+			infoi.bmap = isl_basic_map_simplify(infoi.bmap);
+		infoi.bmap = isl_basic_map_finalize(infoi.bmap);
+		if (!infoi.bmap)
+			return isl_map_free(map);
+		if (!infoi.modified) {
+			ISL_F_SET(infoi.bmap, ISL_BASIC_MAP_NO_IMPLICIT);
+			ISL_F_SET(infoi.bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+		}
+		isl_basic_map_free(map->pi);
+		map->pi = infoi.bmap;
+		infoi.bmap = NULL;
+	}
+
 	return map;
-error:
-	isl_map_free(map);
-	return NULL;
 }
 
 /* For each pair of basic maps in the map, check if the union of the two
  * can be represented by a single basic map.
  * If so, replace the pair by the single basic map and start over.
  *
+ * We factor out any (hidden) common factor from the constraint
+ * coefficients to improve the detection of adjacent constraints.
+ * Note that this function does not call isl_basic_map_gauss,
+ * but it does make sure that only a single copy of the basic map
+ * is affected.  This means that isl_basic_map_gauss may have
+ * to be called at the end of the computation (in update_basic_maps)
+ * on this single copy to ensure that
+ * the basic maps are not left in an unexpected state.
+ *
  * Since we are constructing the tableaus of the basic maps anyway,
  * we exploit them to detect implicit equalities and redundant constraints.
  * This also helps the coalescing as it can ignore the redundant constraints.
  * In order to avoid confusion, we make all implicit equalities explicit
- * in the basic maps.  We don't call isl_basic_map_gauss, though,
- * as that may affect the number of constraints.
- * This means that we have to call isl_basic_map_gauss at the end
- * of the computation to ensure that the basic maps are not left
- * in an unexpected state.
+ * in the basic maps.  If the basic map only has a single reference
+ * (this happens in particular if it was modified by
+ * isl_basic_map_reduce_coefficients), then isl_basic_map_gauss
+ * does not get called on the result.  The call to
+ * isl_basic_map_gauss in update_basic_maps resolves this as well.
+ * For each basic map, we also compute the hash of the apparent affine hull
+ * for use in coalesce.
  */
-struct isl_map *isl_map_coalesce(struct isl_map *map)
+__isl_give isl_map *isl_map_coalesce(__isl_take isl_map *map)
 {
 	int i;
 	unsigned n;
-	struct isl_tab **tabs = NULL;
+	isl_ctx *ctx;
+	struct isl_coalesce_info *info = NULL;
 
 	map = isl_map_remove_empty_parts(map);
 	if (!map)
@@ -1676,61 +4190,54 @@
 	if (map->n <= 1)
 		return map;
 
+	ctx = isl_map_get_ctx(map);
 	map = isl_map_sort_divs(map);
 	map = isl_map_cow(map);
 
 	if (!map)
 		return NULL;
 
-	tabs = isl_calloc_array(map->ctx, struct isl_tab *, map->n);
-	if (!tabs)
+	n = map->n;
+
+	info = isl_calloc_array(map->ctx, struct isl_coalesce_info, n);
+	if (!info)
 		goto error;
 
-	n = map->n;
 	for (i = 0; i < map->n; ++i) {
-		tabsi = isl_tab_from_basic_map(map->pi, 0);
-		if (!tabsi)
+		map->pi = isl_basic_map_reduce_coefficients(map->pi);
+		if (!map->pi)
 			goto error;
-		if (!ISL_F_ISSET(map->pi, ISL_BASIC_MAP_NO_IMPLICIT))
-			if (isl_tab_detect_implicit_equalities(tabsi) < 0)
+		infoi.bmap = isl_basic_map_copy(map->pi);
+		infoi.tab = isl_tab_from_basic_map(infoi.bmap, 0);
+		if (!infoi.tab)
+			goto error;
+		if (!ISL_F_ISSET(infoi.bmap, ISL_BASIC_MAP_NO_IMPLICIT))
+			if (isl_tab_detect_implicit_equalities(infoi.tab) < 0)
 				goto error;
-		map->pi = isl_tab_make_equalities_explicit(tabsi,
-								map->pi);
-		if (!map->pi)
+		infoi.bmap = isl_tab_make_equalities_explicit(infoi.tab,
+								infoi.bmap);
+		if (!infoi.bmap)
 			goto error;
-		if (!ISL_F_ISSET(map->pi, ISL_BASIC_MAP_NO_REDUNDANT))
-			if (isl_tab_detect_redundant(tabsi) < 0)
+		if (!ISL_F_ISSET(infoi.bmap, ISL_BASIC_MAP_NO_REDUNDANT))
+			if (isl_tab_detect_redundant(infoi.tab) < 0)
 				goto error;
+		if (coalesce_info_set_hull_hash(&infoi) < 0)
+			goto error;
 	}
 	for (i = map->n - 1; i >= 0; --i)
-		if (tabsi->empty)
-			drop(map, i, tabs);
-
-	map = coalesce(map, tabs);
+		if (infoi.tab->empty)
+			drop(&infoi);
 
-	if (map)
-		for (i = 0; i < map->n; ++i) {
-			map->pi = isl_basic_map_update_from_tab(map->pi,
-								    tabsi);
-			map->pi = isl_basic_map_gauss(map->pi, NULL);
-			map->pi = isl_basic_map_finalize(map->pi);
-			if (!map->pi)
-				goto error;
-			ISL_F_SET(map->pi, ISL_BASIC_MAP_NO_IMPLICIT);
-			ISL_F_SET(map->pi, ISL_BASIC_MAP_NO_REDUNDANT);
-		}
+	if (coalesce(ctx, n, info) < 0)
+		goto error;
 
-	for (i = 0; i < n; ++i)
-		isl_tab_free(tabsi);
+	map = update_basic_maps(map, n, info);
 
-	free(tabs);
+	clear_coalesce_info(n, info);
 
 	return map;
 error:
-	if (tabs)
-		for (i = 0; i < n; ++i)
-			isl_tab_free(tabsi);
-	free(tabs);
+	clear_coalesce_info(n, info);
 	isl_map_free(map);
 	return NULL;
 }
@@ -1739,7 +4246,7 @@
  * can be represented by a single basic set.
  * If so, replace the pair by the single basic set and start over.
  */
-struct isl_set *isl_set_coalesce(struct isl_set *set)
+__isl_give isl_set *isl_set_coalesce(__isl_take isl_set *set)
 {
-	return (struct isl_set *)isl_map_coalesce((struct isl_map *)set);
+	return set_from_map(isl_map_coalesce(set_to_map(set)));
 }

_service:tar_scm:isl-0.14.tar.xz/isl_config.h.in -> _service:tar_scm:isl-0.24.tar.gz/isl_config.h.in Changed

@@ -1,41 +1,11 @@
 /* isl_config.h.in.  Generated from configure.ac by autoheader.  */
 
-/* Define if HeaderSearchOptions::AddPath takes 4 arguments */
-#undef ADDPATH_TAKES_4_ARGUMENTS
-
-/* Clang installation prefix */
-#undef CLANG_PREFIX
-
-/* Define if CompilerInstance::createDiagnostics takes argc and argv */
-#undef CREATEDIAGNOSTICS_TAKES_ARG
-
-/* Define if CompilerInstance::createPreprocessor takes TranslationUnitKind */
-#undef CREATEPREPROCESSOR_TAKES_TUKIND
-
-/* Define if TargetInfo::CreateTargetInfo takes pointer */
-#undef CREATETARGETINFO_TAKES_POINTER
-
-/* Define if TargetInfo::CreateTargetInfo takes shared_ptr */
-#undef CREATETARGETINFO_TAKES_SHARED_PTR
-
-/* Define if Driver constructor takes default image name */
-#undef DRIVER_CTOR_TAKES_DEFAULTIMAGENAME
-
-/* Define to Diagnostic for older versions of clang */
-#undef DiagnosticsEngine
-
 /* most gcc compilers know a function __attribute__((__warn_unused_result__))
    */
 #undef GCC_WARN_UNUSED_RESULT
 
-/* Define if llvm/ADT/OwningPtr.h exists */
-#undef HAVE_ADT_OWNINGPTR_H
-
-/* Define if clang/Basic/DiagnosticOptions.h exists */
-#undef HAVE_BASIC_DIAGNOSTICOPTIONS_H
-
-/* Define if Driver constructor takes CXXIsProduction argument */
-#undef HAVE_CXXISPRODUCTION
+/* define if the compiler supports basic C++11 syntax */
+#undef HAVE_CXX11
 
 /* Define to 1 if you have the declaration of `ffs', and to 0 if you don't. */
 #undef HAVE_DECL_FFS
@@ -44,6 +14,34 @@
    to 0 if you don't. */
 #undef HAVE_DECL_MP_GET_MEMORY_FUNCTIONS
 
+/* Define to 1 if you have the declaration of `snprintf', and to 0 if you
+   don't. */
+#undef HAVE_DECL_SNPRINTF
+
+/* Define to 1 if you have the declaration of `strcasecmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRCASECMP
+
+/* Define to 1 if you have the declaration of `strncasecmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL_STRNCASECMP
+
+/* Define to 1 if you have the declaration of `_BitScanForward', and to 0 if
+   you don't. */
+#undef HAVE_DECL__BITSCANFORWARD
+
+/* Define to 1 if you have the declaration of `_snprintf', and to 0 if you
+   don't. */
+#undef HAVE_DECL__SNPRINTF
+
+/* Define to 1 if you have the declaration of `_stricmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL__STRICMP
+
+/* Define to 1 if you have the declaration of `_strnicmp', and to 0 if you
+   don't. */
+#undef HAVE_DECL__STRNICMP
+
 /* Define to 1 if you have the declaration of `__builtin_ffs', and to 0 if you
    don't. */
 #undef HAVE_DECL___BUILTIN_FFS
@@ -54,18 +52,12 @@
 /* Define to 1 if you have the <inttypes.h> header file. */
 #undef HAVE_INTTYPES_H
 
-/* Define if Driver constructor takes IsProduction argument */
-#undef HAVE_ISPRODUCTION
-
 /* Define to 1 if you have the `gmp' library (-lgmp). */
 #undef HAVE_LIBGMP
 
 /* Define to 1 if you have the <memory.h> header file. */
 #undef HAVE_MEMORY_H
 
-/* Define if SourceManager has a setMainFileID method */
-#undef HAVE_SETMAINFILEID
-
 /* Define to 1 if you have the <stdint.h> header file. */
 #undef HAVE_STDINT_H
 
@@ -90,12 +82,6 @@
 /* define if your compiler has __attribute__ */
 #undef HAVE___ATTRIBUTE__
 
-/* Return type of HandleTopLevelDeclReturn */
-#undef HandleTopLevelDeclContinue
-
-/* Return type of HandleTopLevelDeclReturn */
-#undef HandleTopLevelDeclReturn
-
 /* Define to the sub-directory where libtool stores uninstalled libraries. */
 #undef LT_OBJDIR
 
@@ -138,31 +124,16 @@
 /* Define to 1 if you have the ANSI C header files. */
 #undef STDC_HEADERS
 
-/* Define if Driver::BuildCompilation takes ArrayRef */
-#undef USE_ARRAYREF
-
 /* use gmp to implement isl_int */
 #undef USE_GMP_FOR_MP
 
 /* use imath to implement isl_int */
 #undef USE_IMATH_FOR_MP
 
+/* Use small integer optimization */
+#undef USE_SMALL_INT_OPT
+
 /* Version number of package */
 #undef VERSION
 
-/* Define to getParamType for newer versions of clang */
-#undef getArgType
-
-/* Define to getHostTriple for older versions of clang */
-#undef getDefaultTargetTriple
-
-/* Define to getInstantiationLineNumber for older versions of clang */
-#undef getExpansionLineNumber
-
-/* Define to getNumParams for newer versions of clang */
-#undef getNumArgs
-
-/* Define to getResultType for older versions of clang */
-#undef getReturnType
-
 #include <isl_config_post.h>

_service:tar_scm:isl-0.14.tar.xz/isl_config_post.h -> _service:tar_scm:isl-0.24.tar.gz/isl_config_post.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_constraint.c -> _service:tar_scm:isl-0.24.tar.gz/isl_constraint.c Changed

@@ -18,10 +18,12 @@
 #include <isl_local_space_private.h>
 #include <isl_val_private.h>
 #include <isl_vec_private.h>
-#include <isl/deprecated/constraint_int.h>
 
-#undef BASE
-#define BASE constraint
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+
+#undef EL_BASE
+#define EL_BASE constraint
 
 #include <isl_list_templ.c>
 
@@ -30,36 +32,16 @@
 	return c ? isl_local_space_get_ctx(c->ls) : NULL;
 }
 
-static unsigned n(struct isl_constraint *c, enum isl_dim_type type)
+static isl_size n(__isl_keep isl_constraint *c, enum isl_dim_type type)
 {
 	return isl_local_space_dim(c->ls, type);
 }
 
-static unsigned offset(struct isl_constraint *c, enum isl_dim_type type)
+static unsigned offset(__isl_keep isl_constraint *c, enum isl_dim_type type)
 {
 	return isl_local_space_offset(c->ls, type);
 }
 
-static unsigned basic_map_offset(__isl_keep isl_basic_map *bmap,
-							enum isl_dim_type type)
-{
-	return type == isl_dim_div ? 1 + isl_space_dim(bmap->dim, isl_dim_all)
-				   : 1 + isl_space_offset(bmap->dim, type);
-}
-
-static unsigned basic_set_offset(struct isl_basic_set *bset,
-							enum isl_dim_type type)
-{
-	isl_space *dim = bset->dim;
-	switch (type) {
-	case isl_dim_param:	return 1;
-	case isl_dim_in:	return 1 + dim->nparam;
-	case isl_dim_out:	return 1 + dim->nparam + dim->n_in;
-	case isl_dim_div:	return 1 + dim->nparam + dim->n_in + dim->n_out;
-	default:		return 0;
-	}
-}
-
 __isl_give isl_constraint *isl_constraint_alloc_vec(int eq,
 	__isl_take isl_local_space *ls, __isl_take isl_vec *v)
 {
@@ -87,22 +69,27 @@
 __isl_give isl_constraint *isl_constraint_alloc(int eq,
 	__isl_take isl_local_space *ls)
 {
+	isl_size dim;
 	isl_ctx *ctx;
 	isl_vec *v;
 
+	dim = isl_local_space_dim(ls, isl_dim_all);
+	if (dim < 0)
+		ls = isl_local_space_free(ls);
 	if (!ls)
 		return NULL;
 
 	ctx = isl_local_space_get_ctx(ls);
-	v = isl_vec_alloc(ctx, 1 + isl_local_space_dim(ls, isl_dim_all));
+	v = isl_vec_alloc(ctx, 1 + dim);
 	v = isl_vec_clr(v);
 	return isl_constraint_alloc_vec(eq, ls, v);
 }
 
-struct isl_constraint *isl_basic_map_constraint(struct isl_basic_map *bmap,
-	isl_int **line)
+__isl_give isl_constraint *isl_basic_map_constraint(
+	__isl_take isl_basic_map *bmap, isl_int **line)
 {
 	int eq;
+	isl_size dim;
 	isl_ctx *ctx;
 	isl_vec *v;
 	isl_local_space *ls = NULL;
@@ -115,7 +102,10 @@
 
 	ctx = isl_basic_map_get_ctx(bmap);
 	ls = isl_basic_map_get_local_space(bmap);
-	v = isl_vec_alloc(ctx, 1 + isl_local_space_dim(ls, isl_dim_all));
+	dim = isl_local_space_dim(ls, isl_dim_all);
+	if (dim < 0)
+		goto error;
+	v = isl_vec_alloc(ctx, 1 + dim);
 	if (!v)
 		goto error;
 	isl_seq_cpy(v->el, line0, v->size);
@@ -129,23 +119,25 @@
 	return NULL;
 }
 
-struct isl_constraint *isl_basic_set_constraint(struct isl_basic_set *bset,
-	isl_int **line)
+__isl_give isl_constraint *isl_basic_set_constraint(
+	__isl_take isl_basic_set *bset, isl_int **line)
 {
-	return isl_basic_map_constraint((struct isl_basic_map *)bset, line);
+	return isl_basic_map_constraint(bset_to_bmap(bset), line);
 }
 
-__isl_give isl_constraint *isl_equality_alloc(__isl_take isl_local_space *ls)
+__isl_give isl_constraint *isl_constraint_alloc_equality(
+	__isl_take isl_local_space *ls)
 {
 	return isl_constraint_alloc(1, ls);
 }
 
-__isl_give isl_constraint *isl_inequality_alloc(__isl_take isl_local_space *ls)
+__isl_give isl_constraint *isl_constraint_alloc_inequality(
+	__isl_take isl_local_space *ls)
 {
 	return isl_constraint_alloc(0, ls);
 }
 
-struct isl_constraint *isl_constraint_dup(struct isl_constraint *c)
+__isl_give isl_constraint *isl_constraint_dup(__isl_keep isl_constraint *c)
 {
 	if (!c)
 		return NULL;
@@ -154,7 +146,7 @@
 						isl_vec_copy(c->v));
 }
 
-struct isl_constraint *isl_constraint_cow(struct isl_constraint *c)
+__isl_give isl_constraint *isl_constraint_cow(__isl_take isl_constraint *c)
 {
 	if (!c)
 		return NULL;
@@ -165,7 +157,8 @@
 	return isl_constraint_dup(c);
 }
 
-struct isl_constraint *isl_constraint_copy(struct isl_constraint *constraint)
+__isl_give isl_constraint *isl_constraint_copy(
+	__isl_keep isl_constraint *constraint)
 {
 	if (!constraint)
 		return NULL;
@@ -193,10 +186,10 @@
  * number of times isl_basic_map_foreach_constraint will
  * call the callback.
  */
-int isl_basic_map_n_constraint(__isl_keep isl_basic_map *bmap)
+isl_size isl_basic_map_n_constraint(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_size_error;
 
 	return bmap->n_eq + bmap->n_ineq;
 }
@@ -205,64 +198,66 @@
  * number of times isl_basic_set_foreach_constraint will
  * call the callback.
  */
-int isl_basic_set_n_constraint(__isl_keep isl_basic_set *bset)
+isl_size isl_basic_set_n_constraint(__isl_keep isl_basic_set *bset)
 {
 	return isl_basic_map_n_constraint(bset);
 }
 
-int isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap,
-	int (*fn)(__isl_take isl_constraint *c, void *user), void *user)
+isl_stat isl_basic_map_foreach_constraint(__isl_keep isl_basic_map *bmap,
+	isl_stat (*fn)(__isl_take isl_constraint *c, void *user), void *user)
 {
 	int i;
 	struct isl_constraint *c;
 
 	if (!bmap)
-		return -1;
+		return isl_stat_error;
 
 	isl_assert(bmap->ctx, ISL_F_ISSET(bmap, ISL_BASIC_MAP_FINAL),
-			return -1);
+			return isl_stat_error);
 
 	for (i = 0; i < bmap->n_eq; ++i) {
 		c = isl_basic_map_constraint(isl_basic_map_copy(bmap),
 						&bmap->eqi);
 		if (!c)
-			return -1;
+			return isl_stat_error;
 		if (fn(c, user) < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		c = isl_basic_map_constraint(isl_basic_map_copy(bmap),
 						&bmap->ineqi);
 		if (!c)
-			return -1;
+			return isl_stat_error;
 		if (fn(c, user) < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
-int isl_basic_set_foreach_constraint(__isl_keep isl_basic_set *bset,
-	int (*fn)(__isl_take isl_constraint *c, void *user), void *user)
+isl_stat isl_basic_set_foreach_constraint(__isl_keep isl_basic_set *bset,
+	isl_stat (*fn)(__isl_take isl_constraint *c, void *user), void *user)
 {
-	return isl_basic_map_foreach_constraint((isl_basic_map *)bset, fn, user);
+	return isl_basic_map_foreach_constraint(bset_to_bmap(bset), fn, user);
 }
 
 /* Add the constraint to the list that "user" points to, if it is not
  * a div constraint.
  */
-static int collect_constraint(__isl_take isl_constraint *constraint,
+static isl_stat collect_constraint(__isl_take isl_constraint *constraint,
 	void *user)
 {
 	isl_constraint_list **list = user;
+	isl_bool is_div;
 
-	if (isl_constraint_is_div_constraint(constraint))
+	is_div = isl_constraint_is_div_constraint(constraint);
+	if (is_div < 0 || is_div)
 		isl_constraint_free(constraint);
 	else
 		*list = isl_constraint_list_add(*list, constraint);
 
-	return 0;
+	return is_div < 0 ? isl_stat_error : isl_stat_ok;
 }
 
 /* Return a list of constraints that, when combined, are equivalent
@@ -274,8 +269,8 @@
 __isl_give isl_constraint_list *isl_basic_map_get_constraint_list(
 	__isl_keep isl_basic_map *bmap)
 {
-	int n;
-	int known;
+	isl_size n;
+	isl_bool known;
 	isl_ctx *ctx;
 	isl_constraint_list *list;
 
@@ -288,6 +283,8 @@
 			"input involves unknown divs", return NULL);
 
 	n = isl_basic_map_n_constraint(bmap);
+	if (n < 0)
+		return NULL;
 	list = isl_constraint_list_alloc(ctx, n);
 	if (isl_basic_map_foreach_constraint(bmap,
 					    &collect_constraint, &list) < 0)
@@ -305,8 +302,8 @@
 	return isl_basic_map_get_constraint_list(bset);
 }
 
-int isl_constraint_is_equal(struct isl_constraint *constraint1,
-	struct isl_constraint *constraint2)
+int isl_constraint_is_equal(__isl_keep isl_constraint *constraint1,
+	__isl_keep isl_constraint *constraint2)
 {
 	int equal;
 
@@ -320,20 +317,20 @@
 	return isl_vec_is_equal(constraint1->v, constraint2->v);
 }
 
-struct isl_basic_map *isl_basic_map_add_constraint(
-	struct isl_basic_map *bmap, struct isl_constraint *constraint)
+__isl_give isl_basic_map *isl_basic_map_add_constraint(
+	__isl_take isl_basic_map *bmap, __isl_take isl_constraint *constraint)
 {
 	isl_ctx *ctx;
-	isl_space *dim;
+	isl_space *space;
 	int equal_space;
 
 	if (!bmap || !constraint)
 		goto error;
 
 	ctx = isl_constraint_get_ctx(constraint);
-	dim = isl_constraint_get_space(constraint);
-	equal_space = isl_space_is_equal(bmap->dim, dim);
-	isl_space_free(dim);
+	space = isl_constraint_get_space(constraint);
+	equal_space = isl_space_is_equal(bmap->dim, space);
+	isl_space_free(space);
 	isl_assert(ctx, equal_space, goto error);
 
 	bmap = isl_basic_map_intersect(bmap,
@@ -345,12 +342,11 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_add_constraint(
-	struct isl_basic_set *bset, struct isl_constraint *constraint)
+__isl_give isl_basic_set *isl_basic_set_add_constraint(
+	__isl_take isl_basic_set *bset, __isl_take isl_constraint *constraint)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_add_constraint((struct isl_basic_map *)bset,
-						constraint);
+	return bset_from_bmap(isl_basic_map_add_constraint(bset_to_bmap(bset),
+							    constraint));
 }
 
 __isl_give isl_map *isl_map_add_constraint(__isl_take isl_map *map,
@@ -370,6 +366,14 @@
 	return isl_map_add_constraint(set, constraint);
 }
 
+/* Return the space of "constraint".
+ */
+static __isl_keep isl_space *isl_constraint_peek_space(
+	__isl_keep isl_constraint *constraint)
+{
+	return constraint ? isl_local_space_peek_space(constraint->ls) : NULL;
+}
+
 __isl_give isl_space *isl_constraint_get_space(
 	__isl_keep isl_constraint *constraint)
 {
@@ -382,31 +386,33 @@
 	return constraint ? isl_local_space_copy(constraint->ls) : NULL;
 }
 
-int isl_constraint_dim(struct isl_constraint *constraint,
+isl_size isl_constraint_dim(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type)
 {
 	if (!constraint)
-		return -1;
+		return isl_size_error;
 	return n(constraint, type);
 }
 
-int isl_constraint_involves_dims(__isl_keep isl_constraint *constraint,
+#undef TYPE
+#define TYPE	isl_constraint
+static
+#include "check_type_range_templ.c"
+
+isl_bool isl_constraint_involves_dims(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
-	isl_ctx *ctx;
 	int *active = NULL;
-	int involves = 0;
+	isl_bool involves = isl_bool_false;
 
 	if (!constraint)
-		return -1;
+		return isl_bool_error;
 	if (n == 0)
-		return 0;
+		return isl_bool_false;
 
-	ctx = isl_constraint_get_ctx(constraint);
-	if (first + n > isl_constraint_dim(constraint, type))
-		isl_die(ctx, isl_error_invalid,
-			"range out of bounds", return -1);
+	if (isl_constraint_check_range(constraint, type, first, n) < 0)
+		return isl_bool_error;
 
 	active = isl_local_space_get_active(constraint->ls,
 					    constraint->v->el + 1);
@@ -416,7 +422,7 @@
 	first += isl_local_space_offset(constraint->ls, type) - 1;
 	for (i = 0; i < n; ++i)
 		if (activefirst + i) {
-			involves = 1;
+			involves = isl_bool_true;
 			break;
 		}
 
@@ -425,41 +431,33 @@
 	return involves;
 error:
 	free(active);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Does the given constraint represent a lower bound on the given
  * dimension?
  */
-int isl_constraint_is_lower_bound(__isl_keep isl_constraint *constraint,
+isl_bool isl_constraint_is_lower_bound(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned pos)
 {
-	if (!constraint)
-		return -1;
-
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
-			"position out of bounds", return -1);
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		return isl_bool_error;
 
 	pos += isl_local_space_offset(constraint->ls, type);
-	return isl_int_is_pos(constraint->v->elpos);
+	return isl_bool_ok(isl_int_is_pos(constraint->v->elpos));
 }
 
 /* Does the given constraint represent an upper bound on the given
  * dimension?
  */
-int isl_constraint_is_upper_bound(__isl_keep isl_constraint *constraint,
+isl_bool isl_constraint_is_upper_bound(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, unsigned pos)
 {
-	if (!constraint)
-		return -1;
-
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
-			"position out of bounds", return -1);
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		return isl_bool_error;
 
 	pos += isl_local_space_offset(constraint->ls, type);
-	return isl_int_is_neg(constraint->v->elpos);
+	return isl_bool_ok(isl_int_is_neg(constraint->v->elpos));
 }
 
 const char *isl_constraint_get_dim_name(__isl_keep isl_constraint *constraint,
@@ -469,7 +467,8 @@
 	    isl_local_space_get_dim_name(constraint->ls, type, pos) : NULL;
 }
 
-void isl_constraint_get_constant(struct isl_constraint *constraint, isl_int *v)
+void isl_constraint_get_constant(__isl_keep isl_constraint *constraint,
+	isl_int *v)
 {
 	if (!constraint)
 		return;
@@ -490,16 +489,12 @@
 	return isl_val_int_from_isl_int(ctx, constraint->v->el0);
 }
 
-void isl_constraint_get_coefficient(struct isl_constraint *constraint,
+void isl_constraint_get_coefficient(__isl_keep isl_constraint *constraint,
 	enum isl_dim_type type, int pos, isl_int *v)
 {
-	if (!constraint)
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
 		return;
 
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(constraint->v->ctx, isl_error_invalid,
-			"position out of bounds", return);
-
 	pos += isl_local_space_offset(constraint->ls, type);
 	isl_int_set(*v, constraint->v->elpos);
 }
@@ -512,14 +507,10 @@
 {
 	isl_ctx *ctx;
 
-	if (!constraint)
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
 		return NULL;
 
 	ctx = isl_constraint_get_ctx(constraint);
-	if (pos < 0 || pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(ctx, isl_error_invalid,
-			"position out of bounds", return NULL);
-
 	pos += isl_local_space_offset(constraint->ls, type);
 	return isl_val_int_from_isl_int(ctx, constraint->v->elpos);
 }
@@ -588,17 +579,8 @@
 	enum isl_dim_type type, int pos, isl_int v)
 {
 	constraint = isl_constraint_cow(constraint);
-	if (!constraint)
-		return NULL;
-
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(constraint->v->ctx, isl_error_invalid,
-			"position out of bounds",
-			return isl_constraint_free(constraint));
-
-	constraint = isl_constraint_cow(constraint);
-	if (!constraint)
-		return NULL;
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		return isl_constraint_free(constraint);
 
 	constraint->v = isl_vec_cow(constraint->v);
 	if (!constraint->v)
@@ -623,10 +605,8 @@
 	if (!isl_val_is_int(v))
 		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
 			"expecting integer value", goto error);
-
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
-			"position out of bounds", goto error);
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		goto error;
 
 	pos += isl_local_space_offset(constraint->ls, type);
 	constraint->v = isl_vec_set_element_val(constraint->v, pos, v);
@@ -643,17 +623,8 @@
 	enum isl_dim_type type, int pos, int v)
 {
 	constraint = isl_constraint_cow(constraint);
-	if (!constraint)
-		return NULL;
-
-	if (pos >= isl_local_space_dim(constraint->ls, type))
-		isl_die(constraint->v->ctx, isl_error_invalid,
-			"position out of bounds",
-			return isl_constraint_free(constraint));
-
-	constraint = isl_constraint_cow(constraint);
-	if (!constraint)
-		return NULL;
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		return isl_constraint_free(constraint);
 
 	constraint->v = isl_vec_cow(constraint->v);
 	if (!constraint->v)
@@ -665,61 +636,8 @@
 	return constraint;
 }
 
-/* Drop any constraint from "bset" that is identical to "constraint".
- * In particular, this means that the local spaces of "bset" and
- * "constraint" need to be the same.
- *
- * Since the given constraint may actually be a pointer into the bset,
- * we have to be careful not to reorder the constraints as the user
- * may be holding on to other constraints from the same bset.
- * This should be cleaned up when the internal representation of
- * isl_constraint is changed to use isl_aff.
- */
-__isl_give isl_basic_set *isl_basic_set_drop_constraint(
-	__isl_take isl_basic_set *bset, __isl_take isl_constraint *constraint)
-{
-	int i;
-	unsigned n;
-	isl_int **row;
-	unsigned total;
-	isl_local_space *ls1;
-	int equal;
-
-	if (!bset || !constraint)
-		goto error;
-
-	ls1 = isl_basic_set_get_local_space(bset);
-	equal = isl_local_space_is_equal(ls1, constraint->ls);
-	isl_local_space_free(ls1);
-	if (equal < 0)
-		goto error;
-	if (!equal) {
-		isl_constraint_free(constraint);
-		return bset;
-	}
-
-	if (isl_constraint_is_equality(constraint)) {
-		n = bset->n_eq;
-		row = bset->eq;
-	} else {
-		n = bset->n_ineq;
-		row = bset->ineq;
-	}
-
-	total = isl_constraint_dim(constraint, isl_dim_all);
-	for (i = 0; i < n; ++i)
-		if (isl_seq_eq(rowi, constraint->v->el, 1 + total))
-			isl_seq_clr(rowi, 1 + total);
-			
-	isl_constraint_free(constraint);
-	return bset;
-error:
-	isl_constraint_free(constraint);
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
-struct isl_constraint *isl_constraint_negate(struct isl_constraint *constraint)
+__isl_give isl_constraint *isl_constraint_negate(
+	__isl_take isl_constraint *constraint)
 {
 	isl_ctx *ctx;
 
@@ -739,30 +657,60 @@
 	return constraint;
 }
 
-int isl_constraint_is_equality(struct isl_constraint *constraint)
+isl_bool isl_constraint_is_equality(struct isl_constraint *constraint)
 {
 	if (!constraint)
-		return -1;
-	return constraint->eq;
+		return isl_bool_error;
+	return isl_bool_ok(constraint->eq);
 }
 
-int isl_constraint_is_div_constraint(__isl_keep isl_constraint *constraint)
+isl_bool isl_constraint_is_div_constraint(__isl_keep isl_constraint *constraint)
 {
 	int i;
-	int n_div;
+	isl_size n_div;
 
 	if (!constraint)
-		return -1;
+		return isl_bool_error;
 	if (isl_constraint_is_equality(constraint))
-		return 0;
+		return isl_bool_false;
 	n_div = isl_constraint_dim(constraint, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
 	for (i = 0; i < n_div; ++i) {
-		if (isl_local_space_is_div_constraint(constraint->ls,
-							constraint->v->el, i))
-			return 1;
+		isl_bool is_div;
+		is_div = isl_local_space_is_div_constraint(constraint->ls,
+							constraint->v->el, i);
+		if (is_div < 0 || is_div)
+			return is_div;
 	}
 
-	return 0;
+	return isl_bool_false;
+}
+
+/* Is "constraint" an equality that corresponds to integer division "div"?
+ *
+ * That is, given an integer division of the form
+ *
+ *	a = floor((f + c)/m)
+ *
+ * is the equality of the form
+ *
+ *		-f + m d + c' = 0
+ * ?
+ * Note that the constant term is not checked explicitly, but given
+ * that this is a valid equality constraint, the constant c' necessarily
+ * has a value close to -c.
+ */
+isl_bool isl_constraint_is_div_equality(__isl_keep isl_constraint *constraint,
+	unsigned div)
+{
+	isl_bool equality;
+
+	equality = isl_constraint_is_equality(constraint);
+	if (equality < 0 || !equality)
+		return equality;
+	return isl_local_space_is_div_equality(constraint->ls,
+						constraint->v->el, div);
 }
 
 /* We manually set ISL_BASIC_SET_FINAL instead of calling
@@ -777,7 +725,7 @@
 	isl_local_space *ls;
 	struct isl_basic_map *bmap;
 	isl_int *c;
-	unsigned total;
+	isl_size total;
 
 	if (!constraint)
 		return NULL;
@@ -797,7 +745,9 @@
 			goto error;
 		c = bmap->ineqk;
 	}
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		goto error;
 	isl_seq_cpy(c, constraint->v->el, 1 + total);
 	isl_constraint_free(constraint);
 	if (bmap)
@@ -809,16 +759,15 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_from_constraint(
-	struct isl_constraint *constraint)
+__isl_give isl_basic_set *isl_basic_set_from_constraint(
+	__isl_take isl_constraint *constraint)
 {
-	if (!constraint)
-		return NULL;
+	isl_space *space;
 
-	if (isl_constraint_dim(constraint, isl_dim_in) != 0)
-		isl_die(isl_constraint_get_ctx(constraint), isl_error_invalid,
-			"not a set constraint", goto error);
-	return (isl_basic_set *)isl_basic_map_from_constraint(constraint);
+	space = isl_constraint_peek_space(constraint);
+	if (isl_space_check_is_set(space) < 0)
+		goto error;
+	return bset_from_bmap(isl_basic_map_from_constraint(constraint));
 error:
 	isl_constraint_free(constraint);
 	return NULL;
@@ -829,19 +778,20 @@
  *
  * If so, and if c is not NULL, then return a copy of this equality in *c.
  */
-int isl_basic_map_has_defining_equality(
+isl_bool isl_basic_map_has_defining_equality(
 	__isl_keep isl_basic_map *bmap, enum isl_dim_type type, int pos,
 	__isl_give isl_constraint **c)
 {
 	int i;
 	unsigned offset;
-	unsigned total;
-
-	if (!bmap)
-		return -1;
-	offset = basic_map_offset(bmap, type);
-	total = isl_basic_map_total_dim(bmap);
-	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
+	isl_size total;
+
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_bool_error;
+	offset = isl_basic_map_offset(bmap, type);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	for (i = 0; i < bmap->n_eq; ++i) {
 		if (isl_int_is_zero(bmap->eqioffset + pos) ||
 		    isl_seq_first_non_zero(bmap->eqi+offset+pos+1,
@@ -850,9 +800,9 @@
 		if (c)
 			*c = isl_basic_map_constraint(isl_basic_map_copy(bmap),
 								&bmap->eqi);
-		return 1;
+		return isl_bool_true;
 	}
-	return 0;
+	return isl_bool_false;
 }
 
 /* Is the variable of "type" at position "pos" of "bset" defined
@@ -860,30 +810,31 @@
  *
  * If so, and if c is not NULL, then return a copy of this equality in *c.
  */
-int isl_basic_set_has_defining_equality(
+isl_bool isl_basic_set_has_defining_equality(
 	__isl_keep isl_basic_set *bset, enum isl_dim_type type, int pos,
 	__isl_give isl_constraint **c)
 {
-	return isl_basic_map_has_defining_equality((isl_basic_map *)bset,
+	return isl_basic_map_has_defining_equality(bset_to_bmap(bset),
 						    type, pos, c);
 }
 
-int isl_basic_set_has_defining_inequalities(
+isl_bool isl_basic_set_has_defining_inequalities(
 	struct isl_basic_set *bset, enum isl_dim_type type, int pos,
 	struct isl_constraint **lower,
 	struct isl_constraint **upper)
 {
 	int i, j;
 	unsigned offset;
-	unsigned total;
+	isl_size total;
 	isl_int m;
 	isl_int **lower_line, **upper_line;
 
-	if (!bset)
-		return -1;
-	offset = basic_set_offset(bset, type);
-	total = isl_basic_set_total_dim(bset);
-	isl_assert(bset->ctx, pos < isl_basic_set_dim(bset, type), return -1);
+	if (isl_basic_set_check_range(bset, type, pos, 1) < 0)
+		return isl_bool_error;
+	offset = isl_basic_set_offset(bset, type);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	isl_int_init(m);
 	for (i = 0; i < bset->n_ineq; ++i) {
 		if (isl_int_is_zero(bset->ineqioffset + pos))
@@ -915,13 +866,13 @@
 			*upper = isl_basic_set_constraint(
 					isl_basic_set_copy(bset), upper_line);
 			isl_int_clear(m);
-			return 1;
+			return isl_bool_true;
 		}
 	}
 	*lower = NULL;
 	*upper = NULL;
 	isl_int_clear(m);
-	return 0;
+	return isl_bool_false;
 }
 
 /* Given two constraints "a" and "b" on the variable at position "abs_pos"
@@ -939,14 +890,15 @@
 {
 	int k;
 	isl_int t;
-	unsigned total;
+	isl_size total;
 
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return isl_basic_set_free(bset);
 	k = isl_basic_set_alloc_inequality(bset);
 	if (k < 0)
 		goto error;
 
-	total = isl_basic_set_dim(bset, isl_dim_all);
-
 	isl_int_init(t);
 	isl_int_neg(t, b1 + abs_pos);
 
@@ -1026,10 +978,10 @@
 	return context;
 }
 
-static int foreach_upper_bound(__isl_keep isl_basic_set *bset,
+static isl_stat foreach_upper_bound(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned abs_pos,
 	__isl_take isl_basic_set *context, int n_upper,
-	int (*fn)(__isl_take isl_constraint *lower,
+	isl_stat (*fn)(__isl_take isl_constraint *lower,
 		  __isl_take isl_constraint *upper,
 		  __isl_take isl_basic_set *bset, void *user), void *user)
 {
@@ -1058,20 +1010,20 @@
 	isl_basic_set_free(context);
 
 	if (i < bset->n_ineq)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_constraint_free(upper);
 	isl_basic_set_free(context_i);
 	isl_basic_set_free(context);
-	return -1;
+	return isl_stat_error;
 }
 
-static int foreach_lower_bound(__isl_keep isl_basic_set *bset,
+static isl_stat foreach_lower_bound(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned abs_pos,
 	__isl_take isl_basic_set *context, int n_lower,
-	int (*fn)(__isl_take isl_constraint *lower,
+	isl_stat (*fn)(__isl_take isl_constraint *lower,
 		  __isl_take isl_constraint *upper,
 		  __isl_take isl_basic_set *bset, void *user), void *user)
 {
@@ -1100,20 +1052,20 @@
 	isl_basic_set_free(context);
 
 	if (i < bset->n_ineq)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_constraint_free(lower);
 	isl_basic_set_free(context_i);
 	isl_basic_set_free(context);
-	return -1;
+	return isl_stat_error;
 }
 
-static int foreach_bound_pair(__isl_keep isl_basic_set *bset,
+static isl_stat foreach_bound_pair(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned abs_pos,
 	__isl_take isl_basic_set *context, int n_lower, int n_upper,
-	int (*fn)(__isl_take isl_constraint *lower,
+	isl_stat (*fn)(__isl_take isl_constraint *lower,
 		  __isl_take isl_constraint *upper,
 		  __isl_take isl_basic_set *bset, void *user), void *user)
 {
@@ -1168,16 +1120,16 @@
 	isl_basic_set_free(context);
 
 	if (i < bset->n_ineq)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_constraint_free(lower);
 	isl_constraint_free(upper);
 	isl_basic_set_free(context_i);
 	isl_basic_set_free(context_j);
 	isl_basic_set_free(context);
-	return -1;
+	return isl_stat_error;
 }
 
 /* For each pair of lower and upper bounds on the variable "pos"
@@ -1196,9 +1148,9 @@
  * If not, we count the number of lower and upper bounds and
  * act accordingly.
  */
-int isl_basic_set_foreach_bound_pair(__isl_keep isl_basic_set *bset,
+isl_stat isl_basic_set_foreach_bound_pair(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos,
-	int (*fn)(__isl_take isl_constraint *lower,
+	isl_stat (*fn)(__isl_take isl_constraint *lower,
 		  __isl_take isl_constraint *upper,
 		  __isl_take isl_basic_set *bset, void *user), void *user)
 {
@@ -1208,16 +1160,17 @@
 	isl_basic_set *context = NULL;
 	unsigned abs_pos;
 	int n_lower, n_upper;
+	isl_size off;
 
-	if (!bset)
-		return -1;
-	isl_assert(bset->ctx, pos < isl_basic_set_dim(bset, type), return -1);
+	if (isl_basic_set_check_range(bset, type, pos, 1) < 0)
+		return isl_stat_error;
 	isl_assert(bset->ctx, type == isl_dim_param || type == isl_dim_set,
-		return -1);
+		return isl_stat_error);
 
-	abs_pos = pos;
-	if (type == isl_dim_set)
-		abs_pos += isl_basic_set_dim(bset, isl_dim_param);
+	off = isl_basic_set_var_offset(bset, type);
+	if (off < 0)
+		return isl_stat_error;
+	abs_pos = off + pos;
 
 	for (i = 0; i < bset->n_eq; ++i) {
 		if (isl_int_is_zero(bset->eqi1 + abs_pos))
@@ -1265,25 +1218,23 @@
 	isl_constraint_free(lower);
 	isl_constraint_free(upper);
 	isl_basic_set_free(context);
-	return -1;
+	return isl_stat_error;
 }
 
 __isl_give isl_aff *isl_constraint_get_bound(
 	__isl_keep isl_constraint *constraint, enum isl_dim_type type, int pos)
 {
+	isl_space *space;
 	isl_aff *aff;
 	isl_ctx *ctx;
 
-	if (!constraint)
+	if (isl_constraint_check_range(constraint, type, pos, 1) < 0)
+		return NULL;
+	space = isl_constraint_peek_space(constraint);
+	if (isl_space_check_is_set(space) < 0)
 		return NULL;
-	ctx = isl_constraint_get_ctx(constraint);
-	if (pos >= isl_constraint_dim(constraint, type))
-		isl_die(ctx, isl_error_invalid,
-			"index out of bounds", return NULL);
-	if (isl_constraint_dim(constraint, isl_dim_in) != 0)
-		isl_die(ctx, isl_error_invalid,
-			"not a set constraint", return NULL);
 
+	ctx = isl_constraint_get_ctx(constraint);
 	pos += offset(constraint, type);
 	if (isl_int_is_zero(constraint->v->elpos))
 		isl_die(ctx, isl_error_invalid,
@@ -1300,6 +1251,7 @@
 		isl_seq_neg(aff->v->el + 1, constraint->v->el, aff->v->size - 1);
 	isl_int_set_si(aff->v->el1 + pos, 0);
 	isl_int_abs(aff->v->el0, constraint->v->elpos);
+	aff = isl_aff_normalize(aff);
 
 	return aff;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_constraint_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_constraint_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_convex_hull.c -> _service:tar_scm:isl-0.24.tar.gz/isl_convex_hull.c Changed

@@ -23,64 +23,29 @@
 #include "isl_tab.h"
 #include <isl_sort.h>
 
-static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set);
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
 
-/* Return 1 if constraint c is redundant with respect to the constraints
- * in bmap.  If c is a lower upper bound in some variable and bmap
- * does not have a lower upper bound in that variable, then c cannot
- * be redundant and we do not need solve any lp.
- */
-int isl_basic_map_constraint_is_redundant(struct isl_basic_map **bmap,
-	isl_int *c, isl_int *opt_n, isl_int *opt_d)
-{
-	enum isl_lp_result res;
-	unsigned total;
-	int i, j;
-
-	if (!bmap)
-		return -1;
-
-	total = isl_basic_map_total_dim(*bmap);
-	for (i = 0; i < total; ++i) {
-		int sign;
-		if (isl_int_is_zero(c1+i))
-			continue;
-		sign = isl_int_sgn(c1+i);
-		for (j = 0; j < (*bmap)->n_ineq; ++j)
-			if (sign == isl_int_sgn((*bmap)->ineqj1+i))
-				break;
-		if (j == (*bmap)->n_ineq)
-			break;
-	}
-	if (i < total)
-		return 0;
-
-	res = isl_basic_map_solve_lp(*bmap, 0, c, (*bmap)->ctx->one,
-					opt_n, opt_d, NULL);
-	if (res == isl_lp_unbounded)
-		return 0;
-	if (res == isl_lp_error)
-		return -1;
-	if (res == isl_lp_empty) {
-		*bmap = isl_basic_map_set_to_empty(*bmap);
-		return 0;
-	}
-	return !isl_int_is_neg(*opt_n);
-}
-
-int isl_basic_set_constraint_is_redundant(struct isl_basic_set **bset,
-	isl_int *c, isl_int *opt_n, isl_int *opt_d)
-{
-	return isl_basic_map_constraint_is_redundant(
-			(struct isl_basic_map **)bset, c, opt_n, opt_d);
-}
+static __isl_give isl_basic_set *uset_convex_hull_wrap_bounded(
+	__isl_take isl_set *set);
 
 /* Remove redundant
  * constraints.  If the minimal value along the normal of a constraint
  * is the same if the constraint is removed, then the constraint is redundant.
  *
+ * Since some constraints may be mutually redundant, sort the constraints
+ * first such that constraints that involve existentially quantified
+ * variables are considered for removal before those that do not.
+ * The sorting is also needed for the use in map_simple_hull.
+ *
+ * Note that isl_tab_detect_implicit_equalities may also end up
+ * marking some constraints as redundant.  Make sure the constraints
+ * are preserved and undo those marking such that isl_tab_detect_redundant
+ * can consider the constraints in the sorted order.
+ *
  * Alternatively, we could have intersected the basic map with the
- * corresponding equality and the checked if the dimension was that
+ * corresponding equality and then checked if the dimension was that
  * of a facet.
  */
 __isl_give isl_basic_map *isl_basic_map_remove_redundancies(
@@ -99,13 +64,22 @@
 	if (bmap->n_ineq <= 1)
 		return bmap;
 
+	bmap = isl_basic_map_sort_constraints(bmap);
 	tab = isl_tab_from_basic_map(bmap, 0);
+	if (!tab)
+		goto error;
+	tab->preserve = 1;
 	if (isl_tab_detect_implicit_equalities(tab) < 0)
 		goto error;
+	if (isl_tab_restore_redundant(tab) < 0)
+		goto error;
+	tab->preserve = 0;
 	if (isl_tab_detect_redundant(tab) < 0)
 		goto error;
 	bmap = isl_basic_map_update_from_tab(bmap, tab);
 	isl_tab_free(tab);
+	if (!bmap)
+		return NULL;
 	ISL_F_SET(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
 	ISL_F_SET(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
 	return bmap;
@@ -118,8 +92,8 @@
 __isl_give isl_basic_set *isl_basic_set_remove_redundancies(
 	__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_remove_redundancies((struct isl_basic_map *)bset);
+	return bset_from_bmap(
+		isl_basic_map_remove_redundancies(bset_to_bmap(bset)));
 }
 
 /* Remove redundant constraints in each of the basic maps.
@@ -139,7 +113,7 @@
  * constraint c and if so, set the constant term such that the
  * resulting constraint is a bounding constraint for the set.
  */
-static int uset_is_bound(struct isl_set *set, isl_int *c, unsigned len)
+static isl_bool uset_is_bound(__isl_keep isl_set *set, isl_int *c, unsigned len)
 {
 	int first;
 	int j;
@@ -176,88 +150,15 @@
 	}
 	isl_int_clear(opt);
 	isl_int_clear(opt_denom);
-	return j >= set->n;
+	return isl_bool_ok(j >= set->n);
 error:
 	isl_int_clear(opt);
 	isl_int_clear(opt_denom);
-	return -1;
+	return isl_bool_error;
 }
 
-__isl_give isl_basic_map *isl_basic_map_set_rational(
-	__isl_take isl_basic_set *bmap)
-{
-	if (!bmap)
-		return NULL;
-
-	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
-		return bmap;
-
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
-	ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL);
-
-	return isl_basic_map_finalize(bmap);
-}
-
-__isl_give isl_basic_set *isl_basic_set_set_rational(
-	__isl_take isl_basic_set *bset)
-{
-	return isl_basic_map_set_rational(bset);
-}
-
-__isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map)
-{
-	int i;
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_set_rational(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
-}
-
-__isl_give isl_set *isl_set_set_rational(__isl_take isl_set *set)
-{
-	return isl_map_set_rational(set);
-}
-
-static struct isl_basic_set *isl_basic_set_add_equality(
-	struct isl_basic_set *bset, isl_int *c)
-{
-	int i;
-	unsigned dim;
-
-	if (!bset)
-		return NULL;
-
-	if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
-		return bset;
-
-	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
-	isl_assert(bset->ctx, bset->n_div == 0, goto error);
-	dim = isl_basic_set_n_dim(bset);
-	bset = isl_basic_set_cow(bset);
-	bset = isl_basic_set_extend(bset, 0, dim, 0, 1, 0);
-	i = isl_basic_set_alloc_equality(bset);
-	if (i < 0)
-		goto error;
-	isl_seq_cpy(bset->eqi, c, 1 + dim);
-	return bset;
-error:
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
-static struct isl_set *isl_set_add_basic_set_equality(struct isl_set *set, isl_int *c)
+static __isl_give isl_set *isl_set_add_basic_set_equality(
+	__isl_take isl_set *set, isl_int *c)
 {
 	int i;
 
@@ -265,7 +166,7 @@
 	if (!set)
 		return NULL;
 	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_add_equality(set->pi, c);
+		set->pi = isl_basic_set_add_eq(set->pi, c);
 		if (!set->pi)
 			goto error;
 	}
@@ -292,18 +193,19 @@
  *
  *			\sum_i x_{i,1} = 1
  */
-static struct isl_basic_set *wrap_constraints(struct isl_set *set)
+static __isl_give isl_basic_set *wrap_constraints(__isl_keep isl_set *set)
 {
 	struct isl_basic_set *lp;
 	unsigned n_eq;
 	unsigned n_ineq;
 	int i, j, k;
-	unsigned dim, lp_dim;
+	isl_size dim, lp_dim;
 
-	if (!set)
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
 		return NULL;
 
-	dim = 1 + isl_set_n_dim(set);
+	dim += 1;
 	n_eq = 1;
 	n_ineq = set->n;
 	for (i = 0; i < set->n; ++i) {
@@ -314,7 +216,9 @@
 	lp = isl_basic_set_set_rational(lp);
 	if (!lp)
 		return NULL;
-	lp_dim = isl_basic_set_n_dim(lp);
+	lp_dim = isl_basic_set_dim(lp, isl_dim_set);
+	if (lp_dim < 0)
+		return isl_basic_set_free(lp);
 	k = isl_basic_set_alloc_equality(lp);
 	isl_int_set_si(lp->eqk0, -1);
 	for (i = 0; i < set->n; ++i) {
@@ -411,15 +315,16 @@
 	struct isl_vec *obj;
 	enum isl_lp_result res;
 	isl_int num, den;
-	unsigned dim;
+	isl_size dim;
 
-	if (!set)
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
 		return NULL;
 	ctx = set->ctx;
 	set = isl_set_copy(set);
 	set = isl_set_set_rational(set);
 
-	dim = 1 + isl_set_n_dim(set);
+	dim += 1;
 	T = isl_mat_alloc(ctx, 3, dim);
 	if (!T)
 		goto error;
@@ -486,10 +391,12 @@
 	struct isl_set *slice = NULL;
 	struct isl_basic_set *face = NULL;
 	int i;
-	unsigned dim = isl_set_n_dim(set);
-	int is_bound;
+	isl_size dim = isl_set_dim(set, isl_dim_set);
+	isl_bool is_bound;
 	isl_mat *bounds = NULL;
 
+	if (dim < 0)
+		return NULL;
 	isl_assert(set->ctx, set->n > 0, goto error);
 	bounds = isl_mat_alloc(set->ctx, 1, 1 + dim);
 	if (!bounds)
@@ -572,16 +479,19 @@
  * After computing the facets of the facet in the z' space,
  * we convert them back to the x space through Q.
  */
-static struct isl_basic_set *compute_facet(struct isl_set *set, isl_int *c)
+static __isl_give isl_basic_set *compute_facet(__isl_keep isl_set *set,
+	isl_int *c)
 {
 	struct isl_mat *m, *U, *Q;
 	struct isl_basic_set *facet = NULL;
 	struct isl_ctx *ctx;
-	unsigned dim;
+	isl_size dim;
 
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
+		return NULL;
 	ctx = set->ctx;
 	set = isl_set_copy(set);
-	dim = isl_set_n_dim(set);
 	m = isl_mat_alloc(set->ctx, 2, 1 + dim);
 	if (!m)
 		goto error;
@@ -595,8 +505,9 @@
 	set = isl_set_preimage(set, U);
 	facet = uset_convex_hull_wrap_bounded(set);
 	facet = isl_basic_set_preimage(facet, Q);
-	if (facet)
-		isl_assert(ctx, facet->n_eq == 0, goto error);
+	if (facet && facet->n_eq != 0)
+		isl_die(ctx, isl_error_internal, "unexpected equality",
+			return isl_basic_set_free(facet));
 	return facet;
 error:
 	isl_basic_set_free(facet);
@@ -625,36 +536,34 @@
  * using the technique in section "3.1 Ridge Generation" of
  * "Extended Convex Hull" by Fukuda et al.
  */
-static struct isl_basic_set *extend(struct isl_basic_set *hull,
-	struct isl_set *set)
+static __isl_give isl_basic_set *extend(__isl_take isl_basic_set *hull,
+	__isl_keep isl_set *set)
 {
 	int i, j, f;
 	int k;
 	struct isl_basic_set *facet = NULL;
 	struct isl_basic_set *hull_facet = NULL;
-	unsigned dim;
+	isl_size dim;
 
-	if (!hull)
-		return NULL;
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0 || !hull)
+		return isl_basic_set_free(hull);
 
 	isl_assert(set->ctx, set->n > 0, goto error);
 
-	dim = isl_set_n_dim(set);
-
 	for (i = 0; i < hull->n_ineq; ++i) {
 		facet = compute_facet(set, hull->ineqi);
-		facet = isl_basic_set_add_equality(facet, hull->ineqi);
+		facet = isl_basic_set_add_eq(facet, hull->ineqi);
 		facet = isl_basic_set_gauss(facet, NULL);
 		facet = isl_basic_set_normalize_constraints(facet);
 		hull_facet = isl_basic_set_copy(hull);
-		hull_facet = isl_basic_set_add_equality(hull_facet, hull->ineqi);
+		hull_facet = isl_basic_set_add_eq(hull_facet, hull->ineqi);
 		hull_facet = isl_basic_set_gauss(hull_facet, NULL);
 		hull_facet = isl_basic_set_normalize_constraints(hull_facet);
 		if (!facet || !hull_facet)
 			goto error;
 		hull = isl_basic_set_cow(hull);
-		hull = isl_basic_set_extend_space(hull,
-			isl_space_copy(hull->dim), 0, 0, facet->n_ineq);
+		hull = isl_basic_set_extend(hull, 0, 0, facet->n_ineq);
 		if (!hull)
 			goto error;
 		for (j = 0; j < facet->n_ineq; ++j) {
@@ -688,7 +597,7 @@
  * We simply collect the lower and upper bounds of each basic set
  * and the biggest of those.
  */
-static struct isl_basic_set *convex_hull_1d(struct isl_set *set)
+static __isl_give isl_basic_set *convex_hull_1d(__isl_take isl_set *set)
 {
 	struct isl_mat *c = NULL;
 	isl_int *lower = NULL;
@@ -808,7 +717,7 @@
 	return NULL;
 }
 
-static struct isl_basic_set *convex_hull_0d(struct isl_set *set)
+static __isl_give isl_basic_set *convex_hull_0d(__isl_take isl_set *set)
 {
 	struct isl_basic_set *convex_hull;
 
@@ -832,18 +741,18 @@
  * to the two original basic sets, retaining only those corresponding
  * to the convex hull.
  */
-static struct isl_basic_set *convex_hull_pair_elim(struct isl_basic_set *bset1,
-	struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *convex_hull_pair_elim(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
 	int i, j, k;
 	struct isl_basic_set *bset2;
 	struct isl_basic_set *hull = NULL;
-	unsigned dim;
+	isl_size dim;
 
-	if (!bset1 || !bset2)
+	dim = isl_basic_set_dim(bset1, isl_dim_set);
+	if (dim < 0 || !bset2)
 		goto error;
 
-	dim = isl_basic_set_n_dim(bset1);
 	hull = isl_basic_set_alloc(bset1->ctx, 0, 2 + 3 * dim, 0,
 				1 + dim + bset1->n_eq + bset2->n_eq,
 				2 + bset1->n_ineq + bset2->n_ineq);
@@ -898,15 +807,15 @@
 
 /* Is the set bounded for each value of the parameters?
  */
-int isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset)
+isl_bool isl_basic_set_is_bounded(__isl_keep isl_basic_set *bset)
 {
 	struct isl_tab *tab;
-	int bounded;
+	isl_bool bounded;
 
 	if (!bset)
-		return -1;
+		return isl_bool_error;
 	if (isl_basic_set_plain_is_empty(bset))
-		return 1;
+		return isl_bool_true;
 
 	tab = isl_tab_from_recession_cone(bset, 1);
 	bounded = isl_tab_cone_is_bounded(tab);
@@ -917,17 +826,20 @@
 /* Is the image bounded for each value of the parameters and
  * the domain variables?
  */
-int isl_basic_map_image_is_bounded(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_image_is_bounded(__isl_keep isl_basic_map *bmap)
 {
-	unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
-	unsigned n_in = isl_basic_map_dim(bmap, isl_dim_in);
-	int bounded;
+	isl_size nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	isl_size n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	isl_bool bounded;
+
+	if (nparam < 0 || n_in < 0)
+		return isl_bool_error;
 
 	bmap = isl_basic_map_copy(bmap);
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_move_dims(bmap, isl_dim_param, nparam,
 					isl_dim_in, 0, n_in);
-	bounded = isl_basic_set_is_bounded((isl_basic_set *)bmap);
+	bounded = isl_basic_set_is_bounded(bset_from_bmap(bmap));
 	isl_basic_map_free(bmap);
 
 	return bounded;
@@ -935,19 +847,19 @@
 
 /* Is the set bounded for each value of the parameters?
  */
-int isl_set_is_bounded(__isl_keep isl_set *set)
+isl_bool isl_set_is_bounded(__isl_keep isl_set *set)
 {
 	int i;
 
 	if (!set)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < set->n; ++i) {
-		int bounded = isl_basic_set_is_bounded(set->pi);
+		isl_bool bounded = isl_basic_set_is_bounded(set->pi);
 		if (!bounded || bounded < 0)
 			return bounded;
 	}
-	return 1;
+	return isl_bool_true;
 }
 
 /* Compute the lineality space of the convex hull of bset1 and bset2.
@@ -956,17 +868,17 @@
  * with the negative of the recession cone of bset2 and then compute
  * the linear hull of the resulting cone.
  */
-static struct isl_basic_set *induced_lineality_space(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *induced_lineality_space(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
 	int i, k;
 	struct isl_basic_set *lin = NULL;
-	unsigned dim;
+	isl_size dim;
 
-	if (!bset1 || !bset2)
+	dim = isl_basic_set_dim(bset1, isl_dim_all);
+	if (dim < 0 || !bset2)
 		goto error;
 
-	dim = isl_basic_set_total_dim(bset1);
 	lin = isl_basic_set_alloc_space(isl_basic_set_get_space(bset1), 0,
 					bset1->n_eq + bset2->n_eq,
 					bset1->n_ineq + bset2->n_ineq);
@@ -1012,7 +924,7 @@
 	return NULL;
 }
 
-static struct isl_basic_set *uset_convex_hull(struct isl_set *set);
+static __isl_give isl_basic_set *uset_convex_hull(__isl_take isl_set *set);
 
 /* Given a set and a linear space "lin" of dimension n > 0,
  * project the linear space from the set, compute the convex hull
@@ -1034,15 +946,15 @@
  * we transform the hull back to the original space as A' Q_1 x >= b',
  * with Q_1 all but the last n rows of Q.
  */
-static struct isl_basic_set *modulo_lineality(struct isl_set *set,
-	struct isl_basic_set *lin)
+static __isl_give isl_basic_set *modulo_lineality(__isl_take isl_set *set,
+	__isl_take isl_basic_set *lin)
 {
-	unsigned total = isl_basic_set_total_dim(lin);
+	isl_size total = isl_basic_set_dim(lin, isl_dim_all);
 	unsigned lin_dim;
 	struct isl_basic_set *hull;
 	struct isl_mat *M, *U, *Q;
 
-	if (!set || !lin)
+	if (!set || total < 0)
 		goto error;
 	lin_dim = total - lin->n_eq;
 	M = isl_mat_sub_alloc6(set->ctx, lin->eq, 0, lin->n_eq, 1, total);
@@ -1078,22 +990,24 @@
  * The next \alpha{ij} correspond to the equalities and come in pairs.
  * The final \alpha{ij} correspond to the inequalities.
  */
-static struct isl_basic_set *valid_direction_lp(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *valid_direction_lp(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
-	isl_space *dim;
+	isl_space *space;
 	struct isl_basic_set *lp;
 	unsigned d;
 	int n;
 	int i, j, k;
+	isl_size total;
 
-	if (!bset1 || !bset2)
+	total = isl_basic_set_dim(bset1, isl_dim_all);
+	if (total < 0 || !bset2)
 		goto error;
-	d = 1 + isl_basic_set_total_dim(bset1);
+	d = 1 + total;
 	n = 2 +
 	    2 * bset1->n_eq + bset1->n_ineq + 2 * bset2->n_eq + bset2->n_ineq;
-	dim = isl_space_set_alloc(bset1->ctx, 0, n);
-	lp = isl_basic_set_alloc_space(dim, 0, d, n);
+	space = isl_space_set_alloc(bset1->ctx, 0, n);
+	lp = isl_basic_set_alloc_space(space, 0, d, n);
 	if (!lp)
 		goto error;
 	for (i = 0; i < n; ++i) {
@@ -1159,14 +1073,14 @@
  * Note that we simply pick any valid direction and make no attempt
  * to pick a "good" or even the "best" valid direction.
  */
-static struct isl_vec *valid_direction(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+static __isl_give isl_vec *valid_direction(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
 	struct isl_basic_set *lp;
 	struct isl_tab *tab;
 	struct isl_vec *sample = NULL;
 	struct isl_vec *dir;
-	unsigned d;
+	isl_size d;
 	int i;
 	int n;
 
@@ -1180,7 +1094,9 @@
 	isl_basic_set_free(lp);
 	if (!sample)
 		goto error;
-	d = isl_basic_set_total_dim(bset1);
+	d = isl_basic_set_dim(bset1, isl_dim_all);
+	if (d < 0)
+		goto error;
 	dir = isl_vec_alloc(bset1->ctx, 1 + d);
 	if (!dir)
 		goto error;
@@ -1222,18 +1138,20 @@
  * In particular, add the "positivity constraint" and then perform
  * the mapping.
  */
-static struct isl_basic_set *homogeneous_map(struct isl_basic_set *bset,
-	struct isl_mat *T)
+static __isl_give isl_basic_set *homogeneous_map(__isl_take isl_basic_set *bset,
+	__isl_take isl_mat *T)
 {
 	int k;
+	isl_size total;
 
-	if (!bset)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
 		goto error;
 	bset = isl_basic_set_extend_constraints(bset, 0, 1);
 	k = isl_basic_set_alloc_inequality(bset);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(bset->ineqk + 1, isl_basic_set_total_dim(bset));
+	isl_seq_clr(bset->ineqk + 1, total);
 	isl_int_set_si(bset->ineqk0, 1);
 	bset = isl_basic_set_preimage(bset, T);
 	return bset;
@@ -1302,8 +1220,8 @@
  *
  * The polyhedron b + A x >= 0 is then the convex hull of the input polyhedra.
  */
-static struct isl_basic_set *convex_hull_pair_pointed(
-	struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *convex_hull_pair_pointed(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
 	struct isl_ctx *ctx = NULL;
 	struct isl_vec *dir = NULL;
@@ -1314,12 +1232,12 @@
 
 	if (!bset1 || !bset2)
 		goto error;
-	ctx = bset1->ctx;
+	ctx = isl_basic_set_get_ctx(bset1);
 	dir = valid_direction(isl_basic_set_copy(bset1),
 				isl_basic_set_copy(bset2));
 	if (!dir)
 		goto error;
-	T = isl_mat_alloc(bset1->ctx, dir->size, dir->size);
+	T = isl_mat_alloc(ctx, dir->size, dir->size);
 	if (!T)
 		goto error;
 	isl_seq_cpy(T->row0, dir->block.data, dir->size);
@@ -1344,9 +1262,9 @@
 	return NULL;
 }
 
-static struct isl_basic_set *uset_convex_hull_wrap(struct isl_set *set);
-static struct isl_basic_set *modulo_affine_hull(
-	struct isl_set *set, struct isl_basic_set *affine_hull);
+static __isl_give isl_basic_set *uset_convex_hull_wrap(__isl_take isl_set *set);
+static __isl_give isl_basic_set *modulo_affine_hull(
+	__isl_take isl_set *set, __isl_take isl_basic_set *affine_hull);
 
 /* Compute the convex hull of a pair of basic sets without any parameters or
  * integer divisions.
@@ -1361,11 +1279,12 @@
  * If the convex hull of the two basic sets would have a non-trivial
  * lineality space, we first project out this lineality space.
  */
-static struct isl_basic_set *convex_hull_pair(struct isl_basic_set *bset1,
-	struct isl_basic_set *bset2)
+static __isl_give isl_basic_set *convex_hull_pair(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
 	isl_basic_set *lin, *aff;
-	int bounded1, bounded2;
+	isl_bool bounded1, bounded2;
+	isl_size total;
 
 	if (bset1->ctx->opt->convex == ISL_CONVEX_HULL_FM)
 		return convex_hull_pair_elim(bset1, bset2);
@@ -1394,12 +1313,13 @@
 				      isl_basic_set_copy(bset2));
 	if (!lin)
 		goto error;
-	if (isl_basic_set_is_universe(lin)) {
+	if (isl_basic_set_plain_is_universe(lin)) {
 		isl_basic_set_free(bset1);
 		isl_basic_set_free(bset2);
 		return lin;
 	}
-	if (lin->n_eq < isl_basic_set_total_dim(lin)) {
+	total = isl_basic_set_dim(lin, isl_dim_all);
+	if (lin->n_eq < total) {
 		struct isl_set *set;
 		set = isl_set_alloc_space(isl_basic_set_get_space(bset1), 2, 0);
 		set = isl_set_add_basic_set(set, bset1);
@@ -1407,6 +1327,8 @@
 		return modulo_lineality(set, lin);
 	}
 	isl_basic_set_free(lin);
+	if (total < 0)
+		goto error;
 
 	return convex_hull_pair_pointed(bset1, bset2);
 error:
@@ -1416,22 +1338,29 @@
 }
 
 /* Compute the lineality space of a basic set.
- * We currently do not allow the basic set to have any divs.
  * We basically just drop the constants and turn every inequality
  * into an equality.
+ * Any explicit representations of local variables are removed
+ * because they may no longer be valid representations
+ * in the lineality space.
  */
-struct isl_basic_set *isl_basic_set_lineality_space(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_lineality_space(
+	__isl_take isl_basic_set *bset)
 {
 	int i, k;
 	struct isl_basic_set *lin = NULL;
-	unsigned dim;
+	isl_size n_div, dim;
 
-	if (!bset)
-		goto error;
-	isl_assert(bset->ctx, bset->n_div == 0, goto error);
-	dim = isl_basic_set_total_dim(bset);
+	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (n_div < 0 || dim < 0)
+		return isl_basic_set_free(bset);
 
-	lin = isl_basic_set_alloc_space(isl_basic_set_get_space(bset), 0, dim, 0);
+	lin = isl_basic_set_alloc_space(isl_basic_set_get_space(bset),
+					n_div, dim, 0);
+	for (i = 0; i < n_div; ++i)
+		if (isl_basic_set_alloc_div(lin) < 0)
+			goto error;
 	if (!lin)
 		goto error;
 	for (i = 0; i < bset->n_eq; ++i) {
@@ -1463,9 +1392,10 @@
 }
 
 /* Compute the (linear) hull of the lineality spaces of the basic sets in the
- * "underlying" set "set".
+ * set "set".
  */
-static struct isl_basic_set *uset_combined_lineality_space(struct isl_set *set)
+__isl_give isl_basic_set *isl_set_combined_lineality_space(
+	__isl_take isl_set *set)
 {
 	int i;
 	struct isl_set *lin = NULL;
@@ -1473,9 +1403,9 @@
 	if (!set)
 		return NULL;
 	if (set->n == 0) {
-		isl_space *dim = isl_set_get_space(set);
+		isl_space *space = isl_set_get_space(set);
 		isl_set_free(set);
-		return isl_basic_set_empty(dim);
+		return isl_basic_set_empty(space);
 	}
 
 	lin = isl_set_alloc_space(isl_set_get_space(set), set->n, 0);
@@ -1494,44 +1424,58 @@
  * lineality space.  If any of the intermediate results has
  * a non-trivial lineality space, it is projected out.
  */
-static struct isl_basic_set *uset_convex_hull_unbounded(struct isl_set *set)
+static __isl_give isl_basic_set *uset_convex_hull_unbounded(
+	__isl_take isl_set *set)
 {
-	struct isl_basic_set *convex_hull = NULL;
+	isl_basic_set_list *list;
 
-	convex_hull = isl_set_copy_basic_set(set);
-	set = isl_set_drop_basic_set(set, convex_hull);
-	if (!set)
-		goto error;
-	while (set->n > 0) {
+	list = isl_set_get_basic_set_list(set);
+	isl_set_free(set);
+
+	while (list) {
+		isl_size n, total;
 		struct isl_basic_set *t;
-		t = isl_set_copy_basic_set(set);
-		if (!t)
-			goto error;
-		set = isl_set_drop_basic_set(set, t);
-		if (!set)
+		isl_basic_set *bset1, *bset2;
+
+		n = isl_basic_set_list_n_basic_set(list);
+		if (n < 0)
 			goto error;
-		convex_hull = convex_hull_pair(convex_hull, t);
-		if (set->n == 0)
-			break;
-		t = isl_basic_set_lineality_space(isl_basic_set_copy(convex_hull));
+		if (n < 2)
+			isl_die(isl_basic_set_list_get_ctx(list),
+				isl_error_internal,
+				"expecting at least two elements", goto error);
+		bset1 = isl_basic_set_list_get_basic_set(list, n - 1);
+		bset2 = isl_basic_set_list_get_basic_set(list, n - 2);
+		bset1 = convex_hull_pair(bset1, bset2);
+		if (n == 2) {
+			isl_basic_set_list_free(list);
+			return bset1;
+		}
+		bset1 = isl_basic_set_underlying_set(bset1);
+		list = isl_basic_set_list_drop(list, n - 2, 2);
+		list = isl_basic_set_list_add(list, bset1);
+
+		t = isl_basic_set_list_get_basic_set(list, n - 2);
+		t = isl_basic_set_lineality_space(t);
 		if (!t)
 			goto error;
-		if (isl_basic_set_is_universe(t)) {
-			isl_basic_set_free(convex_hull);
-			convex_hull = t;
-			break;
+		if (isl_basic_set_plain_is_universe(t)) {
+			isl_basic_set_list_free(list);
+			return t;
 		}
-		if (t->n_eq < isl_basic_set_total_dim(t)) {
-			set = isl_set_add_basic_set(set, convex_hull);
+		total = isl_basic_set_dim(t, isl_dim_all);
+		if (t->n_eq < total) {
+			set = isl_basic_set_list_union(list);
 			return modulo_lineality(set, t);
 		}
 		isl_basic_set_free(t);
+		if (total < 0)
+			goto error;
 	}
-	isl_set_free(set);
-	return convex_hull;
+
+	return NULL;
 error:
-	isl_set_free(set);
-	isl_basic_set_free(convex_hull);
+	isl_basic_set_list_free(list);
 	return NULL;
 }
 
@@ -1539,11 +1483,11 @@
  * facet.
  * This function assumes that the given set is bounded.
  */
-static struct isl_basic_set *initial_hull(struct isl_basic_set *hull,
-	struct isl_set *set)
+static __isl_give isl_basic_set *initial_hull(__isl_take isl_basic_set *hull,
+	__isl_keep isl_set *set)
 {
 	struct isl_mat *bounds = NULL;
-	unsigned dim;
+	isl_size dim;
 	int k;
 
 	if (!hull)
@@ -1554,7 +1498,9 @@
 	k = isl_basic_set_alloc_inequality(hull);
 	if (k < 0)
 		goto error;
-	dim = isl_set_n_dim(set);
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
+		goto error;
 	isl_assert(set->ctx, 1 + dim == bounds->n_col, goto error);
 	isl_seq_cpy(hull->ineqk, bounds->row0, bounds->n_col);
 	isl_mat_free(bounds);
@@ -1572,15 +1518,16 @@
 	int		ineq;
 };
 
-static int max_constraint_equal(const void *entry, const void *val)
+static isl_bool max_constraint_equal(const void *entry, const void *val)
 {
 	struct max_constraint *a = (struct max_constraint *)entry;
 	isl_int *b = (isl_int *)val;
 
-	return isl_seq_eq(a->c->row0 + 1, b, a->c->n_col - 1);
+	return isl_bool_ok(isl_seq_eq(a->c->row0 + 1, b, a->c->n_col - 1));
 }
 
-static void update_constraint(struct isl_ctx *ctx, struct isl_hash_table *table,
+static isl_stat update_constraint(struct isl_ctx *ctx,
+	struct isl_hash_table *table,
 	isl_int *con, unsigned len, int n, int ineq)
 {
 	struct isl_hash_table_entry *entry;
@@ -1591,30 +1538,34 @@
 	entry = isl_hash_table_find(ctx, table, c_hash, max_constraint_equal,
 			con + 1, 0);
 	if (!entry)
-		return;
+		return isl_stat_error;
+	if (entry == isl_hash_table_entry_none)
+		return isl_stat_ok;
 	c = entry->data;
 	if (c->count < n) {
 		isl_hash_table_remove(ctx, table, entry);
-		return;
+		return isl_stat_ok;
 	}
 	c->count++;
 	if (isl_int_gt(c->c->row00, con0))
-		return;
+		return isl_stat_ok;
 	if (isl_int_eq(c->c->row00, con0)) {
 		if (ineq)
 			c->ineq = ineq;
-		return;
+		return isl_stat_ok;
 	}
 	c->c = isl_mat_cow(c->c);
 	isl_int_set(c->c->row00, con0);
 	c->ineq = ineq;
+
+	return isl_stat_ok;
 }
 
-/* Check whether the constraint hash table "table" constains the constraint
+/* Check whether the constraint hash table "table" contains the constraint
  * "con".
  */
-static int has_constraint(struct isl_ctx *ctx, struct isl_hash_table *table,
-	isl_int *con, unsigned len, int n)
+static isl_bool has_constraint(struct isl_ctx *ctx,
+	struct isl_hash_table *table, isl_int *con, unsigned len, int n)
 {
 	struct isl_hash_table_entry *entry;
 	struct max_constraint *c;
@@ -1624,14 +1575,34 @@
 	entry = isl_hash_table_find(ctx, table, c_hash, max_constraint_equal,
 			con + 1, 0);
 	if (!entry)
-		return 0;
+		return isl_bool_error;
+	if (entry == isl_hash_table_entry_none)
+		return isl_bool_false;
 	c = entry->data;
 	if (c->count < n)
-		return 0;
-	return isl_int_eq(c->c->row00, con0);
+		return isl_bool_false;
+	return isl_bool_ok(isl_int_eq(c->c->row00, con0));
+}
+
+/* Are the constraints of "bset" known to be facets?
+ * If there are any equality constraints, then they are not.
+ * If there may be redundant constraints, then those
+ * redundant constraints are not facets.
+ */
+static isl_bool has_facets(__isl_keep isl_basic_set *bset)
+{
+	isl_size n_eq;
+
+	n_eq = isl_basic_set_n_equality(bset);
+	if (n_eq < 0)
+		return isl_bool_error;
+	if (n_eq != 0)
+		return isl_bool_false;
+	return ISL_F_ISSET(bset, ISL_BASIC_SET_NO_REDUNDANT);
 }
 
 /* Check for inequality constraints of a basic set without equalities
+ * or redundant constraints
  * such that the same or more stringent copies of the constraint appear
  * in all of the basic sets.  Such constraints are necessarily facet
  * constraints of the convex hull.
@@ -1641,27 +1612,34 @@
  * all other basic sets and is therefore the convex hull of set.
  * In this case we set *is_hull to 1.
  */
-static struct isl_basic_set *common_constraints(struct isl_basic_set *hull,
-	struct isl_set *set, int *is_hull)
+static __isl_give isl_basic_set *common_constraints(
+	__isl_take isl_basic_set *hull, __isl_keep isl_set *set, int *is_hull)
 {
 	int i, j, s, n;
 	int min_constraints;
 	int best;
 	struct max_constraint *constraints = NULL;
 	struct isl_hash_table *table = NULL;
-	unsigned total;
+	isl_size total;
 
 	*is_hull = 0;
 
-	for (i = 0; i < set->n; ++i)
-		if (set->pi->n_eq == 0)
+	for (i = 0; i < set->n; ++i) {
+		isl_bool facets = has_facets(set->pi);
+		if (facets < 0)
+			return isl_basic_set_free(hull);
+		if (facets)
 			break;
+	}
 	if (i >= set->n)
 		return hull;
 	min_constraints = set->pi->n_ineq;
 	best = i;
 	for (i = best + 1; i < set->n; ++i) {
-		if (set->pi->n_eq != 0)
+		isl_bool facets = has_facets(set->pi);
+		if (facets < 0)
+			return isl_basic_set_free(hull);
+		if (!facets)
 			continue;
 		if (set->pi->n_ineq >= min_constraints)
 			continue;
@@ -1676,7 +1654,9 @@
 	if (isl_hash_table_init(hull->ctx, table, min_constraints))
 		goto error;
 
-	total = isl_space_dim(set->dim, isl_dim_all);
+	total = isl_set_dim(set, isl_dim_all);
+	if (total < 0)
+		goto error;
 	for (i = 0; i < set->pbest->n_ineq; ++i) {
 		constraintsi.c = isl_mat_sub_alloc6(hull->ctx,
 			set->pbest->ineq + i, 0, 1, 0, 1 + total);
@@ -1705,14 +1685,16 @@
 			isl_int *eq = set->ps->eqi;
 			for (j = 0; j < 2; ++j) {
 				isl_seq_neg(eq, eq, 1 + total);
-				update_constraint(hull->ctx, table,
-							    eq, total, n, 0);
+				if (update_constraint(hull->ctx, table,
+						    eq, total, n, 0) < 0)
+					goto error;
 			}
 		}
 		for (i = 0; i < set->ps->n_ineq; ++i) {
 			isl_int *ineq = set->ps->ineqi;
-			update_constraint(hull->ctx, table, ineq, total, n,
-				set->ps->n_eq == 0);
+			if (update_constraint(hull->ctx, table, ineq, total, n,
+					set->ps->n_eq == 0) < 0)
+				goto error;
 		}
 		++n;
 	}
@@ -1734,8 +1716,12 @@
 		if (set->ps->n_ineq != hull->n_ineq)
 			continue;
 		for (i = 0; i < set->ps->n_ineq; ++i) {
+			isl_bool has;
 			isl_int *ineq = set->ps->ineqi;
-			if (!has_constraint(hull->ctx, table, ineq, total, n))
+			has = has_constraint(hull->ctx, table, ineq, total, n);
+			if (has < 0)
+				goto error;
+			if (!has)
 				break;
 		}
 		if (i == set->ps->n_ineq)
@@ -1762,7 +1748,8 @@
  * obvious facet constraints, if any.  If the result happens to
  * be the convex hull of "set" then *is_hull is set to 1.
  */
-static struct isl_basic_set *proto_hull(struct isl_set *set, int *is_hull)
+static __isl_give isl_basic_set *proto_hull(__isl_keep isl_set *set,
+	int *is_hull)
 {
 	struct isl_basic_set *hull;
 	unsigned n_ineq;
@@ -1780,7 +1767,7 @@
 	return common_constraints(hull, set, is_hull);
 }
 
-static struct isl_basic_set *uset_convex_hull_wrap(struct isl_set *set)
+static __isl_give isl_basic_set *uset_convex_hull_wrap(__isl_take isl_set *set)
 {
 	struct isl_basic_set *hull;
 	int is_hull;
@@ -1802,41 +1789,46 @@
  * the Fourier-Motzkin elimination based convex hull.
  * We also handle a few special cases before checking the boundedness.
  */
-static struct isl_basic_set *uset_convex_hull(struct isl_set *set)
+static __isl_give isl_basic_set *uset_convex_hull(__isl_take isl_set *set)
 {
+	isl_bool bounded;
+	isl_size dim;
 	struct isl_basic_set *convex_hull = NULL;
 	struct isl_basic_set *lin;
 
-	if (isl_set_n_dim(set) == 0)
+	dim = isl_set_dim(set, isl_dim_all);
+	if (dim < 0)
+		goto error;
+	if (dim == 0)
 		return convex_hull_0d(set);
 
 	set = isl_set_coalesce(set);
 	set = isl_set_set_rational(set);
 
 	if (!set)
-		goto error;
-	if (!set)
 		return NULL;
 	if (set->n == 1) {
 		convex_hull = isl_basic_set_copy(set->p0);
 		isl_set_free(set);
 		return convex_hull;
 	}
-	if (isl_set_n_dim(set) == 1)
+	if (dim == 1)
 		return convex_hull_1d(set);
 
-	if (isl_set_is_bounded(set) &&
-	    set->ctx->opt->convex == ISL_CONVEX_HULL_WRAP)
+	bounded = isl_set_is_bounded(set);
+	if (bounded < 0)
+		goto error;
+	if (bounded && set->ctx->opt->convex == ISL_CONVEX_HULL_WRAP)
 		return uset_convex_hull_wrap(set);
 
-	lin = uset_combined_lineality_space(isl_set_copy(set));
+	lin = isl_set_combined_lineality_space(isl_set_copy(set));
 	if (!lin)
 		goto error;
-	if (isl_basic_set_is_universe(lin)) {
+	if (isl_basic_set_plain_is_universe(lin)) {
 		isl_set_free(set);
 		return lin;
 	}
-	if (lin->n_eq < isl_basic_set_total_dim(lin))
+	if (lin->n_eq < dim)
 		return modulo_lineality(set, lin);
 	isl_basic_set_free(lin);
 
@@ -1851,14 +1843,17 @@
  * without parameters or divs and where the convex hull of set is
  * known to be full-dimensional.
  */
-static struct isl_basic_set *uset_convex_hull_wrap_bounded(struct isl_set *set)
+static __isl_give isl_basic_set *uset_convex_hull_wrap_bounded(
+	__isl_take isl_set *set)
 {
 	struct isl_basic_set *convex_hull = NULL;
+	isl_size dim;
 
-	if (!set)
+	dim = isl_set_dim(set, isl_dim_all);
+	if (dim < 0)
 		goto error;
 
-	if (isl_set_n_dim(set) == 0) {
+	if (dim == 0) {
 		convex_hull = isl_basic_set_universe(isl_space_copy(set->dim));
 		isl_set_free(set);
 		convex_hull = isl_basic_set_set_rational(convex_hull);
@@ -1875,7 +1870,7 @@
 		convex_hull = isl_basic_map_remove_redundancies(convex_hull);
 		return convex_hull;
 	}
-	if (isl_set_n_dim(set) == 1)
+	if (dim == 1)
 		return convex_hull_1d(set);
 
 	return uset_convex_hull_wrap(set);
@@ -1889,8 +1884,8 @@
  * convex hull of the transformed set and then add the equalities back
  * (after performing the inverse transformation.
  */
-static struct isl_basic_set *modulo_affine_hull(
-	struct isl_set *set, struct isl_basic_set *affine_hull)
+static __isl_give isl_basic_set *modulo_affine_hull(
+	__isl_take isl_set *set, __isl_take isl_basic_set *affine_hull)
 {
 	struct isl_mat *T;
 	struct isl_mat *T2;
@@ -1908,36 +1903,45 @@
 	convex_hull = isl_basic_set_intersect(convex_hull, affine_hull);
 	return convex_hull;
 error:
+	isl_mat_free(T);
+	isl_mat_free(T2);
 	isl_basic_set_free(affine_hull);
 	isl_set_free(set);
 	return NULL;
 }
 
+/* Return an empty basic map living in the same space as "map".
+ */
+static __isl_give isl_basic_map *replace_map_by_empty_basic_map(
+	__isl_take isl_map *map)
+{
+	isl_space *space;
+
+	space = isl_map_get_space(map);
+	isl_map_free(map);
+	return isl_basic_map_empty(space);
+}
+
 /* Compute the convex hull of a map.
  *
  * The implementation was inspired by "Extended Convex Hull" by Fukuda et al.,
  * specifically, the wrapping of facets to obtain new facets.
  */
-struct isl_basic_map *isl_map_convex_hull(struct isl_map *map)
+__isl_give isl_basic_map *isl_map_convex_hull(__isl_take isl_map *map)
 {
 	struct isl_basic_set *bset;
 	struct isl_basic_map *model = NULL;
 	struct isl_basic_set *affine_hull = NULL;
 	struct isl_basic_map *convex_hull = NULL;
 	struct isl_set *set = NULL;
-	struct isl_ctx *ctx;
 
 	map = isl_map_detect_equalities(map);
-	map = isl_map_align_divs(map);
+	map = isl_map_align_divs_internal(map);
 	if (!map)
 		goto error;
 
-	ctx = map->ctx;
-	if (map->n == 0) {
-		convex_hull = isl_basic_map_empty_like_map(map);
-		isl_map_free(map);
-		return convex_hull;
-	}
+	if (map->n == 0)
+		return replace_map_by_empty_basic_map(map);
 
 	model = isl_basic_map_copy(map->p0);
 	set = isl_map_underlying_set(map);
@@ -1968,10 +1972,9 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_set_convex_hull(struct isl_set *set)
+__isl_give isl_basic_set *isl_set_convex_hull(__isl_take isl_set *set)
 {
-	return (struct isl_basic_set *)
-		isl_map_convex_hull((struct isl_map *)set);
+	return bset_from_bmap(isl_map_convex_hull(set_to_map(set)));
 }
 
 __isl_give isl_basic_map *isl_map_polyhedral_hull(__isl_take isl_map *map)
@@ -1984,7 +1987,7 @@
 
 __isl_give isl_basic_set *isl_set_polyhedral_hull(__isl_take isl_set *set)
 {
-	return (isl_basic_set *)isl_map_polyhedral_hull((isl_map *)set);
+	return bset_from_bmap(isl_map_polyhedral_hull(set_to_map(set)));
 }
 
 struct sh_data_entry {
@@ -2027,13 +2030,13 @@
 	isl_int		*p;
 };
 
-static int has_ineq(const void *entry, const void *val)
+static isl_bool has_ineq(const void *entry, const void *val)
 {
 	isl_int *row = (isl_int *)entry;
 	struct ineq_cmp_data *v = (struct ineq_cmp_data *)val;
 
-	return isl_seq_eq(row + 1, v->p + 1, v->len) ||
-	       isl_seq_is_neg(row + 1, v->p + 1, v->len);
+	return isl_bool_ok(isl_seq_eq(row + 1, v->p + 1, v->len) ||
+			   isl_seq_is_neg(row + 1, v->p + 1, v->len));
 }
 
 static int hash_ineq(struct isl_ctx *ctx, struct isl_hash_table *table,
@@ -2057,27 +2060,29 @@
  * Equalities are added as two inequalities.
  * The value in the hash table is a pointer to the (in)equality of "bset".
  */
-static int hash_basic_set(struct isl_hash_table *table,
-				struct isl_basic_set *bset)
+static isl_stat hash_basic_set(struct isl_hash_table *table,
+	__isl_keep isl_basic_set *bset)
 {
 	int i, j;
-	unsigned dim = isl_basic_set_total_dim(bset);
+	isl_size dim = isl_basic_set_dim(bset, isl_dim_all);
 
+	if (dim < 0)
+		return isl_stat_error;
 	for (i = 0; i < bset->n_eq; ++i) {
 		for (j = 0; j < 2; ++j) {
 			isl_seq_neg(bset->eqi, bset->eqi, 1 + dim);
 			if (hash_ineq(bset->ctx, table, bset->eqi, dim) < 0)
-				return -1;
+				return isl_stat_error;
 		}
 	}
 	for (i = 0; i < bset->n_ineq; ++i) {
 		if (hash_ineq(bset->ctx, table, bset->ineqi, dim) < 0)
-			return -1;
+			return isl_stat_error;
 	}
-	return 0;
+	return isl_stat_ok;
 }
 
-static struct sh_data *sh_data_alloc(struct isl_set *set, unsigned n_ineq)
+static struct sh_data *sh_data_alloc(__isl_keep isl_set *set, unsigned n_ineq)
 {
 	struct sh_data *data;
 	int i;
@@ -2116,7 +2121,7 @@
  *	  0 if "ineq" may attain arbitrarily small values on basic set "j"
  *	 -1 if some error occurred
  */
-static int is_bound(struct sh_data *data, struct isl_set *set, int j,
+static int is_bound(struct sh_data *data, __isl_keep isl_set *set, int j,
 	isl_int *ineq, int shift)
 {
 	enum isl_lp_result res;
@@ -2145,6 +2150,52 @@
 	       res == isl_lp_unbounded ? 0 : -1;
 }
 
+/* Set the constant term of "ineq" to the maximum of those of the constraints
+ * in the basic sets of "set" following "i" that are parallel to "ineq".
+ * That is, if any of the basic sets of "set" following "i" have a more
+ * relaxed copy of "ineq", then replace "ineq" by the most relaxed copy.
+ * "c_hash" is the hash value of the linear part of "ineq".
+ * "v" has been set up for use by has_ineq.
+ *
+ * Note that the two inequality constraints corresponding to an equality are
+ * represented by the same inequality constraint in data->pj.table
+ * (but with different hash values).  This means the constraint (or at
+ * least its constant term) may need to be temporarily negated to get
+ * the actually hashed constraint.
+ */
+static isl_stat set_max_constant_term(struct sh_data *data,
+	__isl_keep isl_set *set,
+	int i, isl_int *ineq, uint32_t c_hash, struct ineq_cmp_data *v)
+{
+	int j;
+	isl_ctx *ctx;
+	struct isl_hash_table_entry *entry;
+
+	ctx = isl_set_get_ctx(set);
+	for (j = i + 1; j < set->n; ++j) {
+		int neg;
+		isl_int *ineq_j;
+
+		entry = isl_hash_table_find(ctx, data->pj.table,
+						c_hash, &has_ineq, v, 0);
+		if (!entry)
+			return isl_stat_error;
+		if (entry == isl_hash_table_entry_none)
+			continue;
+
+		ineq_j = entry->data;
+		neg = isl_seq_is_neg(ineq_j + 1, ineq + 1, v->len);
+		if (neg)
+			isl_int_neg(ineq_j0, ineq_j0);
+		if (isl_int_gt(ineq_j0, ineq0))
+			isl_int_set(ineq0, ineq_j0);
+		if (neg)
+			isl_int_neg(ineq_j0, ineq_j0);
+	}
+
+	return isl_stat_ok;
+}
+
 /* Check if inequality "ineq" from basic set "i" is or can be relaxed to
  * become a bound on the whole set.  If so, add the (relaxed) inequality
  * to "hull".  Relaxation is only allowed if "shift" is set.
@@ -2155,38 +2206,48 @@
  * of the inequality.  If so, then we have already considered this
  * inequality and we are done.
  * Otherwise, for each basic set other than "i", we check if the inequality
- * is a bound on the basic set.
+ * is a bound on the basic set, but first replace the constant term
+ * by the maximal value of any translate of the inequality in any
+ * of the following basic sets.
  * For previous basic sets, we know that they do not contain a translate
  * of the inequality, so we directly call is_bound.
  * For following basic sets, we first check if a translate of the
- * inequality appears in its description and if so directly update
- * the inequality accordingly.
+ * inequality appears in its description.  If so, the constant term
+ * of the inequality has already been updated with respect to this
+ * translate and the inequality is therefore known to be a bound
+ * of this basic set.
  */
-static struct isl_basic_set *add_bound(struct isl_basic_set *hull,
-	struct sh_data *data, struct isl_set *set, int i, isl_int *ineq,
+static __isl_give isl_basic_set *add_bound(__isl_take isl_basic_set *hull,
+	struct sh_data *data, __isl_keep isl_set *set, int i, isl_int *ineq,
 	int shift)
 {
 	uint32_t c_hash;
 	struct ineq_cmp_data v;
 	struct isl_hash_table_entry *entry;
 	int j, k;
+	isl_size total;
 
-	if (!hull)
-		return NULL;
+	total = isl_basic_set_dim(hull, isl_dim_all);
+	if (total < 0)
+		return isl_basic_set_free(hull);
 
-	v.len = isl_basic_set_total_dim(hull);
+	v.len = total;
 	v.p = ineq;
 	c_hash = isl_seq_get_hash(ineq + 1, v.len);
 
 	entry = isl_hash_table_find(hull->ctx, data->hull_table, c_hash,
 					has_ineq, &v, 0);
-	if (entry)
+	if (!entry)
+		return isl_basic_set_free(hull);
+	if (entry != isl_hash_table_entry_none)
 		return hull;
 
 	for (j = 0; j < i; ++j) {
 		entry = isl_hash_table_find(hull->ctx, data->pj.table,
 						c_hash, has_ineq, &v, 0);
-		if (entry)
+		if (!entry)
+			return isl_basic_set_free(hull);
+		if (entry != isl_hash_table_entry_none)
 			break;
 	}
 	if (j < i)
@@ -2197,6 +2258,8 @@
 		goto error;
 	isl_seq_cpy(hull->ineqk, ineq, 1 + v.len);
 
+	if (set_max_constant_term(data, set, i, hull->ineqk, c_hash, &v) < 0)
+		goto error;
 	for (j = 0; j < i; ++j) {
 		int bound;
 		bound = is_bound(data, set, j, hull->ineqk, shift);
@@ -2205,38 +2268,25 @@
 		if (!bound)
 			break;
 	}
-	if (j < i) {
-		isl_basic_set_free_inequality(hull, 1);
-		return hull;
-	}
+	if (j < i)
+		return isl_basic_set_free_inequality(hull, 1);
 
 	for (j = i + 1; j < set->n; ++j) {
-		int bound, neg;
-		isl_int *ineq_j;
+		int bound;
 		entry = isl_hash_table_find(hull->ctx, data->pj.table,
 						c_hash, has_ineq, &v, 0);
-		if (entry) {
-			ineq_j = entry->data;
-			neg = isl_seq_is_neg(ineq_j + 1,
-					     hull->ineqk + 1, v.len);
-			if (neg)
-				isl_int_neg(ineq_j0, ineq_j0);
-			if (isl_int_gt(ineq_j0, hull->ineqk0))
-				isl_int_set(hull->ineqk0, ineq_j0);
-			if (neg)
-				isl_int_neg(ineq_j0, ineq_j0);
+		if (!entry)
+			return isl_basic_set_free(hull);
+		if (entry != isl_hash_table_entry_none)
 			continue;
-		}
 		bound = is_bound(data, set, j, hull->ineqk, shift);
 		if (bound < 0)
 			goto error;
 		if (!bound)
 			break;
 	}
-	if (j < set->n) {
-		isl_basic_set_free_inequality(hull, 1);
-		return hull;
-	}
+	if (j < set->n)
+		return isl_basic_set_free_inequality(hull, 1);
 
 	entry = isl_hash_table_find(hull->ctx, data->hull_table, c_hash,
 					has_ineq, &v, 1);
@@ -2254,11 +2304,14 @@
  * become a bound on the whole set.  If so, add the (relaxed) inequality
  * to "hull".  Relaxation is only allowed if "shift" is set.
  */
-static struct isl_basic_set *add_bounds(struct isl_basic_set *bset,
-	struct sh_data *data, struct isl_set *set, int i, int shift)
+static __isl_give isl_basic_set *add_bounds(__isl_take isl_basic_set *bset,
+	struct sh_data *data, __isl_keep isl_set *set, int i, int shift)
 {
 	int j, k;
-	unsigned dim = isl_basic_set_total_dim(bset);
+	isl_size dim = isl_basic_set_dim(bset, isl_dim_all);
+
+	if (dim < 0)
+		return isl_basic_set_free(bset);
 
 	for (j = 0; j < set->pi->n_eq; ++j) {
 		for (k = 0; k < 2; ++k) {
@@ -2318,7 +2371,56 @@
 
 /* Compute a superset of the convex hull of map that is described
  * by only (translates of) the constraints in the constituents of map.
+ * Handle trivial cases where map is NULL or contains at most one disjunct.
+ */
+static __isl_give isl_basic_map *map_simple_hull_trivial(
+	__isl_take isl_map *map)
+{
+	isl_basic_map *hull;
+
+	if (!map)
+		return NULL;
+	if (map->n == 0)
+		return replace_map_by_empty_basic_map(map);
+
+	hull = isl_basic_map_copy(map->p0);
+	isl_map_free(map);
+	return hull;
+}
+
+/* Return a copy of the simple hull cached inside "map".
+ * "shift" determines whether to return the cached unshifted or shifted
+ * simple hull.
+ */
+static __isl_give isl_basic_map *cached_simple_hull(__isl_take isl_map *map,
+	int shift)
+{
+	isl_basic_map *hull;
+
+	hull = isl_basic_map_copy(map->cached_simple_hullshift);
+	isl_map_free(map);
+
+	return hull;
+}
+
+/* Compute a superset of the convex hull of map that is described
+ * by only (translates of) the constraints in the constituents of map.
  * Translation is only allowed if "shift" is set.
+ *
+ * The constraints are sorted while removing redundant constraints
+ * in order to indicate a preference of which constraints should
+ * be preserved.  In particular, pairs of constraints that are
+ * sorted together are preferred to either both be preserved
+ * or both be removed.  The sorting is performed inside
+ * isl_basic_map_remove_redundancies.
+ *
+ * The result of the computation is stored in map->cached_simple_hullshift
+ * such that it can be reused in subsequent calls.  The cache is cleared
+ * whenever the map is modified (in isl_map_cow).
+ * Note that the results need to be stored in the input map for there
+ * to be any chance that they may get reused.  In particular, they
+ * are stored in a copy of the input map that is saved before
+ * the integer division alignment.
  */
 static __isl_give isl_basic_map *map_simple_hull(__isl_take isl_map *map,
 	int shift)
@@ -2328,23 +2430,20 @@
 	struct isl_basic_map *hull;
 	struct isl_basic_map *affine_hull;
 	struct isl_basic_set *bset = NULL;
+	isl_map *input;
 
-	if (!map)
-		return NULL;
-	if (map->n == 0) {
-		hull = isl_basic_map_empty_like_map(map);
-		isl_map_free(map);
-		return hull;
-	}
-	if (map->n == 1) {
-		hull = isl_basic_map_copy(map->p0);
-		isl_map_free(map);
-		return hull;
-	}
+	if (!map || map->n <= 1)
+		return map_simple_hull_trivial(map);
+
+	if (map->cached_simple_hullshift)
+		return cached_simple_hull(map, shift);
 
 	map = isl_map_detect_equalities(map);
+	if (!map || map->n <= 1)
+		return map_simple_hull_trivial(map);
 	affine_hull = isl_map_affine_hull(isl_map_copy(map));
-	map = isl_map_align_divs(map);
+	input = isl_map_copy(map);
+	map = isl_map_align_divs_internal(map);
 	model = map ? isl_basic_map_copy(map->p0) : NULL;
 
 	set = isl_map_underlying_set(map);
@@ -2356,12 +2455,15 @@
 	hull = isl_basic_map_intersect(hull, affine_hull);
 	hull = isl_basic_map_remove_redundancies(hull);
 
-	if (!hull)
-		return NULL;
-	ISL_F_SET(hull, ISL_BASIC_MAP_NO_IMPLICIT);
-	ISL_F_SET(hull, ISL_BASIC_MAP_ALL_EQUALITIES);
+	if (hull) {
+		ISL_F_SET(hull, ISL_BASIC_MAP_NO_IMPLICIT);
+		ISL_F_SET(hull, ISL_BASIC_MAP_ALL_EQUALITIES);
+	}
 
 	hull = isl_basic_map_finalize(hull);
+	if (input)
+		input->cached_simple_hullshift = isl_basic_map_copy(hull);
+	isl_map_free(input);
 
 	return hull;
 }
@@ -2374,10 +2476,9 @@
 	return map_simple_hull(map, 1);
 }
 
-struct isl_basic_set *isl_set_simple_hull(struct isl_set *set)
+__isl_give isl_basic_set *isl_set_simple_hull(__isl_take isl_set *set)
 {
-	return (struct isl_basic_set *)
-		isl_map_simple_hull((struct isl_map *)set);
+	return bset_from_bmap(isl_map_simple_hull(set_to_map(set)));
 }
 
 /* Compute a superset of the convex hull of map that is described
@@ -2395,6 +2496,192 @@
 	return isl_map_unshifted_simple_hull(set);
 }
 
+/* Drop all inequalities from "bmap1" that do not also appear in "bmap2".
+ * A constraint that appears with different constant terms
+ * in "bmap1" and "bmap2" is also kept, with the least restrictive
+ * (i.e., greatest) constant term.
+ * "bmap1" and "bmap2" are assumed to have the same (known)
+ * integer divisions.
+ * The constraints of both "bmap1" and "bmap2" are assumed
+ * to have been sorted using isl_basic_map_sort_constraints.
+ *
+ * Run through the inequality constraints of "bmap1" and "bmap2"
+ * in sorted order.
+ * Each constraint of "bmap1" without a matching constraint in "bmap2"
+ * is removed.
+ * If a match is found, the constraint is kept.  If needed, the constant
+ * term of the constraint is adjusted.
+ */
+static __isl_give isl_basic_map *select_shared_inequalities(
+	__isl_take isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
+{
+	int i1, i2;
+
+	bmap1 = isl_basic_map_cow(bmap1);
+	if (!bmap1 || !bmap2)
+		return isl_basic_map_free(bmap1);
+
+	i1 = bmap1->n_ineq - 1;
+	i2 = bmap2->n_ineq - 1;
+	while (bmap1 && i1 >= 0 && i2 >= 0) {
+		int cmp;
+
+		cmp = isl_basic_map_constraint_cmp(bmap1, bmap1->ineqi1,
+							bmap2->ineqi2);
+		if (cmp < 0) {
+			--i2;
+			continue;
+		}
+		if (cmp > 0) {
+			if (isl_basic_map_drop_inequality(bmap1, i1) < 0)
+				bmap1 = isl_basic_map_free(bmap1);
+			--i1;
+			continue;
+		}
+		if (isl_int_lt(bmap1->ineqi10, bmap2->ineqi20))
+			isl_int_set(bmap1->ineqi10, bmap2->ineqi20);
+		--i1;
+		--i2;
+	}
+	for (; i1 >= 0; --i1)
+		if (isl_basic_map_drop_inequality(bmap1, i1) < 0)
+			bmap1 = isl_basic_map_free(bmap1);
+
+	return bmap1;
+}
+
+/* Drop all equalities from "bmap1" that do not also appear in "bmap2".
+ * "bmap1" and "bmap2" are assumed to have the same (known)
+ * integer divisions.
+ *
+ * Run through the equality constraints of "bmap1" and "bmap2".
+ * Each constraint of "bmap1" without a matching constraint in "bmap2"
+ * is removed.
+ */
+static __isl_give isl_basic_map *select_shared_equalities(
+	__isl_take isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
+{
+	int i1, i2;
+	isl_size total;
+
+	bmap1 = isl_basic_map_cow(bmap1);
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	if (total < 0 || !bmap2)
+		return isl_basic_map_free(bmap1);
+
+	i1 = bmap1->n_eq - 1;
+	i2 = bmap2->n_eq - 1;
+	while (bmap1 && i1 >= 0 && i2 >= 0) {
+		int last1, last2;
+
+		last1 = isl_seq_last_non_zero(bmap1->eqi1 + 1, total);
+		last2 = isl_seq_last_non_zero(bmap2->eqi2 + 1, total);
+		if (last1 > last2) {
+			--i2;
+			continue;
+		}
+		if (last1 < last2) {
+			if (isl_basic_map_drop_equality(bmap1, i1) < 0)
+				bmap1 = isl_basic_map_free(bmap1);
+			--i1;
+			continue;
+		}
+		if (!isl_seq_eq(bmap1->eqi1, bmap2->eqi2, 1 + total)) {
+			if (isl_basic_map_drop_equality(bmap1, i1) < 0)
+				bmap1 = isl_basic_map_free(bmap1);
+		}
+		--i1;
+		--i2;
+	}
+	for (; i1 >= 0; --i1)
+		if (isl_basic_map_drop_equality(bmap1, i1) < 0)
+			bmap1 = isl_basic_map_free(bmap1);
+
+	return bmap1;
+}
+
+/* Compute a superset of "bmap1" and "bmap2" that is described
+ * by only the constraints that appear in both "bmap1" and "bmap2".
+ *
+ * First drop constraints that involve unknown integer divisions
+ * since it is not trivial to check whether two such integer divisions
+ * in different basic maps are the same.
+ * Then align the remaining (known) divs and sort the constraints.
+ * Finally drop all inequalities and equalities from "bmap1" that
+ * do not also appear in "bmap2".
+ */
+__isl_give isl_basic_map *isl_basic_map_plain_unshifted_simple_hull(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
+{
+	if (isl_basic_map_check_equal_space(bmap1, bmap2) < 0)
+		goto error;
+
+	bmap1 = isl_basic_map_drop_constraints_involving_unknown_divs(bmap1);
+	bmap2 = isl_basic_map_drop_constraints_involving_unknown_divs(bmap2);
+	bmap1 = isl_basic_map_order_divs(bmap1);
+	bmap2 = isl_basic_map_align_divs(bmap2, bmap1);
+	bmap1 = isl_basic_map_align_divs(bmap1, bmap2);
+	bmap1 = isl_basic_map_sort_constraints(bmap1);
+	bmap2 = isl_basic_map_sort_constraints(bmap2);
+
+	bmap1 = select_shared_inequalities(bmap1, bmap2);
+	bmap1 = select_shared_equalities(bmap1, bmap2);
+
+	isl_basic_map_free(bmap2);
+	bmap1 = isl_basic_map_finalize(bmap1);
+	return bmap1;
+error:
+	isl_basic_map_free(bmap1);
+	isl_basic_map_free(bmap2);
+	return NULL;
+}
+
+/* Compute a superset of the convex hull of "map" that is described
+ * by only the constraints in the constituents of "map".
+ * In particular, the result is composed of constraints that appear
+ * in each of the basic maps of "map"
+ *
+ * Constraints that involve unknown integer divisions are dropped
+ * since it is not trivial to check whether two such integer divisions
+ * in different basic maps are the same.
+ *
+ * The hull is initialized from the first basic map and then
+ * updated with respect to the other basic maps in turn.
+ */
+__isl_give isl_basic_map *isl_map_plain_unshifted_simple_hull(
+	__isl_take isl_map *map)
+{
+	int i;
+	isl_basic_map *hull;
+
+	if (!map)
+		return NULL;
+	if (map->n <= 1)
+		return map_simple_hull_trivial(map);
+	map = isl_map_drop_constraints_involving_unknown_divs(map);
+	hull = isl_basic_map_copy(map->p0);
+	for (i = 1; i < map->n; ++i) {
+		isl_basic_map *bmap_i;
+
+		bmap_i = isl_basic_map_copy(map->pi);
+		hull = isl_basic_map_plain_unshifted_simple_hull(hull, bmap_i);
+	}
+
+	isl_map_free(map);
+	return hull;
+}
+
+/* Compute a superset of the convex hull of "set" that is described
+ * by only the constraints in the constituents of "set".
+ * In particular, the result is composed of constraints that appear
+ * in each of the basic sets of "set"
+ */
+__isl_give isl_basic_set *isl_set_plain_unshifted_simple_hull(
+	__isl_take isl_set *set)
+{
+	return isl_map_plain_unshifted_simple_hull(set);
+}
+
 /* Check if "ineq" is a bound on "set" and, if so, add it to "hull".
  *
  * For each basic set in "set", we first check if the basic set
@@ -2412,11 +2699,13 @@
 	isl_ctx *ctx;
 	uint32_t c_hash;
 	struct ineq_cmp_data v;
+	isl_size total;
 
-	if (!hull || !set)
+	total = isl_basic_set_dim(hull, isl_dim_all);
+	if (total < 0 || !set)
 		return isl_basic_set_free(hull);
 
-	v.len = isl_basic_set_total_dim(hull);
+	v.len = total;
 	v.p = ineq;
 	c_hash = isl_seq_get_hash(ineq + 1, v.len);
 
@@ -2427,7 +2716,9 @@
 
 		entry = isl_hash_table_find(ctx, data->pi.table,
 						c_hash, &has_ineq, &v, 0);
-		if (entry) {
+		if (!entry)
+			return isl_basic_set_free(hull);
+		if (entry != isl_hash_table_entry_none) {
 			isl_int *ineq_i = entry->data;
 			int neg, more_relaxed;
 
@@ -2484,7 +2775,7 @@
 	int last_added = 0;
 	struct sh_data *data = NULL;
 	isl_basic_set *hull = NULL;
-	unsigned dim;
+	isl_size dim;
 
 	hull = isl_basic_set_alloc_space(isl_set_get_space(set), 0, 0, n_ineq);
 	if (!hull)
@@ -2495,6 +2786,8 @@
 		goto error;
 
 	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
+		goto error;
 	for (i = 0; i < n_ineq; ++i) {
 		int hull_n_ineq = hull->n_ineq;
 		int parallel;
@@ -2530,14 +2823,15 @@
 static __isl_give isl_mat *collect_inequalities(__isl_take isl_mat *mat,
 	__isl_keep isl_basic_set_list *list, isl_int **ineq)
 {
-	int i, j, n, n_eq, n_ineq;
+	int i, j, n_eq, n_ineq;
+	isl_size n;
 
-	if (!mat)
-		return NULL;
+	n = isl_basic_set_list_n_basic_set(list);
+	if (!mat || n < 0)
+		return isl_mat_free(mat);
 
 	n_eq = 0;
 	n_ineq = 0;
-	n = isl_basic_set_list_n_basic_set(list);
 	for (i = 0; i < n; ++i) {
 		isl_basic_set *bset;
 		bset = isl_basic_set_list_get_basic_set(list, i);
@@ -2587,20 +2881,21 @@
 static __isl_give isl_basic_set *uset_unshifted_simple_hull_from_basic_set_list(
 	__isl_take isl_set *set, __isl_take isl_basic_set_list *list)
 {
-	int i, n, n_eq, n_ineq;
-	unsigned dim;
+	int i, n_eq, n_ineq;
+	isl_size n;
+	isl_size dim;
 	isl_ctx *ctx;
 	isl_mat *mat = NULL;
 	isl_int **ineq = NULL;
 	isl_basic_set *hull;
 
-	if (!set)
+	n = isl_basic_set_list_n_basic_set(list);
+	if (!set || n < 0)
 		goto error;
 	ctx = isl_set_get_ctx(set);
 
 	n_eq = 0;
 	n_ineq = 0;
-	n = isl_basic_set_list_n_basic_set(list);
 	for (i = 0; i < n; ++i) {
 		isl_basic_set *bset;
 		bset = isl_basic_set_list_get_basic_set(list, i);
@@ -2616,6 +2911,8 @@
 		goto error;
 
 	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
+		goto error;
 	mat = isl_mat_alloc(ctx, n_eq, 1 + dim);
 	mat = collect_inequalities(mat, list, ineq);
 	if (!mat)
@@ -2638,121 +2935,139 @@
 	return NULL;
 }
 
-/* Compute a superset of the convex hull of "set" that is described
+/* Compute a superset of the convex hull of "map" that is described
  * by only constraints in the elements of "list".
  *
  * If the list is empty, then we can only describe the universe set.
- * If the input set is empty, then all constraints are valid, so
+ * If the input map is empty, then all constraints are valid, so
  * we return the intersection of the elements in "list".
  *
  * Otherwise, we align all divs and temporarily treat them
  * as regular variables, computing the unshifted simple hull in
  * uset_unshifted_simple_hull_from_basic_set_list.
  */
-static __isl_give isl_basic_set *set_unshifted_simple_hull_from_basic_set_list(
-	__isl_take isl_set *set, __isl_take isl_basic_set_list *list)
+static __isl_give isl_basic_map *map_unshifted_simple_hull_from_basic_map_list(
+	__isl_take isl_map *map, __isl_take isl_basic_map_list *list)
 {
-	isl_basic_set *model;
-	isl_basic_set *hull;
+	isl_size n;
+	isl_basic_map *model;
+	isl_basic_map *hull;
+	isl_set *set;
+	isl_basic_set_list *bset_list;
 
-	if (!set || !list)
+	n = isl_basic_map_list_n_basic_map(list);
+	if (!map || n < 0)
 		goto error;
 
-	if (isl_basic_set_list_n_basic_set(list) == 0) {
+	if (n == 0) {
 		isl_space *space;
 
-		space = isl_set_get_space(set);
-		isl_set_free(set);
-		isl_basic_set_list_free(list);
-		return isl_basic_set_universe(space);
+		space = isl_map_get_space(map);
+		isl_map_free(map);
+		isl_basic_map_list_free(list);
+		return isl_basic_map_universe(space);
 	}
-	if (isl_set_plain_is_empty(set)) {
-		isl_set_free(set);
-		return isl_basic_set_list_intersect(list);
+	if (isl_map_plain_is_empty(map)) {
+		isl_map_free(map);
+		return isl_basic_map_list_intersect(list);
 	}
 
-	set = isl_set_align_divs_to_basic_set_list(set, list);
-	if (!set)
+	map = isl_map_align_divs_to_basic_map_list(map, list);
+	if (!map)
 		goto error;
-	list = isl_basic_set_list_align_divs_to_basic_set(list, set->p0);
+	list = isl_basic_map_list_align_divs_to_basic_map(list, map->p0);
 
-	model = isl_basic_set_list_get_basic_set(list, 0);
+	model = isl_basic_map_list_get_basic_map(list, 0);
 
-	set = isl_set_to_underlying_set(set);
-	list = isl_basic_set_list_underlying_set(list);
+	set = isl_map_underlying_set(map);
+	bset_list = isl_basic_map_list_underlying_set(list);
 
-	hull = uset_unshifted_simple_hull_from_basic_set_list(set, list);
+	hull = uset_unshifted_simple_hull_from_basic_set_list(set, bset_list);
 	hull = isl_basic_map_overlying_set(hull, model);
 
 	return hull;
 error:
-	isl_set_free(set);
-	isl_basic_set_list_free(list);
+	isl_map_free(map);
+	isl_basic_map_list_free(list);
 	return NULL;
 }
 
-/* Return a sequence of the basic sets that make up the sets in "list".
+/* Return a sequence of the basic maps that make up the maps in "list".
  */
-static __isl_give isl_basic_set_list *collect_basic_sets(
-	__isl_take isl_set_list *list)
+static __isl_give isl_basic_map_list *collect_basic_maps(
+	__isl_take isl_map_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
-	isl_basic_set_list *bset_list;
+	isl_basic_map_list *bmap_list;
 
 	if (!list)
 		return NULL;
-	n = isl_set_list_n_set(list);
-	ctx = isl_set_list_get_ctx(list);
-	bset_list = isl_basic_set_list_alloc(ctx, 0);
+	n = isl_map_list_n_map(list);
+	ctx = isl_map_list_get_ctx(list);
+	bmap_list = isl_basic_map_list_alloc(ctx, 0);
+	if (n < 0)
+		bmap_list = isl_basic_map_list_free(bmap_list);
 
 	for (i = 0; i < n; ++i) {
-		isl_set *set;
-		isl_basic_set_list *list_i;
+		isl_map *map;
+		isl_basic_map_list *list_i;
 
-		set = isl_set_list_get_set(list, i);
-		set = isl_set_compute_divs(set);
-		list_i = isl_set_get_basic_set_list(set);
-		isl_set_free(set);
-		bset_list = isl_basic_set_list_concat(bset_list, list_i);
+		map = isl_map_list_get_map(list, i);
+		map = isl_map_compute_divs(map);
+		list_i = isl_map_get_basic_map_list(map);
+		isl_map_free(map);
+		bmap_list = isl_basic_map_list_concat(bmap_list, list_i);
 	}
 
-	isl_set_list_free(list);
-	return bset_list;
+	isl_map_list_free(list);
+	return bmap_list;
 }
 
-/* Compute a superset of the convex hull of "set" that is described
+/* Compute a superset of the convex hull of "map" that is described
  * by only constraints in the elements of "list".
  *
- * If "set" is the universe, then the convex hull (and therefore
+ * If "map" is the universe, then the convex hull (and therefore
  * any superset of the convexhull) is the universe as well.
  *
- * Otherwise, we collect all the basic sets in the set list and
- * continue with set_unshifted_simple_hull_from_basic_set_list.
+ * Otherwise, we collect all the basic maps in the map list and
+ * continue with map_unshifted_simple_hull_from_basic_map_list.
  */
-__isl_give isl_basic_set *isl_set_unshifted_simple_hull_from_set_list(
-	__isl_take isl_set *set, __isl_take isl_set_list *list)
+__isl_give isl_basic_map *isl_map_unshifted_simple_hull_from_map_list(
+	__isl_take isl_map *map, __isl_take isl_map_list *list)
 {
-	isl_basic_set_list *bset_list;
+	isl_basic_map_list *bmap_list;
 	int is_universe;
 
-	is_universe = isl_set_plain_is_universe(set);
+	is_universe = isl_map_plain_is_universe(map);
 	if (is_universe < 0)
-		set = isl_set_free(set);
+		map = isl_map_free(map);
 	if (is_universe < 0 || is_universe) {
-		isl_set_list_free(list);
-		return isl_set_unshifted_simple_hull(set);
+		isl_map_list_free(list);
+		return isl_map_unshifted_simple_hull(map);
 	}
 
-	bset_list = collect_basic_sets(list);
-	return set_unshifted_simple_hull_from_basic_set_list(set, bset_list);
+	bmap_list = collect_basic_maps(list);
+	return map_unshifted_simple_hull_from_basic_map_list(map, bmap_list);
+}
+
+/* Compute a superset of the convex hull of "set" that is described
+ * by only constraints in the elements of "list".
+ */
+__isl_give isl_basic_set *isl_set_unshifted_simple_hull_from_set_list(
+	__isl_take isl_set *set, __isl_take isl_set_list *list)
+{
+	return isl_map_unshifted_simple_hull_from_map_list(set, list);
 }
 
 /* Given a set "set", return parametric bounds on the dimension "dim".
  */
-static struct isl_basic_set *set_bounds(struct isl_set *set, int dim)
+static __isl_give isl_basic_set *set_bounds(__isl_keep isl_set *set, int dim)
 {
-	unsigned set_dim = isl_set_dim(set, isl_dim_set);
+	isl_size set_dim = isl_set_dim(set, isl_dim_set);
+	if (set_dim < 0)
+		return NULL;
 	set = isl_set_copy(set);
 	set = isl_set_eliminate_dims(set, dim + 1, set_dim - (dim + 1));
 	set = isl_set_eliminate_dims(set, 0, dim);
@@ -2763,23 +3078,26 @@
  * resulting hull is bounded by a symbolic constant.  If not, the
  * hull is intersected with the corresponding bounds on the whole set.
  */
-struct isl_basic_set *isl_set_bounded_simple_hull(struct isl_set *set)
+__isl_give isl_basic_set *isl_set_bounded_simple_hull(__isl_take isl_set *set)
 {
 	int i, j;
 	struct isl_basic_set *hull;
-	unsigned nparam, left;
+	isl_size nparam, dim, total;
+	unsigned left;
 	int removed_divs = 0;
 
 	hull = isl_set_simple_hull(isl_set_copy(set));
-	if (!hull)
+	nparam = isl_basic_set_dim(hull, isl_dim_param);
+	dim = isl_basic_set_dim(hull, isl_dim_set);
+	total = isl_basic_set_dim(hull, isl_dim_all);
+	if (nparam < 0 || dim < 0 || total < 0)
 		goto error;
 
-	nparam = isl_basic_set_dim(hull, isl_dim_param);
-	for (i = 0; i < isl_basic_set_dim(hull, isl_dim_set); ++i) {
+	for (i = 0; i < dim; ++i) {
 		int lower = 0, upper = 0;
 		struct isl_basic_set *bounds;
 
-		left = isl_basic_set_total_dim(hull) - nparam - i - 1;
+		left = total - nparam - i - 1;
 		for (j = 0; j < hull->n_eq; ++j) {
 			if (isl_int_is_zero(hull->eqj1 + nparam + i))
 				continue;
@@ -2825,5 +3143,6 @@
 	return hull;
 error:
 	isl_set_free(set);
+	isl_basic_set_free(hull);
 	return NULL;
 }

_service:tar_scm:isl-0.24.tar.gz/isl_copy_tuple_id_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_ctx.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ctx.c Changed

@@ -14,6 +14,42 @@
 #define __isl_calloc(type,size)		((type *)calloc(1, size))
 #define __isl_calloc_type(type)		__isl_calloc(type,sizeof(type))
 
+/* Construct an isl_stat indicating whether "obj" is non-NULL.
+ *
+ * That is, return isl_stat_ok if "obj" is non_NULL and
+ * isl_stat_error otherwise.
+ */
+isl_stat isl_stat_non_null(void *obj)
+{
+	if (obj != NULL)
+		return isl_stat_ok;
+	return isl_stat_error;
+}
+
+/* Return the negation of "b", where the negation of isl_bool_error
+ * is isl_bool_error again.
+ */
+isl_bool isl_bool_not(isl_bool b)
+{
+	if (b < 0)
+		return isl_bool_error;
+	if (b == isl_bool_false)
+		return isl_bool_true;
+	return isl_bool_false;
+}
+
+/* Create an isl_bool from an integer.
+ *
+ * Return isl_bool_false if b is zero, otherwise return isl_bool_true.
+ * This function never returns isl_bool_error.
+ */
+isl_bool isl_bool_ok(int b)
+{
+	if (b)
+		return isl_bool_true;
+	return isl_bool_false;
+}
+
 /* Check that the result of an allocation ("p") is not NULL and
  * complain if it is.
  * The only exception is when allocation size ("size") is equal to zero.
@@ -77,13 +113,27 @@
 	return ctx ? check_non_null(ctx, realloc(ptr, size), size) : NULL;
 }
 
+/* Keep track of all information about the current error ("error", "msg",
+ * "file", "line") in "ctx".
+ */
+void isl_ctx_set_full_error(isl_ctx *ctx, enum isl_error error, const char *msg,
+	const char *file, int line)
+{
+	if (!ctx)
+		return;
+	ctx->error = error;
+	ctx->error_msg = msg;
+	ctx->error_file = file;
+	ctx->error_line = line;
+}
+
 void isl_handle_error(isl_ctx *ctx, enum isl_error error, const char *msg,
 	const char *file, int line)
 {
 	if (!ctx)
 		return;
 
-	isl_ctx_set_error(ctx, error);
+	isl_ctx_set_full_error(ctx, error, msg, file, line);
 
 	switch (ctx->opt->on_error) {
 	case ISL_ON_ERROR_WARN:
@@ -114,7 +164,7 @@
 		if (arg->type != isl_arg_child)
 			continue;
 
-		if (arg->offset == (size_t) -1)
+		if (arg->offset == ISL_ARG_OFFSET_NONE)
 			child = opt;
 		else
 			child = *(void **)(((char *)opt) + arg->offset);
@@ -194,7 +244,7 @@
 	ctx->n_cached = 0;
 	ctx->n_miss = 0;
 
-	ctx->error = isl_error_none;
+	isl_ctx_reset_error(ctx);
 
 	ctx->operations = 0;
 	isl_ctx_set_max_operations(ctx, ctx->opt->max_operations);
@@ -270,18 +320,43 @@
 
 enum isl_error isl_ctx_last_error(isl_ctx *ctx)
 {
-	return ctx->error;
+	return ctx ? ctx->error : isl_error_invalid;
+}
+
+/* Return the error message of the last error in "ctx".
+ */
+const char *isl_ctx_last_error_msg(isl_ctx *ctx)
+{
+	return ctx ? ctx->error_msg : NULL;
+}
+
+/* Return the file name where the last error in "ctx" occurred.
+ */
+const char *isl_ctx_last_error_file(isl_ctx *ctx)
+{
+	return ctx ? ctx->error_file : NULL;
+}
+
+/* Return the line number where the last error in "ctx" occurred.
+ */
+int isl_ctx_last_error_line(isl_ctx *ctx)
+{
+	return ctx ? ctx->error_line : -1;
 }
 
 void isl_ctx_reset_error(isl_ctx *ctx)
 {
+	if (!ctx)
+		return;
 	ctx->error = isl_error_none;
+	ctx->error_msg = NULL;
+	ctx->error_file = NULL;
+	ctx->error_line = -1;
 }
 
 void isl_ctx_set_error(isl_ctx *ctx, enum isl_error error)
 {
-	if (ctx)
-		ctx->error = error;
+	isl_ctx_set_full_error(ctx, error, NULL, NULL, -1);
 }
 
 void isl_ctx_abort(isl_ctx *ctx)

_service:tar_scm:isl-0.14.tar.xz/isl_ctx_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_ctx_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_deprecated.c -> _service:tar_scm:isl-0.24.tar.gz/isl_deprecated.c Changed

_service:tar_scm:isl-0.14.tar.xz/isl_dim_map.c -> _service:tar_scm:isl-0.24.tar.gz/isl_dim_map.c Changed

@@ -42,9 +42,16 @@
 	return dim_map;
 }
 
+/* Free "dim_map" and return NULL.
+ */
+__isl_null isl_dim_map *isl_dim_map_free(__isl_take isl_dim_map *dim_map)
+{
+	free(dim_map);
+	return NULL;
+}
+
 void isl_dim_map_range(__isl_keep isl_dim_map *dim_map,
-	unsigned dst_pos, unsigned dst_stride,
-	unsigned src_pos, unsigned src_stride,
+	unsigned dst_pos, int dst_stride, unsigned src_pos, int src_stride,
 	unsigned n, int sign)
 {
 	int i;
@@ -61,27 +68,30 @@
 }
 
 void isl_dim_map_dim_range(__isl_keep isl_dim_map *dim_map,
-	__isl_keep isl_space *dim, enum isl_dim_type type,
+	__isl_keep isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n, unsigned dst_pos)
 {
 	int i;
 	unsigned src_pos;
 
-	if (!dim_map || !dim)
+	if (!dim_map || !space)
 		return;
 	
-	src_pos = 1 + isl_space_offset(dim, type);
+	src_pos = 1 + isl_space_offset(space, type);
 	for (i = 0; i < n; ++i) {
 		dim_map->m1 + dst_pos + i.pos = src_pos + first + i;
 		dim_map->m1 + dst_pos + i.sgn = 1;
 	}
 }
 
-void isl_dim_map_dim(__isl_keep isl_dim_map *dim_map, __isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned dst_pos)
+void isl_dim_map_dim(__isl_keep isl_dim_map *dim_map,
+	__isl_keep isl_space *space, enum isl_dim_type type, unsigned dst_pos)
 {
-	isl_dim_map_dim_range(dim_map, dim, type,
-			      0, isl_space_dim(dim, type), dst_pos);
+	isl_size dim = isl_space_dim(space, type);
+
+	if (dim < 0)
+		return;
+	isl_dim_map_dim_range(dim_map, space, type, 0, dim, dst_pos);
 }
 
 void isl_dim_map_div(__isl_keep isl_dim_map *dim_map,
@@ -93,7 +103,7 @@
 	if (!dim_map || !bmap)
 		return;
 	
-	src_pos = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	src_pos = isl_basic_map_offset(bmap, isl_dim_div);
 	for (i = 0; i < bmap->n_div; ++i) {
 		dim_map->m1 + dst_pos + i.pos = src_pos + i;
 		dim_map->m1 + dst_pos + i.sgn = 1;
@@ -162,12 +172,12 @@
 		copy_div_dim_map(dst->divi1, src->divi, dim_map);
 	}
 
-	free(dim_map);
+	isl_dim_map_free(dim_map);
 	isl_basic_map_free(src);
 
 	return dst;
 error:
-	free(dim_map);
+	isl_dim_map_free(dim_map);
 	isl_basic_map_free(src);
 	isl_basic_map_free(dst);
 	return NULL;
@@ -189,6 +199,9 @@
 	struct isl_dim_map *res;
 	int offset;
 
+	if (!dim_map)
+		return NULL;
+
 	offset = isl_basic_map_offset(bmap, isl_dim_div);
 
 	res = isl_dim_map_alloc(bmap->ctx, dim_map->len - 1 + bmap->n_div);
@@ -214,13 +227,19 @@
 {
 	int i;
 	isl_ctx *ctx;
+	isl_size dim;
+	isl_space *space;
 	struct isl_dim_map *dim_map;
 
 	if (!exp)
 		return NULL;
 
-	ctx = isl_space_get_ctx(exp->dim);
-	dim_map = isl_dim_map_alloc(ctx, isl_space_dim(exp->dim, isl_dim_all));
+	ctx = isl_reordering_get_ctx(exp);
+	space = isl_reordering_peek_space(exp);
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		return NULL;
+	dim_map = isl_dim_map_alloc(ctx, dim);
 	if (!dim_map)
 		return NULL;

_service:tar_scm:isl-0.14.tar.xz/isl_dim_map.h -> _service:tar_scm:isl-0.24.tar.gz/isl_dim_map.h Changed

@@ -4,20 +4,21 @@
 #include <isl/ctx.h>
 #include <isl/space.h>
 #include <isl/map.h>
+#include <isl_reordering.h>
 
 struct isl_dim_map;
 typedef struct isl_dim_map isl_dim_map;
 
 __isl_give isl_dim_map *isl_dim_map_alloc(isl_ctx *ctx, unsigned len);
+__isl_null isl_dim_map *isl_dim_map_free(__isl_take isl_dim_map *dim_map);
 void isl_dim_map_range(__isl_keep isl_dim_map *dim_map,
-	unsigned dst_pos, unsigned dst_stride,
-	unsigned src_pos, unsigned src_stride,
+	unsigned dst_pos, int dst_stride, unsigned src_pos, int src_stride,
 	unsigned n, int sign);
 void isl_dim_map_dim_range(__isl_keep isl_dim_map *dim_map,
-	isl_space *dim, enum isl_dim_type type,
+	__isl_keep isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n, unsigned dst_pos);
-void isl_dim_map_dim(__isl_keep isl_dim_map *dim_map, __isl_keep isl_space *dim,
-	enum isl_dim_type type, unsigned dst_pos);
+void isl_dim_map_dim(__isl_keep isl_dim_map *dim_map,
+	__isl_keep isl_space *space, enum isl_dim_type type, unsigned dst_pos);
 void isl_dim_map_div(__isl_keep isl_dim_map *dim_map,
 	__isl_keep isl_basic_map *bmap, unsigned dst_pos);
 __isl_give isl_basic_set *isl_basic_set_add_constraints_dim_map(

_service:tar_scm:isl-0.24.tar.gz/isl_domain_factor_templ.c Added

@@ -0,0 +1,67 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Drop the "n" domain dimensions starting at "first" from "obj",
+ * after checking that they do not appear in the affine expression.
+ */
+static __isl_give TYPE *FN(TYPE,drop_domain)(__isl_take TYPE *obj,
+	unsigned first, unsigned n)
+{
+	isl_bool involves;
+
+	involves = FN(TYPE,involves_dims)(obj, isl_dim_in, first, n);
+	if (involves < 0)
+		return FN(TYPE,free)(obj);
+	if (involves)
+		isl_die(FN(TYPE,get_ctx)(obj), isl_error_invalid,
+		    "affine expression involves some of the domain dimensions",
+		    return FN(TYPE,free)(obj));
+	return FN(TYPE,drop_dims)(obj, isl_dim_in, first, n);
+}
+
+/* Check that the domain of "obj" is a product.
+ */
+static isl_stat FN(TYPE,check_domain_product)(__isl_keep TYPE *obj)
+{
+	isl_bool is_product;
+
+	is_product = FN(TYPE,domain_is_product)(obj);
+	if (is_product < 0)
+		return isl_stat_error;
+	if (!is_product)
+		isl_die(FN(TYPE,get_ctx)(obj), isl_error_invalid,
+			"domain is not a product", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Given an affine function with a domain of the form A -> B that
+ * does not depend on B, return the same function on domain A.
+ */
+__isl_give TYPE *FN(TYPE,domain_factor_domain)(__isl_take TYPE *obj)
+{
+	isl_space *space;
+	isl_size n, n_in;
+
+	if (FN(TYPE,check_domain_product)(obj) < 0)
+		return FN(TYPE,free)(obj);
+	space = FN(TYPE,get_domain_space)(obj);
+	n = isl_space_dim(space, isl_dim_set);
+	space = isl_space_factor_domain(space);
+	n_in = isl_space_dim(space, isl_dim_set);
+	if (n < 0 || n_in < 0)
+		obj = FN(TYPE,free)(obj);
+	else
+		obj = FN(TYPE,drop_domain)(obj, n_in, n - n_in);
+	obj = FN(TYPE,reset_domain_space)(obj, space);
+	return obj;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_equalities.c -> _service:tar_scm:isl-0.24.tar.gz/isl_equalities.c Changed

@@ -63,7 +63,8 @@
  * then the constraints admit no integer solution and
  * a zero-column matrix is returned.
  */
-static struct isl_mat *particular_solution(struct isl_mat *B, struct isl_vec *d)
+static __isl_give isl_mat *particular_solution(__isl_keep isl_mat *B,
+	__isl_keep isl_vec *d)
 {
 	int i, j;
 	struct isl_mat *M = NULL;
@@ -125,8 +126,8 @@
  * The columns of this matrix generate the lattice that satisfies
  * the single (linear) modulo constraint.
  */
-static struct isl_mat *parameter_compression_1(
-			struct isl_mat *B, struct isl_vec *d)
+static __isl_take isl_mat *parameter_compression_1(__isl_keep isl_mat *B,
+	__isl_keep isl_vec *d)
 {
 	struct isl_mat *U;
 
@@ -156,8 +157,8 @@
  * Putting this on the common denominator, we have
  * D * L_i^{-T} = U_i^T diag(D/d_i, D, ..., D).
  */
-static struct isl_mat *parameter_compression_multi(
-			struct isl_mat *B, struct isl_vec *d)
+static __isl_give isl_mat *parameter_compression_multi(__isl_keep isl_mat *B,
+	__isl_keep isl_vec *d)
 {
 	int i, j, k;
 	isl_int D;
@@ -305,8 +306,8 @@
  * as any y = y_0 + G y' with y' integer is a solution to the original
  * modulo constraints.
  */
-struct isl_mat *isl_mat_parameter_compression(
-			struct isl_mat *B, struct isl_vec *d)
+__isl_give isl_mat *isl_mat_parameter_compression(__isl_take isl_mat *B,
+	__isl_take isl_vec *d)
 {
 	int i;
 	struct isl_mat *cst = NULL;
@@ -430,17 +431,70 @@
 	return isl_mat_parameter_compression(B, d);
 }
 
+/* Return a compression matrix that indicates that there are no solutions
+ * to the original constraints.  In particular, return a zero-column
+ * matrix with 1 + dim rows.  If "T2" is not NULL, then assign *T2
+ * the inverse of this matrix.  *T2 may already have been assigned
+ * matrix, so free it first.
+ * "free1", "free2" and "free3" are temporary matrices that are
+ * not useful when an empty compression is returned.  They are
+ * simply freed.
+ */
+static __isl_give isl_mat *empty_compression(isl_ctx *ctx, unsigned dim,
+	__isl_give isl_mat **T2, __isl_take isl_mat *free1,
+	__isl_take isl_mat *free2, __isl_take isl_mat *free3)
+{
+	isl_mat_free(free1);
+	isl_mat_free(free2);
+	isl_mat_free(free3);
+	if (T2) {
+		isl_mat_free(*T2);
+		*T2 = isl_mat_alloc(ctx, 0, 1 + dim);
+	}
+	return isl_mat_alloc(ctx, 1 + dim, 0);
+}
+
+/* Given a matrix that maps a (possibly) parametric domain to
+ * a parametric domain, add in rows that map the "nparam" parameters onto
+ * themselves.
+ */
+static __isl_give isl_mat *insert_parameter_rows(__isl_take isl_mat *mat,
+	unsigned nparam)
+{
+	int i;
+
+	if (nparam == 0)
+		return mat;
+	if (!mat)
+		return NULL;
+
+	mat = isl_mat_insert_rows(mat, 1, nparam);
+	if (!mat)
+		return NULL;
+
+	for (i = 0; i < nparam; ++i) {
+		isl_seq_clr(mat->row1 + i, mat->n_col);
+		isl_int_set(mat->row1 + i1 + i, mat->row00);
+	}
+
+	return mat;
+}
+
 /* Given a set of equalities
  *
- *		M x - c = 0
+ *		-C(y) + M x = 0
  *
  * this function computes a unimodular transformation from a lower-dimensional
  * space to the original space that bijectively maps the integer points x'
  * in the lower-dimensional space to the integer points x in the original
  * space that satisfy the equalities.
  *
- * The input is given as a matrix B =  -c M  and the output is a
+ * The input is given as a matrix B =  -C M  and the output is a
  * matrix that maps 1 x' to 1 x.
+ * The number of equality constraints in B is assumed to be smaller than
+ * or equal to the number of variables x.
+ * "first" is the position of the first x variable.
+ * The preceding variables are considered to be y-variables.
  * If T2 is not NULL, then *T2 is set to a matrix mapping 1 x to 1 x'.
  *
  * First compute the (left) Hermite normal form of M,
@@ -458,24 +512,27 @@
  *
  * The equalities then become
  *
- *		H1 x1' - c = 0   or   x1' = H1^{-1} c = c'
+ *		-C(y) + H1 x1' = 0   or   x1' = H1^{-1} C(y) = C'(y)
  *
- * If any of the c' is non-integer, then the original set has no
- * integer solutions (since the x' are a unimodular transformation
- * of the x) and a zero-column matrix is returned.
+ * If the denominator of the constant term does not divide the
+ * the common denominator of the coefficients of y, then every
+ * integer point is mapped to a non-integer point and then the original set
+ * has no integer solutions (since the x' are a unimodular transformation
+ * of the x).  In this case, a zero-column matrix is returned.
  * Otherwise, the transformation is given by
  *
- *		x = U1 H1^{-1} c + U2 x2'
+ *		x = U1 H1^{-1} C(y) + U2 x2'
  *
  * The inverse transformation is simply
  *
  *		x2' = Q2 x
  */
-__isl_give isl_mat *isl_mat_variable_compression(__isl_take isl_mat *B,
-	__isl_give isl_mat **T2)
+__isl_give isl_mat *isl_mat_final_variable_compression(__isl_take isl_mat *B,
+	int first, __isl_give isl_mat **T2)
 {
-	int i;
-	struct isl_mat *H = NULL, *C = NULL, *H1, *U = NULL, *U1, *U2, *TC;
+	int i, n;
+	isl_ctx *ctx;
+	isl_mat *H = NULL, *C, *H1, *U = NULL, *U1, *U2;
 	unsigned dim;
 
 	if (T2)
@@ -483,56 +540,62 @@
 	if (!B)
 		goto error;
 
+	ctx = isl_mat_get_ctx(B);
 	dim = B->n_col - 1;
-	H = isl_mat_sub_alloc(B, 0, B->n_row, 1, dim);
+	n = dim - first;
+	if (n < B->n_row)
+		isl_die(ctx, isl_error_invalid, "too many equality constraints",
+			goto error);
+	H = isl_mat_sub_alloc(B, 0, B->n_row, 1 + first, n);
 	H = isl_mat_left_hermite(H, 0, &U, T2);
 	if (!H || !U || (T2 && !*T2))
 		goto error;
 	if (T2) {
 		*T2 = isl_mat_drop_rows(*T2, 0, B->n_row);
-		*T2 = isl_mat_lin_to_aff(*T2);
+		*T2 = isl_mat_diagonal(isl_mat_identity(ctx, 1 + first), *T2);
 		if (!*T2)
 			goto error;
 	}
-	C = isl_mat_alloc(B->ctx, 1+B->n_row, 1);
+	C = isl_mat_alloc(ctx, 1 + B->n_row, 1 + first);
 	if (!C)
 		goto error;
 	isl_int_set_si(C->row00, 1);
-	isl_mat_sub_neg(C->ctx, C->row+1, B->row, B->n_row, 0, 0, 1);
+	isl_seq_clr(C->row0 + 1, first);
+	isl_mat_sub_neg(ctx, C->row + 1, B->row, B->n_row, 0, 0, 1 + first);
 	H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row);
 	H1 = isl_mat_lin_to_aff(H1);
-	TC = isl_mat_inverse_product(H1, C);
-	if (!TC)
+	C = isl_mat_inverse_product(H1, C);
+	if (!C)
 		goto error;
 	isl_mat_free(H);
-	if (!isl_int_is_one(TC->row00)) {
+	if (!isl_int_is_one(C->row00)) {
+		isl_int g;
+
+		isl_int_init(g);
 		for (i = 0; i < B->n_row; ++i) {
-			if (!isl_int_is_divisible_by(TC->row1+i0, TC->row00)) {
-				struct isl_ctx *ctx = B->ctx;
-				isl_mat_free(B);
-				isl_mat_free(TC);
-				isl_mat_free(U);
-				if (T2) {
-					isl_mat_free(*T2);
-					*T2 = NULL;
-				}
-				return isl_mat_alloc(ctx, 1 + dim, 0);
-			}
-			isl_seq_scale_down(TC->row1+i, TC->row1+i, TC->row00, 1);
+			isl_seq_gcd(C->row1 + i + 1, first, &g);
+			isl_int_gcd(g, g, C->row00);
+			if (!isl_int_is_divisible_by(C->row1 + i0, g))
+				break;
 		}
-		isl_int_set_si(TC->row00, 1);
+		isl_int_clear(g);
+
+		if (i < B->n_row)
+			return empty_compression(ctx, dim, T2, B, C, U);
+		C = isl_mat_normalize(C);
 	}
 	U1 = isl_mat_sub_alloc(U, 0, U->n_row, 0, B->n_row);
 	U1 = isl_mat_lin_to_aff(U1);
 	U2 = isl_mat_sub_alloc(U, 0, U->n_row, B->n_row, U->n_row - B->n_row);
 	U2 = isl_mat_lin_to_aff(U2);
 	isl_mat_free(U);
-	TC = isl_mat_product(U1, TC);
-	TC = isl_mat_aff_direct_sum(TC, U2);
+	C = isl_mat_product(U1, C);
+	C = isl_mat_aff_direct_sum(C, U2);
+	C = insert_parameter_rows(C, first);
 
 	isl_mat_free(B);
 
-	return TC;
+	return C;
 error:
 	isl_mat_free(B);
 	isl_mat_free(H);
@@ -544,6 +607,53 @@
 	return NULL;
 }
 
+/* Given a set of equalities
+ *
+ *		M x - c = 0
+ *
+ * this function computes a unimodular transformation from a lower-dimensional
+ * space to the original space that bijectively maps the integer points x'
+ * in the lower-dimensional space to the integer points x in the original
+ * space that satisfy the equalities.
+ *
+ * The input is given as a matrix B =  -c M  and the output is a
+ * matrix that maps 1 x' to 1 x.
+ * The number of equality constraints in B is assumed to be smaller than
+ * or equal to the number of variables x.
+ * If T2 is not NULL, then *T2 is set to a matrix mapping 1 x to 1 x'.
+ */
+__isl_give isl_mat *isl_mat_variable_compression(__isl_take isl_mat *B,
+	__isl_give isl_mat **T2)
+{
+	return isl_mat_final_variable_compression(B, 0, T2);
+}
+
+/* Return "bset" and set *T and *T2 to the identity transformation
+ * on "bset" (provided T and T2 are not NULL).
+ */
+static __isl_give isl_basic_set *return_with_identity(
+	__isl_take isl_basic_set *bset, __isl_give isl_mat **T,
+	__isl_give isl_mat **T2)
+{
+	isl_size dim;
+	isl_mat *id;
+
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		return isl_basic_set_free(bset);
+	if (!T && !T2)
+		return bset;
+
+	id = isl_mat_identity(isl_basic_map_get_ctx(bset), 1 + dim);
+	if (T)
+		*T = isl_mat_copy(id);
+	if (T2)
+		*T2 = isl_mat_copy(id);
+	isl_mat_free(id);
+
+	return bset;
+}
+
 /* Use the n equalities of bset to unimodularly transform the
  * variables x such that n transformed variables x1' have a constant value
  * and rewrite the constraints of bset in terms of the remaining
@@ -551,24 +661,26 @@
  * the new variables x2' back to the original variables x, while T2
  * maps the original variables to the new variables.
  */
-static struct isl_basic_set *compress_variables(
-	struct isl_basic_set *bset, struct isl_mat **T, struct isl_mat **T2)
+static __isl_give isl_basic_set *compress_variables(
+	__isl_take isl_basic_set *bset,
+	__isl_give isl_mat **T, __isl_give isl_mat **T2)
 {
 	struct isl_mat *B, *TC;
-	unsigned dim;
+	isl_size dim;
 
 	if (T)
 		*T = NULL;
 	if (T2)
 		*T2 = NULL;
-	if (!bset)
-		goto error;
-	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
-	isl_assert(bset->ctx, bset->n_div == 0, goto error);
-	dim = isl_basic_set_n_dim(bset);
+	if (isl_basic_set_check_no_params(bset) < 0 ||
+	    isl_basic_set_check_no_locals(bset) < 0)
+		return isl_basic_set_free(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		return isl_basic_set_free(bset);
 	isl_assert(bset->ctx, bset->n_eq <= dim, goto error);
 	if (bset->n_eq == 0)
-		return bset;
+		return return_with_identity(bset, T, T2);
 
 	B = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq, 0, 1 + dim);
 	TC = isl_mat_variable_compression(B, T2);
@@ -580,7 +692,8 @@
 			isl_mat_free(*T2);
 			*T2 = NULL;
 		}
-		return isl_basic_set_set_to_empty(bset);
+		bset = isl_basic_set_set_to_empty(bset);
+		return return_with_identity(bset, T, T2);
 	}
 
 	bset = isl_basic_set_preimage(bset, T ? isl_mat_copy(TC) : TC);
@@ -592,25 +705,21 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_remove_equalities(
-	struct isl_basic_set *bset, struct isl_mat **T, struct isl_mat **T2)
+__isl_give isl_basic_set *isl_basic_set_remove_equalities(
+	__isl_take isl_basic_set *bset, __isl_give isl_mat **T,
+	__isl_give isl_mat **T2)
 {
 	if (T)
 		*T = NULL;
 	if (T2)
 		*T2 = NULL;
-	if (!bset)
-		return NULL;
-	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
+	if (isl_basic_set_check_no_params(bset) < 0)
+		return isl_basic_set_free(bset);
 	bset = isl_basic_set_gauss(bset, NULL);
 	if (ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY))
-		return bset;
+		return return_with_identity(bset, T, T2);
 	bset = compress_variables(bset, T, T2);
 	return bset;
-error:
-	isl_basic_set_free(bset);
-	*T = NULL;
-	return NULL;
 }
 
 /* Check if dimension dim belongs to a residue class
@@ -622,29 +731,35 @@
  * If i_dim does not belong to such a residue class, then *modulo
  * is set to 1 and *residue is set to 0.
  */
-int isl_basic_set_dim_residue_class(struct isl_basic_set *bset,
+isl_stat isl_basic_set_dim_residue_class(__isl_keep isl_basic_set *bset,
 	int pos, isl_int *modulo, isl_int *residue)
 {
+	isl_bool fixed;
 	struct isl_ctx *ctx;
 	struct isl_mat *H = NULL, *U = NULL, *C, *H1, *U1;
-	unsigned total;
-	unsigned nparam;
+	isl_size total;
+	isl_size nparam;
 
 	if (!bset || !modulo || !residue)
-		return -1;
+		return isl_stat_error;
 
-	if (isl_basic_set_plain_dim_is_fixed(bset, pos, residue)) {
+	fixed = isl_basic_set_plain_dim_is_fixed(bset, pos, residue);
+	if (fixed < 0)
+		return isl_stat_error;
+	if (fixed) {
 		isl_int_set_si(*modulo, 0);
-		return 0;
+		return isl_stat_ok;
 	}
 
-	ctx = bset->ctx;
-	total = isl_basic_set_total_dim(bset);
-	nparam = isl_basic_set_n_param(bset);
-	H = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq, 1, total);
+	ctx = isl_basic_set_get_ctx(bset);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (total < 0 || nparam < 0)
+		return isl_stat_error;
+	H = isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 1, total);
 	H = isl_mat_left_hermite(H, 0, &U, NULL);
 	if (!H)
-		return -1;
+		return isl_stat_error;
 
 	isl_seq_gcd(U->rownparam + pos+bset->n_eq,
 			total-bset->n_eq, modulo);
@@ -654,14 +769,14 @@
 		isl_int_set_si(*residue, 0);
 		isl_mat_free(H);
 		isl_mat_free(U);
-		return 0;
+		return isl_stat_ok;
 	}
 
-	C = isl_mat_alloc(bset->ctx, 1+bset->n_eq, 1);
+	C = isl_mat_alloc(ctx, 1 + bset->n_eq, 1);
 	if (!C)
 		goto error;
 	isl_int_set_si(C->row00, 1);
-	isl_mat_sub_neg(C->ctx, C->row+1, bset->eq, bset->n_eq, 0, 0, 1);
+	isl_mat_sub_neg(ctx, C->row + 1, bset->eq, bset->n_eq, 0, 0, 1);
 	H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row);
 	H1 = isl_mat_lin_to_aff(H1);
 	C = isl_mat_inverse_product(H1, C);
@@ -671,23 +786,23 @@
 	isl_mat_free(U);
 	C = isl_mat_product(U1, C);
 	if (!C)
-		return -1;
+		return isl_stat_error;
 	if (!isl_int_is_divisible_by(C->row10, C->row00)) {
 		bset = isl_basic_set_copy(bset);
 		bset = isl_basic_set_set_to_empty(bset);
 		isl_basic_set_free(bset);
 		isl_int_set_si(*modulo, 1);
 		isl_int_set_si(*residue, 0);
-		return 0;
+		return isl_stat_ok;
 	}
 	isl_int_divexact(*residue, C->row10, C->row00);
 	isl_int_fdiv_r(*residue, *residue, *modulo);
 	isl_mat_free(C);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_mat_free(H);
 	isl_mat_free(U);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Check if dimension dim belongs to a residue class
@@ -699,7 +814,7 @@
  * If i_dim does not belong to such a residue class, then *modulo
  * is set to 1 and *residue is set to 0.
  */
-int isl_set_dim_residue_class(struct isl_set *set,
+isl_stat isl_set_dim_residue_class(__isl_keep isl_set *set,
 	int pos, isl_int *modulo, isl_int *residue)
 {
 	isl_int m;
@@ -707,22 +822,22 @@
 	int i;
 
 	if (!set || !modulo || !residue)
-		return -1;
+		return isl_stat_error;
 
 	if (set->n == 0) {
 		isl_int_set_si(*modulo, 0);
 		isl_int_set_si(*residue, 0);
-		return 0;
+		return isl_stat_ok;
 	}
 
 	if (isl_basic_set_dim_residue_class(set->p0, pos, modulo, residue)<0)
-		return -1;
+		return isl_stat_error;
 
 	if (set->n == 1)
-		return 0;
+		return isl_stat_ok;
 
 	if (isl_int_is_one(*modulo))
-		return 0;
+		return isl_stat_ok;
 
 	isl_int_init(m);
 	isl_int_init(r);
@@ -742,11 +857,11 @@
 	isl_int_clear(m);
 	isl_int_clear(r);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_int_clear(m);
 	isl_int_clear(r);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Check if dimension "dim" belongs to a residue class
@@ -758,13 +873,13 @@
  * If i_dim does not belong to such a residue class, then *modulo
  * is set to 1 and *residue is set to 0.
  */
-int isl_set_dim_residue_class_val(__isl_keep isl_set *set,
+isl_stat isl_set_dim_residue_class_val(__isl_keep isl_set *set,
 	int pos, __isl_give isl_val **modulo, __isl_give isl_val **residue)
 {
 	*modulo = NULL;
 	*residue = NULL;
 	if (!set)
-		return -1;
+		return isl_stat_error;
 	*modulo = isl_val_alloc(isl_set_get_ctx(set));
 	*residue = isl_val_alloc(isl_set_get_ctx(set));
 	if (!*modulo || !*residue)
@@ -774,9 +889,9 @@
 		goto error;
 	isl_int_set_si((*modulo)->d, 1);
 	isl_int_set_si((*residue)->d, 1);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_val_free(*modulo);
 	isl_val_free(*residue);
-	return -1;
+	return isl_stat_error;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_equalities.h -> _service:tar_scm:isl-0.24.tar.gz/isl_equalities.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_factorization.c -> _service:tar_scm:isl-0.24.tar.gz/isl_factorization.c Changed

@@ -18,8 +18,18 @@
 #include <isl_space_private.h>
 #include <isl_mat_private.h>
 
+/* Return the isl_ctx to which "f" belongs.
+ */
+isl_ctx *isl_factorizer_get_ctx(__isl_keep isl_factorizer *f)
+{
+	if (!f)
+		return NULL;
+	return isl_basic_set_get_ctx(f->bset);
+}
+
 static __isl_give isl_factorizer *isl_factorizer_alloc(
-	__isl_take isl_morph *morph, int n_group)
+	__isl_keep isl_basic_set *bset, __isl_take isl_morph *morph,
+	int n_group)
 {
 	isl_factorizer *f = NULL;
 	int *len = NULL;
@@ -37,6 +47,7 @@
 	if (!f)
 		goto error;
 
+	f->bset = isl_basic_set_copy(bset);
 	f->morph = morph;
 	f->n_group = n_group;
 	f->len = len;
@@ -48,14 +59,16 @@
 	return NULL;
 }
 
-void isl_factorizer_free(__isl_take isl_factorizer *f)
+__isl_null isl_factorizer *isl_factorizer_free(__isl_take isl_factorizer *f)
 {
 	if (!f)
-		return;
+		return NULL;
 
+	isl_basic_set_free(f->bset);
 	isl_morph_free(f->morph);
 	free(f->len);
 	free(f);
+	return NULL;
 }
 
 void isl_factorizer_dump(__isl_take isl_factorizer *f)
@@ -77,23 +90,24 @@
 
 __isl_give isl_factorizer *isl_factorizer_identity(__isl_keep isl_basic_set *bset)
 {
-	return isl_factorizer_alloc(isl_morph_identity(bset), 0);
+	return isl_factorizer_alloc(bset, isl_morph_identity(bset), 0);
 }
 
 __isl_give isl_factorizer *isl_factorizer_groups(__isl_keep isl_basic_set *bset,
 	__isl_take isl_mat *Q, __isl_take isl_mat *U, int n, int *len)
 {
 	int i;
-	unsigned nvar;
+	isl_size nvar;
 	unsigned ovar;
-	isl_space *dim;
+	isl_space *space;
 	isl_basic_set *dom;
 	isl_basic_set *ran;
 	isl_morph *morph;
 	isl_factorizer *f;
 	isl_mat *id;
 
-	if (!bset || !Q || !U)
+	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0 || !Q || !U)
 		goto error;
 
 	ovar = 1 + isl_space_offset(bset->dim, isl_dim_set);
@@ -101,14 +115,13 @@
 	Q = isl_mat_diagonal(isl_mat_copy(id), Q);
 	U = isl_mat_diagonal(id, U);
 
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
-	dim = isl_basic_set_get_space(bset);
-	dom = isl_basic_set_universe(isl_space_copy(dim));
-	dim = isl_space_drop_dims(dim, isl_dim_set, 0, nvar);
-	dim = isl_space_add_dims(dim, isl_dim_set, nvar);
-	ran = isl_basic_set_universe(dim);
+	space = isl_basic_set_get_space(bset);
+	dom = isl_basic_set_universe(isl_space_copy(space));
+	space = isl_space_drop_dims(space, isl_dim_set, 0, nvar);
+	space = isl_space_add_dims(space, isl_dim_set, nvar);
+	ran = isl_basic_set_universe(space);
 	morph = isl_morph_alloc(dom, ran, Q, U);
-	f = isl_factorizer_alloc(morph, n);
+	f = isl_factorizer_alloc(bset, morph, n);
 	if (!f)
 		return NULL;
 	for (i = 0; i < n; ++i)
@@ -258,17 +271,14 @@
 {
 	int i, j, n, done;
 	isl_mat *H, *U, *Q;
-	unsigned nvar;
+	isl_size nvar;
 	struct isl_factor_groups g = { 0 };
 	isl_factorizer *f;
 
-	if (!bset)
+	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0 || isl_basic_set_check_no_locals(bset) < 0)
 		return NULL;
 
-	isl_assert(bset->ctx, isl_basic_set_dim(bset, isl_dim_div) == 0,
-		return NULL);
-
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
 	if (nvar <= 1)
 		return isl_factorizer_identity(bset);
 
@@ -329,3 +339,51 @@
 	clear_groups(&g);
 	return NULL;
 }
+
+/* Given the factorizer "f" of a basic set,
+ * call "test" on each resulting factor as long as each call succeeds.
+ */
+__isl_give isl_bool isl_factorizer_every_factor_basic_set(
+	__isl_keep isl_factorizer *f,
+	isl_bool (*test)(__isl_keep isl_basic_set *bset, void *user),
+	void *user)
+{
+	int i, n;
+	isl_bool every = isl_bool_true;
+	isl_size nparam, nvar;
+	isl_basic_set *bset;
+
+	if (!f)
+		return isl_bool_error;
+	nparam = isl_basic_set_dim(f->bset, isl_dim_param);
+	nvar = isl_basic_set_dim(f->bset, isl_dim_set);
+	if (nparam < 0 || nvar < 0)
+		return isl_bool_error;
+
+	bset = isl_basic_set_copy(f->bset);
+	bset = isl_morph_basic_set(isl_morph_copy(f->morph), bset);
+
+	for (i = 0, n = 0; i < f->n_group; ++i) {
+		isl_basic_set *factor;
+
+		factor = isl_basic_set_copy(bset);
+		factor = isl_basic_set_drop_constraints_involving(factor,
+			    nparam + n + f->leni, nvar - n - f->leni);
+		factor = isl_basic_set_drop_constraints_involving(factor,
+			    nparam, n);
+		factor = isl_basic_set_drop(factor, isl_dim_set,
+			    n + f->leni, nvar - n - f->leni);
+		factor = isl_basic_set_drop(factor, isl_dim_set, 0, n);
+		every = test(factor, user);
+		isl_basic_set_free(factor);
+
+		if (every < 0 || !every)
+			break;
+
+		n += f->leni;
+	}
+
+	isl_basic_set_free(bset);
+
+	return every;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_factorization.h -> _service:tar_scm:isl-0.24.tar.gz/isl_factorization.h Changed

@@ -1,3 +1,6 @@
+#ifndef ISL_FACTORIZATION_H
+#define ISL_FACTORIZATION_H
+
 #include <isl/set.h>
 #include <isl_morph.h>
 
@@ -5,13 +8,14 @@
 extern "C" {
 #endif
 
-/* Data for factorizing a particular basic set.
+/* Data for factorizing the basic set "bset".
  * After applying "morph" to the basic set, there are "n_group"
  * groups of consecutive set variables, each of length "leni",
  * with 0 <= i < n_group.
  * If no factorization is possible, then "n_group" is set to 0.
  */
 struct isl_factorizer {
+	isl_basic_set	*bset;
 	isl_morph	*morph;
 	int		n_group;
 	int		*len;
@@ -21,9 +25,18 @@
 __isl_give isl_factorizer *isl_basic_set_factorizer(
 	__isl_keep isl_basic_set *bset);
 
-void isl_factorizer_free(__isl_take isl_factorizer *f);
+isl_ctx *isl_factorizer_get_ctx(__isl_keep isl_factorizer *f);
+
+__isl_null isl_factorizer *isl_factorizer_free(__isl_take isl_factorizer *f);
 void isl_factorizer_dump(__isl_take isl_factorizer *f);
 
+__isl_give isl_bool isl_factorizer_every_factor_basic_set(
+	__isl_keep isl_factorizer *f,
+	isl_bool (*test)(__isl_keep isl_basic_set *bset, void *user),
+	void *user);
+
 #if defined(__cplusplus)
 }
 #endif
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/isl_farkas.c -> _service:tar_scm:isl-0.24.tar.gz/isl_farkas.c Changed

@@ -12,6 +12,9 @@
 #include <isl/set.h>
 #include <isl_space_private.h>
 #include <isl_seq.h>
+#include <isl_aff_private.h>
+#include <isl_mat_private.h>
+#include <isl_factorization.h>
 
 /*
  * Let C be a cone and define
@@ -61,27 +64,29 @@
  * to the left, with the leftmost ending up in the constant position.
  */
 
-/* Add the given prefix to all named isl_dim_set dimensions in "dim".
+/* Add the given prefix to all named isl_dim_set dimensions in "space".
  */
-static __isl_give isl_space *isl_space_prefix(__isl_take isl_space *dim,
+static __isl_give isl_space *isl_space_prefix(__isl_take isl_space *space,
 	const char *prefix)
 {
 	int i;
 	isl_ctx *ctx;
-	unsigned nvar;
+	isl_size nvar;
 	size_t prefix_len = strlen(prefix);
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	ctx = isl_space_get_ctx(dim);
-	nvar = isl_space_dim(dim, isl_dim_set);
+	ctx = isl_space_get_ctx(space);
+	nvar = isl_space_dim(space, isl_dim_set);
+	if (nvar < 0)
+		return isl_space_free(space);
 
 	for (i = 0; i < nvar; ++i) {
 		const char *name;
 		char *prefix_name;
 
-		name = isl_space_get_dim_name(dim, isl_dim_set, i);
+		name = isl_space_get_dim_name(space, isl_dim_set, i);
 		if (!name)
 			continue;
 
@@ -92,13 +97,14 @@
 		memcpy(prefix_name, prefix, prefix_len);
 		strcpy(prefix_name + prefix_len, name);
 
-		dim = isl_space_set_dim_name(dim, isl_dim_set, i, prefix_name);
+		space = isl_space_set_dim_name(space,
+						isl_dim_set, i, prefix_name);
 		free(prefix_name);
 	}
 
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -115,55 +121,61 @@
  *
  * and prefix each dimension name with "c_".
  */
-static __isl_give isl_space *isl_space_coefficients(__isl_take isl_space *dim)
+static __isl_give isl_space *isl_space_coefficients(__isl_take isl_space *space)
 {
-	isl_space *dim_param;
-	unsigned nvar;
-	unsigned nparam;
-
-	nvar = isl_space_dim(dim, isl_dim_set);
-	nparam = isl_space_dim(dim, isl_dim_param);
-	dim_param = isl_space_copy(dim);
-	dim_param = isl_space_drop_dims(dim_param, isl_dim_set, 0, nvar);
-	dim_param = isl_space_move_dims(dim_param, isl_dim_set, 0,
+	isl_space *space_param;
+	isl_size nvar;
+	isl_size nparam;
+
+	nvar = isl_space_dim(space, isl_dim_set);
+	nparam = isl_space_dim(space, isl_dim_param);
+	if (nvar < 0 || nparam < 0)
+		return isl_space_free(space);
+	space_param = isl_space_copy(space);
+	space_param = isl_space_drop_dims(space_param, isl_dim_set, 0, nvar);
+	space_param = isl_space_move_dims(space_param, isl_dim_set, 0,
 				 isl_dim_param, 0, nparam);
-	dim_param = isl_space_prefix(dim_param, "c_");
-	dim_param = isl_space_insert_dims(dim_param, isl_dim_set, 0, 1);
-	dim_param = isl_space_set_dim_name(dim_param, isl_dim_set, 0, "c_cst");
-	dim = isl_space_drop_dims(dim, isl_dim_param, 0, nparam);
-	dim = isl_space_prefix(dim, "c_");
-	dim = isl_space_join(isl_space_from_domain(dim_param),
-			   isl_space_from_range(dim));
-	dim = isl_space_wrap(dim);
-	dim = isl_space_set_tuple_name(dim, isl_dim_set, "coefficients");
-
-	return dim;
+	space_param = isl_space_prefix(space_param, "c_");
+	space_param = isl_space_insert_dims(space_param, isl_dim_set, 0, 1);
+	space_param = isl_space_set_dim_name(space_param,
+				isl_dim_set, 0, "c_cst");
+	space = isl_space_drop_dims(space, isl_dim_param, 0, nparam);
+	space = isl_space_prefix(space, "c_");
+	space = isl_space_join(isl_space_from_domain(space_param),
+			   isl_space_from_range(space));
+	space = isl_space_wrap(space);
+	space = isl_space_set_tuple_name(space, isl_dim_set, "coefficients");
+
+	return space;
 }
 
-/* Drop the given prefix from all named dimensions of type "type" in "dim".
+/* Drop the given prefix from all named dimensions of type "type" in "space".
  */
-static __isl_give isl_space *isl_space_unprefix(__isl_take isl_space *dim,
+static __isl_give isl_space *isl_space_unprefix(__isl_take isl_space *space,
 	enum isl_dim_type type, const char *prefix)
 {
 	int i;
-	unsigned n;
+	isl_size n;
 	size_t prefix_len = strlen(prefix);
 
-	n = isl_space_dim(dim, type);
+	n = isl_space_dim(space, type);
+	if (n < 0)
+		return isl_space_free(space);
 
 	for (i = 0; i < n; ++i) {
 		const char *name;
 
-		name = isl_space_get_dim_name(dim, type, i);
+		name = isl_space_get_dim_name(space, type, i);
 		if (!name)
 			continue;
 		if (strncmp(name, prefix, prefix_len))
 			continue;
 
-		dim = isl_space_set_dim_name(dim, type, i, name + prefix_len);
+		space = isl_space_set_dim_name(space,
+						type, i, name + prefix_len);
 	}
 
-	return dim;
+	return space;
 }
 
 /* Given a dimension specification of the space of coefficients, construct
@@ -179,19 +191,22 @@
  *
  * and drop the "c_" prefix from the dimension names.
  */
-static __isl_give isl_space *isl_space_solutions(__isl_take isl_space *dim)
+static __isl_give isl_space *isl_space_solutions(__isl_take isl_space *space)
 {
-	unsigned nparam;
-
-	dim = isl_space_unwrap(dim);
-	dim = isl_space_drop_dims(dim, isl_dim_in, 0, 1);
-	dim = isl_space_unprefix(dim, isl_dim_in, "c_");
-	dim = isl_space_unprefix(dim, isl_dim_out, "c_");
-	nparam = isl_space_dim(dim, isl_dim_in);
-	dim = isl_space_move_dims(dim, isl_dim_param, 0, isl_dim_in, 0, nparam);
-	dim = isl_space_range(dim);
-
-	return dim;
+	isl_size nparam;
+
+	space = isl_space_unwrap(space);
+	space = isl_space_drop_dims(space, isl_dim_in, 0, 1);
+	space = isl_space_unprefix(space, isl_dim_in, "c_");
+	space = isl_space_unprefix(space, isl_dim_out, "c_");
+	nparam = isl_space_dim(space, isl_dim_in);
+	if (nparam < 0)
+		return isl_space_free(space);
+	space = isl_space_move_dims(space,
+				    isl_dim_param, 0, isl_dim_in, 0, nparam);
+	space = isl_space_range(space);
+
+	return space;
 }
 
 /* Return the rational universe basic set in the given space.
@@ -210,28 +225,35 @@
  * As explained above, we add an extra dimension to represent
  * the coefficient of the constant term when going from solutions
  * to coefficients (shift == 1) and we drop the extra dimension when going
- * in the opposite direction (shift == -1).  "dim" is the space in which
- * the dual should be created.
+ * in the opposite direction (shift == -1).
+ * The dual can be created in an arbitrary space.
+ * The caller is responsible for putting the result in the appropriate space.
  *
  * If "bset" is (obviously) empty, then the way this emptiness
  * is represented by the constraints does not allow for the application
  * of the standard farkas algorithm.  We therefore handle this case
  * specifically and return the universe basic set.
  */
-static __isl_give isl_basic_set *farkas(__isl_take isl_space *space,
-	__isl_take isl_basic_set *bset, int shift)
+static __isl_give isl_basic_set *farkas(__isl_take isl_basic_set *bset,
+	int shift)
 {
 	int i, j, k;
+	isl_ctx *ctx;
+	isl_space *space;
 	isl_basic_set *dual = NULL;
-	unsigned total;
+	isl_size total;
+
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return isl_basic_set_free(bset);
 
+	ctx = isl_basic_set_get_ctx(bset);
+	space = isl_space_set_alloc(ctx, 0, total + shift);
 	if (isl_basic_set_plain_is_empty(bset)) {
 		isl_basic_set_free(bset);
 		return rational_universe(space);
 	}
 
-	total = isl_basic_set_total_dim(bset);
-
 	dual = isl_basic_set_alloc_space(space, bset->n_eq + bset->n_ineq,
 					total, bset->n_ineq + (shift > 0));
 	dual = isl_basic_set_set_rational(dual);
@@ -281,8 +303,8 @@
 	}
 
 	dual = isl_basic_set_remove_divs(dual);
-	isl_basic_set_simplify(dual);
-	isl_basic_set_finalize(dual);
+	dual = isl_basic_set_simplify(dual);
+	dual = isl_basic_set_finalize(dual);
 
 	isl_basic_set_free(bset);
 	return dual;
@@ -293,12 +315,531 @@
 }
 
 /* Construct a basic set containing the tuples of coefficients of all
+ * valid affine constraints on the given basic set, ignoring
+ * the space of input and output and without any further decomposition.
+ */
+static __isl_give isl_basic_set *isl_basic_set_coefficients_base(
+	__isl_take isl_basic_set *bset)
+{
+	return farkas(bset, 1);
+}
+
+/* Return the inverse mapping of "morph".
+ */
+static __isl_give isl_mat *peek_inv(__isl_keep isl_morph *morph)
+{
+	return morph ? morph->inv : NULL;
+}
+
+/* Return a copy of the inverse mapping of "morph".
+ */
+static __isl_give isl_mat *get_inv(__isl_keep isl_morph *morph)
+{
+	return isl_mat_copy(peek_inv(morph));
+}
+
+/* Information about a single factor within isl_basic_set_coefficients_product.
+ *
+ * "start" is the position of the first coefficient (beyond
+ * the one corresponding to the constant term) in this factor.
+ * "dim" is the number of coefficients (other than
+ * the one corresponding to the constant term) in this factor.
+ * "n_line" is the number of lines in "coeff".
+ * "n_ray" is the number of rays (other than lines) in "coeff".
+ * "n_vertex" is the number of vertices in "coeff".
+ *
+ * While iterating over the vertices,
+ * "pos" represents the inequality constraint corresponding
+ * to the current vertex.
+ */
+struct isl_coefficients_factor_data {
+	isl_basic_set *coeff;
+	int start;
+	int dim;
+	int n_line;
+	int n_ray;
+	int n_vertex;
+	int pos;
+};
+
+/* Internal data structure for isl_basic_set_coefficients_product.
+ * "n" is the number of factors in the factorization.
+ * "pos" is the next factor that will be considered.
+ * "start_next" is the position of the first coefficient (beyond
+ * the one corresponding to the constant term) in the next factor.
+ * "factors" contains information about the individual "n" factors.
+ */
+struct isl_coefficients_product_data {
+	int n;
+	int pos;
+	int start_next;
+	struct isl_coefficients_factor_data *factors;
+};
+
+/* Initialize the internal data structure for
+ * isl_basic_set_coefficients_product.
+ */
+static isl_stat isl_coefficients_product_data_init(isl_ctx *ctx,
+	struct isl_coefficients_product_data *data, int n)
+{
+	data->n = n;
+	data->pos = 0;
+	data->start_next = 0;
+	data->factors = isl_calloc_array(ctx,
+					struct isl_coefficients_factor_data, n);
+	if (!data->factors)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Free all memory allocated in "data".
+ */
+static void isl_coefficients_product_data_clear(
+	struct isl_coefficients_product_data *data)
+{
+	int i;
+
+	if (data->factors) {
+		for (i = 0; i < data->n; ++i) {
+			isl_basic_set_free(data->factorsi.coeff);
+		}
+	}
+	free(data->factors);
+}
+
+/* Does inequality "ineq" in the (dual) basic set "bset" represent a ray?
+ * In particular, does it have a zero denominator
+ * (i.e., a zero coefficient for the constant term)?
+ */
+static int is_ray(__isl_keep isl_basic_set *bset, int ineq)
+{
+	return isl_int_is_zero(bset->ineqineq1);
+}
+
+/* isl_factorizer_every_factor_basic_set callback that
+ * constructs a basic set containing the tuples of coefficients of all
+ * valid affine constraints on the factor "bset" and
+ * extracts further information that will be used
+ * when combining the results over the different factors.
+ */
+static isl_bool isl_basic_set_coefficients_factor(
+	__isl_keep isl_basic_set *bset, void *user)
+{
+	struct isl_coefficients_product_data *data = user;
+	isl_basic_set *coeff;
+	isl_size n_eq, n_ineq, dim;
+	int i, n_ray, n_vertex;
+
+	coeff = isl_basic_set_coefficients_base(isl_basic_set_copy(bset));
+	data->factorsdata->pos.coeff = coeff;
+	if (!coeff)
+		return isl_bool_error;
+
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	n_eq = isl_basic_set_n_equality(coeff);
+	n_ineq = isl_basic_set_n_inequality(coeff);
+	if (dim < 0 || n_eq < 0 || n_ineq < 0)
+		return isl_bool_error;
+	n_ray = n_vertex = 0;
+	for (i = 0; i < n_ineq; ++i) {
+		if (is_ray(coeff, i))
+			n_ray++;
+		else
+			n_vertex++;
+	}
+	data->factorsdata->pos.start = data->start_next;
+	data->factorsdata->pos.dim = dim;
+	data->factorsdata->pos.n_line = n_eq;
+	data->factorsdata->pos.n_ray = n_ray;
+	data->factorsdata->pos.n_vertex = n_vertex;
+	data->pos++;
+	data->start_next += dim;
+
+	return isl_bool_true;
+}
+
+/* Clear an entry in the product, given that there is a "total" number
+ * of coefficients (other than that of the constant term).
+ */
+static void clear_entry(isl_int *entry, int total)
+{
+	isl_seq_clr(entry, 1 + 1 + total);
+}
+
+/* Set the part of the entry corresponding to factor "data",
+ * from the factor coefficients in "src".
+ */
+static void set_factor(isl_int *entry, isl_int *src,
+	struct isl_coefficients_factor_data *data)
+{
+	isl_seq_cpy(entry + 1 + 1 + data->start, src + 1 + 1, data->dim);
+}
+
+/* Set the part of the entry corresponding to factor "data",
+ * from the factor coefficients in "src" multiplied by "f".
+ */
+static void scale_factor(isl_int *entry, isl_int *src, isl_int f,
+	struct isl_coefficients_factor_data *data)
+{
+	isl_seq_scale(entry + 1 + 1 + data->start, src + 1 + 1, f, data->dim);
+}
+
+/* Add all lines from the given factor to "bset",
+ * given that there is a "total" number of coefficients
+ * (other than that of the constant term).
+ */
+static __isl_give isl_basic_set *add_lines(__isl_take isl_basic_set *bset,
+	struct isl_coefficients_factor_data *factor, int total)
+{
+	int i;
+
+	for (i = 0; i < factor->n_line; ++i) {
+		int k;
+
+		k = isl_basic_set_alloc_equality(bset);
+		if (k < 0)
+			return isl_basic_set_free(bset);
+		clear_entry(bset->eqk, total);
+		set_factor(bset->eqk, factor->coeff->eqi, factor);
+	}
+
+	return bset;
+}
+
+/* Add all rays (other than lines) from the given factor to "bset",
+ * given that there is a "total" number of coefficients
+ * (other than that of the constant term).
+ */
+static __isl_give isl_basic_set *add_rays(__isl_take isl_basic_set *bset,
+	struct isl_coefficients_factor_data *data, int total)
+{
+	int i;
+	int n_ineq = data->n_ray + data->n_vertex;
+
+	for (i = 0; i < n_ineq; ++i) {
+		int k;
+
+		if (!is_ray(data->coeff, i))
+			continue;
+
+		k = isl_basic_set_alloc_inequality(bset);
+		if (k < 0)
+			return isl_basic_set_free(bset);
+		clear_entry(bset->ineqk, total);
+		set_factor(bset->ineqk, data->coeff->ineqi, data);
+	}
+
+	return bset;
+}
+
+/* Move to the first vertex of the given factor starting
+ * at inequality constraint "start", setting factor->pos and
+ * returning 1 if a vertex is found.
+ */
+static int factor_first_vertex(struct isl_coefficients_factor_data *factor,
+	int start)
+{
+	int j;
+	int n = factor->n_ray + factor->n_vertex;
+
+	for (j = start; j < n; ++j) {
+		if (is_ray(factor->coeff, j))
+			continue;
+		factor->pos = j;
+		return 1;
+	}
+
+	return 0;
+}
+
+/* Move to the first constraint in each factor starting at "first"
+ * that represents a vertex.
+ * In particular, skip the initial constraints that correspond to rays.
+ */
+static void first_vertex(struct isl_coefficients_product_data *data, int first)
+{
+	int i;
+
+	for (i = first; i < data->n; ++i)
+		factor_first_vertex(&data->factorsi, 0);
+}
+
+/* Move to the next vertex in the product.
+ * In particular, move to the next vertex of the last factor.
+ * If all vertices of this last factor have already been considered,
+ * then move to the next vertex of the previous factor(s)
+ * until a factor is found that still has a next vertex.
+ * Once such a next vertex has been found, the subsequent
+ * factors are reset to the first vertex.
+ * Return 1 if any next vertex was found.
+ */
+static int next_vertex(struct isl_coefficients_product_data *data)
+{
+	int i;
+
+	for (i = data->n - 1; i >= 0; --i) {
+		struct isl_coefficients_factor_data *factor = &data->factorsi;
+
+		if (!factor_first_vertex(factor, factor->pos + 1))
+			continue;
+		first_vertex(data, i + 1);
+		return 1;
+	}
+
+	return 0;
+}
+
+/* Add a vertex to the product "bset" combining the currently selected
+ * vertices of the factors.
+ *
+ * In the dual representation, the constant term is always zero.
+ * The vertex itself is the sum of the contributions of the factors
+ * with a shared denominator in position 1.
+ *
+ * First compute the shared denominator (lcm) and
+ * then scale the numerators to this shared denominator.
+ */
+static __isl_give isl_basic_set *add_vertex(__isl_take isl_basic_set *bset,
+	struct isl_coefficients_product_data *data)
+{
+	int i;
+	int k;
+	isl_int lcm, f;
+
+	k = isl_basic_set_alloc_inequality(bset);
+	if (k < 0)
+		return isl_basic_set_free(bset);
+
+	isl_int_init(lcm);
+	isl_int_init(f);
+	isl_int_set_si(lcm, 1);
+	for (i = 0; i < data->n; ++i) {
+		struct isl_coefficients_factor_data *factor = &data->factorsi;
+		isl_basic_set *coeff = factor->coeff;
+		int pos = factor->pos;
+		isl_int_lcm(lcm, lcm, coeff->ineqpos1);
+	}
+	isl_int_set_si(bset->ineqk0, 0);
+	isl_int_set(bset->ineqk1, lcm);
+
+	for (i = 0; i < data->n; ++i) {
+		struct isl_coefficients_factor_data *factor = &data->factorsi;
+		isl_basic_set *coeff = factor->coeff;
+		int pos = factor->pos;
+		isl_int_divexact(f, lcm, coeff->ineqpos1);
+		scale_factor(bset->ineqk, coeff->ineqpos, f, factor);
+	}
+
+	isl_int_clear(f);
+	isl_int_clear(lcm);
+
+	return bset;
+}
+
+/* Combine the duals of the factors in the factorization of a basic set
+ * to form the dual of the entire basic set.
+ * The dual share the coefficient of the constant term.
+ * All other coefficients are specific to a factor.
+ * Any constraint not involving the coefficient of the constant term
+ * can therefor simply be copied into the appropriate position.
+ * This includes all equality constraints since the coefficient
+ * of the constant term can always be increased and therefore
+ * never appears in an equality constraint.
+ * The inequality constraints involving the coefficient of
+ * the constant term need to be combined across factors.
+ * In particular, if this coefficient needs to be greater than or equal
+ * to some linear combination of the other coefficients in each factor,
+ * then it needs to be greater than or equal to the sum of
+ * these linear combinations across the factors.
+ *
+ * Alternatively, the constraints of the dual can be seen
+ * as the vertices, rays and lines of the original basic set.
+ * Clearly, rays and lines can simply be copied,
+ * while vertices needs to be combined across factors.
+ * This means that the number of rays and lines in the product
+ * is equal to the sum of the numbers in the factors,
+ * while the number of vertices is the product
+ * of the number of vertices in the factors.  Note that each
+ * factor has at least one vertex.
+ * The only exception is when the factor is the dual of an obviously empty set,
+ * in which case a universe dual is created.
+ * In this case, return a universe dual for the product as well.
+ *
+ * While constructing the vertices, look for the first combination
+ * of inequality constraints that represent a vertex,
+ * construct the corresponding vertex and then move on
+ * to the next combination of inequality constraints until
+ * all combinations have been considered.
+ */
+static __isl_give isl_basic_set *construct_product(isl_ctx *ctx,
+	struct isl_coefficients_product_data *data)
+{
+	int i;
+	int n_line, n_ray, n_vertex;
+	int total;
+	isl_space *space;
+	isl_basic_set *product;
+
+	if (!data->factors)
+		return NULL;
+
+	total = data->start_next;
+
+	n_line = 0;
+	n_ray = 0;
+	n_vertex = 1;
+	for (i = 0; i < data->n; ++i) {
+		n_line += data->factorsi.n_line;
+		n_ray += data->factorsi.n_ray;
+		n_vertex *= data->factorsi.n_vertex;
+	}
+
+	space = isl_space_set_alloc(ctx, 0, 1 + total);
+	if (n_vertex == 0)
+		return rational_universe(space);
+	product = isl_basic_set_alloc_space(space, 0, n_line, n_ray + n_vertex);
+	product = isl_basic_set_set_rational(product);
+
+	for (i = 0; i < data->n; ++i)
+		product = add_lines(product, &data->factorsi, total);
+	for (i = 0; i < data->n; ++i)
+		product = add_rays(product, &data->factorsi, total);
+
+	first_vertex(data, 0);
+	do {
+		product = add_vertex(product, data);
+	} while (next_vertex(data));
+
+	return product;
+}
+
+/* Given a factorization "f" of a basic set,
+ * construct a basic set containing the tuples of coefficients of all
+ * valid affine constraints on the product of the factors, ignoring
+ * the space of input and output.
+ * Note that this product may not be equal to the original basic set,
+ * if a non-trivial transformation is involved.
+ * This is handled by the caller.
+ *
+ * Compute the tuples of coefficients for each factor separately and
+ * then combine the results.
+ */
+static __isl_give isl_basic_set *isl_basic_set_coefficients_product(
+	__isl_take isl_factorizer *f)
+{
+	struct isl_coefficients_product_data data;
+	isl_ctx *ctx;
+	isl_basic_set *coeff;
+	isl_bool every;
+
+	ctx = isl_factorizer_get_ctx(f);
+	if (isl_coefficients_product_data_init(ctx, &data, f->n_group) < 0)
+		f = isl_factorizer_free(f);
+	every = isl_factorizer_every_factor_basic_set(f,
+			&isl_basic_set_coefficients_factor, &data);
+	isl_factorizer_free(f);
+	if (every >= 0)
+		coeff = construct_product(ctx, &data);
+	else
+		coeff = NULL;
+	isl_coefficients_product_data_clear(&data);
+
+	return coeff;
+}
+
+/* Given a factorization "f" of a basic set,
+ * construct a basic set containing the tuples of coefficients of all
+ * valid affine constraints on the basic set, ignoring
+ * the space of input and output.
+ *
+ * The factorization may involve a linear transformation of the basic set.
+ * In particular, the transformed basic set is formulated
+ * in terms of x' = U x, i.e., x = V x', with V = U^{-1}.
+ * The dual is then computed in terms of y' with y'^t z; x' >= 0.
+ * Plugging in y' = 1 0; 0 V^t y yields
+ * y^t 1 0; 0 V z; x' >= 0, i.e., y^t z; x >= 0, which is
+ * the desired set of coefficients y.
+ * Note that this transformation to y' only needs to be applied
+ * if U is not the identity matrix.
+ */
+static __isl_give isl_basic_set *isl_basic_set_coefficients_morphed_product(
+	__isl_take isl_factorizer *f)
+{
+	isl_bool is_identity;
+	isl_space *space;
+	isl_mat *inv;
+	isl_multi_aff *ma;
+	isl_basic_set *coeff;
+
+	if (!f)
+		goto error;
+	is_identity = isl_mat_is_scaled_identity(peek_inv(f->morph));
+	if (is_identity < 0)
+		goto error;
+	if (is_identity)
+		return isl_basic_set_coefficients_product(f);
+
+	inv = get_inv(f->morph);
+	inv = isl_mat_transpose(inv);
+	inv = isl_mat_lin_to_aff(inv);
+
+	coeff = isl_basic_set_coefficients_product(f);
+	space = isl_space_map_from_set(isl_basic_set_get_space(coeff));
+	ma = isl_multi_aff_from_aff_mat(space, inv);
+	coeff = isl_basic_set_preimage_multi_aff(coeff, ma);
+
+	return coeff;
+error:
+	isl_factorizer_free(f);
+	return NULL;
+}
+
+/* Construct a basic set containing the tuples of coefficients of all
+ * valid affine constraints on the given basic set, ignoring
+ * the space of input and output.
+ *
+ * The caller has already checked that "bset" does not involve
+ * any local variables.  It may have parameters, though.
+ * Treat them as regular variables internally.
+ * This is especially important for the factorization,
+ * since the (original) parameters should be taken into account
+ * explicitly in this factorization.
+ *
+ * Check if the basic set can be factorized.
+ * If so, compute constraints on the coefficients of the factors
+ * separately and combine the results.
+ * Otherwise, compute the results for the input basic set as a whole.
+ */
+static __isl_give isl_basic_set *basic_set_coefficients(
+	__isl_take isl_basic_set *bset)
+{
+	isl_factorizer *f;
+	isl_size nparam;
+
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0)
+		return isl_basic_set_free(bset);
+	bset = isl_basic_set_move_dims(bset, isl_dim_set, 0,
+					    isl_dim_param, 0, nparam);
+
+	f = isl_basic_set_factorizer(bset);
+	if (!f)
+		return isl_basic_set_free(bset);
+	if (f->n_group > 0) {
+		isl_basic_set_free(bset);
+		return isl_basic_set_coefficients_morphed_product(f);
+	}
+	isl_factorizer_free(f);
+	return isl_basic_set_coefficients_base(bset);
+}
+
+/* Construct a basic set containing the tuples of coefficients of all
  * valid affine constraints on the given basic set.
  */
 __isl_give isl_basic_set *isl_basic_set_coefficients(
 	__isl_take isl_basic_set *bset)
 {
-	isl_space *dim;
+	isl_space *space;
 
 	if (!bset)
 		return NULL;
@@ -307,10 +848,12 @@
 			"input set not allowed to have local variables",
 			goto error);
 
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_coefficients(dim);
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_coefficients(space);
 
-	return farkas(dim, bset, 1);
+	bset = basic_set_coefficients(bset);
+	bset = isl_basic_set_reset_space(bset, space);
+	return bset;
 error:
 	isl_basic_set_free(bset);
 	return NULL;
@@ -323,7 +866,7 @@
 __isl_give isl_basic_set *isl_basic_set_solutions(
 	__isl_take isl_basic_set *bset)
 {
-	isl_space *dim;
+	isl_space *space;
 
 	if (!bset)
 		return NULL;
@@ -332,10 +875,12 @@
 			"input set not allowed to have local variables",
 			goto error);
 
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_solutions(dim);
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_solutions(space);
 
-	return farkas(dim, bset, -1);
+	bset = farkas(bset, -1);
+	bset = isl_basic_set_reset_space(bset, space);
+	return bset;
 error:
 	isl_basic_set_free(bset);
 	return NULL;
@@ -371,6 +916,24 @@
 	return coeff;
 }
 
+/* Wrapper around isl_basic_set_coefficients for use
+ * as a isl_basic_set_list_map callback.
+ */
+static __isl_give isl_basic_set *coefficients_wrap(
+	__isl_take isl_basic_set *bset, void *user)
+{
+	return isl_basic_set_coefficients(bset);
+}
+
+/* Replace the elements of "list" by the result of applying
+ * isl_basic_set_coefficients to them.
+ */
+__isl_give isl_basic_set_list *isl_basic_set_list_coefficients(
+	__isl_take isl_basic_set_list *list)
+{
+	return isl_basic_set_list_map(list, &coefficients_wrap, NULL);
+}
+
 /* Construct a basic set containing the elements that satisfy all
  * affine constraints whose coefficient tuples are
  * contained in the given set.

_service:tar_scm:isl-0.24.tar.gz/isl_ffs.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_flow.c -> _service:tar_scm:isl-0.24.tar.gz/isl_flow.c Changed

@@ -3,6 +3,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  * Copyright 2012      Universiteit Leiden
+ * Copyright 2014      Ecole Normale Superieure
  *
  * Use of this software is governed by the MIT license
  *
@@ -12,12 +13,19 @@
  * B-3001 Leuven, Belgium
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
  */
 
+#include <isl/val.h>
+#include <isl/space.h>
 #include <isl/set.h>
 #include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
 #include <isl/flow.h>
+#include <isl/schedule_node.h>
 #include <isl_sort.h>
+#include <isl/stream.h>
 
 enum isl_restriction_type {
 	isl_restriction_type_empty,
@@ -154,14 +162,21 @@
 	int		must;
 };
 
+typedef isl_bool (*isl_access_coscheduled)(void *first, void *second);
+
 /* A structure containing the input for dependence analysis:
  * - a sink
  * - n_must + n_may (<= max_source) sources
  * - a function for determining the relative order of sources and sink
+ * - an optional function "coscheduled" for determining whether sources
+ *   may be coscheduled.  If "coscheduled" is NULL, then the sources
+ *   are assumed not to be coscheduled.
  * The must sources are placed before the may sources.
  *
  * domain_map is an auxiliary map that maps the sink access relation
  * to the domain of this access relation.
+ * This field is only needed when restrict_fn is set and
+ * the field itself is set by isl_access_info_compute_flow.
  *
  * restrict_fn is a callback that (if not NULL) will be called
  * right before any lexicographical maximization.
@@ -170,6 +185,7 @@
 	isl_map				*domain_map;
 	struct isl_labeled_map		sink;
 	isl_access_level_before		level_before;
+	isl_access_coscheduled		coscheduled;
 
 	isl_access_restrict		restrict_fn;
 	void				*restrict_user;
@@ -297,6 +313,13 @@
 	return NULL;
 }
 
+/* A helper struct carrying the isl_access_info and an error condition.
+ */
+struct access_sort_info {
+	isl_access_info *access_info;
+	int error;
+};
+
 /* Return -n, 0 or n (with n a positive value), depending on whether
  * the source access identified by p1 should be sorted before, together
  * or after that identified by p2.
@@ -309,10 +332,18 @@
  * If not, we try to order the two statements based on the description
  * of the iteration domains.  This results in an arbitrary, but fairly
  * stable ordering.
+ *
+ * In case of an error, sort_info.error is set to true and all elements are
+ * reported to be equal.
  */
 static int access_sort_cmp(const void *p1, const void *p2, void *user)
 {
-	isl_access_info *acc = user;
+	struct access_sort_info *sort_info = user;
+	isl_access_info *acc = sort_info->access_info;
+
+	if (sort_info->error)
+		return 0;
+
 	const struct isl_labeled_map *i1, *i2;
 	int level1, level2;
 	uint32_t h1, h2;
@@ -320,16 +351,23 @@
 	i2 = (const struct isl_labeled_map *) p2;
 
 	level1 = acc->level_before(i1->data, i2->data);
+	if (level1 < 0)
+		goto error;
 	if (level1 % 2)
 		return -1;
 
 	level2 = acc->level_before(i2->data, i1->data);
+	if (level2 < 0)
+		goto error;
 	if (level2 % 2)
 		return 1;
 
 	h1 = isl_map_get_hash(i1->map);
 	h2 = isl_map_get_hash(i2->map);
 	return h1 > h2 ? 1 : h1 < h2 ? -1 : 0;
+error:
+	sort_info->error = 1;
+	return 0;
 }
 
 /* Sort the must source accesses in their textual order.
@@ -337,13 +375,20 @@
 static __isl_give isl_access_info *isl_access_info_sort_sources(
 	__isl_take isl_access_info *acc)
 {
+	struct access_sort_info sort_info;
+
+	sort_info.access_info = acc;
+	sort_info.error = 0;
+
 	if (!acc)
 		return NULL;
 	if (acc->n_must <= 1)
 		return acc;
 
 	if (isl_sort(acc->source, acc->n_must, sizeof(struct isl_labeled_map),
-		    access_sort_cmp, acc) < 0)
+		    access_sort_cmp, &sort_info) < 0)
+		return isl_access_info_free(acc);
+	if (sort_info.error)
 		return isl_access_info_free(acc);
 
 	return acc;
@@ -355,12 +400,21 @@
 static __isl_give isl_space *space_align_and_join(__isl_take isl_space *left,
 	__isl_take isl_space *right)
 {
-	if (isl_space_match(left, isl_dim_param, right, isl_dim_param))
+	isl_bool equal_params;
+
+	equal_params = isl_space_has_equal_params(left, right);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params)
 		return isl_space_join(left, right);
 
 	left = isl_space_align_params(left, isl_space_copy(right));
 	right = isl_space_align_params(right, isl_space_copy(left));
 	return isl_space_join(left, right);
+error:
+	isl_space_free(left);
+	isl_space_free(right);
+	return NULL;
 }
 
 /* Initialize an empty isl_flow structure corresponding to a given
@@ -394,11 +448,11 @@
 
 	dep->n_source = n;
 	for (i = 0; i < acc->n_must; ++i) {
-		isl_space *dim;
-		dim = space_align_and_join(
+		isl_space *space;
+		space = space_align_and_join(
 			isl_map_get_space(acc->sourcei.map),
 			isl_space_reverse(isl_map_get_space(acc->sink.map)));
-		dep->dep2 * i.map = isl_map_empty(dim);
+		dep->dep2 * i.map = isl_map_empty(space);
 		dep->dep2 * i + 1.map = isl_map_copy(dep->dep2 * i.map);
 		dep->dep2 * i.data = acc->sourcei.data;
 		dep->dep2 * i + 1.data = acc->sourcei.data;
@@ -408,11 +462,11 @@
 			goto error;
 	}
 	for (i = acc->n_must; i < acc->n_must + acc->n_may; ++i) {
-		isl_space *dim;
-		dim = space_align_and_join(
+		isl_space *space;
+		space = space_align_and_join(
 			isl_map_get_space(acc->sourcei.map),
 			isl_space_reverse(isl_map_get_space(acc->sink.map)));
-		dep->depacc->n_must + i.map = isl_map_empty(dim);
+		dep->depacc->n_must + i.map = isl_map_empty(space);
 		dep->depacc->n_must + i.data = acc->sourcei.data;
 		dep->depacc->n_must + i.must = 0;
 		if (!dep->depacc->n_must + i.map)
@@ -431,24 +485,25 @@
  * while the third argument correspond to the final argument of
  * the isl_flow_foreach call.
  */
-int isl_flow_foreach(__isl_keep isl_flow *deps,
-	int (*fn)(__isl_take isl_map *dep, int must, void *dep_user, void *user),
+isl_stat isl_flow_foreach(__isl_keep isl_flow *deps,
+	isl_stat (*fn)(__isl_take isl_map *dep, int must, void *dep_user,
+		void *user),
 	void *user)
 {
 	int i;
 
 	if (!deps)
-		return -1;
+		return isl_stat_error;
 
 	for (i = 0; i < deps->n_source; ++i) {
 		if (isl_map_plain_is_empty(deps->depi.map))
 			continue;
 		if (fn(isl_map_copy(deps->depi.map), deps->depi.must,
 				deps->depi.data, user) < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Return a copy of the subset of the sink for which no source could be found.
@@ -464,12 +519,12 @@
 		return isl_set_unwrap(isl_set_copy(deps->may_no_source));
 }
 
-void isl_flow_free(__isl_take isl_flow *deps)
+__isl_null isl_flow *isl_flow_free(__isl_take isl_flow *deps)
 {
 	int i;
 
 	if (!deps)
-		return;
+		return NULL;
 	isl_set_free(deps->must_no_source);
 	isl_set_free(deps->may_no_source);
 	if (deps->dep) {
@@ -478,6 +533,8 @@
 		free(deps->dep);
 	}
 	free(deps);
+
+	return NULL;
 }
 
 isl_ctx *isl_flow_get_ctx(__isl_keep isl_flow *deps)
@@ -495,14 +552,15 @@
  * be greater than the loop iterator of the range at the last
  * of the level/2 shared loops, i.e., loop level/2 - 1.
  */
-static __isl_give isl_map *after_at_level(__isl_take isl_space *dim, int level)
+static __isl_give isl_map *after_at_level(__isl_take isl_space *space,
+	int level)
 {
 	struct isl_basic_map *bmap;
 
 	if (level % 2)
-		bmap = isl_basic_map_equal(dim, level/2);
+		bmap = isl_basic_map_equal(space, level/2);
 	else
-		bmap = isl_basic_map_more_at(dim, level/2 - 1);
+		bmap = isl_basic_map_more_at(space, level/2 - 1);
 
 	return isl_map_from_basic_map(bmap);
 }
@@ -609,7 +667,7 @@
 					 int k, int after_level,
 					 struct isl_set **empty)
 {
-	isl_space *dim;
+	isl_space *space;
 	struct isl_set *set_C;
 	struct isl_map *read_map;
 	struct isl_map *write_map;
@@ -624,9 +682,9 @@
 
 	write_map = isl_map_reverse(write_map);
 	dep_map = isl_map_apply_range(read_map, write_map);
-	dim = space_align_and_join(isl_map_get_space(acc->sourcek.map),
+	space = space_align_and_join(isl_map_get_space(acc->sourcek.map),
 		    isl_space_reverse(isl_map_get_space(acc->sourcej.map)));
-	after_write = after_at_level(dim, after_level);
+	after_write = after_at_level(space, after_level);
 	after_write = isl_map_apply_range(after_write, old_map);
 	after_write = isl_map_reverse(after_write);
 	dep_map = isl_map_intersect(dep_map, after_write);
@@ -666,24 +724,34 @@
  *
  * If temp_relj is empty, then there can be no improvement and
  * we return immediately.
+ *
+ * This function returns isl_stat_ok in case it was executed successfully and
+ * isl_stat_error in case of errors during the execution of this function.
  */
-static int intermediate_sources(__isl_keep isl_access_info *acc,
+static isl_stat intermediate_sources(__isl_keep isl_access_info *acc,
 	struct isl_map **temp_rel, int j, int sink_level)
 {
 	int k, level;
-	int depth = 2 * isl_map_dim(acc->sourcej.map, isl_dim_in) + 1;
+	isl_size n_in = isl_map_dim(acc->sourcej.map, isl_dim_in);
+	int depth = 2 * n_in + 1;
 
+	if (n_in < 0)
+		return isl_stat_error;
 	if (isl_map_plain_is_empty(temp_relj))
-		return 0;
+		return isl_stat_ok;
 
 	for (k = j - 1; k >= 0; --k) {
 		int plevel, plevel2;
 		plevel = acc->level_before(acc->sourcek.data, acc->sink.data);
+		if (plevel < 0)
+			return isl_stat_error;
 		if (!can_precede_at_level(plevel, sink_level))
 			continue;
 
 		plevel2 = acc->level_before(acc->sourcej.data,
 						acc->sourcek.data);
+		if (plevel2 < 0)
+			return isl_stat_error;
 
 		for (level = sink_level; level <= depth; ++level) {
 			struct isl_map *T;
@@ -706,7 +774,7 @@
 		}
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Compute all iterations of may source j that precedes the sink at the given
@@ -732,7 +800,7 @@
 }
 
 /* For a given mapping between iterations of must source k and iterations
- * of the sink, compute the all iteration of may source j preceding
+ * of the sink, compute all iterations of may source j preceding
  * the sink at level before_level for any of the sink iterations,
  * but following the corresponding iteration of must source k at level
  * after_level.
@@ -741,7 +809,7 @@
 	__isl_take isl_map *old_map,
 	int j, int before_level, int k, int after_level)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_set *set_C;
 	isl_map *read_map;
 	isl_map *write_map;
@@ -756,9 +824,10 @@
 
 	write_map = isl_map_reverse(write_map);
 	dep_map = isl_map_apply_range(read_map, write_map);
-	dim = isl_space_join(isl_map_get_space(acc->sourceacc->n_must + j.map),
+	space = isl_space_join(isl_map_get_space(
+		    acc->sourceacc->n_must + j.map),
 		    isl_space_reverse(isl_map_get_space(acc->sourcek.map)));
-	after_write = after_at_level(dim, after_level);
+	after_write = after_at_level(space, after_level);
 	after_write = isl_map_apply_range(after_write, old_map);
 	after_write = isl_map_reverse(after_write);
 	dep_map = isl_map_intersect(dep_map, after_write);
@@ -780,9 +849,12 @@
 	int j, int sink_level)
 {
 	int k, level;
-	int depth = 2 * isl_map_dim(acc->sourceacc->n_must + j.map,
-					isl_dim_in) + 1;
+	isl_size n_in = isl_map_dim(acc->sourceacc->n_must + j.map,
+				    isl_dim_in);
+	int depth = 2 * n_in + 1;
 
+	if (n_in < 0)
+		return isl_map_free(map);
 	for (k = 0; k < acc->n_must; ++k) {
 		int plevel;
 
@@ -792,6 +864,8 @@
 
 		plevel = acc->level_before(acc->sourcek.data,
 					acc->sourceacc->n_must + j.data);
+		if (plevel < 0)
+			return isl_map_free(map);
 
 		for (level = sink_level; level <= depth; ++level) {
 			isl_map *T;
@@ -823,6 +897,157 @@
 	return map;
 }
 
+/* Given a dependence relation "old_map" between a must-source and the sink,
+ * return a subset of the dependences, augmented with instances
+ * of the source at position "pos" in "acc" that are coscheduled
+ * with the must-source and that access the same element.
+ * That is, if the input lives in a space T -> K, then the output
+ * lives in the space T -> S -> K, with S the space of source "pos", and
+ * the domain factor of the domain product is a subset of the input.
+ * The sources are considered to be coscheduled if they have the same values
+ * for the initial "depth" coordinates.
+ *
+ * First construct a dependence relation S -> K and a mapping
+ * between coscheduled sources T -> S.
+ * The second is combined with the original dependence relation T -> K
+ * to form a relation in T -> S -> K, which is subsequently
+ * uncurried to T -> S -> K.
+ * This result is then intersected with the dependence relation S -> K
+ * to form the output.
+ *
+ * In case a negative depth is given, NULL is returned to indicate an error.
+ */
+static __isl_give isl_map *coscheduled_source(__isl_keep isl_access_info *acc,
+	__isl_keep isl_map *old_map, int pos, int depth)
+{
+	isl_space *space;
+	isl_set *set_C;
+	isl_map *read_map;
+	isl_map *write_map;
+	isl_map *dep_map;
+	isl_map *equal;
+	isl_map *map;
+
+	if (depth < 0)
+		return NULL;
+
+	set_C = isl_map_range(isl_map_copy(old_map));
+	read_map = isl_map_copy(acc->sink.map);
+	read_map = isl_map_intersect_domain(read_map, set_C);
+	write_map = isl_map_copy(acc->sourcepos.map);
+	dep_map = isl_map_domain_product(write_map, read_map);
+	dep_map = isl_set_unwrap(isl_map_domain(dep_map));
+	space = isl_space_join(isl_map_get_space(old_map),
+				isl_space_reverse(isl_map_get_space(dep_map)));
+	equal = isl_map_from_basic_map(isl_basic_map_equal(space, depth));
+	map = isl_map_range_product(equal, isl_map_copy(old_map));
+	map = isl_map_uncurry(map);
+	map = isl_map_intersect_domain_factor_range(map, dep_map);
+
+	return map;
+}
+
+/* After the dependences derived from a must-source have been computed
+ * at a certain level, check if any of the sources of the must-dependences
+ * may be coscheduled with other sources.
+ * If they are any such sources, then there is no way of determining
+ * which of the sources actually comes last and the must-dependences
+ * need to be turned into may-dependences, while dependences from
+ * the other sources need to be added to the may-dependences as well.
+ * "acc" describes the sources and a callback for checking whether
+ * two sources may be coscheduled.  If acc->coscheduled is NULL then
+ * the sources are assumed not to be coscheduled.
+ * "must_rel" and "may_rel" describe the must and may-dependence relations
+ * computed at the current level for the must-sources.  Some of the dependences
+ * may be moved from "must_rel" to "may_rel".
+ * "flow" contains all dependences computed so far (apart from those
+ * in "must_rel" and "may_rel") and may be updated with additional
+ * dependences derived from may-sources.
+ *
+ * In particular, consider all the must-sources with a non-empty
+ * dependence relation in "must_rel".  They are considered in reverse
+ * order because that is the order in which they are considered in the caller.
+ * If any of the must-sources are coscheduled, then the last one
+ * is the one that will have a corresponding dependence relation.
+ * For each must-source i, consider both all the previous must-sources
+ * and all the may-sources.  If any of those may be coscheduled with
+ * must-source i, then compute the coscheduled instances that access
+ * the same memory elements.  The result is a relation T -> S -> K.
+ * The projection onto T -> K is a subset of the must-dependence relation
+ * that needs to be turned into may-dependences.
+ * The projection onto S -> K needs to be added to the may-dependences
+ * of source S.
+ * Since a given must-source instance may be coscheduled with several
+ * other source instances, the dependences that need to be turned
+ * into may-dependences are first collected and only actually removed
+ * from the must-dependences after all other sources have been considered.
+ */
+static __isl_give isl_flow *handle_coscheduled(__isl_keep isl_access_info *acc,
+	__isl_keep isl_map **must_rel, __isl_keep isl_map **may_rel,
+	__isl_take isl_flow *flow)
+{
+	int i, j;
+
+	if (!acc->coscheduled)
+		return flow;
+	for (i = acc->n_must - 1; i >= 0; --i) {
+		isl_map *move;
+
+		if (isl_map_plain_is_empty(must_reli))
+			continue;
+		move = isl_map_empty(isl_map_get_space(must_reli));
+		for (j = i - 1; j >= 0; --j) {
+			int depth;
+			isl_bool coscheduled;
+			isl_map *map, *factor;
+
+			coscheduled = acc->coscheduled(acc->sourcei.data,
+							acc->sourcej.data);
+			if (coscheduled < 0) {
+				isl_map_free(move);
+				return isl_flow_free(flow);
+			}
+			if (!coscheduled)
+				continue;
+			depth = acc->level_before(acc->sourcei.data,
+						acc->sourcej.data) / 2;
+			map = coscheduled_source(acc, must_reli, j, depth);
+			factor = isl_map_domain_factor_range(isl_map_copy(map));
+			may_relj = isl_map_union(may_relj, factor);
+			map = isl_map_domain_factor_domain(map);
+			move = isl_map_union(move, map);
+		}
+		for (j = 0; j < acc->n_may; ++j) {
+			int depth, pos;
+			isl_bool coscheduled;
+			isl_map *map, *factor;
+
+			pos = acc->n_must + j;
+			coscheduled = acc->coscheduled(acc->sourcei.data,
+							acc->sourcepos.data);
+			if (coscheduled < 0) {
+				isl_map_free(move);
+				return isl_flow_free(flow);
+			}
+			if (!coscheduled)
+				continue;
+			depth = acc->level_before(acc->sourcei.data,
+						acc->sourcepos.data) / 2;
+			map = coscheduled_source(acc, must_reli, pos, depth);
+			factor = isl_map_domain_factor_range(isl_map_copy(map));
+			pos = 2 * acc->n_must + j;
+			flow->deppos.map = isl_map_union(flow->deppos.map,
+							    factor);
+			map = isl_map_domain_factor_domain(map);
+			move = isl_map_union(move, map);
+		}
+		must_reli = isl_map_subtract(must_reli, isl_map_copy(move));
+		may_reli = isl_map_union(may_reli, move);
+	}
+
+	return flow;
+}
+
 /* Compute dependences for the case where all accesses are "may"
  * accesses, which boils down to computing memory based dependences.
  * The generic algorithm would also work in this case, but it would
@@ -846,19 +1071,22 @@
 	for (i = 0; i < acc->n_may; ++i) {
 		int plevel;
 		int is_before;
-		isl_space *dim;
+		isl_space *space;
 		isl_map *before;
 		isl_map *dep;
 
 		plevel = acc->level_before(acc->sourcei.data, acc->sink.data);
+		if (plevel < 0)
+			goto error;
+
 		is_before = plevel & 1;
 		plevel >>= 1;
 
-		dim = isl_map_get_space(res->depi.map);
+		space = isl_map_get_space(res->depi.map);
 		if (is_before)
-			before = isl_map_lex_le_first(dim, plevel);
+			before = isl_map_lex_le_first(space, plevel);
 		else
-			before = isl_map_lex_lt_first(dim, plevel);
+			before = isl_map_lex_lt_first(space, plevel);
 		dep = isl_map_apply_range(isl_map_copy(acc->sourcei.map),
 			isl_map_reverse(isl_map_copy(acc->sink.map)));
 		dep = isl_map_intersect(dep, before);
@@ -871,6 +1099,11 @@
 	res->must_no_source = mustdo;
 
 	return res;
+error:
+	isl_set_free(mustdo);
+	isl_set_free(maydo);
+	isl_flow_free(res);
+	return NULL;
 }
 
 /* Compute dependences for the case where there is at least one
@@ -900,7 +1133,12 @@
  * need to be considered.  These iterations are split into those that
  * haven't been matched to any source access (mustdo) and those that have only
  * been matched to may accesses (maydo).
- * At the end of each level, we also consider the may accesses.
+ * At the end of each level, must-sources and may-sources that are coscheduled
+ * with the sources of the must-dependences at that level are considered.
+ * If any coscheduled instances are found, then corresponding may-dependences
+ * are added and the original must-dependences are turned into may-dependences.
+ * Afterwards, the may accesses that occur after must-dependence sources
+ * are considered.
  * In particular, we consider may accesses that precede the remaining
  * sink iterations, moving elements from mustdo to maydo when appropriate,
  * and may accesses that occur between a must source and a sink of any 
@@ -916,6 +1154,7 @@
 	isl_set *mustdo = NULL;
 	isl_set *maydo = NULL;
 	int level, j;
+	isl_size n_in;
 	int depth;
 	isl_map **must_rel = NULL;
 	isl_map **may_rel = NULL;
@@ -928,22 +1167,27 @@
 		goto error;
 	ctx = isl_map_get_ctx(acc->sink.map);
 
-	depth = 2 * isl_map_dim(acc->sink.map, isl_dim_in) + 1;
+	n_in = isl_map_dim(acc->sink.map, isl_dim_in);
+	if (n_in < 0)
+		goto error;
+	depth = 2 * n_in + 1;
 	mustdo = isl_map_domain(isl_map_copy(acc->sink.map));
-	maydo = isl_set_empty_like(mustdo);
+	maydo = isl_set_empty(isl_set_get_space(mustdo));
 	if (!mustdo || !maydo)
 		goto error;
 	if (isl_set_plain_is_empty(mustdo))
 		goto done;
 
-	must_rel = isl_alloc_array(ctx, struct isl_map *, acc->n_must);
-	may_rel = isl_alloc_array(ctx, struct isl_map *, acc->n_must);
+	must_rel = isl_calloc_array(ctx, struct isl_map *, acc->n_must);
+	may_rel = isl_calloc_array(ctx, struct isl_map *, acc->n_must);
 	if (!must_rel || !may_rel)
 		goto error;
 
 	for (level = depth; level >= 1; --level) {
 		for (j = acc->n_must-1; j >=0; --j) {
-			must_relj = isl_map_empty_like(res->dep2 * j.map);
+			isl_space *space;
+			space = isl_map_get_space(res->dep2 * j.map);
+			must_relj = isl_map_empty(space);
 			may_relj = isl_map_copy(must_relj);
 		}
 
@@ -954,6 +1198,8 @@
 
 			plevel = acc->level_before(acc->sourcej.data,
 						     acc->sink.data);
+			if (plevel < 0)
+				goto error;
 			if (!can_precede_at_level(plevel, level))
 				continue;
 
@@ -961,13 +1207,15 @@
 			must_relj = isl_map_union_disjoint(must_relj, T);
 			mustdo = rest;
 
-			intermediate_sources(acc, must_rel, j, level);
+			if (intermediate_sources(acc, must_rel, j, level) < 0)
+				goto error;
 
 			T = last_source(acc, maydo, j, level, &rest);
 			may_relj = isl_map_union_disjoint(may_relj, T);
 			maydo = rest;
 
-			intermediate_sources(acc, may_rel, j, level);
+			if (intermediate_sources(acc, may_rel, j, level) < 0)
+				goto error;
 
 			if (isl_set_plain_is_empty(mustdo) &&
 			    isl_set_plain_is_empty(maydo))
@@ -978,13 +1226,21 @@
 
 			plevel = acc->level_before(acc->sourcej.data,
 						     acc->sink.data);
+			if (plevel < 0)
+				goto error;
 			if (!can_precede_at_level(plevel, level))
 				continue;
 
-			intermediate_sources(acc, must_rel, j, level);
-			intermediate_sources(acc, may_rel, j, level);
+			if (intermediate_sources(acc, must_rel, j, level) < 0)
+				goto error;
+			if (intermediate_sources(acc, may_rel, j, level) < 0)
+				goto error;
 		}
 
+		res = handle_coscheduled(acc, must_rel, may_rel, res);
+		if (!res)
+			goto error;
+
 		for (j = 0; j < acc->n_may; ++j) {
 			int plevel;
 			isl_map *T;
@@ -992,6 +1248,8 @@
 
 			plevel = acc->level_before(acc->sourceacc->n_must + j.data,
 						     acc->sink.data);
+			if (plevel < 0)
+				goto error;
 			if (!can_precede_at_level(plevel, level))
 				continue;
 
@@ -1032,6 +1290,12 @@
 	res->may_no_source = maydo;
 	return res;
 error:
+	if (must_rel)
+		for (j = 0; j < acc->n_must; ++j)
+			isl_map_free(must_relj);
+	if (may_rel)
+		for (j = 0; j < acc->n_must; ++j)
+			isl_map_free(may_relj);
 	isl_flow_free(res);
 	isl_set_free(mustdo);
 	isl_set_free(maydo);
@@ -1054,18 +1318,17 @@
  *
  * To deal with multi-valued sink access relations, the sink iteration
  * domain is first extended with dimensions that correspond to the data
- * space.  After the computation is finished, these extra dimensions are
- * projected out again.
+ * space.  However, these extra dimensions are not projected out again.
+ * It is up to the caller to decide whether these dimensions should be kept.
  */
-__isl_give isl_flow *isl_access_info_compute_flow(__isl_take isl_access_info *acc)
+static __isl_give isl_flow *access_info_compute_flow_core(
+	__isl_take isl_access_info *acc)
 {
-	int j;
 	struct isl_flow *res = NULL;
 
 	if (!acc)
 		return NULL;
 
-	acc->domain_map = isl_map_domain_map(isl_map_copy(acc->sink.map));
 	acc->sink.map = isl_map_range_map(acc->sink.map);
 	if (!acc->sink.map)
 		goto error;
@@ -1076,22 +1339,56 @@
 		acc = isl_access_info_sort_sources(acc);
 		res = compute_val_based_dependences(acc);
 	}
+	acc = isl_access_info_free(acc);
 	if (!res)
+		return NULL;
+	if (!res->must_no_source || !res->may_no_source)
 		goto error;
+	return res;
+error:
+	isl_access_info_free(acc);
+	isl_flow_free(res);
+	return NULL;
+}
+
+/* Given a "sink" access, a list of n "source" accesses,
+ * compute for each iteration of the sink access
+ * and for each element accessed by that iteration,
+ * the source access in the list that last accessed the
+ * element accessed by the sink access before this sink access.
+ * Each access is given as a map from the loop iterators
+ * to the array indices.
+ * The result is a list of n relations between source and sink
+ * iterations and a subset of the domain of the sink access,
+ * corresponding to those iterations that access an element
+ * not previously accessed.
+ *
+ * To deal with multi-valued sink access relations,
+ * access_info_compute_flow_core extends the sink iteration domain
+ * with dimensions that correspond to the data space.  These extra dimensions
+ * are projected out from the result of access_info_compute_flow_core.
+ */
+__isl_give isl_flow *isl_access_info_compute_flow(__isl_take isl_access_info *acc)
+{
+	int j;
+	struct isl_flow *res;
+
+	if (!acc)
+		return NULL;
+
+	acc->domain_map = isl_map_domain_map(isl_map_copy(acc->sink.map));
+	res = access_info_compute_flow_core(acc);
+	if (!res)
+		return NULL;
 
 	for (j = 0; j < res->n_source; ++j) {
-		res->depj.map = isl_map_apply_range(res->depj.map,
-					isl_map_copy(acc->domain_map));
+		res->depj.map = isl_map_range_factor_domain(res->depj.map);
 		if (!res->depj.map)
 			goto error;
 	}
-	if (!res->must_no_source || !res->may_no_source)
-		goto error;
 
-	isl_access_info_free(acc);
 	return res;
 error:
-	isl_access_info_free(acc);
 	isl_flow_free(res);
 	return NULL;
 }
@@ -1126,18 +1423,21 @@
 	__isl_keep isl_map *map)
 {
 	isl_ctx *ctx;
-	isl_space *dim;
+	isl_space *space;
 	struct isl_sched_info *info;
-	int i, n;
+	int i;
+	isl_size n;
 
 	if (!map)
 		return NULL;
 
-	dim = isl_space_unwrap(isl_space_domain(isl_map_get_space(map)));
-	if (!dim)
+	space = isl_space_unwrap(isl_space_domain(isl_map_get_space(map)));
+	if (!space)
+		return NULL;
+	n = isl_space_dim(space, isl_dim_in);
+	isl_space_free(space);
+	if (n < 0)
 		return NULL;
-	n = isl_space_dim(dim, isl_dim_in);
-	isl_space_free(dim);
 
 	ctx = isl_map_get_ctx(map);
 	info = isl_alloc_type(ctx, struct isl_sched_info);
@@ -1167,217 +1467,1814 @@
 	return NULL;
 }
 
-struct isl_compute_flow_data {
-	isl_union_map *must_source;
-	isl_union_map *may_source;
-	isl_union_map *must_dep;
-	isl_union_map *may_dep;
-	isl_union_map *must_no_source;
-	isl_union_map *may_no_source;
+/* The different types of access relations that isl_union_access_info
+ * keeps track of.
 
-	int count;
-	int must;
-	isl_space *dim;
-	struct isl_sched_info *sink_info;
-	struct isl_sched_info **source_info;
-	isl_access_info *accesses;
+ * "isl_access_sink" represents the sink accesses.
+ * "isl_access_must_source" represents the definite source accesses.
+ * "isl_access_may_source" represents the possible source accesses.
+ * "isl_access_kill" represents the kills.
+ *
+ * isl_access_sink is sometimes treated differently and
+ * should therefore appear first.
+ */
+enum isl_access_type {
+	isl_access_sink,
+	isl_access_must_source,
+	isl_access_may_source,
+	isl_access_kill,
+	isl_access_end
 };
 
-static int count_matching_array(__isl_take isl_map *map, void *user)
-{
-	int eq;
-	isl_space *dim;
-	struct isl_compute_flow_data *data;
+/* This structure represents the input for a dependence analysis computation.
+ *
+ * "access" contains the access relations.
+ *
+ * "schedule" or "schedule_map" represents the execution order.
+ * Exactly one of these fields should be NULL.  The other field
+ * determines the execution order.
+ *
+ * The domains of these four maps refer to the same iteration spaces(s).
+ * The ranges of the first three maps also refer to the same data space(s).
+ *
+ * After a call to isl_union_access_info_introduce_schedule,
+ * the "schedule_map" field no longer contains useful information.
+ */
+struct isl_union_access_info {
+	isl_union_map *accessisl_access_end;
 
-	data = (struct isl_compute_flow_data *)user;
+	isl_schedule *schedule;
+	isl_union_map *schedule_map;
+};
 
-	dim = isl_space_range(isl_map_get_space(map));
+/* Free "access" and return NULL.
+ */
+__isl_null isl_union_access_info *isl_union_access_info_free(
+	__isl_take isl_union_access_info *access)
+{
+	enum isl_access_type i;
 
-	eq = isl_space_is_equal(dim, data->dim);
+	if (!access)
+		return NULL;
 
-	isl_space_free(dim);
-	isl_map_free(map);
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		isl_union_map_free(access->accessi);
+	isl_schedule_free(access->schedule);
+	isl_union_map_free(access->schedule_map);
+	free(access);
 
-	if (eq < 0)
-		return -1;
-	if (eq)
-		data->count++;
+	return NULL;
+}
 
-	return 0;
+/* Return the isl_ctx to which "access" belongs.
+ */
+isl_ctx *isl_union_access_info_get_ctx(__isl_keep isl_union_access_info *access)
+{
+	if (!access)
+		return NULL;
+	return isl_union_map_get_ctx(access->accessisl_access_sink);
 }
 
-static int collect_matching_array(__isl_take isl_map *map, void *user)
+/* Construct an empty (invalid) isl_union_access_info object.
+ * The caller is responsible for setting the sink access relation and
+ * initializing all the other fields, e.g., by calling
+ * isl_union_access_info_init.
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_alloc(
+	isl_ctx *ctx)
 {
-	int eq;
-	isl_space *dim;
-	struct isl_sched_info *info;
-	struct isl_compute_flow_data *data;
+	return isl_calloc_type(ctx, isl_union_access_info);
+}
 
-	data = (struct isl_compute_flow_data *)user;
+/* Initialize all the fields of "info", except the sink access relation,
+ * which is assumed to have been set by the caller.
+ *
+ * By default, we use the schedule field of the isl_union_access_info,
+ * but this may be overridden by a call
+ * to isl_union_access_info_set_schedule_map.
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_init(
+	__isl_take isl_union_access_info *info)
+{
+	isl_space *space;
+	isl_union_map *empty;
+	enum isl_access_type i;
 
-	dim = isl_space_range(isl_map_get_space(map));
+	if (!info)
+		return NULL;
+	if (!info->accessisl_access_sink)
+		return isl_union_access_info_free(info);
+
+	space = isl_union_map_get_space(info->accessisl_access_sink);
+	empty = isl_union_map_empty(isl_space_copy(space));
+	for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+		if (!info->accessi)
+			info->accessi = isl_union_map_copy(empty);
+	isl_union_map_free(empty);
+	if (!info->schedule && !info->schedule_map)
+		info->schedule = isl_schedule_empty(isl_space_copy(space));
+	isl_space_free(space);
+
+	for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+		if (!info->accessi)
+			return isl_union_access_info_free(info);
+	if (!info->schedule && !info->schedule_map)
+		return isl_union_access_info_free(info);
 
-	eq = isl_space_is_equal(dim, data->dim);
+	return info;
+}
 
-	isl_space_free(dim);
+/* Create a new isl_union_access_info with the given sink accesses and
+ * and no other accesses or schedule information.
+ */
+__isl_give isl_union_access_info *isl_union_access_info_from_sink(
+	__isl_take isl_union_map *sink)
+{
+	isl_ctx *ctx;
+	isl_union_access_info *access;
 
-	if (eq < 0)
+	if (!sink)
+		return NULL;
+	ctx = isl_union_map_get_ctx(sink);
+	access = isl_union_access_info_alloc(ctx);
+	if (!access)
 		goto error;
-	if (!eq) {
-		isl_map_free(map);
-		return 0;
-	}
-
-	info = sched_info_alloc(map);
-	data->source_infodata->count = info;
+	access->accessisl_access_sink = sink;
+	return isl_union_access_info_init(access);
+error:
+	isl_union_map_free(sink);
+	return NULL;
+}
 
-	data->accesses = isl_access_info_add_source(data->accesses,
-						    map, data->must, info);
+/* Replace the access relation of type "type" of "info" by "access".
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_set(
+	__isl_take isl_union_access_info *info,
+	enum isl_access_type type, __isl_take isl_union_map *access)
+{
+	if (!info || !access)
+		goto error;
 
-	data->count++;
+	isl_union_map_free(info->accesstype);
+	info->accesstype = access;
 
-	return 0;
+	return info;
 error:
-	isl_map_free(map);
-	return -1;
+	isl_union_access_info_free(info);
+	isl_union_map_free(access);
+	return NULL;
 }
 
-/* Determine the shared nesting level and the "textual order" of
- * the given accesses.
- *
- * We first determine the minimal schedule dimension for both accesses.
- *
- * If among those dimensions, we can find one where both have a fixed
- * value and if moreover those values are different, then the previous
- * dimension is the last shared nesting level and the textual order
- * is determined based on the order of the fixed values.
- * If no such fixed values can be found, then we set the shared
- * nesting level to the minimal schedule dimension, with no textual ordering.
+/* Replace the definite source accesses of "access" by "must_source".
  */
-static int before(void *first, void *second)
+__isl_give isl_union_access_info *isl_union_access_info_set_must_source(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *must_source)
 {
-	struct isl_sched_info *info1 = first;
-	struct isl_sched_info *info2 = second;
-	int n1, n2;
-	int i;
-
-	n1 = isl_vec_size(info1->cst);
-	n2 = isl_vec_size(info2->cst);
-
-	if (n2 < n1)
-		n1 = n2;
+	return isl_union_access_info_set(access, isl_access_must_source,
+					must_source);
+}
 
-	for (i = 0; i < n1; ++i) {
-		int r;
-		int cmp;
+/* Replace the possible source accesses of "access" by "may_source".
+ */
+__isl_give isl_union_access_info *isl_union_access_info_set_may_source(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *may_source)
+{
+	return isl_union_access_info_set(access, isl_access_may_source,
+					may_source);
+}
 
-		if (!info1->is_csti)
-			continue;
-		if (!info2->is_csti)
-			continue;
-		cmp = isl_vec_cmp_element(info1->cst, info2->cst, i);
-		if (cmp == 0)
-			continue;
+/* Replace the kills of "info" by "kill".
+ */
+__isl_give isl_union_access_info *isl_union_access_info_set_kill(
+	__isl_take isl_union_access_info *info, __isl_take isl_union_map *kill)
+{
+	return isl_union_access_info_set(info, isl_access_kill, kill);
+}
 
-		r = 2 * i + (cmp < 0);
+/* Return the access relation of type "type" of "info".
+ */
+static __isl_give isl_union_map *isl_union_access_info_get(
+	__isl_keep isl_union_access_info *info, enum isl_access_type type)
+{
+	if (!info)
+		return NULL;
+	return isl_union_map_copy(info->accesstype);
+}
 
-		return r;
-	}
+/* Return the definite source accesses of "info".
+ */
+__isl_give isl_union_map *isl_union_access_info_get_must_source(
+	__isl_keep isl_union_access_info *info)
+{
+	return isl_union_access_info_get(info, isl_access_must_source);
+}
 
-	return 2 * n1;
+/* Return the possible source accesses of "info".
+ */
+__isl_give isl_union_map *isl_union_access_info_get_may_source(
+	__isl_keep isl_union_access_info *info)
+{
+	return isl_union_access_info_get(info, isl_access_may_source);
 }
 
-/* Given a sink access, look for all the source accesses that access
- * the same array and perform dataflow analysis on them using
- * isl_access_info_compute_flow.
+/* Return the kills of "info".
  */
-static int compute_flow(__isl_take isl_map *map, void *user)
+__isl_give isl_union_map *isl_union_access_info_get_kill(
+	__isl_keep isl_union_access_info *info)
+{
+	return isl_union_access_info_get(info, isl_access_kill);
+}
+
+/* Does "info" specify any kills?
+ */
+static isl_bool isl_union_access_has_kill(
+	__isl_keep isl_union_access_info *info)
+{
+	isl_bool empty;
+
+	if (!info)
+		return isl_bool_error;
+	empty = isl_union_map_is_empty(info->accessisl_access_kill);
+	return isl_bool_not(empty);
+}
+
+/* Replace the schedule of "access" by "schedule".
+ * Also free the schedule_map in case it was set last.
+ */
+__isl_give isl_union_access_info *isl_union_access_info_set_schedule(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_schedule *schedule)
+{
+	if (!access || !schedule)
+		goto error;
+
+	access->schedule_map = isl_union_map_free(access->schedule_map);
+	isl_schedule_free(access->schedule);
+	access->schedule = schedule;
+
+	return access;
+error:
+	isl_union_access_info_free(access);
+	isl_schedule_free(schedule);
+	return NULL;
+}
+
+/* Replace the schedule map of "access" by "schedule_map".
+ * Also free the schedule in case it was set last.
+ */
+__isl_give isl_union_access_info *isl_union_access_info_set_schedule_map(
+	__isl_take isl_union_access_info *access,
+	__isl_take isl_union_map *schedule_map)
+{
+	if (!access || !schedule_map)
+		goto error;
+
+	isl_union_map_free(access->schedule_map);
+	access->schedule = isl_schedule_free(access->schedule);
+	access->schedule_map = schedule_map;
+
+	return access;
+error:
+	isl_union_access_info_free(access);
+	isl_union_map_free(schedule_map);
+	return NULL;
+}
+
+__isl_give isl_union_access_info *isl_union_access_info_copy(
+	__isl_keep isl_union_access_info *access)
+{
+	isl_union_access_info *copy;
+	enum isl_access_type i;
+
+	if (!access)
+		return NULL;
+	copy = isl_union_access_info_from_sink(
+		    isl_union_map_copy(access->accessisl_access_sink));
+	for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+		copy = isl_union_access_info_set(copy, i,
+					isl_union_map_copy(access->accessi));
+	if (access->schedule)
+		copy = isl_union_access_info_set_schedule(copy,
+				isl_schedule_copy(access->schedule));
+	else
+		copy = isl_union_access_info_set_schedule_map(copy,
+				isl_union_map_copy(access->schedule_map));
+
+	return copy;
+}
+
+#undef BASE
+#define BASE union_map
+#include "print_yaml_field_templ.c"
+
+/* An enumeration of the various keys that may appear in a YAML mapping
+ * of an isl_union_access_info object.
+ * The keys for the access relation types are assumed to have the same values
+ * as the access relation types in isl_access_type.
+ */
+enum isl_ai_key {
+	isl_ai_key_error = -1,
+	isl_ai_key_sink = isl_access_sink,
+	isl_ai_key_must_source = isl_access_must_source,
+	isl_ai_key_may_source = isl_access_may_source,
+	isl_ai_key_kill = isl_access_kill,
+	isl_ai_key_schedule_map,
+	isl_ai_key_schedule,
+	isl_ai_key_end
+};
+
+/* Textual representations of the YAML keys for an isl_union_access_info
+ * object.
+ */
+static char *key_str = {
+	isl_ai_key_sink = "sink",
+	isl_ai_key_must_source = "must_source",
+	isl_ai_key_may_source = "may_source",
+	isl_ai_key_kill = "kill",
+	isl_ai_key_schedule_map = "schedule_map",
+	isl_ai_key_schedule = "schedule",
+};
+
+/* Print a key-value pair corresponding to the access relation of type "type"
+ * of a YAML mapping of "info" to "p".
+ *
+ * The sink access relation is always printed, but any other access relation
+ * is only printed if it is non-empty.
+ */
+static __isl_give isl_printer *print_access_field(__isl_take isl_printer *p,
+	__isl_keep isl_union_access_info *info, enum isl_access_type type)
+{
+	if (type != isl_access_sink) {
+		isl_bool empty;
+
+		empty = isl_union_map_is_empty(info->accesstype);
+		if (empty < 0)
+			return isl_printer_free(p);
+		if (empty)
+			return p;
+	}
+	return print_yaml_field_union_map(p, key_strtype, info->accesstype);
+}
+
+/* Print the information contained in "access" to "p".
+ * The information is printed as a YAML document.
+ */
+__isl_give isl_printer *isl_printer_print_union_access_info(
+	__isl_take isl_printer *p, __isl_keep isl_union_access_info *access)
+{
+	enum isl_access_type i;
+
+	if (!access)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_mapping(p);
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		p = print_access_field(p, access, i);
+	if (access->schedule) {
+		p = isl_printer_print_str(p, key_strisl_ai_key_schedule);
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_schedule(p, access->schedule);
+		p = isl_printer_yaml_next(p);
+	} else {
+		p = print_yaml_field_union_map(p,
+			key_strisl_ai_key_schedule_map, access->schedule_map);
+	}
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+/* Return a string representation of the information in "access".
+ * The information is printed in flow format.
+ */
+__isl_give char *isl_union_access_info_to_str(
+	__isl_keep isl_union_access_info *access)
+{
+	isl_printer *p;
+	char *s;
+
+	if (!access)
+		return NULL;
+
+	p = isl_printer_to_str(isl_union_access_info_get_ctx(access));
+	p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_FLOW);
+	p = isl_printer_print_union_access_info(p, access);
+	s = isl_printer_get_str(p);
+	isl_printer_free(p);
+
+	return s;
+}
+
+#undef KEY
+#define KEY enum isl_ai_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_ai_key_error
+#undef KEY_END
+#define KEY_END isl_ai_key_end
+#include "extract_key.c"
+
+#undef BASE
+#define BASE union_map
+#include "read_in_string_templ.c"
+
+/* Read an isl_union_access_info object from "s".
+ *
+ * Start off with an empty (invalid) isl_union_access_info object and
+ * then fill up the fields based on the input.
+ * The input needs to contain at least a description of the sink
+ * access relation as well as some form of schedule.
+ * The other access relations are set to empty relations
+ * by isl_union_access_info_init if they are not specified in the input.
+ */
+__isl_give isl_union_access_info *isl_stream_read_union_access_info(
+	isl_stream *s)
+{
+	isl_ctx *ctx;
+	isl_union_access_info *info;
+	int more;
+	int sink_set = 0;
+	int schedule_set = 0;
+
+	if (isl_stream_yaml_read_start_mapping(s))
+		return NULL;
+
+	ctx = isl_stream_get_ctx(s);
+	info = isl_union_access_info_alloc(ctx);
+	while ((more = isl_stream_yaml_next(s)) > 0) {
+		enum isl_ai_key key;
+		isl_union_map *access, *schedule_map;
+		isl_schedule *schedule;
+
+		key = get_key(s);
+		if (isl_stream_yaml_next(s) < 0)
+			return isl_union_access_info_free(info);
+		switch (key) {
+		case isl_ai_key_end:
+		case isl_ai_key_error:
+			return isl_union_access_info_free(info);
+		case isl_ai_key_sink:
+			sink_set = 1;
+		case isl_ai_key_must_source:
+		case isl_ai_key_may_source:
+		case isl_ai_key_kill:
+			access = read_union_map(s);
+			info = isl_union_access_info_set(info, key, access);
+			if (!info)
+				return NULL;
+			break;
+		case isl_ai_key_schedule_map:
+			schedule_set = 1;
+			schedule_map = read_union_map(s);
+			info = isl_union_access_info_set_schedule_map(info,
+								schedule_map);
+			if (!info)
+				return NULL;
+			break;
+		case isl_ai_key_schedule:
+			schedule_set = 1;
+			schedule = isl_stream_read_schedule(s);
+			info = isl_union_access_info_set_schedule(info,
+								schedule);
+			if (!info)
+				return NULL;
+			break;
+		}
+	}
+	if (more < 0)
+		return isl_union_access_info_free(info);
+
+	if (isl_stream_yaml_read_end_mapping(s) < 0) {
+		isl_stream_error(s, NULL, "unexpected extra elements");
+		return isl_union_access_info_free(info);
+	}
+
+	if (!sink_set) {
+		isl_stream_error(s, NULL, "no sink specified");
+		return isl_union_access_info_free(info);
+	}
+
+	if (!schedule_set) {
+		isl_stream_error(s, NULL, "no schedule specified");
+		return isl_union_access_info_free(info);
+	}
+
+	return isl_union_access_info_init(info);
+}
+
+/* Read an isl_union_access_info object from the file "input".
+ */
+__isl_give isl_union_access_info *isl_union_access_info_read_from_file(
+	isl_ctx *ctx, FILE *input)
+{
+	isl_stream *s;
+	isl_union_access_info *access;
+
+	s = isl_stream_new_file(ctx, input);
+	if (!s)
+		return NULL;
+	access = isl_stream_read_union_access_info(s);
+	isl_stream_free(s);
+
+	return access;
+}
+
+/* Update the fields of "access" such that they all have the same parameters,
+ * keeping in mind that the schedule_map field may be NULL and ignoring
+ * the schedule field.
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_align_params(
+	__isl_take isl_union_access_info *access)
+{
+	isl_space *space;
+	enum isl_access_type i;
+
+	if (!access)
+		return NULL;
+
+	space = isl_union_map_get_space(access->accessisl_access_sink);
+	for (i = isl_access_sink + 1; i < isl_access_end; ++i)
+		space = isl_space_align_params(space,
+				isl_union_map_get_space(access->accessi));
+	if (access->schedule_map)
+		space = isl_space_align_params(space,
+				isl_union_map_get_space(access->schedule_map));
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		access->accessi =
+			isl_union_map_align_params(access->accessi,
+							isl_space_copy(space));
+	if (!access->schedule_map) {
+		isl_space_free(space);
+	} else {
+		access->schedule_map =
+		    isl_union_map_align_params(access->schedule_map, space);
+		if (!access->schedule_map)
+			return isl_union_access_info_free(access);
+	}
+
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		if (!access->accessi)
+			return isl_union_access_info_free(access);
+
+	return access;
+}
+
+/* Prepend the schedule dimensions to the iteration domains.
+ *
+ * That is, if the schedule is of the form
+ *
+ *	D -> S
+ *
+ * while the access relations are of the form
+ *
+ *	D -> A
+ *
+ * then the updated access relations are of the form
+ *
+ *	S -> D -> A
+ *
+ * The schedule map is also replaced by the map
+ *
+ *	S -> D -> D
+ *
+ * that is used during the internal computation.
+ * Neither the original schedule map nor this updated schedule map
+ * are used after the call to this function.
+ */
+static __isl_give isl_union_access_info *
+isl_union_access_info_introduce_schedule(
+	__isl_take isl_union_access_info *access)
+{
+	isl_union_map *sm;
+	enum isl_access_type i;
+
+	if (!access)
+		return NULL;
+
+	sm = isl_union_map_reverse(access->schedule_map);
+	sm = isl_union_map_range_map(sm);
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		access->accessi =
+			isl_union_map_apply_range(isl_union_map_copy(sm),
+						access->accessi);
+	access->schedule_map = sm;
+
+	for (i = isl_access_sink; i < isl_access_end; ++i)
+		if (!access->accessi)
+			return isl_union_access_info_free(access);
+	if (!access->schedule_map)
+		return isl_union_access_info_free(access);
+
+	return access;
+}
+
+/* This structure represents the result of a dependence analysis computation.
+ *
+ * "must_dep" represents the full definite dependences
+ * "may_dep" represents the full non-definite dependences.
+ * Both are of the form
+ *
+ *	Source -> Sink -> Data
+ *
+ * (after the schedule dimensions have been projected out).
+ * "must_no_source" represents the subset of the sink accesses for which
+ * definitely no source was found.
+ * "may_no_source" represents the subset of the sink accesses for which
+ * possibly, but not definitely, no source was found.
+ */
+struct isl_union_flow {
+	isl_union_map *must_dep;
+	isl_union_map *may_dep;
+	isl_union_map *must_no_source;
+	isl_union_map *may_no_source;
+};
+
+/* Return the isl_ctx to which "flow" belongs.
+ */
+isl_ctx *isl_union_flow_get_ctx(__isl_keep isl_union_flow *flow)
+{
+	return flow ? isl_union_map_get_ctx(flow->must_dep) : NULL;
+}
+
+/* Free "flow" and return NULL.
+ */
+__isl_null isl_union_flow *isl_union_flow_free(__isl_take isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	isl_union_map_free(flow->must_dep);
+	isl_union_map_free(flow->may_dep);
+	isl_union_map_free(flow->must_no_source);
+	isl_union_map_free(flow->may_no_source);
+	free(flow);
+	return NULL;
+}
+
+void isl_union_flow_dump(__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return;
+
+	fprintf(stderr, "must dependences: ");
+	isl_union_map_dump(flow->must_dep);
+	fprintf(stderr, "may dependences: ");
+	isl_union_map_dump(flow->may_dep);
+	fprintf(stderr, "must no source: ");
+	isl_union_map_dump(flow->must_no_source);
+	fprintf(stderr, "may no source: ");
+	isl_union_map_dump(flow->may_no_source);
+}
+
+/* Return the full definite dependences in "flow", with accessed elements.
+ */
+__isl_give isl_union_map *isl_union_flow_get_full_must_dependence(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_copy(flow->must_dep);
+}
+
+/* Return the full possible dependences in "flow", including the definite
+ * dependences, with accessed elements.
+ */
+__isl_give isl_union_map *isl_union_flow_get_full_may_dependence(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_union(isl_union_map_copy(flow->must_dep),
+				    isl_union_map_copy(flow->may_dep));
+}
+
+/* Return the definite dependences in "flow", without the accessed elements.
+ */
+__isl_give isl_union_map *isl_union_flow_get_must_dependence(
+	__isl_keep isl_union_flow *flow)
+{
+	isl_union_map *dep;
+
+	if (!flow)
+		return NULL;
+	dep = isl_union_map_copy(flow->must_dep);
+	return isl_union_map_range_factor_domain(dep);
+}
+
+/* Return the possible dependences in "flow", including the definite
+ * dependences, without the accessed elements.
+ */
+__isl_give isl_union_map *isl_union_flow_get_may_dependence(
+	__isl_keep isl_union_flow *flow)
+{
+	isl_union_map *dep;
+
+	if (!flow)
+		return NULL;
+	dep = isl_union_map_union(isl_union_map_copy(flow->must_dep),
+				    isl_union_map_copy(flow->may_dep));
+	return isl_union_map_range_factor_domain(dep);
+}
+
+/* Return the non-definite dependences in "flow".
+ */
+static __isl_give isl_union_map *isl_union_flow_get_non_must_dependence(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_copy(flow->may_dep);
+}
+
+/* Return the subset of the sink accesses for which definitely
+ * no source was found.
+ */
+__isl_give isl_union_map *isl_union_flow_get_must_no_source(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_copy(flow->must_no_source);
+}
+
+/* Return the subset of the sink accesses for which possibly
+ * no source was found, including those for which definitely
+ * no source was found.
+ */
+__isl_give isl_union_map *isl_union_flow_get_may_no_source(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_union(isl_union_map_copy(flow->must_no_source),
+				    isl_union_map_copy(flow->may_no_source));
+}
+
+/* Return the subset of the sink accesses for which possibly, but not
+ * definitely, no source was found.
+ */
+static __isl_give isl_union_map *isl_union_flow_get_non_must_no_source(
+	__isl_keep isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+	return isl_union_map_copy(flow->may_no_source);
+}
+
+/* Create a new isl_union_flow object, initialized with empty
+ * dependence relations and sink subsets.
+ */
+static __isl_give isl_union_flow *isl_union_flow_alloc(
+	__isl_take isl_space *space)
+{
+	isl_ctx *ctx;
+	isl_union_map *empty;
+	isl_union_flow *flow;
+
+	if (!space)
+		return NULL;
+	ctx = isl_space_get_ctx(space);
+	flow = isl_alloc_type(ctx, isl_union_flow);
+	if (!flow)
+		goto error;
+
+	empty = isl_union_map_empty(space);
+	flow->must_dep = isl_union_map_copy(empty);
+	flow->may_dep = isl_union_map_copy(empty);
+	flow->must_no_source = isl_union_map_copy(empty);
+	flow->may_no_source = empty;
+
+	if (!flow->must_dep || !flow->may_dep ||
+	    !flow->must_no_source || !flow->may_no_source)
+		return isl_union_flow_free(flow);
+
+	return flow;
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Copy this isl_union_flow object.
+ */
+__isl_give isl_union_flow *isl_union_flow_copy(__isl_keep isl_union_flow *flow)
+{
+	isl_union_flow *copy;
+
+	if (!flow)
+		return NULL;
+
+	copy = isl_union_flow_alloc(isl_union_map_get_space(flow->must_dep));
+
+	if (!copy)
+		return NULL;
+
+	copy->must_dep = isl_union_map_union(copy->must_dep,
+		isl_union_map_copy(flow->must_dep));
+	copy->may_dep = isl_union_map_union(copy->may_dep,
+		isl_union_map_copy(flow->may_dep));
+	copy->must_no_source = isl_union_map_union(copy->must_no_source,
+		isl_union_map_copy(flow->must_no_source));
+	copy->may_no_source = isl_union_map_union(copy->may_no_source,
+		isl_union_map_copy(flow->may_no_source));
+
+	if (!copy->must_dep || !copy->may_dep ||
+	    !copy->must_no_source || !copy->may_no_source)
+		return isl_union_flow_free(copy);
+
+	return copy;
+}
+
+/* Drop the schedule dimensions from the iteration domains in "flow".
+ * In particular, the schedule dimensions have been prepended
+ * to the iteration domains prior to the dependence analysis by
+ * replacing the iteration domain D, by the wrapped map S -> D.
+ * Replace these wrapped maps by the original D.
+ *
+ * In particular, the dependences computed by access_info_compute_flow_core
+ * are of the form
+ *
+ *	S -> D -> S' -> D' -> A
+ *
+ * The schedule dimensions are projected out by first currying the range,
+ * resulting in
+ *
+ *	S -> D -> S' -> D' -> A
+ *
+ * and then computing the factor range
+ *
+ *	D -> D' -> A
+ */
+static __isl_give isl_union_flow *isl_union_flow_drop_schedule(
+	__isl_take isl_union_flow *flow)
+{
+	if (!flow)
+		return NULL;
+
+	flow->must_dep = isl_union_map_range_curry(flow->must_dep);
+	flow->must_dep = isl_union_map_factor_range(flow->must_dep);
+	flow->may_dep = isl_union_map_range_curry(flow->may_dep);
+	flow->may_dep = isl_union_map_factor_range(flow->may_dep);
+	flow->must_no_source =
+		isl_union_map_domain_factor_range(flow->must_no_source);
+	flow->may_no_source =
+		isl_union_map_domain_factor_range(flow->may_no_source);
+
+	if (!flow->must_dep || !flow->may_dep ||
+	    !flow->must_no_source || !flow->may_no_source)
+		return isl_union_flow_free(flow);
+
+	return flow;
+}
+
+struct isl_compute_flow_data {
+	isl_union_map *must_source;
+	isl_union_map *may_source;
+	isl_union_flow *flow;
+
+	int count;
+	int must;
+	isl_space *dim;
+	struct isl_sched_info *sink_info;
+	struct isl_sched_info **source_info;
+	isl_access_info *accesses;
+};
+
+static isl_stat count_matching_array(__isl_take isl_map *map, void *user)
+{
+	int eq;
+	isl_space *space;
+	struct isl_compute_flow_data *data;
+
+	data = (struct isl_compute_flow_data *)user;
+
+	space = isl_space_range(isl_map_get_space(map));
+
+	eq = isl_space_is_equal(space, data->dim);
+
+	isl_space_free(space);
+	isl_map_free(map);
+
+	if (eq < 0)
+		return isl_stat_error;
+	if (eq)
+		data->count++;
+
+	return isl_stat_ok;
+}
+
+static isl_stat collect_matching_array(__isl_take isl_map *map, void *user)
+{
+	int eq;
+	isl_space *space;
+	struct isl_sched_info *info;
+	struct isl_compute_flow_data *data;
+
+	data = (struct isl_compute_flow_data *)user;
+
+	space = isl_space_range(isl_map_get_space(map));
+
+	eq = isl_space_is_equal(space, data->dim);
+
+	isl_space_free(space);
+
+	if (eq < 0)
+		goto error;
+	if (!eq) {
+		isl_map_free(map);
+		return isl_stat_ok;
+	}
+
+	info = sched_info_alloc(map);
+	data->source_infodata->count = info;
+
+	data->accesses = isl_access_info_add_source(data->accesses,
+						    map, data->must, info);
+
+	data->count++;
+
+	return isl_stat_ok;
+error:
+	isl_map_free(map);
+	return isl_stat_error;
+}
+
+/* Determine the shared nesting level and the "textual order" of
+ * the given accesses.
+ *
+ * We first determine the minimal schedule dimension for both accesses.
+ *
+ * If among those dimensions, we can find one where both have a fixed
+ * value and if moreover those values are different, then the previous
+ * dimension is the last shared nesting level and the textual order
+ * is determined based on the order of the fixed values.
+ * If no such fixed values can be found, then we set the shared
+ * nesting level to the minimal schedule dimension, with no textual ordering.
+ */
+static int before(void *first, void *second)
+{
+	struct isl_sched_info *info1 = first;
+	struct isl_sched_info *info2 = second;
+	isl_size n1, n2;
+	int i;
+
+	n1 = isl_vec_size(info1->cst);
+	n2 = isl_vec_size(info2->cst);
+	if (n1 < 0 || n2 < 0)
+		return -1;
+
+	if (n2 < n1)
+		n1 = n2;
+
+	for (i = 0; i < n1; ++i) {
+		int r;
+		int cmp;
+
+		if (!info1->is_csti)
+			continue;
+		if (!info2->is_csti)
+			continue;
+		cmp = isl_vec_cmp_element(info1->cst, info2->cst, i);
+		if (cmp == 0)
+			continue;
+
+		r = 2 * i + (cmp < 0);
+
+		return r;
+	}
+
+	return 2 * n1;
+}
+
+/* Check if the given two accesses may be coscheduled.
+ * If so, return isl_bool_true.  Otherwise return isl_bool_false.
+ *
+ * Two accesses may only be coscheduled if the fixed schedule
+ * coordinates have the same values.
+ */
+static isl_bool coscheduled(void *first, void *second)
+{
+	struct isl_sched_info *info1 = first;
+	struct isl_sched_info *info2 = second;
+	isl_size n1, n2;
+	int i;
+
+	n1 = isl_vec_size(info1->cst);
+	n2 = isl_vec_size(info2->cst);
+	if (n1 < 0 || n2 < 0)
+		return isl_bool_error;
+
+	if (n2 < n1)
+		n1 = n2;
+
+	for (i = 0; i < n1; ++i) {
+		int cmp;
+
+		if (!info1->is_csti)
+			continue;
+		if (!info2->is_csti)
+			continue;
+		cmp = isl_vec_cmp_element(info1->cst, info2->cst, i);
+		if (cmp != 0)
+			return isl_bool_false;
+	}
+
+	return isl_bool_true;
+}
+
+/* Given a sink access, look for all the source accesses that access
+ * the same array and perform dataflow analysis on them using
+ * isl_access_info_compute_flow_core.
+ */
+static isl_stat compute_flow(__isl_take isl_map *map, void *user)
 {
 	int i;
 	isl_ctx *ctx;
 	struct isl_compute_flow_data *data;
 	isl_flow *flow;
+	isl_union_flow *df;
+
+	data = (struct isl_compute_flow_data *)user;
+	df = data->flow;
+
+	ctx = isl_map_get_ctx(map);
+
+	data->accesses = NULL;
+	data->sink_info = NULL;
+	data->source_info = NULL;
+	data->count = 0;
+	data->dim = isl_space_range(isl_map_get_space(map));
+
+	if (isl_union_map_foreach_map(data->must_source,
+					&count_matching_array, data) < 0)
+		goto error;
+	if (isl_union_map_foreach_map(data->may_source,
+					&count_matching_array, data) < 0)
+		goto error;
+
+	data->sink_info = sched_info_alloc(map);
+	data->source_info = isl_calloc_array(ctx, struct isl_sched_info *,
+					     data->count);
+
+	data->accesses = isl_access_info_alloc(isl_map_copy(map),
+				data->sink_info, &before, data->count);
+	if (!data->sink_info || (data->count && !data->source_info) ||
+	    !data->accesses)
+		goto error;
+	data->accesses->coscheduled = &coscheduled;
+	data->count = 0;
+	data->must = 1;
+	if (isl_union_map_foreach_map(data->must_source,
+					&collect_matching_array, data) < 0)
+		goto error;
+	data->must = 0;
+	if (isl_union_map_foreach_map(data->may_source,
+					&collect_matching_array, data) < 0)
+		goto error;
+
+	flow = access_info_compute_flow_core(data->accesses);
+	data->accesses = NULL;
+
+	if (!flow)
+		goto error;
+
+	df->must_no_source = isl_union_map_union(df->must_no_source,
+		    isl_union_map_from_map(isl_flow_get_no_source(flow, 1)));
+	df->may_no_source = isl_union_map_union(df->may_no_source,
+		    isl_union_map_from_map(isl_flow_get_no_source(flow, 0)));
+
+	for (i = 0; i < flow->n_source; ++i) {
+		isl_union_map *dep;
+		dep = isl_union_map_from_map(isl_map_copy(flow->depi.map));
+		if (flow->depi.must)
+			df->must_dep = isl_union_map_union(df->must_dep, dep);
+		else
+			df->may_dep = isl_union_map_union(df->may_dep, dep);
+	}
+
+	isl_flow_free(flow);
+
+	sched_info_free(data->sink_info);
+	if (data->source_info) {
+		for (i = 0; i < data->count; ++i)
+			sched_info_free(data->source_infoi);
+		free(data->source_info);
+	}
+	isl_space_free(data->dim);
+	isl_map_free(map);
+
+	return isl_stat_ok;
+error:
+	isl_access_info_free(data->accesses);
+	sched_info_free(data->sink_info);
+	if (data->source_info) {
+		for (i = 0; i < data->count; ++i)
+			sched_info_free(data->source_infoi);
+		free(data->source_info);
+	}
+	isl_space_free(data->dim);
+	isl_map_free(map);
+
+	return isl_stat_error;
+}
+
+/* Add the kills of "info" to the must-sources.
+ */
+static __isl_give isl_union_access_info *
+isl_union_access_info_add_kill_to_must_source(
+	__isl_take isl_union_access_info *info)
+{
+	isl_union_map *must, *kill;
+
+	must = isl_union_access_info_get_must_source(info);
+	kill = isl_union_access_info_get_kill(info);
+	must = isl_union_map_union(must, kill);
+	return isl_union_access_info_set_must_source(info, must);
+}
+
+/* Drop dependences from "flow" that purely originate from kills.
+ * That is, only keep those dependences that originate from
+ * the original must-sources "must" and/or the original may-sources "may".
+ * In particular, "must" contains the must-sources from before
+ * the kills were added and "may" contains the may-source from before
+ * the kills were removed.
+ *
+ * The dependences are of the form
+ *
+ *	Source -> Sink -> Data
+ *
+ * Only those dependences are kept where the Source -> Data part
+ * is a subset of the original may-sources or must-sources.
+ * Of those, only the must-dependences that intersect with the must-sources
+ * remain must-dependences.
+ * If there is some overlap between the may-sources and the must-sources,
+ * then the may-dependences and must-dependences may also overlap.
+ * This should be fine since the may-dependences are only kept
+ * disjoint from the must-dependences for the isl_union_map_compute_flow
+ * interface.  This interface does not support kills, so it will
+ * not end up calling this function.
+ */
+static __isl_give isl_union_flow *isl_union_flow_drop_kill_source(
+	__isl_take isl_union_flow *flow, __isl_take isl_union_map *must,
+	__isl_take isl_union_map *may)
+{
+	isl_union_map *move;
+
+	if (!flow)
+		goto error;
+	move = isl_union_map_copy(flow->must_dep);
+	move = isl_union_map_intersect_range_factor_range(move,
+				isl_union_map_copy(may));
+	may = isl_union_map_union(may, isl_union_map_copy(must));
+	flow->may_dep = isl_union_map_intersect_range_factor_range(
+				flow->may_dep, may);
+	flow->must_dep = isl_union_map_intersect_range_factor_range(
+				flow->must_dep, must);
+	flow->may_dep = isl_union_map_union(flow->may_dep, move);
+	if (!flow->must_dep || !flow->may_dep)
+		return isl_union_flow_free(flow);
+
+	return flow;
+error:
+	isl_union_map_free(must);
+	isl_union_map_free(may);
+	return NULL;
+}
+
+/* Remove the must accesses from the may accesses.
+ *
+ * A must access always trumps a may access, so there is no need
+ * for a must access to also be considered as a may access.  Doing so
+ * would only cost extra computations only to find out that
+ * the duplicated may access does not make any difference.
+ */
+static __isl_give isl_union_access_info *isl_union_access_info_normalize(
+	__isl_take isl_union_access_info *access)
+{
+	if (!access)
+		return NULL;
+	access->accessisl_access_may_source =
+		isl_union_map_subtract(access->accessisl_access_may_source,
+		    isl_union_map_copy(access->accessisl_access_must_source));
+	if (!access->accessisl_access_may_source)
+		return isl_union_access_info_free(access);
 
-	data = (struct isl_compute_flow_data *)user;
+	return access;
+}
 
-	ctx = isl_map_get_ctx(map);
+/* Given a description of the "sink" accesses, the "source" accesses and
+ * a schedule, compute for each instance of a sink access
+ * and for each element accessed by that instance,
+ * the possible or definite source accesses that last accessed the
+ * element accessed by the sink access before this sink access
+ * in the sense that there is no intermediate definite source access.
+ *
+ * The must_no_source and may_no_source elements of the result
+ * are subsets of access->sink.  The elements must_dep and may_dep
+ * map domain elements of access->{may,must)_source to
+ * domain elements of access->sink.
+ *
+ * This function is used when only the schedule map representation
+ * is available.
+ *
+ * We first prepend the schedule dimensions to the domain
+ * of the accesses so that we can easily compare their relative order.
+ * Then we consider each sink access individually in compute_flow.
+ */
+static __isl_give isl_union_flow *compute_flow_union_map(
+	__isl_take isl_union_access_info *access)
+{
+	struct isl_compute_flow_data data;
+	isl_union_map *sink;
 
-	data->accesses = NULL;
-	data->sink_info = NULL;
-	data->source_info = NULL;
-	data->count = 0;
-	data->dim = isl_space_range(isl_map_get_space(map));
+	access = isl_union_access_info_align_params(access);
+	access = isl_union_access_info_introduce_schedule(access);
+	if (!access)
+		return NULL;
 
-	if (isl_union_map_foreach_map(data->must_source,
-					&count_matching_array, data) < 0)
-		goto error;
-	if (isl_union_map_foreach_map(data->may_source,
-					&count_matching_array, data) < 0)
-		goto error;
+	data.must_source = access->accessisl_access_must_source;
+	data.may_source = access->accessisl_access_may_source;
 
-	data->sink_info = sched_info_alloc(map);
-	data->source_info = isl_calloc_array(ctx, struct isl_sched_info *,
-					     data->count);
+	sink = access->accessisl_access_sink;
+	data.flow = isl_union_flow_alloc(isl_union_map_get_space(sink));
 
-	data->accesses = isl_access_info_alloc(isl_map_copy(map),
-				data->sink_info, &before, data->count);
-	if (!data->sink_info || (data->count && !data->source_info) ||
-	    !data->accesses)
+	if (isl_union_map_foreach_map(sink, &compute_flow, &data) < 0)
 		goto error;
-	data->count = 0;
+
+	data.flow = isl_union_flow_drop_schedule(data.flow);
+
+	isl_union_access_info_free(access);
+	return data.flow;
+error:
+	isl_union_access_info_free(access);
+	isl_union_flow_free(data.flow);
+	return NULL;
+}
+
+/* A schedule access relation.
+ *
+ * The access relation "access" is of the form S -> D -> A,
+ * where S corresponds to the prefix schedule at "node".
+ * "must" is only relevant for source accesses and indicates
+ * whether the access is a must source or a may source.
+ */
+struct isl_scheduled_access {
+	isl_map *access;
+	int must;
+	isl_schedule_node *node;
+};
+
+/* Data structure for keeping track of individual scheduled sink and source
+ * accesses when computing dependence analysis based on a schedule tree.
+ *
+ * "n_sink" is the number of used entries in "sink"
+ * "n_source" is the number of used entries in "source"
+ *
+ * "set_sink", "must" and "node" are only used inside collect_sink_source,
+ * to keep track of the current node and
+ * of what extract_sink_source needs to do.
+ */
+struct isl_compute_flow_schedule_data {
+	isl_union_access_info *access;
+
+	int n_sink;
+	int n_source;
+
+	struct isl_scheduled_access *sink;
+	struct isl_scheduled_access *source;
+
+	int set_sink;
+	int must;
+	isl_schedule_node *node;
+};
+
+/* Align the parameters of all sinks with all sources.
+ *
+ * If there are no sinks or no sources, then no alignment is needed.
+ */
+static void isl_compute_flow_schedule_data_align_params(
+	struct isl_compute_flow_schedule_data *data)
+{
+	int i;
+	isl_space *space;
+
+	if (data->n_sink == 0 || data->n_source == 0)
+		return;
+
+	space = isl_map_get_space(data->sink0.access);
+
+	for (i = 1; i < data->n_sink; ++i)
+		space = isl_space_align_params(space,
+				isl_map_get_space(data->sinki.access));
+	for (i = 0; i < data->n_source; ++i)
+		space = isl_space_align_params(space,
+				isl_map_get_space(data->sourcei.access));
+
+	for (i = 0; i < data->n_sink; ++i)
+		data->sinki.access =
+			isl_map_align_params(data->sinki.access,
+							isl_space_copy(space));
+	for (i = 0; i < data->n_source; ++i)
+		data->sourcei.access =
+			isl_map_align_params(data->sourcei.access,
+							isl_space_copy(space));
+
+	isl_space_free(space);
+}
+
+/* Free all the memory referenced from "data".
+ * Do not free "data" itself as it may be allocated on the stack.
+ */
+static void isl_compute_flow_schedule_data_clear(
+	struct isl_compute_flow_schedule_data *data)
+{
+	int i;
+
+	if (!data->sink)
+		return;
+
+	for (i = 0; i < data->n_sink; ++i) {
+		isl_map_free(data->sinki.access);
+		isl_schedule_node_free(data->sinki.node);
+	}
+
+	for (i = 0; i < data->n_source; ++i) {
+		isl_map_free(data->sourcei.access);
+		isl_schedule_node_free(data->sourcei.node);
+	}
+
+	free(data->sink);
+}
+
+/* isl_schedule_foreach_schedule_node_top_down callback for counting
+ * (an upper bound on) the number of sinks and sources.
+ *
+ * Sinks and sources are only extracted at leaves of the tree,
+ * so we skip the node if it is not a leaf.
+ * Otherwise we increment data->n_sink and data->n_source with
+ * the number of spaces in the sink and source access domains
+ * that reach this node.
+ */
+static isl_bool count_sink_source(__isl_keep isl_schedule_node *node,
+	void *user)
+{
+	struct isl_compute_flow_schedule_data *data = user;
+	isl_union_set *domain;
+	isl_union_map *umap;
+	isl_bool r = isl_bool_false;
+	isl_size n;
+
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_leaf)
+		return isl_bool_true;
+
+	domain = isl_schedule_node_get_universe_domain(node);
+
+	umap = isl_union_map_copy(data->access->accessisl_access_sink);
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
+	data->n_sink += n = isl_union_map_n_map(umap);
+	isl_union_map_free(umap);
+	if (n < 0)
+		r = isl_bool_error;
+
+	umap = isl_union_map_copy(data->access->accessisl_access_must_source);
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
+	data->n_source += n = isl_union_map_n_map(umap);
+	isl_union_map_free(umap);
+	if (n < 0)
+		r = isl_bool_error;
+
+	umap = isl_union_map_copy(data->access->accessisl_access_may_source);
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(domain));
+	data->n_source += n = isl_union_map_n_map(umap);
+	isl_union_map_free(umap);
+	if (n < 0)
+		r = isl_bool_error;
+
+	isl_union_set_free(domain);
+
+	return r;
+}
+
+/* Add a single scheduled sink or source (depending on data->set_sink)
+ * with scheduled access relation "map", must property data->must and
+ * schedule node data->node to the list of sinks or sources.
+ */
+static isl_stat extract_sink_source(__isl_take isl_map *map, void *user)
+{
+	struct isl_compute_flow_schedule_data *data = user;
+	struct isl_scheduled_access *access;
+
+	if (data->set_sink)
+		access = data->sink + data->n_sink++;
+	else
+		access = data->source + data->n_source++;
+
+	access->access = map;
+	access->must = data->must;
+	access->node = isl_schedule_node_copy(data->node);
+
+	return isl_stat_ok;
+}
+
+/* isl_schedule_foreach_schedule_node_top_down callback for collecting
+ * individual scheduled source and sink accesses (taking into account
+ * the domain of the schedule).
+ *
+ * We only collect accesses at the leaves of the schedule tree.
+ * We prepend the schedule dimensions at the leaf to the iteration
+ * domains of the source and sink accesses and then extract
+ * the individual accesses (per space).
+ *
+ * In particular, if the prefix schedule at the node is of the form
+ *
+ *	D -> S
+ *
+ * while the access relations are of the form
+ *
+ *	D -> A
+ *
+ * then the updated access relations are of the form
+ *
+ *	S -> D -> A
+ *
+ * Note that S consists of a single space such that introducing S
+ * in the access relations does not increase the number of spaces.
+ */
+static isl_bool collect_sink_source(__isl_keep isl_schedule_node *node,
+	void *user)
+{
+	struct isl_compute_flow_schedule_data *data = user;
+	isl_union_map *prefix;
+	isl_union_map *umap;
+	isl_bool r = isl_bool_false;
+
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_leaf)
+		return isl_bool_true;
+
+	data->node = node;
+
+	prefix = isl_schedule_node_get_prefix_schedule_relation(node);
+	prefix = isl_union_map_reverse(prefix);
+	prefix = isl_union_map_range_map(prefix);
+
+	data->set_sink = 1;
+	umap = isl_union_map_copy(data->access->accessisl_access_sink);
+	umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
+	if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
+		r = isl_bool_error;
+	isl_union_map_free(umap);
+
+	data->set_sink = 0;
 	data->must = 1;
-	if (isl_union_map_foreach_map(data->must_source,
-					&collect_matching_array, data) < 0)
-		goto error;
+	umap = isl_union_map_copy(data->access->accessisl_access_must_source);
+	umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
+	if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
+		r = isl_bool_error;
+	isl_union_map_free(umap);
+
+	data->set_sink = 0;
 	data->must = 0;
-	if (isl_union_map_foreach_map(data->may_source,
-					&collect_matching_array, data) < 0)
-		goto error;
+	umap = isl_union_map_copy(data->access->accessisl_access_may_source);
+	umap = isl_union_map_apply_range(isl_union_map_copy(prefix), umap);
+	if (isl_union_map_foreach_map(umap, &extract_sink_source, data) < 0)
+		r = isl_bool_error;
+	isl_union_map_free(umap);
 
-	flow = isl_access_info_compute_flow(data->accesses);
-	data->accesses = NULL;
+	isl_union_map_free(prefix);
+
+	return r;
+}
+
+/* isl_access_info_compute_flow callback for determining whether
+ * the shared nesting level and the ordering within that level
+ * for two scheduled accesses for use in compute_single_flow.
+ *
+ * The tokens passed to this function refer to the leaves
+ * in the schedule tree where the accesses take place.
+ *
+ * If n is the shared number of loops, then we need to return
+ * "2 * n + 1" if "first" precedes "second" inside the innermost
+ * shared loop and "2 * n" otherwise.
+ *
+ * The innermost shared ancestor may be the leaves themselves
+ * if the accesses take place in the same leaf.  Otherwise,
+ * it is either a set node or a sequence node.  Only in the case
+ * of a sequence node do we consider one access to precede the other.
+ */
+static int before_node(void *first, void *second)
+{
+	isl_schedule_node *node1 = first;
+	isl_schedule_node *node2 = second;
+	isl_schedule_node *shared;
+	isl_size depth;
+	int before = 0;
+
+	shared = isl_schedule_node_get_shared_ancestor(node1, node2);
+	depth = isl_schedule_node_get_schedule_depth(shared);
+	if (depth < 0) {
+		isl_schedule_node_free(shared);
+		return -1;
+	}
+
+	if (isl_schedule_node_get_type(shared) == isl_schedule_node_sequence) {
+		isl_size pos1, pos2;
+
+		pos1 = isl_schedule_node_get_ancestor_child_position(node1,
+								    shared);
+		pos2 = isl_schedule_node_get_ancestor_child_position(node2,
+								    shared);
+		if (pos1 < 0 || pos2 < 0) {
+			isl_schedule_node_free(shared);
+			return -1;
+		}
+		before = pos1 < pos2;
+	}
 
+	isl_schedule_node_free(shared);
+
+	return 2 * depth + before;
+}
+
+/* Check if the given two accesses may be coscheduled.
+ * If so, return isl_bool_true.  Otherwise return isl_bool_false.
+ *
+ * Two accesses may only be coscheduled if they appear in the same leaf.
+ */
+static isl_bool coscheduled_node(void *first, void *second)
+{
+	isl_schedule_node *node1 = first;
+	isl_schedule_node *node2 = second;
+
+	return isl_bool_ok(node1 == node2);
+}
+
+/* Add the scheduled sources from "data" that access
+ * the same data space as "sink" to "access".
+ */
+static __isl_give isl_access_info *add_matching_sources(
+	__isl_take isl_access_info *access, struct isl_scheduled_access *sink,
+	struct isl_compute_flow_schedule_data *data)
+{
+	int i;
+	isl_space *space;
+
+	space = isl_space_range(isl_map_get_space(sink->access));
+	for (i = 0; i < data->n_source; ++i) {
+		struct isl_scheduled_access *source;
+		isl_space *source_space;
+		int eq;
+
+		source = &data->sourcei;
+		source_space = isl_map_get_space(source->access);
+		source_space = isl_space_range(source_space);
+		eq = isl_space_is_equal(space, source_space);
+		isl_space_free(source_space);
+
+		if (!eq)
+			continue;
+		if (eq < 0)
+			goto error;
+
+		access = isl_access_info_add_source(access,
+		    isl_map_copy(source->access), source->must, source->node);
+	}
+
+	isl_space_free(space);
+	return access;
+error:
+	isl_space_free(space);
+	isl_access_info_free(access);
+	return NULL;
+}
+
+/* Given a scheduled sink access relation "sink", compute the corresponding
+ * dependences on the sources in "data" and add the computed dependences
+ * to "uf".
+ *
+ * The dependences computed by access_info_compute_flow_core are of the form
+ *
+ *	S -> I -> S' -> I' -> A
+ *
+ * The schedule dimensions are projected out by first currying the range,
+ * resulting in
+ *
+ *	S -> I -> S' -> I' -> A
+ *
+ * and then computing the factor range
+ *
+ *	I -> I' -> A
+ */
+static __isl_give isl_union_flow *compute_single_flow(
+	__isl_take isl_union_flow *uf, struct isl_scheduled_access *sink,
+	struct isl_compute_flow_schedule_data *data)
+{
+	int i;
+	isl_access_info *access;
+	isl_flow *flow;
+	isl_map *map;
+
+	if (!uf)
+		return NULL;
+
+	access = isl_access_info_alloc(isl_map_copy(sink->access), sink->node,
+					&before_node, data->n_source);
+	if (access)
+		access->coscheduled = &coscheduled_node;
+	access = add_matching_sources(access, sink, data);
+
+	flow = access_info_compute_flow_core(access);
 	if (!flow)
-		goto error;
+		return isl_union_flow_free(uf);
 
-	data->must_no_source = isl_union_map_union(data->must_no_source,
-		    isl_union_map_from_map(isl_flow_get_no_source(flow, 1)));
-	data->may_no_source = isl_union_map_union(data->may_no_source,
-		    isl_union_map_from_map(isl_flow_get_no_source(flow, 0)));
+	map = isl_map_domain_factor_range(isl_flow_get_no_source(flow, 1));
+	uf->must_no_source = isl_union_map_union(uf->must_no_source,
+						isl_union_map_from_map(map));
+	map = isl_map_domain_factor_range(isl_flow_get_no_source(flow, 0));
+	uf->may_no_source = isl_union_map_union(uf->may_no_source,
+						isl_union_map_from_map(map));
 
 	for (i = 0; i < flow->n_source; ++i) {
 		isl_union_map *dep;
-		dep = isl_union_map_from_map(isl_map_copy(flow->depi.map));
+
+		map = isl_map_range_curry(isl_map_copy(flow->depi.map));
+		map = isl_map_factor_range(map);
+		dep = isl_union_map_from_map(map);
 		if (flow->depi.must)
-			data->must_dep = isl_union_map_union(data->must_dep, dep);
+			uf->must_dep = isl_union_map_union(uf->must_dep, dep);
 		else
-			data->may_dep = isl_union_map_union(data->may_dep, dep);
+			uf->may_dep = isl_union_map_union(uf->may_dep, dep);
 	}
 
 	isl_flow_free(flow);
 
-	sched_info_free(data->sink_info);
-	if (data->source_info) {
-		for (i = 0; i < data->count; ++i)
-			sched_info_free(data->source_infoi);
-		free(data->source_info);
-	}
-	isl_space_free(data->dim);
-	isl_map_free(map);
+	return uf;
+}
 
-	return 0;
+/* Given a description of the "sink" accesses, the "source" accesses and
+ * a schedule, compute for each instance of a sink access
+ * and for each element accessed by that instance,
+ * the possible or definite source accesses that last accessed the
+ * element accessed by the sink access before this sink access
+ * in the sense that there is no intermediate definite source access.
+ * Only consider dependences between statement instances that belong
+ * to the domain of the schedule.
+ *
+ * The must_no_source and may_no_source elements of the result
+ * are subsets of access->sink.  The elements must_dep and may_dep
+ * map domain elements of access->{may,must)_source to
+ * domain elements of access->sink.
+ *
+ * This function is used when a schedule tree representation
+ * is available.
+ *
+ * We extract the individual scheduled source and sink access relations
+ * (taking into account the domain of the schedule) and
+ * then compute dependences for each scheduled sink individually.
+ */
+static __isl_give isl_union_flow *compute_flow_schedule(
+	__isl_take isl_union_access_info *access)
+{
+	struct isl_compute_flow_schedule_data data = { access };
+	int i, n;
+	isl_ctx *ctx;
+	isl_space *space;
+	isl_union_flow *flow;
+
+	ctx = isl_union_access_info_get_ctx(access);
+
+	data.n_sink = 0;
+	data.n_source = 0;
+	if (isl_schedule_foreach_schedule_node_top_down(access->schedule,
+						&count_sink_source, &data) < 0)
+		goto error;
+
+	n = data.n_sink + data.n_source;
+	data.sink = isl_calloc_array(ctx, struct isl_scheduled_access, n);
+	if (n && !data.sink)
+		goto error;
+	data.source = data.sink + data.n_sink;
+
+	data.n_sink = 0;
+	data.n_source = 0;
+	if (isl_schedule_foreach_schedule_node_top_down(access->schedule,
+					    &collect_sink_source, &data) < 0)
+		goto error;
+
+	space = isl_union_map_get_space(access->accessisl_access_sink);
+	flow = isl_union_flow_alloc(space);
+
+	isl_compute_flow_schedule_data_align_params(&data);
+
+	for (i = 0; i < data.n_sink; ++i)
+		flow = compute_single_flow(flow, &data.sinki, &data);
+
+	isl_compute_flow_schedule_data_clear(&data);
+
+	isl_union_access_info_free(access);
+	return flow;
 error:
-	isl_access_info_free(data->accesses);
-	sched_info_free(data->sink_info);
-	if (data->source_info) {
-		for (i = 0; i < data->count; ++i)
-			sched_info_free(data->source_infoi);
-		free(data->source_info);
+	isl_union_access_info_free(access);
+	isl_compute_flow_schedule_data_clear(&data);
+	return NULL;
+}
+
+/* Given a description of the "sink" accesses, the "source" accesses and
+ * a schedule, compute for each instance of a sink access
+ * and for each element accessed by that instance,
+ * the possible or definite source accesses that last accessed the
+ * element accessed by the sink access before this sink access
+ * in the sense that there is no intermediate definite source access.
+ *
+ * The must_no_source and may_no_source elements of the result
+ * are subsets of access->sink.  The elements must_dep and may_dep
+ * map domain elements of access->{may,must)_source to
+ * domain elements of access->sink.
+ *
+ * If any kills have been specified, then they are treated as
+ * must-sources internally.  Any dependence that purely derives
+ * from an original kill is removed from the output.
+ *
+ * We check whether the schedule is available as a schedule tree
+ * or a schedule map and call the corresponding function to perform
+ * the analysis.
+ */
+__isl_give isl_union_flow *isl_union_access_info_compute_flow(
+	__isl_take isl_union_access_info *access)
+{
+	isl_bool has_kill;
+	isl_union_map *must = NULL, *may = NULL;
+	isl_union_flow *flow;
+
+	has_kill = isl_union_access_has_kill(access);
+	if (has_kill < 0)
+		goto error;
+	if (has_kill) {
+		must = isl_union_access_info_get_must_source(access);
+		may = isl_union_access_info_get_may_source(access);
 	}
-	isl_space_free(data->dim);
-	isl_map_free(map);
+	access = isl_union_access_info_add_kill_to_must_source(access);
+	access = isl_union_access_info_normalize(access);
+	if (!access)
+		goto error;
+	if (access->schedule)
+		flow = compute_flow_schedule(access);
+	else
+		flow = compute_flow_union_map(access);
+	if (has_kill)
+		flow = isl_union_flow_drop_kill_source(flow, must, may);
+	return flow;
+error:
+	isl_union_access_info_free(access);
+	isl_union_map_free(must);
+	isl_union_map_free(may);
+	return NULL;
+}
 
-	return -1;
+/* Print the information contained in "flow" to "p".
+ * The information is printed as a YAML document.
+ */
+__isl_give isl_printer *isl_printer_print_union_flow(
+	__isl_take isl_printer *p, __isl_keep isl_union_flow *flow)
+{
+	isl_union_map *umap;
+
+	if (!flow)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_mapping(p);
+	umap = isl_union_flow_get_full_must_dependence(flow);
+	p = print_yaml_field_union_map(p, "must_dependence", umap);
+	isl_union_map_free(umap);
+	umap = isl_union_flow_get_full_may_dependence(flow);
+	p = print_yaml_field_union_map(p, "may_dependence", umap);
+	isl_union_map_free(umap);
+	p = print_yaml_field_union_map(p, "must_no_source",
+					flow->must_no_source);
+	umap = isl_union_flow_get_may_no_source(flow);
+	p = print_yaml_field_union_map(p, "may_no_source", umap);
+	isl_union_map_free(umap);
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+/* Return a string representation of the information in "flow".
+ * The information is printed in flow format.
+ */
+__isl_give char *isl_union_flow_to_str(__isl_keep isl_union_flow *flow)
+{
+	isl_printer *p;
+	char *s;
+
+	if (!flow)
+		return NULL;
+
+	p = isl_printer_to_str(isl_union_flow_get_ctx(flow));
+	p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_FLOW);
+	p = isl_printer_print_union_flow(p, flow);
+	s = isl_printer_get_str(p);
+	isl_printer_free(p);
+
+	return s;
 }
 
 /* Given a collection of "sink" and "source" accesses,
@@ -1392,9 +3289,9 @@
  * corresponding to those iterations that access an element
  * not previously accessed.
  *
- * We first prepend the schedule dimensions to the domain
- * of the accesses so that we can easily compare their relative order.
- * Then we consider each sink access individually in compute_flow.
+ * We collect the inputs in an isl_union_access_info object,
+ * call isl_union_access_info_compute_flow and extract
+ * the outputs from the result.
  */
 int isl_union_map_compute_flow(__isl_take isl_union_map *sink,
 	__isl_take isl_union_map *must_source,
@@ -1404,93 +3301,40 @@
 	__isl_give isl_union_map **must_no_source,
 	__isl_give isl_union_map **may_no_source)
 {
-	isl_space *dim;
-	isl_union_map *range_map = NULL;
-	struct isl_compute_flow_data data;
+	isl_union_access_info *access;
+	isl_union_flow *flow;
 
-	sink = isl_union_map_align_params(sink,
-					    isl_union_map_get_space(must_source));
-	sink = isl_union_map_align_params(sink,
-					    isl_union_map_get_space(may_source));
-	sink = isl_union_map_align_params(sink,
-					    isl_union_map_get_space(schedule));
-	dim = isl_union_map_get_space(sink);
-	must_source = isl_union_map_align_params(must_source, isl_space_copy(dim));
-	may_source = isl_union_map_align_params(may_source, isl_space_copy(dim));
-	schedule = isl_union_map_align_params(schedule, isl_space_copy(dim));
-
-	schedule = isl_union_map_reverse(schedule);
-	range_map = isl_union_map_range_map(schedule);
-	schedule = isl_union_map_reverse(isl_union_map_copy(range_map));
-	sink = isl_union_map_apply_domain(sink, isl_union_map_copy(schedule));
-	must_source = isl_union_map_apply_domain(must_source,
-						isl_union_map_copy(schedule));
-	may_source = isl_union_map_apply_domain(may_source, schedule);
-
-	data.must_source = must_source;
-	data.may_source = may_source;
-	data.must_dep = must_dep ?
-		isl_union_map_empty(isl_space_copy(dim)) : NULL;
-	data.may_dep = may_dep ? isl_union_map_empty(isl_space_copy(dim)) : NULL;
-	data.must_no_source = must_no_source ?
-		isl_union_map_empty(isl_space_copy(dim)) : NULL;
-	data.may_no_source = may_no_source ?
-		isl_union_map_empty(isl_space_copy(dim)) : NULL;
-
-	isl_space_free(dim);
+	access = isl_union_access_info_from_sink(sink);
+	access = isl_union_access_info_set_must_source(access, must_source);
+	access = isl_union_access_info_set_may_source(access, may_source);
+	access = isl_union_access_info_set_schedule_map(access, schedule);
+	flow = isl_union_access_info_compute_flow(access);
 
-	if (isl_union_map_foreach_map(sink, &compute_flow, &data) < 0)
-		goto error;
+	if (must_dep)
+		*must_dep = isl_union_flow_get_must_dependence(flow);
+	if (may_dep)
+		*may_dep = isl_union_flow_get_non_must_dependence(flow);
+	if (must_no_source)
+		*must_no_source = isl_union_flow_get_must_no_source(flow);
+	if (may_no_source)
+		*may_no_source = isl_union_flow_get_non_must_no_source(flow);
 
-	isl_union_map_free(sink);
-	isl_union_map_free(must_source);
-	isl_union_map_free(may_source);
-
-	if (must_dep) {
-		data.must_dep = isl_union_map_apply_domain(data.must_dep,
-					isl_union_map_copy(range_map));
-		data.must_dep = isl_union_map_apply_range(data.must_dep,
-					isl_union_map_copy(range_map));
-		*must_dep = data.must_dep;
-	}
-	if (may_dep) {
-		data.may_dep = isl_union_map_apply_domain(data.may_dep,
-					isl_union_map_copy(range_map));
-		data.may_dep = isl_union_map_apply_range(data.may_dep,
-					isl_union_map_copy(range_map));
-		*may_dep = data.may_dep;
-	}
-	if (must_no_source) {
-		data.must_no_source = isl_union_map_apply_domain(
-			data.must_no_source, isl_union_map_copy(range_map));
-		*must_no_source = data.must_no_source;
-	}
-	if (may_no_source) {
-		data.may_no_source = isl_union_map_apply_domain(
-			data.may_no_source, isl_union_map_copy(range_map));
-		*may_no_source = data.may_no_source;
-	}
+	isl_union_flow_free(flow);
 
-	isl_union_map_free(range_map);
+	if ((must_dep && !*must_dep) || (may_dep && !*may_dep) ||
+	    (must_no_source && !*must_no_source) ||
+	    (may_no_source && !*may_no_source))
+		goto error;
 
 	return 0;
 error:
-	isl_union_map_free(range_map);
-	isl_union_map_free(sink);
-	isl_union_map_free(must_source);
-	isl_union_map_free(may_source);
-	isl_union_map_free(data.must_dep);
-	isl_union_map_free(data.may_dep);
-	isl_union_map_free(data.must_no_source);
-	isl_union_map_free(data.may_no_source);
-
 	if (must_dep)
-		*must_dep = NULL;
+		*must_dep = isl_union_map_free(*must_dep);
 	if (may_dep)
-		*may_dep = NULL;
+		*may_dep = isl_union_map_free(*may_dep);
 	if (must_no_source)
-		*must_no_source = NULL;
+		*must_no_source = isl_union_map_free(*must_no_source);
 	if (may_no_source)
-		*may_no_source = NULL;
+		*may_no_source = isl_union_map_free(*may_no_source);
 	return -1;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_fold.c -> _service:tar_scm:isl-0.24.tar.gz/isl_fold.c Changed

@@ -8,7 +8,6 @@
  * 91893 Orsay, France 
  */
 
-#define ISL_DIM_H
 #include <isl_map_private.h>
 #include <isl_union_map_private.h>
 #include <isl_polynomial_private.h>
@@ -20,11 +19,17 @@
 #include <isl_val_private.h>
 #include <isl_vec_private.h>
 #include <isl_config.h>
-#include <isl/deprecated/polynomial_int.h>
+
+#undef EL_BASE
+#define EL_BASE pw_qpolynomial_fold
+
+#include <isl_list_templ.c>
 
 enum isl_fold isl_fold_type_negate(enum isl_fold type)
 {
 	switch (type) {
+	case isl_fold_error:
+		return isl_fold_error;
 	case isl_fold_min:
 		return isl_fold_max;
 	case isl_fold_max:
@@ -36,30 +41,33 @@
 	isl_die(NULL, isl_error_internal, "unhandled isl_fold type", abort());
 }
 
+/* Construct a new reduction with the given type, domain space and
+ * list of polynomials.
+ */
 static __isl_give isl_qpolynomial_fold *qpolynomial_fold_alloc(
-	enum isl_fold type, __isl_take isl_space *dim, int n)
+	enum isl_fold type, __isl_take isl_space *space,
+	__isl_take isl_qpolynomial_list *list)
 {
+	isl_ctx *ctx;
 	isl_qpolynomial_fold *fold;
 
-	if (!dim)
+	if (type < 0 || !space || !list)
 		goto error;
 
-	isl_assert(dim->ctx, n >= 0, goto error);
-	fold = isl_calloc(dim->ctx, struct isl_qpolynomial_fold,
-			sizeof(struct isl_qpolynomial_fold) +
-			(n - 1) * sizeof(struct isl_qpolynomial *));
+	ctx = isl_space_get_ctx(space);
+	fold = isl_calloc_type(ctx, struct isl_qpolynomial_fold);
 	if (!fold)
 		goto error;
 
 	fold->ref = 1;
-	fold->size = n;
-	fold->n = 0;
 	fold->type = type;
-	fold->dim = dim;
+	fold->dim = space;
+	fold->list = list;
 
 	return fold;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
+	isl_qpolynomial_list_free(list);
 	return NULL;
 }
 
@@ -68,10 +76,72 @@
 	return fold ? fold->dim->ctx : NULL;
 }
 
+/* Return the domain space of "fold".
+ */
+static __isl_keep isl_space *isl_qpolynomial_fold_peek_domain_space(
+	__isl_keep isl_qpolynomial_fold *fold)
+{
+	return fold ? fold->dim : NULL;
+}
+
 __isl_give isl_space *isl_qpolynomial_fold_get_domain_space(
 	__isl_keep isl_qpolynomial_fold *fold)
 {
-	return fold ? isl_space_copy(fold->dim) : NULL;
+	return isl_space_copy(isl_qpolynomial_fold_peek_domain_space(fold));
+}
+
+/* Return the space of the domain of "fold".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "fold".
+ * This allows the space to be modified inplace
+ * if both the expression and its space have only a single reference.
+ * The caller is not allowed to modify "fold" between this call and
+ * a subsequent call to isl_qpolynomial_fold_restore_domain_space.
+ * The only exception is that isl_qpolynomial_fold_free can be called instead.
+ */
+static __isl_give isl_space *isl_qpolynomial_fold_take_domain_space(
+	__isl_keep isl_qpolynomial_fold *fold)
+{
+	isl_space *space;
+
+	if (!fold)
+		return NULL;
+	if (fold->ref != 1)
+		return isl_qpolynomial_fold_get_domain_space(fold);
+	space = fold->dim;
+	fold->dim = NULL;
+	return space;
+}
+
+/* Set the space of the domain of "fold" to "space",
+ * where the space of "fold" may be missing
+ * due to a preceding call to isl_qpolynomial_fold_take_domain_space.
+ * However, in this case, "fold" only has a single reference and
+ * then the call to isl_qpolynomial_fold_cow has no effect.
+ */
+static
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_restore_domain_space(
+	__isl_keep isl_qpolynomial_fold *fold, __isl_take isl_space *space)
+{
+	if (!fold || !space)
+		goto error;
+
+	if (fold->dim == space) {
+		isl_space_free(space);
+		return fold;
+	}
+
+	fold = isl_qpolynomial_fold_cow(fold);
+	if (!fold)
+		goto error;
+	isl_space_free(fold->dim);
+	fold->dim = space;
+
+	return fold;
+error:
+	isl_qpolynomial_fold_free(fold);
+	isl_space_free(space);
+	return NULL;
 }
 
 __isl_give isl_space *isl_qpolynomial_fold_get_space(
@@ -86,32 +156,107 @@
 	return space;
 }
 
-__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim)
+/* Return the list of polynomials in the reduction "fold".
+ */
+__isl_keep isl_qpolynomial_list *isl_qpolynomial_fold_peek_list(
+	__isl_keep isl_qpolynomial_fold *fold)
 {
-	int i;
+	return fold ? fold->list : NULL;
+}
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold || !dim)
+/* Return a copy of the list of polynomials in the reduction "fold".
+ */
+static __isl_give isl_qpolynomial_list *isl_qpolynomial_fold_get_list(
+	__isl_keep isl_qpolynomial_fold *fold)
+{
+	return isl_qpolynomial_list_copy(isl_qpolynomial_fold_peek_list(fold));
+}
+
+/* Return the list of polynomials of "fold".
+ * This may be either a copy or the list itself
+ * if there is only one reference to "fold".
+ * This allows the list to be modified inplace
+ * if both the expression and its list have only a single reference.
+ * The caller is not allowed to modify "fold" between this call and
+ * a subsequent call to isl_qpolynomial_fold_restore_list.
+ * The only exception is that isl_qpolynomial_fold_free can be called instead.
+ */
+static __isl_give isl_qpolynomial_list *isl_qpolynomial_fold_take_list(
+	__isl_keep isl_qpolynomial_fold *fold)
+{
+	isl_qpolynomial_list *list;
+
+	if (!fold)
+		return NULL;
+	if (fold->ref != 1)
+		return isl_qpolynomial_fold_get_list(fold);
+	list = fold->list;
+	fold->list = NULL;
+	return list;
+}
+
+/* Set the space of the list of polynomials of "fold" to "space",
+ * where the list of polynomials of "fold" may be missing
+ * due to a preceding call to isl_qpolynomial_fold_take_list.
+ * However, in this case, "fold" only has a single reference and
+ * then the call to isl_qpolynomial_fold_cow has no effect.
+ */
+static __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_restore_list(
+	__isl_keep isl_qpolynomial_fold *fold,
+	__isl_take isl_qpolynomial_list *list)
+{
+	if (!fold || !list)
 		goto error;
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_reset_domain_space(fold->qpi,
-							isl_space_copy(dim));
-		if (!fold->qpi)
-			goto error;
+	if (fold->list == list) {
+		isl_qpolynomial_list_free(list);
+		return fold;
 	}
 
-	isl_space_free(fold->dim);
-	fold->dim = dim;
+	fold = isl_qpolynomial_fold_cow(fold);
+	if (!fold)
+		goto error;
+	isl_qpolynomial_list_free(fold->list);
+	fold->list = list;
 
 	return fold;
 error:
 	isl_qpolynomial_fold_free(fold);
-	isl_space_free(dim);
+	isl_qpolynomial_list_free(list);
 	return NULL;
 }
 
+/* isl_qpolynomial_list_map callback that calls
+ * isl_qpolynomial_reset_domain_space on "qp".
+ */
+static __isl_give isl_qpolynomial *reset_domain_space(
+	__isl_take isl_qpolynomial *qp, void *user)
+{
+	isl_space *space = user;
+
+	return isl_qpolynomial_reset_domain_space(qp, isl_space_copy(space));
+}
+
+/* Replace the domain space of "fold" by "space".
+ *
+ * Replace the domain space itself and that of all polynomials
+ * in the list.
+ */
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space)
+{
+	isl_qpolynomial_list *list;
+
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &reset_domain_space, space);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
+
+	isl_space_free(isl_qpolynomial_fold_take_domain_space(fold));
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
+
+	return fold;
+}
+
 /* Reset the space of "fold".  This function is called from isl_pw_templ.c
  * and doesn't know if the space of an element object is represented
  * directly or through its domain.  It therefore passes along both.
@@ -124,121 +269,199 @@
 	return isl_qpolynomial_fold_reset_domain_space(fold, domain);
 }
 
-int isl_qpolynomial_fold_involves_dims(__isl_keep isl_qpolynomial_fold *fold,
+/* Internal data structure for isl_qpolynomial_fold_*_dims
+ * representing their arguments.
+ */
+struct isl_fold_dims_data {
+	enum isl_dim_type type;
+	unsigned first;
+	unsigned n;
+};
+
+/* isl_qpolynomial_list_every callback that checks whether "qp"
+ * does not involve any dimensions in the given range.
+ */
+static isl_bool not_involved(__isl_keep isl_qpolynomial *qp, void *user)
+{
+	struct isl_fold_dims_data *data = user;
+	isl_bool involves;
+
+	involves = isl_qpolynomial_involves_dims(qp, data->type,
+							data->first, data->n);
+	return isl_bool_not(involves);
+}
+
+/* Does "fold" involve any dimensions in the given range.
+ *
+ * It involves any of those dimensions if it is not the case
+ * that every polynomial in the reduction does not involve
+ * any of the dimensions.
+ */
+static isl_bool isl_qpolynomial_fold_involves_dims(
+	__isl_keep isl_qpolynomial_fold *fold,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	int i;
+	struct isl_fold_dims_data data = { type, first, n };
+	isl_qpolynomial_list *list;
+	isl_bool not;
 
 	if (!fold)
-		return -1;
-	if (fold->n == 0 || n == 0)
-		return 0;
+		return isl_bool_error;
+	if (n == 0)
+		return isl_bool_false;
 
-	for (i = 0; i < fold->n; ++i) {
-		int involves = isl_qpolynomial_involves_dims(fold->qpi,
-							    type, first, n);
-		if (involves < 0 || involves)
-			return involves;
-	}
-	return 0;
+	list = isl_qpolynomial_fold_peek_list(fold);
+	not = isl_qpolynomial_list_every(list, &not_involved, &data);
+	return isl_bool_not(not);
+}
+
+/* Internal data structure for isl_qpolynomial_fold_set_dim_name
+ * representing its arguments.
+ */
+struct isl_fold_set_dim_name_data {
+	enum isl_dim_type type;
+	unsigned pos;
+	const char *s;
+};
+
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_set_dim_name on "qp".
+ */
+static __isl_give isl_qpolynomial *set_dim_name(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	struct isl_fold_set_dim_name_data *data = user;
+
+	qp = isl_qpolynomial_set_dim_name(qp, data->type, data->pos, data->s);
+	return qp;
+}
+
+/* Given a dimension type for an isl_qpolynomial_fold,
+ * return the corresponding type for the domain.
+ */
+static enum isl_dim_type domain_type(enum isl_dim_type type)
+{
+	if (type == isl_dim_in)
+		return isl_dim_set;
+	return type;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_set_dim_name(
 	__isl_take isl_qpolynomial_fold *fold,
 	enum isl_dim_type type, unsigned pos, const char *s)
 {
-	int i;
+	struct isl_fold_set_dim_name_data data = { type, pos, s };
+	enum isl_dim_type set_type;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
-	fold->dim = isl_space_set_dim_name(fold->dim, type, pos, s);
-	if (!fold->dim)
-		goto error;
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &set_dim_name, &data);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_set_dim_name(fold->qpi,
-							    type, pos, s);
-		if (!fold->qpi)
-			goto error;
-	}
+	set_type = domain_type(type);
+	space = isl_qpolynomial_fold_take_domain_space(fold);
+	space = isl_space_set_dim_name(space, set_type, pos, s);
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
+}
+
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_drop_dims on "qp".
+ */
+static __isl_give isl_qpolynomial *drop_dims(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	struct isl_fold_dims_data *data = user;
+
+	qp = isl_qpolynomial_drop_dims(qp, data->type, data->first, data->n);
+	return qp;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_drop_dims(
 	__isl_take isl_qpolynomial_fold *fold,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	int i;
+	struct isl_fold_dims_data data = { type, first, n };
 	enum isl_dim_type set_type;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
 	if (!fold)
 		return NULL;
 	if (n == 0)
 		return fold;
 
-	set_type = type == isl_dim_in ? isl_dim_set : type;
+	set_type = domain_type(type);
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
-	fold->dim = isl_space_drop_dims(fold->dim, set_type, first, n);
-	if (!fold->dim)
-		goto error;
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &drop_dims, &data);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_drop_dims(fold->qpi,
-							    type, first, n);
-		if (!fold->qpi)
-			goto error;
-	}
+	space = isl_qpolynomial_fold_take_domain_space(fold);
+	space = isl_space_drop_dims(space, set_type, first, n);
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
+}
+
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_insert_dims on "qp".
+ */
+static __isl_give isl_qpolynomial *insert_dims(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	struct isl_fold_dims_data *data = user;
+
+	qp = isl_qpolynomial_insert_dims(qp, data->type, data->first, data->n);
+	return qp;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_insert_dims(
 	__isl_take isl_qpolynomial_fold *fold,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	int i;
+	struct isl_fold_dims_data data = { type, first, n };
+	enum isl_dim_type set_type;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
 	if (!fold)
 		return NULL;
 	if (n == 0 && !isl_space_is_named_or_nested(fold->dim, type))
 		return fold;
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
-	fold->dim = isl_space_insert_dims(fold->dim, type, first, n);
-	if (!fold->dim)
-		goto error;
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &insert_dims, &data);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_insert_dims(fold->qpi,
-							    type, first, n);
-		if (!fold->qpi)
-			goto error;
-	}
+	set_type = domain_type(type);
+	space = isl_qpolynomial_fold_take_domain_space(fold);
+	space = isl_space_insert_dims(space, set_type, first, n);
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
 }
 
+/* Determine the sign of the constant quasipolynomial "qp".
+ *
+ * Return
+ *	-1 if qp <= 0
+ *	 1 if qp >= 0
+ *	 0 if unknown
+ *
+ * For qp == 0, we can return either -1 or 1.  In practice, we return 1.
+ * For qp == NaN, the sign is undefined, so we return 0.
+ */
 static int isl_qpolynomial_cst_sign(__isl_keep isl_qpolynomial *qp)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_as_cst(qp->upoly);
+	if (isl_qpolynomial_is_nan(qp))
+		return 0;
+
+	cst = isl_poly_as_cst(qp->poly);
 	if (!cst)
 		return 0;
 
@@ -303,10 +526,10 @@
 static int isl_qpolynomial_sign(__isl_keep isl_set *set,
 	__isl_keep isl_qpolynomial *qp)
 {
-	int d;
+	isl_size d;
 	int i;
-	int is;
-	struct isl_upoly_rec *rec;
+	isl_bool is;
+	isl_poly_rec *rec;
 	isl_vec *v;
 	isl_int l;
 	enum isl_lp_result res;
@@ -327,18 +550,20 @@
 	if (qp->div->n_row > 0)
 		return 0;
 
-	rec = isl_upoly_as_rec(qp->upoly);
+	rec = isl_poly_as_rec(qp->poly);
 	if (!rec)
 		return 0;
 
 	d = isl_space_dim(qp->dim, isl_dim_all);
+	if (d < 0)
+		return 0;
 	v = isl_vec_alloc(set->ctx, 2 + d);
 	if (!v)
 		return 0;
 
 	isl_seq_clr(v->el + 1, 1 + d);
 	isl_int_set_si(v->el0, 1);
-	isl_int_set_si(v->el2 + qp->upoly->var, 1);
+	isl_int_set_si(v->el2 + qp->poly->var, 1);
 
 	isl_int_init(l);
 
@@ -351,16 +576,16 @@
 
 		min = isl_qpolynomial_cst_on_domain(isl_space_copy(qp->dim), l);
 		base = isl_qpolynomial_var_pow_on_domain(isl_space_copy(qp->dim),
-						qp->upoly->var, 1);
+						qp->poly->var, 1);
 
 		r = isl_qpolynomial_alloc(isl_space_copy(qp->dim), 0,
-					  isl_upoly_copy(rec->prec->n - 1));
+					  isl_poly_copy(rec->prec->n - 1));
 		q = isl_qpolynomial_copy(r);
 
 		for (i = rec->n - 2; i >= 0; --i) {
 			r = isl_qpolynomial_mul(r, isl_qpolynomial_copy(min));
 			t = isl_qpolynomial_alloc(isl_space_copy(qp->dim), 0,
-						  isl_upoly_copy(rec->pi));
+						  isl_poly_copy(rec->pi));
 			r = isl_qpolynomial_add(r, t);
 			if (i == 0)
 				break;
@@ -393,92 +618,166 @@
 	return sgn;
 }
 
+/* Check that "fold1" and "fold2" have the same type.
+ */
+static isl_stat isl_qpolynomial_fold_check_equal_type(
+	__isl_keep isl_qpolynomial_fold *fold1,
+	__isl_keep isl_qpolynomial_fold *fold2)
+{
+	enum isl_fold type1, type2;
+
+	type1 = isl_qpolynomial_fold_get_type(fold1);
+	type2 = isl_qpolynomial_fold_get_type(fold2);
+	if (type1 < 0 || type2 < 0)
+		return isl_stat_error;
+	if (type1 != type2)
+		isl_die(isl_qpolynomial_fold_get_ctx(fold1), isl_error_invalid,
+			"fold types don't match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that "fold1" and "fold2" have the same (domain) space.
+ */
+static isl_stat isl_qpolynomial_fold_check_equal_space(
+	__isl_keep isl_qpolynomial_fold *fold1,
+	__isl_keep isl_qpolynomial_fold *fold2)
+{
+	isl_bool equal;
+	isl_space *space1, *space2;
+
+	space1 = isl_qpolynomial_fold_peek_domain_space(fold1);
+	space2 = isl_qpolynomial_fold_peek_domain_space(fold2);
+	equal = isl_space_is_equal(space1, space2);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_qpolynomial_fold_get_ctx(fold1), isl_error_invalid,
+			"spaces don't match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Combine "list1" and "list2" into a single list, eliminating
+ * those elements of one list that are already covered by the other
+ * list on "set".
+ *
+ * "better" is the sign that the difference qp1 - qp2 needs to have for qp1
+ * to be covered by qp2.
+ */
+static __isl_give isl_qpolynomial_list *merge_lists(__isl_keep isl_set *set,
+	__isl_take isl_qpolynomial_list *list1,
+	__isl_take isl_qpolynomial_list *list2, int better)
+{
+	int i, j;
+	isl_size n1, n2;
+
+	n1 = isl_qpolynomial_list_size(list1);
+	n2 = isl_qpolynomial_list_size(list2);
+	if (n1 < 0 || n2 < 0)
+		goto error;
+
+	for (i = n2 - 1; i >= 0; --i) {
+		for (j = n1 - 1; j >= 0; --j) {
+			isl_qpolynomial *qp1, *qp2, *d;
+			int sgn;
+			isl_bool equal;
+
+			qp1 = isl_qpolynomial_list_peek(list1, j);
+			qp2 = isl_qpolynomial_list_peek(list2, i);
+			equal = isl_qpolynomial_plain_is_equal(qp1, qp2);
+			if (equal < 0)
+				goto error;
+			if (equal)
+				break;
+			d = isl_qpolynomial_sub(
+				isl_qpolynomial_copy(qp1),
+				isl_qpolynomial_copy(qp2));
+			sgn = isl_qpolynomial_sign(set, d);
+			isl_qpolynomial_free(d);
+			if (sgn == 0)
+				continue;
+			if (sgn != better)
+				break;
+			list1 = isl_qpolynomial_list_drop(list1, j, 1);
+			n1--;
+		}
+		if (j < 0)
+			continue;
+		list2 = isl_qpolynomial_list_drop(list2, i, 1);
+		n2--;
+	}
+
+	return isl_qpolynomial_list_concat(list1, list2);
+error:
+	isl_qpolynomial_list_free(list1);
+	isl_qpolynomial_list_free(list2);
+	return NULL;
+}
+
+/* Combine "fold1" and "fold2" into a single reduction, eliminating
+ * those elements of one reduction that are already covered by the other
+ * reduction on "set".
+ *
+ * If "fold1" or "fold2" is an empty reduction, then return
+ * the other reduction.
+ * If "fold1" or "fold2" is a NaN, then return this NaN.
+ */
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_fold_on_domain(
 	__isl_keep isl_set *set,
 	__isl_take isl_qpolynomial_fold *fold1,
 	__isl_take isl_qpolynomial_fold *fold2)
 {
-	int i, j;
-	int n1;
-	struct isl_qpolynomial_fold *res = NULL;
+	isl_qpolynomial_list *list1;
+	isl_qpolynomial_list *list2;
 	int better;
 
-	if (!fold1 || !fold2)
+	if (isl_qpolynomial_fold_check_equal_type(fold1, fold2) < 0)
+		goto error;
+	if (isl_qpolynomial_fold_check_equal_space(fold1, fold2) < 0)
 		goto error;
-
-	isl_assert(fold1->dim->ctx, fold1->type == fold2->type, goto error);
-	isl_assert(fold1->dim->ctx, isl_space_is_equal(fold1->dim, fold2->dim),
-			goto error);
 
 	better = fold1->type == isl_fold_max ? -1 : 1;
 
-	if (isl_qpolynomial_fold_is_empty(fold1)) {
+	if (isl_qpolynomial_fold_is_empty(fold1) ||
+	    isl_qpolynomial_fold_is_nan(fold2)) {
 		isl_qpolynomial_fold_free(fold1);
 		return fold2;
 	}
 
-	if (isl_qpolynomial_fold_is_empty(fold2)) {
+	if (isl_qpolynomial_fold_is_empty(fold2) ||
+	    isl_qpolynomial_fold_is_nan(fold1)) {
 		isl_qpolynomial_fold_free(fold2);
 		return fold1;
 	}
 
-	res = qpolynomial_fold_alloc(fold1->type, isl_space_copy(fold1->dim),
-					fold1->n + fold2->n);
-	if (!res)
-		goto error;
+	list1 = isl_qpolynomial_fold_take_list(fold1);
+	list2 = isl_qpolynomial_fold_take_list(fold2);
 
-	for (i = 0; i < fold1->n; ++i) {
-		res->qpres->n = isl_qpolynomial_copy(fold1->qpi);
-		if (!res->qpres->n)
-			goto error;
-		res->n++;
-	}
-	n1 = res->n;
-
-	for (i = 0; i < fold2->n; ++i) {
-		for (j = n1 - 1; j >= 0; --j) {
-			isl_qpolynomial *d;
-			int sgn;
-			d = isl_qpolynomial_sub(
-				isl_qpolynomial_copy(res->qpj),
-				isl_qpolynomial_copy(fold2->qpi));
-			sgn = isl_qpolynomial_sign(set, d);
-			isl_qpolynomial_free(d);
-			if (sgn == 0)
-				continue;
-			if (sgn != better)
-				break;
-			isl_qpolynomial_free(res->qpj);
-			if (j != n1 - 1)
-				res->qpj = res->qpn1 - 1;
-			n1--;
-			if (n1 != res->n - 1)
-				res->qpn1 = res->qpres->n - 1;
-			res->n--;
-		}
-		if (j >= 0)
-			continue;
-		res->qpres->n = isl_qpolynomial_copy(fold2->qpi);
-		if (!res->qpres->n)
-			goto error;
-		res->n++;
-	}
+	list1 = merge_lists(set, list1, list2, better);
 
-	isl_qpolynomial_fold_free(fold1);
+	fold1 = isl_qpolynomial_fold_restore_list(fold1, list1);
 	isl_qpolynomial_fold_free(fold2);
 
-	return res;
+	return fold1;
 error:
-	isl_qpolynomial_fold_free(res);
 	isl_qpolynomial_fold_free(fold1);
 	isl_qpolynomial_fold_free(fold2);
 	return NULL;
 }
 
+/* isl_qpolynomial_list_map callback for adding "qp2" to "qp".
+ */
+static __isl_give isl_qpolynomial *add_qpolynomial(
+	__isl_take isl_qpolynomial *qp, void *user)
+{
+	isl_qpolynomial *qp2 = user;
+
+	return isl_qpolynomial_add(qp, isl_qpolynomial_copy(qp2));
+}
+
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_add_qpolynomial(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_qpolynomial *qp)
 {
-	int i;
+	isl_qpolynomial_list *list;
 
 	if (!fold || !qp)
 		goto error;
@@ -488,16 +787,9 @@
 		return fold;
 	}
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		goto error;
-
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_add(fold->qpi,
-						isl_qpolynomial_copy(qp));
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &add_qpolynomial, qp);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	isl_qpolynomial_free(qp);
 	return fold;
@@ -513,7 +805,10 @@
 	__isl_take isl_qpolynomial_fold *fold2)
 {
 	int i;
+	isl_size n1, n2;
 	isl_qpolynomial_fold *res = NULL;
+	isl_qpolynomial *qp;
+	isl_qpolynomial_list *list1, *list2;
 
 	if (!fold1 || !fold2)
 		goto error;
@@ -528,25 +823,32 @@
 		return fold1;
 	}
 
-	if (fold1->n == 1 && fold2->n != 1)
+	list1 = isl_qpolynomial_fold_peek_list(fold1);
+	list2 = isl_qpolynomial_fold_peek_list(fold2);
+	n1 = isl_qpolynomial_list_size(list1);
+	n2 = isl_qpolynomial_list_size(list2);
+	if (n1 < 0 || n2 < 0)
+		goto error;
+
+	if (n1 == 1 && n2 != 1)
 		return isl_qpolynomial_fold_add_on_domain(dom, fold2, fold1);
 
-	if (fold2->n == 1) {
-		res = isl_qpolynomial_fold_add_qpolynomial(fold1,
-					isl_qpolynomial_copy(fold2->qp0));
+	qp = isl_qpolynomial_list_get_at(list2, 0);
+	if (n2 == 1) {
+		res = isl_qpolynomial_fold_add_qpolynomial(fold1, qp);
 		isl_qpolynomial_fold_free(fold2);
 		return res;
 	}
 
 	res = isl_qpolynomial_fold_add_qpolynomial(
-				isl_qpolynomial_fold_copy(fold1),
-				isl_qpolynomial_copy(fold2->qp0));
+				isl_qpolynomial_fold_copy(fold1), qp);
 
-	for (i = 1; i < fold2->n; ++i) {
+	for (i = 1; i < n2; ++i) {
 		isl_qpolynomial_fold *res_i;
+
+		qp = isl_qpolynomial_list_get_at(list2, i);
 		res_i = isl_qpolynomial_fold_add_qpolynomial(
-					isl_qpolynomial_fold_copy(fold1),
-					isl_qpolynomial_copy(fold2->qpi));
+					isl_qpolynomial_fold_copy(fold1), qp);
 		res = isl_qpolynomial_fold_fold_on_domain(dom, res, res_i);
 	}
 
@@ -560,58 +862,53 @@
 	return NULL;
 }
 
-__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_substitute_equalities(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_basic_set *eq)
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_substitute_equalities on "qp" and "eq".
+ */
+static __isl_give isl_qpolynomial *substitute_equalities(
+	__isl_take isl_qpolynomial *qp, void *user)
 {
-	int i;
+	isl_basic_set *eq = user;
 
-	if (!fold || !eq)
-		goto error;
+	eq = isl_basic_set_copy(eq);
+	return isl_qpolynomial_substitute_equalities(qp, eq);
+}
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_substitute_equalities(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_basic_set *eq)
+{
+	isl_qpolynomial_list *list;
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_substitute_equalities(fold->qpi,
-							isl_basic_set_copy(eq));
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &substitute_equalities, eq);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	isl_basic_set_free(eq);
 	return fold;
-error:
-	isl_basic_set_free(eq);
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
 }
 
-__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context)
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_substitute_equalities on "qp" and "context".
+ */
+static __isl_give isl_qpolynomial *gist(__isl_take isl_qpolynomial *qp,
+	void *user)
 {
-	int i;
+	isl_set *context = user;
 
-	if (!fold || !context)
-		goto error;
+	return isl_qpolynomial_gist(qp, isl_set_copy(context));
+}
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *context)
+{
+	isl_qpolynomial_list *list;
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_gist(fold->qpi,
-							isl_set_copy(context));
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &gist, context);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	isl_set_free(context);
 	return fold;
-error:
-	isl_set_free(context);
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_gist_params(
@@ -623,12 +920,25 @@
 	return isl_qpolynomial_fold_gist(fold, dom_context);
 }
 
+/* Return a zero (i.e., empty) isl_qpolynomial_fold in the given space.
+ *
+ * This is a helper function for isl_pw_*_as_* that ensures a uniform
+ * interface over all piecewise types.
+ */
+static __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_zero_in_space(
+	__isl_take isl_space *space, enum isl_fold type)
+{
+	return isl_qpolynomial_fold_empty(type, isl_space_domain(space));
+}
+
+#define isl_qpolynomial_fold_involves_nan isl_qpolynomial_fold_is_nan
+
 #define HAS_TYPE
 
 #undef PW
 #define PW isl_pw_qpolynomial_fold
-#undef EL
-#define EL isl_qpolynomial_fold
+#undef BASE
+#define BASE qpolynomial_fold
 #undef EL_IS_ZERO
 #define EL_IS_ZERO is_empty
 #undef ZERO
@@ -640,49 +950,50 @@
 #undef DEFAULT_IS_ZERO
 #define DEFAULT_IS_ZERO 1
 
-#define NO_NEG
-#define NO_PULLBACK
-
 #include <isl_pw_templ.c>
+#include <isl_pw_eval.c>
+#include <isl_pw_insert_dims_templ.c>
+#include <isl_pw_lift_templ.c>
+#include <isl_pw_morph_templ.c>
+#include <isl_pw_move_dims_templ.c>
+#include <isl_pw_opt_templ.c>
 
-#undef UNION
-#define UNION isl_union_pw_qpolynomial_fold
-#undef PART
-#define PART isl_pw_qpolynomial_fold
-#undef PARTS
-#define PARTS pw_qpolynomial_fold
-#define ALIGN_DOMAIN
+#undef BASE
+#define BASE pw_qpolynomial_fold
 
 #define NO_SUB
 
-#include <isl_union_templ.c>
+#include <isl_union_single.c>
+#include <isl_union_eval.c>
 
+/* Construct a new reduction of the given type and space
+ * with an empty list of polynomials.
+ */
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_empty(enum isl_fold type,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
-	return qpolynomial_fold_alloc(type, dim, 0);
+	isl_ctx *ctx;
+	isl_qpolynomial_list *list;
+
+	if (!space)
+		return NULL;
+	ctx = isl_space_get_ctx(space);
+	list = isl_qpolynomial_list_alloc(ctx, 0);
+	return qpolynomial_fold_alloc(type, space, list);
 }
 
+/* Construct a new reduction of the given type and
+ * a single given polynomial.
+ */
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_alloc(
 	enum isl_fold type, __isl_take isl_qpolynomial *qp)
 {
-	isl_qpolynomial_fold *fold;
-
-	if (!qp)
-		return NULL;
-
-	fold = qpolynomial_fold_alloc(type, isl_space_copy(qp->dim), 1);
-	if (!fold)
-		goto error;
-
-	fold->qp0 = qp;
-	fold->n++;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
-	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	isl_qpolynomial_free(qp);
-	return NULL;
+	space = isl_qpolynomial_get_domain_space(qp);
+	list = isl_qpolynomial_list_from_qpolynomial(qp);
+	return qpolynomial_fold_alloc(type, space, list);
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_copy(
@@ -698,27 +1009,14 @@
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_dup(
 	__isl_keep isl_qpolynomial_fold *fold)
 {
-	int i;
-	isl_qpolynomial_fold *dup;
-
-	if (!fold)
-		return NULL;
-	dup = qpolynomial_fold_alloc(fold->type,
-					isl_space_copy(fold->dim), fold->n);
-	if (!dup)
-		return NULL;
-	
-	dup->n = fold->n;
-	for (i = 0; i < fold->n; ++i) {
-		dup->qpi = isl_qpolynomial_copy(fold->qpi);
-		if (!dup->qpi)
-			goto error;
-	}
+	enum isl_fold type;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
-	return dup;
-error:
-	isl_qpolynomial_fold_free(dup);
-	return NULL;
+	type = isl_qpolynomial_fold_get_type(fold);
+	space = isl_qpolynomial_fold_get_domain_space(fold);
+	list = isl_qpolynomial_fold_get_list(fold);
+	return qpolynomial_fold_alloc(type, space, list);
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_cow(
@@ -733,42 +1031,62 @@
 	return isl_qpolynomial_fold_dup(fold);
 }
 
-void isl_qpolynomial_fold_free(__isl_take isl_qpolynomial_fold *fold)
+__isl_null isl_qpolynomial_fold *isl_qpolynomial_fold_free(
+	__isl_take isl_qpolynomial_fold *fold)
 {
-	int i;
-
 	if (!fold)
-		return;
+		return NULL;
 	if (--fold->ref > 0)
-		return;
+		return NULL;
 
-	for (i = 0; i < fold->n; ++i)
-		isl_qpolynomial_free(fold->qpi);
+	isl_qpolynomial_list_free(fold->list);
 	isl_space_free(fold->dim);
 	free(fold);
+
+	return NULL;
 }
 
-int isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold)
+isl_bool isl_qpolynomial_fold_is_empty(__isl_keep isl_qpolynomial_fold *fold)
 {
-	if (!fold)
-		return -1;
+	isl_size n;
+	isl_qpolynomial_list *list;
+
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (n < 0)
+		return isl_bool_error;
 
-	return fold->n == 0;
+	return isl_bool_ok(n == 0);
+}
+
+/* Does "fold" represent max(NaN) or min(NaN)?
+ */
+isl_bool isl_qpolynomial_fold_is_nan(__isl_keep isl_qpolynomial_fold *fold)
+{
+	isl_size n;
+	isl_qpolynomial *qp;
+	isl_qpolynomial_list *list;
+
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (n < 0)
+		return isl_bool_error;
+	if (n != 1)
+		return isl_bool_false;
+	qp = isl_qpolynomial_list_peek(list, 0);
+	return isl_qpolynomial_is_nan(qp);
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_fold(
 	__isl_take isl_qpolynomial_fold *fold1,
 	__isl_take isl_qpolynomial_fold *fold2)
 {
-	int i;
-	struct isl_qpolynomial_fold *res = NULL;
+	isl_qpolynomial_list *list1, *list2;
 
-	if (!fold1 || !fold2)
+	if (isl_qpolynomial_fold_check_equal_type(fold1, fold2) < 0)
+		goto error;
+	if (isl_qpolynomial_fold_check_equal_space(fold1, fold2) < 0)
 		goto error;
-
-	isl_assert(fold1->dim->ctx, fold1->type == fold2->type, goto error);
-	isl_assert(fold1->dim->ctx, isl_space_is_equal(fold1->dim, fold2->dim),
-			goto error);
 
 	if (isl_qpolynomial_fold_is_empty(fold1)) {
 		isl_qpolynomial_fold_free(fold1);
@@ -780,31 +1098,14 @@
 		return fold1;
 	}
 
-	res = qpolynomial_fold_alloc(fold1->type, isl_space_copy(fold1->dim),
-					fold1->n + fold2->n);
-	if (!res)
-		goto error;
-
-	for (i = 0; i < fold1->n; ++i) {
-		res->qpres->n = isl_qpolynomial_copy(fold1->qpi);
-		if (!res->qpres->n)
-			goto error;
-		res->n++;
-	}
-
-	for (i = 0; i < fold2->n; ++i) {
-		res->qpres->n = isl_qpolynomial_copy(fold2->qpi);
-		if (!res->qpres->n)
-			goto error;
-		res->n++;
-	}
-
-	isl_qpolynomial_fold_free(fold1);
+	list1 = isl_qpolynomial_fold_take_list(fold1);
+	list2 = isl_qpolynomial_fold_take_list(fold2);
+	list1 = isl_qpolynomial_list_concat(list1, list2);
+	fold1 = isl_qpolynomial_fold_restore_list(fold1, list1);
 	isl_qpolynomial_fold_free(fold2);
 
-	return res;
+	return fold1;
 error:
-	isl_qpolynomial_fold_free(res);
 	isl_qpolynomial_fold_free(fold1);
 	isl_qpolynomial_fold_free(fold2);
 	return NULL;
@@ -887,20 +1188,16 @@
 	__isl_take isl_union_pw_qpolynomial_fold *u,
 	__isl_take isl_pw_qpolynomial_fold *part)
 {
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
 	u = isl_union_pw_qpolynomial_fold_cow(u);
 
 	if (!part || !u)
 		goto error;
+	if (isl_space_check_equal_params(part->dim, u->space) < 0)
+		goto error;
 
-	isl_assert(u->dim->ctx, isl_space_match(part->dim, isl_dim_param, u->dim,
-					      isl_dim_param), goto error);
-
-	hash = isl_space_get_hash(part->dim);
-	entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
-				    &has_dim, part->dim, 1);
+	entry = isl_union_pw_qpolynomial_fold_find_part_entry(u, part->dim, 1);
 	if (!entry)
 		goto error;
 
@@ -921,14 +1218,14 @@
 	return NULL;
 }
 
-static int fold_part(__isl_take isl_pw_qpolynomial_fold *part, void *user)
+static isl_stat fold_part(__isl_take isl_pw_qpolynomial_fold *part, void *user)
 {
 	isl_union_pw_qpolynomial_fold **u;
 	u = (isl_union_pw_qpolynomial_fold **)user;
 
 	*u = isl_union_pw_qpolynomial_fold_fold_pw_qpolynomial_fold(*u, part);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_fold(
@@ -983,32 +1280,113 @@
 	return isl_pw_qpolynomial_fold_union_add_(pwf1, pwf2);
 }
 
-int isl_qpolynomial_fold_plain_is_equal(__isl_keep isl_qpolynomial_fold *fold1,
+/* Compare two quasi-polynomial reductions.
+ *
+ * Return -1 if "fold1" is "smaller" than "fold2", 1 if "fold1" is "greater"
+ * than "fold2" and 0 if they are equal.
+ */
+int isl_qpolynomial_fold_plain_cmp(__isl_keep isl_qpolynomial_fold *fold1,
 	__isl_keep isl_qpolynomial_fold *fold2)
 {
 	int i;
+	isl_size n1, n2;
+	isl_qpolynomial_list *list1, *list2;
 
-	if (!fold1 || !fold2)
+	if (fold1 == fold2)
+		return 0;
+	list1 = isl_qpolynomial_fold_peek_list(fold1);
+	list2 = isl_qpolynomial_fold_peek_list(fold2);
+	n1 = isl_qpolynomial_list_size(list1);
+	n2 = isl_qpolynomial_list_size(list2);
+	if (n1 < 0)
 		return -1;
+	if (n2 < 0)
+		return 1;
 
-	if (fold1->n != fold2->n)
-		return 0;
+	if (n1 != n2)
+		return n1 - n2;
+
+	for (i = 0; i < n1; ++i) {
+		int cmp;
+		isl_qpolynomial *qp1, *qp2;
+
+		qp1 = isl_qpolynomial_list_peek(list1, i);
+		qp2 = isl_qpolynomial_list_peek(list2, i);
+		cmp = isl_qpolynomial_plain_cmp(qp1, qp2);
+		if (cmp != 0)
+			return cmp;
+	}
+
+	return 0;
+}
+
+/* Are the lists "list1" and "list2", both consisting of "n" elements
+ * obviously equal to each other?
+ */
+static isl_bool isl_qpolynomial_list_plain_is_equal(unsigned n,
+	isl_qpolynomial_list *list1, isl_qpolynomial_list *list2)
+{
+	int i;
+
+	for (i = 0; i < n; ++i) {
+		isl_bool eq;
+		isl_qpolynomial *qp1, *qp2;
 
-	/* We probably want to sort the qps first... */
-	for (i = 0; i < fold1->n; ++i) {
-		int eq = isl_qpolynomial_plain_is_equal(fold1->qpi, fold2->qpi);
+		qp1 = isl_qpolynomial_list_peek(list1, i);
+		qp2 = isl_qpolynomial_list_peek(list2, i);
+		eq = isl_qpolynomial_plain_is_equal(qp1, qp2);
 		if (eq < 0 || !eq)
 			return eq;
 	}
 
-	return 1;
+	return isl_bool_true;
+}
+
+/* Wrapper around isl_qpolynomial_plain_cmp for use
+ * as a isl_qpolynomial_list_sort callback.
+ */
+static int qpolynomial_cmp(__isl_keep isl_qpolynomial *a,
+	__isl_keep isl_qpolynomial *b, void *user)
+{
+	return isl_qpolynomial_plain_cmp(a, b);
+}
+
+isl_bool isl_qpolynomial_fold_plain_is_equal(
+	__isl_keep isl_qpolynomial_fold *fold1,
+	__isl_keep isl_qpolynomial_fold *fold2)
+{
+	isl_bool equal;
+	isl_size n1, n2;
+	isl_qpolynomial_list *list1, *list2;
+
+	list1 = isl_qpolynomial_fold_peek_list(fold1);
+	list2 = isl_qpolynomial_fold_peek_list(fold2);
+	n1 = isl_qpolynomial_list_size(list1);
+	n2 = isl_qpolynomial_list_size(list2);
+	if (n1 < 0 || n2 < 0)
+		return isl_bool_error;
+
+	if (n1 != n2)
+		return isl_bool_false;
+
+	list1 = isl_qpolynomial_list_copy(list1);
+	list1 = isl_qpolynomial_list_sort(list1, &qpolynomial_cmp, NULL);
+	list2 = isl_qpolynomial_list_copy(list2);
+	list2 = isl_qpolynomial_list_sort(list2, &qpolynomial_cmp, NULL);
+	equal = isl_qpolynomial_list_plain_is_equal(n1, list1, list2);
+	isl_qpolynomial_list_free(list1);
+	isl_qpolynomial_list_free(list2);
+	return equal;
 }
 
 __isl_give isl_val *isl_qpolynomial_fold_eval(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_point *pnt)
 {
+	isl_size n;
 	isl_ctx *ctx;
 	isl_val *v;
+	isl_qpolynomial *qp;
+	isl_qpolynomial_list *list;
 
 	if (!fold || !pnt)
 		goto error;
@@ -1018,17 +1396,23 @@
 		fold->type == isl_fold_max || fold->type == isl_fold_min,
 		goto error);
 
-	if (fold->n == 0)
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (n < 0)
+		goto error;
+
+	if (n == 0)
 		v = isl_val_zero(ctx);
 	else {
 		int i;
-		v = isl_qpolynomial_eval(isl_qpolynomial_copy(fold->qp0),
-						isl_point_copy(pnt));
-		for (i = 1; i < fold->n; ++i) {
+
+		qp = isl_qpolynomial_list_get_at(list, 0);
+		v = isl_qpolynomial_eval(qp, isl_point_copy(pnt));
+		for (i = 1; i < n; ++i) {
 			isl_val *v_i;
-			v_i = isl_qpolynomial_eval(
-					    isl_qpolynomial_copy(fold->qpi),
-					    isl_point_copy(pnt));
+
+			qp = isl_qpolynomial_list_get_at(list, i);
+			v_i = isl_qpolynomial_eval(qp, isl_point_copy(pnt));
 			if (fold->type == isl_fold_max)
 				v = isl_val_max(v, v_i);
 			else
@@ -1050,8 +1434,17 @@
 	int i;
 	size_t n = 0;
 
-	for (i = 0; i < pwf->n; ++i)
-		n += pwf->pi.fold->n;
+	for (i = 0; i < pwf->n; ++i) {
+		isl_size n_i;
+		isl_qpolynomial_list *list;
+
+		list = isl_qpolynomial_fold_peek_list(pwf->pi.fold);
+		n_i = isl_qpolynomial_list_size(list);
+		if (n_i < 0)
+			return isl_size_error;
+
+		n += n_i;
+	}
 
 	return n;
 }
@@ -1060,24 +1453,30 @@
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *set, int max)
 {
 	int i;
+	isl_size n;
 	isl_val *opt;
+	isl_qpolynomial *qp;
+	isl_qpolynomial_list *list;
 
-	if (!set || !fold)
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (!set || n < 0)
 		goto error;
 
-	if (fold->n == 0) {
+	if (n == 0) {
 		opt = isl_val_zero(isl_set_get_ctx(set));
 		isl_set_free(set);
 		isl_qpolynomial_fold_free(fold);
 		return opt;
 	}
 
-	opt = isl_qpolynomial_opt_on_domain(isl_qpolynomial_copy(fold->qp0),
-						isl_set_copy(set), max);
-	for (i = 1; i < fold->n; ++i) {
+	qp = isl_qpolynomial_list_get_at(list, 0);
+	opt = isl_qpolynomial_opt_on_domain(qp, isl_set_copy(set), max);
+	for (i = 1; i < n; ++i) {
 		isl_val *opt_i;
-		opt_i = isl_qpolynomial_opt_on_domain(
-				isl_qpolynomial_copy(fold->qpi),
+
+		qp = isl_qpolynomial_list_get_at(list, i);
+		opt_i = isl_qpolynomial_opt_on_domain(qp,
 				isl_set_copy(set), max);
 		if (max)
 			opt = isl_val_max(opt, opt_i);
@@ -1098,56 +1497,63 @@
 /* Check whether for each quasi-polynomial in "fold2" there is
  * a quasi-polynomial in "fold1" that dominates it on "set".
  */
-static int qpolynomial_fold_covers_on_domain(__isl_keep isl_set *set,
+static isl_bool qpolynomial_fold_covers_on_domain(__isl_keep isl_set *set,
 	__isl_keep isl_qpolynomial_fold *fold1,
 	__isl_keep isl_qpolynomial_fold *fold2)
 {
 	int i, j;
 	int covers;
+	isl_size n1, n2;
+	isl_qpolynomial_list *list1, *list2;
 
-	if (!set || !fold1 || !fold2)
-		return -1;
+	list1 = isl_qpolynomial_fold_peek_list(fold1);
+	list2 = isl_qpolynomial_fold_peek_list(fold2);
+	n1 = isl_qpolynomial_list_size(list1);
+	n2 = isl_qpolynomial_list_size(list2);
+	if (!set || n1 < 0 || n2 < 0)
+		return isl_bool_error;
 
 	covers = fold1->type == isl_fold_max ? 1 : -1;
 
-	for (i = 0; i < fold2->n; ++i) {
-		for (j = 0; j < fold1->n; ++j) {
-			isl_qpolynomial *d;
+	for (i = 0; i < n2; ++i) {
+		for (j = 0; j < n1; ++j) {
+			isl_qpolynomial *qp1, *qp2, *d;
 			int sgn;
 
-			d = isl_qpolynomial_sub(
-				isl_qpolynomial_copy(fold1->qpj),
-				isl_qpolynomial_copy(fold2->qpi));
+			qp1 = isl_qpolynomial_list_get_at(list1, j);
+			qp2 = isl_qpolynomial_list_get_at(list2, i);
+			d = isl_qpolynomial_sub(qp1, qp2);
 			sgn = isl_qpolynomial_sign(set, d);
 			isl_qpolynomial_free(d);
 			if (sgn == covers)
 				break;
 		}
-		if (j >= fold1->n)
-			return 0;
+		if (j >= n1)
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Check whether "pwf1" dominated "pwf2", i.e., the domain of "pwf1" contains
  * that of "pwf2" and on each cell, the corresponding fold from pwf1 dominates
  * that of pwf2.
  */
-int isl_pw_qpolynomial_fold_covers(__isl_keep isl_pw_qpolynomial_fold *pwf1,
+isl_bool isl_pw_qpolynomial_fold_covers(
+	__isl_keep isl_pw_qpolynomial_fold *pwf1,
 	__isl_keep isl_pw_qpolynomial_fold *pwf2)
 {
 	int i, j;
 	isl_set *dom1, *dom2;
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!pwf1 || !pwf2)
-		return -1;
+		return isl_bool_error;
 
 	if (pwf2->n == 0)
-		return 1;
+		return isl_bool_true;
 	if (pwf1->n == 0)
-		return 0;
+		return isl_bool_false;
 
 	dom1 = isl_pw_qpolynomial_fold_domain(isl_pw_qpolynomial_fold_copy(pwf1));
 	dom2 = isl_pw_qpolynomial_fold_domain(isl_pw_qpolynomial_fold_copy(pwf2));
@@ -1160,9 +1566,9 @@
 
 	for (i = 0; i < pwf2->n; ++i) {
 		for (j = 0; j < pwf1->n; ++j) {
-			int is_empty;
+			isl_bool is_empty;
 			isl_set *common;
-			int covers;
+			isl_bool covers;
 
 			common = isl_set_intersect(isl_set_copy(pwf1->pj.set),
 						   isl_set_copy(pwf2->pi.set));
@@ -1170,7 +1576,7 @@
 			if (is_empty < 0 || is_empty) {
 				isl_set_free(common);
 				if (is_empty < 0)
-					return -1;
+					return isl_bool_error;
 				continue;
 			}
 			covers = qpolynomial_fold_covers_on_domain(common,
@@ -1181,36 +1587,37 @@
 		}
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph_domain(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_morph *morph)
+/* isl_qpolynomial_list_map callback that calls
+ * isl_qpolynomial_morph_domain on "qp".
+ */
+static __isl_give isl_qpolynomial *morph_domain(
+	__isl_take isl_qpolynomial *qp, void *user)
 {
-	int i;
-	isl_ctx *ctx;
+	isl_morph *morph = user;
 
-	if (!fold || !morph)
-		goto error;
+	return isl_qpolynomial_morph_domain(qp, isl_morph_copy(morph));
+}
 
-	ctx = fold->dim->ctx;
-	isl_assert(ctx, isl_space_is_equal(fold->dim, morph->dom->dim), goto error);
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_morph_domain(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_morph *morph)
+{
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
+	space = isl_qpolynomial_fold_peek_domain_space(fold);
+	if (isl_morph_check_applies(morph, space) < 0)
 		goto error;
 
-	isl_space_free(fold->dim);
-	fold->dim = isl_space_copy(morph->ran->dim);
-	if (!fold->dim)
-		goto error;
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &morph_domain, morph);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_morph_domain(fold->qpi,
-						isl_morph_copy(morph));
-		if (!fold->qpi)
-			goto error;
-	}
+	space = isl_morph_get_ran_space(morph);
+	isl_space_free(isl_qpolynomial_fold_take_domain_space(fold));
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	isl_morph_free(morph);
 
@@ -1224,70 +1631,98 @@
 enum isl_fold isl_qpolynomial_fold_get_type(__isl_keep isl_qpolynomial_fold *fold)
 {
 	if (!fold)
-		return isl_fold_list;
+		return isl_fold_error;
 	return fold->type;
 }
 
+/* Return the type of this piecewise quasipolynomial reduction.
+ */
+enum isl_fold isl_pw_qpolynomial_fold_get_type(
+	__isl_keep isl_pw_qpolynomial_fold *pwf)
+{
+	if (!pwf)
+		return isl_fold_error;
+	return pwf->type;
+}
+
 enum isl_fold isl_union_pw_qpolynomial_fold_get_type(
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf)
 {
 	if (!upwf)
-		return isl_fold_list;
+		return isl_fold_error;
 	return upwf->type;
 }
 
+/* isl_qpolynomial_list_map callback that calls
+ * isl_qpolynomial_lift on "qp".
+ */
+static __isl_give isl_qpolynomial *lift(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	isl_space *space = user;
+
+	return isl_qpolynomial_lift(qp, isl_space_copy(space));
+}
+
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_lift(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim)
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space)
 {
-	int i;
+	isl_qpolynomial_list *list;
 
-	if (!fold || !dim)
+	if (!fold || !space)
 		goto error;
 
-	if (isl_space_is_equal(fold->dim, dim)) {
-		isl_space_free(dim);
+	if (isl_space_is_equal(fold->dim, space)) {
+		isl_space_free(space);
 		return fold;
 	}
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		goto error;
-
-	isl_space_free(fold->dim);
-	fold->dim = isl_space_copy(dim);
-	if (!fold->dim)
-		goto error;
-
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_lift(fold->qpi,
-						isl_space_copy(dim));
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &lift, space);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	isl_space_free(dim);
+	isl_space_free(isl_qpolynomial_fold_take_domain_space(fold));
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	return fold;
 error:
 	isl_qpolynomial_fold_free(fold);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-int isl_qpolynomial_fold_foreach_qpolynomial(
+isl_stat isl_qpolynomial_fold_foreach_qpolynomial(
 	__isl_keep isl_qpolynomial_fold *fold,
-	int (*fn)(__isl_take isl_qpolynomial *qp, void *user), void *user)
+	isl_stat (*fn)(__isl_take isl_qpolynomial *qp, void *user), void *user)
 {
-	int i;
+	isl_qpolynomial_list *list;
 
-	if (!fold)
-		return -1;
+	list = isl_qpolynomial_fold_peek_list(fold);
+	return isl_qpolynomial_list_foreach(list, fn, user);
+}
 
-	for (i = 0; i < fold->n; ++i)
-		if (fn(isl_qpolynomial_copy(fold->qpi), user) < 0)
-			return -1;
+/* Internal data structure for isl_qpolynomial_fold_move_dims
+ * representing its arguments.
+ */
+struct isl_fold_move_dims_data {
+	enum isl_dim_type dst_type;
+	unsigned dst_pos;
+	enum isl_dim_type src_type;
+	unsigned src_pos;
+	unsigned n;
+};
 
-	return 0;
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_move_dims on "qp".
+ */
+static __isl_give isl_qpolynomial *move_dims(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	struct isl_fold_move_dims_data *data = user;
+
+	qp = isl_qpolynomial_move_dims(qp, data->dst_type, data->dst_pos,
+					data->src_type, data->src_pos, data->n);
+	return qp;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_move_dims(
@@ -1295,7 +1730,11 @@
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 {
-	int i;
+	struct isl_fold_move_dims_data data =
+		{ dst_type, dst_pos, src_type, src_pos, n };
+	enum isl_dim_type set_src_type, set_dst_type;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
 	if (n == 0)
 		return fold;
@@ -1304,22 +1743,42 @@
 	if (!fold)
 		return NULL;
 
-	fold->dim = isl_space_move_dims(fold->dim, dst_type, dst_pos,
-						src_type, src_pos, n);
-	if (!fold->dim)
-		goto error;
+	set_src_type = domain_type(src_type);
+	set_dst_type = domain_type(dst_type);
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_move_dims(fold->qpi,
-				dst_type, dst_pos, src_type, src_pos, n);
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &move_dims, &data);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
+
+	space = isl_qpolynomial_fold_take_domain_space(fold);
+	space = isl_space_move_dims(space, set_dst_type, dst_pos,
+						set_src_type, src_pos, n);
+	fold = isl_qpolynomial_fold_restore_domain_space(fold, space);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
+}
+
+/* Internal data structure for isl_qpolynomial_fold_substitute
+ * representing its arguments.
+ */
+struct isl_fold_substitute {
+	enum isl_dim_type type;
+	unsigned first;
+	unsigned n;
+	isl_qpolynomial **subs;
+};
+
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_substitute on "qp".
+ */
+static __isl_give isl_qpolynomial *substitute(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	struct isl_fold_substitute *data = user;
+
+	qp = isl_qpolynomial_substitute(qp,
+				data->type, data->first, data->n, data->subs);
+	return qp;
 }
 
 /* For each 0 <= i < "n", replace variable "first" + i of type "type"
@@ -1330,42 +1789,29 @@
 	enum isl_dim_type type, unsigned first, unsigned n,
 	__isl_keep isl_qpolynomial **subs)
 {
-	int i;
+	struct isl_fold_substitute data = { type, first, n, subs };
+	isl_qpolynomial_list *list;
 
 	if (n == 0)
 		return fold;
 
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold)
-		return NULL;
-
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_substitute(fold->qpi,
-				type, first, n, subs);
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &substitute, &data);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
 }
 
-static int add_pwqp(__isl_take isl_pw_qpolynomial *pwqp, void *user)
+static isl_stat add_pwqp(__isl_take isl_pw_qpolynomial *pwqp, void *user)
 {
-	isl_ctx *ctx;
 	isl_pw_qpolynomial_fold *pwf;
 	isl_union_pw_qpolynomial_fold **upwf;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
 	upwf = (isl_union_pw_qpolynomial_fold **)user;
 
-	ctx = pwqp->dim->ctx;
-	hash = isl_space_get_hash(pwqp->dim);
-	entry = isl_hash_table_find(ctx, &(*upwf)->table,
-				     hash, &has_dim, pwqp->dim, 1);
+	entry = isl_union_pw_qpolynomial_fold_find_part_entry(*upwf,
+			 pwqp->dim, 1);
 	if (!entry)
 		goto error;
 
@@ -1375,17 +1821,16 @@
 	else {
 		entry->data = isl_pw_qpolynomial_fold_add(entry->data, pwf);
 		if (!entry->data)
-			return -1;
-		if (isl_pw_qpolynomial_fold_is_zero(entry->data)) {
-			isl_pw_qpolynomial_fold_free(entry->data);
-			isl_hash_table_remove(ctx, &(*upwf)->table, entry);
-		}
+			return isl_stat_error;
+		if (isl_pw_qpolynomial_fold_is_zero(entry->data))
+			*upwf = isl_union_pw_qpolynomial_fold_remove_part_entry(
+								*upwf, entry);
 	}
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_pw_qpolynomial_free(pwqp);
-	return -1;
+	return isl_stat_error;
 }
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_pw_qpolynomial_fold_add_union_pw_qpolynomial(
@@ -1414,13 +1859,15 @@
 	return NULL;
 }
 
-static int join_compatible(__isl_keep isl_space *dim1, __isl_keep isl_space *dim2)
+static isl_bool join_compatible(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
 {
-	int m;
-	m = isl_space_match(dim1, isl_dim_param, dim2, isl_dim_param);
+	isl_bool m;
+	m = isl_space_has_equal_params(space1, space2);
 	if (m < 0 || !m)
 		return m;
-	return isl_space_tuple_is_equal(dim1, isl_dim_out, dim2, isl_dim_in);
+	return isl_space_tuple_is_equal(space1, isl_dim_out,
+					space2, isl_dim_in);
 }
 
 /* Compute the intersection of the range of the map and the domain
@@ -1434,29 +1881,33 @@
  */
 __isl_give isl_pw_qpolynomial_fold *isl_map_apply_pw_qpolynomial_fold(
 	__isl_take isl_map *map, __isl_take isl_pw_qpolynomial_fold *pwf,
-	int *tight)
+	isl_bool *tight)
 {
 	isl_ctx *ctx;
 	isl_set *dom;
-	isl_space *map_dim;
-	isl_space *pwf_dim;
-	unsigned n_in;
-	int ok;
+	isl_space *map_space;
+	isl_space *pwf_space;
+	isl_size n_in;
+	isl_bool ok;
 
 	ctx = isl_map_get_ctx(map);
 	if (!ctx)
 		goto error;
 
-	map_dim = isl_map_get_space(map);
-	pwf_dim = isl_pw_qpolynomial_fold_get_space(pwf);
-	ok = join_compatible(map_dim, pwf_dim);
-	isl_space_free(map_dim);
-	isl_space_free(pwf_dim);
+	map_space = isl_map_get_space(map);
+	pwf_space = isl_pw_qpolynomial_fold_get_space(pwf);
+	ok = join_compatible(map_space, pwf_space);
+	isl_space_free(map_space);
+	isl_space_free(pwf_space);
+	if (ok < 0)
+		goto error;
 	if (!ok)
 		isl_die(ctx, isl_error_invalid, "incompatible dimensions",
 			goto error);
 
 	n_in = isl_map_dim(map, isl_dim_in);
+	if (n_in < 0)
+		goto error;
 	pwf = isl_pw_qpolynomial_fold_insert_dims(pwf, isl_dim_in, 0, n_in);
 
 	dom = isl_map_wrap(map);
@@ -1475,7 +1926,7 @@
 
 __isl_give isl_pw_qpolynomial_fold *isl_set_apply_pw_qpolynomial_fold(
 	__isl_take isl_set *set, __isl_take isl_pw_qpolynomial_fold *pwf,
-	int *tight)
+	isl_bool *tight)
 {
 	return isl_map_apply_pw_qpolynomial_fold(set, pwf, tight);
 }
@@ -1484,16 +1935,16 @@
 	isl_union_pw_qpolynomial_fold *upwf;
 	isl_union_pw_qpolynomial_fold *res;
 	isl_map *map;
-	int tight;
+	isl_bool tight;
 };
 
-static int pw_qpolynomial_fold_apply(__isl_take isl_pw_qpolynomial_fold *pwf,
-	void *user)
+static isl_stat pw_qpolynomial_fold_apply(
+	__isl_take isl_pw_qpolynomial_fold *pwf, void *user)
 {
 	isl_space *map_dim;
 	isl_space *pwf_dim;
 	struct isl_apply_fold_data *data = user;
-	int ok;
+	isl_bool ok;
 
 	map_dim = isl_map_get_space(data->map);
 	pwf_dim = isl_pw_qpolynomial_fold_get_space(pwf);
@@ -1501,6 +1952,8 @@
 	isl_space_free(map_dim);
 	isl_space_free(pwf_dim);
 
+	if (ok < 0)
+		return isl_stat_error;
 	if (ok) {
 		pwf = isl_map_apply_pw_qpolynomial_fold(isl_map_copy(data->map),
 				    pwf, data->tight ? &data->tight : NULL);
@@ -1509,13 +1962,13 @@
 	} else
 		isl_pw_qpolynomial_fold_free(pwf);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int map_apply(__isl_take isl_map *map, void *user)
+static isl_stat map_apply(__isl_take isl_map *map, void *user)
 {
 	struct isl_apply_fold_data *data = user;
-	int r;
+	isl_stat r;
 
 	data->map = map;
 	r = isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(
@@ -1527,9 +1980,9 @@
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_map_apply_union_pw_qpolynomial_fold(
 	__isl_take isl_union_map *umap,
-	__isl_take isl_union_pw_qpolynomial_fold *upwf, int *tight)
+	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight)
 {
-	isl_space *dim;
+	isl_space *space;
 	enum isl_fold type;
 	struct isl_apply_fold_data data;
 
@@ -1539,10 +1992,10 @@
 				isl_union_pw_qpolynomial_fold_get_space(upwf));
 
 	data.upwf = upwf;
-	data.tight = tight ? 1 : 0;
-	dim = isl_union_pw_qpolynomial_fold_get_space(upwf);
+	data.tight = tight ? isl_bool_true : isl_bool_false;
+	space = isl_union_pw_qpolynomial_fold_get_space(upwf);
 	type = isl_union_pw_qpolynomial_fold_get_type(upwf);
-	data.res = isl_union_pw_qpolynomial_fold_zero(dim, type);
+	data.res = isl_union_pw_qpolynomial_fold_zero(space, type);
 	if (isl_union_map_foreach_map(umap, &map_apply, &data) < 0)
 		goto error;
 
@@ -1562,52 +2015,66 @@
 
 __isl_give isl_union_pw_qpolynomial_fold *isl_union_set_apply_union_pw_qpolynomial_fold(
 	__isl_take isl_union_set *uset,
-	__isl_take isl_union_pw_qpolynomial_fold *upwf, int *tight)
+	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_bool *tight)
 {
 	return isl_union_map_apply_union_pw_qpolynomial_fold(uset, upwf, tight);
 }
 
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_realign_domain on "qp".
+ */
+static __isl_give isl_qpolynomial *realign_domain(
+	__isl_take isl_qpolynomial *qp, void *user)
+{
+	isl_reordering *r = user;
+
+	qp = isl_qpolynomial_realign_domain(qp, isl_reordering_copy(r));
+	return qp;
+}
+
 /* Reorder the dimension of "fold" according to the given reordering.
  */
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_realign_domain(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_reordering *r)
 {
-	int i;
-
-	fold = isl_qpolynomial_fold_cow(fold);
-	if (!fold || !r)
-		goto error;
+	isl_space *space;
+	isl_qpolynomial_list *list;
 
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_realign_domain(fold->qpi,
-						    isl_reordering_copy(r));
-		if (!fold->qpi)
-			goto error;
-	}
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &realign_domain, r);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
-	fold = isl_qpolynomial_fold_reset_domain_space(fold,
-						    isl_space_copy(r->dim));
+	space = isl_reordering_get_space(r);
+	fold = isl_qpolynomial_fold_reset_domain_space(fold, space);
 
 	isl_reordering_free(r);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	isl_reordering_free(r);
-	return NULL;
+}
+
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_mul_isl_int on "qp".
+ */
+static __isl_give isl_qpolynomial *mul_int(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	isl_int *v = user;
+
+	qp = isl_qpolynomial_mul_isl_int(qp, *v);
+	return qp;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_mul_isl_int(
 	__isl_take isl_qpolynomial_fold *fold, isl_int v)
 {
-	int i;
+	isl_qpolynomial_list *list;
 
 	if (isl_int_is_one(v))
 		return fold;
 	if (fold && isl_int_is_zero(v)) {
 		isl_qpolynomial_fold *zero;
-		isl_space *dim = isl_space_copy(fold->dim);
-		zero = isl_qpolynomial_fold_empty(fold->type, dim);
+		isl_space *space = isl_space_copy(fold->dim);
+		zero = isl_qpolynomial_fold_empty(fold->type, space);
 		isl_qpolynomial_fold_free(fold);
 		return zero;
 	}
@@ -1618,16 +2085,12 @@
 
 	if (isl_int_is_neg(v))
 		fold->type = isl_fold_type_negate(fold->type);
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_mul_isl_int(fold->qpi, v);
-		if (!fold->qpi)
-			goto error;
-	}
+
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &mul_int, &v);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	return fold;
-error:
-	isl_qpolynomial_fold_free(fold);
-	return NULL;
 }
 
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
@@ -1636,12 +2099,24 @@
 	return isl_qpolynomial_fold_mul_isl_int(fold, v);
 }
 
+/* isl_qpolynomial_list_map callback for calling
+ * isl_qpolynomial_scale_val on "qp".
+ */
+static __isl_give isl_qpolynomial *scale_val(__isl_take isl_qpolynomial *qp,
+	void *user)
+{
+	isl_val *v = user;
+
+	qp = isl_qpolynomial_scale_val(qp, isl_val_copy(v));
+	return qp;
+}
+
 /* Multiply "fold" by "v".
  */
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_val(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v)
 {
-	int i;
+	isl_qpolynomial_list *list;
 
 	if (!fold || !v)
 		goto error;
@@ -1668,12 +2143,10 @@
 
 	if (isl_val_is_neg(v))
 		fold->type = isl_fold_type_negate(fold->type);
-	for (i = 0; i < fold->n; ++i) {
-		fold->qpi = isl_qpolynomial_scale_val(fold->qpi,
-							isl_val_copy(v));
-		if (!fold->qpi)
-			goto error;
-	}
+
+	list = isl_qpolynomial_fold_take_list(fold);
+	list = isl_qpolynomial_list_map(list, &scale_val, v);
+	fold = isl_qpolynomial_fold_restore_list(fold, list);
 
 	isl_val_free(v);
 	return fold;
@@ -1682,3 +2155,29 @@
 	isl_qpolynomial_fold_free(fold);
 	return NULL;
 }
+
+/* Divide "fold" by "v".
+ */
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale_down_val(
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_val *v)
+{
+	if (!fold || !v)
+		goto error;
+
+	if (isl_val_is_one(v)) {
+		isl_val_free(v);
+		return fold;
+	}
+	if (!isl_val_is_rat(v))
+		isl_die(isl_qpolynomial_fold_get_ctx(fold), isl_error_invalid,
+			"expecting rational factor", goto error);
+	if (isl_val_is_zero(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"cannot scale down by zero", goto error);
+
+	return isl_qpolynomial_fold_scale_val(fold, isl_val_inv(v));
+error:
+	isl_val_free(v);
+	isl_qpolynomial_fold_free(fold);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_hash.c -> _service:tar_scm:isl-0.24.tar.gz/isl_hash.c Changed

@@ -8,7 +8,6 @@
  */
 
 #include <stdlib.h>
-#include <strings.h>
 #include <isl/hash.h>
 #include <isl/ctx.h>
 #include "isl_config.h"
@@ -64,9 +63,9 @@
 
 /* Dummy comparison function that always returns false.
  */
-static int no(const void *entry, const void *val)
+static isl_bool no(const void *entry, const void *val)
 {
-	return 0;
+	return isl_bool_false;
 }
 
 /* Extend "table" to twice its size.
@@ -149,24 +148,37 @@
 	free(table);
 }
 
+/* A dummy entry that is used by isl_hash_table_find
+ * to make a distinction between a missing entry and an error condition.
+ */
+static struct isl_hash_table_entry none = { 0, NULL };
+struct isl_hash_table_entry *isl_hash_table_entry_none = &none;
+
 struct isl_hash_table_entry *isl_hash_table_find(struct isl_ctx *ctx,
-				struct isl_hash_table *table,
-				uint32_t key_hash,
-				int (*eq)(const void *entry, const void *val),
-				const void *val, int reserve)
+			    struct isl_hash_table *table,
+			    uint32_t key_hash,
+			    isl_bool (*eq)(const void *entry, const void *val),
+			    const void *val, int reserve)
 {
 	size_t size;
 	uint32_t h, key_bits;
 
 	key_bits = isl_hash_bits(key_hash, table->bits);
 	size = 1 << table->bits;
-	for (h = key_bits; table->entriesh.data; h = (h+1) % size)
-		if (table->entriesh.hash == key_hash &&
-		    eq(table->entriesh.data, val))
+	for (h = key_bits; table->entriesh.data; h = (h+1) % size) {
+		isl_bool equal;
+
+		if (table->entriesh.hash != key_hash)
+			continue;
+		equal = eq(table->entriesh.data, val);
+		if (equal < 0)
+			return NULL;
+		if (equal)
 			return &table->entriesh;
+	}
 
 	if (!reserve)
-		return NULL;
+		return isl_hash_table_entry_none;
 
 	if (4 * table->n >= 3 * size) {
 		if (grow_table(ctx, table) < 0)
@@ -180,23 +192,22 @@
 	return &table->entriesh;
 }
 
-int isl_hash_table_foreach(struct isl_ctx *ctx,
-				struct isl_hash_table *table,
-				int (*fn)(void **entry, void *user), void *user)
+isl_stat isl_hash_table_foreach(isl_ctx *ctx, struct isl_hash_table *table,
+	isl_stat (*fn)(void **entry, void *user), void *user)
 {
 	size_t size;
 	uint32_t h;
 
 	if (!table->entries)
-		return -1;
+		return isl_stat_error;
 
 	size = 1 << table->bits;
 	for (h = 0; h < size; ++ h)
 		if (table->entriesh.data &&
 		    fn(&table->entriesh.data, user) < 0)
-			return -1;
+			return isl_stat_error;
 	
-	return 0;
+	return isl_stat_ok;
 }
 
 void isl_hash_table_remove(struct isl_ctx *ctx,

_service:tar_scm:isl-0.14.tar.xz/isl_id.c -> _service:tar_scm:isl-0.24.tar.gz/isl_id.c Changed

@@ -11,8 +11,8 @@
 #include <isl_ctx_private.h>
 #include <isl_id_private.h>
 
-#undef BASE
-#define BASE id
+#undef EL_BASE
+#define EL_BASE id
 
 #include <isl_list_templ.c>
 
@@ -81,17 +81,19 @@
 	void *user;
 };
 
-static int isl_id_has_name_and_user(const void *entry, const void *val)
+static isl_bool isl_id_has_name_and_user(const void *entry, const void *val)
 {
 	isl_id *id = (isl_id *)entry;
 	struct isl_name_and_user *nu = (struct isl_name_and_user *) val;
 
 	if (id->user != nu->user)
-		return 0;
-	if (!id->name && !nu->name)
-		return 1;
+		return isl_bool_false;
+	if (id->name == nu->name)
+		return isl_bool_true;
+	if (!id->name || !nu->name)
+		return isl_bool_false;
 
-	return !strcmp(id->name, nu->name);
+	return isl_bool_ok(!strcmp(id->name, nu->name));
 }
 
 __isl_give isl_id *isl_id_alloc(isl_ctx *ctx, const char *name, void *user)
@@ -162,9 +164,9 @@
 		return 1;
 }
 
-static int isl_id_eq(const void *entry, const void *name)
+static isl_bool isl_id_eq(const void *entry, const void *name)
 {
-	return entry == name;
+	return isl_bool_ok(entry == name);
 }
 
 uint32_t isl_hash_id(uint32_t hash, __isl_keep isl_id *id)
@@ -178,7 +180,7 @@
 /* Replace the free_user callback by "free_user".
  */
 __isl_give isl_id *isl_id_set_free_user(__isl_take isl_id *id,
-	__isl_give void (*free_user)(void *user))
+	void (*free_user)(void *user))
 {
 	if (!id)
 		return NULL;
@@ -207,6 +209,8 @@
 	entry = isl_hash_table_find(id->ctx, &id->ctx->id_table, id->hash,
 					isl_id_eq, id, 0);
 	if (!entry)
+		return NULL;
+	if (entry == isl_hash_table_entry_none)
 		isl_die(id->ctx, isl_error_unknown,
 			"unable to find id", (void)0);
 	else
@@ -240,3 +244,63 @@
 	isl_printer_free(p);
 	return NULL;
 }
+
+/* Read an isl_id from "s" based on its name.
+ */
+__isl_give isl_id *isl_stream_read_id(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	char *str;
+	isl_ctx *ctx;
+	isl_id *id;
+
+	if (!s)
+		return NULL;
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	ctx = isl_stream_get_ctx(s);
+	str = isl_token_get_str(ctx, tok);
+	isl_token_free(tok);
+	if (!str)
+		return NULL;
+	id = isl_id_alloc(ctx, str, NULL);
+	free(str);
+
+	return id;
+}
+
+/* Read an isl_id object from the string "str".
+ */
+__isl_give isl_id *isl_id_read_from_str(isl_ctx *ctx, const char *str)
+{
+	isl_id *id;
+	isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	id = isl_stream_read_id(s);
+	isl_stream_free(s);
+	return id;
+}
+
+/* Is "id1" (obviously) equal to "id2"?
+ *
+ * isl_id objects can be compared by pointer value, but
+ * isl_multi_*_plain_is_equal needs an isl_*_plain_is_equal.
+ */
+static isl_bool isl_id_plain_is_equal(__isl_keep isl_id *id1,
+	__isl_keep isl_id *id2)
+{
+	if (!id1 || !id2)
+		return isl_bool_error;
+	return id1 == id2;
+}
+
+#undef BASE
+#define BASE id
+
+#include <isl_multi_no_domain_templ.c>
+#include <isl_multi_no_explicit_domain.c>
+#include <isl_multi_templ.c>

_service:tar_scm:isl-0.14.tar.xz/isl_id_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_id_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_id_to_ast_expr.c -> _service:tar_scm:isl-0.24.tar.gz/isl_id_to_ast_expr.c Changed

_service:tar_scm:isl-0.24.tar.gz/isl_id_to_id.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_id_to_pw_aff.c -> _service:tar_scm:isl-0.24.tar.gz/isl_id_to_pw_aff.c Changed

_service:tar_scm:isl-0.14.tar.xz/isl_ilp.c -> _service:tar_scm:isl-0.24.tar.gz/isl_ilp.c Changed

@@ -10,6 +10,7 @@
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
 #include <isl/ilp.h>
+#include <isl/union_set.h>
 #include "isl_sample.h"
 #include <isl_seq.h>
 #include "isl_equalities.h"
@@ -20,7 +21,6 @@
 #include <isl_vec_private.h>
 #include <isl_lp_private.h>
 #include <isl_ilp_private.h>
-#include <isl/deprecated/ilp_int.h>
 
 /* Given a basic set "bset", construct a basic set U such that for
  * each element x in U, the whole unit box positioned at x is inside
@@ -31,22 +31,25 @@
  * term.  This ensures that if x satisfies the resulting constraints,
  * then x plus any sum of unit vectors satisfies the original constraints.
  */
-static struct isl_basic_set *unit_box_base_points(struct isl_basic_set *bset)
+static __isl_give isl_basic_set *unit_box_base_points(
+	__isl_take isl_basic_set *bset)
 {
 	int i, j, k;
 	struct isl_basic_set *unit_box = NULL;
-	unsigned total;
+	isl_size total;
 
 	if (!bset)
 		goto error;
 
 	if (bset->n_eq != 0) {
-		unit_box = isl_basic_set_empty_like(bset);
+		isl_space *space = isl_basic_set_get_space(bset);
 		isl_basic_set_free(bset);
-		return unit_box;
+		return isl_basic_set_empty(space);
 	}
 
-	total = isl_basic_set_total_dim(bset);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		goto error;
 	unit_box = isl_basic_set_alloc_space(isl_basic_set_get_space(bset),
 					0, 0, bset->n_ineq);
 
@@ -79,7 +82,8 @@
  * and round it up to the nearest integer.
  * If not, we simply pick any integer point in "bset".
  */
-static struct isl_vec *initial_solution(struct isl_basic_set *bset, isl_int *f)
+static __isl_give isl_vec *initial_solution(__isl_keep isl_basic_set *bset,
+	isl_int *f)
 {
 	enum isl_lp_result res;
 	struct isl_basic_set *unit_box;
@@ -101,13 +105,15 @@
 
 /* Restrict "bset" to those points with values for f in the interval l, u.
  */
-static struct isl_basic_set *add_bounds(struct isl_basic_set *bset,
+static __isl_give isl_basic_set *add_bounds(__isl_take isl_basic_set *bset,
 	isl_int *f, isl_int l, isl_int u)
 {
 	int k;
-	unsigned total;
+	isl_size total;
 
-	total = isl_basic_set_total_dim(bset);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return isl_basic_set_free(bset);
 	bset = isl_basic_set_extend_constraints(bset, 0, 2);
 
 	k = isl_basic_set_alloc_inequality(bset);
@@ -144,8 +150,8 @@
  * If no point can be found, we update l to the upper bound of the interval
  * we checked (u or l+floor(u-l-1/2)) plus 1.
  */
-static struct isl_vec *solve_ilp_search(struct isl_basic_set *bset,
-	isl_int *f, isl_int *opt, struct isl_vec *sol, isl_int l, isl_int u)
+static __isl_give isl_vec *solve_ilp_search(__isl_keep isl_basic_set *bset,
+	isl_int *f, isl_int *opt, __isl_take isl_vec *sol, isl_int l, isl_int u)
 {
 	isl_int tmp;
 	int divide = 1;
@@ -203,9 +209,8 @@
  *
  * We then call solve_ilp_search to perform a binary search on the interval.
  */
-static enum isl_lp_result solve_ilp(struct isl_basic_set *bset,
-				      isl_int *f, isl_int *opt,
-				      struct isl_vec **sol_p)
+static enum isl_lp_result solve_ilp(__isl_keep isl_basic_set *bset,
+	isl_int *f, isl_int *opt, __isl_give isl_vec **sol_p)
 {
 	enum isl_lp_result res;
 	isl_int l, u;
@@ -259,17 +264,18 @@
 	return res;
 }
 
-static enum isl_lp_result solve_ilp_with_eq(struct isl_basic_set *bset, int max,
-				      isl_int *f, isl_int *opt,
-				      struct isl_vec **sol_p)
+static enum isl_lp_result solve_ilp_with_eq(__isl_keep isl_basic_set *bset,
+	int max, isl_int *f, isl_int *opt, __isl_give isl_vec **sol_p)
 {
-	unsigned dim;
+	isl_size dim;
 	enum isl_lp_result res;
 	struct isl_mat *T = NULL;
 	struct isl_vec *v;
 
 	bset = isl_basic_set_copy(bset);
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		goto error;
 	v = isl_vec_alloc(bset->ctx, 1 + dim);
 	if (!v)
 		goto error;
@@ -302,19 +308,17 @@
  * If there is any equality among the points in "bset", then we first
  * project it out.  Otherwise, we continue with solve_ilp above.
  */
-enum isl_lp_result isl_basic_set_solve_ilp(struct isl_basic_set *bset, int max,
-				      isl_int *f, isl_int *opt,
-				      struct isl_vec **sol_p)
+enum isl_lp_result isl_basic_set_solve_ilp(__isl_keep isl_basic_set *bset,
+	int max, isl_int *f, isl_int *opt, __isl_give isl_vec **sol_p)
 {
-	unsigned dim;
+	isl_size dim;
 	enum isl_lp_result res;
 
-	if (!bset)
-		return isl_lp_error;
 	if (sol_p)
 		*sol_p = NULL;
 
-	isl_assert(bset->ctx, isl_basic_set_n_param(bset) == 0, goto error);
+	if (isl_basic_set_check_no_params(bset) < 0)
+		return isl_lp_error;
 
 	if (isl_basic_set_plain_is_empty(bset))
 		return isl_lp_empty;
@@ -322,7 +326,9 @@
 	if (bset->n_eq)
 		return solve_ilp_with_eq(bset, max, f, opt, sol_p);
 
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		return isl_lp_error;
 
 	if (max)
 		isl_seq_neg(f, f, 1 + dim);
@@ -335,9 +341,6 @@
 	}
 
 	return res;
-error:
-	isl_basic_set_free(bset);
-	return isl_lp_error;
 }
 
 static enum isl_lp_result basic_set_opt(__isl_keep isl_basic_set *bset, int max,
@@ -354,23 +357,6 @@
 	return res;
 }
 
-static __isl_give isl_mat *extract_divs(__isl_keep isl_basic_set *bset)
-{
-	int i;
-	isl_ctx *ctx = isl_basic_set_get_ctx(bset);
-	isl_mat *div;
-
-	div = isl_mat_alloc(ctx, bset->n_div,
-			    1 + 1 + isl_basic_set_total_dim(bset));
-	if (!div)
-		return NULL;
-
-	for (i = 0; i < bset->n_div; ++i)
-		isl_seq_cpy(div->rowi, bset->divi, div->n_col);
-
-	return div;
-}
-
 enum isl_lp_result isl_basic_set_opt(__isl_keep isl_basic_set *bset, int max,
 	__isl_keep isl_aff *obj, isl_int *opt)
 {
@@ -380,7 +366,7 @@
 	isl_mat *bset_div = NULL;
 	isl_mat *div = NULL;
 	enum isl_lp_result res;
-	int bset_n_div, obj_n_div;
+	isl_size bset_n_div, obj_n_div;
 
 	if (!bset || !obj)
 		return isl_lp_error;
@@ -396,13 +382,15 @@
 
 	bset_n_div = isl_basic_set_dim(bset, isl_dim_div);
 	obj_n_div = isl_aff_dim(obj, isl_dim_div);
+	if (bset_n_div < 0 || obj_n_div < 0)
+		return isl_lp_error;
 	if (bset_n_div == 0 && obj_n_div == 0)
 		return basic_set_opt(bset, max, obj, opt);
 
 	bset = isl_basic_set_copy(bset);
 	obj = isl_aff_copy(obj);
 
-	bset_div = extract_divs(bset);
+	bset_div = isl_basic_set_get_divs(bset);
 	exp1 = isl_alloc_array(ctx, int, bset_n_div);
 	exp2 = isl_alloc_array(ctx, int, obj_n_div);
 	if (!bset_div || (bset_n_div && !exp1) || (obj_n_div && !exp2))
@@ -466,8 +454,9 @@
 			isl_int_clear(opt_i);
 			return res;
 		}
-		if (res == isl_lp_ok)
-			empty = 0;
+		if (res == isl_lp_empty)
+			continue;
+		empty = 0;
 		if (max ? isl_int_gt(opt_i, *opt) : isl_int_lt(opt_i, *opt))
 			isl_int_set(*opt, opt_i);
 	}
@@ -483,12 +472,15 @@
 	__isl_keep isl_aff *obj, isl_int *opt)
 {
 	enum isl_lp_result res;
+	isl_bool aligned;
 
 	if (!set || !obj)
 		return isl_lp_error;
 
-	if (isl_space_match(set->dim, isl_dim_param,
-			    obj->ls->dim, isl_dim_param))
+	aligned = isl_set_space_has_equal_params(set, obj->ls->dim);
+	if (aligned < 0)
+		return isl_lp_error;
+	if (aligned)
 		return isl_set_opt_aligned(set, max, obj, opt);
 
 	set = isl_set_copy(set);
@@ -504,24 +496,6 @@
 	return res;
 }
 
-enum isl_lp_result isl_basic_set_max(__isl_keep isl_basic_set *bset,
-	__isl_keep isl_aff *obj, isl_int *opt)
-{
-	return isl_basic_set_opt(bset, 1, obj, opt);
-}
-
-enum isl_lp_result isl_set_max(__isl_keep isl_set *set,
-	__isl_keep isl_aff *obj, isl_int *opt)
-{
-	return isl_set_opt(set, 1, obj, opt);
-}
-
-enum isl_lp_result isl_set_min(__isl_keep isl_set *set,
-	__isl_keep isl_aff *obj, isl_int *opt)
-{
-	return isl_set_opt(set, 0, obj, opt);
-}
-
 /* Convert the result of a function that returns an isl_lp_result
  * to an isl_val.  The numerator of "v" is set to the optimal value
  * if lp_res is isl_lp_ok.  "max" is set if a maximum was computed.
@@ -595,7 +569,7 @@
  * expression "obj" over the points in "set".
  *
  * Return infinity or negative infinity if the optimal value is unbounded and
- * NaN if "bset" is empty.
+ * NaN if "set" is empty.
  *
  * Call isl_set_opt and translate the results.
  */
@@ -621,7 +595,7 @@
  * expression "obj" over the points in "set".
  *
  * Return infinity or negative infinity if the optimal value is unbounded and
- * NaN if "bset" is empty.
+ * NaN if "set" is empty.
  */
 __isl_give isl_val *isl_set_min_val(__isl_keep isl_set *set,
 	__isl_keep isl_aff *obj)
@@ -633,10 +607,306 @@
  * expression "obj" over the points in "set".
  *
  * Return infinity or negative infinity if the optimal value is unbounded and
- * NaN if "bset" is empty.
+ * NaN if "set" is empty.
  */
 __isl_give isl_val *isl_set_max_val(__isl_keep isl_set *set,
 	__isl_keep isl_aff *obj)
 {
 	return isl_set_opt_val(set, 1, obj);
 }
+
+/* Return the optimum (min or max depending on "max") of "v1" and "v2",
+ * where either may be NaN, signifying an uninitialized value.
+ * That is, if either is NaN, then return the other one.
+ */
+static __isl_give isl_val *val_opt(__isl_take isl_val *v1,
+	__isl_take isl_val *v2, int max)
+{
+	if (!v1 || !v2)
+		goto error;
+	if (isl_val_is_nan(v1)) {
+		isl_val_free(v1);
+		return v2;
+	}
+	if (isl_val_is_nan(v2)) {
+		isl_val_free(v2);
+		return v1;
+	}
+	if (max)
+		return isl_val_max(v1, v2);
+	else
+		return isl_val_min(v1, v2);
+error:
+	isl_val_free(v1);
+	isl_val_free(v2);
+	return NULL;
+}
+
+/* Internal data structure for isl_pw_aff_opt_val.
+ *
+ * "max" is set if the maximum should be computed.
+ * "res" contains the current optimum and is initialized to NaN.
+ */
+struct isl_pw_aff_opt_data {
+	int max;
+
+	isl_val *res;
+};
+
+/* Update the optimum in data->res with respect to the affine function
+ * "aff" defined over "set".
+ */
+static isl_stat piece_opt(__isl_take isl_set *set, __isl_take isl_aff *aff,
+	void *user)
+{
+	struct isl_pw_aff_opt_data *data = user;
+	isl_val *opt;
+
+	opt = isl_set_opt_val(set, data->max, aff);
+	isl_set_free(set);
+	isl_aff_free(aff);
+
+	data->res = val_opt(data->res, opt, data->max);
+	if (!data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Return the minimum (maximum if "max" is set) of the integer piecewise affine
+ * expression "pa" over its definition domain.
+ *
+ * Return infinity or negative infinity if the optimal value is unbounded and
+ * NaN if the domain of "pa" is empty.
+ *
+ * Initialize the result to NaN and then update it for each of the pieces
+ * in "pa".
+ */
+static __isl_give isl_val *isl_pw_aff_opt_val(__isl_take isl_pw_aff *pa,
+	int max)
+{
+	struct isl_pw_aff_opt_data data = { max };
+
+	data.res = isl_val_nan(isl_pw_aff_get_ctx(pa));
+	if (isl_pw_aff_foreach_piece(pa, &piece_opt, &data) < 0)
+		data.res = isl_val_free(data.res);
+
+	isl_pw_aff_free(pa);
+	return data.res;
+}
+
+#undef TYPE
+#define TYPE isl_pw_multi_aff
+#include "isl_ilp_opt_multi_val_templ.c"
+
+#undef TYPE
+#define TYPE isl_multi_pw_aff
+#include "isl_ilp_opt_multi_val_templ.c"
+
+/* Internal data structure for isl_union_pw_aff_opt_val.
+ *
+ * "max" is set if the maximum should be computed.
+ * "res" contains the current optimum and is initialized to NaN.
+ */
+struct isl_union_pw_aff_opt_data {
+	int max;
+
+	isl_val *res;
+};
+
+/* Update the optimum in data->res with the optimum of "pa".
+ */
+static isl_stat pw_aff_opt(__isl_take isl_pw_aff *pa, void *user)
+{
+	struct isl_union_pw_aff_opt_data *data = user;
+	isl_val *opt;
+
+	opt = isl_pw_aff_opt_val(pa, data->max);
+
+	data->res = val_opt(data->res, opt, data->max);
+	if (!data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Return the minimum (maximum if "max" is set) of the integer piecewise affine
+ * expression "upa" over its definition domain.
+ *
+ * Return infinity or negative infinity if the optimal value is unbounded and
+ * NaN if the domain of the expression is empty.
+ *
+ * Initialize the result to NaN and then update it
+ * for each of the piecewise affine expressions in "upa".
+ */
+static __isl_give isl_val *isl_union_pw_aff_opt_val(
+	__isl_take isl_union_pw_aff *upa, int max)
+{
+	struct isl_union_pw_aff_opt_data data = { max };
+
+	data.res = isl_val_nan(isl_union_pw_aff_get_ctx(upa));
+	if (isl_union_pw_aff_foreach_pw_aff(upa, &pw_aff_opt, &data) < 0)
+		data.res = isl_val_free(data.res);
+	isl_union_pw_aff_free(upa);
+
+	return data.res;
+}
+
+/* Return the minimum of the integer piecewise affine
+ * expression "upa" over its definition domain.
+ *
+ * Return negative infinity if the optimal value is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_val *isl_union_pw_aff_min_val(__isl_take isl_union_pw_aff *upa)
+{
+	return isl_union_pw_aff_opt_val(upa, 0);
+}
+
+/* Return the maximum of the integer piecewise affine
+ * expression "upa" over its definition domain.
+ *
+ * Return infinity if the optimal value is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_val *isl_union_pw_aff_max_val(__isl_take isl_union_pw_aff *upa)
+{
+	return isl_union_pw_aff_opt_val(upa, 1);
+}
+
+/* Return a list of minima (maxima if "max" is set)
+ * for each of the expressions in "mupa" over their domains.
+ *
+ * An element in the list is infinity or negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ *
+ * Iterate over all the expressions in "mupa" and collect the results.
+ */
+static __isl_give isl_multi_val *isl_multi_union_pw_aff_opt_multi_val(
+	__isl_take isl_multi_union_pw_aff *mupa, int max)
+{
+	int i;
+	isl_size n;
+	isl_multi_val *mv;
+
+	n = isl_multi_union_pw_aff_size(mupa);
+	if (n < 0)
+		mupa = isl_multi_union_pw_aff_free(mupa);
+	if (!mupa)
+		return NULL;
+
+	mv = isl_multi_val_zero(isl_multi_union_pw_aff_get_space(mupa));
+
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
+		isl_union_pw_aff *upa;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, i);
+		v = isl_union_pw_aff_opt_val(upa, max);
+		mv = isl_multi_val_set_val(mv, i, v);
+	}
+
+	isl_multi_union_pw_aff_free(mupa);
+	return mv;
+}
+
+/* Return a list of minima (maxima if "max" is set) over the points in "uset"
+ * for each of the expressions in "obj".
+ *
+ * An element in the list is infinity or negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the intersection of "uset" with the domain of the expression
+ * is empty.
+ */
+static __isl_give isl_multi_val *isl_union_set_opt_multi_union_pw_aff(
+	__isl_keep isl_union_set *uset, int max,
+	__isl_keep isl_multi_union_pw_aff *obj)
+{
+	uset = isl_union_set_copy(uset);
+	obj = isl_multi_union_pw_aff_copy(obj);
+	obj = isl_multi_union_pw_aff_intersect_domain(obj, uset);
+	return isl_multi_union_pw_aff_opt_multi_val(obj, max);
+}
+
+/* Return a list of minima over the points in "uset"
+ * for each of the expressions in "obj".
+ *
+ * An element in the list is infinity or negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the intersection of "uset" with the domain of the expression
+ * is empty.
+ */
+__isl_give isl_multi_val *isl_union_set_min_multi_union_pw_aff(
+	__isl_keep isl_union_set *uset, __isl_keep isl_multi_union_pw_aff *obj)
+{
+	return isl_union_set_opt_multi_union_pw_aff(uset, 0, obj);
+}
+
+/* Return a list of minima
+ * for each of the expressions in "mupa" over their domains.
+ *
+ * An element in the list is negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_multi_val *isl_multi_union_pw_aff_min_multi_val(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	return isl_multi_union_pw_aff_opt_multi_val(mupa, 0);
+}
+
+/* Return a list of maxima
+ * for each of the expressions in "mupa" over their domains.
+ *
+ * An element in the list is infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_multi_val *isl_multi_union_pw_aff_max_multi_val(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	return isl_multi_union_pw_aff_opt_multi_val(mupa, 1);
+}
+
+#undef BASE
+#define BASE	basic_set
+#include "isl_ilp_opt_val_templ.c"
+
+/* Return the maximal value attained by the given set dimension,
+ * independently of the parameter values and of any other dimensions.
+ *
+ * Return infinity if the optimal value is unbounded and
+ * NaN if "bset" is empty.
+ */
+__isl_give isl_val *isl_basic_set_dim_max_val(__isl_take isl_basic_set *bset,
+	int pos)
+{
+	return isl_basic_set_dim_opt_val(bset, 1, pos);
+}
+
+#undef BASE
+#define BASE	set
+#include "isl_ilp_opt_val_templ.c"
+
+/* Return the minimal value attained by the given set dimension,
+ * independently of the parameter values and of any other dimensions.
+ *
+ * Return negative infinity if the optimal value is unbounded and
+ * NaN if "set" is empty.
+ */
+__isl_give isl_val *isl_set_dim_min_val(__isl_take isl_set *set, int pos)
+{
+	return isl_set_dim_opt_val(set, 0, pos);
+}
+
+/* Return the maximal value attained by the given set dimension,
+ * independently of the parameter values and of any other dimensions.
+ *
+ * Return infinity if the optimal value is unbounded and
+ * NaN if "set" is empty.
+ */
+__isl_give isl_val *isl_set_dim_max_val(__isl_take isl_set *set, int pos)
+{
+	return isl_set_dim_opt_val(set, 1, pos);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_ilp_opt_multi_val_templ.c Added

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2019      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Return a list of minima (maxima if "max" is set)
+ * for each of the expressions in "f" over their (shared) domain.
+ *
+ * An element in the list is infinity or negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ *
+ * Iterate over all the expressions in "f" and collect the results.
+ */
+static __isl_give isl_multi_val *FN(TYPE,opt_multi_val)(__isl_take TYPE *f,
+	int max)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_val *mv;
+
+	n = FN(TYPE,dim)(f, isl_dim_out);
+	if (n < 0)
+		f = FN(TYPE,free)(f);
+	if (!f)
+		return NULL;
+
+	space = isl_space_range(FN(TYPE,get_space)(f));
+	space = isl_space_drop_all_params(space);
+	mv = isl_multi_val_zero(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
+		isl_pw_aff *pa;
+
+		pa = FN(TYPE,get_pw_aff)(f, i);
+		v = isl_pw_aff_opt_val(pa, max);
+		mv = isl_multi_val_set_val(mv, i, v);
+	}
+
+	FN(TYPE,free)(f);
+	return mv;
+}
+
+/* Return a list of minima
+ * for each of the expressions in "f" over their (shared) domain.
+ *
+ * An element in the list is negative infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_multi_val *FN(TYPE,min_multi_val)(__isl_take TYPE *f)
+{
+	return FN(TYPE,opt_multi_val)(f, 0);
+}
+
+/* Return a list of maxima
+ * for each of the expressions in "f" over their (shared) domain.
+ *
+ * An element in the list is infinity if the optimal
+ * value of the corresponding expression is unbounded and
+ * NaN if the domain of the expression is empty.
+ */
+__isl_give isl_multi_val *FN(TYPE,max_multi_val)(__isl_take TYPE *f)
+{
+	return FN(TYPE,opt_multi_val)(f, 1);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_ilp_opt_val_templ.c Added

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege
+ */
+
+#define xCAT(A,B) A ## B
+#define CAT(A,B) xCAT(A,B)
+#undef TYPE
+#define TYPE CAT(isl_,BASE)
+#define xBFN(BASE,NAME) isl_ ## BASE ## _ ## NAME
+#define BFN(BASE,NAME) xBFN(BASE,NAME)
+
+/* Return the minimal (maximal if "max" is set) value attained
+ * by the given set dimension,
+ * independently of the parameter values and of any other dimensions.
+ *
+ * Return infinity or negative infinity if the optimal value is unbounded and
+ * NaN if "set" is empty.
+ */
+static __isl_give isl_val *BFN(BASE,dim_opt_val)(__isl_take TYPE *set, int max,
+	int pos)
+{
+	isl_local_space *ls;
+	isl_aff *obj;
+	isl_val *v;
+
+	if (BFN(BASE,check_range)(set, isl_dim_set, pos, 1) < 0)
+		goto error;
+	ls = isl_local_space_from_space(BFN(BASE,get_space)(set));
+	obj = isl_aff_var_on_domain(ls, isl_dim_set, pos);
+	v = BFN(BASE,opt_val)(set, max, obj);
+	isl_aff_free(obj);
+	BFN(BASE,free)(set);
+
+	return v;
+error:
+	BFN(BASE,free)(set);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_imath.c -> _service:tar_scm:isl-0.24.tar.gz/isl_imath.c Changed

@@ -16,7 +16,7 @@
  */
 int isl_imath_fits_slong_p(mp_int op)
 {
-	unsigned long out;
+	long out;
 	mp_result res = mp_int_to_int(op, &out);
 	return res == MP_OK;
 }
@@ -32,22 +32,52 @@
 
 void isl_imath_addmul_ui(mp_int rop, mp_int op1, unsigned long op2)
 {
-	isl_int temp;
-	isl_int_init(temp);
+	mpz_t temp;
+	mp_int_init(&temp);
 
-	isl_int_set_ui(temp, op2);
-	isl_int_addmul(rop, op1, temp);
+	mp_int_set_uvalue(&temp, op2);
+	mp_int_mul(op1, &temp, &temp);
+	mp_int_add(rop, &temp, rop);
 
-	isl_int_clear(temp);
+	mp_int_clear(&temp);
 }
 
 void isl_imath_submul_ui(mp_int rop, mp_int op1, unsigned long op2)
 {
-	isl_int temp;
-	isl_int_init(temp);
+	mpz_t temp;
+	mp_int_init(&temp);
+
+	mp_int_set_uvalue(&temp, op2);
+	mp_int_mul(op1, &temp, &temp);
+	mp_int_sub(rop, &temp, rop);
+
+	mp_int_clear(&temp);
+}
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * positive infinity (Ceil).
+ */
+void isl_imath_cdiv_q_ui(mp_int rop, mp_int lhs, unsigned long rhs)
+{
+	mpz_t temp;
+	mp_int_init(&temp);
+
+	mp_int_set_uvalue(&temp, rhs);
+	impz_cdiv_q(rop, lhs, &temp);
+
+	mp_int_clear(&temp);
+}
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * negative infinity (Floor).
+ */
+void isl_imath_fdiv_q_ui(mp_int rop, mp_int lhs, unsigned long rhs)
+{
+	mpz_t temp;
+	mp_int_init(&temp);
 
-	isl_int_set_ui(temp, op2);
-	isl_int_submul(rop, op1, temp);
+	mp_int_set_uvalue(&temp, rhs);
+	impz_fdiv_q(rop, lhs, &temp);
 
-	isl_int_clear(temp);
+	mp_int_clear(&temp);
 }

_service:tar_scm:isl-0.14.tar.xz/isl_imath.h -> _service:tar_scm:isl-0.24.tar.gz/isl_imath.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_input.c -> _service:tar_scm:isl-0.24.tar.gz/isl_input.c Changed

@@ -2,6 +2,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2019      Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -10,6 +11,7 @@
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
 #include <ctype.h>
@@ -17,11 +19,13 @@
 #include <string.h>
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
+#include <isl_id_private.h>
 #include <isl/set.h>
 #include <isl_seq.h>
 #include <isl_stream_private.h>
 #include <isl/obj.h>
 #include "isl_polynomial_private.h"
+#include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl_mat_private.h>
 #include <isl_aff_private.h>
@@ -145,7 +149,7 @@
  * In particular, evaluate expressions of the form x^y,
  * with x and y values.
  */
-static struct isl_token *next_token(struct isl_stream *s)
+static struct isl_token *next_token(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok, *tok2;
 
@@ -182,7 +186,7 @@
  *
  * where n, d and v are integer constants.
  */
-__isl_give isl_val *isl_stream_read_val(struct isl_stream *s)
+__isl_give isl_val *isl_stream_read_val(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok = NULL;
 	struct isl_token *tok2 = NULL;
@@ -238,11 +242,10 @@
 
 /* Read an isl_val from "str".
  */
-struct isl_val *isl_val_read_from_str(struct isl_ctx *ctx,
-	const char *str)
+__isl_give isl_val *isl_val_read_from_str(isl_ctx *ctx, const char *str)
 {
 	isl_val *val;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	val = isl_stream_read_val(s);
@@ -250,7 +253,30 @@
 	return val;
 }
 
-static int accept_cst_factor(struct isl_stream *s, isl_int *f)
+/* Perform an integer division on *f and
+ * an integer value read from the stream.
+ */
+static isl_stat int_div_by_cst(__isl_keep isl_stream *s, isl_int *f)
+{
+	struct isl_token *tok;
+
+	tok = next_token(s);
+	if (!tok || tok->type != ISL_TOKEN_VALUE) {
+		isl_stream_error(s, tok, "expecting constant value");
+		goto error;
+	}
+
+	isl_int_fdiv_q(*f, *f, tok->u.v);
+
+	isl_token_free(tok);
+
+	return isl_stat_ok;
+error:
+	isl_token_free(tok);
+	return isl_stat_error;
+}
+
+static isl_stat accept_cst_factor(__isl_keep isl_stream *s, isl_int *f)
 {
 	struct isl_token *tok;
 
@@ -267,10 +293,10 @@
 	if (isl_stream_eat_if_available(s, '*'))
 		return accept_cst_factor(s, f);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_token_free(tok);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Given an affine expression aff, return an affine expression
@@ -280,7 +306,7 @@
  * We introduce an integer division q = aff/d and the result
  * is set to aff - d q.
  */
-static __isl_give isl_pw_aff *affine_mod(struct isl_stream *s,
+static __isl_give isl_pw_aff *affine_mod(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_pw_aff *aff)
 {
 	struct isl_token *tok;
@@ -307,13 +333,13 @@
 	return NULL;
 }
 
-static __isl_give isl_pw_aff *accept_affine(struct isl_stream *s,
+static __isl_give isl_pw_aff *accept_affine(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v);
+static __isl_give isl_pw_aff_list *accept_affine_list(__isl_keep isl_stream *s,
 	__isl_take isl_space *space, struct vars *v);
-static __isl_give isl_pw_aff_list *accept_affine_list(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v);
 
-static __isl_give isl_pw_aff *accept_minmax(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v)
+static __isl_give isl_pw_aff *accept_minmax(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v)
 {
 	struct isl_token *tok;
 	isl_pw_aff_list *list = NULL;
@@ -328,17 +354,17 @@
 	if (isl_stream_eat(s, '('))
 		goto error;
 
-	list = accept_affine_list(s, isl_space_copy(dim), v);
+	list = accept_affine_list(s, isl_space_copy(space), v);
 	if (!list)
 		goto error;
 
 	if (isl_stream_eat(s, ')'))
 		goto error;
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	return min ? isl_pw_aff_list_min(list) : isl_pw_aff_list_max(list);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_pw_aff_list_free(list);
 	return NULL;
 }
@@ -372,8 +398,8 @@
  *	floord(<affine expression>,<denominator>)
  *	ceild(<affine expression>,<denominator>)
  */
-static __isl_give isl_pw_aff *accept_div(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v)
+static __isl_give isl_pw_aff *accept_div(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v)
 {
 	struct isl_token *tok;
 	int f = 0;
@@ -397,7 +423,7 @@
 			goto error;
 	}
 
-	pwaff = accept_affine(s, isl_space_copy(dim), v);
+	pwaff = accept_affine(s, isl_space_copy(space), v);
 
 	if (extra) {
 		if (isl_stream_eat(s, ','))
@@ -411,7 +437,7 @@
 			isl_stream_push_token(s, tok);
 			goto error;
 		}
-		isl_pw_aff_scale_down(pwaff,  tok->u.v);
+		pwaff = isl_pw_aff_scale_down(pwaff,  tok->u.v);
 		isl_token_free(tok);
 	}
 
@@ -428,16 +454,32 @@
 			goto error;
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	return pwaff;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_pw_aff_free(pwaff);
 	return NULL;
 }
 
-static __isl_give isl_pw_aff *accept_affine_factor(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v)
+/* Divide "pa" by an integer constant read from the stream.
+ */
+static __isl_give isl_pw_aff *pw_aff_div_by_cst(__isl_keep isl_stream *s,
+	__isl_take isl_pw_aff *pa)
+{
+	isl_int f;
+	isl_int_init(f);
+	isl_int_set_si(f, 1);
+	if (accept_cst_factor(s, &f) < 0)
+		pa = isl_pw_aff_free(pa);
+	pa = isl_pw_aff_scale_down(pa, f);
+	isl_int_clear(f);
+
+	return pa;
+}
+
+static __isl_give isl_pw_aff *accept_affine_factor(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v)
 {
 	struct isl_token *tok = NULL;
 	isl_pw_aff *res = NULL;
@@ -464,7 +506,7 @@
 			goto error;
 		}
 
-		aff = isl_aff_zero_on_domain(isl_local_space_from_space(isl_space_copy(dim)));
+		aff = isl_aff_zero_on_domain(isl_local_space_from_space(isl_space_copy(space)));
 		if (!aff)
 			goto error;
 		isl_int_set_si(aff->v->el2 + pos, 1);
@@ -472,12 +514,12 @@
 		isl_token_free(tok);
 	} else if (tok->type == ISL_TOKEN_VALUE) {
 		if (isl_stream_eat_if_available(s, '*')) {
-			res = accept_affine_factor(s, isl_space_copy(dim), v);
+			res = accept_affine_factor(s, isl_space_copy(space), v);
 			res = isl_pw_aff_scale(res, tok->u.v);
 		} else {
 			isl_local_space *ls;
 			isl_aff *aff;
-			ls = isl_local_space_from_space(isl_space_copy(dim));
+			ls = isl_local_space_from_space(isl_space_copy(space));
 			aff = isl_aff_zero_on_domain(ls);
 			aff = isl_aff_add_constant(aff, tok->u.v);
 			res = isl_pw_aff_from_aff(aff);
@@ -486,7 +528,7 @@
 	} else if (tok->type == '(') {
 		isl_token_free(tok);
 		tok = NULL;
-		res = accept_affine(s, isl_space_copy(dim), v);
+		res = accept_affine(s, isl_space_copy(space), v);
 		if (!res)
 			goto error;
 		if (isl_stream_eat(s, ')'))
@@ -494,18 +536,18 @@
 	} else if (is_start_of_div(tok)) {
 		isl_stream_push_token(s, tok);
 		tok = NULL;
-		res = accept_div(s, isl_space_copy(dim), v);
+		res = accept_div(s, isl_space_copy(space), v);
 	} else if (tok->type == ISL_TOKEN_MIN || tok->type == ISL_TOKEN_MAX) {
 		isl_stream_push_token(s, tok);
 		tok = NULL;
-		res = accept_minmax(s, isl_space_copy(dim), v);
+		res = accept_minmax(s, isl_space_copy(space), v);
 	} else {
 		isl_stream_error(s, tok, "expecting factor");
 		goto error;
 	}
 	if (isl_stream_eat_if_available(s, '%') ||
 	    isl_stream_eat_if_available(s, ISL_TOKEN_MOD)) {
-		isl_space_free(dim);
+		isl_space_free(space);
 		return affine_mod(s, v, res);
 	}
 	if (isl_stream_eat_if_available(s, '*')) {
@@ -519,25 +561,18 @@
 		res = isl_pw_aff_scale(res, f);
 		isl_int_clear(f);
 	}
-	if (isl_stream_eat_if_available(s, '/')) {
-		isl_int f;
-		isl_int_init(f);
-		isl_int_set_si(f, 1);
-		if (accept_cst_factor(s, &f) < 0) {
-			isl_int_clear(f);
-			goto error2;
-		}
-		res = isl_pw_aff_scale_down(res, f);
-		isl_int_clear(f);
-	}
+	if (isl_stream_eat_if_available(s, '/'))
+		res = pw_aff_div_by_cst(s, res);
+	if (isl_stream_eat_if_available(s, ISL_TOKEN_INT_DIV))
+		res = isl_pw_aff_floor(pw_aff_div_by_cst(s, res));
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	return res;
 error:
 	isl_token_free(tok);
 error2:
 	isl_pw_aff_free(res);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -558,13 +593,10 @@
  */
 static __isl_give isl_pw_aff *nan_on_domain(__isl_keep isl_space *space)
 {
-	isl_local_space *ls;
-
-	ls = isl_local_space_from_space(isl_space_copy(space));
-	return isl_pw_aff_nan_on_domain(ls);
+	return isl_pw_aff_nan_on_domain_space(isl_space_copy(space));
 }
 
-static __isl_give isl_pw_aff *accept_affine(struct isl_stream *s,
+static __isl_give isl_pw_aff *accept_affine(__isl_keep isl_stream *s,
 	__isl_take isl_space *space, struct vars *v)
 {
 	struct isl_token *tok = NULL;
@@ -617,6 +649,10 @@
 				if (!res)
 					goto error;
 			} else {
+				if (isl_stream_eat_if_available(s,
+							ISL_TOKEN_INT_DIV) &&
+				    int_div_by_cst(s, &tok->u.v) < 0)
+					goto error;
 				res = add_cst(res, tok->u.v);
 			}
 			sign = 1;
@@ -657,10 +693,28 @@
 	return NULL;
 }
 
+/* Is "type" the type of a comparison operator between lists
+ * of affine expressions?
+ */
+static int is_list_comparator_type(int type)
+{
+	switch (type) {
+	case ISL_TOKEN_LEX_LT:
+	case ISL_TOKEN_LEX_GT:
+	case ISL_TOKEN_LEX_LE:
+	case ISL_TOKEN_LEX_GE:
+		return 1;
+	default:
+		return 0;
+	}
+}
+
 static int is_comparator(struct isl_token *tok)
 {
 	if (!tok)
 		return 0;
+	if (is_list_comparator_type(tok->type))
+		return 1;
 
 	switch (tok->type) {
 	case ISL_TOKEN_LT:
@@ -675,17 +729,17 @@
 	}
 }
 
-static __isl_give isl_map *read_formula(struct isl_stream *s,
+static __isl_give isl_map *read_formula(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational);
-static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v, int rational);
+static __isl_give isl_pw_aff *accept_extended_affine(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v, int rational);
 
 /* Accept a ternary operator, given the first argument.
  */
-static __isl_give isl_pw_aff *accept_ternary(struct isl_stream *s,
+static __isl_give isl_pw_aff *accept_ternary(__isl_keep isl_stream *s,
 	__isl_take isl_map *cond, struct vars *v, int rational)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_pw_aff *pwaff1 = NULL, *pwaff2 = NULL, *pa_cond;
 
 	if (!cond)
@@ -694,17 +748,17 @@
 	if (isl_stream_eat(s, '?'))
 		goto error;
 
-	dim = isl_space_wrap(isl_map_get_space(cond));
-	pwaff1 = accept_extended_affine(s, dim, v, rational);
+	space = isl_space_wrap(isl_map_get_space(cond));
+	pwaff1 = accept_extended_affine(s, space, v, rational);
 	if (!pwaff1)
 		goto error;
 
 	if (isl_stream_eat(s, ':'))
 		goto error;
 
-	dim = isl_pw_aff_get_domain_space(pwaff1);
-	pwaff2 = accept_extended_affine(s, dim, v, rational);
-	if (!pwaff1)
+	space = isl_pw_aff_get_domain_space(pwaff1);
+	pwaff2 = accept_extended_affine(s, space, v, rational);
+	if (!pwaff2)
 		goto error;
 
 	pa_cond = isl_set_indicator_function(isl_map_wrap(cond));
@@ -718,7 +772,7 @@
 
 /* Set *line and *col to those of the next token, if any.
  */
-static void set_current_line_col(struct isl_stream *s, int *line, int *col)
+static void set_current_line_col(__isl_keep isl_stream *s, int *line, int *col)
 {
 	struct isl_token *tok;
 
@@ -734,7 +788,7 @@
 /* Push a token encapsulating "pa" onto "s", with the given
  * line and column.
  */
-static int push_aff(struct isl_stream *s, int line, int col,
+static isl_stat push_aff(__isl_keep isl_stream *s, int line, int col,
 	__isl_take isl_pw_aff *pa)
 {
 	struct isl_token *tok;
@@ -746,10 +800,27 @@
 	tok->u.pwaff = pa;
 	isl_stream_push_token(s, tok);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_pw_aff_free(pa);
-	return -1;
+	return isl_stat_error;
+}
+
+/* Is the next token a comparison operator?
+ */
+static int next_is_comparator(__isl_keep isl_stream *s)
+{
+	int is_comp;
+	struct isl_token *tok;
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return 0;
+
+	is_comp = is_comparator(tok);
+	isl_stream_push_token(s, tok);
+
+	return is_comp;
 }
 
 /* Accept an affine expression that may involve ternary operators.
@@ -758,31 +829,21 @@
  * Otherwise, we assume the affine expression is part of the first
  * argument of a ternary operator and try to parse that.
  */
-static __isl_give isl_pw_aff *accept_extended_affine(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v, int rational)
+static __isl_give isl_pw_aff *accept_extended_affine(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v, int rational)
 {
-	isl_space *space;
 	isl_map *cond;
 	isl_pw_aff *pwaff;
-	struct isl_token *tok;
 	int line = -1, col = -1;
-	int is_comp;
 
 	set_current_line_col(s, &line, &col);
 
-	pwaff = accept_affine(s, dim, v);
+	pwaff = accept_affine(s, space, v);
 	if (rational)
 		pwaff = isl_pw_aff_set_rational(pwaff);
 	if (!pwaff)
 		return NULL;
-
-	tok = isl_stream_next_token(s);
-	if (!tok)
-		return isl_pw_aff_free(pwaff);
-
-	is_comp = is_comparator(tok);
-	isl_stream_push_token(s, tok);
-	if (!is_comp)
+	if (!next_is_comparator(s))
 		return pwaff;
 
 	space = isl_pw_aff_get_domain_space(pwaff);
@@ -798,22 +859,28 @@
 	return accept_ternary(s, cond, v, rational);
 }
 
-static __isl_give isl_map *read_var_def(struct isl_stream *s,
+static __isl_give isl_map *read_var_def(__isl_keep isl_stream *s,
 	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v,
 	int rational)
 {
 	isl_pw_aff *def;
-	int pos;
+	isl_size pos;
 	isl_map *def_map;
 
 	if (type == isl_dim_param)
 		pos = isl_map_dim(map, isl_dim_param);
 	else {
 		pos = isl_map_dim(map, isl_dim_in);
-		if (type == isl_dim_out)
-			pos += isl_map_dim(map, isl_dim_out);
+		if (type == isl_dim_out) {
+			isl_size n_out = isl_map_dim(map, isl_dim_out);
+			if (pos < 0 || n_out < 0)
+				return isl_map_free(map);
+			pos += n_out;
+		}
 		type = isl_dim_in;
 	}
+	if (pos < 0)
+		return isl_map_free(map);
 	--pos;
 
 	def = accept_extended_affine(s, isl_space_wrap(isl_map_get_space(map)),
@@ -827,14 +894,14 @@
 	return map;
 }
 
-static __isl_give isl_pw_aff_list *accept_affine_list(struct isl_stream *s,
-	__isl_take isl_space *dim, struct vars *v)
+static __isl_give isl_pw_aff_list *accept_affine_list(__isl_keep isl_stream *s,
+	__isl_take isl_space *space, struct vars *v)
 {
 	isl_pw_aff *pwaff;
 	isl_pw_aff_list *list;
 	struct isl_token *tok = NULL;
 
-	pwaff = accept_affine(s, isl_space_copy(dim), v);
+	pwaff = accept_affine(s, isl_space_copy(space), v);
 	list = isl_pw_aff_list_from_pw_aff(pwaff);
 	if (!list)
 		goto error;
@@ -851,22 +918,22 @@
 		}
 		isl_token_free(tok);
 
-		pwaff = accept_affine(s, isl_space_copy(dim), v);
+		pwaff = accept_affine(s, isl_space_copy(space), v);
 		list = isl_pw_aff_list_concat(list,
 				isl_pw_aff_list_from_pw_aff(pwaff));
 		if (!list)
 			goto error;
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	return list;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_pw_aff_list_free(list);
 	return NULL;
 }
 
-static __isl_give isl_map *read_defined_var_list(struct isl_stream *s,
+static __isl_give isl_map *read_defined_var_list(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	struct isl_token *tok;
@@ -911,7 +978,7 @@
 	return NULL;
 }
 
-static int next_is_tuple(struct isl_stream *s)
+static int next_is_tuple(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok;
 	int is_tuple;
@@ -935,19 +1002,23 @@
 	return is_tuple;
 }
 
-/* Allocate an initial tuple with zero dimensions and an anonymous,
- * unstructured space.
- * A tuple is represented as an isl_multi_pw_aff.
- * The range space is the space of the tuple.
- * The domain space is an anonymous space
- * with a dimension for each variable in the set of variables in "v".
- * If a given dimension is not defined in terms of earlier dimensions in
- * the input, then the corresponding isl_pw_aff is set equal to one time
- * the variable corresponding to the dimension being defined.
+/* Does the next token mark the end of a tuple element?
  */
-static __isl_give isl_multi_pw_aff *tuple_alloc(struct vars *v)
+static int next_is_end_tuple_element(__isl_keep isl_stream *s)
 {
-	return isl_multi_pw_aff_alloc(isl_space_alloc(v->ctx, 0, v->n, 0));
+	return isl_stream_next_token_is(s, ',') ||
+	    isl_stream_next_token_is(s, '');
+}
+
+/* Is the next token one that necessarily forms the start of a condition?
+ */
+static int next_is_condition_start(__isl_keep isl_stream *s)
+{
+	return isl_stream_next_token_is(s, ISL_TOKEN_EXISTS) ||
+	    isl_stream_next_token_is(s, ISL_TOKEN_NOT) ||
+	    isl_stream_next_token_is(s, ISL_TOKEN_TRUE) ||
+	    isl_stream_next_token_is(s, ISL_TOKEN_FALSE) ||
+	    isl_stream_next_token_is(s, ISL_TOKEN_MAP);
 }
 
 /* Is "pa" an expression in term of earlier dimensions?
@@ -957,35 +1028,36 @@
  * of "n" expressions.  The final dimensions of "pa" correspond to
  * these "n" expressions.
  */
-static int pw_aff_is_expr(__isl_keep isl_pw_aff *pa, int i, int n)
+static isl_bool pw_aff_is_expr(__isl_keep isl_pw_aff *pa, int i, int n)
 {
 	isl_aff *aff;
 
 	if (!pa)
-		return -1;
+		return isl_bool_error;
 	if (pa->n != 1)
-		return 1;
+		return isl_bool_true;
 	if (!isl_set_plain_is_universe(pa->p0.set))
-		return 1;
+		return isl_bool_true;
 
 	aff = pa->p0.aff;
 	if (isl_int_is_zero(aff->v->elaff->v->size - n + i))
-		return 1;
-	return 0;
+		return isl_bool_true;
+	return isl_bool_false;
 }
 
 /* Does the tuple contain any dimensions that are defined
  * in terms of earlier dimensions?
  */
-static int tuple_has_expr(__isl_keep isl_multi_pw_aff *tuple)
+static isl_bool tuple_has_expr(__isl_keep isl_multi_pw_aff *tuple)
 {
-	int i, n;
-	int has_expr = 0;
+	int i;
+	isl_size n;
+	isl_bool has_expr = isl_bool_false;
 	isl_pw_aff *pa;
 
-	if (!tuple)
-		return -1;
 	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
+	if (n < 0)
+		return isl_bool_error;
 	for (i = 0; i < n; ++i) {
 		pa = isl_multi_pw_aff_get_pw_aff(tuple, i);
 		has_expr = pw_aff_is_expr(pa, i, n);
@@ -997,49 +1069,216 @@
 	return has_expr;
 }
 
-/* Add a dimension to the given tuple.
- * The dimension is initially undefined, so it is encoded
- * as one times itself.
- */
-static __isl_give isl_multi_pw_aff *tuple_add_dim(
-	__isl_take isl_multi_pw_aff *tuple, struct vars *v)
-{
-	isl_space *space;
-	isl_aff *aff;
-	isl_pw_aff *pa;
-
-	tuple = isl_multi_pw_aff_add_dims(tuple, isl_dim_in, 1);
-	space = isl_multi_pw_aff_get_domain_space(tuple);
-	aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
-	aff = isl_aff_add_coefficient_si(aff, isl_dim_in, v->n, 1);
-	pa = isl_pw_aff_from_aff(aff);
-	tuple = isl_multi_pw_aff_flat_range_product(tuple,
-					    isl_multi_pw_aff_from_pw_aff(pa));
-
-	return tuple;
-}
-
-/* Set the name of dimension "pos" in "tuple" to "name".
+/* Set the name of dimension "pos" in "space" to "name".
  * During printing, we add primes if the same name appears more than once
  * to distinguish the occurrences.  Here, we remove those primes from "name"
  * before setting the name of the dimension.
  */
-static __isl_give isl_multi_pw_aff *tuple_set_dim_name(
-	__isl_take isl_multi_pw_aff *tuple, int pos, char *name)
+static __isl_give isl_space *space_set_dim_name(__isl_take isl_space *space,
+	int pos, char *name)
 {
 	char *prime;
 
 	if (!name)
-		return tuple;
+		return space;
 
 	prime = strchr(name, '\'');
 	if (prime)
 		*prime = '\0';
-	tuple = isl_multi_pw_aff_set_dim_name(tuple, isl_dim_set, pos, name);
+	space = isl_space_set_dim_name(space, isl_dim_out, pos, name);
 	if (prime)
 		*prime = '\'';
 
-	return tuple;
+	return space;
+}
+
+/* Construct an isl_pw_aff defined on a "space" (with v->n variables)
+ * that is equal to the last of those variables.
+ */
+static __isl_give isl_pw_aff *identity_tuple_el_on_space(
+	__isl_take isl_space *space, struct vars *v)
+{
+	isl_aff *aff;
+
+	aff = isl_aff_zero_on_domain(isl_local_space_from_space(space));
+	aff = isl_aff_add_coefficient_si(aff, isl_dim_in, v->n - 1, 1);
+	return isl_pw_aff_from_aff(aff);
+}
+
+/* Construct an isl_pw_aff defined on the domain space of "pa"
+ * that is equal to the last variable in "v".
+ *
+ * That is, if D is the domain space of "pa", then construct
+ *
+ *	D..., i -> i.
+ */
+static __isl_give isl_pw_aff *init_range(__isl_keep isl_pw_aff *pa,
+	struct vars *v)
+{
+	isl_space *space;
+
+	space = isl_pw_aff_get_domain_space(pa);
+	return identity_tuple_el_on_space(space, v);
+}
+
+/* Impose the lower bound "lower" on the variable represented by "range_pa".
+ *
+ * In particular, "range_pa" is of the form
+ *
+ *	D..., i -> i : C
+ *
+ * with D also the domains space of "lower' and "C" some constraints.
+ *
+ * Return the expression
+ *
+ *	D..., i -> i : C and i >= lower
+ */
+static __isl_give isl_pw_aff *set_lower(__isl_take isl_pw_aff *range_pa,
+	__isl_take isl_pw_aff *lower)
+{
+	isl_set *range;
+
+	range = isl_pw_aff_ge_set(isl_pw_aff_copy(range_pa), lower);
+	return isl_pw_aff_intersect_domain(range_pa, range);
+}
+
+/* Impose the upper bound "upper" on the variable represented by "range_pa".
+ *
+ * In particular, "range_pa" is of the form
+ *
+ *	D..., i -> i : C
+ *
+ * with D also the domains space of "upper' and "C" some constraints.
+ *
+ * Return the expression
+ *
+ *	D..., i -> i : C and i <= upper
+ */
+static __isl_give isl_pw_aff *set_upper(__isl_take isl_pw_aff *range_pa,
+	__isl_take isl_pw_aff *upper)
+{
+	isl_set *range;
+
+	range = isl_pw_aff_le_set(isl_pw_aff_copy(range_pa), upper);
+	return isl_pw_aff_intersect_domain(range_pa, range);
+}
+
+/* Construct a piecewise affine expression corresponding
+ * to the last variable in "v" that is greater than or equal to "pa".
+ *
+ * In particular, if D is the domain space of "pa",
+ * then construct the expression
+ *
+ *	D..., i -> i,
+ *
+ * impose lower bound "pa" and return
+ *
+ *	D..., i -> i : i >= pa
+ */
+static __isl_give isl_pw_aff *construct_lower(__isl_take isl_pw_aff *pa,
+	struct vars *v)
+{
+	return set_lower(init_range(pa, v), pa);
+}
+
+/* Construct a piecewise affine expression corresponding
+ * to the last variable in "v" that is smaller than or equal to "pa".
+ *
+ * In particular, if D is the domain space of "pa",
+ * then construct the expression
+ *
+ *	D..., i -> i,
+ *
+ * impose lower bound "pa" and return
+ *
+ *	D..., i -> i : i <= pa
+ */
+static __isl_give isl_pw_aff *construct_upper(__isl_take isl_pw_aff *pa,
+	struct vars *v)
+{
+	return set_upper(init_range(pa, v), pa);
+}
+
+/* Construct a piecewise affine expression corresponding
+ * to the last variable in "v" that ranges between "pa" and "pa2".
+ *
+ * In particular, if D is the domain space of "pa" (and "pa2"),
+ * then construct the expression
+ *
+ *	D..., i -> i,
+ *
+ * impose lower bound "pa" and upper bound "pa2" and return
+ *
+ *	D..., i -> i : pa <= i <= pa2
+ */
+static __isl_give isl_pw_aff *construct_range(__isl_take isl_pw_aff *pa,
+	__isl_take isl_pw_aff *pa2, struct vars *v)
+{
+	return set_upper(set_lower(init_range(pa, v), pa), pa2);
+}
+
+static int resolve_paren_expr(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_map *map, int rational);
+
+/* Given that the (piecewise) affine expression "pa"
+ * has just been parsed, followed by a colon,
+ * continue parsing as part of a piecewise affine expression.
+ *
+ * In particular, check if the colon is followed by a condition.
+ * If so, parse the conditions(a) on "pa" and include them in the domain.
+ * Otherwise, if the colon is followed by another (piecewise) affine expression
+ * then consider the two expressions as endpoints of a range of values and
+ * return a piecewise affine expression that takes values in that range.
+ * Note that an affine expression followed by a comparison operator
+ * is considered to be part of a condition.
+ * If the colon is not followed by anything (inside the tuple element),
+ * then consider "pa" as a lower bound on a range of values without upper bound
+ * and return a piecewise affine expression that takes values in that range.
+ */
+static __isl_give isl_pw_aff *update_piecewise_affine_colon(
+	__isl_take isl_pw_aff *pa, __isl_keep isl_stream *s,
+	struct vars *v, int rational)
+{
+	isl_space *dom_space;
+	isl_map *map;
+
+	dom_space = isl_pw_aff_get_domain_space(pa);
+	map = isl_map_universe(isl_space_from_domain(dom_space));
+
+	if (isl_stream_next_token_is(s, '('))
+		if (resolve_paren_expr(s, v, isl_map_copy(map), rational))
+			goto error;
+	if (next_is_end_tuple_element(s)) {
+		isl_map_free(map);
+		return construct_lower(pa, v);
+	}
+	if (!next_is_condition_start(s)) {
+		int line = -1, col = -1;
+		isl_space *space;
+		isl_pw_aff *pa2;
+
+		set_current_line_col(s, &line, &col);
+		space = isl_space_wrap(isl_map_get_space(map));
+		pa2 = accept_affine(s, space, v);
+		if (rational)
+			pa2 = isl_pw_aff_set_rational(pa2);
+		if (!next_is_comparator(s)) {
+			isl_map_free(map);
+			pa2 = isl_pw_aff_domain_factor_domain(pa2);
+			return construct_range(pa, pa2, v);
+		}
+		if (push_aff(s, line, col, pa2) < 0)
+			goto error;
+	}
+
+	map = read_formula(s, v, map, rational);
+	pa = isl_pw_aff_intersect_domain(pa, isl_map_domain(map));
+
+	return pa;
+error:
+	isl_map_free(map);
+	isl_pw_aff_free(pa);
+	return NULL;
 }
 
 /* Accept a piecewise affine expression.
@@ -1048,12 +1287,26 @@
  *
  *	aff1 : condition1; aff2 : conditions2; ...
  *
+ * or one of
+ *
+ *	aff :
+ *	aff1 : aff2
+ *	: aff
+ *	:
+ *
  * or simply
  *
  *	aff
  *
  * each of the affine expressions may in turn include ternary operators.
  *
+ * If the first token is a colon, then the expression must be
+ * ":" or ": aff2", depending on whether anything follows the colon
+ * inside the tuple element.
+ * The first is considered to represent an arbitrary value.
+ * The second is considered to represent a range of values
+ * with the given upper bound and no lower bound.
+ *
  * There may be parentheses around some subexpression of "aff1"
  * around "aff1" itself, around "aff1 : condition1" and/or
  * around the entire piecewise affine expression.
@@ -1063,12 +1316,19 @@
  * expression, we push the parsed expression onto the stream and parse
  * again in case the parentheses enclose some subexpression of "aff1".
  */
-static __isl_give isl_pw_aff *accept_piecewise_affine(struct isl_stream *s,
+static __isl_give isl_pw_aff *accept_piecewise_affine(__isl_keep isl_stream *s,
 	__isl_take isl_space *space, struct vars *v, int rational)
 {
 	isl_pw_aff *res;
 	isl_space *res_space;
 
+	if (isl_stream_eat_if_available(s, ':')) {
+		if (next_is_end_tuple_element(s))
+			return identity_tuple_el_on_space(space, v);
+		else
+			return construct_upper(accept_affine(s, space, v), v);
+	}
+
 	res_space = isl_space_from_domain(isl_space_copy(space));
 	res_space = isl_space_add_dims(res_space, isl_dim_out, 1);
 	res = isl_pw_aff_empty(res_space);
@@ -1092,15 +1352,8 @@
 			pa = accept_extended_affine(s, isl_space_copy(space),
 							v, rational);
 		}
-		if (isl_stream_eat_if_available(s, ':')) {
-			isl_space *dom_space;
-			isl_set *dom;
-
-			dom_space = isl_pw_aff_get_domain_space(pa);
-			dom = isl_set_universe(dom_space);
-			dom = read_formula(s, v, dom, rational);
-			pa = isl_pw_aff_intersect_domain(pa, dom);
-		}
+		if (isl_stream_eat_if_available(s, ':'))
+			pa = update_piecewise_affine_colon(pa, s, v, rational);
 
 		res = isl_pw_aff_union_add(res, pa);
 
@@ -1116,17 +1369,15 @@
 	return isl_pw_aff_free(res);
 }
 
-/* Read an affine expression from "s" and replace the definition
- * of dimension "pos" in "tuple" by this expression.
+/* Read an affine expression from "s" for use in read_tuple.
  *
  * accept_extended_affine requires a wrapped space as input.
- * The domain space of "tuple", on the other hand is an anonymous space,
- * so we have to adjust the space of the isl_pw_aff before adding it
- * to "tuple".
+ * read_tuple on the other hand expects each isl_pw_aff
+ * to have an anonymous space.  We therefore adjust the space
+ * of the isl_pw_aff before returning it.
  */
-static __isl_give isl_multi_pw_aff *read_tuple_var_def(struct isl_stream *s,
-	__isl_take isl_multi_pw_aff *tuple, int pos, struct vars *v,
-	int rational)
+static __isl_give isl_pw_aff *read_tuple_var_def(__isl_keep isl_stream *s,
+	struct vars *v, int rational)
 {
 	isl_space *space;
 	isl_pw_aff *def;
@@ -1134,90 +1385,71 @@
 	space = isl_space_wrap(isl_space_alloc(s->ctx, 0, v->n, 0));
 
 	def = accept_piecewise_affine(s, space, v, rational);
+	def = isl_pw_aff_domain_factor_domain(def);
 
-	space = isl_space_set_alloc(s->ctx, 0, v->n);
-	def = isl_pw_aff_reset_domain_space(def, space);
-	tuple = isl_multi_pw_aff_set_pw_aff(tuple, pos, def);
-
-	return tuple;
+	return def;
 }
 
-/* Read a list of variables and/or affine expressions and return the list
- * as an isl_multi_pw_aff.
+/* Read a list of tuple elements by calling "read_el" on each of them and
+ * return a space with the same number of set dimensions derived from
+ * the parameter space "space" and possibly updated by "read_el".
  * The elements in the list are separated by either "," or "".
  * If "comma" is set then only "," is allowed.
  */
-static __isl_give isl_multi_pw_aff *read_tuple_var_list(struct isl_stream *s,
-	struct vars *v, int rational, int comma)
+static __isl_give isl_space *read_tuple_list(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space, int rational, int comma,
+	__isl_give isl_space *(*read_el)(__isl_keep isl_stream *s,
+		struct vars *v, __isl_take isl_space *space, int rational,
+		void *user),
+	void *user)
 {
-	int i = 0;
-	struct isl_token *tok;
-	isl_multi_pw_aff *res;
+	if (!space)
+		return NULL;
 
-	res = tuple_alloc(v);
+	space = isl_space_set_from_params(space);
 
 	if (isl_stream_next_token_is(s, ''))
-		return res;
-
-	while ((tok = next_token(s)) != NULL) {
-		int new_name = 0;
+		return space;
 
-		res = tuple_add_dim(res, v);
+	for (;;) {
+		struct isl_token *tok;
 
-		if (tok->type == ISL_TOKEN_IDENT) {
-			int n = v->n;
-			int p = vars_pos(v, tok->u.s, -1);
-			if (p < 0)
-				goto error;
-			new_name = p >= n;
-		}
+		space = isl_space_add_dims(space, isl_dim_set, 1);
 
-		if (tok->type == '*') {
-			if (vars_add_anon(v) < 0)
-				goto error;
-			isl_token_free(tok);
-		} else if (new_name) {
-			res = tuple_set_dim_name(res, i, v->v->name);
-			isl_token_free(tok);
-			if (isl_stream_eat_if_available(s, '='))
-				res = read_tuple_var_def(s, res, i, v,
-							rational);
-		} else {
-			isl_stream_push_token(s, tok);
-			tok = NULL;
-			if (vars_add_anon(v) < 0)
-				goto error;
-			res = read_tuple_var_def(s, res, i, v, rational);
-		}
+		space = read_el(s, v, space, rational, user);
+		if (!space)
+			return NULL;
 
 		tok = isl_stream_next_token(s);
 		if (!comma && tok && tok->type == '' &&
 		    isl_stream_next_token_is(s, '')) {
 			isl_token_free(tok);
 			tok = isl_stream_next_token(s);
-		} else if (!tok || tok->type != ',')
+		} else if (!tok || tok->type != ',') {
+			if (tok)
+				isl_stream_push_token(s, tok);
 			break;
+		}
 
 		isl_token_free(tok);
-		i++;
 	}
-	if (tok)
-		isl_stream_push_token(s, tok);
 
-	return res;
-error:
-	isl_token_free(tok);
-	return isl_multi_pw_aff_free(res);
+	return space;
 }
 
-/* Read a tuple and represent it as an isl_multi_pw_aff.  See tuple_alloc.
+/* Read a tuple space from "s" derived from the parameter space "space".
+ * Call "read_el" on each element in the tuples.
  */
-static __isl_give isl_multi_pw_aff *read_tuple(struct isl_stream *s,
-	struct vars *v, int rational, int comma)
+static __isl_give isl_space *read_tuple_space(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space, int rational, int comma,
+	__isl_give isl_space *(*read_el)(__isl_keep isl_stream *s,
+		struct vars *v, __isl_take isl_space *space, int rational,
+		void *user),
+	void *user)
 {
 	struct isl_token *tok;
 	char *name = NULL;
-	isl_multi_pw_aff *res = NULL;
+	isl_space *res = NULL;
 
 	tok = isl_stream_next_token(s);
 	if (!tok)
@@ -1232,29 +1464,152 @@
 	if (isl_stream_eat(s, ''))
 		goto error;
 	if (next_is_tuple(s)) {
-		isl_multi_pw_aff *out;
-		int n;
-		res = read_tuple(s, v, rational, comma);
+		isl_space *out;
+		res = read_tuple_space(s, v, isl_space_copy(space),
+					rational, comma, read_el, user);
 		if (isl_stream_eat(s, ISL_TOKEN_TO))
 			goto error;
-		out = read_tuple(s, v, rational, comma);
-		n = isl_multi_pw_aff_dim(out, isl_dim_out);
-		res = isl_multi_pw_aff_add_dims(res, isl_dim_in, n);
-		res = isl_multi_pw_aff_range_product(res, out);
+		out = read_tuple_space(s, v, isl_space_copy(space),
+					rational, comma, read_el, user);
+		res = isl_space_product(res, out);
 	} else
-		res = read_tuple_var_list(s, v, rational, comma);
+		res = read_tuple_list(s, v, isl_space_copy(space),
+					rational, comma, read_el, user);
 	if (isl_stream_eat(s, ''))
 		goto error;
 
 	if (name) {
-		res = isl_multi_pw_aff_set_tuple_name(res, isl_dim_out, name);
+		res = isl_space_set_tuple_name(res, isl_dim_set, name);
 		free(name);
 	}
 
+	isl_space_free(space);
 	return res;
 error:
 	free(name);
-	return isl_multi_pw_aff_free(res);
+	isl_space_free(res);
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Construct an isl_pw_aff defined on a space with v->n variables
+ * that is equal to the last of those variables.
+ */
+static __isl_give isl_pw_aff *identity_tuple_el(struct vars *v)
+{
+	isl_space *space;
+
+	space = isl_space_set_alloc(v->ctx, 0, v->n);
+	return identity_tuple_el_on_space(space, v);
+}
+
+/* This function is called for each element in a tuple inside read_tuple.
+ * Add a new variable to "v" and construct a corresponding isl_pw_aff defined
+ * over a space containing all variables in "v" defined so far.
+ * The isl_pw_aff expresses the new variable in terms of earlier variables
+ * if a definition is provided.  Otherwise, it is represented as being
+ * equal to itself.
+ * Add the isl_pw_aff to *list.
+ * If the new variable was named, then adjust "space" accordingly and
+ * return the updated space.
+ */
+static __isl_give isl_space *read_tuple_pw_aff_el(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space, int rational, void *user)
+{
+	isl_pw_aff_list **list = (isl_pw_aff_list **) user;
+	isl_pw_aff *pa;
+	struct isl_token *tok;
+	int new_name = 0;
+
+	tok = next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return isl_space_free(space);
+	}
+
+	if (tok->type == ISL_TOKEN_IDENT) {
+		int n = v->n;
+		int p = vars_pos(v, tok->u.s, -1);
+		if (p < 0)
+			goto error;
+		new_name = p >= n;
+	}
+
+	if (tok->type == '*') {
+		if (vars_add_anon(v) < 0)
+			goto error;
+		isl_token_free(tok);
+		pa = identity_tuple_el(v);
+	} else if (new_name) {
+		isl_size pos = isl_space_dim(space, isl_dim_out);
+		if (pos < 0)
+			goto error;
+		pos -= 1;
+		space = space_set_dim_name(space, pos, v->v->name);
+		isl_token_free(tok);
+		if (isl_stream_eat_if_available(s, '='))
+			pa = read_tuple_var_def(s, v, rational);
+		else
+			pa = identity_tuple_el(v);
+	} else {
+		isl_stream_push_token(s, tok);
+		tok = NULL;
+		if (vars_add_anon(v) < 0)
+			goto error;
+		pa = read_tuple_var_def(s, v, rational);
+	}
+
+	*list = isl_pw_aff_list_add(*list, pa);
+	if (!*list)
+		return isl_space_free(space);
+
+	return space;
+error:
+	isl_token_free(tok);
+	return isl_space_free(space);
+}
+
+/* Read a tuple and represent it as an isl_multi_pw_aff.
+ * The range space of the isl_multi_pw_aff is the space of the tuple.
+ * The domain space is an anonymous space
+ * with a dimension for each variable in the set of variables in "v",
+ * including the variables in the range.
+ * If a given dimension is not defined in terms of earlier dimensions in
+ * the input, then the corresponding isl_pw_aff is set equal to one time
+ * the variable corresponding to the dimension being defined.
+ *
+ * The elements in the tuple are collected in a list by read_tuple_pw_aff_el.
+ * Each element in this list is defined over a space representing
+ * the variables defined so far.  We need to adjust the earlier
+ * elements to have as many variables in the domain as the final
+ * element in the list.
+ */
+static __isl_give isl_multi_pw_aff *read_tuple(__isl_keep isl_stream *s,
+	struct vars *v, int rational, int comma)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_pw_aff_list *list;
+
+	space = isl_space_params_alloc(v->ctx, 0);
+	list = isl_pw_aff_list_alloc(s->ctx, 0);
+	space = read_tuple_space(s, v, space, rational, comma,
+				&read_tuple_pw_aff_el, &list);
+	n = isl_space_dim(space, isl_dim_set);
+	if (n < 0)
+		space = isl_space_free(space);
+	for (i = 0; i + 1 < n; ++i) {
+		isl_pw_aff *pa;
+
+		pa = isl_pw_aff_list_get_pw_aff(list, i);
+		pa = isl_pw_aff_add_dims(pa, isl_dim_in, n - (i + 1));
+		list = isl_pw_aff_list_set_pw_aff(list, i, pa);
+	}
+
+	space = isl_space_from_range(space);
+	space = isl_space_add_dims(space, isl_dim_in, v->n);
+	return isl_multi_pw_aff_from_pw_aff_list(space, list);
 }
 
 /* Add the tuple represented by the isl_multi_pw_aff "tuple" to "map".
@@ -1267,14 +1622,15 @@
 	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v,
 	int rational)
 {
-	int i, n;
+	int i;
+	isl_size n;
 	isl_ctx *ctx;
 	isl_space *space = NULL;
 
-	if (!map || !tuple)
+	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
+	if (!map || n < 0)
 		goto error;
 	ctx = isl_multi_pw_aff_get_ctx(tuple);
-	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
 	space = isl_space_range(isl_multi_pw_aff_get_space(tuple));
 	if (!space)
 		goto error;
@@ -1348,7 +1704,7 @@
  * The tuple is initially represented as an isl_multi_pw_aff and
  * then added to "map".
  */
-static __isl_give isl_map *read_map_tuple(struct isl_stream *s,
+static __isl_give isl_map *read_map_tuple(__isl_keep isl_stream *s,
 	__isl_take isl_map *map, enum isl_dim_type type, struct vars *v,
 	int rational, int comma)
 {
@@ -1361,6 +1717,81 @@
 	return map_from_tuple(tuple, map, type, v, rational);
 }
 
+/* Given two equal-length lists of piecewise affine expression with the space
+ * of "set" as domain, construct a set in the same space that expresses
+ * that "left" and "right" satisfy the comparison "type".
+ *
+ * A space is constructed of the same dimension as the number of elements
+ * in the two lists.  The comparison is then expressed in a map from
+ * this space to itself and wrapped into a set.  Finally the two lists
+ * of piecewise affine expressions are plugged into this set.
+ *
+ * Let S be the space of "set" and T the constructed space.
+ * The lists are first changed into two isl_multi_pw_affs in S -> T and
+ * then combined into an isl_multi_pw_aff in S -> T -> T,
+ * while the comparison is first expressed in T -> T, then T -> T
+ * and finally in S.
+ */
+static __isl_give isl_set *list_cmp(__isl_keep isl_set *set, int type,
+	__isl_take isl_pw_aff_list *left, __isl_take isl_pw_aff_list *right)
+{
+	isl_space *space;
+	isl_size n;
+	isl_multi_pw_aff *mpa1, *mpa2;
+
+	n = isl_pw_aff_list_n_pw_aff(left);
+	if (!set || n < 0 || !right)
+		goto error;
+
+	space = isl_set_get_space(set);
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, n);
+	mpa1 = isl_multi_pw_aff_from_pw_aff_list(isl_space_copy(space), left);
+	mpa2 = isl_multi_pw_aff_from_pw_aff_list(isl_space_copy(space), right);
+	mpa1 = isl_multi_pw_aff_range_product(mpa1, mpa2);
+
+	space = isl_space_range(space);
+	switch (type) {
+	case ISL_TOKEN_LEX_LT:
+		set = isl_map_wrap(isl_map_lex_lt(space));
+		break;
+	case ISL_TOKEN_LEX_GT:
+		set = isl_map_wrap(isl_map_lex_gt(space));
+		break;
+	case ISL_TOKEN_LEX_LE:
+		set = isl_map_wrap(isl_map_lex_le(space));
+		break;
+	case ISL_TOKEN_LEX_GE:
+		set = isl_map_wrap(isl_map_lex_ge(space));
+		break;
+	default:
+		isl_multi_pw_aff_free(mpa1);
+		isl_space_free(space);
+		isl_die(isl_set_get_ctx(set), isl_error_internal,
+			"unhandled list comparison type", return NULL);
+	}
+	set = isl_set_preimage_multi_pw_aff(set, mpa1);
+	return set;
+error:
+	isl_pw_aff_list_free(left);
+	isl_pw_aff_list_free(right);
+	return NULL;
+}
+
+/* Construct constraints of the form
+ *
+ *	a op b
+ *
+ * where a is an element in "left", op is an operator of type "type" and
+ * b is an element in "right", add the constraints to "set" and return
+ * the result.
+ * "rational" is set if the constraints should be treated as
+ * a rational constraints.
+ *
+ * If "type" is the type of a comparison operator between lists
+ * of affine expressions, then a single (compound) constraint
+ * is constructed by list_cmp instead.
+ */
 static __isl_give isl_set *construct_constraints(
 	__isl_take isl_set *set, int type,
 	__isl_keep isl_pw_aff_list *left, __isl_keep isl_pw_aff_list *right,
@@ -1374,7 +1805,9 @@
 		left = isl_pw_aff_list_set_rational(left);
 		right = isl_pw_aff_list_set_rational(right);
 	}
-	if (type == ISL_TOKEN_LE)
+	if (is_list_comparator_type(type))
+		cond = list_cmp(set, type, left, right);
+	else if (type == ISL_TOKEN_LE)
 		cond = isl_pw_aff_list_le_set(left, right);
 	else if (type == ISL_TOKEN_GE)
 		cond = isl_pw_aff_list_ge_set(left, right);
@@ -1390,11 +1823,32 @@
 	return isl_set_intersect(set, cond);
 }
 
-static __isl_give isl_map *add_constraint(struct isl_stream *s,
+/* Read a constraint from "s", add it to "map" and return the result.
+ * "v" contains a description of the identifiers parsed so far.
+ * "rational" is set if the constraint should be treated as
+ * a rational constraint.
+ * The constraint read from "s" may be applied to multiple pairs
+ * of affine expressions and may be chained.
+ * In particular, a list of affine expressions is read, followed
+ * by a comparison operator and another list of affine expressions.
+ * The comparison operator is then applied to each pair of elements
+ * in the two lists and the results are added to "map".
+ * However, if the operator expects two lists of affine expressions,
+ * then it is applied directly to those lists and the two lists
+ * are required to have the same length.
+ * If the next token is another comparison operator, then another
+ * list of affine expressions is read and the process repeats.
+ *
+ * The processing is performed on a wrapped copy of "map" because
+ * an affine expression cannot have a binary relation as domain.
+ */
+static __isl_give isl_map *add_constraint(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
-	struct isl_token *tok = NULL;
+	struct isl_token *tok;
+	int type;
 	isl_pw_aff_list *list1 = NULL, *list2 = NULL;
+	isl_size n1, n2;
 	isl_set *set;
 
 	set = isl_map_wrap(map);
@@ -1406,40 +1860,43 @@
 		isl_stream_error(s, tok, "missing operator");
 		if (tok)
 			isl_stream_push_token(s, tok);
-		tok = NULL;
 		goto error;
 	}
+	type = tok->type;
+	isl_token_free(tok);
 	for (;;) {
 		list2 = accept_affine_list(s, isl_set_get_space(set), v);
-		if (!list2)
+		n1 = isl_pw_aff_list_n_pw_aff(list1);
+		n2 = isl_pw_aff_list_n_pw_aff(list2);
+		if (n1 < 0 || n2 < 0)
+			goto error;
+		if (is_list_comparator_type(type) && n1 != n2) {
+			isl_stream_error(s, NULL,
+					"list arguments not of same size");
 			goto error;
+		}
 
-		set = construct_constraints(set, tok->type, list1, list2,
-						rational);
-		isl_token_free(tok);
+		set = construct_constraints(set, type, list1, list2, rational);
 		isl_pw_aff_list_free(list1);
 		list1 = list2;
 
-		tok = isl_stream_next_token(s);
-		if (!is_comparator(tok)) {
-			if (tok)
-				isl_stream_push_token(s, tok);
+		if (!next_is_comparator(s))
 			break;
-		}
+		tok = isl_stream_next_token(s);
+		type = tok->type;
+		isl_token_free(tok);
 	}
 	isl_pw_aff_list_free(list1);
 
 	return isl_set_unwrap(set);
 error:
-	if (tok)
-		isl_token_free(tok);
 	isl_pw_aff_list_free(list1);
 	isl_pw_aff_list_free(list2);
 	isl_set_free(set);
 	return NULL;
 }
 
-static __isl_give isl_map *read_exists(struct isl_stream *s,
+static __isl_give isl_map *read_exists(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	int n = v->n;
@@ -1479,10 +1936,11 @@
  * Otherwise, we assume that the affine expression is the
  * start of a condition and continue parsing.
  */
-static int resolve_paren_expr(struct isl_stream *s,
+static int resolve_paren_expr(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	struct isl_token *tok, *tok2;
+	int has_paren;
 	int line, col;
 	isl_pw_aff *pwaff;
 
@@ -1494,11 +1952,7 @@
 		if (resolve_paren_expr(s, v, isl_map_copy(map), rational))
 			goto error;
 
-	if (isl_stream_next_token_is(s, ISL_TOKEN_EXISTS) ||
-	    isl_stream_next_token_is(s, ISL_TOKEN_NOT) ||
-	    isl_stream_next_token_is(s, ISL_TOKEN_TRUE) ||
-	    isl_stream_next_token_is(s, ISL_TOKEN_FALSE) ||
-	    isl_stream_next_token_is(s, ISL_TOKEN_MAP)) {
+	if (next_is_condition_start(s)) {
 		map = read_formula(s, v, map, rational);
 		if (isl_stream_eat(s, ')'))
 			goto error;
@@ -1519,21 +1973,17 @@
 	if (!pwaff)
 		goto error;
 
-	tok2 = isl_token_new(s->ctx, line, col, 0);
-	if (!tok2)
-		goto error2;
-	tok2->type = ISL_TOKEN_AFF;
-	tok2->u.pwaff = pwaff;
+	has_paren = isl_stream_eat_if_available(s, ')');
 
-	if (isl_stream_eat_if_available(s, ')')) {
-		isl_stream_push_token(s, tok2);
+	if (push_aff(s, line, col, pwaff) < 0)
+		goto error;
+
+	if (has_paren) {
 		isl_token_free(tok);
 		isl_map_free(map);
 		return 0;
 	}
 
-	isl_stream_push_token(s, tok2);
-
 	map = read_formula(s, v, map, rational);
 	if (isl_stream_eat(s, ')'))
 		goto error;
@@ -1543,15 +1993,13 @@
 	isl_stream_push_token(s, tok);
 
 	return 0;
-error2:
-	isl_pw_aff_free(pwaff);
 error:
 	isl_token_free(tok);
 	isl_map_free(map);
 	return -1;
 }
 
-static __isl_give isl_map *read_conjunct(struct isl_stream *s,
+static __isl_give isl_map *read_conjunct(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	if (isl_stream_next_token_is(s, '('))
@@ -1576,9 +2024,9 @@
 		return map;
 
 	if (isl_stream_eat_if_available(s, ISL_TOKEN_FALSE)) {
-		isl_space *dim = isl_map_get_space(map);
+		isl_space *space = isl_map_get_space(map);
 		isl_map_free(map);
-		return isl_map_empty(dim);
+		return isl_map_empty(space);
 	}
 		
 	return add_constraint(s, v, map, rational);
@@ -1587,7 +2035,7 @@
 	return NULL;
 }
 
-static __isl_give isl_map *read_conjuncts(struct isl_stream *s,
+static __isl_give isl_map *read_conjuncts(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	isl_map *res;
@@ -1613,16 +2061,13 @@
 	return res;
 }
 
-static struct isl_map *read_disjuncts(struct isl_stream *s,
+static __isl_give isl_map *read_disjuncts(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	isl_map *res;
 
-	if (isl_stream_next_token_is(s, '}')) {
-		isl_space *dim = isl_map_get_space(map);
-		isl_map_free(map);
-		return isl_map_universe(dim);
-	}
+	if (isl_stream_next_token_is(s, '}'))
+		return map;
 
 	res = read_conjuncts(s, v, isl_map_copy(map), rational);
 	while (isl_stream_eat_if_available(s, ISL_TOKEN_OR)) {
@@ -1657,7 +2102,7 @@
  *
  *	(map \setminus { .. : a}) \cup (map \cap { .. : b })
  */
-static __isl_give isl_map *read_formula(struct isl_stream *s,
+static __isl_give isl_map *read_formula(__isl_keep isl_stream *s,
 	struct vars *v, __isl_take isl_map *map, int rational)
 {
 	isl_map *res;
@@ -1676,46 +2121,48 @@
 	return res;
 }
 
-static int polylib_pos_to_isl_pos(__isl_keep isl_basic_map *bmap, int pos)
+static isl_size polylib_pos_to_isl_pos(__isl_keep isl_basic_map *bmap, int pos)
 {
-	if (pos < isl_basic_map_dim(bmap, isl_dim_out))
-		return 1 + isl_basic_map_dim(bmap, isl_dim_param) +
-			   isl_basic_map_dim(bmap, isl_dim_in) + pos;
-	pos -= isl_basic_map_dim(bmap, isl_dim_out);
-
-	if (pos < isl_basic_map_dim(bmap, isl_dim_in))
-		return 1 + isl_basic_map_dim(bmap, isl_dim_param) + pos;
-	pos -= isl_basic_map_dim(bmap, isl_dim_in);
-
-	if (pos < isl_basic_map_dim(bmap, isl_dim_div))
-		return 1 + isl_basic_map_dim(bmap, isl_dim_param) +
-			   isl_basic_map_dim(bmap, isl_dim_in) +
-			   isl_basic_map_dim(bmap, isl_dim_out) + pos;
-	pos -= isl_basic_map_dim(bmap, isl_dim_div);
+	isl_size n_out, n_in, n_param, n_div;
+
+	n_param = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_param < 0 || n_in < 0 || n_out < 0 || n_div < 0)
+		return isl_size_error;
+
+	if (pos < n_out)
+		return 1 + n_param + n_in + pos;
+	pos -= n_out;
+
+	if (pos < n_in)
+		return 1 + n_param + pos;
+	pos -= n_in;
+
+	if (pos < n_div)
+		return 1 + n_param + n_in + n_out + pos;
+	pos -= n_div;
 
-	if (pos < isl_basic_map_dim(bmap, isl_dim_param))
+	if (pos < n_param)
 		return 1 + pos;
 
 	return 0;
 }
 
 static __isl_give isl_basic_map *basic_map_read_polylib_constraint(
-	struct isl_stream *s, __isl_take isl_basic_map *bmap)
+	__isl_keep isl_stream *s, __isl_take isl_basic_map *bmap)
 {
 	int j;
 	struct isl_token *tok;
 	int type;
 	int k;
 	isl_int *c;
-	unsigned nparam;
-	unsigned dim;
+	isl_size total;
 
 	if (!bmap)
 		return NULL;
 
-	nparam = isl_basic_map_dim(bmap, isl_dim_param);
-	dim = isl_basic_map_dim(bmap, isl_dim_out);
-
 	tok = isl_stream_next_token(s);
 	if (!tok || tok->type != ISL_TOKEN_VALUE) {
 		isl_stream_error(s, tok, "expecting coefficient");
@@ -1743,8 +2190,11 @@
 	if (k < 0)
 		goto error;
 
-	for (j = 0; j < 1 + isl_basic_map_total_dim(bmap); ++j) {
-		int pos;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	for (j = 0; j < 1 + total; ++j) {
+		isl_size pos;
 		tok = isl_stream_next_token(s);
 		if (!tok || tok->type != ISL_TOKEN_VALUE) {
 			isl_stream_error(s, tok, "expecting coefficient");
@@ -1759,8 +2209,11 @@
 			goto error;
 		}
 		pos = polylib_pos_to_isl_pos(bmap, j);
-		isl_int_set(cpos, tok->u.v);
+		if (pos >= 0)
+			isl_int_set(cpos, tok->u.v);
 		isl_token_free(tok);
+		if (pos < 0)
+			return isl_basic_map_free(bmap);
 	}
 
 	return bmap;
@@ -1769,7 +2222,8 @@
 	return NULL;
 }
 
-static __isl_give isl_basic_map *basic_map_read_polylib(struct isl_stream *s)
+static __isl_give isl_basic_map *basic_map_read_polylib(
+	__isl_keep isl_stream *s)
 {
 	int i;
 	struct isl_token *tok;
@@ -1885,7 +2339,7 @@
 	return NULL;
 }
 
-static struct isl_map *map_read_polylib(struct isl_stream *s)
+static __isl_give isl_map *map_read_polylib(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok;
 	struct isl_token *tok2;
@@ -1923,7 +2377,7 @@
 	return map;
 }
 
-static int optional_power(struct isl_stream *s)
+static int optional_power(__isl_keep isl_stream *s)
 {
 	int pow;
 	struct isl_token *tok;
@@ -1948,10 +2402,10 @@
 	return pow;
 }
 
-static __isl_give isl_pw_qpolynomial *read_term(struct isl_stream *s,
+static __isl_give isl_pw_qpolynomial *read_term(__isl_keep isl_stream *s,
 	__isl_keep isl_map *map, struct vars *v);
 
-static __isl_give isl_pw_qpolynomial *read_factor(struct isl_stream *s,
+static __isl_give isl_pw_qpolynomial *read_factor(__isl_keep isl_stream *s,
 	__isl_keep isl_map *map, struct vars *v)
 {
 	isl_pw_qpolynomial *pwqp;
@@ -2059,7 +2513,7 @@
 	return NULL;
 }
 
-static __isl_give isl_pw_qpolynomial *read_term(struct isl_stream *s,
+static __isl_give isl_pw_qpolynomial *read_term(__isl_keep isl_stream *s,
 	__isl_keep isl_map *map, struct vars *v)
 {
 	struct isl_token *tok;
@@ -2100,7 +2554,7 @@
 	return pwqp;
 }
 
-static __isl_give isl_map *read_optional_formula(struct isl_stream *s,
+static __isl_give isl_map *read_optional_formula(__isl_keep isl_stream *s,
 	__isl_take isl_map *map, struct vars *v, int rational)
 {
 	struct isl_token *tok;
@@ -2123,7 +2577,7 @@
 	return NULL;
 }
 
-static struct isl_obj obj_read_poly(struct isl_stream *s,
+static struct isl_obj obj_read_poly(__isl_keep isl_stream *s,
 	__isl_take isl_map *map, struct vars *v, int n)
 {
 	struct isl_obj obj = { isl_obj_pw_qpolynomial, NULL };
@@ -2142,27 +2596,31 @@
 	return obj;
 }
 
-static struct isl_obj obj_read_poly_or_fold(struct isl_stream *s,
+static struct isl_obj obj_read_poly_or_fold(__isl_keep isl_stream *s,
 	__isl_take isl_set *set, struct vars *v, int n)
 {
+	int min, max;
 	struct isl_obj obj = { isl_obj_pw_qpolynomial_fold, NULL };
 	isl_pw_qpolynomial *pwqp;
 	isl_pw_qpolynomial_fold *pwf = NULL;
+	enum isl_fold fold;
 
-	if (!isl_stream_eat_if_available(s, ISL_TOKEN_MAX))
+	max = isl_stream_eat_if_available(s, ISL_TOKEN_MAX);
+	min = !max && isl_stream_eat_if_available(s, ISL_TOKEN_MIN);
+	if (!min && !max)
 		return obj_read_poly(s, set, v, n);
+	fold = max ? isl_fold_max : isl_fold_min;
 
 	if (isl_stream_eat(s, '('))
 		goto error;
 
 	pwqp = read_term(s, set, v);
-	pwf = isl_pw_qpolynomial_fold_from_pw_qpolynomial(isl_fold_max, pwqp);
+	pwf = isl_pw_qpolynomial_fold_from_pw_qpolynomial(fold, pwqp);
 
 	while (isl_stream_eat_if_available(s, ',')) {
 		isl_pw_qpolynomial_fold *pwf_i;
 		pwqp = read_term(s, set, v);
-		pwf_i = isl_pw_qpolynomial_fold_from_pw_qpolynomial(isl_fold_max,
-									pwqp);
+		pwf_i = isl_pw_qpolynomial_fold_from_pw_qpolynomial(fold, pwqp);
 		pwf = isl_pw_qpolynomial_fold_fold(pwf, pwf_i);
 	}
 
@@ -2183,7 +2641,7 @@
 	return obj;
 }
 
-static int is_rational(struct isl_stream *s)
+static int is_rational(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok;
 
@@ -2201,7 +2659,7 @@
 	return 0;
 }
 
-static struct isl_obj obj_read_body(struct isl_stream *s,
+static struct isl_obj obj_read_body(__isl_keep isl_stream *s,
 	__isl_take isl_map *map, struct vars *v)
 {
 	struct isl_token *tok;
@@ -2278,47 +2736,56 @@
 	return obj;
 }
 
-static struct isl_obj obj_add(struct isl_ctx *ctx,
+static struct isl_obj obj_add(__isl_keep isl_stream *s,
 	struct isl_obj obj1, struct isl_obj obj2)
 {
+	if (obj2.type == isl_obj_none || !obj2.v)
+		goto error;
 	if (obj1.type == isl_obj_set && obj2.type == isl_obj_union_set)
-		obj1 = to_union(ctx, obj1);
+		obj1 = to_union(s->ctx, obj1);
 	if (obj1.type == isl_obj_union_set && obj2.type == isl_obj_set)
-		obj2 = to_union(ctx, obj2);
+		obj2 = to_union(s->ctx, obj2);
 	if (obj1.type == isl_obj_map && obj2.type == isl_obj_union_map)
-		obj1 = to_union(ctx, obj1);
+		obj1 = to_union(s->ctx, obj1);
 	if (obj1.type == isl_obj_union_map && obj2.type == isl_obj_map)
-		obj2 = to_union(ctx, obj2);
+		obj2 = to_union(s->ctx, obj2);
 	if (obj1.type == isl_obj_pw_qpolynomial &&
 	    obj2.type == isl_obj_union_pw_qpolynomial)
-		obj1 = to_union(ctx, obj1);
+		obj1 = to_union(s->ctx, obj1);
 	if (obj1.type == isl_obj_union_pw_qpolynomial &&
 	    obj2.type == isl_obj_pw_qpolynomial)
-		obj2 = to_union(ctx, obj2);
+		obj2 = to_union(s->ctx, obj2);
 	if (obj1.type == isl_obj_pw_qpolynomial_fold &&
 	    obj2.type == isl_obj_union_pw_qpolynomial_fold)
-		obj1 = to_union(ctx, obj1);
+		obj1 = to_union(s->ctx, obj1);
 	if (obj1.type == isl_obj_union_pw_qpolynomial_fold &&
 	    obj2.type == isl_obj_pw_qpolynomial_fold)
-		obj2 = to_union(ctx, obj2);
-	isl_assert(ctx, obj1.type == obj2.type, goto error);
+		obj2 = to_union(s->ctx, obj2);
+	if (obj1.type != obj2.type) {
+		isl_stream_error(s, NULL,
+				"attempt to combine incompatible objects");
+		goto error;
+	}
+	if (!obj1.type->add)
+		isl_die(s->ctx, isl_error_internal,
+			"combination not supported on object type", goto error);
 	if (obj1.type == isl_obj_map && !isl_map_has_equal_space(obj1.v, obj2.v)) {
-		obj1 = to_union(ctx, obj1);
-		obj2 = to_union(ctx, obj2);
+		obj1 = to_union(s->ctx, obj1);
+		obj2 = to_union(s->ctx, obj2);
 	}
 	if (obj1.type == isl_obj_set && !isl_set_has_equal_space(obj1.v, obj2.v)) {
-		obj1 = to_union(ctx, obj1);
-		obj2 = to_union(ctx, obj2);
+		obj1 = to_union(s->ctx, obj1);
+		obj2 = to_union(s->ctx, obj2);
 	}
 	if (obj1.type == isl_obj_pw_qpolynomial &&
 	    !isl_pw_qpolynomial_has_equal_space(obj1.v, obj2.v)) {
-		obj1 = to_union(ctx, obj1);
-		obj2 = to_union(ctx, obj2);
+		obj1 = to_union(s->ctx, obj1);
+		obj2 = to_union(s->ctx, obj2);
 	}
 	if (obj1.type == isl_obj_pw_qpolynomial_fold &&
 	    !isl_pw_qpolynomial_fold_has_equal_space(obj1.v, obj2.v)) {
-		obj1 = to_union(ctx, obj1);
-		obj2 = to_union(ctx, obj2);
+		obj1 = to_union(s->ctx, obj1);
+		obj2 = to_union(s->ctx, obj2);
 	}
 	obj1.v = obj1.type->add(obj1.v, obj2.v);
 	return obj1;
@@ -2330,13 +2797,114 @@
 	return obj1;
 }
 
-static struct isl_obj obj_read(struct isl_stream *s)
+/* Are the first two tokens on "s", "domain" (either as a string
+ * or as an identifier) followed by ":"?
+ */
+static int next_is_domain_colon(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	char *name;
+	int res;
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return 0;
+	if (tok->type != ISL_TOKEN_IDENT && tok->type != ISL_TOKEN_STRING) {
+		isl_stream_push_token(s, tok);
+		return 0;
+	}
+
+	name = isl_token_get_str(s->ctx, tok);
+	res = !strcmp(name, "domain") && isl_stream_next_token_is(s, ':');
+	free(name);
+
+	isl_stream_push_token(s, tok);
+
+	return res;
+}
+
+/* Do the first tokens on "s" look like a schedule?
+ *
+ * The root of a schedule is always a domain node, so the first thing
+ * we expect in the stream is a domain key, i.e., "domain" followed
+ * by ":".  If the schedule was printed in YAML flow style, then
+ * we additionally expect a "{" to open the outer mapping.
+ */
+static int next_is_schedule(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int is_schedule;
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return 0;
+	if (tok->type != '{') {
+		isl_stream_push_token(s, tok);
+		return next_is_domain_colon(s);
+	}
+
+	is_schedule = next_is_domain_colon(s);
+	isl_stream_push_token(s, tok);
+
+	return is_schedule;
+}
+
+/* Read an isl_schedule from "s" and store it in an isl_obj.
+ */
+static struct isl_obj schedule_read(__isl_keep isl_stream *s)
+{
+	struct isl_obj obj;
+
+	obj.type = isl_obj_schedule;
+	obj.v = isl_stream_read_schedule(s);
+
+	return obj;
+}
+
+/* Read a disjunction of object bodies from "s".
+ * That is, read the inside of the braces, but not the braces themselves.
+ * "v" contains a description of the identifiers parsed so far.
+ * "map" contains information about the parameters.
+ */
+static struct isl_obj obj_read_disjuncts(__isl_keep isl_stream *s,
+	struct vars *v, __isl_keep isl_map *map)
+{
+	struct isl_obj obj = { isl_obj_set, NULL };
+
+	if (isl_stream_next_token_is(s, '}')) {
+		obj.type = isl_obj_union_set;
+		obj.v = isl_union_set_empty(isl_map_get_space(map));
+		return obj;
+	}
+
+	for (;;) {
+		struct isl_obj o;
+		o = obj_read_body(s, isl_map_copy(map), v);
+		if (!obj.v)
+			obj = o;
+		else
+			obj = obj_add(s, obj, o);
+		if (obj.type == isl_obj_none || !obj.v)
+			return obj;
+		if (!isl_stream_eat_if_available(s, ';'))
+			break;
+		if (isl_stream_next_token_is(s, '}'))
+			break;
+	}
+
+	return obj;
+}
+
+static struct isl_obj obj_read(__isl_keep isl_stream *s)
 {
 	isl_map *map = NULL;
 	struct isl_token *tok;
 	struct vars *v = NULL;
 	struct isl_obj obj = { isl_obj_set, NULL };
 
+	if (next_is_schedule(s))
+		return schedule_read(s);
+
 	tok = next_token(s);
 	if (!tok) {
 		isl_stream_error(s, NULL, "unexpected EOF");
@@ -2408,37 +2976,14 @@
 		map = read_map_tuple(s, map, isl_dim_param, v, 0, 1);
 		if (!map)
 			goto error;
-	} else if (tok->type == '}') {
-		obj.type = isl_obj_union_set;
-		obj.v = isl_union_set_empty(isl_map_get_space(map));
-		isl_token_free(tok);
-		goto done;
 	} else
 		isl_stream_push_token(s, tok);
 
-	for (;;) {
-		struct isl_obj o;
-		tok = NULL;
-		o = obj_read_body(s, isl_map_copy(map), v);
-		if (o.type == isl_obj_none || !o.v)
-			goto error;
-		if (!obj.v)
-			obj = o;
-		else {
-			obj = obj_add(s->ctx, obj, o);
-			if (obj.type == isl_obj_none || !obj.v)
-				goto error;
-		}
-		tok = isl_stream_next_token(s);
-		if (!tok || tok->type != ';')
-			break;
-		isl_token_free(tok);
-		if (isl_stream_next_token_is(s, '}')) {
-			tok = isl_stream_next_token(s);
-			break;
-		}
-	}
+	obj = obj_read_disjuncts(s, v, map);
+	if (obj.type == isl_obj_none || !obj.v)
+		goto error;
 
+	tok = isl_stream_next_token(s);
 	if (tok && tok->type == '}') {
 		isl_token_free(tok);
 	} else {
@@ -2447,7 +2992,7 @@
 			isl_token_free(tok);
 		goto error;
 	}
-done:
+
 	vars_free(v);
 	isl_map_free(map);
 
@@ -2461,12 +3006,12 @@
 	return obj;
 }
 
-struct isl_obj isl_stream_read_obj(struct isl_stream *s)
+struct isl_obj isl_stream_read_obj(__isl_keep isl_stream *s)
 {
 	return obj_read(s);
 }
 
-__isl_give isl_map *isl_stream_read_map(struct isl_stream *s)
+__isl_give isl_map *isl_stream_read_map(__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 
@@ -2484,7 +3029,7 @@
 	return NULL;
 }
 
-__isl_give isl_set *isl_stream_read_set(struct isl_stream *s)
+__isl_give isl_set *isl_stream_read_set(__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 
@@ -2503,7 +3048,7 @@
 	return NULL;
 }
 
-__isl_give isl_union_map *isl_stream_read_union_map(struct isl_stream *s)
+__isl_give isl_union_map *isl_stream_read_union_map(__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 
@@ -2528,17 +3073,19 @@
 	return NULL;
 }
 
-__isl_give isl_union_set *isl_stream_read_union_set(struct isl_stream *s)
+/* Extract an isl_union_set from "obj".
+ * This only works if the object was detected as either a set
+ * (in which case it is converted to a union set) or a union set.
+ */
+static __isl_give isl_union_set *extract_union_set(isl_ctx *ctx,
+	struct isl_obj obj)
 {
-	struct isl_obj obj;
-
-	obj = obj_read(s);
 	if (obj.type == isl_obj_set) {
 		obj.type = isl_obj_union_set;
 		obj.v = isl_union_set_from_set(obj.v);
 	}
 	if (obj.v)
-		isl_assert(s->ctx, obj.type == isl_obj_union_set, goto error);
+		isl_assert(ctx, obj.type == isl_obj_union_set, goto error);
 
 	return obj.v;
 error:
@@ -2546,7 +3093,19 @@
 	return NULL;
 }
 
-static __isl_give isl_basic_map *basic_map_read(struct isl_stream *s)
+/* Read an isl_union_set from "s".
+ * First read a generic object and then try and extract
+ * an isl_union_set from that.
+ */
+__isl_give isl_union_set *isl_stream_read_union_set(__isl_keep isl_stream *s)
+{
+	struct isl_obj obj;
+
+	obj = obj_read(s);
+	return extract_union_set(s->ctx, obj);
+}
+
+static __isl_give isl_basic_map *basic_map_read(__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 	struct isl_map *map;
@@ -2566,7 +3125,7 @@
 			"more than one disjunct", goto error);
 
 	if (map->n == 0)
-		bmap = isl_basic_map_empty_like_map(map);
+		bmap = isl_basic_map_empty(isl_map_get_space(map));
 	else
 		bmap = isl_basic_map_copy(map->p0);
 
@@ -2578,7 +3137,7 @@
 	return NULL;
 }
 
-static __isl_give isl_basic_set *basic_set_read(struct isl_stream *s)
+static __isl_give isl_basic_set *basic_set_read(__isl_keep isl_stream *s)
 {
 	isl_basic_map *bmap;
 	bmap = basic_map_read(s);
@@ -2597,7 +3156,7 @@
 	FILE *input)
 {
 	struct isl_basic_map *bmap;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	bmap = basic_map_read(s);
@@ -2609,7 +3168,7 @@
 	FILE *input)
 {
 	isl_basic_set *bset;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	bset = basic_set_read(s);
@@ -2617,11 +3176,11 @@
 	return bset;
 }
 
-struct isl_basic_map *isl_basic_map_read_from_str(struct isl_ctx *ctx,
+__isl_give isl_basic_map *isl_basic_map_read_from_str(isl_ctx *ctx,
 	const char *str)
 {
 	struct isl_basic_map *bmap;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	bmap = basic_map_read(s);
@@ -2629,11 +3188,11 @@
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_read_from_str(struct isl_ctx *ctx,
+__isl_give isl_basic_set *isl_basic_set_read_from_str(isl_ctx *ctx,
 	const char *str)
 {
 	isl_basic_set *bset;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	bset = basic_set_read(s);
@@ -2645,7 +3204,7 @@
 	FILE *input)
 {
 	struct isl_map *map;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	map = isl_stream_read_map(s);
@@ -2657,7 +3216,7 @@
 	const char *str)
 {
 	struct isl_map *map;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	map = isl_stream_read_map(s);
@@ -2669,7 +3228,7 @@
 	FILE *input)
 {
 	isl_set *set;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	set = isl_stream_read_set(s);
@@ -2677,11 +3236,10 @@
 	return set;
 }
 
-struct isl_set *isl_set_read_from_str(struct isl_ctx *ctx,
-	const char *str)
+__isl_give isl_set *isl_set_read_from_str(isl_ctx *ctx, const char *str)
 {
 	isl_set *set;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	set = isl_stream_read_set(s);
@@ -2693,7 +3251,7 @@
 	FILE *input)
 {
 	isl_union_map *umap;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	umap = isl_stream_read_union_map(s);
@@ -2705,7 +3263,7 @@
 		const char *str)
 {
 	isl_union_map *umap;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	umap = isl_stream_read_union_map(s);
@@ -2717,7 +3275,7 @@
 	FILE *input)
 {
 	isl_union_set *uset;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	uset = isl_stream_read_union_set(s);
@@ -2729,7 +3287,7 @@
 		const char *str)
 {
 	isl_union_set *uset;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	uset = isl_stream_read_union_set(s);
@@ -2737,7 +3295,7 @@
 	return uset;
 }
 
-static __isl_give isl_vec *isl_vec_read_polylib(struct isl_stream *s)
+static __isl_give isl_vec *isl_vec_read_polylib(__isl_keep isl_stream *s)
 {
 	struct isl_vec *vec = NULL;
 	struct isl_token *tok;
@@ -2772,7 +3330,7 @@
 	return NULL;
 }
 
-static __isl_give isl_vec *vec_read(struct isl_stream *s)
+static __isl_give isl_vec *vec_read(__isl_keep isl_stream *s)
 {
 	return isl_vec_read_polylib(s);
 }
@@ -2780,7 +3338,7 @@
 __isl_give isl_vec *isl_vec_read_from_file(isl_ctx *ctx, FILE *input)
 {
 	isl_vec *v;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	v = vec_read(s);
@@ -2789,7 +3347,7 @@
 }
 
 __isl_give isl_pw_qpolynomial *isl_stream_read_pw_qpolynomial(
-	struct isl_stream *s)
+	__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 
@@ -2808,7 +3366,7 @@
 		const char *str)
 {
 	isl_pw_qpolynomial *pwqp;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	pwqp = isl_stream_read_pw_qpolynomial(s);
@@ -2820,7 +3378,7 @@
 		FILE *input)
 {
 	isl_pw_qpolynomial *pwqp;
-	struct isl_stream *s = isl_stream_new_file(ctx, input);
+	isl_stream *s = isl_stream_new_file(ctx, input);
 	if (!s)
 		return NULL;
 	pwqp = isl_stream_read_pw_qpolynomial(s);
@@ -2828,9 +3386,45 @@
 	return pwqp;
 }
 
-/* Is the next token an identifer not in "v"?
+/* Read an isl_pw_qpolynomial_fold from "s".
+ * First read a generic object and
+ * then check that it is an isl_pw_qpolynomial_fold.
+ */
+__isl_give isl_pw_qpolynomial_fold *isl_stream_read_pw_qpolynomial_fold(
+	__isl_keep isl_stream *s)
+{
+	struct isl_obj obj;
+
+	obj = obj_read(s);
+	if (obj.v && obj.type != isl_obj_pw_qpolynomial_fold)
+		isl_die(s->ctx, isl_error_invalid, "invalid input", goto error);
+
+	return obj.v;
+error:
+	obj.type->free(obj.v);
+	return NULL;
+}
+
+/* Read an isl_pw_qpolynomial_fold from "str".
+ */
+__isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_read_from_str(
+	isl_ctx *ctx, const char *str)
+{
+	isl_pw_qpolynomial_fold *pwqp;
+	isl_stream *s;
+
+	s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	pwqp = isl_stream_read_pw_qpolynomial_fold(s);
+	isl_stream_free(s);
+
+	return pwqp;
+}
+
+/* Is the next token an identifier not in "v"?
  */
-static int next_is_fresh_ident(struct isl_stream *s, struct vars *v)
+static int next_is_fresh_ident(__isl_keep isl_stream *s, struct vars *v)
 {
 	int n = v->n;
 	int fresh;
@@ -2855,25 +3449,32 @@
  * If the tuple we are reading is named, we assume it's the domain.
  * Also, if inside the tuple, the first thing we find is a nested tuple
  * or a new identifier, we again assume it's the domain.
+ * Finally, if the tuple is empty, then it must be the domain
+ * since it does not contain an affine expression.
  * Otherwise, we assume we are reading an affine expression.
  */
-static __isl_give isl_set *read_aff_domain(struct isl_stream *s,
+static __isl_give isl_set *read_aff_domain(__isl_keep isl_stream *s,
 	__isl_take isl_set *dom, struct vars *v)
 {
-	struct isl_token *tok;
+	struct isl_token *tok, *tok2;
+	int is_empty;
 
 	tok = isl_stream_next_token(s);
 	if (tok && (tok->type == ISL_TOKEN_IDENT || tok->is_keyword)) {
 		isl_stream_push_token(s, tok);
-		return read_map_tuple(s, dom, isl_dim_set, v, 1, 0);
+		return read_map_tuple(s, dom, isl_dim_set, v, 0, 0);
 	}
 	if (!tok || tok->type != '') {
 		isl_stream_error(s, tok, "expecting ''");
 		goto error;
 	}
-	if (next_is_tuple(s) || next_is_fresh_ident(s, v)) {
+	tok2 = isl_stream_next_token(s);
+	is_empty = tok2 && tok2->type == '';
+	if (tok2)
+		isl_stream_push_token(s, tok2);
+	if (is_empty || next_is_tuple(s) || next_is_fresh_ident(s, v)) {
 		isl_stream_push_token(s, tok);
-		dom = read_map_tuple(s, dom, isl_dim_set, v, 1, 0);
+		dom = read_map_tuple(s, dom, isl_dim_set, v, 0, 0);
 	} else
 		isl_stream_push_token(s, tok);
 
@@ -2887,15 +3488,17 @@
 
 /* Read an affine expression from "s".
  */
-__isl_give isl_aff *isl_stream_read_aff(struct isl_stream *s)
+__isl_give isl_aff *isl_stream_read_aff(__isl_keep isl_stream *s)
 {
 	isl_aff *aff;
 	isl_multi_aff *ma;
+	isl_size dim;
 
 	ma = isl_stream_read_multi_aff(s);
-	if (!ma)
-		return NULL;
-	if (isl_multi_aff_dim(ma, isl_dim_out) != 1)
+	dim = isl_multi_aff_dim(ma, isl_dim_out);
+	if (dim < 0)
+		goto error;
+	if (dim != 1)
 		isl_die(s->ctx, isl_error_invalid,
 			"expecting single affine expression",
 			goto error);
@@ -2910,7 +3513,7 @@
 
 /* Read a piecewise affine expression from "s" with domain (space) "dom".
  */
-static __isl_give isl_pw_aff *read_pw_aff_with_dom(struct isl_stream *s,
+static __isl_give isl_pw_aff *read_pw_aff_with_dom(__isl_keep isl_stream *s,
 	__isl_take isl_set *dom, struct vars *v)
 {
 	isl_pw_aff *pwaff = NULL;
@@ -2936,7 +3539,7 @@
 	return NULL;
 }
 
-__isl_give isl_pw_aff *isl_stream_read_pw_aff(struct isl_stream *s)
+__isl_give isl_pw_aff *isl_stream_read_pw_aff(__isl_keep isl_stream *s)
 {
 	struct vars *v;
 	isl_set *dom = NULL;
@@ -2989,7 +3592,7 @@
 __isl_give isl_aff *isl_aff_read_from_str(isl_ctx *ctx, const char *str)
 {
 	isl_aff *aff;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	aff = isl_stream_read_aff(s);
@@ -3000,7 +3603,7 @@
 __isl_give isl_pw_aff *isl_pw_aff_read_from_str(isl_ctx *ctx, const char *str)
 {
 	isl_pw_aff *pa;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	pa = isl_stream_read_pw_aff(s);
@@ -3008,67 +3611,198 @@
 	return pa;
 }
 
-/* Read an isl_pw_multi_aff from "s".
- * We currently read a generic object and if it turns out to be a set or
- * a map, we convert that to an isl_pw_multi_aff.
- * It would be more efficient if we were to construct the isl_pw_multi_aff
- * directly.
+/* Extract an isl_multi_pw_aff with domain space "dom_space"
+ * from a tuple "tuple" read by read_tuple.
+ *
+ * Note that the function read_tuple accepts tuples where some output or
+ * set dimensions are defined in terms of other output or set dimensions
+ * since this function is also used to read maps.  As a special case,
+ * read_tuple also accept dimensions that are defined in terms of themselves
+ * (i.e., that are not defined).
+ * These cases are not allowed when extracting an isl_multi_pw_aff so check
+ * that the definitions of the output/set dimensions do not involve any
+ * output/set dimensions.
+ * Finally, drop the output dimensions from the domain of the result
+ * of read_tuple (which is of the form input, output -> output,
+ * with anonymous domain) and reset the space.
  */
-__isl_give isl_pw_multi_aff *isl_stream_read_pw_multi_aff(struct isl_stream *s)
+static __isl_give isl_multi_pw_aff *extract_mpa_from_tuple(
+	__isl_take isl_space *dom_space, __isl_keep isl_multi_pw_aff *tuple)
 {
-	struct isl_obj obj;
+	int i;
+	isl_size dim, n;
+	isl_space *space;
+	isl_multi_pw_aff *mpa;
 
-	obj = obj_read(s);
-	if (!obj.v)
-		return NULL;
+	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
+	dim = isl_space_dim(dom_space, isl_dim_all);
+	if (n < 0 || dim < 0)
+		dom_space = isl_space_free(dom_space);
+	space = isl_space_range(isl_multi_pw_aff_get_space(tuple));
+	space = isl_space_align_params(space, isl_space_copy(dom_space));
+	if (!isl_space_is_params(dom_space))
+		space = isl_space_map_from_domain_and_range(
+				isl_space_copy(dom_space), space);
+	isl_space_free(dom_space);
+	mpa = isl_multi_pw_aff_alloc(space);
 
-	if (obj.type == isl_obj_map)
-		return isl_pw_multi_aff_from_map(obj.v);
-	if (obj.type == isl_obj_set)
-		return isl_pw_multi_aff_from_set(obj.v);
+	for (i = 0; i < n; ++i) {
+		isl_pw_aff *pa;
+		pa = isl_multi_pw_aff_get_pw_aff(tuple, i);
+		if (!pa)
+			return isl_multi_pw_aff_free(mpa);
+		if (isl_pw_aff_involves_dims(pa, isl_dim_in, dim, i + 1)) {
+			isl_ctx *ctx = isl_pw_aff_get_ctx(pa);
+			isl_pw_aff_free(pa);
+			isl_die(ctx, isl_error_invalid,
+				"not an affine expression",
+				return isl_multi_pw_aff_free(mpa));
+		}
+		pa = isl_pw_aff_drop_dims(pa, isl_dim_in, dim, n);
+		space = isl_multi_pw_aff_get_domain_space(mpa);
+		pa = isl_pw_aff_reset_domain_space(pa, space);
+		mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
+	}
 
-	obj.type->free(obj.v);
-	isl_die(s->ctx, isl_error_invalid, "unexpected object type",
-		return NULL);
+	return mpa;
 }
 
-__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(isl_ctx *ctx,
-	const char *str)
+/* Read a tuple of affine expressions, together with optional constraints
+ * on the domain from "s".  "dom" represents the initial constraints
+ * on the domain.
+ *
+ * The isl_multi_aff may live in either a set or a map space.
+ * First read the first tuple and check if it is followed by a "->".
+ * If so, convert the tuple into the domain of the isl_multi_pw_aff and
+ * read in the next tuple.  This tuple (or the first tuple if it was
+ * not followed by a "->") is then converted into an isl_multi_pw_aff
+ * through a call to extract_mpa_from_tuple.
+ * The result is converted to an isl_pw_multi_aff and
+ * its domain is intersected with the domain.
+ */
+static __isl_give isl_pw_multi_aff *read_conditional_multi_aff(
+	__isl_keep isl_stream *s, __isl_take isl_set *dom, struct vars *v)
 {
+	isl_multi_pw_aff *tuple;
+	isl_multi_pw_aff *mpa;
 	isl_pw_multi_aff *pma;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
-	if (!s)
-		return NULL;
-	pma = isl_stream_read_pw_multi_aff(s);
-	isl_stream_free(s);
+	int n = v->n;
+
+	tuple = read_tuple(s, v, 0, 0);
+	if (!tuple)
+		goto error;
+	if (isl_stream_eat_if_available(s, ISL_TOKEN_TO)) {
+		isl_map *map = map_from_tuple(tuple, dom, isl_dim_in, v, 0);
+		dom = isl_map_domain(map);
+		tuple = read_tuple(s, v, 0, 0);
+		if (!tuple)
+			goto error;
+	}
+	mpa = extract_mpa_from_tuple(isl_set_get_space(dom), tuple);
+	isl_multi_pw_aff_free(tuple);
+	if (!mpa)
+		dom = isl_set_free(dom);
+
+	dom = read_optional_formula(s, dom, v, 0);
+
+	vars_drop(v, v->n - n);
+
+	pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
+	pma = isl_pw_multi_aff_intersect_domain(pma, dom);
+
 	return pma;
+error:
+	isl_set_free(dom);
+	return NULL;
 }
 
 /* Read an isl_union_pw_multi_aff from "s".
- * We currently read a generic object and if it turns out to be a set or
- * a map, we convert that to an isl_union_pw_multi_aff.
- * It would be more efficient if we were to construct
- * the isl_union_pw_multi_aff directly.
+ *
+ * In particular, first read the parameters and then read a sequence
+ * of zero or more tuples of affine expressions with optional conditions and
+ * add them up.
  */
 __isl_give isl_union_pw_multi_aff *isl_stream_read_union_pw_multi_aff(
-	struct isl_stream *s)
+	__isl_keep isl_stream *s)
 {
-	struct isl_obj obj;
+	struct vars *v;
+	isl_set *dom;
+	isl_union_pw_multi_aff *upma = NULL;
 
-	obj = obj_read(s);
-	if (!obj.v)
+	v = vars_new(s->ctx);
+	if (!v)
 		return NULL;
 
-	if (obj.type == isl_obj_map || obj.type == isl_obj_set)
-		obj = to_union(s->ctx, obj);
-	if (obj.type == isl_obj_union_map)
-		return isl_union_pw_multi_aff_from_union_map(obj.v);
-	if (obj.type == isl_obj_union_set)
-		return isl_union_pw_multi_aff_from_union_set(obj.v);
+	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
+	if (next_is_tuple(s)) {
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
+		if (isl_stream_eat(s, ISL_TOKEN_TO))
+			goto error;
+	}
+	if (isl_stream_eat(s, '{'))
+		goto error;
 
-	obj.type->free(obj.v);
-	isl_die(s->ctx, isl_error_invalid, "unexpected object type",
-		return NULL);
+	upma = isl_union_pw_multi_aff_empty(isl_set_get_space(dom));
+
+	do {
+		isl_pw_multi_aff *pma;
+		isl_union_pw_multi_aff *upma2;
+
+		if (isl_stream_next_token_is(s, '}'))
+			break;
+
+		pma = read_conditional_multi_aff(s, isl_set_copy(dom), v);
+		upma2 = isl_union_pw_multi_aff_from_pw_multi_aff(pma);
+		upma = isl_union_pw_multi_aff_union_add(upma, upma2);
+		if (!upma)
+			goto error;
+	} while (isl_stream_eat_if_available(s, ';'));
+
+	if (isl_stream_eat(s, '}'))
+		goto error;
+
+	isl_set_free(dom);
+	vars_free(v);
+	return upma;
+error:
+	isl_union_pw_multi_aff_free(upma);
+	isl_set_free(dom);
+	vars_free(v);
+	return NULL;
+}
+
+/* Read an isl_pw_multi_aff from "s".
+ *
+ * Read a more generic isl_union_pw_multi_aff first and
+ * then check that the result lives in a single space.
+ */
+__isl_give isl_pw_multi_aff *isl_stream_read_pw_multi_aff(
+	__isl_keep isl_stream *s)
+{
+	isl_bool single_space;
+	isl_union_pw_multi_aff *upma;
+
+	upma = isl_stream_read_union_pw_multi_aff(s);
+	single_space = isl_union_pw_multi_aff_isa_pw_multi_aff(upma);
+	if (single_space < 0)
+		upma = isl_union_pw_multi_aff_free(upma);
+	else if (!single_space)
+		isl_die(s->ctx, isl_error_invalid,
+			"expecting expression in single space",
+			upma = isl_union_pw_multi_aff_free(upma));
+	return isl_union_pw_multi_aff_as_pw_multi_aff(upma);
+}
+
+__isl_give isl_pw_multi_aff *isl_pw_multi_aff_read_from_str(isl_ctx *ctx,
+	const char *str)
+{
+	isl_pw_multi_aff *pma;
+	isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	pma = isl_stream_read_pw_multi_aff(s);
+	isl_stream_free(s);
+	return pma;
 }
 
 /* Read an isl_union_pw_multi_aff from "str".
@@ -3077,7 +3811,7 @@
 	isl_ctx *ctx, const char *str)
 {
 	isl_union_pw_multi_aff *upma;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	upma = isl_stream_read_union_pw_multi_aff(s);
@@ -3111,6 +3845,16 @@
 	return NULL;
 }
 
+#undef BASE
+#define BASE val
+
+#include <isl_multi_read_no_explicit_domain_templ.c>
+
+#undef BASE
+#define BASE id
+
+#include <isl_multi_read_no_explicit_domain_templ.c>
+
 /* Read a multi-affine expression from "s".
  * If the multi-affine expression has a domain, then the tuple
  * representing this domain cannot involve any affine expressions.
@@ -3119,12 +3863,13 @@
  * only depend on parameters and input dimensions and not on other
  * output dimensions.
  */
-__isl_give isl_multi_aff *isl_stream_read_multi_aff(struct isl_stream *s)
+__isl_give isl_multi_aff *isl_stream_read_multi_aff(__isl_keep isl_stream *s)
 {
 	struct vars *v;
 	isl_set *dom = NULL;
 	isl_multi_pw_aff *tuple = NULL;
-	int dim, i, n;
+	int i;
+	isl_size dim, n;
 	isl_space *space, *dom_space;
 	isl_multi_aff *ma = NULL;
 
@@ -3150,7 +3895,7 @@
 	if (isl_stream_eat_if_available(s, ISL_TOKEN_TO)) {
 		isl_set *set;
 		isl_space *space;
-		int has_expr;
+		isl_bool has_expr;
 
 		has_expr = tuple_has_expr(tuple);
 		if (has_expr < 0)
@@ -3172,6 +3917,8 @@
 
 	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
 	dim = isl_set_dim(dom, isl_dim_all);
+	if (n < 0 || dim < 0)
+		goto error;
 	dom_space = isl_set_get_space(dom);
 	space = isl_space_range(isl_multi_pw_aff_get_space(tuple));
 	space = isl_space_align_params(space, isl_space_copy(dom_space));
@@ -3215,7 +3962,7 @@
 	const char *str)
 {
 	isl_multi_aff *maff;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	maff = isl_stream_read_multi_aff(s);
@@ -3228,33 +3975,25 @@
  * The input format is similar to that of map, except that any conditions
  * on the domains should be specified inside the tuple since each
  * piecewise affine expression may have a different domain.
+ * However, additional, shared conditions can also be specified.
+ * This is especially useful for setting the explicit domain
+ * of a zero-dimensional isl_multi_pw_aff.
  *
  * Since we do not know in advance if the isl_multi_pw_aff lives
  * in a set or a map space, we first read the first tuple and check
  * if it is followed by a "->".  If so, we convert the tuple into
  * the domain of the isl_multi_pw_aff and read in the next tuple.
  * This tuple (or the first tuple if it was not followed by a "->")
- * is then converted into the isl_multi_pw_aff.
- *
- * Note that the function read_tuple accepts tuples where some output or
- * set dimensions are defined in terms of other output or set dimensions
- * since this function is also used to read maps.  As a special case,
- * read_tuple also accept dimensions that are defined in terms of themselves
- * (i.e., that are not defined).
- * These cases are not allowed when reading am isl_multi_pw_aff so we check
- * that the definition of the output/set dimensions does not involve any
- * output/set dimensions.
- * We then drop the output dimensions from the domain of the result
- * of read_tuple (which is of the form input, output -> output,
- * with anonymous domain) and reset the space.
+ * is then converted into the isl_multi_pw_aff through a call
+ * to extract_mpa_from_tuple and the domain of the result
+ * is intersected with the domain.
  */
-__isl_give isl_multi_pw_aff *isl_stream_read_multi_pw_aff(struct isl_stream *s)
+__isl_give isl_multi_pw_aff *isl_stream_read_multi_pw_aff(
+	__isl_keep isl_stream *s)
 {
 	struct vars *v;
 	isl_set *dom = NULL;
 	isl_multi_pw_aff *tuple = NULL;
-	int dim, i, n;
-	isl_space *space, *dom_space;
 	isl_multi_pw_aff *mpa = NULL;
 
 	v = vars_new(s->ctx);
@@ -3281,35 +4020,13 @@
 			goto error;
 	}
 
+	if (isl_stream_eat_if_available(s, ':'))
+		dom = read_formula(s, v, dom, 0);
+
 	if (isl_stream_eat(s, '}'))
 		goto error;
 
-	n = isl_multi_pw_aff_dim(tuple, isl_dim_out);
-	dim = isl_set_dim(dom, isl_dim_all);
-	dom_space = isl_set_get_space(dom);
-	space = isl_space_range(isl_multi_pw_aff_get_space(tuple));
-	space = isl_space_align_params(space, isl_space_copy(dom_space));
-	if (!isl_space_is_params(dom_space))
-		space = isl_space_map_from_domain_and_range(
-				isl_space_copy(dom_space), space);
-	isl_space_free(dom_space);
-	mpa = isl_multi_pw_aff_alloc(space);
-
-	for (i = 0; i < n; ++i) {
-		isl_pw_aff *pa;
-		pa = isl_multi_pw_aff_get_pw_aff(tuple, i);
-		if (!pa)
-			goto error;
-		if (isl_pw_aff_involves_dims(pa, isl_dim_in, dim, i + 1)) {
-			isl_pw_aff_free(pa);
-			isl_die(s->ctx, isl_error_invalid,
-				"not an affine expression", goto error);
-		}
-		pa = isl_pw_aff_drop_dims(pa, isl_dim_in, dim, n);
-		space = isl_multi_pw_aff_get_domain_space(mpa);
-		pa = isl_pw_aff_reset_domain_space(pa, space);
-		mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
-	}
+	mpa = extract_mpa_from_tuple(isl_set_get_space(dom), tuple);
 
 	isl_multi_pw_aff_free(tuple);
 	vars_free(v);
@@ -3329,7 +4046,7 @@
 	const char *str)
 {
 	isl_multi_pw_aff *mpa;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	mpa = isl_stream_read_multi_pw_aff(s);
@@ -3337,8 +4054,396 @@
 	return mpa;
 }
 
+/* Read the body of an isl_union_pw_aff from "s" with parameter domain "dom".
+ */
+static __isl_give isl_union_pw_aff *read_union_pw_aff_with_dom(
+	__isl_keep isl_stream *s, __isl_take isl_set *dom, struct vars *v)
+{
+	isl_pw_aff *pa;
+	isl_union_pw_aff *upa = NULL;
+	isl_set *aff_dom;
+	int n;
+
+	n = v->n;
+	aff_dom = read_aff_domain(s, isl_set_copy(dom), v);
+	pa = read_pw_aff_with_dom(s, aff_dom, v);
+	vars_drop(v, v->n - n);
+
+	upa = isl_union_pw_aff_from_pw_aff(pa);
+
+	while (isl_stream_eat_if_available(s, ';')) {
+		isl_pw_aff *pa_i;
+		isl_union_pw_aff *upa_i;
+
+		n = v->n;
+		aff_dom = read_aff_domain(s, isl_set_copy(dom), v);
+		pa_i = read_pw_aff_with_dom(s, aff_dom, v);
+		vars_drop(v, v->n - n);
+
+		upa_i = isl_union_pw_aff_from_pw_aff(pa_i);
+		upa = isl_union_pw_aff_union_add(upa, upa_i);
+	}
+
+	isl_set_free(dom);
+	return upa;
+}
+
+/* Read an isl_union_pw_aff from "s".
+ *
+ * First check if there are any paramters, then read in the opening brace
+ * and use read_union_pw_aff_with_dom to read in the body of
+ * the isl_union_pw_aff.  Finally, read the closing brace.
+ */
+__isl_give isl_union_pw_aff *isl_stream_read_union_pw_aff(
+	__isl_keep isl_stream *s)
+{
+	struct vars *v;
+	isl_set *dom;
+	isl_union_pw_aff *upa = NULL;
+
+	v = vars_new(s->ctx);
+	if (!v)
+		return NULL;
+
+	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
+	if (next_is_tuple(s)) {
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
+		if (isl_stream_eat(s, ISL_TOKEN_TO))
+			goto error;
+	}
+	if (isl_stream_eat(s, '{'))
+		goto error;
+
+	upa = read_union_pw_aff_with_dom(s, isl_set_copy(dom), v);
+
+	if (isl_stream_eat(s, '}'))
+		goto error;
+
+	vars_free(v);
+	isl_set_free(dom);
+	return upa;
+error:
+	vars_free(v);
+	isl_set_free(dom);
+	isl_union_pw_aff_free(upa);
+	return NULL;
+}
+
+/* Read an isl_union_pw_aff from "str".
+ */
+__isl_give isl_union_pw_aff *isl_union_pw_aff_read_from_str(isl_ctx *ctx,
+	const char *str)
+{
+	isl_union_pw_aff *upa;
+	isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	upa = isl_stream_read_union_pw_aff(s);
+	isl_stream_free(s);
+	return upa;
+}
+
+/* This function is called for each element in a tuple inside
+ * isl_stream_read_multi_union_pw_aff.
+ *
+ * Read a '{', the union piecewise affine expression body and a '}' and
+ * add the isl_union_pw_aff to *list.
+ */
+static __isl_give isl_space *read_union_pw_aff_el(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space, int rational, void *user)
+{
+	isl_set *dom;
+	isl_union_pw_aff *upa;
+	isl_union_pw_aff_list **list = (isl_union_pw_aff_list **) user;
+
+	dom = isl_set_universe(isl_space_params(isl_space_copy(space)));
+	if (isl_stream_eat(s, '{'))
+		goto error;
+	upa = read_union_pw_aff_with_dom(s, dom, v);
+	*list = isl_union_pw_aff_list_add(*list, upa);
+	if (isl_stream_eat(s, '}'))
+		return isl_space_free(space);
+	if (!*list)
+		return isl_space_free(space);
+	return space;
+error:
+	isl_set_free(dom);
+	return isl_space_free(space);
+}
+
+/* Do the next tokens in "s" correspond to an empty tuple?
+ * In particular, does the stream start with a '', followed by a '',
+ * not followed by a "->"?
+ */
+static int next_is_empty_tuple(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok, *tok2, *tok3;
+	int is_empty_tuple = 0;
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return 0;
+	if (tok->type != '') {
+		isl_stream_push_token(s, tok);
+		return 0;
+	}
+
+	tok2 = isl_stream_next_token(s);
+	if (tok2 && tok2->type == '') {
+		tok3 = isl_stream_next_token(s);
+		is_empty_tuple = !tok || tok->type != ISL_TOKEN_TO;
+		if (tok3)
+			isl_stream_push_token(s, tok3);
+	}
+	if (tok2)
+		isl_stream_push_token(s, tok2);
+	isl_stream_push_token(s, tok);
+
+	return is_empty_tuple;
+}
+
+/* Do the next tokens in "s" correspond to a tuple of parameters?
+ * In particular, does the stream start with a '' that is not
+ * followed by a '{' or a nested tuple?
+ */
+static int next_is_param_tuple(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok, *tok2;
+	int is_tuple;
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return 0;
+	if (tok->type != '' || next_is_tuple(s)) {
+		isl_stream_push_token(s, tok);
+		return 0;
+	}
+
+	tok2 = isl_stream_next_token(s);
+	is_tuple = tok2 && tok2->type != '{';
+	if (tok2)
+		isl_stream_push_token(s, tok2);
+	isl_stream_push_token(s, tok);
+
+	return is_tuple;
+}
+
+/* Read the core of a body of an isl_multi_union_pw_aff from "s",
+ * i.e., everything except the parameter specification and
+ * without shared domain constraints.
+ * "v" contains a description of the identifiers parsed so far.
+ * The parameters, if any, are specified by "space".
+ *
+ * The body is of the form
+ *
+ *	{ .. : ... ; .. : ... }, { .. : ... ; .. : ... }
+ *
+ * Read the tuple, collecting the individual isl_union_pw_aff
+ * elements in a list and construct the result from the tuple space and
+ * the list.
+ */
+static __isl_give isl_multi_union_pw_aff *read_multi_union_pw_aff_body_core(
+	__isl_keep isl_stream *s, struct vars *v, __isl_take isl_space *space)
+{
+	isl_union_pw_aff_list *list;
+	isl_multi_union_pw_aff *mupa;
+
+	list = isl_union_pw_aff_list_alloc(s->ctx, 0);
+	space = read_tuple_space(s, v, space, 1, 0,
+				&read_union_pw_aff_el, &list);
+	mupa = isl_multi_union_pw_aff_from_union_pw_aff_list(space, list);
+
+	return mupa;
+}
+
+/* Read the body of an isl_union_set from "s",
+ * i.e., everything except the parameter specification.
+ * "v" contains a description of the identifiers parsed so far.
+ * The parameters, if any, are specified by "space".
+ *
+ * First read a generic disjunction of object bodies and then try and extract
+ * an isl_union_set from that.
+ */
+static __isl_give isl_union_set *read_union_set_body(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space)
+{
+	struct isl_obj obj = { isl_obj_set, NULL };
+	isl_map *map;
+
+	map = isl_set_universe(space);
+	if (isl_stream_eat(s, '{') < 0)
+		goto error;
+	obj = obj_read_disjuncts(s, v, map);
+	if (isl_stream_eat(s, '}') < 0)
+		goto error;
+	isl_map_free(map);
+
+	return extract_union_set(s->ctx, obj);
+error:
+	obj.type->free(obj.v);
+	isl_map_free(map);
+	return NULL;
+}
+
+/* Read the body of an isl_multi_union_pw_aff from "s",
+ * i.e., everything except the parameter specification.
+ * "v" contains a description of the identifiers parsed so far.
+ * The parameters, if any, are specified by "space".
+ *
+ * In particular, handle the special case with shared domain constraints.
+ * These are specified as
+ *
+ *	(... : ...)
+ *
+ * and are especially useful for setting the explicit domain
+ * of a zero-dimensional isl_multi_union_pw_aff.
+ * The core isl_multi_union_pw_aff body (...) is read by
+ * read_multi_union_pw_aff_body_core.
+ */
+static __isl_give isl_multi_union_pw_aff *read_multi_union_pw_aff_body(
+	__isl_keep isl_stream *s, struct vars *v, __isl_take isl_space *space)
+{
+	isl_multi_union_pw_aff *mupa;
+
+	if (!isl_stream_next_token_is(s, '('))
+		return read_multi_union_pw_aff_body_core(s, v, space);
+
+	if (isl_stream_eat(s, '(') < 0)
+		goto error;
+	mupa = read_multi_union_pw_aff_body_core(s, v, isl_space_copy(space));
+	if (isl_stream_eat_if_available(s, ':')) {
+		isl_union_set *dom;
+
+		dom = read_union_set_body(s, v, space);
+		mupa = isl_multi_union_pw_aff_intersect_domain(mupa, dom);
+	} else {
+		isl_space_free(space);
+	}
+	if (isl_stream_eat(s, ')') < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+
+	return mupa;
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Read an isl_multi_union_pw_aff from "s".
+ *
+ * The input has the form
+ *
+ *	{ .. : ... ; .. : ... }, { .. : ... ; .. : ... }
+ *
+ * or
+ *
+ *	.. -> { .. : ... ; .. : ... }, { .. : ... ; .. : ... }
+ *
+ * Additionally, a shared domain may be specified as
+ *
+ *	(.. : ...)
+ *
+ * or
+ *
+ *	.. -> (.. : ...)
+ *
+ * The first case is handled by the caller, the second case
+ * is handled by read_multi_union_pw_aff_body.
+ *
+ * We first check for the special case of an empty tuple "".
+ * Then we check if there are any parameters.
+ * Finally, read the tuple and construct the result.
+ */
+static __isl_give isl_multi_union_pw_aff *read_multi_union_pw_aff_core(
+	__isl_keep isl_stream *s)
+{
+	struct vars *v;
+	isl_set *dom = NULL;
+	isl_space *space;
+	isl_multi_union_pw_aff *mupa = NULL;
+
+	if (next_is_empty_tuple(s)) {
+		if (isl_stream_eat(s, ''))
+			return NULL;
+		if (isl_stream_eat(s, ''))
+			return NULL;
+		space = isl_space_set_alloc(s->ctx, 0, 0);
+		return isl_multi_union_pw_aff_zero(space);
+	}
+
+	v = vars_new(s->ctx);
+	if (!v)
+		return NULL;
+
+	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
+	if (next_is_param_tuple(s)) {
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
+		if (isl_stream_eat(s, ISL_TOKEN_TO))
+			goto error;
+	}
+	space = isl_set_get_space(dom);
+	isl_set_free(dom);
+	mupa = read_multi_union_pw_aff_body(s, v, space);
+
+	vars_free(v);
+
+	return mupa;
+error:
+	vars_free(v);
+	isl_set_free(dom);
+	isl_multi_union_pw_aff_free(mupa);
+	return NULL;
+}
+
+/* Read an isl_multi_union_pw_aff from "s".
+ *
+ * In particular, handle the special case with shared domain constraints.
+ * These are specified as
+ *
+ *	(... : ...)
+ *
+ * and are especially useful for setting the explicit domain
+ * of a zero-dimensional isl_multi_union_pw_aff.
+ * The core isl_multi_union_pw_aff (...) is read by
+ * read_multi_union_pw_aff_core.
+ */
+__isl_give isl_multi_union_pw_aff *isl_stream_read_multi_union_pw_aff(
+	__isl_keep isl_stream *s)
+{
+	isl_multi_union_pw_aff *mupa;
+
+	if (!isl_stream_next_token_is(s, '('))
+		return read_multi_union_pw_aff_core(s);
+
+	if (isl_stream_eat(s, '(') < 0)
+		return NULL;
+	mupa = read_multi_union_pw_aff_core(s);
+	if (isl_stream_eat_if_available(s, ':')) {
+		isl_union_set *dom;
+
+		dom = isl_stream_read_union_set(s);
+		mupa = isl_multi_union_pw_aff_intersect_domain(mupa, dom);
+	}
+	if (isl_stream_eat(s, ')') < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+	return mupa;
+}
+
+/* Read an isl_multi_union_pw_aff from "str".
+ */
+__isl_give isl_multi_union_pw_aff *isl_multi_union_pw_aff_read_from_str(
+	isl_ctx *ctx, const char *str)
+{
+	isl_multi_union_pw_aff *mupa;
+	isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	mupa = isl_stream_read_multi_union_pw_aff(s);
+	isl_stream_free(s);
+	return mupa;
+}
+
 __isl_give isl_union_pw_qpolynomial *isl_stream_read_union_pw_qpolynomial(
-	struct isl_stream *s)
+	__isl_keep isl_stream *s)
 {
 	struct isl_obj obj;
 
@@ -3361,7 +4466,7 @@
 	isl_ctx *ctx, const char *str)
 {
 	isl_union_pw_qpolynomial *upwqp;
-	struct isl_stream *s = isl_stream_new_str(ctx, str);
+	isl_stream *s = isl_stream_new_str(ctx, str);
 	if (!s)
 		return NULL;
 	upwqp = isl_stream_read_union_pw_qpolynomial(s);

_service:tar_scm:isl-0.24.tar.gz/isl_insert_domain_templ.c Added

@@ -0,0 +1,39 @@
+/*
+ * Copyright 2019      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+/* Given a function defined over a parameter domain,
+ * convert it to a function defined over a domain corresponding
+ * to "domain".
+ */
+__isl_give TYPE *FN(TYPE,insert_domain)(__isl_take TYPE *obj,
+	__isl_take isl_space *domain)
+{
+	isl_size dim;
+	isl_space *obj_space;
+
+	obj_space = FN(TYPE,peek_space)(obj);
+	if (isl_space_check_is_set(domain) < 0 ||
+	    isl_space_check_is_set(obj_space) < 0)
+		goto error;
+	dim = isl_space_dim(domain, isl_dim_set);
+	if (dim < 0)
+		goto error;
+
+	domain = isl_space_replace_params(domain, obj_space);
+
+	obj = FN(TYPE,from_range)(obj);
+	obj = FN(TYPE,add_dims)(obj, isl_dim_in, dim);
+	obj = FN(TYPE,reset_domain_space)(obj, domain);
+
+	return obj;
+error:
+	isl_space_free(domain);
+	FN(TYPE,free)(obj);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_int.h -> _service:tar_scm:isl-0.24.tar.gz/isl_int.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_int_gmp.h -> _service:tar_scm:isl-0.24.tar.gz/isl_int_gmp.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_int_imath.h -> _service:tar_scm:isl-0.24.tar.gz/isl_int_imath.h Changed

_service:tar_scm:isl-0.24.tar.gz/isl_int_sioimath.c Added

@@ -0,0 +1,223 @@
+#include <stdlib.h>
+#include <string.h>
+
+#include <isl_int.h>
+
+extern int isl_sioimath_decode(isl_sioimath val, int32_t *small, mp_int *big);
+extern int isl_sioimath_decode_big(isl_sioimath val, mp_int *big);
+extern int isl_sioimath_decode_small(isl_sioimath val, int32_t *small);
+
+extern isl_sioimath isl_sioimath_encode_small(int32_t val);
+extern isl_sioimath isl_sioimath_encode_big(mp_int val);
+extern int isl_sioimath_is_small(isl_sioimath val);
+extern int isl_sioimath_is_big(isl_sioimath val);
+extern int32_t isl_sioimath_get_small(isl_sioimath val);
+extern mp_int isl_sioimath_get_big(isl_sioimath val);
+
+extern void isl_siomath_uint32_to_digits(uint32_t num, mp_digit *digits,
+	mp_size *used);
+extern void isl_siomath_ulong_to_digits(unsigned long num, mp_digit *digits,
+	mp_size *used);
+extern void isl_siomath_uint64_to_digits(uint64_t num, mp_digit *digits,
+	mp_size *used);
+
+extern mp_int isl_sioimath_bigarg_src(isl_sioimath arg,
+	isl_sioimath_scratchspace_t *scratch);
+extern mp_int isl_sioimath_siarg_src(signed long arg,
+	isl_sioimath_scratchspace_t *scratch);
+extern mp_int isl_sioimath_si64arg_src(int64_t arg,
+	isl_sioimath_scratchspace_t *scratch);
+extern mp_int isl_sioimath_uiarg_src(unsigned long arg,
+	isl_sioimath_scratchspace_t *scratch);
+extern mp_int isl_sioimath_reinit_big(isl_sioimath_ptr ptr);
+extern void isl_sioimath_set_small(isl_sioimath_ptr ptr, int32_t val);
+extern void isl_sioimath_set_int32(isl_sioimath_ptr ptr, int32_t val);
+extern void isl_sioimath_set_int64(isl_sioimath_ptr ptr, int64_t val);
+extern void isl_sioimath_promote(isl_sioimath_ptr dst);
+extern void isl_sioimath_try_demote(isl_sioimath_ptr dst);
+
+extern void isl_sioimath_init(isl_sioimath_ptr dst);
+extern void isl_sioimath_clear(isl_sioimath_ptr dst);
+extern void isl_sioimath_set(isl_sioimath_ptr dst, isl_sioimath_src val);
+extern void isl_sioimath_set_si(isl_sioimath_ptr dst, long val);
+extern void isl_sioimath_set_ui(isl_sioimath_ptr dst, unsigned long val);
+extern int isl_sioimath_fits_slong(isl_sioimath_src val);
+extern long isl_sioimath_get_si(isl_sioimath_src val);
+extern int isl_sioimath_fits_ulong(isl_sioimath_src val);
+extern unsigned long isl_sioimath_get_ui(isl_sioimath_src val);
+extern double isl_sioimath_get_d(isl_sioimath_src val);
+extern char *isl_sioimath_get_str(isl_sioimath_src val);
+extern void isl_sioimath_abs(isl_sioimath_ptr dst, isl_sioimath_src arg);
+extern void isl_sioimath_neg(isl_sioimath_ptr dst, isl_sioimath_src arg);
+extern void isl_sioimath_swap(isl_sioimath_ptr lhs, isl_sioimath_ptr rhs);
+extern void isl_sioimath_add_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs);
+extern void isl_sioimath_sub_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs);
+
+extern void isl_sioimath_add(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_sub(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_mul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_mul_2exp(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs);
+extern void isl_sioimath_mul_si(isl_sioimath_ptr dst, isl_sioimath lhs,
+	signed long rhs);
+extern void isl_sioimath_mul_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs);
+extern void isl_sioimath_pow_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+extern void isl_sioimath_addmul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_addmul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+extern void isl_sioimath_submul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_submul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+
+/* Implements the Euclidean algorithm to compute the greatest common divisor of
+ * two values in small representation.
+ */
+static uint32_t isl_sioimath_smallgcd(int32_t lhs, int32_t rhs)
+{
+	uint32_t dividend, divisor, remainder;
+
+	dividend = labs(lhs);
+	divisor = labs(rhs);
+	while (divisor) {
+		remainder = dividend % divisor;
+		dividend = divisor;
+		divisor = remainder;
+	}
+
+	return dividend;
+}
+
+/* Compute the greatest common divisor.
+ *
+ * Per GMP convention, gcd(0,0)==0 and otherwise always positive.
+ */
+void isl_sioimath_gcd(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	int32_t lhssmall, rhssmall;
+	uint32_t smallgcd;
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		smallgcd = isl_sioimath_smallgcd(lhssmall, rhssmall);
+		isl_sioimath_set_small(dst, smallgcd);
+		return;
+	}
+
+	impz_gcd(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_bigarg_src(rhs, &scratchrhs));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Compute the lowest common multiple of two numbers.
+ */
+void isl_sioimath_lcm(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	int32_t lhssmall, rhssmall;
+	uint32_t smallgcd;
+	uint64_t multiple;
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		if (lhssmall == 0 || rhssmall == 0) {
+			isl_sioimath_set_small(dst, 0);
+			return;
+		}
+		smallgcd = isl_sioimath_smallgcd(lhssmall, rhssmall);
+		multiple = (uint64_t) abs(lhssmall) * (uint64_t) abs(rhssmall);
+		isl_sioimath_set_int64(dst, multiple / smallgcd);
+		return;
+	}
+
+	impz_lcm(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_bigarg_src(rhs, &scratchrhs));
+	isl_sioimath_try_demote(dst);
+}
+
+extern void isl_sioimath_tdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_tdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+extern void isl_sioimath_cdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_cdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+extern void isl_sioimath_fdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+extern void isl_sioimath_fdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs);
+extern void isl_sioimath_fdiv_r(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+
+/* Parse a number from a string.
+ * If it has less than 10 characters then it will fit into the small
+ * representation (i.e. strlen("2147483647")). Otherwise, let IMath parse it.
+ */
+void isl_sioimath_read(isl_sioimath_ptr dst, const char *str)
+{
+	int32_t small;
+
+	if (strlen(str) < 10) {
+		small = strtol(str, NULL, 10);
+		isl_sioimath_set_small(dst, small);
+		return;
+	}
+
+	mp_int_read_string(isl_sioimath_reinit_big(dst), 10, str);
+	isl_sioimath_try_demote(dst);
+}
+
+extern int isl_sioimath_sgn(isl_sioimath_src arg);
+extern int isl_sioimath_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs);
+extern int isl_sioimath_cmp_si(isl_sioimath_src lhs, signed long rhs);
+extern int isl_sioimath_abs_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs);
+extern int isl_sioimath_is_divisible_by(isl_sioimath_src lhs,
+	isl_sioimath_src rhs);
+
+extern uint32_t isl_sioimath_hash(isl_sioimath_src arg, uint32_t hash);
+extern size_t isl_sioimath_sizeinbase(isl_sioimath_src arg, int base);
+extern void isl_sioimath_print(FILE *out, isl_sioimath_src i, int width);
+
+/* Print an isl_int to FILE*. Adds space padding to the left until at least
+ * width characters are printed.
+ */
+void isl_sioimath_print(FILE *out, isl_sioimath_src i, int width)
+{
+	size_t len;
+	int32_t small;
+	mp_int big;
+	char *buf;
+
+	if (isl_sioimath_decode_small(i, &small)) {
+		fprintf(out, "%*" PRIi32, width, small);
+		return;
+	}
+
+	big = isl_sioimath_get_big(i);
+	len = mp_int_string_len(big, 10);
+	buf = malloc(len);
+	mp_int_to_string(big, 10, buf, len);
+	fprintf(out, "%*s", width, buf);
+	free(buf);
+}
+
+/* Print a number to stdout. Meant for debugging.
+ */
+void isl_sioimath_dump(isl_sioimath_src arg)
+{
+	isl_sioimath_print(stdout, arg, 0);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_int_sioimath.h Added

@@ -0,0 +1,1254 @@
+/*
+ * Copyright 2015 INRIA Paris-Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Michael Kruse, INRIA Paris-Rocquencourt,
+ * Domaine de Voluceau, Rocquenqourt, B.P. 105,
+ * 78153 Le Chesnay Cedex France
+ */
+#ifndef ISL_INT_SIOIMATH_H
+#define ISL_INT_SIOIMATH_H
+
+#include <inttypes.h>
+#include <limits.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <isl_imath.h>
+#include <isl/hash.h>
+
+#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
+
+/* Visual Studio before VS2015 does not support the inline keyword when
+ * compiling in C mode because it was introduced in C99 which it does not
+ * officially support.  Instead, it has a proprietary extension using __inline.
+ */
+#if defined(_MSC_VER) && (_MSC_VER < 1900)
+#define inline __inline
+#endif
+
+/* The type to represent integers optimized for small values. It is either a
+ * pointer to an mp_int ( = mpz_t*; big representation) or an int32_t (small
+ * represenation) with a discriminator at the least significant bit. In big
+ * representation it will be always zero because of heap alignment. It is set
+ * to 1 for small representation and use the 32 most significant bits for the
+ * int32_t.
+ *
+ * Structure on 64 bit machines, with 8-byte aligment (3 bits):
+ *
+ * Big representation:
+ * MSB                                                          LSB
+ * |------------------------------------------------------------000
+ * |                            mpz_t*                            |
+ * |                           != NULL                            |
+ *
+ * Small representation:
+ * MSB                           32                             LSB
+ * |------------------------------|00000000000000000000000000000001
+ * |          int32_t             |
+ * |  2147483647 ... -2147483647  |
+ *                                                                ^
+ *                                                                |
+ *                                                        discriminator bit
+ *
+ * On 32 bit machines isl_sioimath type is blown up to 8 bytes, i.e.
+ * isl_sioimath is guaranteed to be at least 8 bytes. This is to ensure the
+ * int32_t can be hidden in that type without data loss. In the future we might
+ * optimize this to use 31 hidden bits in a 32 bit pointer. We may also use 63
+ * bits on 64 bit machines, but this comes with the cost of additional overflow
+ * checks because there is no standardized 128 bit integer we could expand to.
+ *
+ * We use native integer types and avoid union structures to avoid assumptions
+ * on the machine's endianness.
+ *
+ * This implementation makes the following assumptions:
+ * - long can represent any int32_t
+ * - mp_small is signed long
+ * - mp_usmall is unsigned long
+ * - adresses returned by malloc are aligned to 2-byte boundaries (leastmost
+ *   bit is zero)
+ */
+#if UINT64_MAX > UINTPTR_MAX
+typedef uint64_t isl_sioimath;
+#else
+typedef uintptr_t isl_sioimath;
+#endif
+
+/* The negation of the smallest possible number in int32_t, INT32_MIN
+ * (0x80000000u, -2147483648), cannot be represented in an int32_t, therefore
+ * every operation that may produce this value needs to special-case it.
+ * The operations are:
+ * abs(INT32_MIN)
+ * -INT32_MIN   (negation)
+ * -1 * INT32_MIN (multiplication)
+ * INT32_MIN/-1 (any division: divexact, fdiv, cdiv, tdiv)
+ * To avoid checking these cases, we exclude INT32_MIN from small
+ * representation.
+ */
+#define ISL_SIOIMATH_SMALL_MIN (-INT32_MAX)
+
+/* Largest possible number in small representation */
+#define ISL_SIOIMATH_SMALL_MAX INT32_MAX
+
+/* Used for function parameters the function modifies. */
+typedef isl_sioimath *isl_sioimath_ptr;
+
+/* Used for function parameters that are read-only. */
+typedef isl_sioimath isl_sioimath_src;
+
+/* Return whether the argument is stored in small representation.
+ */
+inline int isl_sioimath_is_small(isl_sioimath val)
+{
+	return val & 0x00000001;
+}
+
+/* Return whether the argument is stored in big representation.
+ */
+inline int isl_sioimath_is_big(isl_sioimath val)
+{
+	return !isl_sioimath_is_small(val);
+}
+
+/* Get the number of an isl_int in small representation. Result is undefined if
+ * val is not stored in that format.
+ */
+inline int32_t isl_sioimath_get_small(isl_sioimath val)
+{
+	return val >> 32;
+}
+
+/* Get the number of an in isl_int in big representation. Result is undefined if
+ * val is not stored in that format.
+ */
+inline mp_int isl_sioimath_get_big(isl_sioimath val)
+{
+	return (mp_int)(uintptr_t) val;
+}
+
+/* Return 1 if val is stored in small representation and store its value to
+ * small. We rely on the compiler to optimize the isl_sioimath_get_small such
+ * that the shift is moved into the branch that executes in case of small
+ * representation. If there is no such branch, then a single shift is still
+ * cheaper than introducing branching code.
+ */
+inline int isl_sioimath_decode_small(isl_sioimath val, int32_t *small)
+{
+	*small = isl_sioimath_get_small(val);
+	return isl_sioimath_is_small(val);
+}
+
+/* Return 1 if val is stored in big representation and store its value to big.
+ */
+inline int isl_sioimath_decode_big(isl_sioimath val, mp_int *big)
+{
+	*big = isl_sioimath_get_big(val);
+	return isl_sioimath_is_big(val);
+}
+
+/* Encode a small representation into an isl_int.
+ */
+inline isl_sioimath isl_sioimath_encode_small(int32_t val)
+{
+	return ((isl_sioimath) val) << 32 | 0x00000001;
+}
+
+/* Encode a big representation.
+ */
+inline isl_sioimath isl_sioimath_encode_big(mp_int val)
+{
+	return (isl_sioimath)(uintptr_t) val;
+}
+
+/* A common situation is to call an IMath function with at least one argument
+ * that is currently in small representation or an integer parameter, i.e. a big
+ * representation of the same number is required. Promoting the original
+ * argument comes with multiple problems, such as modifying a read-only
+ * argument, the responsibility of deallocation and the execution cost. Instead,
+ * we make a copy by 'faking' the IMath internal structure.
+ *
+ * We reserve the maximum number of required digits on the stack to avoid heap
+ * allocations.
+ *
+ * mp_digit can be uint32_t or uint16_t. This code must work for little and big
+ * endian digits. The structure for an uint64_t argument and 32-bit mp_digits is
+ * sketched below.
+ *
+ * |----------------------------|
+ *            uint64_t
+ *
+ * |-------------||-------------|
+ *    mp_digit        mp_digit
+ *    digits1       digits0
+ * Most sig digit  Least sig digit
+ */
+typedef struct {
+	mpz_t big;
+	mp_digit digits(sizeof(uintmax_t) + sizeof(mp_digit) - 1) /
+	                sizeof(mp_digit);
+} isl_sioimath_scratchspace_t;
+
+/* Convert a native integer to IMath's digit representation. A native integer
+ * might be big- or little endian, but IMath always stores the least significant
+ * digit in the lowest array indices.  memcpy therefore is not possible.
+ *
+ * We also have to consider that long and mp_digit can be of different sizes,
+ * depending on the compiler (LP64, LLP64) and IMath's USE_64BIT_WORDS. This
+ * macro should work for all of them.
+ *
+ * "used" is set to the number of written digits. It must be minimal (IMath
+ * checks zeroness using the used field), but always at least one.  Also note
+ * that the result of num>>(sizeof(num)*CHAR_BIT) is undefined.
+ */
+#define ISL_SIOIMATH_TO_DIGITS(num, digits, used)                              \
+	do {                                                                   \
+		int i = 0;                                                     \
+		do {                                                           \
+			(digits)i =                                          \
+			    ((num) >> (sizeof(mp_digit) * CHAR_BIT * i));      \
+			i += 1;                                                \
+			if (i >= (sizeof(num) + sizeof(mp_digit) - 1) /        \
+			             sizeof(mp_digit))                         \
+				break;                                         \
+			if (((num) >> (sizeof(mp_digit) * CHAR_BIT * i)) == 0) \
+				break;                                         \
+		} while (1);                                                   \
+		(used) = i;                                                    \
+	} while (0)
+
+inline void isl_siomath_uint32_to_digits(uint32_t num, mp_digit *digits,
+	mp_size *used)
+{
+	ISL_SIOIMATH_TO_DIGITS(num, digits, *used);
+}
+
+inline void isl_siomath_ulong_to_digits(unsigned long num, mp_digit *digits,
+	mp_size *used)
+{
+	ISL_SIOIMATH_TO_DIGITS(num, digits, *used);
+}
+
+inline void isl_siomath_uint64_to_digits(uint64_t num, mp_digit *digits,
+	mp_size *used)
+{
+	ISL_SIOIMATH_TO_DIGITS(num, digits, *used);
+}
+
+/* Get the IMath representation of an isl_int without modifying it.
+ * For the case it is not in big representation yet, pass some scratch space we
+ * can use to store the big representation in.
+ * In order to avoid requiring init and free on the scratch space, we directly
+ * modify the internal representation.
+ *
+ * The name derives from its indented use: getting the big representation of an
+ * input (src) argument.
+ */
+inline mp_int isl_sioimath_bigarg_src(isl_sioimath arg,
+	isl_sioimath_scratchspace_t *scratch)
+{
+	mp_int big;
+	int32_t small;
+	uint32_t num;
+
+	if (isl_sioimath_decode_big(arg, &big))
+		return big;
+
+	small = isl_sioimath_get_small(arg);
+	scratch->big.digits = scratch->digits;
+	scratch->big.alloc = ARRAY_SIZE(scratch->digits);
+	if (small >= 0) {
+		scratch->big.sign = MP_ZPOS;
+		num = small;
+	} else {
+		scratch->big.sign = MP_NEG;
+		num = -small;
+	}
+
+	isl_siomath_uint32_to_digits(num, scratch->digits, &scratch->big.used);
+	return &scratch->big;
+}
+
+/* Create a temporary IMath mp_int for a signed long.
+ */
+inline mp_int isl_sioimath_siarg_src(signed long arg,
+	isl_sioimath_scratchspace_t *scratch)
+{
+	unsigned long num;
+
+	scratch->big.digits = scratch->digits;
+	scratch->big.alloc = ARRAY_SIZE(scratch->digits);
+	if (arg >= 0) {
+		scratch->big.sign = MP_ZPOS;
+		num = arg;
+	} else {
+		scratch->big.sign = MP_NEG;
+		num = (arg == LONG_MIN) ? ((unsigned long) LONG_MAX) + 1 : -arg;
+	}
+
+	isl_siomath_ulong_to_digits(num, scratch->digits, &scratch->big.used);
+	return &scratch->big;
+}
+
+/* Create a temporary IMath mp_int for an int64_t.
+ */
+inline mp_int isl_sioimath_si64arg_src(int64_t arg,
+	isl_sioimath_scratchspace_t *scratch)
+{
+	uint64_t num;
+
+	scratch->big.digits = scratch->digits;
+	scratch->big.alloc = ARRAY_SIZE(scratch->digits);
+	if (arg >= 0) {
+		scratch->big.sign = MP_ZPOS;
+		num = arg;
+	} else {
+		scratch->big.sign = MP_NEG;
+		num = (arg == INT64_MIN) ? ((uint64_t) INT64_MAX) + 1 : -arg;
+	}
+
+	isl_siomath_uint64_to_digits(num, scratch->digits, &scratch->big.used);
+	return &scratch->big;
+}
+
+/* Create a temporary IMath mp_int for an unsigned long.
+ */
+inline mp_int isl_sioimath_uiarg_src(unsigned long arg,
+	isl_sioimath_scratchspace_t *scratch)
+{
+	scratch->big.digits = scratch->digits;
+	scratch->big.alloc = ARRAY_SIZE(scratch->digits);
+	scratch->big.sign = MP_ZPOS;
+
+	isl_siomath_ulong_to_digits(arg, scratch->digits, &scratch->big.used);
+	return &scratch->big;
+}
+
+/* Ensure big representation. Does not preserve the current number.
+ * Callers may use the fact that the value _is_ preserved if the presentation
+ * was big before.
+ */
+inline mp_int isl_sioimath_reinit_big(isl_sioimath_ptr ptr)
+{
+	if (isl_sioimath_is_small(*ptr))
+		*ptr = isl_sioimath_encode_big(mp_int_alloc());
+	return isl_sioimath_get_big(*ptr);
+}
+
+/* Set ptr to a number in small representation.
+ */
+inline void isl_sioimath_set_small(isl_sioimath_ptr ptr, int32_t val)
+{
+	if (isl_sioimath_is_big(*ptr))
+		mp_int_free(isl_sioimath_get_big(*ptr));
+	*ptr = isl_sioimath_encode_small(val);
+}
+
+/* Set ptr to val, choosing small representation if possible.
+ */
+inline void isl_sioimath_set_int32(isl_sioimath_ptr ptr, int32_t val)
+{
+	if (ISL_SIOIMATH_SMALL_MIN <= val && val <= ISL_SIOIMATH_SMALL_MAX) {
+		isl_sioimath_set_small(ptr, val);
+		return;
+	}
+
+	mp_int_init_value(isl_sioimath_reinit_big(ptr), val);
+}
+
+/* Assign an int64_t number using small representation if possible.
+ */
+inline void isl_sioimath_set_int64(isl_sioimath_ptr ptr, int64_t val)
+{
+	if (ISL_SIOIMATH_SMALL_MIN <= val && val <= ISL_SIOIMATH_SMALL_MAX) {
+		isl_sioimath_set_small(ptr, val);
+		return;
+	}
+
+	isl_sioimath_scratchspace_t scratch;
+	mp_int_copy(isl_sioimath_si64arg_src(val, &scratch),
+	    isl_sioimath_reinit_big(ptr));
+}
+
+/* Convert to big representation while preserving the current number.
+ */
+inline void isl_sioimath_promote(isl_sioimath_ptr dst)
+{
+	int32_t small;
+
+	if (isl_sioimath_is_big(*dst))
+		return;
+
+	small = isl_sioimath_get_small(*dst);
+	mp_int_set_value(isl_sioimath_reinit_big(dst), small);
+}
+
+/* Convert to small representation while preserving the current number. Does
+ * nothing if dst doesn't fit small representation.
+ */
+inline void isl_sioimath_try_demote(isl_sioimath_ptr dst)
+{
+	mp_small small;
+
+	if (isl_sioimath_is_small(*dst))
+		return;
+
+	if (mp_int_to_int(isl_sioimath_get_big(*dst), &small) != MP_OK)
+		return;
+
+	if (ISL_SIOIMATH_SMALL_MIN <= small && small <= ISL_SIOIMATH_SMALL_MAX)
+		isl_sioimath_set_small(dst, small);
+}
+
+/* Initialize an isl_int. The implicit value is 0 in small representation.
+ */
+inline void isl_sioimath_init(isl_sioimath_ptr dst)
+{
+	*dst = isl_sioimath_encode_small(0);
+}
+
+/* Free the resources taken by an isl_int.
+ */
+inline void isl_sioimath_clear(isl_sioimath_ptr dst)
+{
+	if (isl_sioimath_is_small(*dst))
+		return;
+
+	mp_int_free(isl_sioimath_get_big(*dst));
+}
+
+/* Copy the value of one isl_int to another.
+ */
+inline void isl_sioimath_set(isl_sioimath_ptr dst, isl_sioimath_src val)
+{
+	if (isl_sioimath_is_small(val)) {
+		isl_sioimath_set_small(dst, isl_sioimath_get_small(val));
+		return;
+	}
+
+	mp_int_copy(isl_sioimath_get_big(val), isl_sioimath_reinit_big(dst));
+}
+
+/* Store a signed long into an isl_int.
+ */
+inline void isl_sioimath_set_si(isl_sioimath_ptr dst, long val)
+{
+	if (ISL_SIOIMATH_SMALL_MIN <= val && val <= ISL_SIOIMATH_SMALL_MAX) {
+		isl_sioimath_set_small(dst, val);
+		return;
+	}
+
+	mp_int_set_value(isl_sioimath_reinit_big(dst), val);
+}
+
+/* Store an unsigned long into an isl_int.
+ */
+inline void isl_sioimath_set_ui(isl_sioimath_ptr dst, unsigned long val)
+{
+	if (val <= ISL_SIOIMATH_SMALL_MAX) {
+		isl_sioimath_set_small(dst, val);
+		return;
+	}
+
+	mp_int_set_uvalue(isl_sioimath_reinit_big(dst), val);
+}
+
+/* Return whether a number can be represented by a signed long.
+ */
+inline int isl_sioimath_fits_slong(isl_sioimath_src val)
+{
+	mp_small dummy;
+
+	if (isl_sioimath_is_small(val))
+		return 1;
+
+	return mp_int_to_int(isl_sioimath_get_big(val), &dummy) == MP_OK;
+}
+
+/* Return a number as signed long. Result is undefined if the number cannot be
+ * represented as long.
+ */
+inline long isl_sioimath_get_si(isl_sioimath_src val)
+{
+	mp_small result;
+
+	if (isl_sioimath_is_small(val))
+		return isl_sioimath_get_small(val);
+
+	mp_int_to_int(isl_sioimath_get_big(val), &result);
+	return result;
+}
+
+/* Return whether a number can be represented as unsigned long.
+ */
+inline int isl_sioimath_fits_ulong(isl_sioimath_src val)
+{
+	mp_usmall dummy;
+
+	if (isl_sioimath_is_small(val))
+		return isl_sioimath_get_small(val) >= 0;
+
+	return mp_int_to_uint(isl_sioimath_get_big(val), &dummy) == MP_OK;
+}
+
+/* Return a number as unsigned long. Result is undefined if the number cannot be
+ * represented as unsigned long.
+ */
+inline unsigned long isl_sioimath_get_ui(isl_sioimath_src val)
+{
+	mp_usmall result;
+
+	if (isl_sioimath_is_small(val))
+		return isl_sioimath_get_small(val);
+
+	mp_int_to_uint(isl_sioimath_get_big(val), &result);
+	return result;
+}
+
+/* Return a number as floating point value.
+ */
+inline double isl_sioimath_get_d(isl_sioimath_src val)
+{
+	mp_int big;
+	double result = 0;
+	int i;
+
+	if (isl_sioimath_is_small(val))
+		return isl_sioimath_get_small(val);
+
+	big = isl_sioimath_get_big(val);
+	for (i = 0; i < big->used; ++i)
+		result = result * (double) ((uintmax_t) MP_DIGIT_MAX + 1) +
+		         (double) big->digitsi;
+
+	if (big->sign == MP_NEG)
+		result = -result;
+
+	return result;
+}
+
+/* Format a number as decimal string.
+ *
+ * The largest possible string from small representation is 12 characters
+ * ("-2147483647").
+ */
+inline char *isl_sioimath_get_str(isl_sioimath_src val)
+{
+	char *result;
+
+	if (isl_sioimath_is_small(val)) {
+		result = malloc(12);
+		snprintf(result, 12, "%" PRIi32, isl_sioimath_get_small(val));
+		return result;
+	}
+
+	return impz_get_str(NULL, 10, isl_sioimath_get_big(val));
+}
+
+/* Return the absolute value.
+ */
+inline void isl_sioimath_abs(isl_sioimath_ptr dst, isl_sioimath_src arg)
+{
+	if (isl_sioimath_is_small(arg)) {
+		isl_sioimath_set_small(dst, labs(isl_sioimath_get_small(arg)));
+		return;
+	}
+
+	mp_int_abs(isl_sioimath_get_big(arg), isl_sioimath_reinit_big(dst));
+}
+
+/* Return the negation of a number.
+ */
+inline void isl_sioimath_neg(isl_sioimath_ptr dst, isl_sioimath_src arg)
+{
+	if (isl_sioimath_is_small(arg)) {
+		isl_sioimath_set_small(dst, -isl_sioimath_get_small(arg));
+		return;
+	}
+
+	mp_int_neg(isl_sioimath_get_big(arg), isl_sioimath_reinit_big(dst));
+}
+
+/* Swap two isl_ints.
+ *
+ * isl_sioimath can be copied bytewise; nothing depends on its address. It can
+ * also be stored in a CPU register.
+ */
+inline void isl_sioimath_swap(isl_sioimath_ptr lhs, isl_sioimath_ptr rhs)
+{
+	isl_sioimath tmp = *lhs;
+	*lhs = *rhs;
+	*rhs = tmp;
+}
+
+/* Add an unsigned long to the number.
+ *
+ * On LP64 unsigned long exceeds the range of an int64_t, therefore we check in
+ * advance whether small representation possibly overflows.
+ */
+inline void isl_sioimath_add_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs)
+{
+	int32_t smalllhs;
+	isl_sioimath_scratchspace_t lhsscratch;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) &&
+	    (rhs <= (uint64_t) INT64_MAX - (uint64_t) ISL_SIOIMATH_SMALL_MAX)) {
+		isl_sioimath_set_int64(dst, (int64_t) smalllhs + rhs);
+		return;
+	}
+
+	impz_add_ui(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs);
+	isl_sioimath_try_demote(dst);
+}
+
+/* Subtract an unsigned long.
+ *
+ * On LP64 unsigned long exceeds the range of an int64_t.  If
+ * ISL_SIOIMATH_SMALL_MIN-rhs>=INT64_MIN we can do the calculation using int64_t
+ * without risking an overflow.
+ */
+inline void isl_sioimath_sub_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+				unsigned long rhs)
+{
+	int32_t smalllhs;
+	isl_sioimath_scratchspace_t lhsscratch;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) &&
+	    (rhs < (uint64_t) INT64_MIN - (uint64_t) ISL_SIOIMATH_SMALL_MIN)) {
+		isl_sioimath_set_int64(dst, (int64_t) smalllhs - rhs);
+		return;
+	}
+
+	impz_sub_ui(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs);
+	isl_sioimath_try_demote(dst);
+}
+
+/* Sum of two isl_ints.
+ */
+inline void isl_sioimath_add(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs, smallrhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) &&
+	    isl_sioimath_decode_small(rhs, &smallrhs)) {
+		isl_sioimath_set_int64(
+		    dst, (int64_t) smalllhs + (int64_t) smallrhs);
+		return;
+	}
+
+	mp_int_add(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_bigarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Subtract two isl_ints.
+ */
+inline void isl_sioimath_sub(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs, smallrhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) &&
+	    isl_sioimath_decode_small(rhs, &smallrhs)) {
+		isl_sioimath_set_int64(
+		    dst, (int64_t) smalllhs - (int64_t) smallrhs);
+		return;
+	}
+
+	mp_int_sub(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_bigarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Multiply two isl_ints.
+ */
+inline void isl_sioimath_mul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs, smallrhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) &&
+	    isl_sioimath_decode_small(rhs, &smallrhs)) {
+		isl_sioimath_set_int64(
+		    dst, (int64_t) smalllhs * (int64_t) smallrhs);
+		return;
+	}
+
+	mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_bigarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Shift lhs by rhs bits to the left and store the result in dst. Effectively,
+ * this operation computes 'lhs * 2^rhs'.
+ */
+inline void isl_sioimath_mul_2exp(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs;
+	int32_t smalllhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs <= 32ul)) {
+		isl_sioimath_set_int64(dst, ((int64_t) smalllhs) << rhs);
+		return;
+	}
+
+	mp_int_mul_pow2(isl_sioimath_bigarg_src(lhs, &scratchlhs), rhs,
+	    isl_sioimath_reinit_big(dst));
+}
+
+/* Multiply an isl_int and a signed long.
+ */
+inline void isl_sioimath_mul_si(isl_sioimath_ptr dst, isl_sioimath lhs,
+	signed long rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs > LONG_MIN) &&
+	    (labs(rhs) <= UINT32_MAX)) {
+		isl_sioimath_set_int64(dst, (int64_t) smalllhs * (int64_t) rhs);
+		return;
+	}
+
+	mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_siarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Multiply an isl_int and an unsigned long.
+ */
+inline void isl_sioimath_mul_ui(isl_sioimath_ptr dst, isl_sioimath lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs;
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs) && (rhs <= UINT32_MAX)) {
+		isl_sioimath_set_int64(dst, (int64_t) smalllhs * (int64_t) rhs);
+		return;
+	}
+
+	mp_int_mul(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_uiarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Compute the power of an isl_int to an unsigned long.
+ * Always let IMath do it; the result is unlikely to be small except in some
+ * special cases.
+ * Note: 0^0 == 1
+ */
+inline void isl_sioimath_pow_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t scratchlhs, scratchrhs;
+	int32_t smalllhs;
+
+	switch (rhs) {
+	case 0:
+		isl_sioimath_set_small(dst, 1);
+		return;
+	case 1:
+		isl_sioimath_set(dst, lhs);
+		return;
+	case 2:
+		isl_sioimath_mul(dst, lhs, lhs);
+		return;
+	}
+
+	if (isl_sioimath_decode_small(lhs, &smalllhs)) {
+		switch (smalllhs) {
+		case 0:
+			isl_sioimath_set_small(dst, 0);
+			return;
+		case 1:
+			isl_sioimath_set_small(dst, 1);
+			return;
+		case 2:
+			isl_sioimath_set_small(dst, 1);
+			isl_sioimath_mul_2exp(dst, *dst, rhs);
+			return;
+		default:
+			if ((MP_SMALL_MIN <= rhs) && (rhs <= MP_SMALL_MAX)) {
+				mp_int_expt_value(smalllhs, rhs,
+				    isl_sioimath_reinit_big(dst));
+				isl_sioimath_try_demote(dst);
+				return;
+			}
+		}
+	}
+
+	mp_int_expt_full(isl_sioimath_bigarg_src(lhs, &scratchlhs),
+	    isl_sioimath_uiarg_src(rhs, &scratchrhs),
+	    isl_sioimath_reinit_big(dst));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Fused multiply-add.
+ */
+inline void isl_sioimath_addmul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath tmp;
+	isl_sioimath_init(&tmp);
+	isl_sioimath_mul(&tmp, lhs, rhs);
+	isl_sioimath_add(dst, *dst, tmp);
+	isl_sioimath_clear(&tmp);
+}
+
+/* Fused multiply-add with an unsigned long.
+ */
+inline void isl_sioimath_addmul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath tmp;
+	isl_sioimath_init(&tmp);
+	isl_sioimath_mul_ui(&tmp, lhs, rhs);
+	isl_sioimath_add(dst, *dst, tmp);
+	isl_sioimath_clear(&tmp);
+}
+
+/* Fused multiply-subtract.
+ */
+inline void isl_sioimath_submul(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath tmp;
+	isl_sioimath_init(&tmp);
+	isl_sioimath_mul(&tmp, lhs, rhs);
+	isl_sioimath_sub(dst, *dst, tmp);
+	isl_sioimath_clear(&tmp);
+}
+
+/* Fused multiply-add with an unsigned long.
+ */
+inline void isl_sioimath_submul_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath tmp;
+	isl_sioimath_init(&tmp);
+	isl_sioimath_mul_ui(&tmp, lhs, rhs);
+	isl_sioimath_sub(dst, *dst, tmp);
+	isl_sioimath_clear(&tmp);
+}
+
+void isl_sioimath_gcd(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+		      isl_sioimath_src rhs);
+void isl_sioimath_lcm(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+		      isl_sioimath_src rhs);
+
+/* Divide lhs by rhs, rounding to zero (Truncate).
+ */
+inline void isl_sioimath_tdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, rhssmall;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		isl_sioimath_set_small(dst, lhssmall / rhssmall);
+		return;
+	}
+
+	mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch),
+	    isl_sioimath_reinit_big(dst), NULL);
+	isl_sioimath_try_demote(dst);
+	return;
+}
+
+/* Divide lhs by an unsigned long rhs, rounding to zero (Truncate).
+ */
+inline void isl_sioimath_tdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall;
+
+	if (isl_sioimath_is_small(lhs) && (rhs <= (unsigned long) INT32_MAX)) {
+		lhssmall = isl_sioimath_get_small(lhs);
+		isl_sioimath_set_small(dst, lhssmall / (int32_t) rhs);
+		return;
+	}
+
+	if (rhs <= MP_SMALL_MAX) {
+		mp_int_div_value(isl_sioimath_bigarg_src(lhs, &lhsscratch), rhs,
+		    isl_sioimath_reinit_big(dst), NULL);
+		isl_sioimath_try_demote(dst);
+		return;
+	}
+
+	mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_uiarg_src(rhs, &rhsscratch),
+	    isl_sioimath_reinit_big(dst), NULL);
+	isl_sioimath_try_demote(dst);
+}
+
+/* Divide lhs by rhs, rounding to positive infinity (Ceil).
+ */
+inline void isl_sioimath_cdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	int32_t lhssmall, rhssmall;
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t q;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		if ((lhssmall >= 0) && (rhssmall >= 0))
+			q = ((int64_t) lhssmall + (int64_t) rhssmall - 1) /
+			    rhssmall;
+		else if ((lhssmall < 0) && (rhssmall < 0))
+			q = ((int64_t) lhssmall + (int64_t) rhssmall + 1) /
+			    rhssmall;
+		else
+			q = lhssmall / rhssmall;
+		isl_sioimath_set_small(dst, q);
+		return;
+	}
+
+	impz_cdiv_q(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * positive infinity (Ceil).
+ */
+inline void isl_sioimath_cdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, q;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) && (rhs <= INT32_MAX)) {
+		if (lhssmall >= 0)
+			q = ((int64_t) lhssmall + ((int64_t) rhs - 1)) /
+			    (int64_t) rhs;
+		else
+			q = lhssmall / (int32_t) rhs;
+		isl_sioimath_set_small(dst, q);
+		return;
+	}
+
+	impz_cdiv_q(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_uiarg_src(rhs, &rhsscratch));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Divide lhs by rhs, rounding to negative infinity (Floor).
+ */
+inline void isl_sioimath_fdiv_q(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, rhssmall;
+	int32_t q;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		if ((lhssmall < 0) && (rhssmall >= 0))
+			q = ((int64_t) lhssmall - ((int64_t) rhssmall - 1)) /
+			    rhssmall;
+		else if ((lhssmall >= 0) && (rhssmall < 0))
+			q = ((int64_t) lhssmall - ((int64_t) rhssmall + 1)) /
+			    rhssmall;
+		else
+			q = lhssmall / rhssmall;
+		isl_sioimath_set_small(dst, q);
+		return;
+	}
+
+	impz_fdiv_q(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Compute the division of lhs by a rhs of type unsigned long, rounding towards
+ * negative infinity (Floor).
+ */
+inline void isl_sioimath_fdiv_q_ui(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	unsigned long rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, q;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) && (rhs <= INT32_MAX)) {
+		if (lhssmall >= 0)
+			q = (uint32_t) lhssmall / rhs;
+		else
+			q = ((int64_t) lhssmall - ((int64_t) rhs - 1)) /
+			    (int64_t) rhs;
+		isl_sioimath_set_small(dst, q);
+		return;
+	}
+
+	impz_fdiv_q(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_uiarg_src(rhs, &rhsscratch));
+	isl_sioimath_try_demote(dst);
+}
+
+/* Get the remainder of: lhs divided by rhs rounded towards negative infinite
+ * (Floor).
+ */
+inline void isl_sioimath_fdiv_r(isl_sioimath_ptr dst, isl_sioimath_src lhs,
+	isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int64_t lhssmall, rhssmall;
+	int32_t r;
+
+	if (isl_sioimath_is_small(lhs) && isl_sioimath_is_small(rhs)) {
+		lhssmall = isl_sioimath_get_small(lhs);
+		rhssmall = isl_sioimath_get_small(rhs);
+		r = (rhssmall + lhssmall % rhssmall) % rhssmall;
+		isl_sioimath_set_small(dst, r);
+		return;
+	}
+
+	impz_fdiv_r(isl_sioimath_reinit_big(dst),
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch));
+	isl_sioimath_try_demote(dst);
+}
+
+void isl_sioimath_read(isl_sioimath_ptr dst, const char *str);
+
+/* Return:
+ *   +1 for a positive number
+ *   -1 for a negative number
+ *    0 if the number is zero
+ */
+inline int isl_sioimath_sgn(isl_sioimath_src arg)
+{
+	int32_t small;
+
+	if (isl_sioimath_decode_small(arg, &small))
+		return (small > 0) - (small < 0);
+
+	return mp_int_compare_zero(isl_sioimath_get_big(arg));
+}
+
+/* Return:
+ *   +1 if lhs > rhs
+ *   -1 if lhs < rhs
+ *    0 if lhs = rhs
+ */
+inline int isl_sioimath_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, rhssmall;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall))
+		return (lhssmall > rhssmall) - (lhssmall < rhssmall);
+
+	if (isl_sioimath_decode_small(rhs, &rhssmall))
+		return mp_int_compare_value(
+		    isl_sioimath_bigarg_src(lhs, &lhsscratch), rhssmall);
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall))
+		return -mp_int_compare_value(
+		           isl_sioimath_bigarg_src(rhs, &rhsscratch), lhssmall);
+
+	return mp_int_compare(
+	    isl_sioimath_get_big(lhs), isl_sioimath_get_big(rhs));
+}
+
+/* As isl_sioimath_cmp, but with signed long rhs.
+ */
+inline int isl_sioimath_cmp_si(isl_sioimath_src lhs, signed long rhs)
+{
+	int32_t lhssmall;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall))
+		return (lhssmall > rhs) - (lhssmall < rhs);
+
+	return mp_int_compare_value(isl_sioimath_get_big(lhs), rhs);
+}
+
+/* Return:
+ *   +1 if |lhs| > |rhs|
+ *   -1 if |lhs| < |rhs|
+ *    0 if |lhs| = |rhs|
+ */
+inline int isl_sioimath_abs_cmp(isl_sioimath_src lhs, isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, rhssmall;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall)) {
+		lhssmall = labs(lhssmall);
+		rhssmall = labs(rhssmall);
+		return (lhssmall > rhssmall) - (lhssmall < rhssmall);
+	}
+
+	return mp_int_compare_unsigned(
+	    isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch));
+}
+
+/* Return whether lhs is divisible by rhs.
+ * In particular, can rhs be multiplied by some integer to result in lhs?
+ * If rhs is zero, then this means lhs has to be zero too.
+ */
+inline int isl_sioimath_is_divisible_by(isl_sioimath_src lhs,
+					isl_sioimath_src rhs)
+{
+	isl_sioimath_scratchspace_t lhsscratch, rhsscratch;
+	int32_t lhssmall, rhssmall;
+	mpz_t rem;
+	int cmp;
+
+	if (isl_sioimath_sgn(rhs) == 0)
+		return isl_sioimath_sgn(lhs) == 0;
+
+	if (isl_sioimath_decode_small(lhs, &lhssmall) &&
+	    isl_sioimath_decode_small(rhs, &rhssmall))
+		return lhssmall % rhssmall == 0;
+
+	if (isl_sioimath_decode_small(rhs, &rhssmall))
+		return mp_int_divisible_value(
+		    isl_sioimath_bigarg_src(lhs, &lhsscratch), rhssmall);
+
+	mp_int_init(&rem);
+	mp_int_div(isl_sioimath_bigarg_src(lhs, &lhsscratch),
+	    isl_sioimath_bigarg_src(rhs, &rhsscratch), NULL, &rem);
+	cmp = mp_int_compare_zero(&rem);
+	mp_int_clear(&rem);
+	return cmp == 0;
+}
+
+/* Return a hash code of an isl_sioimath.
+ * The hash code for a number in small and big representation must be identical
+ * on the same machine because small representation if not obligatory if fits.
+ */
+inline uint32_t isl_sioimath_hash(isl_sioimath_src arg, uint32_t hash)
+{
+	int32_t small;
+	int i;
+	uint32_t num;
+	mp_digit digits(sizeof(uint32_t) + sizeof(mp_digit) - 1) /
+	                sizeof(mp_digit);
+	mp_size used;
+	const unsigned char *digitdata = (const unsigned char *) &digits;
+
+	if (isl_sioimath_decode_small(arg, &small)) {
+		if (small < 0)
+			isl_hash_byte(hash, 0xFF);
+		num = labs(small);
+
+		isl_siomath_uint32_to_digits(num, digits, &used);
+		for (i = 0; i < used * sizeof(mp_digit); i += 1)
+			isl_hash_byte(hash, digitdatai);
+		return hash;
+	}
+
+	return isl_imath_hash(isl_sioimath_get_big(arg), hash);
+}
+
+/* Return the number of digits in a number of the given base or more, i.e. the
+ * string length without sign and null terminator.
+ *
+ * Current implementation for small representation returns the maximal number
+ * of binary digits in that representation, which can be much larger than the
+ * smallest possible solution.
+ */
+inline size_t isl_sioimath_sizeinbase(isl_sioimath_src arg, int base)
+{
+	int32_t small;
+
+	if (isl_sioimath_decode_small(arg, &small))
+		return sizeof(int32_t) * CHAR_BIT - 1;
+
+	return impz_sizeinbase(isl_sioimath_get_big(arg), base);
+}
+
+void isl_sioimath_print(FILE *out, isl_sioimath_src i, int width);
+void isl_sioimath_dump(isl_sioimath_src arg);
+
+typedef isl_sioimath isl_int1;
+#define isl_int_init(i)			isl_sioimath_init((i))
+#define isl_int_clear(i)		isl_sioimath_clear((i))
+
+#define isl_int_set(r, i)		isl_sioimath_set((r), *(i))
+#define isl_int_set_si(r, i)		isl_sioimath_set_si((r), i)
+#define isl_int_set_ui(r, i)		isl_sioimath_set_ui((r), i)
+#define isl_int_fits_slong(r)		isl_sioimath_fits_slong(*(r))
+#define isl_int_get_si(r)		isl_sioimath_get_si(*(r))
+#define isl_int_fits_ulong(r)		isl_sioimath_fits_ulong(*(r))
+#define isl_int_get_ui(r)		isl_sioimath_get_ui(*(r))
+#define isl_int_get_d(r)		isl_sioimath_get_d(*(r))
+#define isl_int_get_str(r)		isl_sioimath_get_str(*(r))
+#define isl_int_abs(r, i)		isl_sioimath_abs((r), *(i))
+#define isl_int_neg(r, i)		isl_sioimath_neg((r), *(i))
+#define isl_int_swap(i, j)		isl_sioimath_swap((i), (j))
+#define isl_int_swap_or_set(i, j)	isl_sioimath_swap((i), (j))
+#define isl_int_add_ui(r, i, j)		isl_sioimath_add_ui((r), *(i), j)
+#define isl_int_sub_ui(r, i, j)		isl_sioimath_sub_ui((r), *(i), j)
+
+#define isl_int_add(r, i, j)		isl_sioimath_add((r), *(i), *(j))
+#define isl_int_sub(r, i, j)		isl_sioimath_sub((r), *(i), *(j))
+#define isl_int_mul(r, i, j)		isl_sioimath_mul((r), *(i), *(j))
+#define isl_int_mul_2exp(r, i, j)	isl_sioimath_mul_2exp((r), *(i), j)
+#define isl_int_mul_si(r, i, j)		isl_sioimath_mul_si((r), *(i), j)
+#define isl_int_mul_ui(r, i, j)		isl_sioimath_mul_ui((r), *(i), j)
+#define isl_int_pow_ui(r, i, j)		isl_sioimath_pow_ui((r), *(i), j)
+#define isl_int_addmul(r, i, j)		isl_sioimath_addmul((r), *(i), *(j))
+#define isl_int_addmul_ui(r, i, j)	isl_sioimath_addmul_ui((r), *(i), j)
+#define isl_int_submul(r, i, j)		isl_sioimath_submul((r), *(i), *(j))
+#define isl_int_submul_ui(r, i, j)	isl_sioimath_submul_ui((r), *(i), j)
+
+#define isl_int_gcd(r, i, j)		isl_sioimath_gcd((r), *(i), *(j))
+#define isl_int_lcm(r, i, j)		isl_sioimath_lcm((r), *(i), *(j))
+#define isl_int_divexact(r, i, j)	isl_sioimath_tdiv_q((r), *(i), *(j))
+#define isl_int_divexact_ui(r, i, j)	isl_sioimath_tdiv_q_ui((r), *(i), j)
+#define isl_int_tdiv_q(r, i, j)		isl_sioimath_tdiv_q((r), *(i), *(j))
+#define isl_int_cdiv_q(r, i, j)		isl_sioimath_cdiv_q((r), *(i), *(j))
+#define isl_int_cdiv_q_ui(r, i, j)	isl_sioimath_cdiv_q_ui((r), *(i), j)
+#define isl_int_fdiv_q(r, i, j)		isl_sioimath_fdiv_q((r), *(i), *(j))
+#define isl_int_fdiv_r(r, i, j)		isl_sioimath_fdiv_r((r), *(i), *(j))
+#define isl_int_fdiv_q_ui(r, i, j)	isl_sioimath_fdiv_q_ui((r), *(i), j)
+
+#define isl_int_read(r, s)		isl_sioimath_read((r), s)
+#define isl_int_sgn(i)			isl_sioimath_sgn(*(i))
+#define isl_int_cmp(i, j)		isl_sioimath_cmp(*(i), *(j))
+#define isl_int_cmp_si(i, si)		isl_sioimath_cmp_si(*(i), si)
+#define isl_int_eq(i, j)		(isl_sioimath_cmp(*(i), *(j)) == 0)
+#define isl_int_ne(i, j)		(isl_sioimath_cmp(*(i), *(j)) != 0)
+#define isl_int_lt(i, j)		(isl_sioimath_cmp(*(i), *(j)) < 0)
+#define isl_int_le(i, j)		(isl_sioimath_cmp(*(i), *(j)) <= 0)
+#define isl_int_gt(i, j)		(isl_sioimath_cmp(*(i), *(j)) > 0)
+#define isl_int_ge(i, j)		(isl_sioimath_cmp(*(i), *(j)) >= 0)
+#define isl_int_abs_cmp(i, j)		isl_sioimath_abs_cmp(*(i), *(j))
+#define isl_int_abs_eq(i, j)		(isl_sioimath_abs_cmp(*(i), *(j)) == 0)
+#define isl_int_abs_ne(i, j)		(isl_sioimath_abs_cmp(*(i), *(j)) != 0)
+#define isl_int_abs_lt(i, j)		(isl_sioimath_abs_cmp(*(i), *(j)) < 0)
+#define isl_int_abs_gt(i, j)		(isl_sioimath_abs_cmp(*(i), *(j)) > 0)
+#define isl_int_abs_ge(i, j)		(isl_sioimath_abs_cmp(*(i), *(j)) >= 0)
+#define isl_int_is_divisible_by(i, j)	isl_sioimath_is_divisible_by(*(i), *(j))
+
+#define isl_int_hash(v, h)		isl_sioimath_hash(*(v), h)
+#define isl_int_free_str(s)		free(s)
+#define isl_int_print(out, i, width)	isl_sioimath_print(out, *(i), width)
+
+#endif /* ISL_INT_SIOIMATH_H */

_service:tar_scm:isl-0.24.tar.gz/isl_list_macro.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_list_private.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_list_templ.c -> _service:tar_scm:isl-0.24.tar.gz/isl_list_templ.c Changed

@@ -2,6 +2,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2011      INRIA Saclay
  * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2017      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
@@ -14,15 +15,10 @@
 
 #include <isl_sort.h>
 #include <isl_tarjan.h>
+#include <isl/printer.h>
+
+#include <isl_list_macro.h>
 
-#define xCAT(A,B) A ## B
-#define CAT(A,B) xCAT(A,B)
-#undef EL
-#define EL CAT(isl_,BASE)
-#define xFN(TYPE,NAME) TYPE ## _ ## NAME
-#define FN(TYPE,NAME) xFN(TYPE,NAME)
-#define xLIST(EL) EL ## _list
-#define LIST(EL) xLIST(EL)
 #define xS(TYPE,NAME) struct TYPE ## _ ## NAME
 #define S(TYPE,NAME) xS(TYPE,NAME)
 
@@ -130,6 +126,18 @@
 	return res;
 }
 
+/* Check that "index" is a valid position in "list".
+ */
+static isl_stat FN(LIST(EL),check_index)(__isl_keep LIST(EL) *list, int index)
+{
+	if (!list)
+		return isl_stat_error;
+	if (index < 0 || index >= list->n)
+		isl_die(FN(LIST(EL),get_ctx)(list), isl_error_invalid,
+			"index out of bounds", return isl_stat_error);
+	return isl_stat_ok;
+}
+
 __isl_give LIST(EL) *FN(LIST(EL),add)(__isl_take LIST(EL) *list,
 	__isl_take struct EL *el)
 {
@@ -170,6 +178,15 @@
 	return list;
 }
 
+/* Remove all elements from "list".
+ */
+__isl_give LIST(EL) *FN(LIST(EL),clear)(__isl_take LIST(EL) *list)
+{
+	if (!list)
+		return NULL;
+	return FN(LIST(EL),drop)(list, 0, list->n);
+}
+
 /* Insert "el" at position "pos" in "list".
  *
  * If there is only one reference to "list" and if it already has space
@@ -192,8 +209,8 @@
 			"index out of bounds", goto error);
 
 	if (list->ref == 1 && list->size > list->n) {
-		for (i = list->n - 1; i >= pos; --i)
-			list->pi + 1 = list->pi;
+		for (i = list->n; i > pos; --i)
+			list->pi = list->pi - 1;
 		list->n++;
 		list->ppos = el;
 		return list;
@@ -232,31 +249,53 @@
 	return NULL;
 }
 
-int FN(FN(LIST(EL),n),BASE)(__isl_keep LIST(EL) *list)
+/* Return the number of elements in "list".
+ */
+isl_size FN(LIST(EL),size)(__isl_keep LIST(EL) *list)
 {
-	return list ? list->n : 0;
+	return list ? list->n : isl_size_error;
 }
 
-__isl_give EL *FN(FN(LIST(EL),get),BASE)(__isl_keep LIST(EL) *list, int index)
+/* This is an alternative name for the function above.
+ */
+isl_size FN(FN(LIST(EL),n),EL_BASE)(__isl_keep LIST(EL) *list)
 {
-	if (!list)
+	return FN(LIST(EL),size)(list);
+}
+
+/* Return the element at position "index" in "list".
+ */
+__isl_keep EL *FN(LIST(EL),peek)(__isl_keep LIST(EL) *list, int index)
+{
+	if (FN(LIST(EL),check_index)(list, index) < 0)
 		return NULL;
-	if (index < 0 || index >= list->n)
-		isl_die(list->ctx, isl_error_invalid,
-			"index out of bounds", return NULL);
-	return FN(EL,copy)(list->pindex);
+	return list->pindex;
+}
+
+/* Return a copy of the element at position "index" in "list".
+ */
+__isl_give EL *FN(LIST(EL),get_at)(__isl_keep LIST(EL) *list, int index)
+{
+	return FN(EL,copy)(FN(LIST(EL),peek)(list, index));
+}
+
+/* This is an alternative name for the function above.
+ */
+__isl_give EL *FN(FN(LIST(EL),get),EL_BASE)(__isl_keep LIST(EL) *list,
+	int index)
+{
+	return FN(LIST(EL),get_at)(list, index);
 }
 
 /* Replace the element at position "index" in "list" by "el".
  */
-__isl_give LIST(EL) *FN(FN(LIST(EL),set),BASE)(__isl_take LIST(EL) *list,
+__isl_give LIST(EL) *FN(FN(LIST(EL),set),EL_BASE)(__isl_take LIST(EL) *list,
 	int index, __isl_take EL *el)
 {
 	if (!list || !el)
 		goto error;
-	if (index < 0 || index >= list->n)
-		isl_die(list->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (FN(LIST(EL),check_index)(list, index) < 0)
+		goto error;
 	if (list->pindex == el) {
 		FN(EL,free)(el);
 		return list;
@@ -273,23 +312,129 @@
 	return NULL;
 }
 
-int FN(LIST(EL),foreach)(__isl_keep LIST(EL) *list,
-	int (*fn)(__isl_take EL *el, void *user), void *user)
+/* Return the element at position "index" of "list".
+ * This may be either a copy or the element itself
+ * if there is only one reference to "list".
+ * This allows the element to be modified inplace
+ * if both the list and the element have only a single reference.
+ * The caller is not allowed to modify "list" between
+ * this call to isl_list_*_take_* and a subsequent call
+ * to isl_list_*_restore_*.
+ * The only exception is that isl_list_*_free can be called instead.
+ */
+static __isl_give EL *FN(FN(LIST(EL),take),EL_BASE)(__isl_keep LIST(EL) *list,
+	int index)
+{
+	EL *el;
+
+	if (FN(LIST(EL),check_index)(list, index) < 0)
+		return NULL;
+	if (list->ref != 1)
+		return FN(FN(LIST(EL),get),EL_BASE)(list, index);
+	el = list->pindex;
+	list->pindex = NULL;
+	return el;
+}
+
+/* Set the element at position "index" of "list" to "el",
+ * where the position may be empty due to a previous call
+ * to isl_list_*_take_*.
+ */
+static __isl_give LIST(EL) *FN(FN(LIST(EL),restore),EL_BASE)(
+	__isl_take LIST(EL) *list, int index, __isl_take EL *el)
+{
+	return FN(FN(LIST(EL),set),EL_BASE)(list, index, el);
+}
+
+/* Swap the elements of "list" in positions "pos1" and "pos2".
+ */
+__isl_give LIST(EL) *FN(LIST(EL),swap)(__isl_take LIST(EL) *list,
+	unsigned pos1, unsigned pos2)
+{
+	EL *el1, *el2;
+
+	if (pos1 == pos2)
+		return list;
+	el1 = FN(FN(LIST(EL),take),EL_BASE)(list, pos1);
+	el2 = FN(FN(LIST(EL),take),EL_BASE)(list, pos2);
+	list = FN(FN(LIST(EL),restore),EL_BASE)(list, pos1, el2);
+	list = FN(FN(LIST(EL),restore),EL_BASE)(list, pos2, el1);
+	return list;
+}
+
+/* Reverse the elements of "list".
+ */
+__isl_give LIST(EL) *FN(LIST(EL),reverse)(__isl_take LIST(EL) *list)
+{
+	int i, n;
+
+	n = FN(LIST(EL),size)(list);
+	for (i = 0; i < n - 1 - i; ++i)
+		list = FN(LIST(EL),swap)(list, i, n - 1 - i);
+	return list;
+}
+
+isl_stat FN(LIST(EL),foreach)(__isl_keep LIST(EL) *list,
+	isl_stat (*fn)(__isl_take EL *el, void *user), void *user)
 {
 	int i;
 
 	if (!list)
-		return -1;
+		return isl_stat_error;
 
 	for (i = 0; i < list->n; ++i) {
-		EL *el = FN(EL,copy(list->pi));
+		EL *el = FN(EL,copy)(list->pi);
 		if (!el)
-			return -1;
+			return isl_stat_error;
 		if (fn(el, user) < 0)
-			return -1;
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Does "test" succeed on every element of "list"?
+ */
+isl_bool FN(LIST(EL),every)(__isl_keep LIST(EL) *list,
+	isl_bool (*test)(__isl_keep EL *el, void *user), void *user)
+{
+	int i;
+
+	if (!list)
+		return isl_bool_error;
+
+	for (i = 0; i < list->n; ++i) {
+		isl_bool r;
+
+		r = test(list->pi, user);
+		if (r < 0 || !r)
+			return r;
+	}
+
+	return isl_bool_true;
+}
+
+/* Replace each element in "list" by the result of calling "fn"
+ * on the element.
+ */
+__isl_give LIST(EL) *FN(LIST(EL),map)(__isl_keep LIST(EL) *list,
+	__isl_give EL *(*fn)(__isl_take EL *el, void *user), void *user)
+{
+	int i, n;
+
+	if (!list)
+		return NULL;
+
+	n = list->n;
+	for (i = 0; i < n; ++i) {
+		EL *el = FN(FN(LIST(EL),take),EL_BASE)(list, i);
+		if (!el)
+			return FN(LIST(EL),free)(list);
+		el = fn(el, user);
+		list = FN(FN(LIST(EL),restore),EL_BASE)(list, i, el);
 	}
 
-	return 0;
+	return list;
 }
 
 /* Internal data structure for isl_*_list_sort.
@@ -344,7 +489,7 @@
  */
 S(LIST(EL),foreach_scc_data) {
 	LIST(EL) *list;
-	int (*follows)(__isl_keep EL *a, __isl_keep EL *b, void *user);
+	isl_bool (*follows)(__isl_keep EL *a, __isl_keep EL *b, void *user);
 	void *follows_user;
 };
 
@@ -352,7 +497,7 @@
  *
  * Use the user provided callback to find out.
  */
-static int FN(LIST(EL),follows)(int i, int j, void *user)
+static isl_bool FN(LIST(EL),follows)(int i, int j, void *user)
 {
 	S(LIST(EL),foreach_scc_data) *data = user;
 
@@ -363,8 +508,8 @@
 /* Call "fn" on the sublist of "list" that consists of the elements
  * with indices specified by the "n" elements of "pos".
  */
-static int FN(LIST(EL),call_on_scc)(__isl_keep LIST(EL) *list, int *pos, int n,
-	int (*fn)(__isl_take LIST(EL) *scc, void *user), void *user)
+static isl_stat FN(LIST(EL),call_on_scc)(__isl_keep LIST(EL) *list, int *pos,
+	int n, isl_stat (*fn)(__isl_take LIST(EL) *scc, void *user), void *user)
 {
 	int i;
 	isl_ctx *ctx;
@@ -394,10 +539,10 @@
  * We simply call isl_tarjan_graph_init, extract the SCCs from the result and
  * call fn on each of them.
  */
-int FN(LIST(EL),foreach_scc)(__isl_keep LIST(EL) *list,
-	int (*follows)(__isl_keep EL *a, __isl_keep EL *b, void *user),
+isl_stat FN(LIST(EL),foreach_scc)(__isl_keep LIST(EL) *list,
+	isl_bool (*follows)(__isl_keep EL *a, __isl_keep EL *b, void *user),
 	void *follows_user,
-	int (*fn)(__isl_take LIST(EL) *scc, void *user), void *fn_user)
+	isl_stat (*fn)(__isl_take LIST(EL) *scc, void *user), void *fn_user)
 {
 	S(LIST(EL),foreach_scc_data) data = { list, follows, follows_user };
 	int i, n;
@@ -405,9 +550,9 @@
 	struct isl_tarjan_graph *g;
 
 	if (!list)
-		return -1;
+		return isl_stat_error;
 	if (list->n == 0)
-		return 0;
+		return isl_stat_ok;
 	if (list->n == 1)
 		return fn(FN(LIST(EL),copy)(list), fn_user);
 
@@ -415,7 +560,7 @@
 	n = list->n;
 	g = isl_tarjan_graph_init(ctx, n, &FN(LIST(EL),follows), &data);
 	if (!g)
-		return -1;
+		return isl_stat_error;
 
 	i = 0;
 	do {
@@ -440,10 +585,10 @@
 
 	isl_tarjan_graph_free(g);
 
-	return n > 0 ? -1 : 0;
+	return n > 0 ? isl_stat_error : isl_stat_ok;
 }
 
-__isl_give LIST(EL) *FN(FN(LIST(EL),from),BASE)(__isl_take EL *el)
+__isl_give LIST(EL) *FN(FN(LIST(EL),from),EL_BASE)(__isl_take EL *el)
 {
 	isl_ctx *ctx;
 	LIST(EL) *list;
@@ -461,6 +606,34 @@
 	return NULL;
 }
 
+/* This function performs the same operation as isl_*_list_from_*,
+ * but is considered as a function on the element when exported.
+ */
+__isl_give LIST(EL) *FN(EL,to_list)(__isl_take EL *el)
+{
+	return FN(FN(LIST(EL),from),EL_BASE)(el);
+}
+
+/* Append the elements of "list2" to "list1", where "list1" is known
+ * to have only a single reference and enough room to hold
+ * the extra elements.
+ */
+static __isl_give LIST(EL) *FN(LIST(EL),concat_inplace)(
+	__isl_take LIST(EL) *list1, __isl_take LIST(EL) *list2)
+{
+	int i;
+
+	for (i = 0; i < list2->n; ++i)
+		list1 = FN(LIST(EL),add)(list1, FN(EL,copy)(list2->pi));
+	FN(LIST(EL),free)(list2);
+	return list1;
+}
+
+/* Concatenate "list1" and "list2".
+ * If "list1" has only one reference and has enough room
+ * for the elements of "list2", the add the elements to "list1" itself.
+ * Otherwise, create a new list to store the result.
+ */
 __isl_give LIST(EL) *FN(LIST(EL),concat)(__isl_take LIST(EL) *list1,
 	__isl_take LIST(EL) *list2)
 {
@@ -471,6 +644,9 @@
 	if (!list1 || !list2)
 		goto error;
 
+	if (list1->ref == 1 && list1->n + list2->n <= list1->size)
+		return FN(LIST(EL),concat_inplace)(list1, list2);
+
 	ctx = FN(LIST(EL),get_ctx)(list1);
 	res = FN(LIST(EL),alloc)(ctx, list1->n + list2->n);
 	for (i = 0; i < list1->n; ++i)
@@ -487,7 +663,7 @@
 	return NULL;
 }
 
-__isl_give isl_printer *CAT(isl_printer_print_,LIST(BASE))(
+__isl_give isl_printer *CAT(isl_printer_print_,LIST(EL_BASE))(
 	__isl_take isl_printer *p, __isl_keep LIST(EL) *list)
 {
 	int i;
@@ -498,7 +674,7 @@
 	for (i = 0; i < list->n; ++i) {
 		if (i)
 			p = isl_printer_print_str(p, ",");
-		p = CAT(isl_printer_print_,BASE)(p, list->pi);
+		p = CAT(isl_printer_print_,EL_BASE)(p, list->pi);
 	}
 	p = isl_printer_print_str(p, ")");
 	return p;
@@ -507,16 +683,9 @@
 	return NULL;
 }
 
-void FN(LIST(EL),dump)(__isl_keep LIST(EL) *list)
-{
-	isl_printer *printer;
-
-	if (!list)
-		return;
-
-	printer = isl_printer_to_file(FN(LIST(EL),get_ctx)(list), stderr);
-	printer = CAT(isl_printer_print_,LIST(BASE))(printer, list);
-	printer = isl_printer_end_line(printer);
+#undef BASE
+#define BASE LIST(EL_BASE)
 
-	isl_printer_free(printer);
-}
+#define PRINT_DUMP_DEFAULT	0
+#include "print_templ.c"
+#undef PRINT_DUMP_DEFAULT

_service:tar_scm:isl-0.24.tar.gz/isl_local.c Added

@@ -0,0 +1,318 @@
+/*
+ * Copyright 2011      INRIA Saclay
+ * Copyright 2014      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl_vec_private.h>
+#include <isl_mat_private.h>
+#include <isl_reordering.h>
+#include <isl_seq.h>
+#include <isl_local_private.h>
+
+/* Return the isl_ctx to which "local" belongs.
+ */
+isl_ctx *isl_local_get_ctx(__isl_keep isl_local *local)
+{
+	if (!local)
+		return NULL;
+
+	return isl_mat_get_ctx(local);
+}
+
+/* Create an isl_local object from a matrix describing
+ * integer divisions.
+ *
+ * An isl_local object is current defined as exactly such a matrix,
+ * so simply return the input.
+ */
+__isl_give isl_local *isl_local_alloc_from_mat(__isl_take isl_mat *mat)
+{
+	return mat;
+}
+
+/* Free "local" and return NULL.
+ */
+__isl_null isl_local *isl_local_free(__isl_take isl_local *local)
+{
+	isl_mat_free(local);
+	return NULL;
+}
+
+/* Return the number of local variables (isl_dim_div),
+ * the number of other variables (isl_dim_set) or
+ * the total number of variables (isl_dim_all) in "local".
+ *
+ * Other types do not have any meaning for an isl_local object.
+ */
+isl_size isl_local_dim(__isl_keep isl_local *local, enum isl_dim_type type)
+{
+	isl_mat *mat = local;
+
+	if (!local)
+		return isl_size_error;
+	if (type == isl_dim_div)
+		return isl_mat_rows(mat);
+	if (type == isl_dim_all) {
+		isl_size cols = isl_mat_cols(mat);
+		if (cols < 0)
+			return isl_size_error;
+		return cols - 2;
+	}
+	if (type == isl_dim_set) {
+		isl_size total, n_div;
+
+		total = isl_local_dim(local, isl_dim_all);
+		n_div = isl_local_dim(local, isl_dim_div);
+		if (total < 0 || n_div < 0)
+			return isl_size_error;
+		return total - n_div;
+	}
+	isl_die(isl_local_get_ctx(local), isl_error_unsupported,
+		"unsupported dimension type", return isl_size_error);
+}
+
+#undef TYPE
+#define TYPE	isl_local
+static
+#include "check_type_range_templ.c"
+
+/* Check that "pos" is a valid position for a variable in "local".
+ */
+static isl_stat isl_local_check_pos(__isl_keep isl_local *local, int pos)
+{
+	return isl_local_check_range(local, isl_dim_div, pos, 1);
+}
+
+/* Given local variables "local",
+ * is the variable at position "pos" marked as not having
+ * an explicit representation?
+ * Note that even if this variable is not marked in this way and therefore
+ * does have an explicit representation, this representation may still
+ * depend (indirectly) on other local variables that do not
+ * have an explicit representation.
+ */
+isl_bool isl_local_div_is_marked_unknown(__isl_keep isl_local *local, int pos)
+{
+	isl_mat *mat = local;
+
+	if (isl_local_check_pos(local, pos) < 0)
+		return isl_bool_error;
+	return isl_bool_ok(isl_int_is_zero(mat->rowpos0));
+}
+
+/* Given local variables "local",
+ * does the variable at position "pos" have a complete explicit representation?
+ * Having a complete explicit representation requires not only
+ * an explicit representation, but also that all local variables
+ * that appear in this explicit representation in turn have
+ * a complete explicit representation.
+ */
+isl_bool isl_local_div_is_known(__isl_keep isl_local *local, int pos)
+{
+	isl_bool marked;
+	int i, off;
+	isl_size n, cols;
+	isl_mat *mat = local;
+
+	if (isl_local_check_pos(local, pos) < 0)
+		return isl_bool_error;
+
+	marked = isl_local_div_is_marked_unknown(local, pos);
+	if (marked < 0 || marked)
+		return isl_bool_not(marked);
+
+	n = isl_local_dim(local, isl_dim_div);
+	cols = isl_mat_cols(mat);
+	if (n < 0 || cols < 0)
+		return isl_bool_error;
+	off = cols - n;
+
+	for (i = n - 1; i >= 0; --i) {
+		isl_bool known;
+
+		if (isl_int_is_zero(mat->rowposoff + i))
+			continue;
+		known = isl_local_div_is_known(local, i);
+		if (known < 0 || !known)
+			return known;
+	}
+
+	return isl_bool_true;
+}
+
+/* Does "local" have an explicit representation for all local variables?
+ */
+isl_bool isl_local_divs_known(__isl_keep isl_local *local)
+{
+	int i;
+	isl_size n;
+
+	n = isl_local_dim(local, isl_dim_div);
+	if (n < 0)
+		return isl_bool_error;
+
+	for (i = 0; i < n; ++i) {
+		isl_bool unknown = isl_local_div_is_marked_unknown(local, i);
+		if (unknown < 0 || unknown)
+			return isl_bool_not(unknown);
+	}
+
+	return isl_bool_true;
+}
+
+/* Compare two sets of local variables, defined over
+ * the same space.
+ *
+ * Return -1 if "local1" is "smaller" than "local2", 1 if "local1" is "greater"
+ * than "local2" and 0 if they are equal.
+ *
+ * The order is fairly arbitrary.  We do "prefer" divs that only involve
+ * earlier dimensions in the sense that we consider matrices where
+ * the first differing div involves earlier dimensions to be smaller.
+ */
+int isl_local_cmp(__isl_keep isl_local *local1, __isl_keep isl_local *local2)
+{
+	int i;
+	int cmp;
+	isl_bool unknown1, unknown2;
+	int last1, last2;
+	isl_size n_col;
+	isl_mat *mat1 = local1;
+	isl_mat *mat2 = local2;
+
+	if (local1 == local2)
+		return 0;
+	if (!local1)
+		return -1;
+	if (!local2)
+		return 1;
+
+	if (mat1->n_row != mat2->n_row)
+		return mat1->n_row - mat2->n_row;
+
+	n_col = isl_mat_cols(mat1);
+	if (n_col < 0)
+		return -1;
+	for (i = 0; i < mat1->n_row; ++i) {
+		unknown1 = isl_local_div_is_marked_unknown(local1, i);
+		unknown2 = isl_local_div_is_marked_unknown(local2, i);
+		if (unknown1 && unknown2)
+			continue;
+		if (unknown1)
+			return 1;
+		if (unknown2)
+			return -1;
+		last1 = isl_seq_last_non_zero(mat1->rowi + 1, n_col - 1);
+		last2 = isl_seq_last_non_zero(mat2->rowi + 1, n_col - 1);
+		if (last1 != last2)
+			return last1 - last2;
+		cmp = isl_seq_cmp(mat1->rowi, mat2->rowi, n_col);
+		if (cmp != 0)
+			return cmp;
+	}
+
+	return 0;
+}
+
+/* Reorder the columns of the given local variables according to the
+ * given reordering.
+ * The order of the local variables themselves is assumed not to change.
+ */
+__isl_give isl_local *isl_local_reorder(__isl_take isl_local *local,
+	__isl_take isl_reordering *r)
+{
+	isl_mat *div = local;
+	int i, j;
+	isl_size dim;
+	isl_space *space;
+	isl_mat *mat;
+	int extra;
+
+	if (!local || !r)
+		goto error;
+
+	space = isl_reordering_peek_space(r);
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		goto error;
+	extra = dim + div->n_row - r->len;
+	mat = isl_mat_alloc(div->ctx, div->n_row, div->n_col + extra);
+	if (!mat)
+		goto error;
+
+	for (i = 0; i < div->n_row; ++i) {
+		isl_seq_cpy(mat->rowi, div->rowi, 2);
+		isl_seq_clr(mat->rowi + 2, mat->n_col - 2);
+		for (j = 0; j < r->len; ++j)
+			isl_int_set(mat->rowi2 + r->posj,
+				    div->rowi2 + j);
+	}
+
+	isl_reordering_free(r);
+	isl_local_free(local);
+	return isl_local_alloc_from_mat(mat);
+error:
+	isl_reordering_free(r);
+	isl_local_free(local);
+	return NULL;
+}
+
+/* Extend a vector "v" representing an integer point
+ * in the domain space of "local"
+ * to one that also includes values for the local variables.
+ * All local variables are required to have an explicit representation.
+ * If there are no local variables, then the point is not required
+ * to be integral.
+ */
+__isl_give isl_vec *isl_local_extend_point_vec(__isl_keep isl_local *local,
+	__isl_take isl_vec *v)
+{
+	isl_size dim, n_div, size;
+	isl_bool known;
+	isl_mat *mat = local;
+
+	if (!local || !v)
+		return isl_vec_free(v);
+	known = isl_local_divs_known(local);
+	if (known < 0)
+		return isl_vec_free(v);
+	if (!known)
+		isl_die(isl_local_get_ctx(local), isl_error_invalid,
+			"unknown local variables", return isl_vec_free(v));
+	dim = isl_local_dim(local, isl_dim_set);
+	n_div = isl_local_dim(local, isl_dim_div);
+	size = isl_vec_size(v);
+	if (dim < 0 || n_div < 0 || size < 0)
+		return isl_vec_free(v);
+	if (size != 1 + dim)
+		isl_die(isl_local_get_ctx(local), isl_error_invalid,
+			"incorrect size", return isl_vec_free(v));
+	if (n_div == 0)
+		return v;
+	if (!isl_int_is_one(v->el0))
+		isl_die(isl_local_get_ctx(local), isl_error_invalid,
+			"expecting integer point", return isl_vec_free(v));
+	{
+		int i;
+		v = isl_vec_add_els(v, n_div);
+		if (!v)
+			return NULL;
+
+		for (i = 0; i < n_div; ++i) {
+			isl_seq_inner_product(mat->rowi + 1, v->el,
+						1 + dim + i, &v->el1+dim+i);
+			isl_int_fdiv_q(v->el1+dim+i, v->el1+dim+i,
+					mat->rowi0);
+		}
+	}
+
+	return v;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_local.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_local_private.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_local_space.c -> _service:tar_scm:isl-0.24.tar.gz/isl_local_space.c Changed

@@ -11,65 +11,89 @@
  */
 
 #include <isl_ctx_private.h>
+#include <isl/id.h>
 #include <isl_map_private.h>
 #include <isl_local_space_private.h>
 #include <isl_space_private.h>
 #include <isl_mat_private.h>
 #include <isl_aff_private.h>
 #include <isl_vec_private.h>
+#include <isl_point_private.h>
 #include <isl_seq.h>
+#include <isl_local.h>
 
 isl_ctx *isl_local_space_get_ctx(__isl_keep isl_local_space *ls)
 {
 	return ls ? ls->dim->ctx : NULL;
 }
 
-__isl_give isl_local_space *isl_local_space_alloc_div(__isl_take isl_space *dim,
-	__isl_take isl_mat *div)
+/* Return a hash value that digests "ls".
+ */
+uint32_t isl_local_space_get_hash(__isl_keep isl_local_space *ls)
+{
+	uint32_t hash, space_hash, div_hash;
+
+	if (!ls)
+		return 0;
+
+	hash = isl_hash_init();
+	space_hash = isl_space_get_full_hash(isl_local_space_peek_space(ls));
+	isl_hash_hash(hash, space_hash);
+	div_hash = isl_mat_get_hash(ls->div);
+	isl_hash_hash(hash, div_hash);
+
+	return hash;
+}
+
+__isl_give isl_local_space *isl_local_space_alloc_div(
+	__isl_take isl_space *space, __isl_take isl_mat *div)
 {
 	isl_ctx *ctx;
 	isl_local_space *ls = NULL;
 
-	if (!dim || !div)
+	if (!space || !div)
 		goto error;
 
-	ctx = isl_space_get_ctx(dim);
+	ctx = isl_space_get_ctx(space);
 	ls = isl_calloc_type(ctx, struct isl_local_space);
 	if (!ls)
 		goto error;
 
 	ls->ref = 1;
-	ls->dim = dim;
+	ls->dim = space;
 	ls->div = div;
 
 	return ls;
 error:
 	isl_mat_free(div);
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_local_space_free(ls);
 	return NULL;
 }
 
-__isl_give isl_local_space *isl_local_space_alloc(__isl_take isl_space *dim,
+__isl_give isl_local_space *isl_local_space_alloc(__isl_take isl_space *space,
 	unsigned n_div)
 {
 	isl_ctx *ctx;
 	isl_mat *div;
-	unsigned total;
+	isl_size total;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	total = isl_space_dim(dim, isl_dim_all);
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0)
+		return isl_local_space_from_space(isl_space_free(space));
 
-	ctx = isl_space_get_ctx(dim);
+	ctx = isl_space_get_ctx(space);
 	div = isl_mat_alloc(ctx, n_div, 1 + 1 + total + n_div);
-	return isl_local_space_alloc_div(dim, div);
+	return isl_local_space_alloc_div(space, div);
 }
 
-__isl_give isl_local_space *isl_local_space_from_space(__isl_take isl_space *dim)
+__isl_give isl_local_space *isl_local_space_from_space(
+	__isl_take isl_space *space)
 {
-	return isl_local_space_alloc(dim, 0);
+	return isl_local_space_alloc(space, 0);
 }
 
 __isl_give isl_local_space *isl_local_space_copy(__isl_keep isl_local_space *ls)
@@ -119,32 +143,60 @@
 	return NULL;
 }
 
+/* Is the local space that of a parameter domain?
+ */
+isl_bool isl_local_space_is_params(__isl_keep isl_local_space *ls)
+{
+	if (!ls)
+		return isl_bool_error;
+	return isl_space_is_params(ls->dim);
+}
+
 /* Is the local space that of a set?
  */
-int isl_local_space_is_set(__isl_keep isl_local_space *ls)
+isl_bool isl_local_space_is_set(__isl_keep isl_local_space *ls)
+{
+	return ls ? isl_space_is_set(ls->dim) : isl_bool_error;
+}
+
+#undef TYPE
+#define TYPE	isl_local_space
+
+#include "isl_type_has_equal_space_bin_templ.c"
+#include "isl_type_has_space_templ.c"
+
+/* Check that the space of "ls" is equal to "space".
+ */
+static isl_stat isl_local_space_check_has_space(__isl_keep isl_local_space *ls,
+	__isl_keep isl_space *space)
 {
-	return ls ? isl_space_is_set(ls->dim) : -1;
+	isl_bool ok;
+
+	ok = isl_local_space_has_space(ls, space);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
+			"spaces don't match", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 /* Return true if the two local spaces are identical, with identical
  * expressions for the integer divisions.
  */
-int isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
+isl_bool isl_local_space_is_equal(__isl_keep isl_local_space *ls1,
 	__isl_keep isl_local_space *ls2)
 {
-	int equal;
+	isl_bool equal;
 
-	if (!ls1 || !ls2)
-		return -1;
-
-	equal = isl_space_is_equal(ls1->dim, ls2->dim);
+	equal = isl_local_space_has_equal_space(ls1, ls2);
 	if (equal < 0 || !equal)
 		return equal;
 
 	if (!isl_local_space_divs_known(ls1))
-		return 0;
+		return isl_bool_false;
 	if (!isl_local_space_divs_known(ls2))
-		return 0;
+		return isl_bool_false;
 
 	return isl_mat_is_equal(ls1->div, ls2->div);
 }
@@ -153,19 +205,11 @@
  *
  * Return -1 if "ls1" is "smaller" than "ls2", 1 if "ls1" is "greater"
  * than "ls2" and 0 if they are equal.
- *
- * The order is fairly arbitrary.  We do "prefer" divs that only involve
- * earlier dimensions in the sense that we consider local spaces where
- * the first differing div involves earlier dimensions to be smaller.
  */
 int isl_local_space_cmp(__isl_keep isl_local_space *ls1,
 	__isl_keep isl_local_space *ls2)
 {
-	int i;
 	int cmp;
-	int known1, known2;
-	int last1, last2;
-	int n_col;
 
 	if (ls1 == ls2)
 		return 0;
@@ -178,68 +222,69 @@
 	if (cmp != 0)
 		return cmp;
 
-	if (ls1->div->n_row != ls2->div->n_row)
-		return ls1->div->n_row - ls2->div->n_row;
-
-	n_col = isl_mat_cols(ls1->div);
-	for (i = 0; i < ls1->div->n_row; ++i) {
-		known1 = isl_local_space_div_is_known(ls1, i);
-		known2 = isl_local_space_div_is_known(ls2, i);
-		if (!known1 && !known2)
-			continue;
-		if (!known1)
-			return 1;
-		if (!known2)
-			return -1;
-		last1 = isl_seq_last_non_zero(ls1->div->rowi + 1, n_col - 1);
-		last2 = isl_seq_last_non_zero(ls2->div->rowi + 1, n_col - 1);
-		if (last1 != last2)
-			return last1 - last2;
-		cmp = isl_seq_cmp(ls1->div->rowi, ls2->div->rowi, n_col);
-		if (cmp != 0)
-			return cmp;
-	}
-
-	return 0;
+	return isl_local_cmp(ls1->div, ls2->div);
 }
 
-int isl_local_space_dim(__isl_keep isl_local_space *ls,
+isl_size isl_local_space_dim(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type)
 {
 	if (!ls)
-		return 0;
+		return isl_size_error;
 	if (type == isl_dim_div)
 		return ls->div->n_row;
-	if (type == isl_dim_all)
-		return isl_space_dim(ls->dim, isl_dim_all) + ls->div->n_row;
+	if (type == isl_dim_all) {
+		isl_size dim = isl_space_dim(ls->dim, isl_dim_all);
+		if (dim < 0)
+			return isl_size_error;
+		return dim + ls->div->n_row;
+	}
 	return isl_space_dim(ls->dim, type);
 }
 
+#undef TYPE
+#define TYPE	isl_local_space
+#include "check_type_range_templ.c"
+
 unsigned isl_local_space_offset(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type)
 {
-	isl_space *dim;
+	isl_space *space;
 
 	if (!ls)
 		return 0;
 
-	dim = ls->dim;
+	space = ls->dim;
 	switch (type) {
 	case isl_dim_cst:	return 0;
 	case isl_dim_param:	return 1;
-	case isl_dim_in:	return 1 + dim->nparam;
-	case isl_dim_out:	return 1 + dim->nparam + dim->n_in;
-	case isl_dim_div:	return 1 + dim->nparam + dim->n_in + dim->n_out;
+	case isl_dim_in:	return 1 + space->nparam;
+	case isl_dim_out:	return 1 + space->nparam + space->n_in;
+	case isl_dim_div:
+		return 1 + space->nparam + space->n_in + space->n_out;
 	default:		return 0;
 	}
 }
 
+/* Return the position of the dimension of the given type and name
+ * in "ls".
+ * Return -1 if no such dimension can be found.
+ */
+int isl_local_space_find_dim_by_name(__isl_keep isl_local_space *ls,
+	enum isl_dim_type type, const char *name)
+{
+	if (!ls)
+		return -1;
+	if (type == isl_dim_div)
+		return -1;
+	return isl_space_find_dim_by_name(ls->dim, type, name);
+}
+
 /* Does the given dimension have a name?
  */
-int isl_local_space_has_dim_name(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_has_dim_name(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos)
 {
-	return ls ? isl_space_has_dim_name(ls->dim, type, pos) : -1;
+	return ls ? isl_space_has_dim_name(ls->dim, type, pos) : isl_bool_error;
 }
 
 const char *isl_local_space_get_dim_name(__isl_keep isl_local_space *ls,
@@ -248,10 +293,10 @@
 	return ls ? isl_space_get_dim_name(ls->dim, type, pos) : NULL;
 }
 
-int isl_local_space_has_dim_id(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_has_dim_id(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos)
 {
-	return ls ? isl_space_has_dim_id(ls->dim, type, pos) : -1;
+	return ls ? isl_space_has_dim_id(ls->dim, type, pos) : isl_bool_error;
 }
 
 __isl_give isl_id *isl_local_space_get_dim_id(__isl_keep isl_local_space *ls,
@@ -260,10 +305,65 @@
 	return ls ? isl_space_get_dim_id(ls->dim, type, pos) : NULL;
 }
 
+/* Return the argument of the integer division at position "pos" in "ls".
+ * All local variables in "ls" are known to have a (complete) explicit
+ * representation.
+ */
+static __isl_give isl_aff *extract_div(__isl_keep isl_local_space *ls, int pos)
+{
+	isl_aff *aff;
+
+	aff = isl_aff_alloc(isl_local_space_copy(ls));
+	if (!aff)
+		return NULL;
+	isl_seq_cpy(aff->v->el, ls->div->rowpos, aff->v->size);
+	return aff;
+}
+
+/* Return the argument of the integer division at position "pos" in "ls".
+ * The integer division at that position is known to have a complete
+ * explicit representation, but some of the others do not.
+ * Remove them first because the domain of an isl_aff
+ * is not allowed to have unknown local variables.
+ */
+static __isl_give isl_aff *drop_unknown_divs_and_extract_div(
+	__isl_keep isl_local_space *ls, int pos)
+{
+	int i;
+	isl_size n;
+	isl_bool unknown;
+	isl_aff *aff;
+
+	n = isl_local_space_dim(ls, isl_dim_div);
+	if (n < 0)
+		return NULL;
+	ls = isl_local_space_copy(ls);
+	for (i = n - 1; i >= 0; --i) {
+		unknown = isl_local_space_div_is_marked_unknown(ls, i);
+		if (unknown < 0)
+			ls = isl_local_space_free(ls);
+		else if (!unknown)
+			continue;
+		ls = isl_local_space_drop_dims(ls, isl_dim_div, i, 1);
+		if (pos > i)
+			--pos;
+	}
+	aff = extract_div(ls, pos);
+	isl_local_space_free(ls);
+	return aff;
+}
+
+/* Return the argument of the integer division at position "pos" in "ls".
+ * The integer division is assumed to have a complete explicit
+ * representation.  If some of the other integer divisions
+ * do not have an explicit representation, then they need
+ * to be removed first because the domain of an isl_aff
+ * is not allowed to have unknown local variables.
+ */
 __isl_give isl_aff *isl_local_space_get_div(__isl_keep isl_local_space *ls,
 	int pos)
 {
-	isl_aff *aff;
+	isl_bool known;
 
 	if (!ls)
 		return NULL;
@@ -272,26 +372,96 @@
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"index out of bounds", return NULL);
 
-	if (isl_int_is_zero(ls->div->rowpos0))
+	known = isl_local_space_div_is_known(ls, pos);
+	if (known < 0)
+		return NULL;
+	if (!known)
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"expression of div unknown", return NULL);
 	if (!isl_local_space_is_set(ls))
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"cannot represent divs of map spaces", return NULL);
 
-	aff = isl_aff_alloc(isl_local_space_copy(ls));
-	if (!aff)
+	known = isl_local_space_divs_known(ls);
+	if (known < 0)
 		return NULL;
-	isl_seq_cpy(aff->v->el, ls->div->rowpos, aff->v->size);
-	return aff;
+	if (known)
+		return extract_div(ls, pos);
+	else
+		return drop_unknown_divs_and_extract_div(ls, pos);
+}
+
+/* Return the space of "ls".
+ */
+__isl_keep isl_space *isl_local_space_peek_space(__isl_keep isl_local_space *ls)
+{
+	if (!ls)
+		return NULL;
+
+	return ls->dim;
 }
 
 __isl_give isl_space *isl_local_space_get_space(__isl_keep isl_local_space *ls)
 {
+	return isl_space_copy(isl_local_space_peek_space(ls));
+}
+
+/* Return the space of "ls".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "ls".
+ * This allows the space to be modified inplace
+ * if both the local space and its space have only a single reference.
+ * The caller is not allowed to modify "ls" between this call and
+ * a subsequent call to isl_local_space_restore_space.
+ * The only exception is that isl_local_space_free can be called instead.
+ */
+__isl_give isl_space *isl_local_space_take_space(__isl_keep isl_local_space *ls)
+{
+	isl_space *space;
+
 	if (!ls)
 		return NULL;
+	if (ls->ref != 1)
+		return isl_local_space_get_space(ls);
+	space = ls->dim;
+	ls->dim = NULL;
+	return space;
+}
+
+/* Set the space of "ls" to "space", where the space of "ls" may be missing
+ * due to a preceding call to isl_local_space_take_space.
+ * However, in this case, "ls" only has a single reference and
+ * then the call to isl_local_space_cow has no effect.
+ */
+__isl_give isl_local_space *isl_local_space_restore_space(
+	__isl_take isl_local_space *ls, __isl_take isl_space *space)
+{
+	if (!ls || !space)
+		goto error;
+
+	if (ls->dim == space) {
+		isl_space_free(space);
+		return ls;
+	}
+
+	ls = isl_local_space_cow(ls);
+	if (!ls)
+		goto error;
+	isl_space_free(ls->dim);
+	ls->dim = space;
+
+	return ls;
+error:
+	isl_local_space_free(ls);
+	isl_space_free(space);
+	return NULL;
+}
 
-	return isl_space_copy(ls->dim);
+/* Return the local variables of "ls".
+ */
+__isl_keep isl_local *isl_local_space_peek_local(__isl_keep isl_local_space *ls)
+{
+	return ls ? ls->div : NULL;
 }
 
 /* Replace the identifier of the tuple of type "type" by "id".
@@ -343,56 +513,34 @@
 	return NULL;
 }
 
-__isl_give isl_local_space *isl_local_space_reset_space(
-	__isl_take isl_local_space *ls, __isl_take isl_space *dim)
+/* Construct a zero-dimensional local space with the given parameter domain.
+ */
+__isl_give isl_local_space *isl_local_space_set_from_params(
+	__isl_take isl_local_space *ls)
 {
-	ls = isl_local_space_cow(ls);
-	if (!ls || !dim)
-		goto error;
+	isl_space *space;
 
-	isl_space_free(ls->dim);
-	ls->dim = dim;
+	space = isl_local_space_take_space(ls);
+	space = isl_space_set_from_params(space);
+	ls = isl_local_space_restore_space(ls, space);
 
 	return ls;
-error:
-	isl_local_space_free(ls);
-	isl_space_free(dim);
-	return NULL;
 }
 
-/* Reorder the columns of the given div definitions according to the
- * given reordering.
- * The order of the divs themselves is assumed not to change.
- */
-static __isl_give isl_mat *reorder_divs(__isl_take isl_mat *div,
-	__isl_take isl_reordering *r)
+__isl_give isl_local_space *isl_local_space_reset_space(
+	__isl_take isl_local_space *ls, __isl_take isl_space *space)
 {
-	int i, j;
-	isl_mat *mat;
-	int extra;
-
-	if (!div || !r)
-		goto error;
-
-	extra = isl_space_dim(r->dim, isl_dim_all) + div->n_row - r->len;
-	mat = isl_mat_alloc(div->ctx, div->n_row, div->n_col + extra);
-	if (!mat)
+	ls = isl_local_space_cow(ls);
+	if (!ls || !space)
 		goto error;
 
-	for (i = 0; i < div->n_row; ++i) {
-		isl_seq_cpy(mat->rowi, div->rowi, 2);
-		isl_seq_clr(mat->rowi + 2, mat->n_col - 2);
-		for (j = 0; j < r->len; ++j)
-			isl_int_set(mat->rowi2 + r->posj,
-				    div->rowi2 + j);
-	}
+	isl_space_free(ls->dim);
+	ls->dim = space;
 
-	isl_reordering_free(r);
-	isl_mat_free(div);
-	return mat;
+	return ls;
 error:
-	isl_reordering_free(r);
-	isl_mat_free(div);
+	isl_local_space_free(ls);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -407,11 +555,11 @@
 	if (!ls || !r)
 		goto error;
 
-	ls->div = reorder_divs(ls->div, isl_reordering_copy(r));
+	ls->div = isl_local_reorder(ls->div, isl_reordering_copy(r));
 	if (!ls->div)
 		goto error;
 
-	ls = isl_local_space_reset_space(ls, isl_space_copy(r->dim));
+	ls = isl_local_space_reset_space(ls, isl_reordering_get_space(r));
 
 	isl_reordering_free(r);
 	return ls;
@@ -539,7 +687,7 @@
 	__isl_take isl_basic_map *bmap)
 {
 	int i, j;
-	unsigned total;
+	isl_size total;
 
 	bmap = isl_basic_map_order_divs(bmap);
 	if (!bmap)
@@ -547,12 +695,16 @@
 	if (bmap->n_div <= 1)
 		return bmap;
 
-	total = 2 + isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	for (i = 1; i < bmap->n_div; ++i) {
 		for (j = i - 1; j >= 0; --j) {
-			if (bmap_cmp_row(bmap, j, j + 1, total) <= 0)
+			if (bmap_cmp_row(bmap, j, j + 1, 2 + total) <= 0)
 				break;
-			isl_basic_map_swap_div(bmap, j, j + 1);
+			bmap = isl_basic_map_swap_div(bmap, j, j + 1);
+			if (!bmap)
+				return NULL;
 		}
 	}
 
@@ -652,8 +804,8 @@
 	isl_ctx *ctx;
 	int *exp1 = NULL;
 	int *exp2 = NULL;
-	isl_mat *div;
-	int equal;
+	isl_mat *div = NULL;
+	isl_bool equal;
 
 	if (!ls1 || !ls2)
 		goto error;
@@ -700,42 +852,54 @@
 error:
 	free(exp1);
 	free(exp2);
+	isl_mat_free(div);
 	isl_local_space_free(ls1);
 	isl_local_space_free(ls2);
 	return NULL;
 }
 
-/* Does "ls" have an explicit representation for div "div"?
+/* Is the local variable "div" of "ls" marked as not having
+ * an explicit representation?
+ * Note that even if this variable is not marked in this way and therefore
+ * does have an explicit representation, this representation may still
+ * depend (indirectly) on other local variables that do not
+ * have an explicit representation.
  */
-int isl_local_space_div_is_known(__isl_keep isl_local_space *ls, int div)
+isl_bool isl_local_space_div_is_marked_unknown(__isl_keep isl_local_space *ls,
+	int div)
 {
 	if (!ls)
-		return -1;
-	if (div < 0 || div >= ls->div->n_row)
-		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
-			"position out of bounds", return -1);
-	return !isl_int_is_zero(ls->div->rowdiv0);
+		return isl_bool_error;
+	return isl_local_div_is_marked_unknown(ls->div, div);
 }
 
-int isl_local_space_divs_known(__isl_keep isl_local_space *ls)
+/* Does "ls" have a complete explicit representation for div "div"?
+ */
+isl_bool isl_local_space_div_is_known(__isl_keep isl_local_space *ls, int div)
 {
-	int i;
-
 	if (!ls)
-		return -1;
-
-	for (i = 0; i < ls->div->n_row; ++i)
-		if (isl_int_is_zero(ls->div->rowi0))
-			return 0;
+		return isl_bool_error;
+	return isl_local_div_is_known(ls->div, div);
+}
 
-	return 1;
+/* Does "ls" have an explicit representation for all local variables?
+ */
+isl_bool isl_local_space_divs_known(__isl_keep isl_local_space *ls)
+{
+	if (!ls)
+		return isl_bool_error;
+	return isl_local_divs_known(ls->div);
 }
 
 __isl_give isl_local_space *isl_local_space_domain(
 	__isl_take isl_local_space *ls)
 {
-	ls = isl_local_space_drop_dims(ls, isl_dim_out,
-					0, isl_local_space_dim(ls, isl_dim_out));
+	isl_size n_out;
+
+	n_out = isl_local_space_dim(ls, isl_dim_out);
+	if (n_out < 0)
+		return isl_local_space_free(ls);
+	ls = isl_local_space_drop_dims(ls, isl_dim_out, 0, n_out);
 	ls = isl_local_space_cow(ls);
 	if (!ls)
 		return NULL;
@@ -748,8 +912,12 @@
 __isl_give isl_local_space *isl_local_space_range(
 	__isl_take isl_local_space *ls)
 {
-	ls = isl_local_space_drop_dims(ls, isl_dim_in,
-					0, isl_local_space_dim(ls, isl_dim_in));
+	isl_size n_in;
+
+	n_in = isl_local_space_dim(ls, isl_dim_in);
+	if (n_in < 0)
+		return isl_local_space_free(ls);
+	ls = isl_local_space_drop_dims(ls, isl_dim_in, 0, n_in);
 	ls = isl_local_space_cow(ls);
 	if (!ls)
 		return NULL;
@@ -778,17 +946,86 @@
 __isl_give isl_local_space *isl_local_space_add_dims(
 	__isl_take isl_local_space *ls, enum isl_dim_type type, unsigned n)
 {
-	int pos;
+	isl_size pos;
 
-	if (!ls)
-		return NULL;
 	pos = isl_local_space_dim(ls, type);
+	if (pos < 0)
+		return isl_local_space_free(ls);
 	return isl_local_space_insert_dims(ls, type, pos, n);
 }
 
+/* Lift the basic set "bset", living in the space of "ls"
+ * to live in a space with extra coordinates corresponding
+ * to the local variables of "ls".
+ */
+__isl_give isl_basic_set *isl_local_space_lift_basic_set(
+	__isl_take isl_local_space *ls, __isl_take isl_basic_set *bset)
+{
+	isl_size n_local;
+	isl_space *space;
+	isl_basic_set *ls_bset;
+
+	n_local = isl_local_space_dim(ls, isl_dim_div);
+	space = isl_basic_set_peek_space(bset);
+	if (n_local < 0 ||
+	    isl_local_space_check_has_space(ls, space) < 0)
+		goto error;
+
+	if (n_local == 0) {
+		isl_local_space_free(ls);
+		return bset;
+	}
+
+	bset = isl_basic_set_add_dims(bset, isl_dim_set, n_local);
+	ls_bset = isl_basic_set_from_local_space(ls);
+	ls_bset = isl_basic_set_lift(ls_bset);
+	ls_bset = isl_basic_set_flatten(ls_bset);
+	bset = isl_basic_set_intersect(bset, ls_bset);
+
+	return bset;
+error:
+	isl_local_space_free(ls);
+	isl_basic_set_free(bset);
+	return NULL;
+}
+
+/* Lift the set "set", living in the space of "ls"
+ * to live in a space with extra coordinates corresponding
+ * to the local variables of "ls".
+ */
+__isl_give isl_set *isl_local_space_lift_set(__isl_take isl_local_space *ls,
+	__isl_take isl_set *set)
+{
+	isl_size n_local;
+	isl_basic_set *bset;
+
+	n_local = isl_local_space_dim(ls, isl_dim_div);
+	if (n_local < 0 ||
+	    isl_local_space_check_has_space(ls, isl_set_peek_space(set)) < 0)
+		goto error;
+
+	if (n_local == 0) {
+		isl_local_space_free(ls);
+		return set;
+	}
+
+	set = isl_set_add_dims(set, isl_dim_set, n_local);
+	bset = isl_basic_set_from_local_space(ls);
+	bset = isl_basic_set_lift(bset);
+	bset = isl_basic_set_flatten(bset);
+	set = isl_set_intersect(set, isl_set_from_basic_set(bset));
+
+	return set;
+error:
+	isl_local_space_free(ls);
+	isl_set_free(set);
+	return NULL;
+}
+
 /* Remove common factor of non-constant terms and denominator.
  */
-static void normalize_div(__isl_keep isl_local_space *ls, int div)
+static __isl_give isl_local_space *normalize_div(
+	__isl_take isl_local_space *ls, int div)
 {
 	isl_ctx *ctx = ls->div->ctx;
 	unsigned total = ls->div->n_col - 2;
@@ -797,7 +1034,7 @@
 	isl_int_gcd(ctx->normalize_gcd,
 		    ctx->normalize_gcd, ls->div->rowdiv0);
 	if (isl_int_is_one(ctx->normalize_gcd))
-		return;
+		return ls;
 
 	isl_seq_scale_down(ls->div->rowdiv + 2, ls->div->rowdiv + 2,
 			    ctx->normalize_gcd, total);
@@ -805,6 +1042,8 @@
 			    ctx->normalize_gcd);
 	isl_int_fdiv_q(ls->div->rowdiv1, ls->div->rowdiv1,
 			    ctx->normalize_gcd);
+
+	return ls;
 }
 
 /* Exploit the equalities in "eq" to simplify the expressions of
@@ -816,14 +1055,17 @@
 	__isl_take isl_local_space *ls, __isl_take isl_basic_set *eq)
 {
 	int i, j, k;
-	unsigned total;
+	isl_size total, dim;
 	unsigned n_div;
 
 	if (!ls || !eq)
 		goto error;
 
 	total = isl_space_dim(eq->dim, isl_dim_all);
-	if (isl_local_space_dim(ls, isl_dim_all) != total)
+	dim = isl_local_space_dim(ls, isl_dim_all);
+	if (dim < 0 || total < 0)
+		goto error;
+	if (dim != total)
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"spaces don't match", goto error);
 	total++;
@@ -844,7 +1086,9 @@
 				goto error;
 			isl_seq_elim(ls->div->rowk + 1, eq->eqi, j, total,
 					&ls->div->rowk0);
-			normalize_div(ls, k);
+			ls = normalize_div(ls, k);
+			if (!ls)
+				goto error;
 		}
 	}
 
@@ -896,12 +1140,14 @@
 	pos += isl_local_space_offset(ls, type);
 
 	isl_int_init(v);
-	for (i = first; i < ls->div->n_row; ++i) {
+	for (i = first; i < first + n; ++i) {
 		if (isl_int_is_zero(ls->div->rowi1 + pos))
 			continue;
 		isl_seq_substitute(ls->div->rowi, pos, subs,
 			ls->div->n_col, subs_len, v);
-		normalize_div(ls, i);
+		ls = normalize_div(ls, i);
+		if (!ls)
+			break;
 	}
 	isl_int_clear(v);
 
@@ -927,6 +1173,8 @@
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs)
 {
+	isl_size n_div;
+
 	ls = isl_local_space_cow(ls);
 	if (!ls || !subs)
 		return isl_local_space_free(ls);
@@ -934,7 +1182,10 @@
 	if (!isl_space_is_equal(ls->dim, subs->ls->dim))
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"spaces don't match", return isl_local_space_free(ls));
-	if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
+	n_div = isl_local_space_dim(subs->ls, isl_dim_div);
+	if (n_div < 0)
+		return isl_local_space_free(ls);
+	if (n_div != 0)
 		isl_die(isl_local_space_get_ctx(ls), isl_error_unsupported,
 			"cannot handle divs yet",
 			return isl_local_space_free(ls));
@@ -943,11 +1194,11 @@
 					    subs->v->size, 0, ls->div->n_row);
 }
 
-int isl_local_space_is_named_or_nested(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_is_named_or_nested(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type)
 {
 	if (!ls)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_named_or_nested(ls->dim, type);
 }
 
@@ -955,17 +1206,13 @@
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	isl_ctx *ctx;
-
 	if (!ls)
 		return NULL;
 	if (n == 0 && !isl_local_space_is_named_or_nested(ls, type))
 		return ls;
 
-	ctx = isl_local_space_get_ctx(ls);
-	if (first + n > isl_local_space_dim(ls, type))
-		isl_die(ctx, isl_error_invalid, "range out of bounds",
-			return isl_local_space_free(ls));
+	if (isl_local_space_check_range(ls, type, first, n) < 0)
+		return isl_local_space_free(ls);
 
 	ls = isl_local_space_cow(ls);
 	if (!ls)
@@ -991,17 +1238,13 @@
 	__isl_take isl_local_space *ls,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	isl_ctx *ctx;
-
 	if (!ls)
 		return NULL;
 	if (n == 0 && !isl_local_space_is_named_or_nested(ls, type))
 		return ls;
 
-	ctx = isl_local_space_get_ctx(ls);
-	if (first > isl_local_space_dim(ls, type))
-		isl_die(ctx, isl_error_invalid, "position out of bounds",
-			return isl_local_space_free(ls));
+	if (isl_local_space_check_range(ls, type, first, 0) < 0)
+		return isl_local_space_free(ls);
 
 	ls = isl_local_space_cow(ls);
 	if (!ls)
@@ -1023,6 +1266,49 @@
 	return ls;
 }
 
+/* Does the linear part of "constraint" correspond to
+ * integer division "div" in "ls"?
+ *
+ * That is, given div = floor((c + f)/m), is the constraint of the form
+ *
+ *		f - m d + c' >= 0		sign = 1
+ * or
+ *		-f + m d + c'' >= 0		sign = -1
+ * ?
+ * If so, set *sign to the corresponding value.
+ */
+static isl_bool is_linear_div_constraint(__isl_keep isl_local_space *ls,
+	isl_int *constraint, unsigned div, int *sign)
+{
+	isl_bool unknown;
+	unsigned pos;
+
+	unknown = isl_local_space_div_is_marked_unknown(ls, div);
+	if (unknown < 0)
+		return isl_bool_error;
+	if (unknown)
+		return isl_bool_false;
+
+	pos = isl_local_space_offset(ls, isl_dim_div) + div;
+
+	if (isl_int_eq(constraintpos, ls->div->rowdiv0)) {
+		*sign = -1;
+		if (!isl_seq_is_neg(constraint + 1,
+				    ls->div->rowdiv + 2, pos - 1))
+			return isl_bool_false;
+	} else if (isl_int_abs_eq(constraintpos, ls->div->rowdiv0)) {
+		*sign = 1;
+		if (!isl_seq_eq(constraint + 1, ls->div->rowdiv + 2, pos - 1))
+			return isl_bool_false;
+	} else {
+		return isl_bool_false;
+	}
+	if (isl_seq_first_non_zero(constraint + pos + 1,
+				    ls->div->n_row - div - 1) != -1)
+		return isl_bool_false;
+	return isl_bool_true;
+}
+
 /* Check if the constraints pointed to by "constraint" is a div
  * constraint corresponding to div "div" in "ls".
  *
@@ -1031,44 +1317,65 @@
  *		f - m d >= 0
  * or
  *		-(f-(m-1)) + m d >= 0
+ *
+ * First check if the linear part is of the right form and
+ * then check the constant term.
  */
-int isl_local_space_is_div_constraint(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_is_div_constraint(__isl_keep isl_local_space *ls,
 	isl_int *constraint, unsigned div)
 {
-	unsigned pos;
+	int sign;
+	isl_bool linear;
 
-	if (!ls)
-		return -1;
+	linear = is_linear_div_constraint(ls, constraint, div, &sign);
+	if (linear < 0 || !linear)
+		return linear;
 
-	if (isl_int_is_zero(ls->div->rowdiv0))
-		return 0;
-
-	pos = isl_local_space_offset(ls, isl_dim_div) + div;
-
-	if (isl_int_eq(constraintpos, ls->div->rowdiv0)) {
+	if (sign < 0) {
 		int neg;
 		isl_int_sub(ls->div->rowdiv1,
 				ls->div->rowdiv1, ls->div->rowdiv0);
 		isl_int_add_ui(ls->div->rowdiv1, ls->div->rowdiv1, 1);
-		neg = isl_seq_is_neg(constraint, ls->div->rowdiv+1, pos);
+		neg = isl_seq_is_neg(constraint, ls->div->rowdiv + 1, 1);
 		isl_int_sub_ui(ls->div->rowdiv1, ls->div->rowdiv1, 1);
 		isl_int_add(ls->div->rowdiv1,
 				ls->div->rowdiv1, ls->div->rowdiv0);
 		if (!neg)
-			return 0;
-		if (isl_seq_first_non_zero(constraint+pos+1,
-					    ls->div->n_row-div-1) != -1)
-			return 0;
-	} else if (isl_int_abs_eq(constraintpos, ls->div->rowdiv0)) {
-		if (!isl_seq_eq(constraint, ls->div->rowdiv+1, pos))
-			return 0;
-		if (isl_seq_first_non_zero(constraint+pos+1,
-					    ls->div->n_row-div-1) != -1)
-			return 0;
-	} else
-		return 0;
+			return isl_bool_false;
+	} else {
+		if (!isl_int_eq(constraint0, ls->div->rowdiv1))
+			return isl_bool_false;
+	}
 
-	return 1;
+	return isl_bool_true;
+}
+
+/* Is the constraint pointed to by "constraint" one
+ * of an equality that corresponds to integer division "div" in "ls"?
+ *
+ * That is, given an integer division of the form
+ *
+ *	a = floor((f + c)/m)
+ *
+ * is the equality of the form
+ *
+ *		-f + m d + c' = 0
+ * ?
+ * Note that the constant term is not checked explicitly, but given
+ * that this is a valid equality constraint, the constant c' necessarily
+ * has a value close to -c.
+ */
+isl_bool isl_local_space_is_div_equality(__isl_keep isl_local_space *ls,
+	isl_int *constraint, unsigned div)
+{
+	int sign;
+	isl_bool linear;
+
+	linear = is_linear_div_constraint(ls, constraint, div, &sign);
+	if (linear < 0 || !linear)
+		return linear;
+
+	return isl_bool_ok(sign < 0);
 }
 
 /*
@@ -1080,11 +1387,13 @@
 	int i, j;
 	isl_ctx *ctx;
 	int *active = NULL;
-	unsigned total;
+	isl_size total;
 	unsigned offset;
 
 	ctx = isl_local_space_get_ctx(ls);
 	total = isl_local_space_dim(ls, isl_dim_all);
+	if (total < 0)
+		return NULL;
 	active = isl_calloc_array(ctx, int, total);
 	if (total && !active)
 		return NULL;
@@ -1174,7 +1483,7 @@
 	int i;
 	isl_space *space;
 	isl_local_space *res = NULL;
-	int n_div_ls, n_div_ma;
+	isl_size n_div_ls, n_div_ma;
 	isl_int f, c1, c2, g;
 
 	ma = isl_multi_aff_align_divs(ma);
@@ -1185,7 +1494,9 @@
 			"spaces don't match", goto error);
 
 	n_div_ls = isl_local_space_dim(ls, isl_dim_div);
-	n_div_ma = ma->n ? isl_aff_dim(ma->p0, isl_dim_div) : 0;
+	n_div_ma = ma->n ? isl_aff_dim(ma->u.p0, isl_dim_div) : 0;
+	if (n_div_ls < 0 || n_div_ma < 0)
+		goto error;
 
 	space = isl_space_domain(isl_multi_aff_get_space(ma));
 	res = isl_local_space_alloc(space, n_div_ma + n_div_ls);
@@ -1194,7 +1505,7 @@
 
 	if (n_div_ma) {
 		isl_mat_free(res->div);
-		res->div = isl_mat_copy(ma->p0->ls->div);
+		res->div = isl_mat_copy(ma->u.p0->ls->div);
 		res->div = isl_mat_add_zero_cols(res->div, n_div_ls);
 		res->div = isl_mat_add_rows(res->div, n_div_ls);
 		if (!res->div)
@@ -1211,9 +1522,13 @@
 			isl_int_set_si(res->div->rown_div_ma + i0, 0);
 			continue;
 		}
-		isl_seq_preimage(res->div->rown_div_ma + i, ls->div->rowi,
-				ma, 0, 0, n_div_ma, n_div_ls, f, c1, c2, g, 1);
-		normalize_div(res, n_div_ma + i);
+		if (isl_seq_preimage(res->div->rown_div_ma + i,
+			    ls->div->rowi,
+			    ma, 0, 0, n_div_ma, n_div_ls, f, c1, c2, g, 1) < 0)
+			res = isl_local_space_free(res);
+		res = normalize_div(res, n_div_ma + i);
+		if (!res)
+			break;
 	}
 
 	isl_int_clear(f);
@@ -1252,13 +1567,10 @@
 	    !isl_local_space_is_named_or_nested(ls, dst_type))
 		return ls;
 
-	if (src_pos + n > isl_local_space_dim(ls, src_type))
-		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
-			"range out of bounds", return isl_local_space_free(ls));
-	if (dst_pos > isl_local_space_dim(ls, dst_type))
-		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
-			"position out of bounds",
-			return isl_local_space_free(ls));
+	if (isl_local_space_check_range(ls, src_type, src_pos, n) < 0)
+		return isl_local_space_free(ls);
+	if (isl_local_space_check_range(ls, dst_type, dst_pos, 0) < 0)
+		return isl_local_space_free(ls);
 	if (src_type == isl_dim_div)
 		isl_die(isl_local_space_get_ctx(ls), isl_error_invalid,
 			"cannot move divs", return isl_local_space_free(ls));
@@ -1338,3 +1650,58 @@
 
 	return ls;
 }
+
+/* Given the local space "ls" of a map, return the local space of a set
+ * that lives in a space that wraps the space of "ls" and that has
+ * the same divs.
+ */
+__isl_give isl_local_space *isl_local_space_wrap(__isl_take isl_local_space *ls)
+{
+	ls = isl_local_space_cow(ls);
+	if (!ls)
+		return NULL;
+
+	ls->dim = isl_space_wrap(ls->dim);
+	if (!ls->dim)
+		return isl_local_space_free(ls);
+
+	return ls;
+}
+
+/* Lift the point "pnt", living in the (set) space of "ls"
+ * to live in a space with extra coordinates corresponding
+ * to the local variables of "ls".
+ */
+__isl_give isl_point *isl_local_space_lift_point(__isl_take isl_local_space *ls,
+	__isl_take isl_point *pnt)
+{
+	isl_size n_local;
+	isl_space *space;
+	isl_local *local;
+	isl_vec *vec;
+
+	if (isl_local_space_check_has_space(ls, isl_point_peek_space(pnt)) < 0)
+		goto error;
+
+	local = isl_local_space_peek_local(ls);
+	n_local = isl_local_space_dim(ls, isl_dim_div);
+	if (n_local < 0)
+		goto error;
+
+	space = isl_point_take_space(pnt);
+	vec = isl_point_take_vec(pnt);
+
+	space = isl_space_lift(space, n_local);
+	vec = isl_local_extend_point_vec(local, vec);
+
+	pnt = isl_point_restore_vec(pnt, vec);
+	pnt = isl_point_restore_space(pnt, space);
+
+	isl_local_space_free(ls);
+
+	return pnt;
+error:
+	isl_local_space_free(ls);
+	isl_point_free(pnt);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_local_space_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_local_space_private.h Changed

@@ -12,10 +12,18 @@
 	isl_mat *div;
 };
 
-__isl_give isl_local_space *isl_local_space_alloc(__isl_take isl_space *dim,
+isl_stat isl_local_space_check_range(__isl_keep isl_local_space *ls,
+	enum isl_dim_type type, unsigned first, unsigned n);
+
+uint32_t isl_local_space_get_hash(__isl_keep isl_local_space *ls);
+
+__isl_give isl_local_space *isl_local_space_alloc(__isl_take isl_space *space,
 	unsigned n_div);
-__isl_give isl_local_space *isl_local_space_alloc_div(__isl_take isl_space *dim,
-	__isl_take isl_mat *div);
+__isl_give isl_local_space *isl_local_space_alloc_div(
+	__isl_take isl_space *space, __isl_take isl_mat *div);
+
+__isl_keep isl_space *isl_local_space_peek_space(
+	__isl_keep isl_local_space *ls);
 
 __isl_give isl_local_space *isl_local_space_swap_div(
 	__isl_take isl_local_space *ls, int a, int b);
@@ -31,21 +39,32 @@
 
 __isl_give isl_local_space *isl_local_space_replace_divs(
 	__isl_take isl_local_space *ls, __isl_take isl_mat *div);
-int isl_local_space_div_is_known(__isl_keep isl_local_space *ls, int div);
-int isl_local_space_divs_known(__isl_keep isl_local_space *ls);
-
+isl_bool isl_local_space_div_is_marked_unknown(__isl_keep isl_local_space *ls,
+	int div);
+isl_bool isl_local_space_div_is_known(__isl_keep isl_local_space *ls, int div);
+isl_bool isl_local_space_divs_known(__isl_keep isl_local_space *ls);
+
+__isl_give isl_basic_set *isl_local_space_lift_basic_set(
+	__isl_take isl_local_space *ls, __isl_take isl_basic_set *bset);
+__isl_give isl_set *isl_local_space_lift_set(__isl_take isl_local_space *ls,
+	__isl_take isl_set *set);
 __isl_give isl_local_space *isl_local_space_substitute_equalities(
 	__isl_take isl_local_space *ls, __isl_take isl_basic_set *eq);
 
-int isl_local_space_is_named_or_nested(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_is_named_or_nested(__isl_keep isl_local_space *ls,
 	enum isl_dim_type type);
 
+isl_bool isl_local_space_has_equal_space(__isl_keep isl_local_space *ls1,
+	__isl_keep isl_local_space *ls2);
+
 __isl_give isl_local_space *isl_local_space_reset_space(
-	__isl_take isl_local_space *ls, __isl_take isl_space *dim);
+	__isl_take isl_local_space *ls, __isl_take isl_space *space);
 __isl_give isl_local_space *isl_local_space_realign(
 	__isl_take isl_local_space *ls, __isl_take isl_reordering *r);
 
-int isl_local_space_is_div_constraint(__isl_keep isl_local_space *ls,
+isl_bool isl_local_space_is_div_constraint(__isl_keep isl_local_space *ls,
+	isl_int *constraint, unsigned div);
+isl_bool isl_local_space_is_div_equality(__isl_keep isl_local_space *ls,
 	isl_int *constraint, unsigned div);
 
 int *isl_local_space_get_active(__isl_keep isl_local_space *ls, isl_int *l);
@@ -72,4 +91,10 @@
 int isl_local_space_cmp(__isl_keep isl_local_space *ls1,
 	__isl_keep isl_local_space *ls2);
 
+__isl_give isl_point *isl_local_space_lift_point(__isl_take isl_local_space *ls,
+	__isl_take isl_point *pnt);
+
+isl_bool isl_local_space_has_space(__isl_keep isl_local_space *ls,
+	__isl_keep isl_space *space);
+
 #endif

_service:tar_scm:isl-0.14.tar.xz/isl_lp.c -> _service:tar_scm:isl-0.24.tar.gz/isl_lp.c Changed

@@ -19,15 +19,19 @@
 #include <isl_val_private.h>
 #include <isl_vec_private.h>
 
-enum isl_lp_result isl_tab_solve_lp(struct isl_basic_map *bmap, int maximize,
-				      isl_int *f, isl_int denom, isl_int *opt,
-				      isl_int *opt_denom,
-				      struct isl_vec **sol)
+#include <bset_to_bmap.c>
+#include <set_to_map.c>
+
+enum isl_lp_result isl_tab_solve_lp(__isl_keep isl_basic_map *bmap,
+	int maximize, isl_int *f, isl_int denom, isl_int *opt,
+	isl_int *opt_denom, __isl_give isl_vec **sol)
 {
 	struct isl_tab *tab;
 	enum isl_lp_result res;
-	unsigned dim = isl_basic_map_total_dim(bmap);
+	isl_size dim = isl_basic_map_dim(bmap, isl_dim_all);
 
+	if (dim < 0)
+		return isl_lp_error;
 	if (maximize)
 		isl_seq_neg(f, f, 1 + dim);
 
@@ -57,12 +61,11 @@
  * If opt_denom is NULL, then *opt is rounded up (or down)
  * to the nearest integer.
  * The return value reflects the nature of the result (empty, unbounded,
- * minmimal or maximal value returned in *opt).
+ * minimal or maximal value returned in *opt).
  */
-enum isl_lp_result isl_basic_map_solve_lp(struct isl_basic_map *bmap, int max,
-				      isl_int *f, isl_int d, isl_int *opt,
-				      isl_int *opt_denom,
-				      struct isl_vec **sol)
+enum isl_lp_result isl_basic_map_solve_lp(__isl_keep isl_basic_map *bmap,
+	int max, isl_int *f, isl_int d, isl_int *opt, isl_int *opt_denom,
+	__isl_give isl_vec **sol)
 {
 	if (sol)
 		*sol = NULL;
@@ -73,19 +76,18 @@
 	return isl_tab_solve_lp(bmap, max, f, d, opt, opt_denom, sol);
 }
 
-enum isl_lp_result isl_basic_set_solve_lp(struct isl_basic_set *bset, int max,
-				      isl_int *f, isl_int d, isl_int *opt,
-				      isl_int *opt_denom,
-				      struct isl_vec **sol)
+enum isl_lp_result isl_basic_set_solve_lp(__isl_keep isl_basic_set *bset,
+	int max, isl_int *f, isl_int d, isl_int *opt, isl_int *opt_denom,
+	__isl_give isl_vec **sol)
 {
-	return isl_basic_map_solve_lp((struct isl_basic_map *)bset, max,
+	return isl_basic_map_solve_lp(bset_to_bmap(bset), max,
 					f, d, opt, opt_denom, sol);
 }
 
 enum isl_lp_result isl_map_solve_lp(__isl_keep isl_map *map, int max,
 				      isl_int *f, isl_int d, isl_int *opt,
 				      isl_int *opt_denom,
-				      struct isl_vec **sol)
+				      __isl_give isl_vec **sol)
 {
 	int i;
 	isl_int o;
@@ -106,7 +108,9 @@
 		if (map->pi->n_div > max_div)
 			max_div = map->pi->n_div;
 	if (max_div > 0) {
-		unsigned total = isl_space_dim(map->dim, isl_dim_all);
+		isl_size total = isl_map_dim(map, isl_dim_all);
+		if (total < 0)
+			return isl_lp_error;
 		v = isl_vec_alloc(map->ctx, 1 + total + max_div);
 		if (!v)
 			return isl_lp_error;
@@ -194,9 +198,9 @@
 enum isl_lp_result isl_set_solve_lp(__isl_keep isl_set *set, int max,
 				      isl_int *f, isl_int d, isl_int *opt,
 				      isl_int *opt_denom,
-				      struct isl_vec **sol)
+				      __isl_give isl_vec **sol)
 {
-	return isl_map_solve_lp((struct isl_map *)set, max,
+	return isl_map_solve_lp(set_to_map(set), max,
 					f, d, opt, opt_denom, sol);
 }
 
@@ -258,7 +262,7 @@
 	isl_mat *bset_div = NULL;
 	isl_mat *div = NULL;
 	isl_val *res;
-	int bset_n_div, obj_n_div;
+	isl_size bset_n_div, obj_n_div;
 
 	if (!bset || !obj)
 		return NULL;
@@ -270,6 +274,8 @@
 
 	bset_n_div = isl_basic_set_dim(bset, isl_dim_div);
 	obj_n_div = isl_aff_dim(obj, isl_dim_div);
+	if (bset_n_div < 0 || obj_n_div < 0)
+		return NULL;
 	if (bset_n_div == 0 && obj_n_div == 0)
 		return basic_set_opt_lp(bset, max, obj);
 
@@ -317,13 +323,16 @@
 static __isl_give isl_val *isl_basic_set_opt_lp_val(
 	__isl_keep isl_basic_set *bset, int max, __isl_keep isl_aff *obj)
 {
+	isl_bool equal;
 	isl_val *res;
 
 	if (!bset || !obj)
 		return NULL;
 
-	if (isl_space_match(bset->dim, isl_dim_param,
-			    obj->ls->dim, isl_dim_param))
+	equal = isl_basic_set_space_has_equal_params(bset, obj->ls->dim);
+	if (equal < 0)
+		return NULL;
+	if (equal)
 		return isl_basic_set_opt_lp_val_aligned(bset, max, obj);
 
 	bset = isl_basic_set_copy(bset);

_service:tar_scm:isl-0.14.tar.xz/isl_map.c -> _service:tar_scm:isl-0.24.tar.gz/isl_map.c Changed

@@ -3,6 +3,9 @@
  * Copyright 2010      INRIA Saclay
  * Copyright 2012-2014 Ecole Normale Superieure
  * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      INRIA Paris
+ * Copyright 2016      Sven Verdoolaege
+ * Copyright 2018-2019 Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -13,12 +16,17 @@
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
  * B.P. 105 - 78153 Le Chesnay, France
+ * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
+ * CS 42112, 75589 Paris Cedex 12, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
 #include <string.h>
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
 #include <isl_blk.h>
+#include <isl_id_private.h>
+#include <isl/constraint.h>
 #include "isl_space_private.h"
 #include "isl_equalities.h"
 #include <isl_lp_private.h>
@@ -38,35 +46,42 @@
 #include <isl_options_private.h>
 #include <isl_morph.h>
 #include <isl_val_private.h>
-#include <isl/deprecated/map_int.h>
-#include <isl/deprecated/set_int.h>
+#include <isl_printer_private.h>
 
-static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
+#include <set_from_map.c>
+
+/* Treat "bset" as a basic map.
+ * Internally, isl_basic_set is defined to isl_basic_map, so in practice,
+ * this function performs a redundant cast.
+ */
+static __isl_keep const isl_basic_map *const_bset_to_bmap(
+	__isl_keep const isl_basic_set *bset)
 {
-	switch (type) {
-	case isl_dim_param:	return dim->nparam;
-	case isl_dim_in:	return dim->n_in;
-	case isl_dim_out:	return dim->n_out;
-	case isl_dim_all:	return dim->nparam + dim->n_in + dim->n_out;
-	default:		return 0;
-	}
+	return (const isl_basic_map *) bset;
 }
 
-static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
+#undef TYPE
+#define TYPE	isl_basic_map
+#include "has_single_reference_templ.c"
+
+static unsigned pos(__isl_keep isl_space *space, enum isl_dim_type type)
 {
 	switch (type) {
 	case isl_dim_param:	return 1;
-	case isl_dim_in:	return 1 + dim->nparam;
-	case isl_dim_out:	return 1 + dim->nparam + dim->n_in;
+	case isl_dim_in:	return 1 + space->nparam;
+	case isl_dim_out:	return 1 + space->nparam + space->n_in;
 	default:		return 0;
 	}
 }
 
-unsigned isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
+isl_size isl_basic_map_dim(__isl_keep isl_basic_map *bmap,
 				enum isl_dim_type type)
 {
 	if (!bmap)
-		return 0;
+		return isl_size_error;
 	switch (type) {
 	case isl_dim_cst:	return 1;
 	case isl_dim_param:
@@ -78,162 +93,268 @@
 	}
 }
 
-unsigned isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
+/* Return the space of "map".
+ */
+__isl_keep isl_space *isl_map_peek_space(__isl_keep const isl_map *map)
 {
-	return map ? n(map->dim, type) : 0;
+	return map ? map->dim : NULL;
 }
 
-unsigned isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type)
+/* Return the space of "set".
+ */
+__isl_keep isl_space *isl_set_peek_space(__isl_keep isl_set *set)
 {
-	return set ? n(set->dim, type) : 0;
+	return isl_map_peek_space(set_to_map(set));
 }
 
-unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
-					enum isl_dim_type type)
+isl_size isl_map_dim(__isl_keep isl_map *map, enum isl_dim_type type)
+{
+	return isl_space_dim(isl_map_peek_space(map), type);
+}
+
+isl_size isl_set_dim(__isl_keep isl_set *set, enum isl_dim_type type)
+{
+	return isl_map_dim(set_to_map(set), type);
+}
+
+/* Return the position of the variables of the given type
+ * within the sequence of variables of "bmap".
+ */
+isl_size isl_basic_map_var_offset(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type)
+{
+	isl_space *space;
+
+	space = isl_basic_map_peek_space(bmap);
+	if (!space)
+		return isl_size_error;
+
+	switch (type) {
+	case isl_dim_param:
+	case isl_dim_in:
+	case isl_dim_out:	return isl_space_offset(space, type);
+	case isl_dim_div:	return isl_space_dim(space, isl_dim_all);
+	case isl_dim_cst:
+	default:
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"invalid dimension type", return isl_size_error);
+	}
+}
+
+/* Return the position of the variables of the given type
+ * within the sequence of variables of "bset".
+ */
+isl_size isl_basic_set_var_offset(__isl_keep isl_basic_set *bset,
+	enum isl_dim_type type)
+{
+	return isl_basic_map_var_offset(bset_to_bmap(bset), type);
+}
+
+/* Return the position of the coefficients of the variables of the given type
+ * within the sequence of coefficients of "bmap".
+ */
+unsigned isl_basic_map_offset(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type)
 {
-	isl_space *dim = bmap->dim;
 	switch (type) {
 	case isl_dim_cst:	return 0;
-	case isl_dim_param:	return 1;
-	case isl_dim_in:	return 1 + dim->nparam;
-	case isl_dim_out:	return 1 + dim->nparam + dim->n_in;
-	case isl_dim_div:	return 1 + dim->nparam + dim->n_in + dim->n_out;
+	case isl_dim_param:
+	case isl_dim_in:
+	case isl_dim_out:
+	case isl_dim_div:	return 1 + isl_basic_map_var_offset(bmap, type);
 	default:		return 0;
 	}
 }
 
-unsigned isl_basic_set_offset(struct isl_basic_set *bset,
+unsigned isl_basic_set_offset(__isl_keep isl_basic_set *bset,
 					enum isl_dim_type type)
 {
 	return isl_basic_map_offset(bset, type);
 }
 
-static unsigned map_offset(struct isl_map *map, enum isl_dim_type type)
+static unsigned map_offset(__isl_keep isl_map *map, enum isl_dim_type type)
 {
 	return pos(map->dim, type);
 }
 
-unsigned isl_basic_set_dim(__isl_keep isl_basic_set *bset,
+isl_size isl_basic_set_dim(__isl_keep isl_basic_set *bset,
 				enum isl_dim_type type)
 {
 	return isl_basic_map_dim(bset, type);
 }
 
-unsigned isl_basic_set_n_dim(__isl_keep isl_basic_set *bset)
+isl_size isl_basic_set_n_dim(__isl_keep isl_basic_set *bset)
 {
 	return isl_basic_set_dim(bset, isl_dim_set);
 }
 
-unsigned isl_basic_set_n_param(__isl_keep isl_basic_set *bset)
+isl_size isl_basic_set_n_param(__isl_keep isl_basic_set *bset)
 {
 	return isl_basic_set_dim(bset, isl_dim_param);
 }
 
-unsigned isl_basic_set_total_dim(const struct isl_basic_set *bset)
+isl_size isl_basic_set_total_dim(__isl_keep const isl_basic_set *bset)
 {
-	if (!bset)
-		return 0;
-	return isl_space_dim(bset->dim, isl_dim_all) + bset->n_div;
+	return isl_basic_map_total_dim(const_bset_to_bmap(bset));
 }
 
-unsigned isl_set_n_dim(__isl_keep isl_set *set)
+isl_size isl_set_n_dim(__isl_keep isl_set *set)
 {
 	return isl_set_dim(set, isl_dim_set);
 }
 
-unsigned isl_set_n_param(__isl_keep isl_set *set)
+isl_size isl_set_n_param(__isl_keep isl_set *set)
 {
 	return isl_set_dim(set, isl_dim_param);
 }
 
-unsigned isl_basic_map_n_in(const struct isl_basic_map *bmap)
+isl_size isl_basic_map_total_dim(__isl_keep const isl_basic_map *bmap)
 {
-	return bmap ? bmap->dim->n_in : 0;
+	isl_size dim;
+
+	if (!bmap)
+		return isl_size_error;
+	dim = isl_space_dim(bmap->dim, isl_dim_all);
+	if (dim < 0)
+		return isl_size_error;
+	return dim + bmap->n_div;
+}
+
+/* Return the number of equality constraints in the description of "bmap".
+ * Return isl_size_error on error.
+ */
+isl_size isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap)
+{
+	if (!bmap)
+		return isl_size_error;
+	return bmap->n_eq;
 }
 
-unsigned isl_basic_map_n_out(const struct isl_basic_map *bmap)
+/* Return the number of equality constraints in the description of "bset".
+ * Return isl_size_error on error.
+ */
+isl_size isl_basic_set_n_equality(__isl_keep isl_basic_set *bset)
 {
-	return bmap ? bmap->dim->n_out : 0;
+	return isl_basic_map_n_equality(bset_to_bmap(bset));
 }
 
-unsigned isl_basic_map_n_param(const struct isl_basic_map *bmap)
+/* Return the number of inequality constraints in the description of "bmap".
+ * Return isl_size_error on error.
+ */
+isl_size isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap)
+{
+	if (!bmap)
+		return isl_size_error;
+	return bmap->n_ineq;
+}
+
+/* Return the number of inequality constraints in the description of "bset".
+ * Return isl_size_error on error.
+ */
+isl_size isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset)
 {
-	return bmap ? bmap->dim->nparam : 0;
+	return isl_basic_map_n_inequality(bset_to_bmap(bset));
 }
 
-unsigned isl_basic_map_n_div(const struct isl_basic_map *bmap)
+/* Do "bmap1" and "bmap2" have the same parameters?
+ */
+static isl_bool isl_basic_map_has_equal_params(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
 {
-	return bmap ? bmap->n_div : 0;
+	isl_space *space1, *space2;
+
+	space1 = isl_basic_map_peek_space(bmap1);
+	space2 = isl_basic_map_peek_space(bmap2);
+	return isl_space_has_equal_params(space1, space2);
 }
 
-unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap)
+/* Do "map1" and "map2" have the same parameters?
+ */
+isl_bool isl_map_has_equal_params(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
 {
-	return bmap ? isl_space_dim(bmap->dim, isl_dim_all) + bmap->n_div : 0;
+	isl_space *space1, *space2;
+
+	space1 = isl_map_peek_space(map1);
+	space2 = isl_map_peek_space(map2);
+	return isl_space_has_equal_params(space1, space2);
 }
 
-unsigned isl_map_n_in(const struct isl_map *map)
+/* Do "map" and "set" have the same parameters?
+ */
+static isl_bool isl_map_set_has_equal_params(__isl_keep isl_map *map,
+	__isl_keep isl_set *set)
 {
-	return map ? map->dim->n_in : 0;
+	return isl_map_has_equal_params(map, set_to_map(set));
 }
 
-unsigned isl_map_n_out(const struct isl_map *map)
+/* Is the tuple of type "type" of "bmap" the same as the single tuple of "bset"?
+ */
+static isl_bool isl_basic_map_set_tuple_is_equal(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type, __isl_keep isl_basic_set *bset)
 {
-	return map ? map->dim->n_out : 0;
+	isl_space *bmap_space, *bset_space;
+
+	bmap_space = isl_basic_map_peek_space(bmap);
+	bset_space = isl_basic_set_peek_space(bset);
+	return isl_space_tuple_is_equal(bmap_space, type,
+					bset_space, isl_dim_set);
 }
 
-unsigned isl_map_n_param(const struct isl_map *map)
+/* Is the tuple of type "type" of "map" the same as the single tuple of "set"?
+ */
+static isl_bool isl_map_set_tuple_is_equal(__isl_keep isl_map *map,
+	enum isl_dim_type type, __isl_keep isl_set *set)
 {
-	return map ? map->dim->nparam : 0;
+	return isl_map_tuple_is_equal(map, type, set_to_map(set), isl_dim_set);
 }
 
-int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set)
+isl_bool isl_map_compatible_domain(__isl_keep isl_map *map,
+	__isl_keep isl_set *set)
 {
-	int m;
+	isl_bool m;
 	if (!map || !set)
-		return -1;
-	m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param);
+		return isl_bool_error;
+	m = isl_map_has_equal_params(map, set_to_map(set));
 	if (m < 0 || !m)
 		return m;
-	return isl_space_tuple_is_equal(map->dim, isl_dim_in,
-					set->dim, isl_dim_set);
+	return isl_map_set_tuple_is_equal(map, isl_dim_in, set);
 }
 
-int isl_basic_map_compatible_domain(struct isl_basic_map *bmap,
-		struct isl_basic_set *bset)
+isl_bool isl_basic_map_compatible_domain(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *bset)
 {
-	int m;
+	isl_bool m;
 	if (!bmap || !bset)
-		return -1;
-	m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param);
+		return isl_bool_error;
+	m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
 	if (m < 0 || !m)
 		return m;
-	return isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
-					bset->dim, isl_dim_set);
+	return isl_basic_map_set_tuple_is_equal(bmap, isl_dim_in, bset);
 }
 
-int isl_map_compatible_range(__isl_keep isl_map *map, __isl_keep isl_set *set)
+isl_bool isl_map_compatible_range(__isl_keep isl_map *map,
+	__isl_keep isl_set *set)
 {
-	int m;
+	isl_bool m;
 	if (!map || !set)
-		return -1;
-	m = isl_space_match(map->dim, isl_dim_param, set->dim, isl_dim_param);
+		return isl_bool_error;
+	m = isl_map_has_equal_params(map, set_to_map(set));
 	if (m < 0 || !m)
 		return m;
-	return isl_space_tuple_is_equal(map->dim, isl_dim_out,
-					set->dim, isl_dim_set);
+	return isl_map_set_tuple_is_equal(map, isl_dim_out, set);
 }
 
-int isl_basic_map_compatible_range(struct isl_basic_map *bmap,
-		struct isl_basic_set *bset)
+isl_bool isl_basic_map_compatible_range(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *bset)
 {
-	int m;
+	isl_bool m;
 	if (!bmap || !bset)
-		return -1;
-	m = isl_space_match(bmap->dim, isl_dim_param, bset->dim, isl_dim_param);
+		return isl_bool_error;
+	m = isl_basic_map_has_equal_params(bmap, bset_to_bmap(bset));
 	if (m < 0 || !m)
 		return m;
-	return isl_space_tuple_is_equal(bmap->dim, isl_dim_out,
-					bset->dim, isl_dim_set);
+	return isl_basic_map_set_tuple_is_equal(bmap, isl_dim_out, bset);
 }
 
 isl_ctx *isl_basic_map_get_ctx(__isl_keep isl_basic_map *bmap)
@@ -256,18 +377,81 @@
 	return set ? set->ctx : NULL;
 }
 
+/* Return the space of "bmap".
+ */
+__isl_keep isl_space *isl_basic_map_peek_space(
+	__isl_keep const isl_basic_map *bmap)
+{
+	return bmap ? bmap->dim : NULL;
+}
+
+/* Return the space of "bset".
+ */
+__isl_keep isl_space *isl_basic_set_peek_space(__isl_keep isl_basic_set *bset)
+{
+	return isl_basic_map_peek_space(bset_to_bmap(bset));
+}
+
 __isl_give isl_space *isl_basic_map_get_space(__isl_keep isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
-	return isl_space_copy(bmap->dim);
+	return isl_space_copy(isl_basic_map_peek_space(bmap));
 }
 
 __isl_give isl_space *isl_basic_set_get_space(__isl_keep isl_basic_set *bset)
 {
-	if (!bset)
+	return isl_basic_map_get_space(bset_to_bmap(bset));
+}
+
+/* Return the space of "bmap".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "bmap".
+ * This allows the space to be modified inplace
+ * if both the basic map and its space have only a single reference.
+ * The caller is not allowed to modify "bmap" between this call and
+ * a subsequent call to isl_basic_map_restore_space.
+ * The only exception is that isl_basic_map_free can be called instead.
+ */
+static __isl_give isl_space *isl_basic_map_take_space(
+	__isl_keep isl_basic_map *bmap)
+{
+	isl_space *space;
+
+	if (!bmap)
 		return NULL;
-	return isl_space_copy(bset->dim);
+	if (bmap->ref != 1)
+		return isl_basic_map_get_space(bmap);
+	space = bmap->dim;
+	bmap->dim = NULL;
+	return space;
+}
+
+/* Set the space of "bmap" to "space", where the space of "bmap" may be missing
+ * due to a preceding call to isl_basic_map_take_space.
+ * However, in this case, "bmap" only has a single reference and
+ * then the call to isl_basic_map_cow has no effect.
+ */
+static __isl_give isl_basic_map *isl_basic_map_restore_space(
+	__isl_take isl_basic_map *bmap, __isl_take isl_space *space)
+{
+	if (!bmap || !space)
+		goto error;
+
+	if (bmap->dim == space) {
+		isl_space_free(space);
+		return bmap;
+	}
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		goto error;
+	isl_space_free(bmap->dim);
+	bmap->dim = space;
+
+	return bmap;
+error:
+	isl_basic_map_free(bmap);
+	isl_space_free(space);
+	return NULL;
 }
 
 /* Extract the divs in "bmap" as a matrix.
@@ -277,15 +461,15 @@
 	int i;
 	isl_ctx *ctx;
 	isl_mat *div;
-	unsigned total;
+	isl_size v_div;
 	unsigned cols;
 
-	if (!bmap)
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
 		return NULL;
 
 	ctx = isl_basic_map_get_ctx(bmap);
-	total = isl_space_dim(bmap->dim, isl_dim_all);
-	cols = 1 + 1 + total + bmap->n_div;
+	cols = 1 + 1 + v_div + bmap->n_div;
 	div = isl_mat_alloc(ctx, bmap->n_div, cols);
 	if (!div)
 		return NULL;
@@ -321,17 +505,50 @@
 	return isl_basic_map_get_local_space(bset);
 }
 
+/* For each known div d = floor(f/m), add the constraints
+ *
+ *		f - m d >= 0
+ *		-(f-(m-1)) + m d >= 0
+ *
+ * Do not finalize the result.
+ */
+static __isl_give isl_basic_map *add_known_div_constraints(
+	__isl_take isl_basic_map *bmap)
+{
+	int i;
+	isl_size n_div;
+
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_basic_map_free(bmap);
+	if (n_div == 0)
+		return bmap;
+	bmap = isl_basic_map_cow(bmap);
+	bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * n_div);
+	if (!bmap)
+		return NULL;
+	for (i = 0; i < n_div; ++i) {
+		if (isl_int_is_zero(bmap->divi0))
+			continue;
+		bmap = isl_basic_map_add_div_constraints(bmap, i);
+	}
+
+	return bmap;
+}
+
 __isl_give isl_basic_map *isl_basic_map_from_local_space(
 	__isl_take isl_local_space *ls)
 {
 	int i;
-	int n_div;
+	isl_size n_div;
 	isl_basic_map *bmap;
 
+	n_div = isl_local_space_dim(ls, isl_dim_div);
+	if (n_div < 0)
+		ls = isl_local_space_free(ls);
 	if (!ls)
 		return NULL;
 
-	n_div = isl_local_space_dim(ls, isl_dim_div);
 	bmap = isl_basic_map_alloc_space(isl_local_space_get_space(ls),
 					n_div, 0, 2 * n_div);
 
@@ -339,11 +556,9 @@
 		if (isl_basic_map_alloc_div(bmap) < 0)
 			goto error;
 
-	for (i = 0; i < n_div; ++i) {
+	for (i = 0; i < n_div; ++i)
 		isl_seq_cpy(bmap->divi, ls->div->rowi, ls->div->n_col);
-		if (isl_basic_map_add_div_constraints(bmap, i) < 0)
-			goto error;
-	}
+	bmap = add_known_div_constraints(bmap);
 					
 	isl_local_space_free(ls);
 	return bmap;
@@ -361,9 +576,7 @@
 
 __isl_give isl_space *isl_map_get_space(__isl_keep isl_map *map)
 {
-	if (!map)
-		return NULL;
-	return isl_space_copy(map->dim);
+	return isl_space_copy(isl_map_peek_space(map));
 }
 
 __isl_give isl_space *isl_set_get_space(__isl_keep isl_set *set)
@@ -373,22 +586,69 @@
 	return isl_space_copy(set->dim);
 }
 
-__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
-	__isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
+/* Return the space of "map".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "map".
+ * This allows the space to be modified inplace
+ * if both the map and its space have only a single reference.
+ * The caller is not allowed to modify "map" between this call and
+ * a subsequent call to isl_map_restore_space.
+ * The only exception is that isl_map_free can be called instead.
+ */
+static __isl_give isl_space *isl_map_take_space(__isl_keep isl_map *map)
 {
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
+	isl_space *space;
+
+	if (!map)
 		return NULL;
-	bmap->dim = isl_space_set_tuple_name(bmap->dim, type, s);
-	if (!bmap->dim)
+	if (map->ref != 1)
+		return isl_map_get_space(map);
+	space = map->dim;
+	map->dim = NULL;
+	return space;
+}
+
+/* Set the space of "map" to "space", where the space of "map" may be missing
+ * due to a preceding call to isl_map_take_space.
+ * However, in this case, "map" only has a single reference and
+ * then the call to isl_map_cow has no effect.
+ */
+static __isl_give isl_map *isl_map_restore_space(__isl_take isl_map *map,
+	__isl_take isl_space *space)
+{
+	if (!map || !space)
 		goto error;
-	bmap = isl_basic_map_finalize(bmap);
-	return bmap;
+
+	if (map->dim == space) {
+		isl_space_free(space);
+		return map;
+	}
+
+	map = isl_map_cow(map);
+	if (!map)
+		goto error;
+	isl_space_free(map->dim);
+	map->dim = space;
+
+	return map;
 error:
-	isl_basic_map_free(bmap);
+	isl_map_free(map);
+	isl_space_free(space);
 	return NULL;
 }
 
+__isl_give isl_basic_map *isl_basic_map_set_tuple_name(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type, const char *s)
+{
+	isl_space *space;
+
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_set_tuple_name(space, type, s);
+	bmap = isl_basic_map_restore_space(bmap, space);
+	bmap = isl_basic_map_finalize(bmap);
+	return bmap;
+}
+
 __isl_give isl_basic_set *isl_basic_set_set_tuple_name(
 	__isl_take isl_basic_set *bset, const char *s)
 {
@@ -405,21 +665,22 @@
 	enum isl_dim_type type, const char *s)
 {
 	int i;
+	isl_space *space;
 
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_set_tuple_name(map->dim, type, s);
-	if (!map->dim)
-		goto error;
-
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_set_tuple_name(map->pi, type, s);
 		if (!map->pi)
 			goto error;
 	}
 
+	space = isl_map_take_space(map);
+	space = isl_space_set_tuple_name(space, type, s);
+	map = isl_map_restore_space(map, space);
+
 	return map;
 error:
 	isl_map_free(map);
@@ -432,17 +693,13 @@
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, __isl_take isl_id *id)
 {
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		goto error;
-	bmap->dim = isl_space_set_tuple_id(bmap->dim, type, id);
-	if (!bmap->dim)
-		return isl_basic_map_free(bmap);
+	isl_space *space;
+
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_set_tuple_id(space, type, id);
+	bmap = isl_basic_map_restore_space(bmap, space);
 	bmap = isl_basic_map_finalize(bmap);
 	return bmap;
-error:
-	isl_id_free(id);
-	return NULL;
 }
 
 /* Replace the identifier of the tuple by "id".
@@ -455,9 +712,9 @@
 
 /* Does the input or output tuple have a name?
  */
-int isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
+isl_bool isl_map_has_tuple_name(__isl_keep isl_map *map, enum isl_dim_type type)
 {
-	return map ? isl_space_has_tuple_name(map->dim, type) : -1;
+	return map ? isl_space_has_tuple_name(map->dim, type) : isl_bool_error;
 }
 
 const char *isl_map_get_tuple_name(__isl_keep isl_map *map,
@@ -469,22 +726,36 @@
 __isl_give isl_set *isl_set_set_tuple_name(__isl_take isl_set *set,
 	const char *s)
 {
-	return (isl_set *)isl_map_set_tuple_name((isl_map *)set, isl_dim_set, s);
+	return set_from_map(isl_map_set_tuple_name(set_to_map(set),
+						isl_dim_set, s));
 }
 
 __isl_give isl_map *isl_map_set_tuple_id(__isl_take isl_map *map,
 	enum isl_dim_type type, __isl_take isl_id *id)
 {
-	map = isl_map_cow(map);
-	if (!map)
-		goto error;
+	isl_space *space;
 
-	map->dim = isl_space_set_tuple_id(map->dim, type, id);
+	space = isl_map_take_space(map);
+	space = isl_space_set_tuple_id(space, type, id);
+	map = isl_map_restore_space(map, space);
 
-	return isl_map_reset_space(map, isl_space_copy(map->dim));
-error:
-	isl_id_free(id);
-	return NULL;
+	return isl_map_reset_space(map, isl_map_get_space(map));
+}
+
+/* Replace the identifier of the domain tuple of "map" by "id".
+ */
+__isl_give isl_map *isl_map_set_domain_tuple_id(__isl_take isl_map *map,
+	__isl_take isl_id *id)
+{
+	return isl_map_set_tuple_id(map, isl_dim_in, id);
+}
+
+/* Replace the identifier of the range tuple of "map" by "id".
+ */
+__isl_give isl_map *isl_map_set_range_tuple_id(__isl_take isl_map *map,
+	__isl_take isl_id *id)
+{
+	return isl_map_set_tuple_id(map, isl_dim_out, id);
 }
 
 __isl_give isl_set *isl_set_set_tuple_id(__isl_take isl_set *set,
@@ -496,13 +767,13 @@
 __isl_give isl_map *isl_map_reset_tuple_id(__isl_take isl_map *map,
 	enum isl_dim_type type)
 {
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
+	isl_space *space;
 
-	map->dim = isl_space_reset_tuple_id(map->dim, type);
+	space = isl_map_take_space(map);
+	space = isl_space_reset_tuple_id(space, type);
+	map = isl_map_restore_space(map, space);
 
-	return isl_map_reset_space(map, isl_space_copy(map->dim));
+	return isl_map_reset_space(map, isl_map_get_space(map));
 }
 
 __isl_give isl_set *isl_set_reset_tuple_id(__isl_take isl_set *set)
@@ -510,9 +781,23 @@
 	return isl_map_reset_tuple_id(set, isl_dim_set);
 }
 
-int isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
+isl_bool isl_map_has_tuple_id(__isl_keep isl_map *map, enum isl_dim_type type)
+{
+	return map ? isl_space_has_tuple_id(map->dim, type) : isl_bool_error;
+}
+
+/* Does the domain tuple of "map" have an identifier?
+ */
+isl_bool isl_map_has_domain_tuple_id(__isl_keep isl_map *map)
+{
+	return isl_map_has_tuple_id(map, isl_dim_in);
+}
+
+/* Does the range tuple of "map" have an identifier?
+ */
+isl_bool isl_map_has_range_tuple_id(__isl_keep isl_map *map)
 {
-	return map ? isl_space_has_tuple_id(map->dim, type) : -1;
+	return isl_map_has_tuple_id(map, isl_dim_out);
 }
 
 __isl_give isl_id *isl_map_get_tuple_id(__isl_keep isl_map *map,
@@ -521,7 +806,21 @@
 	return map ? isl_space_get_tuple_id(map->dim, type) : NULL;
 }
 
-int isl_set_has_tuple_id(__isl_keep isl_set *set)
+/* Return the identifier of the domain tuple of "map", assuming it has one.
+ */
+__isl_give isl_id *isl_map_get_domain_tuple_id(__isl_keep isl_map *map)
+{
+	return isl_map_get_tuple_id(map, isl_dim_in);
+}
+
+/* Return the identifier of the range tuple of "map", assuming it has one.
+ */
+__isl_give isl_id *isl_map_get_range_tuple_id(__isl_keep isl_map *map)
+{
+	return isl_map_get_tuple_id(map, isl_dim_out);
+}
+
+isl_bool isl_set_has_tuple_id(__isl_keep isl_set *set)
 {
 	return isl_map_has_tuple_id(set, isl_dim_set);
 }
@@ -533,9 +832,11 @@
 
 /* Does the set tuple have a name?
  */
-int isl_set_has_tuple_name(__isl_keep isl_set *set)
+isl_bool isl_set_has_tuple_name(__isl_keep isl_set *set)
 {
-	return set ? isl_space_has_tuple_name(set->dim, isl_dim_set) : -1;
+	if (!set)
+		return isl_bool_error;
+	return isl_space_has_tuple_name(set->dim, isl_dim_set);
 }
 
 
@@ -563,10 +864,12 @@
 
 /* Does the given dimension have a name?
  */
-int isl_map_has_dim_name(__isl_keep isl_map *map,
+isl_bool isl_map_has_dim_name(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos)
 {
-	return map ? isl_space_has_dim_name(map->dim, type, pos) : -1;
+	if (!map)
+		return isl_bool_error;
+	return isl_space_has_dim_name(map->dim, type, pos);
 }
 
 const char *isl_map_get_dim_name(__isl_keep isl_map *map,
@@ -583,47 +886,46 @@
 
 /* Does the given dimension have a name?
  */
-int isl_set_has_dim_name(__isl_keep isl_set *set,
+isl_bool isl_set_has_dim_name(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
-	return set ? isl_space_has_dim_name(set->dim, type, pos) : -1;
+	if (!set)
+		return isl_bool_error;
+	return isl_space_has_dim_name(set->dim, type, pos);
 }
 
 __isl_give isl_basic_map *isl_basic_map_set_dim_name(
 	__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos, const char *s)
 {
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-	bmap->dim = isl_space_set_dim_name(bmap->dim, type, pos, s);
-	if (!bmap->dim)
-		goto error;
+	isl_space *space;
+
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_set_dim_name(space, type, pos, s);
+	bmap = isl_basic_map_restore_space(bmap, space);
 	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_map *isl_map_set_dim_name(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, const char *s)
 {
 	int i;
+	isl_space *space;
 
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_set_dim_name(map->dim, type, pos, s);
-	if (!map->dim)
-		goto error;
-
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_set_dim_name(map->pi, type, pos, s);
 		if (!map->pi)
 			goto error;
 	}
 
+	space = isl_map_take_space(map);
+	space = isl_space_set_dim_name(space, type, pos, s);
+	map = isl_map_restore_space(map, space);
+
 	return map;
 error:
 	isl_map_free(map);
@@ -634,20 +936,23 @@
 	__isl_take isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos, const char *s)
 {
-	return (isl_basic_set *)isl_basic_map_set_dim_name(
-		(isl_basic_map *)bset, type, pos, s);
+	return bset_from_bmap(isl_basic_map_set_dim_name(bset_to_bmap(bset),
+							type, pos, s));
 }
 
 __isl_give isl_set *isl_set_set_dim_name(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, const char *s)
 {
-	return (isl_set *)isl_map_set_dim_name((isl_map *)set, type, pos, s);
+	return set_from_map(isl_map_set_dim_name(set_to_map(set),
+							type, pos, s));
 }
 
-int isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_has_dim_id(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos)
 {
-	return bmap ? isl_space_has_dim_id(bmap->dim, type, pos) : -1;
+	if (!bmap)
+		return isl_bool_error;
+	return isl_space_has_dim_id(bmap->dim, type, pos);
 }
 
 __isl_give isl_id *isl_basic_set_get_dim_id(__isl_keep isl_basic_set *bset,
@@ -656,10 +961,10 @@
 	return bset ? isl_space_get_dim_id(bset->dim, type, pos) : NULL;
 }
 
-int isl_map_has_dim_id(__isl_keep isl_map *map,
+isl_bool isl_map_has_dim_id(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos)
 {
-	return map ? isl_space_has_dim_id(map->dim, type, pos) : -1;
+	return map ? isl_space_has_dim_id(map->dim, type, pos) : isl_bool_error;
 }
 
 __isl_give isl_id *isl_map_get_dim_id(__isl_keep isl_map *map,
@@ -668,7 +973,7 @@
 	return map ? isl_space_get_dim_id(map->dim, type, pos) : NULL;
 }
 
-int isl_set_has_dim_id(__isl_keep isl_set *set,
+isl_bool isl_set_has_dim_id(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
 	return isl_map_has_dim_id(set, type, pos);
@@ -683,16 +988,13 @@
 __isl_give isl_map *isl_map_set_dim_id(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
 {
-	map = isl_map_cow(map);
-	if (!map)
-		goto error;
+	isl_space *space;
 
-	map->dim = isl_space_set_dim_id(map->dim, type, pos, id);
+	space = isl_map_take_space(map);
+	space = isl_space_set_dim_id(space, type, pos, id);
+	map = isl_map_restore_space(map, space);
 
-	return isl_map_reset_space(map, isl_space_copy(map->dim));
-error:
-	isl_id_free(id);
-	return NULL;
+	return isl_map_reset_space(map, isl_map_get_space(map));
 }
 
 __isl_give isl_set *isl_set_set_dim_id(__isl_take isl_set *set,
@@ -715,6 +1017,18 @@
 	return isl_map_find_dim_by_id(set, type, id);
 }
 
+/* Return the position of the dimension of the given type and name
+ * in "bmap".
+ * Return -1 if no such dimension can be found.
+ */
+int isl_basic_map_find_dim_by_name(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type, const char *name)
+{
+	if (!bmap)
+		return -1;
+	return isl_space_find_dim_by_name(bmap->dim, type, name);
+}
+
 int isl_map_find_dim_by_name(__isl_keep isl_map *map, enum isl_dim_type type,
 	const char *name)
 {
@@ -729,6 +1043,52 @@
 	return isl_map_find_dim_by_name(set, type, name);
 }
 
+/* Check whether equality i of bset is a pure stride constraint
+ * on a single dimension, i.e., of the form
+ *
+ *	v = k e
+ *
+ * with k a constant and e an existentially quantified variable.
+ */
+isl_bool isl_basic_set_eq_is_stride(__isl_keep isl_basic_set *bset, int i)
+{
+	isl_size nparam;
+	isl_size d;
+	isl_size n_div;
+	int pos1;
+	int pos2;
+
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	d = isl_basic_set_dim(bset, isl_dim_set);
+	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	if (nparam < 0 || d < 0 || n_div < 0)
+		return isl_bool_error;
+
+	if (!isl_int_is_zero(bset->eqi0))
+		return isl_bool_false;
+
+	if (isl_seq_first_non_zero(bset->eqi + 1, nparam) != -1)
+		return isl_bool_false;
+	pos1 = isl_seq_first_non_zero(bset->eqi + 1 + nparam, d);
+	if (pos1 == -1)
+		return isl_bool_false;
+	if (isl_seq_first_non_zero(bset->eqi + 1 + nparam + pos1 + 1,
+					d - pos1 - 1) != -1)
+		return isl_bool_false;
+
+	pos2 = isl_seq_first_non_zero(bset->eqi + 1 + nparam + d, n_div);
+	if (pos2 == -1)
+		return isl_bool_false;
+	if (isl_seq_first_non_zero(bset->eqi + 1 + nparam + d  + pos2 + 1,
+				   n_div - pos2 - 1) != -1)
+		return isl_bool_false;
+	if (!isl_int_is_one(bset->eqi1 + nparam + pos1) &&
+	    !isl_int_is_negone(bset->eqi1 + nparam + pos1))
+		return isl_bool_false;
+
+	return isl_bool_true;
+}
+
 /* Reset the user pointer on all identifiers of parameters and tuples
  * of the space of "map".
  */
@@ -751,13 +1111,57 @@
 	return isl_map_reset_user(set);
 }
 
-int isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_is_rational(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	return ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
 }
 
+/* Has "map" been marked as a rational map?
+ * In particular, have all basic maps in "map" been marked this way?
+ * An empty map is not considered to be rational.
+ * Maps where only some of the basic maps are marked rational
+ * are not allowed.
+ */
+isl_bool isl_map_is_rational(__isl_keep isl_map *map)
+{
+	int i;
+	isl_bool rational;
+
+	if (!map)
+		return isl_bool_error;
+	if (map->n == 0)
+		return isl_bool_false;
+	rational = isl_basic_map_is_rational(map->p0);
+	if (rational < 0)
+		return rational;
+	for (i = 1; i < map->n; ++i) {
+		isl_bool rational_i;
+
+		rational_i = isl_basic_map_is_rational(map->pi);
+		if (rational_i < 0)
+			return rational_i;
+		if (rational != rational_i)
+			isl_die(isl_map_get_ctx(map), isl_error_unsupported,
+				"mixed rational and integer basic maps "
+				"not supported", return isl_bool_error);
+	}
+
+	return rational;
+}
+
+/* Has "set" been marked as a rational set?
+ * In particular, have all basic set in "set" been marked this way?
+ * An empty set is not considered to be rational.
+ * Sets where only some of the basic sets are marked rational
+ * are not allowed.
+ */
+isl_bool isl_set_is_rational(__isl_keep isl_set *set)
+{
+	return isl_map_is_rational(set);
+}
+
 int isl_basic_set_is_rational(__isl_keep isl_basic_set *bset)
 {
 	return isl_basic_map_is_rational(bset);
@@ -769,22 +1173,22 @@
  * to an integer constant, then it has no rational points, even if it
  * is marked as rational.
  */
-int isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_has_rational(__isl_keep isl_basic_map *bmap)
 {
-	int has_rational = 1;
-	unsigned total;
+	isl_bool has_rational = isl_bool_true;
+	isl_size total;
 
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	if (isl_basic_map_plain_is_empty(bmap))
-		return 0;
+		return isl_bool_false;
 	if (!isl_basic_map_is_rational(bmap))
-		return 0;
+		return isl_bool_false;
 	bmap = isl_basic_map_copy(bmap);
 	bmap = isl_basic_map_implicit_equalities(bmap);
-	if (!bmap)
-		return -1;
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	if (bmap->n_eq == total) {
 		int i, j;
 		for (i = 0; i < bmap->n_eq; ++i) {
@@ -800,7 +1204,7 @@
 				break;
 		}
 		if (i == bmap->n_eq)
-			has_rational = 0;
+			has_rational = isl_bool_false;
 	}
 	isl_basic_map_free(bmap);
 
@@ -809,45 +1213,43 @@
 
 /* Does "map" contain any rational points?
  */
-int isl_map_has_rational(__isl_keep isl_map *map)
+isl_bool isl_map_has_rational(__isl_keep isl_map *map)
 {
 	int i;
-	int has_rational;
+	isl_bool has_rational;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	for (i = 0; i < map->n; ++i) {
 		has_rational = isl_basic_map_has_rational(map->pi);
-		if (has_rational < 0)
-			return -1;
-		if (has_rational)
-			return 1;
+		if (has_rational < 0 || has_rational)
+			return has_rational;
 	}
-	return 0;
+	return isl_bool_false;
 }
 
 /* Does "set" contain any rational points?
  */
-int isl_set_has_rational(__isl_keep isl_set *set)
+isl_bool isl_set_has_rational(__isl_keep isl_set *set)
 {
 	return isl_map_has_rational(set);
 }
 
 /* Is this basic set a parameter domain?
  */
-int isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
+isl_bool isl_basic_set_is_params(__isl_keep isl_basic_set *bset)
 {
 	if (!bset)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_params(bset->dim);
 }
 
 /* Is this set a parameter domain?
  */
-int isl_set_is_params(__isl_keep isl_set *set)
+isl_bool isl_set_is_params(__isl_keep isl_set *set)
 {
 	if (!set)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_params(set->dim);
 }
 
@@ -855,23 +1257,28 @@
  * Users should never call this function.  Outside of isl,
  * a map can never be a parameter domain.
  */
-int isl_map_is_params(__isl_keep isl_map *map)
+isl_bool isl_map_is_params(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_params(map->dim);
 }
 
-static struct isl_basic_map *basic_map_init(struct isl_ctx *ctx,
-		struct isl_basic_map *bmap, unsigned extra,
-		unsigned n_eq, unsigned n_ineq)
+static __isl_give isl_basic_map *basic_map_init(isl_ctx *ctx,
+	__isl_take isl_basic_map *bmap, unsigned extra,
+	unsigned n_eq, unsigned n_ineq)
 {
 	int i;
-	size_t row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + extra;
+	isl_space *space = isl_basic_map_peek_space(bmap);
+	isl_size n_var = isl_space_dim(space, isl_dim_all);
+	size_t row_size = 1 + n_var + extra;
 
 	bmap->ctx = ctx;
 	isl_ctx_ref(ctx);
 
+	if (n_var < 0)
+		return isl_basic_map_free(bmap);
+
 	bmap->block = isl_blk_alloc(ctx, (n_ineq + n_eq) * row_size);
 	if (isl_blk_is_error(bmap->block))
 		goto error;
@@ -915,7 +1322,7 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_alloc(struct isl_ctx *ctx,
+__isl_give isl_basic_set *isl_basic_set_alloc(isl_ctx *ctx,
 		unsigned nparam, unsigned dim, unsigned extra,
 		unsigned n_eq, unsigned n_ineq)
 {
@@ -927,80 +1334,90 @@
 		return NULL;
 
 	bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
-	return (struct isl_basic_set *)bmap;
+	return bset_from_bmap(bmap);
 }
 
-struct isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *dim,
+__isl_give isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *space,
 		unsigned extra, unsigned n_eq, unsigned n_ineq)
 {
 	struct isl_basic_map *bmap;
-	if (!dim)
+	if (!space)
 		return NULL;
-	isl_assert(dim->ctx, dim->n_in == 0, goto error);
-	bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
-	return (struct isl_basic_set *)bmap;
+	isl_assert(space->ctx, space->n_in == 0, goto error);
+	bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
+	return bset_from_bmap(bmap);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
+__isl_give isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *space,
 		unsigned extra, unsigned n_eq, unsigned n_ineq)
 {
 	struct isl_basic_map *bmap;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	bmap = isl_calloc_type(dim->ctx, struct isl_basic_map);
+	bmap = isl_calloc_type(space->ctx, struct isl_basic_map);
 	if (!bmap)
 		goto error;
-	bmap->dim = dim;
+	bmap->dim = space;
 
-	return basic_map_init(dim->ctx, bmap, extra, n_eq, n_ineq);
+	return basic_map_init(space->ctx, bmap, extra, n_eq, n_ineq);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_alloc(struct isl_ctx *ctx,
+__isl_give isl_basic_map *isl_basic_map_alloc(isl_ctx *ctx,
 		unsigned nparam, unsigned in, unsigned out, unsigned extra,
 		unsigned n_eq, unsigned n_ineq)
 {
 	struct isl_basic_map *bmap;
-	isl_space *dim;
+	isl_space *space;
 
-	dim = isl_space_alloc(ctx, nparam, in, out);
-	if (!dim)
+	space = isl_space_alloc(ctx, nparam, in, out);
+	if (!space)
 		return NULL;
 
-	bmap = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
+	bmap = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
 	return bmap;
 }
 
-static void dup_constraints(
-		struct isl_basic_map *dst, struct isl_basic_map *src)
+static __isl_give isl_basic_map *dup_constraints(__isl_take isl_basic_map *dst,
+	__isl_keep isl_basic_map *src)
 {
 	int i;
-	unsigned total = isl_basic_map_total_dim(src);
+	isl_size total = isl_basic_map_dim(src, isl_dim_all);
+
+	if (!dst || total < 0)
+		return isl_basic_map_free(dst);
 
 	for (i = 0; i < src->n_eq; ++i) {
 		int j = isl_basic_map_alloc_equality(dst);
+		if (j < 0)
+			return isl_basic_map_free(dst);
 		isl_seq_cpy(dst->eqj, src->eqi, 1+total);
 	}
 
 	for (i = 0; i < src->n_ineq; ++i) {
 		int j = isl_basic_map_alloc_inequality(dst);
+		if (j < 0)
+			return isl_basic_map_free(dst);
 		isl_seq_cpy(dst->ineqj, src->ineqi, 1+total);
 	}
 
 	for (i = 0; i < src->n_div; ++i) {
 		int j = isl_basic_map_alloc_div(dst);
+		if (j < 0)
+			return isl_basic_map_free(dst);
 		isl_seq_cpy(dst->divj, src->divi, 1+1+total);
 	}
 	ISL_F_SET(dst, ISL_BASIC_SET_FINAL);
+	return dst;
 }
 
-struct isl_basic_map *isl_basic_map_dup(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_dup(__isl_keep isl_basic_map *bmap)
 {
 	struct isl_basic_map *dup;
 
@@ -1008,23 +1425,23 @@
 		return NULL;
 	dup = isl_basic_map_alloc_space(isl_space_copy(bmap->dim),
 			bmap->n_div, bmap->n_eq, bmap->n_ineq);
+	dup = dup_constraints(dup, bmap);
 	if (!dup)
 		return NULL;
-	dup_constraints(dup, bmap);
 	dup->flags = bmap->flags;
 	dup->sample = isl_vec_copy(bmap->sample);
 	return dup;
 }
 
-struct isl_basic_set *isl_basic_set_dup(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_dup(__isl_keep isl_basic_set *bset)
 {
 	struct isl_basic_map *dup;
 
-	dup = isl_basic_map_dup((struct isl_basic_map *)bset);
-	return (struct isl_basic_set *)dup;
+	dup = isl_basic_map_dup(bset_to_bmap(bset));
+	return bset_from_bmap(dup);
 }
 
-struct isl_basic_set *isl_basic_set_copy(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_copy(__isl_keep isl_basic_set *bset)
 {
 	if (!bset)
 		return NULL;
@@ -1036,7 +1453,7 @@
 	return isl_basic_set_dup(bset);
 }
 
-struct isl_set *isl_set_copy(struct isl_set *set)
+__isl_give isl_set *isl_set_copy(__isl_keep isl_set *set)
 {
 	if (!set)
 		return NULL;
@@ -1045,7 +1462,7 @@
 	return set;
 }
 
-struct isl_basic_map *isl_basic_map_copy(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_copy(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
 		return NULL;
@@ -1060,7 +1477,7 @@
 	return bmap;
 }
 
-struct isl_map *isl_map_copy(struct isl_map *map)
+__isl_give isl_map *isl_map_copy(__isl_keep isl_map *map)
 {
 	if (!map)
 		return NULL;
@@ -1091,50 +1508,102 @@
 
 __isl_null isl_basic_set *isl_basic_set_free(__isl_take isl_basic_set *bset)
 {
-	return isl_basic_map_free((struct isl_basic_map *)bset);
+	return isl_basic_map_free(bset_to_bmap(bset));
 }
 
-static int room_for_con(struct isl_basic_map *bmap, unsigned n)
+static int room_for_con(__isl_keep isl_basic_map *bmap, unsigned n)
 {
 	return bmap->n_eq + bmap->n_ineq + n <= bmap->c_size;
 }
 
-__isl_give isl_map *isl_map_align_params_map_map_and(
-	__isl_take isl_map *map1, __isl_take isl_map *map2,
-	__isl_give isl_map *(*fn)(__isl_take isl_map *map1,
-				    __isl_take isl_map *map2))
+/* Check that "bset" does not involve any parameters.
+ */
+isl_stat isl_basic_set_check_no_params(__isl_keep isl_basic_set *bset)
 {
-	if (!map1 || !map2)
-		goto error;
-	if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param))
-		return fn(map1, map2);
-	if (!isl_space_has_named_params(map1->dim) ||
-	    !isl_space_has_named_params(map2->dim))
-		isl_die(map1->ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	map1 = isl_map_align_params(map1, isl_map_get_space(map2));
-	map2 = isl_map_align_params(map2, isl_map_get_space(map1));
-	return fn(map1, map2);
-error:
-	isl_map_free(map1);
-	isl_map_free(map2);
-	return NULL;
+	isl_size nparam;
+
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0)
+		return isl_stat_error;
+	if (nparam != 0)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+			"basic set should not have any parameters",
+			return isl_stat_error);
+	return isl_stat_ok;
 }
 
-int isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
+/* Check that "bset" does not involve any local variables.
+ */
+isl_stat isl_basic_set_check_no_locals(__isl_keep isl_basic_set *bset)
+{
+	isl_size n_div;
+
+	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	if (n_div < 0)
+		return isl_stat_error;
+	if (n_div != 0)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+			"basic set should not have any local variables",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+#undef TYPE
+#define TYPE isl_map
+
+#include "isl_check_named_params_templ.c"
+
+#undef TYPE
+#define TYPE isl_basic_map
+
+static
+#include "isl_check_named_params_templ.c"
+
+/* Check that "bmap1" and "bmap2" have the same parameters,
+ * reporting an error if they do not.
+ */
+static isl_stat isl_basic_map_check_equal_params(
+	__isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
+{
+	isl_bool match;
+
+	match = isl_basic_map_has_equal_params(bmap1, bmap2);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
+			"parameters don't match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+#undef TYPE
+#define TYPE	isl_map
+
+#include "isl_align_params_bin_templ.c"
+
+#undef SUFFIX
+#define SUFFIX	set
+#undef ARG1
+#define ARG1	isl_map
+#undef ARG2
+#define ARG2	isl_set
+
+#include "isl_align_params_templ.c"
+
+isl_bool isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
 	__isl_keep isl_map *map2,
-	int (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
+	isl_bool (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2))
 {
-	int r;
+	isl_bool r;
 
 	if (!map1 || !map2)
-		return -1;
-	if (isl_space_match(map1->dim, isl_dim_param, map2->dim, isl_dim_param))
+		return isl_bool_error;
+	if (isl_map_has_equal_params(map1, map2))
 		return fn(map1, map2);
-	if (!isl_space_has_named_params(map1->dim) ||
-	    !isl_space_has_named_params(map2->dim))
-		isl_die(map1->ctx, isl_error_invalid,
-			"unaligned unnamed parameters", return -1);
+	if (isl_map_check_named_params(map1) < 0)
+		return isl_bool_error;
+	if (isl_map_check_named_params(map2) < 0)
+		return isl_bool_error;
 	map1 = isl_map_copy(map1);
 	map2 = isl_map_copy(map2);
 	map1 = isl_map_align_params(map1, isl_map_get_space(map2));
@@ -1145,16 +1614,18 @@
 	return r;
 }
 
-int isl_basic_map_alloc_equality(struct isl_basic_map *bmap)
+int isl_basic_map_alloc_equality(__isl_keep isl_basic_map *bmap)
 {
+	isl_size total;
 	struct isl_ctx *ctx;
-	if (!bmap)
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return -1;
 	ctx = bmap->ctx;
 	isl_assert(ctx, room_for_con(bmap, 1), return -1);
 	isl_assert(ctx, (bmap->eq - bmap->ineq) + bmap->n_eq <= bmap->c_size,
 			return -1);
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
@@ -1173,49 +1644,55 @@
 		bmap->eq--;
 		return 0;
 	}
-	isl_seq_clr(bmap->eqbmap->n_eq + 1 + isl_basic_map_total_dim(bmap),
+	isl_seq_clr(bmap->eqbmap->n_eq + 1 + total,
 		      bmap->extra - bmap->n_div);
 	return bmap->n_eq++;
 }
 
-int isl_basic_set_alloc_equality(struct isl_basic_set *bset)
+int isl_basic_set_alloc_equality(__isl_keep isl_basic_set *bset)
 {
-	return isl_basic_map_alloc_equality((struct isl_basic_map *)bset);
+	return isl_basic_map_alloc_equality(bset_to_bmap(bset));
 }
 
-int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_free_equality(
+	__isl_take isl_basic_map *bmap, unsigned n)
 {
 	if (!bmap)
-		return -1;
-	isl_assert(bmap->ctx, n <= bmap->n_eq, return -1);
+		return NULL;
+	if (n > bmap->n_eq)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"invalid number of equalities",
+			isl_basic_map_free(bmap));
 	bmap->n_eq -= n;
-	return 0;
+	return bmap;
 }
 
-int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_free_equality(
+	__isl_take isl_basic_set *bset, unsigned n)
 {
-	return isl_basic_map_free_equality((struct isl_basic_map *)bset, n);
+	return bset_from_bmap(isl_basic_map_free_equality(bset_to_bmap(bset),
+							    n));
 }
 
-int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos)
+/* Drop the equality constraint at position "pos",
+ * preserving the order of the other equality constraints.
+ */
+int isl_basic_map_drop_equality(__isl_keep isl_basic_map *bmap, unsigned pos)
 {
 	isl_int *t;
+	int r;
+
 	if (!bmap)
 		return -1;
 	isl_assert(bmap->ctx, pos < bmap->n_eq, return -1);
 
-	if (pos != bmap->n_eq - 1) {
-		t = bmap->eqpos;
-		bmap->eqpos = bmap->eqbmap->n_eq - 1;
-		bmap->eqbmap->n_eq - 1 = t;
-	}
+	t = bmap->eqpos;
 	bmap->n_eq--;
-	return 0;
-}
+	for (r = pos; r < bmap->n_eq; ++r)
+		bmap->eqr = bmap->eqr + 1;
+	bmap->eqbmap->n_eq = t;
 
-int isl_basic_set_drop_equality(struct isl_basic_set *bset, unsigned pos)
-{
-	return isl_basic_map_drop_equality((struct isl_basic_map *)bset, pos);
+	return 0;
 }
 
 /* Turn inequality "pos" of "bmap" into an equality.
@@ -1226,7 +1703,7 @@
  * change in the ordering of the constraints.
  */
 void isl_basic_map_inequality_to_equality(
-		struct isl_basic_map *bmap, unsigned pos)
+		__isl_keep isl_basic_map *bmap, unsigned pos)
 {
 	isl_int *t;
 
@@ -1238,53 +1715,61 @@
 	bmap->n_ineq--;
 	bmap->eq--;
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
 }
 
-static int room_for_ineq(struct isl_basic_map *bmap, unsigned n)
+static int room_for_ineq(__isl_keep isl_basic_map *bmap, unsigned n)
 {
 	return bmap->n_ineq + n <= bmap->eq - bmap->ineq;
 }
 
-int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap)
+int isl_basic_map_alloc_inequality(__isl_keep isl_basic_map *bmap)
 {
+	isl_size total;
 	struct isl_ctx *ctx;
-	if (!bmap)
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return -1;
 	ctx = bmap->ctx;
 	isl_assert(ctx, room_for_ineq(bmap, 1), return -1);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_IMPLICIT);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_ALL_EQUALITIES);
-	isl_seq_clr(bmap->ineqbmap->n_ineq +
-		      1 + isl_basic_map_total_dim(bmap),
+	isl_seq_clr(bmap->ineqbmap->n_ineq + 1 + total,
 		      bmap->extra - bmap->n_div);
 	return bmap->n_ineq++;
 }
 
-int isl_basic_set_alloc_inequality(struct isl_basic_set *bset)
+int isl_basic_set_alloc_inequality(__isl_keep isl_basic_set *bset)
 {
-	return isl_basic_map_alloc_inequality((struct isl_basic_map *)bset);
+	return isl_basic_map_alloc_inequality(bset_to_bmap(bset));
 }
 
-int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_free_inequality(
+	__isl_take isl_basic_map *bmap, unsigned n)
 {
 	if (!bmap)
-		return -1;
-	isl_assert(bmap->ctx, n <= bmap->n_ineq, return -1);
+		return NULL;
+	if (n > bmap->n_ineq)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"invalid number of inequalities",
+			return isl_basic_map_free(bmap));
 	bmap->n_ineq -= n;
-	return 0;
+	return bmap;
 }
 
-int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_free_inequality(
+	__isl_take isl_basic_set *bset, unsigned n)
 {
-	return isl_basic_map_free_inequality((struct isl_basic_map *)bset, n);
+	return bset_from_bmap(isl_basic_map_free_inequality(bset_to_bmap(bset),
+							    n));
 }
 
-int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos)
+int isl_basic_map_drop_inequality(__isl_keep isl_basic_map *bmap, unsigned pos)
 {
 	isl_int *t;
 	if (!bmap)
@@ -1295,29 +1780,39 @@
 		t = bmap->ineqpos;
 		bmap->ineqpos = bmap->ineqbmap->n_ineq - 1;
 		bmap->ineqbmap->n_ineq - 1 = t;
-		ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+		ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
 	}
 	bmap->n_ineq--;
 	return 0;
 }
 
-int isl_basic_set_drop_inequality(struct isl_basic_set *bset, unsigned pos)
+int isl_basic_set_drop_inequality(__isl_keep isl_basic_set *bset, unsigned pos)
 {
-	return isl_basic_map_drop_inequality((struct isl_basic_map *)bset, pos);
+	return isl_basic_map_drop_inequality(bset_to_bmap(bset), pos);
 }
 
 __isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
 	isl_int *eq)
 {
+	isl_bool empty;
+	isl_size total;
 	int k;
 
+	empty = isl_basic_map_plain_is_empty(bmap);
+	if (empty < 0)
+		return isl_basic_map_free(bmap);
+	if (empty)
+		return bmap;
+
+	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
-	if (!bmap)
-		return NULL;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	k = isl_basic_map_alloc_equality(bmap);
 	if (k < 0)
 		goto error;
-	isl_seq_cpy(bmap->eqk, eq, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_cpy(bmap->eqk, eq, 1 + total);
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
@@ -1327,22 +1822,24 @@
 __isl_give isl_basic_set *isl_basic_set_add_eq(__isl_take isl_basic_set *bset,
 	isl_int *eq)
 {
-	return (isl_basic_set *)
-		isl_basic_map_add_eq((isl_basic_map *)bset, eq);
+	return bset_from_bmap(isl_basic_map_add_eq(bset_to_bmap(bset), eq));
 }
 
 __isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
 	isl_int *ineq)
 {
+	isl_size total;
 	int k;
 
+	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
-	if (!bmap)
-		return NULL;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	k = isl_basic_map_alloc_inequality(bmap);
 	if (k < 0)
 		goto error;
-	isl_seq_cpy(bmap->ineqk, ineq, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_cpy(bmap->ineqk, ineq, 1 + total);
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
@@ -1352,178 +1849,147 @@
 __isl_give isl_basic_set *isl_basic_set_add_ineq(__isl_take isl_basic_set *bset,
 	isl_int *ineq)
 {
-	return (isl_basic_set *)
-		isl_basic_map_add_ineq((isl_basic_map *)bset, ineq);
+	return bset_from_bmap(isl_basic_map_add_ineq(bset_to_bmap(bset), ineq));
 }
 
-int isl_basic_map_alloc_div(struct isl_basic_map *bmap)
+int isl_basic_map_alloc_div(__isl_keep isl_basic_map *bmap)
 {
-	if (!bmap)
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return -1;
 	isl_assert(bmap->ctx, bmap->n_div < bmap->extra, return -1);
-	isl_seq_clr(bmap->divbmap->n_div +
-		      1 + 1 + isl_basic_map_total_dim(bmap),
+	isl_seq_clr(bmap->divbmap->n_div + 1 + 1 + total,
 		      bmap->extra - bmap->n_div);
 	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
 	return bmap->n_div++;
 }
 
-int isl_basic_set_alloc_div(struct isl_basic_set *bset)
+int isl_basic_set_alloc_div(__isl_keep isl_basic_set *bset)
 {
-	return isl_basic_map_alloc_div((struct isl_basic_map *)bset);
+	return isl_basic_map_alloc_div(bset_to_bmap(bset));
 }
 
-int isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n)
+#undef TYPE
+#define TYPE	isl_basic_map
+#include "check_type_range_templ.c"
+
+/* Check that there are "n" dimensions of type "type" starting at "first"
+ * in "bset".
+ */
+isl_stat isl_basic_set_check_range(__isl_keep isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	if (!bmap)
-		return -1;
-	isl_assert(bmap->ctx, n <= bmap->n_div, return -1);
-	bmap->n_div -= n;
-	return 0;
+	return isl_basic_map_check_range(bset_to_bmap(bset),
+					type, first, n);
 }
 
-int isl_basic_set_free_div(struct isl_basic_set *bset, unsigned n)
+/* Insert an extra integer division, prescribed by "div", to "bmap"
+ * at (integer division) position "pos".
+ *
+ * The integer division is first added at the end and then moved
+ * into the right position.
+ */
+__isl_give isl_basic_map *isl_basic_map_insert_div(
+	__isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div)
 {
-	return isl_basic_map_free_div((struct isl_basic_map *)bset, n);
-}
+	int i, k;
+	isl_size total;
 
-/* Copy constraint from src to dst, putting the vars of src at offset
- * dim_off in dst and the divs of src at offset div_off in dst.
- * If both sets are actually map, then dim_off applies to the input
- * variables.
- */
-static void copy_constraint(struct isl_basic_map *dst_map, isl_int *dst,
-			    struct isl_basic_map *src_map, isl_int *src,
-			    unsigned in_off, unsigned out_off, unsigned div_off)
-{
-	unsigned src_nparam = isl_basic_map_n_param(src_map);
-	unsigned dst_nparam = isl_basic_map_n_param(dst_map);
-	unsigned src_in = isl_basic_map_n_in(src_map);
-	unsigned dst_in = isl_basic_map_n_in(dst_map);
-	unsigned src_out = isl_basic_map_n_out(src_map);
-	unsigned dst_out = isl_basic_map_n_out(dst_map);
-	isl_int_set(dst0, src0);
-	isl_seq_cpy(dst+1, src+1, isl_min(dst_nparam, src_nparam));
-	if (dst_nparam > src_nparam)
-		isl_seq_clr(dst+1+src_nparam,
-				dst_nparam - src_nparam);
-	isl_seq_clr(dst+1+dst_nparam, in_off);
-	isl_seq_cpy(dst+1+dst_nparam+in_off,
-		    src+1+src_nparam,
-		    isl_min(dst_in-in_off, src_in));
-	if (dst_in-in_off > src_in)
-		isl_seq_clr(dst+1+dst_nparam+in_off+src_in,
-				dst_in - in_off - src_in);
-	isl_seq_clr(dst+1+dst_nparam+dst_in, out_off);
-	isl_seq_cpy(dst+1+dst_nparam+dst_in+out_off,
-		    src+1+src_nparam+src_in,
-		    isl_min(dst_out-out_off, src_out));
-	if (dst_out-out_off > src_out)
-		isl_seq_clr(dst+1+dst_nparam+dst_in+out_off+src_out,
-				dst_out - out_off - src_out);
-	isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out, div_off);
-	isl_seq_cpy(dst+1+dst_nparam+dst_in+dst_out+div_off,
-		    src+1+src_nparam+src_in+src_out,
-		    isl_min(dst_map->extra-div_off, src_map->n_div));
-	if (dst_map->n_div-div_off > src_map->n_div)
-		isl_seq_clr(dst+1+dst_nparam+dst_in+dst_out+
-				div_off+src_map->n_div,
-				dst_map->n_div - div_off - src_map->n_div);
-}
-
-static void copy_div(struct isl_basic_map *dst_map, isl_int *dst,
-		     struct isl_basic_map *src_map, isl_int *src,
-		     unsigned in_off, unsigned out_off, unsigned div_off)
-{
-	isl_int_set(dst0, src0);
-	copy_constraint(dst_map, dst+1, src_map, src+1, in_off, out_off, div_off);
-}
+	bmap = isl_basic_map_cow(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0 || !div)
+		return isl_basic_map_free(bmap);
 
-static struct isl_basic_map *add_constraints(struct isl_basic_map *bmap1,
-		struct isl_basic_map *bmap2, unsigned i_pos, unsigned o_pos)
-{
-	int i;
-	unsigned div_off;
+	if (div->size != 1 + 1 + total)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"unexpected size", return isl_basic_map_free(bmap));
+	if (isl_basic_map_check_range(bmap, isl_dim_div, pos, 0) < 0)
+		return isl_basic_map_free(bmap);
 
-	if (!bmap1 || !bmap2)
-		goto error;
+	bmap = isl_basic_map_extend(bmap, 1, 0, 2);
+	k = isl_basic_map_alloc_div(bmap);
+	if (k < 0)
+		return isl_basic_map_free(bmap);
+	isl_seq_cpy(bmap->divk, div->el, div->size);
+	isl_int_set_si(bmap->divkdiv->size, 0);
 
-	div_off = bmap1->n_div;
+	for (i = k; i > pos; --i)
+		bmap = isl_basic_map_swap_div(bmap, i, i - 1);
 
-	for (i = 0; i < bmap2->n_eq; ++i) {
-		int i1 = isl_basic_map_alloc_equality(bmap1);
-		if (i1 < 0)
-			goto error;
-		copy_constraint(bmap1, bmap1->eqi1, bmap2, bmap2->eqi,
-				i_pos, o_pos, div_off);
-	}
+	return bmap;
+}
 
-	for (i = 0; i < bmap2->n_ineq; ++i) {
-		int i1 = isl_basic_map_alloc_inequality(bmap1);
-		if (i1 < 0)
-			goto error;
-		copy_constraint(bmap1, bmap1->ineqi1, bmap2, bmap2->ineqi,
-				i_pos, o_pos, div_off);
-	}
+isl_stat isl_basic_map_free_div(__isl_keep isl_basic_map *bmap, unsigned n)
+{
+	if (!bmap)
+		return isl_stat_error;
+	isl_assert(bmap->ctx, n <= bmap->n_div, return isl_stat_error);
+	bmap->n_div -= n;
+	return isl_stat_ok;
+}
 
-	for (i = 0; i < bmap2->n_div; ++i) {
-		int i1 = isl_basic_map_alloc_div(bmap1);
-		if (i1 < 0)
-			goto error;
-		copy_div(bmap1, bmap1->divi1, bmap2, bmap2->divi,
-			 i_pos, o_pos, div_off);
-	}
+static __isl_give isl_basic_map *add_constraints(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2,
+	unsigned i_pos, unsigned o_pos)
+{
+	isl_size total, n_param, n_in, n_out, n_div;
+	unsigned o_in, o_out;
+	isl_ctx *ctx;
+	isl_space *space;
+	struct isl_dim_map *dim_map;
 
-	isl_basic_map_free(bmap2);
+	space = isl_basic_map_peek_space(bmap2);
+	if (!bmap1 || !space)
+		goto error;
 
-	return bmap1;
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	n_param = isl_basic_map_dim(bmap2, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap2, isl_dim_in);
+	o_in = isl_basic_map_offset(bmap1, isl_dim_in) - 1 + i_pos;
+	n_out = isl_basic_map_dim(bmap2, isl_dim_out);
+	o_out = isl_basic_map_offset(bmap1, isl_dim_out) - 1 + o_pos;
+	n_div = isl_basic_map_dim(bmap2, isl_dim_div);
+	if (total < 0 || n_param < 0 || n_in < 0 || n_out < 0 || n_div < 0)
+		goto error;
+	ctx = isl_basic_map_get_ctx(bmap1);
+	dim_map = isl_dim_map_alloc(ctx, total + n_div);
+	isl_dim_map_dim_range(dim_map, space, isl_dim_param, 0, n_param, 0);
+	isl_dim_map_dim_range(dim_map, space, isl_dim_in, 0, n_in, o_in);
+	isl_dim_map_dim_range(dim_map, space, isl_dim_out, 0, n_out, o_out);
+	isl_dim_map_div(dim_map, bmap2, total);
 
+	return isl_basic_map_add_constraints_dim_map(bmap1, bmap2, dim_map);
 error:
 	isl_basic_map_free(bmap1);
 	isl_basic_map_free(bmap2);
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1,
-		struct isl_basic_set *bset2, unsigned pos)
-{
-	return (struct isl_basic_set *)
-		add_constraints((struct isl_basic_map *)bset1,
-				(struct isl_basic_map *)bset2, 0, pos);
-}
-
-struct isl_basic_map *isl_basic_map_extend_space(struct isl_basic_map *base,
-		__isl_take isl_space *dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq)
+__isl_give isl_basic_map *isl_basic_map_extend(__isl_take isl_basic_map *base,
+	unsigned extra, unsigned n_eq, unsigned n_ineq)
 {
+	isl_space *space;
 	struct isl_basic_map *ext;
 	unsigned flags;
 	int dims_ok;
 
-	if (!dim)
-		goto error;
-
 	if (!base)
 		goto error;
 
-	dims_ok = isl_space_is_equal(base->dim, dim) &&
-		  base->extra >= base->n_div + extra;
+	dims_ok = base->extra >= base->n_div + extra;
 
 	if (dims_ok && room_for_con(base, n_eq + n_ineq) &&
-		       room_for_ineq(base, n_ineq)) {
-		isl_space_free(dim);
+		       room_for_ineq(base, n_ineq))
 		return base;
-	}
 
-	isl_assert(base->ctx, base->dim->nparam <= dim->nparam, goto error);
-	isl_assert(base->ctx, base->dim->n_in <= dim->n_in, goto error);
-	isl_assert(base->ctx, base->dim->n_out <= dim->n_out, goto error);
 	extra += base->extra;
 	n_eq += base->n_eq;
 	n_ineq += base->n_ineq;
 
-	ext = isl_basic_map_alloc_space(dim, extra, n_eq, n_ineq);
-	dim = NULL;
+	space = isl_basic_map_get_space(base);
+	ext = isl_basic_map_alloc_space(space, extra, n_eq, n_ineq);
 	if (!ext)
 		goto error;
 
@@ -1539,73 +2005,37 @@
 	return ext;
 
 error:
-	isl_space_free(dim);
 	isl_basic_map_free(base);
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_extend_space(struct isl_basic_set *base,
-		__isl_take isl_space *dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq)
+__isl_give isl_basic_set *isl_basic_set_extend(__isl_take isl_basic_set *base,
+	unsigned extra, unsigned n_eq, unsigned n_ineq)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_extend_space((struct isl_basic_map *)base, dim,
-							extra, n_eq, n_ineq);
+	return bset_from_bmap(isl_basic_map_extend(bset_to_bmap(base),
+						    extra, n_eq, n_ineq));
 }
 
-struct isl_basic_map *isl_basic_map_extend_constraints(
-		struct isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
+__isl_give isl_basic_map *isl_basic_map_extend_constraints(
+	__isl_take isl_basic_map *base, unsigned n_eq, unsigned n_ineq)
 {
-	if (!base)
-		return NULL;
-	return isl_basic_map_extend_space(base, isl_space_copy(base->dim),
-					0, n_eq, n_ineq);
+	return isl_basic_map_extend(base, 0, n_eq, n_ineq);
 }
 
-struct isl_basic_map *isl_basic_map_extend(struct isl_basic_map *base,
-		unsigned nparam, unsigned n_in, unsigned n_out, unsigned extra,
-		unsigned n_eq, unsigned n_ineq)
+__isl_give isl_basic_set *isl_basic_set_extend_constraints(
+	__isl_take isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
 {
-	struct isl_basic_map *bmap;
-	isl_space *dim;
-
-	if (!base)
-		return NULL;
-	dim = isl_space_alloc(base->ctx, nparam, n_in, n_out);
-	if (!dim)
-		goto error;
-
-	bmap = isl_basic_map_extend_space(base, dim, extra, n_eq, n_ineq);
-	return bmap;
-error:
-	isl_basic_map_free(base);
-	return NULL;
+	isl_basic_map *bmap = bset_to_bmap(base);
+	bmap = isl_basic_map_extend_constraints(bmap, n_eq, n_ineq);
+	return bset_from_bmap(bmap);
 }
 
-struct isl_basic_set *isl_basic_set_extend(struct isl_basic_set *base,
-		unsigned nparam, unsigned dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_extend((struct isl_basic_map *)base,
-					nparam, 0, dim, extra, n_eq, n_ineq);
-}
-
-struct isl_basic_set *isl_basic_set_extend_constraints(
-		struct isl_basic_set *base, unsigned n_eq, unsigned n_ineq)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_extend_constraints((struct isl_basic_map *)base,
-						    n_eq, n_ineq);
-}
-
-struct isl_basic_set *isl_basic_set_cow(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_cow(__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_cow((struct isl_basic_map *)bset);
+	return bset_from_bmap(isl_basic_map_cow(bset_to_bmap(bset)));
 }
 
-struct isl_basic_map *isl_basic_map_cow(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_cow(__isl_take isl_basic_map *bmap)
 {
 	if (!bmap)
 		return NULL;
@@ -1614,29 +2044,49 @@
 		bmap->ref--;
 		bmap = isl_basic_map_dup(bmap);
 	}
-	if (bmap)
+	if (bmap) {
 		ISL_F_CLR(bmap, ISL_BASIC_SET_FINAL);
+		ISL_F_CLR(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS);
+	}
 	return bmap;
 }
 
-struct isl_set *isl_set_cow(struct isl_set *set)
+/* Clear all cached information in "map", either because it is about
+ * to be modified or because it is being freed.
+ * Always return the same pointer that is passed in.
+ * This is needed for the use in isl_map_free.
+ */
+static __isl_give isl_map *clear_caches(__isl_take isl_map *map)
 {
-	if (!set)
-		return NULL;
+	isl_basic_map_free(map->cached_simple_hull0);
+	isl_basic_map_free(map->cached_simple_hull1);
+	map->cached_simple_hull0 = NULL;
+	map->cached_simple_hull1 = NULL;
+	return map;
+}
 
-	if (set->ref == 1)
-		return set;
-	set->ref--;
-	return isl_set_dup(set);
+__isl_give isl_set *isl_set_cow(__isl_take isl_set *set)
+{
+	return isl_map_cow(set);
 }
 
-struct isl_map *isl_map_cow(struct isl_map *map)
+/* Return an isl_map that is equal to "map" and that has only
+ * a single reference.
+ *
+ * If the original input already has only one reference, then
+ * simply return it, but clear all cached information, since
+ * it may be rendered invalid by the operations that will be
+ * performed on the result.
+ *
+ * Otherwise, create a duplicate (without any cached information).
+ */
+__isl_give isl_map *isl_map_cow(__isl_take isl_map *map)
 {
 	if (!map)
 		return NULL;
 
 	if (map->ref == 1)
-		return map;
+		return clear_caches(map);
 	map->ref--;
 	return isl_map_dup(map);
 }
@@ -1655,12 +2105,9 @@
 	int i;
 	struct isl_blk blk;
 
-	if (!bmap)
+	if (isl_basic_map_check_range(bmap, isl_dim_all, pos - 1, n1 + n2) < 0)
 		goto error;
 
-	isl_assert(bmap->ctx,
-		pos + n1 + n2 <= 1 + isl_basic_map_total_dim(bmap), goto error);
-
 	if (n1 == 0 || n2 == 0)
 		return bmap;
 
@@ -1686,7 +2133,7 @@
 
 	isl_blk_free(bmap->ctx, blk);
 
-	ISL_F_CLR(bmap, ISL_BASIC_SET_NORMALIZED);
+	ISL_F_CLR(bmap, ISL_BASIC_SET_SORTED);
 	bmap = isl_basic_map_gauss(bmap, NULL);
 	return isl_basic_map_finalize(bmap);
 error:
@@ -1694,37 +2141,42 @@
 	return NULL;
 }
 
-static __isl_give isl_basic_set *isl_basic_set_swap_vars(
-	__isl_take isl_basic_set *bset, unsigned n)
-{
-	unsigned dim;
-	unsigned nparam;
-
-	if (!bset)
-		return NULL;
-
-	nparam = isl_basic_set_n_param(bset);
-	dim = isl_basic_set_n_dim(bset);
-	isl_assert(bset->ctx, n <= dim, goto error);
-
-	return isl_basic_map_swap_vars(bset, 1 + nparam, n, dim - n);
-error:
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
-struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap)
+/* The given basic map has turned out to be empty.
+ * Explicitly mark it as such and change the representation
+ * to a canonical representation of the empty basic map.
+ * Since the basic map has conflicting constraints,
+ * it must have at least one constraint, except perhaps
+ * if it was already explicitly marked as being empty.
+ * Do nothing in the latter case, i.e., if it has been marked empty and
+ * has no constraints.
+ */
+__isl_give isl_basic_map *isl_basic_map_set_to_empty(
+	__isl_take isl_basic_map *bmap)
 {
 	int i = 0;
-	unsigned total;
+	isl_bool empty;
+	isl_size n;
+	isl_size total;
+
+	n = isl_basic_map_n_constraint(bmap);
+	empty = isl_basic_map_plain_is_empty(bmap);
+	if (n < 0 || empty < 0)
+		return isl_basic_map_free(bmap);
+	if (n == 0 && empty)
+		return bmap;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	if (isl_basic_map_free_div(bmap, bmap->n_div) < 0)
+		return isl_basic_map_free(bmap);
+	bmap = isl_basic_map_free_inequality(bmap, bmap->n_ineq);
 	if (!bmap)
-		goto error;
-	total = isl_basic_map_total_dim(bmap);
-	isl_basic_map_free_div(bmap, bmap->n_div);
-	isl_basic_map_free_inequality(bmap, bmap->n_ineq);
-	if (bmap->n_eq > 0)
-		isl_basic_map_free_equality(bmap, bmap->n_eq-1);
-	else {
+		return NULL;
+	if (bmap->n_eq > 0) {
+		bmap = isl_basic_map_free_equality(bmap, bmap->n_eq - 1);
+		if (!bmap)
+			return NULL;
+	} else {
 		i = isl_basic_map_alloc_equality(bmap);
 		if (i < 0)
 			goto error;
@@ -1740,10 +2192,75 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_set_to_empty(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_set_to_empty(
+	__isl_take isl_basic_set *bset)
+{
+	return bset_from_bmap(isl_basic_map_set_to_empty(bset_to_bmap(bset)));
+}
+
+__isl_give isl_basic_map *isl_basic_map_set_rational(
+	__isl_take isl_basic_map *bmap)
+{
+	if (!bmap)
+		return NULL;
+
+	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+		return bmap;
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		return NULL;
+
+	ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL);
+
+	return isl_basic_map_finalize(bmap);
+}
+
+__isl_give isl_basic_set *isl_basic_set_set_rational(
+	__isl_take isl_basic_set *bset)
+{
+	return isl_basic_map_set_rational(bset);
+}
+
+__isl_give isl_basic_set *isl_basic_set_set_integral(
+	__isl_take isl_basic_set *bset)
+{
+	if (!bset)
+		return NULL;
+
+	if (!ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL))
+		return bset;
+
+	bset = isl_basic_set_cow(bset);
+	if (!bset)
+		return NULL;
+
+	ISL_F_CLR(bset, ISL_BASIC_MAP_RATIONAL);
+
+	return isl_basic_set_finalize(bset);
+}
+
+__isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_set_to_empty((struct isl_basic_map *)bset);
+	int i;
+
+	map = isl_map_cow(map);
+	if (!map)
+		return NULL;
+	for (i = 0; i < map->n; ++i) {
+		map->pi = isl_basic_map_set_rational(map->pi);
+		if (!map->pi)
+			goto error;
+	}
+	return map;
+error:
+	isl_map_free(map);
+	return NULL;
+}
+
+__isl_give isl_set *isl_set_set_rational(__isl_take isl_set *set)
+{
+	return isl_map_set_rational(set);
 }
 
 /* Swap divs "a" and "b" in "bmap" (without modifying any of the constraints
@@ -1759,10 +2276,15 @@
 /* Swap divs "a" and "b" in "bmap" and adjust the constraints and
  * div definitions accordingly.
  */
-void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b)
+__isl_give isl_basic_map *isl_basic_map_swap_div(__isl_take isl_basic_map *bmap,
+	int a, int b)
 {
 	int i;
-	unsigned off = isl_space_dim(bmap->dim, isl_dim_all);
+	isl_size off;
+
+	off = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (off < 0)
+		return isl_basic_map_free(bmap);
 
 	swap_div(bmap, a, b);
 
@@ -1774,7 +2296,213 @@
 
 	for (i = 0; i < bmap->n_div; ++i)
 		isl_int_swap(bmap->divi1+1+off+a, bmap->divi1+1+off+b);
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
+
+	return bmap;
+}
+
+static void constraint_drop_vars(isl_int *c, unsigned n, unsigned rem)
+{
+	isl_seq_cpy(c, c + n, rem);
+	isl_seq_clr(c + rem, n);
+}
+
+/* Drop n dimensions starting at first.
+ *
+ * In principle, this frees up some extra variables as the number
+ * of columns remains constant, but we would have to extend
+ * the div array too as the number of rows in this array is assumed
+ * to be equal to extra.
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_dims(
+	__isl_take isl_basic_set *bset, unsigned first, unsigned n)
+{
+	return isl_basic_map_drop(bset_to_bmap(bset), isl_dim_set, first, n);
+}
+
+/* Move "n" divs starting at "first" to the end of the list of divs.
+ */
+static __isl_give isl_basic_map *move_divs_last(__isl_take isl_basic_map *bmap,
+	unsigned first, unsigned n)
+{
+	isl_int **div;
+	int i;
+
+	if (first + n == bmap->n_div)
+		return bmap;
+
+	div = isl_alloc_array(bmap->ctx, isl_int *, n);
+	if (!div)
+		goto error;
+	for (i = 0; i < n; ++i)
+		divi = bmap->divfirst + i;
+	for (i = 0; i < bmap->n_div - first - n; ++i)
+		bmap->divfirst + i = bmap->divfirst + n + i;
+	for (i = 0; i < n; ++i)
+		bmap->divbmap->n_div - n + i = divi;
+	free(div);
+	return bmap;
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+#undef TYPE
+#define TYPE	isl_map
+static
+#include "check_type_range_templ.c"
+
+/* Check that there are "n" dimensions of type "type" starting at "first"
+ * in "set".
+ */
+isl_stat isl_set_check_range(__isl_keep isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_map_check_range(set_to_map(set), type, first, n);
+}
+
+/* Drop "n" dimensions of type "type" starting at "first".
+ * Perform the core computation, without cowing or
+ * simplifying and finalizing the result.
+ *
+ * In principle, this frees up some extra variables as the number
+ * of columns remains constant, but we would have to extend
+ * the div array too as the number of rows in this array is assumed
+ * to be equal to extra.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_core(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type,
+	unsigned first, unsigned n)
+{
+	int i;
+	unsigned offset;
+	unsigned left;
+	isl_size total;
+
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+
+	offset = isl_basic_map_offset(bmap, type) + first;
+	left = total - (offset - 1) - n;
+	for (i = 0; i < bmap->n_eq; ++i)
+		constraint_drop_vars(bmap->eqi+offset, n, left);
+
+	for (i = 0; i < bmap->n_ineq; ++i)
+		constraint_drop_vars(bmap->ineqi+offset, n, left);
+
+	for (i = 0; i < bmap->n_div; ++i)
+		constraint_drop_vars(bmap->divi+1+offset, n, left);
+
+	if (type == isl_dim_div) {
+		bmap = move_divs_last(bmap, first, n);
+		if (!bmap)
+			return NULL;
+		if (isl_basic_map_free_div(bmap, n) < 0)
+			return isl_basic_map_free(bmap);
+	} else
+		bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
+	if (!bmap->dim)
+		return isl_basic_map_free(bmap);
+
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
+	return bmap;
+}
+
+/* Drop "n" dimensions of type "type" starting at "first".
+ *
+ * In principle, this frees up some extra variables as the number
+ * of columns remains constant, but we would have to extend
+ * the div array too as the number of rows in this array is assumed
+ * to be equal to extra.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	if (!bmap)
+		return NULL;
+	if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
+		return bmap;
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		return NULL;
+
+	bmap = isl_basic_map_drop_core(bmap, type, first, n);
+
+	bmap = isl_basic_map_simplify(bmap);
+	return isl_basic_map_finalize(bmap);
+}
+
+__isl_give isl_basic_set *isl_basic_set_drop(__isl_take isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return bset_from_bmap(isl_basic_map_drop(bset_to_bmap(bset),
+							type, first, n));
+}
+
+/* No longer consider "map" to be normalized.
+ */
+static __isl_give isl_map *isl_map_unmark_normalized(__isl_take isl_map *map)
+{
+	if (!map)
+		return NULL;
+	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	return map;
+}
+
+__isl_give isl_map *isl_map_drop(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	int i;
+	isl_space *space;
+
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_map_free(map);
+
+	if (n == 0 && !isl_space_is_named_or_nested(map->dim, type))
+		return map;
+	map = isl_map_cow(map);
+	if (!map)
+		goto error;
+
+	for (i = 0; i < map->n; ++i) {
+		map->pi = isl_basic_map_drop(map->pi, type, first, n);
+		if (!map->pi)
+			goto error;
+	}
+	map = isl_map_unmark_normalized(map);
+
+	space = isl_map_take_space(map);
+	space = isl_space_drop_dims(space, type, first, n);
+	map = isl_map_restore_space(map, space);
+
+	return map;
+error:
+	isl_map_free(map);
+	return NULL;
+}
+
+__isl_give isl_set *isl_set_drop(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return set_from_map(isl_map_drop(set_to_map(set), type, first, n));
+}
+
+/* Drop the integer division at position "div", which is assumed
+ * not to appear in any of the constraints or
+ * in any of the other integer divisions.
+ *
+ * Since the integer division is redundant, there is no need to cow.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_div(
+	__isl_take isl_basic_map *bmap, unsigned div)
+{
+	return isl_basic_map_drop_core(bmap, isl_dim_div, div, 1);
 }
 
 /* Eliminate the specified n dimensions starting at first from the
@@ -1786,14 +2514,11 @@
 {
 	int i;
 
-	if (!map)
-		return NULL;
 	if (n == 0)
 		return map;
 
-	if (first + n > isl_map_dim(map, type) || first + n < first)
-		isl_die(map->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_map_free(map);
 
 	map = isl_map_cow(map);
 	if (!map)
@@ -1817,7 +2542,7 @@
 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	return (isl_set *)isl_map_eliminate((isl_map *)set, type, first, n);
+	return set_from_map(isl_map_eliminate(set_to_map(set), type, first, n));
 }
 
 /* Eliminate the specified n dimensions starting at first from the
@@ -1833,10 +2558,12 @@
 __isl_give isl_basic_map *isl_basic_map_remove_divs(
 	__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
-	bmap = isl_basic_map_eliminate_vars(bmap,
-			    isl_space_dim(bmap->dim, isl_dim_all), bmap->n_div);
+	isl_size v_div;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
+	bmap = isl_basic_map_eliminate_vars(bmap, v_div, bmap->n_div);
 	if (!bmap)
 		return NULL;
 	bmap->n_div = 0;
@@ -1846,8 +2573,7 @@
 __isl_give isl_basic_set *isl_basic_set_remove_divs(
 	__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)isl_basic_map_remove_divs(
-			(struct isl_basic_map *)bset);
+	return bset_from_bmap(isl_basic_map_remove_divs(bset_to_bmap(bset)));
 }
 
 __isl_give isl_map *isl_map_remove_divs(__isl_take isl_map *map)
@@ -1879,13 +2605,12 @@
 	return isl_map_remove_divs(set);
 }
 
-struct isl_basic_map *isl_basic_map_remove_dims(struct isl_basic_map *bmap,
-	enum isl_dim_type type, unsigned first, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_remove_dims(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type,
+	unsigned first, unsigned n)
 {
-	if (!bmap)
-		return NULL;
-	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
-			goto error);
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
 	if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
 		return bmap;
 	bmap = isl_basic_map_eliminate_vars(bmap,
@@ -1896,33 +2621,33 @@
 		return bmap;
 	bmap = isl_basic_map_drop(bmap, type, first, n);
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 /* Return true if the definition of the given div (recursively) involves
  * any of the given variables.
  */
-static int div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
+static isl_bool div_involves_vars(__isl_keep isl_basic_map *bmap, int div,
 	unsigned first, unsigned n)
 {
 	int i;
 	unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
 
 	if (isl_int_is_zero(bmap->divdiv0))
-		return 0;
+		return isl_bool_false;
 	if (isl_seq_first_non_zero(bmap->divdiv + 1 + first, n) >= 0)
-		return 1;
+		return isl_bool_true;
 
 	for (i = bmap->n_div - 1; i >= 0; --i) {
+		isl_bool involves;
+
 		if (isl_int_is_zero(bmap->divdiv1 + div_offset + i))
 			continue;
-		if (div_involves_vars(bmap, i, first, n))
-			return 1;
+		involves = div_involves_vars(bmap, i, first, n);
+		if (involves < 0 || involves)
+			return involves;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
 /* Try and add a lower and/or upper bound on "div" to "bmap"
@@ -2021,7 +2746,6 @@
 		isl_int_set_si(bmap->ineqk1 + total + div, -1);
 	}
 
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
@@ -2079,7 +2803,7 @@
 	int i;
 	int check_lb, check_ub;
 	isl_int v;
-	unsigned total;
+	isl_size v_div;
 
 	if (!bmap)
 		return NULL;
@@ -2087,12 +2811,14 @@
 	if (isl_int_is_zero(bmap->divdiv0))
 		return bmap;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
 
 	check_lb = 0;
 	check_ub = 0;
 	for (i = 0; (!check_lb || !check_ub) && i < bmap->n_ineq; ++i) {
-		int s = isl_int_sgn(bmap->ineqi1 + total + div);
+		int s = isl_int_sgn(bmap->ineqi1 + v_div + div);
 		if (s > 0)
 			check_ub = 1;
 		if (s < 0)
@@ -2105,10 +2831,10 @@
 	isl_int_init(v);
 
 	for (i = 0; bmap && i < bmap->n_ineq; ++i) {
-		if (!isl_int_is_zero(bmap->ineqi1 + total + div))
+		if (!isl_int_is_zero(bmap->ineqi1 + v_div + div))
 			continue;
 
-		bmap = insert_bounds_on_div_from_ineq(bmap, div, i, total, v,
+		bmap = insert_bounds_on_div_from_ineq(bmap, div, i, v_div, v,
 							check_lb, check_ub);
 	}
 
@@ -2126,14 +2852,17 @@
 {
 	int i;
 
-	if (!bmap)
-		return NULL;
-	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
-			goto error);
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
 	first += isl_basic_map_offset(bmap, type);
 
 	for (i = bmap->n_div - 1; i >= 0; --i) {
-		if (!div_involves_vars(bmap, i, first, n))
+		isl_bool involves;
+
+		involves = div_involves_vars(bmap, i, first, n);
+		if (involves < 0)
+			return isl_basic_map_free(bmap);
+		if (!involves)
 			continue;
 		bmap = insert_bounds_on_div(bmap, i);
 		bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
@@ -2143,9 +2872,6 @@
 	}
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_set *isl_basic_set_remove_divs_involving_dims(
@@ -2184,98 +2910,337 @@
 __isl_give isl_set *isl_set_remove_divs_involving_dims(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	return (isl_set *)isl_map_remove_divs_involving_dims((isl_map *)set,
-							      type, first, n);
+	return set_from_map(isl_map_remove_divs_involving_dims(set_to_map(set),
+							      type, first, n));
 }
 
-/* Does the desciption of "bmap" depend on the specified dimensions?
+/* Does the description of "bmap" depend on the specified dimensions?
  * We also check whether the dimensions appear in any of the div definitions.
  * In principle there is no need for this check.  If the dimensions appear
  * in a div definition, they also appear in the defining constraints of that
  * div.
  */
-int isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_involves_dims(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
 
-	if (!bmap)
-		return -1;
-
-	if (first + n > isl_basic_map_dim(bmap, type))
-		isl_die(bmap->ctx, isl_error_invalid,
-			"index out of bounds", return -1);
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_bool_error;
 
 	first += isl_basic_map_offset(bmap, type);
 	for (i = 0; i < bmap->n_eq; ++i)
 		if (isl_seq_first_non_zero(bmap->eqi + first, n) >= 0)
-			return 1;
+			return isl_bool_true;
 	for (i = 0; i < bmap->n_ineq; ++i)
 		if (isl_seq_first_non_zero(bmap->ineqi + first, n) >= 0)
-			return 1;
+			return isl_bool_true;
 	for (i = 0; i < bmap->n_div; ++i) {
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
 		if (isl_seq_first_non_zero(bmap->divi + 1 + first, n) >= 0)
-			return 1;
+			return isl_bool_true;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
-int isl_map_involves_dims(__isl_keep isl_map *map,
+isl_bool isl_map_involves_dims(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
 
-	if (!map)
-		return -1;
-
-	if (first + n > isl_map_dim(map, type))
-		isl_die(map->ctx, isl_error_invalid,
-			"index out of bounds", return -1);
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
-		int involves = isl_basic_map_involves_dims(map->pi,
+		isl_bool involves = isl_basic_map_involves_dims(map->pi,
 							    type, first, n);
 		if (involves < 0 || involves)
 			return involves;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
-int isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
+isl_bool isl_basic_set_involves_dims(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	return isl_basic_map_involves_dims(bset, type, first, n);
 }
 
-int isl_set_involves_dims(__isl_keep isl_set *set,
+isl_bool isl_set_involves_dims(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	return isl_map_involves_dims(set, type, first, n);
 }
 
-/* Return true if the definition of the given div is unknown or depends
- * on unknown divs.
+/* Does "bset" involve any local variables, i.e., integer divisions?
+ */
+static isl_bool isl_basic_set_involves_locals(__isl_keep isl_basic_set *bset)
+{
+	isl_size n;
+
+	n = isl_basic_set_dim(bset, isl_dim_div);
+	if (n < 0)
+		return isl_bool_error;
+	return isl_bool_ok(n > 0);
+}
+
+/* isl_set_every_basic_set callback that checks whether "bset"
+ * is free of local variables.
+ */
+static isl_bool basic_set_no_locals(__isl_keep isl_basic_set *bset, void *user)
+{
+	return isl_bool_not(isl_basic_set_involves_locals(bset));
+}
+
+/* Does "set" involve any local variables, i.e., integer divisions?
+ */
+isl_bool isl_set_involves_locals(__isl_keep isl_set *set)
+{
+	isl_bool no_locals;
+
+	no_locals = isl_set_every_basic_set(set, &basic_set_no_locals, NULL);
+	return isl_bool_not(no_locals);
+}
+
+/* Drop all constraints in bmap that involve any of the dimensions
+ * first to first+n-1.
+ * This function only performs the actual removal of constraints.
+ *
+ * This function should not call finalize since it is used by
+ * remove_redundant_divs, which in turn is called by isl_basic_map_finalize.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
+	__isl_take isl_basic_map *bmap, unsigned first, unsigned n)
+{
+	int i;
+
+	if (n == 0)
+		return bmap;
+
+	bmap = isl_basic_map_cow(bmap);
+
+	if (!bmap)
+		return NULL;
+
+	for (i = bmap->n_eq - 1; i >= 0; --i) {
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + first, n) == -1)
+			continue;
+		if (isl_basic_map_drop_equality(bmap, i) < 0)
+			return isl_basic_map_free(bmap);
+	}
+
+	for (i = bmap->n_ineq - 1; i >= 0; --i) {
+		if (isl_seq_first_non_zero(bmap->ineqi + 1 + first, n) == -1)
+			continue;
+		if (isl_basic_map_drop_inequality(bmap, i) < 0)
+			return isl_basic_map_free(bmap);
+	}
+
+	return bmap;
+}
+
+/* Drop all constraints in bset that involve any of the dimensions
+ * first to first+n-1.
+ * This function only performs the actual removal of constraints.
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving(
+	__isl_take isl_basic_set *bset, unsigned first, unsigned n)
+{
+	return isl_basic_map_drop_constraints_involving(bset, first, n);
+}
+
+/* Drop all constraints in bmap that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_not_involving_dims(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	int i;
+
+	if (n == 0) {
+		isl_space *space = isl_basic_map_get_space(bmap);
+		isl_basic_map_free(bmap);
+		return isl_basic_map_universe(space);
+	}
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		return NULL;
+
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
+
+	first += isl_basic_map_offset(bmap, type) - 1;
+
+	for (i = bmap->n_eq - 1; i >= 0; --i) {
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + first, n) != -1)
+			continue;
+		if (isl_basic_map_drop_equality(bmap, i) < 0)
+			return isl_basic_map_free(bmap);
+	}
+
+	for (i = bmap->n_ineq - 1; i >= 0; --i) {
+		if (isl_seq_first_non_zero(bmap->ineqi + 1 + first, n) != -1)
+			continue;
+		if (isl_basic_map_drop_inequality(bmap, i) < 0)
+			return isl_basic_map_free(bmap);
+	}
+
+	bmap = isl_basic_map_add_known_div_constraints(bmap);
+	return bmap;
+}
+
+/* Drop all constraints in bset that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_not_involving_dims(
+	__isl_take isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_basic_map_drop_constraints_not_involving_dims(bset,
+							    type, first, n);
+}
+
+/* Drop all constraints in bmap that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_dims(
+	__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	if (!bmap)
+		return NULL;
+	if (n == 0)
+		return bmap;
+
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
+
+	bmap = isl_basic_map_remove_divs_involving_dims(bmap, type, first, n);
+	first += isl_basic_map_offset(bmap, type) - 1;
+	bmap = isl_basic_map_drop_constraints_involving(bmap, first, n);
+	bmap = isl_basic_map_add_known_div_constraints(bmap);
+	return bmap;
+}
+
+/* Drop all constraints in bset that involve any of the dimensions
+ * first to first + n - 1 of the given type.
  */
-static int div_is_unknown(__isl_keep isl_basic_map *bmap, int div)
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_dims(
+	__isl_take isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_basic_map_drop_constraints_involving_dims(bset,
+							    type, first, n);
+}
+
+/* Drop constraints from "map" by applying "drop" to each basic map.
+ */
+static __isl_give isl_map *drop_constraints(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n,
+	__isl_give isl_basic_map *(*drop)(__isl_take isl_basic_map *bmap,
+		enum isl_dim_type type, unsigned first, unsigned n))
+{
+	int i;
+
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_map_free(map);
+
+	map = isl_map_cow(map);
+	if (!map)
+		return NULL;
+
+	for (i = 0; i < map->n; ++i) {
+		map->pi = drop(map->pi, type, first, n);
+		if (!map->pi)
+			return isl_map_free(map);
+	}
+
+	if (map->n > 1)
+		ISL_F_CLR(map, ISL_MAP_DISJOINT);
+
+	return map;
+}
+
+/* Drop all constraints in map that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_map *isl_map_drop_constraints_involving_dims(
+	__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	if (n == 0)
+		return map;
+	return drop_constraints(map, type, first, n,
+				&isl_basic_map_drop_constraints_involving_dims);
+}
+
+/* Drop all constraints in "map" that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_map *isl_map_drop_constraints_not_involving_dims(
+	__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	if (n == 0) {
+		isl_space *space = isl_map_get_space(map);
+		isl_map_free(map);
+		return isl_map_universe(space);
+	}
+	return drop_constraints(map, type, first, n,
+			    &isl_basic_map_drop_constraints_not_involving_dims);
+}
+
+/* Drop all constraints in set that involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_set *isl_set_drop_constraints_involving_dims(
+	__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_map_drop_constraints_involving_dims(set, type, first, n);
+}
+
+/* Drop all constraints in "set" that do not involve any of the dimensions
+ * first to first + n - 1 of the given type.
+ */
+__isl_give isl_set *isl_set_drop_constraints_not_involving_dims(
+	__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_map_drop_constraints_not_involving_dims(set, type, first, n);
+}
+
+/* Does local variable "div" of "bmap" have a complete explicit representation?
+ * Having a complete explicit representation requires not only
+ * an explicit representation, but also that all local variables
+ * that appear in this explicit representation in turn have
+ * a complete explicit representation.
+ */
+isl_bool isl_basic_map_div_is_known(__isl_keep isl_basic_map *bmap, int div)
 {
 	int i;
 	unsigned div_offset = isl_basic_map_offset(bmap, isl_dim_div);
+	isl_bool marked;
 
-	if (isl_int_is_zero(bmap->divdiv0))
-		return 1;
+	marked = isl_basic_map_div_is_marked_unknown(bmap, div);
+	if (marked < 0 || marked)
+		return isl_bool_not(marked);
 
 	for (i = bmap->n_div - 1; i >= 0; --i) {
+		isl_bool known;
+
 		if (isl_int_is_zero(bmap->divdiv1 + div_offset + i))
 			continue;
-		if (div_is_unknown(bmap, i))
-			return 1;
+		known = isl_basic_map_div_is_known(bmap, i);
+		if (known < 0 || !known)
+			return known;
 	}
 
-	return 0;
+	return isl_bool_true;
 }
 
 /* Remove all divs that are unknown or defined in terms of unknown divs.
@@ -2289,7 +3254,7 @@
 		return NULL;
 
 	for (i = bmap->n_div - 1; i >= 0; --i) {
-		if (!div_is_unknown(bmap, i))
+		if (isl_basic_map_div_is_known(bmap, i))
 			continue;
 		bmap = isl_basic_map_remove_dims(bmap, isl_dim_div, i, 1);
 		if (!bmap)
@@ -2334,18 +3299,19 @@
 
 __isl_give isl_set *isl_set_remove_unknown_divs(__isl_take isl_set *set)
 {
-	return (isl_set *)isl_map_remove_unknown_divs((isl_map *)set);
+	return set_from_map(isl_map_remove_unknown_divs(set_to_map(set)));
 }
 
 __isl_give isl_basic_set *isl_basic_set_remove_dims(
 	__isl_take isl_basic_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	return (isl_basic_set *)
-	    isl_basic_map_remove_dims((isl_basic_map *)bset, type, first, n);
+	isl_basic_map *bmap = bset_to_bmap(bset);
+	bmap = isl_basic_map_remove_dims(bmap, type, first, n);
+	return bset_from_bmap(bmap);
 }
 
-struct isl_map *isl_map_remove_dims(struct isl_map *map,
+__isl_give isl_map *isl_map_remove_dims(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
@@ -2354,9 +3320,8 @@
 		return map;
 
 	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_map_free(map);
 	
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_eliminate_vars(map->pi,
@@ -2374,135 +3339,22 @@
 __isl_give isl_set *isl_set_remove_dims(__isl_take isl_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
-	return (isl_set *)isl_map_remove_dims((isl_map *)bset, type, first, n);
+	return set_from_map(isl_map_remove_dims(set_to_map(bset),
+						type, first, n));
 }
 
 /* Project out n inputs starting at first using Fourier-Motzkin */
-struct isl_map *isl_map_remove_inputs(struct isl_map *map,
+__isl_give isl_map *isl_map_remove_inputs(__isl_take isl_map *map,
 	unsigned first, unsigned n)
 {
 	return isl_map_remove_dims(map, isl_dim_in, first, n);
 }
 
-static void dump_term(struct isl_basic_map *bmap,
-			isl_int c, int pos, FILE *out)
-{
-	const char *name;
-	unsigned in = isl_basic_map_n_in(bmap);
-	unsigned dim = in + isl_basic_map_n_out(bmap);
-	unsigned nparam = isl_basic_map_n_param(bmap);
-	if (!pos)
-		isl_int_print(out, c, 0);
-	else {
-		if (!isl_int_is_one(c))
-			isl_int_print(out, c, 0);
-		if (pos < 1 + nparam) {
-			name = isl_space_get_dim_name(bmap->dim,
-						isl_dim_param, pos - 1);
-			if (name)
-				fprintf(out, "%s", name);
-			else
-				fprintf(out, "p%d", pos - 1);
-		} else if (pos < 1 + nparam + in)
-			fprintf(out, "i%d", pos - 1 - nparam);
-		else if (pos < 1 + nparam + dim)
-			fprintf(out, "o%d", pos - 1 - nparam - in);
-		else
-			fprintf(out, "e%d", pos - 1 - nparam - dim);
-	}
-}
-
-static void dump_constraint_sign(struct isl_basic_map *bmap, isl_int *c,
-				int sign, FILE *out)
-{
-	int i;
-	int first;
-	unsigned len = 1 + isl_basic_map_total_dim(bmap);
-	isl_int v;
-
-	isl_int_init(v);
-	for (i = 0, first = 1; i < len; ++i) {
-		if (isl_int_sgn(ci) * sign <= 0)
-			continue;
-		if (!first)
-			fprintf(out, " + ");
-		first = 0;
-		isl_int_abs(v, ci);
-		dump_term(bmap, v, i, out);
-	}
-	isl_int_clear(v);
-	if (first)
-		fprintf(out, "0");
-}
-
-static void dump_constraint(struct isl_basic_map *bmap, isl_int *c,
-				const char *op, FILE *out, int indent)
-{
-	int i;
-
-	fprintf(out, "%*s", indent, "");
-
-	dump_constraint_sign(bmap, c, 1, out);
-	fprintf(out, " %s ", op);
-	dump_constraint_sign(bmap, c, -1, out);
-
-	fprintf(out, "\n");
-
-	for (i = bmap->n_div; i < bmap->extra; ++i) {
-		if (isl_int_is_zero(c1+isl_space_dim(bmap->dim, isl_dim_all)+i))
-			continue;
-		fprintf(out, "%*s", indent, "");
-		fprintf(out, "ERROR: unused div coefficient not zero\n");
-		abort();
-	}
-}
-
-static void dump_constraints(struct isl_basic_map *bmap,
-				isl_int **c, unsigned n,
-				const char *op, FILE *out, int indent)
-{
-	int i;
-
-	for (i = 0; i < n; ++i)
-		dump_constraint(bmap, ci, op, out, indent);
-}
-
-static void dump_affine(struct isl_basic_map *bmap, isl_int *exp, FILE *out)
-{
-	int j;
-	int first = 1;
-	unsigned total = isl_basic_map_total_dim(bmap);
-
-	for (j = 0; j < 1 + total; ++j) {
-		if (isl_int_is_zero(expj))
-			continue;
-		if (!first && isl_int_is_pos(expj))
-			fprintf(out, "+");
-		dump_term(bmap, expj, j, out);
-		first = 0;
-	}
-}
-
-static void dump(struct isl_basic_map *bmap, FILE *out, int indent)
-{
-	int i;
-
-	dump_constraints(bmap, bmap->eq, bmap->n_eq, "=", out, indent);
-	dump_constraints(bmap, bmap->ineq, bmap->n_ineq, ">=", out, indent);
-
-	for (i = 0; i < bmap->n_div; ++i) {
-		fprintf(out, "%*s", indent, "");
-		fprintf(out, "e%d = (", i);
-		dump_affine(bmap, bmap->divi+1, out);
-		fprintf(out, ")/");
-		isl_int_print(out, bmap->divi0, 0);
-		fprintf(out, "\n");
-	}
-}
-
-void isl_basic_set_print_internal(struct isl_basic_set *bset,
+void isl_basic_set_print_internal(__isl_keep isl_basic_set *bset,
 	FILE *out, int indent)
 {
+	isl_printer *p;
+
 	if (!bset) {
 		fprintf(out, "null basic set\n");
 		return;
@@ -2512,12 +3364,21 @@
 	fprintf(out, "ref: %d, nparam: %d, dim: %d, extra: %d, flags: %x\n",
 			bset->ref, bset->dim->nparam, bset->dim->n_out,
 			bset->extra, bset->flags);
-	dump((struct isl_basic_map *)bset, out, indent);
+
+	p = isl_printer_to_file(isl_basic_set_get_ctx(bset), out);
+	p = isl_printer_set_dump(p, 1);
+	p = isl_printer_set_indent(p, indent);
+	p = isl_printer_start_line(p);
+	p = isl_printer_print_basic_set(p, bset);
+	p = isl_printer_end_line(p);
+	isl_printer_free(p);
 }
 
-void isl_basic_map_print_internal(struct isl_basic_map *bmap,
+void isl_basic_map_print_internal(__isl_keep isl_basic_map *bmap,
 	FILE *out, int indent)
 {
+	isl_printer *p;
+
 	if (!bmap) {
 		fprintf(out, "null basic map\n");
 		return;
@@ -2529,67 +3390,48 @@
 		bmap->ref,
 		bmap->dim->nparam, bmap->dim->n_in, bmap->dim->n_out,
 		bmap->extra, bmap->flags, bmap->dim->n_id);
-	dump(bmap, out, indent);
+
+	p = isl_printer_to_file(isl_basic_map_get_ctx(bmap), out);
+	p = isl_printer_set_dump(p, 1);
+	p = isl_printer_set_indent(p, indent);
+	p = isl_printer_start_line(p);
+	p = isl_printer_print_basic_map(p, bmap);
+	p = isl_printer_end_line(p);
+	isl_printer_free(p);
 }
 
-int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos)
+__isl_give isl_basic_map *isl_inequality_negate(__isl_take isl_basic_map *bmap,
+	unsigned pos)
 {
-	unsigned total;
-	if (!bmap)
-		return -1;
-	total = isl_basic_map_total_dim(bmap);
-	isl_assert(bmap->ctx, pos < bmap->n_ineq, return -1);
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	if (pos >= bmap->n_ineq)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"invalid position", return isl_basic_map_free(bmap));
 	isl_seq_neg(bmap->ineqpos, bmap->ineqpos, 1 + total);
 	isl_int_sub_ui(bmap->ineqpos0, bmap->ineqpos0, 1);
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-	return 0;
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
+	return bmap;
 }
 
-__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *dim, int n,
+__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *space, int n,
 	unsigned flags)
 {
-	struct isl_set *set;
-
-	if (!dim)
-		return NULL;
-	isl_assert(dim->ctx, dim->n_in == 0, goto error);
-	isl_assert(dim->ctx, n >= 0, goto error);
-	set = isl_alloc(dim->ctx, struct isl_set,
-			sizeof(struct isl_set) +
-			(n - 1) * sizeof(struct isl_basic_set *));
-	if (!set)
+	if (isl_space_check_is_set(space) < 0)
 		goto error;
-
-	set->ctx = dim->ctx;
-	isl_ctx_ref(set->ctx);
-	set->ref = 1;
-	set->size = n;
-	set->n = 0;
-	set->dim = dim;
-	set->flags = flags;
-	return set;
+	return isl_map_alloc_space(space, n, flags);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-struct isl_set *isl_set_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned dim, int n, unsigned flags)
-{
-	struct isl_set *set;
-	isl_space *dims;
-
-	dims = isl_space_alloc(ctx, nparam, 0, dim);
-	if (!dims)
-		return NULL;
-
-	set = isl_set_alloc_space(dims, n, flags);
-	return set;
-}
-
 /* Make sure "map" has room for at least "n" more basic maps.
  */
-struct isl_map *isl_map_grow(struct isl_map *map, int n)
+__isl_give isl_map *isl_map_grow(__isl_take isl_map *map, int n)
 {
 	int i;
 	struct isl_map *grown = NULL;
@@ -2618,33 +3460,25 @@
 
 /* Make sure "set" has room for at least "n" more basic sets.
  */
-struct isl_set *isl_set_grow(struct isl_set *set, int n)
+__isl_give isl_set *isl_set_grow(__isl_take isl_set *set, int n)
 {
-	return (struct isl_set *)isl_map_grow((struct isl_map *)set, n);
+	return set_from_map(isl_map_grow(set_to_map(set), n));
 }
 
-struct isl_set *isl_set_dup(struct isl_set *set)
+__isl_give isl_set *isl_set_from_basic_set(__isl_take isl_basic_set *bset)
 {
-	int i;
-	struct isl_set *dup;
-
-	if (!set)
-		return NULL;
-
-	dup = isl_set_alloc_space(isl_space_copy(set->dim), set->n, set->flags);
-	if (!dup)
-		return NULL;
-	for (i = 0; i < set->n; ++i)
-		dup = isl_set_add_basic_set(dup, isl_basic_set_copy(set->pi));
-	return dup;
+	return isl_map_from_basic_map(bset);
 }
 
-struct isl_set *isl_set_from_basic_set(struct isl_basic_set *bset)
+/* This function performs the same operation as isl_set_from_basic_set,
+ * but is considered as a function on an isl_basic_set when exported.
+ */
+__isl_give isl_set *isl_basic_set_to_set(__isl_take isl_basic_set *bset)
 {
-	return isl_map_from_basic_map(bset);
+	return isl_set_from_basic_set(bset);
 }
 
-struct isl_map *isl_map_from_basic_map(struct isl_basic_map *bmap)
+__isl_give isl_map *isl_map_from_basic_map(__isl_take isl_basic_map *bmap)
 {
 	struct isl_map *map;
 
@@ -2658,30 +3492,16 @@
 __isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
 						__isl_take isl_basic_set *bset)
 {
-	return (struct isl_set *)isl_map_add_basic_map((struct isl_map *)set,
-						(struct isl_basic_map *)bset);
+	return set_from_map(isl_map_add_basic_map(set_to_map(set),
+						bset_to_bmap(bset)));
 }
 
 __isl_null isl_set *isl_set_free(__isl_take isl_set *set)
 {
-	int i;
-
-	if (!set)
-		return NULL;
-
-	if (--set->ref > 0)
-		return NULL;
-
-	isl_ctx_deref(set->ctx);
-	for (i = 0; i < set->n; ++i)
-		isl_basic_set_free(set->pi);
-	isl_space_free(set->dim);
-	free(set);
-
-	return NULL;
+	return isl_map_free(set);
 }
 
-void isl_set_print_internal(struct isl_set *set, FILE *out, int indent)
+void isl_set_print_internal(__isl_keep isl_set *set, FILE *out, int indent)
 {
 	int i;
 
@@ -2701,7 +3521,7 @@
 	}
 }
 
-void isl_map_print_internal(struct isl_map *map, FILE *out, int indent)
+void isl_map_print_internal(__isl_keep isl_map *map, FILE *out, int indent)
 {
 	int i;
 
@@ -2722,25 +3542,43 @@
 	}
 }
 
-struct isl_basic_map *isl_basic_map_intersect_domain(
-		struct isl_basic_map *bmap, struct isl_basic_set *bset)
+/* Check that the space of "bset" is the same as that of the domain of "bmap".
+ */
+static isl_stat isl_basic_map_check_compatible_domain(
+	__isl_keep isl_basic_map *bmap, __isl_keep isl_basic_set *bset)
+{
+	isl_bool ok;
+
+	ok = isl_basic_map_compatible_domain(bmap, bset);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+__isl_give isl_basic_map *isl_basic_map_intersect_domain(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *bset)
 {
 	struct isl_basic_map *bmap_domain;
+	isl_size dim;
 
-	if (!bmap || !bset)
+	if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
 		goto error;
 
-	isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param,
-					bset->dim, isl_dim_param), goto error);
-
-	if (isl_space_dim(bset->dim, isl_dim_set) != 0)
-		isl_assert(bset->ctx,
-		    isl_basic_map_compatible_domain(bmap, bset), goto error);
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		goto error;
+	if (dim != 0 &&
+	    isl_basic_map_check_compatible_domain(bmap, bset) < 0)
+		goto error;
 
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap)
 		goto error;
-	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
+	bmap = isl_basic_map_extend(bmap,
 			bset->n_div, bset->n_eq, bset->n_ineq);
 	bmap_domain = isl_basic_map_from_domain(bset);
 	bmap = add_constraints(bmap, bmap_domain, 0, 0);
@@ -2753,22 +3591,39 @@
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_intersect_range(
-		struct isl_basic_map *bmap, struct isl_basic_set *bset)
+/* Check that the space of "bset" is the same as that of the range of "bmap".
+ */
+static isl_stat isl_basic_map_check_compatible_range(
+	__isl_keep isl_basic_map *bmap, __isl_keep isl_basic_set *bset)
+{
+	isl_bool ok;
+
+	ok = isl_basic_map_compatible_range(bmap, bset);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+__isl_give isl_basic_map *isl_basic_map_intersect_range(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *bset)
 {
 	struct isl_basic_map *bmap_range;
+	isl_size dim;
 
-	if (!bmap || !bset)
+	if (isl_basic_map_check_equal_params(bmap, bset_to_bmap(bset)) < 0)
 		goto error;
 
-	isl_assert(bset->ctx, isl_space_match(bmap->dim, isl_dim_param,
-					bset->dim, isl_dim_param), goto error);
-
-	if (isl_space_dim(bset->dim, isl_dim_set) != 0)
-		isl_assert(bset->ctx,
-		    isl_basic_map_compatible_range(bmap, bset), goto error);
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		goto error;
+	if (dim != 0 && isl_basic_map_check_compatible_range(bmap, bset) < 0)
+		goto error;
 
-	if (isl_basic_set_is_universe(bset)) {
+	if (isl_basic_set_plain_is_universe(bset)) {
 		isl_basic_set_free(bset);
 		return bmap;
 	}
@@ -2776,9 +3631,9 @@
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap)
 		goto error;
-	bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
+	bmap = isl_basic_map_extend(bmap,
 			bset->n_div, bset->n_eq, bset->n_ineq);
-	bmap_range = isl_basic_map_from_basic_set(bset, isl_space_copy(bset->dim));
+	bmap_range = bset_to_bmap(bset);
 	bmap = add_constraints(bmap, bmap_range, 0, 0);
 
 	bmap = isl_basic_map_simplify(bmap);
@@ -2789,67 +3644,81 @@
 	return NULL;
 }
 
-int isl_basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec)
+isl_bool isl_basic_map_contains(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_vec *vec)
 {
 	int i;
-	unsigned total;
+	isl_size total;
 	isl_int s;
 
-	if (!bmap || !vec)
-		return -1;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0 || !vec)
+		return isl_bool_error;
 
-	total = 1 + isl_basic_map_total_dim(bmap);
-	if (total != vec->size)
-		return -1;
+	if (1 + total != vec->size)
+		return isl_bool_false;
 
 	isl_int_init(s);
 
 	for (i = 0; i < bmap->n_eq; ++i) {
-		isl_seq_inner_product(vec->el, bmap->eqi, total, &s);
+		isl_seq_inner_product(vec->el, bmap->eqi, 1 + total, &s);
 		if (!isl_int_is_zero(s)) {
 			isl_int_clear(s);
-			return 0;
+			return isl_bool_false;
 		}
 	}
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
-		isl_seq_inner_product(vec->el, bmap->ineqi, total, &s);
+		isl_seq_inner_product(vec->el, bmap->ineqi, 1 + total, &s);
 		if (isl_int_is_neg(s)) {
 			isl_int_clear(s);
-			return 0;
+			return isl_bool_false;
 		}
 	}
 
 	isl_int_clear(s);
 
-	return 1;
+	return isl_bool_true;
 }
 
-int isl_basic_set_contains(struct isl_basic_set *bset, struct isl_vec *vec)
+isl_bool isl_basic_set_contains(__isl_keep isl_basic_set *bset,
+	__isl_keep isl_vec *vec)
 {
-	return isl_basic_map_contains((struct isl_basic_map *)bset, vec);
+	return isl_basic_map_contains(bset_to_bmap(bset), vec);
 }
 
-struct isl_basic_map *isl_basic_map_intersect(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+__isl_give isl_basic_map *isl_basic_map_intersect(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
 	struct isl_vec *sample = NULL;
+	isl_space *space1, *space2;
+	isl_size dim1, dim2, nparam1, nparam2;
 
-	if (!bmap1 || !bmap2)
+	if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
 		goto error;
-
-	isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param,
-				     bmap2->dim, isl_dim_param), goto error);
-	if (isl_space_dim(bmap1->dim, isl_dim_all) ==
-				isl_space_dim(bmap1->dim, isl_dim_param) &&
-	    isl_space_dim(bmap2->dim, isl_dim_all) !=
-				isl_space_dim(bmap2->dim, isl_dim_param))
+	space1 = isl_basic_map_peek_space(bmap1);
+	space2 = isl_basic_map_peek_space(bmap2);
+	dim1 = isl_space_dim(space1, isl_dim_all);
+	dim2 = isl_space_dim(space2, isl_dim_all);
+	nparam1 = isl_space_dim(space1, isl_dim_param);
+	nparam2 = isl_space_dim(space2, isl_dim_param);
+	if (dim1 < 0 || dim2 < 0 || nparam1 < 0 || nparam2 < 0)
+		goto error;
+	if (dim1 == nparam1 && dim2 != nparam2)
 		return isl_basic_map_intersect(bmap2, bmap1);
 
-	if (isl_space_dim(bmap2->dim, isl_dim_all) !=
-					isl_space_dim(bmap2->dim, isl_dim_param))
-		isl_assert(bmap1->ctx,
-			    isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
+	if (dim2 != nparam2 &&
+	    isl_basic_map_check_equal_space(bmap1, bmap2) < 0)
+		goto error;
+
+	if (isl_basic_map_plain_is_empty(bmap1)) {
+		isl_basic_map_free(bmap2);
+		return bmap1;
+	}
+	if (isl_basic_map_plain_is_empty(bmap2)) {
+		isl_basic_map_free(bmap1);
+		return bmap2;
+	}
 
 	if (bmap1->sample &&
 	    isl_basic_map_contains(bmap1, bmap1->sample) > 0 &&
@@ -2863,7 +3732,7 @@
 	bmap1 = isl_basic_map_cow(bmap1);
 	if (!bmap1)
 		goto error;
-	bmap1 = isl_basic_map_extend_space(bmap1, isl_space_copy(bmap1->dim),
+	bmap1 = isl_basic_map_extend(bmap1,
 			bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
 	bmap1 = add_constraints(bmap1, bmap2, 0, 0);
 
@@ -2884,13 +3753,11 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_intersect(
-		struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+__isl_give isl_basic_set *isl_basic_set_intersect(
+	__isl_take isl_basic_set *bset1, __isl_take isl_basic_set *bset2)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_intersect(
-			(struct isl_basic_map *)bset1,
-			(struct isl_basic_map *)bset2);
+	return bset_from_bmap(isl_basic_map_intersect(bset_to_bmap(bset1),
+							bset_to_bmap(bset2)));
 }
 
 __isl_give isl_basic_set *isl_basic_set_intersect_params(
@@ -2915,9 +3782,6 @@
 	if (map2->p0->n_eq + map2->p0->n_ineq != 1)
 		return isl_map_intersect(map2, map1);
 
-	isl_assert(map2->ctx,
-		    map2->p0->n_eq + map2->p0->n_ineq == 1, goto error);
-
 	map1 = isl_map_cow(map1);
 	if (!map1)
 		goto error;
@@ -2925,7 +3789,6 @@
 		isl_map_free(map2);
 		return map1;
 	}
-	map1->p0 = isl_basic_map_cow(map1->p0);
 	if (map2->p0->n_eq == 1)
 		map1->p0 = isl_basic_map_add_eq(map1->p0, map2->p0->eq0);
 	else
@@ -2944,6 +3807,7 @@
 
 	isl_map_free(map2);
 
+	map1 = isl_map_unmark_normalized(map1);
 	return map1;
 error:
 	isl_map_free(map1);
@@ -2958,8 +3822,10 @@
 	__isl_take isl_map *map2)
 {
 	unsigned flags = 0;
+	isl_bool equal;
 	isl_map *result;
 	int i, j;
+	isl_size dim2, nparam2;
 
 	if (!map1 || !map2)
 		goto error;
@@ -2984,8 +3850,19 @@
 	     map2->p0->n_eq + map2->p0->n_ineq == 1))
 		return map_intersect_add_constraint(map1, map2);
 
-	if (isl_space_dim(map2->dim, isl_dim_all) !=
-				isl_space_dim(map2->dim, isl_dim_param))
+	equal = isl_map_plain_is_equal(map1, map2);
+	if (equal < 0)
+		goto error;
+	if (equal) {
+		isl_map_free(map2);
+		return map1;
+	}
+
+	dim2 = isl_map_dim(map2, isl_dim_all);
+	nparam2 = isl_map_dim(map2, isl_dim_param);
+	if (dim2 < 0 || nparam2 < 0)
+		goto error;
+	if (dim2 != nparam2)
 		isl_assert(map1->ctx,
 			    isl_space_is_equal(map1->dim, map2->dim), goto error);
 
@@ -3021,11 +3898,8 @@
 static __isl_give isl_map *map_intersect(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
-	if (!map1 || !map2)
+	if (isl_map_check_equal_space(map1, map2) < 0)
 		goto error;
-	if (!isl_space_is_equal(map1->dim, map2->dim))
-		isl_die(isl_map_get_ctx(map1), isl_error_invalid,
-			"spaces don't match", goto error);
 	return map_intersect_internal(map1, map2);
 error:
 	isl_map_free(map1);
@@ -3036,53 +3910,79 @@
 __isl_give isl_map *isl_map_intersect(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
-	return isl_map_align_params_map_map_and(map1, map2, &map_intersect);
+	isl_map_align_params_bin(&map1, &map2);
+	return map_intersect(map1, map2);
 }
 
-struct isl_set *isl_set_intersect(struct isl_set *set1, struct isl_set *set2)
+__isl_give isl_set *isl_set_intersect(__isl_take isl_set *set1,
+	__isl_take isl_set *set2)
 {
-	return (struct isl_set *)
-		isl_map_intersect((struct isl_map *)set1,
-				  (struct isl_map *)set2);
+	return set_from_map(isl_map_intersect(set_to_map(set1),
+					      set_to_map(set2)));
 }
 
 /* map_intersect_internal accepts intersections
  * with parameter domains, so we can just call that function.
  */
-static __isl_give isl_map *map_intersect_params(__isl_take isl_map *map,
-		__isl_take isl_set *params)
+__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map,
+	__isl_take isl_set *params)
 {
+	isl_map_align_params_set(&map, &params);
 	return map_intersect_internal(map, params);
 }
 
-__isl_give isl_map *isl_map_intersect_params(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
-{
-	return isl_map_align_params_map_map_and(map1, map2, &map_intersect_params);
-}
-
 __isl_give isl_set *isl_set_intersect_params(__isl_take isl_set *set,
 		__isl_take isl_set *params)
 {
 	return isl_map_intersect_params(set, params);
 }
 
-struct isl_basic_map *isl_basic_map_reverse(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_reverse(__isl_take isl_basic_map *bmap)
 {
-	isl_space *dim;
-	struct isl_basic_set *bset;
-	unsigned in;
+	isl_space *space;
+	unsigned pos;
+	isl_size n1, n2;
 
 	if (!bmap)
 		return NULL;
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap)
 		return NULL;
-	dim = isl_space_reverse(isl_space_copy(bmap->dim));
-	in = isl_basic_map_n_in(bmap);
-	bset = isl_basic_set_from_basic_map(bmap);
-	bset = isl_basic_set_swap_vars(bset, in);
-	return isl_basic_map_from_basic_set(bset, dim);
+	space = isl_space_reverse(isl_space_copy(bmap->dim));
+	pos = isl_basic_map_offset(bmap, isl_dim_in);
+	n1 = isl_basic_map_dim(bmap, isl_dim_in);
+	n2 = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n1 < 0 || n2 < 0)
+		bmap = isl_basic_map_free(bmap);
+	bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
+	return isl_basic_map_reset_space(bmap, space);
+}
+
+/* Given a basic map A -> (B -> C), return the corresponding basic map
+ * A -> (C -> B).
+ */
+static __isl_give isl_basic_map *isl_basic_map_range_reverse(
+	__isl_take isl_basic_map *bmap)
+{
+	isl_space *space;
+	isl_size offset, n1, n2;
+
+	space = isl_basic_map_peek_space(bmap);
+	if (isl_space_check_range_is_wrapping(space) < 0)
+		return isl_basic_map_free(bmap);
+	offset = isl_basic_map_var_offset(bmap, isl_dim_out);
+	n1 = isl_space_wrapped_dim(space, isl_dim_out, isl_dim_in);
+	n2 = isl_space_wrapped_dim(space, isl_dim_out, isl_dim_out);
+	if (offset < 0 || n1 < 0 || n2 < 0)
+		return isl_basic_map_free(bmap);
+
+	bmap = isl_basic_map_swap_vars(bmap, 1 + offset, n1, n2);
+
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_range_reverse(space);
+	bmap = isl_basic_map_restore_space(bmap, space);
+
+	return bmap;
 }
 
 static __isl_give isl_basic_map *basic_map_space_reset(
@@ -3105,46 +4005,60 @@
 	__isl_take isl_basic_map *bmap, enum isl_dim_type type,
 	unsigned pos, unsigned n)
 {
-	isl_space *res_dim;
+	isl_bool rational, is_empty;
+	isl_space *res_space;
 	struct isl_basic_map *res;
 	struct isl_dim_map *dim_map;
-	unsigned total, off;
+	isl_size total;
+	unsigned off;
 	enum isl_dim_type t;
 
 	if (n == 0)
 		return basic_map_space_reset(bmap, type);
 
-	if (!bmap)
-		return NULL;
-
-	res_dim = isl_space_insert_dims(isl_basic_map_get_space(bmap), type, pos, n);
+	is_empty = isl_basic_map_plain_is_empty(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (is_empty < 0 || total < 0)
+		return isl_basic_map_free(bmap);
+	res_space = isl_space_insert_dims(isl_basic_map_get_space(bmap),
+					type, pos, n);
+	if (!res_space)
+		return isl_basic_map_free(bmap);
+	if (is_empty) {
+		isl_basic_map_free(bmap);
+		return isl_basic_map_empty(res_space);
+	}
 
-	total = isl_basic_map_total_dim(bmap) + n;
-	dim_map = isl_dim_map_alloc(bmap->ctx, total);
+	dim_map = isl_dim_map_alloc(bmap->ctx, total + n);
 	off = 0;
 	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
+		isl_size dim;
+
 		if (t != type) {
 			isl_dim_map_dim(dim_map, bmap->dim, t, off);
 		} else {
-			unsigned size = isl_basic_map_dim(bmap, t);
+			isl_size size = isl_basic_map_dim(bmap, t);
+			if (size < 0)
+				dim_map = isl_dim_map_free(dim_map);
 			isl_dim_map_dim_range(dim_map, bmap->dim, t,
 						0, pos, off);
 			isl_dim_map_dim_range(dim_map, bmap->dim, t,
 						pos, size - pos, off + pos + n);
 		}
-		off += isl_space_dim(res_dim, t);
+		dim = isl_space_dim(res_space, t);
+		if (dim < 0)
+			dim_map = isl_dim_map_free(dim_map);
+		off += dim;
 	}
 	isl_dim_map_div(dim_map, bmap, off);
 
-	res = isl_basic_map_alloc_space(res_dim,
+	res = isl_basic_map_alloc_space(res_space,
 			bmap->n_div, bmap->n_eq, bmap->n_ineq);
-	if (isl_basic_map_is_rational(bmap))
+	rational = isl_basic_map_is_rational(bmap);
+	if (rational < 0)
+		res = isl_basic_map_free(res);
+	if (rational)
 		res = isl_basic_map_set_rational(res);
-	if (isl_basic_map_plain_is_empty(bmap)) {
-		isl_basic_map_free(bmap);
-		free(dim_map);
-		return isl_basic_map_set_to_empty(res);
-	}
 	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
 	return isl_basic_map_finalize(res);
 }
@@ -3156,13 +4070,15 @@
 	return isl_basic_map_insert_dims(bset, type, pos, n);
 }
 
-__isl_give isl_basic_map *isl_basic_map_add(__isl_take isl_basic_map *bmap,
+__isl_give isl_basic_map *isl_basic_map_add_dims(__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned n)
 {
-	if (!bmap)
-		return NULL;
-	return isl_basic_map_insert_dims(bmap, type,
-					isl_basic_map_dim(bmap, type), n);
+	isl_size dim;
+
+	dim = isl_basic_map_dim(bmap, type);
+	if (dim < 0)
+		return isl_basic_map_free(bmap);
+	return isl_basic_map_insert_dims(bmap, type, dim, n);
 }
 
 __isl_give isl_basic_set *isl_basic_set_add_dims(__isl_take isl_basic_set *bset,
@@ -3171,7 +4087,7 @@
 	if (!bset)
 		return NULL;
 	isl_assert(bset->ctx, type != isl_dim_in, goto error);
-	return (isl_basic_set *)isl_basic_map_add((isl_basic_map *)bset, type, n);
+	return isl_basic_map_add_dims(bset, type, n);
 error:
 	isl_basic_set_free(bset);
 	return NULL;
@@ -3195,6 +4111,7 @@
 		enum isl_dim_type type, unsigned pos, unsigned n)
 {
 	int i;
+	isl_space *space;
 
 	if (n == 0)
 		return map_space_reset(map, type);
@@ -3203,16 +4120,16 @@
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_insert_dims(map->dim, type, pos, n);
-	if (!map->dim)
-		goto error;
-
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_insert_dims(map->pi, type, pos, n);
 		if (!map->pi)
 			goto error;
 	}
 
+	space = isl_map_take_space(map);
+	space = isl_space_insert_dims(space, type, pos, n);
+	map = isl_map_restore_space(map, space);
+
 	return map;
 error:
 	isl_map_free(map);
@@ -3228,9 +4145,12 @@
 __isl_give isl_map *isl_map_add_dims(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned n)
 {
-	if (!map)
-		return NULL;
-	return isl_map_insert_dims(map, type, isl_map_dim(map, type), n);
+	isl_size dim;
+
+	dim = isl_map_dim(map, type);
+	if (dim < 0)
+		return isl_map_free(map);
+	return isl_map_insert_dims(map, type, dim, n);
 }
 
 __isl_give isl_set *isl_set_add_dims(__isl_take isl_set *set,
@@ -3239,7 +4159,7 @@
 	if (!set)
 		return NULL;
 	isl_assert(set->ctx, type != isl_dim_in, goto error);
-	return (isl_set *)isl_map_add_dims((isl_map *)set, type, n);
+	return set_from_map(isl_map_add_dims(set_to_map(set), type, n));
 error:
 	isl_set_free(set);
 	return NULL;
@@ -3250,18 +4170,23 @@
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 {
+	isl_space *space;
 	struct isl_dim_map *dim_map;
 	struct isl_basic_map *res;
 	enum isl_dim_type t;
-	unsigned total, off;
+	isl_size total;
+	unsigned off;
 
 	if (!bmap)
 		return NULL;
-	if (n == 0)
+	if (n == 0) {
+		bmap = isl_basic_map_reset(bmap, src_type);
+		bmap = isl_basic_map_reset(bmap, dst_type);
 		return bmap;
+	}
 
-	isl_assert(bmap->ctx, src_pos + n <= isl_basic_map_dim(bmap, src_type),
-		goto error);
+	if (isl_basic_map_check_range(bmap, src_type, src_pos, n) < 0)
+		return isl_basic_map_free(bmap);
 
 	if (dst_type == src_type && dst_pos == src_pos)
 		return bmap;
@@ -3271,45 +4196,45 @@
 	if (pos(bmap->dim, dst_type) + dst_pos ==
 	    pos(bmap->dim, src_type) + src_pos +
 					    ((src_type < dst_type) ? n : 0)) {
-		bmap = isl_basic_map_cow(bmap);
-		if (!bmap)
-			return NULL;
-
-		bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
+		space = isl_basic_map_take_space(bmap);
+		space = isl_space_move_dims(space, dst_type, dst_pos,
 						src_type, src_pos, n);
-		if (!bmap->dim)
-			goto error;
-
+		bmap = isl_basic_map_restore_space(bmap, space);
 		bmap = isl_basic_map_finalize(bmap);
 
 		return bmap;
 	}
 
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 
 	off = 0;
+	space = isl_basic_map_peek_space(bmap);
 	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
-		unsigned size = isl_space_dim(bmap->dim, t);
+		isl_size size = isl_space_dim(space, t);
+		if (size < 0)
+			dim_map = isl_dim_map_free(dim_map);
 		if (t == dst_type) {
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    0, dst_pos, off);
 			off += dst_pos;
-			isl_dim_map_dim_range(dim_map, bmap->dim, src_type,
+			isl_dim_map_dim_range(dim_map, space, src_type,
 					    src_pos, n, off);
 			off += n;
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    dst_pos, size - dst_pos, off);
 			off += size - dst_pos;
 		} else if (t == src_type) {
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    0, src_pos, off);
 			off += src_pos;
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					src_pos + n, size - src_pos - n, off);
 			off += size - src_pos - n;
 		} else {
-			isl_dim_map_dim(dim_map, bmap->dim, t, off);
+			isl_dim_map_dim(dim_map, space, t, off);
 			off += size;
 		}
 	}
@@ -3318,15 +4243,14 @@
 	res = isl_basic_map_alloc_space(isl_basic_map_get_space(bmap),
 			bmap->n_div, bmap->n_eq, bmap->n_ineq);
 	bmap = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
-	if (!bmap)
-		goto error;
-
-	bmap->dim = isl_space_move_dims(bmap->dim, dst_type, dst_pos,
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_move_dims(space, dst_type, dst_pos,
 					src_type, src_pos, n);
-	if (!bmap->dim)
+	bmap = isl_basic_map_restore_space(bmap, space);
+	if (!bmap)
 		goto error;
 
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
 	bmap = isl_basic_map_gauss(bmap, NULL);
 	bmap = isl_basic_map_finalize(bmap);
 
@@ -3340,8 +4264,10 @@
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 {
-	return (isl_basic_set *)isl_basic_map_move_dims(
-		(isl_basic_map *)bset, dst_type, dst_pos, src_type, src_pos, n);
+	isl_basic_map *bmap = bset_to_bmap(bset);
+	bmap = isl_basic_map_move_dims(bmap, dst_type, dst_pos,
+					src_type, src_pos, n);
+	return bset_from_bmap(bmap);
 }
 
 __isl_give isl_set *isl_set_move_dims(__isl_take isl_set *set,
@@ -3351,8 +4277,8 @@
 	if (!set)
 		return NULL;
 	isl_assert(set->ctx, dst_type != isl_dim_in, goto error);
-	return (isl_set *)isl_map_move_dims((isl_map *)set, dst_type, dst_pos,
-					src_type, src_pos, n);
+	return set_from_map(isl_map_move_dims(set_to_map(set),
+				    dst_type, dst_pos, src_type, src_pos, n));
 error:
 	isl_set_free(set);
 	return NULL;
@@ -3363,14 +4289,16 @@
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 {
 	int i;
+	isl_space *space;
 
-	if (!map)
-		return NULL;
-	if (n == 0)
+	if (n == 0) {
+		map = isl_map_reset(map, src_type);
+		map = isl_map_reset(map, dst_type);
 		return map;
+	}
 
-	isl_assert(map->ctx, src_pos + n <= isl_map_dim(map, src_type),
-		goto error);
+	if (isl_map_check_range(map, src_type, src_pos, n))
+		return isl_map_free(map);
 
 	if (dst_type == src_type && dst_pos == src_pos)
 		return map;
@@ -3381,10 +4309,6 @@
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_move_dims(map->dim, dst_type, dst_pos, src_type, src_pos, n);
-	if (!map->dim)
-		goto error;
-
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_move_dims(map->pi,
 						dst_type, dst_pos,
@@ -3393,6 +4317,11 @@
 			goto error;
 	}
 
+	space = isl_map_take_space(map);
+	space = isl_space_move_dims(space, dst_type, dst_pos,
+					    src_type, src_pos, n);
+	map = isl_map_restore_space(map, space);
+
 	return map;
 error:
 	isl_map_free(map);
@@ -3406,34 +4335,41 @@
 static __isl_give isl_basic_map *move_last(__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
+	isl_space *space;
 	struct isl_dim_map *dim_map;
 	struct isl_basic_map *res;
 	enum isl_dim_type t;
-	unsigned total, off;
+	isl_size total;
+	unsigned off;
 
 	if (!bmap)
 		return NULL;
-	if (pos(bmap->dim, type) + first + n ==
-				1 + isl_space_dim(bmap->dim, isl_dim_all))
+	if (isl_basic_map_offset(bmap, type) + first + n ==
+				isl_basic_map_offset(bmap, isl_dim_div))
 		return bmap;
 
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
 
 	off = 0;
+	space = isl_basic_map_peek_space(bmap);
 	for (t = isl_dim_param; t <= isl_dim_out; ++t) {
-		unsigned size = isl_space_dim(bmap->dim, t);
+		isl_size size = isl_space_dim(space, t);
+		if (size < 0)
+			dim_map = isl_dim_map_free(dim_map);
 		if (t == type) {
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    0, first, off);
 			off += first;
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    first, n, total - bmap->n_div - n);
-			isl_dim_map_dim_range(dim_map, bmap->dim, t,
+			isl_dim_map_dim_range(dim_map, space, t,
 					    first + n, size - (first + n), off);
 			off += size - (first + n);
 		} else {
-			isl_dim_map_dim(dim_map, bmap->dim, t, off);
+			isl_dim_map_dim(dim_map, space, t, off);
 			off += size;
 		}
 	}
@@ -3465,7 +4401,7 @@
 	if (!bmap)
 		return NULL;
 
-	row_size = 1 + isl_space_dim(bmap->dim, isl_dim_all) + bmap->extra;
+	row_size = isl_basic_map_offset(bmap, isl_dim_div) + bmap->extra;
 	old = bmap->block2.data;
 	bmap->block2 = isl_blk_extend(bmap->ctx, bmap->block2,
 					(bmap->extra + n) * (1 + row_size));
@@ -3489,50 +4425,104 @@
 	return bmap;
 }
 
+/* Drop constraints from "bmap" that only involve the variables
+ * of "type" in the range first, first + n that are not related
+ * to any of the variables outside that interval.
+ * These constraints cannot influence the values for the variables
+ * outside the interval, except in case they cause "bmap" to be empty.
+ * Only drop the constraints if "bmap" is known to be non-empty.
+ */
+static __isl_give isl_basic_map *drop_irrelevant_constraints(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type,
+	unsigned first, unsigned n)
+{
+	int i;
+	int *groups;
+	isl_size dim, n_div;
+	isl_bool non_empty;
+
+	non_empty = isl_basic_map_plain_is_non_empty(bmap);
+	if (non_empty < 0)
+		return isl_basic_map_free(bmap);
+	if (!non_empty)
+		return bmap;
+
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (dim < 0 || n_div < 0)
+		return isl_basic_map_free(bmap);
+	groups = isl_calloc_array(isl_basic_map_get_ctx(bmap), int, dim);
+	if (!groups)
+		return isl_basic_map_free(bmap);
+	first += isl_basic_map_offset(bmap, type) - 1;
+	for (i = 0; i < first; ++i)
+		groupsi = -1;
+	for (i = first + n; i < dim - n_div; ++i)
+		groupsi = -1;
+
+	bmap = isl_basic_map_drop_unrelated_constraints(bmap, groups);
+
+	return bmap;
+}
+
 /* Turn the n dimensions of type type, starting at first
  * into existentially quantified variables.
+ *
+ * If a subset of the projected out variables are unrelated
+ * to any of the variables that remain, then the constraints
+ * involving this subset are simply dropped first.
  */
 __isl_give isl_basic_map *isl_basic_map_project_out(
 		__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned first, unsigned n)
 {
+	isl_bool empty;
+	isl_space *space;
+
 	if (n == 0)
 		return basic_map_space_reset(bmap, type);
+	if (type == isl_dim_div)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"cannot project out existentially quantified variables",
+			return isl_basic_map_free(bmap));
 
+	empty = isl_basic_map_plain_is_empty(bmap);
+	if (empty < 0)
+		return isl_basic_map_free(bmap);
+	if (empty)
+		bmap = isl_basic_map_set_to_empty(bmap);
+
+	bmap = drop_irrelevant_constraints(bmap, type, first, n);
 	if (!bmap)
 		return NULL;
 
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
 		return isl_basic_map_remove_dims(bmap, type, first, n);
 
-	isl_assert(bmap->ctx, first + n <= isl_basic_map_dim(bmap, type),
-			goto error);
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
 
 	bmap = move_last(bmap, type, first, n);
 	bmap = isl_basic_map_cow(bmap);
 	bmap = insert_div_rows(bmap, n);
-	if (!bmap)
-		return NULL;
 
-	bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
-	if (!bmap->dim)
-		goto error;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_drop_dims(space, type, first, n);
+	bmap = isl_basic_map_restore_space(bmap, space);
 	bmap = isl_basic_map_simplify(bmap);
 	bmap = isl_basic_map_drop_redundant_divs(bmap);
 	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 /* Turn the n dimensions of type type, starting at first
  * into existentially quantified variables.
  */
-struct isl_basic_set *isl_basic_set_project_out(struct isl_basic_set *bset,
-		enum isl_dim_type type, unsigned first, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_project_out(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type,
+	unsigned first, unsigned n)
 {
-	return (isl_basic_set *)isl_basic_map_project_out(
-			(isl_basic_map *)bset, type, first, n);
+	return bset_from_bmap(isl_basic_map_project_out(bset_to_bmap(bset),
+							type, first, n));
 }
 
 /* Turn the n dimensions of type type, starting at first
@@ -3542,53 +4532,165 @@
 		enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
-
-	if (!map)
-		return NULL;
+	isl_space *space;
 
 	if (n == 0)
 		return map_space_reset(map, type);
 
-	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
+	if (isl_map_check_range(map, type, first, n) < 0)
+		return isl_map_free(map);
 
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_drop_dims(map->dim, type, first, n);
-	if (!map->dim)
-		goto error;
-
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_project_out(map->pi, type, first, n);
 		if (!map->pi)
 			goto error;
 	}
 
+	if (map->n > 1)
+		ISL_F_CLR(map, ISL_MAP_DISJOINT);
+	map = isl_map_unmark_normalized(map);
+
+	space = isl_map_take_space(map);
+	space = isl_space_drop_dims(space, type, first, n);
+	map = isl_map_restore_space(map, space);
+
 	return map;
 error:
 	isl_map_free(map);
 	return NULL;
 }
 
+#undef TYPE
+#define TYPE	isl_map
+#include "isl_project_out_all_params_templ.c"
+
+/* Turn all the dimensions of type "type", except the "n" starting at "first"
+ * into existentially quantified variables.
+ */
+__isl_give isl_map *isl_map_project_onto(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	isl_size dim;
+
+	dim = isl_map_dim(map, type);
+	if (isl_map_check_range(map, type, first, n) < 0 || dim < 0)
+		return isl_map_free(map);
+	map = isl_map_project_out(map, type, first + n, dim - (first + n));
+	map = isl_map_project_out(map, type, 0, first);
+	return map;
+}
+
 /* Turn the n dimensions of type type, starting at first
  * into existentially quantified variables.
  */
 __isl_give isl_set *isl_set_project_out(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned first, unsigned n)
 {
-	return (isl_set *)isl_map_project_out((isl_map *)set, type, first, n);
+	return set_from_map(isl_map_project_out(set_to_map(set),
+						type, first, n));
 }
 
-static struct isl_basic_map *add_divs(struct isl_basic_map *bmap, unsigned n)
+/* If "set" involves a parameter with identifier "id",
+ * then turn it into an existentially quantified variable.
+ */
+__isl_give isl_set *isl_set_project_out_param_id(__isl_take isl_set *set,
+	__isl_take isl_id *id)
+{
+	int pos;
+
+	if (!set || !id)
+		goto error;
+	pos = isl_set_find_dim_by_id(set, isl_dim_param, id);
+	isl_id_free(id);
+	if (pos < 0)
+		return set;
+	return isl_set_project_out(set, isl_dim_param, pos, 1);
+error:
+	isl_set_free(set);
+	isl_id_free(id);
+	return NULL;
+}
+
+/* If "set" involves any of the parameters with identifiers in "list",
+ * then turn them into existentially quantified variables.
+ */
+__isl_give isl_set *isl_set_project_out_param_id_list(__isl_take isl_set *set,
+	__isl_take isl_id_list *list)
+{
+	int i;
+	isl_size n;
+
+	n = isl_id_list_size(list);
+	if (n < 0)
+		goto error;
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+
+		id = isl_id_list_get_at(list, i);
+		set = isl_set_project_out_param_id(set, id);
+	}
+
+	isl_id_list_free(list);
+	return set;
+error:
+	isl_id_list_free(list);
+	isl_set_free(set);
+	return NULL;
+}
+
+/* Project out all parameters from "set" by existentially quantifying
+ * over them.
+ */
+__isl_give isl_set *isl_set_project_out_all_params(__isl_take isl_set *set)
+{
+	return set_from_map(isl_map_project_out_all_params(set_to_map(set)));
+}
+
+/* Return a map that projects the elements in "set" onto their
+ * "n" set dimensions starting at "first".
+ * "type" should be equal to isl_dim_set.
+ */
+__isl_give isl_map *isl_set_project_onto_map(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	int i;
+	isl_map *map;
+
+	if (type != isl_dim_set)
+		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+			"only set dimensions can be projected out", goto error);
+	if (isl_set_check_range(set, type, first, n) < 0)
+		return isl_set_free(set);
+
+	map = isl_map_from_domain(set);
+	map = isl_map_add_dims(map, isl_dim_out, n);
+	for (i = 0; i < n; ++i)
+		map = isl_map_equate(map, isl_dim_in, first + i,
+					isl_dim_out, i);
+	return map;
+error:
+	isl_set_free(set);
+	return NULL;
+}
+
+static __isl_give isl_basic_map *add_divs(__isl_take isl_basic_map *bmap,
+	unsigned n)
 {
 	int i, j;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	for (i = 0; i < n; ++i) {
 		j = isl_basic_map_alloc_div(bmap);
 		if (j < 0)
 			goto error;
-		isl_seq_clr(bmap->divj, 1+1+isl_basic_map_total_dim(bmap));
+		isl_seq_clr(bmap->divj, 1 + 1 + total);
 	}
 	return bmap;
 error:
@@ -3596,32 +4698,58 @@
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_apply_range(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+/* Does "bmap2" apply to the range of "bmap1" (ignoring parameters)?
+ */
+isl_bool isl_basic_map_applies_range(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
+{
+	isl_space *space1, *space2;
+
+	space1 = isl_basic_map_peek_space(bmap1);
+	space2 = isl_basic_map_peek_space(bmap2);
+	return isl_space_tuple_is_equal(space1, isl_dim_out,
+					space2, isl_dim_in);
+}
+
+/* Check that "bmap2" applies to the range of "bmap1" (ignoring parameters).
+ */
+static isl_stat isl_basic_map_check_applies_range(
+	__isl_keep isl_basic_map *bmap1, __isl_keep isl_basic_map *bmap2)
+{
+	isl_bool equal;
+
+	equal = isl_basic_map_applies_range(bmap1, bmap2);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
+			"spaces don't match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+__isl_give isl_basic_map *isl_basic_map_apply_range(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
-	isl_space *dim_result = NULL;
+	isl_space *space_result = NULL;
 	struct isl_basic_map *bmap;
-	unsigned n_in, n_out, n, nparam, total, pos;
+	isl_size n_in, n_out, n, nparam;
+	unsigned total, pos;
 	struct isl_dim_map *dim_map1, *dim_map2;
 
-	if (!bmap1 || !bmap2)
+	if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
+		goto error;
+	if (isl_basic_map_check_applies_range(bmap1, bmap2) < 0)
 		goto error;
-	if (!isl_space_match(bmap1->dim, isl_dim_param,
-				bmap2->dim, isl_dim_param))
-		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
-			"parameters don't match", goto error);
-	if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_out,
-				    bmap2->dim, isl_dim_in))
-		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
-			"spaces don't match", goto error);
 
-	dim_result = isl_space_join(isl_space_copy(bmap1->dim),
-				  isl_space_copy(bmap2->dim));
+	n_in = isl_basic_map_dim(bmap1, isl_dim_in);
+	n_out = isl_basic_map_dim(bmap2, isl_dim_out);
+	n = isl_basic_map_dim(bmap1, isl_dim_out);
+	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
+	if (n_in < 0 || n_out < 0 || n < 0 || nparam < 0)
+		goto error;
 
-	n_in = isl_basic_map_n_in(bmap1);
-	n_out = isl_basic_map_n_out(bmap2);
-	n = isl_basic_map_n_out(bmap1);
-	nparam = isl_basic_map_n_param(bmap1);
+	space_result = isl_space_join(isl_basic_map_get_space(bmap1),
+				  isl_basic_map_get_space(bmap2));
 
 	total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + n;
 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
@@ -3635,7 +4763,7 @@
 	isl_dim_map_dim(dim_map1, bmap1->dim, isl_dim_out, pos += bmap2->n_div);
 	isl_dim_map_dim(dim_map2, bmap2->dim, isl_dim_in, pos);
 
-	bmap = isl_basic_map_alloc_space(dim_result,
+	bmap = isl_basic_map_alloc_space(space_result,
 			bmap1->n_div + bmap2->n_div + n,
 			bmap1->n_eq + bmap2->n_eq,
 			bmap1->n_ineq + bmap2->n_ineq);
@@ -3651,34 +4779,29 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_apply(
-		struct isl_basic_set *bset, struct isl_basic_map *bmap)
+__isl_give isl_basic_set *isl_basic_set_apply(__isl_take isl_basic_set *bset,
+	__isl_take isl_basic_map *bmap)
 {
-	if (!bset || !bmap)
+	if (isl_basic_map_check_compatible_domain(bmap, bset) < 0)
 		goto error;
 
-	isl_assert(bset->ctx, isl_basic_map_compatible_domain(bmap, bset),
-		    goto error);
-
-	return (struct isl_basic_set *)
-		isl_basic_map_apply_range((struct isl_basic_map *)bset, bmap);
+	return bset_from_bmap(isl_basic_map_apply_range(bset_to_bmap(bset),
+							bmap));
 error:
 	isl_basic_set_free(bset);
 	isl_basic_map_free(bmap);
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_apply_domain(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+__isl_give isl_basic_map *isl_basic_map_apply_domain(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
-	if (!bmap1 || !bmap2)
+	if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
 		goto error;
-
-	isl_assert(bmap1->ctx,
-	    isl_basic_map_n_in(bmap1) == isl_basic_map_n_in(bmap2), goto error);
-	isl_assert(bmap1->ctx,
-	    isl_basic_map_n_param(bmap1) == isl_basic_map_n_param(bmap2),
-	    goto error);
+	if (!isl_space_tuple_is_equal(bmap1->dim, isl_dim_in,
+					bmap2->dim, isl_dim_in))
+		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
+			"spaces don't match", goto error);
 
 	bmap1 = isl_basic_map_reverse(bmap1);
 	bmap1 = isl_basic_map_apply_range(bmap1, bmap2);
@@ -3692,23 +4815,23 @@
 /* Given two basic maps A -> f(A) and B -> g(B), construct a basic map
  * A \cap B -> f(A) + f(B)
  */
-struct isl_basic_map *isl_basic_map_sum(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+__isl_give isl_basic_map *isl_basic_map_sum(__isl_take isl_basic_map *bmap1,
+	__isl_take isl_basic_map *bmap2)
 {
-	unsigned n_in, n_out, nparam, total, pos;
+	isl_size n_in, n_out, nparam;
+	unsigned total, pos;
 	struct isl_basic_map *bmap = NULL;
 	struct isl_dim_map *dim_map1, *dim_map2;
 	int i;
 
-	if (!bmap1 || !bmap2)
+	if (isl_basic_map_check_equal_space(bmap1, bmap2) < 0)
 		goto error;
 
-	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
-		goto error);
-
-	nparam = isl_basic_map_n_param(bmap1);
-	n_in = isl_basic_map_n_in(bmap1);
-	n_out = isl_basic_map_n_out(bmap1);
+	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap1, isl_dim_in);
+	n_out = isl_basic_map_dim(bmap1, isl_dim_out);
+	if (nparam < 0 || n_in < 0 || n_out < 0)
+		goto error;
 
 	total = nparam + n_in + n_out + bmap1->n_div + bmap2->n_div + 2 * n_out;
 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
@@ -3751,16 +4874,15 @@
 /* Given two maps A -> f(A) and B -> g(B), construct a map
  * A \cap B -> f(A) + f(B)
  */
-struct isl_map *isl_map_sum(struct isl_map *map1, struct isl_map *map2)
+__isl_give isl_map *isl_map_sum(__isl_take isl_map *map1,
+	__isl_take isl_map *map2)
 {
 	struct isl_map *result;
 	int i, j;
 
-	if (!map1 || !map2)
+	if (isl_map_check_equal_space(map1, map2) < 0)
 		goto error;
 
-	isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
-
 	result = isl_map_alloc_space(isl_space_copy(map1->dim),
 				map1->n * map2->n, 0);
 	if (!result)
@@ -3790,21 +4912,22 @@
 __isl_give isl_set *isl_set_sum(__isl_take isl_set *set1,
 	__isl_take isl_set *set2)
 {
-	return (isl_set *)isl_map_sum((isl_map *)set1, (isl_map *)set2);
+	return set_from_map(isl_map_sum(set_to_map(set1), set_to_map(set2)));
 }
 
 /* Given a basic map A -> f(A), construct A -> -f(A).
  */
-struct isl_basic_map *isl_basic_map_neg(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_neg(__isl_take isl_basic_map *bmap)
 {
 	int i, j;
-	unsigned off, n;
+	unsigned off;
+	isl_size n;
 
 	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
 	n = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n < 0)
+		return isl_basic_map_free(bmap);
+
 	off = isl_basic_map_offset(bmap, isl_dim_out);
 	for (i = 0; i < bmap->n_eq; ++i)
 		for (j = 0; j < n; ++j)
@@ -3826,7 +4949,7 @@
 
 /* Given a map A -> f(A), construct A -> -f(A).
  */
-struct isl_map *isl_map_neg(struct isl_map *map)
+__isl_give isl_map *isl_map_neg(__isl_take isl_map *map)
 {
 	int i;
 
@@ -3848,26 +4971,26 @@
 
 __isl_give isl_set *isl_set_neg(__isl_take isl_set *set)
 {
-	return (isl_set *)isl_map_neg((isl_map *)set);
+	return set_from_map(isl_map_neg(set_to_map(set)));
 }
 
 /* Given a basic map A -> f(A) and an integer d, construct a basic map
  * A -> floor(f(A)/d).
  */
-struct isl_basic_map *isl_basic_map_floordiv(struct isl_basic_map *bmap,
+__isl_give isl_basic_map *isl_basic_map_floordiv(__isl_take isl_basic_map *bmap,
 		isl_int d)
 {
-	unsigned n_in, n_out, nparam, total, pos;
+	isl_size n_in, n_out, nparam;
+	unsigned total, pos;
 	struct isl_basic_map *result = NULL;
 	struct isl_dim_map *dim_map;
 	int i;
 
-	if (!bmap)
-		return NULL;
-
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	n_out = isl_basic_map_n_out(bmap);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (nparam < 0 || n_in < 0 || n_out < 0)
+		return isl_basic_map_free(bmap);
 
 	total = nparam + n_in + n_out + bmap->n_div + n_out;
 	dim_map = isl_dim_map_alloc(bmap->ctx, total);
@@ -3908,7 +5031,7 @@
 /* Given a map A -> f(A) and an integer d, construct a map
  * A -> floor(f(A)/d).
  */
-struct isl_map *isl_map_floordiv(struct isl_map *map, isl_int d)
+__isl_give isl_map *isl_map_floordiv(__isl_take isl_map *map, isl_int d)
 {
 	int i;
 
@@ -3917,12 +5040,12 @@
 		return NULL;
 
 	ISL_F_CLR(map, ISL_MAP_DISJOINT);
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_floordiv(map->pi, d);
 		if (!map->pi)
 			goto error;
 	}
+	map = isl_map_unmark_normalized(map);
 
 	return map;
 error:
@@ -3950,18 +5073,23 @@
 	return NULL;
 }
 
-static struct isl_basic_map *var_equal(struct isl_basic_map *bmap, unsigned pos)
+static __isl_give isl_basic_map *var_equal(__isl_take isl_basic_map *bmap,
+	unsigned pos)
 {
 	int i;
-	unsigned nparam;
-	unsigned n_in;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	if (total < 0 || nparam < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	i = isl_basic_map_alloc_equality(bmap);
 	if (i < 0)
 		goto error;
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	isl_seq_clr(bmap->eqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqi, 1 + total);
 	isl_int_set_si(bmap->eqi1+nparam+pos, -1);
 	isl_int_set_si(bmap->eqi1+nparam+n_in+pos, 1);
 	return isl_basic_map_finalize(bmap);
@@ -3970,20 +5098,25 @@
 	return NULL;
 }
 
-/* Add a constraints to "bmap" expressing i_pos < o_pos
+/* Add a constraint to "bmap" expressing i_pos < o_pos
  */
-static struct isl_basic_map *var_less(struct isl_basic_map *bmap, unsigned pos)
+static __isl_give isl_basic_map *var_less(__isl_take isl_basic_map *bmap,
+	unsigned pos)
 {
 	int i;
-	unsigned nparam;
-	unsigned n_in;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	if (total < 0 || nparam < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
 		goto error;
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	isl_seq_clr(bmap->ineqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqi, 1 + total);
 	isl_int_set_si(bmap->ineqi0, -1);
 	isl_int_set_si(bmap->ineqi1+nparam+pos, -1);
 	isl_int_set_si(bmap->ineqi1+nparam+n_in+pos, 1);
@@ -3999,15 +5132,19 @@
 	__isl_take isl_basic_map *bmap, unsigned pos)
 {
 	int i;
-	unsigned nparam;
-	unsigned n_in;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	if (total < 0 || nparam < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
 		goto error;
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	isl_seq_clr(bmap->ineqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqi, 1 + total);
 	isl_int_set_si(bmap->ineqi1+nparam+pos, -1);
 	isl_int_set_si(bmap->ineqi1+nparam+n_in+pos, 1);
 	return isl_basic_map_finalize(bmap);
@@ -4016,20 +5153,25 @@
 	return NULL;
 }
 
-/* Add a constraints to "bmap" expressing i_pos > o_pos
+/* Add a constraint to "bmap" expressing i_pos > o_pos
  */
-static struct isl_basic_map *var_more(struct isl_basic_map *bmap, unsigned pos)
+static __isl_give isl_basic_map *var_more(__isl_take isl_basic_map *bmap,
+	unsigned pos)
 {
 	int i;
-	unsigned nparam;
-	unsigned n_in;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	if (total < 0 || nparam < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
 		goto error;
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	isl_seq_clr(bmap->ineqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqi, 1 + total);
 	isl_int_set_si(bmap->ineqi0, -1);
 	isl_int_set_si(bmap->ineqi1+nparam+pos, 1);
 	isl_int_set_si(bmap->ineqi1+nparam+n_in+pos, -1);
@@ -4045,15 +5187,19 @@
 	__isl_take isl_basic_map *bmap, unsigned pos)
 {
 	int i;
-	unsigned nparam;
-	unsigned n_in;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	if (total < 0 || nparam < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
 		goto error;
-	nparam = isl_basic_map_n_param(bmap);
-	n_in = isl_basic_map_n_in(bmap);
-	isl_seq_clr(bmap->ineqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqi, 1 + total);
 	isl_int_set_si(bmap->ineqi1+nparam+pos, 1);
 	isl_int_set_si(bmap->ineqi1+nparam+n_in+pos, -1);
 	return isl_basic_map_finalize(bmap);
@@ -4063,11 +5209,11 @@
 }
 
 __isl_give isl_basic_map *isl_basic_map_equal(
-	__isl_take isl_space *dim, unsigned n_equal)
+	__isl_take isl_space *space, unsigned n_equal)
 {
 	int i;
 	struct isl_basic_map *bmap;
-	bmap = isl_basic_map_alloc_space(dim, 0, n_equal, 0);
+	bmap = isl_basic_map_alloc_space(space, 0, n_equal, 0);
 	if (!bmap)
 		return NULL;
 	for (i = 0; i < n_equal && bmap; ++i)
@@ -4075,14 +5221,14 @@
 	return isl_basic_map_finalize(bmap);
 }
 
-/* Return a relation on of dimension "dim" expressing i_0..pos << o_0..pos
+/* Return a relation on of dimension "space" expressing i_0..pos << o_0..pos
  */
-__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *dim,
+__isl_give isl_basic_map *isl_basic_map_less_at(__isl_take isl_space *space,
 	unsigned pos)
 {
 	int i;
 	struct isl_basic_map *bmap;
-	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
+	bmap = isl_basic_map_alloc_space(space, 0, pos, 1);
 	if (!bmap)
 		return NULL;
 	for (i = 0; i < pos && bmap; ++i)
@@ -4092,29 +5238,29 @@
 	return isl_basic_map_finalize(bmap);
 }
 
-/* Return a relation on of dimension "dim" expressing i_0..pos <<= o_0..pos
+/* Return a relation on "space" expressing i_0..pos <<= o_0..pos
  */
 __isl_give isl_basic_map *isl_basic_map_less_or_equal_at(
-	__isl_take isl_space *dim, unsigned pos)
+	__isl_take isl_space *space, unsigned pos)
 {
 	int i;
 	isl_basic_map *bmap;
 
-	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
+	bmap = isl_basic_map_alloc_space(space, 0, pos, 1);
 	for (i = 0; i < pos; ++i)
 		bmap = var_equal(bmap, i);
 	bmap = var_less_or_equal(bmap, pos);
 	return isl_basic_map_finalize(bmap);
 }
 
-/* Return a relation on pairs of sets of dimension "dim" expressing i_pos > o_pos
+/* Return a relation on "space" expressing i_pos > o_pos
  */
-__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *dim,
+__isl_give isl_basic_map *isl_basic_map_more_at(__isl_take isl_space *space,
 	unsigned pos)
 {
 	int i;
 	struct isl_basic_map *bmap;
-	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
+	bmap = isl_basic_map_alloc_space(space, 0, pos, 1);
 	if (!bmap)
 		return NULL;
 	for (i = 0; i < pos && bmap; ++i)
@@ -4124,127 +5270,131 @@
 	return isl_basic_map_finalize(bmap);
 }
 
-/* Return a relation on of dimension "dim" expressing i_0..pos >>= o_0..pos
+/* Return a relation on "space" expressing i_0..pos >>= o_0..pos
  */
 __isl_give isl_basic_map *isl_basic_map_more_or_equal_at(
-	__isl_take isl_space *dim, unsigned pos)
+	__isl_take isl_space *space, unsigned pos)
 {
 	int i;
 	isl_basic_map *bmap;
 
-	bmap = isl_basic_map_alloc_space(dim, 0, pos, 1);
+	bmap = isl_basic_map_alloc_space(space, 0, pos, 1);
 	for (i = 0; i < pos; ++i)
 		bmap = var_equal(bmap, i);
 	bmap = var_more_or_equal(bmap, pos);
 	return isl_basic_map_finalize(bmap);
 }
 
-static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *dims,
+static __isl_give isl_map *map_lex_lte_first(__isl_take isl_space *space,
 	unsigned n, int equal)
 {
 	struct isl_map *map;
 	int i;
 
 	if (n == 0 && equal)
-		return isl_map_universe(dims);
+		return isl_map_universe(space);
 
-	map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
+	map = isl_map_alloc_space(isl_space_copy(space), n, ISL_MAP_DISJOINT);
 
 	for (i = 0; i + 1 < n; ++i)
 		map = isl_map_add_basic_map(map,
-				  isl_basic_map_less_at(isl_space_copy(dims), i));
+				  isl_basic_map_less_at(isl_space_copy(space), i));
 	if (n > 0) {
 		if (equal)
 			map = isl_map_add_basic_map(map,
-			      isl_basic_map_less_or_equal_at(dims, n - 1));
+			      isl_basic_map_less_or_equal_at(space, n - 1));
 		else
 			map = isl_map_add_basic_map(map,
-			      isl_basic_map_less_at(dims, n - 1));
+			      isl_basic_map_less_at(space, n - 1));
 	} else
-		isl_space_free(dims);
+		isl_space_free(space);
 
 	return map;
 }
 
-static __isl_give isl_map *map_lex_lte(__isl_take isl_space *dims, int equal)
+static __isl_give isl_map *map_lex_lte(__isl_take isl_space *space, int equal)
 {
-	if (!dims)
+	if (!space)
 		return NULL;
-	return map_lex_lte_first(dims, dims->n_out, equal);
+	return map_lex_lte_first(space, space->n_out, equal);
 }
 
-__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *dim, unsigned n)
+__isl_give isl_map *isl_map_lex_lt_first(__isl_take isl_space *space,
+	unsigned n)
 {
-	return map_lex_lte_first(dim, n, 0);
+	return map_lex_lte_first(space, n, 0);
 }
 
-__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *dim, unsigned n)
+__isl_give isl_map *isl_map_lex_le_first(__isl_take isl_space *space,
+	unsigned n)
 {
-	return map_lex_lte_first(dim, n, 1);
+	return map_lex_lte_first(space, n, 1);
 }
 
-__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_dim)
+__isl_give isl_map *isl_map_lex_lt(__isl_take isl_space *set_space)
 {
-	return map_lex_lte(isl_space_map_from_set(set_dim), 0);
+	return map_lex_lte(isl_space_map_from_set(set_space), 0);
 }
 
-__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_dim)
+__isl_give isl_map *isl_map_lex_le(__isl_take isl_space *set_space)
 {
-	return map_lex_lte(isl_space_map_from_set(set_dim), 1);
+	return map_lex_lte(isl_space_map_from_set(set_space), 1);
 }
 
-static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *dims,
+static __isl_give isl_map *map_lex_gte_first(__isl_take isl_space *space,
 	unsigned n, int equal)
 {
 	struct isl_map *map;
 	int i;
 
 	if (n == 0 && equal)
-		return isl_map_universe(dims);
+		return isl_map_universe(space);
 
-	map = isl_map_alloc_space(isl_space_copy(dims), n, ISL_MAP_DISJOINT);
+	map = isl_map_alloc_space(isl_space_copy(space), n, ISL_MAP_DISJOINT);
 
 	for (i = 0; i + 1 < n; ++i)
 		map = isl_map_add_basic_map(map,
-				  isl_basic_map_more_at(isl_space_copy(dims), i));
+				  isl_basic_map_more_at(isl_space_copy(space), i));
 	if (n > 0) {
 		if (equal)
 			map = isl_map_add_basic_map(map,
-			      isl_basic_map_more_or_equal_at(dims, n - 1));
+			      isl_basic_map_more_or_equal_at(space, n - 1));
 		else
 			map = isl_map_add_basic_map(map,
-			      isl_basic_map_more_at(dims, n - 1));
+			      isl_basic_map_more_at(space, n - 1));
 	} else
-		isl_space_free(dims);
+		isl_space_free(space);
 
 	return map;
 }
 
-static __isl_give isl_map *map_lex_gte(__isl_take isl_space *dims, int equal)
+static __isl_give isl_map *map_lex_gte(__isl_take isl_space *space, int equal)
 {
-	if (!dims)
+	if (!space)
 		return NULL;
-	return map_lex_gte_first(dims, dims->n_out, equal);
+	return map_lex_gte_first(space, space->n_out, equal);
 }
 
-__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *dim, unsigned n)
+__isl_give isl_map *isl_map_lex_gt_first(__isl_take isl_space *space,
+	unsigned n)
 {
-	return map_lex_gte_first(dim, n, 0);
+	return map_lex_gte_first(space, n, 0);
 }
 
-__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *dim, unsigned n)
+__isl_give isl_map *isl_map_lex_ge_first(__isl_take isl_space *space,
+	unsigned n)
 {
-	return map_lex_gte_first(dim, n, 1);
+	return map_lex_gte_first(space, n, 1);
 }
 
-__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_dim)
+__isl_give isl_map *isl_map_lex_gt(__isl_take isl_space *set_space)
 {
-	return map_lex_gte(isl_space_map_from_set(set_dim), 0);
+	return map_lex_gte(isl_space_map_from_set(set_space), 0);
 }
 
-__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_dim)
+__isl_give isl_map *isl_map_lex_ge(__isl_take isl_space *set_space)
 {
-	return map_lex_gte(isl_space_map_from_set(set_dim), 1);
+	return map_lex_gte(isl_space_map_from_set(set_space), 1);
 }
 
 __isl_give isl_map *isl_set_lex_le_set(__isl_take isl_set *set1,
@@ -4327,147 +5477,95 @@
 	return map;
 }
 
-__isl_give isl_basic_map *isl_basic_map_from_basic_set(
-	__isl_take isl_basic_set *bset, __isl_take isl_space *dim)
-{
-	struct isl_basic_map *bmap;
-
-	bset = isl_basic_set_cow(bset);
-	if (!bset || !dim)
-		goto error;
-
-	isl_assert(bset->ctx, isl_space_compatible(bset->dim, dim), goto error);
-	isl_space_free(bset->dim);
-	bmap = (struct isl_basic_map *) bset;
-	bmap->dim = dim;
-	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_set_free(bset);
-	isl_space_free(dim);
-	return NULL;
-}
-
-struct isl_basic_set *isl_basic_set_from_basic_map(struct isl_basic_map *bmap)
-{
-	if (!bmap)
-		goto error;
-	if (bmap->dim->n_in == 0)
-		return (struct isl_basic_set *)bmap;
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		goto error;
-	bmap->dim = isl_space_as_set_space(bmap->dim);
-	if (!bmap->dim)
-		goto error;
-	bmap = isl_basic_map_finalize(bmap);
-	return (struct isl_basic_set *)bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-/* For a div d = floor(f/m), add the constraint
+/* For the div d = floor(f/m) at position "div", add the constraint
  *
  *		f - m d >= 0
  */
-static int add_upper_div_constraint(__isl_keep isl_basic_map *bmap,
-	unsigned pos, isl_int *div)
+static __isl_give isl_basic_map *add_upper_div_constraint(
+	__isl_take isl_basic_map *bmap, unsigned div)
 {
 	int i;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	isl_size n_div;
+	unsigned pos;
 
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (v_div < 0 || n_div < 0)
+		return isl_basic_map_free(bmap);
+	pos = v_div + div;
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
-		return -1;
-	isl_seq_cpy(bmap->ineqi, div + 1, 1 + total);
-	isl_int_neg(bmap->ineqi1 + pos, div0);
+		return isl_basic_map_free(bmap);
+	isl_seq_cpy(bmap->ineqi, bmap->divdiv + 1, 1 + v_div + n_div);
+	isl_int_neg(bmap->ineqi1 + pos, bmap->divdiv0);
 
-	return 0;
+	return bmap;
 }
 
-/* For a div d = floor(f/m), add the constraint
+/* For the div d = floor(f/m) at position "div", add the constraint
  *
- *		-(f-(n-1)) + m d >= 0
+ *		-(f-(m-1)) + m d >= 0
  */
-static int add_lower_div_constraint(__isl_keep isl_basic_map *bmap,
-	unsigned pos, isl_int *div)
+static __isl_give isl_basic_map *add_lower_div_constraint(
+	__isl_take isl_basic_map *bmap, unsigned div)
 {
 	int i;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	isl_size n_div;
+	unsigned pos;
 
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (v_div < 0 || n_div < 0)
+		return isl_basic_map_free(bmap);
+	pos = v_div + div;
 	i = isl_basic_map_alloc_inequality(bmap);
 	if (i < 0)
-		return -1;
-	isl_seq_neg(bmap->ineqi, div + 1, 1 + total);
-	isl_int_set(bmap->ineqi1 + pos, div0);
+		return isl_basic_map_free(bmap);
+	isl_seq_neg(bmap->ineqi, bmap->divdiv + 1, 1 + v_div + n_div);
+	isl_int_set(bmap->ineqi1 + pos, bmap->divdiv0);
 	isl_int_add(bmap->ineqi0, bmap->ineqi0, bmap->ineqi1 + pos);
 	isl_int_sub_ui(bmap->ineqi0, bmap->ineqi0, 1);
 
-	return 0;
+	return bmap;
 }
 
-/* For a div d = floor(f/m), add the constraints
+/* For the div d = floor(f/m) at position "pos", add the constraints
  *
  *		f - m d >= 0
- *		-(f-(n-1)) + m d >= 0
+ *		-(f-(m-1)) + m d >= 0
  *
  * Note that the second constraint is the negation of
  *
- *		f - m d >= n
+ *		f - m d >= m
  */
-int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
-	unsigned pos, isl_int *div)
-{
-	if (add_upper_div_constraint(bmap, pos, div) < 0)
-		return -1;
-	if (add_lower_div_constraint(bmap, pos, div) < 0)
-		return -1;
-	return 0;
-}
-
-int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
-	unsigned pos, isl_int *div)
-{
-	return isl_basic_map_add_div_constraints_var((isl_basic_map *)bset,
-							pos, div);
-}
-
-int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div)
+__isl_give isl_basic_map *isl_basic_map_add_div_constraints(
+	__isl_take isl_basic_map *bmap, unsigned pos)
 {
-	unsigned total = isl_basic_map_total_dim(bmap);
-	unsigned div_pos = total - bmap->n_div + div;
-
-	return isl_basic_map_add_div_constraints_var(bmap, div_pos,
-							bmap->divdiv);
+	bmap = add_upper_div_constraint(bmap, pos);
+	bmap = add_lower_div_constraint(bmap, pos);
+	return bmap;
 }
 
 /* For each known div d = floor(f/m), add the constraints
  *
  *		f - m d >= 0
- *		-(f-(n-1)) + m d >= 0
+ *		-(f-(m-1)) + m d >= 0
+ *
+ * Remove duplicate constraints in case of some these div constraints
+ * already appear in "bmap".
  */
 __isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
 	__isl_take isl_basic_map *bmap)
 {
-	int i;
-	unsigned n_div;
+	isl_size n_div;
 
-	if (!bmap)
-		return NULL;
 	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_basic_map_free(bmap);
 	if (n_div == 0)
 		return bmap;
-	bmap = isl_basic_map_cow(bmap);
-	bmap = isl_basic_map_extend_constraints(bmap, 0, 2 * n_div);
-	if (!bmap)
-		return NULL;
-	for (i = 0; i < n_div; ++i) {
-		if (isl_int_is_zero(bmap->divi0))
-			continue;
-		if (isl_basic_map_add_div_constraints(bmap, i) < 0)
-			return isl_basic_map_free(bmap);
-	}
 
+	bmap = add_known_div_constraints(bmap);
 	bmap = isl_basic_map_remove_duplicate_constraints(bmap, NULL, 0);
 	bmap = isl_basic_map_finalize(bmap);
 	return bmap;
@@ -4482,53 +5580,43 @@
  *
  * if sign < 0 or the constraint
  *
- *		-(f-(n-1)) + m d >= 0
+ *		-(f-(m-1)) + m d >= 0
  *
  * if sign > 0.
  */
-int isl_basic_map_add_div_constraint(__isl_keep isl_basic_map *bmap,
-	unsigned div, int sign)
+__isl_give isl_basic_map *isl_basic_map_add_div_constraint(
+	__isl_take isl_basic_map *bmap, unsigned div, int sign)
 {
-	unsigned total;
-	unsigned div_pos;
-
-	if (!bmap)
-		return -1;
-
-	total = isl_basic_map_total_dim(bmap);
-	div_pos = total - bmap->n_div + div;
-
 	if (sign < 0)
-		return add_upper_div_constraint(bmap, div_pos, bmap->divdiv);
+		return add_upper_div_constraint(bmap, div);
 	else
-		return add_lower_div_constraint(bmap, div_pos, bmap->divdiv);
+		return add_lower_div_constraint(bmap, div);
 }
 
-int isl_basic_set_add_div_constraints(struct isl_basic_set *bset, unsigned div)
+__isl_give isl_basic_set *isl_basic_map_underlying_set(
+	__isl_take isl_basic_map *bmap)
 {
-	return isl_basic_map_add_div_constraints(bset, div);
-}
+	isl_space *space;
 
-struct isl_basic_set *isl_basic_map_underlying_set(
-		struct isl_basic_map *bmap)
-{
 	if (!bmap)
 		goto error;
 	if (bmap->dim->nparam == 0 && bmap->dim->n_in == 0 &&
 	    bmap->n_div == 0 &&
 	    !isl_space_is_named_or_nested(bmap->dim, isl_dim_in) &&
 	    !isl_space_is_named_or_nested(bmap->dim, isl_dim_out))
-		return (struct isl_basic_set *)bmap;
+		return bset_from_bmap(bmap);
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap)
-		goto error;
-	bmap->dim = isl_space_underlying(bmap->dim, bmap->n_div);
-	if (!bmap->dim)
-		goto error;
+		return NULL;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_underlying(space, bmap->n_div);
+	bmap = isl_basic_map_restore_space(bmap, space);
+	if (!bmap)
+		return NULL;
 	bmap->extra -= bmap->n_div;
 	bmap->n_div = 0;
 	bmap = isl_basic_map_finalize(bmap);
-	return (struct isl_basic_set *)bmap;
+	return bset_from_bmap(bmap);
 error:
 	isl_basic_map_free(bmap);
 	return NULL;
@@ -4537,59 +5625,70 @@
 __isl_give isl_basic_set *isl_basic_set_underlying_set(
 		__isl_take isl_basic_set *bset)
 {
-	return isl_basic_map_underlying_set((isl_basic_map *)bset);
+	return isl_basic_map_underlying_set(bset_to_bmap(bset));
 }
 
 /* Replace each element in "list" by the result of applying
- * isl_basic_set_underlying_set to the element.
+ * isl_basic_map_underlying_set to the element.
  */
-__isl_give isl_basic_set_list *isl_basic_set_list_underlying_set(
-	__isl_take isl_basic_set_list *list)
+__isl_give isl_basic_set_list *isl_basic_map_list_underlying_set(
+	__isl_take isl_basic_map_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
-	if (!list)
-		return NULL;
+	n = isl_basic_map_list_n_basic_map(list);
+	if (n < 0)
+		goto error;
 
-	n = isl_basic_set_list_n_basic_set(list);
 	for (i = 0; i < n; ++i) {
+		isl_basic_map *bmap;
 		isl_basic_set *bset;
 
-		bset = isl_basic_set_list_get_basic_set(list, i);
-		bset = isl_basic_set_underlying_set(bset);
+		bmap = isl_basic_map_list_get_basic_map(list, i);
+		bset = isl_basic_set_underlying_set(bmap);
 		list = isl_basic_set_list_set_basic_set(list, i, bset);
 	}
 
 	return list;
+error:
+	isl_basic_map_list_free(list);
+	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_overlying_set(
-	struct isl_basic_set *bset, struct isl_basic_map *like)
+__isl_give isl_basic_map *isl_basic_map_overlying_set(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_map *like)
 {
 	struct isl_basic_map *bmap;
 	struct isl_ctx *ctx;
+	isl_size dim, bmap_total;
 	unsigned total;
 	int i;
 
 	if (!bset || !like)
 		goto error;
 	ctx = bset->ctx;
-	isl_assert(ctx, bset->n_div == 0, goto error);
-	isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
-	isl_assert(ctx, bset->dim->n_out == isl_basic_map_total_dim(like),
-			goto error);
-	if (isl_space_is_equal(bset->dim, like->dim) && like->n_div == 0) {
+	if (isl_basic_set_check_no_params(bset) < 0 ||
+	    isl_basic_set_check_no_locals(bset) < 0)
+		goto error;
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	bmap_total = isl_basic_map_dim(like, isl_dim_all);
+	if (dim < 0 || bmap_total < 0)
+		goto error;
+	isl_assert(ctx, dim == bmap_total, goto error);
+	if (like->n_div == 0) {
+		isl_space *space = isl_basic_map_get_space(like);
 		isl_basic_map_free(like);
-		return (struct isl_basic_map *)bset;
+		return isl_basic_map_reset_space(bset, space);
 	}
 	bset = isl_basic_set_cow(bset);
 	if (!bset)
 		goto error;
-	total = bset->dim->n_out + bset->extra;
-	bmap = (struct isl_basic_map *)bset;
-	isl_space_free(bmap->dim);
-	bmap->dim = isl_space_copy(like->dim);
-	if (!bmap->dim)
+	total = dim + bset->extra;
+	bmap = bset_to_bmap(bset);
+	isl_space_free(isl_basic_map_take_space(bmap));
+	bmap = isl_basic_map_restore_space(bmap, isl_basic_map_get_space(like));
+	if (!bmap)
 		goto error;
 	bmap->n_div = like->n_div;
 	bmap->extra += like->n_div;
@@ -4625,48 +5724,14 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_from_underlying_set(
-	struct isl_basic_set *bset, struct isl_basic_set *like)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_overlying_set(bset, (struct isl_basic_map *)like);
-}
-
-struct isl_set *isl_set_from_underlying_set(
-	struct isl_set *set, struct isl_basic_set *like)
+__isl_give isl_basic_set *isl_basic_set_from_underlying_set(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *like)
 {
-	int i;
-
-	if (!set || !like)
-		goto error;
-	isl_assert(set->ctx, set->dim->n_out == isl_basic_set_total_dim(like),
-		    goto error);
-	if (isl_space_is_equal(set->dim, like->dim) && like->n_div == 0) {
-		isl_basic_set_free(like);
-		return set;
-	}
-	set = isl_set_cow(set);
-	if (!set)
-		goto error;
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_from_underlying_set(set->pi,
-						      isl_basic_set_copy(like));
-		if (!set->pi)
-			goto error;
-	}
-	isl_space_free(set->dim);
-	set->dim = isl_space_copy(like->dim);
-	if (!set->dim)
-		goto error;
-	isl_basic_set_free(like);
-	return set;
-error:
-	isl_basic_set_free(like);
-	isl_set_free(set);
-	return NULL;
+	return bset_from_bmap(isl_basic_map_overlying_set(bset,
+							bset_to_bmap(like)));
 }
 
-struct isl_set *isl_map_underlying_set(struct isl_map *map)
+__isl_give isl_set *isl_map_underlying_set(__isl_take isl_map *map)
 {
 	int i;
 
@@ -4681,8 +5746,8 @@
 		isl_assert(map->ctx, map->p0->n_div == map->pi->n_div,
 				goto error);
 	for (i = 0; i < map->n; ++i) {
-		map->pi = (struct isl_basic_map *)
-				isl_basic_map_underlying_set(map->pi);
+		map->pi = bset_to_bmap(
+				isl_basic_map_underlying_set(map->pi));
 		if (!map->pi)
 			goto error;
 	}
@@ -4694,85 +5759,148 @@
 	}
 	if (!map->dim)
 		goto error;
-	return (struct isl_set *)map;
+	return set_from_map(map);
 error:
 	isl_map_free(map);
 	return NULL;
 }
 
-struct isl_set *isl_set_to_underlying_set(struct isl_set *set)
-{
-	return (struct isl_set *)isl_map_underlying_set((struct isl_map *)set);
-}
-
+/* Replace the space of "bmap" by "space".
+ *
+ * If the space of "bmap" is identical to "space" (including the identifiers
+ * of the input and output dimensions), then simply return the original input.
+ */
 __isl_give isl_basic_map *isl_basic_map_reset_space(
-	__isl_take isl_basic_map *bmap, __isl_take isl_space *dim)
+	__isl_take isl_basic_map *bmap, __isl_take isl_space *space)
 {
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap || !dim)
-		goto error;
+	isl_bool equal;
+	isl_space *bmap_space;
 
-	isl_space_free(bmap->dim);
-	bmap->dim = dim;
+	bmap_space = isl_basic_map_peek_space(bmap);
+	equal = isl_space_is_equal(bmap_space, space);
+	if (equal >= 0 && equal)
+		equal = isl_space_has_equal_ids(bmap_space, space);
+	if (equal < 0)
+		goto error;
+	if (equal) {
+		isl_space_free(space);
+		return bmap;
+	}
+	isl_space_free(isl_basic_map_take_space(bmap));
+	bmap = isl_basic_map_restore_space(bmap, space);
 
 	bmap = isl_basic_map_finalize(bmap);
 
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
 __isl_give isl_basic_set *isl_basic_set_reset_space(
-	__isl_take isl_basic_set *bset, __isl_take isl_space *dim)
+	__isl_take isl_basic_set *bset, __isl_take isl_space *space)
+{
+	return bset_from_bmap(isl_basic_map_reset_space(bset_to_bmap(bset),
+							space));
+}
+
+/* Check that the total dimensions of "map" and "space" are the same.
+ */
+static isl_stat check_map_space_equal_total_dim(__isl_keep isl_map *map,
+	__isl_keep isl_space *space)
 {
-	return (isl_basic_set *)isl_basic_map_reset_space((isl_basic_map *)bset,
-							dim);
+	isl_size dim1, dim2;
+
+	dim1 = isl_map_dim(map, isl_dim_all);
+	dim2 = isl_space_dim(space, isl_dim_all);
+	if (dim1 < 0 || dim2 < 0)
+		return isl_stat_error;
+	if (dim1 == dim2)
+		return isl_stat_ok;
+	isl_die(isl_map_get_ctx(map), isl_error_invalid,
+		"total dimensions do not match", return isl_stat_error);
 }
 
 __isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
 	int i;
 
 	map = isl_map_cow(map);
-	if (!map || !dim)
+	if (!map || !space)
 		goto error;
 
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_reset_space(map->pi,
-						    isl_space_copy(dim));
+						    isl_space_copy(space));
 		if (!map->pi)
 			goto error;
 	}
-	isl_space_free(map->dim);
-	map->dim = dim;
+	isl_space_free(isl_map_take_space(map));
+	map = isl_map_restore_space(map, space);
 
 	return map;
 error:
 	isl_map_free(map);
-	isl_space_free(dim);
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Replace the space of "map" by "space", without modifying
+ * the dimension of "map".
+ *
+ * If the space of "map" is identical to "space" (including the identifiers
+ * of the input and output dimensions), then simply return the original input.
+ */
+__isl_give isl_map *isl_map_reset_equal_dim_space(__isl_take isl_map *map,
+	__isl_take isl_space *space)
+{
+	isl_bool equal;
+	isl_space *map_space;
+
+	map_space = isl_map_peek_space(map);
+	equal = isl_space_is_equal(map_space, space);
+	if (equal >= 0 && equal)
+		equal = isl_space_has_equal_ids(map_space, space);
+	if (equal < 0)
+		goto error;
+	if (equal) {
+		isl_space_free(space);
+		return map;
+	}
+	if (check_map_space_equal_total_dim(map, space) < 0)
+		goto error;
+	return isl_map_reset_space(map, space);
+error:
+	isl_map_free(map);
+	isl_space_free(space);
 	return NULL;
 }
 
 __isl_give isl_set *isl_set_reset_space(__isl_take isl_set *set,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
-	return (struct isl_set *) isl_map_reset_space((struct isl_map *)set, dim);
+	return set_from_map(isl_map_reset_space(set_to_map(set), space));
 }
 
 /* Compute the parameter domain of the given basic set.
  */
 __isl_give isl_basic_set *isl_basic_set_params(__isl_take isl_basic_set *bset)
 {
+	isl_bool is_params;
 	isl_space *space;
-	unsigned n;
+	isl_size n;
 
-	if (isl_basic_set_is_params(bset))
+	is_params = isl_basic_set_is_params(bset);
+	if (is_params < 0)
+		return isl_basic_set_free(bset);
+	if (is_params)
 		return bset;
 
 	n = isl_basic_set_dim(bset, isl_dim_set);
+	if (n < 0)
+		return isl_basic_set_free(bset);
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
 	space = isl_basic_set_get_space(bset);
 	space = isl_space_params(space);
@@ -4796,18 +5924,7 @@
  */
 __isl_give isl_set *isl_set_params(__isl_take isl_set *set)
 {
-	isl_space *space;
-	unsigned n;
-
-	if (isl_set_is_params(set))
-		return set;
-
-	n = isl_set_dim(set, isl_dim_set);
-	set = isl_set_project_out(set, isl_dim_set, 0, n);
-	space = isl_set_get_space(set);
-	space = isl_space_params(space);
-	set = isl_set_reset_space(set, space);
-	return set;
+	return isl_map_params(set_to_map(set));
 }
 
 /* Construct a zero-dimensional set with the given parameter domain.
@@ -4826,43 +5943,39 @@
 __isl_give isl_set *isl_map_params(__isl_take isl_map *map)
 {
 	isl_space *space;
-	unsigned n;
+	isl_size n_in, n_out;
 
-	n = isl_map_dim(map, isl_dim_in);
-	map = isl_map_project_out(map, isl_dim_in, 0, n);
-	n = isl_map_dim(map, isl_dim_out);
-	map = isl_map_project_out(map, isl_dim_out, 0, n);
+	n_in = isl_map_dim(map, isl_dim_in);
+	n_out = isl_map_dim(map, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		return isl_map_free(map);
+	map = isl_map_project_out(map, isl_dim_in, 0, n_in);
+	map = isl_map_project_out(map, isl_dim_out, 0, n_out);
 	space = isl_map_get_space(map);
 	space = isl_space_params(space);
 	map = isl_map_reset_space(map, space);
 	return map;
 }
 
-struct isl_basic_set *isl_basic_map_domain(struct isl_basic_map *bmap)
+__isl_give isl_basic_set *isl_basic_map_domain(__isl_take isl_basic_map *bmap)
 {
-	isl_space *dim;
-	struct isl_basic_set *domain;
-	unsigned n_in;
-	unsigned n_out;
-
-	if (!bmap)
-		return NULL;
-	dim = isl_space_domain(isl_basic_map_get_space(bmap));
+	isl_space *space;
+	isl_size n_out;
 
-	n_in = isl_basic_map_n_in(bmap);
-	n_out = isl_basic_map_n_out(bmap);
-	domain = isl_basic_set_from_basic_map(bmap);
-	domain = isl_basic_set_project_out(domain, isl_dim_set, n_in, n_out);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n_out < 0)
+		return isl_basic_map_free(bmap);
+	space = isl_space_domain(isl_basic_map_get_space(bmap));
 
-	domain = isl_basic_set_reset_space(domain, dim);
+	bmap = isl_basic_map_project_out(bmap, isl_dim_out, 0, n_out);
 
-	return domain;
+	return isl_basic_map_reset_space(bmap, space);
 }
 
-int isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	return isl_space_may_be_set(bmap->dim);
 }
 
@@ -4870,96 +5983,86 @@
  * Users should never call this function.  Outside of isl,
  * the type should indicate whether something is a set or a map.
  */
-int isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_is_set(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_set(bmap->dim);
 }
 
-struct isl_basic_set *isl_basic_map_range(struct isl_basic_map *bmap)
+__isl_give isl_basic_set *isl_basic_map_range(__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
-	if (isl_basic_map_is_set(bmap))
+	isl_bool is_set;
+
+	is_set = isl_basic_map_is_set(bmap);
+	if (is_set < 0)
+		goto error;
+	if (is_set)
 		return bmap;
 	return isl_basic_map_domain(isl_basic_map_reverse(bmap));
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
 }
 
 __isl_give isl_basic_map *isl_basic_map_domain_map(
 	__isl_take isl_basic_map *bmap)
 {
-	int i, k;
-	isl_space *dim;
+	int i;
+	isl_space *space;
 	isl_basic_map *domain;
-	int nparam, n_in, n_out;
-	unsigned total;
+	isl_size nparam, n_in, n_out;
 
 	nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	n_in = isl_basic_map_dim(bmap, isl_dim_in);
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (nparam < 0 || n_in < 0 || n_out < 0)
+		return isl_basic_map_free(bmap);
 
-	dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
-	domain = isl_basic_map_universe(dim);
+	space = isl_basic_map_get_space(bmap);
+	space = isl_space_from_range(isl_space_domain(space));
+	domain = isl_basic_map_universe(space);
 
 	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
 	bmap = isl_basic_map_apply_range(bmap, domain);
 	bmap = isl_basic_map_extend_constraints(bmap, n_in, 0);
 
-	total = isl_basic_map_total_dim(bmap);
-
-	for (i = 0; i < n_in; ++i) {
-		k = isl_basic_map_alloc_equality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_clr(bmap->eqk, 1 + total);
-		isl_int_set_si(bmap->eqk1 + nparam + i, -1);
-		isl_int_set_si(bmap->eqk1 + nparam + n_in + n_out + i, 1);
-	}
+	for (i = 0; i < n_in; ++i)
+		bmap = isl_basic_map_equate(bmap, isl_dim_in, i,
+						    isl_dim_out, i);
 
 	bmap = isl_basic_map_gauss(bmap, NULL);
 	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_map *isl_basic_map_range_map(
 	__isl_take isl_basic_map *bmap)
 {
-	int i, k;
-	isl_space *dim;
+	int i;
+	isl_space *space;
 	isl_basic_map *range;
-	int nparam, n_in, n_out;
-	unsigned total;
+	isl_size nparam, n_in, n_out;
 
 	nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	n_in = isl_basic_map_dim(bmap, isl_dim_in);
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (nparam < 0 || n_in < 0 || n_out < 0)
+		return isl_basic_map_free(bmap);
 
-	dim = isl_space_from_range(isl_space_range(isl_basic_map_get_space(bmap)));
-	range = isl_basic_map_universe(dim);
+	space = isl_basic_map_get_space(bmap);
+	space = isl_space_from_range(isl_space_range(space));
+	range = isl_basic_map_universe(space);
 
 	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
 	bmap = isl_basic_map_apply_range(bmap, range);
 	bmap = isl_basic_map_extend_constraints(bmap, n_out, 0);
 
-	total = isl_basic_map_total_dim(bmap);
-
-	for (i = 0; i < n_out; ++i) {
-		k = isl_basic_map_alloc_equality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_clr(bmap->eqk, 1 + total);
-		isl_int_set_si(bmap->eqk1 + nparam + n_in + i, -1);
-		isl_int_set_si(bmap->eqk1 + nparam + n_in + n_out + i, 1);
-	}
+	for (i = 0; i < n_out; ++i)
+		bmap = isl_basic_map_equate(bmap, isl_dim_in, n_in + i,
+						    isl_dim_out, i);
 
 	bmap = isl_basic_map_gauss(bmap, NULL);
 	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 int isl_map_may_be_set(__isl_keep isl_map *map)
@@ -4973,120 +6076,86 @@
  * Users should never call this function.  Outside of isl,
  * the type should indicate whether something is a set or a map.
  */
-int isl_map_is_set(__isl_keep isl_map *map)
+isl_bool isl_map_is_set(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	return isl_space_is_set(map->dim);
 }
 
-struct isl_set *isl_map_range(struct isl_map *map)
+__isl_give isl_set *isl_map_range(__isl_take isl_map *map)
 {
-	int i;
-	struct isl_set *set;
+	isl_space *space;
+	isl_size n_in;
 
-	if (!map)
-		goto error;
-	if (isl_map_is_set(map))
-		return (isl_set *)map;
+	n_in = isl_map_dim(map, isl_dim_in);
+	if (n_in < 0)
+		return set_from_map(isl_map_free(map));
+	space = isl_space_range(isl_map_get_space(map));
 
-	map = isl_map_cow(map);
-	if (!map)
-		goto error;
+	map = isl_map_project_out(map, isl_dim_in, 0, n_in);
 
-	set = (struct isl_set *) map;
-	set->dim = isl_space_range(set->dim);
-	if (!set->dim)
-		goto error;
-	for (i = 0; i < map->n; ++i) {
-		set->pi = isl_basic_map_range(map->pi);
-		if (!set->pi)
-			goto error;
-	}
-	ISL_F_CLR(set, ISL_MAP_DISJOINT);
-	ISL_F_CLR(set, ISL_SET_NORMALIZED);
-	return set;
-error:
-	isl_map_free(map);
-	return NULL;
+	return set_from_map(isl_map_reset_space(map, space));
 }
 
-__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
+/* Transform "map" by applying "fn_space" to its space and "fn_bmap"
+ * to each of its basic maps.
+ */
+static __isl_give isl_map *isl_map_transform(__isl_take isl_map *map,
+	__isl_give isl_space *(*fn_space)(__isl_take isl_space *space),
+	__isl_give isl_basic_map *(*fn_bmap)(__isl_take isl_basic_map *bmap))
 {
 	int i;
+	isl_space *space;
 
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
 
-	map->dim = isl_space_domain_map(map->dim);
-	if (!map->dim)
-		goto error;
 	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_domain_map(map->pi);
+		map->pi = fn_bmap(map->pi);
 		if (!map->pi)
-			goto error;
+			return isl_map_free(map);
 	}
-	ISL_F_CLR(map, ISL_MAP_DISJOINT);
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
+
+	space = isl_map_take_space(map);
+	space = fn_space(space);
+	map = isl_map_restore_space(map, space);
+
 	return map;
-error:
-	isl_map_free(map);
-	return NULL;
 }
 
-__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
+__isl_give isl_map *isl_map_domain_map(__isl_take isl_map *map)
 {
-	int i;
-	isl_space *range_dim;
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
+	return isl_map_transform(map, &isl_space_domain_map,
+					&isl_basic_map_domain_map);
+}
 
-	range_dim = isl_space_range(isl_map_get_space(map));
-	range_dim = isl_space_from_range(range_dim);
-	map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
-	map->dim = isl_space_join(map->dim, range_dim);
-	if (!map->dim)
-		goto error;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_range_map(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	ISL_F_CLR(map, ISL_MAP_DISJOINT);
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+__isl_give isl_map *isl_map_range_map(__isl_take isl_map *map)
+{
+	return isl_map_transform(map, &isl_space_range_map,
+					&isl_basic_map_range_map);
 }
 
-__isl_give isl_map *isl_map_from_set(__isl_take isl_set *set,
-	__isl_take isl_space *dim)
+/* Given a wrapped map of the form AB -> C,
+ * return the map AB -> C -> B.
+ */
+__isl_give isl_map *isl_set_wrapped_domain_map(__isl_take isl_set *set)
 {
-	int i;
-	struct isl_map *map = NULL;
+	isl_id *id;
+	isl_map *map;
+
+	if (!set)
+		return NULL;
+	if (!isl_set_has_tuple_id(set))
+		return isl_map_domain_map(isl_set_unwrap(set));
+
+	id = isl_set_get_tuple_id(set);
+	map = isl_map_domain_map(isl_set_unwrap(set));
+	map = isl_map_set_tuple_id(map, isl_dim_in, id);
 
-	set = isl_set_cow(set);
-	if (!set || !dim)
-		goto error;
-	isl_assert(set->ctx, isl_space_compatible(set->dim, dim), goto error);
-	map = (struct isl_map *)set;
-	for (i = 0; i < set->n; ++i) {
-		map->pi = isl_basic_map_from_basic_set(
-				set->pi, isl_space_copy(dim));
-		if (!map->pi)
-			goto error;
-	}
-	isl_space_free(map->dim);
-	map->dim = dim;
 	return map;
-error:
-	isl_space_free(dim);
-	isl_set_free(set);
-	return NULL;
 }
 
 __isl_give isl_basic_map *isl_basic_map_from_domain(
@@ -5102,7 +6171,7 @@
 	space = isl_basic_set_get_space(bset);
 	space = isl_space_from_range(space);
 	bset = isl_basic_set_reset_space(bset, space);
-	return (isl_basic_map *)bset;
+	return bset_to_bmap(bset);
 }
 
 /* Create a relation with the given set as range.
@@ -5115,7 +6184,7 @@
 	space = isl_set_get_space(set);
 	space = isl_space_from_range(space);
 	set = isl_set_reset_space(set, space);
-	return (struct isl_map *)set;
+	return set_to_map(set);
 }
 
 /* Create a relation with the given set as domain.
@@ -5139,144 +6208,81 @@
 	return isl_map_apply_range(isl_map_reverse(domain), range);
 }
 
-struct isl_set *isl_set_from_map(struct isl_map *map)
-{
-	int i;
-	struct isl_set *set = NULL;
-
-	if (!map)
-		return NULL;
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-	map->dim = isl_space_as_set_space(map->dim);
-	if (!map->dim)
-		goto error;
-	set = (struct isl_set *)map;
-	for (i = 0; i < map->n; ++i) {
-		set->pi = isl_basic_set_from_basic_map(map->pi);
-		if (!set->pi)
-			goto error;
-	}
-	return set;
-error:
-	isl_map_free(map);
-	return NULL;
-}
-
-__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *dim, int n,
+/* Return a newly allocated isl_map with given space and flags and
+ * room for "n" basic maps.
+ * Make sure that all cached information is cleared.
+ */
+__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *space, int n,
 	unsigned flags)
 {
 	struct isl_map *map;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (n < 0)
-		isl_die(dim->ctx, isl_error_internal,
+		isl_die(space->ctx, isl_error_internal,
 			"negative number of basic maps", goto error);
-	map = isl_alloc(dim->ctx, struct isl_map,
+	map = isl_calloc(space->ctx, struct isl_map,
 			sizeof(struct isl_map) +
 			(n - 1) * sizeof(struct isl_basic_map *));
 	if (!map)
 		goto error;
 
-	map->ctx = dim->ctx;
+	map->ctx = space->ctx;
 	isl_ctx_ref(map->ctx);
 	map->ref = 1;
 	map->size = n;
 	map->n = 0;
-	map->dim = dim;
+	map->dim = space;
 	map->flags = flags;
 	return map;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-struct isl_map *isl_map_alloc(struct isl_ctx *ctx,
-		unsigned nparam, unsigned in, unsigned out, int n,
-		unsigned flags)
-{
-	struct isl_map *map;
-	isl_space *dims;
-
-	dims = isl_space_alloc(ctx, nparam, in, out);
-	if (!dims)
-		return NULL;
-
-	map = isl_map_alloc_space(dims, n, flags);
-	return map;
-}
-
-__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *dim)
+__isl_give isl_basic_map *isl_basic_map_empty(__isl_take isl_space *space)
 {
 	struct isl_basic_map *bmap;
-	bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
+	bmap = isl_basic_map_alloc_space(space, 0, 1, 0);
 	bmap = isl_basic_map_set_to_empty(bmap);
 	return bmap;
 }
 
-__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *dim)
+__isl_give isl_basic_set *isl_basic_set_empty(__isl_take isl_space *space)
 {
 	struct isl_basic_set *bset;
-	bset = isl_basic_set_alloc_space(dim, 0, 1, 0);
+	bset = isl_basic_set_alloc_space(space, 0, 1, 0);
 	bset = isl_basic_set_set_to_empty(bset);
 	return bset;
 }
 
-struct isl_basic_map *isl_basic_map_empty_like(struct isl_basic_map *model)
+__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *space)
 {
 	struct isl_basic_map *bmap;
-	if (!model)
-		return NULL;
-	bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
-	bmap = isl_basic_map_set_to_empty(bmap);
-	return bmap;
-}
-
-struct isl_basic_map *isl_basic_map_empty_like_map(struct isl_map *model)
-{
-	struct isl_basic_map *bmap;
-	if (!model)
-		return NULL;
-	bmap = isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
-	bmap = isl_basic_map_set_to_empty(bmap);
-	return bmap;
-}
-
-struct isl_basic_set *isl_basic_set_empty_like(struct isl_basic_set *model)
-{
-	struct isl_basic_set *bset;
-	if (!model)
-		return NULL;
-	bset = isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 1, 0);
-	bset = isl_basic_set_set_to_empty(bset);
-	return bset;
-}
-
-__isl_give isl_basic_map *isl_basic_map_universe(__isl_take isl_space *dim)
-{
-	struct isl_basic_map *bmap;
-	bmap = isl_basic_map_alloc_space(dim, 0, 0, 0);
+	bmap = isl_basic_map_alloc_space(space, 0, 0, 0);
 	bmap = isl_basic_map_finalize(bmap);
 	return bmap;
 }
 
-__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *dim)
+__isl_give isl_basic_set *isl_basic_set_universe(__isl_take isl_space *space)
 {
 	struct isl_basic_set *bset;
-	bset = isl_basic_set_alloc_space(dim, 0, 0, 0);
+	bset = isl_basic_set_alloc_space(space, 0, 0, 0);
 	bset = isl_basic_set_finalize(bset);
 	return bset;
 }
 
-__isl_give isl_basic_map *isl_basic_map_nat_universe(__isl_take isl_space *dim)
+__isl_give isl_basic_map *isl_basic_map_nat_universe(
+	__isl_take isl_space *space)
 {
 	int i;
-	unsigned total = isl_space_dim(dim, isl_dim_all);
+	isl_size total = isl_space_dim(space, isl_dim_all);
 	isl_basic_map *bmap;
 
-	bmap= isl_basic_map_alloc_space(dim, 0, 0, total);
+	if (total < 0)
+		space = isl_space_free(space);
+	bmap = isl_basic_map_alloc_space(space, 0, 0, total);
 	for (i = 0; i < total; ++i) {
 		int k = isl_basic_map_alloc_inequality(bmap);
 		if (k < 0)
@@ -5290,103 +6296,69 @@
 	return NULL;
 }
 
-__isl_give isl_basic_set *isl_basic_set_nat_universe(__isl_take isl_space *dim)
-{
-	return isl_basic_map_nat_universe(dim);
-}
-
-__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *dim)
-{
-	return isl_map_from_basic_map(isl_basic_map_nat_universe(dim));
-}
-
-__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *dim)
+__isl_give isl_basic_set *isl_basic_set_nat_universe(
+	__isl_take isl_space *space)
 {
-	return isl_map_nat_universe(dim);
+	return isl_basic_map_nat_universe(space);
 }
 
-__isl_give isl_basic_map *isl_basic_map_universe_like(
-		__isl_keep isl_basic_map *model)
+__isl_give isl_map *isl_map_nat_universe(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_basic_map_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
+	return isl_map_from_basic_map(isl_basic_map_nat_universe(space));
 }
 
-struct isl_basic_set *isl_basic_set_universe_like(struct isl_basic_set *model)
+__isl_give isl_set *isl_set_nat_universe(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
+	return isl_map_nat_universe(space);
 }
 
-__isl_give isl_basic_set *isl_basic_set_universe_like_set(
-	__isl_keep isl_set *model)
+__isl_give isl_map *isl_map_empty(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_basic_set_alloc_space(isl_space_copy(model->dim), 0, 0, 0);
+	return isl_map_alloc_space(space, 0, ISL_MAP_DISJOINT);
 }
 
-__isl_give isl_map *isl_map_empty(__isl_take isl_space *dim)
+__isl_give isl_set *isl_set_empty(__isl_take isl_space *space)
 {
-	return isl_map_alloc_space(dim, 0, ISL_MAP_DISJOINT);
+	return isl_set_alloc_space(space, 0, ISL_MAP_DISJOINT);
 }
 
-struct isl_map *isl_map_empty_like(struct isl_map *model)
+__isl_give isl_map *isl_map_universe(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT);
-}
-
-struct isl_map *isl_map_empty_like_basic_map(struct isl_basic_map *model)
-{
-	if (!model)
+	struct isl_map *map;
+	if (!space)
 		return NULL;
-	return isl_map_alloc_space(isl_space_copy(model->dim), 0, ISL_MAP_DISJOINT);
-}
-
-__isl_give isl_set *isl_set_empty(__isl_take isl_space *dim)
-{
-	return isl_set_alloc_space(dim, 0, ISL_MAP_DISJOINT);
+	map = isl_map_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT);
+	map = isl_map_add_basic_map(map, isl_basic_map_universe(space));
+	return map;
 }
 
-struct isl_set *isl_set_empty_like(struct isl_set *model)
+/* This function performs the same operation as isl_map_universe,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_map *isl_space_universe_map(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_set_empty(isl_space_copy(model->dim));
+	return isl_map_universe(space);
 }
 
-__isl_give isl_map *isl_map_universe(__isl_take isl_space *dim)
-{
-	struct isl_map *map;
-	if (!dim)
-		return NULL;
-	map = isl_map_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT);
-	map = isl_map_add_basic_map(map, isl_basic_map_universe(dim));
-	return map;
-}
-
-__isl_give isl_set *isl_set_universe(__isl_take isl_space *dim)
+__isl_give isl_set *isl_set_universe(__isl_take isl_space *space)
 {
 	struct isl_set *set;
-	if (!dim)
+	if (!space)
 		return NULL;
-	set = isl_set_alloc_space(isl_space_copy(dim), 1, ISL_MAP_DISJOINT);
-	set = isl_set_add_basic_set(set, isl_basic_set_universe(dim));
+	set = isl_set_alloc_space(isl_space_copy(space), 1, ISL_MAP_DISJOINT);
+	set = isl_set_add_basic_set(set, isl_basic_set_universe(space));
 	return set;
 }
 
-__isl_give isl_set *isl_set_universe_like(__isl_keep isl_set *model)
+/* This function performs the same operation as isl_set_universe,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give isl_set *isl_space_universe_set(__isl_take isl_space *space)
 {
-	if (!model)
-		return NULL;
-	return isl_set_universe(isl_space_copy(model->dim));
+	return isl_set_universe(space);
 }
 
-struct isl_map *isl_map_dup(struct isl_map *map)
+__isl_give isl_map *isl_map_dup(__isl_keep isl_map *map)
 {
 	int i;
 	struct isl_map *dup;
@@ -5408,11 +6380,12 @@
 		isl_basic_map_free(bmap);
 		return map;
 	}
-	isl_assert(map->ctx, isl_space_is_equal(map->dim, bmap->dim), goto error);
+	if (isl_map_basic_map_check_equal_space(map, bmap) < 0)
+		goto error;
 	isl_assert(map->ctx, map->n < map->size, goto error);
 	map->pmap->n = bmap;
 	map->n++;
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
 error:
 	if (map)
@@ -5432,6 +6405,7 @@
 	if (--map->ref > 0)
 		return NULL;
 
+	clear_caches(map);
 	isl_ctx_deref(map->ctx);
 	for (i = 0; i < map->n; ++i)
 		isl_basic_map_free(map->pi);
@@ -5441,48 +6415,22 @@
 	return NULL;
 }
 
-struct isl_map *isl_map_extend(struct isl_map *base,
-		unsigned nparam, unsigned n_in, unsigned n_out)
-{
-	int i;
-
-	base = isl_map_cow(base);
-	if (!base)
-		return NULL;
-
-	base->dim = isl_space_extend(base->dim, nparam, n_in, n_out);
-	if (!base->dim)
-		goto error;
-	for (i = 0; i < base->n; ++i) {
-		base->pi = isl_basic_map_extend_space(base->pi,
-				isl_space_copy(base->dim), 0, 0, 0);
-		if (!base->pi)
-			goto error;
-	}
-	return base;
-error:
-	isl_map_free(base);
-	return NULL;
-}
-
-struct isl_set *isl_set_extend(struct isl_set *base,
-		unsigned nparam, unsigned dim)
-{
-	return (struct isl_set *)isl_map_extend((struct isl_map *)base,
-							nparam, 0, dim);
-}
-
-static struct isl_basic_map *isl_basic_map_fix_pos_si(
-	struct isl_basic_map *bmap, unsigned pos, int value)
+static __isl_give isl_basic_map *isl_basic_map_fix_pos_si(
+	__isl_take isl_basic_map *bmap, unsigned pos, int value)
 {
 	int j;
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
 	j = isl_basic_map_alloc_equality(bmap);
 	if (j < 0)
 		goto error;
-	isl_seq_clr(bmap->eqj + 1, isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqj + 1, total);
 	isl_int_set_si(bmap->eqjpos, -1);
 	isl_int_set_si(bmap->eqj0, value);
 	bmap = isl_basic_map_simplify(bmap);
@@ -5496,13 +6444,18 @@
 	__isl_take isl_basic_map *bmap, unsigned pos, isl_int value)
 {
 	int j;
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
 	j = isl_basic_map_alloc_equality(bmap);
 	if (j < 0)
 		goto error;
-	isl_seq_clr(bmap->eqj + 1, isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqj + 1, total);
 	isl_int_set_si(bmap->eqjpos, -1);
 	isl_int_set(bmap->eqj0, value);
 	bmap = isl_basic_map_simplify(bmap);
@@ -5512,30 +6465,22 @@
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_fix_si(struct isl_basic_map *bmap,
+__isl_give isl_basic_map *isl_basic_map_fix_si(__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned pos, int value)
 {
-	if (!bmap)
-		return NULL;
-	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_basic_map_free(bmap);
 	return isl_basic_map_fix_pos_si(bmap,
 		isl_basic_map_offset(bmap, type) + pos, value);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
 		enum isl_dim_type type, unsigned pos, isl_int value)
 {
-	if (!bmap)
-		return NULL;
-	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_basic_map_free(bmap);
 	return isl_basic_map_fix_pos(bmap,
 		isl_basic_map_offset(bmap, type) + pos, value);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 /* Fix the value of the variable at position "pos" of type "type" of "bmap"
@@ -5549,9 +6494,8 @@
 	if (!isl_val_is_int(v))
 		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
 			"expecting integer value", goto error);
-	if (pos >= isl_basic_map_dim(bmap, type))
-		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		goto error;
 	pos += isl_basic_map_offset(bmap, type);
 	bmap = isl_basic_map_fix_pos(bmap, pos, v->n);
 	isl_val_free(v);
@@ -5571,53 +6515,45 @@
 	return isl_basic_map_fix_val(bset, type, pos, v);
 }
 
-struct isl_basic_set *isl_basic_set_fix_si(struct isl_basic_set *bset,
+__isl_give isl_basic_set *isl_basic_set_fix_si(__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned pos, int value)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_fix_si((struct isl_basic_map *)bset,
-					type, pos, value);
+	return bset_from_bmap(isl_basic_map_fix_si(bset_to_bmap(bset),
+						    type, pos, value));
 }
 
 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
 		enum isl_dim_type type, unsigned pos, isl_int value)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_fix((struct isl_basic_map *)bset,
-					type, pos, value);
+	return bset_from_bmap(isl_basic_map_fix(bset_to_bmap(bset),
+						    type, pos, value));
 }
 
-struct isl_basic_map *isl_basic_map_fix_input_si(struct isl_basic_map *bmap,
-		unsigned input, int value)
-{
-	return isl_basic_map_fix_si(bmap, isl_dim_in, input, value);
-}
-
-struct isl_basic_set *isl_basic_set_fix_dim_si(struct isl_basic_set *bset,
-		unsigned dim, int value)
+/* Remove the basic map at position "i" from "map" if this basic map
+ * is (obviously) empty.
+ */
+static __isl_give isl_map *remove_if_empty(__isl_take isl_map *map, int i)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_fix_si((struct isl_basic_map *)bset,
-					isl_dim_set, dim, value);
-}
+	isl_bool empty;
 
-static int remove_if_empty(__isl_keep isl_map *map, int i)
-{
-	int empty = isl_basic_map_plain_is_empty(map->pi);
+	if (!map)
+		return NULL;
 
+	empty = isl_basic_map_plain_is_empty(map->pi);
 	if (empty < 0)
-		return -1;
+		return isl_map_free(map);
 	if (!empty)
-		return 0;
+		return map;
 
 	isl_basic_map_free(map->pi);
-	if (i != map->n - 1) {
-		ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-		map->pi = map->pmap->n - 1;
-	}
 	map->n--;
+	if (i != map->n) {
+		map->pi = map->pmap->n;
+		map = isl_map_unmark_normalized(map);
 
-	return 0;
+	}
+
+	return map;
 }
 
 /* Perform "fn" on each basic map of "map", where we may not be holding
@@ -5643,8 +6579,9 @@
 			goto error;
 		isl_basic_map_free(map->pi);
 		map->pi = bmap;
-		if (remove_if_empty(map, i) < 0)
-			goto error;
+		map = remove_if_empty(map, i);
+		if (!map)
+			return NULL;
 	}
 
 	return map;
@@ -5653,33 +6590,28 @@
 	return NULL;
 }
 
-struct isl_map *isl_map_fix_si(struct isl_map *map,
+__isl_give isl_map *isl_map_fix_si(__isl_take isl_map *map,
 		enum isl_dim_type type, unsigned pos, int value)
 {
 	int i;
 
 	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		return isl_map_free(map);
 	for (i = map->n - 1; i >= 0; --i) {
 		map->pi = isl_basic_map_fix_si(map->pi, type, pos, value);
-		if (remove_if_empty(map, i) < 0)
-			goto error;
+		map = remove_if_empty(map, i);
+		if (!map)
+			return NULL;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
-error:
-	isl_map_free(map);
-	return NULL;
 }
 
 __isl_give isl_set *isl_set_fix_si(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value)
 {
-	return (struct isl_set *)
-		isl_map_fix_si((struct isl_map *)set, type, pos, value);
+	return set_from_map(isl_map_fix_si(set_to_map(set), type, pos, value));
 }
 
 __isl_give isl_map *isl_map_fix(__isl_take isl_map *map,
@@ -5688,16 +6620,14 @@
 	int i;
 
 	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		return isl_map_free(map);
 	for (i = 0; i < map->n; ++i) {
 		map->pi = isl_basic_map_fix(map->pi, type, pos, value);
 		if (!map->pi)
 			goto error;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
 error:
 	isl_map_free(map);
@@ -5707,7 +6637,7 @@
 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, isl_int value)
 {
-	return (struct isl_set *)isl_map_fix((isl_map *)set, type, pos, value);
+	return set_from_map(isl_map_fix(set_to_map(set), type, pos, value));
 }
 
 /* Fix the value of the variable at position "pos" of type "type" of "map"
@@ -5725,16 +6655,16 @@
 	if (!isl_val_is_int(v))
 		isl_die(isl_map_get_ctx(map), isl_error_invalid,
 			"expecting integer value", goto error);
-	if (pos >= isl_map_dim(map, type))
-		isl_die(isl_map_get_ctx(map), isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		goto error;
 	for (i = map->n - 1; i >= 0; --i) {
 		map->pi = isl_basic_map_fix_val(map->pi, type, pos,
 							isl_val_copy(v));
-		if (remove_if_empty(map, i) < 0)
+		map = remove_if_empty(map, i);
+		if (!map)
 			goto error;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	isl_val_free(v);
 	return map;
 error:
@@ -5752,16 +6682,17 @@
 	return isl_map_fix_val(set, type, pos, v);
 }
 
-struct isl_map *isl_map_fix_input_si(struct isl_map *map,
+__isl_give isl_map *isl_map_fix_input_si(__isl_take isl_map *map,
 		unsigned input, int value)
 {
 	return isl_map_fix_si(map, isl_dim_in, input, value);
 }
 
-struct isl_set *isl_set_fix_dim_si(struct isl_set *set, unsigned dim, int value)
+__isl_give isl_set *isl_set_fix_dim_si(__isl_take isl_set *set, unsigned dim,
+	int value)
 {
-	return (struct isl_set *)
-		isl_map_fix_si((struct isl_map *)set, isl_dim_set, dim, value);
+	return set_from_map(isl_map_fix_si(set_to_map(set),
+						isl_dim_set, dim, value));
 }
 
 static __isl_give isl_basic_map *basic_map_bound_si(
@@ -5769,17 +6700,20 @@
 	enum isl_dim_type type, unsigned pos, int value, int upper)
 {
 	int j;
+	isl_size total;
 
-	if (!bmap)
-		return NULL;
-	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), goto error);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_basic_map_free(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	pos += isl_basic_map_offset(bmap, type);
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
 	j = isl_basic_map_alloc_inequality(bmap);
 	if (j < 0)
 		goto error;
-	isl_seq_clr(bmap->ineqj, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqj, 1 + total);
 	if (upper) {
 		isl_int_set_si(bmap->ineqjpos, -1);
 		isl_int_set_si(bmap->ineqj0, value);
@@ -5810,43 +6744,21 @@
 	return basic_map_bound_si(bmap, type, pos, value, 1);
 }
 
-struct isl_basic_set *isl_basic_set_lower_bound_dim(struct isl_basic_set *bset,
-	unsigned dim, isl_int value)
-{
-	int j;
-
-	bset = isl_basic_set_cow(bset);
-	bset = isl_basic_set_extend_constraints(bset, 0, 1);
-	j = isl_basic_set_alloc_inequality(bset);
-	if (j < 0)
-		goto error;
-	isl_seq_clr(bset->ineqj, 1 + isl_basic_set_total_dim(bset));
-	isl_int_set_si(bset->ineqj1 + isl_basic_set_n_param(bset) + dim, 1);
-	isl_int_neg(bset->ineqj0, value);
-	bset = isl_basic_set_simplify(bset);
-	return isl_basic_set_finalize(bset);
-error:
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
 static __isl_give isl_map *map_bound_si(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, int value, int upper)
 {
 	int i;
 
 	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	isl_assert(map->ctx, pos < isl_map_dim(map, type), goto error);
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		return isl_map_free(map);
 	for (i = 0; i < map->n; ++i) {
 		map->pi = basic_map_bound_si(map->pi,
 						 type, pos, value, upper);
 		if (!map->pi)
 			goto error;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
 error:
 	isl_map_free(map);
@@ -5868,8 +6780,8 @@
 __isl_give isl_set *isl_set_lower_bound_si(__isl_take isl_set *set,
 		enum isl_dim_type type, unsigned pos, int value)
 {
-	return (struct isl_set *)
-		isl_map_lower_bound_si((struct isl_map *)set, type, pos, value);
+	return set_from_map(isl_map_lower_bound_si(set_to_map(set),
+							type, pos, value));
 }
 
 __isl_give isl_set *isl_set_upper_bound_si(__isl_take isl_set *set,
@@ -5886,19 +6798,20 @@
 	enum isl_dim_type type, unsigned pos, isl_int value, int upper)
 {
 	int j;
+	isl_size total;
 
-	if (!bmap)
-		return NULL;
-	if (pos >= isl_basic_map_dim(bmap, type))
-		isl_die(bmap->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_basic_map_free(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	pos += isl_basic_map_offset(bmap, type);
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
 	j = isl_basic_map_alloc_inequality(bmap);
 	if (j < 0)
 		goto error;
-	isl_seq_clr(bmap->ineqj, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqj, 1 + total);
 	if (upper) {
 		isl_int_set_si(bmap->ineqjpos, -1);
 		isl_int_set(bmap->ineqj0, value);
@@ -5922,22 +6835,16 @@
 	int i;
 
 	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	if (pos >= isl_map_dim(map, type))
-		isl_die(map->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		return isl_map_free(map);
 	for (i = map->n - 1; i >= 0; --i) {
 		map->pi = basic_map_bound(map->pi, type, pos, value, upper);
-		if (remove_if_empty(map, i) < 0)
-			goto error;
+		map = remove_if_empty(map, i);
+		if (!map)
+			return NULL;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
-error:
-	isl_map_free(map);
-	return NULL;
 }
 
 __isl_give isl_map *isl_map_lower_bound(__isl_take isl_map *map,
@@ -5964,177 +6871,303 @@
 	return isl_map_upper_bound(set, type, pos, value);
 }
 
-/* Force the values of the variable at position "pos" of type "type" of "set"
+/* Force the values of the variable at position "pos" of type "type" of "map"
  * to be no smaller than "value".
  */
-__isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
+__isl_give isl_map *isl_map_lower_bound_val(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
 {
 	if (!value)
 		goto error;
 	if (!isl_val_is_int(value))
-		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
 			"expecting integer value", goto error);
-	set = isl_set_lower_bound(set, type, pos, value->n);
+	map = isl_map_lower_bound(map, type, pos, value->n);
 	isl_val_free(value);
-	return set;
+	return map;
 error:
 	isl_val_free(value);
-	isl_set_free(set);
+	isl_map_free(map);
 	return NULL;
 }
 
 /* Force the values of the variable at position "pos" of type "type" of "set"
+ * to be no smaller than "value".
+ */
+__isl_give isl_set *isl_set_lower_bound_val(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
+{
+	isl_map *map;
+
+	map = set_to_map(set);
+	return set_from_map(isl_map_lower_bound_val(map, type, pos, value));
+}
+
+/* Force the values of the variable at position "pos" of type "type" of "map"
  * to be no greater than "value".
  */
-__isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
+__isl_give isl_map *isl_map_upper_bound_val(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
 {
 	if (!value)
 		goto error;
 	if (!isl_val_is_int(value))
-		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
 			"expecting integer value", goto error);
-	set = isl_set_upper_bound(set, type, pos, value->n);
+	map = isl_map_upper_bound(map, type, pos, value->n);
 	isl_val_free(value);
-	return set;
+	return map;
 error:
 	isl_val_free(value);
-	isl_set_free(set);
+	isl_map_free(map);
 	return NULL;
 }
 
-struct isl_set *isl_set_lower_bound_dim(struct isl_set *set, unsigned dim,
-					isl_int value)
+/* Force the values of the variable at position "pos" of type "type" of "set"
+ * to be no greater than "value".
+ */
+__isl_give isl_set *isl_set_upper_bound_val(__isl_take isl_set *set,
+	enum isl_dim_type type, unsigned pos, __isl_take isl_val *value)
 {
-	int i;
+	isl_map *map;
 
-	set = isl_set_cow(set);
-	if (!set)
-		return NULL;
+	map = set_to_map(set);
+	return set_from_map(isl_map_upper_bound_val(map, type, pos, value));
+}
 
-	isl_assert(set->ctx, dim < isl_set_n_dim(set), goto error);
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_lower_bound_dim(set->pi, dim, value);
-		if (!set->pi)
-			goto error;
-	}
-	return set;
-error:
-	isl_set_free(set);
-	return NULL;
+/* If "mv" has an explicit domain, then intersect the domain of "map"
+ * with this explicit domain.
+ *
+ * An isl_multi_val object never has an explicit domain,
+ * so simply return "map".
+ */
+static __isl_give isl_map *isl_map_intersect_multi_val_explicit_domain(
+	__isl_take isl_map *map, __isl_keep isl_multi_val *mv)
+{
+	return map;
 }
 
-struct isl_map *isl_map_reverse(struct isl_map *map)
+#undef BASE
+#define BASE	val
+#include "isl_map_bound_templ.c"
+
+/* Apply "map_bound" to "set" with the corresponding value in "bound"
+ * for each set dimension, by treating the set as a map.
+ */
+static __isl_give isl_set *set_bound_multi_val(__isl_take isl_set *set,
+	__isl_take isl_multi_val *bound,
+	__isl_give isl_map *map_bound(__isl_take isl_map *map,
+		unsigned pos, __isl_take isl_val *value))
 {
-	int i;
+	isl_map *map;
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
+	map = set_to_map(set);
+	return set_from_map(map_bound_multi_val(map, bound, map_bound));
+}
 
-	map->dim = isl_space_reverse(map->dim);
-	if (!map->dim)
-		goto error;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_reverse(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+#undef BASE
+#define BASE	pw_aff
+#include "isl_map_bound_templ.c"
+
+/* Apply "map_bound" to "set" with the corresponding value in "bound"
+ * for each set dimension, by converting the set and the bound
+ * to objects living in a map space.
+ */
+static __isl_give isl_set *set_bound_multi_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_pw_aff *bound,
+	__isl_give isl_map *set_bound(__isl_take isl_map *map,
+		unsigned pos, __isl_take TYPE *value))
+{
+	isl_map *map;
+
+	map = isl_map_from_range(set);
+	bound = isl_multi_pw_aff_from_range(bound);
+	map = map_bound_multi_pw_aff(map, bound, set_bound);
+	return isl_map_range(map);
+}
+
+/* Wrapper around isl_map_lower_bound_val for use in map_bound_multi_val,
+ * setting a bound on the given output dimension.
+ */
+static __isl_give isl_map *map_lower_bound_val(__isl_take isl_map *map,
+	unsigned pos, __isl_take isl_val *v)
+{
+	return isl_map_lower_bound_val(map, isl_dim_out, pos, v);
 }
 
-static struct isl_map *isl_basic_map_partial_lexopt(
-		struct isl_basic_map *bmap, struct isl_basic_set *dom,
-		struct isl_set **empty, int max)
+/* Force the values of the set dimensions of "set"
+ * to be no smaller than the corresponding values in "lower".
+ */
+__isl_give isl_set *isl_set_lower_bound_multi_val(__isl_take isl_set *set,
+	__isl_take isl_multi_val *lower)
 {
-	return isl_tab_basic_map_partial_lexopt(bmap, dom, empty, max);
+	return set_bound_multi_val(set, lower, &map_lower_bound_val);
 }
 
-struct isl_map *isl_basic_map_partial_lexmax(
-		struct isl_basic_map *bmap, struct isl_basic_set *dom,
-		struct isl_set **empty)
+/* Wrapper around isl_map_upper_bound_val for use in map_bound_multi_val,
+ * setting a bound on the given output dimension.
+ */
+static __isl_give isl_map *map_upper_bound_val(__isl_take isl_map *map,
+	unsigned pos, __isl_take isl_val *v)
 {
-	return isl_basic_map_partial_lexopt(bmap, dom, empty, 1);
+	return isl_map_upper_bound_val(map, isl_dim_out, pos, v);
 }
 
-struct isl_map *isl_basic_map_partial_lexmin(
-		struct isl_basic_map *bmap, struct isl_basic_set *dom,
-		struct isl_set **empty)
+/* Force the values of the set dimensions of "set"
+ * to be no greater than the corresponding values in "upper".
+ */
+__isl_give isl_set *isl_set_upper_bound_multi_val(__isl_take isl_set *set,
+	__isl_take isl_multi_val *upper)
+{
+	return set_bound_multi_val(set, upper, &map_upper_bound_val);
+}
+
+/* Force the symbolic constant expression "bound"
+ * to satisfy the relation "order" with respect to
+ * the output variable at position "pos" of "map".
+ *
+ * Create an affine expression representing the output variable
+ * in terms of the range and
+ * compare it using "order" to "bound" (defined on the domain).
+ * The result is a relation between elements in domain and range that
+ * can be intersected with "map".
+ */
+static __isl_give isl_map *map_bound_pw_aff(__isl_take isl_map *map,
+	unsigned pos, __isl_take isl_pw_aff *bound,
+	__isl_give isl_map *(*order)(__isl_take isl_pw_aff *pa1,
+		__isl_take isl_pw_aff *pa2))
 {
-	return isl_basic_map_partial_lexopt(bmap, dom, empty, 0);
+	isl_space *space;
+	isl_local_space *ls;
+	isl_pw_aff *var;
+
+	space = isl_space_range(isl_map_get_space(map));
+	ls = isl_local_space_from_space(space);
+	var = isl_pw_aff_var_on_domain(ls, isl_dim_set, pos);
+	map = isl_map_intersect(map, order(bound, var));
+	return map;
 }
 
-struct isl_set *isl_basic_set_partial_lexmin(
-		struct isl_basic_set *bset, struct isl_basic_set *dom,
-		struct isl_set **empty)
+/* Force the values of the output variable at position "pos" of "map"
+ * to be no smaller than the symbolic constant expression "lower".
+ */
+static __isl_give isl_map *map_lower_bound_pw_aff(__isl_take isl_map *map,
+	unsigned pos, __isl_take isl_pw_aff *lower)
 {
-	return (struct isl_set *)
-		isl_basic_map_partial_lexmin((struct isl_basic_map *)bset,
-			dom, empty);
+	return map_bound_pw_aff(map, pos, lower, &isl_pw_aff_le_map);
 }
 
-struct isl_set *isl_basic_set_partial_lexmax(
-		struct isl_basic_set *bset, struct isl_basic_set *dom,
-		struct isl_set **empty)
+/* Force the values of the output variable at position "pos" of "map"
+ * to be no greater than the symbolic constant expression "upper".
+ */
+static __isl_give isl_map *map_upper_bound_pw_aff(__isl_take isl_map *map,
+	unsigned pos, __isl_take isl_pw_aff *upper)
 {
-	return (struct isl_set *)
-		isl_basic_map_partial_lexmax((struct isl_basic_map *)bset,
-			dom, empty);
+	return map_bound_pw_aff(map, pos, upper, &isl_pw_aff_ge_map);
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmin_pw_multi_aff(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty)
+/* Force the values of the set dimensions of "set"
+ * to be no smaller than the corresponding constant symbolic expressions
+ * in "lower".
+ */
+__isl_give isl_set *isl_set_lower_bound_multi_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_pw_aff *lower)
 {
-	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 0);
+	return set_bound_multi_pw_aff(set, lower, &map_lower_bound_pw_aff);
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexmax_pw_multi_aff(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty)
+/* Force the values of the set dimensions of "set"
+ * to be no greater than the corresponding constant symbolic expressions
+ * in "upper".
+ */
+__isl_give isl_set *isl_set_upper_bound_multi_pw_aff(__isl_take isl_set *set,
+	__isl_take isl_multi_pw_aff *upper)
 {
-	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, 1);
+	return set_bound_multi_pw_aff(set, upper, &map_upper_bound_pw_aff);
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmin_pw_multi_aff(
-	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty)
+/* Force the values of the output dimensions of "map"
+ * to be no smaller than the corresponding constant symbolic expressions
+ * in "lower".
+ */
+__isl_give isl_map *isl_map_lower_bound_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *lower)
 {
-	return isl_basic_map_partial_lexmin_pw_multi_aff(bset, dom, empty);
+	return map_bound_multi_pw_aff(map, lower, &map_lower_bound_pw_aff);
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_set_partial_lexmax_pw_multi_aff(
-	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty)
+/* Force the values of the output dimensions of "map"
+ * to be no greater than the corresponding constant symbolic expressions
+ * in "upper".
+ */
+__isl_give isl_map *isl_map_upper_bound_multi_pw_aff(__isl_take isl_map *map,
+	__isl_take isl_multi_pw_aff *upper)
 {
-	return isl_basic_map_partial_lexmax_pw_multi_aff(bset, dom, empty);
+	return map_bound_multi_pw_aff(map, upper, &map_upper_bound_pw_aff);
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_map_lexopt_pw_multi_aff(
-	__isl_take isl_basic_map *bmap, int max)
+/* Bound the given variable of "bset" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_basic_set *isl_basic_set_bound(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	isl_int value, int upper)
 {
-	isl_basic_set *dom = NULL;
-	isl_space *dom_space;
+	return bset_from_bmap(basic_map_bound(bset_to_bmap(bset),
+						type, pos, value, upper));
+}
 
-	if (!bmap)
+/* Bound the given variable of "bset" from below (or above is "upper"
+ * is set) to "value".
+ */
+static __isl_give isl_basic_set *isl_basic_set_bound_val(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	__isl_take isl_val *value, int upper)
+{
+	if (!value)
 		goto error;
-	dom_space = isl_space_domain(isl_space_copy(bmap->dim));
-	dom = isl_basic_set_universe(dom_space);
-	return isl_basic_map_partial_lexopt_pw_multi_aff(bmap, dom, NULL, max);
+	if (!isl_val_is_int(value))
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_invalid,
+			"expecting integer value", goto error);
+	bset = isl_basic_set_bound(bset, type, pos, value->n, upper);
+	isl_val_free(value);
+	return bset;
 error:
-	isl_basic_map_free(bmap);
+	isl_val_free(value);
+	isl_basic_set_free(bset);
 	return NULL;
 }
 
-__isl_give isl_pw_multi_aff *isl_basic_map_lexmin_pw_multi_aff(
-	__isl_take isl_basic_map *bmap)
+/* Bound the given variable of "bset" from below to "value".
+ */
+__isl_give isl_basic_set *isl_basic_set_lower_bound_val(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	__isl_take isl_val *value)
+{
+	return isl_basic_set_bound_val(bset, type, pos, value, 0);
+}
+
+/* Bound the given variable of "bset" from above to "value".
+ */
+__isl_give isl_basic_set *isl_basic_set_upper_bound_val(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned pos,
+	__isl_take isl_val *value)
+{
+	return isl_basic_set_bound_val(bset, type, pos, value, 1);
+}
+
+__isl_give isl_map *isl_map_reverse(__isl_take isl_map *map)
 {
-	return isl_basic_map_lexopt_pw_multi_aff(bmap, 0);
+	return isl_map_transform(map, &isl_space_reverse,
+					&isl_basic_map_reverse);
+}
+
+/* Given a map A -> (B -> C), return the corresponding map A -> (C -> B).
+ */
+__isl_give isl_map *isl_map_range_reverse(__isl_take isl_map *map)
+{
+	return isl_map_transform(map, &isl_space_range_reverse,
+					&isl_basic_map_range_reverse);
 }
 
 #undef TYPE
@@ -6150,23 +7183,31 @@
 /* Given a map "map", compute the lexicographically minimal
  * (or maximal) image element for each domain element in dom,
  * in the form of an isl_pw_multi_aff.
- * Set *empty to those elements in dom that do not have an image element.
+ * If "empty" is not NULL, then set *empty to those elements in dom that
+ * do not have an image element.
+ * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
+ * should be computed over the domain of "map".  "empty" is also NULL
+ * in this case.
  *
  * We first compute the lexicographically minimal or maximal element
  * in the first basic map.  This results in a partial solution "res"
  * and a subset "todo" of dom that still need to be handled.
  * We then consider each of the remaining maps in "map" and successively
  * update both "res" and "todo".
+ * If "empty" is NULL, then the todo sets are not needed and therefore
+ * also not computed.
  */
 static __isl_give isl_pw_multi_aff *isl_map_partial_lexopt_aligned_pw_multi_aff(
 	__isl_take isl_map *map, __isl_take isl_set *dom,
-	__isl_give isl_set **empty, int max)
+	__isl_give isl_set **empty, unsigned flags)
 {
 	int i;
+	int full;
 	isl_pw_multi_aff *res;
 	isl_set *todo;
 
-	if (!map || !dom)
+	full = ISL_FL_ISSET(flags, ISL_OPT_FULL);
+	if (!map || (!full && !dom))
 		goto error;
 
 	if (isl_map_plain_is_empty(map)) {
@@ -6179,22 +7220,24 @@
 
 	res = basic_map_partial_lexopt_pw_multi_aff(
 					    isl_basic_map_copy(map->p0),
-					    isl_set_copy(dom), &todo, max);
+					    isl_set_copy(dom), empty, flags);
 
+	if (empty)
+		todo = *empty;
 	for (i = 1; i < map->n; ++i) {
 		isl_pw_multi_aff *res_i;
-		isl_set *todo_i;
 
 		res_i = basic_map_partial_lexopt_pw_multi_aff(
 					    isl_basic_map_copy(map->pi),
-					    isl_set_copy(dom), &todo_i, max);
+					    isl_set_copy(dom), empty, flags);
 
-		if (max)
+		if (ISL_FL_ISSET(flags, ISL_OPT_MAX))
 			res = isl_pw_multi_aff_union_lexmax(res, res_i);
 		else
 			res = isl_pw_multi_aff_union_lexmin(res, res_i);
 
-		todo = isl_set_intersect(todo, todo_i);
+		if (empty)
+			todo = isl_set_intersect(todo, *empty);
 	}
 
 	isl_set_free(dom);
@@ -6202,8 +7245,6 @@
 
 	if (empty)
 		*empty = todo;
-	else
-		isl_set_free(todo);
 
 	return res;
 error:
@@ -6225,67 +7266,38 @@
 #include "isl_map_lexopt_templ.c"
 
 /* Given a map "map", compute the lexicographically minimal
- * (or maximal) image element for each domain element in dom.
- * Set *empty to those elements in dom that do not have an image element.
- *
- * We first compute the lexicographically minimal or maximal element
- * in the first basic map.  This results in a partial solution "res"
- * and a subset "todo" of dom that still need to be handled.
- * We then consider each of the remaining maps in "map" and successively
- * update both "res" and "todo".
- *
- * Let res^k and todo^k be the results after k steps and let i = k + 1.
- * Assume we are computing the lexicographical maximum.
- * We first compute the lexicographically maximal element in basic map i.
- * This results in a partial solution res_i and a subset todo_i.
- * Then we combine these results with those obtain for the first k basic maps
- * to obtain a result that is valid for the first k+1 basic maps.
- * In particular, the set where there is no solution is the set where
- * there is no solution for the first k basic maps and also no solution
- * for the ith basic map, i.e.,
- *
- *	todo^i = todo^k * todo_i
- *
- * On dom(res^k) * dom(res_i), we need to pick the larger of the two
- * solutions, arbitrarily breaking ties in favor of res^k.
- * That is, when res^k(a) >= res_i(a), we pick res^k and
- * when res^k(a) < res_i(a), we pick res_i.  (Here, ">=" and "<" denote
- * the lexicographic order.)
- * In practice, we compute
- *
- *	res^k * (res_i . "<=")
- *
- * and
- *
- *	res_i * (res^k . "<")
- *
- * Finally, we consider the symmetric difference of dom(res^k) and dom(res_i),
- * where only one of res^k and res_i provides a solution and we simply pick
- * that one, i.e.,
- *
- *	res^k * todo_i
- * and
- *	res_i * todo^k
- *
- * Note that we only compute these intersections when dom(res^k) intersects
- * dom(res_i).  Otherwise, the only effect of these intersections is to
- * potentially break up res^k and res_i into smaller pieces.
- * We want to avoid such splintering as much as possible.
- * In fact, an earlier implementation of this function would look for
- * better results in the domain of res^k and for extra results in todo^k,
- * but this would always result in a splintering according to todo^k,
- * even when the domain of basic map i is disjoint from the domains of
- * the previous basic maps.
+ * (or maximal) image element for each domain element in "dom",
+ * in the form of an isl_map.
+ * If "empty" is not NULL, then set *empty to those elements in "dom" that
+ * do not have an image element.
+ * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
+ * should be computed over the domain of "map".  "empty" is also NULL
+ * in this case.
+ *
+ * If the input consists of more than one disjunct, then first
+ * compute the desired result in the form of an isl_pw_multi_aff and
+ * then convert that into an isl_map.
+ *
+ * This function used to have an explicit implementation in terms
+ * of isl_maps, but it would continually intersect the domains of
+ * partial results with the complement of the domain of the next
+ * partial solution, potentially leading to an explosion in the number
+ * of disjuncts if there are several disjuncts in the input.
+ * An even earlier implementation of this function would look for
+ * better results in the domain of the partial result and for extra
+ * results in the complement of this domain, which would lead to
+ * even more splintering.
  */
 static __isl_give isl_map *isl_map_partial_lexopt_aligned(
-		__isl_take isl_map *map, __isl_take isl_set *dom,
-		__isl_give isl_set **empty, int max)
+	__isl_take isl_map *map, __isl_take isl_set *dom,
+	__isl_give isl_set **empty, unsigned flags)
 {
-	int i;
+	int full;
 	struct isl_map *res;
-	struct isl_set *todo;
+	isl_pw_multi_aff *pma;
 
-	if (!map || !dom)
+	full = ISL_FL_ISSET(flags, ISL_OPT_FULL);
+	if (!map || (!full && !dom))
 		goto error;
 
 	if (isl_map_plain_is_empty(map)) {
@@ -6296,53 +7308,16 @@
 		return map;
 	}
 
-	res = basic_map_partial_lexopt(isl_basic_map_copy(map->p0),
-					isl_set_copy(dom), &todo, max);
-
-	for (i = 1; i < map->n; ++i) {
-		isl_map *lt, *le;
-		isl_map *res_i;
-		isl_set *todo_i;
-		isl_space *dim = isl_space_range(isl_map_get_space(res));
-
-		res_i = basic_map_partial_lexopt(isl_basic_map_copy(map->pi),
-					isl_set_copy(dom), &todo_i, max);
-
-		if (max) {
-			lt = isl_map_lex_lt(isl_space_copy(dim));
-			le = isl_map_lex_le(dim);
-		} else {
-			lt = isl_map_lex_gt(isl_space_copy(dim));
-			le = isl_map_lex_ge(dim);
-		}
-		lt = isl_map_apply_range(isl_map_copy(res), lt);
-		lt = isl_map_intersect(lt, isl_map_copy(res_i));
-		le = isl_map_apply_range(isl_map_copy(res_i), le);
-		le = isl_map_intersect(le, isl_map_copy(res));
-
-		if (!isl_map_is_empty(lt) || !isl_map_is_empty(le)) {
-			res = isl_map_intersect_domain(res,
-							isl_set_copy(todo_i));
-			res_i = isl_map_intersect_domain(res_i,
-							isl_set_copy(todo));
-		}
-
-		res = isl_map_union_disjoint(res, res_i);
-		res = isl_map_union_disjoint(res, lt);
-		res = isl_map_union_disjoint(res, le);
-
-		todo = isl_set_intersect(todo, todo_i);
+	if (map->n == 1) {
+		res = basic_map_partial_lexopt(isl_basic_map_copy(map->p0),
+						dom, empty, flags);
+		isl_map_free(map);
+		return res;
 	}
 
-	isl_set_free(dom);
-	isl_map_free(map);
-
-	if (empty)
-		*empty = todo;
-	else
-		isl_set_free(todo);
-
-	return res;
+	pma = isl_map_partial_lexopt_aligned_pw_multi_aff(map, dom, empty,
+							flags);
+	return isl_map_from_pw_multi_aff_internal(pma);
 error:
 	if (empty)
 		*empty = NULL;
@@ -6355,7 +7330,7 @@
 		__isl_take isl_map *map, __isl_take isl_set *dom,
 		__isl_give isl_set **empty)
 {
-	return isl_map_partial_lexopt(map, dom, empty, 1);
+	return isl_map_partial_lexopt(map, dom, empty, ISL_OPT_MAX);
 }
 
 __isl_give isl_map *isl_map_partial_lexmin(
@@ -6369,122 +7344,70 @@
 		__isl_take isl_set *set, __isl_take isl_set *dom,
 		__isl_give isl_set **empty)
 {
-	return (struct isl_set *)
-		isl_map_partial_lexmin((struct isl_map *)set,
-			dom, empty);
+	return set_from_map(isl_map_partial_lexmin(set_to_map(set),
+						    dom, empty));
 }
 
 __isl_give isl_set *isl_set_partial_lexmax(
 		__isl_take isl_set *set, __isl_take isl_set *dom,
 		__isl_give isl_set **empty)
 {
-	return (struct isl_set *)
-		isl_map_partial_lexmax((struct isl_map *)set,
-			dom, empty);
-}
-
-/* Compute the lexicographic minimum (or maximum if "max" is set)
- * of "bmap" over its domain.
- *
- * Since we are not interested in the part of the domain space where
- * there is no solution, we initialize the domain to those constraints
- * of "bmap" that only involve the parameters and the input dimensions.
- * This relieves the parametric programming engine from detecting those
- * inequalities and transferring them to the context.  More importantly,
- * it ensures that those inequalities are transferred first and not
- * intermixed with inequalities that actually split the domain.
- */
-__isl_give isl_map *isl_basic_map_lexopt(__isl_take isl_basic_map *bmap, int max)
-{
-	int n_div;
-	int n_out;
-	isl_basic_map *copy;
-	isl_basic_set *dom;
-
-	n_div = isl_basic_map_dim(bmap, isl_dim_div);
-	n_out = isl_basic_map_dim(bmap, isl_dim_out);
-	copy = isl_basic_map_copy(bmap);
-	copy = isl_basic_map_drop_constraints_involving_dims(copy,
-							isl_dim_div, 0, n_div);
-	copy = isl_basic_map_drop_constraints_involving_dims(copy,
-							isl_dim_out, 0, n_out);
-	dom = isl_basic_map_domain(copy);
-	return isl_basic_map_partial_lexopt(bmap, dom, NULL, max);
+	return set_from_map(isl_map_partial_lexmax(set_to_map(set),
+						    dom, empty));
 }
 
-__isl_give isl_map *isl_basic_map_lexmin(__isl_take isl_basic_map *bmap)
+/* Compute the lexicographic minimum (or maximum if "flags" includes
+ * ISL_OPT_MAX) of "bset" over its parametric domain.
+ */
+__isl_give isl_set *isl_basic_set_lexopt(__isl_take isl_basic_set *bset,
+	unsigned flags)
 {
-	return isl_basic_map_lexopt(bmap, 0);
+	return isl_basic_map_lexopt(bset, flags);
 }
 
 __isl_give isl_map *isl_basic_map_lexmax(__isl_take isl_basic_map *bmap)
 {
-	return isl_basic_map_lexopt(bmap, 1);
+	return isl_basic_map_lexopt(bmap, ISL_OPT_MAX);
 }
 
 __isl_give isl_set *isl_basic_set_lexmin(__isl_take isl_basic_set *bset)
 {
-	return (isl_set *)isl_basic_map_lexmin((isl_basic_map *)bset);
+	return set_from_map(isl_basic_map_lexmin(bset_to_bmap(bset)));
 }
 
 __isl_give isl_set *isl_basic_set_lexmax(__isl_take isl_basic_set *bset)
 {
-	return (isl_set *)isl_basic_map_lexmax((isl_basic_map *)bset);
+	return set_from_map(isl_basic_map_lexmax(bset_to_bmap(bset)));
 }
 
-/* Extract the first and only affine expression from list
- * and then add it to *pwaff with the given dom.
- * This domain is known to be disjoint from other domains
- * because of the way isl_basic_map_foreach_lexmax works.
+/* Compute the lexicographic minimum of "bset" over its parametric domain
+ * for the purpose of quantifier elimination.
+ * That is, find an explicit representation for all the existentially
+ * quantified variables in "bset" by computing their lexicographic
+ * minimum.
  */
-static int update_dim_opt(__isl_take isl_basic_set *dom,
-	__isl_take isl_aff_list *list, void *user)
+static __isl_give isl_set *isl_basic_set_lexmin_compute_divs(
+	__isl_take isl_basic_set *bset)
 {
-	isl_ctx *ctx = isl_basic_set_get_ctx(dom);
-	isl_aff *aff;
-	isl_pw_aff **pwaff = user;
-	isl_pw_aff *pwaff_i;
-
-	if (!list)
-		goto error;
-	if (isl_aff_list_n_aff(list) != 1)
-		isl_die(ctx, isl_error_internal,
-			"expecting single element list", goto error);
-
-	aff = isl_aff_list_get_aff(list, 0);
-	pwaff_i = isl_pw_aff_alloc(isl_set_from_basic_set(dom), aff);
-
-	*pwaff = isl_pw_aff_add_disjoint(*pwaff, pwaff_i);
-
-	isl_aff_list_free(list);
-
-	return 0;
-error:
-	isl_basic_set_free(dom);
-	isl_aff_list_free(list);
-	return -1;
+	return isl_basic_set_lexopt(bset, ISL_OPT_QE);
 }
 
 /* Given a basic map with one output dimension, compute the minimum or
  * maximum of that dimension as an isl_pw_aff.
  *
- * The isl_pw_aff is constructed by having isl_basic_map_foreach_lexopt
- * call update_dim_opt on each leaf of the result.
+ * Compute the optimum as a lexicographic optimum over the single
+ * output dimension and extract the single isl_pw_aff from the result.
  */
 static __isl_give isl_pw_aff *basic_map_dim_opt(__isl_keep isl_basic_map *bmap,
 	int max)
 {
-	isl_space *dim = isl_basic_map_get_space(bmap);
+	isl_pw_multi_aff *pma;
 	isl_pw_aff *pwaff;
-	int r;
 
-	dim = isl_space_from_domain(isl_space_domain(dim));
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	pwaff = isl_pw_aff_empty(dim);
-
-	r = isl_basic_map_foreach_lexopt(bmap, max, &update_dim_opt, &pwaff);
-	if (r < 0)
-		return isl_pw_aff_free(pwaff);
+	bmap = isl_basic_map_copy(bmap);
+	pma = isl_basic_map_lexopt_pw_multi_aff(bmap, max ? ISL_OPT_MAX : 0);
+	pwaff = isl_pw_multi_aff_get_pw_aff(pma, 0);
+	isl_pw_multi_aff_free(pma);
 
 	return pwaff;
 }
@@ -6502,18 +7425,20 @@
 {
 	int i;
 	isl_pw_aff *pwaff;
-	unsigned n_out;
+	isl_size n_out;
 
 	n_out = isl_map_dim(map, isl_dim_out);
+	if (n_out < 0)
+		map = isl_map_free(map);
 	map = isl_map_project_out(map, isl_dim_out, pos + 1, n_out - (pos + 1));
 	map = isl_map_project_out(map, isl_dim_out, 0, pos);
 	if (!map)
 		return NULL;
 
 	if (map->n == 0) {
-		isl_space *dim = isl_map_get_space(map);
+		isl_space *space = isl_map_get_space(map);
 		isl_map_free(map);
-		return isl_pw_aff_empty(dim);
+		return isl_pw_aff_empty(space);
 	}
 
 	pwaff = basic_map_dim_opt(map->p0, max);
@@ -6529,6 +7454,15 @@
 	return pwaff;
 }
 
+/* Compute the minimum of the given output dimension as a function of the
+ * parameters and input dimensions, but independently of
+ * the other output dimensions.
+ */
+__isl_give isl_pw_aff *isl_map_dim_min(__isl_take isl_map *map, int pos)
+{
+	return map_dim_opt(map, pos, 0);
+}
+
 /* Compute the maximum of the given output dimension as a function of the
  * parameters and input dimensions, but independently of
  * the other output dimensions.
@@ -6567,20 +7501,19 @@
 /* Apply a preimage specified by "mat" on the parameters of "bset".
  * bset is assumed to have only parameters and divs.
  */
-static struct isl_basic_set *basic_set_parameter_preimage(
-	struct isl_basic_set *bset, struct isl_mat *mat)
+static __isl_give isl_basic_set *basic_set_parameter_preimage(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *mat)
 {
-	unsigned nparam;
+	isl_size nparam;
 
-	if (!bset || !mat)
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0 || !mat)
 		goto error;
 
 	bset->dim = isl_space_cow(bset->dim);
 	if (!bset->dim)
 		goto error;
 
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-
 	isl_assert(bset->ctx, mat->n_row == 1 + nparam, goto error);
 
 	bset->dim->nparam = 0;
@@ -6600,42 +7533,35 @@
 /* Apply a preimage specified by "mat" on the parameters of "set".
  * set is assumed to have only parameters and divs.
  */
-static struct isl_set *set_parameter_preimage(
-	struct isl_set *set, struct isl_mat *mat)
+static __isl_give isl_set *set_parameter_preimage(__isl_take isl_set *set,
+	__isl_take isl_mat *mat)
 {
-	isl_space *dim = NULL;
-	unsigned nparam;
-
-	if (!set || !mat)
-		goto error;
-
-	dim = isl_space_copy(set->dim);
-	dim = isl_space_cow(dim);
-	if (!dim)
-		goto error;
+	isl_space *space;
+	isl_size nparam;
 
 	nparam = isl_set_dim(set, isl_dim_param);
+	if (nparam < 0 || !mat)
+		goto error;
 
-	isl_assert(set->ctx, mat->n_row == 1 + nparam, goto error);
+	if (mat->n_row != 1 + nparam)
+		isl_die(isl_set_get_ctx(set), isl_error_internal,
+			"unexpected number of rows", goto error);
 
-	dim->nparam = 0;
-	dim->n_out = nparam;
-	isl_set_reset_space(set, dim);
+	space = isl_set_get_space(set);
+	space = isl_space_move_dims(space, isl_dim_set, 0,
+				    isl_dim_param, 0, nparam);
+	set = isl_set_reset_space(set, space);
 	set = isl_set_preimage(set, mat);
-	if (!set)
-		goto error2;
-	dim = isl_space_copy(set->dim);
-	dim = isl_space_cow(dim);
-	if (!dim)
-		goto error2;
-	dim->nparam = dim->n_out;
-	dim->n_out = 0;
-	isl_set_reset_space(set, dim);
+	nparam = isl_set_dim(set, isl_dim_out);
+	if (nparam < 0)
+		set = isl_set_free(set);
+	space = isl_set_get_space(set);
+	space = isl_space_move_dims(space, isl_dim_param, 0,
+				    isl_dim_out, 0, nparam);
+	set = isl_set_reset_space(set, space);
 	return set;
 error:
-	isl_space_free(dim);
 	isl_mat_free(mat);
-error2:
 	isl_set_free(set);
 	return NULL;
 }
@@ -6643,8 +7569,8 @@
 /* Intersect the basic set "bset" with the affine space specified by the
  * equalities in "eq".
  */
-static struct isl_basic_set *basic_set_append_equalities(
-	struct isl_basic_set *bset, struct isl_mat *eq)
+static __isl_give isl_basic_set *basic_set_append_equalities(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *eq)
 {
 	int i, k;
 	unsigned len;
@@ -6652,12 +7578,11 @@
 	if (!bset || !eq)
 		goto error;
 
-	bset = isl_basic_set_extend_space(bset, isl_space_copy(bset->dim), 0,
-					eq->n_row, 0);
+	bset = isl_basic_set_extend(bset, 0, eq->n_row, 0);
 	if (!bset)
 		goto error;
 
-	len = 1 + isl_space_dim(bset->dim, isl_dim_all) + bset->extra;
+	len = isl_basic_set_offset(bset, isl_dim_div) + bset->extra;
 	for (i = 0; i < eq->n_row; ++i) {
 		k = isl_basic_set_alloc_equality(bset);
 		if (k < 0)
@@ -6680,8 +7605,8 @@
 /* Intersect the set "set" with the affine space specified by the
  * equalities in "eq".
  */
-static struct isl_set *set_append_equalities(struct isl_set *set,
-	struct isl_mat *eq)
+static __isl_give isl_set *set_append_equalities(__isl_take isl_set *set,
+	__isl_take isl_mat *eq)
 {
 	int i;
 
@@ -6712,13 +7637,12 @@
 static int first_parameter_equality(__isl_keep isl_basic_set *bset)
 {
 	int i, j;
-	unsigned nparam, n_div;
-
-	if (!bset)
-		return -1;
+	isl_size nparam, n_div;
 
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
 	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	if (nparam < 0 || n_div < 0)
+		return -1;
 
 	for (i = 0, j = n_div - 1; i < bset->n_eq && j >= 0; --j) {
 		if (!isl_int_is_zero(bset->eqi1 + nparam + j))
@@ -6746,12 +7670,12 @@
 {
 	isl_morph *morph1, *morph2;
 	isl_set *set;
-	unsigned n;
+	isl_size n;
 
 	if (!bset)
 		return NULL;
 	if (bset->n_eq == 0)
-		return isl_basic_set_lexmin(bset);
+		return isl_basic_set_lexmin_compute_divs(bset);
 
 	morph1 = isl_basic_set_parameter_compression(bset);
 	bset = isl_morph_basic_set(isl_morph_copy(morph1), bset);
@@ -6759,9 +7683,11 @@
 	morph2 = isl_basic_set_variable_compression(bset, isl_dim_set);
 	bset = isl_morph_basic_set(morph2, bset);
 	n = isl_basic_set_dim(bset, isl_dim_set);
+	if (n < 0)
+		bset = isl_basic_set_free(bset);
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 0, n);
 
-	set = isl_basic_set_lexmin(bset);
+	set = isl_basic_set_lexmin_compute_divs(bset);
 
 	set = isl_morph_set(isl_morph_inverse(morph1), set);
 
@@ -6786,13 +7712,14 @@
  * if so recurse.  The removal of parameter equalities is required
  * for the parameter compression performed by base_compute_divs.
  */
-static struct isl_set *parameter_compute_divs(struct isl_basic_set *bset)
+static __isl_give isl_set *parameter_compute_divs(
+	__isl_take isl_basic_set *bset)
 {
 	int i;
 	struct isl_mat *eq;
 	struct isl_mat *T, *T2;
 	struct isl_set *set;
-	unsigned nparam;
+	isl_size nparam;
 
 	bset = isl_basic_set_cow(bset);
 	if (!bset)
@@ -6812,6 +7739,8 @@
 		return base_compute_divs(bset);
 
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0)
+		return isl_set_from_basic_set(isl_basic_set_free(bset));
 	eq = isl_mat_sub_alloc6(bset->ctx, bset->eq, i, bset->n_eq - i,
 		0, 1 + nparam);
 	eq = isl_mat_cow(eq);
@@ -6848,10 +7777,12 @@
 	__isl_take isl_basic_map *bmap, __isl_keep isl_local_space *ls)
 {
 	int i;
-	int n_div;
+	isl_size n_div;
 	int old_n_div;
 
 	n_div = isl_local_space_dim(ls, isl_dim_div);
+	if (n_div < 0)
+		return isl_basic_map_free(bmap);
 	if (n_div == 0)
 		return bmap;
 
@@ -6877,13 +7808,13 @@
 static __isl_give isl_basic_map *basic_replace_space_by_local_space(
 	__isl_take isl_basic_map *bmap, __isl_take isl_local_space *ls)
 {
-	int n_div;
+	isl_size n_div;
 
 	bmap = isl_basic_map_cow(bmap);
-	if (!bmap || !ls)
+	n_div = isl_local_space_dim(ls, isl_dim_div);
+	if (!bmap || n_div < 0)
 		goto error;
 
-	n_div = isl_local_space_dim(ls, isl_dim_div);
 	bmap = insert_divs_from_local_space(bmap, ls);
 	if (!bmap)
 		goto error;
@@ -6921,10 +7852,8 @@
 		if (!map->pi)
 			goto error;
 	}
-	isl_space_free(map->dim);
-	map->dim = isl_local_space_get_space(ls);
-	if (!map->dim)
-		goto error;
+	isl_space_free(isl_map_take_space(map));
+	map = isl_map_restore_space(map, isl_local_space_get_space(ls));
 
 	isl_local_space_free(ls);
 	return map;
@@ -6948,17 +7877,17 @@
  * is reset to that of the input, including the existentially quantified
  * variables for which we already had an explicit representation.
  */
-static struct isl_map *compute_divs(struct isl_basic_map *bmap)
+static __isl_give isl_map *compute_divs(__isl_take isl_basic_map *bmap)
 {
 	struct isl_basic_set *bset;
 	struct isl_set *set;
 	struct isl_map *map;
-	isl_space *dim;
+	isl_space *space;
 	isl_local_space *ls;
-	unsigned	 nparam;
-	unsigned	 n_in;
-	unsigned	 n_out;
-	unsigned n_known;
+	isl_size nparam;
+	isl_size n_in;
+	isl_size n_out;
+	int n_known;
 	int i;
 
 	bmap = isl_basic_map_sort_divs(bmap);
@@ -6966,16 +7895,16 @@
 	if (!bmap)
 		return NULL;
 
-	for (n_known = 0; n_known < bmap->n_div; ++n_known)
-		if (isl_int_is_zero(bmap->divn_known0))
-			break;
-
+	n_known = isl_basic_map_first_unknown_div(bmap);
 	nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	n_in = isl_basic_map_dim(bmap, isl_dim_in);
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
-	dim = isl_space_set_alloc(bmap->ctx,
+	if (n_known < 0 || nparam < 0 || n_in < 0 || n_out < 0)
+		return isl_map_from_basic_map(isl_basic_map_free(bmap));
+
+	space = isl_space_set_alloc(bmap->ctx,
 				    nparam + n_in + n_out + n_known, 0);
-	if (!dim)
+	if (!space)
 		goto error;
 
 	ls = isl_basic_map_get_local_space(bmap);
@@ -6987,11 +7916,11 @@
 		bmap->n_div -= n_known;
 		bmap->extra -= n_known;
 	}
-	bmap = isl_basic_map_reset_space(bmap, dim);
-	bset = (struct isl_basic_set *)bmap;
+	bmap = isl_basic_map_reset_space(bmap, space);
+	bset = bset_from_bmap(bmap);
 
 	set = parameter_compute_divs(bset);
-	map = (struct isl_map *)set;
+	map = set_to_map(set);
 	map = replace_space_by_local_space(map, ls);
 
 	return map;
@@ -7000,30 +7929,96 @@
 	return NULL;
 }
 
-int isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
+/* Remove the explicit representation of local variable "div",
+ * if there is any.
+ */
+__isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
+	__isl_take isl_basic_map *bmap, int div)
+{
+	isl_bool unknown;
+
+	unknown = isl_basic_map_div_is_marked_unknown(bmap, div);
+	if (unknown < 0)
+		return isl_basic_map_free(bmap);
+	if (unknown)
+		return bmap;
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		return NULL;
+	isl_int_set_si(bmap->divdiv0, 0);
+	return bmap;
+}
+
+/* Is local variable "div" of "bmap" marked as not having an explicit
+ * representation?
+ * Note that even if "div" is not marked in this way and therefore
+ * has an explicit representation, this representation may still
+ * depend (indirectly) on other local variables that do not
+ * have an explicit representation.
+ */
+isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
+	int div)
+{
+	if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
+		return isl_bool_error;
+	return isl_int_is_zero(bmap->divdiv0);
+}
+
+/* Return the position of the first local variable that does not
+ * have an explicit representation.
+ * Return the total number of local variables if they all have
+ * an explicit representation.
+ * Return -1 on error.
+ */
+int isl_basic_map_first_unknown_div(__isl_keep isl_basic_map *bmap)
 {
 	int i;
-	unsigned off;
 
 	if (!bmap)
 		return -1;
 
-	off = isl_space_dim(bmap->dim, isl_dim_all);
 	for (i = 0; i < bmap->n_div; ++i) {
-		if (isl_int_is_zero(bmap->divi0))
-			return 0;
-		isl_assert(bmap->ctx, isl_int_is_zero(bmap->divi1+1+off+i),
-				return -1);
+		if (!isl_basic_map_div_is_known(bmap, i))
+			return i;
 	}
-	return 1;
+	return bmap->n_div;
+}
+
+/* Return the position of the first local variable that does not
+ * have an explicit representation.
+ * Return the total number of local variables if they all have
+ * an explicit representation.
+ * Return -1 on error.
+ */
+int isl_basic_set_first_unknown_div(__isl_keep isl_basic_set *bset)
+{
+	return isl_basic_map_first_unknown_div(bset);
+}
+
+/* Does "bmap" have an explicit representation for all local variables?
+ */
+isl_bool isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap)
+{
+	int first;
+	isl_size n;
+
+	n = isl_basic_map_dim(bmap, isl_dim_div);
+	first = isl_basic_map_first_unknown_div(bmap);
+	if (n < 0 || first < 0)
+		return isl_bool_error;
+	return first == n;
 }
 
-static int map_divs_known(__isl_keep isl_map *map)
+/* Do all basic maps in "map" have an explicit representation
+ * for all local variables?
+ */
+isl_bool isl_map_divs_known(__isl_keep isl_map *map)
 {
 	int i;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
 		int known = isl_basic_map_divs_known(map->pi);
@@ -7031,7 +8026,7 @@
 			return known;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* If bmap contains any unknown divs, then compute explicit
@@ -7039,7 +8034,7 @@
  * quite expensive, so first try to remove divs that aren't
  * strictly needed.
  */
-struct isl_map *isl_basic_map_compute_divs(struct isl_basic_map *bmap)
+__isl_give isl_map *isl_basic_map_compute_divs(__isl_take isl_basic_map *bmap)
 {
 	int known;
 	struct isl_map *map;
@@ -7065,7 +8060,7 @@
 	return NULL;
 }
 
-struct isl_map *isl_map_compute_divs(struct isl_map *map)
+__isl_give isl_map *isl_map_compute_divs(__isl_take isl_map *map)
 {
 	int i;
 	int known;
@@ -7076,7 +8071,7 @@
 	if (map->n == 0)
 		return map;
 
-	known = map_divs_known(map);
+	known = isl_map_divs_known(map);
 	if (known < 0) {
 		isl_map_free(map);
 		return NULL;
@@ -7098,45 +8093,29 @@
 	return res;
 }
 
-struct isl_set *isl_basic_set_compute_divs(struct isl_basic_set *bset)
+__isl_give isl_set *isl_basic_set_compute_divs(__isl_take isl_basic_set *bset)
 {
-	return (struct isl_set *)
-		isl_basic_map_compute_divs((struct isl_basic_map *)bset);
+	return set_from_map(isl_basic_map_compute_divs(bset_to_bmap(bset)));
 }
 
-struct isl_set *isl_set_compute_divs(struct isl_set *set)
+__isl_give isl_set *isl_set_compute_divs(__isl_take isl_set *set)
 {
-	return (struct isl_set *)
-		isl_map_compute_divs((struct isl_map *)set);
+	return set_from_map(isl_map_compute_divs(set_to_map(set)));
 }
 
-struct isl_set *isl_map_domain(struct isl_map *map)
+__isl_give isl_set *isl_map_domain(__isl_take isl_map *map)
 {
-	int i;
-	struct isl_set *set;
+	isl_space *space;
+	isl_size n_out;
 
-	if (!map)
-		goto error;
+	n_out = isl_map_dim(map, isl_dim_out);
+	if (n_out < 0)
+		return set_from_map(isl_map_free(map));
+	space = isl_space_domain(isl_map_get_space(map));
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
+	map = isl_map_project_out(map, isl_dim_out, 0, n_out);
 
-	set = (struct isl_set *)map;
-	set->dim = isl_space_domain(set->dim);
-	if (!set->dim)
-		goto error;
-	for (i = 0; i < map->n; ++i) {
-		set->pi = isl_basic_map_domain(map->pi);
-		if (!set->pi)
-			goto error;
-	}
-	ISL_F_CLR(set, ISL_MAP_DISJOINT);
-	ISL_F_CLR(set, ISL_SET_NORMALIZED);
-	return set;
-error:
-	isl_map_free(map);
-	return NULL;
+	return set_from_map(isl_map_reset_space(map, space));
 }
 
 /* Return the union of "map1" and "map2", where we assume for now that
@@ -7157,13 +8136,9 @@
 	struct isl_map *map = NULL;
 	int is_universe;
 
-	if (!map1 || !map2)
+	if (isl_map_check_equal_space(map1, map2) < 0)
 		goto error;
 
-	if (!isl_space_is_equal(map1->dim, map2->dim))
-		isl_die(isl_map_get_ctx(map1), isl_error_invalid,
-			"spaces don't match", goto error);
-
 	if (map1->n == 0) {
 		isl_map_free(map1);
 		return map2;
@@ -7229,11 +8204,12 @@
 __isl_give isl_map *isl_map_union_disjoint(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
-	return isl_map_align_params_map_map_and(map1, map2, &map_union_disjoint);
+	isl_map_align_params_bin(&map1, &map2);
+	return map_union_disjoint(map1, map2);
 }
 
 /* Return the union of "map1" and "map2", where "map1" and "map2" may
- * not be disjoint.  The parameters are assumed to have been aligned.
+ * not be disjoint.
  *
  * We currently simply call map_union_disjoint, the internal operation
  * of which does not really depend on the inputs being disjoint.
@@ -7244,12 +8220,12 @@
  * As a special case, if "map1" and "map2" are obviously equal,
  * then we simply return "map1".
  */
-static __isl_give isl_map *map_union_aligned(__isl_take isl_map *map1,
+__isl_give isl_map *isl_map_union(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
 	int equal;
 
-	if (!map1 || !map2)
+	if (isl_map_align_params_bin(&map1, &map2) < 0)
 		goto error;
 
 	equal = isl_map_plain_is_equal(map1, map2);
@@ -7272,36 +8248,26 @@
 	return NULL;
 }
 
-/* Return the union of "map1" and "map2", where "map1" and "map2" may
- * not be disjoint.
- */
-__isl_give isl_map *isl_map_union(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
+__isl_give isl_set *isl_set_union_disjoint(
+	__isl_take isl_set *set1, __isl_take isl_set *set2)
 {
-	return isl_map_align_params_map_map_and(map1, map2, &map_union_aligned);
+	return set_from_map(isl_map_union_disjoint(set_to_map(set1),
+						    set_to_map(set2)));
 }
 
-struct isl_set *isl_set_union_disjoint(
-			struct isl_set *set1, struct isl_set *set2)
-{
-	return (struct isl_set *)
-		isl_map_union_disjoint(
-			(struct isl_map *)set1, (struct isl_map *)set2);
-}
-
-struct isl_set *isl_set_union(struct isl_set *set1, struct isl_set *set2)
+__isl_give isl_set *isl_set_union(__isl_take isl_set *set1,
+	__isl_take isl_set *set2)
 {
-	return (struct isl_set *)
-		isl_map_union((struct isl_map *)set1, (struct isl_map *)set2);
+	return set_from_map(isl_map_union(set_to_map(set1), set_to_map(set2)));
 }
 
 /* Apply "fn" to pairs of elements from "map" and "set" and collect
- * the results.
+ * the results in a map living in "space".
  *
  * "map" and "set" are assumed to be compatible and non-NULL.
  */
 static __isl_give isl_map *map_intersect_set(__isl_take isl_map *map,
-	__isl_take isl_set *set,
+	__isl_take isl_space *space, __isl_take isl_set *set,
 	__isl_give isl_basic_map *fn(__isl_take isl_basic_map *bmap,
 		__isl_take isl_basic_set *bset))
 {
@@ -7311,15 +8277,14 @@
 
 	if (isl_set_plain_is_universe(set)) {
 		isl_set_free(set);
-		return map;
+		return isl_map_reset_equal_dim_space(map, space);
 	}
 
 	if (ISL_F_ISSET(map, ISL_MAP_DISJOINT) &&
 	    ISL_F_ISSET(set, ISL_MAP_DISJOINT))
 		ISL_FL_SET(flags, ISL_MAP_DISJOINT);
 
-	result = isl_map_alloc_space(isl_space_copy(map->dim),
-					map->n * set->n, flags);
+	result = isl_map_alloc_space(space, map->n * set->n, flags);
 	for (i = 0; result && i < map->n; ++i)
 		for (j = 0; j < set->n; ++j) {
 			result = isl_map_add_basic_map(result,
@@ -7334,57 +8299,243 @@
 	return result;
 }
 
-static __isl_give isl_map *map_intersect_range(__isl_take isl_map *map,
+__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
 	__isl_take isl_set *set)
 {
-	if (!map || !set)
-		goto error;
+	isl_bool ok;
+	isl_space *space;
 
-	if (!isl_map_compatible_range(map, set))
+	isl_map_align_params_set(&map, &set);
+	ok = isl_map_compatible_range(map, set);
+	if (ok < 0)
+		goto error;
+	if (!ok)
 		isl_die(set->ctx, isl_error_invalid,
 			"incompatible spaces", goto error);
 
-	return map_intersect_set(map, set, &isl_basic_map_intersect_range);
+	space = isl_map_get_space(map);
+	return map_intersect_set(map, space, set,
+				&isl_basic_map_intersect_range);
 error:
 	isl_map_free(map);
 	isl_set_free(set);
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_intersect_range(__isl_take isl_map *map,
+/* Intersect the domain of "map" with "set".
+ *
+ * If the domain dimensions of "map" do not have any identifiers,
+ * then copy them over from "set".
+ */
+__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
 	__isl_take isl_set *set)
 {
-	return isl_map_align_params_map_map_and(map, set, &map_intersect_range);
-}
+	isl_bool ok;
+	isl_space *space;
 
-static __isl_give isl_map *map_intersect_domain(__isl_take isl_map *map,
-	__isl_take isl_set *set)
-{
-	if (!map || !set)
+	isl_map_align_params_set(&map, &set);
+	ok = isl_map_compatible_domain(map, set);
+	if (ok < 0)
 		goto error;
-
-	if (!isl_map_compatible_domain(map, set))
+	if (!ok)
 		isl_die(set->ctx, isl_error_invalid,
 			"incompatible spaces", goto error);
 
-	return map_intersect_set(map, set, &isl_basic_map_intersect_domain);
+	space = isl_map_get_space(map);
+	space = isl_space_copy_ids_if_unset(space, isl_dim_in,
+					isl_set_peek_space(set), isl_dim_set);
+	return map_intersect_set(map, space, set,
+				&isl_basic_map_intersect_domain);
 error:
 	isl_map_free(map);
 	isl_set_free(set);
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_intersect_domain(__isl_take isl_map *map,
-	__isl_take isl_set *set)
+#undef TYPE
+#define TYPE isl_map
+static
+#include "isl_copy_tuple_id_templ.c"
+
+/* Data structure that specifies how isl_map_intersect_factor
+ * should operate.
+ *
+ * "preserve_type" is the tuple where the factor differs from
+ * the input map and of which the identifiers needs
+ * to be preserved explicitly.
+ * "other_factor" is used to extract the space of the other factor
+ * from the space of the product ("map").
+ * "product" is used to combine the given factor and a universe map
+ * in the space returned by "other_factor" to produce a map
+ * that lives in the same space as the input map.
+ */
+struct isl_intersect_factor_control {
+	enum isl_dim_type preserve_type;
+	__isl_give isl_space *(*other_factor)(__isl_take isl_space *space);
+	__isl_give isl_map *(*product)(__isl_take isl_map *factor,
+		__isl_take isl_map *other);
+};
+
+/* Given a map "map" in some product space and a map "factor"
+ * living in some factor space, return the intersection.
+ *
+ * After aligning the parameters,
+ * the map "factor" is first extended to a map living in the same space
+ * as "map" and then a regular intersection is computed.
+ *
+ * Note that the extension is computed as a product, which is anonymous
+ * by default.  If "map" has an identifier on the corresponding tuple,
+ * then this identifier needs to be set on the product
+ * before the intersection is computed.
+ */
+static __isl_give isl_map *isl_map_intersect_factor(
+	__isl_take isl_map *map, __isl_take isl_map *factor,
+	struct isl_intersect_factor_control *control)
+{
+	isl_bool equal;
+	isl_space *space;
+	isl_map *other, *product;
+
+	equal = isl_map_has_equal_params(map, factor);
+	if (equal < 0)
+		goto error;
+	if (!equal) {
+		map = isl_map_align_params(map, isl_map_get_space(factor));
+		factor = isl_map_align_params(factor, isl_map_get_space(map));
+	}
+
+	space = isl_map_get_space(map);
+	other = isl_map_universe(control->other_factor(space));
+	product = control->product(factor, other);
+
+	space = isl_map_peek_space(map);
+	product = isl_map_copy_tuple_id(product, control->preserve_type,
+					space, control->preserve_type);
+	return map_intersect(map, product);
+error:
+	isl_map_free(map);
+	isl_map_free(factor);
+	return NULL;
+}
+
+/* Return the domain product of "map2" and "map1".
+ */
+static __isl_give isl_map *isl_map_reverse_domain_product(
+	__isl_take isl_map *map1, __isl_take isl_map *map2)
+{
+	return isl_map_domain_product(map2, map1);
+}
+
+/* Return the range product of "map2" and "map1".
+ */
+static __isl_give isl_map *isl_map_reverse_range_product(
+	__isl_take isl_map *map1, __isl_take isl_map *map2)
+{
+	return isl_map_range_product(map2, map1);
+}
+
+/* Given a map "map" in a space A -> B -> C and a map "factor"
+ * in the space A -> C, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_domain_factor_domain(
+	__isl_take isl_map *map, __isl_take isl_map *factor)
+{
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_in,
+		.other_factor = isl_space_domain_factor_range,
+		.product = isl_map_domain_product,
+	};
+
+	return isl_map_intersect_factor(map, factor, &control);
+}
+
+/* Given a map "map" in a space A -> B -> C and a map "factor"
+ * in the space B -> C, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_domain_factor_range(
+	__isl_take isl_map *map, __isl_take isl_map *factor)
 {
-	return isl_map_align_params_map_map_and(map, set,
-						&map_intersect_domain);
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_in,
+		.other_factor = isl_space_domain_factor_domain,
+		.product = isl_map_reverse_domain_product,
+	};
+
+	return isl_map_intersect_factor(map, factor, &control);
 }
 
-static __isl_give isl_map *map_apply_domain(__isl_take isl_map *map1,
+/* Given a map "map" in a space A -> B -> C and a map "factor"
+ * in the space A -> B, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_range_factor_domain(
+	__isl_take isl_map *map, __isl_take isl_map *factor)
+{
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_out,
+		.other_factor = isl_space_range_factor_range,
+		.product = isl_map_range_product,
+	};
+
+	return isl_map_intersect_factor(map, factor, &control);
+}
+
+/* Given a map "map" in a space A -> B -> C and a map "factor"
+ * in the space A -> C, return the intersection.
+ */
+__isl_give isl_map *isl_map_intersect_range_factor_range(
+	__isl_take isl_map *map, __isl_take isl_map *factor)
+{
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_out,
+		.other_factor = isl_space_range_factor_domain,
+		.product = isl_map_reverse_range_product,
+	};
+
+	return isl_map_intersect_factor(map, factor, &control);
+}
+
+/* Given a set "set" in a space A -> B and a set "domain"
+ * in the space A, return the intersection.
+ *
+ * The set "domain" is first extended to a set living in the space
+ * A -> B and then a regular intersection is computed.
+ */
+__isl_give isl_set *isl_set_intersect_factor_domain(__isl_take isl_set *set,
+	__isl_take isl_set *domain)
+{
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_set,
+		.other_factor = isl_space_factor_range,
+		.product = isl_map_range_product,
+	};
+
+	return set_from_map(isl_map_intersect_factor(set_to_map(set),
+						set_to_map(domain), &control));
+}
+
+/* Given a set "set" in a space A -> B and a set "range"
+ * in the space B, return the intersection.
+ *
+ * The set "range" is first extended to a set living in the space
+ * A -> B and then a regular intersection is computed.
+ */
+__isl_give isl_set *isl_set_intersect_factor_range(__isl_take isl_set *set,
+	__isl_take isl_set *range)
+{
+	struct isl_intersect_factor_control control = {
+		.preserve_type = isl_dim_set,
+		.other_factor = isl_space_factor_domain,
+		.product = isl_map_reverse_range_product,
+	};
+
+	return set_from_map(isl_map_intersect_factor(set_to_map(set),
+						set_to_map(range), &control));
+}
+
+__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
-	if (!map1 || !map2)
+	if (isl_map_align_params_bin(&map1, &map2) < 0)
 		goto error;
 	map1 = isl_map_reverse(map1);
 	map1 = isl_map_apply_range(map1, map2);
@@ -7395,26 +8546,20 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_apply_domain(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
-{
-	return isl_map_align_params_map_map_and(map1, map2, &map_apply_domain);
-}
-
-static __isl_give isl_map *map_apply_range(__isl_take isl_map *map1,
+__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
-	isl_space *dim_result;
+	isl_space *space;
 	struct isl_map *result;
 	int i, j;
 
-	if (!map1 || !map2)
+	if (isl_map_align_params_bin(&map1, &map2) < 0)
 		goto error;
 
-	dim_result = isl_space_join(isl_space_copy(map1->dim),
+	space = isl_space_join(isl_space_copy(map1->dim),
 				  isl_space_copy(map2->dim));
 
-	result = isl_map_alloc_space(dim_result, map1->n * map2->n, 0);
+	result = isl_map_alloc_space(space, map1->n * map2->n, 0);
 	if (!result)
 		goto error;
 	for (i = 0; i < map1->n; ++i)
@@ -7437,75 +8582,146 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_apply_range(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
+/* Is "bmap" a transformation, i.e.,
+ * does it relate elements from the same space.
+ */
+isl_bool isl_basic_map_is_transformation(__isl_keep isl_basic_map *bmap)
 {
-	return isl_map_align_params_map_map_and(map1, map2, &map_apply_range);
+	isl_space *space;
+
+	space = isl_basic_map_peek_space(bmap);
+	return isl_space_tuple_is_equal(space, isl_dim_in, space, isl_dim_out);
+}
+
+/* Check that "bmap" is a transformation, i.e.,
+ * that it relates elements from the same space.
+ */
+static isl_stat isl_basic_map_check_transformation(
+	__isl_keep isl_basic_map *bmap)
+{
+	isl_bool equal;
+
+	equal = isl_basic_map_is_transformation(bmap);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"domain and range don't match", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 /*
  * returns range - domain
  */
-struct isl_basic_set *isl_basic_map_deltas(struct isl_basic_map *bmap)
+__isl_give isl_basic_set *isl_basic_map_deltas(__isl_take isl_basic_map *bmap)
 {
-	isl_space *dims, *target_dim;
+	isl_space *target_space;
 	struct isl_basic_set *bset;
-	unsigned dim;
-	unsigned nparam;
+	isl_size dim;
+	isl_size nparam;
+	isl_size total;
 	int i;
 
-	if (!bmap)
+	if (isl_basic_map_check_transformation(bmap) < 0)
+		return isl_basic_map_free(bmap);
+	dim = isl_basic_map_dim(bmap, isl_dim_in);
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	if (dim < 0 || nparam < 0)
 		goto error;
-	isl_assert(bmap->ctx, isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
-						  bmap->dim, isl_dim_out),
-		   goto error);
-	target_dim = isl_space_domain(isl_basic_map_get_space(bmap));
-	dim = isl_basic_map_n_in(bmap);
-	nparam = isl_basic_map_n_param(bmap);
-	bset = isl_basic_set_from_basic_map(bmap);
-	bset = isl_basic_set_cow(bset);
-	dims = isl_basic_set_get_space(bset);
-	dims = isl_space_add_dims(dims, isl_dim_set, dim);
-	bset = isl_basic_set_extend_space(bset, dims, 0, dim, 0);
-	bset = isl_basic_set_swap_vars(bset, 2*dim);
+	target_space = isl_space_domain(isl_basic_map_get_space(bmap));
+	bmap = isl_basic_map_from_range(isl_basic_map_wrap(bmap));
+	bmap = isl_basic_map_add_dims(bmap, isl_dim_in, dim);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		bmap = isl_basic_map_free(bmap);
+	bmap = isl_basic_map_extend_constraints(bmap, dim, 0);
 	for (i = 0; i < dim; ++i) {
-		int j = isl_basic_map_alloc_equality(
-					    (struct isl_basic_map *)bset);
+		int j = isl_basic_map_alloc_equality(bmap);
 		if (j < 0) {
-			bset = isl_basic_set_free(bset);
+			bmap = isl_basic_map_free(bmap);
 			break;
 		}
-		isl_seq_clr(bset->eqj, 1 + isl_basic_set_total_dim(bset));
-		isl_int_set_si(bset->eqj1+nparam+i, 1);
-		isl_int_set_si(bset->eqj1+nparam+dim+i, 1);
-		isl_int_set_si(bset->eqj1+nparam+2*dim+i, -1);
+		isl_seq_clr(bmap->eqj, 1 + total);
+		isl_int_set_si(bmap->eqj1+nparam+i, 1);
+		isl_int_set_si(bmap->eqj1+nparam+dim+i, 1);
+		isl_int_set_si(bmap->eqj1+nparam+2*dim+i, -1);
 	}
-	bset = isl_basic_set_project_out(bset, isl_dim_set, dim, 2*dim);
-	bset = isl_basic_set_reset_space(bset, target_dim);
+	bset = isl_basic_map_domain(bmap);
+	bset = isl_basic_set_reset_space(bset, target_space);
 	return bset;
 error:
 	isl_basic_map_free(bmap);
 	return NULL;
 }
 
+/* Is the tuple of type "type1" of "map" the same as
+ * the tuple of type "type2" of "space"?
+ */
+isl_bool isl_map_space_tuple_is_equal(__isl_keep isl_map *map,
+	enum isl_dim_type type1, __isl_keep isl_space *space,
+	enum isl_dim_type type2)
+{
+	isl_space *map_space;
+
+	map_space = isl_map_peek_space(map);
+	return isl_space_tuple_is_equal(map_space, type1, space, type2);
+}
+
+/* Is the tuple of type "type1" of "map1" the same as
+ * the tuple of type "type2" of "map2"?
+ */
+isl_bool isl_map_tuple_is_equal(__isl_keep isl_map *map1,
+	enum isl_dim_type type1, __isl_keep isl_map *map2,
+	enum isl_dim_type type2)
+{
+	isl_space *space1, *space2;
+
+	space1 = isl_map_peek_space(map1);
+	space2 = isl_map_peek_space(map2);
+	return isl_space_tuple_is_equal(space1, type1, space2, type2);
+}
+
+/* Is the space of "obj" equal to "space", ignoring parameters?
+ */
+isl_bool isl_map_has_space_tuples(__isl_keep isl_map *map,
+	__isl_keep isl_space *space)
+{
+	isl_space *map_space;
+
+	map_space = isl_map_peek_space(map);
+	return isl_space_has_equal_tuples(map_space, space);
+}
+
+/* Check that "map" is a transformation, i.e.,
+ * that it relates elements from the same space.
+ */
+isl_stat isl_map_check_transformation(__isl_keep isl_map *map)
+{
+	isl_bool equal;
+
+	equal = isl_map_tuple_is_equal(map, isl_dim_in, map, isl_dim_out);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"domain and range don't match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
 /*
  * returns range - domain
  */
 __isl_give isl_set *isl_map_deltas(__isl_take isl_map *map)
 {
 	int i;
-	isl_space *dim;
+	isl_space *space;
 	struct isl_set *result;
 
-	if (!map)
-		return NULL;
-
-	isl_assert(map->ctx, isl_space_tuple_is_equal(map->dim, isl_dim_in,
-						 map->dim, isl_dim_out),
-		   goto error);
-	dim = isl_map_get_space(map);
-	dim = isl_space_domain(dim);
-	result = isl_set_alloc_space(dim, map->n, 0);
+	if (isl_map_check_transformation(map) < 0)
+		goto error;
+	space = isl_map_get_space(map);
+	space = isl_space_domain(space);
+	result = isl_set_alloc_space(space, map->n, 0);
 	if (!result)
 		goto error;
 	for (i = 0; i < map->n; ++i)
@@ -7525,27 +8741,30 @@
 	__isl_take isl_basic_map *bmap)
 {
 	int i, k;
-	isl_space *dim;
+	isl_space *space;
 	isl_basic_map *domain;
-	int nparam, n;
-	unsigned total;
+	isl_size nparam, n;
+	isl_size total;
 
-	if (!isl_space_tuple_is_equal(bmap->dim, isl_dim_in,
-					bmap->dim, isl_dim_out))
-		isl_die(bmap->ctx, isl_error_invalid,
-			"domain and range don't match", goto error);
+	if (isl_basic_map_check_transformation(bmap) < 0)
+		return isl_basic_map_free(bmap);
 
 	nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	n = isl_basic_map_dim(bmap, isl_dim_in);
+	if (nparam < 0 || n < 0)
+		return isl_basic_map_free(bmap);
 
-	dim = isl_space_from_range(isl_space_domain(isl_basic_map_get_space(bmap)));
-	domain = isl_basic_map_universe(dim);
+	space = isl_basic_map_get_space(bmap);
+	space = isl_space_from_range(isl_space_domain(space));
+	domain = isl_basic_map_universe(space);
 
 	bmap = isl_basic_map_from_domain(isl_basic_map_wrap(bmap));
 	bmap = isl_basic_map_apply_range(bmap, domain);
 	bmap = isl_basic_map_extend_constraints(bmap, n, 0);
 
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
 	for (i = 0; i < n; ++i) {
 		k = isl_basic_map_alloc_equality(bmap);
@@ -7569,113 +8788,55 @@
  */
 __isl_give isl_map *isl_map_deltas_map(__isl_take isl_map *map)
 {
-	int i;
-	isl_space *domain_dim;
-
-	if (!map)
-		return NULL;
-
-	if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
-					map->dim, isl_dim_out))
-		isl_die(map->ctx, isl_error_invalid,
-			"domain and range don't match", goto error);
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
+	if (isl_map_check_transformation(map) < 0)
+		return isl_map_free(map);
 
-	domain_dim = isl_space_from_range(isl_space_domain(isl_map_get_space(map)));
-	map->dim = isl_space_from_domain(isl_space_wrap(map->dim));
-	map->dim = isl_space_join(map->dim, domain_dim);
-	if (!map->dim)
-		goto error;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_deltas_map(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return isl_map_transform(map, &isl_space_range_map,
+					&isl_basic_map_deltas_map);
 }
 
-static __isl_give isl_basic_map *basic_map_identity(__isl_take isl_space *dims)
+/* Return pairs of elements { x -> y } such that y - x is in "deltas".
+ */
+__isl_give isl_map *isl_set_translation(__isl_take isl_set *deltas)
 {
-	struct isl_basic_map *bmap;
-	unsigned nparam;
-	unsigned dim;
-	int i;
-
-	if (!dims)
-		return NULL;
+	isl_space *space;
+	isl_map *map;
 
-	nparam = dims->nparam;
-	dim = dims->n_out;
-	bmap = isl_basic_map_alloc_space(dims, 0, dim, 0);
-	if (!bmap)
-		goto error;
+	space = isl_space_map_from_set(isl_set_get_space(deltas));
+	map = isl_map_deltas_map(isl_map_universe(space));
+	map = isl_map_intersect_range(map, deltas);
 
-	for (i = 0; i < dim; ++i) {
-		int j = isl_basic_map_alloc_equality(bmap);
-		if (j < 0)
-			goto error;
-		isl_seq_clr(bmap->eqj, 1 + isl_basic_map_total_dim(bmap));
-		isl_int_set_si(bmap->eqj1+nparam+i, 1);
-		isl_int_set_si(bmap->eqj1+nparam+dim+i, -1);
-	}
-	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
+	return isl_set_unwrap(isl_map_domain(map));
 }
 
-__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *dim)
+__isl_give isl_basic_map *isl_basic_map_identity(__isl_take isl_space *space)
 {
-	if (!dim)
-		return NULL;
-	if (dim->n_in != dim->n_out)
-		isl_die(dim->ctx, isl_error_invalid,
+	isl_size n_in, n_out;
+
+	n_in = isl_space_dim(space, isl_dim_in);
+	n_out = isl_space_dim(space, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		goto error;
+	if (n_in != n_out)
+		isl_die(space->ctx, isl_error_invalid,
 			"number of input and output dimensions needs to be "
 			"the same", goto error);
-	return basic_map_identity(dim);
+	return isl_basic_map_equal(space, n_in);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_identity_like(struct isl_basic_map *model)
+__isl_give isl_map *isl_map_identity(__isl_take isl_space *space)
 {
-	if (!model || !model->dim)
-		return NULL;
-	return isl_basic_map_identity(isl_space_copy(model->dim));
-}
-
-__isl_give isl_map *isl_map_identity(__isl_take isl_space *dim)
-{
-	return isl_map_from_basic_map(isl_basic_map_identity(dim));
-}
-
-struct isl_map *isl_map_identity_like(struct isl_map *model)
-{
-	if (!model || !model->dim)
-		return NULL;
-	return isl_map_identity(isl_space_copy(model->dim));
-}
-
-struct isl_map *isl_map_identity_like_basic_map(struct isl_basic_map *model)
-{
-	if (!model || !model->dim)
-		return NULL;
-	return isl_map_identity(isl_space_copy(model->dim));
+	return isl_map_from_basic_map(isl_basic_map_identity(space));
 }
 
 __isl_give isl_map *isl_set_identity(__isl_take isl_set *set)
 {
-	isl_space *dim = isl_set_get_space(set);
+	isl_space *space = isl_set_get_space(set);
 	isl_map *id;
-	id = isl_map_identity(isl_space_map_from_set(dim));
+	id = isl_map_identity(isl_space_map_from_set(space));
 	return isl_map_intersect_range(id, set);
 }
 
@@ -7686,14 +8847,16 @@
 	__isl_take isl_space *space)
 {
 	int i;
-	unsigned nparam;
-	unsigned dim;
+	isl_size nparam;
+	isl_size dim;
+	isl_size total;
 	struct isl_basic_set *bset;
 
-	if (!space)
-		return NULL;
-	nparam = space->nparam;
-	dim = space->n_out;
+	nparam = isl_space_dim(space, isl_dim_param);
+	dim = isl_space_dim(space, isl_dim_set);
+	total = isl_space_dim(space, isl_dim_all);
+	if (nparam < 0 || dim < 0 || total < 0)
+		space = isl_space_free(space);
 	bset = isl_basic_set_alloc_space(space, 0, 0, dim);
 	if (!bset)
 		return NULL;
@@ -7701,7 +8864,7 @@
 		int k = isl_basic_set_alloc_inequality(bset);
 		if (k < 0)
 			goto error;
-		isl_seq_clr(bset->ineqk, 1 + isl_basic_set_total_dim(bset));
+		isl_seq_clr(bset->ineqk, 1 + total);
 		isl_int_set_si(bset->ineqk1 + nparam + i, 1);
 	}
 	return bset;
@@ -7712,17 +8875,21 @@
 
 /* Construct the half-space x_pos >= 0.
  */
-static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_space *dim,
+static __isl_give isl_basic_set *nonneg_halfspace(__isl_take isl_space *space,
 	int pos)
 {
 	int k;
+	isl_size total;
 	isl_basic_set *nonneg;
 
-	nonneg = isl_basic_set_alloc_space(dim, 0, 0, 1);
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0)
+		space = isl_space_free(space);
+	nonneg = isl_basic_set_alloc_space(space, 0, 0, 1);
 	k = isl_basic_set_alloc_inequality(nonneg);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(nonneg->ineqk, 1 + isl_basic_set_total_dim(nonneg));
+	isl_seq_clr(nonneg->ineqk, 1 + total);
 	isl_int_set_si(nonneg->ineqkpos, 1);
 
 	return isl_basic_set_finalize(nonneg);
@@ -7733,16 +8900,21 @@
 
 /* Construct the half-space x_pos <= -1.
  */
-static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_space *dim, int pos)
+static __isl_give isl_basic_set *neg_halfspace(__isl_take isl_space *space,
+	int pos)
 {
 	int k;
+	isl_size total;
 	isl_basic_set *neg;
 
-	neg = isl_basic_set_alloc_space(dim, 0, 0, 1);
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0)
+		space = isl_space_free(space);
+	neg = isl_basic_set_alloc_space(space, 0, 0, 1);
 	k = isl_basic_set_alloc_inequality(neg);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(neg->ineqk, 1 + isl_basic_set_total_dim(neg));
+	isl_seq_clr(neg->ineqk, 1 + total);
 	isl_int_set_si(neg->ineqk0, -1);
 	isl_int_set_si(neg->ineqkpos, -1);
 
@@ -7756,42 +8928,40 @@
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
+	unsigned offset;
 	isl_basic_set *nonneg;
 	isl_basic_set *neg;
 
-	if (!set)
-		return NULL;
 	if (n == 0)
 		return set;
 
-	isl_assert(set->ctx, first + n <= isl_set_dim(set, type), goto error);
+	if (isl_set_check_range(set, type, first, n) < 0)
+		return isl_set_free(set);
 
+	offset = pos(set->dim, type);
 	for (i = 0; i < n; ++i) {
 		nonneg = nonneg_halfspace(isl_set_get_space(set),
-					  pos(set->dim, type) + first + i);
-		neg = neg_halfspace(isl_set_get_space(set),
-					  pos(set->dim, type) + first + i);
+					  offset + first + i);
+		neg = neg_halfspace(isl_set_get_space(set), offset + first + i);
 
 		set = isl_set_intersect(set, isl_basic_set_union(nonneg, neg));
 	}
 
 	return set;
-error:
-	isl_set_free(set);
-	return NULL;
 }
 
-static int foreach_orthant(__isl_take isl_set *set, int *signs, int first,
-	int len, int (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
+static isl_stat foreach_orthant(__isl_take isl_set *set, int *signs, int first,
+	int len,
+	isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
 	void *user)
 {
 	isl_set *half;
 
 	if (!set)
-		return -1;
+		return isl_stat_error;
 	if (isl_set_plain_is_empty(set)) {
 		isl_set_free(set);
-		return 0;
+		return isl_stat_ok;
 	}
 	if (first == len)
 		return fn(set, signs, user);
@@ -7810,7 +8980,7 @@
 	return foreach_orthant(half, signs, first + 1, len, fn, user);
 error:
 	isl_set_free(set);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Call "fn" on the intersections of "set" with each of the orthants
@@ -7818,22 +8988,24 @@
  * by the signs array, with each entry having value 1 or -1 according
  * to the sign of the corresponding variable.
  */
-int isl_set_foreach_orthant(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
+isl_stat isl_set_foreach_orthant(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
 	void *user)
 {
-	unsigned nparam;
-	unsigned nvar;
+	isl_size nparam;
+	isl_size nvar;
 	int *signs;
-	int r;
+	isl_stat r;
 
 	if (!set)
-		return -1;
+		return isl_stat_error;
 	if (isl_set_plain_is_empty(set))
-		return 0;
+		return isl_stat_ok;
 
 	nparam = isl_set_dim(set, isl_dim_param);
 	nvar = isl_set_dim(set, isl_dim_set);
+	if (nparam < 0 || nvar < 0)
+		return isl_stat_error;
 
 	signs = isl_alloc_array(set->ctx, int, nparam + nvar);
 
@@ -7845,20 +9017,20 @@
 	return r;
 }
 
-int isl_set_is_equal(struct isl_set *set1, struct isl_set *set2)
+isl_bool isl_set_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
 {
-	return isl_map_is_equal((struct isl_map *)set1, (struct isl_map *)set2);
+	return isl_map_is_equal(set_to_map(set1), set_to_map(set2));
 }
 
-int isl_basic_map_is_subset(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+isl_bool isl_basic_map_is_subset(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
 {
-	int is_subset;
+	isl_bool is_subset;
 	struct isl_map *map1;
 	struct isl_map *map2;
 
 	if (!bmap1 || !bmap2)
-		return -1;
+		return isl_bool_error;
 
 	map1 = isl_map_from_basic_map(isl_basic_map_copy(bmap1));
 	map2 = isl_map_from_basic_map(isl_basic_map_copy(bmap2));
@@ -7871,200 +9043,290 @@
 	return is_subset;
 }
 
-int isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_is_subset(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2)
 {
 	return isl_basic_map_is_subset(bset1, bset2);
 }
 
-int isl_basic_map_is_equal(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+isl_bool isl_basic_map_is_equal(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!bmap1 || !bmap2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_basic_map_is_subset(bmap1, bmap2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_basic_map_is_subset(bmap2, bmap1);
 	return is_subset;
 }
 
-int isl_basic_set_is_equal(
-		struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+isl_bool isl_basic_set_is_equal(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2)
 {
 	return isl_basic_map_is_equal(
-		(struct isl_basic_map *)bset1, (struct isl_basic_map *)bset2);
+		bset_to_bmap(bset1), bset_to_bmap(bset2));
 }
 
-int isl_map_is_empty(struct isl_map *map)
+isl_bool isl_map_is_empty(__isl_keep isl_map *map)
 {
 	int i;
 	int is_empty;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	for (i = 0; i < map->n; ++i) {
 		is_empty = isl_basic_map_is_empty(map->pi);
 		if (is_empty < 0)
-			return -1;
+			return isl_bool_error;
 		if (!is_empty)
-			return 0;
+			return isl_bool_false;
 	}
-	return 1;
+	return isl_bool_true;
 }
 
-int isl_map_plain_is_empty(__isl_keep isl_map *map)
+isl_bool isl_map_plain_is_empty(__isl_keep isl_map *map)
 {
-	return map ? map->n == 0 : -1;
+	return map ? map->n == 0 : isl_bool_error;
 }
 
-int isl_map_fast_is_empty(__isl_keep isl_map *map)
+isl_bool isl_set_plain_is_empty(__isl_keep isl_set *set)
 {
-	return isl_map_plain_is_empty(map);
+	return set ? set->n == 0 : isl_bool_error;
 }
 
-int isl_set_plain_is_empty(struct isl_set *set)
+isl_bool isl_set_is_empty(__isl_keep isl_set *set)
 {
-	return set ? set->n == 0 : -1;
+	return isl_map_is_empty(set_to_map(set));
 }
 
-int isl_set_fast_is_empty(__isl_keep isl_set *set)
+#undef TYPE
+#define TYPE	isl_basic_map
+
+static
+#include "isl_type_has_equal_space_bin_templ.c"
+#include "isl_type_check_equal_space_templ.c"
+
+/* Check that "bset1" and "bset2" live in the same space,
+ * reporting an error if they do not.
+ */
+isl_stat isl_basic_set_check_equal_space(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2)
 {
-	return isl_set_plain_is_empty(set);
+	return isl_basic_map_check_equal_space(bset_to_bmap(bset1),
+						bset_to_bmap(bset1));
 }
 
-int isl_set_is_empty(struct isl_set *set)
+#undef TYPE
+#define TYPE	isl_map
+
+#include "isl_type_has_equal_space_bin_templ.c"
+#include "isl_type_check_equal_space_templ.c"
+#include "isl_type_has_space_templ.c"
+
+isl_bool isl_set_has_equal_space(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2)
 {
-	return isl_map_is_empty((struct isl_map *)set);
+	return isl_map_has_equal_space(set_to_map(set1), set_to_map(set2));
 }
 
-int isl_map_has_equal_space(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
-{
-	if (!map1 || !map2)
-		return -1;
+#undef TYPE1
+#define TYPE1		isl_map
+#undef TYPE2
+#define TYPE2		isl_basic_map
+#undef TYPE_PAIR
+#define TYPE_PAIR	isl_map_basic_map
 
-	return isl_space_is_equal(map1->dim, map2->dim);
-}
+static
+#include "isl_type_has_equal_space_templ.c"
+#include "isl_type_check_equal_space_templ.c"
 
-int isl_set_has_equal_space(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+/* Check that "set" and "bset" live in the same space,
+ * reporting an error if they do not.
+ */
+isl_stat isl_set_basic_set_check_equal_space(__isl_keep isl_set *set,
+	__isl_keep isl_basic_set *bset)
 {
-	if (!set1 || !set2)
-		return -1;
-
-	return isl_space_is_equal(set1->dim, set2->dim);
+	return isl_map_basic_map_check_equal_space(set_to_map(set),
+						    bset_to_bmap(bset));
 }
 
-static int map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+static isl_bool map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_map_is_subset(map1, map2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_map_is_subset(map2, map1);
 	return is_subset;
 }
 
-int isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+/* Is "map1" equal to "map2"?
+ *
+ * First check if they are obviously equal.
+ * If not, then perform a more detailed analysis.
+ */
+isl_bool isl_map_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
 {
+	isl_bool equal;
+
+	equal = isl_map_plain_is_equal(map1, map2);
+	if (equal < 0 || equal)
+		return equal;
 	return isl_map_align_params_map_map_and_test(map1, map2, &map_is_equal);
 }
 
-int isl_basic_map_is_strict_subset(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+isl_bool isl_basic_map_is_strict_subset(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!bmap1 || !bmap2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_basic_map_is_subset(bmap1, bmap2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_basic_map_is_subset(bmap2, bmap1);
-	if (is_subset == -1)
-		return is_subset;
-	return !is_subset;
+	return isl_bool_not(is_subset);
 }
 
-int isl_map_is_strict_subset(struct isl_map *map1, struct isl_map *map2)
+isl_bool isl_map_is_strict_subset(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_map_is_subset(map1, map2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_map_is_subset(map2, map1);
-	if (is_subset == -1)
-		return is_subset;
-	return !is_subset;
+	return isl_bool_not(is_subset);
 }
 
-int isl_set_is_strict_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+isl_bool isl_set_is_strict_subset(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2)
 {
-	return isl_map_is_strict_subset((isl_map *)set1, (isl_map *)set2);
+	return isl_map_is_strict_subset(set_to_map(set1), set_to_map(set2));
 }
 
-int isl_basic_map_is_universe(struct isl_basic_map *bmap)
+/* Is "bmap" obviously equal to the universe with the same space?
+ *
+ * That is, does it not have any constraints?
+ */
+isl_bool isl_basic_map_plain_is_universe(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	return bmap->n_eq == 0 && bmap->n_ineq == 0;
 }
 
-int isl_basic_set_is_universe(struct isl_basic_set *bset)
+/* Is "bset" obviously equal to the universe with the same space?
+ */
+isl_bool isl_basic_set_plain_is_universe(__isl_keep isl_basic_set *bset)
 {
-	if (!bset)
-		return -1;
-	return bset->n_eq == 0 && bset->n_ineq == 0;
+	return isl_basic_map_plain_is_universe(bset);
 }
 
-int isl_map_plain_is_universe(__isl_keep isl_map *map)
+/* If "c" does not involve any existentially quantified variables,
+ * then set *univ to false and abort
+ */
+static isl_stat involves_divs(__isl_take isl_constraint *c, void *user)
+{
+	isl_bool *univ = user;
+	isl_size n;
+
+	n = isl_constraint_dim(c, isl_dim_div);
+	if (n < 0)
+		c = isl_constraint_free(c);
+	*univ = isl_constraint_involves_dims(c, isl_dim_div, 0, n);
+	isl_constraint_free(c);
+	if (*univ < 0 || !*univ)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Is "bmap" equal to the universe with the same space?
+ *
+ * First check if it is obviously equal to the universe.
+ * If not and if there are any constraints not involving
+ * existentially quantified variables, then it is certainly
+ * not equal to the universe.
+ * Otherwise, check if the universe is a subset of "bmap".
+ */
+isl_bool isl_basic_map_is_universe(__isl_keep isl_basic_map *bmap)
+{
+	isl_size n_div;
+	isl_bool univ;
+	isl_basic_map *test;
+
+	univ = isl_basic_map_plain_is_universe(bmap);
+	if (univ < 0 || univ)
+		return univ;
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
+	if (n_div == 0)
+		return isl_bool_false;
+	univ = isl_bool_true;
+	if (isl_basic_map_foreach_constraint(bmap, &involves_divs, &univ) < 0 &&
+	    univ)
+		return isl_bool_error;
+	if (univ < 0 || !univ)
+		return univ;
+	test = isl_basic_map_universe(isl_basic_map_get_space(bmap));
+	univ = isl_basic_map_is_subset(test, bmap);
+	isl_basic_map_free(test);
+	return univ;
+}
+
+/* Is "bset" equal to the universe with the same space?
+ */
+isl_bool isl_basic_set_is_universe(__isl_keep isl_basic_set *bset)
+{
+	return isl_basic_map_is_universe(bset);
+}
+
+isl_bool isl_map_plain_is_universe(__isl_keep isl_map *map)
 {
 	int i;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
-		int r = isl_basic_map_is_universe(map->pi);
+		isl_bool r = isl_basic_map_plain_is_universe(map->pi);
 		if (r < 0 || r)
 			return r;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
-int isl_set_plain_is_universe(__isl_keep isl_set *set)
+isl_bool isl_set_plain_is_universe(__isl_keep isl_set *set)
 {
-	return isl_map_plain_is_universe((isl_map *) set);
+	return isl_map_plain_is_universe(set_to_map(set));
 }
 
-int isl_set_fast_is_universe(__isl_keep isl_set *set)
-{
-	return isl_set_plain_is_universe(set);
-}
-
-int isl_basic_map_is_empty(struct isl_basic_map *bmap)
+isl_bool isl_basic_map_is_empty(__isl_keep isl_basic_map *bmap)
 {
 	struct isl_basic_set *bset = NULL;
 	struct isl_vec *sample = NULL;
-	int empty;
-	unsigned total;
+	isl_bool empty, non_empty;
 
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
-		return 1;
+		return isl_bool_true;
 
-	if (isl_basic_map_is_universe(bmap))
-		return 0;
+	if (isl_basic_map_plain_is_universe(bmap))
+		return isl_bool_false;
 
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
 		struct isl_basic_map *copy = isl_basic_map_copy(bmap);
@@ -8074,22 +9336,19 @@
 		return empty;
 	}
 
-	total = 1 + isl_basic_map_total_dim(bmap);
-	if (bmap->sample && bmap->sample->size == total) {
-		int contains = isl_basic_map_contains(bmap, bmap->sample);
-		if (contains < 0)
-			return -1;
-		if (contains)
-			return 0;
-	}
+	non_empty = isl_basic_map_plain_is_non_empty(bmap);
+	if (non_empty < 0)
+		return isl_bool_error;
+	if (non_empty)
+		return isl_bool_false;
 	isl_vec_free(bmap->sample);
 	bmap->sample = NULL;
 	bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
 	if (!bset)
-		return -1;
+		return isl_bool_error;
 	sample = isl_basic_set_sample_vec(bset);
 	if (!sample)
-		return -1;
+		return isl_bool_error;
 	empty = sample->size == 0;
 	isl_vec_free(bmap->sample);
 	bmap->sample = sample;
@@ -8099,43 +9358,52 @@
 	return empty;
 }
 
-int isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_plain_is_empty(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	return ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY);
 }
 
-int isl_basic_map_fast_is_empty(__isl_keep isl_basic_map *bmap)
-{
-	return isl_basic_map_plain_is_empty(bmap);
-}
-
-int isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset)
+isl_bool isl_basic_set_plain_is_empty(__isl_keep isl_basic_set *bset)
 {
 	if (!bset)
-		return -1;
+		return isl_bool_error;
 	return ISL_F_ISSET(bset, ISL_BASIC_SET_EMPTY);
 }
 
-int isl_basic_set_fast_is_empty(__isl_keep isl_basic_set *bset)
+/* Is "bmap" known to be non-empty?
+ *
+ * That is, is the cached sample still valid?
+ */
+isl_bool isl_basic_map_plain_is_non_empty(__isl_keep isl_basic_map *bmap)
 {
-	return isl_basic_set_plain_is_empty(bset);
+	isl_size total;
+
+	if (!bmap)
+		return isl_bool_error;
+	if (!bmap->sample)
+		return isl_bool_false;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	if (bmap->sample->size != 1 + total)
+		return isl_bool_false;
+	return isl_basic_map_contains(bmap, bmap->sample);
 }
 
-int isl_basic_set_is_empty(struct isl_basic_set *bset)
+isl_bool isl_basic_set_is_empty(__isl_keep isl_basic_set *bset)
 {
-	return isl_basic_map_is_empty((struct isl_basic_map *)bset);
+	return isl_basic_map_is_empty(bset_to_bmap(bset));
 }
 
-struct isl_map *isl_basic_map_union(
-	struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+__isl_give isl_map *isl_basic_map_union(__isl_take isl_basic_map *bmap1,
+	__isl_take isl_basic_map *bmap2)
 {
 	struct isl_map *map;
-	if (!bmap1 || !bmap2)
-		goto error;
 
-	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim), goto error);
+	if (isl_basic_map_check_equal_space(bmap1, bmap2) < 0)
+		goto error;
 
 	map = isl_map_alloc_space(isl_space_copy(bmap1->dim), 2, 0);
 	if (!map)
@@ -8149,24 +9417,23 @@
 	return NULL;
 }
 
-struct isl_set *isl_basic_set_union(
-		struct isl_basic_set *bset1, struct isl_basic_set *bset2)
+__isl_give isl_set *isl_basic_set_union(__isl_take isl_basic_set *bset1,
+	__isl_take isl_basic_set *bset2)
 {
-	return (struct isl_set *)isl_basic_map_union(
-					    (struct isl_basic_map *)bset1,
-					    (struct isl_basic_map *)bset2);
+	return set_from_map(isl_basic_map_union(bset_to_bmap(bset1),
+						bset_to_bmap(bset2)));
 }
 
 /* Order divs such that any div only depends on previous divs */
-struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_order_divs(
+	__isl_take isl_basic_map *bmap)
 {
 	int i;
-	unsigned off;
-
-	if (!bmap)
-		return NULL;
+	isl_size off;
 
-	off = isl_space_dim(bmap->dim, isl_dim_all);
+	off = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (off < 0)
+		return isl_basic_map_free(bmap);
 
 	for (i = 0; i < bmap->n_div; ++i) {
 		int pos;
@@ -8176,18 +9443,18 @@
 							    bmap->n_div-i);
 		if (pos == -1)
 			continue;
-		isl_basic_map_swap_div(bmap, i, i + pos);
+		if (pos == 0)
+			isl_die(isl_basic_map_get_ctx(bmap), isl_error_internal,
+				"integer division depends on itself",
+				return isl_basic_map_free(bmap));
+		bmap = isl_basic_map_swap_div(bmap, i, i + pos);
+		if (!bmap)
+			return NULL;
 		--i;
 	}
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_order_divs((struct isl_basic_map *)bset);
-}
-
 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map)
 {
 	int i;
@@ -8207,79 +9474,125 @@
 	return NULL;
 }
 
+/* Sort the local variables of "bset".
+ */
+__isl_give isl_basic_set *isl_basic_set_sort_divs(
+	__isl_take isl_basic_set *bset)
+{
+	return bset_from_bmap(isl_basic_map_sort_divs(bset_to_bmap(bset)));
+}
+
 /* Apply the expansion computed by isl_merge_divs.
  * The expansion itself is given by "exp" while the resulting
  * list of divs is given by "div".
+ *
+ * Move the integer divisions of "bmap" into the right position
+ * according to "exp" and then introduce the additional integer
+ * divisions, adding div constraints.
+ * The moving should be done first to avoid moving coefficients
+ * in the definitions of the extra integer divisions.
  */
-__isl_give isl_basic_set *isl_basic_set_expand_divs(
-	__isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp)
+__isl_give isl_basic_map *isl_basic_map_expand_divs(
+	__isl_take isl_basic_map *bmap, __isl_take isl_mat *div, int *exp)
 {
 	int i, j;
 	int n_div;
 
-	bset = isl_basic_set_cow(bset);
-	if (!bset || !div)
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap || !div)
 		goto error;
 
-	if (div->n_row < bset->n_div)
+	if (div->n_row < bmap->n_div)
 		isl_die(isl_mat_get_ctx(div), isl_error_invalid,
 			"not an expansion", goto error);
 
-	n_div = bset->n_div;
-	bset = isl_basic_map_extend_space(bset, isl_space_copy(bset->dim),
-					    div->n_row - n_div, 0,
+	n_div = bmap->n_div;
+	bmap = isl_basic_map_extend(bmap, div->n_row - n_div, 0,
 					    2 * (div->n_row - n_div));
 
 	for (i = n_div; i < div->n_row; ++i)
-		if (isl_basic_set_alloc_div(bset) < 0)
+		if (isl_basic_map_alloc_div(bmap) < 0)
 			goto error;
 
-	j = n_div - 1;
-	for (i = div->n_row - 1; i >= 0; --i) {
-		if (j >= 0 && expj == i) {
-			if (i != j)
-				isl_basic_map_swap_div(bset, i, j);
-			j--;
+	for (j = n_div - 1; j >= 0; --j) {
+		if (expj == j)
+			break;
+		bmap = isl_basic_map_swap_div(bmap, j, expj);
+		if (!bmap)
+			goto error;
+	}
+	j = 0;
+	for (i = 0; i < div->n_row; ++i) {
+		if (j < n_div && expj == i) {
+			j++;
 		} else {
-			isl_seq_cpy(bset->divi, div->rowi, div->n_col);
-			if (isl_basic_map_add_div_constraints(bset, i) < 0)
+			isl_seq_cpy(bmap->divi, div->rowi, div->n_col);
+			if (isl_basic_map_div_is_marked_unknown(bmap, i))
+				continue;
+			bmap = isl_basic_map_add_div_constraints(bmap, i);
+			if (!bmap)
 				goto error;
 		}
 	}
 
 	isl_mat_free(div);
-	return bset;
+	return bmap;
 error:
-	isl_basic_set_free(bset);
+	isl_basic_map_free(bmap);
 	isl_mat_free(div);
 	return NULL;
 }
 
+/* Apply the expansion computed by isl_merge_divs.
+ * The expansion itself is given by "exp" while the resulting
+ * list of divs is given by "div".
+ */
+__isl_give isl_basic_set *isl_basic_set_expand_divs(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp)
+{
+	return isl_basic_map_expand_divs(bset, div, exp);
+}
+
 /* Look for a div in dst that corresponds to the div "div" in src.
  * The divs before "div" in src and dst are assumed to be the same.
  * 
- * Returns -1 if no corresponding div was found and the position
- * of the corresponding div in dst otherwise.
+ * Return the position of the corresponding div in dst
+ * if there is one.  Otherwise, return a position beyond the integer divisions.
+ * Return -1 on error.
  */
-static int find_div(struct isl_basic_map *dst,
-			struct isl_basic_map *src, unsigned div)
+static int find_div(__isl_keep isl_basic_map *dst,
+	__isl_keep isl_basic_map *src, unsigned div)
 {
 	int i;
+	isl_size n_div;
+	isl_size v_div;
 
-	unsigned total = isl_space_dim(src->dim, isl_dim_all);
-
-	isl_assert(dst->ctx, div <= dst->n_div, return -1);
-	for (i = div; i < dst->n_div; ++i)
-		if (isl_seq_eq(dst->divi, src->divdiv, 1+1+total+div) &&
-		    isl_seq_first_non_zero(dst->divi+1+1+total+div,
-						dst->n_div - div) == -1)
+	v_div = isl_basic_map_var_offset(src, isl_dim_div);
+	n_div = isl_basic_map_dim(dst, isl_dim_div);
+	if (n_div < 0 || v_div < 0)
+		return -1;
+	isl_assert(dst->ctx, div <= n_div, return -1);
+	for (i = div; i < n_div; ++i)
+		if (isl_seq_eq(dst->divi, src->divdiv, 1+1+v_div+div) &&
+		    isl_seq_first_non_zero(dst->divi + 1 + 1 + v_div + div,
+						n_div - div) == -1)
 			return i;
-	return -1;
+	return n_div;
 }
 
 /* Align the divs of "dst" to those of "src", adding divs from "src"
  * if needed.  That is, make sure that the first src->n_div divs
  * of the result are equal to those of src.
+ * The integer division of "src" are assumed to be ordered.
+ *
+ * The integer divisions are swapped into the right position
+ * (possibly after adding them first).  This may result
+ * in the remaining integer divisions appearing in the wrong order,
+ * i.e., with some integer division appearing before
+ * some other integer division on which it depends.
+ * The integer divisions therefore need to be ordered.
+ * This will not affect the integer divisions aligned to those of "src",
+ * since "src" is assumed to have ordered integer divisions.
  *
  * The result is not finalized as by design it will have redundant
  * divs if any divs from "src" were copied.
@@ -8288,8 +9601,10 @@
 	__isl_take isl_basic_map *dst, __isl_keep isl_basic_map *src)
 {
 	int i;
-	int known, extended;
-	unsigned total;
+	isl_bool known;
+	int extended;
+	isl_size v_div;
+	isl_size dst_n_div;
 
 	if (!dst || !src)
 		return isl_basic_map_free(dst);
@@ -8305,45 +9620,47 @@
 			"some src divs are unknown",
 			return isl_basic_map_free(dst));
 
-	src = isl_basic_map_order_divs(src);
+	v_div = isl_basic_map_var_offset(src, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(dst);
 
 	extended = 0;
-	total = isl_space_dim(src->dim, isl_dim_all);
+	dst_n_div = isl_basic_map_dim(dst, isl_dim_div);
+	if (dst_n_div < 0)
+		dst = isl_basic_map_free(dst);
 	for (i = 0; i < src->n_div; ++i) {
 		int j = find_div(dst, src, i);
-		if (j < 0) {
+		if (j < 0)
+			dst = isl_basic_map_free(dst);
+		if (j == dst_n_div) {
 			if (!extended) {
 				int extra = src->n_div - i;
 				dst = isl_basic_map_cow(dst);
 				if (!dst)
-					return NULL;
-				dst = isl_basic_map_extend_space(dst,
-						isl_space_copy(dst->dim),
+					return isl_basic_map_free(dst);
+				dst = isl_basic_map_extend(dst,
 						extra, 0, 2 * extra);
 				extended = 1;
 			}
 			j = isl_basic_map_alloc_div(dst);
 			if (j < 0)
 				return isl_basic_map_free(dst);
-			isl_seq_cpy(dst->divj, src->divi, 1+1+total+i);
-			isl_seq_clr(dst->divj+1+1+total+i, dst->n_div - i);
-			if (isl_basic_map_add_div_constraints(dst, j) < 0)
+			isl_seq_cpy(dst->divj, src->divi, 1+1+v_div+i);
+			isl_seq_clr(dst->divj+1+1+v_div+i, dst->n_div - i);
+			dst_n_div++;
+			dst = isl_basic_map_add_div_constraints(dst, j);
+			if (!dst)
 				return isl_basic_map_free(dst);
 		}
 		if (j != i)
-			isl_basic_map_swap_div(dst, i, j);
+			dst = isl_basic_map_swap_div(dst, i, j);
+		if (!dst)
+			return isl_basic_map_free(dst);
 	}
-	return dst;
+	return isl_basic_map_order_divs(dst);
 }
 
-struct isl_basic_set *isl_basic_set_align_divs(
-		struct isl_basic_set *dst, struct isl_basic_set *src)
-{
-	return (struct isl_basic_set *)isl_basic_map_align_divs(
-		(struct isl_basic_map *)dst, (struct isl_basic_map *)src);
-}
-
-struct isl_map *isl_map_align_divs(struct isl_map *map)
+__isl_give isl_map *isl_map_align_divs_internal(__isl_take isl_map *map)
 {
 	int i;
 
@@ -8352,6 +9669,7 @@
 	if (map->n == 0)
 		return map;
 	map = isl_map_compute_divs(map);
+	map = isl_map_order_divs(map);
 	map = isl_map_cow(map);
 	if (!map)
 		return NULL;
@@ -8364,74 +9682,88 @@
 			return isl_map_free(map);
 	}
 
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	map = isl_map_unmark_normalized(map);
 	return map;
 }
 
-struct isl_set *isl_set_align_divs(struct isl_set *set)
+__isl_give isl_map *isl_map_align_divs(__isl_take isl_map *map)
+{
+	return isl_map_align_divs_internal(map);
+}
+
+__isl_give isl_set *isl_set_align_divs(__isl_take isl_set *set)
 {
-	return (struct isl_set *)isl_map_align_divs((struct isl_map *)set);
+	return set_from_map(isl_map_align_divs_internal(set_to_map(set)));
 }
 
-/* Align the divs of the basic sets in "set" to those
- * of the basic sets in "list", as well as to the other basic sets in "set".
+/* Align the divs of the basic maps in "map" to those
+ * of the basic maps in "list", as well as to the other basic maps in "map".
  * The elements in "list" are assumed to have known divs.
  */
-__isl_give isl_set *isl_set_align_divs_to_basic_set_list(
-	__isl_take isl_set *set, __isl_keep isl_basic_set_list *list)
+__isl_give isl_map *isl_map_align_divs_to_basic_map_list(
+	__isl_take isl_map *map, __isl_keep isl_basic_map_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
-	set = isl_set_compute_divs(set);
-	set = isl_set_cow(set);
-	if (!set || !list)
-		return isl_set_free(set);
-	if (set->n == 0)
-		return set;
+	n = isl_basic_map_list_n_basic_map(list);
+	map = isl_map_compute_divs(map);
+	map = isl_map_cow(map);
+	if (!map || n < 0)
+		return isl_map_free(map);
+	if (map->n == 0)
+		return map;
 
-	n = isl_basic_set_list_n_basic_set(list);
 	for (i = 0; i < n; ++i) {
-		isl_basic_set *bset;
+		isl_basic_map *bmap;
 
-		bset = isl_basic_set_list_get_basic_set(list, i);
-		set->p0 = isl_basic_set_align_divs(set->p0, bset);
-		isl_basic_set_free(bset);
+		bmap = isl_basic_map_list_get_basic_map(list, i);
+		bmap = isl_basic_map_order_divs(bmap);
+		map->p0 = isl_basic_map_align_divs(map->p0, bmap);
+		isl_basic_map_free(bmap);
 	}
-	if (!set->p0)
-		return isl_set_free(set);
+	if (!map->p0)
+		return isl_map_free(map);
 
-	return isl_set_align_divs(set);
+	return isl_map_align_divs_internal(map);
 }
 
-/* Align the divs of each element of "list" to those of "bset".
- * Both "bset" and the elements of "list" are assumed to have known divs.
+/* Align the divs of each element of "list" to those of "bmap".
+ * Both "bmap" and the elements of "list" are assumed to have known divs.
  */
-__isl_give isl_basic_set_list *isl_basic_set_list_align_divs_to_basic_set(
-	__isl_take isl_basic_set_list *list, __isl_keep isl_basic_set *bset)
+__isl_give isl_basic_map_list *isl_basic_map_list_align_divs_to_basic_map(
+	__isl_take isl_basic_map_list *list, __isl_keep isl_basic_map *bmap)
 {
-	int i, n;
+	int i;
+	isl_size n;
 
-	if (!list || !bset)
-		return isl_basic_set_list_free(list);
+	n = isl_basic_map_list_n_basic_map(list);
+	if (n < 0 || !bmap)
+		return isl_basic_map_list_free(list);
 
-	n = isl_basic_set_list_n_basic_set(list);
 	for (i = 0; i < n; ++i) {
-		isl_basic_set *bset_i;
+		isl_basic_map *bmap_i;
 
-		bset_i = isl_basic_set_list_get_basic_set(list, i);
-		bset_i = isl_basic_set_align_divs(bset_i, bset);
-		list = isl_basic_set_list_set_basic_set(list, i, bset_i);
+		bmap_i = isl_basic_map_list_get_basic_map(list, i);
+		bmap_i = isl_basic_map_align_divs(bmap_i, bmap);
+		list = isl_basic_map_list_set_basic_map(list, i, bmap_i);
 	}
 
 	return list;
 }
 
-static __isl_give isl_set *set_apply( __isl_take isl_set *set,
+__isl_give isl_set *isl_set_apply( __isl_take isl_set *set,
 	__isl_take isl_map *map)
 {
-	if (!set || !map)
+	isl_bool ok;
+
+	isl_map_align_params_set(&map, &set);
+	ok = isl_map_compatible_domain(map, set);
+	if (ok < 0)
 		goto error;
-	isl_assert(set->ctx, isl_map_compatible_domain(map, set), goto error);
+	if (!ok)
+		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+			"incompatible spaces", goto error);
 	map = isl_map_intersect_domain(map, set);
 	set = isl_map_range(map);
 	return set;
@@ -8441,16 +9773,10 @@
 	return NULL;
 }
 
-__isl_give isl_set *isl_set_apply( __isl_take isl_set *set,
-	__isl_take isl_map *map)
-{
-	return isl_map_align_params_map_map_and(set, map, &set_apply);
-}
-
 /* There is no need to cow as removing empty parts doesn't change
  * the meaning of the set.
  */
-struct isl_map *isl_map_remove_empty_parts(struct isl_map *map)
+__isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map)
 {
 	int i;
 
@@ -8458,65 +9784,32 @@
 		return NULL;
 
 	for (i = map->n - 1; i >= 0; --i)
-		remove_if_empty(map, i);
+		map = remove_if_empty(map, i);
 
 	return map;
 }
 
-struct isl_set *isl_set_remove_empty_parts(struct isl_set *set)
+__isl_give isl_set *isl_set_remove_empty_parts(__isl_take isl_set *set)
 {
-	return (struct isl_set *)
-		isl_map_remove_empty_parts((struct isl_map *)set);
+	return set_from_map(isl_map_remove_empty_parts(set_to_map(set)));
 }
 
-struct isl_basic_map *isl_map_copy_basic_map(struct isl_map *map)
+/* Create a binary relation that maps the shared initial "pos" dimensions
+ * of "bset1" and "bset2" to the remaining dimensions of "bset1" and "bset2".
+ */
+static __isl_give isl_basic_map *join_initial(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2, int pos)
 {
-	struct isl_basic_map *bmap;
-	if (!map || map->n == 0)
-		return NULL;
-	bmap = map->pmap->n-1;
-	isl_assert(map->ctx, ISL_F_ISSET(bmap, ISL_BASIC_SET_FINAL), return NULL);
-	return isl_basic_map_copy(bmap);
-}
+	isl_basic_map *bmap1;
+	isl_basic_map *bmap2;
 
-struct isl_basic_set *isl_set_copy_basic_set(struct isl_set *set)
-{
-	return (struct isl_basic_set *)
-		isl_map_copy_basic_map((struct isl_map *)set);
-}
-
-__isl_give isl_map *isl_map_drop_basic_map(__isl_take isl_map *map,
-						__isl_keep isl_basic_map *bmap)
-{
-	int i;
-
-	if (!map || !bmap)
-		goto error;
-	for (i = map->n-1; i >= 0; --i) {
-		if (map->pi != bmap)
-			continue;
-		map = isl_map_cow(map);
-		if (!map)
-			goto error;
-		isl_basic_map_free(map->pi);
-		if (i != map->n-1) {
-			ISL_F_CLR(map, ISL_SET_NORMALIZED);
-			map->pi = map->pmap->n-1;
-		}
-		map->n--;
-		return map;
-	}
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
-}
-
-struct isl_set *isl_set_drop_basic_set(struct isl_set *set,
-						struct isl_basic_set *bset)
-{
-	return (struct isl_set *)isl_map_drop_basic_map((struct isl_map *)set,
-						(struct isl_basic_map *)bset);
+	bmap1 = isl_basic_map_from_range(isl_basic_set_copy(bset1));
+	bmap2 = isl_basic_map_from_range(isl_basic_set_copy(bset2));
+	bmap1 = isl_basic_map_move_dims(bmap1, isl_dim_in, 0,
+					isl_dim_out, 0, pos);
+	bmap2 = isl_basic_map_move_dims(bmap2, isl_dim_in, 0,
+					isl_dim_out, 0, pos);
+	return isl_basic_map_range_product(bmap1, bmap2);
 }
 
 /* Given two basic sets bset1 and bset2, compute the maximal difference
@@ -8527,40 +9820,28 @@
 	__isl_keep isl_basic_set *bset1, __isl_keep isl_basic_set *bset2,
 	int pos, isl_int *opt)
 {
-	isl_space *dims;
-	struct isl_basic_map *bmap1 = NULL;
-	struct isl_basic_map *bmap2 = NULL;
+	isl_basic_map *bmap1;
 	struct isl_ctx *ctx;
 	struct isl_vec *obj;
-	unsigned total;
-	unsigned nparam;
-	unsigned dim1, dim2;
+	isl_size total;
+	isl_size nparam;
+	isl_size dim1;
 	enum isl_lp_result res;
 
-	if (!bset1 || !bset2)
+	nparam = isl_basic_set_dim(bset1, isl_dim_param);
+	dim1 = isl_basic_set_dim(bset1, isl_dim_set);
+	if (nparam < 0 || dim1 < 0 || !bset2)
+		return isl_lp_error;
+
+	bmap1 = join_initial(bset1, bset2, pos);
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	if (total < 0)
 		return isl_lp_error;
 
-	nparam = isl_basic_set_n_param(bset1);
-	dim1 = isl_basic_set_n_dim(bset1);
-	dim2 = isl_basic_set_n_dim(bset2);
-	dims = isl_space_alloc(bset1->ctx, nparam, pos, dim1 - pos);
-	bmap1 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset1), dims);
-	dims = isl_space_alloc(bset2->ctx, nparam, pos, dim2 - pos);
-	bmap2 = isl_basic_map_from_basic_set(isl_basic_set_copy(bset2), dims);
-	if (!bmap1 || !bmap2)
-		goto error;
-	bmap1 = isl_basic_map_cow(bmap1);
-	bmap1 = isl_basic_map_extend(bmap1, nparam,
-			pos, (dim1 - pos) + (dim2 - pos),
-			bmap2->n_div, bmap2->n_eq, bmap2->n_ineq);
-	bmap1 = add_constraints(bmap1, bmap2, 0, dim1 - pos);
-	if (!bmap1)
-		goto error2;
-	total = isl_basic_map_total_dim(bmap1);
 	ctx = bmap1->ctx;
 	obj = isl_vec_alloc(ctx, 1 + total);
 	if (!obj)
-		goto error2;
+		goto error;
 	isl_seq_clr(obj->block.data, 1 + total);
 	isl_int_set_si(obj->block.data1+nparam+pos, 1);
 	isl_int_set_si(obj->block.data1+nparam+pos+(dim1-pos), -1);
@@ -8570,8 +9851,6 @@
 	isl_vec_free(obj);
 	return res;
 error:
-	isl_basic_map_free(bmap2);
-error2:
 	isl_basic_map_free(bmap1);
 	return isl_lp_error;
 }
@@ -8587,8 +9866,8 @@
  *	 0 if bset1 and bset2 are incomparable
  *	-2 if some error occurred.
  */
-int isl_basic_set_compare_at(struct isl_basic_set *bset1,
-	struct isl_basic_set *bset2, int pos)
+int isl_basic_set_compare_at(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2, int pos)
 {
 	isl_int opt;
 	enum isl_lp_result res;
@@ -8626,28 +9905,35 @@
 int isl_basic_set_follows_at(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2, int pos)
 {
-	isl_int opt;
-	enum isl_lp_result res;
-	int cmp;
-
-	isl_int_init(opt);
-
-	res = basic_set_maximal_difference_at(bset1, bset2, pos, &opt);
-
-	if (res == isl_lp_empty)
-		cmp = -1;
-	else if ((res == isl_lp_ok && isl_int_is_pos(opt)) ||
-		  res == isl_lp_unbounded)
-		cmp = 1;
-	else if (res == isl_lp_ok && isl_int_is_neg(opt))
-		cmp = -1;
-	else if (res == isl_lp_ok)
-		cmp = 0;
-	else
-		cmp = -2;
+	isl_bool empty;
+	isl_basic_map *bmap;
+	isl_size dim1;
 
-	isl_int_clear(opt);
-	return cmp;
+	dim1 = isl_basic_set_dim(bset1, isl_dim_set);
+	if (dim1 < 0)
+		return -2;
+	bmap = join_initial(bset1, bset2, pos);
+	bmap = isl_basic_map_order_ge(bmap, isl_dim_out, 0,
+					    isl_dim_out, dim1 - pos);
+	empty = isl_basic_map_is_empty(bmap);
+	if (empty < 0)
+		goto error;
+	if (empty) {
+		isl_basic_map_free(bmap);
+		return -1;
+	}
+	bmap = isl_basic_map_order_gt(bmap, isl_dim_out, 0,
+					    isl_dim_out, dim1 - pos);
+	empty = isl_basic_map_is_empty(bmap);
+	if (empty < 0)
+		goto error;
+	isl_basic_map_free(bmap);
+	if (empty)
+		return 0;
+	return 1;
+error:
+	isl_basic_map_free(bmap);
+	return -2;
 }
 
 /* Given two sets set1 and set2, check whether
@@ -8683,16 +9969,16 @@
 	return follows;
 }
 
-static int isl_basic_map_plain_has_fixed_var(__isl_keep isl_basic_map *bmap,
-	unsigned pos, isl_int *val)
+static isl_bool isl_basic_map_plain_has_fixed_var(
+	__isl_keep isl_basic_map *bmap, unsigned pos, isl_int *val)
 {
 	int i;
 	int d;
-	unsigned total;
+	isl_size total;
 
-	if (!bmap)
-		return -1;
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	for (i = 0, d = total-1; i < bmap->n_eq && d+1 > pos; ++i) {
 		for (; d+1 > pos; --d)
 			if (!isl_int_is_zero(bmap->eqi1+d))
@@ -8700,39 +9986,39 @@
 		if (d != pos)
 			continue;
 		if (isl_seq_first_non_zero(bmap->eqi+1, d) != -1)
-			return 0;
+			return isl_bool_false;
 		if (isl_seq_first_non_zero(bmap->eqi+1+d+1, total-d-1) != -1)
-			return 0;
+			return isl_bool_false;
 		if (!isl_int_is_one(bmap->eqi1+d))
-			return 0;
+			return isl_bool_false;
 		if (val)
 			isl_int_neg(*val, bmap->eqi0);
-		return 1;
+		return isl_bool_true;
 	}
-	return 0;
+	return isl_bool_false;
 }
 
-static int isl_map_plain_has_fixed_var(__isl_keep isl_map *map,
+static isl_bool isl_map_plain_has_fixed_var(__isl_keep isl_map *map,
 	unsigned pos, isl_int *val)
 {
 	int i;
 	isl_int v;
 	isl_int tmp;
-	int fixed;
+	isl_bool fixed;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	if (map->n == 0)
-		return 0;
+		return isl_bool_false;
 	if (map->n == 1)
 		return isl_basic_map_plain_has_fixed_var(map->p0, pos, val); 
 	isl_int_init(v);
 	isl_int_init(tmp);
 	fixed = isl_basic_map_plain_has_fixed_var(map->p0, pos, &v); 
-	for (i = 1; fixed == 1 && i < map->n; ++i) {
+	for (i = 1; fixed == isl_bool_true && i < map->n; ++i) {
 		fixed = isl_basic_map_plain_has_fixed_var(map->pi, pos, &tmp); 
-		if (fixed == 1 && isl_int_ne(tmp, v))
-			fixed = 0;
+		if (fixed == isl_bool_true && isl_int_ne(tmp, v))
+			fixed = isl_bool_false;
 	}
 	if (val)
 		isl_int_set(*val, v);
@@ -8741,24 +10027,18 @@
 	return fixed;
 }
 
-static int isl_basic_set_plain_has_fixed_var(__isl_keep isl_basic_set *bset,
-	unsigned pos, isl_int *val)
+static isl_bool isl_basic_set_plain_has_fixed_var(
+	__isl_keep isl_basic_set *bset, unsigned pos, isl_int *val)
 {
-	return isl_basic_map_plain_has_fixed_var((struct isl_basic_map *)bset,
+	return isl_basic_map_plain_has_fixed_var(bset_to_bmap(bset),
 						pos, val);
 }
 
-static int isl_set_plain_has_fixed_var(__isl_keep isl_set *set, unsigned pos,
-	isl_int *val)
-{
-	return isl_map_plain_has_fixed_var((struct isl_map *)set, pos, val);
-}
-
-int isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_plain_is_fixed(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos, isl_int *val)
 {
-	if (pos >= isl_basic_map_dim(bmap, type))
-		return -1;
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_bool_error;
 	return isl_basic_map_plain_has_fixed_var(bmap,
 		isl_basic_map_offset(bmap, type) - 1 + pos, val);
 }
@@ -8773,7 +10053,7 @@
 {
 	isl_ctx *ctx;
 	isl_val *v;
-	int fixed;
+	isl_bool fixed;
 
 	if (!bmap)
 		return NULL;
@@ -8792,11 +10072,11 @@
 	return isl_val_nan(ctx);
 }
 
-int isl_map_plain_is_fixed(__isl_keep isl_map *map,
+isl_bool isl_map_plain_is_fixed(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos, isl_int *val)
 {
-	if (pos >= isl_map_dim(map, type))
-		return -1;
+	if (isl_map_check_range(map, type, pos, 1) < 0)
+		return isl_bool_error;
 	return isl_map_plain_has_fixed_var(map,
 		map_offset(map, type) - 1 + pos, val);
 }
@@ -8810,7 +10090,7 @@
 {
 	isl_ctx *ctx;
 	isl_val *v;
-	int fixed;
+	isl_bool fixed;
 
 	if (!map)
 		return NULL;
@@ -8839,131 +10119,67 @@
 	return isl_map_plain_get_val_if_fixed(set, type, pos);
 }
 
-int isl_set_plain_is_fixed(__isl_keep isl_set *set,
-	enum isl_dim_type type, unsigned pos, isl_int *val)
+/* Return a sequence of values in the same space as "set"
+ * that are equal to the corresponding set dimensions of "set"
+ * for those set dimensions that obviously lie on a hyperplane
+ * where the dimension has a fixed value.
+ * The other elements are set to NaN.
+ */
+__isl_give isl_multi_val *isl_set_get_plain_multi_val_if_fixed(
+	__isl_keep isl_set *set)
 {
-	return isl_map_plain_is_fixed(set, type, pos, val);
-}
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_multi_val *mv;
 
-int isl_map_fast_is_fixed(__isl_keep isl_map *map,
-	enum isl_dim_type type, unsigned pos, isl_int *val)
-{
-	return isl_map_plain_is_fixed(map, type, pos, val);
-}
+	space = isl_space_drop_all_params(isl_set_get_space(set));
+	mv = isl_multi_val_alloc(space);
+	n = isl_multi_val_size(mv);
+	if (n < 0)
+		return isl_multi_val_free(mv);
 
-/* Check if dimension dim has fixed value and if so and if val is not NULL,
- * then return this fixed value in *val.
- */
-int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
-	unsigned dim, isl_int *val)
-{
-	return isl_basic_set_plain_has_fixed_var(bset,
-					isl_basic_set_n_param(bset) + dim, val);
-}
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
 
-/* Check if dimension dim has fixed value and if so and if val is not NULL,
- * then return this fixed value in *val.
- */
-int isl_set_plain_dim_is_fixed(__isl_keep isl_set *set,
-	unsigned dim, isl_int *val)
-{
-	return isl_set_plain_has_fixed_var(set, isl_set_n_param(set) + dim, val);
-}
+		v = isl_set_plain_get_val_if_fixed(set, isl_dim_set, i);
+		mv = isl_multi_val_set_val(mv, i, v);
+	}
 
-int isl_set_fast_dim_is_fixed(__isl_keep isl_set *set,
-	unsigned dim, isl_int *val)
-{
-	return isl_set_plain_dim_is_fixed(set, dim, val);
+	return mv;
 }
 
-/* Check if input variable in has fixed value and if so and if val is not NULL,
+/* Check if dimension dim has fixed value and if so and if val is not NULL,
  * then return this fixed value in *val.
  */
-int isl_map_plain_input_is_fixed(__isl_keep isl_map *map,
-	unsigned in, isl_int *val)
-{
-	return isl_map_plain_has_fixed_var(map, isl_map_n_param(map) + in, val);
-}
-
-/* Check if dimension dim has an (obvious) fixed lower bound and if so
- * and if val is not NULL, then return this lower bound in *val.
- */
-int isl_basic_set_plain_dim_has_fixed_lower_bound(
-	__isl_keep isl_basic_set *bset, unsigned dim, isl_int *val)
-{
-	int i, i_eq = -1, i_ineq = -1;
-	isl_int *c;
-	unsigned total;
-	unsigned nparam;
-
-	if (!bset)
-		return -1;
-	total = isl_basic_set_total_dim(bset);
-	nparam = isl_basic_set_n_param(bset);
-	for (i = 0; i < bset->n_eq; ++i) {
-		if (isl_int_is_zero(bset->eqi1+nparam+dim))
-			continue;
-		if (i_eq != -1)
-			return 0;
-		i_eq = i;
-	}
-	for (i = 0; i < bset->n_ineq; ++i) {
-		if (!isl_int_is_pos(bset->ineqi1+nparam+dim))
-			continue;
-		if (i_eq != -1 || i_ineq != -1)
-			return 0;
-		i_ineq = i;
-	}
-	if (i_eq == -1 && i_ineq == -1)
-		return 0;
-	c = i_eq != -1 ? bset->eqi_eq : bset->ineqi_ineq;
-	/* The coefficient should always be one due to normalization. */
-	if (!isl_int_is_one(c1+nparam+dim))
-		return 0;
-	if (isl_seq_first_non_zero(c+1, nparam+dim) != -1)
-		return 0;
-	if (isl_seq_first_non_zero(c+1+nparam+dim+1,
-					total - nparam - dim - 1) != -1)
-		return 0;
-	if (val)
-		isl_int_neg(*val, c0);
-	return 1;
-}
-
-int isl_set_plain_dim_has_fixed_lower_bound(__isl_keep isl_set *set,
+isl_bool isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
 	unsigned dim, isl_int *val)
 {
-	int i;
-	isl_int v;
-	isl_int tmp;
-	int fixed;
+	isl_size nparam;
 
-	if (!set)
-		return -1;
-	if (set->n == 0)
-		return 0;
-	if (set->n == 1)
-		return isl_basic_set_plain_dim_has_fixed_lower_bound(set->p0,
-								dim, val);
-	isl_int_init(v);
-	isl_int_init(tmp);
-	fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->p0,
-								dim, &v);
-	for (i = 1; fixed == 1 && i < set->n; ++i) {
-		fixed = isl_basic_set_plain_dim_has_fixed_lower_bound(set->pi,
-								dim, &tmp);
-		if (fixed == 1 && isl_int_ne(tmp, v))
-			fixed = 0;
-	}
-	if (val)
-		isl_int_set(*val, v);
-	isl_int_clear(tmp);
-	isl_int_clear(v);
-	return fixed;
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0)
+		return isl_bool_error;
+	return isl_basic_set_plain_has_fixed_var(bset, nparam + dim, val);
 }
 
-/* uset_gist depends on constraints without existentially quantified
+/* Return -1 if the constraint "c1" should be sorted before "c2"
+ * and 1 if it should be sorted after "c2".
+ * Return 0 if the two constraints are the same (up to the constant term).
+ *
+ * In particular, if a constraint involves later variables than another
+ * then it is sorted after this other constraint.
+ * uset_gist depends on constraints without existentially quantified
  * variables sorting first.
+ *
+ * For constraints that have the same latest variable, those
+ * with the same coefficient for this latest variable (first in absolute value
+ * and then in actual value) are grouped together.
+ * This is useful for detecting pairs of constraints that can
+ * be chained in their printed representation.
+ *
+ * Finally, within a group, constraints are sorted according to
+ * their coefficients (excluding the constant term).
  */
 static int sort_constraint_cmp(const void *p1, const void *p2, void *arg)
 {
@@ -8971,6 +10187,7 @@
 	isl_int **c2 = (isl_int **) p2;
 	int l1, l2;
 	unsigned size = *(unsigned *) arg;
+	int cmp;
 
 	l1 = isl_seq_last_non_zero(*c1 + 1, size);
 	l2 = isl_seq_last_non_zero(*c2 + 1, size);
@@ -8978,70 +10195,90 @@
 	if (l1 != l2)
 		return l1 - l2;
 
+	cmp = isl_int_abs_cmp((*c1)1 + l1, (*c2)1 + l1);
+	if (cmp != 0)
+		return cmp;
+	cmp = isl_int_cmp((*c1)1 + l1, (*c2)1 + l1);
+	if (cmp != 0)
+		return -cmp;
+
 	return isl_seq_cmp(*c1 + 1, *c2 + 1, size);
 }
 
-static struct isl_basic_map *isl_basic_map_sort_constraints(
-	struct isl_basic_map *bmap)
+/* Return -1 if the constraint "c1" of "bmap" is sorted before "c2"
+ * by isl_basic_map_sort_constraints, 1 if it is sorted after "c2"
+ * and 0 if the two constraints are the same (up to the constant term).
+ */
+int isl_basic_map_constraint_cmp(__isl_keep isl_basic_map *bmap,
+	isl_int *c1, isl_int *c2)
 {
-	unsigned total;
+	isl_size total;
+	unsigned size;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return -2;
+	size = total;
+	return sort_constraint_cmp(&c1, &c2, &size);
+}
+
+__isl_give isl_basic_map *isl_basic_map_sort_constraints(
+	__isl_take isl_basic_map *bmap)
+{
+	isl_size total;
+	unsigned size;
 
 	if (!bmap)
 		return NULL;
 	if (bmap->n_ineq == 0)
 		return bmap;
-	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
+	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_SORTED))
 		return bmap;
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	size = total;
 	if (isl_sort(bmap->ineq, bmap->n_ineq, sizeof(isl_int *),
-		    &sort_constraint_cmp, &total) < 0)
+		    &sort_constraint_cmp, &size) < 0)
 		return isl_basic_map_free(bmap);
+	ISL_F_SET(bmap, ISL_BASIC_MAP_SORTED);
 	return bmap;
 }
 
 __isl_give isl_basic_set *isl_basic_set_sort_constraints(
 	__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)isl_basic_map_sort_constraints(
-						(struct isl_basic_map *)bset);
+	isl_basic_map *bmap = bset_to_bmap(bset);
+	return bset_from_bmap(isl_basic_map_sort_constraints(bmap));
 }
 
-struct isl_basic_map *isl_basic_map_normalize(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_normalize(
+	__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
-	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED))
-		return bmap;
 	bmap = isl_basic_map_remove_redundancies(bmap);
 	bmap = isl_basic_map_sort_constraints(bmap);
-	if (bmap)
-		ISL_F_SET(bmap, ISL_BASIC_MAP_NORMALIZED);
 	return bmap;
 }
-
-struct isl_basic_set *isl_basic_set_normalize(struct isl_basic_set *bset)
-{
-	return (struct isl_basic_set *)isl_basic_map_normalize(
-						(struct isl_basic_map *)bset);
-}
-
-int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1,
-	const __isl_keep isl_basic_map *bmap2)
+int isl_basic_map_plain_cmp(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2)
 {
 	int i, cmp;
-	unsigned total;
+	isl_size total;
+	isl_space *space1, *space2;
+
+	if (!bmap1 || !bmap2)
+		return -1;
 
 	if (bmap1 == bmap2)
 		return 0;
+	space1 = isl_basic_map_peek_space(bmap1);
+	space2 = isl_basic_map_peek_space(bmap2);
+	cmp = isl_space_cmp(space1, space2);
+	if (cmp)
+		return cmp;
 	if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) !=
 	    ISL_F_ISSET(bmap2, ISL_BASIC_MAP_RATIONAL))
 		return ISL_F_ISSET(bmap1, ISL_BASIC_MAP_RATIONAL) ? -1 : 1;
-	if (isl_basic_map_n_param(bmap1) != isl_basic_map_n_param(bmap2))
-		return isl_basic_map_n_param(bmap1) - isl_basic_map_n_param(bmap2);
-	if (isl_basic_map_n_in(bmap1) != isl_basic_map_n_in(bmap2))
-		return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
-	if (isl_basic_map_n_out(bmap1) != isl_basic_map_n_out(bmap2))
-		return isl_basic_map_n_out(bmap1) - isl_basic_map_n_out(bmap2);
 	if (ISL_F_ISSET(bmap1, ISL_BASIC_MAP_EMPTY) &&
 	    ISL_F_ISSET(bmap2, ISL_BASIC_MAP_EMPTY))
 		return 0;
@@ -9055,7 +10292,9 @@
 		return bmap1->n_ineq - bmap2->n_ineq;
 	if (bmap1->n_div != bmap2->n_div)
 		return bmap1->n_div - bmap2->n_div;
-	total = isl_basic_map_total_dim(bmap1);
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	if (total < 0)
+		return -1;
 	for (i = 0; i < bmap1->n_eq; ++i) {
 		cmp = isl_seq_cmp(bmap1->eqi, bmap2->eqi, 1+total);
 		if (cmp)
@@ -9074,8 +10313,8 @@
 	return 0;
 }
 
-int isl_basic_set_plain_cmp(const __isl_keep isl_basic_set *bset1,
-	const __isl_keep isl_basic_set *bset2)
+int isl_basic_set_plain_cmp(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2)
 {
 	return isl_basic_map_plain_cmp(bset1, bset2);
 }
@@ -9098,23 +10337,25 @@
 	return 0;
 }
 
-int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2)
 {
+	if (!bmap1 || !bmap2)
+		return isl_bool_error;
 	return isl_basic_map_plain_cmp(bmap1, bmap2) == 0;
 }
 
-int isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_plain_is_equal(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2)
 {
-	return isl_basic_map_plain_is_equal((isl_basic_map *)bset1,
-					    (isl_basic_map *)bset2);
+	return isl_basic_map_plain_is_equal(bset_to_bmap(bset1),
+					    bset_to_bmap(bset2));
 }
 
 static int qsort_bmap_cmp(const void *p1, const void *p2)
 {
-	const struct isl_basic_map *bmap1 = *(const struct isl_basic_map **)p1;
-	const struct isl_basic_map *bmap2 = *(const struct isl_basic_map **)p2;
+	isl_basic_map *bmap1 = *(isl_basic_map **) p1;
+	isl_basic_map *bmap2 = *(isl_basic_map **) p2;
 
 	return isl_basic_map_plain_cmp(bmap1, bmap2);
 }
@@ -9209,23 +10450,25 @@
 	return NULL;
 }
 
-struct isl_set *isl_set_normalize(struct isl_set *set)
+__isl_give isl_set *isl_set_normalize(__isl_take isl_set *set)
 {
-	return (struct isl_set *)isl_map_normalize((struct isl_map *)set);
+	return set_from_map(isl_map_normalize(set_to_map(set)));
 }
 
-int isl_map_plain_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+isl_bool isl_map_plain_is_equal(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
 {
 	int i;
-	int equal;
+	isl_bool equal;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 
 	if (map1 == map2)
-		return 1;
-	if (!isl_space_is_equal(map1->dim, map2->dim))
-		return 0;
+		return isl_bool_true;
+	equal = isl_map_has_equal_space(map1, map2);
+	if (equal < 0 || !equal)
+		return equal;
 
 	map1 = isl_map_copy(map1);
 	map2 = isl_map_copy(map2);
@@ -9245,180 +10488,165 @@
 error:
 	isl_map_free(map1);
 	isl_map_free(map2);
-	return -1;
-}
-
-int isl_map_fast_is_equal(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
-{
-	return isl_map_plain_is_equal(map1, map2);
-}
-
-int isl_set_plain_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
-{
-	return isl_map_plain_is_equal((struct isl_map *)set1,
-						(struct isl_map *)set2);
+	return isl_bool_error;
 }
 
-int isl_set_fast_is_equal(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+isl_bool isl_set_plain_is_equal(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2)
 {
-	return isl_set_plain_is_equal(set1, set2);
+	return isl_map_plain_is_equal(set_to_map(set1), set_to_map(set2));
 }
 
-/* Return an interval that ranges from min to max (inclusive)
+/* Return the basic maps in "map" as a list.
  */
-struct isl_basic_set *isl_basic_set_interval(struct isl_ctx *ctx,
-	isl_int min, isl_int max)
+__isl_give isl_basic_map_list *isl_map_get_basic_map_list(
+	__isl_keep isl_map *map)
 {
-	int k;
-	struct isl_basic_set *bset = NULL;
+	int i;
+	isl_ctx *ctx;
+	isl_basic_map_list *list;
 
-	bset = isl_basic_set_alloc(ctx, 0, 1, 0, 0, 2);
-	if (!bset)
-		goto error;
+	if (!map)
+		return NULL;
+	ctx = isl_map_get_ctx(map);
+	list = isl_basic_map_list_alloc(ctx, map->n);
 
-	k = isl_basic_set_alloc_inequality(bset);
-	if (k < 0)
-		goto error;
-	isl_int_set_si(bset->ineqk1, 1);
-	isl_int_neg(bset->ineqk0, min);
+	for (i = 0; i < map->n; ++i) {
+		isl_basic_map *bmap;
 
-	k = isl_basic_set_alloc_inequality(bset);
-	if (k < 0)
-		goto error;
-	isl_int_set_si(bset->ineqk1, -1);
-	isl_int_set(bset->ineqk0, max);
+		bmap = isl_basic_map_copy(map->pi);
+		list = isl_basic_map_list_add(list, bmap);
+	}
 
-	return bset;
-error:
-	isl_basic_set_free(bset);
-	return NULL;
+	return list;
 }
 
-/* Return the basic sets in "set" as a list.
+/* Return the intersection of the elements in the non-empty list "list".
+ * All elements are assumed to live in the same space.
  */
-__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
-	__isl_keep isl_set *set)
+__isl_give isl_basic_map *isl_basic_map_list_intersect(
+	__isl_take isl_basic_map_list *list)
 {
 	int i;
-	isl_ctx *ctx;
-	isl_basic_set_list *list;
+	isl_size n;
+	isl_basic_map *bmap;
 
-	if (!set)
-		return NULL;
-	ctx = isl_set_get_ctx(set);
-	list = isl_basic_set_list_alloc(ctx, set->n);
+	n = isl_basic_map_list_n_basic_map(list);
+	if (n < 0)
+		goto error;
+	if (n < 1)
+		isl_die(isl_basic_map_list_get_ctx(list), isl_error_invalid,
+			"expecting non-empty list", goto error);
 
-	for (i = 0; i < set->n; ++i) {
-		isl_basic_set *bset;
+	bmap = isl_basic_map_list_get_basic_map(list, 0);
+	for (i = 1; i < n; ++i) {
+		isl_basic_map *bmap_i;
 
-		bset = isl_basic_set_copy(set->pi);
-		list = isl_basic_set_list_add(list, bset);
+		bmap_i = isl_basic_map_list_get_basic_map(list, i);
+		bmap = isl_basic_map_intersect(bmap, bmap_i);
 	}
 
-	return list;
+	isl_basic_map_list_free(list);
+	return bmap;
+error:
+	isl_basic_map_list_free(list);
+	return NULL;
 }
 
 /* Return the intersection of the elements in the non-empty list "list".
  * All elements are assumed to live in the same space.
  */
 __isl_give isl_basic_set *isl_basic_set_list_intersect(
-	__isl_take struct isl_basic_set_list *list)
+	__isl_take isl_basic_set_list *list)
+{
+	return isl_basic_map_list_intersect(list);
+}
+
+/* Return the union of the elements of "list".
+ * The list is required to have at least one element.
+ */
+__isl_give isl_set *isl_basic_set_list_union(
+	__isl_take isl_basic_set_list *list)
 {
-	int i, n;
+	int i;
+	isl_size n;
+	isl_space *space;
 	isl_basic_set *bset;
+	isl_set *set;
 
-	if (!list)
-		return NULL;
 	n = isl_basic_set_list_n_basic_set(list);
+	if (n < 0)
+		goto error;
 	if (n < 1)
 		isl_die(isl_basic_set_list_get_ctx(list), isl_error_invalid,
 			"expecting non-empty list", goto error);
-	
+
 	bset = isl_basic_set_list_get_basic_set(list, 0);
-	for (i = 1; i < n; ++i) {
-		isl_basic_set *bset_i;
+	space = isl_basic_set_get_space(bset);
+	isl_basic_set_free(bset);
 
-		bset_i = isl_basic_set_list_get_basic_set(list, i);
-		bset = isl_basic_set_intersect(bset, bset_i);
+	set = isl_set_alloc_space(space, n, 0);
+	for (i = 0; i < n; ++i) {
+		bset = isl_basic_set_list_get_basic_set(list, i);
+		set = isl_set_add_basic_set(set, bset);
 	}
 
 	isl_basic_set_list_free(list);
-	return bset;
+	return set;
 error:
 	isl_basic_set_list_free(list);
 	return NULL;
 }
 
-/* Return the Cartesian product of the basic sets in list (in the given order).
+/* Return the union of the elements in the non-empty list "list".
+ * All elements are assumed to live in the same space.
  */
-__isl_give isl_basic_set *isl_basic_set_list_product(
-	__isl_take struct isl_basic_set_list *list)
+__isl_give isl_set *isl_set_list_union(__isl_take isl_set_list *list)
 {
 	int i;
-	unsigned dim;
-	unsigned nparam;
-	unsigned extra;
-	unsigned n_eq;
-	unsigned n_ineq;
-	struct isl_basic_set *product = NULL;
-
-	if (!list)
-		goto error;
-	isl_assert(list->ctx, list->n > 0, goto error);
-	isl_assert(list->ctx, list->p0, goto error);
-	nparam = isl_basic_set_n_param(list->p0);
-	dim = isl_basic_set_n_dim(list->p0);
-	extra = list->p0->n_div;
-	n_eq = list->p0->n_eq;
-	n_ineq = list->p0->n_ineq;
-	for (i = 1; i < list->n; ++i) {
-		isl_assert(list->ctx, list->pi, goto error);
-		isl_assert(list->ctx,
-		    nparam == isl_basic_set_n_param(list->pi), goto error);
-		dim += isl_basic_set_n_dim(list->pi);
-		extra += list->pi->n_div;
-		n_eq += list->pi->n_eq;
-		n_ineq += list->pi->n_ineq;
-	}
-	product = isl_basic_set_alloc(list->ctx, nparam, dim, extra,
-					n_eq, n_ineq);
-	if (!product)
-		goto error;
-	dim = 0;
-	for (i = 0; i < list->n; ++i) {
-		isl_basic_set_add_constraints(product,
-					isl_basic_set_copy(list->pi), dim);
-		dim += isl_basic_set_n_dim(list->pi);
+	isl_size n;
+	isl_set *set;
+
+	n = isl_set_list_n_set(list);
+	if (n < 0)
+		goto error;
+	if (n < 1)
+		isl_die(isl_set_list_get_ctx(list), isl_error_invalid,
+			"expecting non-empty list", goto error);
+
+	set = isl_set_list_get_set(list, 0);
+	for (i = 1; i < n; ++i) {
+		isl_set *set_i;
+
+		set_i = isl_set_list_get_set(list, i);
+		set = isl_set_union(set, set_i);
 	}
-	isl_basic_set_list_free(list);
-	return product;
+
+	isl_set_list_free(list);
+	return set;
 error:
-	isl_basic_set_free(product);
-	isl_basic_set_list_free(list);
+	isl_set_list_free(list);
 	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_product(
-		struct isl_basic_map *bmap1, struct isl_basic_map *bmap2)
+__isl_give isl_basic_map *isl_basic_map_product(
+	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
-	isl_space *dim_result = NULL;
+	isl_space *space_result = NULL;
 	struct isl_basic_map *bmap;
 	unsigned in1, in2, out1, out2, nparam, total, pos;
 	struct isl_dim_map *dim_map1, *dim_map2;
 
-	if (!bmap1 || !bmap2)
+	if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
 		goto error;
-
-	isl_assert(bmap1->ctx, isl_space_match(bmap1->dim, isl_dim_param,
-				     bmap2->dim, isl_dim_param), goto error);
-	dim_result = isl_space_product(isl_space_copy(bmap1->dim),
+	space_result = isl_space_product(isl_space_copy(bmap1->dim),
 						   isl_space_copy(bmap2->dim));
 
-	in1 = isl_basic_map_n_in(bmap1);
-	in2 = isl_basic_map_n_in(bmap2);
-	out1 = isl_basic_map_n_out(bmap1);
-	out2 = isl_basic_map_n_out(bmap2);
-	nparam = isl_basic_map_n_param(bmap1);
+	in1 = isl_basic_map_dim(bmap1, isl_dim_in);
+	in2 = isl_basic_map_dim(bmap2, isl_dim_in);
+	out1 = isl_basic_map_dim(bmap1, isl_dim_out);
+	out2 = isl_basic_map_dim(bmap2, isl_dim_out);
+	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
 
 	total = nparam + in1 + in2 + out1 + out2 + bmap1->n_div + bmap2->n_div;
 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
@@ -9432,7 +10660,7 @@
 	isl_dim_map_div(dim_map1, bmap1, pos += out2);
 	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
 
-	bmap = isl_basic_map_alloc_space(dim_result,
+	bmap = isl_basic_map_alloc_space(space_result,
 			bmap1->n_div + bmap2->n_div,
 			bmap1->n_eq + bmap2->n_eq,
 			bmap1->n_ineq + bmap2->n_ineq);
@@ -9465,21 +10693,23 @@
 __isl_give isl_basic_map *isl_basic_map_domain_product(
 	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
+	isl_space *space1, *space2;
 	isl_space *space_result = NULL;
 	isl_basic_map *bmap;
-	unsigned in1, in2, out, nparam, total, pos;
+	isl_size in1, in2, out, nparam;
+	unsigned total, pos;
 	struct isl_dim_map *dim_map1, *dim_map2;
 
-	if (!bmap1 || !bmap2)
-		goto error;
-
-	space_result = isl_space_domain_product(isl_space_copy(bmap1->dim),
-						isl_space_copy(bmap2->dim));
-
 	in1 = isl_basic_map_dim(bmap1, isl_dim_in);
 	in2 = isl_basic_map_dim(bmap2, isl_dim_in);
 	out = isl_basic_map_dim(bmap1, isl_dim_out);
 	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
+	if (in1 < 0 || in2 < 0 || out < 0 || nparam < 0)
+		goto error;
+
+	space1 = isl_basic_map_get_space(bmap1);
+	space2 = isl_basic_map_get_space(bmap2);
+	space_result = isl_space_domain_product(space1, space2);
 
 	total = nparam + in1 + in2 + out + bmap1->n_div + bmap2->n_div;
 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
@@ -9510,27 +10740,29 @@
 __isl_give isl_basic_map *isl_basic_map_range_product(
 	__isl_take isl_basic_map *bmap1, __isl_take isl_basic_map *bmap2)
 {
-	isl_space *dim_result = NULL;
+	isl_bool rational;
+	isl_space *space_result = NULL;
 	isl_basic_map *bmap;
-	unsigned in, out1, out2, nparam, total, pos;
+	isl_size in, out1, out2, nparam;
+	unsigned total, pos;
 	struct isl_dim_map *dim_map1, *dim_map2;
 
-	if (!bmap1 || !bmap2)
+	rational = isl_basic_map_is_rational(bmap1);
+	if (rational >= 0 && rational)
+		rational = isl_basic_map_is_rational(bmap2);
+	in = isl_basic_map_dim(bmap1, isl_dim_in);
+	out1 = isl_basic_map_dim(bmap1, isl_dim_out);
+	out2 = isl_basic_map_dim(bmap2, isl_dim_out);
+	nparam = isl_basic_map_dim(bmap1, isl_dim_param);
+	if (in < 0 || out1 < 0 || out2 < 0 || nparam < 0 || rational < 0)
 		goto error;
 
-	if (!isl_space_match(bmap1->dim, isl_dim_param,
-			    bmap2->dim, isl_dim_param))
-		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
-			"parameters don't match", goto error);
+	if (isl_basic_map_check_equal_params(bmap1, bmap2) < 0)
+		goto error;
 
-	dim_result = isl_space_range_product(isl_space_copy(bmap1->dim),
+	space_result = isl_space_range_product(isl_space_copy(bmap1->dim),
 					   isl_space_copy(bmap2->dim));
 
-	in = isl_basic_map_dim(bmap1, isl_dim_in);
-	out1 = isl_basic_map_n_out(bmap1);
-	out2 = isl_basic_map_n_out(bmap2);
-	nparam = isl_basic_map_n_param(bmap1);
-
 	total = nparam + in + out1 + out2 + bmap1->n_div + bmap2->n_div;
 	dim_map1 = isl_dim_map_alloc(bmap1->ctx, total);
 	dim_map2 = isl_dim_map_alloc(bmap1->ctx, total);
@@ -9543,12 +10775,14 @@
 	isl_dim_map_div(dim_map1, bmap1, pos += out2);
 	isl_dim_map_div(dim_map2, bmap2, pos += bmap1->n_div);
 
-	bmap = isl_basic_map_alloc_space(dim_result,
+	bmap = isl_basic_map_alloc_space(space_result,
 			bmap1->n_div + bmap2->n_div,
 			bmap1->n_eq + bmap2->n_eq,
 			bmap1->n_ineq + bmap2->n_ineq);
 	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap1, dim_map1);
 	bmap = isl_basic_map_add_constraints_dim_map(bmap, bmap2, dim_map2);
+	if (rational)
+		bmap = isl_basic_map_set_rational(bmap);
 	bmap = isl_basic_map_simplify(bmap);
 	return isl_basic_map_finalize(bmap);
 error:
@@ -9587,12 +10821,14 @@
 	unsigned flags = 0;
 	struct isl_map *result;
 	int i, j;
+	isl_bool m;
 
-	if (!map1 || !map2)
+	m = isl_map_has_equal_params(map1, map2);
+	if (m < 0)
 		goto error;
-
-	isl_assert(map1->ctx, isl_space_match(map1->dim, isl_dim_param,
-					 map2->dim, isl_dim_param), goto error);
+	if (!m)
+		isl_die(isl_map_get_ctx(map1), isl_error_invalid,
+			"parameters don't match", goto error);
 
 	if (ISL_F_ISSET(map1, ISL_MAP_DISJOINT) &&
 	    ISL_F_ISSET(map2, ISL_MAP_DISJOINT))
@@ -9628,19 +10864,14 @@
 
 /* Given two maps A -> B and C -> D, construct a map A -> C -> B -> D
  */
-static __isl_give isl_map *map_product_aligned(__isl_take isl_map *map1,
+__isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
+	isl_map_align_params_bin(&map1, &map2);
 	return map_product(map1, map2, &isl_space_product,
 			&isl_basic_map_product, 0);
 }
 
-__isl_give isl_map *isl_map_product(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
-{
-	return isl_map_align_params_map_map_and(map1, map2, &map_product_aligned);
-}
-
 /* Given two maps A -> B and C -> D, construct a map (A, C) -> (B, D)
  */
 __isl_give isl_map *isl_map_flat_product(__isl_take isl_map *map1,
@@ -9655,7 +10886,8 @@
 
 /* Given two set A and B, construct its Cartesian product A x B.
  */
-struct isl_set *isl_set_product(struct isl_set *set1, struct isl_set *set2)
+__isl_give isl_set *isl_set_product(__isl_take isl_set *set1,
+	__isl_take isl_set *set2)
 {
 	return isl_map_range_product(set1, set2);
 }
@@ -9668,34 +10900,130 @@
 
 /* Given two maps A -> B and C -> D, construct a map A -> C -> (B * D)
  */
-static __isl_give isl_map *map_domain_product_aligned(__isl_take isl_map *map1,
+__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
+	isl_map_align_params_bin(&map1, &map2);
 	return map_product(map1, map2, &isl_space_domain_product,
 				&isl_basic_map_domain_product, 1);
 }
 
 /* Given two maps A -> B and C -> D, construct a map (A * C) -> B -> D
  */
-static __isl_give isl_map *map_range_product_aligned(__isl_take isl_map *map1,
+__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
+	isl_map_align_params_bin(&map1, &map2);
 	return map_product(map1, map2, &isl_space_range_product,
 				&isl_basic_map_range_product, 1);
 }
 
-__isl_give isl_map *isl_map_domain_product(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
+/* Given a map of the form A -> B -> C -> D, return the map A -> C.
+ */
+__isl_give isl_map *isl_map_factor_domain(__isl_take isl_map *map)
 {
-	return isl_map_align_params_map_map_and(map1, map2,
-						&map_domain_product_aligned);
+	isl_space *space;
+	isl_size total1, keep1, total2, keep2;
+
+	total1 = isl_map_dim(map, isl_dim_in);
+	total2 = isl_map_dim(map, isl_dim_out);
+	if (total1 < 0 || total2 < 0)
+		return isl_map_free(map);
+	if (!isl_space_domain_is_wrapping(map->dim) ||
+	    !isl_space_range_is_wrapping(map->dim))
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"not a product", return isl_map_free(map));
+
+	space = isl_map_get_space(map);
+	space = isl_space_factor_domain(space);
+	keep1 = isl_space_dim(space, isl_dim_in);
+	keep2 = isl_space_dim(space, isl_dim_out);
+	if (keep1 < 0 || keep2 < 0)
+		map = isl_map_free(map);
+	map = isl_map_project_out(map, isl_dim_in, keep1, total1 - keep1);
+	map = isl_map_project_out(map, isl_dim_out, keep2, total2 - keep2);
+	map = isl_map_reset_space(map, space);
+
+	return map;
 }
 
-__isl_give isl_map *isl_map_range_product(__isl_take isl_map *map1,
-	__isl_take isl_map *map2)
+/* Given a map of the form A -> B -> C -> D, return the map B -> D.
+ */
+__isl_give isl_map *isl_map_factor_range(__isl_take isl_map *map)
+{
+	isl_space *space;
+	isl_size total1, keep1, total2, keep2;
+
+	total1 = isl_map_dim(map, isl_dim_in);
+	total2 = isl_map_dim(map, isl_dim_out);
+	if (total1 < 0 || total2 < 0)
+		return isl_map_free(map);
+	if (!isl_space_domain_is_wrapping(map->dim) ||
+	    !isl_space_range_is_wrapping(map->dim))
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"not a product", return isl_map_free(map));
+
+	space = isl_map_get_space(map);
+	space = isl_space_factor_range(space);
+	keep1 = isl_space_dim(space, isl_dim_in);
+	keep2 = isl_space_dim(space, isl_dim_out);
+	if (keep1 < 0 || keep2 < 0)
+		map = isl_map_free(map);
+	map = isl_map_project_out(map, isl_dim_in, 0, total1 - keep1);
+	map = isl_map_project_out(map, isl_dim_out, 0, total2 - keep2);
+	map = isl_map_reset_space(map, space);
+
+	return map;
+}
+
+/* Given a map of the form A -> B -> C, return the map A -> C.
+ */
+__isl_give isl_map *isl_map_domain_factor_domain(__isl_take isl_map *map)
 {
-	return isl_map_align_params_map_map_and(map1, map2,
-						&map_range_product_aligned);
+	isl_space *space;
+	isl_size total, keep;
+
+	total = isl_map_dim(map, isl_dim_in);
+	if (total < 0)
+		return isl_map_free(map);
+	if (!isl_space_domain_is_wrapping(map->dim))
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"domain is not a product", return isl_map_free(map));
+
+	space = isl_map_get_space(map);
+	space = isl_space_domain_factor_domain(space);
+	keep = isl_space_dim(space, isl_dim_in);
+	if (keep < 0)
+		map = isl_map_free(map);
+	map = isl_map_project_out(map, isl_dim_in, keep, total - keep);
+	map = isl_map_reset_space(map, space);
+
+	return map;
+}
+
+/* Given a map of the form A -> B -> C, return the map B -> C.
+ */
+__isl_give isl_map *isl_map_domain_factor_range(__isl_take isl_map *map)
+{
+	isl_space *space;
+	isl_size total, keep;
+
+	total = isl_map_dim(map, isl_dim_in);
+	if (total < 0)
+		return isl_map_free(map);
+	if (!isl_space_domain_is_wrapping(map->dim))
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"domain is not a product", return isl_map_free(map));
+
+	space = isl_map_get_space(map);
+	space = isl_space_domain_factor_range(space);
+	keep = isl_space_dim(space, isl_dim_in);
+	if (keep < 0)
+		map = isl_map_free(map);
+	map = isl_map_project_out(map, isl_dim_in, 0, total - keep);
+	map = isl_map_reset_space(map, space);
+
+	return map;
 }
 
 /* Given a map A -> B -> C, extract the map A -> B.
@@ -9703,18 +11031,20 @@
 __isl_give isl_map *isl_map_range_factor_domain(__isl_take isl_map *map)
 {
 	isl_space *space;
-	int total, keep;
+	isl_size total, keep;
 
-	if (!map)
-		return NULL;
+	total = isl_map_dim(map, isl_dim_out);
+	if (total < 0)
+		return isl_map_free(map);
 	if (!isl_space_range_is_wrapping(map->dim))
 		isl_die(isl_map_get_ctx(map), isl_error_invalid,
 			"range is not a product", return isl_map_free(map));
 
 	space = isl_map_get_space(map);
-	total = isl_space_dim(space, isl_dim_out);
 	space = isl_space_range_factor_domain(space);
 	keep = isl_space_dim(space, isl_dim_out);
+	if (keep < 0)
+		map = isl_map_free(map);
 	map = isl_map_project_out(map, isl_dim_out, keep, total - keep);
 	map = isl_map_reset_space(map, space);
 
@@ -9726,18 +11056,20 @@
 __isl_give isl_map *isl_map_range_factor_range(__isl_take isl_map *map)
 {
 	isl_space *space;
-	int total, keep;
+	isl_size total, keep;
 
-	if (!map)
-		return NULL;
+	total = isl_map_dim(map, isl_dim_out);
+	if (total < 0)
+		return isl_map_free(map);
 	if (!isl_space_range_is_wrapping(map->dim))
 		isl_die(isl_map_get_ctx(map), isl_error_invalid,
 			"range is not a product", return isl_map_free(map));
 
 	space = isl_map_get_space(map);
-	total = isl_space_dim(space, isl_dim_out);
 	space = isl_space_range_factor_range(space);
 	keep = isl_space_dim(space, isl_dim_out);
+	if (keep < 0)
+		map = isl_map_free(map);
 	map = isl_map_project_out(map, isl_dim_out, 0, total - keep);
 	map = isl_map_reset_space(map, space);
 
@@ -9772,15 +11104,15 @@
 {
 	int i;
 	uint32_t hash = isl_hash_init();
-	unsigned total;
+	isl_size total;
 
 	if (!bmap)
 		return 0;
 	bmap = isl_basic_map_copy(bmap);
 	bmap = isl_basic_map_normalize(bmap);
-	if (!bmap)
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return 0;
-	total = isl_basic_map_total_dim(bmap);
 	isl_hash_byte(hash, bmap->n_eq & 0xFF);
 	for (i = 0; i < bmap->n_eq; ++i) {
 		uint32_t c_hash;
@@ -9808,7 +11140,7 @@
 
 uint32_t isl_basic_set_get_hash(__isl_keep isl_basic_set *bset)
 {
-	return isl_basic_map_get_hash((isl_basic_map *)bset);
+	return isl_basic_map_get_hash(bset_to_bmap(bset));
 }
 
 uint32_t isl_map_get_hash(__isl_keep isl_map *map)
@@ -9837,92 +11169,98 @@
 
 uint32_t isl_set_get_hash(__isl_keep isl_set *set)
 {
-	return isl_map_get_hash((isl_map *)set);
+	return isl_map_get_hash(set_to_map(set));
 }
 
-/* Check if the value for dimension dim is completely determined
- * by the values of the other parameters and variables.
- * That is, check if dimension dim is involved in an equality.
+/* Return the number of basic maps in the (current) representation of "map".
  */
-int isl_basic_set_dim_is_unique(struct isl_basic_set *bset, unsigned dim)
+isl_size isl_map_n_basic_map(__isl_keep isl_map *map)
 {
-	int i;
-	unsigned nparam;
+	return map ? map->n : isl_size_error;
+}
 
-	if (!bset)
-		return -1;
-	nparam = isl_basic_set_n_param(bset);
-	for (i = 0; i < bset->n_eq; ++i)
-		if (!isl_int_is_zero(bset->eqi1 + nparam + dim))
-			return 1;
-	return 0;
+isl_size isl_set_n_basic_set(__isl_keep isl_set *set)
+{
+	return set ? set->n : isl_size_error;
 }
 
-/* Check if the value for dimension dim is completely determined
- * by the values of the other parameters and variables.
- * That is, check if dimension dim is involved in an equality
- * for each of the subsets.
- */
-int isl_set_dim_is_unique(struct isl_set *set, unsigned dim)
+isl_stat isl_map_foreach_basic_map(__isl_keep isl_map *map,
+	isl_stat (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
 {
 	int i;
 
-	if (!set)
-		return -1;
-	for (i = 0; i < set->n; ++i) {
-		int unique;
-		unique = isl_basic_set_dim_is_unique(set->pi, dim);
-		if (unique != 1)
-			return unique;
-	}
-	return 1;
-}
+	if (!map)
+		return isl_stat_error;
 
-/* Return the number of basic maps in the (current) representation of "map".
- */
-int isl_map_n_basic_map(__isl_keep isl_map *map)
-{
-	return map ? map->n : 0;
+	for (i = 0; i < map->n; ++i)
+		if (fn(isl_basic_map_copy(map->pi), user) < 0)
+			return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
-int isl_set_n_basic_set(__isl_keep isl_set *set)
+isl_stat isl_set_foreach_basic_set(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
 {
-	return set ? set->n : 0;
+	int i;
+
+	if (!set)
+		return isl_stat_error;
+
+	for (i = 0; i < set->n; ++i)
+		if (fn(isl_basic_set_copy(set->pi), user) < 0)
+			return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
-int isl_map_foreach_basic_map(__isl_keep isl_map *map,
-	int (*fn)(__isl_take isl_basic_map *bmap, void *user), void *user)
+/* Does "test" succeed on every basic set in "set"?
+ */
+isl_bool isl_set_every_basic_set(__isl_keep isl_set *set,
+	isl_bool (*test)(__isl_keep isl_basic_set *bset, void *user),
+	void *user)
 {
 	int i;
 
-	if (!map)
-		return -1;
+	if (!set)
+		return isl_bool_error;
 
-	for (i = 0; i < map->n; ++i)
-		if (fn(isl_basic_map_copy(map->pi), user) < 0)
-			return -1;
+	for (i = 0; i < set->n; ++i) {
+		isl_bool r;
 
-	return 0;
+		r = test(set->pi, user);
+		if (r < 0 || !r)
+			return r;
+	}
+
+	return isl_bool_true;
 }
 
-int isl_set_foreach_basic_set(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_basic_set *bset, void *user), void *user)
+/* Return a list of basic sets, the union of which is equal to "set".
+ */
+__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
+	__isl_keep isl_set *set)
 {
 	int i;
+	isl_basic_set_list *list;
 
 	if (!set)
-		return -1;
+		return NULL;
 
-	for (i = 0; i < set->n; ++i)
-		if (fn(isl_basic_set_copy(set->pi), user) < 0)
-			return -1;
+	list = isl_basic_set_list_alloc(isl_set_get_ctx(set), set->n);
+	for (i = 0; i < set->n; ++i) {
+		isl_basic_set *bset;
 
-	return 0;
+		bset = isl_basic_set_copy(set->pi);
+		list = isl_basic_set_list_add(list, bset);
+	}
+
+	return list;
 }
 
 __isl_give isl_basic_set *isl_basic_set_lift(__isl_take isl_basic_set *bset)
 {
-	isl_space *dim;
+	isl_space *space;
 
 	if (!bset)
 		return NULL;
@@ -9931,12 +11269,12 @@
 	if (!bset)
 		return NULL;
 
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_lift(dim, bset->n_div);
-	if (!dim)
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_lift(space, bset->n_div);
+	if (!space)
 		goto error;
 	isl_space_free(bset->dim);
-	bset->dim = dim;
+	bset->dim = space;
 	bset->extra -= bset->n_div;
 	bset->n_div = 0;
 
@@ -9951,10 +11289,10 @@
 __isl_give isl_set *isl_set_lift(__isl_take isl_set *set)
 {
 	int i;
-	isl_space *dim;
+	isl_space *space;
 	unsigned n_div;
 
-	set = isl_set_align_divs(set);
+	set = set_from_map(isl_map_align_divs_internal(set_to_map(set)));
 
 	if (!set)
 		return NULL;
@@ -9964,12 +11302,12 @@
 		return NULL;
 
 	n_div = set->p0->n_div;
-	dim = isl_set_get_space(set);
-	dim = isl_space_lift(dim, n_div);
-	if (!dim)
+	space = isl_set_get_space(set);
+	space = isl_space_lift(space, n_div);
+	if (!space)
 		goto error;
 	isl_space_free(set->dim);
-	set->dim = dim;
+	set->dim = space;
 
 	for (i = 0; i < set->n; ++i) {
 		set->pi = isl_basic_set_lift(set->pi);
@@ -9983,76 +11321,14 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_set_lifting(__isl_take isl_set *set)
-{
-	isl_space *dim;
-	struct isl_basic_map *bmap;
-	unsigned n_set;
-	unsigned n_div;
-	unsigned n_param;
-	unsigned total;
-	int i, k, l;
-
-	set = isl_set_align_divs(set);
-
-	if (!set)
-		return NULL;
-
-	dim = isl_set_get_space(set);
-	if (set->n == 0 || set->p0->n_div == 0) {
-		isl_set_free(set);
-		return isl_map_identity(isl_space_map_from_set(dim));
-	}
-
-	n_div = set->p0->n_div;
-	dim = isl_space_map_from_set(dim);
-	n_param = isl_space_dim(dim, isl_dim_param);
-	n_set = isl_space_dim(dim, isl_dim_in);
-	dim = isl_space_extend(dim, n_param, n_set, n_set + n_div);
-	bmap = isl_basic_map_alloc_space(dim, 0, n_set, 2 * n_div);
-	for (i = 0; i < n_set; ++i)
-		bmap = var_equal(bmap, i);
-
-	total = n_param + n_set + n_set + n_div;
-	for (i = 0; i < n_div; ++i) {
-		k = isl_basic_map_alloc_inequality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bmap->ineqk, set->p0->divi+1, 1+n_param);
-		isl_seq_clr(bmap->ineqk+1+n_param, n_set);
-		isl_seq_cpy(bmap->ineqk+1+n_param+n_set,
-			    set->p0->divi+1+1+n_param, n_set + n_div);
-		isl_int_neg(bmap->ineqk1+n_param+n_set+n_set+i,
-			    set->p0->divi0);
-
-		l = isl_basic_map_alloc_inequality(bmap);
-		if (l < 0)
-			goto error;
-		isl_seq_neg(bmap->ineql, bmap->ineqk, 1 + total);
-		isl_int_add(bmap->ineql0, bmap->ineql0,
-			    set->p0->divi0);
-		isl_int_sub_ui(bmap->ineql0, bmap->ineql0, 1);
-	}
-
-	isl_set_free(set);
-	bmap = isl_basic_map_simplify(bmap);
-	bmap = isl_basic_map_finalize(bmap);
-	return isl_map_from_basic_map(bmap);
-error:
-	isl_set_free(set);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
 int isl_basic_set_size(__isl_keep isl_basic_set *bset)
 {
-	unsigned dim;
+	isl_size dim;
 	int size = 0;
 
-	if (!bset)
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
 		return -1;
-
-	dim = isl_basic_set_total_dim(bset);
 	size += bset->n_eq * (1 + dim);
 	size += bset->n_ineq * (1 + dim);
 	size += bset->n_div * (2 + dim);
@@ -10077,15 +11353,13 @@
 /* Check if there is any lower bound (if lower == 0) and/or upper
  * bound (if upper == 0) on the specified dim.
  */
-static int basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
+static isl_bool basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos, int lower, int upper)
 {
 	int i;
 
-	if (!bmap)
-		return -1;
-
-	isl_assert(bmap->ctx, pos < isl_basic_map_dim(bmap, type), return -1);
+	if (isl_basic_map_check_range(bmap, type, pos, 1) < 0)
+		return isl_bool_error;
 
 	pos += isl_basic_map_offset(bmap, type);
 
@@ -10093,12 +11367,12 @@
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
 		if (!isl_int_is_zero(bmap->divi1 + pos))
-			return 1;
+			return isl_bool_true;
 	}
 
 	for (i = 0; i < bmap->n_eq; ++i)
 		if (!isl_int_is_zero(bmap->eqipos))
-			return 1;
+			return isl_bool_true;
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		int sgn = isl_int_sgn(bmap->ineqipos);
@@ -10111,76 +11385,76 @@
 	return lower && upper;
 }
 
-int isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_dim_is_bounded(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos)
 {
 	return basic_map_dim_is_bounded(bmap, type, pos, 0, 0);
 }
 
-int isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_dim_has_lower_bound(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos)
 {
 	return basic_map_dim_is_bounded(bmap, type, pos, 0, 1);
 }
 
-int isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_dim_has_upper_bound(__isl_keep isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned pos)
 {
 	return basic_map_dim_is_bounded(bmap, type, pos, 1, 0);
 }
 
-int isl_map_dim_is_bounded(__isl_keep isl_map *map,
+isl_bool isl_map_dim_is_bounded(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos)
 {
 	int i;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
-		int bounded;
+		isl_bool bounded;
 		bounded = isl_basic_map_dim_is_bounded(map->pi, type, pos);
 		if (bounded < 0 || !bounded)
 			return bounded;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-/* Return 1 if the specified dim is involved in both an upper bound
+/* Return true if the specified dim is involved in both an upper bound
  * and a lower bound.
  */
-int isl_set_dim_is_bounded(__isl_keep isl_set *set,
+isl_bool isl_set_dim_is_bounded(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
-	return isl_map_dim_is_bounded((isl_map *)set, type, pos);
+	return isl_map_dim_is_bounded(set_to_map(set), type, pos);
 }
 
 /* Does "map" have a bound (according to "fn") for any of its basic maps?
  */
-static int has_any_bound(__isl_keep isl_map *map,
+static isl_bool has_any_bound(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos,
-	int (*fn)(__isl_keep isl_basic_map *bmap,
+	isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
 		  enum isl_dim_type type, unsigned pos))
 {
 	int i;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
-		int bounded;
+		isl_bool bounded;
 		bounded = fn(map->pi, type, pos);
 		if (bounded < 0 || bounded)
 			return bounded;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
 /* Return 1 if the specified dim is involved in any lower bound.
  */
-int isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_any_lower_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
 	return has_any_bound(set, type, pos,
@@ -10189,7 +11463,7 @@
 
 /* Return 1 if the specified dim is involved in any upper bound.
  */
-int isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_any_upper_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
 	return has_any_bound(set, type, pos,
@@ -10198,29 +11472,29 @@
 
 /* Does "map" have a bound (according to "fn") for all of its basic maps?
  */
-static int has_bound(__isl_keep isl_map *map,
+static isl_bool has_bound(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos,
-	int (*fn)(__isl_keep isl_basic_map *bmap,
+	isl_bool (*fn)(__isl_keep isl_basic_map *bmap,
 		  enum isl_dim_type type, unsigned pos))
 {
 	int i;
 
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
-		int bounded;
+		isl_bool bounded;
 		bounded = fn(map->pi, type, pos);
 		if (bounded < 0 || !bounded)
 			return bounded;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Return 1 if the specified dim has a lower bound (in each of its basic sets).
  */
-int isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_lower_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
 	return has_bound(set, type, pos, &isl_basic_map_dim_has_lower_bound);
@@ -10228,7 +11502,7 @@
 
 /* Return 1 if the specified dim has an upper bound (in each of its basic sets).
  */
-int isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
+isl_bool isl_set_dim_has_upper_bound(__isl_keep isl_set *set,
 	enum isl_dim_type type, unsigned pos)
 {
 	return has_bound(set, type, pos, &isl_basic_map_dim_has_upper_bound);
@@ -10242,18 +11516,20 @@
  *	-1 means that the variable is non-positive
  *	0 means the variable attains both positive and negative values.
  */
-int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
+isl_stat isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
 	unsigned first, unsigned n, int *signs)
 {
 	isl_vec *bound = NULL;
 	struct isl_tab *tab = NULL;
 	struct isl_tab_undo *snap;
 	int i;
+	isl_size total;
 
-	if (!bset || !signs)
-		return -1;
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0 || !signs)
+		return isl_stat_error;
 
-	bound = isl_vec_alloc(bset->ctx, 1 + isl_basic_set_total_dim(bset));
+	bound = isl_vec_alloc(bset->ctx, 1 + total);
 	tab = isl_tab_from_basic_set(bset, 0);
 	if (!bound || !tab)
 		goto error;
@@ -10291,20 +11567,20 @@
 
 	isl_tab_free(tab);
 	isl_vec_free(bound);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_tab_free(tab);
 	isl_vec_free(bound);
-	return -1;
+	return isl_stat_error;
 }
 
-int isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
+isl_stat isl_basic_set_dims_get_sign(__isl_keep isl_basic_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n, int *signs)
 {
 	if (!bset || !signs)
-		return -1;
-	isl_assert(bset->ctx, first + n <= isl_basic_set_dim(bset, type),
-		return -1);
+		return isl_stat_error;
+	if (isl_basic_set_check_range(bset, type, first, n) < 0)
+		return isl_stat_error;
 
 	first += pos(bset->dim, type) - 1;
 	return isl_basic_set_vars_get_sign(bset, first, n, signs);
@@ -10318,32 +11594,137 @@
  * Otherwise, we check if it actually depends on them or on any integer
  * divisions that may depend on them.
  */
-static int div_may_involve_output(__isl_keep isl_basic_map *bmap, int div)
+static isl_bool div_may_involve_output(__isl_keep isl_basic_map *bmap, int div)
 {
 	int i;
-	unsigned n_out, o_out;
-	unsigned n_div, o_div;
+	isl_size n_out, n_div;
+	unsigned o_out, o_div;
 
 	if (isl_int_is_zero(bmap->divdiv0))
-		return 1;
+		return isl_bool_true;
 
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n_out < 0)
+		return isl_bool_error;
 	o_out = isl_basic_map_offset(bmap, isl_dim_out);
 
 	if (isl_seq_first_non_zero(bmap->divdiv + 1 + o_out, n_out) != -1)
-		return 1;
+		return isl_bool_true;
 
 	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
 	o_div = isl_basic_map_offset(bmap, isl_dim_div);
 
 	for (i = 0; i < n_div; ++i) {
+		isl_bool may_involve;
+
 		if (isl_int_is_zero(bmap->divdiv1 + o_div + i))
 			continue;
-		if (div_may_involve_output(bmap, i))
-			return 1;
+		may_involve = div_may_involve_output(bmap, i);
+		if (may_involve < 0 || may_involve)
+			return may_involve;
 	}
 
-	return 0;
+	return isl_bool_false;
+}
+
+/* Return the first integer division of "bmap" in the range
+ * first, first + n that may depend on any output dimensions and
+ * that has a non-zero coefficient in "c" (where the first coefficient
+ * in "c" corresponds to integer division "first").
+ */
+static int first_div_may_involve_output(__isl_keep isl_basic_map *bmap,
+	isl_int *c, int first, int n)
+{
+	int k;
+
+	if (!bmap)
+		return -1;
+
+	for (k = first; k < first + n; ++k) {
+		isl_bool may_involve;
+
+		if (isl_int_is_zero(ck))
+			continue;
+		may_involve = div_may_involve_output(bmap, k);
+		if (may_involve < 0)
+			return -1;
+		if (may_involve)
+			return k;
+	}
+
+	return first + n;
+}
+
+/* Look for a pair of inequality constraints in "bmap" of the form
+ *
+ *	-l + i >= 0		or		i >= l
+ * and
+ *	n + l - i >= 0		or		i <= l + n
+ *
+ * with n < "m" and i the output dimension at position "pos".
+ * (Note that n >= 0 as otherwise the two constraints would conflict.)
+ * Furthermore, "l" is only allowed to involve parameters, input dimensions
+ * and earlier output dimensions, as well as integer divisions that do
+ * not involve any of the output dimensions.
+ *
+ * Return the index of the first inequality constraint or bmap->n_ineq
+ * if no such pair can be found.
+ */
+static int find_modulo_constraint_pair(__isl_keep isl_basic_map *bmap,
+	int pos, isl_int m)
+{
+	int i, j;
+	isl_ctx *ctx;
+	isl_size total;
+	isl_size n_div, n_out;
+	unsigned o_div, o_out;
+	int less;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (total < 0 || n_out < 0 || n_div < 0)
+		return -1;
+
+	ctx = isl_basic_map_get_ctx(bmap);
+	o_out = isl_basic_map_offset(bmap, isl_dim_out);
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	for (i = 0; i < bmap->n_ineq; ++i) {
+		if (!isl_int_abs_eq(bmap->ineqio_out + pos, ctx->one))
+			continue;
+		if (isl_seq_first_non_zero(bmap->ineqi + o_out + pos + 1,
+					n_out - (pos + 1)) != -1)
+			continue;
+		if (first_div_may_involve_output(bmap, bmap->ineqi + o_div,
+						0, n_div) < n_div)
+			continue;
+		for (j = i + 1; j < bmap->n_ineq; ++j) {
+			if (!isl_int_abs_eq(bmap->ineqjo_out + pos,
+					    ctx->one))
+				continue;
+			if (!isl_seq_is_neg(bmap->ineqi + 1,
+					    bmap->ineqj + 1, total))
+				continue;
+			break;
+		}
+		if (j >= bmap->n_ineq)
+			continue;
+		isl_int_add(bmap->ineqi0,
+			    bmap->ineqi0, bmap->ineqj0);
+		less = isl_int_abs_lt(bmap->ineqi0, m);
+		isl_int_sub(bmap->ineqi0,
+			    bmap->ineqi0, bmap->ineqj0);
+		if (!less)
+			continue;
+		if (isl_int_is_one(bmap->ineqio_out + pos))
+			return i;
+		else
+			return j;
+	}
+
+	return bmap->n_ineq;
 }
 
 /* Return the index of the equality of "bmap" that defines
@@ -10351,38 +11732,70 @@
  * The equality may also involve integer divisions, as long
  * as those integer divisions are defined in terms of
  * parameters or input dimensions.
+ * In this case, *div is set to the number of integer divisions and
+ * *ineq is set to the number of inequality constraints (provided
+ * div and ineq are not NULL).
+ *
+ * The equality may also involve a single integer division involving
+ * the output dimensions (typically only output dimension "pos") as
+ * long as the coefficient of output dimension "pos" is 1 or -1 and
+ * there is a pair of constraints i >= l and i <= l + n, with i referring
+ * to output dimension "pos", l an expression involving only earlier
+ * dimensions and n smaller than the coefficient of the integer division
+ * in the equality.  In this case, the output dimension can be defined
+ * in terms of a modulo expression that does not involve the integer division.
+ * *div is then set to this single integer division and
+ * *ineq is set to the index of constraint i >= l.
+ *
  * Return bmap->n_eq if there is no such equality.
  * Return -1 on error.
  */
 int isl_basic_map_output_defining_equality(__isl_keep isl_basic_map *bmap,
-	int pos)
+	int pos, int *div, int *ineq)
 {
-	int j, k;
-	unsigned n_out, o_out;
-	unsigned n_div, o_div;
+	int j, k, l;
+	isl_size n_div, n_out;
+	unsigned o_div, o_out;
 
-	if (!bmap)
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_out < 0 || n_div < 0)
 		return -1;
 
-	n_out = isl_basic_map_dim(bmap, isl_dim_out);
 	o_out = isl_basic_map_offset(bmap, isl_dim_out);
-	n_div = isl_basic_map_dim(bmap, isl_dim_div);
 	o_div = isl_basic_map_offset(bmap, isl_dim_div);
 
+	if (ineq)
+		*ineq = bmap->n_ineq;
+	if (div)
+		*div = n_div;
 	for (j = 0; j < bmap->n_eq; ++j) {
 		if (isl_int_is_zero(bmap->eqjo_out + pos))
 			continue;
 		if (isl_seq_first_non_zero(bmap->eqj + o_out + pos + 1,
 					n_out - (pos + 1)) != -1)
 			continue;
-		for (k = 0; k < n_div; ++k) {
-			if (isl_int_is_zero(bmap->eqjo_div + k))
-				continue;
-			if (div_may_involve_output(bmap, k))
-				break;
-		}
+		k = first_div_may_involve_output(bmap, bmap->eqj + o_div,
+						0, n_div);
 		if (k >= n_div)
 			return j;
+		if (!isl_int_is_one(bmap->eqjo_out + pos) &&
+		    !isl_int_is_negone(bmap->eqjo_out + pos))
+			continue;
+		if (first_div_may_involve_output(bmap, bmap->eqj + o_div,
+						k + 1, n_div - (k+1)) < n_div)
+			continue;
+		l = find_modulo_constraint_pair(bmap, pos,
+						bmap->eqjo_div + k);
+		if (l < 0)
+			return -1;
+		if (l >= bmap->n_ineq)
+			continue;
+		if (div)
+			*div = k;
+		if (ineq)
+			*ineq = l;
+		return j;
 	}
 
 	return bmap->n_eq;
@@ -10393,27 +11806,27 @@
  * an equality that defines the output dimension in terms of
  * earlier dimensions.
  */
-int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap)
 {
 	int i;
-	unsigned n_out;
-
-	if (!bmap)
-		return -1;
+	isl_size n_out;
 
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n_out < 0)
+		return isl_bool_error;
 
 	for (i = 0; i < n_out; ++i) {
 		int eq;
 
-		eq = isl_basic_map_output_defining_equality(bmap, i);
+		eq = isl_basic_map_output_defining_equality(bmap, i,
+							    NULL, NULL);
 		if (eq < 0)
-			return -1;
+			return isl_bool_error;
 		if (eq >= bmap->n_eq)
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Check if the given basic map is single-valued.
@@ -10423,12 +11836,12 @@
  *
  * and check if the result is a subset of the identity mapping.
  */
-int isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_is_single_valued(__isl_keep isl_basic_map *bmap)
 {
 	isl_space *space;
 	isl_basic_map *test;
 	isl_basic_map *id;
-	int sv;
+	isl_bool sv;
 
 	sv = isl_basic_map_plain_is_single_valued(bmap);
 	if (sv < 0 || sv)
@@ -10451,14 +11864,14 @@
 
 /* Check if the given map is obviously single-valued.
  */
-int isl_map_plain_is_single_valued(__isl_keep isl_map *map)
+isl_bool isl_map_plain_is_single_valued(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	if (map->n == 0)
-		return 1;
+		return isl_bool_true;
 	if (map->n >= 2)
-		return 0;
+		return isl_bool_false;
 
 	return isl_basic_map_plain_is_single_valued(map->p0);
 }
@@ -10470,12 +11883,12 @@
  *
  * and check if the result is a subset of the identity mapping.
  */
-int isl_map_is_single_valued(__isl_keep isl_map *map)
+isl_bool isl_map_is_single_valued(__isl_keep isl_map *map)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_map *test;
 	isl_map *id;
-	int sv;
+	isl_bool sv;
 
 	sv = isl_map_plain_is_single_valued(map);
 	if (sv < 0 || sv)
@@ -10484,8 +11897,8 @@
 	test = isl_map_reverse(isl_map_copy(map));
 	test = isl_map_apply_range(test, isl_map_copy(map));
 
-	dim = isl_space_map_from_set(isl_space_range(isl_map_get_space(map)));
-	id = isl_map_identity(dim);
+	space = isl_space_map_from_set(isl_space_range(isl_map_get_space(map)));
+	id = isl_map_identity(space);
 
 	sv = isl_map_is_subset(test, id);
 
@@ -10495,9 +11908,9 @@
 	return sv;
 }
 
-int isl_map_is_injective(__isl_keep isl_map *map)
+isl_bool isl_map_is_injective(__isl_keep isl_map *map)
 {
-	int in;
+	isl_bool in;
 
 	map = isl_map_copy(map);
 	map = isl_map_reverse(map);
@@ -10509,9 +11922,9 @@
 
 /* Check if the given map is obviously injective.
  */
-int isl_map_plain_is_injective(__isl_keep isl_map *map)
+isl_bool isl_map_plain_is_injective(__isl_keep isl_map *map)
 {
-	int in;
+	isl_bool in;
 
 	map = isl_map_copy(map);
 	map = isl_map_reverse(map);
@@ -10521,9 +11934,9 @@
 	return in;
 }
 
-int isl_map_is_bijective(__isl_keep isl_map *map)
+isl_bool isl_map_is_bijective(__isl_keep isl_map *map)
 {
-	int sv;
+	isl_bool sv;
 
 	sv = isl_map_is_single_valued(map);
 	if (sv < 0 || !sv)
@@ -10532,9 +11945,32 @@
 	return isl_map_is_injective(map);
 }
 
-int isl_set_is_singleton(__isl_keep isl_set *set)
+isl_bool isl_set_is_singleton(__isl_keep isl_set *set)
 {
-	return isl_map_is_single_valued((isl_map *)set);
+	return isl_map_is_single_valued(set_to_map(set));
+}
+
+/* Does "map" only map elements to themselves?
+ *
+ * If the domain and range spaces are different, then "map"
+ * is considered not to be an identity relation, even if it is empty.
+ * Otherwise, construct the maximal identity relation and
+ * check whether "map" is a subset of this relation.
+ */
+isl_bool isl_map_is_identity(__isl_keep isl_map *map)
+{
+	isl_map *id;
+	isl_bool equal, is_identity;
+
+	equal = isl_map_tuple_is_equal(map, isl_dim_in, map, isl_dim_out);
+	if (equal < 0 || !equal)
+		return equal;
+
+	id = isl_map_identity(isl_map_get_space(map));
+	is_identity = isl_map_is_subset(map, id);
+	isl_map_free(id);
+
+	return is_identity;
 }
 
 int isl_map_is_translation(__isl_keep isl_map *map)
@@ -10558,19 +11994,21 @@
 	return 1;
 }
 
-int isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
+isl_bool isl_basic_set_is_box(__isl_keep isl_basic_set *bset)
 {
 	int i, j;
-	unsigned nvar;
+	isl_size nvar, n_div;
 	unsigned ovar;
 
-	if (!bset)
-		return -1;
-
-	if (isl_basic_set_dim(bset, isl_dim_div) != 0)
-		return 0;
+	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
+	if (n_div != 0)
+		return isl_bool_false;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0)
+		return isl_bool_error;
 	ovar = isl_space_offset(bset->dim, isl_dim_set);
 	for (j = 0; j < nvar; ++j) {
 		int lower = 0, upper = 0;
@@ -10578,7 +12016,7 @@
 			if (isl_int_is_zero(bset->eqi1 + ovar + j))
 				continue;
 			if (!unique(bset->eqi + 1 + ovar, j, nvar))
-				return 0;
+				return isl_bool_false;
 			break;
 		}
 		if (i < bset->n_eq)
@@ -10587,104 +12025,119 @@
 			if (isl_int_is_zero(bset->ineqi1 + ovar + j))
 				continue;
 			if (!unique(bset->ineqi + 1 + ovar, j, nvar))
-				return 0;
+				return isl_bool_false;
 			if (isl_int_is_pos(bset->ineqi1 + ovar + j))
 				lower = 1;
 			else
 				upper = 1;
 		}
 		if (!lower || !upper)
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-int isl_set_is_box(__isl_keep isl_set *set)
+isl_bool isl_set_is_box(__isl_keep isl_set *set)
 {
 	if (!set)
-		return -1;
+		return isl_bool_error;
 	if (set->n != 1)
-		return 0;
+		return isl_bool_false;
 
 	return isl_basic_set_is_box(set->p0);
 }
 
-int isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset)
+isl_bool isl_basic_set_is_wrapping(__isl_keep isl_basic_set *bset)
 {
 	if (!bset)
-		return -1;
+		return isl_bool_error;
 	
 	return isl_space_is_wrapping(bset->dim);
 }
 
-int isl_set_is_wrapping(__isl_keep isl_set *set)
+isl_bool isl_set_is_wrapping(__isl_keep isl_set *set)
 {
 	if (!set)
-		return -1;
+		return isl_bool_error;
 	
 	return isl_space_is_wrapping(set->dim);
 }
 
+/* Modify the space of "map" through a call to "change".
+ * If "can_change" is set (not NULL), then first call it to check
+ * if the modification is allowed, printing the error message "cannot_change"
+ * if it is not.
+ */
+static __isl_give isl_map *isl_map_change_space(__isl_take isl_map *map,
+	isl_bool (*can_change)(__isl_keep isl_map *map),
+	const char *cannot_change,
+	__isl_give isl_space *(*change)(__isl_take isl_space *space))
+{
+	isl_bool ok;
+	isl_space *space;
+
+	if (!map)
+		return NULL;
+
+	ok = can_change ? can_change(map) : isl_bool_true;
+	if (ok < 0)
+		return isl_map_free(map);
+	if (!ok)
+		isl_die(isl_map_get_ctx(map), isl_error_invalid, cannot_change,
+			return isl_map_free(map));
+
+	space = change(isl_map_get_space(map));
+	map = isl_map_reset_space(map, space);
+
+	return map;
+}
+
 /* Is the domain of "map" a wrapped relation?
  */
-int isl_map_domain_is_wrapping(__isl_keep isl_map *map)
+isl_bool isl_map_domain_is_wrapping(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_domain_is_wrapping(map->dim);
 }
 
+/* Does "map" have a wrapped relation in both domain and range?
+ */
+isl_bool isl_map_is_product(__isl_keep isl_map *map)
+{
+	return isl_space_is_product(isl_map_peek_space(map));
+}
+
 /* Is the range of "map" a wrapped relation?
  */
-int isl_map_range_is_wrapping(__isl_keep isl_map *map)
+isl_bool isl_map_range_is_wrapping(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_range_is_wrapping(map->dim);
 }
 
 __isl_give isl_basic_set *isl_basic_map_wrap(__isl_take isl_basic_map *bmap)
 {
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
+	isl_space *space;
 
-	bmap->dim = isl_space_wrap(bmap->dim);
-	if (!bmap->dim)
-		goto error;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_wrap(space);
+	bmap = isl_basic_map_restore_space(bmap, space);
 
 	bmap = isl_basic_map_finalize(bmap);
 
-	return (isl_basic_set *)bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
+	return bset_from_bmap(bmap);
 }
 
+/* Given a map A -> B, return the set (A -> B).
+ */
 __isl_give isl_set *isl_map_wrap(__isl_take isl_map *map)
 {
-	int i;
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = (isl_basic_map *)isl_basic_map_wrap(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	map->dim = isl_space_wrap(map->dim);
-	if (!map->dim)
-		goto error;
-
-	return (isl_set *)map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return isl_map_change_space(map, NULL, NULL, &isl_space_wrap);
 }
 
 __isl_give isl_basic_map *isl_basic_set_unwrap(__isl_take isl_basic_set *bset)
@@ -10699,72 +12152,40 @@
 
 	bset = isl_basic_set_finalize(bset);
 
-	return (isl_basic_map *)bset;
+	return bset_to_bmap(bset);
 error:
 	isl_basic_set_free(bset);
 	return NULL;
 }
 
+/* Given a set (A -> B), return the map A -> B.
+ * Error out if "set" is not of the form (A -> B).
+ */
 __isl_give isl_map *isl_set_unwrap(__isl_take isl_set *set)
 {
-	int i;
-
-	if (!set)
-		return NULL;
-
-	if (!isl_set_is_wrapping(set))
-		isl_die(set->ctx, isl_error_invalid, "not a wrapping set",
-			goto error);
-
-	set = isl_set_cow(set);
-	if (!set)
-		return NULL;
-
-	for (i = 0; i < set->n; ++i) {
-		set->pi = (isl_basic_set *)isl_basic_set_unwrap(set->pi);
-		if (!set->pi)
-			goto error;
-	}
-
-	set->dim = isl_space_unwrap(set->dim);
-	if (!set->dim)
-		goto error;
-
-	return (isl_map *)set;
-error:
-	isl_set_free(set);
-	return NULL;
+	return isl_map_change_space(set, &isl_set_is_wrapping,
+				    "not a wrapping set", &isl_space_unwrap);
 }
 
 __isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type)
 {
-	if (!bmap)
-		return NULL;
-
-	if (!isl_space_is_named_or_nested(bmap->dim, type))
-		return bmap;
-
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
+	isl_space *space;
 
-	bmap->dim = isl_space_reset(bmap->dim, type);
-	if (!bmap->dim)
-		goto error;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_reset(space, type);
+	bmap = isl_basic_map_restore_space(bmap, space);
 
-	bmap = isl_basic_map_finalize(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
 	enum isl_dim_type type)
 {
 	int i;
+	isl_space *space;
 
 	if (!map)
 		return NULL;
@@ -10781,9 +12202,10 @@
 		if (!map->pi)
 			goto error;
 	}
-	map->dim = isl_space_reset(map->dim, type);
-	if (!map->dim)
-		goto error;
+
+	space = isl_map_take_space(map);
+	space = isl_space_reset(space, type);
+	map = isl_map_restore_space(map, space);
 
 	return map;
 error:
@@ -10793,216 +12215,138 @@
 
 __isl_give isl_basic_map *isl_basic_map_flatten(__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
+	isl_space *space;
 
-	if (!bmap->dim->nested0 && !bmap->dim->nested1)
-		return bmap;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_flatten(space);
+	bmap = isl_basic_map_restore_space(bmap, space);
 
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
-	bmap->dim = isl_space_flatten(bmap->dim);
-	if (!bmap->dim)
-		goto error;
-
-	bmap = isl_basic_map_finalize(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_set *isl_basic_set_flatten(__isl_take isl_basic_set *bset)
 {
-	return (isl_basic_set *)isl_basic_map_flatten((isl_basic_map *)bset);
+	return bset_from_bmap(isl_basic_map_flatten(bset_to_bmap(bset)));
 }
 
 __isl_give isl_basic_map *isl_basic_map_flatten_domain(
 	__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
+	isl_space *space;
 
-	if (!bmap->dim->nested0)
-		return bmap;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_flatten_domain(space);
+	bmap = isl_basic_map_restore_space(bmap, space);
 
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
-	bmap->dim = isl_space_flatten_domain(bmap->dim);
-	if (!bmap->dim)
-		goto error;
-
-	bmap = isl_basic_map_finalize(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_map *isl_basic_map_flatten_range(
 	__isl_take isl_basic_map *bmap)
 {
-	if (!bmap)
-		return NULL;
-
-	if (!bmap->dim->nested1)
-		return bmap;
-
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
+	isl_space *space;
 
-	bmap->dim = isl_space_flatten_range(bmap->dim);
-	if (!bmap->dim)
-		goto error;
+	space = isl_basic_map_take_space(bmap);
+	space = isl_space_flatten_range(space);
+	bmap = isl_basic_map_restore_space(bmap, space);
 
-	bmap = isl_basic_map_finalize(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
+/* Remove any internal structure from the spaces of domain and range of "map".
+ */
 __isl_give isl_map *isl_map_flatten(__isl_take isl_map *map)
 {
-	int i;
-
 	if (!map)
 		return NULL;
 
 	if (!map->dim->nested0 && !map->dim->nested1)
 		return map;
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_flatten(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	map->dim = isl_space_flatten(map->dim);
-	if (!map->dim)
-		goto error;
-
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return isl_map_change_space(map, NULL, NULL, &isl_space_flatten);
 }
 
 __isl_give isl_set *isl_set_flatten(__isl_take isl_set *set)
 {
-	return (isl_set *)isl_map_flatten((isl_map *)set);
+	return set_from_map(isl_map_flatten(set_to_map(set)));
 }
 
 __isl_give isl_map *isl_set_flatten_map(__isl_take isl_set *set)
 {
-	isl_space *dim, *flat_dim;
+	isl_space *space, *flat_space;
 	isl_map *map;
 
-	dim = isl_set_get_space(set);
-	flat_dim = isl_space_flatten(isl_space_copy(dim));
-	map = isl_map_identity(isl_space_join(isl_space_reverse(dim), flat_dim));
+	space = isl_set_get_space(set);
+	flat_space = isl_space_flatten(isl_space_copy(space));
+	map = isl_map_identity(isl_space_join(isl_space_reverse(space),
+						flat_space));
 	map = isl_map_intersect_domain(map, set);
 
 	return map;
 }
 
+/* Remove any internal structure from the space of the domain of "map".
+ */
 __isl_give isl_map *isl_map_flatten_domain(__isl_take isl_map *map)
 {
-	int i;
-
 	if (!map)
 		return NULL;
 
 	if (!map->dim->nested0)
 		return map;
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_flatten_domain(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	map->dim = isl_space_flatten_domain(map->dim);
-	if (!map->dim)
-		goto error;
-
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return isl_map_change_space(map, NULL, NULL, &isl_space_flatten_domain);
 }
 
+/* Remove any internal structure from the space of the range of "map".
+ */
 __isl_give isl_map *isl_map_flatten_range(__isl_take isl_map *map)
 {
-	int i;
-
 	if (!map)
 		return NULL;
 
 	if (!map->dim->nested1)
 		return map;
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_flatten_range(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	map->dim = isl_space_flatten_range(map->dim);
-	if (!map->dim)
-		goto error;
-
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return isl_map_change_space(map, NULL, NULL, &isl_space_flatten_range);
 }
 
 /* Reorder the dimensions of "bmap" according to the given dim_map
- * and set the dimension specification to "dim".
+ * and set the dimension specification to "space" and
+ * perform Gaussian elimination on the result.
  */
 __isl_give isl_basic_map *isl_basic_map_realign(__isl_take isl_basic_map *bmap,
-	__isl_take isl_space *dim, __isl_take struct isl_dim_map *dim_map)
+	__isl_take isl_space *space, __isl_take struct isl_dim_map *dim_map)
 {
 	isl_basic_map *res;
 	unsigned flags;
+	isl_size n_div;
 
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap || !dim || !dim_map)
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0 || !space || !dim_map)
 		goto error;
 
 	flags = bmap->flags;
 	ISL_FL_CLR(flags, ISL_BASIC_MAP_FINAL);
-	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED);
+	ISL_FL_CLR(flags, ISL_BASIC_MAP_SORTED);
 	ISL_FL_CLR(flags, ISL_BASIC_MAP_NORMALIZED_DIVS);
-	res = isl_basic_map_alloc_space(dim,
-			bmap->n_div, bmap->n_eq, bmap->n_ineq);
+	res = isl_basic_map_alloc_space(space, n_div, bmap->n_eq, bmap->n_ineq);
 	res = isl_basic_map_add_constraints_dim_map(res, bmap, dim_map);
 	if (res)
 		res->flags = flags;
+	res = isl_basic_map_gauss(res, NULL);
 	res = isl_basic_map_finalize(res);
 	return res;
 error:
-	free(dim_map);
+	isl_dim_map_free(dim_map);
 	isl_basic_map_free(bmap);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -11021,23 +12365,25 @@
 
 	for (i = 0; i < map->n; ++i) {
 		struct isl_dim_map *dim_map_i;
+		isl_space *space;
 
 		dim_map_i = isl_dim_map_extend(dim_map, map->pi);
 
-		map->pi = isl_basic_map_realign(map->pi,
-					    isl_space_copy(r->dim), dim_map_i);
+		space = isl_reordering_get_space(r);
+		map->pi = isl_basic_map_realign(map->pi, space, dim_map_i);
 
 		if (!map->pi)
 			goto error;
 	}
 
-	map = isl_map_reset_space(map, isl_space_copy(r->dim));
+	map = isl_map_reset_space(map, isl_reordering_get_space(r));
+	map = isl_map_unmark_normalized(map);
 
 	isl_reordering_free(r);
-	free(dim_map);
+	isl_dim_map_free(dim_map);
 	return map;
 error:
-	free(dim_map);
+	isl_dim_map_free(dim_map);
 	isl_map_free(map);
 	isl_reordering_free(r);
 	return NULL;
@@ -11046,13 +12392,14 @@
 __isl_give isl_set *isl_set_realign(__isl_take isl_set *set,
 	__isl_take isl_reordering *r)
 {
-	return (isl_set *)isl_map_realign((isl_map *)set, r);
+	return set_from_map(isl_map_realign(set_to_map(set), r));
 }
 
 __isl_give isl_map *isl_map_align_params(__isl_take isl_map *map,
 	__isl_take isl_space *model)
 {
 	isl_ctx *ctx;
+	isl_bool aligned;
 
 	if (!map || !model)
 		goto error;
@@ -11061,16 +12408,14 @@
 	if (!isl_space_has_named_params(model))
 		isl_die(ctx, isl_error_invalid,
 			"model has unnamed parameters", goto error);
-	if (!isl_space_has_named_params(map->dim))
-		isl_die(ctx, isl_error_invalid,
-			"relation has unnamed parameters", goto error);
-	if (!isl_space_match(map->dim, isl_dim_param, model, isl_dim_param)) {
+	if (isl_map_check_named_params(map) < 0)
+		goto error;
+	aligned = isl_map_space_has_equal_params(map, model);
+	if (aligned < 0)
+		goto error;
+	if (!aligned) {
 		isl_reordering *exp;
 
-		model = isl_space_drop_dims(model, isl_dim_in,
-					0, isl_space_dim(model, isl_dim_in));
-		model = isl_space_drop_dims(model, isl_dim_out,
-					0, isl_space_dim(model, isl_dim_out));
 		exp = isl_parameter_alignment_reordering(map->dim, model);
 		exp = isl_reordering_extend_space(exp, isl_map_get_space(map));
 		map = isl_map_realign(map, exp);
@@ -11097,6 +12442,7 @@
 	__isl_take isl_basic_map *bmap, __isl_take isl_space *model)
 {
 	isl_ctx *ctx;
+	isl_bool equal_params;
 
 	if (!bmap || !model)
 		goto error;
@@ -11105,26 +12451,24 @@
 	if (!isl_space_has_named_params(model))
 		isl_die(ctx, isl_error_invalid,
 			"model has unnamed parameters", goto error);
-	if (!isl_space_has_named_params(bmap->dim))
-		isl_die(ctx, isl_error_invalid,
-			"relation has unnamed parameters", goto error);
-	if (!isl_space_match(bmap->dim, isl_dim_param, model, isl_dim_param)) {
+	if (isl_basic_map_check_named_params(bmap) < 0)
+		goto error;
+	equal_params = isl_space_has_equal_params(bmap->dim, model);
+	if (equal_params < 0)
+		goto error;
+	if (!equal_params) {
 		isl_reordering *exp;
 		struct isl_dim_map *dim_map;
 
-		model = isl_space_drop_dims(model, isl_dim_in,
-					0, isl_space_dim(model, isl_dim_in));
-		model = isl_space_drop_dims(model, isl_dim_out,
-					0, isl_space_dim(model, isl_dim_out));
 		exp = isl_parameter_alignment_reordering(bmap->dim, model);
 		exp = isl_reordering_extend_space(exp,
 					isl_basic_map_get_space(bmap));
 		dim_map = isl_dim_map_from_reordering(exp);
 		bmap = isl_basic_map_realign(bmap,
-				    exp ? isl_space_copy(exp->dim) : NULL,
+				    isl_reordering_get_space(exp),
 				    isl_dim_map_extend(dim_map, bmap));
 		isl_reordering_free(exp);
-		free(dim_map);
+		isl_dim_map_free(dim_map);
 	}
 
 	isl_space_free(model);
@@ -11135,6 +12479,36 @@
 	return NULL;
 }
 
+/* Do "bset" and "space" have the same parameters?
+ */
+isl_bool isl_basic_set_space_has_equal_params(__isl_keep isl_basic_set *bset,
+	__isl_keep isl_space *space)
+{
+	isl_space *bset_space;
+
+	bset_space = isl_basic_set_peek_space(bset);
+	return isl_space_has_equal_params(bset_space, space);
+}
+
+/* Do "map" and "space" have the same parameters?
+ */
+isl_bool isl_map_space_has_equal_params(__isl_keep isl_map *map,
+	__isl_keep isl_space *space)
+{
+	isl_space *map_space;
+
+	map_space = isl_map_peek_space(map);
+	return isl_space_has_equal_params(map_space, space);
+}
+
+/* Do "set" and "space" have the same parameters?
+ */
+isl_bool isl_set_space_has_equal_params(__isl_keep isl_set *set,
+	__isl_keep isl_space *space)
+{
+	return isl_map_space_has_equal_params(set_to_map(set), space);
+}
+
 /* Align the parameters of "bset" to those of "model", introducing
  * additional parameters if needed.
  */
@@ -11144,6 +12518,295 @@
 	return isl_basic_map_align_params(bset, model);
 }
 
+/* Drop all parameters not referenced by "map".
+ */
+__isl_give isl_map *isl_map_drop_unused_params(__isl_take isl_map *map)
+{
+	int i;
+	isl_size n;
+
+	n = isl_map_dim(map, isl_dim_param);
+	if (isl_map_check_named_params(map) < 0 || n < 0)
+		return isl_map_free(map);
+
+	for (i = n - 1; i >= 0; i--) {
+		isl_bool involves;
+
+		involves = isl_map_involves_dims(map, isl_dim_param, i, 1);
+		if (involves < 0)
+			return isl_map_free(map);
+		if (!involves)
+			map = isl_map_project_out(map, isl_dim_param, i, 1);
+	}
+
+	return map;
+}
+
+/* Drop all parameters not referenced by "set".
+ */
+__isl_give isl_set *isl_set_drop_unused_params(
+	__isl_take isl_set *set)
+{
+	return set_from_map(isl_map_drop_unused_params(set_to_map(set)));
+}
+
+/* Drop all parameters not referenced by "bmap".
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_unused_params(
+	__isl_take isl_basic_map *bmap)
+{
+	isl_size nparam;
+	int i;
+
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	if (nparam < 0 || isl_basic_map_check_named_params(bmap) < 0)
+		return isl_basic_map_free(bmap);
+
+	for (i = nparam - 1; i >= 0; i--) {
+		isl_bool involves;
+
+		involves = isl_basic_map_involves_dims(bmap,
+							isl_dim_param, i, 1);
+		if (involves < 0)
+			return isl_basic_map_free(bmap);
+		if (!involves)
+			bmap = isl_basic_map_drop(bmap, isl_dim_param, i, 1);
+	}
+
+	return bmap;
+}
+
+/* Drop all parameters not referenced by "bset".
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_unused_params(
+	__isl_take isl_basic_set *bset)
+{
+	return bset_from_bmap(isl_basic_map_drop_unused_params(
+							bset_to_bmap(bset)));
+}
+
+/* Given a tuple of identifiers "tuple" in a space that corresponds
+ * to that of "set", if any of those identifiers appear as parameters
+ * in "set", then equate those parameters with the corresponding
+ * set dimensions and project out the parameters.
+ * The result therefore has no such parameters.
+ */
+static __isl_give isl_set *equate_params(__isl_take isl_set *set,
+	__isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size n;
+	isl_space *set_space, *tuple_space;
+
+	set_space = isl_set_peek_space(set);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	if (isl_space_check_equal_tuples(tuple_space, set_space) < 0)
+		return isl_set_free(set);
+	n = isl_multi_id_size(tuple);
+	if (n < 0)
+		return isl_set_free(set);
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+		int pos;
+
+		id = isl_multi_id_get_at(tuple, i);
+		if (!id)
+			return isl_set_free(set);
+		pos = isl_set_find_dim_by_id(set, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos < 0)
+			continue;
+		set = isl_set_equate(set, isl_dim_param, pos, isl_dim_set, i);
+		set = isl_set_project_out(set, isl_dim_param, pos, 1);
+	}
+	return set;
+}
+
+/* Bind the set dimensions of "set" to parameters with identifiers
+ * specified by "tuple", living in the same space as "set".
+ *
+ * If no parameters with these identifiers appear in "set" already,
+ * then the set dimensions are simply reinterpreted as parameters.
+ * Otherwise, the parameters are first equated to the corresponding
+ * set dimensions.
+ */
+__isl_give isl_set *isl_set_bind(__isl_take isl_set *set,
+	__isl_take isl_multi_id *tuple)
+{
+	isl_space *space;
+
+	set = equate_params(set, tuple);
+	space = isl_set_get_space(set);
+	space = isl_space_bind_set(space, tuple);
+	isl_multi_id_free(tuple);
+	set = isl_set_reset_space(set, space);
+
+	return set;
+}
+
+/* Given a tuple of identifiers "tuple" in a space that corresponds
+ * to the domain of "map", if any of those identifiers appear as parameters
+ * in "map", then equate those parameters with the corresponding
+ * input dimensions and project out the parameters.
+ * The result therefore has no such parameters.
+ */
+static __isl_give isl_map *map_equate_params(__isl_take isl_map *map,
+	__isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size n;
+	isl_space *map_space, *tuple_space;
+
+	map_space = isl_map_peek_space(map);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	if (isl_space_check_domain_tuples(tuple_space, map_space) < 0)
+		return isl_map_free(map);
+	n = isl_multi_id_size(tuple);
+	if (n < 0)
+		return isl_map_free(map);
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+		int pos;
+
+		id = isl_multi_id_get_at(tuple, i);
+		if (!id)
+			return isl_map_free(map);
+		pos = isl_map_find_dim_by_id(map, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos < 0)
+			continue;
+		map = isl_map_equate(map, isl_dim_param, pos, isl_dim_in, i);
+		map = isl_map_project_out(map, isl_dim_param, pos, 1);
+	}
+	return map;
+}
+
+/* Bind the input dimensions of "map" to parameters with identifiers
+ * specified by "tuple", living in the domain space of "map".
+ *
+ * If no parameters with these identifiers appear in "map" already,
+ * then the input dimensions are simply reinterpreted as parameters.
+ * Otherwise, the parameters are first equated to the corresponding
+ * input dimensions.
+ */
+__isl_give isl_set *isl_map_bind_domain(__isl_take isl_map *map,
+	__isl_take isl_multi_id *tuple)
+{
+	isl_space *space;
+	isl_set *set;
+
+	map = map_equate_params(map, tuple);
+	space = isl_map_get_space(map);
+	space = isl_space_bind_map_domain(space, tuple);
+	isl_multi_id_free(tuple);
+	set = set_from_map(isl_map_reset_space(map, space));
+
+	return set;
+}
+
+/* Bind the output dimensions of "map" to parameters with identifiers
+ * specified by "tuple", living in the range space of "map".
+ *
+ * Since binding is more easily implemented on the domain,
+ * bind the input dimensions of the inverse of "map".
+ */
+__isl_give isl_set *isl_map_bind_range(__isl_take isl_map *map,
+	__isl_take isl_multi_id *tuple)
+{
+	return isl_map_bind_domain(isl_map_reverse(map), tuple);
+}
+
+/* Insert a domain corresponding to "tuple"
+ * into the nullary or unary relation "set".
+ * The result has an extra initial tuple and is therefore
+ * either a unary or binary relation.
+ * Any parameters with identifiers in "tuple" are reinterpreted
+ * as the corresponding domain dimensions.
+ */
+static __isl_give isl_map *unbind_params_insert_domain(
+	__isl_take isl_set *set, __isl_take isl_multi_id *tuple)
+{
+	isl_space *space;
+	isl_reordering *r;
+
+	space = isl_set_peek_space(set);
+	r = isl_reordering_unbind_params_insert_domain(space, tuple);
+	isl_multi_id_free(tuple);
+
+	return isl_map_realign(set_to_map(set), r);
+}
+
+/* Construct a set with "tuple" as domain from the parameter domain "set".
+ * Any parameters with identifiers in "tuple" are reinterpreted
+ * as the corresponding set dimensions.
+ */
+__isl_give isl_set *isl_set_unbind_params(__isl_take isl_set *set,
+	__isl_take isl_multi_id *tuple)
+{
+	isl_bool is_params;
+
+	is_params = isl_set_is_params(set);
+	if (is_params < 0)
+		set = isl_set_free(set);
+	else if (!is_params)
+		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+			"expecting parameter domain", set = isl_set_free(set));
+	return set_from_map(unbind_params_insert_domain(set, tuple));
+}
+
+/* Check that "set" is a proper set, i.e., that it is not a parameter domain.
+ */
+static isl_stat isl_set_check_is_set(__isl_keep isl_set *set)
+{
+	isl_bool is_params;
+
+	is_params = isl_set_is_params(set);
+	if (is_params < 0)
+		return isl_stat_error;
+	else if (is_params)
+		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+			"expecting proper set", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Construct a map with "domain" as domain and "set" as range.
+ * Any parameters with identifiers in "domain" are reinterpreted
+ * as the corresponding domain dimensions.
+ */
+__isl_give isl_map *isl_set_unbind_params_insert_domain(
+	__isl_take isl_set *set, __isl_take isl_multi_id *domain)
+{
+	if (isl_set_check_is_set(set) < 0)
+		set = isl_set_free(set);
+	return unbind_params_insert_domain(set, domain);
+}
+
+/* Construct a map with "domain" as domain and "set" as range.
+ */
+__isl_give isl_map *isl_set_insert_domain(__isl_take isl_set *set,
+	__isl_take isl_space *domain)
+{
+	isl_size dim;
+	isl_space *space;
+	isl_map *map;
+
+	if (isl_set_check_is_set(set) < 0 || isl_space_check_is_set(domain) < 0)
+		domain = isl_space_free(domain);
+	dim = isl_space_dim(domain, isl_dim_set);
+	if (dim < 0)
+		domain = isl_space_free(domain);
+	space = isl_set_get_space(set);
+	domain = isl_space_replace_params(domain, space);
+	space = isl_space_map_from_domain_and_range(domain, space);
+
+	map = isl_map_from_range(set);
+	map = isl_map_add_dims(map, isl_dim_in, dim);
+	map = isl_map_reset_space(map, space);
+
+	return map;
+}
+
 __isl_give isl_mat *isl_basic_map_equalities_matrix(
 		__isl_keep isl_basic_map *bmap, enum isl_dim_type c1,
 		enum isl_dim_type c2, enum isl_dim_type c3,
@@ -11153,17 +12816,21 @@
 	struct isl_mat *mat;
 	int i, j, k;
 	int pos;
+	isl_size total;
 
-	if (!bmap)
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return NULL;
-	mat = isl_mat_alloc(bmap->ctx, bmap->n_eq,
-				isl_basic_map_total_dim(bmap) + 1);
+	mat = isl_mat_alloc(bmap->ctx, bmap->n_eq, total + 1);
 	if (!mat)
 		return NULL;
 	for (i = 0; i < bmap->n_eq; ++i)
 		for (j = 0, pos = 0; j < 5; ++j) {
 			int off = isl_basic_map_offset(bmap, cj);
-			for (k = 0; k < isl_basic_map_dim(bmap, cj); ++k) {
+			isl_size dim = isl_basic_map_dim(bmap, cj);
+			if (dim < 0)
+				return isl_mat_free(mat);
+			for (k = 0; k < dim; ++k) {
 				isl_int_set(mat->rowipos,
 					    bmap->eqioff + k);
 				++pos;
@@ -11182,17 +12849,21 @@
 	struct isl_mat *mat;
 	int i, j, k;
 	int pos;
+	isl_size total;
 
-	if (!bmap)
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return NULL;
-	mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq,
-				isl_basic_map_total_dim(bmap) + 1);
+	mat = isl_mat_alloc(bmap->ctx, bmap->n_ineq, total + 1);
 	if (!mat)
 		return NULL;
 	for (i = 0; i < bmap->n_ineq; ++i)
 		for (j = 0, pos = 0; j < 5; ++j) {
 			int off = isl_basic_map_offset(bmap, cj);
-			for (k = 0; k < isl_basic_map_dim(bmap, cj); ++k) {
+			isl_size dim = isl_basic_map_dim(bmap, cj);
+			if (dim < 0)
+				return isl_mat_free(mat);
+			for (k = 0; k < dim; ++k) {
 				isl_int_set(mat->rowipos,
 					    bmap->ineqioff + k);
 				++pos;
@@ -11203,35 +12874,37 @@
 }
 
 __isl_give isl_basic_map *isl_basic_map_from_constraint_matrices(
-	__isl_take isl_space *dim,
+	__isl_take isl_space *space,
 	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3,
 	enum isl_dim_type c4, enum isl_dim_type c5)
 {
 	enum isl_dim_type c5 = { c1, c2, c3, c4, c5 };
-	isl_basic_map *bmap;
+	isl_basic_map *bmap = NULL;
+	isl_size dim;
 	unsigned total;
 	unsigned extra;
 	int i, j, k, l;
 	int pos;
 
-	if (!dim || !eq || !ineq)
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0 || !eq || !ineq)
 		goto error;
 
 	if (eq->n_col != ineq->n_col)
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"equalities and inequalities matrices should have "
 			"same number of columns", goto error);
 
-	total = 1 + isl_space_dim(dim, isl_dim_all);
+	total = 1 + dim;
 
 	if (eq->n_col < total)
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"number of columns too small", goto error);
 
 	extra = eq->n_col - total;
 
-	bmap = isl_basic_map_alloc_space(isl_space_copy(dim), extra,
+	bmap = isl_basic_map_alloc_space(isl_space_copy(space), extra,
 				       eq->n_row, ineq->n_row);
 	if (!bmap)
 		goto error;
@@ -11247,7 +12920,10 @@
 			goto error;
 		for (j = 0, pos = 0; j < 5; ++j) {
 			int off = isl_basic_map_offset(bmap, cj);
-			for (k = 0; k < isl_basic_map_dim(bmap, cj); ++k) {
+			isl_size dim = isl_basic_map_dim(bmap, cj);
+			if (dim < 0)
+				goto error;
+			for (k = 0; k < dim; ++k) {
 				isl_int_set(bmap->eqloff + k, 
 					    eq->rowipos);
 				++pos;
@@ -11260,7 +12936,10 @@
 			goto error;
 		for (j = 0, pos = 0; j < 5; ++j) {
 			int off = isl_basic_map_offset(bmap, cj);
-			for (k = 0; k < isl_basic_map_dim(bmap, cj); ++k) {
+			isl_size dim = isl_basic_map_dim(bmap, cj);
+			if (dim < 0)
+				goto error;
+			for (k = 0; k < dim; ++k) {
 				isl_int_set(bmap->ineqloff + k, 
 					    ineq->rowipos);
 				++pos;
@@ -11268,16 +12947,17 @@
 		}
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(eq);
 	isl_mat_free(ineq);
 
 	bmap = isl_basic_map_simplify(bmap);
 	return isl_basic_map_finalize(bmap);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(eq);
 	isl_mat_free(ineq);
+	isl_basic_map_free(bmap);
 	return NULL;
 }
 
@@ -11285,7 +12965,7 @@
 	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
 {
-	return isl_basic_map_equalities_matrix((isl_basic_map *)bset,
+	return isl_basic_map_equalities_matrix(bset_to_bmap(bset),
 						c1, c2, c3, c4, isl_dim_in);
 }
 
@@ -11293,32 +12973,33 @@
 	__isl_keep isl_basic_set *bset, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
 {
-	return isl_basic_map_inequalities_matrix((isl_basic_map *)bset,
+	return isl_basic_map_inequalities_matrix(bset_to_bmap(bset),
 						 c1, c2, c3, c4, isl_dim_in);
 }
 
 __isl_give isl_basic_set *isl_basic_set_from_constraint_matrices(
-	__isl_take isl_space *dim,
+	__isl_take isl_space *space,
 	__isl_take isl_mat *eq, __isl_take isl_mat *ineq, enum isl_dim_type c1,
 	enum isl_dim_type c2, enum isl_dim_type c3, enum isl_dim_type c4)
 {
-	return (isl_basic_set*)
-	    isl_basic_map_from_constraint_matrices(dim, eq, ineq,
+	isl_basic_map *bmap;
+	bmap = isl_basic_map_from_constraint_matrices(space, eq, ineq,
 						   c1, c2, c3, c4, isl_dim_in);
+	return bset_from_bmap(bmap);
 }
 
-int isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_can_zip(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	
 	return isl_space_can_zip(bmap->dim);
 }
 
-int isl_map_can_zip(__isl_keep isl_map *map)
+isl_bool isl_map_can_zip(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	
 	return isl_space_can_zip(map->dim);
 }
@@ -11329,8 +13010,9 @@
 __isl_give isl_basic_map *isl_basic_map_zip(__isl_take isl_basic_map *bmap)
 {
 	unsigned pos;
-	unsigned n1;
-	unsigned n2;
+	isl_size n_in;
+	isl_size n1;
+	isl_size n2;
 
 	if (!bmap)
 		return NULL;
@@ -11338,10 +13020,12 @@
 	if (!isl_basic_map_can_zip(bmap))
 		isl_die(bmap->ctx, isl_error_invalid,
 			"basic map cannot be zipped", goto error);
-	pos = isl_basic_map_offset(bmap, isl_dim_in) +
-		isl_space_dim(bmap->dim->nested0, isl_dim_in);
+	n_in = isl_space_dim(bmap->dim->nested0, isl_dim_in);
 	n1 = isl_space_dim(bmap->dim->nested0, isl_dim_out);
 	n2 = isl_space_dim(bmap->dim->nested1, isl_dim_in);
+	if (n_in < 0 || n1 < 0 || n2 < 0)
+		return isl_basic_map_free(bmap);
+	pos = isl_basic_map_offset(bmap, isl_dim_in) + n_in;
 	bmap = isl_basic_map_cow(bmap);
 	bmap = isl_basic_map_swap_vars(bmap, pos, n1, n2);
 	if (!bmap)
@@ -11349,6 +13033,7 @@
 	bmap->dim = isl_space_zip(bmap->dim);
 	if (!bmap->dim)
 		goto error;
+	bmap = isl_basic_map_mark_final(bmap);
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
@@ -11360,8 +13045,6 @@
  */
 __isl_give isl_map *isl_map_zip(__isl_take isl_map *map)
 {
-	int i;
-
 	if (!map)
 		return NULL;
 
@@ -11369,21 +13052,7 @@
 		isl_die(map->ctx, isl_error_invalid, "map cannot be zipped",
 			goto error);
 
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_zip(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-
-	map->dim = isl_space_zip(map->dim);
-	if (!map->dim)
-		goto error;
-
-	return map;
+	return isl_map_transform(map, &isl_space_zip, &isl_basic_map_zip);
 error:
 	isl_map_free(map);
 	return NULL;
@@ -11392,10 +13061,10 @@
 /* Can we apply isl_basic_map_curry to "bmap"?
  * That is, does it have a nested relation in its domain?
  */
-int isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_can_curry(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_can_curry(bmap->dim);
 }
@@ -11403,10 +13072,10 @@
 /* Can we apply isl_map_curry to "map"?
  * That is, does it have a nested relation in its domain?
  */
-int isl_map_can_curry(__isl_keep isl_map *map)
+isl_bool isl_map_can_curry(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_can_curry(map->dim);
 }
@@ -11429,6 +13098,7 @@
 	bmap->dim = isl_space_curry(bmap->dim);
 	if (!bmap->dim)
 		goto error;
+	bmap = isl_basic_map_mark_final(bmap);
 	return bmap;
 error:
 	isl_basic_map_free(bmap);
@@ -11440,42 +13110,39 @@
  */
 __isl_give isl_map *isl_map_curry(__isl_take isl_map *map)
 {
-	int i;
-
-	if (!map)
-		return NULL;
-
-	if (!isl_map_can_curry(map))
-		isl_die(map->ctx, isl_error_invalid, "map cannot be curried",
-			goto error);
+	return isl_map_change_space(map, &isl_map_can_curry,
+				    "map cannot be curried", &isl_space_curry);
+}
 
-	map = isl_map_cow(map);
+/* Can isl_map_range_curry be applied to "map"?
+ * That is, does it have a nested relation in its range,
+ * the domain of which is itself a nested relation?
+ */
+isl_bool isl_map_can_range_curry(__isl_keep isl_map *map)
+{
 	if (!map)
-		return NULL;
+		return isl_bool_error;
 
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_curry(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-
-	map->dim = isl_space_curry(map->dim);
-	if (!map->dim)
-		goto error;
+	return isl_space_can_range_curry(map->dim);
+}
 
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+/* Given a map A -> ((B -> C) -> D), return the corresponding map
+ * A -> (B -> (C -> D)).
+ */
+__isl_give isl_map *isl_map_range_curry(__isl_take isl_map *map)
+{
+	return isl_map_change_space(map, &isl_map_can_range_curry,
+				    "map range cannot be curried",
+				    &isl_space_range_curry);
 }
 
 /* Can we apply isl_basic_map_uncurry to "bmap"?
  * That is, does it have a nested relation in its domain?
  */
-int isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_can_uncurry(__isl_keep isl_basic_map *bmap)
 {
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_can_uncurry(bmap->dim);
 }
@@ -11483,10 +13150,10 @@
 /* Can we apply isl_map_uncurry to "map"?
  * That is, does it have a nested relation in its domain?
  */
-int isl_map_can_uncurry(__isl_keep isl_map *map)
+isl_bool isl_map_can_uncurry(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	return isl_space_can_uncurry(map->dim);
 }
@@ -11510,6 +13177,7 @@
 	bmap->dim = isl_space_uncurry(bmap->dim);
 	if (!bmap->dim)
 		return isl_basic_map_free(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
 	return bmap;
 }
 
@@ -11518,162 +13186,8 @@
  */
 __isl_give isl_map *isl_map_uncurry(__isl_take isl_map *map)
 {
-	int i;
-
-	if (!map)
-		return NULL;
-
-	if (!isl_map_can_uncurry(map))
-		isl_die(map->ctx, isl_error_invalid, "map cannot be uncurried",
-			return isl_map_free(map));
-
-	map = isl_map_cow(map);
-	if (!map)
-		return NULL;
-
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_uncurry(map->pi);
-		if (!map->pi)
-			return isl_map_free(map);
-	}
-
-	map->dim = isl_space_uncurry(map->dim);
-	if (!map->dim)
-		return isl_map_free(map);
-
-	return map;
-}
-
-/* Construct a basic map mapping the domain of the affine expression
- * to a one-dimensional range prescribed by the affine expression.
- */
-__isl_give isl_basic_map *isl_basic_map_from_aff(__isl_take isl_aff *aff)
-{
-	int k;
-	int pos;
-	isl_local_space *ls;
-	isl_basic_map *bmap;
-
-	if (!aff)
-		return NULL;
-
-	ls = isl_aff_get_local_space(aff);
-	bmap = isl_basic_map_from_local_space(ls);
-	bmap = isl_basic_map_extend_constraints(bmap, 1, 0);
-	k = isl_basic_map_alloc_equality(bmap);
-	if (k < 0)
-		goto error;
-
-	pos = isl_basic_map_offset(bmap, isl_dim_out);
-	isl_seq_cpy(bmap->eqk, aff->v->el + 1, pos);
-	isl_int_neg(bmap->eqkpos, aff->v->el0);
-	isl_seq_cpy(bmap->eqk + pos + 1, aff->v->el + 1 + pos,
-		    aff->v->size - (pos + 1));
-
-	isl_aff_free(aff);
-	bmap = isl_basic_map_finalize(bmap);
-	return bmap;
-error:
-	isl_aff_free(aff);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-/* Construct a map mapping the domain of the affine expression
- * to a one-dimensional range prescribed by the affine expression.
- */
-__isl_give isl_map *isl_map_from_aff(__isl_take isl_aff *aff)
-{
-	isl_basic_map *bmap;
-
-	bmap = isl_basic_map_from_aff(aff);
-	return isl_map_from_basic_map(bmap);
-}
-
-/* Construct a basic map mapping the domain the multi-affine expression
- * to its range, with each dimension in the range equated to the
- * corresponding affine expression.
- */
-__isl_give isl_basic_map *isl_basic_map_from_multi_aff(
-	__isl_take isl_multi_aff *maff)
-{
-	int i;
-	isl_space *space;
-	isl_basic_map *bmap;
-
-	if (!maff)
-		return NULL;
-
-	if (isl_space_dim(maff->space, isl_dim_out) != maff->n)
-		isl_die(isl_multi_aff_get_ctx(maff), isl_error_internal,
-			"invalid space", goto error);
-
-	space = isl_space_domain(isl_multi_aff_get_space(maff));
-	bmap = isl_basic_map_universe(isl_space_from_domain(space));
-
-	for (i = 0; i < maff->n; ++i) {
-		isl_aff *aff;
-		isl_basic_map *bmap_i;
-
-		aff = isl_aff_copy(maff->pi);
-		bmap_i = isl_basic_map_from_aff(aff);
-
-		bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
-	}
-
-	bmap = isl_basic_map_reset_space(bmap, isl_multi_aff_get_space(maff));
-
-	isl_multi_aff_free(maff);
-	return bmap;
-error:
-	isl_multi_aff_free(maff);
-	return NULL;
-}
-
-/* Construct a map mapping the domain the multi-affine expression
- * to its range, with each dimension in the range equated to the
- * corresponding affine expression.
- */
-__isl_give isl_map *isl_map_from_multi_aff(__isl_take isl_multi_aff *maff)
-{
-	isl_basic_map *bmap;
-
-	bmap = isl_basic_map_from_multi_aff(maff);
-	return isl_map_from_basic_map(bmap);
-}
-
-/* Construct a basic map mapping a domain in the given space to
- * to an n-dimensional range, with n the number of elements in the list,
- * where each coordinate in the range is prescribed by the
- * corresponding affine expression.
- * The domains of all affine expressions in the list are assumed to match
- * domain_dim.
- */
-__isl_give isl_basic_map *isl_basic_map_from_aff_list(
-	__isl_take isl_space *domain_dim, __isl_take isl_aff_list *list)
-{
-	int i;
-	isl_space *dim;
-	isl_basic_map *bmap;
-
-	if (!list)
-		return NULL;
-
-	dim = isl_space_from_domain(domain_dim);
-	bmap = isl_basic_map_universe(dim);
-
-	for (i = 0; i < list->n; ++i) {
-		isl_aff *aff;
-		isl_basic_map *bmap_i;
-
-		aff = isl_aff_copy(list->pi);
-		bmap_i = isl_basic_map_from_aff(aff);
-
-		bmap = isl_basic_map_flat_range_product(bmap, bmap_i);
-	}
-
-	isl_aff_list_free(list);
-	return bmap;
+	return isl_map_change_space(map, &isl_map_can_uncurry,
+				"map cannot be uncurried", &isl_space_uncurry);
 }
 
 __isl_give isl_set *isl_set_equate(__isl_take isl_set *set,
@@ -11689,16 +13203,13 @@
 {
 	isl_basic_map *bmap = NULL;
 	int i;
+	isl_size total;
 
-	if (!space)
-		return NULL;
-
-	if (pos1 >= isl_space_dim(space, type1))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"index out of bounds", goto error);
-	if (pos2 >= isl_space_dim(space, type2))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"index out of bounds", goto error);
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0 ||
+	    isl_space_check_range(space, type1, pos1, 1) < 0 ||
+	    isl_space_check_range(space, type2, pos2, 1) < 0)
+		goto error;
 
 	if (type1 == type2 && pos1 == pos2)
 		return isl_basic_map_universe(space);
@@ -11707,7 +13218,7 @@
 	i = isl_basic_map_alloc_equality(bmap);
 	if (i < 0)
 		goto error;
-	isl_seq_clr(bmap->eqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqi, 1 + total);
 	pos1 += isl_basic_map_offset(bmap, type1);
 	pos2 += isl_basic_map_offset(bmap, type2);
 	isl_int_set_si(bmap->eqipos1, -1);
@@ -11756,22 +13267,21 @@
 {
 	isl_basic_map *bmap = NULL;
 	int i;
+	isl_size total;
 
-	if (!map)
-		return NULL;
-
-	if (pos1 >= isl_map_dim(map, type1))
-		isl_die(map->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
-	if (pos2 >= isl_map_dim(map, type2))
-		isl_die(map->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_map_check_range(map, type1, pos1, 1) < 0)
+		return isl_map_free(map);
+	if (isl_map_check_range(map, type2, pos2, 1) < 0)
+		return isl_map_free(map);
 
+	total = isl_map_dim(map, isl_dim_all);
+	if (total < 0)
+		return isl_map_free(map);
 	bmap = isl_basic_map_alloc_space(isl_map_get_space(map), 0, 1, 0);
 	i = isl_basic_map_alloc_equality(bmap);
 	if (i < 0)
 		goto error;
-	isl_seq_clr(bmap->eqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqi, 1 + total);
 	pos1 += isl_basic_map_offset(bmap, type1);
 	pos2 += isl_basic_map_offset(bmap, type2);
 	isl_int_set_si(bmap->eqipos1, 1);
@@ -11796,17 +13306,13 @@
 {
 	isl_constraint *c;
 
+	if (isl_space_check_range(space, type1, pos1, 1) < 0 ||
+	    isl_space_check_range(space, type2, pos2, 1) < 0)
+		space = isl_space_free(space);
 	if (!space)
 		return NULL;
 
-	c = isl_inequality_alloc(isl_local_space_from_space(space));
-
-	if (pos1 >= isl_constraint_dim(c, type1))
-		isl_die(isl_constraint_get_ctx(c), isl_error_invalid,
-			"index out of bounds", return isl_constraint_free(c));
-	if (pos2 >= isl_constraint_dim(c, type2))
-		isl_die(isl_constraint_get_ctx(c), isl_error_invalid,
-			"index out of bounds", return isl_constraint_free(c));
+	c = isl_constraint_alloc_inequality(isl_local_space_from_space(space));
 
 	if (type1 == type2 && pos1 == pos2)
 		return c;
@@ -11870,25 +13376,21 @@
 {
 	isl_basic_map *bmap = NULL;
 	int i;
+	isl_size total;
 
-	if (!space)
-		return NULL;
-
-	if (pos1 >= isl_space_dim(space, type1))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"index out of bounds", goto error);
-	if (pos2 >= isl_space_dim(space, type2))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_space_check_range(space, type1, pos1, 1) < 0 ||
+	    isl_space_check_range(space, type2, pos2, 1) < 0)
+		goto error;
 
 	if (type1 == type2 && pos1 == pos2)
 		return isl_basic_map_empty(space);
 
 	bmap = isl_basic_map_alloc_space(space, 0, 0, 1);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
 	i = isl_basic_map_alloc_inequality(bmap);
-	if (i < 0)
+	if (total < 0 || i < 0)
 		return isl_basic_map_free(bmap);
-	isl_seq_clr(bmap->ineqi, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqi, 1 + total);
 	pos1 += isl_basic_map_offset(bmap, type1);
 	pos2 += isl_basic_map_offset(bmap, type2);
 	isl_int_set_si(bmap->ineqipos1, 1);
@@ -12001,6 +13503,7 @@
 	int i;
 	isl_int v;
 	isl_ctx *ctx;
+	isl_size n_div;
 
 	if (bset && isl_basic_set_plain_is_empty(bset))
 		return bset;
@@ -12013,7 +13516,10 @@
 	if (!isl_space_is_equal(bset->dim, subs->ls->dim))
 		isl_die(ctx, isl_error_invalid,
 			"spaces don't match", goto error);
-	if (isl_local_space_dim(subs->ls, isl_dim_div) != 0)
+	n_div = isl_local_space_dim(subs->ls, isl_dim_div);
+	if (n_div < 0)
+		goto error;
+	if (n_div != 0)
 		isl_die(ctx, isl_error_unsupported,
 			"cannot handle divs yet", goto error);
 	if (!isl_int_is_one(subs->v->el0))
@@ -12078,8 +13584,9 @@
 
 	for (i = set->n - 1; i >= 0; --i) {
 		set->pi = isl_basic_set_substitute(set->pi, type, pos, subs);
-		if (remove_if_empty(set, i) < 0)
-			goto error;
+		set = set_from_map(remove_if_empty(set_to_map(set), i));
+		if (!set)
+			return NULL;
 	}
 
 	return set;
@@ -12090,18 +13597,17 @@
 
 /* Check if the range of "ma" is compatible with the domain or range
  * (depending on "type") of "bmap".
- * Return -1 if anything is wrong.
  */
-static int check_basic_map_compatible_range_multi_aff(
+static isl_stat check_basic_map_compatible_range_multi_aff(
 	__isl_keep isl_basic_map *bmap, enum isl_dim_type type,
 	__isl_keep isl_multi_aff *ma)
 {
-	int m;
+	isl_bool m;
 	isl_space *ma_space;
 
 	ma_space = isl_multi_aff_get_space(ma);
 
-	m = isl_space_match(bmap->dim, isl_dim_param, ma_space, isl_dim_param);
+	m = isl_space_has_equal_params(bmap->dim, ma_space);
 	if (m < 0)
 		goto error;
 	if (!m)
@@ -12115,10 +13621,10 @@
 			"spaces don't match", goto error);
 
 	isl_space_free(ma_space);
-	return m;
+	return isl_stat_ok;
 error:
 	isl_space_free(ma_space);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Copy the divs from "ma" to "bmap", adding zeros for the "n_before"
@@ -12126,23 +13632,23 @@
  * the "n_after" coefficients after the transformed range of dimensions
  * and the coefficients of the other divs in "bmap".
  */
-static int set_ma_divs(__isl_keep isl_basic_map *bmap,
+static __isl_give isl_basic_map *set_ma_divs(__isl_take isl_basic_map *bmap,
 	__isl_keep isl_multi_aff *ma, int n_before, int n_after, int n_div)
 {
 	int i;
-	int n_param;
-	int n_set;
+	isl_size n_param;
+	isl_size n_set;
 	isl_local_space *ls;
 
 	if (n_div == 0)
-		return 0;
-
-	ls = isl_aff_get_domain_local_space(ma->p0);
-	if (!ls)
-		return -1;
+		return bmap;
 
+	ls = isl_aff_get_domain_local_space(ma->u.p0);
 	n_param = isl_local_space_dim(ls, isl_dim_param);
 	n_set = isl_local_space_dim(ls, isl_dim_set);
+	if (n_param < 0 || n_set < 0)
+		return isl_basic_map_free(bmap);
+
 	for (i = 0; i < n_div; ++i) {
 		int o_bmap = 0, o_ls = 0;
 
@@ -12162,15 +13668,16 @@
 		o_bmap += n_div;
 		o_ls += n_div;
 		isl_seq_clr(bmap->divi + o_bmap, bmap->n_div - n_div);
-		if (isl_basic_set_add_div_constraints(bmap, i) < 0)
+		bmap = isl_basic_map_add_div_constraints(bmap, i);
+		if (!bmap)
 			goto error;
 	}
 
 	isl_local_space_free(ls);
-	return 0;
+	return bmap;
 error:
 	isl_local_space_free(ls);
-	return -1;
+	return isl_basic_map_free(bmap);
 }
 
 /* How many stride constraints does "ma" enforce?
@@ -12183,7 +13690,7 @@
 	int strides = 0;
 
 	for (i = 0; i < ma->n; ++i)
-		if (!isl_int_is_one(ma->pi->v->el0))
+		if (!isl_int_is_one(ma->u.pi->v->el0))
 			strides++;
 
 	return strides;
@@ -12199,26 +13706,33 @@
  *	f_i y + h_i = m_i alpha_i
  *
  * with alpha_i an additional existentially quantified variable.
+ *
+ * The input variables of "ma" correspond to a subset of the variables
+ * of "bmap".  There are "n_before" variables in "bmap" before this
+ * subset and "n_after" variables after this subset.
+ * The integer divisions of the affine expressions in "ma" are assumed
+ * to have been aligned.  There are "n_div_ma" of them and
+ * they appear first in "bmap", straight after the "n_after" variables.
  */
 static __isl_give isl_basic_map *add_ma_strides(
 	__isl_take isl_basic_map *bmap, __isl_keep isl_multi_aff *ma,
-	int n_before, int n_after)
+	int n_before, int n_after, int n_div_ma)
 {
 	int i, k;
 	int div;
-	int total;
-	int n_param;
-	int n_in;
-	int n_div;
+	isl_size total;
+	isl_size n_param;
+	isl_size n_in;
 
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
 	n_param = isl_multi_aff_dim(ma, isl_dim_param);
 	n_in = isl_multi_aff_dim(ma, isl_dim_in);
-	n_div = isl_multi_aff_dim(ma, isl_dim_div);
+	if (total < 0 || n_param < 0 || n_in < 0)
+		return isl_basic_map_free(bmap);
 	for (i = 0; i < ma->n; ++i) {
 		int o_bmap = 0, o_ma = 1;
 
-		if (isl_int_is_one(ma->pi->v->el0))
+		if (isl_int_is_one(ma->u.pi->v->el0))
 			continue;
 		div = isl_basic_map_alloc_div(bmap);
 		k = isl_basic_map_alloc_equality(bmap);
@@ -12226,23 +13740,23 @@
 			goto error;
 		isl_int_set_si(bmap->divdiv0, 0);
 		isl_seq_cpy(bmap->eqk + o_bmap,
-			    ma->pi->v->el + o_ma, 1 + n_param);
+			    ma->u.pi->v->el + o_ma, 1 + n_param);
 		o_bmap += 1 + n_param;
 		o_ma += 1 + n_param;
 		isl_seq_clr(bmap->eqk + o_bmap, n_before);
 		o_bmap += n_before;
 		isl_seq_cpy(bmap->eqk + o_bmap,
-			    ma->pi->v->el + o_ma, n_in);
+			    ma->u.pi->v->el + o_ma, n_in);
 		o_bmap += n_in;
 		o_ma += n_in;
 		isl_seq_clr(bmap->eqk + o_bmap, n_after);
 		o_bmap += n_after;
 		isl_seq_cpy(bmap->eqk + o_bmap,
-			    ma->pi->v->el + o_ma, n_div);
-		o_bmap += n_div;
-		o_ma += n_div;
+			    ma->u.pi->v->el + o_ma, n_div_ma);
+		o_bmap += n_div_ma;
+		o_ma += n_div_ma;
 		isl_seq_clr(bmap->eqk + o_bmap, 1 + total - o_bmap);
-		isl_int_neg(bmap->eqk1 + total, ma->pi->v->el0);
+		isl_int_neg(bmap->eqk1 + total, ma->u.pi->v->el0);
 		total++;
 	}
 
@@ -12321,9 +13835,10 @@
 	int i, k;
 	isl_space *space;
 	isl_basic_map *res = NULL;
-	int n_before, n_after, n_div_bmap, n_div_ma;
+	isl_size n_before, n_after, n_div_bmap, n_div_ma;
 	isl_int f, c1, c2, g;
-	int rational, strides;
+	isl_bool rational;
+	int strides;
 
 	isl_int_init(f);
 	isl_int_init(c1);
@@ -12344,7 +13859,9 @@
 		n_after = 0;
 	}
 	n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
-	n_div_ma = ma->n ? isl_aff_dim(ma->p0, isl_dim_div) : 0;
+	n_div_ma = ma->n ? isl_aff_dim(ma->u.p0, isl_dim_div) : 0;
+	if (n_before < 0 || n_after < 0 || n_div_bmap < 0 || n_div_ma < 0)
+		goto error;
 
 	space = isl_multi_aff_get_domain_space(ma);
 	space = isl_space_set(isl_basic_map_get_space(bmap), type, space);
@@ -12359,23 +13876,28 @@
 		if (isl_basic_map_alloc_div(res) < 0)
 			goto error;
 
-	if (set_ma_divs(res, ma, n_before, n_after, n_div_ma) < 0)
+	res = set_ma_divs(res, ma, n_before, n_after, n_div_ma);
+	if (!res)
 		goto error;
 
 	for (i = 0; i < bmap->n_eq; ++i) {
 		k = isl_basic_map_alloc_equality(res);
 		if (k < 0)
 			goto error;
-		isl_seq_preimage(res->eqk, bmap->eqi, ma, n_before,
-				n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
+		if (isl_seq_preimage(res->eqk, bmap->eqi, ma, n_before,
+				    n_after, n_div_ma, n_div_bmap,
+				    f, c1, c2, g, 0) < 0)
+			goto error;
 	}
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		k = isl_basic_map_alloc_inequality(res);
 		if (k < 0)
 			goto error;
-		isl_seq_preimage(res->ineqk, bmap->ineqi, ma, n_before,
-				n_after, n_div_ma, n_div_bmap, f, c1, c2, g, 0);
+		if (isl_seq_preimage(res->ineqk, bmap->ineqi, ma, n_before,
+				    n_after, n_div_ma, n_div_bmap,
+				    f, c1, c2, g, 0) < 0)
+			goto error;
 	}
 
 	for (i = 0; i < bmap->n_div; ++i) {
@@ -12383,13 +13905,14 @@
 			isl_int_set_si(res->divn_div_ma + i0, 0);
 			continue;
 		}
-		isl_seq_preimage(res->divn_div_ma + i, bmap->divi, ma,
+		if (isl_seq_preimage(res->divn_div_ma + i, bmap->divi, ma,
 				    n_before, n_after, n_div_ma, n_div_bmap,
-				    f, c1, c2, g, 1);
+				    f, c1, c2, g, 1) < 0)
+			goto error;
 	}
 
 	if (strides)
-		res = add_ma_strides(res, ma, n_before, n_after);
+		res = add_ma_strides(res, ma, n_before, n_after, n_div_ma);
 
 	isl_int_clear(f);
 	isl_int_clear(c1);
@@ -12397,7 +13920,7 @@
 	isl_int_clear(g);
 	isl_basic_map_free(bmap);
 	isl_multi_aff_free(ma);
-	res = isl_basic_set_simplify(res);
+	res = isl_basic_map_simplify(res);
 	return isl_basic_map_finalize(res);
 error:
 	isl_int_clear(f);
@@ -12446,22 +13969,24 @@
 
 /* Check if the range of "ma" is compatible with the domain or range
  * (depending on "type") of "map".
- * Return -1 if anything is wrong.
+ * Return isl_stat_error if anything is wrong.
  */
-static int check_map_compatible_range_multi_aff(
+static isl_stat check_map_compatible_range_multi_aff(
 	__isl_keep isl_map *map, enum isl_dim_type type,
 	__isl_keep isl_multi_aff *ma)
 {
-	int m;
+	isl_bool m;
 	isl_space *ma_space;
 
 	ma_space = isl_multi_aff_get_space(ma);
-	m = isl_space_tuple_is_equal(map->dim, type, ma_space, isl_dim_out);
+	m = isl_map_space_tuple_is_equal(map, type, ma_space, isl_dim_out);
 	isl_space_free(ma_space);
-	if (m >= 0 && !m)
+	if (m < 0)
+		return isl_stat_error;
+	if (!m)
 		isl_die(isl_map_get_ctx(map), isl_error_invalid,
-			"spaces don't match", return -1);
-	return m;
+			"spaces don't match", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 /* Compute the preimage of the domain or range (depending on "type")
@@ -12496,9 +14021,9 @@
 	space = isl_multi_aff_get_domain_space(ma);
 	space = isl_space_set(isl_map_get_space(map), type, space);
 
-	isl_space_free(map->dim);
-	map->dim = space;
-	if (!map->dim)
+	isl_space_free(isl_map_take_space(map));
+	map = isl_map_restore_space(map, space);
+	if (!map)
 		goto error;
 
 	isl_multi_aff_free(ma);
@@ -12522,14 +14047,20 @@
 __isl_give isl_map *isl_map_preimage_multi_aff(__isl_take isl_map *map,
 	enum isl_dim_type type, __isl_take isl_multi_aff *ma)
 {
+	isl_bool aligned;
+
 	if (!map || !ma)
 		goto error;
 
-	if (isl_space_match(map->dim, isl_dim_param, ma->space, isl_dim_param))
+	aligned = isl_map_space_has_equal_params(map, ma->space);
+	if (aligned < 0)
+		goto error;
+	if (aligned)
 		return map_preimage_multi_aff(map, type, ma);
 
-	if (!isl_space_has_named_params(map->dim) ||
-	    !isl_space_has_named_params(ma->space))
+	if (isl_map_check_named_params(map) < 0)
+		goto error;
+	if (!isl_space_has_named_params(ma->space))
 		isl_die(map->ctx, isl_error_invalid,
 			"unaligned unnamed parameters", goto error);
 	map = isl_map_align_params(map, isl_multi_aff_get_space(ma));
@@ -12641,16 +14172,21 @@
 __isl_give isl_map *isl_map_preimage_pw_multi_aff(__isl_take isl_map *map,
 	enum isl_dim_type type, __isl_take isl_pw_multi_aff *pma)
 {
+	isl_bool aligned;
+
 	if (!map || !pma)
 		goto error;
 
-	if (isl_space_match(map->dim, isl_dim_param, pma->dim, isl_dim_param))
+	aligned = isl_map_space_has_equal_params(map, pma->dim);
+	if (aligned < 0)
+		goto error;
+	if (aligned)
 		return isl_map_preimage_pw_multi_aff_aligned(map, type, pma);
 
-	if (!isl_space_has_named_params(map->dim) ||
-	    !isl_space_has_named_params(pma->dim))
-		isl_die(map->ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
+	if (isl_map_check_named_params(map) < 0)
+		goto error;
+	if (isl_pw_multi_aff_check_named_params(pma) < 0)
+		goto error;
 	map = isl_map_align_params(map, isl_pw_multi_aff_get_space(pma));
 	pma = isl_pw_multi_aff_align_params(pma, isl_map_get_space(map));
 
@@ -12706,18 +14242,26 @@
  * We create a separate isl_multi_aff to effectuate this change
  * in order to avoid spurious splitting of the map along the pieces
  * of "mpa".
+ * If "mpa" has a non-trivial explicit domain, however,
+ * then the full substitution should be performed.
  */
 __isl_give isl_map *isl_map_preimage_multi_pw_aff(__isl_take isl_map *map,
 	enum isl_dim_type type, __isl_take isl_multi_pw_aff *mpa)
 {
-	int n;
+	isl_size n;
+	isl_bool full;
 	isl_pw_multi_aff *pma;
 
-	if (!map || !mpa)
+	n = isl_map_dim(map, type);
+	if (n < 0 || !mpa)
 		goto error;
 
-	n = isl_map_dim(map, type);
-	if (!isl_map_involves_dims(map, type, 0, n)) {
+	full = isl_map_involves_dims(map, type, 0, n);
+	if (full >= 0 && !full)
+		full = isl_multi_pw_aff_has_non_trivial_domain(mpa);
+	if (full < 0)
+		goto error;
+	if (!full) {
 		isl_space *space;
 		isl_multi_aff *ma;
 
@@ -12754,3 +14298,209 @@
 {
 	return isl_map_preimage_multi_pw_aff(set, isl_dim_set, mpa);
 }
+
+/* Return a copy of the equality constraints of "bset" as a matrix.
+ */
+__isl_give isl_mat *isl_basic_set_extract_equalities(
+	__isl_keep isl_basic_set *bset)
+{
+	isl_ctx *ctx;
+	isl_size total;
+
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return NULL;
+
+	ctx = isl_basic_set_get_ctx(bset);
+	return isl_mat_sub_alloc6(ctx, bset->eq, 0, bset->n_eq, 0, 1 + total);
+}
+
+/* Are the "n" "coefficients" starting at "first" of the integer division
+ * expressions at position "pos1" in "bmap1" and "pos2" in "bmap2" equal
+ * to each other?
+ * The "coefficient" at position 0 is the denominator.
+ * The "coefficient" at position 1 is the constant term.
+ */
+isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
+	int pos1, __isl_keep isl_basic_map *bmap2, int pos2,
+	unsigned first, unsigned n)
+{
+	if (isl_basic_map_check_range(bmap1, isl_dim_div, pos1, 1) < 0)
+		return isl_bool_error;
+	if (isl_basic_map_check_range(bmap2, isl_dim_div, pos2, 1) < 0)
+		return isl_bool_error;
+	return isl_seq_eq(bmap1->divpos1 + first,
+			  bmap2->divpos2 + first, n);
+}
+
+/* Are the integer division expressions at position "pos1" in "bmap1" and
+ * "pos2" in "bmap2" equal to each other, except that the constant terms
+ * are different?
+ */
+isl_bool isl_basic_map_equal_div_expr_except_constant(
+	__isl_keep isl_basic_map *bmap1, int pos1,
+	__isl_keep isl_basic_map *bmap2, int pos2)
+{
+	isl_bool equal;
+	isl_size total, total2;
+
+	total = isl_basic_map_dim(bmap1, isl_dim_all);
+	total2 = isl_basic_map_dim(bmap2, isl_dim_all);
+	if (total < 0 || total2 < 0)
+		return isl_bool_error;
+	if (total != total2)
+		isl_die(isl_basic_map_get_ctx(bmap1), isl_error_invalid,
+			"incomparable div expressions", return isl_bool_error);
+	equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
+						0, 1);
+	if (equal < 0 || !equal)
+		return equal;
+	equal = isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
+						1, 1);
+	if (equal < 0 || equal)
+		return isl_bool_not(equal);
+	return isl_basic_map_equal_div_expr_part(bmap1, pos1, bmap2, pos2,
+						2, total);
+}
+
+/* Replace the numerator of the constant term of the integer division
+ * expression at position "div" in "bmap" by "value".
+ * The caller guarantees that this does not change the meaning
+ * of the input.
+ */
+__isl_give isl_basic_map *isl_basic_map_set_div_expr_constant_num_si_inplace(
+	__isl_take isl_basic_map *bmap, int div, int value)
+{
+	if (isl_basic_map_check_range(bmap, isl_dim_div, div, 1) < 0)
+		return isl_basic_map_free(bmap);
+
+	isl_int_set_si(bmap->divdiv1, value);
+
+	return bmap;
+}
+
+/* Is the point "inner" internal to inequality constraint "ineq"
+ * of "bset"?
+ * The point is considered to be internal to the inequality constraint,
+ * if it strictly lies on the positive side of the inequality constraint,
+ * or if it lies on the constraint and the constraint is lexico-positive.
+ */
+static isl_bool is_internal(__isl_keep isl_vec *inner,
+	__isl_keep isl_basic_set *bset, int ineq)
+{
+	isl_ctx *ctx;
+	int pos;
+	isl_size total;
+
+	if (!inner || !bset)
+		return isl_bool_error;
+
+	ctx = isl_basic_set_get_ctx(bset);
+	isl_seq_inner_product(inner->el, bset->ineqineq, inner->size,
+				&ctx->normalize_gcd);
+	if (!isl_int_is_zero(ctx->normalize_gcd))
+		return isl_int_is_nonneg(ctx->normalize_gcd);
+
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	pos = isl_seq_first_non_zero(bset->ineqineq + 1, total);
+	return isl_int_is_pos(bset->ineqineq1 + pos);
+}
+
+/* Tighten the inequality constraints of "bset" that are outward with respect
+ * to the point "vec".
+ * That is, tighten the constraints that are not satisfied by "vec".
+ *
+ * "vec" is a point internal to some superset S of "bset" that is used
+ * to make the subsets of S disjoint, by tightening one half of the constraints
+ * that separate two subsets.  In particular, the constraints of S
+ * are all satisfied by "vec" and should not be tightened.
+ * Of the internal constraints, those that have "vec" on the outside
+ * are tightened.  The shared facet is included in the adjacent subset
+ * with the opposite constraint.
+ * For constraints that saturate "vec", this criterion cannot be used
+ * to determine which of the two sides should be tightened.
+ * Instead, the sign of the first non-zero coefficient is used
+ * to make this choice.  Note that this second criterion is never used
+ * on the constraints of S since "vec" is interior to "S".
+ */
+__isl_give isl_basic_set *isl_basic_set_tighten_outward(
+	__isl_take isl_basic_set *bset, __isl_keep isl_vec *vec)
+{
+	int j;
+
+	bset = isl_basic_set_cow(bset);
+	if (!bset)
+		return NULL;
+	for (j = 0; j < bset->n_ineq; ++j) {
+		isl_bool internal;
+
+		internal = is_internal(vec, bset, j);
+		if (internal < 0)
+			return isl_basic_set_free(bset);
+		if (internal)
+			continue;
+		isl_int_sub_ui(bset->ineqj0, bset->ineqj0, 1);
+	}
+
+	return bset;
+}
+
+/* Replace the variables x of type "type" starting at "first" in "bmap"
+ * by x' with x = M x' with M the matrix trans.
+ * That is, replace the corresponding coefficients c by c M.
+ *
+ * The transformation matrix should be a square matrix.
+ */
+__isl_give isl_basic_map *isl_basic_map_transform_dims(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned first,
+	__isl_take isl_mat *trans)
+{
+	unsigned pos;
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap || !trans)
+		goto error;
+
+	if (trans->n_row != trans->n_col)
+		isl_die(trans->ctx, isl_error_invalid,
+			"expecting square transformation matrix", goto error);
+	if (isl_basic_map_check_range(bmap, type, first, trans->n_row) < 0)
+		goto error;
+
+	pos = isl_basic_map_offset(bmap, type) + first;
+
+	if (isl_mat_sub_transform(bmap->eq, bmap->n_eq, pos,
+			isl_mat_copy(trans)) < 0)
+		goto error;
+	if (isl_mat_sub_transform(bmap->ineq, bmap->n_ineq, pos,
+		      isl_mat_copy(trans)) < 0)
+		goto error;
+	if (isl_mat_sub_transform(bmap->div, bmap->n_div, 1 + pos,
+		      isl_mat_copy(trans)) < 0)
+		goto error;
+
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
+	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS);
+
+	isl_mat_free(trans);
+	return bmap;
+error:
+	isl_mat_free(trans);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Replace the variables x of type "type" starting at "first" in "bset"
+ * by x' with x = M x' with M the matrix trans.
+ * That is, replace the corresponding coefficients c by c M.
+ *
+ * The transformation matrix should be a square matrix.
+ */
+__isl_give isl_basic_set *isl_basic_set_transform_dims(
+	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned first,
+	__isl_take isl_mat *trans)
+{
+	return isl_basic_map_transform_dims(bset, type, first, trans);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_map_bound_templ.c Added

@@ -0,0 +1,57 @@
+/*
+ * Copyright 2018      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#include "isl_multi_macro.h"
+#undef TYPE
+#define TYPE CAT(isl_,BASE)
+
+/* Check that "map" and "multi" live in the same space, ignoring parameters.
+ */
+static isl_stat FN(check_map_equal_tuples_multi,BASE)(__isl_keep isl_map *map,
+	__isl_keep MULTI(BASE) *multi)
+{
+	isl_space *map_space, *multi_space;
+
+	map_space = isl_map_peek_space(map);
+	multi_space = FN(MULTI(BASE),peek_space)(multi);
+	return isl_space_check_equal_tuples(map_space, multi_space);
+}
+
+/* Apply "map_bound" to "map" with the corresponding value in "bound"
+ * for each output dimension.
+ * If "bound" has an explicit domain (which implies that "bound"
+ * is zero-dimensional), then intersect the domain of "map"
+ * with this explicit domain instead.
+ */
+static __isl_give isl_map *FN(map_bound_multi,BASE)(__isl_take isl_map *map,
+	__isl_take MULTI(BASE) *bound,
+	__isl_give isl_map *map_bound(__isl_take isl_map *map,
+		unsigned pos, __isl_take TYPE *value))
+{
+	int i;
+	isl_size dim;
+
+	dim = isl_map_dim(map, isl_dim_out);
+	if (dim < 0 || FN(check_map_equal_tuples_multi,BASE)(map, bound) < 0)
+		goto error;
+
+	for (i = 0; i < dim; ++i) {
+		TYPE *el;
+
+		el = FN(MULTI(BASE),get_at)(bound, i);
+		map = map_bound(map, i, el);
+	}
+	map = FN(FN(isl_map_intersect_multi,BASE),explicit_domain)(map, bound);
+	FN(MULTI(BASE),free)(bound);
+	return map;
+error:
+	isl_map_free(map);
+	FN(MULTI(BASE),free)(bound);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_map_lexopt_templ.c -> _service:tar_scm:isl-0.24.tar.gz/isl_map_lexopt_templ.c Changed

@@ -17,21 +17,83 @@
 #define xSF(TYPE,SUFFIX) TYPE ## SUFFIX
 #define SF(TYPE,SUFFIX) xSF(TYPE,SUFFIX)
 
+/* Compute the lexicographic minimum (or maximum if "flags" includes
+ * ISL_OPT_MAX) of "bmap" over the domain "dom" and return the result.
+ * If "empty" is not NULL, then *empty is assigned a set that
+ * contains those parts of the domain where there is no solution.
+ * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
+ * should be computed over the domain of "bmap".  "empty" is also NULL
+ * in this case.
+ * If "bmap" is marked as rational (ISL_BASIC_MAP_RATIONAL),
+ * then the rational optimum is computed.  Otherwise, the integral optimum
+ * is computed.
+ */
+static __isl_give TYPE *SF(isl_basic_map_partial_lexopt,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty, unsigned flags)
+{
+	return SF(isl_tab_basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty,
+							    flags);
+}
+
+__isl_give TYPE *SF(isl_basic_map_partial_lexmax,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty)
+{
+	unsigned flags = ISL_OPT_MAX;
+	return SF(isl_basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, flags);
+}
+
+__isl_give TYPE *SF(isl_basic_map_partial_lexmin,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty)
+{
+	unsigned flags = 0;
+	return SF(isl_basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, flags);
+}
+
+__isl_give TYPE *SF(isl_basic_set_partial_lexmin,SUFFIX)(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty)
+{
+	return SF(isl_basic_map_partial_lexmin,SUFFIX)(bset, dom, empty);
+}
+
+__isl_give TYPE *SF(isl_basic_set_partial_lexmax,SUFFIX)(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty)
+{
+	return SF(isl_basic_map_partial_lexmax,SUFFIX)(bset, dom, empty);
+}
+
 /* Given a basic map "bmap", compute the lexicographically minimal
  * (or maximal) image element for each domain element in dom.
- * Set *empty to those elements in dom that do not have an image element.
+ * If empty is not NULL, then set *empty to those elements in dom
+ * that do not have an image element.
+ * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
+ * should be computed over the domain of "bmap".  "empty" is also NULL
+ * in this case.
  *
  * We first make sure the basic sets in dom are disjoint and then
  * simply collect the results over each of the basic sets separately.
  * We could probably improve the efficiency a bit by moving the union
  * domain down into the parametric integer programming.
+ *
+ * If a full optimum is being computed (i.e., "flags" includes ISL_OPT_FULL),
+ * then no domain is given and there is then also no need to consider
+ * the disjuncts of the domain.
  */
 static __isl_give TYPE *SF(basic_map_partial_lexopt,SUFFIX)(
 	__isl_take isl_basic_map *bmap, __isl_take isl_set *dom,
-	__isl_give isl_set **empty, int max)
+	__isl_give isl_set **empty, unsigned flags)
 {
 	int i;
 	TYPE *res;
+	isl_set *all_empty;
+
+	if (ISL_FL_ISSET(flags, ISL_OPT_FULL))
+		return SF(isl_basic_map_partial_lexopt,SUFFIX)(bmap, NULL,
+								empty, flags);
 
 	dom = isl_set_make_disjoint(dom);
 	if (!dom)
@@ -48,33 +110,58 @@
 	}
 
 	res = SF(isl_basic_map_partial_lexopt,SUFFIX)(isl_basic_map_copy(bmap),
-			isl_basic_set_copy(dom->p0), empty, max);
-		
+			isl_basic_set_copy(dom->p0), empty, flags);
+
+	if (empty)
+		all_empty = *empty;
 	for (i = 1; i < dom->n; ++i) {
 		TYPE *res_i;
-		isl_set *empty_i;
 
 		res_i = SF(isl_basic_map_partial_lexopt,SUFFIX)(
 				isl_basic_map_copy(bmap),
-				isl_basic_set_copy(dom->pi), &empty_i, max);
+				isl_basic_set_copy(dom->pi), empty, flags);
 
 		res = ADD(res, res_i);
-		*empty = isl_set_union_disjoint(*empty, empty_i);
+		if (empty)
+			all_empty = isl_set_union_disjoint(all_empty, *empty);
 	}
 
+	if (empty)
+		*empty = all_empty;
 	isl_set_free(dom);
 	isl_basic_map_free(bmap);
 	return res;
 error:
-	*empty = NULL;
+	if (empty)
+		*empty = NULL;
 	isl_set_free(dom);
 	isl_basic_map_free(bmap);
 	return NULL;
 }
 
+/* Compute the lexicographic minimum (or maximum if "flags" includes
+ * ISL_OPT_MAX) of "bmap" over its domain.
+ */
+__isl_give TYPE *SF(isl_basic_map_lexopt,SUFFIX)(
+	__isl_take isl_basic_map *bmap, unsigned flags)
+{
+	ISL_FL_SET(flags, ISL_OPT_FULL);
+	return SF(isl_basic_map_partial_lexopt,SUFFIX)(bmap, NULL, NULL, flags);
+}
+
+__isl_give TYPE *SF(isl_basic_map_lexmin,SUFFIX)(__isl_take isl_basic_map *bmap)
+{
+	return SF(isl_basic_map_lexopt,SUFFIX)(bmap, 0);
+}
+
 static __isl_give TYPE *SF(isl_map_partial_lexopt_aligned,SUFFIX)(
 	__isl_take isl_map *map, __isl_take isl_set *dom,
-	__isl_give isl_set **empty, int max);
+	__isl_give isl_set **empty, unsigned flags);
+/* This function is currently only used when TYPE is defined as isl_map. */
+static __isl_give TYPE *SF(isl_map_partial_lexopt,SUFFIX)(
+	__isl_take isl_map *map, __isl_take isl_set *dom,
+	__isl_give isl_set **empty, unsigned flags)
+	__attribute__ ((unused));
 
 /* Given a map "map", compute the lexicographically minimal
  * (or maximal) image element for each domain element in dom.
@@ -84,20 +171,24 @@
  */
 static __isl_give TYPE *SF(isl_map_partial_lexopt,SUFFIX)(
 	__isl_take isl_map *map, __isl_take isl_set *dom,
-	__isl_give isl_set **empty, int max)
+	__isl_give isl_set **empty, unsigned flags)
 {
-	if (!map || !dom)
+	isl_bool aligned;
+
+	aligned = isl_map_set_has_equal_params(map, dom);
+	if (aligned < 0)
 		goto error;
-	if (isl_space_match(map->dim, isl_dim_param, dom->dim, isl_dim_param))
+	if (aligned)
 		return SF(isl_map_partial_lexopt_aligned,SUFFIX)(map, dom,
-								empty, max);
+								empty, flags);
 	if (!isl_space_has_named_params(map->dim) ||
 	    !isl_space_has_named_params(dom->dim))
 		isl_die(map->ctx, isl_error_invalid,
 			"unaligned unnamed parameters", goto error);
 	map = isl_map_align_params(map, isl_map_get_space(dom));
 	dom = isl_map_align_params(dom, isl_map_get_space(map));
-	return SF(isl_map_partial_lexopt_aligned,SUFFIX)(map, dom, empty, max);
+	return SF(isl_map_partial_lexopt_aligned,SUFFIX)(map, dom, empty,
+							flags);
 error:
 	if (empty)
 		*empty = NULL;
@@ -106,19 +197,15 @@
 	return NULL;
 }
 
-__isl_give TYPE *SF(isl_map_lexopt,SUFFIX)(__isl_take isl_map *map, int max)
+/* Compute the lexicographic minimum (or maximum if "flags" includes
+ * ISL_OPT_MAX) of "map" over its domain.
+ */
+__isl_give TYPE *SF(isl_map_lexopt,SUFFIX)(__isl_take isl_map *map,
+	unsigned flags)
 {
-	isl_set *dom = NULL;
-	isl_space *dom_space;
-
-	if (!map)
-		goto error;
-	dom_space = isl_space_domain(isl_space_copy(map->dim));
-	dom = isl_set_universe(dom_space);
-	return SF(isl_map_partial_lexopt,SUFFIX)(map, dom, NULL, max);
-error:
-	isl_map_free(map);
-	return NULL;
+	ISL_FL_SET(flags, ISL_OPT_FULL);
+	return SF(isl_map_partial_lexopt_aligned,SUFFIX)(map, NULL, NULL,
+							flags);
 }
 
 __isl_give TYPE *SF(isl_map_lexmin,SUFFIX)(__isl_take isl_map *map)
@@ -128,7 +215,7 @@
 
 __isl_give TYPE *SF(isl_map_lexmax,SUFFIX)(__isl_take isl_map *map)
 {
-	return SF(isl_map_lexopt,SUFFIX)(map, 1);
+	return SF(isl_map_lexopt,SUFFIX)(map, ISL_OPT_MAX);
 }
 
 __isl_give TYPE *SF(isl_set_lexmin,SUFFIX)(__isl_take isl_set *set)

_service:tar_scm:isl-0.24.tar.gz/isl_map_list.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_map_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_map_private.h Changed

@@ -11,16 +11,16 @@
 #define ISL_MAP_PRIVATE_H
 
 #define isl_basic_set	isl_basic_map
+#define isl_maybe_isl_basic_set	isl_maybe_isl_basic_map
 #define isl_set		isl_map
 #define isl_basic_set_list	isl_basic_map_list
 #define isl_set_list	isl_map_list
 #include <isl/list.h>
-ISL_DECLARE_LIST(basic_map)
-ISL_DECLARE_LIST(map)
 #include <isl/set.h>
 #include <isl/map.h>
 #include <isl_reordering.h>
 #include <isl/vec.h>
+#include <isl/hash.h>
 #include <isl_blk.h>
 
 /* A "basic map" is a relation between two sets of variables,
@@ -40,17 +40,19 @@
 #define ISL_BASIC_MAP_NO_IMPLICIT	(1 << 2)
 #define ISL_BASIC_MAP_NO_REDUNDANT	(1 << 3)
 #define ISL_BASIC_MAP_RATIONAL		(1 << 4)
-#define ISL_BASIC_MAP_NORMALIZED	(1 << 5)
+#define ISL_BASIC_MAP_SORTED		(1 << 5)
 #define ISL_BASIC_MAP_NORMALIZED_DIVS	(1 << 6)
 #define ISL_BASIC_MAP_ALL_EQUALITIES	(1 << 7)
+#define ISL_BASIC_MAP_REDUCED_COEFFICIENTS	(1 << 8)
 #define ISL_BASIC_SET_FINAL		(1 << 0)
 #define ISL_BASIC_SET_EMPTY		(1 << 1)
 #define ISL_BASIC_SET_NO_IMPLICIT	(1 << 2)
 #define ISL_BASIC_SET_NO_REDUNDANT	(1 << 3)
 #define ISL_BASIC_SET_RATIONAL		(1 << 4)
-#define ISL_BASIC_SET_NORMALIZED	(1 << 5)
+#define ISL_BASIC_SET_SORTED		(1 << 5)
 #define ISL_BASIC_SET_NORMALIZED_DIVS	(1 << 6)
 #define ISL_BASIC_SET_ALL_EQUALITIES	(1 << 7)
+#define ISL_BASIC_SET_REDUCED_COEFFICIENTS	(1 << 8)
 	unsigned flags;
 
 	struct isl_ctx *ctx;
@@ -86,6 +88,10 @@
  * Currently, the isl_set structure is identical to the isl_map structure
  * and the library depends on this correspondence internally.
  * However, users should not depend on this correspondence.
+ *
+ * "cached_simple_hull" contains copies of the unshifted and shifted
+ * simple hulls, if they have already been computed.  Otherwise,
+ * the entries are NULL.
  */
 struct isl_map {
 	int ref;
@@ -94,6 +100,7 @@
 #define ISL_SET_DISJOINT		(1 << 0)
 #define ISL_SET_NORMALIZED		(1 << 1)
 	unsigned flags;
+	isl_basic_map *cached_simple_hull2;
 
 	struct isl_ctx *ctx;
 
@@ -110,78 +117,128 @@
 
 #include <isl_list_templ.h>
 
+__isl_give isl_basic_set *isl_basic_set_alloc(isl_ctx *ctx,
+	unsigned nparam, unsigned dim, unsigned extra,
+	unsigned n_eq, unsigned n_ineq);
+__isl_give isl_basic_set *isl_basic_set_extend_constraints(
+	__isl_take isl_basic_set *base, unsigned n_eq, unsigned n_ineq);
+__isl_give isl_basic_set *isl_basic_set_finalize(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_dup(__isl_keep isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_simplify(
+	__isl_take isl_basic_set *bset);
+
+__isl_give isl_basic_map *isl_basic_map_alloc(isl_ctx *ctx,
+	unsigned nparam, unsigned in, unsigned out, unsigned extra,
+	unsigned n_eq, unsigned n_ineq);
+__isl_give isl_basic_map *isl_basic_map_mark_final(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_finalize(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_extend_constraints(
+	__isl_take isl_basic_map *base, unsigned n_eq, unsigned n_ineq);
+__isl_give isl_basic_map *isl_basic_map_simplify(
+	__isl_take isl_basic_map *bmap);
+
+__isl_give isl_set *isl_set_add_basic_set(__isl_take isl_set *set,
+	__isl_take isl_basic_set *bset);
+
+__isl_give isl_map *isl_map_add_basic_map(__isl_take isl_map *map,
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_map *isl_map_dup(__isl_keep isl_map *map);
+
+__isl_give isl_basic_set *isl_basic_set_from_underlying_set(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *like);
+
 __isl_give isl_map *isl_map_realign(__isl_take isl_map *map,
 	__isl_take isl_reordering *r);
 __isl_give isl_set *isl_set_realign(__isl_take isl_set *set,
 	__isl_take isl_reordering *r);
 
+__isl_give isl_basic_map *isl_basic_map_reset(__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type);
 __isl_give isl_map *isl_map_reset(__isl_take isl_map *map,
 	enum isl_dim_type type);
 
+__isl_keep isl_space *isl_basic_map_peek_space(
+	__isl_keep const isl_basic_map *bmap);
+__isl_keep isl_space *isl_basic_set_peek_space(__isl_keep isl_basic_set *bset);
+__isl_keep isl_space *isl_map_peek_space(__isl_keep const isl_map *map);
+__isl_keep isl_space *isl_set_peek_space(__isl_keep isl_set *set);
+
 __isl_give isl_basic_set *isl_basic_set_reset_space(
-	__isl_take isl_basic_set *bset, __isl_take isl_space *dim);
+	__isl_take isl_basic_set *bset, __isl_take isl_space *space);
 __isl_give isl_basic_map *isl_basic_map_reset_space(
-	__isl_take isl_basic_map *bmap, __isl_take isl_space *dim);
+	__isl_take isl_basic_map *bmap, __isl_take isl_space *space);
 __isl_give isl_map *isl_map_reset_space(__isl_take isl_map *map,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
+__isl_give isl_map *isl_map_reset_equal_dim_space(__isl_take isl_map *map,
+	__isl_take isl_space *space);
 
-unsigned isl_basic_map_offset(struct isl_basic_map *bmap,
+isl_size isl_basic_map_var_offset(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type);
+isl_size isl_basic_set_var_offset(__isl_keep isl_basic_set *bset,
+	enum isl_dim_type type);
+unsigned isl_basic_map_offset(__isl_keep isl_basic_map *bmap,
 					enum isl_dim_type type);
-unsigned isl_basic_set_offset(struct isl_basic_set *bset,
+unsigned isl_basic_set_offset(__isl_keep isl_basic_set *bset,
 					enum isl_dim_type type);
 
-int isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_may_be_set(__isl_keep isl_basic_map *bmap);
 int isl_map_may_be_set(__isl_keep isl_map *map);
-int isl_map_compatible_domain(struct isl_map *map, struct isl_set *set);
-int isl_basic_map_compatible_domain(struct isl_basic_map *bmap,
-		struct isl_basic_set *bset);
-int isl_basic_map_compatible_range(struct isl_basic_map *bmap,
-		struct isl_basic_set *bset);
-
-struct isl_basic_map *isl_basic_map_extend_space(struct isl_basic_map *base,
-		__isl_take isl_space *dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-struct isl_basic_set *isl_basic_set_extend_space(struct isl_basic_set *base,
-		__isl_take isl_space *dim, unsigned extra,
-		unsigned n_eq, unsigned n_ineq);
-struct isl_basic_set *isl_basic_set_add_constraints(struct isl_basic_set *bset1,
-		struct isl_basic_set *bset2, unsigned pos);
-
-struct isl_map *isl_map_grow(struct isl_map *map, int n);
-struct isl_set *isl_set_grow(struct isl_set *set, int n);
-
-int isl_basic_set_contains(struct isl_basic_set *bset, struct isl_vec *vec);
-int isl_basic_map_contains(struct isl_basic_map *bmap, struct isl_vec *vec);
-
-__isl_give isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *dim,
+isl_bool isl_map_compatible_domain(__isl_keep isl_map *map,
+	__isl_keep isl_set *set);
+isl_bool isl_basic_map_compatible_domain(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *bset);
+isl_bool isl_basic_map_compatible_range(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *bset);
+
+__isl_give isl_basic_map *isl_basic_map_extend(__isl_take isl_basic_map *base,
+	unsigned extra, unsigned n_eq, unsigned n_ineq);
+__isl_give isl_basic_set *isl_basic_set_extend(__isl_take isl_basic_set *base,
+	unsigned extra, unsigned n_eq, unsigned n_ineq);
+
+__isl_give isl_map *isl_map_grow(__isl_take isl_map *map, int n);
+__isl_give isl_set *isl_set_grow(__isl_take isl_set *set, int n);
+
+isl_bool isl_basic_set_contains(__isl_keep isl_basic_set *bset,
+	__isl_keep isl_vec *vec);
+isl_bool isl_basic_map_contains(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_vec *vec);
+
+__isl_give isl_basic_set *isl_basic_set_alloc_space(__isl_take isl_space *space,
 		unsigned extra, unsigned n_eq, unsigned n_ineq);
-__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *dim, int n,
+__isl_give isl_set *isl_set_alloc_space(__isl_take isl_space *space, int n,
 	unsigned flags);
-__isl_give isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *dim,
+__isl_give isl_basic_map *isl_basic_map_alloc_space(__isl_take isl_space *space,
 		unsigned extra, unsigned n_eq, unsigned n_ineq);
-__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *dim, int n,
+__isl_give isl_map *isl_map_alloc_space(__isl_take isl_space *space, int n,
 	unsigned flags);
 
-unsigned isl_basic_map_total_dim(const struct isl_basic_map *bmap);
-
-int isl_basic_map_alloc_equality(struct isl_basic_map *bmap);
-int isl_basic_set_alloc_equality(struct isl_basic_set *bset);
-int isl_basic_set_free_inequality(struct isl_basic_set *bset, unsigned n);
-int isl_basic_map_free_equality(struct isl_basic_map *bmap, unsigned n);
-int isl_basic_set_free_equality(struct isl_basic_set *bset, unsigned n);
-int isl_basic_set_alloc_inequality(struct isl_basic_set *bset);
-int isl_basic_map_alloc_inequality(struct isl_basic_map *bmap);
-int isl_basic_map_free_inequality(struct isl_basic_map *bmap, unsigned n);
-int isl_basic_map_alloc_div(struct isl_basic_map *bmap);
-int isl_basic_set_alloc_div(struct isl_basic_set *bset);
-int isl_basic_map_free_div(struct isl_basic_map *bmap, unsigned n);
-int isl_basic_set_free_div(struct isl_basic_set *bset, unsigned n);
+int isl_basic_map_alloc_equality(__isl_keep isl_basic_map *bmap);
+int isl_basic_set_alloc_equality(__isl_keep isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_free_inequality(
+	__isl_take isl_basic_set *bset, unsigned n);
+__isl_give isl_basic_map *isl_basic_map_free_equality(
+	__isl_take isl_basic_map *bmap, unsigned n);
+__isl_give isl_basic_set *isl_basic_set_free_equality(
+	__isl_take isl_basic_set *bset, unsigned n);
+int isl_basic_set_alloc_inequality(__isl_keep isl_basic_set *bset);
+int isl_basic_map_alloc_inequality(__isl_keep isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_free_inequality(
+	__isl_take isl_basic_map *bmap, unsigned n);
+int isl_basic_map_alloc_div(__isl_keep isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_insert_div(
+	__isl_take isl_basic_map *bmap, int pos, __isl_keep isl_vec *div);
+int isl_basic_set_alloc_div(__isl_keep isl_basic_set *bset);
+isl_stat isl_basic_map_free_div(__isl_keep isl_basic_map *bmap, unsigned n);
+__isl_give isl_basic_map *isl_basic_map_drop_div(
+	__isl_take isl_basic_map *bmap, unsigned div);
 void isl_basic_map_inequality_to_equality(
-		struct isl_basic_map *bmap, unsigned pos);
-int isl_basic_map_drop_equality(struct isl_basic_map *bmap, unsigned pos);
-int isl_basic_set_drop_equality(struct isl_basic_set *bset, unsigned pos);
-int isl_basic_set_drop_inequality(struct isl_basic_set *bset, unsigned pos);
-int isl_basic_map_drop_inequality(struct isl_basic_map *bmap, unsigned pos);
+		__isl_keep isl_basic_map *bmap, unsigned pos);
+int isl_basic_map_drop_equality(__isl_keep isl_basic_map *bmap, unsigned pos);
+int isl_basic_set_drop_inequality(__isl_keep isl_basic_set *bset, unsigned pos);
+int isl_basic_map_drop_inequality(__isl_keep isl_basic_map *bmap, unsigned pos);
 __isl_give isl_basic_set *isl_basic_set_add_eq(__isl_take isl_basic_set *bset,
 	isl_int *eq);
 __isl_give isl_basic_map *isl_basic_map_add_eq(__isl_take isl_basic_map *bmap,
@@ -191,124 +248,174 @@
 __isl_give isl_basic_map *isl_basic_map_add_ineq(__isl_take isl_basic_map *bmap,
 	isl_int *ineq);
 
-int isl_inequality_negate(struct isl_basic_map *bmap, unsigned pos);
+__isl_give isl_basic_set *isl_basic_set_tighten_outward(
+	__isl_take isl_basic_set *bset, __isl_keep isl_vec *vec);
+
+__isl_give isl_basic_map *isl_inequality_negate(__isl_take isl_basic_map *bmap,
+	unsigned pos);
+
+isl_bool isl_basic_map_has_single_reference(__isl_keep isl_basic_map *bmap);
+__isl_give isl_basic_set *isl_basic_set_cow(__isl_take isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_cow(__isl_take isl_basic_map *bmap);
+__isl_give isl_set *isl_set_cow(__isl_take isl_set *set);
+__isl_give isl_map *isl_map_cow(__isl_take isl_map *map);
+
+uint32_t isl_basic_map_get_hash(__isl_keep isl_basic_map *bmap);
 
-struct isl_basic_set *isl_basic_set_cow(struct isl_basic_set *bset);
-struct isl_basic_map *isl_basic_map_cow(struct isl_basic_map *bmap);
-struct isl_set *isl_set_cow(struct isl_set *set);
-struct isl_map *isl_map_cow(struct isl_map *map);
+__isl_give isl_set *isl_basic_set_list_union(
+	__isl_take isl_basic_set_list *list);
 
-struct isl_basic_map *isl_basic_map_set_to_empty(struct isl_basic_map *bmap);
-struct isl_basic_set *isl_basic_set_set_to_empty(struct isl_basic_set *bset);
-struct isl_basic_set *isl_basic_set_order_divs(struct isl_basic_set *bset);
-void isl_basic_map_swap_div(struct isl_basic_map *bmap, int a, int b);
-struct isl_basic_map *isl_basic_map_order_divs(struct isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_set_to_empty(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_basic_set *isl_basic_set_set_to_empty(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_swap_div(__isl_take isl_basic_map *bmap,
+	int a, int b);
+__isl_give isl_basic_map *isl_basic_map_order_divs(
+	__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_order_divs(__isl_take isl_map *map);
-struct isl_basic_map *isl_basic_map_align_divs(
-		struct isl_basic_map *dst, struct isl_basic_map *src);
-struct isl_basic_set *isl_basic_set_align_divs(
-		struct isl_basic_set *dst, struct isl_basic_set *src);
-__isl_give isl_set *isl_set_align_divs_to_basic_set_list(
-	__isl_take isl_set *set, __isl_keep isl_basic_set_list *list);
-__isl_give isl_basic_set_list *isl_basic_set_list_align_divs_to_basic_set(
-	__isl_take isl_basic_set_list *list, __isl_keep isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_align_divs(
+	__isl_take isl_basic_map *dst, __isl_keep isl_basic_map *src);
+__isl_give isl_map *isl_map_align_divs_to_basic_map_list(
+	__isl_take isl_map *map, __isl_keep isl_basic_map_list *list);
+__isl_give isl_basic_map_list *isl_basic_map_list_align_divs_to_basic_map(
+	__isl_take isl_basic_map_list *list, __isl_keep isl_basic_map *bmap);
+__isl_give isl_map *isl_map_align_divs_internal(__isl_take isl_map *map);
+__isl_give isl_basic_set *isl_basic_set_sort_divs(
+	__isl_take isl_basic_set *bset);
 __isl_give isl_basic_map *isl_basic_map_sort_divs(
 	__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_sort_divs(__isl_take isl_map *map);
-struct isl_basic_map *isl_basic_map_gauss(
-	struct isl_basic_map *bmap, int *progress);
-struct isl_basic_set *isl_basic_set_gauss(
-	struct isl_basic_set *bset, int *progress);
+__isl_give isl_basic_map *isl_basic_map_gauss5(__isl_take isl_basic_map *bmap,
+	int *progress,
+	isl_stat (*swap)(unsigned a, unsigned b, void *user),
+	isl_stat (*drop)(unsigned n, void *user), void *user);
+__isl_give isl_basic_map *isl_basic_map_gauss(__isl_take isl_basic_map *bmap,
+	int *progress);
+__isl_give isl_basic_set *isl_basic_set_gauss(
+	__isl_take isl_basic_set *bset, int *progress);
+int isl_basic_map_constraint_cmp(__isl_keep isl_basic_map *bmap,
+	isl_int *c1, isl_int *c2);
+__isl_give isl_basic_map *isl_basic_map_sort_constraints(
+	__isl_take isl_basic_map *bmap);
 __isl_give isl_basic_set *isl_basic_set_sort_constraints(
 	__isl_take isl_basic_set *bset);
-int isl_basic_map_plain_cmp(const __isl_keep isl_basic_map *bmap1,
-	const __isl_keep isl_basic_map *bmap2);
-int isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
+int isl_basic_map_plain_cmp(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2);
+isl_bool isl_basic_map_plain_is_equal(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2);
-struct isl_basic_map *isl_basic_map_normalize_constraints(
-	struct isl_basic_map *bmap);
-struct isl_basic_set *isl_basic_set_normalize_constraints(
-	struct isl_basic_set *bset);
-struct isl_basic_map *isl_basic_map_implicit_equalities(
-						struct isl_basic_map *bmap);
-struct isl_basic_set *isl_basic_map_underlying_set(struct isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_normalize_constraints(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_basic_set *isl_basic_set_normalize_constraints(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_implicit_equalities(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_basic_set *isl_basic_map_underlying_set(
+	__isl_take isl_basic_map *bmap);
 __isl_give isl_basic_set *isl_basic_set_underlying_set(
 		__isl_take isl_basic_set *bset);
-__isl_give isl_basic_set_list *isl_basic_set_list_underlying_set(
-	__isl_take isl_basic_set_list *list);
-struct isl_set *isl_map_underlying_set(struct isl_map *map);
-struct isl_basic_map *isl_basic_map_overlying_set(struct isl_basic_set *bset,
-	struct isl_basic_map *like);
+__isl_give isl_basic_set_list *isl_basic_map_list_underlying_set(
+	__isl_take isl_basic_map_list *list);
+__isl_give isl_set *isl_map_underlying_set(__isl_take isl_map *map);
+__isl_give isl_basic_map *isl_basic_map_overlying_set(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_map *like);
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_unknown_divs(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_unknown_divs(
+	__isl_take isl_basic_map *bmap);
+__isl_give isl_map *isl_map_drop_constraints_involving_unknown_divs(
+	__isl_take isl_map *map);
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving(
+	__isl_take isl_basic_map *bmap, unsigned first, unsigned n);
 __isl_give isl_basic_set *isl_basic_set_drop_constraints_involving(
 	__isl_take isl_basic_set *bset, unsigned first, unsigned n);
 __isl_give isl_basic_set *isl_basic_set_drop(__isl_take isl_basic_set *bset,
 	enum isl_dim_type type, unsigned first, unsigned n);
-struct isl_basic_map *isl_basic_map_drop(struct isl_basic_map *bmap,
+__isl_give isl_basic_map *isl_basic_map_drop(__isl_take isl_basic_map *bmap,
 	enum isl_dim_type type, unsigned first, unsigned n);
-struct isl_set *isl_set_drop(struct isl_set *set,
+__isl_give isl_set *isl_set_drop(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n);
-struct isl_basic_set *isl_basic_set_drop_dims(
-		struct isl_basic_set *bset, unsigned first, unsigned n);
-struct isl_set *isl_set_drop_dims(
-		struct isl_set *set, unsigned first, unsigned n);
-struct isl_map *isl_map_drop_inputs(
-		struct isl_map *map, unsigned first, unsigned n);
-struct isl_map *isl_map_drop(struct isl_map *map,
+__isl_give isl_basic_set *isl_basic_set_drop_dims(
+	__isl_take isl_basic_set *bset, unsigned first, unsigned n);
+__isl_give isl_map *isl_map_drop(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_basic_map *isl_basic_map_drop_unrelated_constraints(
+	__isl_take isl_basic_map *bmap, __isl_take int *group);
 
+__isl_give isl_basic_map *isl_basic_map_eliminate_pure_unit_divs(
+	__isl_take isl_basic_map *bmap);
 __isl_give isl_basic_map *isl_basic_map_remove_duplicate_constraints(
 	__isl_take isl_basic_map *bmap, int *progress, int detect_divs);
+__isl_give isl_basic_map *isl_basic_map_detect_inequality_pairs(
+	__isl_take isl_basic_map *bmap, int *progress);
 
-struct isl_map *isl_map_remove_empty_parts(struct isl_map *map);
-struct isl_set *isl_set_remove_empty_parts(struct isl_set *set);
+__isl_give isl_map *isl_map_remove_empty_parts(__isl_take isl_map *map);
+__isl_give isl_set *isl_set_remove_empty_parts(__isl_take isl_set *set);
 __isl_give isl_map *isl_map_remove_obvious_duplicates(__isl_take isl_map *map);
 
-struct isl_set *isl_set_normalize(struct isl_set *set);
-
-struct isl_set *isl_set_drop_vars(
-		struct isl_set *set, unsigned first, unsigned n);
+__isl_give isl_set *isl_set_normalize(__isl_take isl_set *set);
 
-struct isl_basic_map *isl_basic_map_eliminate_vars(
-	struct isl_basic_map *bmap, unsigned pos, unsigned n);
-struct isl_basic_set *isl_basic_set_eliminate_vars(
-	struct isl_basic_set *bset, unsigned pos, unsigned n);
+__isl_give isl_basic_map *isl_basic_map_eliminate_vars(
+	__isl_take isl_basic_map *bmap, unsigned pos, unsigned n);
+__isl_give isl_basic_set *isl_basic_set_eliminate_vars(
+	__isl_take isl_basic_set *bset, unsigned pos, unsigned n);
 
 __isl_give isl_map *isl_map_eliminate(__isl_take isl_map *map,
 	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_set *isl_set_eliminate(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned first, unsigned n);
+__isl_give isl_map *isl_map_project_onto(__isl_take isl_map *map,
+	enum isl_dim_type type, unsigned first, unsigned n);
 
-int isl_basic_set_constraint_is_redundant(struct isl_basic_set **bset,
-	isl_int *c, isl_int *opt_n, isl_int *opt_d);
-
-int isl_basic_map_add_div_constraint(__isl_keep isl_basic_map *bmap,
-	unsigned div, int sign);
-int isl_basic_map_add_div_constraints(struct isl_basic_map *bmap, unsigned div);
+__isl_give isl_basic_map *isl_basic_map_add_div_constraint(
+	__isl_take isl_basic_map *bmap, unsigned div, int sign);
+__isl_give isl_basic_map *isl_basic_map_add_div_constraints(
+	__isl_take isl_basic_map *bmap, unsigned div);
 __isl_give isl_basic_map *isl_basic_map_add_known_div_constraints(
 	__isl_take isl_basic_map *bmap);
-struct isl_basic_map *isl_basic_map_drop_redundant_divs(
-	struct isl_basic_map *bmap);
-struct isl_basic_set *isl_basic_set_drop_redundant_divs(
-	struct isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_drop_redundant_divs(
+	__isl_take isl_basic_map *bmap);
 
-struct isl_basic_set *isl_basic_set_recession_cone(struct isl_basic_set *bset);
-struct isl_basic_set *isl_basic_set_lineality_space(struct isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_recession_cone(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_lineality_space(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_set *isl_set_combined_lineality_space(
+	__isl_take isl_set *set);
 
-struct isl_basic_set *isl_basic_set_set_rational(struct isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_set_integral(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_set *isl_basic_set_set_rational(
+	__isl_take isl_basic_set *bset);
 __isl_give isl_set *isl_set_set_rational(__isl_take isl_set *set);
 __isl_give isl_basic_map *isl_basic_map_set_rational(
 	__isl_take isl_basic_map *bmap);
 __isl_give isl_map *isl_map_set_rational(__isl_take isl_map *map);
 
-int isl_map_has_rational(__isl_keep isl_map *map);
-int isl_set_has_rational(__isl_keep isl_set *set);
+isl_bool isl_map_is_rational(__isl_keep isl_map *map);
+isl_bool isl_set_is_rational(__isl_keep isl_set *set);
+
+isl_bool isl_map_has_rational(__isl_keep isl_map *map);
+isl_bool isl_set_has_rational(__isl_keep isl_set *set);
+
+__isl_give isl_basic_map *isl_basic_map_from_multi_aff2(
+	__isl_take isl_multi_aff *maff, int rational);
+__isl_give isl_map *isl_map_from_multi_aff_internal(
+	__isl_take isl_multi_aff *ma);
+__isl_give isl_map *isl_map_from_pw_aff_internal(__isl_take isl_pw_aff *pa);
+__isl_give isl_map *isl_map_from_pw_multi_aff_internal(
+	__isl_take isl_pw_multi_aff *pma);
 
 struct isl_mat;
 
-struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset,
-	struct isl_mat *mat);
-struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat);
+__isl_give isl_basic_set *isl_basic_set_preimage(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *mat);
+__isl_give isl_set *isl_set_preimage(
+	__isl_take isl_set *set, __isl_take isl_mat *mat);
 
+__isl_give isl_basic_map *isl_basic_map_transform_dims(
+	__isl_take isl_basic_map *bmap, enum isl_dim_type type, unsigned first,
+	__isl_take isl_mat *trans);
 __isl_give isl_basic_set *isl_basic_set_transform_dims(
 	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned first,
 	__isl_take isl_mat *trans);
@@ -316,23 +423,20 @@
 isl_int *isl_set_wrap_facet(__isl_keep isl_set *set,
 	isl_int *facet, isl_int *ridge);
 
-int isl_basic_map_contains_point(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_contains_point(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_point *point);
+isl_bool isl_set_contains_point(__isl_keep isl_set *set,
 	__isl_keep isl_point *point);
-int isl_set_contains_point(__isl_keep isl_set *set, __isl_keep isl_point *point);
 
-int isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
+isl_stat isl_basic_set_vars_get_sign(__isl_keep isl_basic_set *bset,
 	unsigned first, unsigned n, int *signs);
-int isl_set_foreach_orthant(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
+isl_stat isl_set_foreach_orthant(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_set *orthant, int *signs, void *user),
 	void *user);
 
-int isl_basic_map_add_div_constraints_var(__isl_keep isl_basic_map *bmap,
-	unsigned pos, isl_int *div);
-int isl_basic_set_add_div_constraints_var(__isl_keep isl_basic_set *bset,
-	unsigned pos, isl_int *div);
-int isl_basic_map_is_div_constraint(__isl_keep isl_basic_map *bmap,
-	isl_int *constraint, unsigned div);
-int isl_basic_set_is_div_constraint(__isl_keep isl_basic_set *bset,
+isl_bool isl_basic_set_eq_is_stride(__isl_keep isl_basic_set *bset, int i);
+
+isl_bool isl_basic_map_is_div_constraint(__isl_keep isl_basic_map *bmap,
 	isl_int *constraint, unsigned div);
 
 __isl_give isl_basic_set *isl_basic_set_from_local_space(
@@ -341,30 +445,59 @@
 	__isl_take isl_local_space *ls);
 __isl_give isl_basic_set *isl_basic_set_expand_divs(
 	__isl_take isl_basic_set *bset, __isl_take isl_mat *div, int *exp);
-
-int isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap);
+__isl_give isl_basic_map *isl_basic_map_expand_divs(
+	__isl_take isl_basic_set *bmap, __isl_take isl_mat *div, int *exp);
+
+isl_size isl_basic_set_n_equality(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_map_n_equality(__isl_keep isl_basic_map *bmap);
+isl_size isl_basic_set_n_inequality(__isl_keep isl_basic_set *bset);
+isl_size isl_basic_map_n_inequality(__isl_keep isl_basic_map *bmap);
+
+__isl_give isl_basic_map *isl_basic_map_mark_div_unknown(
+	__isl_take isl_basic_map *bmap, int div);
+isl_bool isl_basic_map_div_is_marked_unknown(__isl_keep isl_basic_map *bmap,
+	int div);
+isl_bool isl_basic_map_div_is_known(__isl_keep isl_basic_map *bmap, int div);
+int isl_basic_set_first_unknown_div(__isl_keep isl_basic_set *bset);
+int isl_basic_map_first_unknown_div(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_divs_known(__isl_keep isl_basic_map *bmap);
+isl_bool isl_map_divs_known(__isl_keep isl_map *map);
 __isl_give isl_mat *isl_basic_set_get_divs(__isl_keep isl_basic_set *bset);
 __isl_give isl_mat *isl_basic_map_get_divs(__isl_keep isl_basic_map *bmap);
 
+isl_bool isl_set_every_basic_set(__isl_keep isl_set *set,
+	isl_bool (*test)(__isl_keep isl_basic_set *bset, void *user),
+	void *user);
 __isl_give isl_map *isl_map_inline_foreach_basic_map(__isl_take isl_map *map,
 	__isl_give isl_basic_map *(*fn)(__isl_take isl_basic_map *bmap));
 
-__isl_give isl_map *isl_map_align_params_map_map_and(
-	__isl_take isl_map *map1, __isl_take isl_map *map2,
-	__isl_give isl_map *(*fn)(__isl_take isl_map *map1,
-				    __isl_take isl_map *map2));
-int isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
-	__isl_keep isl_map *map2,
-	int (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2));
+isl_stat isl_basic_set_check_no_params(__isl_keep isl_basic_set *bset);
+isl_stat isl_basic_set_check_no_locals(__isl_keep isl_basic_set *bset);
 
-int isl_basic_map_foreach_lexopt(__isl_keep isl_basic_map *bmap, int max,
-	int (*fn)(__isl_take isl_basic_set *dom, __isl_take isl_aff_list *list,
-		  void *user),
-	void *user);
-int isl_basic_set_foreach_lexopt(__isl_keep isl_basic_set *bset, int max,
-	int (*fn)(__isl_take isl_basic_set *dom, __isl_take isl_aff_list *list,
-		  void *user),
-	void *user);
+isl_stat isl_basic_set_check_range(__isl_keep isl_basic_set *bset,
+	enum isl_dim_type type, unsigned first, unsigned n);
+isl_stat isl_set_check_range(__isl_keep isl_set *set,
+	enum isl_dim_type type, unsigned first, unsigned n);
+isl_stat isl_basic_map_check_range(__isl_keep isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned first, unsigned n);
+isl_stat isl_map_check_named_params(__isl_keep isl_map *map);
+
+isl_bool isl_map_has_equal_params(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
+isl_bool isl_basic_set_space_has_equal_params(__isl_keep isl_basic_set *bset,
+	__isl_keep isl_space *space);
+isl_bool isl_set_space_has_equal_params(__isl_keep isl_set *set,
+	__isl_keep isl_space *space);
+isl_bool isl_map_space_has_equal_params(__isl_keep isl_map *map,
+	__isl_keep isl_space *space);
+
+isl_stat isl_map_align_params_bin(__isl_keep isl_map **map1,
+	__isl_keep isl_map **map2);
+isl_stat isl_map_align_params_set(__isl_keep isl_map **map,
+	__isl_keep isl_set **set);
+isl_bool isl_map_align_params_map_map_and_test(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2,
+	isl_bool (*fn)(__isl_keep isl_map *map1, __isl_keep isl_map *map2));
 
 __isl_give isl_set *isl_set_substitute(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, __isl_keep isl_aff *subs);
@@ -372,37 +505,94 @@
 __isl_give isl_set *isl_set_gist_params_basic_set(__isl_take isl_set *set,
 	__isl_take isl_basic_set *context);
 
-int isl_map_compatible_range(__isl_keep isl_map *map, __isl_keep isl_set *set);
+isl_bool isl_map_compatible_range(__isl_keep isl_map *map,
+	__isl_keep isl_set *set);
 
-int isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_plain_is_non_empty(__isl_keep isl_basic_map *bmap);
+isl_bool isl_basic_map_plain_is_single_valued(__isl_keep isl_basic_map *bmap);
 
-int isl_map_is_set(__isl_keep isl_map *map);
+isl_bool isl_map_is_set(__isl_keep isl_map *map);
+isl_bool isl_map_is_params(__isl_keep isl_map *map);
 
-int isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
+isl_bool isl_basic_set_plain_dim_is_fixed(__isl_keep isl_basic_set *bset,
 	unsigned dim, isl_int *val);
 
-int isl_basic_set_dim_residue_class(struct isl_basic_set *bset,
+__isl_give isl_set *isl_set_plain_gist_basic_set(__isl_take isl_set *set,
+	__isl_take isl_basic_set *context);
+__isl_give isl_map *isl_map_plain_gist_basic_map(__isl_take isl_map *map,
+	__isl_take isl_basic_map *context);
+__isl_give isl_map *isl_map_plain_gist(__isl_take isl_map *map,
+	__isl_take isl_map *context);
+
+__isl_give isl_basic_set *isl_basic_set_plain_affine_hull(
+	__isl_take isl_basic_set *bset);
+__isl_give isl_basic_map *isl_basic_map_plain_affine_hull(
+	__isl_take isl_basic_map *bmap);
+
+isl_stat isl_basic_set_dim_residue_class(__isl_keep isl_basic_set *bset,
 	int pos, isl_int *modulo, isl_int *residue);
-int isl_set_dim_residue_class(struct isl_set *set,
+isl_stat isl_set_dim_residue_class(__isl_keep isl_set *set,
 	int pos, isl_int *modulo, isl_int *residue);
 
 __isl_give isl_basic_set *isl_basic_set_fix(__isl_take isl_basic_set *bset,
 	enum isl_dim_type type, unsigned pos, isl_int value);
+__isl_give isl_basic_map *isl_basic_map_fix(__isl_take isl_basic_map *bmap,
+	enum isl_dim_type type, unsigned pos, isl_int value);
 __isl_give isl_set *isl_set_fix(__isl_take isl_set *set,
 	enum isl_dim_type type, unsigned pos, isl_int value);
-int isl_map_plain_is_fixed(__isl_keep isl_map *map,
+isl_bool isl_map_plain_is_fixed(__isl_keep isl_map *map,
 	enum isl_dim_type type, unsigned pos, isl_int *val);
 
 int isl_basic_map_output_defining_equality(__isl_keep isl_basic_map *bmap,
-	int pos);
+	int pos, int *div, int *ineq);
 
-__isl_give isl_basic_set_list *isl_set_get_basic_set_list(
-	__isl_keep isl_set *set);
+__isl_give isl_basic_map *isl_basic_map_reduce_coefficients(
+	__isl_take isl_basic_map *bmap);
 
-__isl_give isl_map *isl_map_fixed_power(__isl_take isl_map *map, isl_int exp);
+__isl_give isl_basic_map *isl_basic_map_shift_div(
+	__isl_take isl_basic_map *bmap, int div, int pos, isl_int shift);
 
 int isl_basic_set_count_upto(__isl_keep isl_basic_set *bset,
 	isl_int max, isl_int *count);
 int isl_set_count_upto(__isl_keep isl_set *set, isl_int max, isl_int *count);
 
+isl_bool isl_map_space_tuple_is_equal(__isl_keep isl_map *map,
+	enum isl_dim_type type1, __isl_keep isl_space *space,
+	enum isl_dim_type type2);
+isl_bool isl_map_tuple_is_equal(__isl_keep isl_map *map1,
+	enum isl_dim_type type1, __isl_keep isl_map *map2,
+	enum isl_dim_type type2);
+isl_bool isl_map_has_space(__isl_keep isl_map *map,
+	__isl_keep isl_space *space);
+isl_bool isl_map_has_space_tuples(__isl_keep isl_map *map,
+	__isl_keep isl_space *space);
+
+isl_bool isl_basic_map_is_transformation(__isl_keep isl_basic_map *bmap);
+isl_stat isl_map_check_transformation(__isl_keep isl_map *map);
+isl_stat isl_basic_set_check_equal_space(__isl_keep isl_basic_set *bset1,
+	__isl_keep isl_basic_set *bset2);
+isl_stat isl_basic_map_check_equal_space(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2);
+isl_stat isl_set_basic_set_check_equal_space(__isl_keep isl_set *set,
+	__isl_keep isl_basic_set *bset);
+isl_stat isl_map_basic_map_check_equal_space(__isl_keep isl_map *map,
+	__isl_keep isl_basic_map *bmap);
+isl_stat isl_map_check_equal_space(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2);
+
+isl_bool isl_basic_map_applies_range(__isl_keep isl_basic_map *bmap1,
+	__isl_keep isl_basic_map *bmap2);
+
+__isl_give isl_mat *isl_basic_set_extract_equalities(
+	__isl_keep isl_basic_set *bset);
+
+isl_bool isl_basic_map_equal_div_expr_part(__isl_keep isl_basic_map *bmap1,
+	int pos1, __isl_keep isl_basic_map *bmap2, int pos2,
+	unsigned first, unsigned n);
+isl_bool isl_basic_map_equal_div_expr_except_constant(
+	__isl_keep isl_basic_map *bmap1, int pos1,
+	__isl_keep isl_basic_map *bmap2, int pos2);
+__isl_give isl_basic_map *isl_basic_map_set_div_expr_constant_num_si_inplace(
+	__isl_take isl_basic_map *bmap, int div, int value);
+
 #endif

_service:tar_scm:isl-0.14.tar.xz/isl_map_simplify.c -> _service:tar_scm:isl-0.24.tar.gz/isl_map_simplify.c Changed

@@ -1,7 +1,8 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
- * Copyright 2012      Ecole Normale Superieure
- * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2014-2015 INRIA Rocquencourt
+ * Copyright 2016      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
@@ -12,7 +13,6 @@
  * B.P. 105 - 78153 Le Chesnay, France
  */
 
-#include <strings.h>
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
 #include "isl_equalities.h"
@@ -23,14 +23,19 @@
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 
-static void swap_equality(struct isl_basic_map *bmap, int a, int b)
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
+#include <set_from_map.c>
+
+static void swap_equality(__isl_keep isl_basic_map *bmap, int a, int b)
 {
 	isl_int *t = bmap->eqa;
 	bmap->eqa = bmap->eqb;
 	bmap->eqb = t;
 }
 
-static void swap_inequality(struct isl_basic_map *bmap, int a, int b)
+static void swap_inequality(__isl_keep isl_basic_map *bmap, int a, int b)
 {
 	if (a != b) {
 		isl_int *t = bmap->ineqa;
@@ -39,343 +44,192 @@
 	}
 }
 
-static void constraint_drop_vars(isl_int *c, unsigned n, unsigned rem)
-{
-	isl_seq_cpy(c, c + n, rem);
-	isl_seq_clr(c + rem, n);
-}
-
-/* Drop n dimensions starting at first.
- *
- * In principle, this frees up some extra variables as the number
- * of columns remains constant, but we would have to extend
- * the div array too as the number of rows in this array is assumed
- * to be equal to extra.
- */
-struct isl_basic_set *isl_basic_set_drop_dims(
-		struct isl_basic_set *bset, unsigned first, unsigned n)
-{
-	int i;
-
-	if (!bset)
-		goto error;
-
-	isl_assert(bset->ctx, first + n <= bset->dim->n_out, goto error);
-
-	if (n == 0 && !isl_space_get_tuple_name(bset->dim, isl_dim_set))
-		return bset;
-
-	bset = isl_basic_set_cow(bset);
-	if (!bset)
-		return NULL;
-
-	for (i = 0; i < bset->n_eq; ++i)
-		constraint_drop_vars(bset->eqi+1+bset->dim->nparam+first, n,
-				     (bset->dim->n_out-first-n)+bset->extra);
-
-	for (i = 0; i < bset->n_ineq; ++i)
-		constraint_drop_vars(bset->ineqi+1+bset->dim->nparam+first, n,
-				     (bset->dim->n_out-first-n)+bset->extra);
-
-	for (i = 0; i < bset->n_div; ++i)
-		constraint_drop_vars(bset->divi+1+1+bset->dim->nparam+first, n,
-				     (bset->dim->n_out-first-n)+bset->extra);
-
-	bset->dim = isl_space_drop_outputs(bset->dim, first, n);
-	if (!bset->dim)
-		goto error;
-
-	ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
-	bset = isl_basic_set_simplify(bset);
-	return isl_basic_set_finalize(bset);
-error:
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
-struct isl_set *isl_set_drop_dims(
-		struct isl_set *set, unsigned first, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_normalize_constraints(
+	__isl_take isl_basic_map *bmap)
 {
 	int i;
+	isl_int gcd;
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
 
-	if (!set)
-		goto error;
-
-	isl_assert(set->ctx, first + n <= set->dim->n_out, goto error);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
-	if (n == 0 && !isl_space_get_tuple_name(set->dim, isl_dim_set))
-		return set;
-	set = isl_set_cow(set);
-	if (!set)
-		goto error;
-	set->dim = isl_space_drop_outputs(set->dim, first, n);
-	if (!set->dim)
-		goto error;
+	isl_int_init(gcd);
+	for (i = bmap->n_eq - 1; i >= 0; --i) {
+		isl_seq_gcd(bmap->eqi+1, total, &gcd);
+		if (isl_int_is_zero(gcd)) {
+			if (!isl_int_is_zero(bmap->eqi0)) {
+				bmap = isl_basic_map_set_to_empty(bmap);
+				break;
+			}
+			if (isl_basic_map_drop_equality(bmap, i) < 0)
+				goto error;
+			continue;
+		}
+		if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+			isl_int_gcd(gcd, gcd, bmap->eqi0);
+		if (isl_int_is_one(gcd))
+			continue;
+		if (!isl_int_is_divisible_by(bmap->eqi0, gcd)) {
+			bmap = isl_basic_map_set_to_empty(bmap);
+			break;
+		}
+		isl_seq_scale_down(bmap->eqi, bmap->eqi, gcd, 1+total);
+	}
 
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_drop_dims(set->pi, first, n);
-		if (!set->pi)
-			goto error;
+	for (i = bmap->n_ineq - 1; i >= 0; --i) {
+		isl_seq_gcd(bmap->ineqi+1, total, &gcd);
+		if (isl_int_is_zero(gcd)) {
+			if (isl_int_is_neg(bmap->ineqi0)) {
+				bmap = isl_basic_map_set_to_empty(bmap);
+				break;
+			}
+			if (isl_basic_map_drop_inequality(bmap, i) < 0)
+				goto error;
+			continue;
+		}
+		if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
+			isl_int_gcd(gcd, gcd, bmap->ineqi0);
+		if (isl_int_is_one(gcd))
+			continue;
+		isl_int_fdiv_q(bmap->ineqi0, bmap->ineqi0, gcd);
+		isl_seq_scale_down(bmap->ineqi+1, bmap->ineqi+1, gcd, total);
 	}
+	isl_int_clear(gcd);
 
-	ISL_F_CLR(set, ISL_SET_NORMALIZED);
-	return set;
+	return bmap;
 error:
-	isl_set_free(set);
+	isl_int_clear(gcd);
+	isl_basic_map_free(bmap);
 	return NULL;
 }
 
-/* Move "n" divs starting at "first" to the end of the list of divs.
- */
-static struct isl_basic_map *move_divs_last(struct isl_basic_map *bmap,
-	unsigned first, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_normalize_constraints(
+	__isl_take isl_basic_set *bset)
 {
-	isl_int **div;
-	int i;
-
-	if (first + n == bmap->n_div)
-		return bmap;
-
-	div = isl_alloc_array(bmap->ctx, isl_int *, n);
-	if (!div)
-		goto error;
-	for (i = 0; i < n; ++i)
-		divi = bmap->divfirst + i;
-	for (i = 0; i < bmap->n_div - first - n; ++i)
-		bmap->divfirst + i = bmap->divfirst + n + i;
-	for (i = 0; i < n; ++i)
-		bmap->divbmap->n_div - n + i = divi;
-	free(div);
-	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
+	isl_basic_map *bmap = bset_to_bmap(bset);
+	return bset_from_bmap(isl_basic_map_normalize_constraints(bmap));
 }
 
-/* Drop "n" dimensions of type "type" starting at "first".
+/* Reduce the coefficient of the variable at position "pos"
+ * in integer division "div", such that it lies in the half-open
+ * interval (1/2,1/2, extracting any excess value from this integer division.
+ * "pos" is as determined by isl_basic_map_offset, i.e., pos == 0
+ * corresponds to the constant term.
  *
- * In principle, this frees up some extra variables as the number
- * of columns remains constant, but we would have to extend
- * the div array too as the number of rows in this array is assumed
- * to be equal to extra.
+ * That is, the integer division is of the form
+ *
+ *	floor((... + (c * d + r) * x_pos + ...)/d)
+ *
+ * with -d < 2 * r <= d.
+ * Replace it by
+ *
+ *	floor((... + r * x_pos + ...)/d) + c * x_pos
+ *
+ * If 2 * ((c * d + r) % d) <= d, then c = floor((c * d + r)/d).
+ * Otherwise, c = floor((c * d + r)/d) + 1.
+ *
+ * This is the same normalization that is performed by isl_aff_floor.
  */
-struct isl_basic_map *isl_basic_map_drop(struct isl_basic_map *bmap,
-	enum isl_dim_type type, unsigned first, unsigned n)
+static __isl_give isl_basic_map *reduce_coefficient_in_div(
+	__isl_take isl_basic_map *bmap, int div, int pos)
 {
-	int i;
-	unsigned dim;
-	unsigned offset;
-	unsigned left;
+	isl_int shift;
+	int add_one;
 
-	if (!bmap)
-		goto error;
-
-	dim = isl_basic_map_dim(bmap, type);
-	isl_assert(bmap->ctx, first + n <= dim, goto error);
-
-	if (n == 0 && !isl_space_is_named_or_nested(bmap->dim, type))
-		return bmap;
-
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		return NULL;
-
-	offset = isl_basic_map_offset(bmap, type) + first;
-	left = isl_basic_map_total_dim(bmap) - (offset - 1) - n;
-	for (i = 0; i < bmap->n_eq; ++i)
-		constraint_drop_vars(bmap->eqi+offset, n, left);
+	isl_int_init(shift);
+	isl_int_fdiv_r(shift, bmap->divdiv1 + pos, bmap->divdiv0);
+	isl_int_mul_ui(shift, shift, 2);
+	add_one = isl_int_gt(shift, bmap->divdiv0);
+	isl_int_fdiv_q(shift, bmap->divdiv1 + pos, bmap->divdiv0);
+	if (add_one)
+		isl_int_add_ui(shift, shift, 1);
+	isl_int_neg(shift, shift);
+	bmap = isl_basic_map_shift_div(bmap, div, pos, shift);
+	isl_int_clear(shift);
 
-	for (i = 0; i < bmap->n_ineq; ++i)
-		constraint_drop_vars(bmap->ineqi+offset, n, left);
-
-	for (i = 0; i < bmap->n_div; ++i)
-		constraint_drop_vars(bmap->divi+1+offset, n, left);
-
-	if (type == isl_dim_div) {
-		bmap = move_divs_last(bmap, first, n);
-		if (!bmap)
-			goto error;
-		isl_basic_map_free_div(bmap, n);
-	} else
-		bmap->dim = isl_space_drop_dims(bmap->dim, type, first, n);
-	if (!bmap->dim)
-		goto error;
-
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-	bmap = isl_basic_map_simplify(bmap);
-	return isl_basic_map_finalize(bmap);
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-__isl_give isl_basic_set *isl_basic_set_drop(__isl_take isl_basic_set *bset,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return (isl_basic_set *)isl_basic_map_drop((isl_basic_map *)bset,
-							type, first, n);
-}
-
-struct isl_basic_map *isl_basic_map_drop_inputs(
-		struct isl_basic_map *bmap, unsigned first, unsigned n)
-{
-	return isl_basic_map_drop(bmap, isl_dim_in, first, n);
+	return bmap;
 }
 
-struct isl_map *isl_map_drop(struct isl_map *map,
-	enum isl_dim_type type, unsigned first, unsigned n)
+/* Does the coefficient of the variable at position "pos"
+ * in integer division "div" need to be reduced?
+ * That is, does it lie outside the half-open interval (1/2,1/2?
+ * The coefficient c/d lies outside this interval if abs(2 * c) >= d and
+ * 2 * c != d.
+ */
+static isl_bool needs_reduction(__isl_keep isl_basic_map *bmap, int div,
+	int pos)
 {
-	int i;
+	isl_bool r;
 
-	if (!map)
-		goto error;
-
-	isl_assert(map->ctx, first + n <= isl_map_dim(map, type), goto error);
+	if (isl_int_is_zero(bmap->divdiv1 + pos))
+		return isl_bool_false;
 
-	if (n == 0 && !isl_space_get_tuple_name(map->dim, type))
-		return map;
-	map = isl_map_cow(map);
-	if (!map)
-		goto error;
-	map->dim = isl_space_drop_dims(map->dim, type, first, n);
-	if (!map->dim)
-		goto error;
+	isl_int_mul_ui(bmap->divdiv1 + pos, bmap->divdiv1 + pos, 2);
+	r = isl_int_abs_ge(bmap->divdiv1 + pos, bmap->divdiv0) &&
+	    !isl_int_eq(bmap->divdiv1 + pos, bmap->divdiv0);
+	isl_int_divexact_ui(bmap->divdiv1 + pos,
+			    bmap->divdiv1 + pos, 2);
 
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_drop(map->pi, type, first, n);
-		if (!map->pi)
-			goto error;
-	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
-}
-
-struct isl_set *isl_set_drop(struct isl_set *set,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return (isl_set *)isl_map_drop((isl_map *)set, type, first, n);
-}
-
-struct isl_map *isl_map_drop_inputs(
-		struct isl_map *map, unsigned first, unsigned n)
-{
-	return isl_map_drop(map, isl_dim_in, first, n);
+	return r;
 }
 
-/*
- * We don't cow, as the div is assumed to be redundant.
+/* Reduce the coefficients (including the constant term) of
+ * integer division "div", if needed.
+ * In particular, make sure all coefficients lie in
+ * the half-open interval (1/2,1/2.
  */
-static struct isl_basic_map *isl_basic_map_drop_div(
-		struct isl_basic_map *bmap, unsigned div)
+static __isl_give isl_basic_map *reduce_div_coefficients_of_div(
+	__isl_take isl_basic_map *bmap, int div)
 {
 	int i;
-	unsigned pos;
-
-	if (!bmap)
-		goto error;
+	isl_size total;
 
-	pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	for (i = 0; i < 1 + total; ++i) {
+		isl_bool reduce;
 
-	isl_assert(bmap->ctx, div < bmap->n_div, goto error);
-
-	for (i = 0; i < bmap->n_eq; ++i)
-		constraint_drop_vars(bmap->eqi+pos, 1, bmap->extra-div-1);
-
-	for (i = 0; i < bmap->n_ineq; ++i) {
-		if (!isl_int_is_zero(bmap->ineqipos)) {
-			isl_basic_map_drop_inequality(bmap, i);
-			--i;
+		reduce = needs_reduction(bmap, div, i);
+		if (reduce < 0)
+			return isl_basic_map_free(bmap);
+		if (!reduce)
 			continue;
-		}
-		constraint_drop_vars(bmap->ineqi+pos, 1, bmap->extra-div-1);
-	}
-
-	for (i = 0; i < bmap->n_div; ++i)
-		constraint_drop_vars(bmap->divi+1+pos, 1, bmap->extra-div-1);
-
-	if (div != bmap->n_div - 1) {
-		int j;
-		isl_int *t = bmap->divdiv;
-
-		for (j = div; j < bmap->n_div - 1; ++j)
-			bmap->divj = bmap->divj+1;
-
-		bmap->divbmap->n_div - 1 = t;
+		bmap = reduce_coefficient_in_div(bmap, div, i);
+		if (!bmap)
+			break;
 	}
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-	isl_basic_map_free_div(bmap, 1);
 
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
-struct isl_basic_map *isl_basic_map_normalize_constraints(
-	struct isl_basic_map *bmap)
+/* Reduce the coefficients (including the constant term) of
+ * the known integer divisions, if needed
+ * In particular, make sure all coefficients lie in
+ * the half-open interval (1/2,1/2.
+ */
+static __isl_give isl_basic_map *reduce_div_coefficients(
+	__isl_take isl_basic_map *bmap)
 {
 	int i;
-	isl_int gcd;
-	unsigned total = isl_basic_map_total_dim(bmap);
 
 	if (!bmap)
 		return NULL;
+	if (bmap->n_div == 0)
+		return bmap;
 
-	isl_int_init(gcd);
-	for (i = bmap->n_eq - 1; i >= 0; --i) {
-		isl_seq_gcd(bmap->eqi+1, total, &gcd);
-		if (isl_int_is_zero(gcd)) {
-			if (!isl_int_is_zero(bmap->eqi0)) {
-				bmap = isl_basic_map_set_to_empty(bmap);
-				break;
-			}
-			isl_basic_map_drop_equality(bmap, i);
-			continue;
-		}
-		if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
-			isl_int_gcd(gcd, gcd, bmap->eqi0);
-		if (isl_int_is_one(gcd))
+	for (i = 0; i < bmap->n_div; ++i) {
+		if (isl_int_is_zero(bmap->divi0))
 			continue;
-		if (!isl_int_is_divisible_by(bmap->eqi0, gcd)) {
-			bmap = isl_basic_map_set_to_empty(bmap);
+		bmap = reduce_div_coefficients_of_div(bmap, i);
+		if (!bmap)
 			break;
-		}
-		isl_seq_scale_down(bmap->eqi, bmap->eqi, gcd, 1+total);
 	}
 
-	for (i = bmap->n_ineq - 1; i >= 0; --i) {
-		isl_seq_gcd(bmap->ineqi+1, total, &gcd);
-		if (isl_int_is_zero(gcd)) {
-			if (isl_int_is_neg(bmap->ineqi0)) {
-				bmap = isl_basic_map_set_to_empty(bmap);
-				break;
-			}
-			isl_basic_map_drop_inequality(bmap, i);
-			continue;
-		}
-		if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL))
-			isl_int_gcd(gcd, gcd, bmap->ineqi0);
-		if (isl_int_is_one(gcd))
-			continue;
-		isl_int_fdiv_q(bmap->ineqi0, bmap->ineqi0, gcd);
-		isl_seq_scale_down(bmap->ineqi+1, bmap->ineqi+1, gcd, total);
-	}
-	isl_int_clear(gcd);
-
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_normalize_constraints(
-	struct isl_basic_set *bset)
-{
-	return (struct isl_basic_set *)isl_basic_map_normalize_constraints(
-		(struct isl_basic_map *)bset);
-}
-
 /* Remove any common factor in numerator and denominator of the div expression,
  * not taking into account the constant term.
  * That is, if the div is of the form
@@ -389,23 +243,28 @@
  * The difference {a/m}/d in the argument satisfies 0 <= {a/m}/d < 1/d
  * and can therefore not influence the result of the floor.
  */
-static void normalize_div_expression(__isl_keep isl_basic_map *bmap, int div)
+static __isl_give isl_basic_map *normalize_div_expression(
+	__isl_take isl_basic_map *bmap, int div)
 {
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
 	isl_ctx *ctx = bmap->ctx;
 
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 	if (isl_int_is_zero(bmap->divdiv0))
-		return;
+		return bmap;
 	isl_seq_gcd(bmap->divdiv + 2, total, &ctx->normalize_gcd);
 	isl_int_gcd(ctx->normalize_gcd, ctx->normalize_gcd, bmap->divdiv0);
 	if (isl_int_is_one(ctx->normalize_gcd))
-		return;
+		return bmap;
 	isl_int_fdiv_q(bmap->divdiv1, bmap->divdiv1,
 			ctx->normalize_gcd);
 	isl_int_divexact(bmap->divdiv0, bmap->divdiv0,
 			ctx->normalize_gcd);
 	isl_seq_scale_down(bmap->divdiv + 2, bmap->divdiv + 2,
 			ctx->normalize_gcd, total);
+
+	return bmap;
 }
 
 /* Remove any common factor in numerator and denominator of a div expression,
@@ -432,24 +291,27 @@
 		return bmap;
 
 	for (i = 0; i < bmap->n_div; ++i)
-		normalize_div_expression(bmap, i);
+		bmap = normalize_div_expression(bmap, i);
 
 	return bmap;
 }
 
 /* Assumes divs have been ordered if keep_divs is set.
  */
-static void eliminate_var_using_equality(struct isl_basic_map *bmap,
+static __isl_give isl_basic_map *eliminate_var_using_equality(
+	__isl_take isl_basic_map *bmap,
 	unsigned pos, isl_int *eq, int keep_divs, int *progress)
 {
-	unsigned total;
-	unsigned space_total;
+	isl_size total;
+	isl_size v_div;
 	int k;
 	int last_div;
 
-	total = isl_basic_map_total_dim(bmap);
-	space_total = isl_space_dim(bmap->dim, isl_dim_all);
-	last_div = isl_seq_last_non_zero(eq + 1 + space_total, bmap->n_div);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (total < 0 || v_div < 0)
+		return isl_basic_map_free(bmap);
+	last_div = isl_seq_last_non_zero(eq + 1 + v_div, bmap->n_div);
 	for (k = 0; k < bmap->n_eq; ++k) {
 		if (bmap->eqk == eq)
 			continue;
@@ -468,7 +330,8 @@
 			*progress = 1;
 		isl_seq_elim(bmap->ineqk, eq, 1+pos, 1+total, NULL);
 		isl_seq_normalize(bmap->ctx, bmap->ineqk, 1 + total);
-		ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
+		ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+		ISL_F_CLR(bmap, ISL_BASIC_MAP_SORTED);
 	}
 
 	for (k = 0; k < bmap->n_div; ++k) {
@@ -488,54 +351,69 @@
 		if (last_div == -1 || (keep_divs && last_div < k)) {
 			isl_seq_elim(bmap->divk+1, eq,
 					1+pos, 1+total, &bmap->divk0);
-			normalize_div_expression(bmap, k);
+			bmap = normalize_div_expression(bmap, k);
+			if (!bmap)
+				return NULL;
 		} else
 			isl_seq_clr(bmap->divk, 1 + total);
-		ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 	}
+
+	return bmap;
 }
 
 /* Assumes divs have been ordered if keep_divs is set.
  */
-static void eliminate_div(struct isl_basic_map *bmap, isl_int *eq,
-	unsigned div, int keep_divs)
+static __isl_give isl_basic_map *eliminate_div(__isl_take isl_basic_map *bmap,
+	isl_int *eq, unsigned div, int keep_divs)
 {
-	unsigned pos = isl_space_dim(bmap->dim, isl_dim_all) + div;
+	isl_size v_div;
+	unsigned pos;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
+	pos = v_div + div;
+	bmap = eliminate_var_using_equality(bmap, pos, eq, keep_divs, NULL);
 
-	eliminate_var_using_equality(bmap, pos, eq, keep_divs, NULL);
+	bmap = isl_basic_map_drop_div(bmap, div);
 
-	isl_basic_map_drop_div(bmap, div);
+	return bmap;
 }
 
 /* Check if elimination of div "div" using equality "eq" would not
  * result in a div depending on a later div.
  */
-static int ok_to_eliminate_div(struct isl_basic_map *bmap, isl_int *eq,
+static isl_bool ok_to_eliminate_div(__isl_keep isl_basic_map *bmap, isl_int *eq,
 	unsigned div)
 {
 	int k;
 	int last_div;
-	unsigned space_total = isl_space_dim(bmap->dim, isl_dim_all);
-	unsigned pos = space_total + div;
+	isl_size v_div;
+	unsigned pos;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_bool_error;
+	pos = v_div + div;
 
-	last_div = isl_seq_last_non_zero(eq + 1 + space_total, bmap->n_div);
+	last_div = isl_seq_last_non_zero(eq + 1 + v_div, bmap->n_div);
 	if (last_div < 0 || last_div <= div)
-		return 1;
+		return isl_bool_true;
 
 	for (k = 0; k <= last_div; ++k) {
 		if (isl_int_is_zero(bmap->divk0))
-			return 1;
+			continue;
 		if (!isl_int_is_zero(bmap->divk1 + 1 + pos))
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-/* Elimininate divs based on equalities
+/* Eliminate divs based on equalities
  */
-static struct isl_basic_map *eliminate_divs_eq(
-		struct isl_basic_map *bmap, int *progress)
+static __isl_give isl_basic_map *eliminate_divs_eq(
+	__isl_take isl_basic_map *bmap, int *progress)
 {
 	int d;
 	int i;
@@ -547,19 +425,25 @@
 	if (!bmap)
 		return NULL;
 
-	off = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	off = isl_basic_map_offset(bmap, isl_dim_div);
 
 	for (d = bmap->n_div - 1; d >= 0 ; --d) {
 		for (i = 0; i < bmap->n_eq; ++i) {
+			isl_bool ok;
+
 			if (!isl_int_is_one(bmap->eqioff + d) &&
 			    !isl_int_is_negone(bmap->eqioff + d))
 				continue;
-			if (!ok_to_eliminate_div(bmap, bmap->eqi, d))
+			ok = ok_to_eliminate_div(bmap, bmap->eqi, d);
+			if (ok < 0)
+				return isl_basic_map_free(bmap);
+			if (!ok)
 				continue;
 			modified = 1;
 			*progress = 1;
-			eliminate_div(bmap, bmap->eqi, d, 1);
-			isl_basic_map_drop_equality(bmap, i);
+			bmap = eliminate_div(bmap, bmap->eqi, d, 1);
+			if (isl_basic_map_drop_equality(bmap, i) < 0)
+				return isl_basic_map_free(bmap);
 			break;
 		}
 	}
@@ -568,10 +452,10 @@
 	return bmap;
 }
 
-/* Elimininate divs based on inequalities
+/* Eliminate divs based on inequalities
  */
-static struct isl_basic_map *eliminate_divs_ineq(
-		struct isl_basic_map *bmap, int *progress)
+static __isl_give isl_basic_map *eliminate_divs_ineq(
+	__isl_take isl_basic_map *bmap, int *progress)
 {
 	int d;
 	int i;
@@ -582,7 +466,7 @@
 		return NULL;
 
 	ctx = bmap->ctx;
-	off = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	off = isl_basic_map_offset(bmap, isl_dim_div);
 
 	for (d = bmap->n_div - 1; d >= 0 ; --d) {
 		for (i = 0; i < bmap->n_eq; ++i)
@@ -606,21 +490,128 @@
 	return bmap;
 }
 
-struct isl_basic_map *isl_basic_map_gauss(
-	struct isl_basic_map *bmap, int *progress)
+/* Does the equality constraint at position "eq" in "bmap" involve
+ * any local variables in the range first, first + n)
+ * that are not marked as having an explicit representation?
+ */
+static isl_bool bmap_eq_involves_unknown_divs(__isl_keep isl_basic_map *bmap,
+	int eq, unsigned first, unsigned n)
+{
+	unsigned o_div;
+	int i;
+
+	if (!bmap)
+		return isl_bool_error;
+
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	for (i = 0; i < n; ++i) {
+		isl_bool unknown;
+
+		if (isl_int_is_zero(bmap->eqeqo_div + first + i))
+			continue;
+		unknown = isl_basic_map_div_is_marked_unknown(bmap, first + i);
+		if (unknown < 0)
+			return isl_bool_error;
+		if (unknown)
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* The last local variable involved in the equality constraint
+ * at position "eq" in "bmap" is the local variable at position "div".
+ * It can therefore be used to extract an explicit representation
+ * for that variable.
+ * Do so unless the local variable already has an explicit representation or
+ * the explicit representation would involve any other local variables
+ * that in turn do not have an explicit representation.
+ * An equality constraint involving local variables without an explicit
+ * representation can be used in isl_basic_map_drop_redundant_divs
+ * to separate out an independent local variable.  Introducing
+ * an explicit representation here would block this transformation,
+ * while the partial explicit representation in itself is not very useful.
+ * Set *progress if anything is changed.
+ *
+ * The equality constraint is of the form
+ *
+ *	f(x) + n e >= 0
+ *
+ * with n a positive number.  The explicit representation derived from
+ * this constraint is
+ *
+ *	floor((-f(x))/n)
+ */
+static __isl_give isl_basic_map *set_div_from_eq(__isl_take isl_basic_map *bmap,
+	int div, int eq, int *progress)
+{
+	isl_size total;
+	unsigned o_div;
+	isl_bool involves;
+
+	if (!bmap)
+		return NULL;
+
+	if (!isl_int_is_zero(bmap->divdiv0))
+		return bmap;
+
+	involves = bmap_eq_involves_unknown_divs(bmap, eq, 0, div);
+	if (involves < 0)
+		return isl_basic_map_free(bmap);
+	if (involves)
+		return bmap;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	isl_seq_neg(bmap->divdiv + 1, bmap->eqeq, 1 + total);
+	isl_int_set_si(bmap->divdiv1 + o_div + div, 0);
+	isl_int_set(bmap->divdiv0, bmap->eqeqo_div + div);
+	if (progress)
+		*progress = 1;
+
+	return bmap;
+}
+
+/* Perform fangcheng (Gaussian elimination) on the equality
+ * constraints of "bmap".
+ * That is, put them into row-echelon form, starting from the last column
+ * backward and use them to eliminate the corresponding coefficients
+ * from all constraints.
+ *
+ * If "progress" is not NULL, then it gets set if the elimination
+ * results in any changes.
+ * The elimination process may result in some equality constraints
+ * getting interchanged or removed.
+ * If "swap" or "drop" are not NULL, then they get called when
+ * two equality constraints get interchanged or
+ * when a number of final equality constraints get removed.
+ * As a special case, if the input turns out to be empty,
+ * then drop gets called with the number of removed equality
+ * constraints set to the total number of equality constraints.
+ * If "swap" or "drop" are not NULL, then the local variables (if any)
+ * are assumed to be in a valid order.
+ */
+__isl_give isl_basic_map *isl_basic_map_gauss5(__isl_take isl_basic_map *bmap,
+	int *progress,
+	isl_stat (*swap)(unsigned a, unsigned b, void *user),
+	isl_stat (*drop)(unsigned n, void *user), void *user)
 {
 	int k;
 	int done;
 	int last_var;
 	unsigned total_var;
-	unsigned total;
+	isl_size total;
+	unsigned n_drop;
 
-	bmap = isl_basic_map_order_divs(bmap);
+	if (!swap && !drop)
+		bmap = isl_basic_map_order_divs(bmap);
 
-	if (!bmap)
-		return NULL;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
-	total = isl_basic_map_total_dim(bmap);
 	total_var = total - bmap->n_div;
 
 	last_var = total - 1;
@@ -634,42 +625,50 @@
 		}
 		if (last_var < 0)
 			break;
-		if (k != done)
+		if (k != done) {
 			swap_equality(bmap, k, done);
+			if (swap && swap(k, done, user) < 0)
+				return isl_basic_map_free(bmap);
+		}
 		if (isl_int_is_neg(bmap->eqdone1+last_var))
 			isl_seq_neg(bmap->eqdone, bmap->eqdone, 1+total);
 
-		eliminate_var_using_equality(bmap, last_var, bmap->eqdone, 1,
-						progress);
+		bmap = eliminate_var_using_equality(bmap, last_var,
+						bmap->eqdone, 1, progress);
 
-		if (last_var >= total_var &&
-		    isl_int_is_zero(bmap->divlast_var - total_var0)) {
-			unsigned div = last_var - total_var;
-			isl_seq_neg(bmap->divdiv+1, bmap->eqdone, 1+total);
-			isl_int_set_si(bmap->divdiv1+1+last_var, 0);
-			isl_int_set(bmap->divdiv0,
-				    bmap->eqdone1+last_var);
-			if (progress)
-				*progress = 1;
-			ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
-		}
+		if (last_var >= total_var)
+			bmap = set_div_from_eq(bmap, last_var - total_var,
+						done, progress);
+		if (!bmap)
+			return NULL;
 	}
 	if (done == bmap->n_eq)
 		return bmap;
 	for (k = done; k < bmap->n_eq; ++k) {
 		if (isl_int_is_zero(bmap->eqk0))
 			continue;
+		if (drop && drop(bmap->n_eq, user) < 0)
+			return isl_basic_map_free(bmap);
 		return isl_basic_map_set_to_empty(bmap);
 	}
-	isl_basic_map_free_equality(bmap, bmap->n_eq-done);
+	n_drop = bmap->n_eq - done;
+	bmap = isl_basic_map_free_equality(bmap, n_drop);
+	if (drop && drop(n_drop, user) < 0)
+		return isl_basic_map_free(bmap);
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_gauss(
-	struct isl_basic_set *bset, int *progress)
+__isl_give isl_basic_map *isl_basic_map_gauss(__isl_take isl_basic_map *bmap,
+	int *progress)
 {
-	return (struct isl_basic_set*)isl_basic_map_gauss(
-			(struct isl_basic_map *)bset, progress);
+	return isl_basic_map_gauss5(bmap, progress, NULL, NULL, NULL);
+}
+
+__isl_give isl_basic_set *isl_basic_set_gauss(
+	__isl_take isl_basic_set *bset, int *progress)
+{
+	return bset_from_bmap(isl_basic_map_gauss(bset_to_bmap(bset),
+							progress));
 }
 
 
@@ -684,23 +683,129 @@
 	return old_v << 1;
 }
 
-static int hash_index(isl_int ***index, unsigned int size, int bits,
-			struct isl_basic_map *bmap, int k)
+/* Hash table of inequalities in a basic map.
+ * "index" is an array of addresses of inequalities in the basic map, some
+ * of which are NULL.  The inequalities are hashed on the coefficients
+ * except the constant term.
+ * "size" is the number of elements in the array and is always a power of two
+ * "bits" is the number of bits need to represent an index into the array.
+ * "total" is the total dimension of the basic map.
+ */
+struct isl_constraint_index {
+	unsigned int size;
+	int bits;
+	isl_int ***index;
+	isl_size total;
+};
+
+/* Fill in the "ci" data structure for holding the inequalities of "bmap".
+ */
+static isl_stat create_constraint_index(struct isl_constraint_index *ci,
+	__isl_keep isl_basic_map *bmap)
+{
+	isl_ctx *ctx;
+
+	ci->index = NULL;
+	if (!bmap)
+		return isl_stat_error;
+	ci->total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (ci->total < 0)
+		return isl_stat_error;
+	if (bmap->n_ineq == 0)
+		return isl_stat_ok;
+	ci->size = round_up(4 * (bmap->n_ineq + 1) / 3 - 1);
+	ci->bits = ffs(ci->size) - 1;
+	ctx = isl_basic_map_get_ctx(bmap);
+	ci->index = isl_calloc_array(ctx, isl_int **, ci->size);
+	if (!ci->index)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Free the memory allocated by create_constraint_index.
+ */
+static void constraint_index_free(struct isl_constraint_index *ci)
+{
+	free(ci->index);
+}
+
+/* Return the position in ci->index that contains the address of
+ * an inequality that is equal to *ineq up to the constant term,
+ * provided this address is not identical to "ineq".
+ * If there is no such inequality, then return the position where
+ * such an inequality should be inserted.
+ */
+static int hash_index_ineq(struct isl_constraint_index *ci, isl_int **ineq)
 {
 	int h;
-	unsigned total = isl_basic_map_total_dim(bmap);
-	uint32_t hash = isl_seq_get_hash_bits(bmap->ineqk+1, total, bits);
-	for (h = hash; indexh; h = (h+1) % size)
-		if (&bmap->ineqk != indexh &&
-		    isl_seq_eq(bmap->ineqk+1, indexh0+1, total))
+	uint32_t hash = isl_seq_get_hash_bits((*ineq) + 1, ci->total, ci->bits);
+	for (h = hash; ci->indexh; h = (h+1) % ci->size)
+		if (ineq != ci->indexh &&
+		    isl_seq_eq((*ineq) + 1, ci->indexh0+1, ci->total))
 			break;
 	return h;
 }
 
-static int set_hash_index(isl_int ***index, unsigned int size, int bits,
-			  struct isl_basic_set *bset, int k)
+/* Return the position in ci->index that contains the address of
+ * an inequality that is equal to the k'th inequality of "bmap"
+ * up to the constant term, provided it does not point to the very
+ * same inequality.
+ * If there is no such inequality, then return the position where
+ * such an inequality should be inserted.
+ */
+static int hash_index(struct isl_constraint_index *ci,
+	__isl_keep isl_basic_map *bmap, int k)
+{
+	return hash_index_ineq(ci, &bmap->ineqk);
+}
+
+static int set_hash_index(struct isl_constraint_index *ci,
+	__isl_keep isl_basic_set *bset, int k)
+{
+	return hash_index(ci, bset, k);
+}
+
+/* Fill in the "ci" data structure with the inequalities of "bset".
+ */
+static isl_stat setup_constraint_index(struct isl_constraint_index *ci,
+	__isl_keep isl_basic_set *bset)
+{
+	int k, h;
+
+	if (create_constraint_index(ci, bset) < 0)
+		return isl_stat_error;
+
+	for (k = 0; k < bset->n_ineq; ++k) {
+		h = set_hash_index(ci, bset, k);
+		ci->indexh = &bset->ineqk;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Is the inequality ineq (obviously) redundant with respect
+ * to the constraints in "ci"?
+ *
+ * Look for an inequality in "ci" with the same coefficients and then
+ * check if the contant term of "ineq" is greater than or equal
+ * to the constant term of that inequality.  If so, "ineq" is clearly
+ * redundant.
+ *
+ * Note that hash_index_ineq ignores a stored constraint if it has
+ * the same address as the passed inequality.  It is ok to pass
+ * the address of a local variable here since it will never be
+ * the same as the address of a constraint in "ci".
+ */
+static isl_bool constraint_index_is_redundant(struct isl_constraint_index *ci,
+	isl_int *ineq)
 {
-	return hash_index(index, size, bits, (struct isl_basic_map *)bset, k);
+	int h;
+
+	h = hash_index_ineq(ci, &ineq);
+	if (!ci->indexh)
+		return isl_bool_false;
+	return isl_int_ge(ineq0, (*ci->indexh)0);
 }
 
 /* If we can eliminate more than one div, then we need to make
@@ -708,8 +813,8 @@
  * change the position of the other divs that still need to
  * be removed.
  */
-static struct isl_basic_map *remove_duplicate_divs(
-	struct isl_basic_map *bmap, int *progress)
+static __isl_give isl_basic_map *remove_duplicate_divs(
+	__isl_take isl_basic_map *bmap, int *progress)
 {
 	unsigned int size;
 	int *index;
@@ -717,7 +822,7 @@
 	int k, l, h;
 	int bits;
 	struct isl_blk eq;
-	unsigned total_var;
+	isl_size v_div;
 	unsigned total;
 	struct isl_ctx *ctx;
 
@@ -725,8 +830,10 @@
 	if (!bmap || bmap->n_div <= 1)
 		return bmap;
 
-	total_var = isl_space_dim(bmap->dim, isl_dim_all);
-	total = total_var + bmap->n_div;
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
+	total = v_div + bmap->n_div;
 
 	ctx = bmap->ctx;
 	for (k = bmap->n_div - 1; k >= 0; --k)
@@ -735,12 +842,14 @@
 	if (k <= 0)
 		return bmap;
 
-	elim_for = isl_calloc_array(ctx, int, bmap->n_div);
 	size = round_up(4 * bmap->n_div / 3 - 1);
+	if (size == 0)
+		return bmap;
+	elim_for = isl_calloc_array(ctx, int, bmap->n_div);
 	bits = ffs(size) - 1;
 	index = isl_calloc_array(ctx, int, size);
-	if (!index)
-		return bmap;
+	if (!elim_for || !index)
+		goto out;
 	eq = isl_blk_alloc(ctx, 1+total);
 	if (isl_blk_is_error(eq))
 		goto out;
@@ -769,11 +878,13 @@
 		if (!elim_forl)
 			continue;
 		k = elim_forl - 1;
-		isl_int_set_si(eq.data1+total_var+k, -1);
-		isl_int_set_si(eq.data1+total_var+l, 1);
-		eliminate_div(bmap, eq.data, l, 1);
-		isl_int_set_si(eq.data1+total_var+k, 0);
-		isl_int_set_si(eq.data1+total_var+l, 0);
+		isl_int_set_si(eq.data1 + v_div + k, -1);
+		isl_int_set_si(eq.data1 + v_div + l, 1);
+		bmap = eliminate_div(bmap, eq.data, l, 1);
+		if (!bmap)
+			break;
+		isl_int_set_si(eq.data1 + v_div + k, 0);
+		isl_int_set_si(eq.data1 + v_div + l, 0);
 	}
 
 	isl_blk_free(ctx, eq);
@@ -783,18 +894,20 @@
 	return bmap;
 }
 
-static int n_pure_div_eq(struct isl_basic_map *bmap)
+static int n_pure_div_eq(__isl_keep isl_basic_map *bmap)
 {
 	int i, j;
-	unsigned total;
+	isl_size v_div;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return -1;
 	for (i = 0, j = bmap->n_div-1; i < bmap->n_eq; ++i) {
-		while (j >= 0 && isl_int_is_zero(bmap->eqi1 + total + j))
+		while (j >= 0 && isl_int_is_zero(bmap->eqi1 + v_div + j))
 			--j;
 		if (j < 0)
 			break;
-		if (isl_seq_first_non_zero(bmap->eqi + 1 + total, j) != -1)
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + v_div, j) != -1)
 			return 0;
 	}
 	return i;
@@ -848,11 +961,11 @@
  * we have to replace each x'', i.e., the x'_k with (g_kk = 1),
  * by the corresponding row from C_2.
  */
-static struct isl_basic_map *normalize_divs(
-	struct isl_basic_map *bmap, int *progress)
+static __isl_give isl_basic_map *normalize_divs(__isl_take isl_basic_map *bmap,
+	int *progress)
 {
 	int i, j, k;
-	int total;
+	isl_size v_div;
 	int div_eq;
 	struct isl_mat *B;
 	struct isl_vec *d;
@@ -860,7 +973,7 @@
 	struct isl_mat *C = NULL;
 	struct isl_mat *C2 = NULL;
 	isl_int v;
-	int *pos;
+	int *pos = NULL;
 	int dropped, needed;
 
 	if (!bmap)
@@ -875,14 +988,16 @@
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_NORMALIZED_DIVS))
 		return bmap;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
 	div_eq = n_pure_div_eq(bmap);
+	if (v_div < 0 || div_eq < 0)
+		return isl_basic_map_free(bmap);
 	if (div_eq == 0)
 		return bmap;
 
 	if (div_eq < bmap->n_eq) {
 		B = isl_mat_sub_alloc6(bmap->ctx, bmap->eq, div_eq,
-					bmap->n_eq - div_eq, 0, 1 + total);
+					bmap->n_eq - div_eq, 0, 1 + v_div);
 		C = isl_mat_variable_compression(B, &C2);
 		if (!C || !C2)
 			goto error;
@@ -898,11 +1013,11 @@
 	if (!d)
 		goto error;
 	for (i = 0, j = bmap->n_div-1; i < div_eq; ++i) {
-		while (j >= 0 && isl_int_is_zero(bmap->eqi1 + total + j))
+		while (j >= 0 && isl_int_is_zero(bmap->eqi1 + v_div + j))
 			--j;
-		isl_int_set(d->block.datai, bmap->eqi1 + total + j);
+		isl_int_set(d->block.datai, bmap->eqi1 + v_div + j);
 	}
-	B = isl_mat_sub_alloc6(bmap->ctx, bmap->eq, 0, div_eq, 0, 1 + total);
+	B = isl_mat_sub_alloc6(bmap->ctx, bmap->eq, 0, div_eq, 0, 1 + v_div);
 
 	if (C) {
 		B = isl_mat_product(B, C);
@@ -933,11 +1048,12 @@
 	dropped = 0;
 	for (j = bmap->n_div - 1; j >= 0; --j) {
 		for (i = 0; i < bmap->n_eq; ++i)
-			if (!isl_int_is_zero(bmap->eqi1 + total + j))
+			if (!isl_int_is_zero(bmap->eqi1 + v_div + j))
 				break;
 		if (i < bmap->n_eq) {
 			bmap = isl_basic_map_drop_div(bmap, j);
-			isl_basic_map_drop_equality(bmap, i);
+			if (isl_basic_map_drop_equality(bmap, i) < 0)
+				goto error;
 			++dropped;
 		}
 	}
@@ -950,8 +1066,7 @@
 			needed++;
 	}
 	if (needed > dropped) {
-		bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
-				needed, needed, 0);
+		bmap = isl_basic_map_extend(bmap, needed, needed, 0);
 		if (!bmap)
 			goto error;
 	}
@@ -959,11 +1074,11 @@
 		if (isl_int_is_one(T->rowii))
 			continue;
 		k = isl_basic_map_alloc_div(bmap);
-		posi = 1 + total + k;
-		isl_seq_clr(bmap->divk + 1, 1 + total + bmap->n_div);
+		posi = 1 + v_div + k;
+		isl_seq_clr(bmap->divk + 1, 1 + v_div + bmap->n_div);
 		isl_int_set(bmap->divk0, T->rowii);
 		if (C2)
-			isl_seq_cpy(bmap->divk + 1, C2->rowi, 1 + total);
+			isl_seq_cpy(bmap->divk + 1, C2->rowi, 1 + v_div);
 		else
 			isl_int_set_si(bmap->divk1 + i, 1);
 		for (j = 0; j < i; ++j) {
@@ -971,13 +1086,13 @@
 				continue;
 			if (posj < T->n_row && C2)
 				isl_seq_submul(bmap->divk + 1, T->rowij,
-						C2->rowposj, 1 + total);
+						C2->rowposj, 1 + v_div);
 			else
 				isl_int_neg(bmap->divk1 + posj,
 								T->rowij);
 		}
 		j = isl_basic_map_alloc_equality(bmap);
-		isl_seq_neg(bmap->eqj, bmap->divk+1, 1+total+bmap->n_div);
+		isl_seq_neg(bmap->eqj, bmap->divk+1, 1+v_div+bmap->n_div);
 		isl_int_set(bmap->eqjposi, bmap->divk0);
 	}
 	free(pos);
@@ -991,16 +1106,18 @@
 
 	return bmap;
 error:
+	free(pos);
 	isl_mat_free(C);
 	isl_mat_free(C2);
 	isl_mat_free(T);
-	return bmap;
+	isl_basic_map_free(bmap);
+	return NULL;
 }
 
-static struct isl_basic_map *set_div_from_lower_bound(
-	struct isl_basic_map *bmap, int div, int ineq)
+static __isl_give isl_basic_map *set_div_from_lower_bound(
+	__isl_take isl_basic_map *bmap, int div, int ineq)
 {
-	unsigned total = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	unsigned total = isl_basic_map_offset(bmap, isl_dim_div);
 
 	isl_seq_neg(bmap->divdiv + 1, bmap->ineqineq, total + bmap->n_div);
 	isl_int_set(bmap->divdiv0, bmap->ineqineqtotal + div);
@@ -1017,11 +1134,11 @@
  * any other undefined divs or if any known div is defined in
  * terms of the unknown div.
  */
-static int ok_to_set_div_from_bound(struct isl_basic_map *bmap,
+static isl_bool ok_to_set_div_from_bound(__isl_keep isl_basic_map *bmap,
 	int div, int ineq)
 {
 	int j;
-	unsigned total = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	unsigned total = isl_basic_map_offset(bmap, isl_dim_div);
 
 	/* Not defined in terms of unknown divs */
 	for (j = 0; j < bmap->n_div; ++j) {
@@ -1030,7 +1147,7 @@
 		if (isl_int_is_zero(bmap->ineqineqtotal + j))
 			continue;
 		if (isl_int_is_zero(bmap->divj0))
-			return 0;
+			return isl_bool_false;
 	}
 
 	/* No other div defined in terms of this one => avoid loops */
@@ -1040,10 +1157,10 @@
 		if (isl_int_is_zero(bmap->divj0))
 			continue;
 		if (!isl_int_is_zero(bmap->divj1 + total + div))
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Would an expression for div "div" based on inequality "ineq" of "bmap"
@@ -1054,19 +1171,19 @@
  * (disregarding the div that it would define) is in an earlier position
  * than the last variable involved in the current div expression.
  */
-static int better_div_constraint(__isl_keep isl_basic_map *bmap,
+static isl_bool better_div_constraint(__isl_keep isl_basic_map *bmap,
 	int div, int ineq)
 {
-	unsigned total = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	unsigned total = isl_basic_map_offset(bmap, isl_dim_div);
 	int last_div;
 	int last_ineq;
 
 	if (isl_int_is_zero(bmap->divdiv0))
-		return 1;
+		return isl_bool_true;
 
 	if (isl_seq_last_non_zero(bmap->ineqineq + total + div + 1,
 				  bmap->n_div - (div + 1)) >= 0)
-		return 0;
+		return isl_bool_false;
 
 	last_ineq = isl_seq_last_non_zero(bmap->ineqineq, total + div);
 	last_div = isl_seq_last_non_zero(bmap->divdiv + 1,
@@ -1087,20 +1204,26 @@
  * any other undefined divs or if any known div is defined in
  * terms of the unknown div.
  */
-static struct isl_basic_map *check_for_div_constraints(
-	struct isl_basic_map *bmap, int k, int l, isl_int sum, int *progress)
+static __isl_give isl_basic_map *check_for_div_constraints(
+	__isl_take isl_basic_map *bmap, int k, int l, isl_int sum,
+	int *progress)
 {
 	int i;
-	unsigned total = 1 + isl_space_dim(bmap->dim, isl_dim_all);
+	unsigned total = isl_basic_map_offset(bmap, isl_dim_div);
 
 	for (i = 0; i < bmap->n_div; ++i) {
+		isl_bool set_div;
+
 		if (isl_int_is_zero(bmap->ineqktotal + i))
 			continue;
 		if (isl_int_abs_ge(sum, bmap->ineqktotal + i))
 			continue;
-		if (!better_div_constraint(bmap, i, k))
-			continue;
-		if (!ok_to_set_div_from_bound(bmap, i, k))
+		set_div = better_div_constraint(bmap, i, k);
+		if (set_div >= 0 && set_div)
+			set_div = ok_to_set_div_from_bound(bmap, i, k);
+		if (set_div < 0)
+			return isl_basic_map_free(bmap);
+		if (!set_div)
 			break;
 		if (isl_int_is_pos(bmap->ineqktotal + i))
 			bmap = set_div_from_lower_bound(bmap, i, k);
@@ -1116,47 +1239,41 @@
 __isl_give isl_basic_map *isl_basic_map_remove_duplicate_constraints(
 	__isl_take isl_basic_map *bmap, int *progress, int detect_divs)
 {
-	unsigned int size;
-	isl_int ***index;
+	struct isl_constraint_index ci;
 	int k, l, h;
-	int bits;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
 	isl_int sum;
-	isl_ctx *ctx;
 
-	if (!bmap || bmap->n_ineq <= 1)
+	if (total < 0 || bmap->n_ineq <= 1)
 		return bmap;
 
-	size = round_up(4 * (bmap->n_ineq+1) / 3 - 1);
-	bits = ffs(size) - 1;
-	ctx = isl_basic_map_get_ctx(bmap);
-	index = isl_calloc_array(ctx, isl_int **, size);
-	if (!index)
+	if (create_constraint_index(&ci, bmap) < 0)
 		return bmap;
 
-	indexisl_seq_get_hash_bits(bmap->ineq0+1, total, bits) = &bmap->ineq0;
+	h = isl_seq_get_hash_bits(bmap->ineq0 + 1, total, ci.bits);
+	ci.indexh = &bmap->ineq0;
 	for (k = 1; k < bmap->n_ineq; ++k) {
-		h = hash_index(index, size, bits, bmap, k);
-		if (!indexh) {
-			indexh = &bmap->ineqk;
+		h = hash_index(&ci, bmap, k);
+		if (!ci.indexh) {
+			ci.indexh = &bmap->ineqk;
 			continue;
 		}
 		if (progress)
 			*progress = 1;
-		l = indexh - &bmap->ineq0;
+		l = ci.indexh - &bmap->ineq0;
 		if (isl_int_lt(bmap->ineqk0, bmap->ineql0))
 			swap_inequality(bmap, k, l);
 		isl_basic_map_drop_inequality(bmap, k);
 		--k;
 	}
 	isl_int_init(sum);
-	for (k = 0; k < bmap->n_ineq-1; ++k) {
+	for (k = 0; bmap && k < bmap->n_ineq-1; ++k) {
 		isl_seq_neg(bmap->ineqk+1, bmap->ineqk+1, total);
-		h = hash_index(index, size, bits, bmap, k);
+		h = hash_index(&ci, bmap, k);
 		isl_seq_neg(bmap->ineqk+1, bmap->ineqk+1, total);
-		if (!indexh)
+		if (!ci.indexh)
 			continue;
-		l = indexh - &bmap->ineq0;
+		l = ci.indexh - &bmap->ineq0;
 		isl_int_add(sum, bmap->ineqk0, bmap->ineql0);
 		if (isl_int_is_pos(sum)) {
 			if (detect_divs)
@@ -1180,13 +1297,36 @@
 	}
 	isl_int_clear(sum);
 
-	free(index);
+	constraint_index_free(&ci);
 	return bmap;
 }
 
+/* Detect all pairs of inequalities that form an equality.
+ *
+ * isl_basic_map_remove_duplicate_constraints detects at most one such pair.
+ * Call it repeatedly while it is making progress.
+ */
+__isl_give isl_basic_map *isl_basic_map_detect_inequality_pairs(
+	__isl_take isl_basic_map *bmap, int *progress)
+{
+	int duplicate;
 
-/* Eliminate knowns divs from constraints where they appear with
- * a (positive or negative) unit coefficient.
+	do {
+		duplicate = 0;
+		bmap = isl_basic_map_remove_duplicate_constraints(bmap,
+								&duplicate, 0);
+		if (progress && duplicate)
+			*progress = 1;
+	} while (duplicate);
+
+	return bmap;
+}
+
+/* Given a known integer division "div" that is not integral
+ * (with denominator 1), eliminate it from the constraints in "bmap"
+ * where it appears with a (positive or negative) unit coefficient.
+ * If "progress" is not NULL, then it gets set if the elimination
+ * results in any changes.
  *
  * That is, replace
  *
@@ -1216,80 +1356,179 @@
  * being modified by this function.  The modified constraint may
  * no longer imply this div constraint, so we add it back to make
  * sure we do not lose any information.
+ */
+static __isl_give isl_basic_map *eliminate_unit_div(
+	__isl_take isl_basic_map *bmap, int div, int *progress)
+{
+	int j;
+	isl_size v_div, dim;
+	isl_ctx *ctx;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	if (v_div < 0 || dim < 0)
+		return isl_basic_map_free(bmap);
+
+	ctx = isl_basic_map_get_ctx(bmap);
+
+	for (j = 0; j < bmap->n_ineq; ++j) {
+		int s;
+
+		if (!isl_int_is_one(bmap->ineqj1 + v_div + div) &&
+		    !isl_int_is_negone(bmap->ineqj1 + v_div + div))
+			continue;
+
+		if (progress)
+			*progress = 1;
+
+		s = isl_int_sgn(bmap->ineqj1 + v_div + div);
+		isl_int_set_si(bmap->ineqj1 + v_div + div, 0);
+		if (s < 0)
+			isl_seq_combine(bmap->ineqj,
+				ctx->negone, bmap->divdiv + 1,
+				bmap->divdiv0, bmap->ineqj, 1 + dim);
+		else
+			isl_seq_combine(bmap->ineqj,
+				ctx->one, bmap->divdiv + 1,
+				bmap->divdiv0, bmap->ineqj, 1 + dim);
+		if (s < 0) {
+			isl_int_add(bmap->ineqj0,
+				bmap->ineqj0, bmap->divdiv0);
+			isl_int_sub_ui(bmap->ineqj0,
+				bmap->ineqj0, 1);
+		}
+
+		bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
+		bmap = isl_basic_map_add_div_constraint(bmap, div, s);
+		if (!bmap)
+			return NULL;
+	}
+
+	return bmap;
+}
+
+/* Eliminate selected known divs from constraints where they appear with
+ * a (positive or negative) unit coefficient.
+ * In particular, only handle those for which "select" returns isl_bool_true.
+ * If "progress" is not NULL, then it gets set if the elimination
+ * results in any changes.
  *
  * We skip integral divs, i.e., those with denominator 1, as we would
  * risk eliminating the div from the div constraints.  We do not need
  * to handle those divs here anyway since the div constraints will turn
- * out to form an equality and this equality can then be use to eliminate
+ * out to form an equality and this equality can then be used to eliminate
  * the div from all constraints.
  */
-static __isl_give isl_basic_map *eliminate_unit_divs(
-	__isl_take isl_basic_map *bmap, int *progress)
+static __isl_give isl_basic_map *eliminate_selected_unit_divs(
+	__isl_take isl_basic_map *bmap,
+	isl_bool (*select)(__isl_keep isl_basic_map *bmap, int div),
+	int *progress)
 {
-	int i, j;
-	isl_ctx *ctx;
-	unsigned total;
+	int i;
 
 	if (!bmap)
 		return NULL;
 
-	ctx = isl_basic_map_get_ctx(bmap);
-	total = 1 + isl_space_dim(bmap->dim, isl_dim_all);
-
 	for (i = 0; i < bmap->n_div; ++i) {
+		isl_bool selected;
+
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
 		if (isl_int_is_one(bmap->divi0))
 			continue;
-		for (j = 0; j < bmap->n_ineq; ++j) {
-			int s;
+		selected = select(bmap, i);
+		if (selected < 0)
+			return isl_basic_map_free(bmap);
+		if (!selected)
+			continue;
+		bmap = eliminate_unit_div(bmap, i, progress);
+		if (!bmap)
+			return NULL;
+	}
 
-			if (!isl_int_is_one(bmap->ineqjtotal + i) &&
-			    !isl_int_is_negone(bmap->ineqjtotal + i))
-				continue;
+	return bmap;
+}
 
-			*progress = 1;
+/* eliminate_selected_unit_divs callback that selects every
+ * integer division.
+ */
+static isl_bool is_any_div(__isl_keep isl_basic_map *bmap, int div)
+{
+	return isl_bool_true;
+}
 
-			s = isl_int_sgn(bmap->ineqjtotal + i);
-			isl_int_set_si(bmap->ineqjtotal + i, 0);
-			if (s < 0)
-				isl_seq_combine(bmap->ineqj,
-					ctx->negone, bmap->divi + 1,
-					bmap->divi0, bmap->ineqj,
-					total + bmap->n_div);
-			else
-				isl_seq_combine(bmap->ineqj,
-					ctx->one, bmap->divi + 1,
-					bmap->divi0, bmap->ineqj,
-					total + bmap->n_div);
-			if (s < 0) {
-				isl_int_add(bmap->ineqj0,
-					bmap->ineqj0, bmap->divi0);
-				isl_int_sub_ui(bmap->ineqj0,
-					bmap->ineqj0, 1);
-			}
+/* Eliminate known divs from constraints where they appear with
+ * a (positive or negative) unit coefficient.
+ * If "progress" is not NULL, then it gets set if the elimination
+ * results in any changes.
+ */
+static __isl_give isl_basic_map *eliminate_unit_divs(
+	__isl_take isl_basic_map *bmap, int *progress)
+{
+	return eliminate_selected_unit_divs(bmap, &is_any_div, progress);
+}
 
-			bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
-			if (isl_basic_map_add_div_constraint(bmap, i, s) < 0)
-				return isl_basic_map_free(bmap);
-		}
+/* eliminate_selected_unit_divs callback that selects
+ * integer divisions that only appear with
+ * a (positive or negative) unit coefficient
+ * (outside their div constraints).
+ */
+static isl_bool is_pure_unit_div(__isl_keep isl_basic_map *bmap, int div)
+{
+	int i;
+	isl_size v_div, n_ineq;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	n_ineq = isl_basic_map_n_inequality(bmap);
+	if (v_div < 0 || n_ineq < 0)
+		return isl_bool_error;
+
+	for (i = 0; i < n_ineq; ++i) {
+		isl_bool skip;
+
+		if (isl_int_is_zero(bmap->ineqi1 + v_div + div))
+			continue;
+		skip = isl_basic_map_is_div_constraint(bmap,
+							bmap->ineqi, div);
+		if (skip < 0)
+			return isl_bool_error;
+		if (skip)
+			continue;
+		if (!isl_int_is_one(bmap->ineqi1 + v_div + div) &&
+		    !isl_int_is_negone(bmap->ineqi1 + v_div + div))
+			return isl_bool_false;
 	}
 
-	return bmap;
+	return isl_bool_true;
+}
+
+/* Eliminate known divs from constraints where they appear with
+ * a (positive or negative) unit coefficient,
+ * but only if they do not appear in any other constraints
+ * (other than the div constraints).
+ */
+__isl_give isl_basic_map *isl_basic_map_eliminate_pure_unit_divs(
+	__isl_take isl_basic_map *bmap)
+{
+	return eliminate_selected_unit_divs(bmap, &is_pure_unit_div, NULL);
 }
 
-struct isl_basic_map *isl_basic_map_simplify(struct isl_basic_map *bmap)
+__isl_give isl_basic_map *isl_basic_map_simplify(__isl_take isl_basic_map *bmap)
 {
 	int progress = 1;
 	if (!bmap)
 		return NULL;
 	while (progress) {
+		isl_bool empty;
+
 		progress = 0;
-		if (!bmap)
-			break;
-		if (isl_basic_map_plain_is_empty(bmap))
+		empty = isl_basic_map_plain_is_empty(bmap);
+		if (empty < 0)
+			return isl_basic_map_free(bmap);
+		if (empty)
 			break;
 		bmap = isl_basic_map_normalize_constraints(bmap);
+		bmap = reduce_div_coefficients(bmap);
 		bmap = normalize_div_expressions(bmap);
 		bmap = remove_duplicate_divs(bmap, &progress);
 		bmap = eliminate_unit_divs(bmap, &progress);
@@ -1300,26 +1539,28 @@
 		bmap = normalize_divs(bmap, &progress);
 		bmap = isl_basic_map_remove_duplicate_constraints(bmap,
 								&progress, 1);
+		if (bmap && progress)
+			ISL_F_CLR(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS);
 	}
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_simplify(struct isl_basic_set *bset)
+__isl_give isl_basic_set *isl_basic_set_simplify(
+	__isl_take isl_basic_set *bset)
 {
-	return (struct isl_basic_set *)
-		isl_basic_map_simplify((struct isl_basic_map *)bset);
+	return bset_from_bmap(isl_basic_map_simplify(bset_to_bmap(bset)));
 }
 
 
-int isl_basic_map_is_div_constraint(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_is_div_constraint(__isl_keep isl_basic_map *bmap,
 	isl_int *constraint, unsigned div)
 {
 	unsigned pos;
 
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 
-	pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
+	pos = isl_basic_map_offset(bmap, isl_dim_div) + div;
 
 	if (isl_int_eq(constraintpos, bmap->divdiv0)) {
 		int neg;
@@ -1331,29 +1572,22 @@
 		isl_int_add(bmap->divdiv1,
 				bmap->divdiv1, bmap->divdiv0);
 		if (!neg)
-			return 0;
+			return isl_bool_false;
 		if (isl_seq_first_non_zero(constraint+pos+1,
 					    bmap->n_div-div-1) != -1)
-			return 0;
+			return isl_bool_false;
 	} else if (isl_int_abs_eq(constraintpos, bmap->divdiv0)) {
 		if (!isl_seq_eq(constraint, bmap->divdiv+1, pos))
-			return 0;
+			return isl_bool_false;
 		if (isl_seq_first_non_zero(constraint+pos+1,
 					    bmap->n_div-div-1) != -1)
-			return 0;
+			return isl_bool_false;
 	} else
-		return 0;
-
-	return 1;
-}
+		return isl_bool_false;
 
-int isl_basic_set_is_div_constraint(__isl_keep isl_basic_set *bset,
-	isl_int *constraint, unsigned div)
-{
-	return isl_basic_map_is_div_constraint(bset, constraint, div);
+	return isl_bool_true;
 }
 
-
 /* If the only constraints a div d=floor(f/m)
  * appears in are its two defining constraints
  *
@@ -1362,30 +1596,37 @@
  *
  * then it can safely be removed.
  */
-static int div_is_redundant(struct isl_basic_map *bmap, int div)
+static isl_bool div_is_redundant(__isl_keep isl_basic_map *bmap, int div)
 {
 	int i;
-	unsigned pos = 1 + isl_space_dim(bmap->dim, isl_dim_all) + div;
+	isl_size v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	unsigned pos = 1 + v_div + div;
+
+	if (v_div < 0)
+		return isl_bool_error;
 
 	for (i = 0; i < bmap->n_eq; ++i)
 		if (!isl_int_is_zero(bmap->eqipos))
-			return 0;
+			return isl_bool_false;
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
+		isl_bool red;
+
 		if (isl_int_is_zero(bmap->ineqipos))
 			continue;
-		if (!isl_basic_map_is_div_constraint(bmap, bmap->ineqi, div))
-			return 0;
+		red = isl_basic_map_is_div_constraint(bmap, bmap->ineqi, div);
+		if (red < 0 || !red)
+			return red;
 	}
 
 	for (i = 0; i < bmap->n_div; ++i) {
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
 		if (!isl_int_is_zero(bmap->divi1+pos))
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /*
@@ -1394,78 +1635,65 @@
  * when the divs of a basic map have been temporarily aligned
  * with the divs of another basic map.
  */
-static struct isl_basic_map *remove_redundant_divs(struct isl_basic_map *bmap)
+static __isl_give isl_basic_map *remove_redundant_divs(
+	__isl_take isl_basic_map *bmap)
 {
 	int i;
+	isl_size v_div;
 
-	if (!bmap)
-		return NULL;
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
 
 	for (i = bmap->n_div-1; i >= 0; --i) {
-		if (!div_is_redundant(bmap, i))
+		isl_bool redundant;
+
+		redundant = div_is_redundant(bmap, i);
+		if (redundant < 0)
+			return isl_basic_map_free(bmap);
+		if (!redundant)
 			continue;
+		bmap = isl_basic_map_drop_constraints_involving(bmap,
+								v_div + i, 1);
 		bmap = isl_basic_map_drop_div(bmap, i);
 	}
 	return bmap;
 }
 
-struct isl_basic_map *isl_basic_map_finalize(struct isl_basic_map *bmap)
+/* Mark "bmap" as final, without checking for obviously redundant
+ * integer divisions.  This function should be used when "bmap"
+ * is known not to involve any such integer divisions.
+ */
+__isl_give isl_basic_map *isl_basic_map_mark_final(
+	__isl_take isl_basic_map *bmap)
 {
-	bmap = remove_redundant_divs(bmap);
 	if (!bmap)
 		return NULL;
 	ISL_F_SET(bmap, ISL_BASIC_SET_FINAL);
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_finalize(struct isl_basic_set *bset)
-{
-	return (struct isl_basic_set *)
-		isl_basic_map_finalize((struct isl_basic_map *)bset);
-}
-
-struct isl_set *isl_set_finalize(struct isl_set *set)
+/* Mark "bmap" as final, after removing obviously redundant integer divisions.
+ */
+__isl_give isl_basic_map *isl_basic_map_finalize(__isl_take isl_basic_map *bmap)
 {
-	int i;
-
-	if (!set)
-		return NULL;
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_basic_set_finalize(set->pi);
-		if (!set->pi)
-			goto error;
-	}
-	return set;
-error:
-	isl_set_free(set);
-	return NULL;
+	bmap = remove_redundant_divs(bmap);
+	bmap = isl_basic_map_mark_final(bmap);
+	return bmap;
 }
 
-struct isl_map *isl_map_finalize(struct isl_map *map)
+__isl_give isl_basic_set *isl_basic_set_finalize(
+	__isl_take isl_basic_set *bset)
 {
-	int i;
-
-	if (!map)
-		return NULL;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_finalize(map->pi);
-		if (!map->pi)
-			goto error;
-	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-	return map;
-error:
-	isl_map_free(map);
-	return NULL;
+	return bset_from_bmap(isl_basic_map_finalize(bset_to_bmap(bset)));
 }
 
-
 /* Remove definition of any div that is defined in terms of the given variable.
  * The div itself is not removed.  Functions such as
  * eliminate_divs_ineq depend on the other divs remaining in place.
  */
-static struct isl_basic_map *remove_dependent_vars(struct isl_basic_map *bmap,
-									int pos)
+static __isl_give isl_basic_map *remove_dependent_vars(
+	__isl_take isl_basic_map *bmap, int pos)
 {
 	int i;
 
@@ -1477,7 +1705,9 @@
 			continue;
 		if (isl_int_is_zero(bmap->divi1+1+pos))
 			continue;
-		isl_int_set_si(bmap->divi0, 0);
+		bmap = isl_basic_map_mark_div_unknown(bmap, i);
+		if (!bmap)
+			return NULL;
 	}
 	return bmap;
 }
@@ -1485,19 +1715,19 @@
 /* Eliminate the specified variables from the constraints using
  * Fourier-Motzkin.  The variables themselves are not removed.
  */
-struct isl_basic_map *isl_basic_map_eliminate_vars(
-	struct isl_basic_map *bmap, unsigned pos, unsigned n)
+__isl_give isl_basic_map *isl_basic_map_eliminate_vars(
+	__isl_take isl_basic_map *bmap, unsigned pos, unsigned n)
 {
 	int d;
 	int i, j, k;
-	unsigned total;
+	isl_size total;
 	int need_gauss = 0;
 
 	if (n == 0)
 		return bmap;
-	if (!bmap)
-		return NULL;
-	total = isl_basic_map_total_dim(bmap);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
 
 	bmap = isl_basic_map_cow(bmap);
 	for (d = pos + n - 1; d >= 0 && d >= pos; --d)
@@ -1515,8 +1745,10 @@
 		for (i = 0; i < bmap->n_eq; ++i) {
 			if (isl_int_is_zero(bmap->eqi1+d))
 				continue;
-			eliminate_var_using_equality(bmap, d, bmap->eqi, 0, NULL);
-			isl_basic_map_drop_equality(bmap, i);
+			bmap = eliminate_var_using_equality(bmap, d,
+							bmap->eqi, 0, NULL);
+			if (isl_basic_map_drop_equality(bmap, i) < 0)
+				return isl_basic_map_free(bmap);
 			need_gauss = 1;
 			break;
 		}
@@ -1570,7 +1802,6 @@
 				break;
 		}
 	}
-	ISL_F_CLR(bmap, ISL_BASIC_MAP_NORMALIZED);
 	if (need_gauss)
 		bmap = isl_basic_map_gauss(bmap, NULL);
 	return bmap;
@@ -1579,11 +1810,11 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_eliminate_vars(
-	struct isl_basic_set *bset, unsigned pos, unsigned n)
+__isl_give isl_basic_set *isl_basic_set_eliminate_vars(
+	__isl_take isl_basic_set *bset, unsigned pos, unsigned n)
 {
-	return (struct isl_basic_set *)isl_basic_map_eliminate_vars(
-			(struct isl_basic_map *)bset, pos, n);
+	return bset_from_bmap(isl_basic_map_eliminate_vars(bset_to_bmap(bset),
+								pos, n));
 }
 
 /* Eliminate the specified n dimensions starting at first from the
@@ -1602,9 +1833,8 @@
 	if (n == 0)
 		return bmap;
 
-	if (first + n > isl_basic_map_dim(bmap, type) || first + n < first)
-		isl_die(bmap->ctx, isl_error_invalid,
-			"index out of bounds", goto error);
+	if (isl_basic_map_check_range(bmap, type, first, n) < 0)
+		return isl_basic_map_free(bmap);
 
 	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL)) {
 		first += isl_basic_map_offset(bmap, type) - 1;
@@ -1617,9 +1847,6 @@
 	bmap = isl_basic_map_insert_dims(bmap, type, first, n);
 	bmap = isl_basic_map_reset_space(bmap, space);
 	return bmap;
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
 }
 
 __isl_give isl_basic_set *isl_basic_set_eliminate(
@@ -1629,19 +1856,114 @@
 	return isl_basic_map_eliminate(bset, type, first, n);
 }
 
+/* Remove all constraints from "bmap" that reference any unknown local
+ * variables (directly or indirectly).
+ *
+ * Dropping all constraints on a local variable will make it redundant,
+ * so it will get removed implicitly by
+ * isl_basic_map_drop_constraints_involving_dims.  Some other local
+ * variables may also end up becoming redundant if they only appear
+ * in constraints together with the unknown local variable.
+ * Therefore, start over after calling
+ * isl_basic_map_drop_constraints_involving_dims.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_constraints_involving_unknown_divs(
+	__isl_take isl_basic_map *bmap)
+{
+	isl_bool known;
+	isl_size n_div;
+	int i, o_div;
+
+	known = isl_basic_map_divs_known(bmap);
+	if (known < 0)
+		return isl_basic_map_free(bmap);
+	if (known)
+		return bmap;
+
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_basic_map_free(bmap);
+	o_div = isl_basic_map_offset(bmap, isl_dim_div) - 1;
+
+	for (i = 0; i < n_div; ++i) {
+		known = isl_basic_map_div_is_known(bmap, i);
+		if (known < 0)
+			return isl_basic_map_free(bmap);
+		if (known)
+			continue;
+		bmap = remove_dependent_vars(bmap, o_div + i);
+		bmap = isl_basic_map_drop_constraints_involving_dims(bmap,
+							    isl_dim_div, i, 1);
+		n_div = isl_basic_map_dim(bmap, isl_dim_div);
+		if (n_div < 0)
+			return isl_basic_map_free(bmap);
+		i = -1;
+	}
+
+	return bmap;
+}
+
+/* Remove all constraints from "bset" that reference any unknown local
+ * variables (directly or indirectly).
+ */
+__isl_give isl_basic_set *isl_basic_set_drop_constraints_involving_unknown_divs(
+	__isl_take isl_basic_set *bset)
+{
+	isl_basic_map *bmap;
+
+	bmap = bset_to_bmap(bset);
+	bmap = isl_basic_map_drop_constraints_involving_unknown_divs(bmap);
+	return bset_from_bmap(bmap);
+}
+
+/* Remove all constraints from "map" that reference any unknown local
+ * variables (directly or indirectly).
+ *
+ * Since constraints may get dropped from the basic maps,
+ * they may no longer be disjoint from each other.
+ */
+__isl_give isl_map *isl_map_drop_constraints_involving_unknown_divs(
+	__isl_take isl_map *map)
+{
+	int i;
+	isl_bool known;
+
+	known = isl_map_divs_known(map);
+	if (known < 0)
+		return isl_map_free(map);
+	if (known)
+		return map;
+
+	map = isl_map_cow(map);
+	if (!map)
+		return NULL;
+
+	for (i = 0; i < map->n; ++i) {
+		map->pi =
+		    isl_basic_map_drop_constraints_involving_unknown_divs(
+								    map->pi);
+		if (!map->pi)
+			return isl_map_free(map);
+	}
+
+	if (map->n > 1)
+		ISL_F_CLR(map, ISL_MAP_DISJOINT);
+
+	return map;
+}
+
 /* Don't assume equalities are in order, because align_divs
  * may have changed the order of the divs.
  */
-static void compute_elimination_index(struct isl_basic_map *bmap, int *elim)
+static void compute_elimination_index(__isl_keep isl_basic_map *bmap, int *elim,
+	unsigned len)
 {
 	int d, i;
-	unsigned total;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
-	for (d = 0; d < total; ++d)
+	for (d = 0; d < len; ++d)
 		elimd = -1;
 	for (i = 0; i < bmap->n_eq; ++i) {
-		for (d = total - 1; d >= 0; --d) {
+		for (d = len - 1; d >= 0; --d) {
 			if (isl_int_is_zero(bmap->eqi1+d))
 				continue;
 			elimd = i;
@@ -1650,19 +1972,18 @@
 	}
 }
 
-static void set_compute_elimination_index(struct isl_basic_set *bset, int *elim)
+static void set_compute_elimination_index(__isl_keep isl_basic_set *bset,
+	int *elim, unsigned len)
 {
-	compute_elimination_index((struct isl_basic_map *)bset, elim);
+	compute_elimination_index(bset_to_bmap(bset), elim, len);
 }
 
 static int reduced_using_equalities(isl_int *dst, isl_int *src,
-	struct isl_basic_map *bmap, int *elim)
+	__isl_keep isl_basic_map *bmap, int *elim, unsigned total)
 {
 	int d;
 	int copied = 0;
-	unsigned total;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
 	for (d = total - 1; d >= 0; --d) {
 		if (isl_int_is_zero(src1+d))
 			continue;
@@ -1678,17 +1999,18 @@
 }
 
 static int set_reduced_using_equalities(isl_int *dst, isl_int *src,
-	struct isl_basic_set *bset, int *elim)
+	__isl_keep isl_basic_set *bset, int *elim, unsigned total)
 {
 	return reduced_using_equalities(dst, src,
-					(struct isl_basic_map *)bset, elim);
+					bset_to_bmap(bset), elim, total);
 }
 
-static struct isl_basic_set *isl_basic_set_reduce_using_equalities(
-	struct isl_basic_set *bset, struct isl_basic_set *context)
+static __isl_give isl_basic_set *isl_basic_set_reduce_using_equalities(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *context)
 {
 	int i;
 	int *elim;
+	isl_size dim;
 
 	if (!bset || !context)
 		goto error;
@@ -1699,19 +2021,20 @@
 	}
 
 	bset = isl_basic_set_cow(bset);
-	if (!bset)
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
 		goto error;
 
-	elim = isl_alloc_array(bset->ctx, int, isl_basic_set_n_dim(bset));
+	elim = isl_alloc_array(bset->ctx, int, dim);
 	if (!elim)
 		goto error;
-	set_compute_elimination_index(context, elim);
+	set_compute_elimination_index(context, elim, dim);
 	for (i = 0; i < bset->n_eq; ++i)
 		set_reduced_using_equalities(bset->eqi, bset->eqi,
-							context, elim);
+							context, elim, dim);
 	for (i = 0; i < bset->n_ineq; ++i)
 		set_reduced_using_equalities(bset->ineqi, bset->ineqi,
-							context, elim);
+							context, elim, dim);
 	isl_basic_set_free(context);
 	free(elim);
 	bset = isl_basic_set_simplify(bset);
@@ -1723,35 +2046,76 @@
 	return NULL;
 }
 
-static struct isl_basic_set *remove_shifted_constraints(
-	struct isl_basic_set *bset, struct isl_basic_set *context)
+/* For each inequality in "ineq" that is a shifted (more relaxed)
+ * copy of an inequality in "context", mark the corresponding entry
+ * in "row" with -1.
+ * If an inequality only has a non-negative constant term, then
+ * mark it as well.
+ */
+static isl_stat mark_shifted_constraints(__isl_keep isl_mat *ineq,
+	__isl_keep isl_basic_set *context, int *row)
 {
-	unsigned int size;
-	isl_int ***index;
-	int bits;
-	int k, h, l;
-	isl_ctx *ctx;
+	struct isl_constraint_index ci;
+	isl_size n_ineq, cols;
+	unsigned total;
+	int k;
 
-	if (!bset)
-		return NULL;
+	if (!ineq || !context)
+		return isl_stat_error;
+	if (context->n_ineq == 0)
+		return isl_stat_ok;
+	if (setup_constraint_index(&ci, context) < 0)
+		return isl_stat_error;
+
+	n_ineq = isl_mat_rows(ineq);
+	cols = isl_mat_cols(ineq);
+	if (n_ineq < 0 || cols < 0)
+		return isl_stat_error;
+	total = cols - 1;
+	for (k = 0; k < n_ineq; ++k) {
+		int l;
+		isl_bool redundant;
+
+		l = isl_seq_first_non_zero(ineq->rowk + 1, total);
+		if (l < 0 && isl_int_is_nonneg(ineq->rowk0)) {
+			rowk = -1;
+			continue;
+		}
+		redundant = constraint_index_is_redundant(&ci, ineq->rowk);
+		if (redundant < 0)
+			goto error;
+		if (!redundant)
+			continue;
+		rowk = -1;
+	}
+	constraint_index_free(&ci);
+	return isl_stat_ok;
+error:
+	constraint_index_free(&ci);
+	return isl_stat_error;
+}
 
-	size = round_up(4 * (context->n_ineq+1) / 3 - 1);
-	bits = ffs(size) - 1;
-	ctx = isl_basic_set_get_ctx(bset);
-	index = isl_calloc_array(ctx, isl_int **, size);
-	if (!index)
+static __isl_give isl_basic_set *remove_shifted_constraints(
+	__isl_take isl_basic_set *bset, __isl_keep isl_basic_set *context)
+{
+	struct isl_constraint_index ci;
+	int k;
+
+	if (!bset || !context)
+		return bset;
+
+	if (context->n_ineq == 0)
+		return bset;
+	if (setup_constraint_index(&ci, context) < 0)
 		return bset;
 
-	for (k = 0; k < context->n_ineq; ++k) {
-		h = set_hash_index(index, size, bits, context, k);
-		indexh = &context->ineqk;
-	}
 	for (k = 0; k < bset->n_ineq; ++k) {
-		h = set_hash_index(index, size, bits, bset, k);
-		if (!indexh)
-			continue;
-		l = indexh - &context->ineq0;
-		if (isl_int_lt(bset->ineqk0, context->ineql0))
+		isl_bool redundant;
+
+		redundant = constraint_index_is_redundant(&ci, bset->ineqk);
+		if (redundant < 0)
+			goto error;
+		if (!redundant)
 			continue;
 		bset = isl_basic_set_cow(bset);
 		if (!bset)
@@ -1759,10 +2123,10 @@
 		isl_basic_set_drop_inequality(bset, k);
 		--k;
 	}
-	free(index);
+	constraint_index_free(&ci);
 	return bset;
 error:
-	free(index);
+	constraint_index_free(&ci);
 	return bset;
 }
 
@@ -1785,6 +2149,7 @@
 		return bmap;
 	}
 
+	bmap = isl_basic_map_order_divs(bmap);
 	context = isl_basic_map_align_divs(context, bmap);
 	bmap = isl_basic_map_align_divs(bmap, context);
 
@@ -1819,30 +2184,39 @@
 	return 0;
 }
 
-/* Drop constraints from "bset" that do not involve any of
+/* Drop constraints from "bmap" that do not involve any of
  * the dimensions marked "relevant".
  */
-static __isl_give isl_basic_set *drop_unrelated_constraints(
-	__isl_take isl_basic_set *bset, int *relevant)
+static __isl_give isl_basic_map *drop_unrelated_constraints(
+	__isl_take isl_basic_map *bmap, int *relevant)
 {
-	int i, dim;
+	int i;
+	isl_size dim;
 
-	dim = isl_basic_set_dim(bset, isl_dim_set);
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	if (dim < 0)
+		return isl_basic_map_free(bmap);
 	for (i = 0; i < dim; ++i)
 		if (!relevanti)
 			break;
 	if (i >= dim)
-		return bset;
+		return bmap;
 
-	for (i = bset->n_eq - 1; i >= 0; --i)
-		if (!is_related(bset->eqi + 1, dim, relevant))
-			isl_basic_set_drop_equality(bset, i);
-
-	for (i = bset->n_ineq - 1; i >= 0; --i)
-		if (!is_related(bset->ineqi + 1, dim, relevant))
-			isl_basic_set_drop_inequality(bset, i);
+	for (i = bmap->n_eq - 1; i >= 0; --i)
+		if (!is_related(bmap->eqi + 1, dim, relevant)) {
+			bmap = isl_basic_map_cow(bmap);
+			if (isl_basic_map_drop_equality(bmap, i) < 0)
+				return isl_basic_map_free(bmap);
+		}
 
-	return bset;
+	for (i = bmap->n_ineq - 1; i >= 0; --i)
+		if (!is_related(bmap->ineqi + 1, dim, relevant)) {
+			bmap = isl_basic_map_cow(bmap);
+			if (isl_basic_map_drop_inequality(bmap, i) < 0)
+				return isl_basic_map_free(bmap);
+		}
+
+	return bmap;
 }
 
 /* Update the groups in "group" based on the (linear part of a) constraint "c".
@@ -1878,24 +2252,34 @@
 	}
 }
 
-/* Drop constraints from "context" that are irrelevant for computing
- * the gist of "bset".
- *
- * In particular, drop constraints in variables that are not related
- * to any of the variables involved in the constraints of "bset"
- * in the sense that there is no sequence of constraints that connects them.
+/* Allocate an array of groups of variables, one for each variable
+ * in "context", initialized to zero.
+ */
+static int *alloc_groups(__isl_keep isl_basic_set *context)
+{
+	isl_ctx *ctx;
+	isl_size dim;
+
+	dim = isl_basic_set_dim(context, isl_dim_set);
+	if (dim < 0)
+		return NULL;
+	ctx = isl_basic_set_get_ctx(context);
+	return isl_calloc_array(ctx, int, dim);
+}
+
+/* Drop constraints from "bmap" that only involve variables that are
+ * not related to any of the variables marked with a "-1" in "group".
  *
  * We construct groups of variables that collect variables that
- * (indirectly) appear in some common constraint of "context".
+ * (indirectly) appear in some common constraint of "bmap".
  * Each group is identified by the first variable in the group,
- * except for the special group of variables that appear in "bset"
- * (or are related to those variables), which is identified by -1.
+ * except for the special group of variables that was already identified
+ * in the input as -1 (or are related to those variables).
  * If groupi is equal to i (or -1), then the group of i is i (or -1),
  * otherwise the group of i is the group of groupi.
  *
- * We first initialize the -1 group with the variables that appear in "bset".
- * Then we initialize groups for the remaining variables.
- * Then we iterate over the constraints of "context" and update the
+ * We first initialize groups for the remaining variables.
+ * Then we iterate over the constraints of "bmap" and update the
  * group of the variables in the constraint by the smallest group.
  * Finally, we resolve indirect references to groups by running over
  * the variables.
@@ -1903,24 +2287,69 @@
  * After computing the groups, we drop constraints that do not involve
  * any variables in the -1 group.
  */
+__isl_give isl_basic_map *isl_basic_map_drop_unrelated_constraints(
+	__isl_take isl_basic_map *bmap, __isl_take int *group)
+{
+	isl_size dim;
+	int i;
+	int last;
+
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	if (dim < 0)
+		return isl_basic_map_free(bmap);
+
+	last = -1;
+	for (i = 0; i < dim; ++i)
+		if (groupi >= 0)
+			last = groupi = i;
+	if (last < 0) {
+		free(group);
+		return bmap;
+	}
+
+	for (i = 0; i < bmap->n_eq; ++i)
+		update_groups(dim, group, bmap->eqi + 1);
+	for (i = 0; i < bmap->n_ineq; ++i)
+		update_groups(dim, group, bmap->ineqi + 1);
+
+	for (i = 0; i < dim; ++i)
+		if (groupi >= 0)
+			groupi = groupgroupi;
+
+	for (i = 0; i < dim; ++i)
+		groupi = groupi == -1;
+
+	bmap = drop_unrelated_constraints(bmap, group);
+
+	free(group);
+	return bmap;
+}
+
+/* Drop constraints from "context" that are irrelevant for computing
+ * the gist of "bset".
+ *
+ * In particular, drop constraints in variables that are not related
+ * to any of the variables involved in the constraints of "bset"
+ * in the sense that there is no sequence of constraints that connects them.
+ *
+ * We first mark all variables that appear in "bset" as belonging
+ * to a "-1" group and then continue with group_and_drop_irrelevant_constraints.
+ */
 static __isl_give isl_basic_set *drop_irrelevant_constraints(
 	__isl_take isl_basic_set *context, __isl_keep isl_basic_set *bset)
 {
-	isl_ctx *ctx;
 	int *group;
-	int dim;
+	isl_size dim;
 	int i, j;
-	int last;
 
-	if (!context || !bset)
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (!context || dim < 0)
 		return isl_basic_set_free(context);
 
-	dim = isl_basic_set_dim(bset, isl_dim_set);
-	ctx = isl_basic_set_get_ctx(bset);
-	group = isl_calloc_array(ctx, int, dim);
+	group = alloc_groups(context);
 
 	if (!group)
-		goto error;
+		return isl_basic_set_free(context);
 
 	for (i = 0; i < dim; ++i) {
 		for (j = 0; j < bset->n_eq; ++j)
@@ -1937,40 +2366,149 @@
 			groupi = -1;
 	}
 
-	last = -1;
-	for (i = 0; i < dim; ++i)
-		if (groupi >= 0)
-			last = groupi = i;
-	if (last < 0) {
-		free(group);
-		return context;
+	return isl_basic_map_drop_unrelated_constraints(context, group);
+}
+
+/* Drop constraints from "context" that are irrelevant for computing
+ * the gist of the inequalities "ineq".
+ * Inequalities in "ineq" for which the corresponding element of row
+ * is set to -1 have already been marked for removal and should be ignored.
+ *
+ * In particular, drop constraints in variables that are not related
+ * to any of the variables involved in "ineq"
+ * in the sense that there is no sequence of constraints that connects them.
+ *
+ * We first mark all variables that appear in "bset" as belonging
+ * to a "-1" group and then continue with group_and_drop_irrelevant_constraints.
+ */
+static __isl_give isl_basic_set *drop_irrelevant_constraints_marked(
+	__isl_take isl_basic_set *context, __isl_keep isl_mat *ineq, int *row)
+{
+	int *group;
+	isl_size dim;
+	int i, j;
+	isl_size n;
+
+	dim = isl_basic_set_dim(context, isl_dim_set);
+	n = isl_mat_rows(ineq);
+	if (dim < 0 || n < 0)
+		return isl_basic_set_free(context);
+
+	group = alloc_groups(context);
+
+	if (!group)
+		return isl_basic_set_free(context);
+
+	for (i = 0; i < dim; ++i) {
+		for (j = 0; j < n; ++j) {
+			if (rowj < 0)
+				continue;
+			if (!isl_int_is_zero(ineq->rowj1 + i))
+				break;
+		}
+		if (j < n)
+			groupi = -1;
 	}
 
-	for (i = 0; i < context->n_eq; ++i)
-		update_groups(dim, group, context->eqi + 1);
-	for (i = 0; i < context->n_ineq; ++i)
-		update_groups(dim, group, context->ineqi + 1);
+	return isl_basic_map_drop_unrelated_constraints(context, group);
+}
 
-	for (i = 0; i < dim; ++i)
-		if (groupi >= 0)
-			groupi = groupgroupi;
+/* Do all "n" entries of "row" contain a negative value?
+ */
+static int all_neg(int *row, int n)
+{
+	int i;
 
-	for (i = 0; i < dim; ++i)
-		groupi = groupi == -1;
+	for (i = 0; i < n; ++i)
+		if (rowi >= 0)
+			return 0;
 
-	context = drop_unrelated_constraints(context, group);
+	return 1;
+}
 
-	free(group);
-	return context;
-error:
-	free(group);
-	return isl_basic_set_free(context);
+/* Update the inequalities in "bset" based on the information in "row"
+ * and "tab".
+ *
+ * In particular, the array "row" contains either -1, meaning that
+ * the corresponding inequality of "bset" is redundant, or the index
+ * of an inequality in "tab".
+ *
+ * If the row entry is -1, then drop the inequality.
+ * Otherwise, if the constraint is marked redundant in the tableau,
+ * then drop the inequality.  Similarly, if it is marked as an equality
+ * in the tableau, then turn the inequality into an equality and
+ * perform Gaussian elimination.
+ */
+static __isl_give isl_basic_set *update_ineq(__isl_take isl_basic_set *bset,
+	__isl_keep int *row, struct isl_tab *tab)
+{
+	int i;
+	unsigned n_ineq;
+	unsigned n_eq;
+	int found_equality = 0;
+
+	if (!bset)
+		return NULL;
+	if (tab && tab->empty)
+		return isl_basic_set_set_to_empty(bset);
+
+	n_ineq = bset->n_ineq;
+	for (i = n_ineq - 1; i >= 0; --i) {
+		if (rowi < 0) {
+			if (isl_basic_set_drop_inequality(bset, i) < 0)
+				return isl_basic_set_free(bset);
+			continue;
+		}
+		if (!tab)
+			continue;
+		n_eq = tab->n_eq;
+		if (isl_tab_is_equality(tab, n_eq + rowi)) {
+			isl_basic_map_inequality_to_equality(bset, i);
+			found_equality = 1;
+		} else if (isl_tab_is_redundant(tab, n_eq + rowi)) {
+			if (isl_basic_set_drop_inequality(bset, i) < 0)
+				return isl_basic_set_free(bset);
+		}
+	}
+
+	if (found_equality)
+		bset = isl_basic_set_gauss(bset, NULL);
+	bset = isl_basic_set_finalize(bset);
+	return bset;
+}
+
+/* Update the inequalities in "bset" based on the information in "row"
+ * and "tab" and free all arguments (other than "bset").
+ */
+static __isl_give isl_basic_set *update_ineq_free(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *ineq,
+	__isl_take isl_basic_set *context, __isl_take int *row,
+	struct isl_tab *tab)
+{
+	isl_mat_free(ineq);
+	isl_basic_set_free(context);
+
+	bset = update_ineq(bset, row, tab);
+
+	free(row);
+	isl_tab_free(tab);
+	return bset;
 }
 
 /* Remove all information from bset that is redundant in the context
- * of context.  Both bset and context are assumed to be full-dimensional.
+ * of context.
+ * "ineq" contains the (possibly transformed) inequalities of "bset",
+ * in the same order.
+ * The (explicit) equalities of "bset" are assumed to have been taken
+ * into account by the transformation such that only the inequalities
+ * are relevant.
+ * "context" is assumed not to be empty.
+ *
+ * "row" keeps track of the constraint index of a "bset" inequality in "tab".
+ * A value of -1 means that the inequality is obviously redundant and may
+ * not even appear in  "tab".
  *
- * We first remove the inequalities from "bset"
+ * We first mark the inequalities of "bset"
  * that are obviously redundant with respect to some inequality in "context".
  * Then we remove those constraints from "context" that have become
  * irrelevant for computing the gist of "bset".
@@ -1990,96 +2528,93 @@
  * Finally, we update bset according to the results.
  */
 static __isl_give isl_basic_set *uset_gist_full(__isl_take isl_basic_set *bset,
-	__isl_take isl_basic_set *context)
+	__isl_take isl_mat *ineq, __isl_take isl_basic_set *context)
 {
-	int i, k;
+	int i, r;
+	int *row = NULL;
+	isl_ctx *ctx;
 	isl_basic_set *combined = NULL;
 	struct isl_tab *tab = NULL;
-	unsigned context_ineq;
-	unsigned total;
+	unsigned n_eq, context_ineq;
 
-	if (!bset || !context)
+	if (!bset || !ineq || !context)
 		goto error;
 
-	if (isl_basic_set_is_universe(bset)) {
+	if (bset->n_ineq == 0 || isl_basic_set_plain_is_universe(context)) {
 		isl_basic_set_free(context);
+		isl_mat_free(ineq);
 		return bset;
 	}
 
-	if (isl_basic_set_is_universe(context)) {
-		isl_basic_set_free(context);
-		return bset;
-	}
+	ctx = isl_basic_set_get_ctx(context);
+	row = isl_calloc_array(ctx, int, bset->n_ineq);
+	if (!row)
+		goto error;
 
-	bset = remove_shifted_constraints(bset, context);
-	if (!bset)
+	if (mark_shifted_constraints(ineq, context, row) < 0)
 		goto error;
-	if (bset->n_ineq == 0)
-		goto done;
+	if (all_neg(row, bset->n_ineq))
+		return update_ineq_free(bset, ineq, context, row, NULL);
 
-	context = drop_irrelevant_constraints(context, bset);
+	context = drop_irrelevant_constraints_marked(context, ineq, row);
 	if (!context)
 		goto error;
-	if (isl_basic_set_is_universe(context)) {
-		isl_basic_set_free(context);
-		return bset;
-	}
+	if (isl_basic_set_plain_is_universe(context))
+		return update_ineq_free(bset, ineq, context, row, NULL);
 
+	n_eq = context->n_eq;
 	context_ineq = context->n_ineq;
 	combined = isl_basic_set_cow(isl_basic_set_copy(context));
 	combined = isl_basic_set_extend_constraints(combined, 0, bset->n_ineq);
 	tab = isl_tab_from_basic_set(combined, 0);
 	for (i = 0; i < context_ineq; ++i)
-		if (isl_tab_freeze_constraint(tab, i) < 0)
+		if (isl_tab_freeze_constraint(tab, n_eq + i) < 0)
 			goto error;
 	if (isl_tab_extend_cons(tab, bset->n_ineq) < 0)
 		goto error;
-	for (i = 0; i < bset->n_ineq; ++i)
-		if (isl_tab_add_ineq(tab, bset->ineqi) < 0)
+	r = context_ineq;
+	for (i = 0; i < bset->n_ineq; ++i) {
+		if (rowi < 0)
+			continue;
+		combined = isl_basic_set_add_ineq(combined, ineq->rowi);
+		if (isl_tab_add_ineq(tab, ineq->rowi) < 0)
 			goto error;
-	bset = isl_basic_set_add_constraints(combined, bset, 0);
-	combined = NULL;
-	if (!bset)
+		rowi = r++;
+	}
+	if (isl_tab_detect_implicit_equalities(tab) < 0)
 		goto error;
 	if (isl_tab_detect_redundant(tab) < 0)
 		goto error;
-	total = isl_basic_set_total_dim(bset);
-	for (i = context_ineq; i < bset->n_ineq; ++i) {
+	for (i = bset->n_ineq - 1; i >= 0; --i) {
+		isl_basic_set *test;
 		int is_empty;
-		if (tab->coni.is_redundant)
+
+		if (rowi < 0)
 			continue;
-		tab->coni.is_redundant = 1;
-		combined = isl_basic_set_dup(bset);
-		combined = isl_basic_set_update_from_tab(combined, tab);
-		combined = isl_basic_set_extend_constraints(combined, 0, 1);
-		k = isl_basic_set_alloc_inequality(combined);
-		if (k < 0)
-			goto error;
-		isl_seq_neg(combined->ineqk, bset->ineqi, 1 + total);
-		isl_int_sub_ui(combined->ineqk0, combined->ineqk0, 1);
-		is_empty = isl_basic_set_is_empty(combined);
+		r = rowi;
+		if (tab->conn_eq + r.is_redundant)
+			continue;
+		test = isl_basic_set_dup(combined);
+		test = isl_inequality_negate(test, r);
+		test = isl_basic_set_update_from_tab(test, tab);
+		is_empty = isl_basic_set_is_empty(test);
+		isl_basic_set_free(test);
 		if (is_empty < 0)
 			goto error;
-		isl_basic_set_free(combined);
-		combined = NULL;
-		if (!is_empty)
-			tab->coni.is_redundant = 0;
+		if (is_empty)
+			tab->conn_eq + r.is_redundant = 1;
 	}
-	for (i = 0; i < context_ineq; ++i)
-		tab->coni.is_redundant = 1;
-	bset = isl_basic_set_update_from_tab(bset, tab);
+	bset = update_ineq_free(bset, ineq, context, row, tab);
 	if (bset) {
 		ISL_F_SET(bset, ISL_BASIC_SET_NO_IMPLICIT);
 		ISL_F_SET(bset, ISL_BASIC_SET_NO_REDUNDANT);
 	}
 
-	isl_tab_free(tab);
-done:
-	bset = isl_basic_set_simplify(bset);
-	bset = isl_basic_set_finalize(bset);
-	isl_basic_set_free(context);
+	isl_basic_set_free(combined);
 	return bset;
 error:
+	free(row);
+	isl_mat_free(ineq);
 	isl_tab_free(tab);
 	isl_basic_set_free(combined);
 	isl_basic_set_free(context);
@@ -2087,6 +2622,163 @@
 	return NULL;
 }
 
+/* Extract the inequalities of "bset" as an isl_mat.
+ */
+static __isl_give isl_mat *extract_ineq(__isl_keep isl_basic_set *bset)
+{
+	isl_size total;
+	isl_ctx *ctx;
+	isl_mat *ineq;
+
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
+		return NULL;
+
+	ctx = isl_basic_set_get_ctx(bset);
+	ineq = isl_mat_sub_alloc6(ctx, bset->ineq, 0, bset->n_ineq,
+				    0, 1 + total);
+
+	return ineq;
+}
+
+/* Remove all information from "bset" that is redundant in the context
+ * of "context", for the case where both "bset" and "context" are
+ * full-dimensional.
+ */
+static __isl_give isl_basic_set *uset_gist_uncompressed(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *context)
+{
+	isl_mat *ineq;
+
+	ineq = extract_ineq(bset);
+	return uset_gist_full(bset, ineq, context);
+}
+
+/* Replace "bset" by an empty basic set in the same space.
+ */
+static __isl_give isl_basic_set *replace_by_empty(
+	__isl_take isl_basic_set *bset)
+{
+	isl_space *space;
+
+	space = isl_basic_set_get_space(bset);
+	isl_basic_set_free(bset);
+	return isl_basic_set_empty(space);
+}
+
+/* Remove all information from "bset" that is redundant in the context
+ * of "context", for the case where the combined equalities of
+ * "bset" and "context" allow for a compression that can be obtained
+ * by preapplication of "T".
+ * If the compression of "context" is empty, meaning that "bset" and
+ * "context" do not intersect, then return the empty set.
+ *
+ * "bset" itself is not transformed by "T".  Instead, the inequalities
+ * are extracted from "bset" and those are transformed by "T".
+ * uset_gist_full then determines which of the transformed inequalities
+ * are redundant with respect to the transformed "context" and removes
+ * the corresponding inequalities from "bset".
+ *
+ * After preapplying "T" to the inequalities, any common factor is
+ * removed from the coefficients.  If this results in a tightening
+ * of the constant term, then the same tightening is applied to
+ * the corresponding untransformed inequality in "bset".
+ * That is, if after plugging in T, a constraint f(x) >= 0 is of the form
+ *
+ *	g f'(x) + r >= 0
+ *
+ * with 0 <= r < g, then it is equivalent to
+ *
+ *	f'(x) >= 0
+ *
+ * This means that f(x) >= 0 is equivalent to f(x) - r >= 0 in the affine
+ * subspace compressed by T since the latter would be transformed to
+ *
+ *	g f'(x) >= 0
+ */
+static __isl_give isl_basic_set *uset_gist_compressed(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *context,
+	__isl_take isl_mat *T)
+{
+	isl_ctx *ctx;
+	isl_mat *ineq;
+	int i;
+	isl_size n_row, n_col;
+	isl_int rem;
+
+	ineq = extract_ineq(bset);
+	ineq = isl_mat_product(ineq, isl_mat_copy(T));
+	context = isl_basic_set_preimage(context, T);
+
+	if (!ineq || !context)
+		goto error;
+	if (isl_basic_set_plain_is_empty(context)) {
+		isl_mat_free(ineq);
+		isl_basic_set_free(context);
+		return replace_by_empty(bset);
+	}
+
+	ctx = isl_mat_get_ctx(ineq);
+	n_row = isl_mat_rows(ineq);
+	n_col = isl_mat_cols(ineq);
+	if (n_row < 0 || n_col < 0)
+		goto error;
+	isl_int_init(rem);
+	for (i = 0; i < n_row; ++i) {
+		isl_seq_gcd(ineq->rowi + 1, n_col - 1, &ctx->normalize_gcd);
+		if (isl_int_is_zero(ctx->normalize_gcd))
+			continue;
+		if (isl_int_is_one(ctx->normalize_gcd))
+			continue;
+		isl_seq_scale_down(ineq->rowi + 1, ineq->rowi + 1,
+				    ctx->normalize_gcd, n_col - 1);
+		isl_int_fdiv_r(rem, ineq->rowi0, ctx->normalize_gcd);
+		isl_int_fdiv_q(ineq->rowi0,
+				ineq->rowi0, ctx->normalize_gcd);
+		if (isl_int_is_zero(rem))
+			continue;
+		bset = isl_basic_set_cow(bset);
+		if (!bset)
+			break;
+		isl_int_sub(bset->ineqi0, bset->ineqi0, rem);
+	}
+	isl_int_clear(rem);
+
+	return uset_gist_full(bset, ineq, context);
+error:
+	isl_mat_free(ineq);
+	isl_basic_set_free(context);
+	isl_basic_set_free(bset);
+	return NULL;
+}
+
+/* Project "bset" onto the variables that are involved in "template".
+ */
+static __isl_give isl_basic_set *project_onto_involved(
+	__isl_take isl_basic_set *bset, __isl_keep isl_basic_set *template)
+{
+	int i;
+	isl_size n;
+
+	n = isl_basic_set_dim(template, isl_dim_set);
+	if (n < 0 || !template)
+		return isl_basic_set_free(bset);
+
+	for (i = 0; i < n; ++i) {
+		isl_bool involved;
+
+		involved = isl_basic_set_involves_dims(template,
+							isl_dim_set, i, 1);
+		if (involved < 0)
+			return isl_basic_set_free(bset);
+		if (involved)
+			continue;
+		bset = isl_basic_set_eliminate_vars(bset, i, 1);
+	}
+
+	return bset;
+}
+
 /* Remove all information from bset that is redundant in the context
  * of context.  In particular, equalities that are linear combinations
  * of those in context are removed.  Then the inequalities that are
@@ -2097,9 +2789,13 @@
  * that are irrelevant for computing the gist of "bset".
  * Alternatively, we could factorize the intersection of "context" and "bset".
  *
- * We first compute the integer affine hull of the intersection,
- * compute the gist inside this affine hull and then add back
- * those equalities that are not implied by the context.
+ * We first compute the intersection of the integer affine hulls
+ * of "bset" and "context",
+ * compute the gist inside this intersection and then reduce
+ * the constraints with respect to the equalities of the context
+ * that only involve variables already involved in the input.
+ * If the intersection of the affine hulls turns out to be empty,
+ * then return the empty set.
  *
  * If two constraints are mutually redundant, then uset_gist_full
  * will remove the second of those constraints.  We therefore first
@@ -2112,19 +2808,24 @@
 	__isl_take isl_basic_set *context)
 {
 	isl_mat *eq;
-	isl_mat *T, *T2;
+	isl_mat *T;
 	isl_basic_set *aff;
 	isl_basic_set *aff_context;
-	unsigned total;
+	isl_size total;
 
-	if (!bset || !context)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0 || !context)
 		goto error;
 
 	context = drop_irrelevant_constraints(context, bset);
 
+	bset = isl_basic_set_detect_equalities(bset);
 	aff = isl_basic_set_copy(bset);
-	aff = isl_basic_set_intersect(aff, isl_basic_set_copy(context));
-	aff = isl_basic_set_affine_hull(aff);
+	aff = isl_basic_set_plain_affine_hull(aff);
+	context = isl_basic_set_detect_equalities(context);
+	aff_context = isl_basic_set_copy(context);
+	aff_context = isl_basic_set_plain_affine_hull(aff_context);
+	aff = isl_basic_set_intersect(aff, aff_context);
 	if (!aff)
 		goto error;
 	if (isl_basic_set_plain_is_empty(aff)) {
@@ -2135,28 +2836,22 @@
 	bset = isl_basic_set_sort_constraints(bset);
 	if (aff->n_eq == 0) {
 		isl_basic_set_free(aff);
-		return uset_gist_full(bset, context);
+		return uset_gist_uncompressed(bset, context);
 	}
-	total = isl_basic_set_total_dim(bset);
 	eq = isl_mat_sub_alloc6(bset->ctx, aff->eq, 0, aff->n_eq, 0, 1 + total);
 	eq = isl_mat_cow(eq);
-	T = isl_mat_variable_compression(eq, &T2);
+	T = isl_mat_variable_compression(eq, NULL);
+	isl_basic_set_free(aff);
 	if (T && T->n_col == 0) {
 		isl_mat_free(T);
-		isl_mat_free(T2);
 		isl_basic_set_free(context);
-		isl_basic_set_free(aff);
-		return isl_basic_set_set_to_empty(bset);
+		return replace_by_empty(bset);
 	}
 
 	aff_context = isl_basic_set_affine_hull(isl_basic_set_copy(context));
+	aff_context = project_onto_involved(aff_context, bset);
 
-	bset = isl_basic_set_preimage(bset, isl_mat_copy(T));
-	context = isl_basic_set_preimage(context, T);
-
-	bset = uset_gist_full(bset, context);
-	bset = isl_basic_set_preimage(bset, T2);
-	bset = isl_basic_set_intersect(bset, aff);
+	bset = uset_gist_compressed(bset, context, T);
 	bset = isl_basic_set_reduce_using_equalities(bset, aff_context);
 
 	if (bset) {
@@ -2171,42 +2866,374 @@
 	return NULL;
 }
 
-/* Normalize the divs in "bmap" in the context of the equalities in "context".
- * We simply add the equalities in context to bmap and then do a regular
- * div normalizations.  Better results can be obtained by normalizing
- * only the divs in bmap than do not also appear in context.
- * We need to be careful to reduce the divs using the equalities
- * so that later calls to isl_basic_map_overlying_set wouldn't introduce
- * spurious constraints.
+/* Return the number of equality constraints in "bmap" that involve
+ * local variables.  This function assumes that Gaussian elimination
+ * has been applied to the equality constraints.
  */
-static struct isl_basic_map *normalize_divs_in_context(
-	struct isl_basic_map *bmap, struct isl_basic_map *context)
+static int n_div_eq(__isl_keep isl_basic_map *bmap)
 {
 	int i;
-	unsigned total_context;
-	int div_eq;
+	isl_size total, n_div;
 
-	div_eq = n_pure_div_eq(bmap);
-	if (div_eq == 0)
-		return bmap;
+	if (!bmap)
+		return -1;
+
+	if (bmap->n_eq == 0)
+		return 0;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return -1;
+	total -= n_div;
+
+	for (i = 0; i < bmap->n_eq; ++i)
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + total,
+					    n_div) == -1)
+			return i;
 
-	if (context->n_div > 0)
-		bmap = isl_basic_map_align_divs(bmap, context);
+	return bmap->n_eq;
+}
 
-	total_context = isl_basic_map_total_dim(context);
-	bmap = isl_basic_map_extend_constraints(bmap, context->n_eq, 0);
-	for (i = 0; i < context->n_eq; ++i) {
-		int k;
+/* Construct a basic map in "space" defined by the equality constraints in "eq".
+ * The constraints are assumed not to involve any local variables.
+ */
+static __isl_give isl_basic_map *basic_map_from_equalities(
+	__isl_take isl_space *space, __isl_take isl_mat *eq)
+{
+	int i, k;
+	isl_size total;
+	isl_basic_map *bmap = NULL;
+
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0 || !eq)
+		goto error;
+
+	if (1 + total != eq->n_col)
+		isl_die(isl_space_get_ctx(space), isl_error_internal,
+			"unexpected number of columns", goto error);
+
+	bmap = isl_basic_map_alloc_space(isl_space_copy(space),
+					    0, eq->n_row, 0);
+	for (i = 0; i < eq->n_row; ++i) {
 		k = isl_basic_map_alloc_equality(bmap);
 		if (k < 0)
-			return isl_basic_map_free(bmap);
-		isl_seq_cpy(bmap->eqk, context->eqi, 1 + total_context);
-		isl_seq_clr(bmap->eqk + 1 + total_context,
-				isl_basic_map_total_dim(bmap) - total_context);
+			goto error;
+		isl_seq_cpy(bmap->eqk, eq->rowi, eq->n_col);
 	}
+
+	isl_space_free(space);
+	isl_mat_free(eq);
+	return bmap;
+error:
+	isl_space_free(space);
+	isl_mat_free(eq);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Construct and return a variable compression based on the equality
+ * constraints in "bmap1" and "bmap2" that do not involve the local variables.
+ * "n1" is the number of (initial) equality constraints in "bmap1"
+ * that do involve local variables.
+ * "n2" is the number of (initial) equality constraints in "bmap2"
+ * that do involve local variables.
+ * "total" is the total number of other variables.
+ * This function assumes that Gaussian elimination
+ * has been applied to the equality constraints in both "bmap1" and "bmap2"
+ * such that the equality constraints not involving local variables
+ * are those that start at "n1" or "n2".
+ *
+ * If either of "bmap1" and "bmap2" does not have such equality constraints,
+ * then simply compute the compression based on the equality constraints
+ * in the other basic map.
+ * Otherwise, combine the equality constraints from both into a new
+ * basic map such that Gaussian elimination can be applied to this combination
+ * and then construct a variable compression from the resulting
+ * equality constraints.
+ */
+static __isl_give isl_mat *combined_variable_compression(
+	__isl_keep isl_basic_map *bmap1, int n1,
+	__isl_keep isl_basic_map *bmap2, int n2, int total)
+{
+	isl_ctx *ctx;
+	isl_mat *E1, *E2, *V;
+	isl_basic_map *bmap;
+
+	ctx = isl_basic_map_get_ctx(bmap1);
+	if (bmap1->n_eq == n1) {
+		E2 = isl_mat_sub_alloc6(ctx, bmap2->eq,
+					n2, bmap2->n_eq - n2, 0, 1 + total);
+		return isl_mat_variable_compression(E2, NULL);
+	}
+	if (bmap2->n_eq == n2) {
+		E1 = isl_mat_sub_alloc6(ctx, bmap1->eq,
+					n1, bmap1->n_eq - n1, 0, 1 + total);
+		return isl_mat_variable_compression(E1, NULL);
+	}
+	E1 = isl_mat_sub_alloc6(ctx, bmap1->eq,
+				n1, bmap1->n_eq - n1, 0, 1 + total);
+	E2 = isl_mat_sub_alloc6(ctx, bmap2->eq,
+				n2, bmap2->n_eq - n2, 0, 1 + total);
+	E1 = isl_mat_concat(E1, E2);
+	bmap = basic_map_from_equalities(isl_basic_map_get_space(bmap1), E1);
 	bmap = isl_basic_map_gauss(bmap, NULL);
-	bmap = normalize_divs(bmap, NULL);
-	bmap = isl_basic_map_gauss(bmap, NULL);
+	if (!bmap)
+		return NULL;
+	E1 = isl_mat_sub_alloc6(ctx, bmap->eq, 0, bmap->n_eq, 0, 1 + total);
+	V = isl_mat_variable_compression(E1, NULL);
+	isl_basic_map_free(bmap);
+
+	return V;
+}
+
+/* Extract the stride constraints from "bmap", compressed
+ * with respect to both the stride constraints in "context" and
+ * the remaining equality constraints in both "bmap" and "context".
+ * "bmap_n_eq" is the number of (initial) stride constraints in "bmap".
+ * "context_n_eq" is the number of (initial) stride constraints in "context".
+ *
+ * Let x be all variables in "bmap" (and "context") other than the local
+ * variables.  First compute a variable compression
+ *
+ *	x = V x'
+ *
+ * based on the non-stride equality constraints in "bmap" and "context".
+ * Consider the stride constraints of "context",
+ *
+ *	A(x) + B(y) = 0
+ *
+ * with y the local variables and plug in the variable compression,
+ * resulting in
+ *
+ *	A(V x') + B(y) = 0
+ *
+ * Use these constraints to compute a parameter compression on x'
+ *
+ *	x' = T x''
+ *
+ * Now consider the stride constraints of "bmap"
+ *
+ *	C(x) + D(y) = 0
+ *
+ * and plug in x = V*T x''.
+ * That is, return A = C*V*T D.
+ */
+static __isl_give isl_mat *extract_compressed_stride_constraints(
+	__isl_keep isl_basic_map *bmap, int bmap_n_eq,
+	__isl_keep isl_basic_map *context, int context_n_eq)
+{
+	isl_size total, n_div;
+	isl_ctx *ctx;
+	isl_mat *A, *B, *T, *V;
+
+	total = isl_basic_map_dim(context, isl_dim_all);
+	n_div = isl_basic_map_dim(context, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return NULL;
+	total -= n_div;
+
+	ctx = isl_basic_map_get_ctx(bmap);
+
+	V = combined_variable_compression(bmap, bmap_n_eq,
+						context, context_n_eq, total);
+
+	A = isl_mat_sub_alloc6(ctx, context->eq, 0, context_n_eq, 0, 1 + total);
+	B = isl_mat_sub_alloc6(ctx, context->eq,
+				0, context_n_eq, 1 + total, n_div);
+	A = isl_mat_product(A, isl_mat_copy(V));
+	T = isl_mat_parameter_compression_ext(A, B);
+	T = isl_mat_product(V, T);
+
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		T = isl_mat_free(T);
+	else
+		T = isl_mat_diagonal(T, isl_mat_identity(ctx, n_div));
+
+	A = isl_mat_sub_alloc6(ctx, bmap->eq,
+				0, bmap_n_eq, 0, 1 + total + n_div);
+	A = isl_mat_product(A, T);
+
+	return A;
+}
+
+/* Remove the prime factors from *g that have an exponent that
+ * is strictly smaller than the exponent in "c".
+ * All exponents in *g are known to be smaller than or equal
+ * to those in "c".
+ *
+ * That is, if *g is equal to
+ *
+ *	p_1^{e_1} p_2^{e_2} ... p_n^{e_n}
+ *
+ * and "c" is equal to
+ *
+ *	p_1^{f_1} p_2^{f_2} ... p_n^{f_n}
+ *
+ * then update *g to
+ *
+ *	p_1^{e_1 * (e_1 = f_1)} p_2^{e_2 * (e_2 = f_2)} ...
+ *		p_n^{e_n * (e_n = f_n)}
+ *
+ * If e_i = f_i, then c / *g does not have any p_i factors and therefore
+ * neither does the gcd of *g and c / *g.
+ * If e_i < f_i, then the gcd of *g and c / *g has a positive
+ * power min(e_i, s_i) of p_i with s_i = f_i - e_i among its factors.
+ * Dividing *g by this gcd therefore strictly reduces the exponent
+ * of the prime factors that need to be removed, while leaving the
+ * other prime factors untouched.
+ * Repeating this process until gcd(*g, c / *g) = 1 therefore
+ * removes all undesired factors, without removing any others.
+ */
+static void remove_incomplete_powers(isl_int *g, isl_int c)
+{
+	isl_int t;
+
+	isl_int_init(t);
+	for (;;) {
+		isl_int_divexact(t, c, *g);
+		isl_int_gcd(t, t, *g);
+		if (isl_int_is_one(t))
+			break;
+		isl_int_divexact(*g, *g, t);
+	}
+	isl_int_clear(t);
+}
+
+/* Reduce the "n" stride constraints in "bmap" based on a copy "A"
+ * of the same stride constraints in a compressed space that exploits
+ * all equalities in the context and the other equalities in "bmap".
+ *
+ * If the stride constraints of "bmap" are of the form
+ *
+ *	C(x) + D(y) = 0
+ *
+ * then A is of the form
+ *
+ *	B(x') + D(y) = 0
+ *
+ * If any of these constraints involves only a single local variable y,
+ * then the constraint appears as
+ *
+ *	f(x) + m y_i = 0
+ *
+ * in "bmap" and as
+ *
+ *	h(x') + m y_i = 0
+ *
+ * in "A".
+ *
+ * Let g be the gcd of m and the coefficients of h.
+ * Then, in particular, g is a divisor of the coefficients of h and
+ *
+ *	f(x) = h(x')
+ *
+ * is known to be a multiple of g.
+ * If some prime factor in m appears with the same exponent in g,
+ * then it can be removed from m because f(x) is already known
+ * to be a multiple of g and therefore in particular of this power
+ * of the prime factors.
+ * Prime factors that appear with a smaller exponent in g cannot
+ * be removed from m.
+ * Let g' be the divisor of g containing all prime factors that
+ * appear with the same exponent in m and g, then
+ *
+ *	f(x) + m y_i = 0
+ *
+ * can be replaced by
+ *
+ *	f(x) + m/g' y_i' = 0
+ *
+ * Note that (if g' != 1) this changes the explicit representation
+ * of y_i to that of y_i', so the integer division at position i
+ * is marked unknown and later recomputed by a call to
+ * isl_basic_map_gauss.
+ */
+static __isl_give isl_basic_map *reduce_stride_constraints(
+	__isl_take isl_basic_map *bmap, int n, __isl_keep isl_mat *A)
+{
+	int i;
+	isl_size total, n_div;
+	int any = 0;
+	isl_int gcd;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (total < 0 || n_div < 0 || !A)
+		return isl_basic_map_free(bmap);
+	total -= n_div;
+
+	isl_int_init(gcd);
+	for (i = 0; i < n; ++i) {
+		int div;
+
+		div = isl_seq_first_non_zero(bmap->eqi + 1 + total, n_div);
+		if (div < 0)
+			isl_die(isl_basic_map_get_ctx(bmap), isl_error_internal,
+				"equality constraints modified unexpectedly",
+				goto error);
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + total + div + 1,
+						n_div - div - 1) != -1)
+			continue;
+		if (isl_mat_row_gcd(A, i, &gcd) < 0)
+			goto error;
+		if (isl_int_is_one(gcd))
+			continue;
+		remove_incomplete_powers(&gcd, bmap->eqi1 + total + div);
+		if (isl_int_is_one(gcd))
+			continue;
+		isl_int_divexact(bmap->eqi1 + total + div,
+				bmap->eqi1 + total + div, gcd);
+		bmap = isl_basic_map_mark_div_unknown(bmap, div);
+		if (!bmap)
+			goto error;
+		any = 1;
+	}
+	isl_int_clear(gcd);
+
+	if (any)
+		bmap = isl_basic_map_gauss(bmap, NULL);
+
+	return bmap;
+error:
+	isl_int_clear(gcd);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Simplify the stride constraints in "bmap" based on
+ * the remaining equality constraints in "bmap" and all equality
+ * constraints in "context".
+ * Only do this if both "bmap" and "context" have stride constraints.
+ *
+ * First extract a copy of the stride constraints in "bmap" in a compressed
+ * space exploiting all the other equality constraints and then
+ * use this compressed copy to simplify the original stride constraints.
+ */
+static __isl_give isl_basic_map *gist_strides(__isl_take isl_basic_map *bmap,
+	__isl_keep isl_basic_map *context)
+{
+	int bmap_n_eq, context_n_eq;
+	isl_mat *A;
+
+	if (!bmap || !context)
+		return isl_basic_map_free(bmap);
+
+	bmap_n_eq = n_div_eq(bmap);
+	context_n_eq = n_div_eq(context);
+
+	if (bmap_n_eq < 0 || context_n_eq < 0)
+		return isl_basic_map_free(bmap);
+	if (bmap_n_eq == 0 || context_n_eq == 0)
+		return bmap;
+
+	A = extract_compressed_stride_constraints(bmap, bmap_n_eq,
+						    context, context_n_eq);
+	bmap = reduce_stride_constraints(bmap, bmap_n_eq, A);
+
+	isl_mat_free(A);
+
 	return bmap;
 }
 
@@ -2225,18 +3252,23 @@
  * this form that are most obviously redundant with respect to
  * the context.  We also remove those div constraints that are
  * redundant with respect to the other constraints in the result.
+ *
+ * The stride constraints among the equality constraints in "bmap" are
+ * also simplified with respecting to the other equality constraints
+ * in "bmap" and with respect to all equality constraints in "context".
  */
-struct isl_basic_map *isl_basic_map_gist(struct isl_basic_map *bmap,
-	struct isl_basic_map *context)
+__isl_give isl_basic_map *isl_basic_map_gist(__isl_take isl_basic_map *bmap,
+	__isl_take isl_basic_map *context)
 {
 	isl_basic_set *bset, *eq;
 	isl_basic_map *eq_bmap;
-	unsigned n_div, n_eq, n_ineq;
+	isl_size total, n_div, n_div_bmap;
+	unsigned extra, n_eq, n_ineq;
 
 	if (!bmap || !context)
 		goto error;
 
-	if (isl_basic_map_is_universe(bmap)) {
+	if (isl_basic_map_plain_is_universe(bmap)) {
 		isl_basic_map_free(context);
 		return bmap;
 	}
@@ -2253,18 +3285,21 @@
 
 	bmap = isl_basic_map_remove_redundancies(bmap);
 	context = isl_basic_map_remove_redundancies(context);
-	if (!context)
-		goto error;
-
-	if (context->n_eq)
-		bmap = normalize_divs_in_context(bmap, context);
-
+	bmap = isl_basic_map_order_divs(bmap);
 	context = isl_basic_map_align_divs(context, bmap);
-	bmap = isl_basic_map_align_divs(bmap, context);
-	n_div = isl_basic_map_dim(bmap, isl_dim_div);
 
-	bset = uset_gist(isl_basic_map_underlying_set(isl_basic_map_copy(bmap)),
+	n_div = isl_basic_map_dim(context, isl_dim_div);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div_bmap = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0 || total < 0 || n_div_bmap < 0)
+		goto error;
+	extra = n_div - n_div_bmap;
+
+	bset = isl_basic_map_underlying_set(isl_basic_map_copy(bmap));
+	bset = isl_basic_set_add_dims(bset, isl_dim_set, extra);
+	bset = uset_gist(bset,
 		    isl_basic_map_underlying_set(isl_basic_map_copy(context)));
+	bset = isl_basic_set_project_out(bset, isl_dim_set, total, extra);
 
 	if (!bset || bset->n_eq == 0 || n_div == 0 ||
 	    isl_basic_set_plain_is_empty(bset)) {
@@ -2275,13 +3310,12 @@
 	n_eq = bset->n_eq;
 	n_ineq = bset->n_ineq;
 	eq = isl_basic_set_copy(bset);
-	eq = isl_basic_set_cow(bset);
-	if (isl_basic_set_free_inequality(eq, n_ineq) < 0)
-		eq = isl_basic_set_free(eq);
-	if (isl_basic_set_free_equality(bset, n_eq) < 0)
-		bset = isl_basic_set_free(bset);
+	eq = isl_basic_set_cow(eq);
+	eq = isl_basic_set_free_inequality(eq, n_ineq);
+	bset = isl_basic_set_free_equality(bset, n_eq);
 
 	eq_bmap = isl_basic_map_overlying_set(eq, isl_basic_map_copy(bmap));
+	eq_bmap = gist_strides(eq_bmap, context);
 	eq_bmap = isl_basic_map_remove_shifted_constraints(eq_bmap, context);
 	bmap = isl_basic_map_overlying_set(bset, bmap);
 	bmap = isl_basic_map_intersect(bmap, eq_bmap);
@@ -2314,9 +3348,8 @@
 
 	context = isl_basic_map_remove_redundancies(context);
 	map = isl_map_cow(map);
-	if (!map || !context)
+	if (isl_map_basic_map_check_equal_space(map, context) < 0)
 		goto error;
-	isl_assert(map->ctx, isl_space_is_equal(map->dim, context->dim), goto error);
 	map = isl_map_compute_divs(map);
 	if (!map)
 		goto error;
@@ -2341,6 +3374,276 @@
 	return NULL;
 }
 
+/* Drop all inequalities from "bmap" that also appear in "context".
+ * "context" is assumed to have only known local variables and
+ * the initial local variables of "bmap" are assumed to be the same
+ * as those of "context".
+ * The constraints of both "bmap" and "context" are assumed
+ * to have been sorted using isl_basic_map_sort_constraints.
+ *
+ * Run through the inequality constraints of "bmap" and "context"
+ * in sorted order.
+ * If a constraint of "bmap" involves variables not in "context",
+ * then it cannot appear in "context".
+ * If a matching constraint is found, it is removed from "bmap".
+ */
+static __isl_give isl_basic_map *drop_inequalities(
+	__isl_take isl_basic_map *bmap, __isl_keep isl_basic_map *context)
+{
+	int i1, i2;
+	isl_size total, bmap_total;
+	unsigned extra;
+
+	total = isl_basic_map_dim(context, isl_dim_all);
+	bmap_total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0 || bmap_total < 0)
+		return isl_basic_map_free(bmap);
+
+	extra = bmap_total - total;
+
+	i1 = bmap->n_ineq - 1;
+	i2 = context->n_ineq - 1;
+	while (bmap && i1 >= 0 && i2 >= 0) {
+		int cmp;
+
+		if (isl_seq_first_non_zero(bmap->ineqi1 + 1 + total,
+					    extra) != -1) {
+			--i1;
+			continue;
+		}
+		cmp = isl_basic_map_constraint_cmp(context, bmap->ineqi1,
+							context->ineqi2);
+		if (cmp < 0) {
+			--i2;
+			continue;
+		}
+		if (cmp > 0) {
+			--i1;
+			continue;
+		}
+		if (isl_int_eq(bmap->ineqi10, context->ineqi20)) {
+			bmap = isl_basic_map_cow(bmap);
+			if (isl_basic_map_drop_inequality(bmap, i1) < 0)
+				bmap = isl_basic_map_free(bmap);
+		}
+		--i1;
+		--i2;
+	}
+
+	return bmap;
+}
+
+/* Drop all equalities from "bmap" that also appear in "context".
+ * "context" is assumed to have only known local variables and
+ * the initial local variables of "bmap" are assumed to be the same
+ * as those of "context".
+ *
+ * Run through the equality constraints of "bmap" and "context"
+ * in sorted order.
+ * If a constraint of "bmap" involves variables not in "context",
+ * then it cannot appear in "context".
+ * If a matching constraint is found, it is removed from "bmap".
+ */
+static __isl_give isl_basic_map *drop_equalities(
+	__isl_take isl_basic_map *bmap, __isl_keep isl_basic_map *context)
+{
+	int i1, i2;
+	isl_size total, bmap_total;
+	unsigned extra;
+
+	total = isl_basic_map_dim(context, isl_dim_all);
+	bmap_total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0 || bmap_total < 0)
+		return isl_basic_map_free(bmap);
+
+	extra = bmap_total - total;
+
+	i1 = bmap->n_eq - 1;
+	i2 = context->n_eq - 1;
+
+	while (bmap && i1 >= 0 && i2 >= 0) {
+		int last1, last2;
+
+		if (isl_seq_first_non_zero(bmap->eqi1 + 1 + total,
+					    extra) != -1)
+			break;
+		last1 = isl_seq_last_non_zero(bmap->eqi1 + 1, total);
+		last2 = isl_seq_last_non_zero(context->eqi2 + 1, total);
+		if (last1 > last2) {
+			--i2;
+			continue;
+		}
+		if (last1 < last2) {
+			--i1;
+			continue;
+		}
+		if (isl_seq_eq(bmap->eqi1, context->eqi2, 1 + total)) {
+			bmap = isl_basic_map_cow(bmap);
+			if (isl_basic_map_drop_equality(bmap, i1) < 0)
+				bmap = isl_basic_map_free(bmap);
+		}
+		--i1;
+		--i2;
+	}
+
+	return bmap;
+}
+
+/* Remove the constraints in "context" from "bmap".
+ * "context" is assumed to have explicit representations
+ * for all local variables.
+ *
+ * First align the divs of "bmap" to those of "context" and
+ * sort the constraints.  Then drop all constraints from "bmap"
+ * that appear in "context".
+ */
+__isl_give isl_basic_map *isl_basic_map_plain_gist(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_map *context)
+{
+	isl_bool done, known;
+
+	done = isl_basic_map_plain_is_universe(context);
+	if (done == isl_bool_false)
+		done = isl_basic_map_plain_is_universe(bmap);
+	if (done == isl_bool_false)
+		done = isl_basic_map_plain_is_empty(context);
+	if (done == isl_bool_false)
+		done = isl_basic_map_plain_is_empty(bmap);
+	if (done < 0)
+		goto error;
+	if (done) {
+		isl_basic_map_free(context);
+		return bmap;
+	}
+	known = isl_basic_map_divs_known(context);
+	if (known < 0)
+		goto error;
+	if (!known)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"context has unknown divs", goto error);
+
+	context = isl_basic_map_order_divs(context);
+	bmap = isl_basic_map_align_divs(bmap, context);
+	bmap = isl_basic_map_gauss(bmap, NULL);
+	bmap = isl_basic_map_sort_constraints(bmap);
+	context = isl_basic_map_sort_constraints(context);
+
+	bmap = drop_inequalities(bmap, context);
+	bmap = drop_equalities(bmap, context);
+
+	isl_basic_map_free(context);
+	bmap = isl_basic_map_finalize(bmap);
+	return bmap;
+error:
+	isl_basic_map_free(bmap);
+	isl_basic_map_free(context);
+	return NULL;
+}
+
+/* Replace "map" by the disjunct at position "pos" and free "context".
+ */
+static __isl_give isl_map *replace_by_disjunct(__isl_take isl_map *map,
+	int pos, __isl_take isl_basic_map *context)
+{
+	isl_basic_map *bmap;
+
+	bmap = isl_basic_map_copy(map->ppos);
+	isl_map_free(map);
+	isl_basic_map_free(context);
+	return isl_map_from_basic_map(bmap);
+}
+
+/* Remove the constraints in "context" from "map".
+ * If any of the disjuncts in the result turns out to be the universe,
+ * then return this universe.
+ * "context" is assumed to have explicit representations
+ * for all local variables.
+ */
+__isl_give isl_map *isl_map_plain_gist_basic_map(__isl_take isl_map *map,
+	__isl_take isl_basic_map *context)
+{
+	int i;
+	isl_bool univ, known;
+
+	univ = isl_basic_map_plain_is_universe(context);
+	if (univ < 0)
+		goto error;
+	if (univ) {
+		isl_basic_map_free(context);
+		return map;
+	}
+	known = isl_basic_map_divs_known(context);
+	if (known < 0)
+		goto error;
+	if (!known)
+		isl_die(isl_map_get_ctx(map), isl_error_invalid,
+			"context has unknown divs", goto error);
+
+	map = isl_map_cow(map);
+	if (!map)
+		goto error;
+	for (i = 0; i < map->n; ++i) {
+		map->pi = isl_basic_map_plain_gist(map->pi,
+						isl_basic_map_copy(context));
+		univ = isl_basic_map_plain_is_universe(map->pi);
+		if (univ < 0)
+			goto error;
+		if (univ && map->n > 1)
+			return replace_by_disjunct(map, i, context);
+	}
+
+	isl_basic_map_free(context);
+	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
+	if (map->n > 1)
+		ISL_F_CLR(map, ISL_MAP_DISJOINT);
+	return map;
+error:
+	isl_map_free(map);
+	isl_basic_map_free(context);
+	return NULL;
+}
+
+/* Remove the constraints in "context" from "set".
+ * If any of the disjuncts in the result turns out to be the universe,
+ * then return this universe.
+ * "context" is assumed to have explicit representations
+ * for all local variables.
+ */
+__isl_give isl_set *isl_set_plain_gist_basic_set(__isl_take isl_set *set,
+	__isl_take isl_basic_set *context)
+{
+	return set_from_map(isl_map_plain_gist_basic_map(set_to_map(set),
+							bset_to_bmap(context)));
+}
+
+/* Remove the constraints in "context" from "map".
+ * If any of the disjuncts in the result turns out to be the universe,
+ * then return this universe.
+ * "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_map *isl_map_plain_gist(__isl_take isl_map *map,
+	__isl_take isl_map *context)
+{
+	isl_basic_map *hull;
+
+	hull = isl_map_unshifted_simple_hull(context);
+	return isl_map_plain_gist_basic_map(map, hull);
+}
+
+/* Replace "map" by a universe map in the same space and free "drop".
+ */
+static __isl_give isl_map *replace_by_universe(__isl_take isl_map *map,
+	__isl_take isl_map *drop)
+{
+	isl_map *res;
+
+	res = isl_map_universe(isl_map_get_space(map));
+	isl_map_free(map);
+	isl_map_free(drop);
+	return res;
+}
+
 /* Return a map that has the same intersection with "context" as "map"
  * and that is as "simple" as possible.
  *
@@ -2350,13 +3653,30 @@
  * If "map" and "context" are identical to each other, then we can
  * return the corresponding universe.
  *
+ * If either "map" or "context" consists of multiple disjuncts,
+ * then check if "context" happens to be a subset of "map",
+ * in which case all constraints can be removed.
+ * In case of multiple disjuncts, the standard procedure
+ * may not be able to detect that all constraints can be removed.
+ *
  * If none of these cases apply, we have to work a bit harder.
+ * During this computation, we make use of a single disjunct context,
+ * so if the original context consists of more than one disjunct
+ * then we need to approximate the context by a single disjunct set.
+ * Simply taking the simple hull may drop constraints that are
+ * only implicitly available in each disjunct.  We therefore also
+ * look for constraints among those defining "map" that are valid
+ * for the context.  These can then be used to simplify away
+ * the corresponding constraints in "map".
  */
-static __isl_give isl_map *map_gist(__isl_take isl_map *map,
+__isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
 	__isl_take isl_map *context)
 {
 	int equal;
 	int is_universe;
+	isl_size n_disjunct_map, n_disjunct_context;
+	isl_bool subset;
+	isl_basic_map *hull;
 
 	is_universe = isl_map_plain_is_universe(map);
 	if (is_universe >= 0 && !is_universe)
@@ -2368,42 +3688,60 @@
 		return map;
 	}
 
+	isl_map_align_params_bin(&map, &context);
 	equal = isl_map_plain_is_equal(map, context);
 	if (equal < 0)
 		goto error;
-	if (equal) {
-		isl_map *res = isl_map_universe(isl_map_get_space(map));
-		isl_map_free(map);
-		isl_map_free(context);
-		return res;
+	if (equal)
+		return replace_by_universe(map, context);
+
+	n_disjunct_map = isl_map_n_basic_map(map);
+	n_disjunct_context = isl_map_n_basic_map(context);
+	if (n_disjunct_map < 0 || n_disjunct_context < 0)
+		goto error;
+	if (n_disjunct_map != 1 || n_disjunct_context != 1) {
+		subset = isl_map_is_subset(context, map);
+		if (subset < 0)
+			goto error;
+		if (subset)
+			return replace_by_universe(map, context);
 	}
 
 	context = isl_map_compute_divs(context);
-	return isl_map_gist_basic_map(map, isl_map_simple_hull(context));
+	if (!context)
+		goto error;
+	if (n_disjunct_context == 1) {
+		hull = isl_map_simple_hull(context);
+	} else {
+		isl_ctx *ctx;
+		isl_map_list *list;
+
+		ctx = isl_map_get_ctx(map);
+		list = isl_map_list_alloc(ctx, 2);
+		list = isl_map_list_add(list, isl_map_copy(context));
+		list = isl_map_list_add(list, isl_map_copy(map));
+		hull = isl_map_unshifted_simple_hull_from_map_list(context,
+								    list);
+	}
+	return isl_map_gist_basic_map(map, hull);
 error:
 	isl_map_free(map);
 	isl_map_free(context);
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_gist(__isl_take isl_map *map,
-	__isl_take isl_map *context)
-{
-	return isl_map_align_params_map_map_and(map, context, &map_gist);
-}
-
-struct isl_basic_set *isl_basic_set_gist(struct isl_basic_set *bset,
-						struct isl_basic_set *context)
+__isl_give isl_basic_set *isl_basic_set_gist(__isl_take isl_basic_set *bset,
+	__isl_take isl_basic_set *context)
 {
-	return (struct isl_basic_set *)isl_basic_map_gist(
-		(struct isl_basic_map *)bset, (struct isl_basic_map *)context);
+	return bset_from_bmap(isl_basic_map_gist(bset_to_bmap(bset),
+						bset_to_bmap(context)));
 }
 
 __isl_give isl_set *isl_set_gist_basic_set(__isl_take isl_set *set,
 	__isl_take isl_basic_set *context)
 {
-	return (struct isl_set *)isl_map_gist_basic_map((struct isl_map *)set,
-					(struct isl_basic_map *)context);
+	return set_from_map(isl_map_gist_basic_map(set_to_map(set),
+					bset_to_bmap(context)));
 }
 
 __isl_give isl_set *isl_set_gist_params_basic_set(__isl_take isl_set *set,
@@ -2418,8 +3756,20 @@
 __isl_give isl_set *isl_set_gist(__isl_take isl_set *set,
 	__isl_take isl_set *context)
 {
-	return (struct isl_set *)isl_map_gist((struct isl_map *)set,
-					(struct isl_map *)context);
+	return set_from_map(isl_map_gist(set_to_map(set), set_to_map(context)));
+}
+
+/* Compute the gist of "bmap" with respect to the constraints "context"
+ * on the domain.
+ */
+__isl_give isl_basic_map *isl_basic_map_gist_domain(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *context)
+{
+	isl_space *space = isl_basic_map_get_space(bmap);
+	isl_basic_map *bmap_context = isl_basic_map_universe(space);
+
+	bmap_context = isl_basic_map_intersect_domain(bmap_context, context);
+	return isl_basic_map_gist(bmap, bmap_context);
 }
 
 __isl_give isl_map *isl_map_gist_domain(__isl_take isl_map *map,
@@ -2457,37 +3807,37 @@
  * one basic map in the context of the equalities of the other
  * basic map and check if we get a contradiction.
  */
-int isl_basic_map_plain_is_disjoint(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_plain_is_disjoint(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2)
 {
 	struct isl_vec *v = NULL;
 	int *elim = NULL;
-	unsigned total;
+	isl_size total;
 	int i;
 
-	if (!bmap1 || !bmap2)
-		return -1;
-	isl_assert(bmap1->ctx, isl_space_is_equal(bmap1->dim, bmap2->dim),
-			return -1);
+	if (isl_basic_map_check_equal_space(bmap1, bmap2) < 0)
+		return isl_bool_error;
 	if (bmap1->n_div || bmap2->n_div)
-		return 0;
+		return isl_bool_false;
 	if (!bmap1->n_eq && !bmap2->n_eq)
-		return 0;
+		return isl_bool_false;
 
 	total = isl_space_dim(bmap1->dim, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 	if (total == 0)
-		return 0;
+		return isl_bool_false;
 	v = isl_vec_alloc(bmap1->ctx, 1 + total);
 	if (!v)
 		goto error;
 	elim = isl_alloc_array(bmap1->ctx, int, total);
 	if (!elim)
 		goto error;
-	compute_elimination_index(bmap1, elim);
+	compute_elimination_index(bmap1, elim, total);
 	for (i = 0; i < bmap2->n_eq; ++i) {
 		int reduced;
 		reduced = reduced_using_equalities(v->block.data, bmap2->eqi,
-							bmap1, elim);
+							bmap1, elim, total);
 		if (reduced && !isl_int_is_zero(v->block.data0) &&
 		    isl_seq_first_non_zero(v->block.data + 1, total) == -1)
 			goto disjoint;
@@ -2495,63 +3845,76 @@
 	for (i = 0; i < bmap2->n_ineq; ++i) {
 		int reduced;
 		reduced = reduced_using_equalities(v->block.data,
-						bmap2->ineqi, bmap1, elim);
+					bmap2->ineqi, bmap1, elim, total);
 		if (reduced && isl_int_is_neg(v->block.data0) &&
 		    isl_seq_first_non_zero(v->block.data + 1, total) == -1)
 			goto disjoint;
 	}
-	compute_elimination_index(bmap2, elim);
+	compute_elimination_index(bmap2, elim, total);
 	for (i = 0; i < bmap1->n_ineq; ++i) {
 		int reduced;
 		reduced = reduced_using_equalities(v->block.data,
-						bmap1->ineqi, bmap2, elim);
+					bmap1->ineqi, bmap2, elim, total);
 		if (reduced && isl_int_is_neg(v->block.data0) &&
 		    isl_seq_first_non_zero(v->block.data + 1, total) == -1)
 			goto disjoint;
 	}
 	isl_vec_free(v);
 	free(elim);
-	return 0;
+	return isl_bool_false;
 disjoint:
 	isl_vec_free(v);
 	free(elim);
-	return 1;
+	return isl_bool_true;
 error:
 	isl_vec_free(v);
 	free(elim);
-	return -1;
+	return isl_bool_error;
 }
 
 int isl_basic_set_plain_is_disjoint(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2)
 {
-	return isl_basic_map_plain_is_disjoint((struct isl_basic_map *)bset1,
-					      (struct isl_basic_map *)bset2);
+	return isl_basic_map_plain_is_disjoint(bset_to_bmap(bset1),
+					      bset_to_bmap(bset2));
 }
 
-/* Are "map1" and "map2" obviously disjoint?
- *
- * If one of them is empty or if they live in different spaces (ignoring
- * parameters), then they are clearly disjoint.
- *
- * If they have different parameters, then we skip any further tests.
- *
- * If they are obviously equal, but not obviously empty, then we will
- * not be able to detect if they are disjoint.
+/* Does "test" hold for all pairs of basic maps in "map1" and "map2"?
+ */
+static isl_bool all_pairs(__isl_keep isl_map *map1, __isl_keep isl_map *map2,
+	isl_bool (*test)(__isl_keep isl_basic_map *bmap1,
+		__isl_keep isl_basic_map *bmap2))
+{
+	int i, j;
+
+	if (!map1 || !map2)
+		return isl_bool_error;
+
+	for (i = 0; i < map1->n; ++i) {
+		for (j = 0; j < map2->n; ++j) {
+			isl_bool d = test(map1->pi, map2->pj);
+			if (d != isl_bool_true)
+				return d;
+		}
+	}
+
+	return isl_bool_true;
+}
+
+/* Are "map1" and "map2" obviously disjoint, based on information
+ * that can be derived without looking at the individual basic maps?
  *
- * Otherwise we check if each basic map in "map1" is obviously disjoint
- * from each basic map in "map2".
+ * In particular, if one of them is empty or if they live in different spaces
+ * (ignoring parameters), then they are clearly disjoint.
  */
-int isl_map_plain_is_disjoint(__isl_keep isl_map *map1,
+static isl_bool isl_map_plain_is_disjoint_global(__isl_keep isl_map *map1,
 	__isl_keep isl_map *map2)
 {
-	int i, j;
-	int disjoint;
-	int intersect;
-	int match;
+	isl_bool disjoint;
+	isl_bool match;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 
 	disjoint = isl_map_plain_is_empty(map1);
 	if (disjoint < 0 || disjoint)
@@ -2561,50 +3924,79 @@
 	if (disjoint < 0 || disjoint)
 		return disjoint;
 
-	match = isl_space_tuple_is_equal(map1->dim, isl_dim_in,
-				map2->dim, isl_dim_in);
+	match = isl_map_tuple_is_equal(map1, isl_dim_in, map2, isl_dim_in);
 	if (match < 0 || !match)
-		return match < 0 ? -1 : 1;
+		return match < 0 ? isl_bool_error : isl_bool_true;
 
-	match = isl_space_tuple_is_equal(map1->dim, isl_dim_out,
-				map2->dim, isl_dim_out);
+	match = isl_map_tuple_is_equal(map1, isl_dim_out, map2, isl_dim_out);
 	if (match < 0 || !match)
-		return match < 0 ? -1 : 1;
+		return match < 0 ? isl_bool_error : isl_bool_true;
+
+	return isl_bool_false;
+}
 
-	match = isl_space_match(map1->dim, isl_dim_param,
-				map2->dim, isl_dim_param);
+/* Are "map1" and "map2" obviously disjoint?
+ *
+ * If one of them is empty or if they live in different spaces (ignoring
+ * parameters), then they are clearly disjoint.
+ * This is checked by isl_map_plain_is_disjoint_global.
+ *
+ * If they have different parameters, then we skip any further tests.
+ *
+ * If they are obviously equal, but not obviously empty, then we will
+ * not be able to detect if they are disjoint.
+ *
+ * Otherwise we check if each basic map in "map1" is obviously disjoint
+ * from each basic map in "map2".
+ */
+isl_bool isl_map_plain_is_disjoint(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
+{
+	isl_bool disjoint;
+	isl_bool intersect;
+	isl_bool match;
+
+	disjoint = isl_map_plain_is_disjoint_global(map1, map2);
+	if (disjoint < 0 || disjoint)
+		return disjoint;
+
+	match = isl_map_has_equal_params(map1, map2);
 	if (match < 0 || !match)
-		return match < 0 ? -1 : 0;
+		return match < 0 ? isl_bool_error : isl_bool_false;
 
 	intersect = isl_map_plain_is_equal(map1, map2);
 	if (intersect < 0 || intersect)
-		return intersect < 0 ? -1 : 0;
+		return intersect < 0 ? isl_bool_error : isl_bool_false;
 
-	for (i = 0; i < map1->n; ++i) {
-		for (j = 0; j < map2->n; ++j) {
-			int d = isl_basic_map_plain_is_disjoint(map1->pi,
-							       map2->pj);
-			if (d != 1)
-				return d;
-		}
-	}
-	return 1;
+	return all_pairs(map1, map2, &isl_basic_map_plain_is_disjoint);
+}
+
+/* Are "map1" and "map2" disjoint?
+ * The parameters are assumed to have been aligned.
+ *
+ * In particular, check whether all pairs of basic maps are disjoint.
+ */
+static isl_bool isl_map_is_disjoint_aligned(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
+{
+	return all_pairs(map1, map2, &isl_basic_map_is_disjoint);
 }
 
 /* Are "map1" and "map2" disjoint?
  *
  * They are disjoint if they are "obviously disjoint" or if one of them
  * is empty.  Otherwise, they are not disjoint if one of them is universal.
- * If none of these cases apply, we compute the intersection and see if
- * the result is empty.
+ * If the two inputs are (obviously) equal and not empty, then they are
+ * not disjoint.
+ * If none of these cases apply, then check if all pairs of basic maps
+ * are disjoint after aligning the parameters.
  */
-int isl_map_is_disjoint(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+isl_bool isl_map_is_disjoint(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
 {
-	int disjoint;
-	int intersect;
-	isl_map *test;
+	isl_bool disjoint;
+	isl_bool intersect;
 
-	disjoint = isl_map_plain_is_disjoint(map1, map2);
+	disjoint = isl_map_plain_is_disjoint_global(map1, map2);
 	if (disjoint < 0 || disjoint)
 		return disjoint;
 
@@ -2618,17 +4010,18 @@
 
 	intersect = isl_map_plain_is_universe(map1);
 	if (intersect < 0 || intersect)
-		return intersect < 0 ? -1 : 0;
+		return isl_bool_not(intersect);
 
 	intersect = isl_map_plain_is_universe(map2);
 	if (intersect < 0 || intersect)
-		return intersect < 0 ? -1 : 0;
+		return isl_bool_not(intersect);
 
-	test = isl_map_intersect(isl_map_copy(map1), isl_map_copy(map2));
-	disjoint = isl_map_is_empty(test);
-	isl_map_free(test);
+	intersect = isl_map_plain_is_equal(map1, map2);
+	if (intersect < 0 || intersect)
+		return isl_bool_not(intersect);
 
-	return disjoint;
+	return isl_map_align_params_map_map_and_test(map1, map2,
+						&isl_map_is_disjoint_aligned);
 }
 
 /* Are "bmap1" and "bmap2" disjoint?
@@ -2638,11 +4031,11 @@
  * If none of these cases apply, we compute the intersection and see if
  * the result is empty.
  */
-int isl_basic_map_is_disjoint(__isl_keep isl_basic_map *bmap1,
+isl_bool isl_basic_map_is_disjoint(__isl_keep isl_basic_map *bmap1,
 	__isl_keep isl_basic_map *bmap2)
 {
-	int disjoint;
-	int intersect;
+	isl_bool disjoint;
+	isl_bool intersect;
 	isl_basic_map *test;
 
 	disjoint = isl_basic_map_plain_is_disjoint(bmap1, bmap2);
@@ -2657,13 +4050,13 @@
 	if (disjoint < 0 || disjoint)
 		return disjoint;
 
-	intersect = isl_basic_map_is_universe(bmap1);
+	intersect = isl_basic_map_plain_is_universe(bmap1);
 	if (intersect < 0 || intersect)
-		return intersect < 0 ? -1 : 0;
+		return isl_bool_not(intersect);
 
-	intersect = isl_basic_map_is_universe(bmap2);
+	intersect = isl_basic_map_plain_is_universe(bmap2);
 	if (intersect < 0 || intersect)
-		return intersect < 0 ? -1 : 0;
+		return isl_bool_not(intersect);
 
 	test = isl_basic_map_intersect(isl_basic_map_copy(bmap1),
 		isl_basic_map_copy(bmap2));
@@ -2675,34 +4068,58 @@
 
 /* Are "bset1" and "bset2" disjoint?
  */
-int isl_basic_set_is_disjoint(__isl_keep isl_basic_set *bset1,
+isl_bool isl_basic_set_is_disjoint(__isl_keep isl_basic_set *bset1,
 	__isl_keep isl_basic_set *bset2)
 {
 	return isl_basic_map_is_disjoint(bset1, bset2);
 }
 
-int isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
+isl_bool isl_set_plain_is_disjoint(__isl_keep isl_set *set1,
 	__isl_keep isl_set *set2)
 {
-	return isl_map_plain_is_disjoint((struct isl_map *)set1,
-					(struct isl_map *)set2);
+	return isl_map_plain_is_disjoint(set_to_map(set1), set_to_map(set2));
 }
 
 /* Are "set1" and "set2" disjoint?
  */
-int isl_set_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+isl_bool isl_set_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
 {
 	return isl_map_is_disjoint(set1, set2);
 }
 
-int isl_set_fast_is_disjoint(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+/* Is "v" equal to 0, 1 or -1?
+ */
+static int is_zero_or_one(isl_int v)
+{
+	return isl_int_is_zero(v) || isl_int_is_one(v) || isl_int_is_negone(v);
+}
+
+/* Are the "n" coefficients starting at "first" of inequality constraints
+ * "i" and "j" of "bmap" opposite to each other?
+ */
+static int is_opposite_part(__isl_keep isl_basic_map *bmap, int i, int j,
+	int first, int n)
+{
+	return isl_seq_is_neg(bmap->ineqi + first, bmap->ineqj + first, n);
+}
+
+/* Are inequality constraints "i" and "j" of "bmap" opposite to each other,
+ * apart from the constant term?
+ */
+static isl_bool is_opposite(__isl_keep isl_basic_map *bmap, int i, int j)
 {
-	return isl_set_plain_is_disjoint(set1, set2);
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	return is_opposite_part(bmap, i, j, 1, total);
 }
 
 /* Check if we can combine a given div with lower bound l and upper
  * bound u with some other div and if so return that other div.
- * Otherwise return -1.
+ * Otherwise, return a position beyond the integer divisions.
+ * Return -1 on error.
  *
  * We first check that
  *	- the bounds are opposites of each other (except for the constant
@@ -2720,38 +4137,45 @@
  * of this second div b and such that in any constraint that contains
  * a (except for the given lower and upper bound), also contains b
  * with a coefficient that is m times that of b.
- * That is, all constraints (execpt for the lower and upper bound)
+ * That is, all constraints (except for the lower and upper bound)
  * are of the form
  *
  *	e + f (a + m b) >= 0
  *
+ * Furthermore, in the constraints that only contain b, the coefficient
+ * of b should be equal to 1 or -1.
  * If so, we return b so that "a + m b" can be replaced by
  * a single div "c = a + m b".
  */
-static int div_find_coalesce(struct isl_basic_map *bmap, int *pairs,
+static int div_find_coalesce(__isl_keep isl_basic_map *bmap, int *pairs,
 	unsigned div, unsigned l, unsigned u)
 {
 	int i, j;
-	unsigned dim;
-	int coalesce = -1;
+	unsigned n_div;
+	isl_size v_div;
+	int coalesce;
+	isl_bool opp;
 
-	if (bmap->n_div <= 1)
-		return -1;
-	dim = isl_space_dim(bmap->dim, isl_dim_all);
-	if (isl_seq_first_non_zero(bmap->ineql + 1 + dim, div) != -1)
-		return -1;
-	if (isl_seq_first_non_zero(bmap->ineql + 1 + dim + div + 1,
-				   bmap->n_div - div - 1) != -1)
-		return -1;
-	if (!isl_seq_is_neg(bmap->ineql + 1, bmap->inequ + 1,
-			    dim + bmap->n_div))
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div <= 1)
+		return n_div;
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
 		return -1;
+	if (isl_seq_first_non_zero(bmap->ineql + 1 + v_div, div) != -1)
+		return n_div;
+	if (isl_seq_first_non_zero(bmap->ineql + 1 + v_div + div + 1,
+				   n_div - div - 1) != -1)
+		return n_div;
+	opp = is_opposite(bmap, l, u);
+	if (opp < 0 || !opp)
+		return opp < 0 ? -1 : n_div;
 
-	for (i = 0; i < bmap->n_div; ++i) {
+	for (i = 0; i < n_div; ++i) {
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
-		if (!isl_int_is_zero(bmap->divi1 + 1 + dim + div))
-			return -1;
+		if (!isl_int_is_zero(bmap->divi1 + 1 + v_div + div))
+			return n_div;
 	}
 
 	isl_int_add(bmap->ineql0, bmap->ineql0, bmap->inequ0);
@@ -2761,37 +4185,41 @@
 		bmap = isl_basic_map_copy(bmap);
 		bmap = isl_basic_map_set_to_empty(bmap);
 		isl_basic_map_free(bmap);
-		return -1;
+		return n_div;
 	}
 	isl_int_add_ui(bmap->ineql0, bmap->ineql0, 1);
-	for (i = 0; i < bmap->n_div; ++i) {
+	coalesce = n_div;
+	for (i = 0; i < n_div; ++i) {
 		if (i == div)
 			continue;
 		if (!pairsi)
 			continue;
-		for (j = 0; j < bmap->n_div; ++j) {
+		for (j = 0; j < n_div; ++j) {
 			if (isl_int_is_zero(bmap->divj0))
 				continue;
-			if (!isl_int_is_zero(bmap->divj1 + 1 + dim + i))
+			if (!isl_int_is_zero(bmap->divj1 + 1 + v_div + i))
 				break;
 		}
-		if (j < bmap->n_div)
+		if (j < n_div)
 			continue;
 		for (j = 0; j < bmap->n_ineq; ++j) {
 			int valid;
 			if (j == l || j == u)
 				continue;
-			if (isl_int_is_zero(bmap->ineqj1 + dim + div))
-				continue;
-			if (isl_int_is_zero(bmap->ineqj1 + dim + i))
+			if (isl_int_is_zero(bmap->ineqj1 + v_div + div)) {
+				if (is_zero_or_one(bmap->ineqj1 + v_div + i))
+					continue;
+				break;
+			}
+			if (isl_int_is_zero(bmap->ineqj1 + v_div + i))
 				break;
-			isl_int_mul(bmap->ineqj1 + dim + div,
-				    bmap->ineqj1 + dim + div,
+			isl_int_mul(bmap->ineqj1 + v_div + div,
+				    bmap->ineqj1 + v_div + div,
 				    bmap->ineql0);
-			valid = isl_int_eq(bmap->ineqj1 + dim + div,
-					   bmap->ineqj1 + dim + i);
-			isl_int_divexact(bmap->ineqj1 + dim + div,
-					 bmap->ineqj1 + dim + div,
+			valid = isl_int_eq(bmap->ineqj1 + v_div + div,
+					   bmap->ineqj1 + v_div + i);
+			isl_int_divexact(bmap->ineqj1 + v_div + div,
+					 bmap->ineqj1 + v_div + div,
 					 bmap->ineql0);
 			if (!valid)
 				break;
@@ -2806,12 +4234,60 @@
 	return coalesce;
 }
 
-/* Given a lower and an upper bound on div i, construct an inequality
- * that when nonnegative ensures that this pair of bounds always allows
- * for an integer value of the given div.
+/* Internal data structure used during the construction and/or evaluation of
+ * an inequality that ensures that a pair of bounds always allows
+ * for an integer value.
+ *
+ * "tab" is the tableau in which the inequality is evaluated.  It may
+ * be NULL until it is actually needed.
+ * "v" contains the inequality coefficients.
+ * "g", "fl" and "fu" are temporary scalars used during the construction and
+ * evaluation.
+ */
+struct test_ineq_data {
+	struct isl_tab *tab;
+	isl_vec *v;
+	isl_int g;
+	isl_int fl;
+	isl_int fu;
+};
+
+/* Free all the memory allocated by the fields of "data".
+ */
+static void test_ineq_data_clear(struct test_ineq_data *data)
+{
+	isl_tab_free(data->tab);
+	isl_vec_free(data->v);
+	isl_int_clear(data->g);
+	isl_int_clear(data->fl);
+	isl_int_clear(data->fu);
+}
+
+/* Is the inequality stored in data->v satisfied by "bmap"?
+ * That is, does it only attain non-negative values?
+ * data->tab is a tableau corresponding to "bmap".
+ */
+static isl_bool test_ineq_is_satisfied(__isl_keep isl_basic_map *bmap,
+	struct test_ineq_data *data)
+{
+	isl_ctx *ctx;
+	enum isl_lp_result res;
+
+	ctx = isl_basic_map_get_ctx(bmap);
+	if (!data->tab)
+		data->tab = isl_tab_from_basic_map(bmap, 0);
+	res = isl_tab_min(data->tab, data->v->el, ctx->one, &data->g, NULL, 0);
+	if (res == isl_lp_error)
+		return isl_bool_error;
+	return res == isl_lp_ok && isl_int_is_nonneg(data->g);
+}
+
+/* Given a lower and an upper bound on div i, do they always allow
+ * for an integer value of the given div?
+ * Determine this property by constructing an inequality
+ * such that the property is guaranteed when the inequality is nonnegative.
  * The lower bound is inequality l, while the upper bound is inequality u.
- * The constructed inequality is stored in ineq.
- * g, fl, fu are temporary scalars.
+ * The constructed inequality is stored in data->v.
  *
  * Let the upper bound be
  *
@@ -2835,62 +4311,112 @@
  * That is, the test constraint is
  *
  *	f_l e_u + f_u e_l + f_l - 1 + f_u - 1 + 1 >= f_u f_l g
+ *
+ * or
+ *
+ *	f_l e_u + f_u e_l + f_l - 1 + f_u - 1 + 1 - f_u f_l g >= 0
+ *
+ * If the coefficients of f_l e_u + f_u e_l have a common divisor g',
+ * then the constraint can be scaled down by a factor g',
+ * with the constant term replaced by
+ * floor((f_l e_{u,0} + f_u e_{l,0} + f_l - 1 + f_u - 1 + 1 - f_u f_l g)/g').
+ * Note that the result of applying Fourier-Motzkin to this pair
+ * of constraints is
+ *
+ *	f_l e_u + f_u e_l >= 0
+ *
+ * If the constant term of the scaled down version of this constraint,
+ * i.e., floor((f_l e_{u,0} + f_u e_{l,0})/g') is equal to the constant
+ * term of the scaled down test constraint, then the test constraint
+ * is known to hold and no explicit evaluation is required.
+ * This is essentially the Omega test.
+ *
+ * If the test constraint consists of only a constant term, then
+ * it is sufficient to look at the sign of this constant term.
  */
-static void construct_test_ineq(struct isl_basic_map *bmap, int i,
-	int l, int u, isl_int *ineq, isl_int g, isl_int fl, isl_int fu)
+static isl_bool int_between_bounds(__isl_keep isl_basic_map *bmap, int i,
+	int l, int u, struct test_ineq_data *data)
 {
-	unsigned dim;
-	dim = isl_space_dim(bmap->dim, isl_dim_all);
+	unsigned offset;
+	isl_size n_div;
+
+	offset = isl_basic_map_offset(bmap, isl_dim_div);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
 
-	isl_int_gcd(g, bmap->ineql1 + dim + i, bmap->inequ1 + dim + i);
-	isl_int_divexact(fl, bmap->ineql1 + dim + i, g);
-	isl_int_divexact(fu, bmap->inequ1 + dim + i, g);
-	isl_int_neg(fu, fu);
-	isl_seq_combine(ineq, fl, bmap->inequ, fu, bmap->ineql,
-			1 + dim + bmap->n_div);
-	isl_int_add(ineq0, ineq0, fl);
-	isl_int_add(ineq0, ineq0, fu);
-	isl_int_sub_ui(ineq0, ineq0, 1);
-	isl_int_mul(g, g, fl);
-	isl_int_mul(g, g, fu);
-	isl_int_sub(ineq0, ineq0, g);
+	isl_int_gcd(data->g,
+		    bmap->ineqloffset + i, bmap->inequoffset + i);
+	isl_int_divexact(data->fl, bmap->ineqloffset + i, data->g);
+	isl_int_divexact(data->fu, bmap->inequoffset + i, data->g);
+	isl_int_neg(data->fu, data->fu);
+	isl_seq_combine(data->v->el, data->fl, bmap->inequ,
+			data->fu, bmap->ineql, offset + n_div);
+	isl_int_mul(data->g, data->g, data->fl);
+	isl_int_mul(data->g, data->g, data->fu);
+	isl_int_sub(data->g, data->g, data->fl);
+	isl_int_sub(data->g, data->g, data->fu);
+	isl_int_add_ui(data->g, data->g, 1);
+	isl_int_sub(data->fl, data->v->el0, data->g);
+
+	isl_seq_gcd(data->v->el + 1, offset - 1 + n_div, &data->g);
+	if (isl_int_is_zero(data->g))
+		return isl_int_is_nonneg(data->fl);
+	if (isl_int_is_one(data->g)) {
+		isl_int_set(data->v->el0, data->fl);
+		return test_ineq_is_satisfied(bmap, data);
+	}
+	isl_int_fdiv_q(data->fl, data->fl, data->g);
+	isl_int_fdiv_q(data->v->el0, data->v->el0, data->g);
+	if (isl_int_eq(data->fl, data->v->el0))
+		return isl_bool_true;
+	isl_int_set(data->v->el0, data->fl);
+	isl_seq_scale_down(data->v->el + 1, data->v->el + 1, data->g,
+			    offset - 1 + n_div);
+
+	return test_ineq_is_satisfied(bmap, data);
 }
 
 /* Remove more kinds of divs that are not strictly needed.
  * In particular, if all pairs of lower and upper bounds on a div
  * are such that they allow at least one integer value of the div,
- * the we can eliminate the div using Fourier-Motzkin without
+ * then we can eliminate the div using Fourier-Motzkin without
  * introducing any spurious solutions.
+ *
+ * If at least one of the two constraints has a unit coefficient for the div,
+ * then the presence of such a value is guaranteed so there is no need to check.
+ * In particular, the value attained by the bound with unit coefficient
+ * can serve as this intermediate value.
  */
-static struct isl_basic_map *drop_more_redundant_divs(
-	struct isl_basic_map *bmap, int *pairs, int n)
+static __isl_give isl_basic_map *drop_more_redundant_divs(
+	__isl_take isl_basic_map *bmap, __isl_take int *pairs, int n)
 {
-	struct isl_tab *tab = NULL;
-	struct isl_vec *vec = NULL;
-	unsigned dim;
+	isl_ctx *ctx;
+	struct test_ineq_data data = { NULL, NULL };
+	unsigned off;
+	isl_size n_div;
 	int remove = -1;
-	isl_int g, fl, fu;
 
-	isl_int_init(g);
-	isl_int_init(fl);
-	isl_int_init(fu);
+	isl_int_init(data.g);
+	isl_int_init(data.fl);
+	isl_int_init(data.fu);
 
-	if (!bmap)
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
 		goto error;
 
-	dim = isl_space_dim(bmap->dim, isl_dim_all);
-	vec = isl_vec_alloc(bmap->ctx, 1 + dim + bmap->n_div);
-	if (!vec)
+	ctx = isl_basic_map_get_ctx(bmap);
+	off = isl_basic_map_offset(bmap, isl_dim_div);
+	data.v = isl_vec_alloc(ctx, off + n_div);
+	if (!data.v)
 		goto error;
 
-	tab = isl_tab_from_basic_map(bmap, 0);
-
 	while (n > 0) {
 		int i, l, u;
 		int best = -1;
-		enum isl_lp_result res;
+		isl_bool has_int;
 
-		for (i = 0; i < bmap->n_div; ++i) {
+		for (i = 0; i < n_div; ++i) {
 			if (!pairsi)
 				continue;
 			if (best >= 0 && pairsbest <= pairsi)
@@ -2900,27 +4426,31 @@
 
 		i = best;
 		for (l = 0; l < bmap->n_ineq; ++l) {
-			if (!isl_int_is_pos(bmap->ineql1 + dim + i))
+			if (!isl_int_is_pos(bmap->ineqloff + i))
+				continue;
+			if (isl_int_is_one(bmap->ineqloff + i))
 				continue;
 			for (u = 0; u < bmap->n_ineq; ++u) {
-				if (!isl_int_is_neg(bmap->inequ1 + dim + i))
+				if (!isl_int_is_neg(bmap->inequoff + i))
+					continue;
+				if (isl_int_is_negone(bmap->inequoff + i))
 					continue;
-				construct_test_ineq(bmap, i, l, u,
-						    vec->el, g, fl, fu);
-				res = isl_tab_min(tab, vec->el,
-						  bmap->ctx->one, &g, NULL, 0);
-				if (res == isl_lp_error)
+				has_int = int_between_bounds(bmap, i, l, u,
+								&data);
+				if (has_int < 0)
 					goto error;
-				if (res == isl_lp_empty) {
-					bmap = isl_basic_map_set_to_empty(bmap);
+				if (data.tab && data.tab->empty)
 					break;
-				}
-				if (res != isl_lp_ok || isl_int_is_neg(g))
+				if (!has_int)
 					break;
 			}
 			if (u < bmap->n_ineq)
 				break;
 		}
+		if (data.tab && data.tab->empty) {
+			bmap = isl_basic_map_set_to_empty(bmap);
+			break;
+		}
 		if (l == bmap->n_ineq) {
 			remove = i;
 			break;
@@ -2929,12 +4459,7 @@
 		--n;
 	}
 
-	isl_tab_free(tab);
-	isl_vec_free(vec);
-
-	isl_int_clear(g);
-	isl_int_clear(fl);
-	isl_int_clear(fu);
+	test_ineq_data_clear(&data);
 
 	free(pairs);
 
@@ -2946,16 +4471,12 @@
 error:
 	free(pairs);
 	isl_basic_map_free(bmap);
-	isl_tab_free(tab);
-	isl_vec_free(vec);
-	isl_int_clear(g);
-	isl_int_clear(fl);
-	isl_int_clear(fu);
+	test_ineq_data_clear(&data);
 	return NULL;
 }
 
-/* Given a pair of divs div1 and div2 such that, expect for the lower bound l
- * and the upper bound u, div1 always occurs together with div2 in the form 
+/* Given a pair of divs div1 and div2 such that, except for the lower bound l
+ * and the upper bound u, div1 always occurs together with div2 in the form
  * (div1 + m div2), where m is the constant range on the variable div1
  * allowed by l and u, replace the pair div1 and div2 by a single
  * div that is equal to div1 + m div2.
@@ -2963,13 +4484,14 @@
  * The new div will appear in the location that contains div2.
  * We need to modify all constraints that contain
  * div2 = (div - div1) / m
+ * The coefficient of div2 is known to be equal to 1 or -1.
  * (If a constraint does not contain div2, it will also not contain div1.)
  * If the constraint also contains div1, then we know they appear
  * as f (div1 + m div2) and we can simply replace (div1 + m div2) by div,
  * i.e., the coefficient of div is f.
  *
  * Otherwise, we first need to introduce div1 into the constraint.
- * Let the l be
+ * Let l be
  *
  *	div1 + f >=0
  *
@@ -2979,41 +4501,45 @@
  *
  * A lower bound on div2
  *
- *	n div2 + t >= 0
+ *	div2 + t >= 0
  *
  * can be replaced by
  *
- *	(n * (m div 2 + div1) + m t + n f)/g >= 0
+ *	m div2 + div1 + m t + f >= 0
  *
- * with g = gcd(m,n).
  * An upper bound
  *
- *	-n div2 + t >= 0
+ *	-div2 + t >= 0
  *
  * can be replaced by
  *
- *	(-n * (m div2 + div1) + m t + n f')/g >= 0
+ *	-(m div2 + div1) + m t + f' >= 0
  *
  * These constraint are those that we would obtain from eliminating
  * div1 using Fourier-Motzkin.
  *
  * After all constraints have been modified, we drop the lower and upper
  * bound and then drop div1.
+ * Since the new div is only placed in the same location that used
+ * to store div2, but otherwise has a different meaning, any possible
+ * explicit representation of the original div2 is removed.
  */
-static struct isl_basic_map *coalesce_divs(struct isl_basic_map *bmap,
+static __isl_give isl_basic_map *coalesce_divs(__isl_take isl_basic_map *bmap,
 	unsigned div1, unsigned div2, unsigned l, unsigned u)
 {
-	isl_int a;
-	isl_int b;
+	isl_ctx *ctx;
 	isl_int m;
-	unsigned dim, total;
+	isl_size v_div;
+	unsigned total;
 	int i;
 
-	dim = isl_space_dim(bmap->dim, isl_dim_all);
-	total = 1 + dim + bmap->n_div;
+	ctx = isl_basic_map_get_ctx(bmap);
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0)
+		return isl_basic_map_free(bmap);
+	total = 1 + v_div + bmap->n_div;
 
-	isl_int_init(a);
-	isl_int_init(b);
 	isl_int_init(m);
 	isl_int_add(m, bmap->ineql0, bmap->inequ0);
 	isl_int_add_ui(m, m, 1);
@@ -3021,28 +4547,21 @@
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		if (i == l || i == u)
 			continue;
-		if (isl_int_is_zero(bmap->ineqi1 + dim + div2))
+		if (isl_int_is_zero(bmap->ineqi1 + v_div + div2))
 			continue;
-		if (isl_int_is_zero(bmap->ineqi1 + dim + div1)) {
-			isl_int_gcd(b, m, bmap->ineqi1 + dim + div2);
-			isl_int_divexact(a, m, b);
-			isl_int_divexact(b, bmap->ineqi1 + dim + div2, b);
-			if (isl_int_is_pos(b)) {
-				isl_seq_combine(bmap->ineqi, a, bmap->ineqi,
-						b, bmap->ineql, total);
-			} else {
-				isl_int_neg(b, b);
-				isl_seq_combine(bmap->ineqi, a, bmap->ineqi,
-						b, bmap->inequ, total);
-			}
+		if (isl_int_is_zero(bmap->ineqi1 + v_div + div1)) {
+			if (isl_int_is_pos(bmap->ineqi1 + v_div + div2))
+				isl_seq_combine(bmap->ineqi, m, bmap->ineqi,
+						ctx->one, bmap->ineql, total);
+			else
+				isl_seq_combine(bmap->ineqi, m, bmap->ineqi,
+						ctx->one, bmap->inequ, total);
 		}
-		isl_int_set(bmap->ineqi1 + dim + div2,
-			    bmap->ineqi1 + dim + div1);
-		isl_int_set_si(bmap->ineqi1 + dim + div1, 0);
+		isl_int_set(bmap->ineqi1 + v_div + div2,
+			    bmap->ineqi1 + v_div + div1);
+		isl_int_set_si(bmap->ineqi1 + v_div + div1, 0);
 	}
 
-	isl_int_clear(a);
-	isl_int_clear(b);
 	isl_int_clear(m);
 	if (l > u) {
 		isl_basic_map_drop_inequality(bmap, l);
@@ -3051,6 +4570,7 @@
 		isl_basic_map_drop_inequality(bmap, u);
 		isl_basic_map_drop_inequality(bmap, l);
 	}
+	bmap = isl_basic_map_mark_div_unknown(bmap, div2);
 	bmap = isl_basic_map_drop_div(bmap, div1);
 	return bmap;
 }
@@ -3063,27 +4583,33 @@
  * is any other div "c" with which we can coalesce the div
  * and if so, perform the coalescing.
  */
-static struct isl_basic_map *coalesce_or_drop_more_redundant_divs(
-	struct isl_basic_map *bmap, int *pairs, int n)
+static __isl_give isl_basic_map *coalesce_or_drop_more_redundant_divs(
+	__isl_take isl_basic_map *bmap, int *pairs, int n)
 {
 	int i, l, u;
-	unsigned dim;
+	isl_size v_div;
+	isl_size n_div;
 
-	dim = isl_space_dim(bmap->dim, isl_dim_all);
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (v_div < 0 || n_div < 0)
+		return isl_basic_map_free(bmap);
 
-	for (i = 0; i < bmap->n_div; ++i) {
+	for (i = 0; i < n_div; ++i) {
 		if (!pairsi)
 			continue;
 		for (l = 0; l < bmap->n_ineq; ++l) {
-			if (!isl_int_is_one(bmap->ineql1 + dim + i))
+			if (!isl_int_is_one(bmap->ineql1 + v_div + i))
 				continue;
 			for (u = 0; u < bmap->n_ineq; ++u) {
 				int c;
 
-				if (!isl_int_is_negone(bmap->inequ1+dim+i))
+				if (!isl_int_is_negone(bmap->inequ1+v_div+i))
 					continue;
 				c = div_find_coalesce(bmap, pairs, i, l, u);
 				if (c < 0)
+					goto error;
+				if (c >= n_div)
 					continue;
 				free(pairs);
 				bmap = coalesce_divs(bmap, i, c, l, u);
@@ -3092,13 +4618,350 @@
 		}
 	}
 
-	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY))
+	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_EMPTY)) {
+		free(pairs);
 		return bmap;
+	}
 
 	return drop_more_redundant_divs(bmap, pairs, n);
+error:
+	free(pairs);
+	isl_basic_map_free(bmap);
+	return NULL;
 }
 
-/* Remove divs that are not strictly needed.
+/* Are the "n" coefficients starting at "first" of inequality constraints
+ * "i" and "j" of "bmap" equal to each other?
+ */
+static int is_parallel_part(__isl_keep isl_basic_map *bmap, int i, int j,
+	int first, int n)
+{
+	return isl_seq_eq(bmap->ineqi + first, bmap->ineqj + first, n);
+}
+
+/* Are inequality constraints "i" and "j" of "bmap" equal to each other,
+ * apart from the constant term and the coefficient at position "pos"?
+ */
+static isl_bool is_parallel_except(__isl_keep isl_basic_map *bmap, int i, int j,
+	int pos)
+{
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	return is_parallel_part(bmap, i, j, 1, pos - 1) &&
+		is_parallel_part(bmap, i, j, pos + 1, total - pos);
+}
+
+/* Are inequality constraints "i" and "j" of "bmap" opposite to each other,
+ * apart from the constant term and the coefficient at position "pos"?
+ */
+static isl_bool is_opposite_except(__isl_keep isl_basic_map *bmap, int i, int j,
+	int pos)
+{
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	return is_opposite_part(bmap, i, j, 1, pos - 1) &&
+		is_opposite_part(bmap, i, j, pos + 1, total - pos);
+}
+
+/* Restart isl_basic_map_drop_redundant_divs after "bmap" has
+ * been modified, simplying it if "simplify" is set.
+ * Free the temporary data structure "pairs" that was associated
+ * to the old version of "bmap".
+ */
+static __isl_give isl_basic_map *drop_redundant_divs_again(
+	__isl_take isl_basic_map *bmap, __isl_take int *pairs, int simplify)
+{
+	if (simplify)
+		bmap = isl_basic_map_simplify(bmap);
+	free(pairs);
+	return isl_basic_map_drop_redundant_divs(bmap);
+}
+
+/* Is "div" the single unknown existentially quantified variable
+ * in inequality constraint "ineq" of "bmap"?
+ * "div" is known to have a non-zero coefficient in "ineq".
+ */
+static isl_bool single_unknown(__isl_keep isl_basic_map *bmap, int ineq,
+	int div)
+{
+	int i;
+	isl_size n_div;
+	unsigned o_div;
+	isl_bool known;
+
+	known = isl_basic_map_div_is_known(bmap, div);
+	if (known < 0 || known)
+		return isl_bool_not(known);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_bool_error;
+	if (n_div == 1)
+		return isl_bool_true;
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	for (i = 0; i < n_div; ++i) {
+		isl_bool known;
+
+		if (i == div)
+			continue;
+		if (isl_int_is_zero(bmap->ineqineqo_div + i))
+			continue;
+		known = isl_basic_map_div_is_known(bmap, i);
+		if (known < 0 || !known)
+			return known;
+	}
+
+	return isl_bool_true;
+}
+
+/* Does integer division "div" have coefficient 1 in inequality constraint
+ * "ineq" of "map"?
+ */
+static isl_bool has_coef_one(__isl_keep isl_basic_map *bmap, int div, int ineq)
+{
+	unsigned o_div;
+
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	if (isl_int_is_one(bmap->ineqineqo_div + div))
+		return isl_bool_true;
+
+	return isl_bool_false;
+}
+
+/* Turn inequality constraint "ineq" of "bmap" into an equality and
+ * then try and drop redundant divs again,
+ * freeing the temporary data structure "pairs" that was associated
+ * to the old version of "bmap".
+ */
+static __isl_give isl_basic_map *set_eq_and_try_again(
+	__isl_take isl_basic_map *bmap, int ineq, __isl_take int *pairs)
+{
+	bmap = isl_basic_map_cow(bmap);
+	isl_basic_map_inequality_to_equality(bmap, ineq);
+	return drop_redundant_divs_again(bmap, pairs, 1);
+}
+
+/* Drop the integer division at position "div", along with the two
+ * inequality constraints "ineq1" and "ineq2" in which it appears
+ * from "bmap" and then try and drop redundant divs again,
+ * freeing the temporary data structure "pairs" that was associated
+ * to the old version of "bmap".
+ */
+static __isl_give isl_basic_map *drop_div_and_try_again(
+	__isl_take isl_basic_map *bmap, int div, int ineq1, int ineq2,
+	__isl_take int *pairs)
+{
+	if (ineq1 > ineq2) {
+		isl_basic_map_drop_inequality(bmap, ineq1);
+		isl_basic_map_drop_inequality(bmap, ineq2);
+	} else {
+		isl_basic_map_drop_inequality(bmap, ineq2);
+		isl_basic_map_drop_inequality(bmap, ineq1);
+	}
+	bmap = isl_basic_map_drop_div(bmap, div);
+	return drop_redundant_divs_again(bmap, pairs, 0);
+}
+
+/* Given two inequality constraints
+ *
+ *	f(x) + n d + c >= 0,		(ineq)
+ *
+ * with d the variable at position "pos", and
+ *
+ *	f(x) + c0 >= 0,			(lower)
+ *
+ * compute the maximal value of the lower bound ceil((-f(x) - c)/n)
+ * determined by the first constraint.
+ * That is, store
+ *
+ *	ceil((c0 - c)/n)
+ *
+ * in *l.
+ */
+static void lower_bound_from_parallel(__isl_keep isl_basic_map *bmap,
+	int ineq, int lower, int pos, isl_int *l)
+{
+	isl_int_neg(*l, bmap->ineqineq0);
+	isl_int_add(*l, *l, bmap->ineqlower0);
+	isl_int_cdiv_q(*l, *l, bmap->ineqineqpos);
+}
+
+/* Given two inequality constraints
+ *
+ *	f(x) + n d + c >= 0,		(ineq)
+ *
+ * with d the variable at position "pos", and
+ *
+ *	-f(x) - c0 >= 0,		(upper)
+ *
+ * compute the minimal value of the lower bound ceil((-f(x) - c)/n)
+ * determined by the first constraint.
+ * That is, store
+ *
+ *	ceil((-c1 - c)/n)
+ *
+ * in *u.
+ */
+static void lower_bound_from_opposite(__isl_keep isl_basic_map *bmap,
+	int ineq, int upper, int pos, isl_int *u)
+{
+	isl_int_neg(*u, bmap->ineqineq0);
+	isl_int_sub(*u, *u, bmap->inequpper0);
+	isl_int_cdiv_q(*u, *u, bmap->ineqineqpos);
+}
+
+/* Given a lower bound constraint "ineq" on "div" in "bmap",
+ * does the corresponding lower bound have a fixed value in "bmap"?
+ *
+ * In particular, "ineq" is of the form
+ *
+ *	f(x) + n d + c >= 0
+ *
+ * with n > 0, c the constant term and
+ * d the existentially quantified variable "div".
+ * That is, the lower bound is
+ *
+ *	ceil((-f(x) - c)/n)
+ *
+ * Look for a pair of constraints
+ *
+ *	f(x) + c0 >= 0
+ *	-f(x) + c1 >= 0
+ *
+ * i.e., -c1 <= -f(x) <= c0, that fix ceil((-f(x) - c)/n) to a constant value.
+ * That is, check that
+ *
+ *	ceil((-c1 - c)/n) = ceil((c0 - c)/n)
+ *
+ * If so, return the index of inequality f(x) + c0 >= 0.
+ * Otherwise, return bmap->n_ineq.
+ * Return -1 on error.
+ */
+static int lower_bound_is_cst(__isl_keep isl_basic_map *bmap, int div, int ineq)
+{
+	int i;
+	int lower = -1, upper = -1;
+	unsigned o_div;
+	isl_int l, u;
+	int equal;
+
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	for (i = 0; i < bmap->n_ineq && (lower < 0 || upper < 0); ++i) {
+		isl_bool par, opp;
+
+		if (i == ineq)
+			continue;
+		if (!isl_int_is_zero(bmap->ineqio_div + div))
+			continue;
+		par = isl_bool_false;
+		if (lower < 0)
+			par = is_parallel_except(bmap, ineq, i, o_div + div);
+		if (par < 0)
+			return -1;
+		if (par) {
+			lower = i;
+			continue;
+		}
+		opp = isl_bool_false;
+		if (upper < 0)
+			opp = is_opposite_except(bmap, ineq, i, o_div + div);
+		if (opp < 0)
+			return -1;
+		if (opp)
+			upper = i;
+	}
+
+	if (lower < 0 || upper < 0)
+		return bmap->n_ineq;
+
+	isl_int_init(l);
+	isl_int_init(u);
+
+	lower_bound_from_parallel(bmap, ineq, lower, o_div + div, &l);
+	lower_bound_from_opposite(bmap, ineq, upper, o_div + div, &u);
+
+	equal = isl_int_eq(l, u);
+
+	isl_int_clear(l);
+	isl_int_clear(u);
+
+	return equal ? lower : bmap->n_ineq;
+}
+
+/* Given a lower bound constraint "ineq" on the existentially quantified
+ * variable "div", such that the corresponding lower bound has
+ * a fixed value in "bmap", assign this fixed value to the variable and
+ * then try and drop redundant divs again,
+ * freeing the temporary data structure "pairs" that was associated
+ * to the old version of "bmap".
+ * "lower" determines the constant value for the lower bound.
+ *
+ * In particular, "ineq" is of the form
+ *
+ *	f(x) + n d + c >= 0,
+ *
+ * while "lower" is of the form
+ *
+ *	f(x) + c0 >= 0
+ *
+ * The lower bound is ceil((-f(x) - c)/n) and its constant value
+ * is ceil((c0 - c)/n).
+ */
+static __isl_give isl_basic_map *fix_cst_lower(__isl_take isl_basic_map *bmap,
+	int div, int ineq, int lower, int *pairs)
+{
+	isl_int c;
+	unsigned o_div;
+
+	isl_int_init(c);
+
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	lower_bound_from_parallel(bmap, ineq, lower, o_div + div, &c);
+	bmap = isl_basic_map_fix(bmap, isl_dim_div, div, c);
+	free(pairs);
+
+	isl_int_clear(c);
+
+	return isl_basic_map_drop_redundant_divs(bmap);
+}
+
+/* Do any of the integer divisions of "bmap" involve integer division "div"?
+ *
+ * The integer division "div" could only ever appear in any later
+ * integer division (with an explicit representation).
+ */
+static isl_bool any_div_involves_div(__isl_keep isl_basic_map *bmap, int div)
+{
+	int i;
+	isl_size v_div, n_div;
+
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (v_div < 0 || n_div < 0)
+		return isl_bool_error;
+
+	for (i = div + 1; i < n_div; ++i) {
+		isl_bool unknown;
+
+		unknown = isl_basic_map_div_is_marked_unknown(bmap, i);
+		if (unknown < 0)
+			return isl_bool_error;
+		if (unknown)
+			continue;
+		if (!isl_int_is_zero(bmap->divi1 + 1 + v_div + div))
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* Remove divs that are not strictly needed based on the inequality
+ * constraints.
  * In particular, if a div only occurs positively (or negatively)
  * in constraints, then it can simply be dropped.
  * Also, if a div occurs in only two constraints and if moreover
@@ -3106,9 +4969,32 @@
  * term and if the sum of the constant terms is such that for any value
  * of the other values, there is always at least one integer value of the
  * div, i.e., if one plus this sum is greater than or equal to
- * the (absolute value) of the coefficent of the div in the constraints,
+ * the (absolute value) of the coefficient of the div in the constraints,
  * then we can also simply drop the div.
  *
+ * If an existentially quantified variable does not have an explicit
+ * representation, appears in only a single lower bound that does not
+ * involve any other such existentially quantified variables and appears
+ * in this lower bound with coefficient 1,
+ * then fix the variable to the value of the lower bound.  That is,
+ * turn the inequality into an equality.
+ * If for any value of the other variables, there is any value
+ * for the existentially quantified variable satisfying the constraints,
+ * then this lower bound also satisfies the constraints.
+ * It is therefore safe to pick this lower bound.
+ *
+ * The same reasoning holds even if the coefficient is not one.
+ * However, fixing the variable to the value of the lower bound may
+ * in general introduce an extra integer division, in which case
+ * it may be better to pick another value.
+ * If this integer division has a known constant value, then plugging
+ * in this constant value removes the existentially quantified variable
+ * completely.  In particular, if the lower bound is of the form
+ * ceil((-f(x) - c)/n) and there are two constraints, f(x) + c0 >= 0 and
+ * -f(x) + c1 >= 0 such that ceil((-c1 - c)/n) = ceil((c0 - c)/n),
+ * then the existentially quantified variable can be assigned this
+ * shared value.
+ *
  * We skip divs that appear in equalities or in the definition of other divs.
  * Divs that appear in the definition of other divs usually occur in at least
  * 4 constraints, but the constraints may have been simplified.
@@ -3116,35 +5002,42 @@
  * If any divs are left after these simple checks then we move on
  * to more complicated cases in drop_more_redundant_divs.
  */
-struct isl_basic_map *isl_basic_map_drop_redundant_divs(
-	struct isl_basic_map *bmap)
+static __isl_give isl_basic_map *isl_basic_map_drop_redundant_divs_ineq(
+	__isl_take isl_basic_map *bmap)
 {
 	int i, j;
-	unsigned off;
+	isl_size off;
 	int *pairs = NULL;
 	int n = 0;
+	isl_size n_ineq;
 
 	if (!bmap)
 		goto error;
 	if (bmap->n_div == 0)
 		return bmap;
 
-	off = isl_space_dim(bmap->dim, isl_dim_all);
+	off = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (off < 0)
+		return isl_basic_map_free(bmap);
 	pairs = isl_calloc_array(bmap->ctx, int, bmap->n_div);
 	if (!pairs)
 		goto error;
 
+	n_ineq = isl_basic_map_n_inequality(bmap);
+	if (n_ineq < 0)
+		goto error;
 	for (i = 0; i < bmap->n_div; ++i) {
 		int pos, neg;
 		int last_pos, last_neg;
 		int redundant;
 		int defined;
+		isl_bool involves, opp, set_div;
 
 		defined = !isl_int_is_zero(bmap->divi0);
-		for (j = i; j < bmap->n_div; ++j)
-			if (!isl_int_is_zero(bmap->divj1 + 1 + off + i))
-				break;
-		if (j < bmap->n_div)
+		involves = any_div_involves_div(bmap, i);
+		if (involves < 0)
+			goto error;
+		if (involves)
 			continue;
 		for (j = 0; j < bmap->n_eq; ++j)
 			if (!isl_int_is_zero(bmap->eqj1 + off + i))
@@ -3169,15 +5062,39 @@
 				if (!isl_int_is_zero(bmap->ineqj1+off+i))
 					isl_basic_map_drop_inequality(bmap, j);
 			bmap = isl_basic_map_drop_div(bmap, i);
-			free(pairs);
-			return isl_basic_map_drop_redundant_divs(bmap);
+			return drop_redundant_divs_again(bmap, pairs, 0);
 		}
 		if (pairsi != 1)
+			opp = isl_bool_false;
+		else
+			opp = is_opposite(bmap, last_pos, last_neg);
+		if (opp < 0)
+			goto error;
+		if (!opp) {
+			int lower;
+			isl_bool single, one;
+
+			if (pos != 1)
+				continue;
+			single = single_unknown(bmap, last_pos, i);
+			if (single < 0)
+				goto error;
+			if (!single)
+				continue;
+			one = has_coef_one(bmap, i, last_pos);
+			if (one < 0)
+				goto error;
+			if (one)
+				return set_eq_and_try_again(bmap, last_pos,
+							    pairs);
+			lower = lower_bound_is_cst(bmap, i, last_pos);
+			if (lower < 0)
+				goto error;
+			if (lower < n_ineq)
+				return fix_cst_lower(bmap, i, last_pos, lower,
+						pairs);
 			continue;
-		if (!isl_seq_is_neg(bmap->ineqlast_pos + 1,
-				    bmap->ineqlast_neg + 1,
-				    off + bmap->n_div))
-			continue;
+		}
 
 		isl_int_add(bmap->ineqlast_pos0,
 			    bmap->ineqlast_pos0, bmap->ineqlast_neg0);
@@ -3189,28 +5106,21 @@
 			       bmap->ineqlast_pos0, 1);
 		isl_int_sub(bmap->ineqlast_pos0,
 			    bmap->ineqlast_pos0, bmap->ineqlast_neg0);
-		if (!redundant) {
-			if (defined ||
-			    !ok_to_set_div_from_bound(bmap, i, last_pos)) {
-				pairsi = 0;
-				--n;
-				continue;
-			}
+		if (redundant)
+			return drop_div_and_try_again(bmap, i,
+						    last_pos, last_neg, pairs);
+		if (defined)
+			set_div = isl_bool_false;
+		else
+			set_div = ok_to_set_div_from_bound(bmap, i, last_pos);
+		if (set_div < 0)
+			return isl_basic_map_free(bmap);
+		if (set_div) {
 			bmap = set_div_from_lower_bound(bmap, i, last_pos);
-			bmap = isl_basic_map_simplify(bmap);
-			free(pairs);
-			return isl_basic_map_drop_redundant_divs(bmap);
-		}
-		if (last_pos > last_neg) {
-			isl_basic_map_drop_inequality(bmap, last_pos);
-			isl_basic_map_drop_inequality(bmap, last_neg);
-		} else {
-			isl_basic_map_drop_inequality(bmap, last_neg);
-			isl_basic_map_drop_inequality(bmap, last_pos);
+			return drop_redundant_divs_again(bmap, pairs, 1);
 		}
-		bmap = isl_basic_map_drop_div(bmap, i);
-		free(pairs);
-		return isl_basic_map_drop_redundant_divs(bmap);
+		pairsi = 0;
+		--n;
 	}
 
 	if (n > 0)
@@ -3224,33 +5134,411 @@
 	return NULL;
 }
 
-struct isl_basic_set *isl_basic_set_drop_redundant_divs(
-	struct isl_basic_set *bset)
+/* Consider the coefficients at "c" as a row vector and replace
+ * them with their product with "T".  "T" is assumed to be a square matrix.
+ */
+static isl_stat preimage(isl_int *c, __isl_keep isl_mat *T)
 {
-	return (struct isl_basic_set *)
-	    isl_basic_map_drop_redundant_divs((struct isl_basic_map *)bset);
+	isl_size n;
+	isl_ctx *ctx;
+	isl_vec *v;
+
+	n = isl_mat_rows(T);
+	if (n < 0)
+		return isl_stat_error;
+	if (isl_seq_first_non_zero(c, n) == -1)
+		return isl_stat_ok;
+	ctx = isl_mat_get_ctx(T);
+	v = isl_vec_alloc(ctx, n);
+	if (!v)
+		return isl_stat_error;
+	isl_seq_swp_or_cpy(v->el, c, n);
+	v = isl_vec_mat_product(v, isl_mat_copy(T));
+	if (!v)
+		return isl_stat_error;
+	isl_seq_swp_or_cpy(c, v->el, n);
+	isl_vec_free(v);
+
+	return isl_stat_ok;
 }
 
-struct isl_map *isl_map_drop_redundant_divs(struct isl_map *map)
+/* Plug in T for the variables in "bmap" starting at "pos".
+ * T is a linear unimodular matrix, i.e., without constant term.
+ */
+static __isl_give isl_basic_map *isl_basic_map_preimage_vars(
+	__isl_take isl_basic_map *bmap, unsigned pos, __isl_take isl_mat *T)
 {
 	int i;
+	isl_size n_row, n_col;
 
-	if (!map)
-		return NULL;
-	for (i = 0; i < map->n; ++i) {
-		map->pi = isl_basic_map_drop_redundant_divs(map->pi);
-		if (!map->pi)
+	bmap = isl_basic_map_cow(bmap);
+	n_row = isl_mat_rows(T);
+	n_col = isl_mat_cols(T);
+	if (!bmap || n_row < 0 || n_col < 0)
+		goto error;
+
+	if (n_col != n_row)
+		isl_die(isl_mat_get_ctx(T), isl_error_invalid,
+			"expecting square matrix", goto error);
+
+	if (isl_basic_map_check_range(bmap, isl_dim_all, pos, n_col) < 0)
+		goto error;
+
+	for (i = 0; i < bmap->n_eq; ++i)
+		if (preimage(bmap->eqi + 1 + pos, T) < 0)
+			goto error;
+	for (i = 0; i < bmap->n_ineq; ++i)
+		if (preimage(bmap->ineqi + 1 + pos, T) < 0)
+			goto error;
+	for (i = 0; i < bmap->n_div; ++i) {
+		if (isl_basic_map_div_is_marked_unknown(bmap, i))
+			continue;
+		if (preimage(bmap->divi + 1 + 1 + pos, T) < 0)
 			goto error;
 	}
-	ISL_F_CLR(map, ISL_MAP_NORMALIZED);
-	return map;
+
+	isl_mat_free(T);
+	return bmap;
 error:
-	isl_map_free(map);
+	isl_basic_map_free(bmap);
+	isl_mat_free(T);
 	return NULL;
 }
 
-struct isl_set *isl_set_drop_redundant_divs(struct isl_set *set)
+/* Remove divs that are not strictly needed.
+ *
+ * First look for an equality constraint involving two or more
+ * existentially quantified variables without an explicit
+ * representation.  Replace the combination that appears
+ * in the equality constraint by a single existentially quantified
+ * variable such that the equality can be used to derive
+ * an explicit representation for the variable.
+ * If there are no more such equality constraints, then continue
+ * with isl_basic_map_drop_redundant_divs_ineq.
+ *
+ * In particular, if the equality constraint is of the form
+ *
+ *	f(x) + \sum_i c_i a_i = 0
+ *
+ * with a_i existentially quantified variable without explicit
+ * representation, then apply a transformation on the existentially
+ * quantified variables to turn the constraint into
+ *
+ *	f(x) + g a_1' = 0
+ *
+ * with g the gcd of the c_i.
+ * In order to easily identify which existentially quantified variables
+ * have a complete explicit representation, i.e., without being defined
+ * in terms of other existentially quantified variables without
+ * an explicit representation, the existentially quantified variables
+ * are first sorted.
+ *
+ * The variable transformation is computed by extending the row
+ * c_1/g ... c_n/g to a unimodular matrix, obtaining the transformation
+ *
+ *	a_1'   c_1/g ... c_n/g    a_1 
+ *	a_2'                        a_2 
+ *	 ...   =         U             ....
+ *	a_n'            	      a_n 
+ *
+ * with c_1/g ... c_n/g representing the first row of U.
+ * The inverse of U is then plugged into the original constraints.
+ * The call to isl_basic_map_simplify makes sure the explicit
+ * representation for a_1' is extracted from the equality constraint.
+ */
+__isl_give isl_basic_map *isl_basic_map_drop_redundant_divs(
+	__isl_take isl_basic_map *bmap)
+{
+	int first;
+	int i;
+	unsigned o_div;
+	isl_size n_div;
+	int l;
+	isl_ctx *ctx;
+	isl_mat *T;
+
+	if (!bmap)
+		return NULL;
+	if (isl_basic_map_divs_known(bmap))
+		return isl_basic_map_drop_redundant_divs_ineq(bmap);
+	if (bmap->n_eq == 0)
+		return isl_basic_map_drop_redundant_divs_ineq(bmap);
+	bmap = isl_basic_map_sort_divs(bmap);
+	if (!bmap)
+		return NULL;
+
+	first = isl_basic_map_first_unknown_div(bmap);
+	if (first < 0)
+		return isl_basic_map_free(bmap);
+
+	o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_basic_map_free(bmap);
+
+	for (i = 0; i < bmap->n_eq; ++i) {
+		l = isl_seq_first_non_zero(bmap->eqi + o_div + first,
+					    n_div - (first));
+		if (l < 0)
+			continue;
+		l += first;
+		if (isl_seq_first_non_zero(bmap->eqi + o_div + l + 1,
+					    n_div - (l + 1)) == -1)
+			continue;
+		break;
+	}
+	if (i >= bmap->n_eq)
+		return isl_basic_map_drop_redundant_divs_ineq(bmap);
+
+	ctx = isl_basic_map_get_ctx(bmap);
+	T = isl_mat_alloc(ctx, n_div - l, n_div - l);
+	if (!T)
+		return isl_basic_map_free(bmap);
+	isl_seq_cpy(T->row0, bmap->eqi + o_div + l, n_div - l);
+	T = isl_mat_normalize_row(T, 0);
+	T = isl_mat_unimodular_complete(T, 1);
+	T = isl_mat_right_inverse(T);
+
+	for (i = l; i < n_div; ++i)
+		bmap = isl_basic_map_mark_div_unknown(bmap, i);
+	bmap = isl_basic_map_preimage_vars(bmap, o_div - 1 + l, T);
+	bmap = isl_basic_map_simplify(bmap);
+
+	return isl_basic_map_drop_redundant_divs(bmap);
+}
+
+/* Does "bmap" satisfy any equality that involves more than 2 variables
+ * and/or has coefficients different from -1 and 1?
+ */
+static isl_bool has_multiple_var_equality(__isl_keep isl_basic_map *bmap)
+{
+	int i;
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+
+	for (i = 0; i < bmap->n_eq; ++i) {
+		int j, k;
+
+		j = isl_seq_first_non_zero(bmap->eqi + 1, total);
+		if (j < 0)
+			continue;
+		if (!isl_int_is_one(bmap->eqi1 + j) &&
+		    !isl_int_is_negone(bmap->eqi1 + j))
+			return isl_bool_true;
+
+		j += 1;
+		k = isl_seq_first_non_zero(bmap->eqi + 1 + j, total - j);
+		if (k < 0)
+			continue;
+		j += k;
+		if (!isl_int_is_one(bmap->eqi1 + j) &&
+		    !isl_int_is_negone(bmap->eqi1 + j))
+			return isl_bool_true;
+
+		j += 1;
+		k = isl_seq_first_non_zero(bmap->eqi + 1 + j, total - j);
+		if (k >= 0)
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* Remove any common factor g from the constraint coefficients in "v".
+ * The constant term is stored in the first position and is replaced
+ * by floor(c/g).  If any common factor is removed and if this results
+ * in a tightening of the constraint, then set *tightened.
+ */
+static __isl_give isl_vec *normalize_constraint(__isl_take isl_vec *v,
+	int *tightened)
 {
-	return (struct isl_set *)
-	    isl_map_drop_redundant_divs((struct isl_map *)set);
+	isl_ctx *ctx;
+
+	if (!v)
+		return NULL;
+	ctx = isl_vec_get_ctx(v);
+	isl_seq_gcd(v->el + 1, v->size - 1, &ctx->normalize_gcd);
+	if (isl_int_is_zero(ctx->normalize_gcd))
+		return v;
+	if (isl_int_is_one(ctx->normalize_gcd))
+		return v;
+	v = isl_vec_cow(v);
+	if (!v)
+		return NULL;
+	if (tightened && !isl_int_is_divisible_by(v->el0, ctx->normalize_gcd))
+		*tightened = 1;
+	isl_int_fdiv_q(v->el0, v->el0, ctx->normalize_gcd);
+	isl_seq_scale_down(v->el + 1, v->el + 1, ctx->normalize_gcd,
+				v->size - 1);
+	return v;
+}
+
+/* If "bmap" is an integer set that satisfies any equality involving
+ * more than 2 variables and/or has coefficients different from -1 and 1,
+ * then use variable compression to reduce the coefficients by removing
+ * any (hidden) common factor.
+ * In particular, apply the variable compression to each constraint,
+ * factor out any common factor in the non-constant coefficients and
+ * then apply the inverse of the compression.
+ * At the end, we mark the basic map as having reduced constants.
+ * If this flag is still set on the next invocation of this function,
+ * then we skip the computation.
+ *
+ * Removing a common factor may result in a tightening of some of
+ * the constraints.  If this happens, then we may end up with two
+ * opposite inequalities that can be replaced by an equality.
+ * We therefore call isl_basic_map_detect_inequality_pairs,
+ * which checks for such pairs of inequalities as well as eliminate_divs_eq
+ * and isl_basic_map_gauss if such a pair was found.
+ *
+ * Tightening may also result in some other constraints becoming
+ * (rationally) redundant with respect to the tightened constraint
+ * (in combination with other constraints).  The basic map may
+ * therefore no longer be assumed to have no redundant constraints.
+ *
+ * Note that this function may leave the result in an inconsistent state.
+ * In particular, the constraints may not be gaussed.
+ * Unfortunately, isl_map_coalesce actually depends on this inconsistent state
+ * for some of the test cases to pass successfully.
+ * Any potential modification of the representation is therefore only
+ * performed on a single copy of the basic map.
+ */
+__isl_give isl_basic_map *isl_basic_map_reduce_coefficients(
+	__isl_take isl_basic_map *bmap)
+{
+	isl_size total;
+	isl_bool multi;
+	isl_ctx *ctx;
+	isl_vec *v;
+	isl_mat *eq, *T, *T2;
+	int i;
+	int tightened;
+
+	if (!bmap)
+		return NULL;
+	if (ISL_F_ISSET(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS))
+		return bmap;
+	if (isl_basic_map_is_rational(bmap))
+		return bmap;
+	if (bmap->n_eq == 0)
+		return bmap;
+	multi = has_multiple_var_equality(bmap);
+	if (multi < 0)
+		return isl_basic_map_free(bmap);
+	if (!multi)
+		return bmap;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_basic_map_free(bmap);
+	ctx = isl_basic_map_get_ctx(bmap);
+	v = isl_vec_alloc(ctx, 1 + total);
+	if (!v)
+		return isl_basic_map_free(bmap);
+
+	eq = isl_mat_sub_alloc6(ctx, bmap->eq, 0, bmap->n_eq, 0, 1 + total);
+	T = isl_mat_variable_compression(eq, &T2);
+	if (!T || !T2)
+		goto error;
+	if (T->n_col == 0) {
+		isl_mat_free(T);
+		isl_mat_free(T2);
+		isl_vec_free(v);
+		return isl_basic_map_set_to_empty(bmap);
+	}
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		goto error;
+
+	tightened = 0;
+	for (i = 0; i < bmap->n_ineq; ++i) {
+		isl_seq_cpy(v->el, bmap->ineqi, 1 + total);
+		v = isl_vec_mat_product(v, isl_mat_copy(T));
+		v = normalize_constraint(v, &tightened);
+		v = isl_vec_mat_product(v, isl_mat_copy(T2));
+		if (!v)
+			goto error;
+		isl_seq_cpy(bmap->ineqi, v->el, 1 + total);
+	}
+
+	isl_mat_free(T);
+	isl_mat_free(T2);
+	isl_vec_free(v);
+
+	ISL_F_SET(bmap, ISL_BASIC_MAP_REDUCED_COEFFICIENTS);
+
+	if (tightened) {
+		int progress = 0;
+
+		ISL_F_CLR(bmap, ISL_BASIC_MAP_NO_REDUNDANT);
+		bmap = isl_basic_map_detect_inequality_pairs(bmap, &progress);
+		if (progress) {
+			bmap = eliminate_divs_eq(bmap, &progress);
+			bmap = isl_basic_map_gauss(bmap, NULL);
+		}
+	}
+
+	return bmap;
+error:
+	isl_mat_free(T);
+	isl_mat_free(T2);
+	isl_vec_free(v);
+	return isl_basic_map_free(bmap);
+}
+
+/* Shift the integer division at position "div" of "bmap"
+ * by "shift" times the variable at position "pos".
+ * "pos" is as determined by isl_basic_map_offset, i.e., pos == 0
+ * corresponds to the constant term.
+ *
+ * That is, if the integer division has the form
+ *
+ *	floor(f(x)/d)
+ *
+ * then replace it by
+ *
+ *	floor((f(x) + shift * d * x_pos)/d) - shift * x_pos
+ */
+__isl_give isl_basic_map *isl_basic_map_shift_div(
+	__isl_take isl_basic_map *bmap, int div, int pos, isl_int shift)
+{
+	int i;
+	isl_size total, n_div;
+
+	if (isl_int_is_zero(shift))
+		return bmap;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	total -= n_div;
+	if (total < 0 || n_div < 0)
+		return isl_basic_map_free(bmap);
+
+	isl_int_addmul(bmap->divdiv1 + pos, shift, bmap->divdiv0);
+
+	for (i = 0; i < bmap->n_eq; ++i) {
+		if (isl_int_is_zero(bmap->eqi1 + total + div))
+			continue;
+		isl_int_submul(bmap->eqipos,
+				shift, bmap->eqi1 + total + div);
+	}
+	for (i = 0; i < bmap->n_ineq; ++i) {
+		if (isl_int_is_zero(bmap->ineqi1 + total + div))
+			continue;
+		isl_int_submul(bmap->ineqipos,
+				shift, bmap->ineqi1 + total + div);
+	}
+	for (i = 0; i < bmap->n_div; ++i) {
+		if (isl_int_is_zero(bmap->divi0))
+			continue;
+		if (isl_int_is_zero(bmap->divi1 + 1 + total + div))
+			continue;
+		isl_int_submul(bmap->divi1 + pos,
+				shift, bmap->divi1 + 1 + total + div);
+	}
+
+	return bmap;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_map_subtract.c -> _service:tar_scm:isl-0.24.tar.gz/isl_map_subtract.c Changed

@@ -15,6 +15,9 @@
 #include <isl_point_private.h>
 #include <isl_vec_private.h>
 
+#include <set_to_map.c>
+#include <set_from_map.c>
+
 /* Expand the constraint "c" into "v".  The initial "dim" dimensions
  * are the same, but "v" may have more divs than "c" and the divs of "c"
  * may appear in different positions in "v".
@@ -43,35 +46,39 @@
 /* Add all constraints of bmap to tab.  The equalities of bmap
  * are added as a pair of inequalities.
  */
-static int tab_add_constraints(struct isl_tab *tab,
+static isl_stat tab_add_constraints(struct isl_tab *tab,
 	__isl_keep isl_basic_map *bmap, int *div_map)
 {
 	int i;
 	unsigned dim;
-	unsigned tab_total;
-	unsigned bmap_total;
+	isl_size tab_total;
+	isl_size bmap_n_div;
+	isl_size bmap_total;
 	isl_vec *v;
 
 	if (!tab || !bmap)
-		return -1;
+		return isl_stat_error;
 
-	tab_total = isl_basic_map_total_dim(tab->bmap);
-	bmap_total = isl_basic_map_total_dim(bmap);
-	dim = isl_space_dim(tab->bmap->dim, isl_dim_all);
+	tab_total = isl_basic_map_dim(tab->bmap, isl_dim_all);
+	bmap_total = isl_basic_map_dim(bmap, isl_dim_all);
+	bmap_n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	dim = bmap_total - bmap_n_div;
+	if (tab_total < 0 || bmap_total < 0 || bmap_n_div < 0)
+		return isl_stat_error;
 
 	if (isl_tab_extend_cons(tab, 2 * bmap->n_eq + bmap->n_ineq) < 0)
-		return -1;
+		return isl_stat_error;
 
 	v = isl_vec_alloc(bmap->ctx, 1 + tab_total);
 	if (!v)
-		return -1;
+		return isl_stat_error;
 
 	for (i = 0; i < bmap->n_eq; ++i) {
-		expand_constraint(v, dim, bmap->eqi, div_map, bmap->n_div);
+		expand_constraint(v, dim, bmap->eqi, div_map, bmap_n_div);
 		if (isl_tab_add_ineq(tab, v->el) < 0)
 			goto error;
 		isl_seq_neg(bmap->eqi, bmap->eqi, 1 + bmap_total);
-		expand_constraint(v, dim, bmap->eqi, div_map, bmap->n_div);
+		expand_constraint(v, dim, bmap->eqi, div_map, bmap_n_div);
 		if (isl_tab_add_ineq(tab, v->el) < 0)
 			goto error;
 		isl_seq_neg(bmap->eqi, bmap->eqi, 1 + bmap_total);
@@ -80,7 +87,7 @@
 	}
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
-		expand_constraint(v, dim, bmap->ineqi, div_map, bmap->n_div);
+		expand_constraint(v, dim, bmap->ineqi, div_map, bmap_n_div);
 		if (isl_tab_add_ineq(tab, v->el) < 0)
 			goto error;
 		if (tab->empty)
@@ -88,36 +95,44 @@
 	}
 
 	isl_vec_free(v);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_vec_free(v);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Add a specific constraint of bmap (or its opposite) to tab.
  * The position of the constraint is specified by "c", where
  * the equalities of bmap are counted twice, once for the inequality
  * that is equal to the equality, and once for its negation.
+ *
+ * Each of these constraints has been added to "tab" before by
+ * tab_add_constraints (and later removed again), so there should
+ * already be a row available for the constraint.
  */
-static int tab_add_constraint(struct isl_tab *tab,
+static isl_stat tab_add_constraint(struct isl_tab *tab,
 	__isl_keep isl_basic_map *bmap, int *div_map, int c, int oppose)
 {
 	unsigned dim;
-	unsigned tab_total;
-	unsigned bmap_total;
+	isl_size tab_total;
+	isl_size bmap_n_div;
+	isl_size bmap_total;
 	isl_vec *v;
-	int r;
+	isl_stat r;
 
 	if (!tab || !bmap)
-		return -1;
+		return isl_stat_error;
 
-	tab_total = isl_basic_map_total_dim(tab->bmap);
-	bmap_total = isl_basic_map_total_dim(bmap);
-	dim = isl_space_dim(tab->bmap->dim, isl_dim_all);
+	tab_total = isl_basic_map_dim(tab->bmap, isl_dim_all);
+	bmap_total = isl_basic_map_dim(bmap, isl_dim_all);
+	bmap_n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	dim = bmap_total - bmap_n_div;
+	if (tab_total < 0 || bmap_total < 0 || bmap_n_div < 0)
+		return isl_stat_error;
 
 	v = isl_vec_alloc(bmap->ctx, 1 + tab_total);
 	if (!v)
-		return -1;
+		return isl_stat_error;
 
 	if (c < 2 * bmap->n_eq) {
 		if ((c % 2) != oppose)
@@ -125,7 +140,7 @@
 					1 + bmap_total);
 		if (oppose)
 			isl_int_sub_ui(bmap->eqc/20, bmap->eqc/20, 1);
-		expand_constraint(v, dim, bmap->eqc/2, div_map, bmap->n_div);
+		expand_constraint(v, dim, bmap->eqc/2, div_map, bmap_n_div);
 		r = isl_tab_add_ineq(tab, v->el);
 		if (oppose)
 			isl_int_add_ui(bmap->eqc/20, bmap->eqc/20, 1);
@@ -139,7 +154,7 @@
 					1 + bmap_total);
 			isl_int_sub_ui(bmap->ineqc0, bmap->ineqc0, 1);
 		}
-		expand_constraint(v, dim, bmap->ineqc, div_map, bmap->n_div);
+		expand_constraint(v, dim, bmap->ineqc, div_map, bmap_n_div);
 		r = isl_tab_add_ineq(tab, v->el);
 		if (oppose) {
 			isl_int_add_ui(bmap->ineqc0, bmap->ineqc0, 1);
@@ -152,35 +167,38 @@
 	return r;
 }
 
-static int tab_add_divs(struct isl_tab *tab, __isl_keep isl_basic_map *bmap,
-	int **div_map)
+static isl_stat tab_add_divs(struct isl_tab *tab,
+	__isl_keep isl_basic_map *bmap, int **div_map)
 {
 	int i, j;
 	struct isl_vec *vec;
-	unsigned total;
+	isl_size total;
 	unsigned dim;
 
 	if (!bmap)
-		return -1;
+		return isl_stat_error;
 	if (!bmap->n_div)
-		return 0;
+		return isl_stat_ok;
 
 	if (!*div_map)
 		*div_map = isl_alloc_array(bmap->ctx, int, bmap->n_div);
 	if (!*div_map)
-		return -1;
+		return isl_stat_error;
 
-	total = isl_basic_map_total_dim(tab->bmap);
+	total = isl_basic_map_dim(tab->bmap, isl_dim_all);
+	if (total < 0)
+		return isl_stat_error;
 	dim = total - tab->bmap->n_div;
 	vec = isl_vec_alloc(bmap->ctx, 2 + total + bmap->n_div);
 	if (!vec)
-		return -1;
+		return isl_stat_error;
 
 	for (i = 0; i < bmap->n_div; ++i) {
 		isl_seq_cpy(vec->el, bmap->divi, 2 + dim);
 		isl_seq_clr(vec->el + 2 + dim, tab->bmap->n_div);
 		for (j = 0; j < i; ++j)
-			isl_int_set(vec->el2 + dim + (*div_map)j,
+			isl_int_add(vec->el2 + dim + (*div_map)j,
+				    vec->el2 + dim + (*div_map)j,
 					bmap->divi2 + dim + j);
 		for (j = 0; j < tab->bmap->n_div; ++j)
 			if (isl_seq_eq(tab->bmap->divj,
@@ -189,18 +207,18 @@
 		(*div_map)i = j;
 		if (j == tab->bmap->n_div) {
 			vec->size = 2 + dim + tab->bmap->n_div;
-			if (isl_tab_add_div(tab, vec, NULL, NULL) < 0)
+			if (isl_tab_add_div(tab, vec) < 0)
 				goto error;
 		}
 	}
 
 	isl_vec_free(vec);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_vec_free(vec);
 
-	return -1;
+	return isl_stat_error;
 }
 
 /* Freeze all constraints of tableau tab.
@@ -254,7 +272,7 @@
  * return a negative value.
  */
 struct isl_diff_collector {
-	int (*add)(struct isl_diff_collector *dc,
+	isl_stat (*add)(struct isl_diff_collector *dc,
 		    __isl_take isl_basic_map *bmap);
 };
 
@@ -287,14 +305,14 @@
  * has been removed when we end up in a leaf, we simply pass along
  * the original basic map.
  */
-static int basic_map_collect_diff(__isl_take isl_basic_map *bmap,
+static isl_stat basic_map_collect_diff(__isl_take isl_basic_map *bmap,
 	__isl_take isl_map *map, struct isl_diff_collector *dc)
 {
 	int i;
 	int modified;
 	int level;
 	int init;
-	int empty;
+	isl_bool empty;
 	isl_ctx *ctx;
 	struct isl_tab *tab = NULL;
 	struct isl_tab_undo **snap = NULL;
@@ -307,7 +325,7 @@
 	if (empty) {
 		isl_basic_map_free(bmap);
 		isl_map_free(map);
-		return empty < 0 ? -1 : 0;
+		return empty < 0 ? isl_stat_error : isl_stat_ok;
 	}
 
 	bmap = isl_basic_map_cow(bmap);
@@ -437,7 +455,7 @@
 	isl_basic_map_free(bmap);
 	isl_map_free(map);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_tab_free(tab);
 	free(snap);
@@ -451,7 +469,7 @@
 	free(div_map);
 	isl_basic_map_free(bmap);
 	isl_map_free(map);
-	return -1;
+	return isl_stat_error;
 }
 
 /* A diff collector that actually collects all parts of the
@@ -464,7 +482,7 @@
 
 /* isl_subtract_diff_collector callback.
  */
-static int basic_map_subtract_add(struct isl_diff_collector *dc,
+static isl_stat basic_map_subtract_add(struct isl_diff_collector *dc,
 			    __isl_take isl_basic_map *bmap)
 {
 	struct isl_subtract_diff_collector *sdc;
@@ -473,7 +491,7 @@
 	sdc->diff = isl_map_union_disjoint(sdc->diff,
 			isl_map_from_basic_map(bmap));
 
-	return sdc->diff ? 0 : -1;
+	return sdc->diff ? isl_stat_ok : isl_stat_error;
 }
 
 /* Return the set difference between bmap and map.
@@ -483,7 +501,7 @@
 {
 	struct isl_subtract_diff_collector sdc;
 	sdc.dc.add = &basic_map_subtract_add;
-	sdc.diff = isl_map_empty_like_basic_map(bmap);
+	sdc.diff = isl_map_empty(isl_basic_map_get_space(bmap));
 	if (basic_map_collect_diff(bmap, map, &sdc.dc) < 0) {
 		isl_map_free(sdc.diff);
 		sdc.diff = NULL;
@@ -491,22 +509,44 @@
 	return sdc.diff;
 }
 
+/* Return an empty map living in the same space as "map1" and "map2".
+ */
+static __isl_give isl_map *replace_pair_by_empty( __isl_take isl_map *map1,
+	__isl_take isl_map *map2)
+{
+	isl_space *space;
+
+	space = isl_map_get_space(map1);
+	isl_map_free(map1);
+	isl_map_free(map2);
+	return isl_map_empty(space);
+}
+
 /* Return the set difference between map1 and map2.
  * (U_i A_i) \ (U_j B_j) is computed as U_i (A_i \ (U_j B_j))
  *
+ * If "map1" and "map2" are obviously equal to each other,
+ * then return an empty map in the same space.
+ *
  * If "map1" and "map2" are disjoint, then simply return "map1".
  */
-static __isl_give isl_map *map_subtract( __isl_take isl_map *map1,
+__isl_give isl_map *isl_map_subtract( __isl_take isl_map *map1,
 	__isl_take isl_map *map2)
 {
 	int i;
-	int disjoint;
+	int equal, disjoint;
 	struct isl_map *diff;
 
-	if (!map1 || !map2)
+	if (isl_map_align_params_bin(&map1, &map2) < 0)
+		goto error;
+	if (isl_map_check_equal_space(map1, map2) < 0)
 		goto error;
 
-	isl_assert(map1->ctx, isl_space_is_equal(map1->dim, map2->dim), goto error);
+	equal = isl_map_plain_is_equal(map1, map2);
+	if (equal < 0)
+		goto error;
+	if (equal)
+		return replace_pair_by_empty(map1, map2);
 
 	disjoint = isl_map_is_disjoint(map1, map2);
 	if (disjoint < 0)
@@ -524,7 +564,7 @@
 	map1 = isl_map_remove_empty_parts(map1);
 	map2 = isl_map_remove_empty_parts(map2);
 
-	diff = isl_map_empty_like(map1);
+	diff = isl_map_empty(isl_map_get_space(map1));
 	for (i = 0; i < map1->n; ++i) {
 		struct isl_map *d;
 		d = basic_map_subtract(isl_basic_map_copy(map1->pi),
@@ -545,27 +585,26 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_subtract( __isl_take isl_map *map1,
-	__isl_take isl_map *map2)
-{
-	return isl_map_align_params_map_map_and(map1, map2, &map_subtract);
-}
-
-struct isl_set *isl_set_subtract(struct isl_set *set1, struct isl_set *set2)
+__isl_give isl_set *isl_set_subtract(__isl_take isl_set *set1,
+	__isl_take isl_set *set2)
 {
-	return (struct isl_set *)
-		isl_map_subtract(
-			(struct isl_map *)set1, (struct isl_map *)set2);
+	return set_from_map(isl_map_subtract(set_to_map(set1),
+					    set_to_map(set2)));
 }
 
 /* Remove the elements of "dom" from the domain of "map".
  */
-static __isl_give isl_map *map_subtract_domain(__isl_take isl_map *map,
+__isl_give isl_map *isl_map_subtract_domain(__isl_take isl_map *map,
 	__isl_take isl_set *dom)
 {
+	isl_bool ok;
 	isl_map *ext_dom;
 
-	if (!isl_map_compatible_domain(map, dom))
+	isl_map_align_params_set(&map, &dom);
+	ok = isl_map_compatible_domain(map, dom);
+	if (ok < 0)
+		goto error;
+	if (!ok)
 		isl_die(isl_set_get_ctx(dom), isl_error_invalid,
 			"incompatible spaces", goto error);
 	
@@ -578,20 +617,19 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_subtract_domain(__isl_take isl_map *map,
-	__isl_take isl_set *dom)
-{
-	return isl_map_align_params_map_map_and(map, dom, &map_subtract_domain);
-}
-
 /* Remove the elements of "dom" from the range of "map".
  */
-static __isl_give isl_map *map_subtract_range(__isl_take isl_map *map,
+__isl_give isl_map *isl_map_subtract_range(__isl_take isl_map *map,
 	__isl_take isl_set *dom)
 {
+	isl_bool ok;
 	isl_map *ext_dom;
 
-	if (!isl_map_compatible_range(map, dom))
+	isl_map_align_params_set(&map, &dom);
+	ok = isl_map_compatible_range(map, dom);
+	if (ok < 0)
+		goto error;
+	if (!ok)
 		isl_die(isl_set_get_ctx(dom), isl_error_invalid,
 			"incompatible spaces", goto error);
 	
@@ -604,67 +642,63 @@
 	return NULL;
 }
 
-__isl_give isl_map *isl_map_subtract_range(__isl_take isl_map *map,
-	__isl_take isl_set *dom)
-{
-	return isl_map_align_params_map_map_and(map, dom, &map_subtract_range);
-}
-
 /* A diff collector that aborts as soon as its add function is called,
  * setting empty to 0.
  */
 struct isl_is_empty_diff_collector {
 	struct isl_diff_collector dc;
-	int empty;
+	isl_bool empty;
 };
 
 /* isl_is_empty_diff_collector callback.
  */
-static int basic_map_is_empty_add(struct isl_diff_collector *dc,
+static isl_stat basic_map_is_empty_add(struct isl_diff_collector *dc,
 			    __isl_take isl_basic_map *bmap)
 {
 	struct isl_is_empty_diff_collector *edc;
 	edc = (struct isl_is_empty_diff_collector *)dc;
 
-	edc->empty = 0;
+	edc->empty = isl_bool_false;
 
 	isl_basic_map_free(bmap);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Check if bmap \ map is empty by computing this set difference
  * and breaking off as soon as the difference is known to be non-empty.
  */
-static int basic_map_diff_is_empty(__isl_keep isl_basic_map *bmap,
+static isl_bool basic_map_diff_is_empty(__isl_keep isl_basic_map *bmap,
 	__isl_keep isl_map *map)
 {
-	int r;
+	isl_bool empty;
+	isl_stat r;
 	struct isl_is_empty_diff_collector edc;
 
-	r = isl_basic_map_plain_is_empty(bmap);
-	if (r)
-		return r;
+	empty = isl_basic_map_plain_is_empty(bmap);
+	if (empty)
+		return empty;
 
 	edc.dc.add = &basic_map_is_empty_add;
-	edc.empty = 1;
+	edc.empty = isl_bool_true;
 	r = basic_map_collect_diff(isl_basic_map_copy(bmap),
 				   isl_map_copy(map), &edc.dc);
 	if (!edc.empty)
-		return 0;
+		return isl_bool_false;
 
-	return r < 0 ? -1 : 1;
+	return r < 0 ? isl_bool_error : isl_bool_true;
 }
 
 /* Check if map1 \ map2 is empty by checking if the set difference is empty
  * for each of the basic maps in map1.
  */
-static int map_diff_is_empty(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+static isl_bool map_diff_is_empty(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
 {
 	int i;
-	int is_empty = 1;
+	isl_bool is_empty = isl_bool_true;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 	
 	for (i = 0; i < map1->n; ++i) {
 		is_empty = basic_map_diff_is_empty(map1->pi, map2);
@@ -675,27 +709,32 @@
 	return is_empty;
 }
 
-/* Return 1 if "bmap" contains a single element.
+/* Return true if "bmap" contains a single element.
  */
-int isl_basic_map_plain_is_singleton(__isl_keep isl_basic_map *bmap)
+isl_bool isl_basic_map_plain_is_singleton(__isl_keep isl_basic_map *bmap)
 {
+	isl_size total;
+
 	if (!bmap)
-		return -1;
+		return isl_bool_error;
 	if (bmap->n_div)
-		return 0;
+		return isl_bool_false;
 	if (bmap->n_ineq)
-		return 0;
-	return bmap->n_eq == isl_basic_map_total_dim(bmap);
+		return isl_bool_false;
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
+	return bmap->n_eq == total;
 }
 
-/* Return 1 if "map" contains a single element.
+/* Return true if "map" contains a single element.
  */
-int isl_map_plain_is_singleton(__isl_keep isl_map *map)
+isl_bool isl_map_plain_is_singleton(__isl_keep isl_map *map)
 {
 	if (!map)
-		return -1;
+		return isl_bool_error;
 	if (map->n != 1)
-		return 0;
+		return isl_bool_false;
 
 	return isl_basic_map_plain_is_singleton(map->p0);
 }
@@ -707,14 +746,14 @@
 	__isl_keep isl_basic_map *bmap)
 {
 	int j;
-	unsigned dim;
+	isl_size dim;
 	struct isl_vec *point;
 	isl_int m;
 
-	if (!bmap)
+	dim = isl_basic_map_dim(bmap, isl_dim_all);
+	if (dim < 0)
 		return NULL;
 
-	dim = isl_basic_map_total_dim(bmap);
 	isl_assert(bmap->ctx, bmap->n_eq == dim, return NULL);
 	point = isl_vec_alloc(bmap->ctx, 1 + dim);
 	if (!point)
@@ -753,25 +792,27 @@
 	return NULL;
 }
 
-/* Return 1 is the singleton map "map1" is a subset of "map2",
+/* Return isl_bool_true if the singleton map "map1" is a subset of "map2",
  * i.e., if the single element of "map1" is also an element of "map2".
  * Assumes "map2" has known divs.
  */
-static int map_is_singleton_subset(__isl_keep isl_map *map1,
+static isl_bool map_is_singleton_subset(__isl_keep isl_map *map1,
 	__isl_keep isl_map *map2)
 {
 	int i;
-	int is_subset = 0;
+	isl_bool is_subset = isl_bool_false;
 	struct isl_point *point;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 	if (map1->n != 1)
-		return -1;
+		isl_die(isl_map_get_ctx(map1), isl_error_invalid,
+			"expecting single-disjunct input",
+			return isl_bool_error);
 
 	point = singleton_extract_point(map1->p0);
 	if (!point)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map2->n; ++i) {
 		is_subset = isl_basic_map_contains_point(map2->pi, point);
@@ -783,42 +824,46 @@
 	return is_subset;
 }
 
-static int map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+static isl_bool map_is_subset(__isl_keep isl_map *map1,
+	__isl_keep isl_map *map2)
 {
-	int is_subset = 0;
-	int empty;
-	int rat1, rat2;
+	isl_bool is_subset = isl_bool_false;
+	isl_bool empty, single;
+	isl_bool rat1, rat2;
 
 	if (!map1 || !map2)
-		return -1;
+		return isl_bool_error;
 
 	if (!isl_map_has_equal_space(map1, map2))
-		return 0;
+		return isl_bool_false;
 
 	empty = isl_map_is_empty(map1);
 	if (empty < 0)
-		return -1;
+		return isl_bool_error;
 	if (empty)
-		return 1;
+		return isl_bool_true;
 
 	empty = isl_map_is_empty(map2);
 	if (empty < 0)
-		return -1;
+		return isl_bool_error;
 	if (empty)
-		return 0;
+		return isl_bool_false;
 
 	rat1 = isl_map_has_rational(map1);
 	rat2 = isl_map_has_rational(map2);
 	if (rat1 < 0 || rat2 < 0)
-		return -1;
+		return isl_bool_error;
 	if (rat1 && !rat2)
-		return 0;
+		return isl_bool_false;
 
 	if (isl_map_plain_is_universe(map2))
-		return 1;
+		return isl_bool_true;
 
+	single = isl_map_plain_is_singleton(map1);
+	if (single < 0)
+		return isl_bool_error;
 	map2 = isl_map_compute_divs(isl_map_copy(map2));
-	if (isl_map_plain_is_singleton(map1)) {
+	if (single) {
 		is_subset = map_is_singleton_subset(map1, map2);
 		isl_map_free(map2);
 		return is_subset;
@@ -829,16 +874,15 @@
 	return is_subset;
 }
 
-int isl_map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
+isl_bool isl_map_is_subset(__isl_keep isl_map *map1, __isl_keep isl_map *map2)
 {
 	return isl_map_align_params_map_map_and_test(map1, map2,
 							&map_is_subset);
 }
 
-int isl_set_is_subset(struct isl_set *set1, struct isl_set *set2)
+isl_bool isl_set_is_subset(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
 {
-	return isl_map_is_subset(
-			(struct isl_map *)set1, (struct isl_map *)set2);
+	return isl_map_is_subset(set_to_map(set1), set_to_map(set2));
 }
 
 __isl_give isl_map *isl_map_make_disjoint(__isl_take isl_map *map)
@@ -879,7 +923,7 @@
 
 __isl_give isl_set *isl_set_make_disjoint(__isl_take isl_set *set)
 {
-	return (struct isl_set *)isl_map_make_disjoint((struct isl_map *)set);
+	return set_from_map(isl_map_make_disjoint(set_to_map(set)));
 }
 
 __isl_give isl_map *isl_map_complement(__isl_take isl_map *map)

_service:tar_scm:isl-0.14.tar.xz/isl_map_to_basic_set.c -> _service:tar_scm:isl-0.24.tar.gz/isl_map_to_basic_set.c Changed

_service:tar_scm:isl-0.14.tar.xz/isl_mat.c -> _service:tar_scm:isl-0.24.tar.gz/isl_mat.c Changed

@@ -1,11 +1,15 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
+ * Copyright 2010      INRIA Saclay
  * Copyright 2014      Ecole Normale Superieure
+ * Copyright 2017      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege, K.U.Leuven, Departement
  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
+ * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
+ * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
  * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
  */
 
@@ -17,14 +21,36 @@
 #include <isl_vec_private.h>
 #include <isl_space_private.h>
 #include <isl_val_private.h>
-#include <isl/deprecated/mat_int.h>
 
 isl_ctx *isl_mat_get_ctx(__isl_keep isl_mat *mat)
 {
 	return mat ? mat->ctx : NULL;
 }
 
-struct isl_mat *isl_mat_alloc(struct isl_ctx *ctx,
+/* Return a hash value that digests "mat".
+ */
+uint32_t isl_mat_get_hash(__isl_keep isl_mat *mat)
+{
+	int i;
+	uint32_t hash;
+
+	if (!mat)
+		return 0;
+
+	hash = isl_hash_init();
+	isl_hash_byte(hash, mat->n_row & 0xFF);
+	isl_hash_byte(hash, mat->n_col & 0xFF);
+	for (i = 0; i < mat->n_row; ++i) {
+		uint32_t row_hash;
+
+		row_hash = isl_seq_get_hash(mat->rowi, mat->n_col);
+		isl_hash_hash(hash, row_hash);
+	}
+
+	return hash;
+}
+
+__isl_give isl_mat *isl_mat_alloc(isl_ctx *ctx,
 	unsigned n_row, unsigned n_col)
 {
 	int i;
@@ -38,12 +64,14 @@
 	mat->block = isl_blk_alloc(ctx, n_row * n_col);
 	if (isl_blk_is_error(mat->block))
 		goto error;
-	mat->row = isl_alloc_array(ctx, isl_int *, n_row);
+	mat->row = isl_calloc_array(ctx, isl_int *, n_row);
 	if (n_row && !mat->row)
 		goto error;
 
-	for (i = 0; i < n_row; ++i)
-		mat->rowi = mat->block.data + i * n_col;
+	if (n_col != 0) {
+		for (i = 0; i < n_row; ++i)
+			mat->rowi = mat->block.data + i * n_col;
+	}
 
 	mat->ctx = ctx;
 	isl_ctx_ref(ctx);
@@ -60,7 +88,7 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_extend(struct isl_mat *mat,
+__isl_give isl_mat *isl_mat_extend(__isl_take isl_mat *mat,
 	unsigned n_row, unsigned n_col)
 {
 	int i;
@@ -171,7 +199,7 @@
 		isl_seq_neg(dsti+dst_col, srci+src_col, n_col);
 }
 
-struct isl_mat *isl_mat_copy(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_copy(__isl_keep isl_mat *mat)
 {
 	if (!mat)
 		return NULL;
@@ -180,7 +208,7 @@
 	return mat;
 }
 
-struct isl_mat *isl_mat_dup(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_dup(__isl_keep isl_mat *mat)
 {
 	int i;
 	struct isl_mat *mat2;
@@ -195,7 +223,7 @@
 	return mat2;
 }
 
-struct isl_mat *isl_mat_cow(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_cow(__isl_take isl_mat *mat)
 {
 	struct isl_mat *mat2;
 	if (!mat)
@@ -226,26 +254,74 @@
 	return NULL;
 }
 
-int isl_mat_rows(__isl_keep isl_mat *mat)
+isl_size isl_mat_rows(__isl_keep isl_mat *mat)
 {
-	return mat ? mat->n_row : -1;
+	return mat ? mat->n_row : isl_size_error;
 }
 
-int isl_mat_cols(__isl_keep isl_mat *mat)
+isl_size isl_mat_cols(__isl_keep isl_mat *mat)
 {
-	return mat ? mat->n_col : -1;
+	return mat ? mat->n_col : isl_size_error;
 }
 
-int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v)
+/* Check that "col" is a valid column position for "mat".
+ */
+static isl_stat check_col(__isl_keep isl_mat *mat, int col)
 {
 	if (!mat)
-		return -1;
-	if (row < 0 || row >= mat->n_row)
-		isl_die(mat->ctx, isl_error_invalid, "row out of range",
-			return -1);
+		return isl_stat_error;
 	if (col < 0 || col >= mat->n_col)
-		isl_die(mat->ctx, isl_error_invalid, "column out of range",
-			return -1);
+		isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
+			"column out of range", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that "row" is a valid row position for "mat".
+ */
+static isl_stat check_row(__isl_keep isl_mat *mat, int row)
+{
+	if (!mat)
+		return isl_stat_error;
+	if (row < 0 || row >= mat->n_row)
+		isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
+			"row out of range", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that there are "n" columns starting at position "first" in "mat".
+ */
+static isl_stat check_col_range(__isl_keep isl_mat *mat, unsigned first,
+	unsigned n)
+{
+	if (!mat)
+		return isl_stat_error;
+	if (first + n > mat->n_col || first + n < first)
+		isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
+			"column position or range out of bounds",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that there are "n" rows starting at position "first" in "mat".
+ */
+static isl_stat check_row_range(__isl_keep isl_mat *mat, unsigned first,
+	unsigned n)
+{
+	if (!mat)
+		return isl_stat_error;
+	if (first + n > mat->n_row || first + n < first)
+		isl_die(isl_mat_get_ctx(mat), isl_error_invalid,
+			"row position or range out of bounds",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v)
+{
+	if (check_row(mat, row) < 0)
+		return -1;
+	if (check_col(mat, col) < 0)
+		return -1;
 	isl_int_set(*v, mat->rowrowcol);
 	return 0;
 }
@@ -257,15 +333,11 @@
 {
 	isl_ctx *ctx;
 
-	if (!mat)
+	if (check_row(mat, row) < 0)
+		return NULL;
+	if (check_col(mat, col) < 0)
 		return NULL;
 	ctx = isl_mat_get_ctx(mat);
-	if (row < 0 || row >= mat->n_row)
-		isl_die(ctx, isl_error_invalid, "row out of range",
-			return NULL);
-	if (col < 0 || col >= mat->n_col)
-		isl_die(ctx, isl_error_invalid, "column out of range",
-			return NULL);
 	return isl_val_int_from_isl_int(ctx, mat->rowrowcol);
 }
 
@@ -273,38 +345,24 @@
 	int row, int col, isl_int v)
 {
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
-	if (row < 0 || row >= mat->n_row)
-		isl_die(mat->ctx, isl_error_invalid, "row out of range",
-			goto error);
-	if (col < 0 || col >= mat->n_col)
-		isl_die(mat->ctx, isl_error_invalid, "column out of range",
-			goto error);
+	if (check_row(mat, row) < 0)
+		return isl_mat_free(mat);
+	if (check_col(mat, col) < 0)
+		return isl_mat_free(mat);
 	isl_int_set(mat->rowrowcol, v);
 	return mat;
-error:
-	isl_mat_free(mat);
-	return NULL;
 }
 
 __isl_give isl_mat *isl_mat_set_element_si(__isl_take isl_mat *mat,
 	int row, int col, int v)
 {
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
-	if (row < 0 || row >= mat->n_row)
-		isl_die(mat->ctx, isl_error_invalid, "row out of range",
-			goto error);
-	if (col < 0 || col >= mat->n_col)
-		isl_die(mat->ctx, isl_error_invalid, "column out of range",
-			goto error);
+	if (check_row(mat, row) < 0)
+		return isl_mat_free(mat);
+	if (check_col(mat, col) < 0)
+		return isl_mat_free(mat);
 	isl_int_set_si(mat->rowrowcol, v);
 	return mat;
-error:
-	isl_mat_free(mat);
-	return NULL;
 }
 
 /* Replace the element at row "row", column "col" of "mat" by "v".
@@ -342,6 +400,22 @@
 	return mat;
 }
 
+/* Create an "n_row" by "n_col" matrix with zero elements.
+ */
+__isl_give isl_mat *isl_mat_zero(isl_ctx *ctx, unsigned n_row, unsigned n_col)
+{
+	int i;
+	isl_mat *mat;
+
+	mat = isl_mat_alloc(ctx, n_row, n_col);
+	if (!mat)
+		return NULL;
+	for (i = 0; i < n_row; ++i)
+		isl_seq_clr(mat->rowi, n_col);
+
+	return mat;
+}
+
 __isl_give isl_mat *isl_mat_identity(isl_ctx *ctx, unsigned n_row)
 {
 	if (!ctx)
@@ -351,29 +425,30 @@
 
 /* Is "mat" a (possibly scaled) identity matrix?
  */
-int isl_mat_is_scaled_identity(__isl_keep isl_mat *mat)
+isl_bool isl_mat_is_scaled_identity(__isl_keep isl_mat *mat)
 {
 	int i;
 
 	if (!mat)
-		return -1;
+		return isl_bool_error;
 	if (mat->n_row != mat->n_col)
-		return 0;
+		return isl_bool_false;
 
 	for (i = 0; i < mat->n_row; ++i) {
 		if (isl_seq_first_non_zero(mat->rowi, i) != -1)
-			return 0;
+			return isl_bool_false;
 		if (isl_int_ne(mat->row00, mat->rowii))
-			return 0;
+			return isl_bool_false;
 		if (isl_seq_first_non_zero(mat->rowi + i + 1,
 					    mat->n_col - (i + 1)) != -1)
-			return 0;
+			return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-struct isl_vec *isl_mat_vec_product(struct isl_mat *mat, struct isl_vec *vec)
+__isl_give isl_vec *isl_mat_vec_product(__isl_take isl_mat *mat,
+	__isl_take isl_vec *vec)
 {
 	int i;
 	struct isl_vec *prod;
@@ -428,7 +503,8 @@
 	return NULL;
 }
 
-struct isl_vec *isl_vec_mat_product(struct isl_vec *vec, struct isl_mat *mat)
+__isl_give isl_vec *isl_vec_mat_product(__isl_take isl_vec *vec,
+	__isl_take isl_mat *mat)
 {
 	int i, j;
 	struct isl_vec *prod;
@@ -456,8 +532,8 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_aff_direct_sum(struct isl_mat *left,
-	struct isl_mat *right)
+__isl_give isl_mat *isl_mat_aff_direct_sum(__isl_take isl_mat *left,
+	__isl_take isl_mat *right)
 {
 	int i;
 	struct isl_mat *sum;
@@ -506,8 +582,8 @@
 	return NULL;
 }
 
-static void exchange(struct isl_mat *M, struct isl_mat **U,
-	struct isl_mat **Q, unsigned row, unsigned i, unsigned j)
+static void exchange(__isl_keep isl_mat *M, __isl_keep isl_mat **U,
+	__isl_keep isl_mat **Q, unsigned row, unsigned i, unsigned j)
 {
 	int r;
 	for (r = row; r < M->n_row; ++r)
@@ -520,8 +596,8 @@
 		isl_mat_swap_rows(*Q, i, j);
 }
 
-static void subtract(struct isl_mat *M, struct isl_mat **U,
-	struct isl_mat **Q, unsigned row, unsigned i, unsigned j, isl_int m)
+static void subtract(__isl_keep isl_mat *M, __isl_keep isl_mat **U,
+	__isl_keep isl_mat **Q, unsigned row, unsigned i, unsigned j, isl_int m)
 {
 	int r;
 	for (r = row; r < M->n_row; ++r)
@@ -536,8 +612,8 @@
 	}
 }
 
-static void oppose(struct isl_mat *M, struct isl_mat **U,
-	struct isl_mat **Q, unsigned row, unsigned col)
+static void oppose(__isl_keep isl_mat *M, __isl_keep isl_mat **U,
+	__isl_keep isl_mat **Q, unsigned row, unsigned col)
 {
 	int r;
 	for (r = row; r < M->n_row; ++r)
@@ -562,8 +638,8 @@
  * column.
  * If U or Q are NULL, then these matrices are not computed.
  */
-struct isl_mat *isl_mat_left_hermite(struct isl_mat *M, int neg,
-	struct isl_mat **U, struct isl_mat **Q)
+__isl_give isl_mat *isl_mat_left_hermite(__isl_take isl_mat *M, int neg,
+	__isl_give isl_mat **U, __isl_give isl_mat **Q)
 {
 	isl_int c;
 	int row, col;
@@ -574,9 +650,6 @@
 		*Q = NULL;
 	if (!M)
 		goto error;
-	M = isl_mat_cow(M);
-	if (!M)
-		goto error;
 	if (U) {
 		*U = isl_mat_identity(M->ctx, M->n_col);
 		if (!*U)
@@ -588,6 +661,13 @@
 			goto error;
 	}
 
+	if (M->n_col == 0)
+		return M;
+
+	M = isl_mat_cow(M);
+	if (!M)
+		goto error;
+
 	col = 0;
 	isl_int_init(c);
 	for (row = 0; row < M->n_row; ++row) {
@@ -640,9 +720,155 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_right_kernel(struct isl_mat *mat)
+/* Use row "row" of "mat" to eliminate column "col" from all other rows.
+ */
+static __isl_give isl_mat *eliminate(__isl_take isl_mat *mat, int row, int col)
+{
+	int k;
+	isl_size nr, nc;
+	isl_ctx *ctx;
+
+	nr = isl_mat_rows(mat);
+	nc = isl_mat_cols(mat);
+	if (nr < 0 || nc < 0)
+		return isl_mat_free(mat);
+
+	ctx = isl_mat_get_ctx(mat);
+
+	for (k = 0; k < nr; ++k) {
+		if (k == row)
+			continue;
+		if (isl_int_is_zero(mat->rowkcol))
+			continue;
+		mat = isl_mat_cow(mat);
+		if (!mat)
+			return NULL;
+		isl_seq_elim(mat->rowk, mat->rowrow, col, nc, NULL);
+		isl_seq_normalize(ctx, mat->rowk, nc);
+	}
+
+	return mat;
+}
+
+/* Perform Gaussian elimination on the rows of "mat", but start
+ * from the final row and the final column.
+ * Any zero rows that result from the elimination are removed.
+ *
+ * In particular, for each column from last to first,
+ * look for the last row with a non-zero coefficient in that column,
+ * move it last (but before other rows moved last in previous steps) and
+ * use it to eliminate the column from the other rows.
+ */
+__isl_give isl_mat *isl_mat_reverse_gauss(__isl_take isl_mat *mat)
+{
+	int k, row, last;
+	isl_size nr, nc;
+
+	nr = isl_mat_rows(mat);
+	nc = isl_mat_cols(mat);
+	if (nr < 0 || nc < 0)
+		return isl_mat_free(mat);
+
+	last = nc - 1;
+	for (row = nr - 1; row >= 0; --row) {
+		for (; last >= 0; --last) {
+			for (k = row; k >= 0; --k)
+				if (!isl_int_is_zero(mat->rowklast))
+					break;
+			if (k >= 0)
+				break;
+		}
+		if (last < 0)
+			break;
+		if (k != row)
+			mat = isl_mat_swap_rows(mat, k, row);
+		if (!mat)
+			return NULL;
+		if (isl_int_is_neg(mat->rowrowlast))
+			mat = isl_mat_row_neg(mat, row);
+		mat = eliminate(mat, row, last);
+		if (!mat)
+			return NULL;
+	}
+	mat = isl_mat_drop_rows(mat, 0, row + 1);
+
+	return mat;
+}
+
+/* Negate the lexicographically negative rows of "mat" such that
+ * all rows in the result are lexicographically non-negative.
+ */
+__isl_give isl_mat *isl_mat_lexnonneg_rows(__isl_take isl_mat *mat)
+{
+	int i;
+	isl_size nr, nc;
+
+	nr = isl_mat_rows(mat);
+	nc = isl_mat_cols(mat);
+	if (nr < 0 || nc < 0)
+		return isl_mat_free(mat);
+
+	for (i = 0; i < nr; ++i) {
+		int pos;
+
+		pos = isl_seq_first_non_zero(mat->rowi, nc);
+		if (pos < 0)
+			continue;
+		if (isl_int_is_nonneg(mat->rowipos))
+			continue;
+		mat = isl_mat_row_neg(mat, i);
+		if (!mat)
+			return NULL;
+	}
+
+	return mat;
+}
+
+/* Given a matrix "H" is column echelon form, what is the first
+ * zero column?  That is how many initial columns are non-zero?
+ * Start looking at column "first_col" and only consider
+ * the columns to be of size "n_row".
+ * "H" is assumed to be non-NULL.
+ *
+ * Since "H" is in column echelon form, the first non-zero entry
+ * in a column is always in a later position compared to the previous column.
+ */
+static int hermite_first_zero_col(__isl_keep isl_mat *H, int first_col,
+	int n_row)
+{
+	int row, col;
+
+	for (col = first_col, row = 0; col < H->n_col; ++col) {
+		for (; row < n_row; ++row)
+			if (!isl_int_is_zero(H->rowrowcol))
+				break;
+		if (row == n_row)
+			return col;
+	}
+
+	return H->n_col;
+}
+
+/* Return the rank of "mat", or isl_size_error in case of error.
+ */
+isl_size isl_mat_rank(__isl_keep isl_mat *mat)
 {
-	int i, rank;
+	int rank;
+	isl_mat *H;
+
+	H = isl_mat_left_hermite(isl_mat_copy(mat), 0, NULL, NULL);
+	if (!H)
+		return isl_size_error;
+
+	rank = hermite_first_zero_col(H, 0, H->n_row);
+	isl_mat_free(H);
+
+	return rank;
+}
+
+__isl_give isl_mat *isl_mat_right_kernel(__isl_take isl_mat *mat)
+{
+	int rank;
 	struct isl_mat *U = NULL;
 	struct isl_mat *K;
 
@@ -650,12 +876,7 @@
 	if (!mat || !U)
 		goto error;
 
-	for (i = 0, rank = 0; rank < mat->n_col; ++rank) {
-		while (i < mat->n_row && isl_int_is_zero(mat->rowirank))
-			++i;
-		if (i >= mat->n_row)
-			break;
-	}
+	rank = hermite_first_zero_col(mat, 0, mat->n_row);
 	K = isl_mat_alloc(U->ctx, U->n_row, U->n_col - rank);
 	if (!K)
 		goto error;
@@ -669,7 +890,7 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_lin_to_aff(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_lin_to_aff(__isl_take isl_mat *mat)
 {
 	int i;
 	struct isl_mat *mat2;
@@ -752,21 +973,25 @@
 	return min;
 }
 
-static void inv_exchange(struct isl_mat *left, struct isl_mat *right,
-	unsigned i, unsigned j)
+static isl_stat inv_exchange(__isl_keep isl_mat **left,
+	__isl_keep isl_mat **right, unsigned i, unsigned j)
 {
-	left = isl_mat_swap_rows(left, i, j);
-	right = isl_mat_swap_rows(right, i, j);
+	*left = isl_mat_swap_rows(*left, i, j);
+	*right = isl_mat_swap_rows(*right, i, j);
+
+	if (!*left || !*right)
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 static void inv_oppose(
-	struct isl_mat *left, struct isl_mat *right, unsigned row)
+	__isl_keep isl_mat *left, __isl_keep isl_mat *right, unsigned row)
 {
 	isl_seq_neg(left->rowrow+row, left->rowrow+row, left->n_col-row);
 	isl_seq_neg(right->rowrow, right->rowrow, right->n_col);
 }
 
-static void inv_subtract(struct isl_mat *left, struct isl_mat *right,
+static void inv_subtract(__isl_keep isl_mat *left, __isl_keep isl_mat *right,
 	unsigned row, unsigned i, isl_int m)
 {
 	isl_int_neg(m, m);
@@ -780,8 +1005,8 @@
 
 /* Compute inv(left)*right
  */
-struct isl_mat *isl_mat_inverse_product(struct isl_mat *left,
-	struct isl_mat *right)
+__isl_give isl_mat *isl_mat_inverse_product(__isl_take isl_mat *left,
+	__isl_take isl_mat *right)
 {
 	int row;
 	isl_int a, b;
@@ -814,7 +1039,8 @@
 		}
 		pivot += row;
 		if (pivot != row)
-			inv_exchange(left, right, pivot, row);
+			if (inv_exchange(&left, &right, pivot, row) < 0)
+				goto error;
 		if (isl_int_is_neg(left->rowrowrow))
 			inv_oppose(left, right, row);
 		first = row+1;
@@ -824,10 +1050,12 @@
 			isl_int_fdiv_q(a, left->rowfirstrow,
 					left->rowrowrow);
 			inv_subtract(left, right, row, first, a);
-			if (!isl_int_is_zero(left->rowfirstrow))
-				inv_exchange(left, right, row, first);
-			else
+			if (!isl_int_is_zero(left->rowfirstrow)) {
+				if (inv_exchange(&left, &right, row, first) < 0)
+					goto error;
+			} else {
 				++first;
+			}
 		}
 		for (i = 0; i < row; ++i) {
 			if (isl_int_is_zero(left->rowirow))
@@ -870,7 +1098,7 @@
 	return NULL;
 }
 
-void isl_mat_col_scale(struct isl_mat *mat, unsigned col, isl_int m)
+void isl_mat_col_scale(__isl_keep isl_mat *mat, unsigned col, isl_int m)
 {
 	int i;
 
@@ -878,7 +1106,7 @@
 		isl_int_mul(mat->rowicol, mat->rowicol, m);
 }
 
-void isl_mat_col_combine(struct isl_mat *mat, unsigned dst,
+void isl_mat_col_combine(__isl_keep isl_mat *mat, unsigned dst,
 	isl_int m1, unsigned src1, isl_int m2, unsigned src2)
 {
 	int i;
@@ -893,7 +1121,7 @@
 	isl_int_clear(tmp);
 }
 
-struct isl_mat *isl_mat_right_inverse(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_right_inverse(__isl_take isl_mat *mat)
 {
 	struct isl_mat *inv;
 	int row;
@@ -972,7 +1200,7 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_transpose(struct isl_mat *mat)
+__isl_give isl_mat *isl_mat_transpose(__isl_take isl_mat *mat)
 {
 	struct isl_mat *transpose = NULL;
 	int i, j;
@@ -1002,39 +1230,44 @@
 	return NULL;
 }
 
-struct isl_mat *isl_mat_swap_cols(struct isl_mat *mat, unsigned i, unsigned j)
+__isl_give isl_mat *isl_mat_swap_cols(__isl_take isl_mat *mat,
+	unsigned i, unsigned j)
 {
 	int r;
 
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
-	isl_assert(mat->ctx, i < mat->n_col, goto error);
-	isl_assert(mat->ctx, j < mat->n_col, goto error);
+	if (check_col_range(mat, i, 1) < 0 ||
+	    check_col_range(mat, j, 1) < 0)
+		return isl_mat_free(mat);
 
 	for (r = 0; r < mat->n_row; ++r)
 		isl_int_swap(mat->rowri, mat->rowrj);
 	return mat;
-error:
-	isl_mat_free(mat);
-	return NULL;
 }
 
-struct isl_mat *isl_mat_swap_rows(struct isl_mat *mat, unsigned i, unsigned j)
+__isl_give isl_mat *isl_mat_swap_rows(__isl_take isl_mat *mat,
+	unsigned i, unsigned j)
 {
 	isl_int *t;
 
 	if (!mat)
 		return NULL;
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
+	if (check_row_range(mat, i, 1) < 0 ||
+	    check_row_range(mat, j, 1) < 0)
+		return isl_mat_free(mat);
+
 	t = mat->rowi;
 	mat->rowi = mat->rowj;
 	mat->rowj = t;
 	return mat;
 }
 
+/* Calculate the product of two matrices.
+ *
+ * This function is optimized for operand matrices that contain many zeros and
+ * skips multiplications where we know one of the operands is zero.
+ */
 __isl_give isl_mat *isl_mat_product(__isl_take isl_mat *left,
 	__isl_take isl_mat *right)
 {
@@ -1055,10 +1288,13 @@
 		return prod;
 	}
 	for (i = 0; i < prod->n_row; ++i) {
-		for (j = 0; j < prod->n_col; ++j) {
+		for (j = 0; j < prod->n_col; ++j)
 			isl_int_mul(prod->rowij,
 				    left->rowi0, right->row0j);
-			for (k = 1; k < left->n_col; ++k)
+		for (k = 1; k < left->n_col; ++k) {
+			if (isl_int_is_zero(left->rowik))
+				continue;
+			for (j = 0; j < prod->n_col; ++j)
 				isl_int_addmul(prod->rowij,
 					    left->rowik, right->rowkj);
 		}
@@ -1115,14 +1351,14 @@
  * M the matrix mat.
  *
  * If there are fewer variables x' then there are x, then we perform
- * the transformation in place, which that, in principle,
+ * the transformation in place, which means that, in principle,
  * this frees up some extra variables as the number
  * of columns remains constant, but we would have to extend
  * the div array too as the number of rows in this array is assumed
  * to be equal to extra.
  */
-struct isl_basic_set *isl_basic_set_preimage(struct isl_basic_set *bset,
-	struct isl_mat *mat)
+__isl_give isl_basic_set *isl_basic_set_preimage(
+	__isl_take isl_basic_set *bset, __isl_take isl_mat *mat)
 {
 	struct isl_ctx *ctx;
 
@@ -1131,15 +1367,15 @@
 
 	ctx = bset->ctx;
 	bset = isl_basic_set_cow(bset);
-	if (!bset)
+	if (isl_basic_set_check_no_params(bset) < 0)
 		goto error;
 
-	isl_assert(ctx, bset->dim->nparam == 0, goto error);
 	isl_assert(ctx, 1+bset->dim->n_out == mat->n_row, goto error);
 	isl_assert(ctx, mat->n_col > 0, goto error);
 
 	if (mat->n_col > mat->n_row) {
-		bset = isl_basic_set_extend(bset, 0, mat->n_col-1, 0, 0, 0);
+		bset = isl_basic_set_add_dims(bset, isl_dim_set,
+						mat->n_col - mat->n_row);
 		if (!bset)
 			goto error;
 	} else if (mat->n_col < mat->n_row) {
@@ -1162,7 +1398,7 @@
 
 	ISL_F_CLR(bset, ISL_BASIC_SET_NO_IMPLICIT);
 	ISL_F_CLR(bset, ISL_BASIC_SET_NO_REDUNDANT);
-	ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
+	ISL_F_CLR(bset, ISL_BASIC_SET_SORTED);
 	ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED_DIVS);
 	ISL_F_CLR(bset, ISL_BASIC_SET_ALL_EQUALITIES);
 
@@ -1177,16 +1413,15 @@
 	return NULL;
 }
 
-struct isl_set *isl_set_preimage(struct isl_set *set, struct isl_mat *mat)
+__isl_give isl_set *isl_set_preimage(
+	__isl_take isl_set *set, __isl_take isl_mat *mat)
 {
-	struct isl_ctx *ctx;
 	int i;
 
 	set = isl_set_cow(set);
 	if (!set)
-		return NULL;
+		goto error;
 
-	ctx = set->ctx;
 	for (i = 0; i < set->n; ++i) {
 		set->pi = isl_basic_set_preimage(set->pi,
 						    isl_mat_copy(mat));
@@ -1209,71 +1444,28 @@
 	return NULL;
 }
 
-/* Replace the variables x starting at pos in the rows q
- * by x' with x = M x' with M the matrix mat.
+/* Replace the variables x starting at "first_col" in the rows "rows"
+ * of some coefficient matrix by x' with x = M x' with M the matrix mat.
  * That is, replace the corresponding coefficients c by c M.
  */
-static int transform(isl_ctx *ctx, isl_int **q, unsigned n,
-	unsigned pos, __isl_take isl_mat *mat)
+isl_stat isl_mat_sub_transform(isl_int **row, unsigned n_row,
+	unsigned first_col, __isl_take isl_mat *mat)
 {
 	int i;
+	isl_ctx *ctx;
 	isl_mat *t;
 
-	t = isl_mat_sub_alloc6(ctx, q, 0, n, pos, mat->n_row);
+	if (!mat)
+		return isl_stat_error;
+	ctx = isl_mat_get_ctx(mat);
+	t = isl_mat_sub_alloc6(ctx, row, 0, n_row, first_col, mat->n_row);
 	t = isl_mat_product(t, mat);
 	if (!t)
-		return -1;
-	for (i = 0; i < n; ++i)
-		isl_seq_swp_or_cpy(qi + pos, t->rowi, t->n_col);
+		return isl_stat_error;
+	for (i = 0; i < n_row; ++i)
+		isl_seq_swp_or_cpy(rowi + first_col, t->rowi, t->n_col);
 	isl_mat_free(t);
-	return 0;
-}
-
-/* Replace the variables x of type "type" starting at "first" in "bset"
- * by x' with x = M x' with M the matrix trans.
- * That is, replace the corresponding coefficients c by c M.
- *
- * The transformation matrix should be a square matrix.
- */
-__isl_give isl_basic_set *isl_basic_set_transform_dims(
-	__isl_take isl_basic_set *bset, enum isl_dim_type type, unsigned first,
-	__isl_take isl_mat *trans)
-{
-	isl_ctx *ctx;
-	unsigned pos;
-
-	bset = isl_basic_set_cow(bset);
-	if (!bset || !trans)
-		goto error;
-
-	ctx = isl_basic_set_get_ctx(bset);
-	if (trans->n_row != trans->n_col)
-		isl_die(trans->ctx, isl_error_invalid,
-			"expecting square transformation matrix", goto error);
-	if (first + trans->n_row > isl_basic_set_dim(bset, type))
-		isl_die(trans->ctx, isl_error_invalid,
-			"oversized transformation matrix", goto error);
-
-	pos = isl_basic_set_offset(bset, type) + first;
-
-	if (transform(ctx, bset->eq, bset->n_eq, pos, isl_mat_copy(trans)) < 0)
-		goto error;
-	if (transform(ctx, bset->ineq, bset->n_ineq, pos,
-		      isl_mat_copy(trans)) < 0)
-		goto error;
-	if (transform(ctx, bset->div, bset->n_div, 1 + pos,
-		      isl_mat_copy(trans)) < 0)
-		goto error;
-
-	ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED);
-	ISL_F_CLR(bset, ISL_BASIC_SET_NORMALIZED_DIVS);
-
-	isl_mat_free(trans);
-	return bset;
-error:
-	isl_mat_free(trans);
-	isl_basic_set_free(bset);
-	return NULL;
+	return isl_stat_ok;
 }
 
 void isl_mat_print_internal(__isl_keep isl_mat *mat, FILE *out, int indent)
@@ -1310,7 +1502,8 @@
 	isl_mat_print_internal(mat, stderr, 0);
 }
 
-struct isl_mat *isl_mat_drop_cols(struct isl_mat *mat, unsigned col, unsigned n)
+__isl_give isl_mat *isl_mat_drop_cols(__isl_take isl_mat *mat,
+	unsigned col, unsigned n)
 {
 	int r;
 
@@ -1318,8 +1511,8 @@
 		return mat;
 
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
+	if (check_col_range(mat, col, n) < 0)
+		return isl_mat_free(mat);
 
 	if (col != mat->n_col-n) {
 		for (r = 0; r < mat->n_row; ++r)
@@ -1330,13 +1523,14 @@
 	return mat;
 }
 
-struct isl_mat *isl_mat_drop_rows(struct isl_mat *mat, unsigned row, unsigned n)
+__isl_give isl_mat *isl_mat_drop_rows(__isl_take isl_mat *mat,
+	unsigned row, unsigned n)
 {
 	int r;
 
 	mat = isl_mat_cow(mat);
-	if (!mat)
-		return NULL;
+	if (check_row_range(mat, row, n) < 0)
+		return isl_mat_free(mat);
 
 	for (r = row; r+n < mat->n_row; ++r)
 		mat->rowr = mat->rowr+n;
@@ -1350,8 +1544,8 @@
 {
 	isl_mat *ext;
 
-	if (!mat)
-		return NULL;
+	if (check_col_range(mat, col, 0) < 0)
+		return isl_mat_free(mat);
 	if (n == 0)
 		return mat;
 
@@ -1400,8 +1594,8 @@
 {
 	isl_mat *ext;
 
-	if (!mat)
-		return NULL;
+	if (check_row_range(mat, row, 0) < 0)
+		return isl_mat_free(mat);
 	if (n == 0)
 		return mat;
 
@@ -1451,7 +1645,7 @@
 	return isl_mat_insert_zero_rows(mat, mat->n_row, n);
 }
 
-void isl_mat_col_submul(struct isl_mat *mat,
+void isl_mat_col_submul(__isl_keep isl_mat *mat,
 			int dst_col, isl_int f, int src_col)
 {
 	int i;
@@ -1472,7 +1666,8 @@
 			    mat->rowidst_col, mat->rowisrc_col);
 }
 
-void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col)
+void isl_mat_col_mul(__isl_keep isl_mat *mat, int dst_col, isl_int f,
+	int src_col)
 {
 	int i;
 
@@ -1480,7 +1675,66 @@
 		isl_int_mul(mat->rowidst_col, f, mat->rowisrc_col);
 }
 
-struct isl_mat *isl_mat_unimodular_complete(struct isl_mat *M, int row)
+/* Add "f" times column "src_col" to column "dst_col" of "mat" and
+ * return the result.
+ */
+__isl_give isl_mat *isl_mat_col_addmul(__isl_take isl_mat *mat, int dst_col,
+	isl_int f, int src_col)
+{
+	int i;
+
+	if (check_col(mat, dst_col) < 0 || check_col(mat, src_col) < 0)
+		return isl_mat_free(mat);
+
+	for (i = 0; i < mat->n_row; ++i) {
+		if (isl_int_is_zero(mat->rowisrc_col))
+			continue;
+		mat = isl_mat_cow(mat);
+		if (!mat)
+			return NULL;
+		isl_int_addmul(mat->rowidst_col, f, mat->rowisrc_col);
+	}
+
+	return mat;
+}
+
+/* Negate column "col" of "mat" and return the result.
+ */
+__isl_give isl_mat *isl_mat_col_neg(__isl_take isl_mat *mat, int col)
+{
+	int i;
+
+	if (check_col(mat, col) < 0)
+		return isl_mat_free(mat);
+
+	for (i = 0; i < mat->n_row; ++i) {
+		if (isl_int_is_zero(mat->rowicol))
+			continue;
+		mat = isl_mat_cow(mat);
+		if (!mat)
+			return NULL;
+		isl_int_neg(mat->rowicol, mat->rowicol);
+	}
+
+	return mat;
+}
+
+/* Negate row "row" of "mat" and return the result.
+ */
+__isl_give isl_mat *isl_mat_row_neg(__isl_take isl_mat *mat, int row)
+{
+	if (check_row(mat, row) < 0)
+		return isl_mat_free(mat);
+	if (isl_seq_first_non_zero(mat->rowrow, mat->n_col) == -1)
+		return mat;
+	mat = isl_mat_cow(mat);
+	if (!mat)
+		return NULL;
+	isl_seq_neg(mat->rowrow, mat->rowrow, mat->n_col);
+	return mat;
+}
+
+__isl_give isl_mat *isl_mat_unimodular_complete(__isl_take isl_mat *M, int row)
 {
 	int r;
 	struct isl_mat *H = NULL, *Q = NULL;
@@ -1542,24 +1796,24 @@
 	return NULL;
 }
 
-int isl_mat_is_equal(__isl_keep isl_mat *mat1, __isl_keep isl_mat *mat2)
+isl_bool isl_mat_is_equal(__isl_keep isl_mat *mat1, __isl_keep isl_mat *mat2)
 {
 	int i;
 
 	if (!mat1 || !mat2)
-		return -1;
+		return isl_bool_error;
 
 	if (mat1->n_row != mat2->n_row)
-		return 0;
+		return isl_bool_false;
 
 	if (mat1->n_col != mat2->n_col)
-		return 0;
+		return isl_bool_false;
 
 	for (i = 0; i < mat1->n_row; ++i)
 		if (!isl_seq_eq(mat1->rowi, mat2->rowi, mat1->n_col))
-			return 0;
+			return isl_bool_false;
 
-	return 1;
+	return isl_bool_true;
 }
 
 __isl_give isl_mat *isl_mat_from_row_vec(__isl_take isl_vec *vec)
@@ -1650,6 +1904,19 @@
 	return NULL;
 }
 
+/* Return the gcd of the elements in row "row" of "mat" in *gcd.
+ * Return isl_stat_ok on success and isl_stat_error on failure.
+ */
+isl_stat isl_mat_row_gcd(__isl_keep isl_mat *mat, int row, isl_int *gcd)
+{
+	if (check_row(mat, row) < 0)
+		return isl_stat_error;
+
+	isl_seq_gcd(mat->rowrow, mat->n_col, gcd);
+
+	return isl_stat_ok;
+}
+
 void isl_mat_gcd(__isl_keep isl_mat *mat, isl_int *gcd)
 {
 	int i;
@@ -1667,6 +1934,25 @@
 	isl_int_clear(g);
 }
 
+/* Return the result of scaling "mat" by a factor of "m".
+ */
+__isl_give isl_mat *isl_mat_scale(__isl_take isl_mat *mat, isl_int m)
+{
+	int i;
+
+	if (isl_int_is_one(m))
+		return mat;
+
+	mat = isl_mat_cow(mat);
+	if (!mat)
+		return NULL;
+
+	for (i = 0; i < mat->n_row; ++i)
+		isl_seq_scale(mat->rowi, mat->rowi, m, mat->n_col);
+
+	return mat;
+}
+
 __isl_give isl_mat *isl_mat_scale_down(__isl_take isl_mat *mat, isl_int m)
 {
 	int i;
@@ -1740,3 +2026,85 @@
 
 	return i;
 }
+
+/* Return a basis for the space spanned by the rows of "mat".
+ * Any basis will do, so simply perform Gaussian elimination and
+ * remove the empty rows.
+ */
+__isl_give isl_mat *isl_mat_row_basis(__isl_take isl_mat *mat)
+{
+	return isl_mat_reverse_gauss(mat);
+}
+
+/* Return rows that extend a basis of "mat1" to one
+ * that covers both "mat1" and "mat2".
+ * The Hermite normal form of the concatenation of the two matrices is
+ *
+ *	                      Q1 
+ *	 M1  =  H1 0  0   Q2 
+ *	 M2  =  H2 H3 0   Q3 
+ *
+ * The number of columns in H1 and H3 determine the number of rows
+ * in Q1 and Q2.  Q1 is a basis for M1, while Q2 extends this basis
+ * to also cover M2.
+ */
+__isl_give isl_mat *isl_mat_row_basis_extension(
+	__isl_take isl_mat *mat1, __isl_take isl_mat *mat2)
+{
+	isl_size n_row;
+	int r1, r;
+	isl_size n1;
+	isl_mat *H, *Q;
+
+	n1 = isl_mat_rows(mat1);
+	H = isl_mat_concat(mat1, mat2);
+	H = isl_mat_left_hermite(H, 0, NULL, &Q);
+	if (n1 < 0 || !H || !Q)
+		goto error;
+
+	r1 = hermite_first_zero_col(H, 0, n1);
+	r = hermite_first_zero_col(H, r1, H->n_row);
+	n_row = isl_mat_rows(Q);
+	if (n_row < 0)
+		goto error;
+	Q = isl_mat_drop_rows(Q, r, n_row - r);
+	Q = isl_mat_drop_rows(Q, 0, r1);
+
+	isl_mat_free(H);
+	return Q;
+error:
+	isl_mat_free(H);
+	isl_mat_free(Q);
+	return NULL;
+}
+
+/* Are the rows of "mat1" linearly independent of those of "mat2"?
+ * That is, is there no linear dependence among the combined rows
+ * that is not already present in either "mat1" or "mat2"?
+ * In other words, is the rank of "mat1" and "mat2" combined equal
+ * to the sum of the ranks of "mat1" and "mat2"?
+ */
+isl_bool isl_mat_has_linearly_independent_rows(__isl_keep isl_mat *mat1,
+	__isl_keep isl_mat *mat2)
+{
+	isl_size r1, r2, r;
+	isl_mat *mat;
+
+	r1 = isl_mat_rank(mat1);
+	if (r1 < 0)
+		return isl_bool_error;
+	if (r1 == 0)
+		return isl_bool_true;
+	r2 = isl_mat_rank(mat2);
+	if (r2 < 0)
+		return isl_bool_error;
+	if (r2 == 0)
+		return isl_bool_true;
+
+	mat = isl_mat_concat(isl_mat_copy(mat1), isl_mat_copy(mat2));
+	r = isl_mat_rank(mat);
+	isl_mat_free(mat);
+	if (r < 0)
+		return isl_bool_error;
+	return isl_bool_ok(r == r1 + r2);
+}

_service:tar_scm:isl-0.14.tar.xz/isl_mat_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_mat_private.h Changed

@@ -1,3 +1,6 @@
+#ifndef ISL_MAT_PRIVATE_H
+#define ISL_MAT_PRIVATE_H
+
 #include <isl/mat.h>
 #include <isl_blk.h>
 
@@ -20,6 +23,11 @@
 	struct isl_blk block;
 };
 
+uint32_t isl_mat_get_hash(__isl_keep isl_mat *mat);
+
+__isl_give isl_mat *isl_mat_zero(isl_ctx *ctx, unsigned n_row, unsigned n_col);
+__isl_give isl_mat *isl_mat_dup(__isl_keep isl_mat *mat);
+__isl_give isl_mat *isl_mat_cow(__isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_sub_alloc(__isl_keep isl_mat *mat,
 	unsigned first_row, unsigned n_row, unsigned first_col, unsigned n_col);
 __isl_give isl_mat *isl_mat_sub_alloc6(isl_ctx *ctx, isl_int **row,
@@ -28,19 +36,35 @@
 	unsigned n_row, unsigned dst_col, unsigned src_col, unsigned n_col);
 void isl_mat_sub_neg(struct isl_ctx *ctx, isl_int **dst, isl_int **src,
 	unsigned n_row, unsigned dst_col, unsigned src_col, unsigned n_col);
+isl_stat isl_mat_sub_transform(isl_int **row, unsigned n_row,
+	unsigned first_col, __isl_take isl_mat *mat);
 __isl_give isl_mat *isl_mat_diag(isl_ctx *ctx, unsigned n_row, isl_int d);
 
+__isl_give isl_mat *isl_mat_reverse_gauss(__isl_take isl_mat *mat);
+
+__isl_give isl_mat *isl_mat_scale(__isl_take isl_mat *mat, isl_int m);
 __isl_give isl_mat *isl_mat_scale_down_row(__isl_take isl_mat *mat, int row,
 	isl_int m);
 
 __isl_give isl_vec *isl_mat_get_row(__isl_keep isl_mat *mat, unsigned row);
 
-int isl_mat_is_scaled_identity(__isl_keep isl_mat *mat);
+__isl_give isl_mat *isl_mat_lexnonneg_rows(__isl_take isl_mat *mat);
 
-void isl_mat_col_mul(struct isl_mat *mat, int dst_col, isl_int f, int src_col);
-void isl_mat_col_submul(struct isl_mat *mat,
+isl_bool isl_mat_is_scaled_identity(__isl_keep isl_mat *mat);
+
+isl_stat isl_mat_row_gcd(__isl_keep isl_mat *mat, int row, isl_int *gcd);
+
+void isl_mat_col_mul(__isl_keep isl_mat *mat, int dst_col, isl_int f,
+	int src_col);
+void isl_mat_col_submul(__isl_keep isl_mat *mat,
 			int dst_col, isl_int f, int src_col);
+__isl_give isl_mat *isl_mat_col_addmul(__isl_take isl_mat *mat, int dst_col,
+	isl_int f, int src_col);
+__isl_give isl_mat *isl_mat_col_neg(__isl_take isl_mat *mat, int col);
+__isl_give isl_mat *isl_mat_row_neg(__isl_take isl_mat *mat, int row);
 
 int isl_mat_get_element(__isl_keep isl_mat *mat, int row, int col, isl_int *v);
 __isl_give isl_mat *isl_mat_set_element(__isl_take isl_mat *mat,
 	int row, int col, isl_int v);
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/isl_maybe_ast_graft_list.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_maybe_map.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_morph.c -> _service:tar_scm:isl-0.24.tar.gz/isl_morph.c Changed

@@ -17,6 +17,9 @@
 #include <isl_mat_private.h>
 #include <isl_space_private.h>
 #include <isl_equalities.h>
+#include <isl_id_private.h>
+#include <isl_aff_private.h>
+#include <isl_vec_private.h>
 
 isl_ctx *isl_morph_get_ctx(__isl_keep isl_morph *morph)
 {
@@ -83,34 +86,39 @@
 	return isl_morph_dup(morph);
 }
 
-void isl_morph_free(__isl_take isl_morph *morph)
+__isl_null isl_morph *isl_morph_free(__isl_take isl_morph *morph)
 {
 	if (!morph)
-		return;
+		return NULL;
 
 	if (--morph->ref > 0)
-		return;
+		return NULL;
 
 	isl_basic_set_free(morph->dom);
 	isl_basic_set_free(morph->ran);
 	isl_mat_free(morph->map);
 	isl_mat_free(morph->inv);
 	free(morph);
+
+	return NULL;
 }
 
 /* Is "morph" an identity on the parameters?
  */
-static int identity_on_parameters(__isl_keep isl_morph *morph)
+static isl_bool identity_on_parameters(__isl_keep isl_morph *morph)
 {
-	int is_identity;
-	unsigned nparam;
+	isl_bool is_identity;
+	isl_size nparam, nparam_ran;
 	isl_mat *sub;
 
 	nparam = isl_morph_dom_dim(morph, isl_dim_param);
-	if (nparam != isl_morph_ran_dim(morph, isl_dim_param))
-		return 0;
+	nparam_ran = isl_morph_ran_dim(morph, isl_dim_param);
+	if (nparam < 0 || nparam_ran < 0)
+		return isl_bool_error;
+	if (nparam != nparam_ran)
+		return isl_bool_false;
 	if (nparam == 0)
-		return 1;
+		return isl_bool_true;
 	sub = isl_mat_sub_alloc(morph->map, 0, 1 + nparam, 0, 1 + nparam);
 	is_identity = isl_mat_is_scaled_identity(sub);
 	isl_mat_free(sub);
@@ -130,9 +138,9 @@
 	isl_space *dom, *ran, *space;
 	isl_local_space *ls;
 	isl_multi_aff *ma;
-	unsigned nparam, nvar;
+	isl_size nparam, nvar;
 	int i;
-	int is_identity;
+	isl_bool is_identity;
 
 	if (!morph)
 		return NULL;
@@ -152,6 +160,8 @@
 
 	nparam = isl_multi_aff_dim(ma, isl_dim_param);
 	nvar = isl_multi_aff_dim(ma, isl_dim_out);
+	if (nparam < 0 || nvar < 0)
+		ma = isl_multi_aff_free(ma);
 	for (i = 0; i < nvar; ++i) {
 		isl_val *val;
 		isl_vec *v;
@@ -171,12 +181,46 @@
 
 /* Return the domain space of "morph".
  */
-__isl_give isl_space *isl_morph_get_dom_space(__isl_keep isl_morph *morph)
+static __isl_keep isl_space *isl_morph_peek_dom_space(
+	__isl_keep isl_morph *morph)
 {
 	if (!morph)
 		return NULL;
 
-	return isl_basic_set_get_space(morph->dom);
+	return isl_basic_set_peek_space(morph->dom);
+}
+
+/* Return a copy of the domain space of "morph".
+ */
+__isl_give isl_space *isl_morph_get_dom_space(__isl_keep isl_morph *morph)
+{
+	return isl_space_copy(isl_morph_peek_dom_space(morph));
+}
+
+/* Check that the match against "space" with result "match" was successful.
+ */
+static isl_stat check_space_match(__isl_keep isl_space *space, isl_bool match)
+{
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"spaces don't match", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Check that "morph" can be applied to the "space".
+ */
+isl_stat isl_morph_check_applies(__isl_keep isl_morph *morph,
+	__isl_keep isl_space *space)
+{
+	isl_space *dom_space;
+	isl_bool applies;
+
+	dom_space = isl_morph_peek_dom_space(morph);
+	applies = isl_space_is_equal(dom_space, space);
+	return check_space_match(space, applies);
 }
 
 __isl_give isl_space *isl_morph_get_ran_space(__isl_keep isl_morph *morph)
@@ -187,18 +231,18 @@
 	return isl_space_copy(morph->ran->dim);
 }
 
-unsigned isl_morph_dom_dim(__isl_keep isl_morph *morph, enum isl_dim_type type)
+isl_size isl_morph_dom_dim(__isl_keep isl_morph *morph, enum isl_dim_type type)
 {
 	if (!morph)
-		return 0;
+		return isl_size_error;
 
 	return isl_basic_set_dim(morph->dom, type);
 }
 
-unsigned isl_morph_ran_dim(__isl_keep isl_morph *morph, enum isl_dim_type type)
+isl_size isl_morph_ran_dim(__isl_keep isl_morph *morph, enum isl_dim_type type)
 {
 	if (!morph)
-		return 0;
+		return isl_size_error;
 
 	return isl_basic_set_dim(morph->ran, type);
 }
@@ -261,12 +305,14 @@
  */
 __isl_give isl_morph *isl_morph_dom_params(__isl_take isl_morph *morph)
 {
-	unsigned n;
+	isl_size n;
 
 	morph = isl_morph_cow(morph);
 	if (!morph)
 		return NULL;
 	n = isl_basic_set_dim(morph->dom, isl_dim_set);
+	if (n < 0)
+		return isl_morph_free(morph);
 	morph = isl_morph_remove_dom_dims(morph, isl_dim_set, 0, n);
 	if (!morph)
 		return NULL;
@@ -282,12 +328,14 @@
  */
 __isl_give isl_morph *isl_morph_ran_params(__isl_take isl_morph *morph)
 {
-	unsigned n;
+	isl_size n;
 
 	morph = isl_morph_cow(morph);
 	if (!morph)
 		return NULL;
 	n = isl_basic_set_dim(morph->ran, isl_dim_set);
+	if (n < 0)
+		return isl_morph_free(morph);
 	morph = isl_morph_remove_ran_dims(morph, isl_dim_set, 0, n);
 	if (!morph)
 		return NULL;
@@ -299,13 +347,27 @@
 	return NULL;
 }
 
+/* Replace the identifier of the tuple of the range of the morph by "id".
+ */
+static __isl_give isl_morph *isl_morph_set_ran_tuple_id(
+	__isl_take isl_morph *morph, __isl_keep isl_id *id)
+{
+	morph = isl_morph_cow(morph);
+	if (!morph)
+		return NULL;
+	morph->ran = isl_basic_set_set_tuple_id(morph->ran, isl_id_copy(id));
+	if (!morph->ran)
+		return isl_morph_free(morph);
+	return morph;
+}
+
 void isl_morph_print_internal(__isl_take isl_morph *morph, FILE *out)
 {
 	if (!morph)
 		return;
 
-	isl_basic_set_print(morph->dom, out, 0, "", "", ISL_FORMAT_ISL);
-	isl_basic_set_print(morph->ran, out, 0, "", "", ISL_FORMAT_ISL);
+	isl_basic_set_dump(morph->dom);
+	isl_basic_set_dump(morph->ran);
 	isl_mat_print_internal(morph->map, out, 4);
 	isl_mat_print_internal(morph->inv, out, 4);
 }
@@ -319,12 +381,12 @@
 {
 	isl_mat *id;
 	isl_basic_set *universe;
-	unsigned total;
+	isl_size total;
 
-	if (!bset)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
 		return NULL;
 
-	total = isl_basic_set_total_dim(bset);
 	id = isl_mat_identity(bset->ctx, 1 + total);
 	universe = isl_basic_set_universe(isl_space_copy(bset->dim));
 
@@ -339,12 +401,12 @@
 {
 	isl_mat *id;
 	isl_basic_set *empty;
-	unsigned total;
+	isl_size total;
 
-	if (!bset)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
 		return NULL;
 
-	total = isl_basic_set_total_dim(bset);
 	id = isl_mat_identity(bset->ctx, 1 + total);
 	empty = isl_basic_set_empty(isl_space_copy(bset->dim));
 
@@ -352,32 +414,6 @@
 		id, isl_mat_copy(id));
 }
 
-/* Given a matrix that maps a (possibly) parametric domain to
- * a parametric domain, add in rows that map the "nparam" parameters onto
- * themselves.
- */
-static __isl_give isl_mat *insert_parameter_rows(__isl_take isl_mat *mat,
-	unsigned nparam)
-{
-	int i;
-
-	if (nparam == 0)
-		return mat;
-	if (!mat)
-		return NULL;
-
-	mat = isl_mat_insert_rows(mat, 1, nparam);
-	if (!mat)
-		return NULL;
-
-	for (i = 0; i < nparam; ++i) {
-		isl_seq_clr(mat->row1 + i, mat->n_col);
-		isl_int_set(mat->row1 + i1 + i, mat->row00);
-	}
-
-	return mat;
-}
-
 /* Construct a basic set described by the "n" equalities of "bset" starting
  * at "first".
  */
@@ -386,19 +422,20 @@
 {
 	int i, k;
 	isl_basic_set *eq;
-	unsigned total;
+	isl_size total;
 
-	isl_assert(bset->ctx, bset->n_div == 0, return NULL);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0 || isl_basic_set_check_no_locals(bset) < 0)
+		return NULL;
 
-	total = isl_basic_set_total_dim(bset);
-	eq = isl_basic_set_alloc_space(isl_space_copy(bset->dim), 0, n, 0);
+	eq = isl_basic_set_alloc_space(isl_basic_set_get_space(bset), 0, n, 0);
 	if (!eq)
 		return NULL;
 	for (i = 0; i < n; ++i) {
 		k = isl_basic_set_alloc_equality(eq);
 		if (k < 0)
 			goto error;
-		isl_seq_cpy(eq->eqk, bset->eqfirst + k, 1 + total);
+		isl_seq_cpy(eq->eqk, bset->eqfirst + i, 1 + total);
 	}
 
 	return eq;
@@ -407,14 +444,10 @@
 	return NULL;
 }
 
-/* Given a basic set, exploit the equalties in the basic set to construct
- * a morphishm that maps the basic set to a lower-dimensional space.
+/* Given a basic set, exploit the equalities in the basic set to construct
+ * a morphism that maps the basic set to a lower-dimensional space.
  * Specifically, the morphism reduces the number of dimensions of type "type".
  *
- * This function is a slight generalization of isl_mat_variable_compression
- * in that it allows the input to be parametric and that it allows for the
- * compression of either parameters or set variables.
- *
  * We first select the equalities of interest, that is those that involve
  * variables of type "type" and no later variables.
  * Denote those equalities as
@@ -424,35 +457,14 @@
  * where C(p) depends on the parameters if type == isl_dim_set and
  * is a constant if type == isl_dim_param.
  *
- * First compute the (left) Hermite normal form of M,
+ * Use isl_mat_final_variable_compression to construct a compression
  *
- *		M U1 U2 = M U = H = H1 0
- * or
- *		              M = H Q = H1 0 Q1
- *                                             Q2
+ *	x = T x'
  *
- * with U, Q unimodular, Q = U^{-1} (and H lower triangular).
- * Define the transformed variables as
+ *	x' = Q x
  *
- *		x = U1 U2  x1'  = U1 U2 Q1 x
- *		             x2'            Q2
- *
- * The equalities then become
- *
- *		-C(p) + H1 x1' = 0   or   x1' = H1^{-1} C(p) = C'(p)
- *
- * If the denominator of the constant term does not divide the
- * the common denominator of the parametric terms, then every
- * integer point is mapped to a non-integer point and then the original set has no
- * integer solutions (since the x' are a unimodular transformation
- * of the x).  In this case, an empty morphism is returned.
- * Otherwise, the transformation is given by
- *
- *		x = U1 H1^{-1} C(p) + U2 x2'
- *
- * The inverse transformation is simply
- *
- *		x2' = Q2 x
+ * If T is a zero-column matrix, then the set of equality constraints
+ * do not admit a solution.  In this case, an empty morphism is returned.
  *
  * Both matrices are extended to map the full original space to the full
  * compressed space.
@@ -461,12 +473,13 @@
 	__isl_keep isl_basic_set *bset, enum isl_dim_type type)
 {
 	unsigned otype;
-	unsigned ntype;
+	isl_size ntype;
 	unsigned orest;
 	unsigned nrest;
+	isl_size total;
 	int f_eq, n_eq;
-	isl_space *dim;
-	isl_mat *H, *U, *Q, *C = NULL, *H1, *U1, *U2;
+	isl_space *space;
+	isl_mat *E, *Q, *C;
 	isl_basic_set *dom, *ran;
 
 	if (!bset)
@@ -475,12 +488,16 @@
 	if (isl_basic_set_plain_is_empty(bset))
 		return isl_morph_empty(bset);
 
-	isl_assert(bset->ctx, bset->n_div == 0, return NULL);
+	if (isl_basic_set_check_no_locals(bset) < 0)
+		return NULL;
 
-	otype = 1 + isl_space_offset(bset->dim, type);
 	ntype = isl_basic_set_dim(bset, type);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (ntype < 0 || total < 0)
+		return NULL;
+	otype = isl_basic_set_offset(bset, type);
 	orest = otype + ntype;
-	nrest = isl_basic_set_total_dim(bset) - (orest - 1);
+	nrest = total - (orest - 1);
 
 	for (f_eq = 0; f_eq < bset->n_eq; ++f_eq)
 		if (isl_seq_first_non_zero(bset->eqf_eq + orest, nrest) == -1)
@@ -491,73 +508,41 @@
 	if (n_eq == 0)
 		return isl_morph_identity(bset);
 
-	H = isl_mat_sub_alloc6(bset->ctx, bset->eq, f_eq, n_eq, otype, ntype);
-	H = isl_mat_left_hermite(H, 0, &U, &Q);
-	if (!H || !U || !Q)
-		goto error;
-	Q = isl_mat_drop_rows(Q, 0, n_eq);
-	Q = isl_mat_diagonal(isl_mat_identity(bset->ctx, otype), Q);
-	Q = isl_mat_diagonal(Q, isl_mat_identity(bset->ctx, nrest));
-	C = isl_mat_alloc(bset->ctx, 1 + n_eq, otype);
-	if (!C)
-		goto error;
-	isl_int_set_si(C->row00, 1);
-	isl_seq_clr(C->row0 + 1, otype - 1);
-	isl_mat_sub_neg(C->ctx, C->row + 1, bset->eq + f_eq, n_eq, 0, 0, otype);
-	H1 = isl_mat_sub_alloc(H, 0, H->n_row, 0, H->n_row);
-	H1 = isl_mat_lin_to_aff(H1);
-	C = isl_mat_inverse_product(H1, C);
-	if (!C)
-		goto error;
-	isl_mat_free(H);
-
-	if (!isl_int_is_one(C->row00)) {
-		int i;
-		isl_int g;
-
-		isl_int_init(g);
-		for (i = 0; i < n_eq; ++i) {
-			isl_seq_gcd(C->row1 + i + 1, otype - 1, &g);
-			isl_int_gcd(g, g, C->row00);
-			if (!isl_int_is_divisible_by(C->row1 + i0, g))
-				break;
-		}
-		isl_int_clear(g);
-
-		if (i < n_eq) {
-			isl_mat_free(C);
-			isl_mat_free(U);
-			isl_mat_free(Q);
-			return isl_morph_empty(bset);
-		}
-
-		C = isl_mat_normalize(C);
+	E = isl_mat_sub_alloc6(bset->ctx, bset->eq, f_eq, n_eq, 0, orest);
+	C = isl_mat_final_variable_compression(E, otype - 1, &Q);
+	if (!Q)
+		C = isl_mat_free(C);
+	if (C && C->n_col == 0) {
+		isl_mat_free(C);
+		isl_mat_free(Q);
+		return isl_morph_empty(bset);
 	}
 
-	U1 = isl_mat_sub_alloc(U, 0, U->n_row, 0, n_eq);
-	U1 = isl_mat_lin_to_aff(U1);
-	U2 = isl_mat_sub_alloc(U, 0, U->n_row, n_eq, U->n_row - n_eq);
-	U2 = isl_mat_lin_to_aff(U2);
-	isl_mat_free(U);
-
-	C = isl_mat_product(U1, C);
-	C = isl_mat_aff_direct_sum(C, U2);
-	C = insert_parameter_rows(C, otype - 1);
+	Q = isl_mat_diagonal(Q, isl_mat_identity(bset->ctx, nrest));
 	C = isl_mat_diagonal(C, isl_mat_identity(bset->ctx, nrest));
 
-	dim = isl_space_copy(bset->dim);
-	dim = isl_space_drop_dims(dim, type, 0, ntype);
-	dim = isl_space_add_dims(dim, type, ntype - n_eq);
-	ran = isl_basic_set_universe(dim);
+	space = isl_space_copy(bset->dim);
+	space = isl_space_drop_dims(space, type, 0, ntype);
+	space = isl_space_add_dims(space, type, ntype - n_eq);
+	ran = isl_basic_set_universe(space);
 	dom = copy_equalities(bset, f_eq, n_eq);
 
 	return isl_morph_alloc(dom, ran, Q, C);
-error:
-	isl_mat_free(C);
-	isl_mat_free(H);
-	isl_mat_free(U);
-	isl_mat_free(Q);
-	return NULL;
+}
+
+/* Given a basic set, exploit the equalities in the basic set to construct
+ * a morphism that maps the basic set to a lower-dimensional space
+ * with identifier "id".
+ * Specifically, the morphism reduces the number of set dimensions.
+ */
+__isl_give isl_morph *isl_basic_set_variable_compression_with_id(
+	__isl_keep isl_basic_set *bset, __isl_keep isl_id *id)
+{
+	isl_morph *morph;
+
+	morph = isl_basic_set_variable_compression(bset, isl_dim_set);
+	morph = isl_morph_set_ran_tuple_id(morph, id);
+	return morph;
 }
 
 /* Construct a parameter compression for "bset".
@@ -579,9 +564,9 @@
 __isl_give isl_morph *isl_basic_set_parameter_compression(
 	__isl_keep isl_basic_set *bset)
 {
-	unsigned nparam;
-	unsigned nvar;
-	unsigned n_div;
+	isl_size nparam;
+	isl_size nvar;
+	isl_size n_div;
 	int n_eq;
 	isl_mat *H, *B;
 	isl_mat *map, *inv;
@@ -599,6 +584,8 @@
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
 	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	if (nparam < 0 || nvar < 0 || n_div < 0)
+		return NULL;
 
 	if (isl_seq_first_non_zero(bset->eqbset->n_eq - 1 + 1 + nparam,
 				    nvar + n_div) == -1)
@@ -622,196 +609,96 @@
 	return isl_morph_alloc(dom, ran, map, inv);
 }
 
-/* Add stride constraints to "bset" based on the inverse mapping
- * that was plugged in.  In particular, if morph maps x' to x,
- * the the constraints of the original input
- *
- *	A x' + b >= 0
- *
- * have been rewritten to
- *
- *	A inv x + b >= 0
- *
- * However, this substitution may loose information on the integrality of x',
- * so we need to impose that
- *
- *	inv x
- *
- * is integral.  If inv = B/d, this means that we need to impose that
- *
- *	B x = 0		mod d
- *
- * or
- *
- *	exists alpha in Z^m: B x = d alpha
- *
- * This function is similar to add_strides in isl_affine_hull.c
+/* Construct an isl_multi_aff that corresponds
+ * to the affine transformation matrix "mat" and
+ * that lives in an anonymous space.
  */
-static __isl_give isl_basic_set *add_strides(__isl_take isl_basic_set *bset,
-	__isl_keep isl_morph *morph)
+static __isl_give isl_multi_aff *isl_multi_aff_from_aff_mat_anonymous(
+	__isl_take isl_mat *mat)
 {
-	int i, div, k;
-	isl_int gcd;
-
-	if (isl_int_is_one(morph->inv->row00))
-		return bset;
-
-	isl_int_init(gcd);
-
-	for (i = 0; 1 + i < morph->inv->n_row; ++i) {
-		isl_seq_gcd(morph->inv->row1 + i, morph->inv->n_col, &gcd);
-		if (isl_int_is_divisible_by(gcd, morph->inv->row00))
-			continue;
-		div = isl_basic_set_alloc_div(bset);
-		if (div < 0)
-			goto error;
-		isl_int_set_si(bset->divdiv0, 0);
-		k = isl_basic_set_alloc_equality(bset);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bset->eqk, morph->inv->row1 + i,
-			    morph->inv->n_col);
-		isl_seq_clr(bset->eqk + morph->inv->n_col, bset->n_div);
-		isl_int_set(bset->eqkmorph->inv->n_col + div,
-			    morph->inv->row00);
-	}
-
-	isl_int_clear(gcd);
-
-	return bset;
-error:
-	isl_int_clear(gcd);
-	isl_basic_set_free(bset);
-	return NULL;
+	isl_size n_row, n_col;
+	isl_ctx *ctx;
+	isl_space *space;
+
+	ctx = isl_mat_get_ctx(mat);
+	n_row = isl_mat_rows(mat);
+	n_col = isl_mat_cols(mat);
+	if (n_row < 0 || n_col < 0)
+		space = NULL;
+	else
+		space = isl_space_alloc(ctx, 0, n_col - 1, n_row - 1);
+
+	return isl_multi_aff_from_aff_mat(space, mat);
 }
 
 /* Apply the morphism to the basic set.
- * We basically just compute the preimage of "bset" under the inverse mapping
- * in morph, add in stride constraints and intersect with the range
- * of the morphism.
+ * In particular, compute the preimage of "bset" under the inverse mapping
+ * in morph and intersect with the range of the morphism.
+ * Note that the mapping in morph applies to both parameters and set dimensions,
+ * so the parameters need to be treated as set dimensions during the call
+ * to isl_basic_set_preimage_multi_aff.
  */
 __isl_give isl_basic_set *isl_morph_basic_set(__isl_take isl_morph *morph,
 	__isl_take isl_basic_set *bset)
 {
-	isl_basic_set *res = NULL;
-	isl_mat *mat = NULL;
-	int i, k;
-	int max_stride;
-
-	if (!morph || !bset)
-		goto error;
-
-	isl_assert(bset->ctx, isl_space_is_equal(bset->dim, morph->dom->dim),
-		    goto error);
-
-	max_stride = morph->inv->n_row - 1;
-	if (isl_int_is_one(morph->inv->row00))
-		max_stride = 0;
-	res = isl_basic_set_alloc_space(isl_space_copy(morph->ran->dim),
-		bset->n_div + max_stride, bset->n_eq + max_stride, bset->n_ineq);
-
-	for (i = 0; i < bset->n_div; ++i)
-		if (isl_basic_set_alloc_div(res) < 0)
-			goto error;
-
-	mat = isl_mat_sub_alloc6(bset->ctx, bset->eq, 0, bset->n_eq,
-					0, morph->inv->n_row);
-	mat = isl_mat_product(mat, isl_mat_copy(morph->inv));
-	if (!mat)
-		goto error;
-	for (i = 0; i < bset->n_eq; ++i) {
-		k = isl_basic_set_alloc_equality(res);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(res->eqk, mat->rowi, mat->n_col);
-		isl_seq_scale(res->eqk + mat->n_col, bset->eqi + mat->n_col,
-				morph->inv->row00, bset->n_div);
-	}
-	isl_mat_free(mat);
+	isl_size n_param;
+	isl_space *space;
+	isl_multi_aff *ma;
 
-	mat = isl_mat_sub_alloc6(bset->ctx, bset->ineq, 0, bset->n_ineq,
-					0, morph->inv->n_row);
-	mat = isl_mat_product(mat, isl_mat_copy(morph->inv));
-	if (!mat)
+	if (!morph || isl_basic_set_check_equal_space(bset, morph->dom) < 0)
 		goto error;
-	for (i = 0; i < bset->n_ineq; ++i) {
-		k = isl_basic_set_alloc_inequality(res);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(res->ineqk, mat->rowi, mat->n_col);
-		isl_seq_scale(res->ineqk + mat->n_col,
-				bset->ineqi + mat->n_col,
-				morph->inv->row00, bset->n_div);
-	}
-	isl_mat_free(mat);
-
-	mat = isl_mat_sub_alloc6(bset->ctx, bset->div, 0, bset->n_div,
-					1, morph->inv->n_row);
-	mat = isl_mat_product(mat, isl_mat_copy(morph->inv));
-	if (!mat)
+	n_param = isl_basic_set_dim(morph->dom, isl_dim_param);
+	if (n_param < 0)
 		goto error;
-	for (i = 0; i < bset->n_div; ++i) {
-		isl_int_mul(res->divi0,
-				morph->inv->row00, bset->divi0);
-		isl_seq_cpy(res->divi + 1, mat->rowi, mat->n_col);
-		isl_seq_scale(res->divi + 1 + mat->n_col,
-				bset->divi + 1 + mat->n_col,
-				morph->inv->row00, bset->n_div);
-	}
-	isl_mat_free(mat);
-
-	res = add_strides(res, morph);
 
-	if (isl_basic_set_is_rational(bset))
-		res = isl_basic_set_set_rational(res);
+	ma = isl_multi_aff_from_aff_mat_anonymous(isl_mat_copy(morph->inv));
 
-	res = isl_basic_set_simplify(res);
-	res = isl_basic_set_finalize(res);
-
-	res = isl_basic_set_intersect(res, isl_basic_set_copy(morph->ran));
+	bset = isl_basic_set_move_dims(bset, isl_dim_set, 0,
+					isl_dim_param, 0, n_param);
+	bset = isl_basic_set_preimage_multi_aff(bset, ma);
+	space = isl_basic_set_get_space(morph->ran);
+	bset = isl_basic_set_reset_space(bset, space);
+	bset = isl_basic_set_intersect(bset, isl_basic_set_copy(morph->ran));
 
 	isl_morph_free(morph);
-	isl_basic_set_free(bset);
-	return res;
+	return bset;
 error:
-	isl_mat_free(mat);
 	isl_morph_free(morph);
 	isl_basic_set_free(bset);
-	isl_basic_set_free(res);
 	return NULL;
 }
 
 /* Apply the morphism to the set.
+ * In particular, compute the preimage of "set" under the inverse mapping
+ * in morph and intersect with the range of the morphism.
+ * Note that the mapping in morph applies to both parameters and set dimensions,
+ * so the parameters need to be treated as set dimensions during the call
+ * to isl_set_preimage_multi_aff.
  */
 __isl_give isl_set *isl_morph_set(__isl_take isl_morph *morph,
 	__isl_take isl_set *set)
 {
-	int i;
+	isl_size n_param;
+	isl_space *space;
+	isl_multi_aff *ma;
+	isl_basic_set *ran;
 
-	if (!morph || !set)
+	if (!morph || isl_set_basic_set_check_equal_space(set, morph->dom) < 0)
 		goto error;
-
-	isl_assert(set->ctx, isl_space_is_equal(set->dim, morph->dom->dim), goto error);
-
-	set = isl_set_cow(set);
-	if (!set)
+	n_param = isl_basic_set_dim(morph->dom, isl_dim_param);
+	if (n_param < 0)
 		goto error;
 
-	isl_space_free(set->dim);
-	set->dim = isl_space_copy(morph->ran->dim);
-	if (!set->dim)
-		goto error;
+	ma = isl_multi_aff_from_aff_mat_anonymous(isl_mat_copy(morph->inv));
 
-	for (i = 0; i < set->n; ++i) {
-		set->pi = isl_morph_basic_set(isl_morph_copy(morph), set->pi);
-		if (!set->pi)
-			goto error;
-	}
+	set = isl_set_move_dims(set, isl_dim_set, 0, isl_dim_param, 0, n_param);
+	set = isl_set_preimage_multi_aff(set, ma);
+	space = isl_basic_set_get_space(morph->ran);
+	set = isl_set_reset_space(set, space);
+	ran = isl_basic_set_copy(morph->ran);
+	set = isl_set_intersect(set, isl_set_from_basic_set(ran));
 
 	isl_morph_free(morph);
-
-	ISL_F_CLR(set, ISL_SET_NORMALIZED);
-
 	return set;
 error:
 	isl_set_free(set);
@@ -869,7 +756,7 @@
 	return morph;
 }
 
-/* We detect all the equalities first to avoid implicit equalties
+/* We detect all the equalities first to avoid implicit equalities
  * being discovered during the computations.  In particular,
  * the compression on the variables could expose additional stride
  * constraints on the parameters.  This would result in existentially

_service:tar_scm:isl-0.14.tar.xz/isl_morph.h -> _service:tar_scm:isl-0.24.tar.gz/isl_morph.h Changed

@@ -12,6 +12,7 @@
 #define ISL_MORHP_H
 
 #include <stdio.h>
+#include <isl/id_type.h>
 #include <isl/space.h>
 #include <isl/mat.h>
 #include <isl/set.h>
@@ -42,14 +43,17 @@
 	__isl_take isl_mat *map, __isl_take isl_mat *inv);
 __isl_give isl_morph *isl_morph_copy(__isl_keep isl_morph *morph);
 __isl_give isl_morph *isl_morph_identity(__isl_keep isl_basic_set *bset);
-void isl_morph_free(__isl_take isl_morph *morph);
+__isl_null isl_morph *isl_morph_free(__isl_take isl_morph *morph);
+
+isl_stat isl_morph_check_applies(__isl_keep isl_morph *morph,
+	__isl_keep isl_space *space);
 
 __isl_give isl_space *isl_morph_get_dom_space(__isl_keep isl_morph *morph);
 __isl_give isl_space *isl_morph_get_ran_space(__isl_keep isl_morph *morph);
 __isl_give isl_multi_aff *isl_morph_get_var_multi_aff(
 	__isl_keep isl_morph *morph);
-unsigned isl_morph_dom_dim(__isl_keep isl_morph *morph, enum isl_dim_type type);
-unsigned isl_morph_ran_dim(__isl_keep isl_morph *morph, enum isl_dim_type type);
+isl_size isl_morph_dom_dim(__isl_keep isl_morph *morph, enum isl_dim_type type);
+isl_size isl_morph_ran_dim(__isl_keep isl_morph *morph, enum isl_dim_type type);
 
 __isl_give isl_morph *isl_morph_remove_dom_dims(__isl_take isl_morph *morph,
 	enum isl_dim_type type, unsigned first, unsigned n);
@@ -67,6 +71,8 @@
 
 __isl_give isl_morph *isl_basic_set_variable_compression(
 	__isl_keep isl_basic_set *bset, enum isl_dim_type type);
+__isl_give isl_morph *isl_basic_set_variable_compression_with_id(
+	__isl_keep isl_basic_set *bset, __isl_keep isl_id *id);
 __isl_give isl_morph *isl_basic_set_parameter_compression(
 	__isl_keep isl_basic_set *bset);
 __isl_give isl_morph *isl_basic_set_full_compression(

_service:tar_scm:isl-0.24.tar.gz/isl_multi_add_constant_templ.c Added

@@ -0,0 +1,93 @@
+/*
+ * Copyright 2019      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#include <isl_multi_macro.h>
+
+/* Add "v" to the constant terms of all the base expressions of "multi".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),add_constant_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_val *v)
+{
+	isl_bool zero;
+	isl_size n;
+	int i;
+
+	zero = isl_val_is_zero(v);
+	n = FN(MULTI(BASE),size)(multi);
+	if (zero < 0 || n < 0)
+		goto error;
+	if (zero || n == 0) {
+		isl_val_free(v);
+		return multi;
+	}
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		multi->u.pi = FN(EL,add_constant_val)(multi->u.pi,
+							    isl_val_copy(v));
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_val_free(v);
+	return multi;
+error:
+	FN(MULTI(BASE),free)(multi);
+	isl_val_free(v);
+	return NULL;
+}
+
+/* Add the elements of "mv" to the constant terms of
+ * the corresponding base expressions of "multi".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),add_constant_multi_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
+{
+	isl_space *multi_space, *mv_space;
+	isl_bool zero, equal;
+	isl_size n;
+	int i;
+
+	zero = isl_multi_val_is_zero(mv);
+	n = FN(MULTI(BASE),size)(multi);
+	multi_space = FN(MULTI(BASE),peek_space)(multi);
+	mv_space = isl_multi_val_peek_space(mv);
+	equal = isl_space_tuple_is_equal(multi_space, isl_dim_out,
+					mv_space, isl_dim_out);
+	if (zero < 0 || n < 0 || equal < 0)
+		goto error;
+	if (!equal)
+		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
+			"spaces don't match", goto error);
+	if (zero || n == 0) {
+		isl_multi_val_free(mv);
+		return multi;
+	}
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		isl_val *v = isl_multi_val_get_at(mv, i);
+		multi->u.pi = FN(EL,add_constant_val)(multi->u.pi, v);
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_multi_val_free(mv);
+	return multi;
+error:
+	FN(MULTI(BASE),free)(multi);
+	isl_multi_val_free(mv);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_align_set.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_align_templ.c Added

@@ -0,0 +1,45 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ */
+
+/* Align the parameters of "multi" and "domain" (if needed) and
+ * call "fn".
+ */
+static __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),align_params),ALIGN_DOMBASE)(
+	__isl_take MULTI(BASE) *multi, __isl_take ALIGN_DOM *domain,
+	__isl_give MULTI(BASE) *fn(__isl_take MULTI(BASE) *multi,
+		__isl_take ALIGN_DOM *domain))
+{
+	isl_bool aligned;
+	isl_bool named;
+	isl_space *dom_space;
+
+	aligned = FN(ALIGN_DOM,space_has_equal_params)(domain, multi->space);
+	if (aligned < 0)
+		goto error;
+	if (aligned)
+		return fn(multi, domain);
+
+	dom_space = FN(ALIGN_DOM,peek_space)(domain);
+	named = isl_space_has_named_params(multi->space);
+	if (named >= 0 && named)
+		named = isl_space_has_named_params(dom_space);
+	if (named < 0)
+		goto error;
+	if (!named)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+			"unaligned unnamed parameters", goto error);
+	multi = FN(MULTI(BASE),align_params)(multi,
+					    FN(ALIGN_DOM,get_space)(domain));
+	domain = FN(ALIGN_DOM,align_params)(domain,
+					    FN(MULTI(BASE),get_space)(multi));
+	return fn(multi, domain);
+error:
+	FN(MULTI(BASE),free)(multi);
+	FN(ALIGN_DOM,free)(domain);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_align_union_set.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_apply_set.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_apply_templ.c Added

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <isl_multi_macro.h>
+
+/* Transform the elements of "multi" by applying "fn" to them
+ * with extra argument "set".
+ *
+ * The parameters of "multi" and "set" are assumed to have been aligned.
+ */
+__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),apply_aligned),APPLY_DOMBASE)(
+	__isl_take MULTI(BASE) *multi, __isl_take APPLY_DOM *set,
+	__isl_give EL *(*fn)(EL *el, __isl_take APPLY_DOM *set))
+{
+	int i;
+
+	if (!multi || !set)
+		goto error;
+
+	if (multi->n == 0) {
+		FN(APPLY_DOM,free)(set);
+		return multi;
+	}
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = fn(multi->u.pi, FN(APPLY_DOM,copy)(set));
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	FN(APPLY_DOM,free)(set);
+	return multi;
+error:
+	FN(APPLY_DOM,free)(set);
+	FN(MULTI(BASE),free)(multi);
+	return NULL;
+}
+
+/* Transform the elements of "multi" by applying "fn" to them
+ * with extra argument "set".
+ *
+ * Align the parameters if needed and call apply_set_aligned.
+ */
+static __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),apply),APPLY_DOMBASE)(
+	__isl_take MULTI(BASE) *multi, __isl_take APPLY_DOM *set,
+	__isl_give EL *(*fn)(EL *el, __isl_take APPLY_DOM *set))
+{
+	isl_bool aligned;
+	isl_ctx *ctx;
+
+	if (!multi || !set)
+		goto error;
+
+	aligned = FN(APPLY_DOM,space_has_equal_params)(set, multi->space);
+	if (aligned < 0)
+		goto error;
+	if (aligned)
+		return FN(FN(MULTI(BASE),apply_aligned),APPLY_DOMBASE)(multi,
+								    set, fn);
+	ctx = FN(MULTI(BASE),get_ctx)(multi);
+	if (!isl_space_has_named_params(multi->space) ||
+	    !isl_space_has_named_params(set->dim))
+		isl_die(ctx, isl_error_invalid,
+			"unaligned unnamed parameters", goto error);
+	multi = FN(MULTI(BASE),align_params)(multi,
+						FN(APPLY_DOM,get_space)(set));
+	set = FN(APPLY_DOM,align_params)(set, FN(MULTI(BASE),get_space)(multi));
+	return FN(FN(MULTI(BASE),apply_aligned),APPLY_DOMBASE)(multi, set, fn);
+error:
+	FN(MULTI(BASE),free)(multi);
+	FN(APPLY_DOM,free)(set);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_apply_union_set.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_arith_templ.c Added

@@ -0,0 +1,234 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl_val_private.h>
+
+#include <isl_multi_macro.h>
+
+/* Add "multi2" to "multi1" and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),add)(__isl_take MULTI(BASE) *multi1,
+	__isl_take MULTI(BASE) *multi2)
+{
+	return FN(MULTI(BASE),bin_op)(multi1, multi2, &FN(EL,add));
+}
+
+/* Subtract "multi2" from "multi1" and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),sub)(__isl_take MULTI(BASE) *multi1,
+	__isl_take MULTI(BASE) *multi2)
+{
+	return FN(MULTI(BASE),bin_op)(multi1, multi2, &FN(EL,sub));
+}
+
+/* Multiply the elements of "multi" by "v" and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_val)(__isl_take MULTI(BASE) *multi,
+	__isl_take isl_val *v)
+{
+	int i;
+
+	if (!multi || !v)
+		goto error;
+
+	if (isl_val_is_one(v)) {
+		isl_val_free(v);
+		return multi;
+	}
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational factor", goto error);
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,scale_val)(multi->u.pi,
+						isl_val_copy(v));
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_val_free(v);
+	return multi;
+error:
+	isl_val_free(v);
+	return FN(MULTI(BASE),free)(multi);
+}
+
+/* Divide the elements of "multi" by "v" and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_down_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_val *v)
+{
+	int i;
+
+	if (!multi || !v)
+		goto error;
+
+	if (isl_val_is_one(v)) {
+		isl_val_free(v);
+		return multi;
+	}
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational factor", goto error);
+	if (isl_val_is_zero(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"cannot scale down by zero", goto error);
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,scale_down_val)(multi->u.pi,
+						    isl_val_copy(v));
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_val_free(v);
+	return multi;
+error:
+	isl_val_free(v);
+	return FN(MULTI(BASE),free)(multi);
+}
+
+/* Multiply the elements of "multi" by the corresponding element of "mv"
+ * and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_multi_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
+{
+	int i;
+
+	if (!multi || !mv)
+		goto error;
+
+	if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
+					mv->space, isl_dim_set))
+		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
+			"spaces don't match", goto error);
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	for (i = 0; i < multi->n; ++i) {
+		isl_val *v;
+
+		v = isl_multi_val_get_val(mv, i);
+		multi->u.pi = FN(EL,scale_val)(multi->u.pi, v);
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_multi_val_free(mv);
+	return multi;
+error:
+	isl_multi_val_free(mv);
+	return FN(MULTI(BASE),free)(multi);
+}
+
+/* Divide the elements of "multi" by the corresponding element of "mv"
+ * and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_down_multi_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
+{
+	int i;
+
+	if (!multi || !mv)
+		goto error;
+
+	if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
+					mv->space, isl_dim_set))
+		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
+			"spaces don't match", goto error);
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		isl_val *v;
+
+		v = isl_multi_val_get_val(mv, i);
+		multi->u.pi = FN(EL,scale_down_val)(multi->u.pi, v);
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_multi_val_free(mv);
+	return multi;
+error:
+	isl_multi_val_free(mv);
+	return FN(MULTI(BASE),free)(multi);
+}
+
+/* Compute the residues of the elements of "multi" modulo
+ * the corresponding element of "mv" and return the result.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),mod_multi_val)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
+{
+	int i;
+
+	if (!multi || !mv)
+		goto error;
+
+	if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
+					mv->space, isl_dim_set))
+		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
+			"spaces don't match", goto error);
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	for (i = 0; i < multi->n; ++i) {
+		isl_val *v;
+
+		v = isl_multi_val_get_val(mv, i);
+		multi->u.pi = FN(EL,mod_val)(multi->u.pi, v);
+		if (!multi->u.pi)
+			goto error;
+	}
+
+	isl_multi_val_free(mv);
+	return multi;
+error:
+	isl_multi_val_free(mv);
+	return FN(MULTI(BASE),free)(multi);
+}
+
+/* Return the opposite of "multi".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),neg)(__isl_take MULTI(BASE) *multi)
+{
+	int i;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,neg)(multi->u.pi);
+		if (!multi->u.pi)
+			return FN(MULTI(BASE),free)(multi);
+	}
+
+	return multi;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_bind_domain_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_bind_templ.c Added

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2018      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+/* Bind the expressions of "multi" to parameters with identifiers
+ * specified by "tuple", living in the same space as
+ * (the target space of) "multi",
+ * returning the elements in the domain where the expressions
+ * are equal to the parameters.
+ */
+__isl_give DOM *FN(MULTI(BASE),bind)(__isl_take MULTI(BASE) *multi,
+	__isl_take isl_multi_id *tuple)
+{
+	int i;
+	isl_id *id;
+	isl_stat r;
+	isl_size n;
+	isl_space *multi_space, *tuple_space;
+	EL *el;
+	DOM *bnd;
+
+	multi_space = isl_space_range(FN(MULTI(BASE),get_space)(multi));
+	tuple_space = isl_multi_id_peek_space(tuple);
+	r = isl_space_check_equal_tuples(multi_space, tuple_space);
+	isl_space_free(multi_space);
+	if (r < 0)
+		goto error;
+	n = FN(MULTI(BASE),dim)(multi, isl_dim_set);
+	if (n < 0)
+		goto error;
+
+	if (n == 0) {
+		isl_multi_id_free(tuple);
+		return FN(MULTI(BASE),domain)(multi);
+	}
+
+	el = FN(MULTI(BASE),get_at)(multi, 0);
+	id = isl_multi_id_get_at(tuple, 0);
+	bnd = FN(EL,bind_id)(el, id);
+
+	for (i = 1; i < n; ++i) {
+		DOM *bnd_i;
+
+		el = FN(MULTI(BASE),get_at)(multi, i);
+		id = isl_multi_id_get_at(tuple, i);
+		bnd_i = FN(EL,bind_id)(el, id);
+
+		bnd_i = FN(DOM,align_params)(bnd_i, FN(DOM,get_space)(bnd));
+		bnd = FN(DOM,align_params)(bnd, FN(DOM,get_space)(bnd_i));
+		bnd = FN(DOM,intersect)(bnd, bnd_i);
+	}
+
+	FN(MULTI(BASE),free)(multi);
+	isl_multi_id_free(tuple);
+	return bnd;
+error:
+	FN(MULTI(BASE),free)(multi);
+	isl_multi_id_free(tuple);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_cmp.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_coalesce.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_dim_id_templ.c Added

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Return the position of the dimension of the given type and name
+ * in "multi".
+ * Return -1 if no such dimension can be found.
+ */
+int FN(MULTI(BASE),find_dim_by_name)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type, const char *name)
+{
+	if (!multi)
+		return -1;
+	return isl_space_find_dim_by_name(multi->space, type, name);
+}
+
+/* Return the position of the first dimension of "type" with id "id".
+ * Return -1 if there is no such dimension.
+ */
+int FN(MULTI(BASE),find_dim_by_id)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type, __isl_keep isl_id *id)
+{
+	if (!multi)
+		return -1;
+	return isl_space_find_dim_by_id(multi->space, type, id);
+}
+
+/* Return the id of the given dimension.
+ */
+__isl_give isl_id *FN(MULTI(BASE),get_dim_id)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos)
+{
+	return multi ? isl_space_get_dim_id(multi->space, type, pos) : NULL;
+}
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_name)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos, const char *s)
+{
+	int i;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	multi->space = isl_space_set_dim_name(multi->space, type, pos, s);
+	if (!multi->space)
+		return FN(MULTI(BASE),free)(multi);
+
+	if (type == isl_dim_out)
+		return multi;
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,set_dim_name)(multi->u.pi,
+							type, pos, s);
+		if (!multi->u.pi)
+			return FN(MULTI(BASE),free)(multi);
+	}
+
+	return multi;
+}
+
+/* Set the id of the given dimension of "multi" to "id".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_id)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
+{
+	isl_space *space;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi || !id)
+		goto error;
+
+	space = FN(MULTI(BASE),get_space)(multi);
+	space = isl_space_set_dim_id(space, type, pos, id);
+
+	return FN(MULTI(BASE),reset_space)(multi, space);
+error:
+	isl_id_free(id);
+	FN(MULTI(BASE),free)(multi);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_dims.c Added

@@ -0,0 +1,119 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl_space_private.h>
+
+#include <isl_multi_macro.h>
+
+/* Check whether "multi" has non-zero coefficients for any dimension
+ * in the given range or if any of these dimensions appear
+ * with non-zero coefficients in any of the integer divisions involved.
+ */
+isl_bool FN(MULTI(BASE),involves_dims)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	int i;
+
+	if (!multi)
+		return isl_bool_error;
+	if (n == 0)
+		return isl_bool_false;
+
+	for (i = 0; i < multi->n; ++i) {
+		isl_bool involves;
+
+		involves = FN(EL,involves_dims)(multi->u.pi, type, first, n);
+		if (involves < 0 || involves)
+			return involves;
+	}
+
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		return FN(MULTI(BASE),involves_explicit_domain_dims)(multi,
+								type, first, n);
+
+	return isl_bool_false;
+}
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),insert_dims)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	int i;
+
+	if (!multi)
+		return NULL;
+	if (type == isl_dim_out)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+			"cannot insert output/set dimensions",
+			return FN(MULTI(BASE),free)(multi));
+	if (n == 0 && !isl_space_is_named_or_nested(multi->space, type))
+		return multi;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	multi->space = isl_space_insert_dims(multi->space, type, first, n);
+	if (!multi->space)
+		return FN(MULTI(BASE),free)(multi);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		multi = FN(MULTI(BASE),insert_explicit_domain_dims)(multi,
+								type, first, n);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,insert_dims)(multi->u.pi,
+							type, first, n);
+		if (!multi->u.pi)
+			return FN(MULTI(BASE),free)(multi);
+	}
+
+	return multi;
+}
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),add_dims)(__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned n)
+{
+	isl_size pos;
+
+	pos = FN(MULTI(BASE),dim)(multi, type);
+	if (pos < 0)
+		return FN(MULTI(BASE),free)(multi);
+
+	return FN(MULTI(BASE),insert_dims)(multi, type, pos, n);
+}
+
+/* Project the domain of "multi" onto its parameter space.
+ * "multi" may not involve any of the domain dimensions.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),project_domain_on_params)(
+	__isl_take MULTI(BASE) *multi)
+{
+	isl_size n;
+	isl_bool involves;
+	isl_space *space;
+
+	n = FN(MULTI(BASE),dim)(multi, isl_dim_in);
+	if (n < 0)
+		return FN(MULTI(BASE),free)(multi);
+	involves = FN(MULTI(BASE),involves_dims)(multi, isl_dim_in, 0, n);
+	if (involves < 0)
+		return FN(MULTI(BASE),free)(multi);
+	if (involves)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+		    "expression involves some of the domain dimensions",
+		    return FN(MULTI(BASE),free)(multi));
+	multi = FN(MULTI(BASE),drop_dims)(multi, isl_dim_in, 0, n);
+	space = FN(MULTI(BASE),get_domain_space)(multi);
+	space = isl_space_params(space);
+	multi = FN(MULTI(BASE),reset_domain_space)(multi, space);
+	return multi;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_domain_templ.c Added

@@ -0,0 +1,42 @@
+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/set.h>
+
+#include <isl_multi_macro.h>
+
+/* Return the shared domain of the elements of "multi".
+ *
+ * If "multi" has an explicit domain, then return this domain.
+ */
+__isl_give isl_set *FN(MULTI(BASE),domain)(__isl_take MULTI(BASE) *multi)
+{
+	int i;
+	isl_set *dom;
+
+	if (!multi)
+		return NULL;
+
+	if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
+		dom = FN(MULTI(BASE),get_explicit_domain)(multi);
+		FN(MULTI(BASE),free)(multi);
+		return dom;
+	}
+
+	dom = isl_set_universe(FN(MULTI(BASE),get_domain_space)(multi));
+	for (i = 0; i < multi->n; ++i) {
+		isl_set *dom_i;
+
+		dom_i = FN(EL,domain)(FN(FN(MULTI(BASE),get),BASE)(multi, i));
+		dom = isl_set_intersect(dom, dom_i);
+	}
+
+	FN(MULTI(BASE),free)(multi);
+	return dom;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_explicit_domain.c Added

@@ -0,0 +1,205 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* These versions of the explicit domain functions are used
+ * when the multi expression may have an explicit domain.
+ */
+
+#include <isl_multi_macro.h>
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),cow)(__isl_take MULTI(BASE) *multi);
+
+/* Does "multi" have an explicit domain?
+ *
+ * An explicit domain is only available if "multi" is zero-dimensional.
+ */
+static int FN(MULTI(BASE),has_explicit_domain)(__isl_keep MULTI(BASE) *multi)
+{
+	return multi && multi->n == 0;
+}
+
+/* Check that "multi" has an explicit domain.
+ */
+static isl_stat FN(MULTI(BASE),check_has_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	if (!multi)
+		return isl_stat_error;
+	if (!FN(MULTI(BASE),has_explicit_domain)(multi))
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_internal,
+			"expression does not have an explicit domain",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Return the explicit domain of "multi", assuming it has one.
+ */
+static __isl_keep DOM *FN(MULTI(BASE),peek_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi) < 0)
+		return NULL;
+	return multi->u.dom;
+}
+
+/* Return a copy of the explicit domain of "multi", assuming it has one.
+ */
+static __isl_give DOM *FN(MULTI(BASE),get_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	return FN(DOM,copy)(FN(MULTI(BASE),peek_explicit_domain)(multi));
+}
+
+/* Replace the explicit domain of "multi" by "dom", assuming it has one.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),set_explicit_domain)(
+	__isl_take MULTI(BASE) *multi, __isl_take DOM *dom)
+{
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi) < 0)
+		goto error;
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi || !dom)
+		goto error;
+	FN(DOM,free)(multi->u.dom);
+	multi->u.dom = dom;
+	if (!multi->u.dom)
+		return FN(MULTI(BASE),free)(multi);
+	return multi;
+error:
+	FN(MULTI(BASE),free)(multi);
+	FN(DOM,free)(dom);
+	return NULL;
+}
+
+/* Intersect the domain of "dst" with the explicit domain of "src".
+ *
+ * In the case of isl_multi_union_pw_aff objects, the explicit domain
+ * of "src" is allowed to have only constraints on the parameters, even
+ * if the domain of "dst" contains actual domain elements.  In this case,
+ * the domain of "dst" is intersected with those parameter constraints.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_explicit_domain)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src)
+{
+	isl_bool is_params;
+	DOM *dom;
+
+	dom = FN(MULTI(BASE),peek_explicit_domain)(src);
+	is_params = FN(DOM,is_params)(dom);
+	if (is_params < 0)
+		return FN(MULTI(BASE),free)(dst);
+
+	dom = FN(DOM,copy)(dom);
+	if (!is_params) {
+		dst = FN(MULTI(BASE),intersect_domain)(dst, dom);
+	} else {
+		isl_set *params;
+
+		params = FN(DOM,params)(dom);
+		dst = FN(MULTI(BASE),intersect_params)(dst, params);
+	}
+
+	return dst;
+}
+
+/* Set the explicit domain of "dst" to that of "src".
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),copy_explicit_domain)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src)
+{
+	DOM *dom;
+
+	dom = FN(MULTI(BASE),get_explicit_domain)(src);
+	dst = FN(MULTI(BASE),set_explicit_domain)(dst, dom);
+
+	return dst;
+}
+
+/* Align the parameters of the explicit domain of "multi" to those of "space".
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_explicit_domain_params)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
+{
+	DOM *dom;
+
+	dom = FN(MULTI(BASE),get_explicit_domain)(multi);
+	dom = FN(DOM,align_params)(dom, space);
+	multi = FN(MULTI(BASE),set_explicit_domain)(multi, dom);
+
+	return multi;
+}
+
+/* Replace the space of the explicit domain of "multi" by "space",
+ * without modifying its dimension.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_explicit_domain_space)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
+{
+	DOM *dom;
+
+	dom = FN(MULTI(BASE),get_explicit_domain)(multi);
+	dom = FN(DOM,reset_equal_dim_space)(dom, space);
+	multi = FN(MULTI(BASE),set_explicit_domain)(multi, dom);
+
+	return multi;
+}
+
+/* Free the explicit domain of "multi".
+ */
+static void FN(MULTI(BASE),free_explicit_domain)(__isl_keep MULTI(BASE) *multi)
+{
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi) < 0)
+		return;
+	FN(DOM,free)(multi->u.dom);
+}
+
+/* Do "multi1" and "multi2" have the same explicit domain?
+ */
+static isl_bool FN(MULTI(BASE),equal_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi1, __isl_keep MULTI(BASE) *multi2)
+{
+	DOM *dom1, *dom2;
+	isl_bool equal;
+
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi1) < 0 ||
+	    FN(MULTI(BASE),check_has_explicit_domain)(multi2) < 0)
+		return isl_bool_error;
+	dom1 = FN(MULTI(BASE),get_explicit_domain)(multi1);
+	dom2 = FN(MULTI(BASE),get_explicit_domain)(multi2);
+	equal = FN(DOM,is_equal)(dom1, dom2);
+	FN(DOM,free)(dom1);
+	FN(DOM,free)(dom2);
+
+	return equal;
+}
+
+static isl_stat FN(MULTI(BASE),check_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi) __attribute__ ((unused));
+
+/* Debugging function to check that the explicit domain of "multi"
+ * has the correct space.
+ */
+isl_stat FN(MULTI(BASE),check_explicit_domain)(__isl_keep MULTI(BASE) *multi)
+{
+	isl_space *space1, *space2;
+	isl_bool equal;
+
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi) < 0)
+		return isl_stat_error;
+	space1 = isl_space_domain(isl_space_copy(multi->space));
+	space2 = FN(DOM,get_space)(multi->u.dom);
+	equal = isl_space_is_equal(space1, space2);
+	isl_space_free(space1);
+	isl_space_free(space2);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_internal,
+			"check failed", return isl_stat_error);
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_floor.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_from_base_templ.c Added

@@ -0,0 +1,37 @@
+/*
+ * Copyright 2012,2014 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Create a multiple expression with a single output/set dimension
+ * equal to "el".
+ * For most multiple expression types, the base type has a single
+ * output/set dimension and the space of the result is therefore
+ * the same as the space of the input.
+ * In the case of isl_multi_union_pw_aff, however, the base type
+ * lives in a parameter space and we therefore need to add
+ * a single set dimension.
+ */
+__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),BASE)(__isl_take EL *el)
+{
+	isl_space *space;
+	MULTI(BASE) *multi;
+
+	space = FN(EL,get_space(el));
+	if (isl_space_is_params(space)) {
+		space = isl_space_set_from_params(space);
+		space = isl_space_add_dims(space, isl_dim_set, 1);
+	}
+	multi = FN(MULTI(BASE),alloc)(space);
+	multi = FN(FN(MULTI(BASE),set),BASE)(multi, 0, el);
+
+	return multi;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_gist.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_hash.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_identity_templ.c Added

@@ -0,0 +1,96 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl/local_space.h>
+
+#include <isl_multi_macro.h>
+
+/* Create a multi expression in the given space that maps each
+ * input dimension to the corresponding output dimension.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),identity)(__isl_take isl_space *space)
+{
+	int i;
+	isl_size n_in, n_out;
+	isl_local_space *ls;
+	MULTI(BASE) *multi;
+
+	if (!space)
+		return NULL;
+
+	if (isl_space_is_set(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting map space", goto error);
+
+	n_in = isl_space_dim(space, isl_dim_in);
+	n_out = isl_space_dim(space, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		goto error;
+	if (n_in != n_out)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"number of input and output dimensions needs to be "
+			"the same", goto error);
+
+	multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
+
+	if (!n_out) {
+		isl_space_free(space);
+		return multi;
+	}
+
+	space = isl_space_domain(space);
+	ls = isl_local_space_from_space(space);
+
+	for (i = 0; i < n_out; ++i) {
+		EL *el;
+		el = FN(EL,var_on_domain)(isl_local_space_copy(ls),
+						isl_dim_set, i);
+		multi = FN(FN(MULTI(BASE),set),BASE)(multi, i, el);
+	}
+
+	isl_local_space_free(ls);
+
+	return multi;
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Create a multi expression that maps elements in the given space
+ * to themselves.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),identity_on_domain_space)(
+	__isl_take isl_space *space)
+{
+	return FN(MULTI(BASE),identity)(isl_space_map_from_set(space));
+}
+
+/* This function performs the same operation as
+ * isl_multi_*_identity_on_domain_space,
+ * but is considered as a function on an isl_space when exported.
+ */
+__isl_give MULTI(BASE) *FN(FN(isl_space_identity_multi,BASE),on_domain)(
+	__isl_take isl_space *space)
+{
+	return FN(MULTI(BASE),identity_on_domain_space)(space);
+}
+
+/* Create a multi expression in the same space as "multi" that maps each
+ * input dimension to the corresponding output dimension.
+ */
+__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),identity_multi),BASE)(
+	__isl_take MULTI(BASE) *multi)
+{
+	isl_space *space;
+
+	space = FN(MULTI(BASE),get_space)(multi);
+	FN(MULTI(BASE),free)(multi);
+	return FN(MULTI(BASE),identity)(space);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_insert_domain_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_intersect.c Added

@@ -0,0 +1,151 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ */
+
+#include <isl_multi_macro.h>
+
+/* Does the space of "domain" correspond to that of the domain of "multi"?
+ * The parameters do not need to be aligned.
+ */
+static isl_bool FN(MULTI(BASE),compatible_domain)(
+	__isl_keep MULTI(BASE) *multi, __isl_keep DOM *domain)
+{
+	isl_bool ok;
+	isl_space *space, *domain_space;
+
+	domain_space = FN(DOM,get_space)(domain);
+	space = FN(MULTI(BASE),get_space)(multi);
+	ok = isl_space_has_domain_tuples(domain_space, space);
+	isl_space_free(space);
+	isl_space_free(domain_space);
+
+	return ok;
+}
+
+/* Check that the space of "domain" corresponds to
+ * that of the domain of "multi", ignoring parameters.
+ */
+static isl_stat FN(MULTI(BASE),check_compatible_domain)(
+	__isl_keep MULTI(BASE) *multi, __isl_keep DOM *domain)
+{
+	isl_bool ok;
+
+	ok = FN(MULTI(BASE),compatible_domain)(multi, domain);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(FN(DOM,get_ctx)(domain), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Intersect the explicit domain of "multi" with "domain".
+ *
+ * The parameters of "multi" and "domain" are assumed to have been aligned.
+ *
+ * In the case of an isl_multi_union_pw_aff object, the explicit domain
+ * is allowed to have only constraints on the parameters, while
+ * "domain" contains actual domain elements.  In this case,
+ * "domain" is intersected with those parameter constraints and
+ * then used as the explicit domain of "multi".
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),domain_intersect_aligned)(
+	__isl_take MULTI(BASE) *multi, __isl_take DOM *domain)
+{
+	isl_bool is_params;
+	DOM *multi_dom;
+
+	if (FN(MULTI(BASE),check_compatible_domain)(multi, domain) < 0)
+		goto error;
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi) < 0)
+		goto error;
+	is_params = FN(DOM,is_params)(multi->u.dom);
+	if (is_params < 0)
+		goto error;
+	multi_dom = FN(MULTI(BASE),get_explicit_domain)(multi);
+	if (!is_params) {
+		domain = FN(DOM,intersect)(multi_dom, domain);
+	} else {
+		isl_set *params;
+
+		params = FN(DOM,params)(multi_dom);
+		domain = FN(DOM,intersect_params)(domain, params);
+	}
+	multi = FN(MULTI(BASE),set_explicit_domain)(multi, domain);
+	return multi;
+error:
+	FN(MULTI(BASE),free)(multi);
+	FN(DOM,free)(domain);
+	return NULL;
+}
+
+/* Intersect the explicit domain of "multi" with "domain".
+ * First align the parameters, if needed.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),domain_intersect)(
+	__isl_take MULTI(BASE) *multi, __isl_take DOM *domain)
+{
+	return FN(FN(MULTI(BASE),align_params),DOMBASE)(multi, domain,
+				    FN(MULTI(BASE),domain_intersect_aligned));
+}
+
+/* Intersect the domain of "multi" with "domain".
+ *
+ * If "multi" has an explicit domain, then only this domain
+ * needs to be intersected.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_domain)(
+	__isl_take MULTI(BASE) *multi, __isl_take DOM *domain)
+{
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		return FN(MULTI(BASE),domain_intersect)(multi, domain);
+	return FN(FN(MULTI(BASE),apply),DOMBASE)(multi, domain,
+					&FN(EL,intersect_domain));
+}
+
+/* Intersect the parameter domain of the explicit domain of "multi"
+ * with "domain".
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),domain_intersect_params_aligned)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
+{
+	DOM *multi_dom;
+
+	multi_dom = FN(MULTI(BASE),get_explicit_domain)(multi);
+	multi_dom = FN(DOM,intersect_params)(multi_dom, domain);
+	multi = FN(MULTI(BASE),set_explicit_domain)(multi, multi_dom);
+
+	return multi;
+}
+
+/* Intersect the parameter domain of the explicit domain of "multi"
+ * with "domain".
+ * First align the parameters, if needed.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),domain_intersect_params)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
+{
+	return FN(FN(MULTI(BASE),align_params),set)(multi, domain,
+			    FN(MULTI(BASE),domain_intersect_params_aligned));
+}
+
+/* Intersect the parameter domain of "multi" with "domain".
+ *
+ * If "multi" has an explicit domain, then only this domain
+ * needs to be intersected.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_params)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
+{
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		return FN(MULTI(BASE),domain_intersect_params)(multi, domain);
+	return FN(MULTI(BASE),apply_set)(multi, domain,
+					&FN(EL,intersect_params));
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_locals_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_macro.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_min_max_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_move_dims_templ.c Added

@@ -0,0 +1,71 @@
+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Move the "n" dimensions of "src_type" starting at "src_pos" of "multi"
+ * to dimensions of "dst_type" at "dst_pos".
+ *
+ * We only support moving input dimensions to parameters and vice versa.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),move_dims)(__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+{
+	int i;
+
+	if (!multi)
+		return NULL;
+
+	if (n == 0 &&
+	    !isl_space_is_named_or_nested(multi->space, src_type) &&
+	    !isl_space_is_named_or_nested(multi->space, dst_type))
+		return multi;
+
+	if (dst_type == isl_dim_out || src_type == isl_dim_out)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+			"cannot move output/set dimension",
+			return FN(MULTI(BASE),free)(multi));
+	if (dst_type == isl_dim_div || src_type == isl_dim_div)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+			"cannot move divs",
+			return FN(MULTI(BASE),free)(multi));
+	if (FN(MULTI(BASE),check_range)(multi, src_type, src_pos, n) < 0)
+		return FN(MULTI(BASE),free)(multi);
+	if (dst_type == src_type)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_unsupported,
+			"moving dims within the same type not supported",
+			return FN(MULTI(BASE),free)(multi));
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	multi->space = isl_space_move_dims(multi->space, dst_type, dst_pos,
+						src_type, src_pos, n);
+	if (!multi->space)
+		return FN(MULTI(BASE),free)(multi);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		multi = FN(MULTI(BASE),move_explicit_domain_dims)(multi,
+				dst_type, dst_pos, src_type, src_pos, n);
+	if (!multi)
+		return NULL;
+
+	for (i = 0; i < multi->n; ++i) {
+		multi->u.pi = FN(EL,move_dims)(multi->u.pi,
+						dst_type, dst_pos,
+						src_type, src_pos, n);
+		if (!multi->u.pi)
+			return FN(MULTI(BASE),free)(multi);
+	}
+
+	return multi;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_nan_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_no_domain_templ.c Added

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl/local_space.h>
+#include <isl_reordering.h>
+
+#include <isl_multi_macro.h>
+
+/* The functions in this file are meant for base object types
+ * that do not have any associated space.  They are only meant to be used
+ * in the generic isl_multi_* functions which have to deal with base objects
+ * that do have an associated space.
+ */
+
+
+/* Drop the "n" first dimensions of type "type" at position "first".
+ *
+ * For a base expression without an associated space, this function
+ * does not do anything.
+ */
+static __isl_give EL *FN(EL,drop_dims)(__isl_take EL *el,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return el;
+}
+
+/* Return the space of "el".
+ *
+ * For a base expression without an associated space,
+ * the conditions surrounding the call to this function make sure
+ * that this function will never actually get called.  We return a valid
+ * space anyway, just in case.
+ */
+static __isl_give isl_space *FN(EL,get_space)(__isl_keep EL *el)
+{
+	if (!el)
+		return NULL;
+
+	return isl_space_params_alloc(FN(EL,get_ctx)(el), 0);
+}
+
+/* Reset the domain space of "el" to "space".
+ *
+ * For a base expression without an associated space, this function
+ * does not do anything, apart from error handling and cleaning up memory.
+ */
+static __isl_give EL *FN(EL,reset_domain_space)(__isl_take EL *el,
+	__isl_take isl_space *space)
+{
+	if (!space)
+		return FN(EL,free)(el);
+	isl_space_free(space);
+	return el;
+}
+
+/* Align the parameters of "el" to those of "space".
+ *
+ * For a base expression without an associated space, this function
+ * does not do anything, apart from error handling and cleaning up memory.
+ * Note that the conditions surrounding the call to this function make sure
+ * that this function will never actually get called.
+ */
+static __isl_give EL *FN(EL,align_params)(__isl_take EL *el,
+	__isl_take isl_space *space)
+{
+	if (!space)
+		return FN(EL,free)(el);
+	isl_space_free(space);
+	return el;
+}
+
+/* Reorder the dimensions of the domain of "el" according
+ * to the given reordering.
+ *
+ * For a base expression without an associated space, this function
+ * does not do anything, apart from error handling and cleaning up memory.
+ */
+static __isl_give EL *FN(EL,realign_domain)(__isl_take EL *el,
+	__isl_take isl_reordering *r)
+{
+	if (!r)
+		return FN(EL,free)(el);
+	isl_reordering_free(r);
+	return el;
+}
+
+/* Do the parameters of "el" match those of "space"?
+ *
+ * For a base expression without an associated space, this function
+ * simply returns true, except if "el" or "space" are NULL.
+ */
+static isl_bool FN(EL,matching_params)(__isl_keep EL *el,
+	__isl_keep isl_space *space)
+{
+	if (!el || !space)
+		return isl_bool_error;
+	return isl_bool_true;
+}
+
+/* Check that the domain space of "el" matches "space".
+ *
+ * For a base expression without an associated space, this function
+ * simply returns isl_stat_ok, except if "el" or "space" are NULL.
+ */
+static isl_stat FN(EL,check_match_domain_space)(__isl_keep EL *el,
+	__isl_keep isl_space *space)
+{
+	if (!el || !space)
+		return isl_stat_error;
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_no_explicit_domain.c Added

@@ -0,0 +1,172 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* These versions of the explicit domain functions are used
+ * when the multi expression cannot have an explicit domain.
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Does "multi" have an explicit domain?
+ *
+ * No.
+ */
+static int FN(MULTI(BASE),has_explicit_domain)(__isl_keep MULTI(BASE) *multi)
+{
+	return 0;
+}
+
+/* Initialize the explicit domain of "multi".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),init_explicit_domain)(
+	__isl_take MULTI(BASE) *multi)
+{
+	return multi;
+}
+
+/* Intersect the domain of "dst" with the explicit domain of "src".
+ * "src" cannot have an explicit domain, so this function is never called.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_explicit_domain)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src)
+{
+	return dst;
+}
+
+/* Set the explicit domain of "dst" to that of "src".
+ * "src" and "dst" cannot have an explicit domain,
+ * so this function is never called.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),copy_explicit_domain)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src)
+{
+	return dst;
+}
+
+/* Only used by multi-expressions that include "isl_multi_product_templ.c".
+ */
+static __isl_give MULTI(BASE) *
+FN(MULTI(BASE),intersect_explicit_domain_product)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src1,
+	__isl_keep MULTI(BASE) *src2) __attribute__ ((unused));
+
+/* Intersect the domain of "dst" with the domain product
+ * of the explicit domains of "src1" and "src2".
+ * This function is only called if at least one of "src1" or "src2"
+ * has an explicit domain.
+ * "src1", "src2" and "dst" cannot have an explicit domain,
+ * so this function is never called.
+ */
+static __isl_give MULTI(BASE) *
+FN(MULTI(BASE),intersect_explicit_domain_product)(
+	__isl_take MULTI(BASE) *dst, __isl_keep MULTI(BASE) *src1,
+	__isl_keep MULTI(BASE) *src2)
+{
+	return dst;
+}
+
+/* Align the parameters of the explicit domain of "multi" to those of "space".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_explicit_domain_params)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
+{
+	isl_space_free(space);
+	return multi;
+}
+
+/* Replace the space of the explicit domain of "multi" by "space",
+ * without modifying its dimension.
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_explicit_domain_space)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_space *space)
+{
+	isl_space_free(space);
+	return multi;
+}
+
+/* Check whether the explicit domain of "multi" has non-zero coefficients
+ * for any dimension in the given range or if any of these dimensions appear
+ * with non-zero coefficients in any of the integer divisions involved.
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+isl_bool FN(MULTI(BASE),involves_explicit_domain_dims)(
+	__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	return isl_bool_false;
+}
+
+/* Insert "n" dimensions of type "type" at position "pos"
+ * of the explicit domain of "multi".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),insert_explicit_domain_dims)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	return multi;
+}
+
+/* Drop the "n" dimensions of type "type" starting at position "pos"
+ * of the explicit domain of "multi".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),drop_explicit_domain_dims)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	return multi;
+}
+
+/* Move the "n" dimensions of "src_type" starting at "src_pos" of
+ * of the explicit domain of "multi" to dimensions of "dst_type" at "dst_pos".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),move_explicit_domain_dims)(
+	__isl_take MULTI(BASE) *multi,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+{
+	return multi;
+}
+
+/* Free the explicit domain of "multi".
+ * "multi" cannot have an explicit domain, so this function is never called.
+ */
+static void FN(MULTI(BASE),free_explicit_domain)(__isl_keep MULTI(BASE) *multi)
+{
+}
+
+/* Do "multi1" and "multi2" have the same explicit domain?
+ * "multi1" and "multi2" cannot have an explicit domain,
+ * so this function is never called.
+ */
+static isl_bool FN(MULTI(BASE),equal_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi1, __isl_keep MULTI(BASE) *multi2)
+{
+	return isl_bool_true;
+}
+
+static isl_stat FN(MULTI(BASE),check_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi) __attribute__ ((unused));
+
+/* Debugging function to check that the explicit domain of "multi"
+ * has the correct space.
+ * "multi" cannot have an explicit domain,
+ * so this function should never be called.
+ */
+static isl_stat FN(MULTI(BASE),check_explicit_domain)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_param_templ.c Added

@@ -0,0 +1,60 @@
+/*
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege
+ */
+
+#include <isl_multi_macro.h>
+
+/* Does the multiple expression "multi" depend in any way
+ * on the parameter with identifier "id"?
+ */
+isl_bool FN(MULTI(BASE),involves_param_id)(__isl_keep MULTI(BASE) *multi,
+	__isl_keep isl_id *id)
+{
+	int i;
+	int pos;
+
+	if (!multi || !id)
+		return isl_bool_error;
+	if (multi->n == 0)
+		return isl_bool_false;
+	pos = FN(MULTI(BASE),find_dim_by_id)(multi, isl_dim_param, id);
+	if (pos < 0)
+		return isl_bool_false;
+
+	for (i = 0; i < multi->n; ++i) {
+		isl_bool involved = FN(EL,involves_param_id)(multi->u.pi, id);
+		if (involved < 0 || involved)
+			return involved;
+	}
+
+	return isl_bool_false;
+}
+
+/* Does the multiple expression "multi" depend in any way
+ * on any of the parameters with identifiers in "list"?
+ */
+isl_bool FN(MULTI(BASE),involves_param_id_list)(__isl_keep MULTI(BASE) *multi,
+	__isl_keep isl_id_list *list)
+{
+	int i;
+	isl_size n;
+
+	n = isl_id_list_size(list);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 0; i < n; ++i) {
+		isl_bool involves;
+		isl_id *id;
+
+		id = isl_id_list_get_at(list, i);
+		involves = FN(MULTI(BASE),involves_param_id)(multi, id);
+		isl_id_free(id);
+
+		if (involves < 0 || involves)
+			return involves;
+	}
+
+	return isl_bool_false;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_product_templ.c Added

@@ -0,0 +1,68 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Given two MULTI(BASE)s A -> B and C -> D,
+ * construct a MULTI(BASE) A -> C -> B -> D.
+ *
+ * If "multi1" and/or "multi2" has an explicit domain, then
+ * intersect the domain of the result with these explicit domains.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),product)(
+	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
+{
+	int i;
+	EL *el;
+	isl_space *space;
+	MULTI(BASE) *res;
+	isl_size in1, in2, out1, out2;
+
+	FN(MULTI(BASE),align_params_bin)(&multi1, &multi2);
+	in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
+	in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
+	out1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
+	out2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
+	if (in1 < 0 || in2 < 0 || out1 < 0 || out2 < 0)
+		goto error;
+	space = isl_space_product(FN(MULTI(BASE),get_space)(multi1),
+				  FN(MULTI(BASE),get_space)(multi2));
+	res = FN(MULTI(BASE),alloc)(isl_space_copy(space));
+	space = isl_space_domain(space);
+
+	for (i = 0; i < out1; ++i) {
+		el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
+		el = FN(EL,insert_dims)(el, isl_dim_in, in1, in2);
+		el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
+		res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
+	}
+
+	for (i = 0; i < out2; ++i) {
+		el = FN(FN(MULTI(BASE),get),BASE)(multi2, i);
+		el = FN(EL,insert_dims)(el, isl_dim_in, 0, in1);
+		el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
+		res = FN(FN(MULTI(BASE),set),BASE)(res, out1 + i, el);
+	}
+
+	if (FN(MULTI(BASE),has_explicit_domain)(multi1) ||
+	    FN(MULTI(BASE),has_explicit_domain)(multi2))
+		res = FN(MULTI(BASE),intersect_explicit_domain_product)(res,
+								multi1, multi2);
+
+	isl_space_free(space);
+	FN(MULTI(BASE),free)(multi1);
+	FN(MULTI(BASE),free)(multi2);
+	return res;
+error:
+	FN(MULTI(BASE),free)(multi1);
+	FN(MULTI(BASE),free)(multi2);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_pw_aff_explicit_domain.c Added

@@ -0,0 +1,134 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* Initialize the explicit domain of "mpa".
+ *
+ * The explicit domain is initialized to a universe set
+ * in the domain space.
+ */
+static __isl_give isl_multi_pw_aff *isl_multi_pw_aff_init_explicit_domain(
+	__isl_take isl_multi_pw_aff *mpa)
+{
+	if (isl_multi_pw_aff_check_has_explicit_domain(mpa) < 0)
+		return isl_multi_pw_aff_free(mpa);
+	mpa->u.dom = isl_set_universe(isl_multi_pw_aff_get_domain_space(mpa));
+	if (!mpa->u.dom)
+		return isl_multi_pw_aff_free(mpa);
+	return mpa;
+}
+
+/* Intersect the domain of "dst" with the domain product
+ * of the explicit domains of "src1" and "src2".
+ * This function is only called if at least one of "src1" or "src2"
+ * has an explicit domain.
+ */
+static __isl_give isl_multi_pw_aff *
+isl_multi_pw_aff_intersect_explicit_domain_product(
+	__isl_take isl_multi_pw_aff *dst, __isl_keep isl_multi_pw_aff *src1,
+	__isl_keep isl_multi_pw_aff *src2)
+{
+	isl_space *space;
+	isl_set *dom;
+	isl_map *map;
+
+	if (!src1 || !src2)
+		return FN(isl_multi_pw_aff,free)(dst);
+	space = isl_multi_pw_aff_get_domain_space(dst);
+	dom = isl_set_universe(space);
+	map = isl_set_unwrap(dom);
+	if (isl_multi_pw_aff_has_explicit_domain(src1)) {
+		dom = isl_set_copy(src1->u.dom);
+		map = isl_map_intersect_domain(map, dom);
+	}
+	if (isl_multi_pw_aff_has_explicit_domain(src2)) {
+		dom = isl_set_copy(src2->u.dom);
+		map = isl_map_intersect_range(map, dom);
+	}
+	dom = isl_map_wrap(map);
+	dst = isl_multi_pw_aff_intersect_domain(dst, dom);
+	return dst;
+}
+
+/* Check whether the explicit domain of "mpa" has non-zero coefficients
+ * for any dimension in the given range or if any of these dimensions appear
+ * with non-zero coefficients in any of the integer divisions involved.
+ */
+isl_bool isl_multi_pw_aff_involves_explicit_domain_dims(
+	__isl_keep isl_multi_pw_aff *mpa,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	if (isl_multi_pw_aff_check_has_explicit_domain(mpa) < 0)
+		return isl_bool_error;
+	if (type == isl_dim_in)
+		type = isl_dim_set;
+	return isl_set_involves_dims(mpa->u.dom, type, pos, n);
+}
+
+/* Insert "n" dimensions of type "type" at position "pos"
+ * of the explicit domain of "mpa".
+ */
+static __isl_give isl_multi_pw_aff *
+isl_multi_pw_aff_insert_explicit_domain_dims(__isl_take isl_multi_pw_aff *mpa,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	if (isl_multi_pw_aff_check_has_explicit_domain(mpa) < 0)
+		return isl_multi_pw_aff_free(mpa);
+	mpa = isl_multi_pw_aff_cow(mpa);
+	if (!mpa)
+		return NULL;
+	if (type == isl_dim_in)
+		type = isl_dim_set;
+	mpa->u.dom = isl_set_insert_dims(mpa->u.dom, type, pos, n);
+	if (!mpa->u.dom)
+		return isl_multi_pw_aff_free(mpa);
+	return mpa;
+}
+
+/* Drop the "n" dimensions of type "type" starting at position "pos"
+ * of the explicit domain of "mpa".
+ */
+static __isl_give isl_multi_pw_aff *
+isl_multi_pw_aff_drop_explicit_domain_dims(__isl_take isl_multi_pw_aff *mpa,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	if (isl_multi_pw_aff_check_has_explicit_domain(mpa) < 0)
+		return isl_multi_pw_aff_free(mpa);
+	mpa = isl_multi_pw_aff_cow(mpa);
+	if (!mpa)
+		return NULL;
+	if (type == isl_dim_in)
+		type = isl_dim_set;
+	mpa->u.dom = isl_set_drop(mpa->u.dom, type, pos, n);
+	if (!mpa->u.dom)
+		return isl_multi_pw_aff_free(mpa);
+	return mpa;
+}
+
+/* Move the "n" dimensions of "src_type" starting at "src_pos" of
+ * of the explicit domain of "mpa" to dimensions of "dst_type" at "dst_pos".
+ */
+static __isl_give isl_multi_pw_aff *isl_multi_pw_aff_move_explicit_domain_dims(
+	__isl_take isl_multi_pw_aff *mpa,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+{
+	if (isl_multi_pw_aff_check_has_explicit_domain(mpa) < 0)
+		return isl_multi_pw_aff_free(mpa);
+	mpa = isl_multi_pw_aff_cow(mpa);
+	if (!mpa)
+		return NULL;
+	if (dst_type == isl_dim_in)
+		dst_type = isl_dim_set;
+	if (src_type == isl_dim_in)
+		src_type = isl_dim_set;
+	mpa->u.dom = isl_set_move_dims(mpa->u.dom, dst_type, dst_pos,
+				src_type, src_pos, n);
+	if (!mpa->u.dom)
+		return isl_multi_pw_aff_free(mpa);
+	return mpa;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_read_no_explicit_domain_templ.c Added

@@ -0,0 +1,94 @@
+/*
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl/set.h>
+
+#include <isl_multi_macro.h>
+
+/* This function is called for each element in a tuple inside
+ * isl_stream_read_multi_*.
+ * Read an EL from "s" and add it to *list.
+ */
+static __isl_give isl_space *FN(read_el,BASE)(__isl_keep isl_stream *s,
+	struct vars *v, __isl_take isl_space *space, int rational, void *user)
+{
+	LIST(EL) **list = (LIST(EL) **) user;
+	EL *el;
+
+	el = FN(isl_stream_read,BASE)(s);
+	*list = FN(LIST(EL),add)(*list, el);
+	if (!*list)
+		return isl_space_free(space);
+
+	return space;
+}
+
+/* Read a multi expression from "s".
+ *
+ * We first read a tuple space, collecting the element values in a list.
+ * Then we create an isl_multi_* from the space and the isl_*_list.
+ */
+__isl_give MULTI(BASE) *FN(isl_stream_read_multi,BASE)(
+	__isl_keep isl_stream *s)
+{
+	struct vars *v;
+	isl_set *dom = NULL;
+	isl_space *space;
+	MULTI(BASE) *multi = NULL;
+	LIST(EL) *list;
+
+	v = vars_new(s->ctx);
+	if (!v)
+		return NULL;
+
+	dom = isl_set_universe(isl_space_params_alloc(s->ctx, 0));
+	if (next_is_tuple(s)) {
+		dom = read_map_tuple(s, dom, isl_dim_param, v, 1, 0);
+		if (isl_stream_eat(s, ISL_TOKEN_TO))
+			goto error;
+	}
+	if (!isl_set_plain_is_universe(dom))
+		isl_die(s->ctx, isl_error_invalid,
+			"expecting universe parameter domain", goto error);
+	if (isl_stream_eat(s, '{'))
+		goto error;
+
+	space = isl_set_get_space(dom);
+
+	list = FN(LIST(EL),alloc)(s->ctx, 0);
+	space = read_tuple_space(s, v, space, 1, 0, &FN(read_el,BASE), &list);
+	multi = FN(FN(MULTI(BASE),from),LIST(BASE))(space, list);
+
+	if (isl_stream_eat(s, '}'))
+		goto error;
+
+	vars_free(v);
+	isl_set_free(dom);
+	return multi;
+error:
+	vars_free(v);
+	isl_set_free(dom);
+	FN(MULTI(BASE),free)(multi);
+	return NULL;
+}
+
+/* Read a multi expression from "str".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),read_from_str)(isl_ctx *ctx,
+	const char *str)
+{
+	MULTI(BASE) *multi;
+	isl_stream *s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	multi = FN(isl_stream_read_multi,BASE)(s);
+	isl_stream_free(s);
+	return multi;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_splice_templ.c Added

@@ -0,0 +1,63 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/ctx.h>
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+/* Given two multi expressions, "multi1"
+ *
+ *	A1 A2 -> B1 B2
+ *
+ * where A2 starts at position "in_pos" and B2 starts at position "out_pos",
+ * and "multi2"
+ *
+ *	C -> D
+ *
+ * return the multi expression
+ *
+ *	A1 C A2 -> B1 D B2
+ *
+ * We first insert input dimensions to obtain
+ *
+ *	A1 C A2 -> B1 B2
+ *
+ * and
+ *
+ *	A1 C A2 -> D
+ *
+ * and then apply range_splice.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),splice)(
+	__isl_take MULTI(BASE) *multi1, unsigned in_pos, unsigned out_pos,
+	__isl_take MULTI(BASE) *multi2)
+{
+	isl_size n_in1;
+	isl_size n_in2;
+
+	n_in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
+	n_in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
+	if (n_in1 < 0 || n_in2 < 0)
+		goto error;
+
+	if (FN(MULTI(BASE),check_range)(multi1, isl_dim_in, in_pos, 0) < 0)
+		goto error;
+
+	multi1 = FN(MULTI(BASE),insert_dims)(multi1, isl_dim_in, in_pos, n_in2);
+	multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, n_in2,
+						n_in1 - in_pos);
+	multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, 0, in_pos);
+
+	return FN(MULTI(BASE),range_splice)(multi1, out_pos, multi2);
+error:
+	FN(MULTI(BASE),free)(multi1);
+	FN(MULTI(BASE),free)(multi2);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_multi_templ.c -> _service:tar_scm:isl-0.24.tar.gz/isl_multi_templ.c Changed

@@ -1,6 +1,6 @@
 /*
  * Copyright 2011      Sven Verdoolaege
- * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2012-2014 Ecole Normale Superieure
  *
  * Use of this software is governed by the MIT license
  *
@@ -8,30 +8,30 @@
  * Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  */
 
+#include <isl/id.h>
 #include <isl_space_private.h>
 #include <isl/set.h>
 #include <isl_reordering.h>
 
-#define xCAT(A,B) A ## B
-#define CAT(A,B) xCAT(A,B)
-#undef EL
-#define EL CAT(isl_,BASE)
-#define xFN(TYPE,NAME) TYPE ## _ ## NAME
-#define FN(TYPE,NAME) xFN(TYPE,NAME)
-#define xMULTI(BASE) isl_multi_ ## BASE
-#define MULTI(BASE) xMULTI(BASE)
+#include <isl_multi_macro.h>
+
 #define MULTI_NAME(BASE) "isl_multi_" #BASE
-#define xLIST(EL) EL ## _list
-#define LIST(EL) xLIST(EL)
 
 isl_ctx *FN(MULTI(BASE),get_ctx)(__isl_keep MULTI(BASE) *multi)
 {
 	return multi ? isl_space_get_ctx(multi->space) : NULL;
 }
 
+/* Return the space of "multi".
+ */
+__isl_keep isl_space *FN(MULTI(BASE),peek_space)(__isl_keep MULTI(BASE) *multi)
+{
+	return multi ? multi->space : NULL;
+}
+
 __isl_give isl_space *FN(MULTI(BASE),get_space)(__isl_keep MULTI(BASE) *multi)
 {
-	return multi ? isl_space_copy(multi->space) : NULL;
+	return isl_space_copy(FN(MULTI(BASE),peek_space)(multi));
 }
 
 __isl_give isl_space *FN(MULTI(BASE),get_domain_space)(
@@ -40,25 +40,36 @@
 	return multi ? isl_space_domain(isl_space_copy(multi->space)) : NULL;
 }
 
+/* Allocate a multi expression living in "space".
+ *
+ * If the number of base expressions is zero, then make sure
+ * there is enough room in the structure for the explicit domain,
+ * in case the type supports such an explicit domain.
+ */
 __isl_give MULTI(BASE) *FN(MULTI(BASE),alloc)(__isl_take isl_space *space)
 {
 	isl_ctx *ctx;
-	int n;
+	isl_size n;
 	MULTI(BASE) *multi;
 
-	if (!space)
-		return NULL;
+	n = isl_space_dim(space, isl_dim_out);
+	if (n < 0)
+		goto error;
 
 	ctx = isl_space_get_ctx(space);
-	n = isl_space_dim(space, isl_dim_out);
-	multi = isl_calloc(ctx, MULTI(BASE),
+	if (n > 0)
+		multi = isl_calloc(ctx, MULTI(BASE),
 			 sizeof(MULTI(BASE)) + (n - 1) * sizeof(struct EL *));
+	else
+		multi = isl_calloc(ctx, MULTI(BASE), sizeof(MULTI(BASE)));
 	if (!multi)
 		goto error;
 
 	multi->space = space;
 	multi->n = n;
 	multi->ref = 1;
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		multi = FN(MULTI(BASE),init_explicit_domain)(multi);
 	return multi;
 error:
 	isl_space_free(space);
@@ -79,7 +90,9 @@
 
 	for (i = 0; i < multi->n; ++i)
 		dup = FN(FN(MULTI(BASE),set),BASE)(dup, i,
-						    FN(EL,copy)(multi->pi));
+						    FN(EL,copy)(multi->u.pi));
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		dup = FN(MULTI(BASE),copy_explicit_domain)(dup, multi);
 
 	return dup;
 }
@@ -117,175 +130,99 @@
 
 	isl_space_free(multi->space);
 	for (i = 0; i < multi->n; ++i)
-		FN(EL,free)(multi->pi);
+		FN(EL,free)(multi->u.pi);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		FN(MULTI(BASE),free_explicit_domain)(multi);
 	free(multi);
 
 	return NULL;
 }
 
-/* Check whether "multi" has non-zero coefficients for any dimension
- * in the given range or if any of these dimensions appear
- * with non-zero coefficients in any of the integer divisions involved.
- */
-int FN(MULTI(BASE),involves_dims)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	int i;
-
-	if (!multi)
-		return -1;
-	if (multi->n == 0 || n == 0)
-		return 0;
-
-	for (i = 0; i < multi->n; ++i) {
-		int involves;
-
-		involves = FN(EL,involves_dims)(multi->pi, type, first, n);
-		if (involves < 0 || involves)
-			return involves;
-	}
-
-	return 0;
-}
-
-__isl_give MULTI(BASE) *FN(MULTI(BASE),insert_dims)(
-	__isl_take MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned first, unsigned n)
+isl_size FN(MULTI(BASE),dim)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type)
 {
-	int i;
-
-	if (!multi)
-		return NULL;
-	if (type == isl_dim_out)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"cannot insert output/set dimensions",
-			return FN(MULTI(BASE),free)(multi));
-	if (n == 0 && !isl_space_is_named_or_nested(multi->space, type))
-		return multi;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	multi->space = isl_space_insert_dims(multi->space, type, first, n);
-	if (!multi->space)
-		return FN(MULTI(BASE),free)(multi);
-
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,insert_dims)(multi->pi, type, first, n);
-		if (!multi->pi)
-			return FN(MULTI(BASE),free)(multi);
-	}
-
-	return multi;
+	return isl_space_dim(FN(MULTI(BASE),peek_space)(multi), type);
 }
 
-__isl_give MULTI(BASE) *FN(MULTI(BASE),add_dims)(__isl_take MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned n)
+/* Return the number of base expressions in "multi".
+ */
+isl_size FN(MULTI(BASE),size)(__isl_keep MULTI(BASE) *multi)
 {
-	unsigned pos;
-
-	pos = FN(MULTI(BASE),dim)(multi, type);
-
-	return FN(MULTI(BASE),insert_dims)(multi, type, pos, n);
+	return multi ? multi->n : isl_size_error;
 }
 
-unsigned FN(MULTI(BASE),dim)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type)
-{
-	return multi ? isl_space_dim(multi->space, type) : 0;
-}
+#undef TYPE
+#define TYPE	MULTI(BASE)
+static
+#include "check_type_range_templ.c"
 
-/* Return the position of the first dimension of "type" with id "id".
- * Return -1 if there is no such dimension.
+/* Return a copy of the base expression at position "pos" in "multi".
  */
-int FN(MULTI(BASE),find_dim_by_id)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type, __isl_keep isl_id *id)
+__isl_give EL *FN(MULTI(BASE),get_at)(__isl_keep MULTI(BASE) *multi, int pos)
 {
-	if (!multi)
-		return -1;
-	return isl_space_find_dim_by_id(multi->space, type, id);
+	isl_ctx *ctx;
+
+	if (FN(MULTI(BASE),check_range)(multi, isl_dim_out, pos, 1) < 0)
+		return NULL;
+	ctx = FN(MULTI(BASE),get_ctx)(multi);
+	return FN(EL,copy)(multi->u.ppos);
 }
 
-/* Return the id of the given dimension.
+/* This is an alternative name for the function above.
  */
-__isl_give isl_id *FN(MULTI(BASE),get_dim_id)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned pos)
+__isl_give EL *FN(FN(MULTI(BASE),get),BASE)(__isl_keep MULTI(BASE) *multi,
+	int pos)
 {
-	return multi ? isl_space_get_dim_id(multi->space, type, pos) : NULL;
+	return FN(MULTI(BASE),get_at)(multi, pos);
 }
 
-__isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_name)(
-	__isl_take MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned pos, const char *s)
+/* Set the element at position "pos" of "multi" to "el",
+ * where the position may be empty if "multi" has only a single reference.
+ */
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),restore)(
+	__isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
 {
-	int i;
-
 	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
+	if (!multi || !el)
+		goto error;
 
-	multi->space = isl_space_set_dim_name(multi->space, type, pos, s);
-	if (!multi->space)
-		return FN(MULTI(BASE),free)(multi);
+	if (FN(MULTI(BASE),check_range)(multi, isl_dim_out, pos, 1) < 0)
+		goto error;
 
-	if (type == isl_dim_out)
-		return multi;
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,set_dim_name)(multi->pi, type, pos, s);
-		if (!multi->pi)
-			return FN(MULTI(BASE),free)(multi);
-	}
+	FN(EL,free)(multi->u.ppos);
+	multi->u.ppos = el;
 
 	return multi;
+error:
+	FN(MULTI(BASE),free)(multi);
+	FN(EL,free)(el);
+	return NULL;
 }
 
-const char *FN(MULTI(BASE),get_tuple_name)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type)
-{
-	return multi ? isl_space_get_tuple_name(multi->space, type) : NULL;
-}
-
-/* Does the specified tuple have an id?
- */
-int FN(MULTI(BASE),has_tuple_id)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type)
-{
-	return multi ? isl_space_has_tuple_id(multi->space, type) : -1;
-}
-
-/* Return the id of the specified tuple.
+/* Set the element at position "pos" of "multi" to "el",
+ * where the position may be empty if "multi" has only a single reference.
+ * However, the space of "multi" is available and is checked
+ * for compatibility with "el".
  */
-__isl_give isl_id *FN(MULTI(BASE),get_tuple_id)(__isl_keep MULTI(BASE) *multi,
-	enum isl_dim_type type)
-{
-	return multi ? isl_space_get_tuple_id(multi->space, type) : NULL;
-}
-
-__isl_give EL *FN(FN(MULTI(BASE),get),BASE)(__isl_keep MULTI(BASE) *multi,
-	int pos)
+static __isl_give MULTI(BASE) *FN(MULTI(BASE),restore_check_space)(
+	__isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
 {
-	isl_ctx *ctx;
+	isl_space *space;
 
-	if (!multi)
-		return NULL;
-	ctx = FN(MULTI(BASE),get_ctx)(multi);
-	if (pos < 0 || pos >= multi->n)
-		isl_die(ctx, isl_error_invalid,
-			"index out of bounds", return NULL);
-	return FN(EL,copy)(multi->ppos);
+	space = FN(MULTI(BASE),peek_space)(multi);
+	if (FN(EL,check_match_domain_space)(el, space) < 0)
+		multi = FN(MULTI(BASE),free)(multi);
+	return FN(MULTI(BASE),restore)(multi, pos, el);
 }
 
-__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),set),BASE)(
+/* Replace the base expression at position "pos" in "multi" with "el".
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_at)(
 	__isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
 {
 	isl_space *multi_space = NULL;
 	isl_space *el_space = NULL;
-	int match;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi || !el)
-		goto error;
+	isl_bool match;
 
 	multi_space = FN(MULTI(BASE),get_space)(multi);
 	match = FN(EL,matching_params)(el, multi_space);
@@ -298,15 +235,8 @@
 		multi_space = FN(MULTI(BASE),get_space)(multi);
 		el = FN(EL,align_params)(el, isl_space_copy(multi_space));
 	}
-	if (FN(EL,check_match_domain_space)(el, multi_space) < 0)
-		goto error;
-
-	if (pos < 0 || pos >= multi->n)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"index out of bounds", goto error);
 
-	FN(EL,free)(multi->ppos);
-	multi->ppos = el;
+	multi = FN(MULTI(BASE),restore_check_space)(multi, pos, el);
 
 	isl_space_free(multi_space);
 	isl_space_free(el_space);
@@ -320,11 +250,44 @@
 	return NULL;
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),set),BASE)(
+	__isl_take MULTI(BASE) *multi, int pos, __isl_take EL *el)
+{
+	return FN(MULTI(BASE),set_at)(multi, pos, el);
+}
+
+/* Return the base expressions of "multi" as a list.
+ */
+__isl_give LIST(EL) *FN(MULTI(BASE),get_list)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	isl_size n;
+	int i;
+	LIST(EL) *list;
+
+	n = FN(MULTI(BASE),size)(multi);
+	if (n < 0)
+		return NULL;
+	list = FN(LIST(EL),alloc)(FN(MULTI(BASE),get_ctx(multi)), n);
+	for (i = 0; i < n; ++i) {
+		EL *el = FN(MULTI(BASE),get_at)(multi, i);
+		list = FN(LIST(EL),add)(list, el);
+	}
+
+	return list;
+}
+
 /* Reset the space of "multi".  This function is called from isl_pw_templ.c
  * and doesn't know if the space of an element object is represented
  * directly or through its domain.  It therefore passes along both,
- * which we pass along to the element function since we don't how
+ * which we pass along to the element function since we don't know how
  * that is represented either.
+ *
+ * If "multi" has an explicit domain, then the caller is expected
+ * to make sure that any modification that would change the dimensions
+ * of the explicit domain has bee applied before this function is called.
  */
 __isl_give MULTI(BASE) *FN(MULTI(BASE),reset_space_and_domain)(
 	__isl_take MULTI(BASE) *multi, __isl_take isl_space *space,
@@ -337,9 +300,15 @@
 		goto error;
 
 	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,reset_domain_space)(multi->pi,
+		multi->u.pi = FN(EL,reset_domain_space)(multi->u.pi,
 				 isl_space_copy(domain));
-		if (!multi->pi)
+		if (!multi->u.pi)
+			goto error;
+	}
+	if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
+		multi = FN(MULTI(BASE),reset_explicit_domain_space)(multi,
+							isl_space_copy(domain));
+		if (!multi)
 			goto error;
 	}
 	isl_space_free(domain);
@@ -373,85 +342,6 @@
 	return FN(MULTI(BASE),reset_space_and_domain)(multi, space, domain);
 }
 
-/* Set the id of the given dimension of "multi" to "id".
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),set_dim_id)(
-	__isl_take MULTI(BASE) *multi,
-	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
-{
-	isl_space *space;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi || !id)
-		goto error;
-
-	space = FN(MULTI(BASE),get_space)(multi);
-	space = isl_space_set_dim_id(space, type, pos, id);
-
-	return FN(MULTI(BASE),reset_space)(multi, space);
-error:
-	isl_id_free(id);
-	FN(MULTI(BASE),free)(multi);
-	return NULL;
-}
-
-__isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_name)(
-	__isl_keep MULTI(BASE) *multi, enum isl_dim_type type,
-	const char *s)
-{
-	isl_space *space;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	space = FN(MULTI(BASE),get_space)(multi);
-	space = isl_space_set_tuple_name(space, type, s);
-
-	return FN(MULTI(BASE),reset_space)(multi, space);
-}
-
-__isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_id)(
-	__isl_take MULTI(BASE) *multi, enum isl_dim_type type,
-	__isl_take isl_id *id)
-{
-	isl_space *space;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		goto error;
-
-	space = FN(MULTI(BASE),get_space)(multi);
-	space = isl_space_set_tuple_id(space, type, id);
-
-	return FN(MULTI(BASE),reset_space)(multi, space);
-error:
-	isl_id_free(id);
-	return NULL;
-}
-
-/* Drop the id on the specified tuple.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),reset_tuple_id)(
-	__isl_take MULTI(BASE) *multi, enum isl_dim_type type)
-{
-	isl_space *space;
-
-	if (!multi)
-		return NULL;
-	if (!FN(MULTI(BASE),has_tuple_id)(multi, type))
-		return multi;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	space = FN(MULTI(BASE),get_space)(multi);
-	space = isl_space_reset_tuple_id(space, type);
-
-	return FN(MULTI(BASE),reset_space)(multi, space);
-}
-
 /* Reset the user pointer on all identifiers of parameters and tuples
  * of the space of "multi".
  */
@@ -470,20 +360,21 @@
 	__isl_take MULTI(BASE) *multi, __isl_take isl_reordering *exp)
 {
 	int i;
+	isl_space *space;
 
 	multi = FN(MULTI(BASE),cow)(multi);
 	if (!multi || !exp)
 		goto error;
 
 	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,realign_domain)(multi->pi,
+		multi->u.pi = FN(EL,realign_domain)(multi->u.pi,
 						isl_reordering_copy(exp));
-		if (!multi->pi)
+		if (!multi->u.pi)
 			goto error;
 	}
 
-	multi = FN(MULTI(BASE),reset_domain_space)(multi,
-						    isl_space_copy(exp->dim));
+	space = isl_reordering_get_space(exp);
+	multi = FN(MULTI(BASE),reset_domain_space)(multi, space);
 
 	isl_reordering_free(exp);
 	return multi;
@@ -494,18 +385,24 @@
 }
 
 /* Align the parameters of "multi" to those of "model".
+ *
+ * If "multi" has an explicit domain, then align the parameters
+ * of the domain first.
  */
 __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params)(
 	__isl_take MULTI(BASE) *multi, __isl_take isl_space *model)
 {
 	isl_ctx *ctx;
+	isl_bool equal_params;
 	isl_reordering *exp;
 
 	if (!multi || !model)
 		goto error;
 
-	if (isl_space_match(multi->space, isl_dim_param,
-			     model, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(multi->space, model);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params) {
 		isl_space_free(model);
 		return multi;
 	}
@@ -518,7 +415,12 @@
 		isl_die(ctx, isl_error_invalid,
 			"input has unnamed parameters", goto error);
 
-	model = isl_space_params(model);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi)) {
+		multi = FN(MULTI(BASE),align_explicit_domain_params)(multi,
+							isl_space_copy(model));
+		if (!multi)
+			goto error;
+	}
 	exp = isl_parameter_alignment_reordering(multi->space, model);
 	exp = isl_reordering_extend_space(exp,
 				    FN(MULTI(BASE),get_domain_space)(multi));
@@ -532,175 +434,40 @@
 	return NULL;
 }
 
-#if !defined(NO_GIST) || !defined(NO_INTERSECT_DOMAIN)
-static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params_multi_set_and)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *set,
-	__isl_give MULTI(BASE) *(*fn)(__isl_take MULTI(BASE) *multi,
-					__isl_take isl_set *set))
-{
-	isl_ctx *ctx;
-
-	if (!multi || !set)
-		goto error;
-	if (isl_space_match(multi->space, isl_dim_param,
-			    set->dim, isl_dim_param))
-		return fn(multi, set);
-	ctx = FN(MULTI(BASE),get_ctx)(multi);
-	if (!isl_space_has_named_params(multi->space) ||
-	    !isl_space_has_named_params(set->dim))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	multi = FN(MULTI(BASE),align_params)(multi, isl_set_get_space(set));
-	set = isl_set_align_params(set, FN(MULTI(BASE),get_space)(multi));
-	return fn(multi, set);
-error:
-	FN(MULTI(BASE),free)(multi);
-	isl_set_free(set);
-	return NULL;
-}
-#endif
-
-#ifndef NO_GIST
-__isl_give MULTI(BASE) *FN(MULTI(BASE),gist_aligned)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *context)
-{
-	int i;
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi || !context)
-		goto error;
-
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,gist)(multi->pi, isl_set_copy(context));
-		if (!multi->pi)
-			goto error;
-	}
-
-	isl_set_free(context);
-	return multi;
-error:
-	isl_set_free(context);
-	FN(MULTI(BASE),free)(multi);
-	return NULL;
-}
-
-__isl_give MULTI(BASE) *FN(MULTI(BASE),gist)(__isl_take MULTI(BASE) *multi,
-	__isl_take isl_set *context)
-{
-	return FN(MULTI(BASE),align_params_multi_set_and)(multi, context,
-						&FN(MULTI(BASE),gist_aligned));
-}
-
-__isl_give MULTI(BASE) *FN(MULTI(BASE),gist_params)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *context)
-{
-	isl_space *space = FN(MULTI(BASE),get_domain_space)(multi);
-	isl_set *dom_context = isl_set_universe(space);
-	dom_context = isl_set_intersect_params(dom_context, context);
-	return FN(MULTI(BASE),gist)(multi, dom_context);
-}
-#endif
-
-#ifndef NO_INTERSECT_DOMAIN
-/* Transform the domain of "multi" by combining it with "domain"
- * using "fn".
- *
- * The parameters of "multi" and "domain" are assumed to have been aligned.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_aligned)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain,
-	__isl_give EL *(*fn)(EL *el, __isl_take isl_set *set2))
-{
-	int i;
-
-	if (!multi || !domain)
-		goto error;
-
-	if (multi->n == 0) {
-		isl_set_free(domain);
-		return multi;
-	}
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		goto error;
-
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = fn(multi->pi, isl_set_copy(domain));
-		if (!multi->pi)
-			goto error;
-	}
-
-	isl_set_free(domain);
-	return multi;
-error:
-	isl_set_free(domain);
-	FN(MULTI(BASE),free)(multi);
-	return NULL;
-}
-
-/* Intersect the domain of "multi" with "domain".
- *
- * The parameters of "multi" and "domain" are assumed to have been aligned.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_domain_aligned)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
-{
-	return FN(MULTI(BASE),intersect_aligned)(multi, domain,
-						&FN(EL,intersect_domain));
-}
-
-/* Intersect the domain of "multi" with "domain".
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_domain)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
-{
-	return FN(MULTI(BASE),align_params_multi_set_and)(multi, domain,
-				    &FN(MULTI(BASE),intersect_domain_aligned));
-}
-
-/* Intersect the parameter domain of "multi" with "domain".
+/* Create a multi expression in the given space with the elements of "list"
+ * as base expressions.
  *
- * The parameters of "multi" and "domain" are assumed to have been aligned.
+ * Since isl_multi_*_restore_* assumes that the element and
+ * the multi expression have matching spaces, the alignment
+ * (if any) needs to be performed beforehand.
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_params_aligned)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
-{
-	return FN(MULTI(BASE),intersect_aligned)(multi, domain,
-						&FN(EL,intersect_params));
-}
-
-/* Intersect the parameter domain of "multi" with "domain".
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),intersect_params)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_set *domain)
-{
-	return FN(MULTI(BASE),align_params_multi_set_and)(multi, domain,
-				    &FN(MULTI(BASE),intersect_params_aligned));
-}
-#endif
-
 __isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),LIST(BASE))(
 	__isl_take isl_space *space, __isl_take LIST(EL) *list)
 {
 	int i;
-	int n;
+	isl_size n, dim;
 	isl_ctx *ctx;
 	MULTI(BASE) *multi;
 
-	if (!space || !list)
+	dim = isl_space_dim(space, isl_dim_out);
+	n = FN(FN(LIST(EL),n),BASE)(list);
+	if (dim < 0 || n < 0)
 		goto error;
 
 	ctx = isl_space_get_ctx(space);
-	n = FN(FN(LIST(EL),n),BASE)(list);
-	if (n != isl_space_dim(space, isl_dim_out))
+	if (n != dim)
 		isl_die(ctx, isl_error_invalid,
 			"invalid number of elements in list", goto error);
 
+	for (i = 0; i < n; ++i) {
+		EL *el = FN(LIST(EL),peek)(list, i);
+		space = isl_space_align_params(space, FN(EL,get_space)(el));
+	}
 	multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
 	for (i = 0; i < n; ++i) {
-		multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
-					FN(FN(LIST(EL),get),BASE)(list, i));
+		EL *el = FN(FN(LIST(EL),get),BASE)(list, i);
+		el = FN(EL,align_params)(el, isl_space_copy(space));
+		multi = FN(MULTI(BASE),restore_check_space)(multi, i, el);
 	}
 
 	isl_space_free(space);
@@ -712,195 +479,88 @@
 	return NULL;
 }
 
-#ifndef NO_IDENTITY
-/* Create a multi expression in the given space that maps each
- * input dimension to the corresponding output dimension.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),identity)(__isl_take isl_space *space)
-{
-	int i, n;
-	isl_local_space *ls;
-	MULTI(BASE) *multi;
-
-	if (!space)
-		return NULL;
-
-	if (isl_space_is_set(space))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"expecting map space", goto error);
-
-	n = isl_space_dim(space, isl_dim_out);
-	if (n != isl_space_dim(space, isl_dim_in))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"number of input and output dimensions needs to be "
-			"the same", goto error);
-
-	multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
-
-	if (!n) {
-		isl_space_free(space);
-		return multi;
-	}
-
-	space = isl_space_domain(space);
-	ls = isl_local_space_from_space(space);
-
-	for (i = 0; i < n; ++i) {
-		EL *el;
-		el = FN(EL,var_on_domain)(isl_local_space_copy(ls),
-						isl_dim_set, i);
-		multi = FN(FN(MULTI(BASE),set),BASE)(multi, i, el);
-	}
-
-	isl_local_space_free(ls);
-
-	return multi;
-error:
-	isl_space_free(space);
-	return NULL;
-}
-#endif
-
-/* Construct a multi expression in the given space with value zero in
- * each of the output dimensions.
+/* This function performs the same operation as isl_multi_*_from_*_list,
+ * but is considered as a function on an isl_space when exported.
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),zero)(__isl_take isl_space *space)
-{
-	int n;
-	MULTI(BASE) *multi;
-
-	if (!space)
-		return NULL;
-
-	n = isl_space_dim(space , isl_dim_out);
-	multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
-
-	if (!n)
-		isl_space_free(space);
-	else {
-		int i;
-		isl_local_space *ls;
-		EL *el;
-
-		space = isl_space_domain(space);
-		ls = isl_local_space_from_space(space);
-		el = FN(EL,zero_on_domain)(ls);
-
-		for (i = 0; i < n; ++i)
-			multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
-							    FN(EL,copy)(el));
-
-		FN(EL,free)(el);
-	}
-
-	return multi;
-}
-
-#ifndef NO_FROM_BASE
-__isl_give MULTI(BASE) *FN(FN(MULTI(BASE),from),BASE)(__isl_take EL *el)
+__isl_give MULTI(BASE) *FN(isl_space_multi,BASE)(__isl_take isl_space *space,
+	__isl_take LIST(EL) *list)
 {
-	MULTI(BASE) *multi;
-
-	multi = FN(MULTI(BASE),alloc)(FN(EL,get_space)(el));
-	multi = FN(FN(MULTI(BASE),set),BASE)(multi, 0, el);
-
-	return multi;
+	return FN(FN(MULTI(BASE),from),LIST(BASE))(space, list);
 }
-#endif
 
 __isl_give MULTI(BASE) *FN(MULTI(BASE),drop_dims)(
 	__isl_take MULTI(BASE) *multi,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
-	unsigned dim;
 
 	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	dim = FN(MULTI(BASE),dim)(multi, type);
-	if (first + n > dim || first + n < first)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"index out of bounds",
-			return FN(MULTI(BASE),cow)(multi));
+	if (FN(MULTI(BASE),check_range)(multi, type, first, n) < 0)
+		return FN(MULTI(BASE),free)(multi);
 
 	multi->space = isl_space_drop_dims(multi->space, type, first, n);
 	if (!multi->space)
-		return FN(MULTI(BASE),cow)(multi);
+		return FN(MULTI(BASE),free)(multi);
 
 	if (type == isl_dim_out) {
 		for (i = 0; i < n; ++i)
-			FN(EL,free)(multi->pfirst + i);
+			FN(EL,free)(multi->u.pfirst + i);
 		for (i = first; i + n < multi->n; ++i)
-			multi->pi = multi->pi + n;
+			multi->u.pi = multi->u.pi + n;
 		multi->n -= n;
+		if (n > 0 && FN(MULTI(BASE),has_explicit_domain)(multi))
+			multi = FN(MULTI(BASE),init_explicit_domain)(multi);
 
 		return multi;
 	}
 
+	if (FN(MULTI(BASE),has_explicit_domain)(multi))
+		multi = FN(MULTI(BASE),drop_explicit_domain_dims)(multi,
+								type, first, n);
+	if (!multi)
+		return NULL;
+
 	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,drop_dims)(multi->pi, type, first, n);
-		if (!multi->pi)
-			return FN(MULTI(BASE),cow)(multi);
+		multi->u.pi = FN(EL,drop_dims)(multi->u.pi, type, first, n);
+		if (!multi->u.pi)
+			return FN(MULTI(BASE),free)(multi);
 	}
 
 	return multi;
 }
 
-/* Align the parameters of "multi1" and "multi2" (if needed) and call "fn".
- */
-static __isl_give MULTI(BASE) *FN(MULTI(BASE),align_params_multi_multi_and)(
-	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
-	__isl_give MULTI(BASE) *(*fn)(__isl_take MULTI(BASE) *multi1,
-		__isl_take MULTI(BASE) *multi2))
-{
-	isl_ctx *ctx;
+#undef TYPE
+#define TYPE MULTI(BASE)
 
-	if (!multi1 || !multi2)
-		goto error;
-	if (isl_space_match(multi1->space, isl_dim_param,
-			    multi2->space, isl_dim_param))
-		return fn(multi1, multi2);
-	ctx = FN(MULTI(BASE),get_ctx)(multi1);
-	if (!isl_space_has_named_params(multi1->space) ||
-	    !isl_space_has_named_params(multi2->space))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	multi1 = FN(MULTI(BASE),align_params)(multi1,
-					    FN(MULTI(BASE),get_space)(multi2));
-	multi2 = FN(MULTI(BASE),align_params)(multi2,
-					    FN(MULTI(BASE),get_space)(multi1));
-	return fn(multi1, multi2);
-error:
-	FN(MULTI(BASE),free)(multi1);
-	FN(MULTI(BASE),free)(multi2);
-	return NULL;
-}
+#include "isl_check_named_params_templ.c"
+static
+#include "isl_align_params_bin_templ.c"
 
 /* Given two MULTI(BASE)s A -> B and C -> D,
  * construct a MULTI(BASE) (A * C) -> B -> D.
  *
- * The parameters are assumed to have been aligned.
+ * If "multi1" and/or "multi2" has an explicit domain, then
+ * intersect the domain of the result with these explicit domains.
  */
-static __isl_give MULTI(BASE) *FN(MULTI(BASE),range_product_aligned)(
+__isl_give MULTI(BASE) *FN(MULTI(BASE),range_product)(
 	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
 {
-	int i, n1, n2;
+	int i;
+	isl_size n1, n2;
 	EL *el;
 	isl_space *space;
 	MULTI(BASE) *res;
 
-	if (!multi1 || !multi2)
+	FN(MULTI(BASE),align_params_bin)(&multi1, &multi2);
+	n1 = FN(MULTI(BASE),size)(multi1);
+	n2 = FN(MULTI(BASE),size)(multi2);
+	if (n1 < 0 || n2 < 0)
 		goto error;
 
 	space = isl_space_range_product(FN(MULTI(BASE),get_space)(multi1),
 					FN(MULTI(BASE),get_space)(multi2));
 	res = FN(MULTI(BASE),alloc)(space);
 
-	n1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
-	n2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
-
 	for (i = 0; i < n1; ++i) {
 		el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
 		res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
@@ -911,6 +571,11 @@
 		res = FN(FN(MULTI(BASE),set),BASE)(res, n1 + i, el);
 	}
 
+	if (FN(MULTI(BASE),has_explicit_domain)(multi1))
+		res = FN(MULTI(BASE),intersect_explicit_domain)(res, multi1);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi2))
+		res = FN(MULTI(BASE),intersect_explicit_domain)(res, multi2);
+
 	FN(MULTI(BASE),free)(multi1);
 	FN(MULTI(BASE),free)(multi2);
 	return res;
@@ -920,22 +585,12 @@
 	return NULL;
 }
 
-/* Given two MULTI(BASE)s A -> B and C -> D,
- * construct a MULTI(BASE) (A * C) -> B -> D.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),range_product)(
-	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
-{
-	return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
-					&FN(MULTI(BASE),range_product_aligned));
-}
-
 /* Is the range of "multi" a wrapped relation?
  */
-int FN(MULTI(BASE),range_is_wrapping)(__isl_keep MULTI(BASE) *multi)
+isl_bool FN(MULTI(BASE),range_is_wrapping)(__isl_keep MULTI(BASE) *multi)
 {
 	if (!multi)
-		return -1;
+		return isl_bool_error;
 	return isl_space_range_is_wrapping(multi->space);
 }
 
@@ -945,19 +600,21 @@
 	__isl_take MULTI(BASE) *multi)
 {
 	isl_space *space;
-	int total, keep;
+	isl_size total, keep;
 
-	if (!multi)
-		return NULL;
+	total = FN(MULTI(BASE),dim)(multi, isl_dim_out);
+	if (total < 0)
+		return FN(MULTI(BASE),free)(multi);
 	if (!isl_space_range_is_wrapping(multi->space))
 		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 			"range is not a product",
 			return FN(MULTI(BASE),free)(multi));
 
 	space = FN(MULTI(BASE),get_space)(multi);
-	total = isl_space_dim(space, isl_dim_out);
 	space = isl_space_range_factor_domain(space);
 	keep = isl_space_dim(space, isl_dim_out);
+	if (keep < 0)
+		multi = FN(MULTI(BASE),free)(multi);
 	multi = FN(MULTI(BASE),drop_dims)(multi,
 					isl_dim_out, keep, total - keep);
 	multi = FN(MULTI(BASE),reset_space)(multi, space);
@@ -971,76 +628,51 @@
 	__isl_take MULTI(BASE) *multi)
 {
 	isl_space *space;
-	int total, keep;
+	isl_size total, keep;
 
-	if (!multi)
-		return NULL;
+	total = FN(MULTI(BASE),dim)(multi, isl_dim_out);
+	if (total < 0)
+		return FN(MULTI(BASE),free)(multi);
 	if (!isl_space_range_is_wrapping(multi->space))
 		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
 			"range is not a product",
 			return FN(MULTI(BASE),free)(multi));
 
 	space = FN(MULTI(BASE),get_space)(multi);
-	total = isl_space_dim(space, isl_dim_out);
 	space = isl_space_range_factor_range(space);
 	keep = isl_space_dim(space, isl_dim_out);
+	if (keep < 0)
+		multi = FN(MULTI(BASE),free)(multi);
 	multi = FN(MULTI(BASE),drop_dims)(multi, isl_dim_out, 0, total - keep);
 	multi = FN(MULTI(BASE),reset_space)(multi, space);
 
 	return multi;
 }
 
-/* Given two MULTI(BASE)s A -> B and C -> D,
- * construct a MULTI(BASE) A -> C -> B -> D.
- *
- * The parameters are assumed to have been aligned.
+/* Given a function B -> C, extract the function C.
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),product_aligned)(
-	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
+__isl_give MULTI(BASE) *FN(MULTI(BASE),factor_range)(
+	__isl_take MULTI(BASE) *multi)
 {
-	int i;
-	EL *el;
 	isl_space *space;
-	MULTI(BASE) *res;
-	int in1, in2, out1, out2;
-
-	in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
-	in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
-	out1 = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
-	out2 = FN(MULTI(BASE),dim)(multi2, isl_dim_out);
-	space = isl_space_product(FN(MULTI(BASE),get_space)(multi1),
-				  FN(MULTI(BASE),get_space)(multi2));
-	res = FN(MULTI(BASE),alloc)(isl_space_copy(space));
-	space = isl_space_domain(space);
-
-	for (i = 0; i < out1; ++i) {
-		el = FN(FN(MULTI(BASE),get),BASE)(multi1, i);
-		el = FN(EL,insert_dims)(el, isl_dim_in, in1, in2);
-		el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
-		res = FN(FN(MULTI(BASE),set),BASE)(res, i, el);
-	}
+	isl_size total, keep;
 
-	for (i = 0; i < out2; ++i) {
-		el = FN(FN(MULTI(BASE),get),BASE)(multi2, i);
-		el = FN(EL,insert_dims)(el, isl_dim_in, 0, in1);
-		el = FN(EL,reset_domain_space)(el, isl_space_copy(space));
-		res = FN(FN(MULTI(BASE),set),BASE)(res, out1 + i, el);
-	}
+	total = FN(MULTI(BASE),dim)(multi, isl_dim_set);
+	if (total < 0)
+		return FN(MULTI(BASE),free)(multi);
+	if (!isl_space_is_wrapping(multi->space))
+		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
+			"not a product", return FN(MULTI(BASE),free)(multi));
 
-	isl_space_free(space);
-	FN(MULTI(BASE),free)(multi1);
-	FN(MULTI(BASE),free)(multi2);
-	return res;
-}
+	space = FN(MULTI(BASE),get_space)(multi);
+	space = isl_space_factor_range(space);
+	keep = isl_space_dim(space, isl_dim_set);
+	if (keep < 0)
+		multi = FN(MULTI(BASE),free)(multi);
+	multi = FN(MULTI(BASE),drop_dims)(multi, isl_dim_set, 0, total - keep);
+	multi = FN(MULTI(BASE),reset_space)(multi, space);
 
-/* Given two MULTI(BASE)s A -> B and C -> D,
- * construct a MULTI(BASE) A -> C -> B -> D.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),product)(
-	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
-{
-	return FN(MULTI(BASE),align_params_multi_multi_and)(multi1, multi2,
-					&FN(MULTI(BASE),product_aligned));
+	return multi;
 }
 
 __isl_give MULTI(BASE) *FN(MULTI(BASE),flatten_range)(
@@ -1093,15 +725,14 @@
 	__isl_take MULTI(BASE) *multi2)
 {
 	MULTI(BASE) *res;
-	unsigned dim;
+	isl_size dim;
 
-	if (!multi1 || !multi2)
+	dim = FN(MULTI(BASE),size)(multi1);
+	if (dim < 0 || !multi2)
 		goto error;
 
-	dim = FN(MULTI(BASE),dim)(multi1, isl_dim_out);
-	if (pos > dim)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
-			"index out of bounds", goto error);
+	if (FN(MULTI(BASE),check_range)(multi1, isl_dim_out, pos, 0) < 0)
+		goto error;
 
 	res = FN(MULTI(BASE),copy)(multi1);
 	res = FN(MULTI(BASE),drop_dims)(res, isl_dim_out, pos, dim - pos);
@@ -1117,57 +748,13 @@
 	return NULL;
 }
 
-/* Given two multi expressions, "multi1"
- *
- *	A1 A2 -> B1 B2
- *
- * where A2 starts at position "in_pos" and B2 starts at position "out_pos",
- * and "multi2"
- *
- *	C -> D
- *
- * return the multi expression
- *
- *	A1 C A2 -> B1 D B2
- *
- * We first insert input dimensions to obtain
- *
- *	A1 C A2 -> B1 B2
- *
- * and
- *
- *	A1 C A2 -> D
- *
- * and then apply range_splice.
- */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),splice)(
-	__isl_take MULTI(BASE) *multi1, unsigned in_pos, unsigned out_pos,
-	__isl_take MULTI(BASE) *multi2)
-{
-	unsigned n_in1;
-	unsigned n_in2;
-
-	if (!multi1 || !multi2)
-		goto error;
-
-	n_in1 = FN(MULTI(BASE),dim)(multi1, isl_dim_in);
-	if (in_pos > n_in1)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi1), isl_error_invalid,
-			"index out of bounds", goto error);
-
-	n_in2 = FN(MULTI(BASE),dim)(multi2, isl_dim_in);
+#undef TYPE
+#define TYPE	MULTI(BASE)
 
-	multi1 = FN(MULTI(BASE),insert_dims)(multi1, isl_dim_in, in_pos, n_in2);
-	multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, n_in2,
-						n_in1 - in_pos);
-	multi2 = FN(MULTI(BASE),insert_dims)(multi2, isl_dim_in, 0, in_pos);
-
-	return FN(MULTI(BASE),range_splice)(multi1, out_pos, multi2);
-error:
-	FN(MULTI(BASE),free)(multi1);
-	FN(MULTI(BASE),free)(multi2);
-	return NULL;
-}
+static
+#include "isl_type_has_equal_space_bin_templ.c"
+static
+#include "isl_type_check_equal_space_templ.c"
 
 /* This function is currently only used from isl_aff.c
  */
@@ -1178,29 +765,32 @@
 
 /* Pairwise perform "fn" to the elements of "multi1" and "multi2" and
  * return the result.
+ *
+ * If "multi2" has an explicit domain, then
+ * intersect the domain of the result with this explicit domain.
  */
 static __isl_give MULTI(BASE) *FN(MULTI(BASE),bin_op)(
 	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2,
 	__isl_give EL *(*fn)(__isl_take EL *, __isl_take EL *))
 {
 	int i;
-	isl_ctx *ctx;
 
+	FN(MULTI(BASE),align_params_bin)(&multi1, &multi2);
 	multi1 = FN(MULTI(BASE),cow)(multi1);
-	if (!multi1 || !multi2)
+	if (FN(MULTI(BASE),check_equal_space)(multi1, multi2) < 0)
 		goto error;
 
-	ctx = FN(MULTI(BASE),get_ctx)(multi1);
-	if (!isl_space_is_equal(multi1->space, multi2->space))
-		isl_die(ctx, isl_error_invalid,
-			"spaces don't match", goto error);
-
 	for (i = 0; i < multi1->n; ++i) {
-		multi1->pi = fn(multi1->pi, FN(EL,copy)(multi2->pi));
-		if (!multi1->pi)
+		multi1->u.pi = fn(multi1->u.pi,
+						FN(EL,copy)(multi2->u.pi));
+		if (!multi1->u.pi)
 			goto error;
 	}
 
+	if (FN(MULTI(BASE),has_explicit_domain)(multi2))
+		multi1 = FN(MULTI(BASE),intersect_explicit_domain)(multi1,
+								    multi2);
+
 	FN(MULTI(BASE),free)(multi2);
 	return multi1;
 error:
@@ -1209,170 +799,57 @@
 	return NULL;
 }
 
-/* Multiply the elements of "multi" by "v" and return the result.
+/* Only used on some multi-expressions.
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_val)(__isl_take MULTI(BASE) *multi,
-	__isl_take isl_val *v)
-{
-	int i;
+static isl_bool FN(MULTI(BASE),any)(__isl_keep MULTI(BASE) *multi,
+	isl_bool (*test)(__isl_keep EL *)) __attribute__ ((unused));
 
-	if (!multi || !v)
-		goto error;
-
-	if (isl_val_is_one(v)) {
-		isl_val_free(v);
-		return multi;
-	}
-
-	if (!isl_val_is_rat(v))
-		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational factor", goto error);
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,scale_val)(multi->pi, isl_val_copy(v));
-		if (!multi->pi)
-			goto error;
-	}
-
-	isl_val_free(v);
-	return multi;
-error:
-	isl_val_free(v);
-	return FN(MULTI(BASE),free)(multi);
-}
-
-/* Multiply the elements of "multi" by the corresponding element of "mv"
- * and return the result.
+/* Does "test" succeed on any base expression of "multi"?
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_multi_val)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
+static isl_bool FN(MULTI(BASE),any)(__isl_keep MULTI(BASE) *multi,
+	isl_bool (*test)(__isl_keep EL *))
 {
+	isl_size n;
 	int i;
 
-	if (!multi || !mv)
-		goto error;
-
-	if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
-					mv->space, isl_dim_set))
-		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
-			"spaces don't match", goto error);
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	for (i = 0; i < multi->n; ++i) {
-		isl_val *v;
+	n = FN(MULTI(BASE),size)(multi);
+	if (n < 0)
+		return isl_bool_error;
 
-		v = isl_multi_val_get_val(mv, i);
-		multi->pi = FN(EL,scale_val)(multi->pi, v);
-		if (!multi->pi)
-			goto error;
+	for (i = 0; i < n; ++i) {
+		isl_bool any = test(multi->u.pi);
+		if (any < 0 || any)
+			return any;
 	}
 
-	isl_multi_val_free(mv);
-	return multi;
-error:
-	isl_multi_val_free(mv);
-	return FN(MULTI(BASE),free)(multi);
+	return isl_bool_false;
 }
 
-/* Divide the elements of "multi" by the corresponding element of "mv"
- * and return the result.
+/* Only used on some multi-expressions.
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),scale_down_multi_val)(
-	__isl_take MULTI(BASE) *multi, __isl_take isl_multi_val *mv)
-{
-	int i;
-
-	if (!multi || !mv)
-		goto error;
-
-	if (!isl_space_tuple_is_equal(multi->space, isl_dim_out,
-					mv->space, isl_dim_set))
-		isl_die(isl_multi_val_get_ctx(mv), isl_error_invalid,
-			"spaces don't match", goto error);
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
+static isl_bool FN(MULTI(BASE),every)(__isl_keep MULTI(BASE) *multi,
+	isl_bool (*test)(__isl_keep EL *)) __attribute__ ((unused));
 
-	for (i = 0; i < multi->n; ++i) {
-		isl_val *v;
-
-		v = isl_multi_val_get_val(mv, i);
-		multi->pi = FN(EL,scale_down_val)(multi->pi, v);
-		if (!multi->pi)
-			goto error;
-	}
-
-	isl_multi_val_free(mv);
-	return multi;
-error:
-	isl_multi_val_free(mv);
-	return FN(MULTI(BASE),free)(multi);
-}
-
-#ifndef NO_MOVE_DIMS
-/* Move the "n" dimensions of "src_type" starting at "src_pos" of "multi"
- * to dimensions of "dst_type" at "dst_pos".
- *
- * We only support moving input dimensions to parameters and vice versa.
+/* Does "test" succeed on every base expression of "multi"?
  */
-__isl_give MULTI(BASE) *FN(MULTI(BASE),move_dims)(__isl_take MULTI(BASE) *multi,
-	enum isl_dim_type dst_type, unsigned dst_pos,
-	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+static isl_bool FN(MULTI(BASE),every)(__isl_keep MULTI(BASE) *multi,
+	isl_bool (*test)(__isl_keep EL *))
 {
+	isl_size n;
 	int i;
 
-	if (!multi)
-		return NULL;
-
-	if (n == 0 &&
-	    !isl_space_is_named_or_nested(multi->space, src_type) &&
-	    !isl_space_is_named_or_nested(multi->space, dst_type))
-		return multi;
+	n = FN(MULTI(BASE),size)(multi);
+	if (n < 0)
+		return isl_bool_error;
 
-	if (dst_type == isl_dim_out || src_type == isl_dim_out)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"cannot move output/set dimension",
-			return FN(MULTI(BASE),free)(multi));
-	if (dst_type == isl_dim_div || src_type == isl_dim_div)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"cannot move divs",
-			return FN(MULTI(BASE),free)(multi));
-	if (src_pos + n > isl_space_dim(multi->space, src_type))
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_invalid,
-			"range out of bounds",
-			return FN(MULTI(BASE),free)(multi));
-	if (dst_type == src_type)
-		isl_die(FN(MULTI(BASE),get_ctx)(multi), isl_error_unsupported,
-			"moving dims within the same type not supported",
-			return FN(MULTI(BASE),free)(multi));
-
-	multi = FN(MULTI(BASE),cow)(multi);
-	if (!multi)
-		return NULL;
-
-	multi->space = isl_space_move_dims(multi->space, dst_type, dst_pos,
-						src_type, src_pos, n);
-	if (!multi->space)
-		return FN(MULTI(BASE),free)(multi);
-
-	for (i = 0; i < multi->n; ++i) {
-		multi->pi = FN(EL,move_dims)(multi->pi, dst_type, dst_pos,
-						src_type, src_pos, n);
-		if (!multi->pi)
-			return FN(MULTI(BASE),free)(multi);
+	for (i = 0; i < n; ++i) {
+		isl_bool every = test(multi->u.pi);
+		if (every < 0 || !every)
+			return every;
 	}
 
-	return multi;
+	return isl_bool_true;
 }
-#endif
 
 /* Convert a multiple expression defined over a parameter domain
  * into one that is defined over a zero-dimensional set.
@@ -1398,49 +875,32 @@
 
 /* Are "multi1" and "multi2" obviously equal?
  */
-int FN(MULTI(BASE),plain_is_equal)(__isl_keep MULTI(BASE) *multi1,
+isl_bool FN(MULTI(BASE),plain_is_equal)(__isl_keep MULTI(BASE) *multi1,
 	__isl_keep MULTI(BASE) *multi2)
 {
 	int i;
-	int equal;
+	isl_bool equal;
 
 	if (!multi1 || !multi2)
-		return -1;
+		return isl_bool_error;
 	if (multi1->n != multi2->n)
-		return 0;
+		return isl_bool_false;
 	equal = isl_space_is_equal(multi1->space, multi2->space);
 	if (equal < 0 || !equal)
 		return equal;
 
 	for (i = 0; i < multi1->n; ++i) {
-		equal = FN(EL,plain_is_equal)(multi1->pi, multi2->pi);
+		equal = FN(EL,plain_is_equal)(multi1->u.pi, multi2->u.pi);
 		if (equal < 0 || !equal)
 			return equal;
 	}
 
-	return 1;
-}
-
-#ifndef NO_DOMAIN
-/* Return the shared domain of the elements of "multi".
- */
-__isl_give isl_set *FN(MULTI(BASE),domain)(__isl_take MULTI(BASE) *multi)
-{
-	int i;
-	isl_set *dom;
-
-	if (!multi)
-		return NULL;
-
-	dom = isl_set_universe(FN(MULTI(BASE),get_domain_space)(multi));
-	for (i = 0; i < multi->n; ++i) {
-		isl_set *dom_i;
-
-		dom_i = FN(EL,domain)(FN(FN(MULTI(BASE),get),BASE)(multi, i));
-		dom = isl_set_intersect(dom, dom_i);
+	if (FN(MULTI(BASE),has_explicit_domain)(multi1) ||
+	    FN(MULTI(BASE),has_explicit_domain)(multi2)) {
+		equal = FN(MULTI(BASE),equal_explicit_domain)(multi1, multi2);
+		if (equal < 0 || !equal)
+			return equal;
 	}
 
-	FN(MULTI(BASE),free)(multi);
-	return dom;
+	return isl_bool_true;
 }
-#endif

_service:tar_scm:isl-0.14.tar.xz/isl_multi_templ.h -> _service:tar_scm:isl-0.24.tar.gz/isl_multi_templ.h Changed

@@ -1,18 +1,34 @@
 #include <isl/space.h>
 
-#define xCAT(A,B) A ## B
-#define CAT(A,B) xCAT(A,B)
-#undef EL
-#define EL CAT(isl_,BASE)
-#define xMULTI(BASE) isl_multi_ ## BASE
-#define MULTI(BASE) xMULTI(BASE)
+#include <isl_multi_macro.h>
 
+/* A multiple expression with base expressions of type EL.
+ *
+ * "space" is the space in which the multiple expression lives.
+ * "n" is the number of base expression and is equal
+ * to the output or set dimension of "space".
+ * "p" is an array of size "n" of base expressions.
+ * The array is only accessible when n > 0.
+ * "dom" is the explicit domain, if present
+ * The explicit domain is only accessible when n == 0.
+ */
 struct MULTI(BASE) {
 	int ref;
 	isl_space *space;
 
 	int n;
-	EL *p1;
+	struct {
+#ifdef EXPLICIT_DOMAIN
+		DOM *dom;
+#endif
+		EL *p1;
+	} u;
 };
 
 __isl_give MULTI(BASE) *CAT(MULTI(BASE),_alloc)(__isl_take isl_space *space);
+__isl_keep isl_space *FN(MULTI(BASE),peek_space)(__isl_keep MULTI(BASE) *multi);
+
+#ifdef EXPLICIT_DOMAIN
+isl_bool CAT(MULTI(BASE),_has_non_trivial_domain)(
+	__isl_keep MULTI(BASE) *multi);
+#endif

_service:tar_scm:isl-0.24.tar.gz/isl_multi_tuple_id_templ.c Added

@@ -0,0 +1,145 @@
+/*
+ * Copyright 2011      Sven Verdoolaege
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+
+#include <isl_multi_macro.h>
+
+const char *FN(MULTI(BASE),get_tuple_name)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type)
+{
+	return multi ? isl_space_get_tuple_name(multi->space, type) : NULL;
+}
+
+/* Does the specified tuple have an id?
+ */
+isl_bool FN(MULTI(BASE),has_tuple_id)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type)
+{
+	if (!multi)
+		return isl_bool_error;
+	return isl_space_has_tuple_id(multi->space, type);
+}
+
+/* Does the (range) tuple of "multi" have an identifier?
+ *
+ * Technically, the implementation should use isl_dim_set if "multi"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+isl_bool FN(MULTI(BASE),has_range_tuple_id)(__isl_keep MULTI(BASE) *multi)
+{
+	return FN(MULTI(BASE),has_tuple_id)(multi, isl_dim_out);
+}
+
+/* Return the id of the specified tuple.
+ */
+__isl_give isl_id *FN(MULTI(BASE),get_tuple_id)(__isl_keep MULTI(BASE) *multi,
+	enum isl_dim_type type)
+{
+	return multi ? isl_space_get_tuple_id(multi->space, type) : NULL;
+}
+
+/* Return the identifier of the (range) tuple of "multi", assuming it has one.
+ *
+ * Technically, the implementation should use isl_dim_set if "multi"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+__isl_give isl_id *FN(MULTI(BASE),get_range_tuple_id)(
+	__isl_keep MULTI(BASE) *multi)
+{
+	return FN(MULTI(BASE),get_tuple_id)(multi, isl_dim_out);
+}
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_name)(
+	__isl_keep MULTI(BASE) *multi, enum isl_dim_type type,
+	const char *s)
+{
+	isl_space *space;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	space = FN(MULTI(BASE),get_space)(multi);
+	space = isl_space_set_tuple_name(space, type, s);
+
+	return FN(MULTI(BASE),reset_space)(multi, space);
+}
+
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_tuple_id)(
+	__isl_take MULTI(BASE) *multi, enum isl_dim_type type,
+	__isl_take isl_id *id)
+{
+	isl_space *space;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		goto error;
+
+	space = FN(MULTI(BASE),get_space)(multi);
+	space = isl_space_set_tuple_id(space, type, id);
+
+	return FN(MULTI(BASE),reset_space)(multi, space);
+error:
+	isl_id_free(id);
+	return NULL;
+}
+
+/* Replace the identifier of the (range) tuple of "multi" by "id".
+ *
+ * Technically, the implementation should use isl_dim_set if "multi"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),set_range_tuple_id)(
+	__isl_take MULTI(BASE) *multi, __isl_take isl_id *id)
+{
+	return FN(MULTI(BASE),set_tuple_id)(multi, isl_dim_out, id);
+}
+
+/* Drop the id on the specified tuple.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),reset_tuple_id)(
+	__isl_take MULTI(BASE) *multi, enum isl_dim_type type)
+{
+	isl_space *space;
+
+	if (!multi)
+		return NULL;
+	if (!FN(MULTI(BASE),has_tuple_id)(multi, type))
+		return multi;
+
+	multi = FN(MULTI(BASE),cow)(multi);
+	if (!multi)
+		return NULL;
+
+	space = FN(MULTI(BASE),get_space)(multi);
+	space = isl_space_reset_tuple_id(space, type);
+
+	return FN(MULTI(BASE),reset_space)(multi, space);
+}
+
+/* Drop the identifier of the (range) tuple of "multi".
+ *
+ * Technically, the implementation should use isl_dim_set if "multi"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),reset_range_tuple_id)(
+	__isl_take MULTI(BASE) *multi)
+{
+	return FN(MULTI(BASE),reset_tuple_id)(multi, isl_dim_out);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_unbind_params_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_union_add_templ.c Added

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <isl_multi_macro.h>
+
+/* Compute the sum of "multi1" and "multi2" on the union of their domains,
+ * with the actual sum on the shared domain and
+ * the defined expression on the symmetric difference of the domains.
+ *
+ * We simply iterate over the elements in both arguments and
+ * call isl_union_pw_aff_union_add on each of them, if there is
+ * at least one element.
+ *
+ * Otherwise, the two expressions have an explicit domain and
+ * the union of these explicit domains is computed.
+ * This assumes that the explicit domains are either both in terms
+ * of specific domains elements or both in terms of parameters.
+ * However, if one of the expressions does not have any constraints
+ * on its explicit domain, then this is allowed as well and the result
+ * is the expression with no constraints on its explicit domain.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),union_add)(
+	__isl_take MULTI(BASE) *multi1, __isl_take MULTI(BASE) *multi2)
+{
+	isl_bool has_domain, is_params1, is_params2;
+
+	if (!multi1)
+		goto error;
+	if (multi1->n > 0)
+		return FN(MULTI(BASE),bin_op)(multi1, multi2,
+					    &FN(EL,union_add));
+	FN(MULTI(BASE),align_params_bin)(&multi1, &multi2);
+	if (FN(MULTI(BASE),check_equal_space)(multi1, multi2) < 0)
+		goto error;
+	if (FN(MULTI(BASE),check_has_explicit_domain)(multi1) < 0 ||
+	    FN(MULTI(BASE),check_has_explicit_domain)(multi2) < 0)
+		goto error;
+
+	has_domain = FN(MULTI(BASE),has_non_trivial_domain)(multi1);
+	if (has_domain < 0)
+		goto error;
+	if (!has_domain) {
+		FN(MULTI(BASE),free)(multi2);
+		return multi1;
+	}
+	has_domain = FN(MULTI(BASE),has_non_trivial_domain)(multi2);
+	if (has_domain < 0)
+		goto error;
+	if (!has_domain) {
+		FN(MULTI(BASE),free)(multi1);
+		return multi2;
+	}
+
+	is_params1 = FN(DOM,is_params)(multi1->u.dom);
+	is_params2 = FN(DOM,is_params)(multi2->u.dom);
+	if (is_params1 < 0 || is_params2 < 0)
+		goto error;
+	if (is_params1 != is_params2)
+		isl_die(FN(MULTI(BASE),get_ctx)(multi1),
+			isl_error_invalid,
+			"cannot compute union of concrete domain and "
+			"parameter constraints", goto error);
+	multi1 = FN(MULTI(BASE),cow)(multi1);
+	if (!multi1)
+		goto error;
+	multi1->u.dom = FN(DOM,union)(multi1->u.dom,
+					FN(DOM,copy)(multi2->u.dom));
+	if (!multi1->u.dom)
+		goto error;
+	FN(MULTI(BASE),free)(multi2);
+	return multi1;
+error:
+	FN(MULTI(BASE),free)(multi1);
+	FN(MULTI(BASE),free)(multi2);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_union_pw_aff_explicit_domain.c Added

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* Initialize the explicit domain of "mupa".
+ *
+ * The explicit domain is initialized to a universe parameter set.
+ * It may later be specialized with constraints on the parameter or
+ * specific domain instances.
+ */
+static __isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_init_explicit_domain(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	isl_space *space;
+
+	if (isl_multi_union_pw_aff_check_has_explicit_domain(mupa) < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+	space = isl_space_params(isl_multi_union_pw_aff_get_space(mupa));
+	mupa->u.dom = isl_union_set_from_set(isl_set_universe(space));
+	if (!mupa->u.dom)
+		return isl_multi_union_pw_aff_free(mupa);
+	return mupa;
+}
+
+/* Drop the "n" dimensions of type "type" starting at position "pos"
+ * of the explicit domain of "mupa".
+ */
+static __isl_give isl_multi_union_pw_aff *
+isl_multi_union_pw_aff_drop_explicit_domain_dims(
+	__isl_take isl_multi_union_pw_aff *mupa,
+	enum isl_dim_type type, unsigned pos, unsigned n)
+{
+	if (isl_multi_union_pw_aff_check_has_explicit_domain(mupa) < 0)
+		return isl_multi_union_pw_aff_free(mupa);
+	if (type != isl_dim_param)
+		isl_die(isl_multi_union_pw_aff_get_ctx(mupa), isl_error_invalid,
+			"can only drop parameters",
+			return isl_multi_union_pw_aff_free(mupa));
+	mupa = isl_multi_union_pw_aff_cow(mupa);
+	if (!mupa)
+		return NULL;
+	mupa->u.dom = isl_union_set_project_out(mupa->u.dom, type, pos, n);
+	if (!mupa->u.dom)
+		return isl_multi_union_pw_aff_free(mupa);
+	return mupa;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_multi_zero_space_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_multi_zero_templ.c Added

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/space.h>
+#include <isl/local_space.h>
+
+#include <isl_multi_macro.h>
+
+/* Construct a multi expression in the given space with value zero in
+ * each of the output dimensions.
+ */
+__isl_give MULTI(BASE) *FN(MULTI(BASE),zero)(__isl_take isl_space *space)
+{
+	isl_size n;
+	MULTI(BASE) *multi;
+
+	n = isl_space_dim(space , isl_dim_out);
+	if (n < 0)
+		goto error;
+
+	multi = FN(MULTI(BASE),alloc)(isl_space_copy(space));
+
+	if (!n)
+		isl_space_free(space);
+	else {
+		int i;
+		isl_local_space *ls;
+		EL *el;
+
+		space = isl_space_domain(space);
+		ls = isl_local_space_from_space(space);
+		el = FN(EL,zero_on_domain)(ls);
+
+		for (i = 0; i < n; ++i)
+			multi = FN(FN(MULTI(BASE),set),BASE)(multi, i,
+							    FN(EL,copy)(el));
+
+		FN(EL,free)(el);
+	}
+
+	return multi;
+error:
+	isl_space_free(space);
+	return NULL;
+}
+
+#include "isl_multi_zero_space_templ.c"

_service:tar_scm:isl-0.14.tar.xz/isl_obj.c -> _service:tar_scm:isl-0.24.tar.gz/isl_obj.c Changed

@@ -1,6 +1,7 @@
 /*
  * Copyright 2010      INRIA Saclay
  * Copyright 2014      Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
  *
  * Use of this software is governed by the MIT license
  *
@@ -8,12 +9,18 @@
  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
  * 91893 Orsay, France 
  * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
  */
 
+#include <isl/val.h>
 #include <isl/aff.h>
 #include <isl/set.h>
 #include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
 #include <isl/polynomial.h>
+#include <isl/schedule.h>
 #include <isl/obj.h>
 
 static void *isl_obj_val_copy(void *v)
@@ -333,3 +340,26 @@
 	isl_obj_union_pw_qpf_print,
 	isl_obj_union_pw_qpf_free
 };
+
+static void *isl_obj_schedule_copy(void *v)
+{
+	return isl_schedule_copy((isl_schedule *) v);
+}
+
+static void isl_obj_schedule_free(void *v)
+{
+	isl_schedule_free((isl_schedule *) v);
+}
+
+static __isl_give isl_printer *isl_obj_schedule_print(
+	__isl_take isl_printer *p, void *v)
+{
+	return isl_printer_print_schedule(p, (isl_schedule *) v);
+}
+
+struct isl_obj_vtable isl_obj_schedule_vtable = {
+	isl_obj_schedule_copy,
+	NULL,
+	isl_obj_schedule_print,
+	isl_obj_schedule_free
+};

_service:tar_scm:isl-0.24.tar.gz/isl_opt_mpa_templ.c Added

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2018      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#undef TYPE
+#define TYPE CAT(isl_,BASE)
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Compute the optima of the set or output dimensions as a function of the
+ * parameters (and input dimensions), but independently of
+ * the other set or output dimensions,
+ * given a function "opt" that computes this optimum
+ * for a single dimension.
+ *
+ * If the resulting multi piecewise affine expression has
+ * an explicit domain, then assign it the (parameter) domain of the input.
+ * In other cases, the (parameter) domain is stored in the individual elements.
+ */
+static __isl_give isl_multi_pw_aff *FN(BASE,opt_mpa)(__isl_take TYPE *obj,
+	__isl_give isl_pw_aff *(*opt)(__isl_take TYPE *obj, int pos))
+{
+	int i;
+	isl_size n;
+	isl_multi_pw_aff *mpa;
+
+	mpa = isl_multi_pw_aff_alloc(FN(TYPE,get_space)(obj));
+	n = isl_multi_pw_aff_size(mpa);
+	if (n < 0)
+		mpa = isl_multi_pw_aff_free(mpa);
+	for (i = 0; i < n; ++i) {
+		isl_pw_aff *pa;
+
+		pa = opt(FN(TYPE,copy)(obj), i);
+		mpa = isl_multi_pw_aff_set_pw_aff(mpa, i, pa);
+	}
+	if (isl_multi_pw_aff_has_explicit_domain(mpa)) {
+		isl_set *dom;
+
+		dom = FN(TYPE,domain)(FN(TYPE,copy)(obj));
+		mpa = isl_multi_pw_aff_intersect_domain(mpa, dom);
+	}
+	FN(TYPE,free)(obj);
+
+	return mpa;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_options.c -> _service:tar_scm:isl-0.24.tar.gz/isl_options.c Changed

@@ -72,12 +72,30 @@
 	{0}
 };
 
+#define		ISL_SCHEDULE_FUSE_MAX			0
+#define		ISL_SCHEDULE_FUSE_MIN			1
+
 static struct isl_arg_choice fuse = {
 	{"max",		ISL_SCHEDULE_FUSE_MAX},
 	{"min",		ISL_SCHEDULE_FUSE_MIN},
 	{0}
 };
 
+/* Callback for setting the "schedule-fuse" option.
+ * This (now hidden) option tries to mimic an option that was
+ * replaced by the schedule-serialize-sccs option.
+ * Setting the old option to ISL_SCHEDULE_FUSE_MIN is now
+ * expressed by turning on the schedule-serialize-sccs option.
+ */
+static int set_fuse(void *opt, unsigned val)
+{
+	struct isl_options *options = opt;
+
+	options->schedule_serialize_sccs = (val == ISL_SCHEDULE_FUSE_MIN);
+
+	return 0;
+}
+
 static struct isl_arg_choice separation_bounds = {
 	{"explicit",	ISL_AST_BUILD_SEPARATION_BOUNDS_EXPLICIT},
 	{"implicit",	ISL_AST_BUILD_SEPARATION_BOUNDS_IMPLICIT},
@@ -116,6 +134,9 @@
 	convex,	ISL_CONVEX_HULL_WRAP, "convex hull algorithm to use")
 ISL_ARG_BOOL(struct isl_options, coalesce_bounded_wrapping, 0,
 	"coalesce-bounded-wrapping", 1, "bound wrapping during coalescing")
+ISL_ARG_BOOL(struct isl_options, coalesce_preserve_locals, 0,
+	"coalesce-preserve-locals", 0,
+	"preserve local variables during coalescing")
 ISL_ARG_INT(struct isl_options, schedule_max_coefficient, 0,
 	"schedule-max-coefficient", "limit", -1, "Only consider schedules "
 	"where the coefficients of the variable and parameter dimensions "
@@ -133,17 +154,32 @@
 ISL_ARG_BOOL(struct isl_options, schedule_maximize_band_depth, 0,
 	"schedule-maximize-band-depth", 0,
 	"maximize the number of scheduling dimensions in a band")
+ISL_ARG_BOOL(struct isl_options, schedule_maximize_coincidence, 0,
+	"schedule-maximize-coincidence", 0,
+	"maximize the number of coincident dimensions in a band")
 ISL_ARG_BOOL(struct isl_options, schedule_split_scaled, 0,
 	"schedule-split-scaled", 1,
 	"split non-tilable bands with scaled schedules")
+ISL_ARG_BOOL(struct isl_options, schedule_treat_coalescing, 0,
+	"schedule-treat-coalescing", 1,
+	"try and prevent or adjust schedules that perform loop coalescing")
 ISL_ARG_BOOL(struct isl_options, schedule_separate_components, 0,
 	"schedule-separate-components", 1,
 	"separate components in dependence graph")
+ISL_ARG_BOOL(struct isl_options, schedule_whole_component, 0,
+	"schedule-whole-component", 0,
+	"try and compute schedule for entire component first")
 ISL_ARG_CHOICE(struct isl_options, schedule_algorithm, 0,
 	"schedule-algorithm", isl_schedule_algorithm_choice,
 	ISL_SCHEDULE_ALGORITHM_ISL, "scheduling algorithm to use")
-ISL_ARG_CHOICE(struct isl_options, schedule_fuse, 0, "schedule-fuse", fuse,
-	ISL_SCHEDULE_FUSE_MAX, "level of fusion during scheduling")
+ISL_ARG_BOOL(struct isl_options, schedule_carry_self_first, 0,
+	"schedule-carry-self-first", 1, "try and carry self-dependences first")
+ISL_ARG_BOOL(struct isl_options, schedule_serialize_sccs, 0,
+	"schedule-serialize-sccs", 0,
+	"serialize strongly connected components in dependence graph")
+ISL_ARG_PHANTOM_USER_CHOICE_F(0, "schedule-fuse", fuse, &set_fuse,
+	ISL_SCHEDULE_FUSE_MAX, "level of fusion during scheduling",
+	ISL_ARG_HIDDEN)
 ISL_ARG_BOOL(struct isl_options, tile_scale_tile_loops, 0,
 	"tile-scale-tile-loops", 1, "scale tile loops")
 ISL_ARG_BOOL(struct isl_options, tile_shift_point_loops, 0,
@@ -154,10 +190,16 @@
 ISL_ARG_BOOL(struct isl_options, ast_always_print_block, 0,
 	"ast-always-print-block", 0, "print for and if bodies as a block "
 	"regardless of the number of statements in the body")
+ISL_ARG_BOOL(struct isl_options, ast_print_outermost_block, 0,
+	"ast-print-outermost-block", 1, "print outermost block node as a block")
+ISL_ARG_BOOL(struct isl_options, ast_print_macro_once, 0,
+	"ast-print-macro-once", 0, "only print macro definitions once")
 ISL_ARG_BOOL(struct isl_options, ast_build_atomic_upper_bound, 0,
 	"ast-build-atomic-upper-bound", 1, "generate atomic upper bounds")
 ISL_ARG_BOOL(struct isl_options, ast_build_prefer_pdiv, 0,
 	"ast-build-prefer-pdiv", 1, "prefer pdiv operation over fdiv")
+ISL_ARG_BOOL(struct isl_options, ast_build_detect_min_max, 0,
+	"ast-build-detect-min-max", 0, "detect min/max expressions")
 ISL_ARG_BOOL(struct isl_options, ast_build_exploit_nested_bounds, 0,
 	"ast-build-exploit-nested-bounds", 1,
 	"simplify conditions based on bounds of nested for loops")
@@ -195,11 +237,21 @@
 	on_error)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	pip_symmetry)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	pip_symmetry)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	coalesce_bounded_wrapping)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	coalesce_bounded_wrapping)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	coalesce_preserve_locals)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	coalesce_preserve_locals)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	gbr_only_first)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	gbr_only_first)
@@ -220,16 +272,31 @@
 	schedule_maximize_band_depth)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_maximize_coincidence)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_maximize_coincidence)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_split_scaled)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_split_scaled)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_treat_coalescing)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_treat_coalescing)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_separate_components)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_separate_components)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_whole_component)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_whole_component)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_outer_coincidence)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_outer_coincidence)
@@ -239,10 +306,15 @@
 ISL_CTX_GET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
 	schedule_algorithm)
 
-ISL_CTX_SET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
-	schedule_fuse)
-ISL_CTX_GET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
-	schedule_fuse)
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_carry_self_first)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_carry_self_first)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_serialize_sccs)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	schedule_serialize_sccs)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	tile_scale_tile_loops)
@@ -265,6 +337,11 @@
 	ast_build_prefer_pdiv)
 
 ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_build_detect_min_max)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_build_detect_min_max)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	ast_build_exploit_nested_bounds)
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	ast_build_exploit_nested_bounds)
@@ -284,6 +361,16 @@
 ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
 	ast_always_print_block)
 
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_print_outermost_block)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_print_outermost_block)
+
+ISL_CTX_SET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_print_macro_once)
+ISL_CTX_GET_BOOL_DEF(isl_options, struct isl_options, isl_options_args,
+	ast_print_macro_once)
+
 ISL_CTX_SET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,
 	ast_build_separation_bounds)
 ISL_CTX_GET_CHOICE_DEF(isl_options, struct isl_options, isl_options_args,

_service:tar_scm:isl-0.14.tar.xz/isl_options_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_options_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_output.c -> _service:tar_scm:isl-0.24.tar.gz/isl_output.c Changed

@@ -2,6 +2,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  * Copyright 2012-2013 Ecole Normale Superieure
+ * Copyright 2019      Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -9,7 +10,8 @@
  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
- * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
 #include <stdlib.h>
@@ -23,13 +25,22 @@
 #include <isl_space_private.h>
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
+#include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl/constraint.h>
+#include <isl_local.h>
 #include <isl_local_space_private.h>
 #include <isl_aff_private.h>
+#include <isl_id_private.h>
 #include <isl_val_private.h>
+#include <isl_constraint_private.h>
 #include <isl/ast_build.h>
 #include <isl_sort.h>
+#include <isl_output_private.h>
+
+#include <bset_to_bmap.c>
+#include <set_to_map.c>
+#include <uset_to_umap.c>
 
 static const char *s_to2 = { " -> ", " \\to " };
 static const char *s_and2 = { " and ", " \\wedge " };
@@ -44,6 +55,7 @@
 static const char *s_open_exists2 = { "exists (", "\\exists \\, " };
 static const char *s_close_exists2 = { ")", "" };
 static const char *s_div_prefix2 = { "e", "\\alpha_" };
+static const char *s_mod2 = { "mod", "\\bmod" };
 static const char *s_param_prefix2 = { "p", "p_" };
 static const char *s_input_prefix2 = { "i", "i_" };
 static const char *s_output_prefix2 = { "o", "o_" };
@@ -52,11 +64,14 @@
 	struct isl_basic_map *bmap, int ineq, int n, __isl_take isl_printer *p)
 {
 	int i;
-	unsigned n_in = isl_basic_map_dim(bmap, isl_dim_in);
-	unsigned n_out = isl_basic_map_dim(bmap, isl_dim_out);
-	unsigned nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	isl_size n_in = isl_basic_map_dim(bmap, isl_dim_in);
+	isl_size n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	isl_size nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	isl_int *c = ineq ? bmap->ineqn : bmap->eqn;
 
+	if (n_in < 0 || n_out < 0 || nparam < 0)
+		return isl_printer_free(p);
+
 	p = isl_printer_start_line(p);
 	p = isl_printer_print_int(p, ineq);
 	for (i = 0; i < n_out; ++i) {
@@ -99,30 +114,38 @@
 static __isl_give isl_printer *bset_print_constraints_polylib(
 	struct isl_basic_set *bset, __isl_take isl_printer *p)
 {
-	return print_constraints_polylib((struct isl_basic_map *)bset, p);
+	return print_constraints_polylib(bset_to_bmap(bset), p);
 }
 
 static __isl_give isl_printer *isl_basic_map_print_polylib(
 	__isl_keep isl_basic_map *bmap, __isl_take isl_printer *p, int ext)
 {
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_size total;
+
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_printer_free(p);
 	p = isl_printer_start_line(p);
 	p = isl_printer_print_int(p, bmap->n_eq + bmap->n_ineq);
 	p = isl_printer_print_str(p, " ");
 	p = isl_printer_print_int(p, 1 + total + 1);
 	if (ext) {
+		isl_size n_in = isl_basic_map_dim(bmap, isl_dim_in);
+		isl_size n_out = isl_basic_map_dim(bmap, isl_dim_out);
+		isl_size n_div = isl_basic_map_dim(bmap, isl_dim_div);
+		isl_size nparam = isl_basic_map_dim(bmap, isl_dim_param);
+
+		if (n_in < 0 || n_out < 0 || n_div < 0 || nparam < 0)
+			return isl_printer_free(p);
+
 		p = isl_printer_print_str(p, " ");
-		p = isl_printer_print_int(p,
-				    isl_basic_map_dim(bmap, isl_dim_out));
+		p = isl_printer_print_int(p, n_out);
 		p = isl_printer_print_str(p, " ");
-		p = isl_printer_print_int(p,
-				    isl_basic_map_dim(bmap, isl_dim_in));
+		p = isl_printer_print_int(p, n_in);
 		p = isl_printer_print_str(p, " ");
-		p = isl_printer_print_int(p,
-				    isl_basic_map_dim(bmap, isl_dim_div));
+		p = isl_printer_print_int(p, n_div);
 		p = isl_printer_print_str(p, " ");
-		p = isl_printer_print_int(p,
-				    isl_basic_map_dim(bmap, isl_dim_param));
+		p = isl_printer_print_int(p, nparam);
 	}
 	p = isl_printer_end_line(p);
 	return print_constraints_polylib(bmap, p);
@@ -131,7 +154,7 @@
 static __isl_give isl_printer *isl_basic_set_print_polylib(
 	__isl_keep isl_basic_set *bset, __isl_take isl_printer *p, int ext)
 {
-	return isl_basic_map_print_polylib((struct isl_basic_map *)bset, p, ext);
+	return isl_basic_map_print_polylib(bset_to_bmap(bset), p, ext);
 }
 
 static __isl_give isl_printer *isl_map_print_polylib(__isl_keep isl_map *map,
@@ -153,20 +176,23 @@
 static __isl_give isl_printer *isl_set_print_polylib(__isl_keep isl_set *set,
 	__isl_take isl_printer *p, int ext)
 {
-	return isl_map_print_polylib((struct isl_map *)set, p, ext);
+	return isl_map_print_polylib(set_to_map(set), p, ext);
 }
 
-static int count_same_name(__isl_keep isl_space *dim,
+static isl_size count_same_name(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos, const char *name)
 {
 	enum isl_dim_type t;
-	unsigned p, s;
+	int p;
+	isl_size s;
 	int count = 0;
 
 	for (t = isl_dim_param; t <= type && t <= isl_dim_out; ++t) {
-		s = t == type ? pos : isl_space_dim(dim, t);
+		s = t == type ? pos : isl_space_dim(space, t);
+		if (s < 0)
+			return isl_size_error;
 		for (p = 0; p < s; ++p) {
-			const char *n = isl_space_get_dim_name(dim, t, p);
+			const char *n = isl_space_get_dim_name(space, t, p);
 			if (n && !strcmp(n, name))
 				count++;
 		}
@@ -174,15 +200,19 @@
 	return count;
 }
 
-static __isl_give isl_printer *print_name(__isl_keep isl_space *dim,
+/* Print the name of the variable of type "type" and position "pos"
+ * in "space" to "p".
+ */
+static __isl_give isl_printer *print_name(__isl_keep isl_space *space,
 	__isl_take isl_printer *p, enum isl_dim_type type, unsigned pos,
 	int latex)
 {
 	const char *name;
 	char buffer20;
-	int primes;
+	isl_size primes;
 
-	name = type == isl_dim_div ? NULL : isl_space_get_dim_name(dim, type, pos);
+	name = type == isl_dim_div ? NULL
+				   : isl_space_get_dim_name(space, type, pos);
 
 	if (!name) {
 		const char *prefix;
@@ -190,61 +220,86 @@
 			prefix = s_param_prefixlatex;
 		else if (type == isl_dim_div)
 			prefix = s_div_prefixlatex;
-		else if (isl_space_is_set(dim) || type == isl_dim_in)
+		else if (isl_space_is_set(space) || type == isl_dim_in)
 			prefix = s_input_prefixlatex;
 		else
 			prefix = s_output_prefixlatex;
 		snprintf(buffer, sizeof(buffer), "%s%d", prefix, pos);
 		name = buffer;
 	}
-	primes = count_same_name(dim, name == buffer ? isl_dim_div : type,
+	primes = count_same_name(space, name == buffer ? isl_dim_div : type,
 				 pos, name);
+	if (primes < 0)
+		return isl_printer_free(p);
 	p = isl_printer_print_str(p, name);
 	while (primes-- > 0)
 		p = isl_printer_print_str(p, "'");
 	return p;
 }
 
-static enum isl_dim_type pos2type(__isl_keep isl_space *dim, unsigned *pos)
+static isl_stat pos2type(__isl_keep isl_space *space,
+	enum isl_dim_type *type, unsigned *pos)
 {
-	enum isl_dim_type type;
-	unsigned n_in = isl_space_dim(dim, isl_dim_in);
-	unsigned n_out = isl_space_dim(dim, isl_dim_out);
-	unsigned nparam = isl_space_dim(dim, isl_dim_param);
+	isl_size n_in = isl_space_dim(space, isl_dim_in);
+	isl_size n_out = isl_space_dim(space, isl_dim_out);
+	isl_size nparam = isl_space_dim(space, isl_dim_param);
+
+	if (n_in < 0 || n_out < 0 || nparam < 0)
+		return isl_stat_error;
 
 	if (*pos < 1 + nparam) {
-		type = isl_dim_param;
+		*type = isl_dim_param;
 		*pos -= 1;
 	} else if (*pos < 1 + nparam + n_in) {
-		type = isl_dim_in;
+		*type = isl_dim_in;
 		*pos -= 1 + nparam;
 	} else if (*pos < 1 + nparam + n_in + n_out) {
-		type = isl_dim_out;
+		*type = isl_dim_out;
 		*pos -= 1 + nparam + n_in;
 	} else {
-		type = isl_dim_div;
+		*type = isl_dim_div;
 		*pos -= 1 + nparam + n_in + n_out;
 	}
 
-	return type;
+	return isl_stat_ok;
+}
+
+/* Can the div expression of the integer division at position "row" of "div"
+ * be printed?
+ * In particular, are the div expressions available and does the selected
+ * variable have a known explicit representation?
+ * Furthermore, the Omega format does not allow any div expressions
+ * to be printed.
+ */
+static isl_bool can_print_div_expr(__isl_keep isl_printer *p,
+	__isl_keep isl_mat *div, int pos)
+{
+	if (p->output_format == ISL_FORMAT_OMEGA)
+		return isl_bool_false;
+	if (!div)
+		return isl_bool_false;
+	return isl_bool_not(isl_local_div_is_marked_unknown(div, pos));
 }
 
-static __isl_give isl_printer *print_div(__isl_keep isl_space *dim,
+static __isl_give isl_printer *print_div(__isl_keep isl_space *space,
 	__isl_keep isl_mat *div, int pos, __isl_take isl_printer *p);
 
-static __isl_give isl_printer *print_term(__isl_keep isl_space *dim,
+static __isl_give isl_printer *print_term(__isl_keep isl_space *space,
 	__isl_keep isl_mat *div,
 	isl_int c, unsigned pos, __isl_take isl_printer *p, int latex)
 {
 	enum isl_dim_type type;
 	int print_div_def;
 
+	if (!p || !space)
+		return isl_printer_free(p);
+
 	if (pos == 0)
 		return isl_printer_print_isl_int(p, c);
 
-	type = pos2type(dim, &pos);
-	print_div_def = type == isl_dim_div && div &&
-			!isl_int_is_zero(div->rowpos0);
+	if (pos2type(space, &type, &pos) < 0)
+		return isl_printer_free(p);
+	print_div_def = type == isl_dim_div && can_print_div_expr(p, div, pos);
 
 	if (isl_int_is_one(c))
 		;
@@ -256,13 +311,13 @@
 			p = isl_printer_print_str(p, "*");
 	}
 	if (print_div_def)
-		p = print_div(dim, div, pos, p);
+		p = print_div(space, div, pos, p);
 	else
-		p = print_name(dim, p, type, pos, latex);
+		p = print_name(space, p, type, pos, latex);
 	return p;
 }
 
-static __isl_give isl_printer *print_affine_of_len(__isl_keep isl_space *dim,
+static __isl_give isl_printer *print_affine_of_len(__isl_keep isl_space *space,
 	__isl_keep isl_mat *div,
 	__isl_take isl_printer *p, isl_int *c, int len)
 {
@@ -282,7 +337,7 @@
 				p = isl_printer_print_str(p, " + ");
 		}
 		first = 0;
-		p = print_term(dim, div, ci, i, p, 0);
+		p = print_term(space, div, ci, i, p, 0);
 		if (flip)
 			isl_int_neg(ci, ci);
 	}
@@ -291,46 +346,40 @@
 	return p;
 }
 
-static __isl_give isl_printer *print_affine(__isl_keep isl_basic_map *bmap,
-	__isl_keep isl_space *dim, __isl_take isl_printer *p, isl_int *c)
-{
-	unsigned len = 1 + isl_basic_map_total_dim(bmap);
-	return print_affine_of_len(dim, NULL, p, c, len);
-}
-
-/* Internal data structure for print_space.
- *
- * latex is set if that is the output format.
- * print_dim (if not NULL) is called on each dimension.
- * user is set by the caller of print_space and may be used inside print_dim.
- *
- * space is the global space that is being printed.  This field is set by
- *	print_space.
- * type is the tuple of the global space that is currently being printed.
- *	This field is set by print_space.
+/* Print an affine expression "c"
+ * to "p", with the variable names taken from "space" and
+ * the integer division definitions taken from "div".
  */
-struct isl_print_space_data {
-	int latex;
-	__isl_give isl_printer *(*print_dim)(__isl_take isl_printer *p,
-		struct isl_print_space_data *data, unsigned pos);
-	void *user;
+static __isl_give isl_printer *print_affine(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, isl_int *c)
+{
+	isl_size n_div, total;
+	unsigned len;
 
-	isl_space *space;
-	enum isl_dim_type type;
-};
+	total = isl_space_dim(space, isl_dim_all);
+	n_div = isl_mat_rows(div);
+	if (total < 0 || n_div < 0)
+		return isl_printer_free(p);
+	len = 1 + total + n_div;
+	return print_affine_of_len(space, div, p, c, len);
+}
 
-/* offset is the offset of local_dim inside data->type of data->space.
+/* offset is the offset of local_space inside data->type of data->space.
  */
 static __isl_give isl_printer *print_nested_var_list(__isl_take isl_printer *p,
-	__isl_keep isl_space *local_dim, enum isl_dim_type local_type,
+	__isl_keep isl_space *local_space, enum isl_dim_type local_type,
 	struct isl_print_space_data *data, int offset)
 {
 	int i;
+	isl_size dim;
 
-	if (data->space != local_dim && local_type == isl_dim_out)
-		offset += local_dim->n_in;
+	if (data->space != local_space && local_type == isl_dim_out)
+		offset += local_space->n_in;
 
-	for (i = 0; i < isl_space_dim(local_dim, local_type); ++i) {
+	dim = isl_space_dim(local_space, local_type);
+	if (dim < 0)
+		return isl_printer_free(p);
+	for (i = 0; i < dim; ++i) {
 		if (i)
 			p = isl_printer_print_str(p, ", ");
 		if (data->print_dim)
@@ -355,13 +404,16 @@
 	struct isl_print_space_data *data, int offset);
 
 static __isl_give isl_printer *print_nested_tuple(__isl_take isl_printer *p,
-	__isl_keep isl_space *local_dim, enum isl_dim_type local_type,
+	__isl_keep isl_space *local_space, enum isl_dim_type local_type,
 	struct isl_print_space_data *data, int offset)
 {
 	const char *name = NULL;
-	unsigned n = isl_space_dim(local_dim, local_type);
+	isl_size n = isl_space_dim(local_space, local_type);
+
+	if (n < 0)
+		return isl_printer_free(p);
 	if ((local_type == isl_dim_in || local_type == isl_dim_out)) {
-		name = isl_space_get_tuple_name(local_dim, local_type);
+		name = isl_space_get_tuple_name(local_space, local_type);
 		if (name) {
 			if (data->latex)
 				p = isl_printer_print_str(p, "\\mathrm{");
@@ -373,27 +425,27 @@
 	if (!data->latex || n != 1 || name)
 		p = isl_printer_print_str(p, s_open_listdata->latex);
 	if ((local_type == isl_dim_in || local_type == isl_dim_out) &&
-	    local_dim->nestedlocal_type - isl_dim_in) {
-		if (data->space != local_dim && local_type == isl_dim_out)
-			offset += local_dim->n_in;
+	    local_space->nestedlocal_type - isl_dim_in) {
+		if (data->space != local_space && local_type == isl_dim_out)
+			offset += local_space->n_in;
 		p = print_nested_map_dim(p,
-				local_dim->nestedlocal_type - isl_dim_in,
+				local_space->nestedlocal_type - isl_dim_in,
 				data, offset);
 	} else
-		p = print_nested_var_list(p, local_dim, local_type, data,
+		p = print_nested_var_list(p, local_space, local_type, data,
 					  offset);
 	if (!data->latex || n != 1 || name)
 		p = isl_printer_print_str(p, s_close_listdata->latex);
 	return p;
 }
 
-static __isl_give isl_printer *print_tuple(__isl_keep isl_space *dim,
+static __isl_give isl_printer *print_tuple(__isl_keep isl_space *space,
 	__isl_take isl_printer *p, enum isl_dim_type type,
 	struct isl_print_space_data *data)
 {
-	data->space = dim;
+	data->space = space;
 	data->type = type;
-	return print_nested_tuple(p, dim, type, data, 0);
+	return print_nested_tuple(p, space, type, data, 0);
 }
 
 static __isl_give isl_printer *print_nested_map_dim(__isl_take isl_printer *p,
@@ -407,66 +459,341 @@
 	return p;
 }
 
-static __isl_give isl_printer *print_space(__isl_keep isl_space *dim,
+__isl_give isl_printer *isl_print_space(__isl_keep isl_space *space,
 	__isl_take isl_printer *p, int rational,
 	struct isl_print_space_data *data)
 {
 	if (rational && !data->latex)
 		p = isl_printer_print_str(p, "rat: ");
-	if (isl_space_is_params(dim))
+	if (isl_space_is_params(space))
 		;
-	else if (isl_space_is_set(dim))
-		p = print_tuple(dim, p, isl_dim_set, data);
+	else if (isl_space_is_set(space))
+		p = print_tuple(space, p, isl_dim_set, data);
 	else {
-		p = print_tuple(dim, p, isl_dim_in, data);
+		p = print_tuple(space, p, isl_dim_in, data);
 		p = isl_printer_print_str(p, s_todata->latex);
-		p = print_tuple(dim, p, isl_dim_out, data);
+		p = print_tuple(space, p, isl_dim_out, data);
 	}
 
 	return p;
 }
 
-static __isl_give isl_printer *print_omega_parameters(__isl_keep isl_space *dim,
-	__isl_take isl_printer *p)
+static __isl_give isl_printer *print_omega_parameters(
+	__isl_keep isl_space *space, __isl_take isl_printer *p)
 {
-	if (isl_space_dim(dim, isl_dim_param) == 0)
+	isl_size nparam = isl_space_dim(space, isl_dim_param);
+
+	if (nparam < 0)
+		return isl_printer_free(p);
+	if (nparam == 0)
 		return p;
 
 	p = isl_printer_start_line(p);
 	p = isl_printer_print_str(p, "symbolic ");
-	p = print_var_list(p, dim, isl_dim_param);
+	p = print_var_list(p, space, isl_dim_param);
 	p = isl_printer_print_str(p, ";");
 	p = isl_printer_end_line(p);
 	return p;
 }
 
-static __isl_give isl_printer *print_constraint(struct isl_basic_map *bmap,
-	__isl_keep isl_space *dim, __isl_take isl_printer *p,
-	isl_int *c, int last, const char *op, int first_constraint, int latex)
+/* Does the inequality constraint following "i" in "bmap"
+ * have an opposite value for the same last coefficient?
+ * "last" is the position of the last coefficient of inequality "i".
+ * If the next constraint is a div constraint, then it is ignored
+ * since div constraints are not printed.
+ */
+static isl_bool next_is_opposite(__isl_keep isl_basic_map *bmap, int i,
+	int last)
+{
+	int r;
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
+	unsigned o_div = isl_basic_map_offset(bmap, isl_dim_div);
+
+	if (total < 0)
+		return isl_bool_error;
+	if (i + 1 >= bmap->n_ineq)
+		return isl_bool_false;
+	if (isl_seq_last_non_zero(bmap->ineqi + 1, 1 + total) != last)
+		return isl_bool_false;
+	if (last >= o_div) {
+		isl_bool is_div;
+		is_div = isl_basic_map_is_div_constraint(bmap,
+					    bmap->ineqi + 1, last - o_div);
+		if (is_div < 0)
+			return isl_bool_error;
+		if (is_div)
+			return isl_bool_false;
+	}
+	r = isl_int_abs_eq(bmap->ineqilast, bmap->ineqi + 1last) &&
+	    !isl_int_eq(bmap->ineqilast, bmap->ineqi + 1last);
+	return isl_bool_ok(r);
+}
+
+/* Return a string representation of the operator used when
+ * printing a constraint where the LHS is greater than or equal to the LHS
+ * (sign > 0) or smaller than or equal to the LHS (sign < 0).
+ * If "strict" is set, then return the strict version of the comparison
+ * operator.
+ */
+static const char *constraint_op(int sign, int strict, int latex)
 {
-	if (!first_constraint)
-		p = isl_printer_print_str(p, s_andlatex);
+	if (strict)
+		return sign < 0 ? "<" : ">";
+	if (sign < 0)
+		return s_lelatex;
+	else
+		return s_gelatex;
+}
+
+/* Print one side of a constraint "c" to "p", with
+ * the variable names taken from "space" and the integer division definitions
+ * taken from "div".
+ * "last" is the position of the last non-zero coefficient.
+ * Let c' be the result of zeroing out this coefficient, then
+ * the partial constraint
+ *
+ *	c' op
+ *
+ * is printed.
+ */
+static __isl_give isl_printer *print_half_constraint(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div,
+	isl_int *c, int last, const char *op, int latex)
+{
+	isl_int_set_si(clast, 0);
+	p = print_affine(p, space, div, c);
+
+	p = isl_printer_print_str(p, " ");
+	p = isl_printer_print_str(p, op);
+	p = isl_printer_print_str(p, " ");
+
+	return p;
+}
 
+/* Print a constraint "c" to "p", with the variable names
+ * taken from "space" and the integer division definitions taken from "div".
+ * "last" is the position of the last non-zero coefficient, which is
+ * moreover assumed to be negative.
+ * Let c' be the result of zeroing out this coefficient, then
+ * the constraint is printed in the form
+ *
+ *	-clast op c'
+ */
+static __isl_give isl_printer *print_constraint(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div,
+	isl_int *c, int last, const char *op, int latex)
+{
 	isl_int_abs(clast, clast);
 
-	p = print_term(dim, NULL, clast, last, p, latex);
+	p = print_term(space, div, clast, last, p, latex);
 
 	p = isl_printer_print_str(p, " ");
 	p = isl_printer_print_str(p, op);
 	p = isl_printer_print_str(p, " ");
 
 	isl_int_set_si(clast, 0);
-	p = print_affine(bmap, dim, p, c);
+	p = print_affine(p, space, div, c);
+
+	return p;
+}
+
+/* Given an integer division
+ *
+ *	floor(f/m)
+ *
+ * at position "pos" in "div", print the corresponding modulo expression
+ *
+ *	(f) mod m
+ *
+ * to "p".  The variable names are taken from "space", while any
+ * nested integer division definitions are taken from "div".
+ */
+static __isl_give isl_printer *print_mod(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, int pos,
+	int latex)
+{
+	if (!p || !div)
+		return isl_printer_free(p);
+
+	p = isl_printer_print_str(p, "(");
+	p = print_affine_of_len(space, div, p,
+				div->rowpos + 1, div->n_col - 1);
+	p = isl_printer_print_str(p, ") ");
+	p = isl_printer_print_str(p, s_modlatex);
+	p = isl_printer_print_str(p, " ");
+	p = isl_printer_print_isl_int(p, div->rowpos0);
+	return p;
+}
+
+/* Given an equality constraint with a non-zero coefficient "c"
+ * in position "pos", is this term of the form
+ *
+ *	a m floor(g/m),
+ *
+ * with c = a m?
+ * Return the position of the corresponding integer division if so.
+ * Return the number of integer divisions if not.
+ * Return isl_size_error on error.
+ *
+ * Modulo constraints are currently not printed in C format.
+ * Other than that, "pos" needs to correspond to an integer division
+ * with explicit representation and "c" needs to be a multiple
+ * of the denominator of the integer division.
+ */
+static isl_size print_as_modulo_pos(__isl_keep isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, unsigned pos,
+	isl_int c)
+{
+	isl_bool can_print;
+	isl_size n_div;
+	enum isl_dim_type type;
+
+	n_div = isl_mat_rows(div);
+	if (!p || !space || n_div < 0)
+		return isl_size_error;
+	if (p->output_format == ISL_FORMAT_C)
+		return n_div;
+	if (pos2type(space, &type, &pos) < 0)
+		return isl_size_error;
+	if (type != isl_dim_div)
+		return n_div;
+	can_print = can_print_div_expr(p, div, pos);
+	if (can_print < 0)
+		return isl_size_error;
+	if (!can_print)
+		return n_div;
+	if (!isl_int_is_divisible_by(c, div->rowpos0))
+		return n_div;
+	return pos;
+}
+
+/* Print equality constraint "c" to "p" as a modulo constraint,
+ * with the variable names taken from "space" and
+ * the integer division definitions taken from "div".
+ * "last" is the position of the last non-zero coefficient, which is
+ * moreover assumed to be negative and a multiple of the denominator
+ * of the corresponding integer division.  "div_pos" is the corresponding
+ * position in the sequence of integer divisions.
+ *
+ * The equality is of the form
+ *
+ *	f - a m floor(g/m) = 0.
+ *
+ * Print it as
+ *
+ *	a (g mod m) = -f + a g
+ */
+static __isl_give isl_printer *print_eq_mod_constraint(
+	__isl_take isl_printer *p, __isl_keep isl_space *space,
+	__isl_keep isl_mat *div, unsigned div_pos,
+	isl_int *c, int last, int latex)
+{
+	isl_ctx *ctx;
+	int multiple;
 
+	ctx = isl_printer_get_ctx(p);
+	isl_int_divexact(clast, clast, div->rowdiv_pos0);
+	isl_int_abs(clast, clast);
+	multiple = !isl_int_is_one(clast);
+	if (multiple) {
+		p = isl_printer_print_isl_int(p, clast);
+		p = isl_printer_print_str(p, "*(");
+	}
+	p = print_mod(p, space, div, div_pos, latex);
+	if (multiple)
+		p = isl_printer_print_str(p, ")");
+	p = isl_printer_print_str(p, " = ");
+	isl_seq_combine(c, ctx->negone, c,
+			    clast, div->rowdiv_pos + 1, last);
+	isl_int_set_si(clast, 0);
+	p = print_affine(p, space, div, c);
 	return p;
 }
 
+/* Print equality constraint "c" to "p", with the variable names
+ * taken from "space" and the integer division definitions taken from "div".
+ * "last" is the position of the last non-zero coefficient, which is
+ * moreover assumed to be negative.
+ *
+ * If possible, print the equality constraint as a modulo constraint.
+ */
+static __isl_give isl_printer *print_eq_constraint(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, isl_int *c,
+	int last, int latex)
+{
+	isl_size n_div;
+	isl_size div_pos;
+
+	n_div = isl_mat_rows(div);
+	div_pos = print_as_modulo_pos(p, space, div, last, clast);
+	if (n_div < 0 || div_pos < 0)
+		return isl_printer_free(p);
+	if (div_pos < n_div)
+		return print_eq_mod_constraint(p, space, div, div_pos,
+						c, last, latex);
+	return print_constraint(p, space, div, c, last, "=", latex);
+}
+
+/* Print the constraints of "bmap" to "p".
+ * The names of the variables are taken from "space" and
+ * the integer division definitions are taken from "div".
+ * Div constraints are only printed in "dump" mode.
+ * The constraints are sorted prior to printing (except in "dump" mode).
+ *
+ * If x is the last variable with a non-zero coefficient,
+ * then a lower bound
+ *
+ *	f - a x >= 0
+ *
+ * is printed as
+ *
+ *	a x <= f
+ *
+ * while an upper bound
+ *
+ *	f + a x >= 0
+ *
+ * is printed as
+ *
+ *	a x >= -f
+ *
+ * If the next constraint has an opposite sign for the same last coefficient,
+ * then it is printed as
+ *
+ *	f >= a x
+ *
+ * or
+ *
+ *	-f <= a x
+ *
+ * instead.  In fact, the "a x" part is not printed explicitly, but
+ * reused from the next constraint, which is therefore treated as
+ * a first constraint in the conjunction.
+ *
+ * If the constant term of "f" is -1, then "f" is replaced by "f + 1" and
+ * the comparison operator is replaced by the strict variant.
+ * Essentially, ">= 1" is replaced by "> 0".
+ */
 static __isl_give isl_printer *print_constraints(__isl_keep isl_basic_map *bmap,
-	__isl_keep isl_space *dim, __isl_take isl_printer *p, int latex)
+	__isl_keep isl_space *space, __isl_keep isl_mat *div,
+	__isl_take isl_printer *p, int latex)
 {
 	int i;
-	struct isl_vec *c;
-	unsigned total = isl_basic_map_total_dim(bmap);
+	isl_vec *c = NULL;
+	int rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
+	isl_size total = isl_basic_map_dim(bmap, isl_dim_all);
+	unsigned o_div = isl_basic_map_offset(bmap, isl_dim_div);
+	int first = 1;
+	int dump;
+
+	if (total < 0 || !p)
+		return isl_printer_free(p);
+	bmap = isl_basic_map_copy(bmap);
+	dump = p->dump;
+	if (!dump)
+		bmap = isl_basic_map_sort_constraints(bmap);
+	if (!bmap)
+		goto error;
 
 	c = isl_vec_alloc(bmap->ctx, 1 + total);
 	if (!c)
@@ -480,44 +807,81 @@
 			p = isl_printer_print_str(p, "0 = 0");
 			continue;
 		}
+		if (!first)
+			p = isl_printer_print_str(p, s_andlatex);
 		if (isl_int_is_neg(bmap->eqil))
 			isl_seq_cpy(c->el, bmap->eqi, 1 + total);
 		else
 			isl_seq_neg(c->el, bmap->eqi, 1 + total);
-		p = print_constraint(bmap, dim, p, c->el, l,
-				    "=", i == bmap->n_eq - 1, latex);
+		p = print_eq_constraint(p, space, div, c->el, l, latex);
+		first = 0;
 	}
 	for (i = 0; i < bmap->n_ineq; ++i) {
+		isl_bool combine;
 		int l = isl_seq_last_non_zero(bmap->ineqi, 1 + total);
+		int strict;
 		int s;
 		const char *op;
 		if (l < 0)
 			continue;
+		if (!dump && l >= o_div &&
+		    can_print_div_expr(p, div, l - o_div)) {
+			isl_bool is_div;
+			is_div = isl_basic_map_is_div_constraint(bmap,
+						    bmap->ineqi, l - o_div);
+			if (is_div < 0)
+				goto error;
+			if (is_div)
+				continue;
+		}
+		if (!first)
+			p = isl_printer_print_str(p, s_andlatex);
 		s = isl_int_sgn(bmap->ineqil);
+		strict = !rational && isl_int_is_negone(bmap->ineqi0);
 		if (s < 0)
 			isl_seq_cpy(c->el, bmap->ineqi, 1 + total);
 		else
 			isl_seq_neg(c->el, bmap->ineqi, 1 + total);
-		op = s < 0 ? s_lelatex : s_gelatex;
-		p = print_constraint(bmap, dim, p, c->el, l,
-					op, !bmap->n_eq && !i, latex);
+		if (strict)
+			isl_int_set_si(c->el0, 0);
+		combine = dump ? isl_bool_false : next_is_opposite(bmap, i, l);
+		if (combine < 0)
+			goto error;
+		if (combine) {
+			op = constraint_op(-s, strict, latex);
+			p = print_half_constraint(p, space, div, c->el, l,
+						op, latex);
+			first = 1;
+		} else {
+			op = constraint_op(s, strict, latex);
+			p = print_constraint(p, space, div, c->el, l,
+						op, latex);
+			first = 0;
+		}
 	}
 
+	isl_basic_map_free(bmap);
 	isl_vec_free(c);
 
 	return p;
 error:
+	isl_basic_map_free(bmap);
 	isl_vec_free(c);
 	isl_printer_free(p);
 	return NULL;
 }
 
-static __isl_give isl_printer *print_div(__isl_keep isl_space *dim,
+static __isl_give isl_printer *print_div(__isl_keep isl_space *space,
 	__isl_keep isl_mat *div, int pos, __isl_take isl_printer *p)
 {
-	int c = p->output_format == ISL_FORMAT_C;
+	int c;
+
+	if (!p || !div)
+		return isl_printer_free(p);
+
+	c = p->output_format == ISL_FORMAT_C;
 	p = isl_printer_print_str(p, c ? "floord(" : "floor((");
-	p = print_affine_of_len(dim, div, p,
+	p = print_affine_of_len(space, div, p,
 				div->rowpos + 1, div->n_col - 1);
 	p = isl_printer_print_str(p, c ? ", " : ")/");
 	p = isl_printer_print_isl_int(p, div->rowpos0);
@@ -525,26 +889,31 @@
 	return p;
 }
 
-/* Print a comma separated list of div names, with their definitions
- * (provided that they have a definition and we are printing in isl format).
+/* Print a comma separated list of div names, except those that have
+ * a definition that can be printed.
+ * If "print_defined_divs" is set, then those div names are printed
+ * as well, along with their definitions.
  */
 static __isl_give isl_printer *print_div_list(__isl_take isl_printer *p,
-	__isl_keep isl_space *space, __isl_keep isl_mat *div, int latex)
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, int latex,
+	int print_defined_divs)
 {
 	int i;
-	unsigned n_div;
-
-	if (!p || !space || !div)
-		return isl_printer_free(p);
+	int first = 1;
+	isl_size n_div;
 
 	n_div = isl_mat_rows(div);
+	if (!p || !space || n_div < 0)
+		return isl_printer_free(p);
 
 	for (i = 0; i < n_div; ++i) {
-		if (i)
+		if (!print_defined_divs && can_print_div_expr(p, div, i))
+			continue;
+		if (!first)
 			p = isl_printer_print_str(p, ", ");
 		p = print_name(space, p, isl_dim_div, i, latex);
-		if (p->output_format != ISL_FORMAT_ISL ||
-		    isl_int_is_zero(div->rowi0))
+		first = 0;
+		if (!can_print_div_expr(p, div, i))
 			continue;
 		p = isl_printer_print_str(p, " = ");
 		p = print_div(space, div, i, p);
@@ -553,25 +922,95 @@
 	return p;
 }
 
-static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
-	__isl_keep isl_space *dim, __isl_take isl_printer *p, int latex)
+/* Does printing an object with local variables described by "div"
+ * require an "exists" clause?
+ * That is, are there any local variables without an explicit representation?
+ * An exists clause is also needed in "dump" mode because
+ * explicit div representations are not printed inline in that case.
+ */
+static isl_bool need_exists(__isl_keep isl_printer *p, __isl_keep isl_mat *div)
 {
-	if (bmap->n_div > 0) {
-		isl_space *space;
-		isl_mat *div;
+	int i;
+	isl_size n;
+
+	n = isl_mat_rows(div);
+	if (!p || n < 0)
+		return isl_bool_error;
+	if (n == 0)
+		return isl_bool_false;
+	if (p->dump)
+		return isl_bool_true;
+	for (i = 0; i < n; ++i)
+		if (!can_print_div_expr(p, div, i))
+			return isl_bool_true;
+	return isl_bool_false;
+}
+
+/* Print the start of an exists clause, i.e.,
+ *
+ *	(exists variables:
+ *
+ * In dump mode, local variables with an explicit definition are printed
+ * as well because they will not be printed inline.
+ */
+static __isl_give isl_printer *open_exists(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, int latex)
+{
+	int dump;
 
-		space = isl_basic_map_get_space(bmap);
-		div = isl_basic_map_get_divs(bmap);
-		p = isl_printer_print_str(p, s_open_existslatex);
-		p = print_div_list(p, space, div, latex);
-		isl_space_free(space);
-		isl_mat_free(div);
-		p = isl_printer_print_str(p, ": ");
-	}
+	if (!p)
+		return NULL;
+
+	dump = p->dump;
+	p = isl_printer_print_str(p, s_open_existslatex);
+	p = print_div_list(p, space, div, latex, dump);
+	p = isl_printer_print_str(p, ": ");
+
+	return p;
+}
+
+/* Remove the explicit representations of all local variables in "div".
+ */
+static __isl_give isl_mat *mark_all_unknown(__isl_take isl_mat *div)
+{
+	int i;
+	isl_size n_div;
+
+	n_div = isl_mat_rows(div);
+	if (n_div < 0)
+		return isl_mat_free(div);
+
+	for (i = 0; i < n_div; ++i)
+		div = isl_mat_set_element_si(div, i, 0, 0);
+	return div;
+}
 
-	p = print_constraints(bmap, dim, p, latex);
+/* Print the constraints of "bmap" to "p".
+ * The names of the variables are taken from "space".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ * Do not print inline explicit div representations in "dump" mode.
+ */
+static __isl_give isl_printer *print_disjunct(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_space *space, __isl_take isl_printer *p, int latex)
+{
+	int dump;
+	isl_mat *div;
+	isl_bool exists;
 
-	if (bmap->n_div > 0)
+	if (!p)
+		return NULL;
+	dump = p->dump;
+	div = isl_basic_map_get_divs(bmap);
+	exists = need_exists(p, div);
+	if (exists >= 0 && exists)
+		p = open_exists(p, space, div, latex);
+
+	if (dump)
+		div = mark_all_unknown(div);
+	p = print_constraints(bmap, space, div, p, latex);
+	isl_mat_free(div);
+
+	if (exists >= 0 && exists)
 		p = isl_printer_print_str(p, s_close_existslatex);
 	return p;
 }
@@ -585,7 +1024,7 @@
 	__isl_keep isl_basic_map *bmap, __isl_keep isl_space *space,
 	__isl_take isl_printer *p, int latex)
 {
-	if (isl_basic_map_is_universe(bmap))
+	if (isl_basic_map_plain_is_universe(bmap))
 		return p;
 
 	p = isl_printer_print_str(p, ": ");
@@ -644,6 +1083,26 @@
 	return p;
 }
 
+/* Print the list of parameters in "space", followed by an arrow, to "p",
+ * if there are any parameters.
+ */
+static __isl_give isl_printer *print_param_tuple(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, struct isl_print_space_data *data)
+{
+	isl_size nparam;
+
+	nparam = isl_space_dim(space, isl_dim_param);
+	if (!p || nparam < 0)
+		return isl_printer_free(p);
+	if (nparam == 0)
+		return p;
+
+	p = print_tuple(space, p, isl_dim_param, data);
+	p = isl_printer_print_str(p, s_todata->latex);
+
+	return p;
+}
+
 static __isl_give isl_printer *isl_basic_map_print_isl(
 	__isl_keep isl_basic_map *bmap, __isl_take isl_printer *p,
 	int latex)
@@ -651,53 +1110,133 @@
 	struct isl_print_space_data data = { .latex = latex };
 	int rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
 
-	if (isl_basic_map_dim(bmap, isl_dim_param) > 0) {
-		p = print_tuple(bmap->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, bmap->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
-	p = print_space(bmap->dim, p, rational, &data);
+	p = isl_print_space(bmap->dim, p, rational, &data);
 	p = isl_printer_print_str(p, " : ");
 	p = print_disjunct(bmap, bmap->dim, p, latex);
 	p = isl_printer_print_str(p, " }");
 	return p;
 }
 
-static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
-	__isl_take isl_printer *p, int latex)
+/* Print the disjuncts of a map (or set) "map" to "p".
+ * The names of the variables are taken from "space".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ */
+static __isl_give isl_printer *print_disjuncts_core(__isl_keep isl_map *map,
+	__isl_keep isl_space *space, __isl_take isl_printer *p, int latex)
 {
 	int i;
 
-	if (isl_map_plain_is_universe(map))
-		return p;
-
-	p = isl_printer_print_str(p, s_such_thatlatex);
 	if (map->n == 0)
-		p = isl_printer_print_str(p, "1 = 0");
+		p = isl_printer_print_str(p, "false");
 	for (i = 0; i < map->n; ++i) {
 		if (i)
 			p = isl_printer_print_str(p, s_orlatex);
 		if (map->n > 1 && map->pi->n_eq + map->pi->n_ineq > 1)
 			p = isl_printer_print_str(p, "(");
-		p = print_disjunct(map->pi, map->dim, p, latex);
+		p = print_disjunct(map->pi, space, p, latex);
 		if (map->n > 1 && map->pi->n_eq + map->pi->n_ineq > 1)
 			p = isl_printer_print_str(p, ")");
 	}
 	return p;
 }
 
+/* Print the disjuncts of a map (or set) "map" to "p".
+ * The names of the variables are taken from "space".
+ * "hull" describes constraints shared by all disjuncts of "map".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ *
+ * Print the disjuncts as a conjunction of "hull" and
+ * the result of removing the constraints of "hull" from "map".
+ * If this result turns out to be the universe, then simply print "hull".
+ */
+static __isl_give isl_printer *print_disjuncts_in_hull(__isl_keep isl_map *map,
+	__isl_keep isl_space *space, __isl_take isl_basic_map *hull,
+	__isl_take isl_printer *p, int latex)
+{
+	isl_bool is_universe;
+
+	p = print_disjunct(hull, space, p, latex);
+	map = isl_map_plain_gist_basic_map(isl_map_copy(map), hull);
+	is_universe = isl_map_plain_is_universe(map);
+	if (is_universe < 0)
+		goto error;
+	if (!is_universe) {
+		p = isl_printer_print_str(p, s_andlatex);
+		p = isl_printer_print_str(p, "(");
+		p = print_disjuncts_core(map, space, p, latex);
+		p = isl_printer_print_str(p, ")");
+	}
+	isl_map_free(map);
+
+	return p;
+error:
+	isl_map_free(map);
+	isl_printer_free(p);
+	return NULL;
+}
+
+/* Print the disjuncts of a map (or set) "map" to "p".
+ * The names of the variables are taken from "space".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ *
+ * If there are at least two disjuncts and "dump" mode is not turned out,
+ * check for any shared constraints among all disjuncts.
+ * If there are any, then print them separately in print_disjuncts_in_hull.
+ */
+static __isl_give isl_printer *print_disjuncts(__isl_keep isl_map *map,
+	__isl_keep isl_space *space, __isl_take isl_printer *p, int latex)
+{
+	if (isl_map_plain_is_universe(map))
+		return p;
+
+	p = isl_printer_print_str(p, s_such_thatlatex);
+	if (!p)
+		return NULL;
+
+	if (!p->dump && map->n >= 2) {
+		isl_basic_map *hull;
+		isl_bool is_universe;
+
+		hull = isl_map_plain_unshifted_simple_hull(isl_map_copy(map));
+		is_universe = isl_basic_map_plain_is_universe(hull);
+		if (is_universe < 0)
+			p = isl_printer_free(p);
+		else if (!is_universe)
+			return print_disjuncts_in_hull(map, space, hull,
+							p, latex);
+		isl_basic_map_free(hull);
+	}
+
+	return print_disjuncts_core(map, space, p, latex);
+}
+
 /* Print the disjuncts of a map (or set).
+ * The names of the variables are taken from "space".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ *
  * If the map turns out to be a universal parameter domain, then
  * we need to print the colon.  Otherwise, the output looks identical
  * to the empty set.
  */
 static __isl_give isl_printer *print_disjuncts_map(__isl_keep isl_map *map,
-	__isl_take isl_printer *p, int latex)
+	__isl_keep isl_space *space, __isl_take isl_printer *p, int latex)
 {
 	if (isl_map_plain_is_universe(map) && isl_space_is_params(map->dim))
 		return isl_printer_print_str(p, s_such_thatlatex);
 	else
-		return print_disjuncts(map, p, latex);
+		return print_disjuncts(map, space, p, latex);
+}
+
+/* Print the disjuncts of a set.
+ * The names of the variables are taken from "space".
+ * "latex" is set if the constraints should be printed in LaTeX format.
+ */
+static __isl_give isl_printer *print_disjuncts_set(__isl_keep isl_set *set,
+	__isl_keep isl_space *space, __isl_take isl_printer *p, int latex)
+{
+	return print_disjuncts_map(set_to_map(set), space, p, latex);
 }
 
 struct isl_aff_split {
@@ -723,18 +1262,20 @@
 static __isl_give isl_basic_map *get_aff(__isl_take isl_basic_map *bmap)
 {
 	int i, j;
-	unsigned nparam, n_in, n_out, total;
+	isl_size nparam, n_in, n_out, total;
 
 	bmap = isl_basic_map_cow(bmap);
 	if (!bmap)
 		return NULL;
-	if (isl_basic_map_free_inequality(bmap, bmap->n_ineq) < 0)
-		goto error;
+	bmap = isl_basic_map_free_inequality(bmap, bmap->n_ineq);
 
 	nparam = isl_basic_map_dim(bmap, isl_dim_param);
 	n_in = isl_basic_map_dim(bmap, isl_dim_in);
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
 	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (n_in < 0 || n_out < 0 || nparam < 0 || total < 0)
+		return isl_basic_map_free(bmap);
+
 	for (i = bmap->n_eq - 1; i >= 0; --i) {
 		j = isl_seq_last_non_zero(bmap->eqi + 1, total);
 		if (j >= nparam && j < nparam + n_in + n_out &&
@@ -766,20 +1307,19 @@
 	__isl_keep isl_basic_map *aff)
 {
 	int i, j;
-	unsigned total;
+	isl_size v_div;
 
-	if (!bmap || !aff)
+	v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	if (v_div < 0 || !aff)
 		goto error;
 
-	total = isl_space_dim(bmap->dim, isl_dim_all);
-
 	for (i = bmap->n_eq - 1; i >= 0; --i) {
-		if (isl_seq_first_non_zero(bmap->eqi + 1 + total,
+		if (isl_seq_first_non_zero(bmap->eqi + 1 + v_div,
 					    bmap->n_div) != -1)
 			continue;
 		for (j = 0; j < aff->n_eq; ++j) {
-			if (!isl_seq_eq(bmap->eqi, aff->eqj, 1 + total) &&
-			    !isl_seq_is_neg(bmap->eqi, aff->eqj, 1 + total))
+			if (!isl_seq_eq(bmap->eqi, aff->eqj, 1 + v_div) &&
+			    !isl_seq_is_neg(bmap->eqi, aff->eqj, 1 + v_div))
 				continue;
 			if (isl_basic_map_drop_equality(bmap, i) < 0)
 				goto error;
@@ -841,16 +1381,16 @@
 }
 
 static int defining_equality(__isl_keep isl_basic_map *eq,
-	__isl_keep isl_space *dim, enum isl_dim_type type, int pos)
+	__isl_keep isl_space *space, enum isl_dim_type type, int pos)
 {
 	int i;
-	unsigned total;
+	isl_size total;
 
-	if (!eq)
+	total = isl_basic_map_dim(eq, isl_dim_all);
+	if (total < 0)
 		return -1;
 
-	pos += isl_space_offset(dim, type);
-	total = isl_basic_map_total_dim(eq);
+	pos += isl_space_offset(space, type);
 
 	for (i = 0; i < eq->n_eq; ++i) {
 		if (isl_seq_last_non_zero(eq->eqi + 1, total) != pos)
@@ -868,7 +1408,8 @@
  * data->user is assumed to be an isl_basic_map keeping track of equalities.
  *
  * If the current dimension is defined by these equalities, then print
- * the corresponding expression.  Otherwise, print the name of the dimension.
+ * the corresponding expression, assigned to the name of the dimension
+ * if there is any.  Otherwise, print the name of the dimension.
  */
 static __isl_give isl_printer *print_dim_eq(__isl_take isl_printer *p,
 	struct isl_print_space_data *data, unsigned pos)
@@ -878,8 +1419,13 @@
 
 	j = defining_equality(eq, data->space, data->type, pos);
 	if (j >= 0) {
-		pos += 1 + isl_space_offset(data->space, data->type);
-		p = print_affine_of_len(eq->dim, NULL, p, eq->eqj, pos);
+		if (isl_space_has_dim_name(data->space, data->type, pos)) {
+			p = print_name(data->space, p, data->type, pos,
+					data->latex);
+			p = isl_printer_print_str(p, " = ");
+		}
+		pos += 1 + isl_space_offset(data->space, data->type);
+		p = print_affine_of_len(data->space, NULL, p, eq->eqj, pos);
 	} else {
 		p = print_name(data->space, p, data->type, pos, data->latex);
 	}
@@ -888,7 +1434,7 @@
 }
 
 static __isl_give isl_printer *print_split_map(__isl_take isl_printer *p,
-	struct isl_aff_split *split, int n)
+	struct isl_aff_split *split, int n, __isl_keep isl_space *space)
 {
 	struct isl_print_space_data data = { 0 };
 	int i;
@@ -896,18 +1442,15 @@
 
 	data.print_dim = &print_dim_eq;
 	for (i = 0; i < n; ++i) {
-		isl_space *dim;
-
 		if (!spliti.map)
 			break;
-		dim = spliti.map->dim;
 		rational = spliti.map->n > 0 &&
 		    ISL_F_ISSET(spliti.map->p0, ISL_BASIC_MAP_RATIONAL);
 		if (i)
 			p = isl_printer_print_str(p, "; ");
 		data.user = spliti.aff;
-		p = print_space(dim, p, rational, &data);
-		p = print_disjuncts_map(spliti.map, p, 0);
+		p = isl_print_space(space, p, rational, &data);
+		p = print_disjuncts_map(spliti.map, space, p, 0);
 	}
 
 	return p;
@@ -920,15 +1463,17 @@
 	struct isl_aff_split *split = NULL;
 	int rational;
 
-	if (map->n > 0)
+	if (!p || !map)
+		return isl_printer_free(p);
+	if (!p->dump && map->n > 0)
 		split = split_aff(map);
 	if (split) {
-		p = print_split_map(p, split, map->n);
+		p = print_split_map(p, split, map->n, map->dim);
 	} else {
 		rational = map->n > 0 &&
 		    ISL_F_ISSET(map->p0, ISL_BASIC_MAP_RATIONAL);
-		p = print_space(map->dim, p, rational, &data);
-		p = print_disjuncts_map(map, p, 0);
+		p = isl_print_space(map->dim, p, rational, &data);
+		p = print_disjuncts_map(map, map->dim, p, 0);
 	}
 	free_split(split, map->n);
 	return p;
@@ -939,10 +1484,7 @@
 {
 	struct isl_print_space_data data = { 0 };
 
-	if (isl_map_dim(map, isl_dim_param) > 0) {
-		p = print_tuple(map->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, s_to0);
-	}
+	p = print_param_tuple(p, map->dim, &data);
 	p = isl_printer_print_str(p, s_open_set0);
 	p = isl_map_print_isl_body(map, p);
 	p = isl_printer_print_str(p, s_close_set0);
@@ -955,15 +1497,12 @@
 	struct isl_print_space_data data = { 0 };
 
 	data.latex = 1;
-	if (isl_map_dim(map, isl_dim_param) > 0) {
-		p = print_tuple(map->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, s_to1);
-	}
+	p = print_param_tuple(p, map->dim, &data);
 	p = isl_printer_print_str(p, s_open_set1);
 	data.print_dim = &print_dim_eq;
 	data.user = aff;
-	p = print_space(map->dim, p, 0, &data);
-	p = print_disjuncts_map(map, p, 1);
+	p = isl_print_space(map->dim, p, 0, &data);
+	p = print_disjuncts_map(map, map->dim, p, 1);
 	p = isl_printer_print_str(p, s_close_set1);
 
 	return p;
@@ -1008,24 +1547,6 @@
 	return NULL;
 }
 
-void isl_basic_map_print(__isl_keep isl_basic_map *bmap, FILE *out, int indent,
-	const char *prefix, const char *suffix, unsigned output_format)
-{
-	isl_printer *printer;
-
-	if (!bmap)
-		return;
-
-	printer = isl_printer_to_file(bmap->ctx, out);
-	printer = isl_printer_set_indent(printer, indent);
-	printer = isl_printer_set_prefix(printer, prefix);
-	printer = isl_printer_set_suffix(printer, suffix);
-	printer = isl_printer_set_output_format(printer, output_format);
-	isl_printer_print_basic_map(printer, bmap);
-
-	isl_printer_free(printer);
-}
-
 __isl_give isl_printer *isl_printer_print_basic_set(__isl_take isl_printer *p,
 	__isl_keep isl_basic_set *bset)
 {
@@ -1048,31 +1569,13 @@
 	return NULL;
 }
 
-void isl_basic_set_print(struct isl_basic_set *bset, FILE *out, int indent,
-	const char *prefix, const char *suffix, unsigned output_format)
-{
-	isl_printer *printer;
-
-	if (!bset)
-		return;
-
-	printer = isl_printer_to_file(bset->ctx, out);
-	printer = isl_printer_set_indent(printer, indent);
-	printer = isl_printer_set_prefix(printer, prefix);
-	printer = isl_printer_set_suffix(printer, suffix);
-	printer = isl_printer_set_output_format(printer, output_format);
-	isl_printer_print_basic_set(printer, bset);
-
-	isl_printer_free(printer);
-}
-
 __isl_give isl_printer *isl_printer_print_set(__isl_take isl_printer *p,
 	__isl_keep isl_set *set)
 {
 	if (!p || !set)
 		goto error;
 	if (p->output_format == ISL_FORMAT_ISL)
-		return isl_map_print_isl((isl_map *)set, p);
+		return isl_map_print_isl(set_to_map(set), p);
 	else if (p->output_format == ISL_FORMAT_POLYLIB)
 		return isl_set_print_polylib(set, p, 0);
 	else if (p->output_format == ISL_FORMAT_EXT_POLYLIB)
@@ -1080,29 +1583,13 @@
 	else if (p->output_format == ISL_FORMAT_OMEGA)
 		return isl_set_print_omega(set, p);
 	else if (p->output_format == ISL_FORMAT_LATEX)
-		return isl_map_print_latex((isl_map *)set, p);
+		return isl_map_print_latex(set_to_map(set), p);
 	isl_assert(set->ctx, 0, goto error);
 error:
 	isl_printer_free(p);
 	return NULL;
 }
 
-void isl_set_print(struct isl_set *set, FILE *out, int indent,
-	unsigned output_format)
-{
-	isl_printer *printer;
-
-	if (!set)
-		return;
-
-	printer = isl_printer_to_file(set->ctx, out);
-	printer = isl_printer_set_indent(printer, indent);
-	printer = isl_printer_set_output_format(printer, output_format);
-	printer = isl_printer_print_set(printer, set);
-
-	isl_printer_free(printer);
-}
-
 __isl_give isl_printer *isl_printer_print_map(__isl_take isl_printer *p,
 	__isl_keep isl_map *map)
 {
@@ -1130,7 +1617,7 @@
 	int first;
 };
 
-static int print_map_body(__isl_take isl_map *map, void *user)
+static isl_stat print_map_body(__isl_take isl_map *map, void *user)
 {
 	struct isl_union_print_data *data;
 	data = (struct isl_union_print_data *)user;
@@ -1142,30 +1629,53 @@
 	data->p = isl_map_print_isl_body(map, data->p);
 	isl_map_free(map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static __isl_give isl_printer *isl_union_map_print_isl(
-	__isl_keep isl_union_map *umap, __isl_take isl_printer *p)
+/* Print the body of "umap" (everything except the parameter declarations)
+ * to "p" in isl format.
+ */
+static __isl_give isl_printer *isl_printer_print_union_map_isl_body(
+	__isl_take isl_printer *p, __isl_keep isl_union_map *umap)
 {
-	struct isl_union_print_data data = { p, 1 };
-	struct isl_print_space_data space_data = { 0 };
-	isl_space *dim;
+	struct isl_union_print_data data;
 
-	dim = isl_union_map_get_space(umap);
-	if (isl_space_dim(dim, isl_dim_param) > 0) {
-		p = print_tuple(dim, p, isl_dim_param, &space_data);
-		p = isl_printer_print_str(p, s_to0);
-	}
-	isl_space_free(dim);
 	p = isl_printer_print_str(p, s_open_set0);
+	data.p = p;
+	data.first = 1;
 	isl_union_map_foreach_map(umap, &print_map_body, &data);
 	p = data.p;
 	p = isl_printer_print_str(p, s_close_set0);
 	return p;
 }
 
-static int print_latex_map_body(__isl_take isl_map *map, void *user)
+/* Print the body of "uset" (everything except the parameter declarations)
+ * to "p" in isl format.
+ */
+static __isl_give isl_printer *isl_printer_print_union_set_isl_body(
+	__isl_take isl_printer *p, __isl_keep isl_union_set *uset)
+{
+	return isl_printer_print_union_map_isl_body(p, uset_to_umap(uset));
+}
+
+/* Print the isl_union_map "umap" to "p" in isl format.
+ */
+static __isl_give isl_printer *isl_union_map_print_isl(
+	__isl_keep isl_union_map *umap, __isl_take isl_printer *p)
+{
+	struct isl_print_space_data space_data = { 0 };
+	isl_space *space;
+
+	space = isl_union_map_get_space(umap);
+	p = print_param_tuple(p, space, &space_data);
+	isl_space_free(space);
+
+	p = isl_printer_print_union_map_isl_body(p, umap);
+
+	return p;
+}
+
+static isl_stat print_latex_map_body(__isl_take isl_map *map, void *user)
 {
 	struct isl_union_print_data *data;
 	data = (struct isl_union_print_data *)user;
@@ -1177,7 +1687,7 @@
 	data->p = isl_map_print_latex(map, data->p);
 	isl_map_free(map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_printer *isl_union_map_print_latex(
@@ -1214,9 +1724,9 @@
 		goto error;
 
 	if (p->output_format == ISL_FORMAT_ISL)
-		return isl_union_map_print_isl((isl_union_map *)uset, p);
+		return isl_union_map_print_isl(uset_to_umap(uset), p);
 	if (p->output_format == ISL_FORMAT_LATEX)
-		return isl_union_map_print_latex((isl_union_map *)uset, p);
+		return isl_union_map_print_latex(uset_to_umap(uset), p);
 
 	isl_die(p->ctx, isl_error_invalid,
 		"invalid output format for isl_union_set", goto error);
@@ -1225,41 +1735,33 @@
 	return NULL;
 }
 
-void isl_map_print(__isl_keep isl_map *map, FILE *out, int indent,
-	unsigned output_format)
-{
-	isl_printer *printer;
-
-	if (!map)
-		return;
-
-	printer = isl_printer_to_file(map->ctx, out);
-	printer = isl_printer_set_indent(printer, indent);
-	printer = isl_printer_set_output_format(printer, output_format);
-	printer = isl_printer_print_map(printer, map);
-
-	isl_printer_free(printer);
-}
-
-static int upoly_rec_n_non_zero(__isl_keep struct isl_upoly_rec *rec)
+static isl_size poly_rec_n_non_zero(__isl_keep isl_poly_rec *rec)
 {
 	int i;
 	int n;
 
-	for (i = 0, n = 0; i < rec->n; ++i)
-		if (!isl_upoly_is_zero(rec->pi))
+	if (!rec)
+		return isl_size_error;
+
+	for (i = 0, n = 0; i < rec->n; ++i) {
+		isl_bool is_zero = isl_poly_is_zero(rec->pi);
+
+		if (is_zero < 0)
+			return isl_size_error;
+		if (!is_zero)
 			++n;
+	}
 
 	return n;
 }
 
-static __isl_give isl_printer *upoly_print_cst(__isl_keep struct isl_upoly *up,
+static __isl_give isl_printer *poly_print_cst(__isl_keep isl_poly *poly,
 	__isl_take isl_printer *p, int first)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 	int neg;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
 		goto error;
 	neg = !first && isl_int_is_neg(cst->n);
@@ -1286,29 +1788,31 @@
 }
 
 static __isl_give isl_printer *print_base(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_mat *div, int var)
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, int var)
 {
-	unsigned total;
+	isl_size total;
 
-	total = isl_space_dim(dim, isl_dim_all);
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0)
+		return isl_printer_free(p);
 	if (var < total)
-		p = print_term(dim, NULL, dim->ctx->one, 1 + var, p, 0);
+		p = print_term(space, NULL, space->ctx->one, 1 + var, p, 0);
 	else
-		p = print_div(dim, div, var - total, p);
+		p = print_div(space, div, var - total, p);
 	return p;
 }
 
 static __isl_give isl_printer *print_pow(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_mat *div, int var, int exp)
+	__isl_keep isl_space *space, __isl_keep isl_mat *div, int var, int exp)
 {
-	p = print_base(p, dim, div, var);
+	p = print_base(p, space, div, var);
 	if (exp == 1)
 		return p;
 	if (p->output_format == ISL_FORMAT_C) {
 		int i;
 		for (i = 1; i < exp; ++i) {
 			p = isl_printer_print_str(p, "*");
-			p = print_base(p, dim, div, var);
+			p = print_base(p, space, div, var);
 		}
 	} else {
 		p = isl_printer_print_str(p, "^");
@@ -1317,53 +1821,63 @@
 	return p;
 }
 
-static __isl_give isl_printer *upoly_print(__isl_keep struct isl_upoly *up,
-	__isl_keep isl_space *dim, __isl_keep isl_mat *div,
-	__isl_take isl_printer *p, int outer)
+/* Print the polynomial "poly" defined over the domain space "space" and
+ * local variables defined by "div" to "p".
+ */
+static __isl_give isl_printer *poly_print(__isl_keep isl_poly *poly,
+	__isl_keep isl_space *space, __isl_keep isl_mat *div,
+	__isl_take isl_printer *p)
 {
-	int i, n, first, print_parens;
-	struct isl_upoly_rec *rec;
+	int i, first, print_parens;
+	isl_size n;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (!p || !up || !dim || !div)
+	is_cst = isl_poly_is_cst(poly);
+	if (!p || is_cst < 0 || !space || !div)
 		goto error;
 
-	if (isl_upoly_is_cst(up))
-		return upoly_print_cst(up, p, 1);
+	if (is_cst)
+		return poly_print_cst(poly, p, 1);
 
-	rec = isl_upoly_as_rec(up);
-	if (!rec)
-		goto error;
-	n = upoly_rec_n_non_zero(rec);
-	print_parens = n > 1 ||
-		    (outer && rec->up.var >= isl_space_dim(dim, isl_dim_all));
+	rec = isl_poly_as_rec(poly);
+	n = poly_rec_n_non_zero(rec);
+	if (n < 0)
+		return isl_printer_free(p);
+	print_parens = n > 1;
 	if (print_parens)
 		p = isl_printer_print_str(p, "(");
 	for (i = 0, first = 1; i < rec->n; ++i) {
-		if (isl_upoly_is_zero(rec->pi))
+		isl_bool is_zero = isl_poly_is_zero(rec->pi);
+		isl_bool is_one = isl_poly_is_one(rec->pi);
+		isl_bool is_negone = isl_poly_is_negone(rec->pi);
+		isl_bool is_cst = isl_poly_is_cst(rec->pi);
+
+		if (is_zero < 0 || is_one < 0 || is_negone < 0)
+			return isl_printer_free(p);
+		if (is_zero)
 			continue;
-		if (isl_upoly_is_negone(rec->pi)) {
+		if (is_negone) {
 			if (!i)
 				p = isl_printer_print_str(p, "-1");
 			else if (first)
 				p = isl_printer_print_str(p, "-");
 			else
 				p = isl_printer_print_str(p, " - ");
-		} else if (isl_upoly_is_cst(rec->pi) &&
-				!isl_upoly_is_one(rec->pi))
-			p = upoly_print_cst(rec->pi, p, first);
+		} else if (is_cst && !is_one)
+			p = poly_print_cst(rec->pi, p, first);
 		else {
 			if (!first)
 				p = isl_printer_print_str(p, " + ");
-			if (i == 0 || !isl_upoly_is_one(rec->pi))
-				p = upoly_print(rec->pi, dim, div, p, 0);
+			if (i == 0 || !is_one)
+				p = poly_print(rec->pi, space, div, p);
 		}
 		first = 0;
 		if (i == 0)
 			continue;
-		if (!isl_upoly_is_one(rec->pi) &&
-		    !isl_upoly_is_negone(rec->pi))
+		if (!is_one && !is_negone)
 			p = isl_printer_print_str(p, " * ");
-		p = print_pow(p, dim, div, rec->up.var, i);
+		p = print_pow(p, space, div, rec->poly.var, i);
 	}
 	if (print_parens)
 		p = isl_printer_print_str(p, ")");
@@ -1378,7 +1892,7 @@
 {
 	if (!p || !qp)
 		goto error;
-	p = upoly_print(qp->upoly, qp->dim, qp->div, p, 1);
+	p = poly_print(qp->poly, qp->dim, qp->div, p);
 	return p;
 error:
 	isl_printer_free(p);
@@ -1393,13 +1907,10 @@
 	if (!p || !qp)
 		goto error;
 
-	if (isl_space_dim(qp->dim, isl_dim_param) > 0) {
-		p = print_tuple(qp->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, qp->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
 	if (!isl_space_is_params(qp->dim)) {
-		p = print_space(qp->dim, p, 0, &data);
+		p = isl_print_space(qp->dim, p, 0, &data);
 		p = isl_printer_print_str(p, " -> ");
 	}
 	p = print_qpolynomial(p, qp);
@@ -1410,31 +1921,33 @@
 	return NULL;
 }
 
+/* Print the quasi-polynomial "qp" to "p" in C format, with the variable names
+ * taken from the domain space "space".
+ */
 static __isl_give isl_printer *print_qpolynomial_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_qpolynomial *qp)
+	__isl_keep isl_space *space, __isl_keep isl_qpolynomial *qp)
 {
-	isl_int den;
+	isl_bool is_one;
+	isl_val *den;
 
-	isl_int_init(den);
-	isl_qpolynomial_get_den(qp, &den);
-	if (!isl_int_is_one(den)) {
-		isl_qpolynomial *f;
+	den = isl_qpolynomial_get_den(qp);
+	qp = isl_qpolynomial_copy(qp);
+	qp = isl_qpolynomial_scale_val(qp, isl_val_copy(den));
+	is_one = isl_val_is_one(den);
+	if (is_one < 0)
+		p = isl_printer_free(p);
+	if (!is_one)
 		p = isl_printer_print_str(p, "(");
-		qp = isl_qpolynomial_copy(qp);
-		f = isl_qpolynomial_rat_cst_on_domain(isl_space_copy(qp->dim),
-						den, qp->dim->ctx->one);
-		qp = isl_qpolynomial_mul(qp, f);
-	}
 	if (qp)
-		p = upoly_print(qp->upoly, dim, qp->div, p, 0);
+		p = poly_print(qp->poly, space, qp->div, p);
 	else
 		p = isl_printer_free(p);
-	if (!isl_int_is_one(den)) {
+	if (!is_one) {
 		p = isl_printer_print_str(p, ")/");
-		p = isl_printer_print_isl_int(p, den);
-		isl_qpolynomial_free(qp);
+		p = isl_printer_print_val(p, den);
 	}
-	isl_int_clear(den);
+	isl_qpolynomial_free(qp);
+	isl_val_free(den);
 	return p;
 }
 
@@ -1475,16 +1988,25 @@
 	__isl_keep isl_qpolynomial_fold *fold, __isl_take isl_printer *p)
 {
 	int i;
+	isl_qpolynomial_list *list;
+	isl_size n;
 
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (n < 0)
+		return isl_printer_free(p);
 	if (fold->type == isl_fold_min)
 		p = isl_printer_print_str(p, "min");
 	else if (fold->type == isl_fold_max)
 		p = isl_printer_print_str(p, "max");
 	p = isl_printer_print_str(p, "(");
-	for (i = 0; i < fold->n; ++i) {
+	for (i = 0; i < n; ++i) {
+		isl_qpolynomial *qp;
+
 		if (i)
 			p = isl_printer_print_str(p, ", ");
-		p = print_qpolynomial(p, fold->qpi);
+		qp = isl_qpolynomial_list_peek(list, i);
+		p = print_qpolynomial(p, qp);
 	}
 	p = isl_printer_print_str(p, ")");
 	return p;
@@ -1513,14 +2035,18 @@
 	int i = 0;
 
 	for (i = 0; i < pwqp->n; ++i) {
+		isl_space *space;
+
 		if (i)
 			p = isl_printer_print_str(p, "; ");
-		if (!isl_space_is_params(pwqp->pi.set->dim)) {
-			p = print_space(pwqp->pi.set->dim, p, 0, &data);
+		space = isl_qpolynomial_get_domain_space(pwqp->pi.qp);
+		if (!isl_space_is_params(space)) {
+			p = isl_print_space(space, p, 0, &data);
 			p = isl_printer_print_str(p, " -> ");
 		}
 		p = print_qpolynomial(p, pwqp->pi.qp);
-		p = print_disjuncts((isl_map *)pwqp->pi.set, p, 0);
+		p = print_disjuncts(set_to_map(pwqp->pi.set), space, p, 0);
+		isl_space_free(space);
 	}
 
 	return p;
@@ -1534,10 +2060,7 @@
 	if (!p || !pwqp)
 		goto error;
 
-	if (isl_space_dim(pwqp->dim, isl_dim_param) > 0) {
-		p = print_tuple(pwqp->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, pwqp->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
 	if (pwqp->n == 0) {
 		if (!isl_space_is_set(pwqp->dim)) {
@@ -1576,14 +2099,18 @@
 	int i = 0;
 
 	for (i = 0; i < pwf->n; ++i) {
+		isl_space *space;
+
 		if (i)
 			p = isl_printer_print_str(p, "; ");
-		if (!isl_space_is_params(pwf->pi.set->dim)) {
-			p = print_space(pwf->pi.set->dim, p, 0, &data);
+		space = isl_qpolynomial_fold_get_domain_space(pwf->pi.fold);
+		if (!isl_space_is_params(space)) {
+			p = isl_print_space(space, p, 0, &data);
 			p = isl_printer_print_str(p, " -> ");
 		}
 		p = qpolynomial_fold_print(pwf->pi.fold, p);
-		p = print_disjuncts((isl_map *)pwf->pi.set, p, 0);
+		p = print_disjuncts(set_to_map(pwf->pi.set), space, p, 0);
+		isl_space_free(space);
 	}
 
 	return p;
@@ -1594,10 +2121,7 @@
 {
 	struct isl_print_space_data data = { 0 };
 
-	if (isl_space_dim(pwf->dim, isl_dim_param) > 0) {
-		p = print_tuple(pwf->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, pwf->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
 	if (pwf->n == 0) {
 		if (!isl_space_is_set(pwf->dim)) {
@@ -1611,87 +2135,8 @@
 	return p;
 }
 
-static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_basic_set *bset, isl_int *c);
-
-static __isl_give isl_printer *print_name_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim,
-	__isl_keep isl_basic_set *bset, enum isl_dim_type type, unsigned pos)
-{
-	if (type == isl_dim_div) {
-		p = isl_printer_print_str(p, "floord(");
-		p = print_affine_c(p, dim, bset, bset->divpos + 1);
-		p = isl_printer_print_str(p, ", ");
-		p = isl_printer_print_isl_int(p, bset->divpos0);
-		p = isl_printer_print_str(p, ")");
-	} else {
-		const char *name;
-
-		name = isl_space_get_dim_name(dim, type, pos);
-		if (!name)
-			name = "UNNAMED";
-		p = isl_printer_print_str(p, name);
-	}
-	return p;
-}
-
-static __isl_give isl_printer *print_term_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim,
-	__isl_keep isl_basic_set *bset, isl_int c, unsigned pos)
-{
-	enum isl_dim_type type;
-
-	if (pos == 0)
-		return isl_printer_print_isl_int(p, c);
-
-	if (isl_int_is_one(c))
-		;
-	else if (isl_int_is_negone(c))
-		p = isl_printer_print_str(p, "-");
-	else {
-		p = isl_printer_print_isl_int(p, c);
-		p = isl_printer_print_str(p, "*");
-	}
-	type = pos2type(dim, &pos);
-	p = print_name_c(p, dim, bset, type, pos);
-	return p;
-}
-
-static __isl_give isl_printer *print_partial_affine_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim,
-	__isl_keep isl_basic_set *bset, isl_int *c, unsigned len)
-{
-	int i;
-	int first;
-
-	for (i = 0, first = 1; i < len; ++i) {
-		int flip = 0;
-		if (isl_int_is_zero(ci))
-			continue;
-		if (!first) {
-			if (isl_int_is_neg(ci)) {
-				flip = 1;
-				isl_int_neg(ci, ci);
-				p = isl_printer_print_str(p, " - ");
-			} else 
-				p = isl_printer_print_str(p, " + ");
-		}
-		first = 0;
-		p = print_term_c(p, dim, bset, ci, i);
-		if (flip)
-			isl_int_neg(ci, ci);
-	}
-	if (first)
-		p = isl_printer_print_str(p, "0");
-	return p;
-}
-
-static __isl_give isl_printer *print_affine_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_basic_set *bset, isl_int *c)
-{
-	unsigned len = 1 + isl_basic_set_total_dim(bset);
-	return print_partial_affine_c(p, dim, bset, c, len);
-}
+static __isl_give isl_printer *print_ls_affine_c(__isl_take isl_printer *p,
+	__isl_keep isl_local_space *ls, isl_int *c);
 
 /* We skip the constraint if it is implied by the div expression.
  *
@@ -1699,23 +2144,29 @@
  * is updated if the constraint is actually printed.
  */
 static __isl_give isl_printer *print_constraint_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim,
-	__isl_keep isl_basic_set *bset, isl_int *c, const char *op, int *first)
+	__isl_keep isl_local_space *ls, isl_int *c, const char *op, int *first)
 {
 	unsigned o_div;
-	unsigned n_div;
+	isl_size n_div;
 	int div;
 
-	o_div = isl_basic_set_offset(bset, isl_dim_div);
-	n_div = isl_basic_set_dim(bset, isl_dim_div);
+	o_div = isl_local_space_offset(ls, isl_dim_div);
+	n_div = isl_local_space_dim(ls, isl_dim_div);
+	if (n_div < 0)
+		return isl_printer_free(p);
 	div = isl_seq_last_non_zero(c + o_div, n_div);
-	if (div >= 0 && isl_basic_set_is_div_constraint(bset, c, div))
-		return p;
+	if (div >= 0) {
+		isl_bool is_div = isl_local_space_is_div_constraint(ls, c, div);
+		if (is_div < 0)
+			return isl_printer_free(p);
+		if (is_div)
+			return p;
+	}
 
 	if (!*first)
 		p = isl_printer_print_str(p, " && ");
 
-	p = print_affine_c(p, dim, bset, c);
+	p = print_ls_affine_c(p, ls, c);
 	p = isl_printer_print_str(p, " ");
 	p = isl_printer_print_str(p, op);
 	p = isl_printer_print_str(p, " 0");
@@ -1725,24 +2176,36 @@
 	return p;
 }
 
+static __isl_give isl_printer *print_ls_partial_affine_c(
+	__isl_take isl_printer *p, __isl_keep isl_local_space *ls,
+	isl_int *c, unsigned len);
+
 static __isl_give isl_printer *print_basic_set_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_basic_set *bset)
+	__isl_keep isl_space *space, __isl_keep isl_basic_set *bset)
 {
 	int i, j;
 	int first = 1;
-	unsigned n_div = isl_basic_set_dim(bset, isl_dim_div);
-	unsigned total = isl_basic_set_total_dim(bset) - n_div;
+	isl_size n_div = isl_basic_set_dim(bset, isl_dim_div);
+	isl_size total = isl_basic_set_dim(bset, isl_dim_all);
+	isl_mat *div;
+	isl_local_space *ls;
 
+	if (n_div < 0 || total < 0)
+		return isl_printer_free(p);
+
+	total -= n_div;
+	div = isl_basic_set_get_divs(bset);
+	ls = isl_local_space_alloc_div(isl_space_copy(space), div);
 	for (i = 0; i < bset->n_eq; ++i) {
 		j = isl_seq_last_non_zero(bset->eqi + 1 + total, n_div);
 		if (j < 0)
-			p = print_constraint_c(p, dim, bset,
+			p = print_constraint_c(p, ls,
 						bset->eqi, "==", &first);
 		else {
 			if (i)
 				p = isl_printer_print_str(p, " && ");
 			p = isl_printer_print_str(p, "(");
-			p = print_partial_affine_c(p, dim, bset, bset->eqi,
+			p = print_ls_partial_affine_c(p, ls, bset->eqi,
 						   1 + total + j);
 			p = isl_printer_print_str(p, ") % ");
 			p = isl_printer_print_isl_int(p,
@@ -1752,13 +2215,13 @@
 		}
 	}
 	for (i = 0; i < bset->n_ineq; ++i)
-		p = print_constraint_c(p, dim, bset, bset->ineqi, ">=",
-					&first);
+		p = print_constraint_c(p, ls, bset->ineqi, ">=", &first);
+	isl_local_space_free(ls);
 	return p;
 }
 
 static __isl_give isl_printer *print_set_c(__isl_take isl_printer *p,
-	__isl_keep isl_space *dim, __isl_keep isl_set *set)
+	__isl_keep isl_space *space, __isl_keep isl_set *set)
 {
 	int i;
 
@@ -1773,29 +2236,37 @@
 			p = isl_printer_print_str(p, " || ");
 		if (set->n > 1)
 			p = isl_printer_print_str(p, "(");
-		p = print_basic_set_c(p, dim, set->pi);
+		p = print_basic_set_c(p, space, set->pi);
 		if (set->n > 1)
 			p = isl_printer_print_str(p, ")");
 	}
 	return p;
 }
 
+/* Print the piecewise quasi-polynomial "pwqp" to "p" in C format.
+ */
 static __isl_give isl_printer *print_pw_qpolynomial_c(
 	__isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial *pwqp)
 {
 	int i;
+	isl_space *space;
 
-	if (pwqp->n == 1 && isl_set_plain_is_universe(pwqp->p0.set))
-		return print_qpolynomial_c(p, pwqp->dim, pwqp->p0.qp);
+	space = isl_pw_qpolynomial_get_domain_space(pwqp);
+	if (pwqp->n == 1 && isl_set_plain_is_universe(pwqp->p0.set)) {
+		p = print_qpolynomial_c(p, space, pwqp->p0.qp);
+		isl_space_free(space);
+		return p;
+	}
 
 	for (i = 0; i < pwqp->n; ++i) {
 		p = isl_printer_print_str(p, "(");
-		p = print_set_c(p, pwqp->dim, pwqp->pi.set);
+		p = print_set_c(p, space, pwqp->pi.set);
 		p = isl_printer_print_str(p, ") ? (");
-		p = print_qpolynomial_c(p, pwqp->dim, pwqp->pi.qp);
+		p = print_qpolynomial_c(p, space, pwqp->pi.qp);
 		p = isl_printer_print_str(p, ") : ");
 	}
 
+	isl_space_free(space);
 	p = isl_printer_print_str(p, "0");
 	return p;
 }
@@ -1816,7 +2287,7 @@
 	return NULL;
 }
 
-static int print_pwqp_body(__isl_take isl_pw_qpolynomial *pwqp, void *user)
+static isl_stat print_pwqp_body(__isl_take isl_pw_qpolynomial *pwqp, void *user)
 {
 	struct isl_union_print_data *data;
 	data = (struct isl_union_print_data *)user;
@@ -1828,23 +2299,22 @@
 	data->p = isl_pwqp_print_isl_body(data->p, pwqp);
 	isl_pw_qpolynomial_free(pwqp);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_printer *print_union_pw_qpolynomial_isl(
 	__isl_take isl_printer *p, __isl_keep isl_union_pw_qpolynomial *upwqp)
 {
-	struct isl_union_print_data data = { p, 1 };
+	struct isl_union_print_data data;
 	struct isl_print_space_data space_data = { 0 };
-	isl_space *dim;
+	isl_space *space;
 
-	dim = isl_union_pw_qpolynomial_get_space(upwqp);
-	if (isl_space_dim(dim, isl_dim_param) > 0) {
-		p = print_tuple(dim, p, isl_dim_param, &space_data);
-		p = isl_printer_print_str(p, " -> ");
-	}
-	isl_space_free(dim);
+	space = isl_union_pw_qpolynomial_get_space(upwqp);
+	p = print_param_tuple(p, space, &space_data);
+	isl_space_free(space);
 	p = isl_printer_print_str(p, "{ ");
+	data.p = p;
+	data.first = 1;
 	isl_union_pw_qpolynomial_foreach_pw_qpolynomial(upwqp, &print_pwqp_body,
 							&data);
 	p = data.p;
@@ -1868,22 +2338,34 @@
 	return NULL;
 }
 
+/* Print the quasi-polynomial reduction "fold" to "p" in C format,
+ * with the variable names taken from the domain space "space".
+ */
 static __isl_give isl_printer *print_qpolynomial_fold_c(
-	__isl_take isl_printer *p, __isl_keep isl_space *dim,
+	__isl_take isl_printer *p, __isl_keep isl_space *space,
 	__isl_keep isl_qpolynomial_fold *fold)
 {
 	int i;
+	isl_qpolynomial_list *list;
+	isl_size n;
 
-	for (i = 0; i < fold->n - 1; ++i)
+	list = isl_qpolynomial_fold_peek_list(fold);
+	n = isl_qpolynomial_list_size(list);
+	if (n < 0)
+		return isl_printer_free(p);
+	for (i = 0; i < n - 1; ++i)
 		if (fold->type == isl_fold_min)
 			p = isl_printer_print_str(p, "min(");
 		else if (fold->type == isl_fold_max)
 			p = isl_printer_print_str(p, "max(");
 
-	for (i = 0; i < fold->n; ++i) {
+	for (i = 0; i < n; ++i) {
+		isl_qpolynomial *qp;
+
 		if (i)
 			p = isl_printer_print_str(p, ", ");
-		p = print_qpolynomial_c(p, dim, fold->qpi);
+		qp = isl_qpolynomial_list_peek(list, i);
+		p = print_qpolynomial_c(p, space, qp);
 		if (i)
 			p = isl_printer_print_str(p, ")");
 	}
@@ -1906,22 +2388,30 @@
 	return NULL;
 }
 
+/* Print the piecewise quasi-polynomial reduction "pwf" to "p" in C format.
+ */
 static __isl_give isl_printer *print_pw_qpolynomial_fold_c(
 	__isl_take isl_printer *p, __isl_keep isl_pw_qpolynomial_fold *pwf)
 {
 	int i;
+	isl_space *space;
 
-	if (pwf->n == 1 && isl_set_plain_is_universe(pwf->p0.set))
-		return print_qpolynomial_fold_c(p, pwf->dim, pwf->p0.fold);
+	space = isl_pw_qpolynomial_fold_get_domain_space(pwf);
+	if (pwf->n == 1 && isl_set_plain_is_universe(pwf->p0.set)) {
+		p = print_qpolynomial_fold_c(p, space, pwf->p0.fold);
+		isl_space_free(space);
+		return p;
+	}
 
 	for (i = 0; i < pwf->n; ++i) {
 		p = isl_printer_print_str(p, "(");
-		p = print_set_c(p, pwf->dim, pwf->pi.set);
+		p = print_set_c(p, space, pwf->pi.set);
 		p = isl_printer_print_str(p, ") ? (");
-		p = print_qpolynomial_fold_c(p, pwf->dim, pwf->pi.fold);
+		p = print_qpolynomial_fold_c(p, space, pwf->pi.fold);
 		p = isl_printer_print_str(p, ") : ");
 	}
 
+	isl_space_free(space);
 	p = isl_printer_print_str(p, "0");
 	return p;
 }
@@ -1957,7 +2447,8 @@
 	isl_printer_free(p);
 }
 
-static int print_pwf_body(__isl_take isl_pw_qpolynomial_fold *pwf, void *user)
+static isl_stat print_pwf_body(__isl_take isl_pw_qpolynomial_fold *pwf,
+	void *user)
 {
 	struct isl_union_print_data *data;
 	data = (struct isl_union_print_data *)user;
@@ -1969,24 +2460,23 @@
 	data->p = isl_pwf_print_isl_body(data->p, pwf);
 	isl_pw_qpolynomial_fold_free(pwf);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_printer *print_union_pw_qpolynomial_fold_isl(
 	__isl_take isl_printer *p,
 	__isl_keep isl_union_pw_qpolynomial_fold *upwf)
 {
-	struct isl_union_print_data data = { p, 1 };
+	struct isl_union_print_data data;
 	struct isl_print_space_data space_data = { 0 };
-	isl_space *dim;
+	isl_space *space;
 
-	dim = isl_union_pw_qpolynomial_fold_get_space(upwf);
-	if (isl_space_dim(dim, isl_dim_param) > 0) {
-		p = print_tuple(dim, p, isl_dim_param, &space_data);
-		p = isl_printer_print_str(p, " -> ");
-	}
-	isl_space_free(dim);
+	space = isl_union_pw_qpolynomial_fold_get_space(upwf);
+	p = print_param_tuple(p, space, &space_data);
+	isl_space_free(space);
 	p = isl_printer_print_str(p, "{ ");
+	data.p = p;
+	data.first = 1;
 	isl_union_pw_qpolynomial_fold_foreach_pw_qpolynomial_fold(upwf,
 							&print_pwf_body, &data);
 	p = data.p;
@@ -2011,17 +2501,43 @@
 	return NULL;
 }
 
+/* Print the isl_constraint "c" to "p".
+ */
 __isl_give isl_printer *isl_printer_print_constraint(__isl_take isl_printer *p,
 	__isl_keep isl_constraint *c)
 {
-	isl_basic_map *bmap;
+	struct isl_print_space_data data = { 0 };
+	isl_local_space *ls;
+	isl_space *space;
+	isl_bool exists;
 
 	if (!p || !c)
 		goto error;
 
-	bmap = isl_basic_map_from_constraint(isl_constraint_copy(c));
-	p = isl_printer_print_basic_map(p, bmap);
-	isl_basic_map_free(bmap);
+	ls = isl_constraint_get_local_space(c);
+	if (!ls)
+		return isl_printer_free(p);
+	space = isl_local_space_get_space(ls);
+	p = print_param_tuple(p, space, &data);
+	p = isl_printer_print_str(p, "{ ");
+	p = isl_print_space(space, p, 0, &data);
+	p = isl_printer_print_str(p, " : ");
+	exists = need_exists(p, ls->div);
+	if (exists < 0)
+		p = isl_printer_free(p);
+	if (exists >= 0 && exists)
+		p = open_exists(p, space, ls->div, 0);
+	p = print_affine_of_len(space, ls->div, p, c->v->el, c->v->size);
+	if (isl_constraint_is_equality(c))
+		p = isl_printer_print_str(p, " = 0");
+	else
+		p = isl_printer_print_str(p, " >= 0");
+	if (exists >= 0 && exists)
+		p = isl_printer_print_str(p, s_close_exists0);
+	p = isl_printer_print_str(p, " }");
+	isl_space_free(space);
+	isl_local_space_free(ls);
+
 	return p;
 error:
 	isl_printer_free(p);
@@ -2029,23 +2545,20 @@
 }
 
 static __isl_give isl_printer *isl_printer_print_space_isl(
-	__isl_take isl_printer *p, __isl_keep isl_space *dim)
+	__isl_take isl_printer *p, __isl_keep isl_space *space)
 {
 	struct isl_print_space_data data = { 0 };
 
-	if (!dim)
+	if (!space)
 		goto error;
 
-	if (isl_space_dim(dim, isl_dim_param) > 0) {
-		p = print_tuple(dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, space, &data);
 
 	p = isl_printer_print_str(p, "{ ");
-	if (isl_space_is_params(dim))
+	if (isl_space_is_params(space))
 		p = isl_printer_print_str(p, s_such_that0);
 	else
-		p = print_space(dim, p, 0, &data);
+		p = isl_print_space(space, p, 0, &data);
 	p = isl_printer_print_str(p, " }");
 
 	return p;
@@ -2073,24 +2586,20 @@
 	__isl_keep isl_local_space *ls)
 {
 	struct isl_print_space_data data = { 0 };
-	unsigned total;
-	unsigned n_div;
+	isl_size n_div;
 
-	if (!ls)
+	n_div = isl_local_space_dim(ls, isl_dim_div);
+	if (n_div < 0)
 		goto error;
 
-	total = isl_local_space_dim(ls, isl_dim_all);
-	if (isl_local_space_dim(ls, isl_dim_param) > 0) {
-		p = print_tuple(ls->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, ls->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
-	p = print_space(ls->dim, p, 0, &data);
-	n_div = isl_local_space_dim(ls, isl_dim_div);
+	p = isl_print_space(ls->dim, p, 0, &data);
 	if (n_div > 0) {
 		p = isl_printer_print_str(p, " : ");
 		p = isl_printer_print_str(p, s_open_exists0);
-		p = print_div_list(p, ls->dim, ls->div, 0);
+		p = print_div_list(p, ls->dim, ls->div, 0, 1);
+		p = isl_printer_print_str(p, s_close_exists0);
 	} else if (isl_space_is_params(ls->dim))
 		p = isl_printer_print_str(p, s_such_that0);
 	p = isl_printer_print_str(p, " }");
@@ -2100,18 +2609,193 @@
 	return NULL;
 }
 
-static __isl_give isl_printer *print_aff_body(__isl_take isl_printer *p,
-	__isl_keep isl_aff *aff)
+/* Look for the last of the "n" integer divisions that is used in "aff" and
+ * that can be printed as a modulo and
+ * return the position of this integer division.
+ * Return "n" if no such integer division can be found.
+ * Return isl_size_error on error.
+ *
+ * In particular, look for an integer division that appears in "aff"
+ * with a coefficient that is a multiple of the denominator
+ * of the integer division.
+ * That is, check if the numerator of "aff" is of the form
+ *
+ *	f(...) + a m floor(g/m)
+ *
+ * and return the position of "floor(g/m)".
+ *
+ * Note that, unlike print_as_modulo_pos, no check needs to be made
+ * for whether the integer division can be printed, since it will
+ * need to be printed as an integer division anyway if it is not printed
+ * as a modulo.
+ */
+static isl_size last_modulo(__isl_keep isl_printer *p, __isl_keep isl_aff *aff,
+	unsigned n)
 {
-	unsigned total;
+	isl_size o_div;
+	int i;
+
+	if (n == 0)
+		return n;
+	o_div = isl_aff_domain_offset(aff, isl_dim_div);
+	if (o_div < 0)
+		return isl_size_error;
+	for (i = n - 1; i >= 0; --i) {
+		if (isl_int_is_zero(aff->v->el1 + o_div + i))
+			continue;
+		if (isl_int_is_divisible_by(aff->v->el1 + o_div + i,
+					    aff->ls->div->rowi0))
+			return i;
+	}
+
+	return n;
+}
+
+/* Print the numerator of the affine expression "aff" to "p",
+ * with the variable names taken from "space".
+ */
+static __isl_give isl_printer *print_aff_num_base(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff)
+{
+	isl_size total;
+
+	total = isl_aff_domain_dim(aff, isl_dim_all);
+	if (total < 0)
+		return isl_printer_free(p);
+	p = print_affine_of_len(space, aff->ls->div, p,
+				aff->v->el + 1, 1 + total);
+
+	return p;
+}
+
+static __isl_give isl_printer *print_aff_num(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff);
 
+/* Print the modulo term "c" * ("aff" mod "mod") to "p",
+ * with the variable names taken from "space".
+ * If "first" is set, then this is the first term of an expression.
+ */
+static __isl_give isl_printer *print_mod_term(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff, int first,
+	__isl_take isl_val *c, __isl_keep isl_val *mod)
+{
+	isl_bool is_one, is_neg;
+
+	is_neg = isl_val_is_neg(c);
+	if (is_neg < 0)
+		p = isl_printer_free(p);
+	if (!first) {
+		if (is_neg)
+			c = isl_val_neg(c);
+		p = isl_printer_print_str(p, is_neg ? " - " : " + ");
+	}
+	is_one = isl_val_is_one(c);
+	if (is_one < 0)
+		p = isl_printer_free(p);
+	if (!is_one) {
+		p = isl_printer_print_val(p, c);
+		p = isl_printer_print_str(p, "*(");
+	}
+	p = isl_printer_print_str(p, "(");
+	p = print_aff_num(p, space, aff);
+	p = isl_printer_print_str(p, ")");
+	p = isl_printer_print_str(p, " mod ");
+	p = isl_printer_print_val(p, mod);
+	if (!is_one)
+		p = isl_printer_print_str(p, ")");
+
+	isl_val_free(c);
+
+	return p;
+}
+
+/* Print the numerator of the affine expression "aff" to "p",
+ * with the variable names taken from "space",
+ * given that the numerator of "aff" is of the form
+ *
+ *	f(...) + a m floor(g/m)
+ *
+ * with "floor(g/m)" the integer division at position "last".
+ *
+ * First replace "aff" by its numerator and rewrite it as
+ *
+ *	f(...) + a g - a (g mod m)
+ *
+ * Recursively write out (the numerator of) "f(...) + a g"
+ * (which may involve other modulo expressions) and
+ * then write out "- a (g mod m)".
+ */
+static __isl_give isl_printer *print_aff_num_mod(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff, unsigned last)
+{
+	isl_bool is_zero;
+	isl_val *a, *m;
+	isl_aff *div, *term;
+
+	aff = isl_aff_copy(aff);
+	aff = isl_aff_scale_val(aff, isl_aff_get_denominator_val(aff));
+	a = isl_aff_get_coefficient_val(aff, isl_dim_div, last);
+	aff = isl_aff_set_coefficient_si(aff, isl_dim_div, last, 0);
+	div = isl_aff_get_div(aff, last);
+	m = isl_aff_get_denominator_val(div);
+	a = isl_val_div(a, isl_val_copy(m));
+	div = isl_aff_scale_val(div, isl_val_copy(m));
+	term = isl_aff_scale_val(isl_aff_copy(div), isl_val_copy(a));
+	aff = isl_aff_add(aff, term);
+
+	is_zero = isl_aff_plain_is_zero(aff);
+	if (is_zero < 0) {
+		p = isl_printer_free(p);
+	} else {
+		if (!is_zero)
+			p = print_aff_num(p, space, aff);
+		a = isl_val_neg(a);
+		p = print_mod_term(p, space, div, is_zero, isl_val_copy(a), m);
+	}
+
+	isl_val_free(a);
+	isl_val_free(m);
+	isl_aff_free(aff);
+	isl_aff_free(div);
+
+	return p;
+}
+
+/* Print the numerator of the affine expression "aff" to "p",
+ * with the variable names taken from "space",
+ * separating out any (obvious) modulo expressions.
+ *
+ * In particular, look for modulo expressions in "aff",
+ * separating them out if found and simply printing out "aff" otherwise.
+ */
+static __isl_give isl_printer *print_aff_num(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff)
+{
+	isl_size n_div, mod;
+
+	n_div = isl_aff_dim(aff, isl_dim_div);
+	if (n_div < 0)
+		return isl_printer_free(p);
+	mod = last_modulo(p, aff, n_div);
+	if (mod < 0)
+		return isl_printer_free(p);
+	if (mod < n_div)
+		return print_aff_num_mod(p, space, aff, mod);
+	else
+		return print_aff_num_base(p, space, aff);
+}
+
+/* Print the (potentially rational) affine expression "aff" to "p",
+ * with the variable names taken from "space".
+ */
+static __isl_give isl_printer *print_aff_body(__isl_take isl_printer *p,
+	__isl_keep isl_space *space, __isl_keep isl_aff *aff)
+{
 	if (isl_aff_is_nan(aff))
 		return isl_printer_print_str(p, "NaN");
 
-	total = isl_local_space_dim(aff->ls, isl_dim_all);
 	p = isl_printer_print_str(p, "(");
-	p = print_affine_of_len(aff->ls->dim, aff->ls->div, p,
-				aff->v->el + 1, 1 + total);
+	p = print_aff_num(p, space, aff);
 	if (isl_int_is_one(aff->v->el0))
 		p = isl_printer_print_str(p, ")");
 	else {
@@ -2134,7 +2818,7 @@
 		p = isl_printer_print_str(p, " -> ");
 	}
 	p = isl_printer_print_str(p, "");
-	p = print_aff_body(p, aff);
+	p = print_aff_body(p, aff->ls->dim, aff);
 	p = isl_printer_print_str(p, "");
 
 	return p;
@@ -2148,10 +2832,7 @@
 	if (!aff)
 		goto error;
 
-	if (isl_local_space_dim(aff->ls, isl_dim_param) > 0) {
-		p = print_tuple(aff->ls->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, aff->ls->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
 	p = print_aff(p, aff);
 	p = isl_printer_print_str(p, " }");
@@ -2161,26 +2842,42 @@
 	return NULL;
 }
 
+/* Print the body of an isl_pw_aff, i.e., a semicolon delimited
+ * sequence of affine expressions, each followed by constraints.
+ */
+static __isl_give isl_printer *print_pw_aff_body(
+	__isl_take isl_printer *p, __isl_keep isl_pw_aff *pa)
+{
+	int i;
+
+	if (!pa)
+		return isl_printer_free(p);
+
+	for (i = 0; i < pa->n; ++i) {
+		isl_space *space;
+
+		if (i)
+			p = isl_printer_print_str(p, "; ");
+		p = print_aff(p, pa->pi.aff);
+		space = isl_aff_get_domain_space(pa->pi.aff);
+		p = print_disjuncts(set_to_map(pa->pi.set), space, p, 0);
+		isl_space_free(space);
+	}
+
+	return p;
+}
+
 static __isl_give isl_printer *print_pw_aff_isl(__isl_take isl_printer *p,
 	__isl_keep isl_pw_aff *pwaff)
 {
 	struct isl_print_space_data data = { 0 };
-	int i;
 
 	if (!pwaff)
 		goto error;
 
-	if (isl_space_dim(pwaff->dim, isl_dim_param) > 0) {
-		p = print_tuple(pwaff->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, pwaff->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
-	for (i = 0; i < pwaff->n; ++i) {
-		if (i)
-			p = isl_printer_print_str(p, "; ");
-		p = print_aff(p, pwaff->pi.aff);
-		p = print_disjuncts((isl_map *)pwaff->pi.set, p, 0);
-	}
+	p = print_pw_aff_body(p, pwaff);
 	p = isl_printer_print_str(p, " }");
 	return p;
 error:
@@ -2188,9 +2885,6 @@
 	return NULL;
 }
 
-static __isl_give isl_printer *print_ls_affine_c(__isl_take isl_printer *p,
-	__isl_keep isl_local_space *ls, isl_int *c);
-
 static __isl_give isl_printer *print_ls_name_c(__isl_take isl_printer *p,
 	__isl_keep isl_local_space *ls, enum isl_dim_type type, unsigned pos)
 {
@@ -2216,6 +2910,9 @@
 {
 	enum isl_dim_type type;
 
+	if (!p || !ls)
+		return isl_printer_free(p);
+
 	if (pos == 0)
 		return isl_printer_print_isl_int(p, c);
 
@@ -2227,7 +2924,8 @@
 		p = isl_printer_print_isl_int(p, c);
 		p = isl_printer_print_str(p, "*");
 	}
-	type = pos2type(ls->dim, &pos);
+	if (pos2type(ls->dim, &type, &pos) < 0)
+		return isl_printer_free(p);
 	p = print_ls_name_c(p, ls, type, pos);
 	return p;
 }
@@ -2264,16 +2962,21 @@
 static __isl_give isl_printer *print_ls_affine_c(__isl_take isl_printer *p,
 	__isl_keep isl_local_space *ls, isl_int *c)
 {
-	unsigned len = 1 + isl_local_space_dim(ls, isl_dim_all);
-	return print_ls_partial_affine_c(p, ls, c, len);
+	isl_size total = isl_local_space_dim(ls, isl_dim_all);
+
+	if (total < 0)
+		return isl_printer_free(p);
+	return print_ls_partial_affine_c(p, ls, c, 1 + total);
 }
 
 static __isl_give isl_printer *print_aff_c(__isl_take isl_printer *p,
 	__isl_keep isl_aff *aff)
 {
-	unsigned total;
+	isl_size total;
 
-	total = isl_local_space_dim(aff->ls, isl_dim_all);
+	total = isl_aff_domain_dim(aff, isl_dim_all);
+	if (total < 0)
+		return isl_printer_free(p);
 	if (!isl_int_is_one(aff->v->el0))
 		p = isl_printer_print_str(p, "(");
 	p = print_ls_partial_affine_c(p, aff->ls, aff->v->el + 1, 1 + total);
@@ -2345,22 +3048,107 @@
 	return NULL;
 }
 
+/* Print "pa" in a sequence of isl_pw_affs delimited by semicolons.
+ * Each isl_pw_aff itself is also printed as semicolon delimited
+ * sequence of pieces.
+ * If data->first = 1, then this is the first in the sequence.
+ * Update data->first to tell the next element that it is not the first.
+ */
+static isl_stat print_pw_aff_body_wrap(__isl_take isl_pw_aff *pa,
+	void *user)
+{
+	struct isl_union_print_data *data;
+	data = (struct isl_union_print_data *) user;
+
+	if (!data->first)
+		data->p = isl_printer_print_str(data->p, "; ");
+	data->first = 0;
+
+	data->p = print_pw_aff_body(data->p, pa);
+	isl_pw_aff_free(pa);
+
+	return data->p ? isl_stat_ok : isl_stat_error;
+}
+
+/* Print the body of an isl_union_pw_aff, i.e., a semicolon delimited
+ * sequence of affine expressions, each followed by constraints,
+ * with the sequence enclosed in braces.
+ */
+static __isl_give isl_printer *print_union_pw_aff_body(
+	__isl_take isl_printer *p, __isl_keep isl_union_pw_aff *upa)
+{
+	struct isl_union_print_data data = { p, 1 };
+
+	p = isl_printer_print_str(p, s_open_set0);
+	data.p = p;
+	if (isl_union_pw_aff_foreach_pw_aff(upa,
+					    &print_pw_aff_body_wrap, &data) < 0)
+		data.p = isl_printer_free(data.p);
+	p = data.p;
+	p = isl_printer_print_str(p, s_close_set0);
+
+	return p;
+}
+
+/* Print the isl_union_pw_aff "upa" to "p" in isl format.
+ *
+ * The individual isl_pw_affs are delimited by a semicolon.
+ */
+static __isl_give isl_printer *print_union_pw_aff_isl(
+	__isl_take isl_printer *p, __isl_keep isl_union_pw_aff *upa)
+{
+	struct isl_print_space_data data = { 0 };
+	isl_space *space;
+
+	space = isl_union_pw_aff_get_space(upa);
+	p = print_param_tuple(p, space, &data);
+	isl_space_free(space);
+	p = print_union_pw_aff_body(p, upa);
+	return p;
+}
+
+/* Print the isl_union_pw_aff "upa" to "p".
+ *
+ * We currently only support an isl format.
+ */
+__isl_give isl_printer *isl_printer_print_union_pw_aff(
+	__isl_take isl_printer *p, __isl_keep isl_union_pw_aff *upa)
+{
+	if (!p || !upa)
+		return isl_printer_free(p);
+
+	if (p->output_format == ISL_FORMAT_ISL)
+		return print_union_pw_aff_isl(p, upa);
+	isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
+		"unsupported output format", return isl_printer_free(p));
+}
+
 /* Print dimension "pos" of data->space to "p".
  *
  * data->user is assumed to be an isl_multi_aff.
  *
  * If the current dimension is an output dimension, then print
  * the corresponding expression.  Otherwise, print the name of the dimension.
+ * Make sure to use the domain space for printing names as
+ * that is the space that will be used for printing constraints (if any).
  */
 static __isl_give isl_printer *print_dim_ma(__isl_take isl_printer *p,
 	struct isl_print_space_data *data, unsigned pos)
 {
 	isl_multi_aff *ma = data->user;
+	isl_space *space;
 
-	if (data->type == isl_dim_out)
-		p = print_aff_body(p, ma->ppos);
-	else
-		p = print_name(data->space, p, data->type, pos, data->latex);
+	space = isl_multi_aff_get_domain_space(ma);
+	if (data->type == isl_dim_out) {
+		p = print_aff_body(p, space, ma->u.ppos);
+	} else {
+		enum isl_dim_type type = data->type;
+
+		if (type == isl_dim_in)
+			type = isl_dim_set;
+		p = print_name(space, p, type, pos, data->latex);
+	}
+	isl_space_free(space);
 
 	return p;
 }
@@ -2372,7 +3160,7 @@
 
 	data.print_dim = &print_dim_ma;
 	data.user = maff;
-	return print_space(maff->space, p, 0, &data);
+	return isl_print_space(maff->space, p, 0, &data);
 }
 
 static __isl_give isl_printer *print_multi_aff_isl(__isl_take isl_printer *p,
@@ -2383,10 +3171,7 @@
 	if (!maff)
 		goto error;
 
-	if (isl_space_dim(maff->space, isl_dim_param) > 0) {
-		p = print_tuple(maff->space, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, maff->space, &data);
 	p = isl_printer_print_str(p, "{ ");
 	p = print_multi_aff(p, maff);
 	p = isl_printer_print_str(p, " }");
@@ -2420,10 +3205,14 @@
 		goto error;
 
 	for (i = 0; i < pma->n; ++i) {
+		isl_space *space;
+
 		if (i)
 			p = isl_printer_print_str(p, "; ");
 		p = print_multi_aff(p, pma->pi.maff);
-		p = print_disjuncts((isl_map *)pma->pi.set, p, 0);
+		space = isl_multi_aff_get_domain_space(pma->pi.maff);
+		p = print_disjuncts(set_to_map(pma->pi.set), space, p, 0);
+		isl_space_free(space);
 	}
 	return p;
 error:
@@ -2439,10 +3228,7 @@
 	if (!pma)
 		goto error;
 
-	if (isl_space_dim(pma->dim, isl_dim_param) > 0) {
-		p = print_tuple(pma->dim, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, pma->dim, &data);
 	p = isl_printer_print_str(p, "{ ");
 	p = print_pw_multi_aff_body(p, pma);
 	p = isl_printer_print_str(p, " }");
@@ -2452,26 +3238,32 @@
 	return NULL;
 }
 
+/* Print the unnamed, single-dimensional piecewise multi affine expression "pma"
+ * to "p".
+ */
 static __isl_give isl_printer *print_unnamed_pw_multi_aff_c(
 	__isl_take isl_printer *p, __isl_keep isl_pw_multi_aff *pma)
 {
 	int i;
+	isl_space *space;
 
+	space = isl_pw_multi_aff_get_domain_space(pma);
 	for (i = 0; i < pma->n - 1; ++i) {
 		p = isl_printer_print_str(p, "(");
-		p = print_set_c(p, pma->dim, pma->pi.set);
+		p = print_set_c(p, space, pma->pi.set);
 		p = isl_printer_print_str(p, ") ? (");
-		p = print_aff_c(p, pma->pi.maff->p0);
+		p = print_aff_c(p, pma->pi.maff->u.p0);
 		p = isl_printer_print_str(p, ") : ");
 	}
+	isl_space_free(space);
 
-	return print_aff_c(p, pma->ppma->n - 1.maff->p0);
+	return print_aff_c(p, pma->ppma->n - 1.maff->u.p0);
 }
 
 static __isl_give isl_printer *print_pw_multi_aff_c(__isl_take isl_printer *p,
 	__isl_keep isl_pw_multi_aff *pma)
 {
-	int n;
+	isl_size n;
 	const char *name;
 
 	if (!pma)
@@ -2480,8 +3272,11 @@
 		isl_die(p->ctx, isl_error_unsupported,
 			"cannot print empty isl_pw_multi_aff in C format",
 			goto error);
+	n = isl_pw_multi_aff_dim(pma, isl_dim_out);
+	if (n < 0)
+		return isl_printer_free(p);
 	name = isl_pw_multi_aff_get_tuple_name(pma, isl_dim_out);
-	if (!name && isl_pw_multi_aff_dim(pma, isl_dim_out) == 1)
+	if (!name && n == 1)
 		return print_unnamed_pw_multi_aff_c(p, pma);
 	if (!name)
 		isl_die(p->ctx, isl_error_unsupported,
@@ -2489,7 +3284,6 @@
 			goto error);
 
 	p = isl_printer_print_str(p, name);
-	n = isl_pw_multi_aff_dim(pma, isl_dim_out);
 	if (n != 0)
 		isl_die(p->ctx, isl_error_unsupported,
 			"not supported yet", goto error);
@@ -2517,7 +3311,7 @@
 	return NULL;
 }
 
-static int print_pw_multi_aff_body_wrap(__isl_take isl_pw_multi_aff *pma,
+static isl_stat print_pw_multi_aff_body_wrap(__isl_take isl_pw_multi_aff *pma,
 	void *user)
 {
 	struct isl_union_print_data *data;
@@ -2530,23 +3324,22 @@
 	data->p = print_pw_multi_aff_body(data->p, pma);
 	isl_pw_multi_aff_free(pma);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_printer *print_union_pw_multi_aff_isl(
 	__isl_take isl_printer *p, __isl_keep isl_union_pw_multi_aff *upma)
 {
-	struct isl_union_print_data data = { p, 1 };
+	struct isl_union_print_data data;
 	struct isl_print_space_data space_data = { 0 };
 	isl_space *space;
 
 	space = isl_union_pw_multi_aff_get_space(upma);
-	if (isl_space_dim(space, isl_dim_param) > 0) {
-		p = print_tuple(space, p, isl_dim_param, &space_data);
-		p = isl_printer_print_str(p, s_to0);
-	}
+	p = print_param_tuple(p, space, &space_data);
 	isl_space_free(space);
 	p = isl_printer_print_str(p, s_open_set0);
+	data.p = p;
+	data.first = 1;
 	isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
 					&print_pw_multi_aff_body_wrap, &data);
 	p = data.p;
@@ -2576,31 +3369,46 @@
  * If the current dimension is an output dimension, then print
  * the corresponding piecewise affine expression.
  * Otherwise, print the name of the dimension.
+ * Make sure to use the same space in both cases.
+ * In particular, use the domain space for printing names as
+ * that is the space that is used for printing constraints.
  */
 static __isl_give isl_printer *print_dim_mpa(__isl_take isl_printer *p,
 	struct isl_print_space_data *data, unsigned pos)
 {
 	int i;
 	int need_parens;
+	isl_space *space;
 	isl_multi_pw_aff *mpa = data->user;
 	isl_pw_aff *pa;
 
-	if (data->type != isl_dim_out)
-		return print_name(data->space, p, data->type, pos, data->latex);
+	if (data->type != isl_dim_out) {
+		enum isl_dim_type type = data->type;
+
+		if (type == isl_dim_in)
+			type = isl_dim_set;
+		space = isl_multi_pw_aff_get_domain_space(mpa);
+		p = print_name(space, p, type, pos, data->latex);
+		isl_space_free(space);
+		return p;
+	}
 
-	pa = mpa->ppos;
+	pa = mpa->u.ppos;
 	if (pa->n == 0)
-		return isl_printer_print_str(p, "(0 : 1 = 0)");
+		return isl_printer_print_str(p, "(0 : false)");
 
 	need_parens = pa->n != 1 || !isl_set_plain_is_universe(pa->p0.set);
 	if (need_parens)
 		p = isl_printer_print_str(p, "(");
+	space = isl_multi_pw_aff_get_domain_space(mpa);
 	for (i = 0; i < pa->n; ++i) {
+
 		if (i)
 			p = isl_printer_print_str(p, "; ");
-		p = print_aff_body(p, pa->pi.aff);
-		p = print_disjuncts(pa->pi.set, p, 0);
+		p = print_aff_body(p, space, pa->pi.aff);
+		p = print_disjuncts(pa->pi.set, space, p, 0);
 	}
+	isl_space_free(space);
 	if (need_parens)
 		p = isl_printer_print_str(p, ")");
 
@@ -2608,23 +3416,34 @@
 }
 
 /* Print "mpa" to "p" in isl format.
+ *
+ * If "mpa" is zero-dimensional and has a non-trivial explicit domain,
+ * then it is printed after the tuple of affine expressions.
  */
 static __isl_give isl_printer *print_multi_pw_aff_isl(__isl_take isl_printer *p,
 	__isl_keep isl_multi_pw_aff *mpa)
 {
 	struct isl_print_space_data data = { 0 };
+	isl_bool has_domain;
 
 	if (!mpa)
 		return isl_printer_free(p);
 
-	if (isl_space_dim(mpa->space, isl_dim_param) > 0) {
-		p = print_tuple(mpa->space, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, mpa->space, &data);
 	p = isl_printer_print_str(p, "{ ");
 	data.print_dim = &print_dim_mpa;
 	data.user = mpa;
-	p = print_space(mpa->space, p, 0, &data);
+	p = isl_print_space(mpa->space, p, 0, &data);
+	has_domain = isl_multi_pw_aff_has_non_trivial_domain(mpa);
+	if (has_domain < 0)
+		return isl_printer_free(p);
+	if (has_domain) {
+		isl_space *space;
+
+		space = isl_space_domain(isl_space_copy(mpa->space));
+		p = print_disjuncts_set(mpa->u.dom, space, p, 0);
+		isl_space_free(space);
+	}
 	p = isl_printer_print_str(p, " }");
 	return p;
 }
@@ -2654,7 +3473,7 @@
 	isl_multi_val *mv = data->user;
 
 	if (data->type == isl_dim_out)
-		return isl_printer_print_val(p, mv->ppos);
+		return isl_printer_print_val(p, mv->u.ppos);
 	else
 		return print_name(data->space, p, data->type, pos, data->latex);
 }
@@ -2669,14 +3488,11 @@
 	if (!mv)
 		return isl_printer_free(p);
 
-	if (isl_space_dim(mv->space, isl_dim_param) > 0) {
-		p = print_tuple(mv->space, p, isl_dim_param, &data);
-		p = isl_printer_print_str(p, " -> ");
-	}
+	p = print_param_tuple(p, mv->space, &data);
 	p = isl_printer_print_str(p, "{ ");
 	data.print_dim = &print_dim_mv;
 	data.user = mv;
-	p = print_space(mv->space, p, 0, &data);
+	p = isl_print_space(mv->space, p, 0, &data);
 	p = isl_printer_print_str(p, " }");
 	return p;
 }
@@ -2696,3 +3512,135 @@
 	isl_die(p->ctx, isl_error_unsupported, "unsupported output format",
 		return isl_printer_free(p));
 }
+
+/* Print dimension "pos" of data->space to "p".
+ *
+ * data->user is assumed to be an isl_multi_id.
+ *
+ * If the current dimension is an output dimension, then print
+ * the corresponding identifier.  Otherwise, print the name of the dimension.
+ */
+static __isl_give isl_printer *print_dim_mi(__isl_take isl_printer *p,
+	struct isl_print_space_data *data, unsigned pos)
+{
+	isl_multi_id *mi = data->user;
+
+	if (data->type == isl_dim_out)
+		return isl_printer_print_id(p, mi->u.ppos);
+	else
+		return print_name(data->space, p, data->type, pos, data->latex);
+}
+
+/* Print the isl_multi_id "mi" to "p" in isl format.
+ */
+static __isl_give isl_printer *print_multi_id_isl(__isl_take isl_printer *p,
+	__isl_keep isl_multi_id *mi)
+{
+	isl_space *space;
+	struct isl_print_space_data data = { 0 };
+
+	space = isl_multi_id_peek_space(mi);
+	p = print_param_tuple(p, space, &data);
+	p = isl_printer_print_str(p, "{ ");
+	data.print_dim = &print_dim_mi;
+	data.user = mi;
+	p = isl_print_space(space, p, 0, &data);
+	p = isl_printer_print_str(p, " }");
+	return p;
+}
+
+/* Print the isl_multi_id "mi" to "p".
+ *
+ * Currently only supported in isl format.
+ */
+__isl_give isl_printer *isl_printer_print_multi_id(
+	__isl_take isl_printer *p, __isl_keep isl_multi_id *mi)
+{
+	if (!p || !mi)
+		return isl_printer_free(p);
+
+	if (p->output_format == ISL_FORMAT_ISL)
+		return print_multi_id_isl(p, mi);
+	isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
+		"unsupported output format", return isl_printer_free(p));
+}
+
+/* Print dimension "pos" of data->space to "p".
+ *
+ * data->user is assumed to be an isl_multi_union_pw_aff.
+ *
+ * The current dimension is necessarily a set dimension, so
+ * we print the corresponding isl_union_pw_aff, including
+ * the braces.
+ */
+static __isl_give isl_printer *print_union_pw_aff_dim(__isl_take isl_printer *p,
+	struct isl_print_space_data *data, unsigned pos)
+{
+	isl_multi_union_pw_aff *mupa = data->user;
+	isl_union_pw_aff *upa;
+
+	upa = isl_multi_union_pw_aff_get_union_pw_aff(mupa, pos);
+	p = print_union_pw_aff_body(p, upa);
+	isl_union_pw_aff_free(upa);
+
+	return p;
+}
+
+/* Print the isl_multi_union_pw_aff "mupa" to "p" in isl format.
+ *
+ * If "mupa" is zero-dimensional and has a non-trivial explicit domain,
+ * then it is printed after the tuple of affine expressions.
+ * In order to clarify that this domain belongs to the expression,
+ * the tuple along with the domain are placed inside parentheses.
+ * If "mupa" has any parameters, then the opening parenthesis
+ * appears after the parameter declarations.
+ */
+static __isl_give isl_printer *print_multi_union_pw_aff_isl(
+	__isl_take isl_printer *p, __isl_keep isl_multi_union_pw_aff *mupa)
+{
+	struct isl_print_space_data data = { 0 };
+	isl_bool has_domain;
+	isl_space *space;
+
+	if (!mupa)
+		return isl_printer_free(p);
+	has_domain = isl_multi_union_pw_aff_has_non_trivial_domain(mupa);
+	if (has_domain < 0)
+		return isl_printer_free(p);
+
+	space = isl_multi_union_pw_aff_get_space(mupa);
+	p = print_param_tuple(p, space, &data);
+
+	if (has_domain)
+		p = isl_printer_print_str(p, "(");
+
+	data.print_dim = &print_union_pw_aff_dim;
+	data.user = mupa;
+
+	p = isl_print_space(space, p, 0, &data);
+	isl_space_free(space);
+
+	if (has_domain) {
+		p = isl_printer_print_str(p, " : ");
+		p = isl_printer_print_union_set_isl_body(p, mupa->u.dom);
+		p = isl_printer_print_str(p, ")");
+	}
+
+	return p;
+}
+
+/* Print the isl_multi_union_pw_aff "mupa" to "p" in isl format.
+ *
+ * We currently only support an isl format.
+ */
+__isl_give isl_printer *isl_printer_print_multi_union_pw_aff(
+	__isl_take isl_printer *p, __isl_keep isl_multi_union_pw_aff *mupa)
+{
+	if (!p || !mupa)
+		return isl_printer_free(p);
+
+	if (p->output_format == ISL_FORMAT_ISL)
+		return print_multi_union_pw_aff_isl(p, mupa);
+	isl_die(isl_printer_get_ctx(p), isl_error_unsupported,
+		"unsupported output format", return isl_printer_free(p));
+}

_service:tar_scm:isl-0.24.tar.gz/isl_output_private.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_point.c -> _service:tar_scm:isl-0.24.tar.gz/isl_point.c Changed

@@ -1,68 +1,110 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ * Copyright 2015      Sven Verdoolaege
+ * Copyright 2019      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
 #include <isl_map_private.h>
 #include <isl_point_private.h>
 #include <isl/set.h>
+#include <isl/union_set.h>
 #include <isl_sample.h>
 #include <isl_scan.h>
 #include <isl_seq.h>
 #include <isl_space_private.h>
+#include <isl_local_private.h>
 #include <isl_val_private.h>
 #include <isl_vec_private.h>
-#include <isl/deprecated/point_int.h>
+#include <isl_output_private.h>
+
+#include <set_to_map.c>
 
 isl_ctx *isl_point_get_ctx(__isl_keep isl_point *pnt)
 {
 	return pnt ? isl_space_get_ctx(pnt->dim) : NULL;
 }
 
+/* Return the space of "pnt".
+ */
+__isl_keep isl_space *isl_point_peek_space(__isl_keep isl_point *pnt)
+{
+	return pnt ? pnt->dim : NULL;
+}
+
 __isl_give isl_space *isl_point_get_space(__isl_keep isl_point *pnt)
 {
-	return pnt ? isl_space_copy(pnt->dim) : NULL;
+	return isl_space_copy(isl_point_peek_space(pnt));
 }
 
-__isl_give isl_point *isl_point_alloc(__isl_take isl_space *dim,
+#undef TYPE1
+#define TYPE1		isl_basic_map
+#undef TYPE2
+#define TYPE2		isl_point
+#undef TYPE_PAIR
+#define TYPE_PAIR	isl_basic_map_point
+
+static
+#include "isl_type_has_equal_space_templ.c"
+static
+#include "isl_type_check_equal_space_templ.c"
+
+__isl_give isl_point *isl_point_alloc(__isl_take isl_space *space,
 	__isl_take isl_vec *vec)
 {
 	struct isl_point *pnt;
+	isl_size dim;
 
-	if (!dim || !vec)
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0 || !vec)
 		goto error;
 
-	if (vec->size > 1 + isl_space_dim(dim, isl_dim_all)) {
+	if (vec->size > 1 + dim) {
 		vec = isl_vec_cow(vec);
 		if (!vec)
 			goto error;
-		vec->size = 1 + isl_space_dim(dim, isl_dim_all);
+		vec->size = 1 + dim;
 	}
 
-	pnt = isl_alloc_type(dim->ctx, struct isl_point);
+	pnt = isl_alloc_type(space->ctx, struct isl_point);
 	if (!pnt)
 		goto error;
 
 	pnt->ref = 1;
-	pnt->dim = dim;
+	pnt->dim = space;
 	pnt->vec = vec;
 
 	return pnt;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_vec_free(vec);
 	return NULL;
 }
 
-__isl_give isl_point *isl_point_zero(__isl_take isl_space *dim)
+__isl_give isl_point *isl_point_zero(__isl_take isl_space *space)
 {
 	isl_vec *vec;
+	isl_size dim;
 
-	if (!dim)
-		return NULL;
-	vec = isl_vec_alloc(dim->ctx, 1 + isl_space_dim(dim, isl_dim_all));
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		goto error;
+	vec = isl_vec_alloc(space->ctx, 1 + dim);
 	if (!vec)
 		goto error;
 	isl_int_set_si(vec->el0, 1);
 	isl_seq_clr(vec->el + 1, vec->size - 1);
-	return isl_point_alloc(dim, vec);
+	return isl_point_alloc(space, vec);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -99,52 +141,174 @@
 	return pnt;
 }
 
-void isl_point_free(__isl_take isl_point *pnt)
+__isl_null isl_point *isl_point_free(__isl_take isl_point *pnt)
 {
 	if (!pnt)
-		return;
+		return NULL;
 
 	if (--pnt->ref > 0)
-		return;
+		return NULL;
 
 	isl_space_free(pnt->dim);
 	isl_vec_free(pnt->vec);
 	free(pnt);
+	return NULL;
 }
 
-__isl_give isl_point *isl_point_void(__isl_take isl_space *dim)
+__isl_give isl_point *isl_point_void(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	return isl_point_alloc(dim, isl_vec_alloc(dim->ctx, 0));
+	return isl_point_alloc(space, isl_vec_alloc(space->ctx, 0));
 }
 
-int isl_point_is_void(__isl_keep isl_point *pnt)
+isl_bool isl_point_is_void(__isl_keep isl_point *pnt)
 {
 	if (!pnt)
-		return -1;
+		return isl_bool_error;
 
-	return pnt->vec->size == 0;
+	return isl_bool_ok(pnt->vec->size == 0);
 }
 
-int isl_point_get_coordinate(__isl_keep isl_point *pnt,
-	enum isl_dim_type type, int pos, isl_int *v)
+/* Return the space of "pnt".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "pnt".
+ * This allows the space to be modified inplace
+ * if both the point and its space have only a single reference.
+ * The caller is not allowed to modify "pnt" between this call and
+ * a subsequent call to isl_point_restore_space.
+ * The only exception is that isl_point_free can be called instead.
+ */
+__isl_give isl_space *isl_point_take_space(__isl_keep isl_point *pnt)
 {
-	if (!pnt || isl_point_is_void(pnt))
-		return -1;
+	isl_space *space;
 
-	if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
-		isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
-			"position out of bounds", return -1);
+	if (!pnt)
+		return NULL;
+	if (pnt->ref != 1)
+		return isl_point_get_space(pnt);
+	space = pnt->dim;
+	pnt->dim = NULL;
+	return space;
+}
+
+/* Set the space of "pnt" to "space", where the space of "pnt" may be missing
+ * due to a preceding call to isl_point_take_space.
+ * However, in this case, "pnt" only has a single reference and
+ * then the call to isl_point_cow has no effect.
+ */
+__isl_give isl_point *isl_point_restore_space(__isl_take isl_point *pnt,
+	__isl_take isl_space *space)
+{
+	if (!pnt || !space)
+		goto error;
+
+	if (pnt->dim == space) {
+		isl_space_free(space);
+		return pnt;
+	}
+
+	pnt = isl_point_cow(pnt);
+	if (!pnt)
+		goto error;
+	isl_space_free(pnt->dim);
+	pnt->dim = space;
+
+	return pnt;
+error:
+	isl_point_free(pnt);
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Return the coordinate vector of "pnt".
+ */
+__isl_keep isl_vec *isl_point_peek_vec(__isl_keep isl_point *pnt)
+{
+	return pnt ? pnt->vec : NULL;
+}
+
+/* Return a copy of the coordinate vector of "pnt".
+ */
+__isl_give isl_vec *isl_point_get_vec(__isl_keep isl_point *pnt)
+{
+	return isl_vec_copy(isl_point_peek_vec(pnt));
+}
+
+/* Return the coordinate vector of "pnt".
+ * This may be either a copy or the coordinate vector itself
+ * if there is only one reference to "pnt".
+ * This allows the coordinate vector to be modified inplace
+ * if both the point and its coordinate vector have only a single reference.
+ * The caller is not allowed to modify "pnt" between this call and
+ * a subsequent call to isl_point_restore_vec.
+ * The only exception is that isl_point_free can be called instead.
+ */
+__isl_give isl_vec *isl_point_take_vec(__isl_keep isl_point *pnt)
+{
+	isl_vec *vec;
+
+	if (!pnt)
+		return NULL;
+	if (pnt->ref != 1)
+		return isl_point_get_vec(pnt);
+	vec = pnt->vec;
+	pnt->vec = NULL;
+	return vec;
+}
+
+/* Set the coordinate vector of "pnt" to "vec",
+ * where the coordinate vector of "pnt" may be missing
+ * due to a preceding call to isl_point_take_vec.
+ * However, in this case, "pnt" only has a single reference and
+ * then the call to isl_point_cow has no effect.
+ */
+__isl_give isl_point *isl_point_restore_vec(__isl_take isl_point *pnt,
+	__isl_take isl_vec *vec)
+{
+	if (!pnt || !vec)
+		goto error;
+
+	if (pnt->vec == vec) {
+		isl_vec_free(vec);
+		return pnt;
+	}
+
+	pnt = isl_point_cow(pnt);
+	if (!pnt)
+		goto error;
+	isl_vec_free(pnt->vec);
+	pnt->vec = vec;
+
+	return pnt;
+error:
+	isl_point_free(pnt);
+	isl_vec_free(vec);
+	return NULL;
+}
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(pnt->dim, isl_dim_param);
-	isl_int_set(*v, pnt->vec->el1 + pos);
+/* Return the number of variables of the given type.
+ */
+static isl_size isl_point_dim(__isl_keep isl_point *pnt, enum isl_dim_type type)
+{
+	return isl_space_dim(isl_point_peek_space(pnt), type);
+}
 
-	return 0;
+/* Return the position of the coordinates of the given type
+ * within the sequence of coordinates of "pnt".
+ */
+static isl_size isl_point_var_offset(__isl_keep isl_point *pnt,
+	enum isl_dim_type type)
+{
+	return pnt ? isl_space_offset(pnt->dim, type) : isl_size_error;
 }
 
+#undef TYPE
+#define TYPE	isl_point
+static
+#include "check_type_range_templ.c"
+
 /* Return the value of coordinate "pos" of type "type" of "pnt".
  */
 __isl_give isl_val *isl_point_get_coordinate_val(__isl_keep isl_point *pnt,
@@ -152,6 +316,7 @@
 {
 	isl_ctx *ctx;
 	isl_val *v;
+	isl_size off;
 
 	if (!pnt)
 		return NULL;
@@ -160,40 +325,66 @@
 	if (isl_point_is_void(pnt))
 		isl_die(ctx, isl_error_invalid,
 			"void point does not have coordinates", return NULL);
-	if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
-		isl_die(ctx, isl_error_invalid,
-			"position out of bounds", return NULL);
+	if (isl_point_check_range(pnt, type, pos, 1) < 0)
+		return NULL;
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(pnt->dim, isl_dim_param);
+	off = isl_point_var_offset(pnt, type);
+	if (off < 0)
+		return NULL;
+	pos += off;
 
 	v = isl_val_rat_from_isl_int(ctx, pnt->vec->el1 + pos,
 						pnt->vec->el0);
 	return isl_val_normalize(v);
 }
 
-__isl_give isl_point *isl_point_set_coordinate(__isl_take isl_point *pnt,
-	enum isl_dim_type type, int pos, isl_int v)
+/* Set all entries of "mv" to NaN.
+ */
+static __isl_give isl_multi_val *set_nan(__isl_take isl_multi_val *mv)
 {
-	if (!pnt || isl_point_is_void(pnt))
-		return pnt;
+	int i;
+	isl_size n;
+	isl_val *v;
 
-	pnt = isl_point_cow(pnt);
-	if (!pnt)
-		return NULL;
-	pnt->vec = isl_vec_cow(pnt->vec);
-	if (!pnt->vec)
-		goto error;
+	n = isl_multi_val_size(mv);
+	if (n < 0)
+		return isl_multi_val_free(mv);
+	v = isl_val_nan(isl_multi_val_get_ctx(mv));
+	for (i = 0; i < n; ++i)
+		mv = isl_multi_val_set_at(mv, i, isl_val_copy(v));
+	isl_val_free(v);
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(pnt->dim, isl_dim_param);
+	return mv;
+}
 
-	isl_int_set(pnt->vec->el1 + pos, v);
+/* Return the values of the set dimensions of "pnt".
+ * Return a sequence of NaNs in case of a void point.
+ */
+__isl_give isl_multi_val *isl_point_get_multi_val(__isl_keep isl_point *pnt)
+{
+	int i;
+	isl_bool is_void;
+	isl_size n;
+	isl_multi_val *mv;
 
-	return pnt;
-error:
-	isl_point_free(pnt);
-	return NULL;
+	is_void = isl_point_is_void(pnt);
+	if (is_void < 0)
+		return NULL;
+
+	mv = isl_multi_val_alloc(isl_point_get_space(pnt));
+	if (is_void)
+		return set_nan(mv);
+	n = isl_multi_val_size(mv);
+	if (n < 0)
+		return isl_multi_val_free(mv);
+	for (i = 0; i < n; ++i) {
+		isl_val *v;
+
+		v = isl_point_get_coordinate_val(pnt, isl_dim_set, i);
+		mv = isl_multi_val_set_at(mv, i, v);
+	}
+
+	return mv;
 }
 
 /* Replace coordinate "pos" of type "type" of "pnt" by "v".
@@ -206,13 +397,13 @@
 	if (isl_point_is_void(pnt))
 		isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
 			"void point does not have coordinates", goto error);
-	if (pos < 0 || pos >= isl_space_dim(pnt->dim, type))
-		isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
-			"position out of bounds", goto error);
+	if (isl_point_check_range(pnt, type, pos, 1) < 0)
+		goto error;
 	if (!isl_val_is_rat(v))
 		isl_die(isl_point_get_ctx(pnt), isl_error_invalid,
 			"expecting rational value", goto error);
 
+	pos += isl_space_offset(isl_point_peek_space(pnt), type);
 	if (isl_int_eq(pnt->vec->el1 + pos, v->n) &&
 	    isl_int_eq(pnt->vec->el0, v->d)) {
 		isl_val_free(v);
@@ -251,6 +442,8 @@
 __isl_give isl_point *isl_point_add_ui(__isl_take isl_point *pnt,
 	enum isl_dim_type type, int pos, unsigned val)
 {
+	isl_size off;
+
 	if (!pnt || isl_point_is_void(pnt))
 		return pnt;
 
@@ -261,8 +454,10 @@
 	if (!pnt->vec)
 		goto error;
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(pnt->dim, isl_dim_param);
+	off = isl_point_var_offset(pnt, type);
+	if (off < 0)
+		goto error;
+	pos += off;
 
 	isl_int_add_ui(pnt->vec->el1 + pos, pnt->vec->el1 + pos, val);
 
@@ -275,6 +470,8 @@
 __isl_give isl_point *isl_point_sub_ui(__isl_take isl_point *pnt,
 	enum isl_dim_type type, int pos, unsigned val)
 {
+	isl_size off;
+
 	if (!pnt || isl_point_is_void(pnt))
 		return pnt;
 
@@ -285,8 +482,10 @@
 	if (!pnt->vec)
 		goto error;
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(pnt->dim, isl_dim_param);
+	off = isl_point_var_offset(pnt, type);
+	if (off < 0)
+		goto error;
+	pos += off;
 
 	isl_int_sub_ui(pnt->vec->el1 + pos, pnt->vec->el1 + pos, val);
 
@@ -298,12 +497,13 @@
 
 struct isl_foreach_point {
 	struct isl_scan_callback callback;
-	int (*fn)(__isl_take isl_point *pnt, void *user);
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user);
 	void *user;
 	isl_space *dim;
 };
 
-static int foreach_point(struct isl_scan_callback *cb, __isl_take isl_vec *sample)
+static isl_stat foreach_point(struct isl_scan_callback *cb,
+	__isl_take isl_vec *sample)
 {
 	struct isl_foreach_point *fp = (struct isl_foreach_point *)cb;
 	isl_point *pnt;
@@ -313,18 +513,18 @@
 	return fp->fn(pnt, fp->user);
 }
 
-int isl_set_foreach_point(__isl_keep isl_set *set,
-	int (*fn)(__isl_take isl_point *pnt, void *user), void *user)
+isl_stat isl_set_foreach_point(__isl_keep isl_set *set,
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user)
 {
 	struct isl_foreach_point fp = { { &foreach_point }, fn, user };
 	int i;
 
 	if (!set)
-		return -1;
+		return isl_stat_error;
 
 	fp.dim = isl_set_get_space(set);
 	if (!fp.dim)
-		return -1;
+		return isl_stat_error;
 
 	set = isl_set_copy(set);
 	set = isl_set_cow(set);
@@ -341,11 +541,11 @@
 	isl_set_free(set);
 	isl_space_free(fp.dim);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(set);
 	isl_space_free(fp.dim);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Return 1 if "bmap" contains the point "point".
@@ -353,32 +553,22 @@
  * The point is first extended with the divs and then passed
  * to basic_map_contains.
  */
-int isl_basic_map_contains_point(__isl_keep isl_basic_map *bmap,
+isl_bool isl_basic_map_contains_point(__isl_keep isl_basic_map *bmap,
 	__isl_keep isl_point *point)
 {
-	int i;
-	struct isl_vec *vec;
-	unsigned dim;
-	int contains;
+	isl_local *local;
+	isl_vec *vec;
+	isl_bool contains;
 
-	if (!bmap || !point)
-		return -1;
-	isl_assert(bmap->ctx, isl_space_is_equal(bmap->dim, point->dim), return -1);
+	if (isl_basic_map_point_check_equal_space(bmap, point) < 0)
+		return isl_bool_error;
 	if (bmap->n_div == 0)
 		return isl_basic_map_contains(bmap, point->vec);
 
-	dim = isl_basic_map_total_dim(bmap) - bmap->n_div;
-	vec = isl_vec_alloc(bmap->ctx, 1 + dim + bmap->n_div);
-	if (!vec)
-		return -1;
-
-	isl_seq_cpy(vec->el, point->vec->el, point->vec->size);
-	for (i = 0; i < bmap->n_div; ++i) {
-		isl_seq_inner_product(bmap->divi + 1, vec->el,
-					1 + dim + i, &vec->el1+dim+i);
-		isl_int_fdiv_q(vec->el1+dim+i, vec->el1+dim+i,
-				bmap->divi0);
-	}
+	local = isl_local_alloc_from_mat(isl_basic_map_get_divs(bmap));
+	vec = isl_point_get_vec(point);
+	vec = isl_local_extend_point_vec(local, vec);
+	isl_local_free(local);
 
 	contains = isl_basic_map_contains(bmap, vec);
 
@@ -386,18 +576,19 @@
 	return contains;
 }
 
-int isl_map_contains_point(__isl_keep isl_map *map, __isl_keep isl_point *point)
+isl_bool isl_map_contains_point(__isl_keep isl_map *map,
+	__isl_keep isl_point *point)
 {
 	int i;
-	int found = 0;
+	isl_bool found = isl_bool_false;
 
 	if (!map || !point)
-		return -1;
+		return isl_bool_error;
 
 	map = isl_map_copy(map);
 	map = isl_map_compute_divs(map);
 	if (!map)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < map->n; ++i) {
 		found = isl_basic_map_contains_point(map->pi, point);
@@ -411,12 +602,13 @@
 	return found;
 error:
 	isl_map_free(map);
-	return -1;
+	return isl_bool_error;
 }
 
-int isl_set_contains_point(__isl_keep isl_set *set, __isl_keep isl_point *point)
+isl_bool isl_set_contains_point(__isl_keep isl_set *set,
+	__isl_keep isl_point *point)
 {
-	return isl_map_contains_point((isl_map *)set, point);
+	return isl_map_contains_point(set_to_map(set), point);
 }
 
 __isl_give isl_basic_set *isl_basic_set_from_point(__isl_take isl_point *pnt)
@@ -442,11 +634,37 @@
 	return isl_set_from_basic_set(bset);
 }
 
+/* This function performs the same operation as isl_set_from_point,
+ * but is considered as a function on an isl_point when exported.
+ */
+__isl_give isl_set *isl_point_to_set(__isl_take isl_point *pnt)
+{
+	return isl_set_from_point(pnt);
+}
+
+/* Construct a union set, containing the single element "pnt".
+ * If "pnt" is void, then return an empty union set.
+ */
+__isl_give isl_union_set *isl_union_set_from_point(__isl_take isl_point *pnt)
+{
+	if (!pnt)
+		return NULL;
+	if (isl_point_is_void(pnt)) {
+		isl_space *space;
+
+		space = isl_point_get_space(pnt);
+		isl_point_free(pnt);
+		return isl_union_set_empty(space);
+	}
+
+	return isl_union_set_from_set(isl_set_from_point(pnt));
+}
+
 __isl_give isl_basic_set *isl_basic_set_box_from_points(
 	__isl_take isl_point *pnt1, __isl_take isl_point *pnt2)
 {
-	isl_basic_set *bset;
-	unsigned total;
+	isl_basic_set *bset = NULL;
+	isl_size total;
 	int i;
 	int k;
 	isl_int t;
@@ -460,11 +678,11 @@
 			isl_space_is_equal(pnt1->dim, pnt2->dim), goto error);
 
 	if (isl_point_is_void(pnt1) && isl_point_is_void(pnt2)) {
-		isl_space *dim = isl_space_copy(pnt1->dim);
+		isl_space *space = isl_space_copy(pnt1->dim);
 		isl_point_free(pnt1);
 		isl_point_free(pnt2);
 		isl_int_clear(t);
-		return isl_basic_set_empty(dim);
+		return isl_basic_set_empty(space);
 	}
 	if (isl_point_is_void(pnt1)) {
 		isl_point_free(pnt1);
@@ -477,7 +695,9 @@
 		return isl_basic_set_from_point(pnt1);
 	}
 
-	total = isl_space_dim(pnt1->dim, isl_dim_all);
+	total = isl_point_dim(pnt1, isl_dim_all);
+	if (total < 0)
+		goto error;
 	bset = isl_basic_set_alloc_space(isl_space_copy(pnt1->dim), 0, 0, 2 * total);
 
 	for (i = 0; i < total; ++i) {
@@ -523,6 +743,7 @@
 	isl_point_free(pnt1);
 	isl_point_free(pnt2);
 	isl_int_clear(t);
+	isl_basic_set_free(bset);
 	return NULL;
 }
 
@@ -534,12 +755,29 @@
 	return isl_set_from_basic_set(bset);
 }
 
+/* Print the coordinate at position "pos" of the point "pnt".
+ */
+static __isl_give isl_printer *print_coordinate(__isl_take isl_printer *p,
+	struct isl_print_space_data *data, unsigned pos)
+{
+	isl_point *pnt = data->user;
+
+	pos += isl_space_offset(data->space, data->type);
+	p = isl_printer_print_isl_int(p, pnt->vec->el1 + pos);
+	if (!isl_int_is_one(pnt->vec->el0)) {
+		p = isl_printer_print_str(p, "/");
+		p = isl_printer_print_isl_int(p, pnt->vec->el0);
+	}
+
+	return p;
+}
+
 __isl_give isl_printer *isl_printer_print_point(
 	__isl_take isl_printer *p, __isl_keep isl_point *pnt)
 {
+	struct isl_print_space_data data = { 0 };
 	int i;
-	unsigned nparam;
-	unsigned dim;
+	isl_size nparam;
 
 	if (!pnt)
 		return p;
@@ -548,8 +786,9 @@
 		return p;
 	}
 
-	nparam = isl_space_dim(pnt->dim, isl_dim_param);
-	dim = isl_space_dim(pnt->dim, isl_dim_set);
+	nparam = isl_point_dim(pnt, isl_dim_param);
+	if (nparam < 0)
+		return isl_printer_free(p);
 	if (nparam > 0) {
 		p = isl_printer_print_str(p, "");
 		for (i = 0; i < nparam; ++i) {
@@ -570,16 +809,10 @@
 		p = isl_printer_print_str(p, "");
 		p = isl_printer_print_str(p, " -> ");
 	}
-	p = isl_printer_print_str(p, "");
-	for (i = 0; i < dim; ++i) {
-		if (i)
-			p = isl_printer_print_str(p, ", ");
-		p = isl_printer_print_isl_int(p, pnt->vec->el1 + nparam + i);
-		if (!isl_int_is_one(pnt->vec->el0)) {
-			p = isl_printer_print_str(p, "/");
-			p = isl_printer_print_isl_int(p, pnt->vec->el0);
-		}
-	}
-	p = isl_printer_print_str(p, "");
+	data.print_dim = &print_coordinate;
+	data.user = pnt;
+	p = isl_printer_print_str(p, "{ ");
+	p = isl_print_space(pnt->dim, p, 0, &data);
+	p = isl_printer_print_str(p, " }");
 	return p;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_point_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_point_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_polynomial.c -> _service:tar_scm:isl-0.24.tar.gz/isl_polynomial.c Changed

@@ -9,7 +9,6 @@
  */
 
 #include <stdlib.h>
-#define ISL_DIM_H
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
 #include <isl_factorization.h>
@@ -23,213 +22,282 @@
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 #include <isl_range.h>
+#include <isl_local.h>
 #include <isl_local_space_private.h>
 #include <isl_aff_private.h>
 #include <isl_val_private.h>
 #include <isl_config.h>
-#include <isl/deprecated/polynomial_int.h>
 
-static unsigned pos(__isl_keep isl_space *dim, enum isl_dim_type type)
+#undef EL_BASE
+#define EL_BASE qpolynomial
+
+#include <isl_list_templ.c>
+
+#undef EL_BASE
+#define EL_BASE pw_qpolynomial
+
+#include <isl_list_templ.c>
+
+static unsigned pos(__isl_keep isl_space *space, enum isl_dim_type type)
 {
 	switch (type) {
 	case isl_dim_param:	return 0;
-	case isl_dim_in:	return dim->nparam;
-	case isl_dim_out:	return dim->nparam + dim->n_in;
+	case isl_dim_in:	return space->nparam;
+	case isl_dim_out:	return space->nparam + space->n_in;
 	default:		return 0;
 	}
 }
 
-int isl_upoly_is_cst(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_cst(__isl_keep isl_poly *poly)
 {
-	if (!up)
-		return -1;
+	if (!poly)
+		return isl_bool_error;
 
-	return up->var < 0;
+	return isl_bool_ok(poly->var < 0);
 }
 
-__isl_keep struct isl_upoly_cst *isl_upoly_as_cst(__isl_keep struct isl_upoly *up)
+__isl_keep isl_poly_cst *isl_poly_as_cst(__isl_keep isl_poly *poly)
 {
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	isl_assert(up->ctx, up->var < 0, return NULL);
+	isl_assert(poly->ctx, poly->var < 0, return NULL);
 
-	return (struct isl_upoly_cst *)up;
+	return (isl_poly_cst *) poly;
 }
 
-__isl_keep struct isl_upoly_rec *isl_upoly_as_rec(__isl_keep struct isl_upoly *up)
+__isl_keep isl_poly_rec *isl_poly_as_rec(__isl_keep isl_poly *poly)
 {
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	isl_assert(up->ctx, up->var >= 0, return NULL);
+	isl_assert(poly->ctx, poly->var >= 0, return NULL);
 
-	return (struct isl_upoly_rec *)up;
+	return (isl_poly_rec *) poly;
 }
 
-int isl_upoly_is_equal(__isl_keep struct isl_upoly *up1,
-	__isl_keep struct isl_upoly *up2)
+/* Compare two polynomials.
+ *
+ * Return -1 if "poly1" is "smaller" than "poly2", 1 if "poly1" is "greater"
+ * than "poly2" and 0 if they are equal.
+ */
+static int isl_poly_plain_cmp(__isl_keep isl_poly *poly1,
+	__isl_keep isl_poly *poly2)
 {
 	int i;
-	struct isl_upoly_rec *rec1, *rec2;
+	isl_bool is_cst1;
+	isl_poly_rec *rec1, *rec2;
 
-	if (!up1 || !up2)
+	if (poly1 == poly2)
+		return 0;
+	is_cst1 = isl_poly_is_cst(poly1);
+	if (is_cst1 < 0)
 		return -1;
-	if (up1 == up2)
+	if (!poly2)
 		return 1;
-	if (up1->var != up2->var)
+	if (poly1->var != poly2->var)
+		return poly1->var - poly2->var;
+
+	if (is_cst1) {
+		isl_poly_cst *cst1, *cst2;
+		int cmp;
+
+		cst1 = isl_poly_as_cst(poly1);
+		cst2 = isl_poly_as_cst(poly2);
+		if (!cst1 || !cst2)
+			return 0;
+		cmp = isl_int_cmp(cst1->n, cst2->n);
+		if (cmp != 0)
+			return cmp;
+		return isl_int_cmp(cst1->d, cst2->d);
+	}
+
+	rec1 = isl_poly_as_rec(poly1);
+	rec2 = isl_poly_as_rec(poly2);
+	if (!rec1 || !rec2)
 		return 0;
-	if (isl_upoly_is_cst(up1)) {
-		struct isl_upoly_cst *cst1, *cst2;
-		cst1 = isl_upoly_as_cst(up1);
-		cst2 = isl_upoly_as_cst(up2);
+
+	if (rec1->n != rec2->n)
+		return rec1->n - rec2->n;
+
+	for (i = 0; i < rec1->n; ++i) {
+		int cmp = isl_poly_plain_cmp(rec1->pi, rec2->pi);
+		if (cmp != 0)
+			return cmp;
+	}
+
+	return 0;
+}
+
+isl_bool isl_poly_is_equal(__isl_keep isl_poly *poly1,
+	__isl_keep isl_poly *poly2)
+{
+	int i;
+	isl_bool is_cst1;
+	isl_poly_rec *rec1, *rec2;
+
+	is_cst1 = isl_poly_is_cst(poly1);
+	if (is_cst1 < 0 || !poly2)
+		return isl_bool_error;
+	if (poly1 == poly2)
+		return isl_bool_true;
+	if (poly1->var != poly2->var)
+		return isl_bool_false;
+	if (is_cst1) {
+		isl_poly_cst *cst1, *cst2;
+		int r;
+		cst1 = isl_poly_as_cst(poly1);
+		cst2 = isl_poly_as_cst(poly2);
 		if (!cst1 || !cst2)
-			return -1;
-		return isl_int_eq(cst1->n, cst2->n) &&
-		       isl_int_eq(cst1->d, cst2->d);
+			return isl_bool_error;
+		r = isl_int_eq(cst1->n, cst2->n) &&
+		    isl_int_eq(cst1->d, cst2->d);
+		return isl_bool_ok(r);
 	}
 
-	rec1 = isl_upoly_as_rec(up1);
-	rec2 = isl_upoly_as_rec(up2);
+	rec1 = isl_poly_as_rec(poly1);
+	rec2 = isl_poly_as_rec(poly2);
 	if (!rec1 || !rec2)
-		return -1;
+		return isl_bool_error;
 
 	if (rec1->n != rec2->n)
-		return 0;
+		return isl_bool_false;
 
 	for (i = 0; i < rec1->n; ++i) {
-		int eq = isl_upoly_is_equal(rec1->pi, rec2->pi);
+		isl_bool eq = isl_poly_is_equal(rec1->pi, rec2->pi);
 		if (eq < 0 || !eq)
 			return eq;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
-int isl_upoly_is_zero(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_zero(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_zero(cst->n) && isl_int_is_pos(cst->d);
+	return isl_bool_ok(isl_int_is_zero(cst->n) && isl_int_is_pos(cst->d));
 }
 
-int isl_upoly_sgn(__isl_keep struct isl_upoly *up)
+int isl_poly_sgn(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return 0;
-	if (!isl_upoly_is_cst(up))
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
 		return 0;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
 		return 0;
 
 	return isl_int_sgn(cst->n);
 }
 
-int isl_upoly_is_nan(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_nan(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_zero(cst->n) && isl_int_is_zero(cst->d);
+	return isl_bool_ok(isl_int_is_zero(cst->n) && isl_int_is_zero(cst->d));
 }
 
-int isl_upoly_is_infty(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_infty(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_pos(cst->n) && isl_int_is_zero(cst->d);
+	return isl_bool_ok(isl_int_is_pos(cst->n) && isl_int_is_zero(cst->d));
 }
 
-int isl_upoly_is_neginfty(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_neginfty(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_neg(cst->n) && isl_int_is_zero(cst->d);
+	return isl_bool_ok(isl_int_is_neg(cst->n) && isl_int_is_zero(cst->d));
 }
 
-int isl_upoly_is_one(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_one(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
+	int r;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_eq(cst->n, cst->d) && isl_int_is_pos(cst->d);
+	r = isl_int_eq(cst->n, cst->d) && isl_int_is_pos(cst->d);
+	return isl_bool_ok(r);
 }
 
-int isl_upoly_is_negone(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_negone(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
-		return -1;
-	if (!isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_negone(cst->n) && isl_int_is_one(cst->d);
+	return isl_bool_ok(isl_int_is_negone(cst->n) && isl_int_is_one(cst->d));
 }
 
-__isl_give struct isl_upoly_cst *isl_upoly_cst_alloc(struct isl_ctx *ctx)
+__isl_give isl_poly_cst *isl_poly_cst_alloc(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_alloc_type(ctx, struct isl_upoly_cst);
+	cst = isl_alloc_type(ctx, struct isl_poly_cst);
 	if (!cst)
 		return NULL;
 
-	cst->up.ref = 1;
-	cst->up.ctx = ctx;
+	cst->poly.ref = 1;
+	cst->poly.ctx = ctx;
 	isl_ctx_ref(ctx);
-	cst->up.var = -1;
+	cst->poly.var = -1;
 
 	isl_int_init(cst->n);
 	isl_int_init(cst->d);
@@ -237,108 +305,106 @@
 	return cst;
 }
 
-__isl_give struct isl_upoly *isl_upoly_zero(struct isl_ctx *ctx)
+__isl_give isl_poly *isl_poly_zero(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set_si(cst->n, 0);
 	isl_int_set_si(cst->d, 1);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_one(struct isl_ctx *ctx)
+__isl_give isl_poly *isl_poly_one(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set_si(cst->n, 1);
 	isl_int_set_si(cst->d, 1);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_infty(struct isl_ctx *ctx)
+__isl_give isl_poly *isl_poly_infty(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set_si(cst->n, 1);
 	isl_int_set_si(cst->d, 0);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_neginfty(struct isl_ctx *ctx)
+__isl_give isl_poly *isl_poly_neginfty(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set_si(cst->n, -1);
 	isl_int_set_si(cst->d, 0);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_nan(struct isl_ctx *ctx)
+__isl_give isl_poly *isl_poly_nan(isl_ctx *ctx)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set_si(cst->n, 0);
 	isl_int_set_si(cst->d, 0);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_rat_cst(struct isl_ctx *ctx,
-	isl_int n, isl_int d)
+__isl_give isl_poly *isl_poly_rat_cst(isl_ctx *ctx, isl_int n, isl_int d)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	cst = isl_upoly_cst_alloc(ctx);
+	cst = isl_poly_cst_alloc(ctx);
 	if (!cst)
 		return NULL;
 
 	isl_int_set(cst->n, n);
 	isl_int_set(cst->d, d);
 
-	return &cst->up;
+	return &cst->poly;
 }
 
-__isl_give struct isl_upoly_rec *isl_upoly_alloc_rec(struct isl_ctx *ctx,
-	int var, int size)
+__isl_give isl_poly_rec *isl_poly_alloc_rec(isl_ctx *ctx, int var, int size)
 {
-	struct isl_upoly_rec *rec;
+	isl_poly_rec *rec;
 
 	isl_assert(ctx, var >= 0, return NULL);
 	isl_assert(ctx, size >= 0, return NULL);
-	rec = isl_calloc(ctx, struct isl_upoly_rec,
-			sizeof(struct isl_upoly_rec) +
-			size * sizeof(struct isl_upoly *));
+	rec = isl_calloc(ctx, struct isl_poly_rec,
+			sizeof(struct isl_poly_rec) +
+			size * sizeof(struct isl_poly *));
 	if (!rec)
 		return NULL;
 
-	rec->up.ref = 1;
-	rec->up.ctx = ctx;
+	rec->poly.ref = 1;
+	rec->poly.ctx = ctx;
 	isl_ctx_ref(ctx);
-	rec->up.var = var;
+	rec->poly.var = var;
 
 	rec->n = 0;
 	rec->size = size;
@@ -347,19 +413,19 @@
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_reset_domain_space(
-	__isl_take isl_qpolynomial *qp, __isl_take isl_space *dim)
+	__isl_take isl_qpolynomial *qp, __isl_take isl_space *space)
 {
 	qp = isl_qpolynomial_cow(qp);
-	if (!qp || !dim)
+	if (!qp || !space)
 		goto error;
 
 	isl_space_free(qp->dim);
-	qp->dim = dim;
+	qp->dim = space;
 
 	return qp;
 error:
 	isl_qpolynomial_free(qp);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -380,10 +446,46 @@
 	return qp ? qp->dim->ctx : NULL;
 }
 
+/* Return the domain space of "qp".
+ */
+static __isl_keep isl_space *isl_qpolynomial_peek_domain_space(
+	__isl_keep isl_qpolynomial *qp)
+{
+	return qp ? qp->dim : NULL;
+}
+
+/* Return a copy of the domain space of "qp".
+ */
 __isl_give isl_space *isl_qpolynomial_get_domain_space(
 	__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_space_copy(qp->dim) : NULL;
+	return isl_space_copy(isl_qpolynomial_peek_domain_space(qp));
+}
+
+#undef TYPE
+#define TYPE		isl_qpolynomial
+#undef PEEK_SPACE
+#define PEEK_SPACE	peek_domain_space
+
+static
+#include "isl_type_has_equal_space_bin_templ.c"
+static
+#include "isl_type_check_equal_space_templ.c"
+
+#undef PEEK_SPACE
+
+/* Return a copy of the local space on which "qp" is defined.
+ */
+static __isl_give isl_local_space *isl_qpolynomial_get_domain_local_space(
+	__isl_keep isl_qpolynomial *qp)
+{
+	isl_space *space;
+
+	if (!qp)
+		return NULL;
+
+	space = isl_qpolynomial_get_domain_space(qp);
+	return isl_local_space_alloc_div(space, isl_mat_copy(qp->div));
 }
 
 __isl_give isl_space *isl_qpolynomial_get_space(__isl_keep isl_qpolynomial *qp)
@@ -397,159 +499,240 @@
 	return space;
 }
 
+/* Return the number of variables of the given type in the domain of "qp".
+ */
+isl_size isl_qpolynomial_domain_dim(__isl_keep isl_qpolynomial *qp,
+	enum isl_dim_type type)
+{
+	isl_space *space;
+	isl_size dim;
+
+	space = isl_qpolynomial_peek_domain_space(qp);
+
+	if (!space)
+		return isl_size_error;
+	if (type == isl_dim_div)
+		return qp->div->n_row;
+	dim = isl_space_dim(space, type);
+	if (dim < 0)
+		return isl_size_error;
+	if (type == isl_dim_all) {
+		isl_size n_div;
+
+		n_div = isl_qpolynomial_domain_dim(qp, isl_dim_div);
+		if (n_div < 0)
+			return isl_size_error;
+		dim += n_div;
+	}
+	return dim;
+}
+
+/* Given the type of a dimension of an isl_qpolynomial,
+ * return the type of the corresponding dimension in its domain.
+ * This function is only called for "type" equal to isl_dim_in or
+ * isl_dim_param.
+ */
+static enum isl_dim_type domain_type(enum isl_dim_type type)
+{
+	return type == isl_dim_in ? isl_dim_set : type;
+}
+
 /* Externally, an isl_qpolynomial has a map space, but internally, the
  * ls field corresponds to the domain of that space.
  */
-unsigned isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp,
+isl_size isl_qpolynomial_dim(__isl_keep isl_qpolynomial *qp,
 	enum isl_dim_type type)
 {
 	if (!qp)
-		return 0;
+		return isl_size_error;
 	if (type == isl_dim_out)
 		return 1;
-	if (type == isl_dim_in)
-		type = isl_dim_set;
-	return isl_space_dim(qp->dim, type);
+	type = domain_type(type);
+	return isl_qpolynomial_domain_dim(qp, type);
+}
+
+/* Return the offset of the first variable of type "type" within
+ * the variables of the domain of "qp".
+ */
+static isl_size isl_qpolynomial_domain_var_offset(
+	__isl_keep isl_qpolynomial *qp, enum isl_dim_type type)
+{
+	isl_space *space;
+
+	space = isl_qpolynomial_peek_domain_space(qp);
+	if (!space)
+		return isl_size_error;
+
+	switch (type) {
+	case isl_dim_param:
+	case isl_dim_set:	return isl_space_offset(space, type);
+	case isl_dim_div:	return isl_space_dim(space, isl_dim_all);
+	case isl_dim_cst:
+	default:
+		isl_die(isl_qpolynomial_get_ctx(qp), isl_error_invalid,
+			"invalid dimension type", return isl_size_error);
+	}
+}
+
+/* Return the offset of the first coefficient of type "type" in
+ * the domain of "qp".
+ */
+unsigned isl_qpolynomial_domain_offset(__isl_keep isl_qpolynomial *qp,
+	enum isl_dim_type type)
+{
+	switch (type) {
+	case isl_dim_cst:
+		return 0;
+	case isl_dim_param:
+	case isl_dim_set:
+	case isl_dim_div:
+		return 1 + isl_qpolynomial_domain_var_offset(qp, type);
+	default:
+		return 0;
+	}
 }
 
-int isl_qpolynomial_is_zero(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_zero(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_is_zero(qp->upoly) : -1;
+	return qp ? isl_poly_is_zero(qp->poly) : isl_bool_error;
 }
 
-int isl_qpolynomial_is_one(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_one(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_is_one(qp->upoly) : -1;
+	return qp ? isl_poly_is_one(qp->poly) : isl_bool_error;
 }
 
-int isl_qpolynomial_is_nan(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_nan(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_is_nan(qp->upoly) : -1;
+	return qp ? isl_poly_is_nan(qp->poly) : isl_bool_error;
 }
 
-int isl_qpolynomial_is_infty(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_infty(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_is_infty(qp->upoly) : -1;
+	return qp ? isl_poly_is_infty(qp->poly) : isl_bool_error;
 }
 
-int isl_qpolynomial_is_neginfty(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_neginfty(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_is_neginfty(qp->upoly) : -1;
+	return qp ? isl_poly_is_neginfty(qp->poly) : isl_bool_error;
 }
 
 int isl_qpolynomial_sgn(__isl_keep isl_qpolynomial *qp)
 {
-	return qp ? isl_upoly_sgn(qp->upoly) : 0;
+	return qp ? isl_poly_sgn(qp->poly) : 0;
 }
 
-static void upoly_free_cst(__isl_take struct isl_upoly_cst *cst)
+static void poly_free_cst(__isl_take isl_poly_cst *cst)
 {
 	isl_int_clear(cst->n);
 	isl_int_clear(cst->d);
 }
 
-static void upoly_free_rec(__isl_take struct isl_upoly_rec *rec)
+static void poly_free_rec(__isl_take isl_poly_rec *rec)
 {
 	int i;
 
 	for (i = 0; i < rec->n; ++i)
-		isl_upoly_free(rec->pi);
+		isl_poly_free(rec->pi);
 }
 
-__isl_give struct isl_upoly *isl_upoly_copy(__isl_keep struct isl_upoly *up)
+__isl_give isl_poly *isl_poly_copy(__isl_keep isl_poly *poly)
 {
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	up->ref++;
-	return up;
+	poly->ref++;
+	return poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_dup_cst(__isl_keep struct isl_upoly *up)
+__isl_give isl_poly *isl_poly_dup_cst(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
-	struct isl_upoly_cst *dup;
+	isl_poly_cst *cst;
+	isl_poly_cst *dup;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
 		return NULL;
 
-	dup = isl_upoly_as_cst(isl_upoly_zero(up->ctx));
+	dup = isl_poly_as_cst(isl_poly_zero(poly->ctx));
 	if (!dup)
 		return NULL;
 	isl_int_set(dup->n, cst->n);
 	isl_int_set(dup->d, cst->d);
 
-	return &dup->up;
+	return &dup->poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_dup_rec(__isl_keep struct isl_upoly *up)
+__isl_give isl_poly *isl_poly_dup_rec(__isl_keep isl_poly *poly)
 {
 	int i;
-	struct isl_upoly_rec *rec;
-	struct isl_upoly_rec *dup;
+	isl_poly_rec *rec;
+	isl_poly_rec *dup;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		return NULL;
 
-	dup = isl_upoly_alloc_rec(up->ctx, up->var, rec->n);
+	dup = isl_poly_alloc_rec(poly->ctx, poly->var, rec->n);
 	if (!dup)
 		return NULL;
 
 	for (i = 0; i < rec->n; ++i) {
-		dup->pi = isl_upoly_copy(rec->pi);
+		dup->pi = isl_poly_copy(rec->pi);
 		if (!dup->pi)
 			goto error;
 		dup->n++;
 	}
 
-	return &dup->up;
+	return &dup->poly;
 error:
-	isl_upoly_free(&dup->up);
+	isl_poly_free(&dup->poly);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_dup(__isl_keep struct isl_upoly *up)
+__isl_give isl_poly *isl_poly_dup(__isl_keep isl_poly *poly)
 {
-	if (!up)
-		return NULL;
+	isl_bool is_cst;
 
-	if (isl_upoly_is_cst(up))
-		return isl_upoly_dup_cst(up);
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return NULL;
+	if (is_cst)
+		return isl_poly_dup_cst(poly);
 	else
-		return isl_upoly_dup_rec(up);
+		return isl_poly_dup_rec(poly);
 }
 
-__isl_give struct isl_upoly *isl_upoly_cow(__isl_take struct isl_upoly *up)
+__isl_give isl_poly *isl_poly_cow(__isl_take isl_poly *poly)
 {
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	if (up->ref == 1)
-		return up;
-	up->ref--;
-	return isl_upoly_dup(up);
+	if (poly->ref == 1)
+		return poly;
+	poly->ref--;
+	return isl_poly_dup(poly);
 }
 
-void isl_upoly_free(__isl_take struct isl_upoly *up)
+__isl_null isl_poly *isl_poly_free(__isl_take isl_poly *poly)
 {
-	if (!up)
-		return;
+	if (!poly)
+		return NULL;
 
-	if (--up->ref > 0)
-		return;
+	if (--poly->ref > 0)
+		return NULL;
 
-	if (up->var < 0)
-		upoly_free_cst((struct isl_upoly_cst *)up);
+	if (poly->var < 0)
+		poly_free_cst((isl_poly_cst *) poly);
 	else
-		upoly_free_rec((struct isl_upoly_rec *)up);
+		poly_free_rec((isl_poly_rec *) poly);
 
-	isl_ctx_deref(up->ctx);
-	free(up);
+	isl_ctx_deref(poly->ctx);
+	free(poly);
+	return NULL;
 }
 
-static void isl_upoly_cst_reduce(__isl_keep struct isl_upoly_cst *cst)
+static void isl_poly_cst_reduce(__isl_keep isl_poly_cst *cst)
 {
 	isl_int gcd;
 
@@ -562,18 +745,18 @@
 	isl_int_clear(gcd);
 }
 
-__isl_give struct isl_upoly *isl_upoly_sum_cst(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2)
+__isl_give isl_poly *isl_poly_sum_cst(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2)
 {
-	struct isl_upoly_cst *cst1;
-	struct isl_upoly_cst *cst2;
+	isl_poly_cst *cst1;
+	isl_poly_cst *cst2;
 
-	up1 = isl_upoly_cow(up1);
-	if (!up1 || !up2)
+	poly1 = isl_poly_cow(poly1);
+	if (!poly1 || !poly2)
 		goto error;
 
-	cst1 = isl_upoly_as_cst(up1);
-	cst2 = isl_upoly_as_cst(up2);
+	cst1 = isl_poly_as_cst(poly1);
+	cst2 = isl_poly_as_cst(poly2);
 
 	if (isl_int_eq(cst1->d, cst2->d))
 		isl_int_add(cst1->n, cst1->n, cst2->n);
@@ -583,489 +766,554 @@
 		isl_int_mul(cst1->d, cst1->d, cst2->d);
 	}
 
-	isl_upoly_cst_reduce(cst1);
+	isl_poly_cst_reduce(cst1);
 
-	isl_upoly_free(up2);
-	return up1;
+	isl_poly_free(poly2);
+	return poly1;
 error:
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
 	return NULL;
 }
 
-static __isl_give struct isl_upoly *replace_by_zero(
-	__isl_take struct isl_upoly *up)
+static __isl_give isl_poly *replace_by_zero(__isl_take isl_poly *poly)
 {
 	struct isl_ctx *ctx;
 
-	if (!up)
+	if (!poly)
 		return NULL;
-	ctx = up->ctx;
-	isl_upoly_free(up);
-	return isl_upoly_zero(ctx);
+	ctx = poly->ctx;
+	isl_poly_free(poly);
+	return isl_poly_zero(ctx);
 }
 
-static __isl_give struct isl_upoly *replace_by_constant_term(
-	__isl_take struct isl_upoly *up)
+static __isl_give isl_poly *replace_by_constant_term(__isl_take isl_poly *poly)
 {
-	struct isl_upoly_rec *rec;
-	struct isl_upoly *cst;
+	isl_poly_rec *rec;
+	isl_poly *cst;
 
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
-	cst = isl_upoly_copy(rec->p0);
-	isl_upoly_free(up);
+	cst = isl_poly_copy(rec->p0);
+	isl_poly_free(poly);
 	return cst;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_sum(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2)
+__isl_give isl_poly *isl_poly_sum(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2)
 {
 	int i;
-	struct isl_upoly_rec *rec1, *rec2;
+	isl_bool is_zero, is_nan, is_cst;
+	isl_poly_rec *rec1, *rec2;
 
-	if (!up1 || !up2)
+	if (!poly1 || !poly2)
 		goto error;
 
-	if (isl_upoly_is_nan(up1)) {
-		isl_upoly_free(up2);
-		return up1;
+	is_nan = isl_poly_is_nan(poly1);
+	if (is_nan < 0)
+		goto error;
+	if (is_nan) {
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (isl_upoly_is_nan(up2)) {
-		isl_upoly_free(up1);
-		return up2;
+	is_nan = isl_poly_is_nan(poly2);
+	if (is_nan < 0)
+		goto error;
+	if (is_nan) {
+		isl_poly_free(poly1);
+		return poly2;
 	}
 
-	if (isl_upoly_is_zero(up1)) {
-		isl_upoly_free(up1);
-		return up2;
+	is_zero = isl_poly_is_zero(poly1);
+	if (is_zero < 0)
+		goto error;
+	if (is_zero) {
+		isl_poly_free(poly1);
+		return poly2;
 	}
 
-	if (isl_upoly_is_zero(up2)) {
-		isl_upoly_free(up2);
-		return up1;
+	is_zero = isl_poly_is_zero(poly2);
+	if (is_zero < 0)
+		goto error;
+	if (is_zero) {
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (up1->var < up2->var)
-		return isl_upoly_sum(up2, up1);
+	if (poly1->var < poly2->var)
+		return isl_poly_sum(poly2, poly1);
 
-	if (up2->var < up1->var) {
-		struct isl_upoly_rec *rec;
-		if (isl_upoly_is_infty(up2) || isl_upoly_is_neginfty(up2)) {
-			isl_upoly_free(up1);
-			return up2;
+	if (poly2->var < poly1->var) {
+		isl_poly_rec *rec;
+		isl_bool is_infty;
+
+		is_infty = isl_poly_is_infty(poly2);
+		if (is_infty >= 0 && !is_infty)
+			is_infty = isl_poly_is_neginfty(poly2);
+		if (is_infty < 0)
+			goto error;
+		if (is_infty) {
+			isl_poly_free(poly1);
+			return poly2;
 		}
-		up1 = isl_upoly_cow(up1);
-		rec = isl_upoly_as_rec(up1);
+		poly1 = isl_poly_cow(poly1);
+		rec = isl_poly_as_rec(poly1);
 		if (!rec)
 			goto error;
-		rec->p0 = isl_upoly_sum(rec->p0, up2);
+		rec->p0 = isl_poly_sum(rec->p0, poly2);
 		if (rec->n == 1)
-			up1 = replace_by_constant_term(up1);
-		return up1;
+			poly1 = replace_by_constant_term(poly1);
+		return poly1;
 	}
 
-	if (isl_upoly_is_cst(up1))
-		return isl_upoly_sum_cst(up1, up2);
+	is_cst = isl_poly_is_cst(poly1);
+	if (is_cst < 0)
+		goto error;
+	if (is_cst)
+		return isl_poly_sum_cst(poly1, poly2);
 
-	rec1 = isl_upoly_as_rec(up1);
-	rec2 = isl_upoly_as_rec(up2);
+	rec1 = isl_poly_as_rec(poly1);
+	rec2 = isl_poly_as_rec(poly2);
 	if (!rec1 || !rec2)
 		goto error;
 
 	if (rec1->n < rec2->n)
-		return isl_upoly_sum(up2, up1);
+		return isl_poly_sum(poly2, poly1);
 
-	up1 = isl_upoly_cow(up1);
-	rec1 = isl_upoly_as_rec(up1);
+	poly1 = isl_poly_cow(poly1);
+	rec1 = isl_poly_as_rec(poly1);
 	if (!rec1)
 		goto error;
 
 	for (i = rec2->n - 1; i >= 0; --i) {
-		rec1->pi = isl_upoly_sum(rec1->pi,
-					    isl_upoly_copy(rec2->pi));
+		isl_bool is_zero;
+
+		rec1->pi = isl_poly_sum(rec1->pi,
+					    isl_poly_copy(rec2->pi));
 		if (!rec1->pi)
 			goto error;
-		if (i == rec1->n - 1 && isl_upoly_is_zero(rec1->pi)) {
-			isl_upoly_free(rec1->pi);
+		if (i != rec1->n - 1)
+			continue;
+		is_zero = isl_poly_is_zero(rec1->pi);
+		if (is_zero < 0)
+			goto error;
+		if (is_zero) {
+			isl_poly_free(rec1->pi);
 			rec1->n--;
 		}
 	}
 
 	if (rec1->n == 0)
-		up1 = replace_by_zero(up1);
+		poly1 = replace_by_zero(poly1);
 	else if (rec1->n == 1)
-		up1 = replace_by_constant_term(up1);
+		poly1 = replace_by_constant_term(poly1);
 
-	isl_upoly_free(up2);
+	isl_poly_free(poly2);
 
-	return up1;
+	return poly1;
 error:
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_cst_add_isl_int(
-	__isl_take struct isl_upoly *up, isl_int v)
+__isl_give isl_poly *isl_poly_cst_add_isl_int(__isl_take isl_poly *poly,
+	isl_int v)
 {
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	up = isl_upoly_cow(up);
-	if (!up)
+	poly = isl_poly_cow(poly);
+	if (!poly)
 		return NULL;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 
 	isl_int_addmul(cst->n, cst->d, v);
 
-	return up;
+	return poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_add_isl_int(
-	__isl_take struct isl_upoly *up, isl_int v)
+__isl_give isl_poly *isl_poly_add_isl_int(__isl_take isl_poly *poly, isl_int v)
 {
-	struct isl_upoly_rec *rec;
-
-	if (!up)
-		return NULL;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (isl_upoly_is_cst(up))
-		return isl_upoly_cst_add_isl_int(up, v);
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return isl_poly_cst_add_isl_int(poly, v);
 
-	up = isl_upoly_cow(up);
-	rec = isl_upoly_as_rec(up);
+	poly = isl_poly_cow(poly);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
-	rec->p0 = isl_upoly_add_isl_int(rec->p0, v);
+	rec->p0 = isl_poly_add_isl_int(rec->p0, v);
 	if (!rec->p0)
 		goto error;
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_cst_mul_isl_int(
-	__isl_take struct isl_upoly *up, isl_int v)
+__isl_give isl_poly *isl_poly_cst_mul_isl_int(__isl_take isl_poly *poly,
+	isl_int v)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_zero;
+	isl_poly_cst *cst;
 
-	if (isl_upoly_is_zero(up))
-		return up;
+	is_zero = isl_poly_is_zero(poly);
+	if (is_zero < 0)
+		return isl_poly_free(poly);
+	if (is_zero)
+		return poly;
 
-	up = isl_upoly_cow(up);
-	if (!up)
+	poly = isl_poly_cow(poly);
+	if (!poly)
 		return NULL;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 
 	isl_int_mul(cst->n, cst->n, v);
 
-	return up;
+	return poly;
 }
 
-__isl_give struct isl_upoly *isl_upoly_mul_isl_int(
-	__isl_take struct isl_upoly *up, isl_int v)
+__isl_give isl_poly *isl_poly_mul_isl_int(__isl_take isl_poly *poly, isl_int v)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (!up)
-		return NULL;
-
-	if (isl_upoly_is_cst(up))
-		return isl_upoly_cst_mul_isl_int(up, v);
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return isl_poly_cst_mul_isl_int(poly, v);
 
-	up = isl_upoly_cow(up);
-	rec = isl_upoly_as_rec(up);
+	poly = isl_poly_cow(poly);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
 	for (i = 0; i < rec->n; ++i) {
-		rec->pi = isl_upoly_mul_isl_int(rec->pi, v);
+		rec->pi = isl_poly_mul_isl_int(rec->pi, v);
 		if (!rec->pi)
 			goto error;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
-/* Multiply the constant polynomial "up" by "v".
+/* Multiply the constant polynomial "poly" by "v".
  */
-static __isl_give struct isl_upoly *isl_upoly_cst_scale_val(
-	__isl_take struct isl_upoly *up, __isl_keep isl_val *v)
+static __isl_give isl_poly *isl_poly_cst_scale_val(__isl_take isl_poly *poly,
+	__isl_keep isl_val *v)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_zero;
+	isl_poly_cst *cst;
 
-	if (isl_upoly_is_zero(up))
-		return up;
+	is_zero = isl_poly_is_zero(poly);
+	if (is_zero < 0)
+		return isl_poly_free(poly);
+	if (is_zero)
+		return poly;
 
-	up = isl_upoly_cow(up);
-	if (!up)
+	poly = isl_poly_cow(poly);
+	if (!poly)
 		return NULL;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 
 	isl_int_mul(cst->n, cst->n, v->n);
 	isl_int_mul(cst->d, cst->d, v->d);
-	isl_upoly_cst_reduce(cst);
+	isl_poly_cst_reduce(cst);
 
-	return up;
+	return poly;
 }
 
-/* Multiply the polynomial "up" by "v".
+/* Multiply the polynomial "poly" by "v".
  */
-static __isl_give struct isl_upoly *isl_upoly_scale_val(
-	__isl_take struct isl_upoly *up, __isl_keep isl_val *v)
+static __isl_give isl_poly *isl_poly_scale_val(__isl_take isl_poly *poly,
+	__isl_keep isl_val *v)
 {
 	int i;
-	struct isl_upoly_rec *rec;
-
-	if (!up)
-		return NULL;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (isl_upoly_is_cst(up))
-		return isl_upoly_cst_scale_val(up, v);
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return isl_poly_cst_scale_val(poly, v);
 
-	up = isl_upoly_cow(up);
-	rec = isl_upoly_as_rec(up);
+	poly = isl_poly_cow(poly);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
 	for (i = 0; i < rec->n; ++i) {
-		rec->pi = isl_upoly_scale_val(rec->pi, v);
+		rec->pi = isl_poly_scale_val(rec->pi, v);
 		if (!rec->pi)
 			goto error;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_mul_cst(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2)
+__isl_give isl_poly *isl_poly_mul_cst(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2)
 {
-	struct isl_upoly_cst *cst1;
-	struct isl_upoly_cst *cst2;
+	isl_poly_cst *cst1;
+	isl_poly_cst *cst2;
 
-	up1 = isl_upoly_cow(up1);
-	if (!up1 || !up2)
+	poly1 = isl_poly_cow(poly1);
+	if (!poly1 || !poly2)
 		goto error;
 
-	cst1 = isl_upoly_as_cst(up1);
-	cst2 = isl_upoly_as_cst(up2);
+	cst1 = isl_poly_as_cst(poly1);
+	cst2 = isl_poly_as_cst(poly2);
 
 	isl_int_mul(cst1->n, cst1->n, cst2->n);
 	isl_int_mul(cst1->d, cst1->d, cst2->d);
 
-	isl_upoly_cst_reduce(cst1);
+	isl_poly_cst_reduce(cst1);
 
-	isl_upoly_free(up2);
-	return up1;
+	isl_poly_free(poly2);
+	return poly1;
 error:
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_mul_rec(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2)
+__isl_give isl_poly *isl_poly_mul_rec(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2)
 {
-	struct isl_upoly_rec *rec1;
-	struct isl_upoly_rec *rec2;
-	struct isl_upoly_rec *res = NULL;
+	isl_poly_rec *rec1;
+	isl_poly_rec *rec2;
+	isl_poly_rec *res = NULL;
 	int i, j;
 	int size;
 
-	rec1 = isl_upoly_as_rec(up1);
-	rec2 = isl_upoly_as_rec(up2);
+	rec1 = isl_poly_as_rec(poly1);
+	rec2 = isl_poly_as_rec(poly2);
 	if (!rec1 || !rec2)
 		goto error;
 	size = rec1->n + rec2->n - 1;
-	res = isl_upoly_alloc_rec(up1->ctx, up1->var, size);
+	res = isl_poly_alloc_rec(poly1->ctx, poly1->var, size);
 	if (!res)
 		goto error;
 
 	for (i = 0; i < rec1->n; ++i) {
-		res->pi = isl_upoly_mul(isl_upoly_copy(rec2->p0),
-					    isl_upoly_copy(rec1->pi));
+		res->pi = isl_poly_mul(isl_poly_copy(rec2->p0),
+					    isl_poly_copy(rec1->pi));
 		if (!res->pi)
 			goto error;
 		res->n++;
 	}
 	for (; i < size; ++i) {
-		res->pi = isl_upoly_zero(up1->ctx);
+		res->pi = isl_poly_zero(poly1->ctx);
 		if (!res->pi)
 			goto error;
 		res->n++;
 	}
 	for (i = 0; i < rec1->n; ++i) {
 		for (j = 1; j < rec2->n; ++j) {
-			struct isl_upoly *up;
-			up = isl_upoly_mul(isl_upoly_copy(rec2->pj),
-					    isl_upoly_copy(rec1->pi));
-			res->pi + j = isl_upoly_sum(res->pi + j, up);
+			isl_poly *poly;
+			poly = isl_poly_mul(isl_poly_copy(rec2->pj),
+					    isl_poly_copy(rec1->pi));
+			res->pi + j = isl_poly_sum(res->pi + j, poly);
 			if (!res->pi + j)
 				goto error;
 		}
 	}
 
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
 
-	return &res->up;
+	return &res->poly;
 error:
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
-	isl_upoly_free(&res->up);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
+	isl_poly_free(&res->poly);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_mul(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2)
+__isl_give isl_poly *isl_poly_mul(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2)
 {
-	if (!up1 || !up2)
+	isl_bool is_zero, is_nan, is_one, is_cst;
+
+	if (!poly1 || !poly2)
 		goto error;
 
-	if (isl_upoly_is_nan(up1)) {
-		isl_upoly_free(up2);
-		return up1;
+	is_nan = isl_poly_is_nan(poly1);
+	if (is_nan < 0)
+		goto error;
+	if (is_nan) {
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (isl_upoly_is_nan(up2)) {
-		isl_upoly_free(up1);
-		return up2;
+	is_nan = isl_poly_is_nan(poly2);
+	if (is_nan < 0)
+		goto error;
+	if (is_nan) {
+		isl_poly_free(poly1);
+		return poly2;
 	}
 
-	if (isl_upoly_is_zero(up1)) {
-		isl_upoly_free(up2);
-		return up1;
+	is_zero = isl_poly_is_zero(poly1);
+	if (is_zero < 0)
+		goto error;
+	if (is_zero) {
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (isl_upoly_is_zero(up2)) {
-		isl_upoly_free(up1);
-		return up2;
+	is_zero = isl_poly_is_zero(poly2);
+	if (is_zero < 0)
+		goto error;
+	if (is_zero) {
+		isl_poly_free(poly1);
+		return poly2;
 	}
 
-	if (isl_upoly_is_one(up1)) {
-		isl_upoly_free(up1);
-		return up2;
+	is_one = isl_poly_is_one(poly1);
+	if (is_one < 0)
+		goto error;
+	if (is_one) {
+		isl_poly_free(poly1);
+		return poly2;
 	}
 
-	if (isl_upoly_is_one(up2)) {
-		isl_upoly_free(up2);
-		return up1;
+	is_one = isl_poly_is_one(poly2);
+	if (is_one < 0)
+		goto error;
+	if (is_one) {
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (up1->var < up2->var)
-		return isl_upoly_mul(up2, up1);
+	if (poly1->var < poly2->var)
+		return isl_poly_mul(poly2, poly1);
 
-	if (up2->var < up1->var) {
+	if (poly2->var < poly1->var) {
 		int i;
-		struct isl_upoly_rec *rec;
-		if (isl_upoly_is_infty(up2) || isl_upoly_is_neginfty(up2)) {
-			isl_ctx *ctx = up1->ctx;
-			isl_upoly_free(up1);
-			isl_upoly_free(up2);
-			return isl_upoly_nan(ctx);
+		isl_poly_rec *rec;
+		isl_bool is_infty;
+
+		is_infty = isl_poly_is_infty(poly2);
+		if (is_infty >= 0 && !is_infty)
+			is_infty = isl_poly_is_neginfty(poly2);
+		if (is_infty < 0)
+			goto error;
+		if (is_infty) {
+			isl_ctx *ctx = poly1->ctx;
+			isl_poly_free(poly1);
+			isl_poly_free(poly2);
+			return isl_poly_nan(ctx);
 		}
-		up1 = isl_upoly_cow(up1);
-		rec = isl_upoly_as_rec(up1);
+		poly1 = isl_poly_cow(poly1);
+		rec = isl_poly_as_rec(poly1);
 		if (!rec)
 			goto error;
 
 		for (i = 0; i < rec->n; ++i) {
-			rec->pi = isl_upoly_mul(rec->pi,
-						    isl_upoly_copy(up2));
+			rec->pi = isl_poly_mul(rec->pi,
+						isl_poly_copy(poly2));
 			if (!rec->pi)
 				goto error;
 		}
-		isl_upoly_free(up2);
-		return up1;
+		isl_poly_free(poly2);
+		return poly1;
 	}
 
-	if (isl_upoly_is_cst(up1))
-		return isl_upoly_mul_cst(up1, up2);
+	is_cst = isl_poly_is_cst(poly1);
+	if (is_cst < 0)
+		goto error;
+	if (is_cst)
+		return isl_poly_mul_cst(poly1, poly2);
 
-	return isl_upoly_mul_rec(up1, up2);
+	return isl_poly_mul_rec(poly1, poly2);
 error:
-	isl_upoly_free(up1);
-	isl_upoly_free(up2);
+	isl_poly_free(poly1);
+	isl_poly_free(poly2);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_pow(__isl_take struct isl_upoly *up,
-	unsigned power)
+__isl_give isl_poly *isl_poly_pow(__isl_take isl_poly *poly, unsigned power)
 {
-	struct isl_upoly *res;
+	isl_poly *res;
 
-	if (!up)
+	if (!poly)
 		return NULL;
 	if (power == 1)
-		return up;
+		return poly;
 
 	if (power % 2)
-		res = isl_upoly_copy(up);
+		res = isl_poly_copy(poly);
 	else
-		res = isl_upoly_one(up->ctx);
+		res = isl_poly_one(poly->ctx);
 
 	while (power >>= 1) {
-		up = isl_upoly_mul(up, isl_upoly_copy(up));
+		poly = isl_poly_mul(poly, isl_poly_copy(poly));
 		if (power % 2)
-			res = isl_upoly_mul(res, isl_upoly_copy(up));
+			res = isl_poly_mul(res, isl_poly_copy(poly));
 	}
 
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return res;
 }
 
-__isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *dim,
-	unsigned n_div, __isl_take struct isl_upoly *up)
+__isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *space,
+	unsigned n_div, __isl_take isl_poly *poly)
 {
 	struct isl_qpolynomial *qp = NULL;
-	unsigned total;
+	isl_size total;
 
-	if (!dim || !up)
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0 || !poly)
 		goto error;
 
-	if (!isl_space_is_set(dim))
-		isl_die(isl_space_get_ctx(dim), isl_error_invalid,
+	if (!isl_space_is_set(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
 			"domain of polynomial should be a set", goto error);
 
-	total = isl_space_dim(dim, isl_dim_all);
-
-	qp = isl_calloc_type(dim->ctx, struct isl_qpolynomial);
+	qp = isl_calloc_type(space->ctx, struct isl_qpolynomial);
 	if (!qp)
 		goto error;
 
 	qp->ref = 1;
-	qp->div = isl_mat_alloc(dim->ctx, n_div, 1 + 1 + total + n_div);
+	qp->div = isl_mat_alloc(space->ctx, n_div, 1 + 1 + total + n_div);
 	if (!qp->div)
 		goto error;
 
-	qp->dim = dim;
-	qp->upoly = up;
+	qp->dim = space;
+	qp->poly = poly;
 
 	return qp;
 error:
-	isl_space_free(dim);
-	isl_upoly_free(up);
+	isl_space_free(space);
+	isl_poly_free(poly);
 	isl_qpolynomial_free(qp);
 	return NULL;
 }
@@ -1087,7 +1335,7 @@
 		return NULL;
 
 	dup = isl_qpolynomial_alloc(isl_space_copy(qp->dim), qp->div->n_row,
-				    isl_upoly_copy(qp->upoly));
+				    isl_poly_copy(qp->poly));
 	if (!dup)
 		return NULL;
 	isl_mat_free(dup->div);
@@ -1123,79 +1371,84 @@
 
 	isl_space_free(qp->dim);
 	isl_mat_free(qp->div);
-	isl_upoly_free(qp->upoly);
+	isl_poly_free(qp->poly);
 
 	free(qp);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_var_pow(isl_ctx *ctx, int pos, int power)
+__isl_give isl_poly *isl_poly_var_pow(isl_ctx *ctx, int pos, int power)
 {
 	int i;
-	struct isl_upoly_rec *rec;
-	struct isl_upoly_cst *cst;
+	isl_poly_rec *rec;
+	isl_poly_cst *cst;
 
-	rec = isl_upoly_alloc_rec(ctx, pos, 1 + power);
+	rec = isl_poly_alloc_rec(ctx, pos, 1 + power);
 	if (!rec)
 		return NULL;
 	for (i = 0; i < 1 + power; ++i) {
-		rec->pi = isl_upoly_zero(ctx);
+		rec->pi = isl_poly_zero(ctx);
 		if (!rec->pi)
 			goto error;
 		rec->n++;
 	}
-	cst = isl_upoly_as_cst(rec->ppower);
+	cst = isl_poly_as_cst(rec->ppower);
 	isl_int_set_si(cst->n, 1);
 
-	return &rec->up;
+	return &rec->poly;
 error:
-	isl_upoly_free(&rec->up);
+	isl_poly_free(&rec->poly);
 	return NULL;
 }
 
 /* r array maps original positions to new positions.
  */
-static __isl_give struct isl_upoly *reorder(__isl_take struct isl_upoly *up,
-	int *r)
+static __isl_give isl_poly *reorder(__isl_take isl_poly *poly, int *r)
 {
 	int i;
-	struct isl_upoly_rec *rec;
-	struct isl_upoly *base;
-	struct isl_upoly *res;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
+	isl_poly *base;
+	isl_poly *res;
 
-	if (isl_upoly_is_cst(up))
-		return up;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return poly;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
-	isl_assert(up->ctx, rec->n >= 1, goto error);
+	isl_assert(poly->ctx, rec->n >= 1, goto error);
 
-	base = isl_upoly_var_pow(up->ctx, rup->var, 1);
-	res = reorder(isl_upoly_copy(rec->prec->n - 1), r);
+	base = isl_poly_var_pow(poly->ctx, rpoly->var, 1);
+	res = reorder(isl_poly_copy(rec->prec->n - 1), r);
 
 	for (i = rec->n - 2; i >= 0; --i) {
-		res = isl_upoly_mul(res, isl_upoly_copy(base));
-		res = isl_upoly_sum(res, reorder(isl_upoly_copy(rec->pi), r));
+		res = isl_poly_mul(res, isl_poly_copy(base));
+		res = isl_poly_sum(res, reorder(isl_poly_copy(rec->pi), r));
 	}
 
-	isl_upoly_free(base);
-	isl_upoly_free(up);
+	isl_poly_free(base);
+	isl_poly_free(poly);
 
 	return res;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
-static int compatible_divs(__isl_keep isl_mat *div1, __isl_keep isl_mat *div2)
+static isl_bool compatible_divs(__isl_keep isl_mat *div1,
+	__isl_keep isl_mat *div2)
 {
 	int n_row, n_col;
-	int equal;
+	isl_bool equal;
 
 	isl_assert(div1->ctx, div1->n_row >= div2->n_row &&
-				div1->n_col >= div2->n_col, return -1);
+				div1->n_col >= div2->n_col,
+		    return isl_bool_error);
 
 	if (div1->n_row == div2->n_row)
 		return isl_mat_is_equal(div1, div2);
@@ -1250,14 +1503,16 @@
 	struct isl_div_sort_info *array = NULL;
 	int *pos = NULL, *at = NULL;
 	int *reordering = NULL;
-	unsigned div_pos;
+	isl_size div_pos;
 
 	if (!qp)
 		return NULL;
 	if (qp->div->n_row <= 1)
 		return qp;
 
-	div_pos = isl_space_dim(qp->dim, isl_dim_all);
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		return isl_qpolynomial_free(qp);
 
 	array = isl_alloc_array(qp->div->ctx, struct isl_div_sort_info,
 				qp->div->n_row);
@@ -1306,9 +1561,9 @@
 		reorderingdiv_pos + arrayi.row = div_pos + i - skip;
 	}
 
-	qp->upoly = reorder(qp->upoly, reordering);
+	qp->poly = reorder(qp->poly, reordering);
 
-	if (!qp->upoly || !qp->div)
+	if (!qp->poly || !qp->div)
 		goto error;
 
 	free(at);
@@ -1326,28 +1581,32 @@
 	return NULL;
 }
 
-static __isl_give struct isl_upoly *expand(__isl_take struct isl_upoly *up,
-	int *exp, int first)
+static __isl_give isl_poly *expand(__isl_take isl_poly *poly, int *exp,
+	int first)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (isl_upoly_is_cst(up))
-		return up;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return poly;
 
-	if (up->var < first)
-		return up;
+	if (poly->var < first)
+		return poly;
 
-	if (expup->var - first == up->var - first)
-		return up;
+	if (exppoly->var - first == poly->var - first)
+		return poly;
 
-	up = isl_upoly_cow(up);
-	if (!up)
+	poly = isl_poly_cow(poly);
+	if (!poly)
 		goto error;
 
-	up->var = expup->var - first + first;
+	poly->var = exppoly->var - first + first;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
@@ -1357,9 +1616,9 @@
 			goto error;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
@@ -1398,10 +1657,10 @@
 	isl_mat_free(qp2->div);
 	qp2->div = isl_mat_copy(div);
 
-	qp1->upoly = expand(qp1->upoly, exp1, div->n_col - div->n_row - 2);
-	qp2->upoly = expand(qp2->upoly, exp2, div->n_col - div->n_row - 2);
+	qp1->poly = expand(qp1->poly, exp1, div->n_col - div->n_row - 2);
+	qp2->poly = expand(qp2->poly, exp2, div->n_col - div->n_row - 2);
 
-	if (!qp1->upoly || !qp2->upoly)
+	if (!qp1->poly || !qp2->poly)
 		goto error;
 
 	isl_mat_free(div);
@@ -1421,20 +1680,24 @@
 __isl_give isl_qpolynomial *isl_qpolynomial_add(__isl_take isl_qpolynomial *qp1,
 	__isl_take isl_qpolynomial *qp2)
 {
+	isl_bool compatible;
+
 	qp1 = isl_qpolynomial_cow(qp1);
 
-	if (!qp1 || !qp2)
+	if (isl_qpolynomial_check_equal_space(qp1, qp2) < 0)
 		goto error;
 
 	if (qp1->div->n_row < qp2->div->n_row)
 		return isl_qpolynomial_add(qp2, qp1);
 
-	isl_assert(qp1->dim->ctx, isl_space_is_equal(qp1->dim, qp2->dim), goto error);
-	if (!compatible_divs(qp1->div, qp2->div))
+	compatible = compatible_divs(qp1->div, qp2->div);
+	if (compatible < 0)
+		goto error;
+	if (!compatible)
 		return with_merged_divs(isl_qpolynomial_add, qp1, qp2);
 
-	qp1->upoly = isl_upoly_sum(qp1->upoly, isl_upoly_copy(qp2->upoly));
-	if (!qp1->upoly)
+	qp1->poly = isl_poly_sum(qp1->poly, isl_poly_copy(qp2->poly));
+	if (!qp1->poly)
 		goto error;
 
 	isl_qpolynomial_free(qp2);
@@ -1472,8 +1735,8 @@
 	if (!qp)
 		return NULL;
 
-	qp->upoly = isl_upoly_add_isl_int(qp->upoly, v);
-	if (!qp->upoly)
+	qp->poly = isl_poly_add_isl_int(qp->poly, v);
+	if (!qp->poly)
 		goto error;
 
 	return qp;
@@ -1508,8 +1771,8 @@
 	if (!qp)
 		return NULL;
 
-	qp->upoly = isl_upoly_mul_isl_int(qp->upoly, v);
-	if (!qp->upoly)
+	qp->poly = isl_poly_mul_isl_int(qp->poly, v);
+	if (!qp->poly)
 		goto error;
 
 	return qp;
@@ -1554,8 +1817,8 @@
 	if (!qp)
 		goto error;
 
-	qp->upoly = isl_upoly_scale_val(qp->upoly, v);
-	if (!qp->upoly)
+	qp->poly = isl_poly_scale_val(qp->poly, v);
+	if (!qp->poly)
 		qp = isl_qpolynomial_free(qp);
 
 	isl_val_free(v);
@@ -1566,23 +1829,49 @@
 	return NULL;
 }
 
+/* Divide "qp" by "v".
+ */
+__isl_give isl_qpolynomial *isl_qpolynomial_scale_down_val(
+	__isl_take isl_qpolynomial *qp, __isl_take isl_val *v)
+{
+	if (!qp || !v)
+		goto error;
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_qpolynomial_get_ctx(qp), isl_error_invalid,
+			"expecting rational factor", goto error);
+	if (isl_val_is_zero(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"cannot scale down by zero", goto error);
+
+	return isl_qpolynomial_scale_val(qp, isl_val_inv(v));
+error:
+	isl_val_free(v);
+	isl_qpolynomial_free(qp);
+	return NULL;
+}
+
 __isl_give isl_qpolynomial *isl_qpolynomial_mul(__isl_take isl_qpolynomial *qp1,
 	__isl_take isl_qpolynomial *qp2)
 {
+	isl_bool compatible;
+
 	qp1 = isl_qpolynomial_cow(qp1);
 
-	if (!qp1 || !qp2)
+	if (isl_qpolynomial_check_equal_space(qp1, qp2) < 0)
 		goto error;
 
 	if (qp1->div->n_row < qp2->div->n_row)
 		return isl_qpolynomial_mul(qp2, qp1);
 
-	isl_assert(qp1->dim->ctx, isl_space_is_equal(qp1->dim, qp2->dim), goto error);
-	if (!compatible_divs(qp1->div, qp2->div))
+	compatible = compatible_divs(qp1->div, qp2->div);
+	if (compatible < 0)
+		goto error;
+	if (!compatible)
 		return with_merged_divs(isl_qpolynomial_mul, qp1, qp2);
 
-	qp1->upoly = isl_upoly_mul(qp1->upoly, isl_upoly_copy(qp2->upoly));
-	if (!qp1->upoly)
+	qp1->poly = isl_poly_mul(qp1->poly, isl_poly_copy(qp2->poly));
+	if (!qp1->poly)
 		goto error;
 
 	isl_qpolynomial_free(qp2);
@@ -1602,8 +1891,8 @@
 	if (!qp)
 		return NULL;
 
-	qp->upoly = isl_upoly_pow(qp->upoly, power);
-	if (!qp->upoly)
+	qp->poly = isl_poly_pow(qp->poly, power);
+	if (!qp->poly)
 		goto error;
 
 	return qp;
@@ -1634,111 +1923,112 @@
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_zero_on_domain(
-	__isl_take isl_space *dim)
+	__isl_take isl_space *domain)
 {
-	if (!dim)
+	if (!domain)
 		return NULL;
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_zero(dim->ctx));
+	return isl_qpolynomial_alloc(domain, 0, isl_poly_zero(domain->ctx));
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_one_on_domain(
-	__isl_take isl_space *dim)
+	__isl_take isl_space *domain)
 {
-	if (!dim)
+	if (!domain)
 		return NULL;
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_one(dim->ctx));
+	return isl_qpolynomial_alloc(domain, 0, isl_poly_one(domain->ctx));
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_infty_on_domain(
-	__isl_take isl_space *dim)
+	__isl_take isl_space *domain)
 {
-	if (!dim)
+	if (!domain)
 		return NULL;
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_infty(dim->ctx));
+	return isl_qpolynomial_alloc(domain, 0, isl_poly_infty(domain->ctx));
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_neginfty_on_domain(
-	__isl_take isl_space *dim)
+	__isl_take isl_space *domain)
 {
-	if (!dim)
+	if (!domain)
 		return NULL;
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_neginfty(dim->ctx));
+	return isl_qpolynomial_alloc(domain, 0, isl_poly_neginfty(domain->ctx));
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_nan_on_domain(
-	__isl_take isl_space *dim)
+	__isl_take isl_space *domain)
 {
-	if (!dim)
+	if (!domain)
 		return NULL;
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_nan(dim->ctx));
+	return isl_qpolynomial_alloc(domain, 0, isl_poly_nan(domain->ctx));
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_cst_on_domain(
-	__isl_take isl_space *dim,
+	__isl_take isl_space *domain,
 	isl_int v)
 {
 	struct isl_qpolynomial *qp;
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	if (!dim)
-		return NULL;
-
-	qp = isl_qpolynomial_alloc(dim, 0, isl_upoly_zero(dim->ctx));
+	qp = isl_qpolynomial_zero_on_domain(domain);
 	if (!qp)
 		return NULL;
 
-	cst = isl_upoly_as_cst(qp->upoly);
+	cst = isl_poly_as_cst(qp->poly);
 	isl_int_set(cst->n, v);
 
 	return qp;
 }
 
-int isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
+isl_bool isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
 	isl_int *n, isl_int *d)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
 	if (!qp)
-		return -1;
+		return isl_bool_error;
 
-	if (!isl_upoly_is_cst(qp->upoly))
-		return 0;
+	is_cst = isl_poly_is_cst(qp->poly);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	cst = isl_upoly_as_cst(qp->upoly);
+	cst = isl_poly_as_cst(qp->poly);
 	if (!cst)
-		return -1;
+		return isl_bool_error;
 
 	if (n)
 		isl_int_set(*n, cst->n);
 	if (d)
 		isl_int_set(*d, cst->d);
 
-	return 1;
+	return isl_bool_true;
 }
 
-/* Return the constant term of "up".
+/* Return the constant term of "poly".
  */
-static __isl_give isl_val *isl_upoly_get_constant_val(
-	__isl_keep struct isl_upoly *up)
+static __isl_give isl_val *isl_poly_get_constant_val(__isl_keep isl_poly *poly)
 {
-	struct isl_upoly_cst *cst;
+	isl_bool is_cst;
+	isl_poly_cst *cst;
 
-	if (!up)
+	if (!poly)
 		return NULL;
 
-	while (!isl_upoly_is_cst(up)) {
-		struct isl_upoly_rec *rec;
+	while ((is_cst = isl_poly_is_cst(poly)) == isl_bool_false) {
+		isl_poly_rec *rec;
 
-		rec = isl_upoly_as_rec(up);
+		rec = isl_poly_as_rec(poly);
 		if (!rec)
 			return NULL;
-		up = rec->p0;
+		poly = rec->p0;
 	}
+	if (is_cst < 0)
+		return NULL;
 
-	cst = isl_upoly_as_cst(up);
+	cst = isl_poly_as_cst(poly);
 	if (!cst)
 		return NULL;
-	return isl_val_rat_from_isl_int(cst->up.ctx, cst->n, cst->d);
+	return isl_val_rat_from_isl_int(cst->poly.ctx, cst->n, cst->d);
 }
 
 /* Return the constant term of "qp".
@@ -1749,51 +2039,49 @@
 	if (!qp)
 		return NULL;
 
-	return isl_upoly_get_constant_val(qp->upoly);
+	return isl_poly_get_constant_val(qp->poly);
 }
 
-int isl_upoly_is_affine(__isl_keep struct isl_upoly *up)
+isl_bool isl_poly_is_affine(__isl_keep isl_poly *poly)
 {
-	int is_cst;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (!up)
-		return -1;
+	if (!poly)
+		return isl_bool_error;
 
-	if (up->var < 0)
-		return 1;
+	if (poly->var < 0)
+		return isl_bool_true;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
-		return -1;
+		return isl_bool_error;
 
 	if (rec->n > 2)
-		return 0;
+		return isl_bool_false;
 
-	isl_assert(up->ctx, rec->n > 1, return -1);
+	isl_assert(poly->ctx, rec->n > 1, return isl_bool_error);
 
-	is_cst = isl_upoly_is_cst(rec->p1);
-	if (is_cst < 0)
-		return -1;
-	if (!is_cst)
-		return 0;
+	is_cst = isl_poly_is_cst(rec->p1);
+	if (is_cst < 0 || !is_cst)
+		return is_cst;
 
-	return isl_upoly_is_affine(rec->p0);
+	return isl_poly_is_affine(rec->p0);
 }
 
-int isl_qpolynomial_is_affine(__isl_keep isl_qpolynomial *qp)
+isl_bool isl_qpolynomial_is_affine(__isl_keep isl_qpolynomial *qp)
 {
 	if (!qp)
-		return -1;
+		return isl_bool_error;
 
 	if (qp->div->n_row > 0)
-		return 0;
+		return isl_bool_false;
 
-	return isl_upoly_is_affine(qp->upoly);
+	return isl_poly_is_affine(qp->poly);
 }
 
 static void update_coeff(__isl_keep isl_vec *aff,
-	__isl_keep struct isl_upoly_cst *cst, int pos)
+	__isl_keep isl_poly_cst *cst, int pos)
 {
 	isl_int gcd;
 	isl_int f;
@@ -1812,56 +2100,55 @@
 	isl_int_clear(f);
 }
 
-int isl_upoly_update_affine(__isl_keep struct isl_upoly *up,
-	__isl_keep isl_vec *aff)
+int isl_poly_update_affine(__isl_keep isl_poly *poly, __isl_keep isl_vec *aff)
 {
-	struct isl_upoly_cst *cst;
-	struct isl_upoly_rec *rec;
+	isl_poly_cst *cst;
+	isl_poly_rec *rec;
 
-	if (!up || !aff)
+	if (!poly || !aff)
 		return -1;
 
-	if (up->var < 0) {
-		struct isl_upoly_cst *cst;
+	if (poly->var < 0) {
+		isl_poly_cst *cst;
 
-		cst = isl_upoly_as_cst(up);
+		cst = isl_poly_as_cst(poly);
 		if (!cst)
 			return -1;
 		update_coeff(aff, cst, 0);
 		return 0;
 	}
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		return -1;
-	isl_assert(up->ctx, rec->n == 2, return -1);
+	isl_assert(poly->ctx, rec->n == 2, return -1);
 
-	cst = isl_upoly_as_cst(rec->p1);
+	cst = isl_poly_as_cst(rec->p1);
 	if (!cst)
 		return -1;
-	update_coeff(aff, cst, 1 + up->var);
+	update_coeff(aff, cst, 1 + poly->var);
 
-	return isl_upoly_update_affine(rec->p0, aff);
+	return isl_poly_update_affine(rec->p0, aff);
 }
 
 __isl_give isl_vec *isl_qpolynomial_extract_affine(
 	__isl_keep isl_qpolynomial *qp)
 {
 	isl_vec *aff;
-	unsigned d;
+	isl_size d;
 
-	if (!qp)
+	d = isl_qpolynomial_domain_dim(qp, isl_dim_all);
+	if (d < 0)
 		return NULL;
 
-	d = isl_space_dim(qp->dim, isl_dim_all);
-	aff = isl_vec_alloc(qp->div->ctx, 2 + d + qp->div->n_row);
+	aff = isl_vec_alloc(qp->div->ctx, 2 + d);
 	if (!aff)
 		return NULL;
 
-	isl_seq_clr(aff->el + 1, 1 + d + qp->div->n_row);
+	isl_seq_clr(aff->el + 1, 1 + d);
 	isl_int_set_si(aff->el0, 1);
 
-	if (isl_upoly_update_affine(qp->upoly, aff) < 0)
+	if (isl_poly_update_affine(qp->poly, aff) < 0)
 		goto error;
 
 	return aff;
@@ -1870,13 +2157,48 @@
 	return NULL;
 }
 
-int isl_qpolynomial_plain_is_equal(__isl_keep isl_qpolynomial *qp1,
+/* Compare two quasi-polynomials.
+ *
+ * Return -1 if "qp1" is "smaller" than "qp2", 1 if "qp1" is "greater"
+ * than "qp2" and 0 if they are equal.
+ */
+int isl_qpolynomial_plain_cmp(__isl_keep isl_qpolynomial *qp1,
 	__isl_keep isl_qpolynomial *qp2)
 {
-	int equal;
+	int cmp;
 
-	if (!qp1 || !qp2)
+	if (qp1 == qp2)
+		return 0;
+	if (!qp1)
 		return -1;
+	if (!qp2)
+		return 1;
+
+	cmp = isl_space_cmp(qp1->dim, qp2->dim);
+	if (cmp != 0)
+		return cmp;
+
+	cmp = isl_local_cmp(qp1->div, qp2->div);
+	if (cmp != 0)
+		return cmp;
+
+	return isl_poly_plain_cmp(qp1->poly, qp2->poly);
+}
+
+/* Is "qp1" obviously equal to "qp2"?
+ *
+ * NaN is not equal to anything, not even to another NaN.
+ */
+isl_bool isl_qpolynomial_plain_is_equal(__isl_keep isl_qpolynomial *qp1,
+	__isl_keep isl_qpolynomial *qp2)
+{
+	isl_bool equal;
+
+	if (!qp1 || !qp2)
+		return isl_bool_error;
+
+	if (isl_qpolynomial_is_nan(qp1) || isl_qpolynomial_is_nan(qp2))
+		return isl_bool_false;
 
 	equal = isl_space_is_equal(qp1->dim, qp2->dim);
 	if (equal < 0 || !equal)
@@ -1886,137 +2208,149 @@
 	if (equal < 0 || !equal)
 		return equal;
 
-	return isl_upoly_is_equal(qp1->upoly, qp2->upoly);
+	return isl_poly_is_equal(qp1->poly, qp2->poly);
 }
 
-static void upoly_update_den(__isl_keep struct isl_upoly *up, isl_int *d)
+static isl_stat poly_update_den(__isl_keep isl_poly *poly, isl_int *d)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (isl_upoly_is_cst(up)) {
-		struct isl_upoly_cst *cst;
-		cst = isl_upoly_as_cst(up);
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_stat_error;
+	if (is_cst) {
+		isl_poly_cst *cst;
+		cst = isl_poly_as_cst(poly);
 		if (!cst)
-			return;
+			return isl_stat_error;
 		isl_int_lcm(*d, *d, cst->d);
-		return;
+		return isl_stat_ok;
 	}
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
-		return;
+		return isl_stat_error;
 
 	for (i = 0; i < rec->n; ++i)
-		upoly_update_den(rec->pi, d);
+		poly_update_den(rec->pi, d);
+
+	return isl_stat_ok;
 }
 
-void isl_qpolynomial_get_den(__isl_keep isl_qpolynomial *qp, isl_int *d)
+__isl_give isl_val *isl_qpolynomial_get_den(__isl_keep isl_qpolynomial *qp)
 {
-	isl_int_set_si(*d, 1);
+	isl_val *d;
+
 	if (!qp)
-		return;
-	upoly_update_den(qp->upoly, d);
+		return NULL;
+	d = isl_val_one(isl_qpolynomial_get_ctx(qp));
+	if (!d)
+		return NULL;
+	if (poly_update_den(qp->poly, &d->n) < 0)
+		return isl_val_free(d);
+	return d;
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_var_pow_on_domain(
-	__isl_take isl_space *dim, int pos, int power)
+	__isl_take isl_space *domain, int pos, int power)
 {
 	struct isl_ctx *ctx;
 
-	if (!dim)
+	if (!domain)
 		return NULL;
 
-	ctx = dim->ctx;
+	ctx = domain->ctx;
 
-	return isl_qpolynomial_alloc(dim, 0, isl_upoly_var_pow(ctx, pos, power));
+	return isl_qpolynomial_alloc(domain, 0,
+					isl_poly_var_pow(ctx, pos, power));
 }
 
-__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(__isl_take isl_space *dim,
-	enum isl_dim_type type, unsigned pos)
+__isl_give isl_qpolynomial *isl_qpolynomial_var_on_domain(
+	__isl_take isl_space *domain, enum isl_dim_type type, unsigned pos)
 {
-	if (!dim)
-		return NULL;
-
-	isl_assert(dim->ctx, isl_space_dim(dim, isl_dim_in) == 0, goto error);
-	isl_assert(dim->ctx, pos < isl_space_dim(dim, type), goto error);
+	if (isl_space_check_is_set(domain ) < 0)
+		goto error;
+	if (isl_space_check_range(domain, type, pos, 1) < 0)
+		goto error;
 
-	if (type == isl_dim_set)
-		pos += isl_space_dim(dim, isl_dim_param);
+	pos += isl_space_offset(domain, type);
 
-	return isl_qpolynomial_var_pow_on_domain(dim, pos, 1);
+	return isl_qpolynomial_var_pow_on_domain(domain, pos, 1);
 error:
-	isl_space_free(dim);
+	isl_space_free(domain);
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_subs(__isl_take struct isl_upoly *up,
-	unsigned first, unsigned n, __isl_keep struct isl_upoly **subs)
+__isl_give isl_poly *isl_poly_subs(__isl_take isl_poly *poly,
+	unsigned first, unsigned n, __isl_keep isl_poly **subs)
 {
 	int i;
-	struct isl_upoly_rec *rec;
-	struct isl_upoly *base, *res;
-
-	if (!up)
-		return NULL;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
+	isl_poly *base, *res;
 
-	if (isl_upoly_is_cst(up))
-		return up;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst)
+		return poly;
 
-	if (up->var < first)
-		return up;
+	if (poly->var < first)
+		return poly;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
-	isl_assert(up->ctx, rec->n >= 1, goto error);
+	isl_assert(poly->ctx, rec->n >= 1, goto error);
 
-	if (up->var >= first + n)
-		base = isl_upoly_var_pow(up->ctx, up->var, 1);
+	if (poly->var >= first + n)
+		base = isl_poly_var_pow(poly->ctx, poly->var, 1);
 	else
-		base = isl_upoly_copy(subsup->var - first);
+		base = isl_poly_copy(subspoly->var - first);
 
-	res = isl_upoly_subs(isl_upoly_copy(rec->prec->n - 1), first, n, subs);
+	res = isl_poly_subs(isl_poly_copy(rec->prec->n - 1), first, n, subs);
 	for (i = rec->n - 2; i >= 0; --i) {
-		struct isl_upoly *t;
-		t = isl_upoly_subs(isl_upoly_copy(rec->pi), first, n, subs);
-		res = isl_upoly_mul(res, isl_upoly_copy(base));
-		res = isl_upoly_sum(res, t);
+		isl_poly *t;
+		t = isl_poly_subs(isl_poly_copy(rec->pi), first, n, subs);
+		res = isl_poly_mul(res, isl_poly_copy(base));
+		res = isl_poly_sum(res, t);
 	}
 
-	isl_upoly_free(base);
-	isl_upoly_free(up);
+	isl_poly_free(base);
+	isl_poly_free(poly);
 				
 	return res;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }	
 
-__isl_give struct isl_upoly *isl_upoly_from_affine(isl_ctx *ctx, isl_int *f,
+__isl_give isl_poly *isl_poly_from_affine(isl_ctx *ctx, isl_int *f,
 	isl_int denom, unsigned len)
 {
 	int i;
-	struct isl_upoly *up;
+	isl_poly *poly;
 
 	isl_assert(ctx, len >= 1, return NULL);
 
-	up = isl_upoly_rat_cst(ctx, f0, denom);
+	poly = isl_poly_rat_cst(ctx, f0, denom);
 	for (i = 0; i < len - 1; ++i) {
-		struct isl_upoly *t;
-		struct isl_upoly *c;
+		isl_poly *t;
+		isl_poly *c;
 
 		if (isl_int_is_zero(f1 + i))
 			continue;
 
-		c = isl_upoly_rat_cst(ctx, f1 + i, denom);
-		t = isl_upoly_var_pow(ctx, i, 1);
-		t = isl_upoly_mul(c, t);
-		up = isl_upoly_sum(up, t);
+		c = isl_poly_rat_cst(ctx, f1 + i, denom);
+		t = isl_poly_var_pow(ctx, i, 1);
+		t = isl_poly_mul(c, t);
+		poly = isl_poly_sum(poly, t);
 	}
 
-	return up;
+	return poly;
 }
 
 /* Remove common factor of non-constant terms and denominator.
@@ -2045,12 +2379,12 @@
  * of any other integer divisions.
  */
 static __isl_give isl_qpolynomial *substitute_div(
-	__isl_take isl_qpolynomial *qp,
-	int div, __isl_take struct isl_upoly *s)
+	__isl_take isl_qpolynomial *qp, int div, __isl_take isl_poly *s)
 {
 	int i;
-	int total;
+	isl_size div_pos;
 	int *reordering;
+	isl_ctx *ctx;
 
 	if (!qp || !s)
 		goto error;
@@ -2059,31 +2393,34 @@
 	if (!qp)
 		goto error;
 
-	total = isl_space_dim(qp->dim, isl_dim_all);
-	qp->upoly = isl_upoly_subs(qp->upoly, total + div, 1, &s);
-	if (!qp->upoly)
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		goto error;
+	qp->poly = isl_poly_subs(qp->poly, div_pos + div, 1, &s);
+	if (!qp->poly)
 		goto error;
 
-	reordering = isl_alloc_array(qp->dim->ctx, int, total + qp->div->n_row);
+	ctx = isl_qpolynomial_get_ctx(qp);
+	reordering = isl_alloc_array(ctx, int, div_pos + qp->div->n_row);
 	if (!reordering)
 		goto error;
-	for (i = 0; i < total + div; ++i)
+	for (i = 0; i < div_pos + div; ++i)
 		reorderingi = i;
-	for (i = total + div + 1; i < total + qp->div->n_row; ++i)
+	for (i = div_pos + div + 1; i < div_pos + qp->div->n_row; ++i)
 		reorderingi = i - 1;
 	qp->div = isl_mat_drop_rows(qp->div, div, 1);
-	qp->div = isl_mat_drop_cols(qp->div, 2 + total + div, 1);
-	qp->upoly = reorder(qp->upoly, reordering);
+	qp->div = isl_mat_drop_cols(qp->div, 2 + div_pos + div, 1);
+	qp->poly = reorder(qp->poly, reordering);
 	free(reordering);
 
-	if (!qp->upoly || !qp->div)
+	if (!qp->poly || !qp->div)
 		goto error;
 
-	isl_upoly_free(s);
+	isl_poly_free(s);
 	return qp;
 error:
 	isl_qpolynomial_free(qp);
-	isl_upoly_free(s);
+	isl_poly_free(s);
 	return NULL;
 }
 
@@ -2094,27 +2431,27 @@
 	__isl_take isl_qpolynomial *qp)
 {
 	int i, j;
-	int total;
-	struct isl_upoly *s;
+	isl_size div_pos;
+	isl_poly *s;
 
-	if (!qp)
-		return NULL;
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		return isl_qpolynomial_free(qp);
 
-	total = isl_space_dim(qp->dim, isl_dim_all);
 	for (i = 0; qp && i < qp->div->n_row; ++i) {
 		if (!isl_int_is_one(qp->div->rowi0))
 			continue;
 		for (j = i + 1; j < qp->div->n_row; ++j) {
-			if (isl_int_is_zero(qp->div->rowj2 + total + i))
+			if (isl_int_is_zero(qp->div->rowj2 + div_pos + i))
 				continue;
 			isl_seq_combine(qp->div->rowj + 1,
 				qp->div->ctx->one, qp->div->rowj + 1,
-				qp->div->rowj2 + total + i,
-				qp->div->rowi + 1, 1 + total + i);
-			isl_int_set_si(qp->div->rowj2 + total + i, 0);
+				qp->div->rowj2 + div_pos + i,
+				qp->div->rowi + 1, 1 + div_pos + i);
+			isl_int_set_si(qp->div->rowj2 + div_pos + i, 0);
 			normalize_div(qp, j);
 		}
-		s = isl_upoly_from_affine(qp->dim->ctx, qp->div->rowi + 1,
+		s = isl_poly_from_affine(qp->dim->ctx, qp->div->rowi + 1,
 					qp->div->rowi0, qp->div->n_col - 1);
 		qp = substitute_div(qp, i, s);
 		--i;
@@ -2129,11 +2466,11 @@
  * inside the division, so we need to add floor(e/d) * x outside.
  * That is, we replace q by q' + floor(e/d) * x and we therefore need
  * to adjust the coefficient of x in each later div that depends on the
- * current div "div" and also in the affine expression "aff"
- * (if it too depends on "div").
+ * current div "div" and also in the affine expressions in the rows of "mat"
+ * (if they too depend on "div").
  */
 static void reduce_div(__isl_keep isl_qpolynomial *qp, int div,
-	__isl_keep isl_vec *aff)
+	__isl_keep isl_mat **mat)
 {
 	int i, j;
 	isl_int v;
@@ -2147,8 +2484,7 @@
 		isl_int_fdiv_q(v, qp->div->rowdiv1 + i, qp->div->rowdiv0);
 		isl_int_fdiv_r(qp->div->rowdiv1 + i,
 				qp->div->rowdiv1 + i, qp->div->rowdiv0);
-		if (!isl_int_is_zero(aff->el1 + total + div))
-			isl_int_addmul(aff->eli, v, aff->el1 + total + div);
+		*mat = isl_mat_col_addmul(*mat, i, v, 1 + total + div);
 		for (j = div + 1; j < qp->div->n_row; ++j) {
 			if (isl_int_is_zero(qp->div->rowj2 + total + div))
 				continue;
@@ -2188,11 +2524,11 @@
 
 /* Replace div "div" q = e/d by -(-e+(d-1))/d.
  * We only invert the coefficients of e (and the coefficient of q in
- * later divs and in "aff").  After calling this function, the
+ * later divs and in the rows of "mat").  After calling this function, the
  * coefficients of e should be reduced again.
  */
 static void invert_div(__isl_keep isl_qpolynomial *qp, int div,
-	__isl_keep isl_vec *aff)
+	__isl_keep isl_mat **mat)
 {
 	unsigned total = qp->div->n_col - qp->div->n_row - 2;
 
@@ -2201,15 +2537,18 @@
 	isl_int_sub_ui(qp->div->rowdiv1, qp->div->rowdiv1, 1);
 	isl_int_add(qp->div->rowdiv1,
 		    qp->div->rowdiv1, qp->div->rowdiv0);
-	if (!isl_int_is_zero(aff->el1 + total + div))
-		isl_int_neg(aff->el1 + total + div, aff->el1 + total + div);
+	*mat = isl_mat_col_neg(*mat, 1 + total + div);
 	isl_mat_col_mul(qp->div, 2 + total + div,
 			qp->div->ctx->negone, 2 + total + div);
 }
 
-/* Assuming "qp" is a monomial, reduce all its divs to have coefficients
+/* Reduce all divs of "qp" to have coefficients
  * in the interval 0, d-1, with d the denominator and such that the
  * last non-zero coefficient that is not equal to d/2 is smaller than d/2.
+ * The modifications to the integer divisions need to be reflected
+ * in the factors of the polynomial that refer to the original
+ * integer divisions.  To this end, the modifications are collected
+ * as a set of affine expressions and then plugged into the polynomial.
  *
  * After the reduction, some divs may have become redundant or identical,
  * so we call substitute_non_divs and sort_divs.  If these functions
@@ -2220,65 +2559,75 @@
 static __isl_give isl_qpolynomial *reduce_divs(__isl_take isl_qpolynomial *qp)
 {
 	int i;
-	isl_vec *aff = NULL;
-	struct isl_upoly *s;
-	unsigned n_div;
-
-	if (!qp)
-		return NULL;
-
-	aff = isl_vec_alloc(qp->div->ctx, qp->div->n_col - 1);
-	aff = isl_vec_clr(aff);
-	if (!aff)
-		goto error;
+	isl_ctx *ctx;
+	isl_mat *mat;
+	isl_poly **s;
+	unsigned o_div;
+	isl_size n_div, total, new_n_div;
+
+	total = isl_qpolynomial_domain_dim(qp, isl_dim_all);
+	n_div = isl_qpolynomial_domain_dim(qp, isl_dim_div);
+	o_div = isl_qpolynomial_domain_offset(qp, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return isl_qpolynomial_free(qp);
+	ctx = isl_qpolynomial_get_ctx(qp);
+	mat = isl_mat_zero(ctx, n_div, 1 + total);
 
-	isl_int_set_si(aff->el1 + qp->upoly->var, 1);
+	for (i = 0; i < n_div; ++i)
+		mat = isl_mat_set_element_si(mat, i, o_div + i, 1);
 
 	for (i = 0; i < qp->div->n_row; ++i) {
 		normalize_div(qp, i);
-		reduce_div(qp, i, aff);
+		reduce_div(qp, i, &mat);
 		if (needs_invert(qp->div, i)) {
-			invert_div(qp, i, aff);
-			reduce_div(qp, i, aff);
+			invert_div(qp, i, &mat);
+			reduce_div(qp, i, &mat);
 		}
 	}
+	if (!mat)
+		goto error;
 
-	s = isl_upoly_from_affine(qp->div->ctx, aff->el,
-				  qp->div->ctx->one, aff->size);
-	qp->upoly = isl_upoly_subs(qp->upoly, qp->upoly->var, 1, &s);
-	isl_upoly_free(s);
-	if (!qp->upoly)
+	s = isl_alloc_array(ctx, struct isl_poly *, n_div);
+	if (n_div && !s)
+		goto error;
+	for (i = 0; i < n_div; ++i)
+		si = isl_poly_from_affine(ctx, mat->rowi, ctx->one,
+					    1 + total);
+	qp->poly = isl_poly_subs(qp->poly, o_div - 1, n_div, s);
+	for (i = 0; i < n_div; ++i)
+		isl_poly_free(si);
+	free(s);
+	if (!qp->poly)
 		goto error;
 
-	isl_vec_free(aff);
+	isl_mat_free(mat);
 
-	n_div = qp->div->n_row;
 	qp = substitute_non_divs(qp);
 	qp = sort_divs(qp);
-	if (qp && qp->div->n_row < n_div)
+	new_n_div = isl_qpolynomial_domain_dim(qp, isl_dim_div);
+	if (new_n_div < 0)
+		return isl_qpolynomial_free(qp);
+	if (new_n_div < n_div)
 		return reduce_divs(qp);
 
 	return qp;
 error:
 	isl_qpolynomial_free(qp);
-	isl_vec_free(aff);
+	isl_mat_free(mat);
 	return NULL;
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain(
-	__isl_take isl_space *dim, const isl_int n, const isl_int d)
+	__isl_take isl_space *domain, const isl_int n, const isl_int d)
 {
 	struct isl_qpolynomial *qp;
-	struct isl_upoly_cst *cst;
-
-	if (!dim)
-		return NULL;
+	isl_poly_cst *cst;
 
-	qp = isl_qpolynomial_alloc(dim, 0, isl_upoly_zero(dim->ctx));
+	qp = isl_qpolynomial_zero_on_domain(domain);
 	if (!qp)
 		return NULL;
 
-	cst = isl_upoly_as_cst(qp->upoly);
+	cst = isl_poly_as_cst(qp->poly);
 	isl_int_set(cst->n, n);
 	isl_int_set(cst->d, d);
 
@@ -2291,58 +2640,57 @@
 	__isl_take isl_space *domain, __isl_take isl_val *val)
 {
 	isl_qpolynomial *qp;
-	struct isl_upoly_cst *cst;
+	isl_poly_cst *cst;
 
-	if (!domain || !val)
+	qp = isl_qpolynomial_zero_on_domain(domain);
+	if (!qp || !val)
 		goto error;
 
-	qp = isl_qpolynomial_alloc(isl_space_copy(domain), 0,
-					isl_upoly_zero(domain->ctx));
-	if (!qp)
-		goto error;
-
-	cst = isl_upoly_as_cst(qp->upoly);
+	cst = isl_poly_as_cst(qp->poly);
 	isl_int_set(cst->n, val->n);
 	isl_int_set(cst->d, val->d);
 
-	isl_space_free(domain);
 	isl_val_free(val);
 	return qp;
 error:
-	isl_space_free(domain);
 	isl_val_free(val);
+	isl_qpolynomial_free(qp);
 	return NULL;
 }
 
-static int up_set_active(__isl_keep struct isl_upoly *up, int *active, int d)
+static isl_stat poly_set_active(__isl_keep isl_poly *poly, int *active, int d)
 {
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 	int i;
 
-	if (!up)
-		return -1;
-
-	if (isl_upoly_is_cst(up))
-		return 0;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_stat_error;
+	if (is_cst)
+		return isl_stat_ok;
 
-	if (up->var < d)
-		activeup->var = 1;
+	if (poly->var < d)
+		activepoly->var = 1;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	for (i = 0; i < rec->n; ++i)
-		if (up_set_active(rec->pi, active, d) < 0)
-			return -1;
+		if (poly_set_active(rec->pi, active, d) < 0)
+			return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int set_active(__isl_keep isl_qpolynomial *qp, int *active)
+static isl_stat set_active(__isl_keep isl_qpolynomial *qp, int *active)
 {
 	int i, j;
-	int d = isl_space_dim(qp->dim, isl_dim_all);
+	isl_size d;
+	isl_space *space;
 
-	if (!qp || !active)
-		return -1;
+	space = isl_qpolynomial_peek_domain_space(qp);
+	d = isl_space_dim(space, isl_dim_all);
+	if (d < 0 || !active)
+		return isl_stat_error;
 
 	for (i = 0; i < d; ++i)
 		for (j = 0; j < qp->div->n_row; ++j) {
@@ -2352,36 +2700,49 @@
 			break;
 		}
 
-	return up_set_active(qp->upoly, active, d);
+	return poly_set_active(qp->poly, active, d);
 }
 
-int isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp,
+#undef TYPE
+#define TYPE	isl_qpolynomial
+static
+#include "check_type_range_templ.c"
+
+isl_bool isl_qpolynomial_involves_dims(__isl_keep isl_qpolynomial *qp,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
 	int i;
 	int *active = NULL;
-	int involves = 0;
+	isl_bool involves = isl_bool_false;
+	isl_size offset;
+	isl_size d;
+	isl_space *space;
 
 	if (!qp)
-		return -1;
+		return isl_bool_error;
 	if (n == 0)
-		return 0;
+		return isl_bool_false;
 
-	isl_assert(qp->dim->ctx,
-		    first + n <= isl_qpolynomial_dim(qp, type), return -1);
+	if (isl_qpolynomial_check_range(qp, type, first, n) < 0)
+		return isl_bool_error;
 	isl_assert(qp->dim->ctx, type == isl_dim_param ||
-				 type == isl_dim_in, return -1);
+				 type == isl_dim_in, return isl_bool_error);
 
-	active = isl_calloc_array(qp->dim->ctx, int,
-					isl_space_dim(qp->dim, isl_dim_all));
+	space = isl_qpolynomial_peek_domain_space(qp);
+	d = isl_space_dim(space, isl_dim_all);
+	if (d < 0)
+		return isl_bool_error;
+	active = isl_calloc_array(qp->dim->ctx, int, d);
 	if (set_active(qp, active) < 0)
 		goto error;
 
-	if (type == isl_dim_in)
-		first += isl_space_dim(qp->dim, isl_dim_param);
+	offset = isl_qpolynomial_domain_var_offset(qp, domain_type(type));
+	if (offset < 0)
+		goto error;
+	first += offset;
 	for (i = 0; i < n; ++i)
 		if (activefirst + i) {
-			involves = 1;
+			involves = isl_bool_true;
 			break;
 		}
 
@@ -2390,7 +2751,7 @@
 	return involves;
 error:
 	free(active);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Remove divs that do not appear in the quasi-polynomial, nor in any
@@ -2400,7 +2761,7 @@
 	__isl_take isl_qpolynomial *qp)
 {
 	int i, j;
-	int d;
+	isl_size div_pos;
 	int len;
 	int skip;
 	int *active = NULL;
@@ -2414,25 +2775,27 @@
 	if (qp->div->n_row == 0)
 		return qp;
 
-	d = isl_space_dim(qp->dim, isl_dim_all);
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		return isl_qpolynomial_free(qp);
 	len = qp->div->n_col - 2;
 	ctx = isl_qpolynomial_get_ctx(qp);
 	active = isl_calloc_array(ctx, int, len);
 	if (!active)
 		goto error;
 
-	if (up_set_active(qp->upoly, active, len) < 0)
+	if (poly_set_active(qp->poly, active, len) < 0)
 		goto error;
 
 	for (i = qp->div->n_row - 1; i >= 0; --i) {
-		if (!actived + i) {
+		if (!activediv_pos + i) {
 			redundant = 1;
 			continue;
 		}
 		for (j = 0; j < i; ++j) {
-			if (isl_int_is_zero(qp->div->rowi2 + d + j))
+			if (isl_int_is_zero(qp->div->rowi2 + div_pos + j))
 				continue;
-			actived + j = 1;
+			activediv_pos + j = 1;
 			break;
 		}
 	}
@@ -2446,24 +2809,24 @@
 	if (!reordering)
 		goto error;
 
-	for (i = 0; i < d; ++i)
+	for (i = 0; i < div_pos; ++i)
 		reorderingi = i;
 
 	skip = 0;
 	n_div = qp->div->n_row;
 	for (i = 0; i < n_div; ++i) {
-		if (!actived + i) {
+		if (!activediv_pos + i) {
 			qp->div = isl_mat_drop_rows(qp->div, i - skip, 1);
 			qp->div = isl_mat_drop_cols(qp->div,
-						    2 + d + i - skip, 1);
+						    2 + div_pos + i - skip, 1);
 			skip++;
 		}
-		reorderingd + i = d + i - skip;
+		reorderingdiv_pos + i = div_pos + i - skip;
 	}
 
-	qp->upoly = reorder(qp->upoly, reordering);
+	qp->poly = reorder(qp->poly, reordering);
 
-	if (!qp->upoly || !qp->div)
+	if (!qp->poly || !qp->div)
 		goto error;
 
 	free(active);
@@ -2477,37 +2840,37 @@
 	return NULL;
 }
 
-__isl_give struct isl_upoly *isl_upoly_drop(__isl_take struct isl_upoly *up,
+__isl_give isl_poly *isl_poly_drop(__isl_take isl_poly *poly,
 	unsigned first, unsigned n)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_poly_rec *rec;
 
-	if (!up)
+	if (!poly)
 		return NULL;
-	if (n == 0 || up->var < 0 || up->var < first)
-		return up;
-	if (up->var < first + n) {
-		up = replace_by_constant_term(up);
-		return isl_upoly_drop(up, first, n);
+	if (n == 0 || poly->var < 0 || poly->var < first)
+		return poly;
+	if (poly->var < first + n) {
+		poly = replace_by_constant_term(poly);
+		return isl_poly_drop(poly, first, n);
 	}
-	up = isl_upoly_cow(up);
-	if (!up)
+	poly = isl_poly_cow(poly);
+	if (!poly)
 		return NULL;
-	up->var -= n;
-	rec = isl_upoly_as_rec(up);
+	poly->var -= n;
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
 	for (i = 0; i < rec->n; ++i) {
-		rec->pi = isl_upoly_drop(rec->pi, first, n);
+		rec->pi = isl_poly_drop(rec->pi, first, n);
 		if (!rec->pi)
 			goto error;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
@@ -2518,6 +2881,11 @@
 	qp = isl_qpolynomial_cow(qp);
 	if (!qp)
 		return NULL;
+	if (type == isl_dim_out)
+		isl_die(isl_qpolynomial_get_ctx(qp), isl_error_invalid,
+			"cannot set name of output/set dimension",
+			return isl_qpolynomial_free(qp));
+	type = domain_type(type);
 	qp->dim = isl_space_set_dim_name(qp->dim, type, pos, s);
 	if (!qp->dim)
 		goto error;
@@ -2531,14 +2899,17 @@
 	__isl_take isl_qpolynomial *qp,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
+	isl_size offset;
+
 	if (!qp)
 		return NULL;
 	if (type == isl_dim_out)
 		isl_die(qp->dim->ctx, isl_error_invalid,
 			"cannot drop output/set dimension",
 			goto error);
-	if (type == isl_dim_in)
-		type = isl_dim_set;
+	if (isl_qpolynomial_check_range(qp, type, first, n) < 0)
+		return isl_qpolynomial_free(qp);
+	type = domain_type(type);
 	if (n == 0 && !isl_space_is_named_or_nested(qp->dim, type))
 		return qp;
 
@@ -2546,8 +2917,6 @@
 	if (!qp)
 		return NULL;
 
-	isl_assert(qp->dim->ctx, first + n <= isl_space_dim(qp->dim, type),
-			goto error);
 	isl_assert(qp->dim->ctx, type == isl_dim_param ||
 				 type == isl_dim_set, goto error);
 
@@ -2555,15 +2924,17 @@
 	if (!qp->dim)
 		goto error;
 
-	if (type == isl_dim_set)
-		first += isl_space_dim(qp->dim, isl_dim_param);
+	offset = isl_qpolynomial_domain_var_offset(qp, type);
+	if (offset < 0)
+		goto error;
+	first += offset;
 
 	qp->div = isl_mat_drop_cols(qp->div, 2 + first, n);
 	if (!qp->div)
 		goto error;
 
-	qp->upoly = isl_upoly_drop(qp->upoly, first, n);
-	if (!qp->upoly)
+	qp->poly = isl_poly_drop(qp->poly, first, n);
+	if (!qp->poly)
 		goto error;
 
 	return qp;
@@ -2579,10 +2950,12 @@
 	__isl_take isl_qpolynomial *qp)
 {
 	isl_space *space;
-	unsigned n;
-	int involves;
+	isl_size n;
+	isl_bool involves;
 
 	n = isl_qpolynomial_dim(qp, isl_dim_in);
+	if (n < 0)
+		return isl_qpolynomial_free(qp);
 	involves = isl_qpolynomial_involves_dims(qp, isl_dim_in, 0, n);
 	if (involves < 0)
 		return isl_qpolynomial_free(qp);
@@ -2604,7 +2977,7 @@
 	isl_int denom;
 	unsigned total;
 	unsigned n_div;
-	struct isl_upoly *up;
+	isl_poly *poly;
 
 	if (!eq)
 		goto error;
@@ -2620,7 +2993,7 @@
 	if (!qp->div)
 		goto error;
 
-	total = 1 + isl_space_dim(eq->dim, isl_dim_all);
+	total = isl_basic_set_offset(eq, isl_dim_div);
 	n_div = eq->n_div;
 	isl_int_init(denom);
 	for (i = 0; i < eq->n_eq; ++i) {
@@ -2641,14 +3014,14 @@
 		isl_int_abs(denom, eq->eqij);
 		isl_int_set_si(eq->eqij, 0);
 
-		up = isl_upoly_from_affine(qp->dim->ctx,
+		poly = isl_poly_from_affine(qp->dim->ctx,
 						   eq->eqi, denom, total);
-		qp->upoly = isl_upoly_subs(qp->upoly, j - 1, 1, &up);
-		isl_upoly_free(up);
+		qp->poly = isl_poly_subs(qp->poly, j - 1, 1, &poly);
+		isl_poly_free(poly);
 	}
 	isl_int_clear(denom);
 
-	if (!qp->upoly)
+	if (!qp->poly)
 		goto error;
 
 	isl_basic_set_free(eq);
@@ -2679,32 +3052,6 @@
 	return NULL;
 }
 
-static __isl_give isl_basic_set *add_div_constraints(
-	__isl_take isl_basic_set *bset, __isl_take isl_mat *div)
-{
-	int i;
-	unsigned total;
-
-	if (!bset || !div)
-		goto error;
-
-	bset = isl_basic_set_extend_constraints(bset, 0, 2 * div->n_row);
-	if (!bset)
-		goto error;
-	total = isl_basic_set_total_dim(bset);
-	for (i = 0; i < div->n_row; ++i)
-		if (isl_basic_set_add_div_constraints_var(bset,
-				    total - div->n_row + i, div->rowi) < 0)
-			goto error;
-
-	isl_mat_free(div);
-	return bset;
-error:
-	isl_mat_free(div);
-	isl_basic_set_free(bset);
-	return NULL;
-}
-
 /* Look for equalities among the variables shared by context and qp
  * and the integer divisions of qp, if any.
  * The equalities are then used to eliminate variables and/or integer
@@ -2713,26 +3060,14 @@
 __isl_give isl_qpolynomial *isl_qpolynomial_gist(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_set *context)
 {
+	isl_local_space *ls;
 	isl_basic_set *aff;
 
-	if (!qp)
-		goto error;
-	if (qp->div->n_row > 0) {
-		isl_basic_set *bset;
-		context = isl_set_add_dims(context, isl_dim_set,
-					    qp->div->n_row);
-		bset = isl_basic_set_universe(isl_set_get_space(context));
-		bset = add_div_constraints(bset, isl_mat_copy(qp->div));
-		context = isl_set_intersect(context,
-					    isl_set_from_basic_set(bset));
-	}
+	ls = isl_qpolynomial_get_domain_local_space(qp);
+	context = isl_local_space_lift_set(ls, context);
 
 	aff = isl_set_affine_hull(context);
 	return isl_qpolynomial_substitute_equalities_lifted(qp, aff);
-error:
-	isl_qpolynomial_free(qp);
-	isl_set_free(context);
-	return NULL;
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_gist_params(
@@ -2744,27 +3079,23 @@
 	return isl_qpolynomial_gist(qp, dom_context);
 }
 
-__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_from_qpolynomial(
-	__isl_take isl_qpolynomial *qp)
+/* Return a zero isl_qpolynomial in the given space.
+ *
+ * This is a helper function for isl_pw_*_as_* that ensures a uniform
+ * interface over all piecewise types.
+ */
+static __isl_give isl_qpolynomial *isl_qpolynomial_zero_in_space(
+	__isl_take isl_space *space)
 {
-	isl_set *dom;
-
-	if (!qp)
-		return NULL;
-	if (isl_qpolynomial_is_zero(qp)) {
-		isl_space *dim = isl_qpolynomial_get_space(qp);
-		isl_qpolynomial_free(qp);
-		return isl_pw_qpolynomial_zero(dim);
-	}
-
-	dom = isl_set_universe(isl_qpolynomial_get_domain_space(qp));
-	return isl_pw_qpolynomial_alloc(dom, qp);
+	return isl_qpolynomial_zero_on_domain(isl_space_domain(space));
 }
 
+#define isl_qpolynomial_involves_nan isl_qpolynomial_is_nan
+
 #undef PW
 #define PW isl_pw_qpolynomial
-#undef EL
-#define EL isl_qpolynomial
+#undef BASE
+#define BASE qpolynomial
 #undef EL_IS_ZERO
 #define EL_IS_ZERO is_zero
 #undef ZERO
@@ -2776,19 +3107,22 @@
 #undef DEFAULT_IS_ZERO
 #define DEFAULT_IS_ZERO 1
 
-#define NO_PULLBACK
-
 #include <isl_pw_templ.c>
-
-#undef UNION
-#define UNION isl_union_pw_qpolynomial
-#undef PART
-#define PART isl_pw_qpolynomial
-#undef PARTS
-#define PARTS pw_qpolynomial
-#define ALIGN_DOMAIN
-
-#include <isl_union_templ.c>
+#include <isl_pw_eval.c>
+#include <isl_pw_insert_dims_templ.c>
+#include <isl_pw_lift_templ.c>
+#include <isl_pw_morph_templ.c>
+#include <isl_pw_move_dims_templ.c>
+#include <isl_pw_neg_templ.c>
+#include <isl_pw_opt_templ.c>
+#include <isl_pw_sub_templ.c>
+
+#undef BASE
+#define BASE pw_qpolynomial
+
+#include <isl_union_single.c>
+#include <isl_union_eval.c>
+#include <isl_union_neg.c>
 
 int isl_pw_qpolynomial_is_one(__isl_keep isl_pw_qpolynomial *pwqp)
 {
@@ -2876,79 +3210,86 @@
 	return NULL;
 }
 
-__isl_give isl_val *isl_upoly_eval(__isl_take struct isl_upoly *up,
+__isl_give isl_val *isl_poly_eval(__isl_take isl_poly *poly,
 	__isl_take isl_vec *vec)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 	isl_val *res;
 	isl_val *base;
 
-	if (isl_upoly_is_cst(up)) {
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		goto error;
+	if (is_cst) {
 		isl_vec_free(vec);
-		res = isl_upoly_get_constant_val(up);
-		isl_upoly_free(up);
+		res = isl_poly_get_constant_val(poly);
+		isl_poly_free(poly);
 		return res;
 	}
 
-	rec = isl_upoly_as_rec(up);
-	if (!rec)
+	rec = isl_poly_as_rec(poly);
+	if (!rec || !vec)
 		goto error;
 
-	isl_assert(up->ctx, rec->n >= 1, goto error);
+	isl_assert(poly->ctx, rec->n >= 1, goto error);
 
-	base = isl_val_rat_from_isl_int(up->ctx,
-					vec->el1 + up->var, vec->el0);
+	base = isl_val_rat_from_isl_int(poly->ctx,
+					vec->el1 + poly->var, vec->el0);
 
-	res = isl_upoly_eval(isl_upoly_copy(rec->prec->n - 1),
+	res = isl_poly_eval(isl_poly_copy(rec->prec->n - 1),
 				isl_vec_copy(vec));
 
 	for (i = rec->n - 2; i >= 0; --i) {
 		res = isl_val_mul(res, isl_val_copy(base));
-		res = isl_val_add(res,
-			    isl_upoly_eval(isl_upoly_copy(rec->pi),
+		res = isl_val_add(res, isl_poly_eval(isl_poly_copy(rec->pi),
 							    isl_vec_copy(vec)));
 	}
 
 	isl_val_free(base);
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	isl_vec_free(vec);
 	return res;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	isl_vec_free(vec);
 	return NULL;
 }
 
+/* Evaluate "qp" in the void point "pnt".
+ * In particular, return the value NaN.
+ */
+static __isl_give isl_val *eval_void(__isl_take isl_qpolynomial *qp,
+	__isl_take isl_point *pnt)
+{
+	isl_ctx *ctx;
+
+	ctx = isl_point_get_ctx(pnt);
+	isl_qpolynomial_free(qp);
+	isl_point_free(pnt);
+	return isl_val_nan(ctx);
+}
+
 __isl_give isl_val *isl_qpolynomial_eval(__isl_take isl_qpolynomial *qp,
 	__isl_take isl_point *pnt)
 {
+	isl_bool is_void;
 	isl_vec *ext;
 	isl_val *v;
 
 	if (!qp || !pnt)
 		goto error;
 	isl_assert(pnt->dim->ctx, isl_space_is_equal(pnt->dim, qp->dim), goto error);
+	is_void = isl_point_is_void(pnt);
+	if (is_void < 0)
+		goto error;
+	if (is_void)
+		return eval_void(qp, pnt);
 
-	if (qp->div->n_row == 0)
-		ext = isl_vec_copy(pnt->vec);
-	else {
-		int i;
-		unsigned dim = isl_space_dim(qp->dim, isl_dim_all);
-		ext = isl_vec_alloc(qp->dim->ctx, 1 + dim + qp->div->n_row);
-		if (!ext)
-			goto error;
-
-		isl_seq_cpy(ext->el, pnt->vec->el, pnt->vec->size);
-		for (i = 0; i < qp->div->n_row; ++i) {
-			isl_seq_inner_product(qp->div->rowi + 1, ext->el,
-						1 + dim + i, &ext->el1+dim+i);
-			isl_int_fdiv_q(ext->el1+dim+i, ext->el1+dim+i,
-					qp->div->rowi0);
-		}
-	}
+	ext = isl_local_extend_point_vec(qp->div, isl_vec_copy(pnt->vec));
 
-	v = isl_upoly_eval(isl_upoly_copy(qp->upoly), ext);
+	v = isl_poly_eval(isl_poly_copy(qp->poly), ext);
 
 	isl_qpolynomial_free(qp);
 	isl_point_free(pnt);
@@ -2960,8 +3301,7 @@
 	return NULL;
 }
 
-int isl_upoly_cmp(__isl_keep struct isl_upoly_cst *cst1,
-	__isl_keep struct isl_upoly_cst *cst2)
+int isl_poly_cmp(__isl_keep isl_poly_cst *cst1, __isl_keep isl_poly_cst *cst2)
 {
 	int cmp;
 	isl_int t;
@@ -2987,8 +3327,9 @@
 		isl_die(qp->div->ctx, isl_error_invalid,
 			"cannot insert output/set dimensions",
 			goto error);
-	if (type == isl_dim_in)
-		type = isl_dim_set;
+	if (isl_qpolynomial_check_range(qp, type, first, 0) < 0)
+		return isl_qpolynomial_free(qp);
+	type = domain_type(type);
 	if (n == 0 && !isl_space_is_named_or_nested(qp->dim, type))
 		return qp;
 
@@ -2996,9 +3337,6 @@
 	if (!qp)
 		return NULL;
 
-	isl_assert(qp->div->ctx, first <= isl_space_dim(qp->dim, type),
-		    goto error);
-
 	g_pos = pos(qp->dim, type) + first;
 
 	qp->div = isl_mat_insert_zero_cols(qp->div, 2 + g_pos, n);
@@ -3013,9 +3351,9 @@
 			goto error;
 		for (i = 0; i < total - g_pos; ++i)
 			expi = i + n;
-		qp->upoly = expand(qp->upoly, exp, g_pos);
+		qp->poly = expand(qp->poly, exp, g_pos);
 		free(exp);
-		if (!qp->upoly)
+		if (!qp->poly)
 			goto error;
 	}
 
@@ -3032,24 +3370,15 @@
 __isl_give isl_qpolynomial *isl_qpolynomial_add_dims(
 	__isl_take isl_qpolynomial *qp, enum isl_dim_type type, unsigned n)
 {
-	unsigned pos;
+	isl_size pos;
 
 	pos = isl_qpolynomial_dim(qp, type);
+	if (pos < 0)
+		return isl_qpolynomial_free(qp);
 
 	return isl_qpolynomial_insert_dims(qp, type, pos, n);
 }
 
-__isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_add_dims(
-	__isl_take isl_pw_qpolynomial *pwqp,
-	enum isl_dim_type type, unsigned n)
-{
-	unsigned pos;
-
-	pos = isl_pw_qpolynomial_dim(pwqp, type);
-
-	return isl_pw_qpolynomial_insert_dims(pwqp, type, pos, n);
-}
-
 static int *reordering_move(isl_ctx *ctx,
 	unsigned len, unsigned dst, unsigned src, unsigned n)
 {
@@ -3092,10 +3421,6 @@
 	unsigned g_src_pos;
 	int *reordering;
 
-	if (n == 0)
-		return qp;
-
-	qp = isl_qpolynomial_cow(qp);
 	if (!qp)
 		return NULL;
 
@@ -3103,13 +3428,21 @@
 		isl_die(qp->dim->ctx, isl_error_invalid,
 			"cannot move output/set dimension",
 			goto error);
+	if (isl_qpolynomial_check_range(qp, src_type, src_pos, n) < 0)
+		return isl_qpolynomial_free(qp);
 	if (dst_type == isl_dim_in)
 		dst_type = isl_dim_set;
 	if (src_type == isl_dim_in)
 		src_type = isl_dim_set;
 
-	isl_assert(qp->dim->ctx, src_pos + n <= isl_space_dim(qp->dim, src_type),
-		goto error);
+	if (n == 0 &&
+	    !isl_space_is_named_or_nested(qp->dim, src_type) &&
+	    !isl_space_is_named_or_nested(qp->dim, dst_type))
+		return qp;
+
+	qp = isl_qpolynomial_cow(qp);
+	if (!qp)
+		return NULL;
 
 	g_dst_pos = pos(qp->dim, dst_type) + dst_pos;
 	g_src_pos = pos(qp->dim, src_type) + src_pos;
@@ -3128,9 +3461,9 @@
 	if (!reordering)
 		goto error;
 
-	qp->upoly = reorder(qp->upoly, reordering);
+	qp->poly = reorder(qp->poly, reordering);
 	free(reordering);
-	if (!qp->upoly)
+	if (!qp->poly)
 		goto error;
 
 	qp->dim = isl_space_move_dims(qp->dim, dst_type, dst_pos, src_type, src_pos, n);
@@ -3143,36 +3476,37 @@
 	return NULL;
 }
 
-__isl_give isl_qpolynomial *isl_qpolynomial_from_affine(__isl_take isl_space *dim,
-	isl_int *f, isl_int denom)
+__isl_give isl_qpolynomial *isl_qpolynomial_from_affine(
+	__isl_take isl_space *space, isl_int *f, isl_int denom)
 {
-	struct isl_upoly *up;
+	isl_size d;
+	isl_poly *poly;
 
-	dim = isl_space_domain(dim);
-	if (!dim)
+	space = isl_space_domain(space);
+	if (!space)
 		return NULL;
 
-	up = isl_upoly_from_affine(dim->ctx, f, denom,
-					1 + isl_space_dim(dim, isl_dim_all));
+	d = isl_space_dim(space, isl_dim_all);
+	poly = d < 0 ? NULL : isl_poly_from_affine(space->ctx, f, denom, 1 + d);
 
-	return isl_qpolynomial_alloc(dim, 0, up);
+	return isl_qpolynomial_alloc(space, 0, poly);
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_from_aff(__isl_take isl_aff *aff)
 {
 	isl_ctx *ctx;
-	struct isl_upoly *up;
+	isl_poly *poly;
 	isl_qpolynomial *qp;
 
 	if (!aff)
 		return NULL;
 
 	ctx = isl_aff_get_ctx(aff);
-	up = isl_upoly_from_affine(ctx, aff->v->el + 1, aff->v->el0,
+	poly = isl_poly_from_affine(ctx, aff->v->el + 1, aff->v->el0,
 				    aff->v->size - 1);
 
 	qp = isl_qpolynomial_alloc(isl_aff_get_domain_space(aff),
-				    aff->ls->div->n_row, up);
+				    aff->ls->div->n_row, poly);
 	if (!qp)
 		goto error;
 
@@ -3235,7 +3569,7 @@
 	__isl_keep isl_qpolynomial **subs)
 {
 	int i;
-	struct isl_upoly **ups;
+	isl_poly **polys;
 
 	if (n == 0)
 		return qp;
@@ -3248,19 +3582,17 @@
 		isl_die(qp->dim->ctx, isl_error_invalid,
 			"cannot substitute output/set dimension",
 			goto error);
-	if (type == isl_dim_in)
-		type = isl_dim_set;
+	if (isl_qpolynomial_check_range(qp, type, first, n) < 0)
+		return isl_qpolynomial_free(qp);
+	type = domain_type(type);
 
 	for (i = 0; i < n; ++i)
 		if (!subsi)
 			goto error;
 
-	isl_assert(qp->dim->ctx, first + n <= isl_space_dim(qp->dim, type),
-			goto error);
-
 	for (i = 0; i < n; ++i)
-		isl_assert(qp->dim->ctx, isl_space_is_equal(qp->dim, subsi->dim),
-				goto error);
+		if (isl_qpolynomial_check_equal_space(qp, subsi) < 0)
+			goto error;
 
 	isl_assert(qp->dim->ctx, qp->div->n_row == 0, goto error);
 	for (i = 0; i < n; ++i)
@@ -3268,17 +3600,17 @@
 
 	first += pos(qp->dim, type);
 
-	ups = isl_alloc_array(qp->dim->ctx, struct isl_upoly *, n);
-	if (!ups)
+	polys = isl_alloc_array(qp->dim->ctx, struct isl_poly *, n);
+	if (!polys)
 		goto error;
 	for (i = 0; i < n; ++i)
-		upsi = subsi->upoly;
+		polysi = subsi->poly;
 
-	qp->upoly = isl_upoly_subs(qp->upoly, first, n, ups);
+	qp->poly = isl_poly_subs(qp->poly, first, n, polys);
 
-	free(ups);
+	free(polys);
 
-	if (!qp->upoly)
+	if (!qp->poly)
 		goto error;
 
 	return qp;
@@ -3292,60 +3624,65 @@
  * that results from replacing each of the integer divisions by the
  * corresponding extra set dimension.
  */
-int isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
+isl_stat isl_qpolynomial_as_polynomial_on_domain(__isl_keep isl_qpolynomial *qp,
 	__isl_keep isl_basic_set *bset,
-	int (*fn)(__isl_take isl_basic_set *bset,
+	isl_stat (*fn)(__isl_take isl_basic_set *bset,
 		  __isl_take isl_qpolynomial *poly, void *user), void *user)
 {
-	isl_space *dim;
-	isl_mat *div;
+	isl_space *space;
+	isl_local_space *ls;
 	isl_qpolynomial *poly;
 
 	if (!qp || !bset)
-		goto error;
+		return isl_stat_error;
 	if (qp->div->n_row == 0)
 		return fn(isl_basic_set_copy(bset), isl_qpolynomial_copy(qp),
 			  user);
 
-	div = isl_mat_copy(qp->div);
-	dim = isl_space_copy(qp->dim);
-	dim = isl_space_add_dims(dim, isl_dim_set, qp->div->n_row);
-	poly = isl_qpolynomial_alloc(dim, 0, isl_upoly_copy(qp->upoly));
+	space = isl_space_copy(qp->dim);
+	space = isl_space_add_dims(space, isl_dim_set, qp->div->n_row);
+	poly = isl_qpolynomial_alloc(space, 0, isl_poly_copy(qp->poly));
 	bset = isl_basic_set_copy(bset);
-	bset = isl_basic_set_add_dims(bset, isl_dim_set, qp->div->n_row);
-	bset = add_div_constraints(bset, div);
+	ls = isl_qpolynomial_get_domain_local_space(qp);
+	bset = isl_local_space_lift_basic_set(ls, bset);
 
 	return fn(bset, poly, user);
-error:
-	return -1;
 }
 
 /* Return total degree in variables first (inclusive) up to last (exclusive).
  */
-int isl_upoly_degree(__isl_keep struct isl_upoly *up, int first, int last)
+int isl_poly_degree(__isl_keep isl_poly *poly, int first, int last)
 {
 	int deg = -1;
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_zero, is_cst;
+	isl_poly_rec *rec;
 
-	if (!up)
+	is_zero = isl_poly_is_zero(poly);
+	if (is_zero < 0)
 		return -2;
-	if (isl_upoly_is_zero(up))
+	if (is_zero)
 		return -1;
-	if (isl_upoly_is_cst(up) || up->var < first)
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return -2;
+	if (is_cst || poly->var < first)
 		return 0;
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		return -2;
 
 	for (i = 0; i < rec->n; ++i) {
 		int d;
 
-		if (isl_upoly_is_zero(rec->pi))
+		is_zero = isl_poly_is_zero(rec->pi);
+		if (is_zero < 0)
+			return -2;
+		if (is_zero)
 			continue;
-		d = isl_upoly_degree(rec->pi, first, last);
-		if (up->var < last)
+		d = isl_poly_degree(rec->pi, first, last);
+		if (poly->var < last)
 			d += i;
 		if (d > deg)
 			deg = d;
@@ -3359,61 +3696,64 @@
 int isl_qpolynomial_degree(__isl_keep isl_qpolynomial *poly)
 {
 	unsigned ovar;
-	unsigned nvar;
+	isl_size nvar;
 
 	if (!poly)
 		return -2;
 
 	ovar = isl_space_offset(poly->dim, isl_dim_set);
 	nvar = isl_space_dim(poly->dim, isl_dim_set);
-	return isl_upoly_degree(poly->upoly, ovar, ovar + nvar);
+	if (nvar < 0)
+		return -2;
+	return isl_poly_degree(poly->poly, ovar, ovar + nvar);
 }
 
-__isl_give struct isl_upoly *isl_upoly_coeff(__isl_keep struct isl_upoly *up,
+__isl_give isl_poly *isl_poly_coeff(__isl_keep isl_poly *poly,
 	unsigned pos, int deg)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_cst;
+	isl_poly_rec *rec;
 
-	if (!up)
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
 		return NULL;
-
-	if (isl_upoly_is_cst(up) || up->var < pos) {
+	if (is_cst || poly->var < pos) {
 		if (deg == 0)
-			return isl_upoly_copy(up);
+			return isl_poly_copy(poly);
 		else
-			return isl_upoly_zero(up->ctx);
+			return isl_poly_zero(poly->ctx);
 	}
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		return NULL;
 
-	if (up->var == pos) {
+	if (poly->var == pos) {
 		if (deg < rec->n)
-			return isl_upoly_copy(rec->pdeg);
+			return isl_poly_copy(rec->pdeg);
 		else
-			return isl_upoly_zero(up->ctx);
+			return isl_poly_zero(poly->ctx);
 	}
 
-	up = isl_upoly_copy(up);
-	up = isl_upoly_cow(up);
-	rec = isl_upoly_as_rec(up);
+	poly = isl_poly_copy(poly);
+	poly = isl_poly_cow(poly);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
 	for (i = 0; i < rec->n; ++i) {
-		struct isl_upoly *t;
-		t = isl_upoly_coeff(rec->pi, pos, deg);
+		isl_poly *t;
+		t = isl_poly_coeff(rec->pi, pos, deg);
 		if (!t)
 			goto error;
-		isl_upoly_free(rec->pi);
+		isl_poly_free(rec->pi);
 		rec->pi = t;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
@@ -3424,7 +3764,7 @@
 	enum isl_dim_type type, unsigned t_pos, int deg)
 {
 	unsigned g_pos;
-	struct isl_upoly *up;
+	isl_poly *poly;
 	isl_qpolynomial *c;
 
 	if (!qp)
@@ -3434,16 +3774,15 @@
 		isl_die(qp->div->ctx, isl_error_invalid,
 			"output/set dimension does not have a coefficient",
 			return NULL);
-	if (type == isl_dim_in)
-		type = isl_dim_set;
-
-	isl_assert(qp->div->ctx, t_pos < isl_space_dim(qp->dim, type),
-			return NULL);
+	if (isl_qpolynomial_check_range(qp, type, t_pos, 1) < 0)
+		return NULL;
+	type = domain_type(type);
 
 	g_pos = pos(qp->dim, type) + t_pos;
-	up = isl_upoly_coeff(qp->upoly, g_pos, deg);
+	poly = isl_poly_coeff(qp->poly, g_pos, deg);
 
-	c = isl_qpolynomial_alloc(isl_space_copy(qp->dim), qp->div->n_row, up);
+	c = isl_qpolynomial_alloc(isl_space_copy(qp->dim),
+				qp->div->n_row, poly);
 	if (!c)
 		return NULL;
 	isl_mat_free(c->div);
@@ -3460,49 +3799,56 @@
  * last (exclusive) by inserting powers of variable first.
  * Variable first is assumed not to appear in the input.
  */
-__isl_give struct isl_upoly *isl_upoly_homogenize(
-	__isl_take struct isl_upoly *up, int deg, int target,
-	int first, int last)
+__isl_give isl_poly *isl_poly_homogenize(__isl_take isl_poly *poly, int deg,
+	int target, int first, int last)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_zero, is_cst;
+	isl_poly_rec *rec;
 
-	if (!up)
-		return NULL;
-	if (isl_upoly_is_zero(up))
-		return up;
+	is_zero = isl_poly_is_zero(poly);
+	if (is_zero < 0)
+		return isl_poly_free(poly);
+	if (is_zero)
+		return poly;
 	if (deg == target)
-		return up;
-	if (isl_upoly_is_cst(up) || up->var < first) {
-		struct isl_upoly *hom;
+		return poly;
+	is_cst = isl_poly_is_cst(poly);
+	if (is_cst < 0)
+		return isl_poly_free(poly);
+	if (is_cst || poly->var < first) {
+		isl_poly *hom;
 
-		hom = isl_upoly_var_pow(up->ctx, first, target - deg);
+		hom = isl_poly_var_pow(poly->ctx, first, target - deg);
 		if (!hom)
 			goto error;
-		rec = isl_upoly_as_rec(hom);
-		rec->ptarget - deg = isl_upoly_mul(rec->ptarget - deg, up);
+		rec = isl_poly_as_rec(hom);
+		rec->ptarget - deg = isl_poly_mul(rec->ptarget - deg, poly);
 
 		return hom;
 	}
 
-	up = isl_upoly_cow(up);
-	rec = isl_upoly_as_rec(up);
+	poly = isl_poly_cow(poly);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
 	for (i = 0; i < rec->n; ++i) {
-		if (isl_upoly_is_zero(rec->pi))
+		is_zero = isl_poly_is_zero(rec->pi);
+		if (is_zero < 0)
+			return isl_poly_free(poly);
+		if (is_zero)
 			continue;
-		rec->pi = isl_upoly_homogenize(rec->pi,
-				up->var < last ? deg + i : i, target,
+		rec->pi = isl_poly_homogenize(rec->pi,
+				poly->var < last ? deg + i : i, target,
 				first, last);
 		if (!rec->pi)
 			goto error;
 	}
 
-	return up;
+	return poly;
 error:
-	isl_upoly_free(up);
+	isl_poly_free(poly);
 	return NULL;
 }
 
@@ -3513,7 +3859,7 @@
 	__isl_take isl_qpolynomial *poly)
 {
 	unsigned ovar;
-	unsigned nvar;
+	isl_size nvar;
 	int deg = isl_qpolynomial_degree(poly);
 
 	if (deg < -1)
@@ -3526,9 +3872,10 @@
 
 	ovar = isl_space_offset(poly->dim, isl_dim_set);
 	nvar = isl_space_dim(poly->dim, isl_dim_set);
-	poly->upoly = isl_upoly_homogenize(poly->upoly, 0, deg,
-						ovar, ovar + nvar);
-	if (!poly->upoly)
+	if (nvar < 0)
+		return isl_qpolynomial_free(poly);
+	poly->poly = isl_poly_homogenize(poly->poly, 0, deg, ovar, ovar + nvar);
+	if (!poly->poly)
 		goto error;
 
 	return poly;
@@ -3537,31 +3884,33 @@
 	return NULL;
 }
 
-__isl_give isl_term *isl_term_alloc(__isl_take isl_space *dim,
+__isl_give isl_term *isl_term_alloc(__isl_take isl_space *space,
 	__isl_take isl_mat *div)
 {
 	isl_term *term;
+	isl_size d;
 	int n;
 
-	if (!dim || !div)
+	d = isl_space_dim(space, isl_dim_all);
+	if (d < 0 || !div)
 		goto error;
 
-	n = isl_space_dim(dim, isl_dim_all) + div->n_row;
+	n = d + div->n_row;
 
-	term = isl_calloc(dim->ctx, struct isl_term,
+	term = isl_calloc(space->ctx, struct isl_term,
 			sizeof(struct isl_term) + (n - 1) * sizeof(int));
 	if (!term)
 		goto error;
 
 	term->ref = 1;
-	term->dim = dim;
+	term->dim = space;
 	term->div = div;
 	isl_int_init(term->n);
 	isl_int_init(term->d);
 	
 	return term;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(div);
 	return NULL;
 }
@@ -3579,13 +3928,12 @@
 {
 	int i;
 	isl_term *dup;
-	unsigned total;
+	isl_size total;
 
-	if (!term)
+	total = isl_term_dim(term, isl_dim_all);
+	if (total < 0)
 		return NULL;
 
-	total = isl_space_dim(term->dim, isl_dim_all) + term->div->n_row;
-
 	dup = isl_term_alloc(isl_space_copy(term->dim), isl_mat_copy(term->div));
 	if (!dup)
 		return NULL;
@@ -3610,34 +3958,69 @@
 	return isl_term_dup(term);
 }
 
-void isl_term_free(__isl_take isl_term *term)
+__isl_null isl_term *isl_term_free(__isl_take isl_term *term)
 {
 	if (!term)
-		return;
+		return NULL;
 
 	if (--term->ref > 0)
-		return;
+		return NULL;
 
 	isl_space_free(term->dim);
 	isl_mat_free(term->div);
 	isl_int_clear(term->n);
 	isl_int_clear(term->d);
 	free(term);
+
+	return NULL;
 }
 
-unsigned isl_term_dim(__isl_keep isl_term *term, enum isl_dim_type type)
+isl_size isl_term_dim(__isl_keep isl_term *term, enum isl_dim_type type)
 {
+	isl_size dim;
+
 	if (!term)
-		return 0;
+		return isl_size_error;
 
 	switch (type) {
 	case isl_dim_param:
 	case isl_dim_in:
 	case isl_dim_out:	return isl_space_dim(term->dim, type);
 	case isl_dim_div:	return term->div->n_row;
-	case isl_dim_all:	return isl_space_dim(term->dim, isl_dim_all) +
-								term->div->n_row;
-	default:		return 0;
+	case isl_dim_all:	dim = isl_space_dim(term->dim, isl_dim_all);
+				if (dim < 0)
+					return isl_size_error;
+				return dim + term->div->n_row;
+	default:		return isl_size_error;
+	}
+}
+
+/* Return the space of "term".
+ */
+static __isl_keep isl_space *isl_term_peek_space(__isl_keep isl_term *term)
+{
+	return term ? term->dim : NULL;
+}
+
+/* Return the offset of the first variable of type "type" within
+ * the variables of "term".
+ */
+static isl_size isl_term_offset(__isl_keep isl_term *term,
+	enum isl_dim_type type)
+{
+	isl_space *space;
+
+	space = isl_term_peek_space(term);
+	if (!space)
+		return isl_size_error;
+
+	switch (type) {
+	case isl_dim_param:
+	case isl_dim_set:	return isl_space_offset(space, type);
+	case isl_dim_div:	return isl_space_dim(space, isl_dim_all);
+	default:
+		isl_die(isl_term_get_ctx(term), isl_error_invalid,
+			"invalid dimension type", return isl_size_error);
 	}
 }
 
@@ -3653,13 +4036,6 @@
 	isl_int_set(*n, term->n);
 }
 
-void isl_term_get_den(__isl_keep isl_term *term, isl_int *d)
-{
-	if (!term)
-		return;
-	isl_int_set(*d, term->d);
-}
-
 /* Return the coefficient of the term "term".
  */
 __isl_give isl_val *isl_term_get_coefficient_val(__isl_keep isl_term *term)
@@ -3671,20 +4047,23 @@
 					term->n, term->d);
 }
 
-int isl_term_get_exp(__isl_keep isl_term *term,
+#undef TYPE
+#define TYPE	isl_term
+static
+#include "check_type_range_templ.c"
+
+isl_size isl_term_get_exp(__isl_keep isl_term *term,
 	enum isl_dim_type type, unsigned pos)
 {
-	if (!term)
-		return -1;
+	isl_size offset;
 
-	isl_assert(term->dim->ctx, pos < isl_term_dim(term, type), return -1);
+	if (isl_term_check_range(term, type, pos, 1) < 0)
+		return isl_size_error;
+	offset = isl_term_offset(term, type);
+	if (offset < 0)
+		return isl_size_error;
 
-	if (type >= isl_dim_set)
-		pos += isl_space_dim(term->dim, isl_dim_param);
-	if (type >= isl_dim_div)
-		pos += isl_space_dim(term->dim, isl_dim_set);
-
-	return term->powpos;
+	return term->powoffset + pos;
 }
 
 __isl_give isl_aff *isl_term_get_div(__isl_keep isl_term *term, unsigned pos)
@@ -3692,12 +4071,9 @@
 	isl_local_space *ls;
 	isl_aff *aff;
 
-	if (!term)
+	if (isl_term_check_range(term, isl_dim_div, pos, 1) < 0)
 		return NULL;
 
-	isl_assert(term->dim->ctx, pos < isl_term_dim(term, isl_dim_div),
-			return NULL);
-
 	ls = isl_local_space_alloc_div(isl_space_copy(term->dim),
 					isl_mat_copy(term->div));
 	aff = isl_aff_alloc(ls);
@@ -3711,26 +4087,37 @@
 	return aff;
 }
 
-__isl_give isl_term *isl_upoly_foreach_term(__isl_keep struct isl_upoly *up,
-	int (*fn)(__isl_take isl_term *term, void *user),
+__isl_give isl_term *isl_poly_foreach_term(__isl_keep isl_poly *poly,
+	isl_stat (*fn)(__isl_take isl_term *term, void *user),
 	__isl_take isl_term *term, void *user)
 {
 	int i;
-	struct isl_upoly_rec *rec;
+	isl_bool is_zero, is_bad, is_cst;
+	isl_poly_rec *rec;
 
-	if (!up || !term)
+	is_zero = isl_poly_is_zero(poly);
+	if (is_zero < 0 || !term)
 		goto error;
 
-	if (isl_upoly_is_zero(up))
+	if (is_zero)
 		return term;
 
-	isl_assert(up->ctx, !isl_upoly_is_nan(up), goto error);
-	isl_assert(up->ctx, !isl_upoly_is_infty(up), goto error);
-	isl_assert(up->ctx, !isl_upoly_is_neginfty(up), goto error);
-
-	if (isl_upoly_is_cst(up)) {
-		struct isl_upoly_cst *cst;
-		cst = isl_upoly_as_cst(up);
+	is_cst = isl_poly_is_cst(poly);
+	is_bad = isl_poly_is_nan(poly);
+	if (is_bad >= 0 && !is_bad)
+		is_bad = isl_poly_is_infty(poly);
+	if (is_bad >= 0 && !is_bad)
+		is_bad = isl_poly_is_neginfty(poly);
+	if (is_cst < 0 || is_bad < 0)
+		return isl_term_free(term);
+	if (is_bad)
+		isl_die(isl_term_get_ctx(term), isl_error_invalid,
+			"cannot handle NaN/infty polynomial",
+			return isl_term_free(term));
+
+	if (is_cst) {
+		isl_poly_cst *cst;
+		cst = isl_poly_as_cst(poly);
 		if (!cst)
 			goto error;
 		term = isl_term_cow(term);
@@ -3743,7 +4130,7 @@
 		return term;
 	}
 
-	rec = isl_upoly_as_rec(up);
+	rec = isl_poly_as_rec(poly);
 	if (!rec)
 		goto error;
 
@@ -3751,12 +4138,15 @@
 		term = isl_term_cow(term);
 		if (!term)
 			goto error;
-		term->powup->var = i;
-		term = isl_upoly_foreach_term(rec->pi, fn, term, user);
+		term->powpoly->var = i;
+		term = isl_poly_foreach_term(rec->pi, fn, term, user);
 		if (!term)
 			goto error;
 	}
-	term->powup->var = 0;
+	term = isl_term_cow(term);
+	if (!term)
+		return NULL;
+	term->powpoly->var = 0;
 
 	return term;
 error:
@@ -3764,45 +4154,48 @@
 	return NULL;
 }
 
-int isl_qpolynomial_foreach_term(__isl_keep isl_qpolynomial *qp,
-	int (*fn)(__isl_take isl_term *term, void *user), void *user)
+isl_stat isl_qpolynomial_foreach_term(__isl_keep isl_qpolynomial *qp,
+	isl_stat (*fn)(__isl_take isl_term *term, void *user), void *user)
 {
 	isl_term *term;
 
 	if (!qp)
-		return -1;
+		return isl_stat_error;
 
 	term = isl_term_alloc(isl_space_copy(qp->dim), isl_mat_copy(qp->div));
 	if (!term)
-		return -1;
+		return isl_stat_error;
 
-	term = isl_upoly_foreach_term(qp->upoly, fn, term, user);
+	term = isl_poly_foreach_term(qp->poly, fn, term, user);
 
 	isl_term_free(term);
 
-	return term ? 0 : -1;
+	return term ? isl_stat_ok : isl_stat_error;
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_from_term(__isl_take isl_term *term)
 {
-	struct isl_upoly *up;
+	isl_poly *poly;
 	isl_qpolynomial *qp;
-	int i, n;
+	int i;
+	isl_size n;
 
+	n = isl_term_dim(term, isl_dim_all);
+	if (n < 0)
+		term = isl_term_free(term);
 	if (!term)
 		return NULL;
 
-	n = isl_space_dim(term->dim, isl_dim_all) + term->div->n_row;
-
-	up = isl_upoly_rat_cst(term->dim->ctx, term->n, term->d);
+	poly = isl_poly_rat_cst(term->dim->ctx, term->n, term->d);
 	for (i = 0; i < n; ++i) {
 		if (!term->powi)
 			continue;
-		up = isl_upoly_mul(up,
-			isl_upoly_var_pow(term->dim->ctx, i, term->powi));
+		poly = isl_poly_mul(poly,
+			    isl_poly_var_pow(term->dim->ctx, i, term->powi));
 	}
 
-	qp = isl_qpolynomial_alloc(isl_space_copy(term->dim), term->div->n_row, up);
+	qp = isl_qpolynomial_alloc(isl_space_copy(term->dim),
+				    term->div->n_row, poly);
 	if (!qp)
 		goto error;
 	isl_mat_free(qp->div);
@@ -3819,17 +4212,17 @@
 }
 
 __isl_give isl_qpolynomial *isl_qpolynomial_lift(__isl_take isl_qpolynomial *qp,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
 	int i;
 	int extra;
-	unsigned total;
+	isl_size total, d_set, d_qp;
 
-	if (!qp || !dim)
+	if (!qp || !space)
 		goto error;
 
-	if (isl_space_is_equal(qp->dim, dim)) {
-		isl_space_free(dim);
+	if (isl_space_is_equal(qp->dim, space)) {
+		isl_space_free(space);
 		return qp;
 	}
 
@@ -3837,9 +4230,12 @@
 	if (!qp)
 		goto error;
 
-	extra = isl_space_dim(dim, isl_dim_set) -
-			isl_space_dim(qp->dim, isl_dim_set);
+	d_set = isl_space_dim(space, isl_dim_set);
+	d_qp = isl_qpolynomial_domain_dim(qp, isl_dim_set);
+	extra = d_set - d_qp;
 	total = isl_space_dim(qp->dim, isl_dim_all);
+	if (d_set < 0 || d_qp < 0 || total < 0)
+		goto error;
 	if (qp->div->n_row) {
 		int *exp;
 
@@ -3848,9 +4244,9 @@
 			goto error;
 		for (i = 0; i < qp->div->n_row; ++i)
 			expi = extra + i;
-		qp->upoly = expand(qp->upoly, exp, total);
+		qp->poly = expand(qp->poly, exp, total);
 		free(exp);
-		if (!qp->upoly)
+		if (!qp->poly)
 			goto error;
 	}
 	qp->div = isl_mat_insert_cols(qp->div, 2 + total, extra);
@@ -3860,11 +4256,11 @@
 		isl_seq_clr(qp->div->rowi + 2 + total, extra);
 
 	isl_space_free(qp->dim);
-	qp->dim = dim;
+	qp->dim = space;
 
 	return qp;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_qpolynomial_free(qp);
 	return NULL;
 }
@@ -3877,14 +4273,14 @@
 {
 	int *active = NULL;
 	int i;
-	int d;
-	unsigned nparam;
-	unsigned nvar;
+	isl_size d;
+	isl_size nparam;
+	isl_size nvar;
 
-	if (!set || !qp)
+	d = isl_set_dim(set, isl_dim_all);
+	if (d < 0 || !qp)
 		goto error;
 
-	d = isl_space_dim(set->dim, isl_dim_all);
 	active = isl_calloc_array(set->ctx, int, d);
 	if (set_active(qp, active) < 0)
 		goto error;
@@ -3898,8 +4294,10 @@
 		return set;
 	}
 
-	nparam = isl_space_dim(set->dim, isl_dim_param);
-	nvar = isl_space_dim(set->dim, isl_dim_set);
+	nparam = isl_set_dim(set, isl_dim_param);
+	nvar = isl_set_dim(set, isl_dim_set);
+	if (nparam < 0 || nvar < 0)
+		goto error;
 	for (i = 0; i < nparam; ++i) {
 		if (activei)
 			continue;
@@ -3929,7 +4327,7 @@
 	int max;
 };
 
-static int opt_fn(__isl_take isl_point *pnt, void *user)
+static isl_stat opt_fn(__isl_take isl_point *pnt, void *user)
 {
 	struct isl_opt_data *data = (struct isl_opt_data *)user;
 	isl_val *val;
@@ -3944,18 +4342,22 @@
 		data->opt = isl_val_min(data->opt, val);
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_val *isl_qpolynomial_opt_on_domain(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_set *set, int max)
 {
 	struct isl_opt_data data = { NULL, 1, NULL, max };
+	isl_bool is_cst;
 
 	if (!set || !qp)
 		goto error;
 
-	if (isl_upoly_is_cst(qp->upoly)) {
+	is_cst = isl_poly_is_cst(qp->poly);
+	if (is_cst < 0)
+		goto error;
+	if (is_cst) {
 		isl_set_free(set);
 		data.opt = isl_qpolynomial_get_constant_val(qp);
 		isl_qpolynomial_free(qp);
@@ -3987,35 +4389,36 @@
 	int i;
 	int n_sub;
 	isl_ctx *ctx;
-	struct isl_upoly **subs;
+	isl_space *space;
+	isl_poly **subs;
 	isl_mat *mat, *diag;
 
 	qp = isl_qpolynomial_cow(qp);
-	if (!qp || !morph)
-		goto error;
 
-	ctx = qp->dim->ctx;
-	isl_assert(ctx, isl_space_is_equal(qp->dim, morph->dom->dim), goto error);
+	space = isl_qpolynomial_peek_domain_space(qp);
+	if (isl_morph_check_applies(morph, space) < 0)
+		goto error;
 
+	ctx = isl_qpolynomial_get_ctx(qp);
 	n_sub = morph->inv->n_row - 1;
 	if (morph->inv->n_row != morph->inv->n_col)
 		n_sub += qp->div->n_row;
-	subs = isl_calloc_array(ctx, struct isl_upoly *, n_sub);
+	subs = isl_calloc_array(ctx, struct isl_poly *, n_sub);
 	if (n_sub && !subs)
 		goto error;
 
 	for (i = 0; 1 + i < morph->inv->n_row; ++i)
-		subsi = isl_upoly_from_affine(ctx, morph->inv->row1 + i,
+		subsi = isl_poly_from_affine(ctx, morph->inv->row1 + i,
 					morph->inv->row00, morph->inv->n_col);
 	if (morph->inv->n_row != morph->inv->n_col)
 		for (i = 0; i < qp->div->n_row; ++i)
 			subsmorph->inv->n_row - 1 + i =
-			    isl_upoly_var_pow(ctx, morph->inv->n_col - 1 + i, 1);
+			    isl_poly_var_pow(ctx, morph->inv->n_col - 1 + i, 1);
 
-	qp->upoly = isl_upoly_subs(qp->upoly, 0, n_sub, subs);
+	qp->poly = isl_poly_subs(qp->poly, 0, n_sub, subs);
 
 	for (i = 0; i < n_sub; ++i)
-		isl_upoly_free(subsi);
+		isl_poly_free(subsi);
 	free(subs);
 
 	diag = isl_mat_diag(ctx, 1, morph->inv->row00);
@@ -4026,7 +4429,7 @@
 	isl_space_free(qp->dim);
 	qp->dim = isl_space_copy(morph->ran->dim);
 
-	if (!qp->upoly || !qp->div || !qp->dim)
+	if (!qp->poly || !qp->div || !qp->dim)
 		goto error;
 
 	isl_morph_free(morph);
@@ -4038,72 +4441,12 @@
 	return NULL;
 }
 
-static int neg_entry(void **entry, void *user)
-{
-	isl_pw_qpolynomial **pwqp = (isl_pw_qpolynomial **)entry;
-
-	*pwqp = isl_pw_qpolynomial_neg(*pwqp);
-
-	return *pwqp ? 0 : -1;
-}
-
-__isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_neg(
-	__isl_take isl_union_pw_qpolynomial *upwqp)
-{
-	upwqp = isl_union_pw_qpolynomial_cow(upwqp);
-	if (!upwqp)
-		return NULL;
-
-	if (isl_hash_table_foreach(upwqp->dim->ctx, &upwqp->table,
-				   &neg_entry, NULL) < 0)
-		goto error;
-
-	return upwqp;
-error:
-	isl_union_pw_qpolynomial_free(upwqp);
-	return NULL;
-}
-
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_mul(
 	__isl_take isl_union_pw_qpolynomial *upwqp1,
 	__isl_take isl_union_pw_qpolynomial *upwqp2)
 {
-	return match_bin_op(upwqp1, upwqp2, &isl_pw_qpolynomial_mul);
-}
-
-/* Reorder the columns of the given div definitions according to the
- * given reordering.
- */
-static __isl_give isl_mat *reorder_divs(__isl_take isl_mat *div,
-	__isl_take isl_reordering *r)
-{
-	int i, j;
-	isl_mat *mat;
-	int extra;
-
-	if (!div || !r)
-		goto error;
-
-	extra = isl_space_dim(r->dim, isl_dim_all) + div->n_row - r->len;
-	mat = isl_mat_alloc(div->ctx, div->n_row, div->n_col + extra);
-	if (!mat)
-		goto error;
-
-	for (i = 0; i < div->n_row; ++i) {
-		isl_seq_cpy(mat->rowi, div->rowi, 2);
-		isl_seq_clr(mat->rowi + 2, mat->n_col - 2);
-		for (j = 0; j < r->len; ++j)
-			isl_int_set(mat->rowi2 + r->posj,
-				    div->rowi2 + j);
-	}
-
-	isl_reordering_free(r);
-	isl_mat_free(div);
-	return mat;
-error:
-	isl_reordering_free(r);
-	isl_mat_free(div);
-	return NULL;
+	return isl_union_pw_qpolynomial_match_bin_op(upwqp1, upwqp2,
+						&isl_pw_qpolynomial_mul);
 }
 
 /* Reorder the dimension of "qp" according to the given reordering.
@@ -4111,6 +4454,8 @@
 __isl_give isl_qpolynomial *isl_qpolynomial_realign_domain(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_reordering *r)
 {
+	isl_space *space;
+
 	qp = isl_qpolynomial_cow(qp);
 	if (!qp)
 		goto error;
@@ -4119,15 +4464,16 @@
 	if (!r)
 		goto error;
 
-	qp->div = reorder_divs(qp->div, isl_reordering_copy(r));
+	qp->div = isl_local_reorder(qp->div, isl_reordering_copy(r));
 	if (!qp->div)
 		goto error;
 
-	qp->upoly = reorder(qp->upoly, r->pos);
-	if (!qp->upoly)
+	qp->poly = reorder(qp->poly, r->pos);
+	if (!qp->poly)
 		goto error;
 
-	qp = isl_qpolynomial_reset_domain_space(qp, isl_space_copy(r->dim));
+	space = isl_reordering_get_space(r);
+	qp = isl_qpolynomial_reset_domain_space(qp, space);
 
 	isl_reordering_free(r);
 	return qp;
@@ -4140,16 +4486,17 @@
 __isl_give isl_qpolynomial *isl_qpolynomial_align_params(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_space *model)
 {
+	isl_bool equal_params;
+
 	if (!qp || !model)
 		goto error;
 
-	if (!isl_space_match(qp->dim, isl_dim_param, model, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(qp->dim, model);
+	if (equal_params < 0)
+		goto error;
+	if (!equal_params) {
 		isl_reordering *exp;
 
-		model = isl_space_drop_dims(model, isl_dim_in,
-					0, isl_space_dim(model, isl_dim_in));
-		model = isl_space_drop_dims(model, isl_dim_out,
-					0, isl_space_dim(model, isl_dim_out));
 		exp = isl_parameter_alignment_reordering(qp->dim, model);
 		exp = isl_reordering_extend_space(exp,
 					isl_qpolynomial_get_domain_space(qp));
@@ -4179,18 +4526,18 @@
  *	f - m v >= 0
  *	-f + m v + (m - 1) >= 0
  */
-static __isl_give isl_set *set_div_slice(__isl_take isl_space *dim,
+static __isl_give isl_set *set_div_slice(__isl_take isl_space *space,
 	__isl_keep isl_qpolynomial *qp, int div, isl_int v)
 {
-	int total;
+	isl_size total;
 	isl_basic_set *bset = NULL;
 	int k;
 
-	if (!dim || !qp)
+	total = isl_space_dim(space, isl_dim_all);
+	if (total < 0 || !qp)
 		goto error;
 
-	total = isl_space_dim(dim, isl_dim_all);
-	bset = isl_basic_set_alloc_space(isl_space_copy(dim), 0, 0, 2);
+	bset = isl_basic_set_alloc_space(isl_space_copy(space), 0, 0, 2);
 
 	k = isl_basic_set_alloc_inequality(bset);
 	if (k < 0)
@@ -4206,61 +4553,60 @@
 	isl_int_add(bset->ineqk0, bset->ineqk0, qp->div->rowdiv0);
 	isl_int_sub_ui(bset->ineqk0, bset->ineqk0, 1);
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	return isl_set_from_basic_set(bset);
 error:
 	isl_basic_set_free(bset);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-static int split_periods(__isl_take isl_set *set,
+static isl_stat split_periods(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial *qp, void *user);
 
 /* Create a slice of the domain "set" such that integer division "div"
  * has the fixed value "v" and add the results to data->res,
  * replacing the integer division by "v" in "qp".
  */
-static int set_div(__isl_take isl_set *set,
+static isl_stat set_div(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial *qp, int div, isl_int v,
 	struct isl_split_periods_data *data)
 {
 	int i;
-	int total;
+	isl_size div_pos;
 	isl_set *slice;
-	struct isl_upoly *cst;
+	isl_poly *cst;
 
 	slice = set_div_slice(isl_set_get_space(set), qp, div, v);
 	set = isl_set_intersect(set, slice);
 
-	if (!qp)
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
 		goto error;
 
-	total = isl_space_dim(qp->dim, isl_dim_all);
-
 	for (i = div + 1; i < qp->div->n_row; ++i) {
-		if (isl_int_is_zero(qp->div->rowi2 + total + div))
+		if (isl_int_is_zero(qp->div->rowi2 + div_pos + div))
 			continue;
 		isl_int_addmul(qp->div->rowi1,
-				qp->div->rowi2 + total + div, v);
-		isl_int_set_si(qp->div->rowi2 + total + div, 0);
+				qp->div->rowi2 + div_pos + div, v);
+		isl_int_set_si(qp->div->rowi2 + div_pos + div, 0);
 	}
 
-	cst = isl_upoly_rat_cst(qp->dim->ctx, v, qp->dim->ctx->one);
+	cst = isl_poly_rat_cst(qp->dim->ctx, v, qp->dim->ctx->one);
 	qp = substitute_div(qp, div, cst);
 
 	return split_periods(set, qp, data);
 error:
 	isl_set_free(set);
 	isl_qpolynomial_free(qp);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Split the domain "set" such that integer division "div"
  * has a fixed value (ranging from "min" to "max") on each slice
  * and add the results to data->res.
  */
-static int split_div(__isl_take isl_set *set,
+static isl_stat split_div(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial *qp, int div, isl_int min, isl_int max,
 	struct isl_split_periods_data *data)
 {
@@ -4273,11 +4619,11 @@
 	}
 	isl_set_free(set);
 	isl_qpolynomial_free(qp);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(set);
 	isl_qpolynomial_free(qp);
-	return -1;
+	return isl_stat_error;
 }
 
 /* If "qp" refers to any integer division
@@ -4286,15 +4632,15 @@
  * Add the results (or the original if no splitting occurs)
  * to data->res.
  */
-static int split_periods(__isl_take isl_set *set,
+static isl_stat split_periods(__isl_take isl_set *set,
 	__isl_take isl_qpolynomial *qp, void *user)
 {
 	int i;
 	isl_pw_qpolynomial *pwqp;
 	struct isl_split_periods_data *data;
 	isl_int min, max;
-	int total;
-	int r = 0;
+	isl_size div_pos;
+	isl_stat r = isl_stat_ok;
 
 	data = (struct isl_split_periods_data *)user;
 
@@ -4304,16 +4650,19 @@
 	if (qp->div->n_row == 0) {
 		pwqp = isl_pw_qpolynomial_alloc(set, qp);
 		data->res = isl_pw_qpolynomial_add_disjoint(data->res, pwqp);
-		return 0;
+		return isl_stat_ok;
 	}
 
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		goto error;
+
 	isl_int_init(min);
 	isl_int_init(max);
-	total = isl_space_dim(qp->dim, isl_dim_all);
 	for (i = 0; i < qp->div->n_row; ++i) {
 		enum isl_lp_result lp_res;
 
-		if (isl_seq_first_non_zero(qp->div->rowi + 2 + total,
+		if (isl_seq_first_non_zero(qp->div->rowi + 2 + div_pos,
 						qp->div->n_row) != -1)
 			continue;
 
@@ -4357,7 +4706,7 @@
 error:
 	isl_set_free(set);
 	isl_qpolynomial_free(qp);
-	return -1;
+	return isl_stat_error;
 }
 
 /* If any quasi-polynomial in pwqp refers to any integer division
@@ -4389,27 +4738,87 @@
  *	0	if cst == 0
  *	1	if cst == 1
  *  infinity	if cst == -1
+ *
+ * If cst == -1, then explicitly check whether the domain is empty and,
+ * if so, return 0 instead.
  */
 static __isl_give isl_pw_qpolynomial *constant_on_domain(
 	__isl_take isl_basic_set *bset, int cst)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_qpolynomial *qp;
 
+	if (cst < 0 && isl_basic_set_is_empty(bset) == isl_bool_true)
+		cst = 0;
 	if (!bset)
 		return NULL;
 
 	bset = isl_basic_set_params(bset);
-	dim = isl_basic_set_get_space(bset);
+	space = isl_basic_set_get_space(bset);
 	if (cst < 0)
-		qp = isl_qpolynomial_infty_on_domain(dim);
+		qp = isl_qpolynomial_infty_on_domain(space);
 	else if (cst == 0)
-		qp = isl_qpolynomial_zero_on_domain(dim);
+		qp = isl_qpolynomial_zero_on_domain(space);
 	else
-		qp = isl_qpolynomial_one_on_domain(dim);
+		qp = isl_qpolynomial_one_on_domain(space);
 	return isl_pw_qpolynomial_alloc(isl_set_from_basic_set(bset), qp);
 }
 
+/* Internal data structure for multiplicative_call_factor_pw_qpolynomial.
+ * "fn" is the function that is called on each factor.
+ * "pwpq" collects the results.
+ */
+struct isl_multiplicative_call_data_pw_qpolynomial {
+	__isl_give isl_pw_qpolynomial *(*fn)(__isl_take isl_basic_set *bset);
+	isl_pw_qpolynomial *pwqp;
+};
+
+/* Call "fn" on "bset" and return the result,
+ * but first check if "bset" has any redundant constraints or
+ * implicit equality constraints.
+ * If so, there may be further opportunities for detecting factors or
+ * removing equality constraints, so recursively call
+ * the top-level isl_basic_set_multiplicative_call.
+ */
+static __isl_give isl_pw_qpolynomial *multiplicative_call_base(
+	__isl_take isl_basic_set *bset,
+	__isl_give isl_pw_qpolynomial *(*fn)(__isl_take isl_basic_set *bset))
+{
+	isl_size n1, n2, n_eq;
+
+	n1 = isl_basic_set_n_constraint(bset);
+	if (n1 < 0)
+		bset = isl_basic_set_free(bset);
+	bset = isl_basic_set_remove_redundancies(bset);
+	bset = isl_basic_set_detect_equalities(bset);
+	n2 = isl_basic_set_n_constraint(bset);
+	n_eq = isl_basic_set_n_equality(bset);
+	if (n2 < 0 || n_eq < 0)
+		bset = isl_basic_set_free(bset);
+	else if (n2 < n1 || n_eq > 0)
+		return isl_basic_set_multiplicative_call(bset, fn);
+	return fn(bset);
+}
+
+/* isl_factorizer_every_factor_basic_set callback that applies
+ * data->fn to the factor "bset" and multiplies in the result
+ * in data->pwqp.
+ */
+static isl_bool multiplicative_call_factor_pw_qpolynomial(
+	__isl_keep isl_basic_set *bset, void *user)
+{
+	struct isl_multiplicative_call_data_pw_qpolynomial *data = user;
+	isl_pw_qpolynomial *res;
+
+	bset = isl_basic_set_copy(bset);
+	res = multiplicative_call_base(bset, data->fn);
+	data->pwqp = isl_pw_qpolynomial_mul(data->pwqp, res);
+	if (!data->pwqp)
+		return isl_bool_error;
+
+	return isl_bool_true;
+}
+
 /* Factor bset, call fn on each of the factors and return the product.
  *
  * If no factors can be found, simply call fn on the input.
@@ -4420,57 +4829,36 @@
 	__isl_take isl_basic_set *bset,
 	__isl_give isl_pw_qpolynomial *(*fn)(__isl_take isl_basic_set *bset))
 {
-	int i, n;
-	isl_space *dim;
+	struct isl_multiplicative_call_data_pw_qpolynomial data = { fn };
+	isl_space *space;
 	isl_set *set;
 	isl_factorizer *f;
 	isl_qpolynomial *qp;
-	isl_pw_qpolynomial *pwqp;
-	unsigned nparam;
-	unsigned nvar;
+	isl_bool every;
 
 	f = isl_basic_set_factorizer(bset);
 	if (!f)
 		goto error;
 	if (f->n_group == 0) {
 		isl_factorizer_free(f);
-		return fn(bset);
+		return multiplicative_call_base(bset, fn);
 	}
 
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
-
-	dim = isl_basic_set_get_space(bset);
-	dim = isl_space_domain(dim);
-	set = isl_set_universe(isl_space_copy(dim));
-	qp = isl_qpolynomial_one_on_domain(dim);
-	pwqp = isl_pw_qpolynomial_alloc(set, qp);
-
-	bset = isl_morph_basic_set(isl_morph_copy(f->morph), bset);
-
-	for (i = 0, n = 0; i < f->n_group; ++i) {
-		isl_basic_set *bset_i;
-		isl_pw_qpolynomial *pwqp_i;
-
-		bset_i = isl_basic_set_copy(bset);
-		bset_i = isl_basic_set_drop_constraints_involving(bset_i,
-			    nparam + n + f->leni, nvar - n - f->leni);
-		bset_i = isl_basic_set_drop_constraints_involving(bset_i,
-			    nparam, n);
-		bset_i = isl_basic_set_drop(bset_i, isl_dim_set,
-			    n + f->leni, nvar - n - f->leni);
-		bset_i = isl_basic_set_drop(bset_i, isl_dim_set, 0, n);
-
-		pwqp_i = fn(bset_i);
-		pwqp = isl_pw_qpolynomial_mul(pwqp, pwqp_i);
-
-		n += f->leni;
-	}
+	space = isl_basic_set_get_space(bset);
+	space = isl_space_params(space);
+	set = isl_set_universe(isl_space_copy(space));
+	qp = isl_qpolynomial_one_on_domain(space);
+	data.pwqp = isl_pw_qpolynomial_alloc(set, qp);
+
+	every = isl_factorizer_every_factor_basic_set(f,
+			&multiplicative_call_factor_pw_qpolynomial, &data);
+	if (every < 0)
+		data.pwqp = isl_pw_qpolynomial_free(data.pwqp);
 
 	isl_basic_set_free(bset);
 	isl_factorizer_free(f);
 
-	return pwqp;
+	return data.pwqp;
 error:
 	isl_basic_set_free(bset);
 	return NULL;
@@ -4488,7 +4876,8 @@
 	__isl_take isl_basic_set *bset,
 	__isl_give isl_pw_qpolynomial *(*fn)(__isl_take isl_basic_set *bset))
 {
-	int bounded;
+	isl_bool bounded;
+	isl_size dim;
 	isl_morph *morph;
 	isl_pw_qpolynomial *pwqp;
 
@@ -4498,7 +4887,10 @@
 	if (isl_basic_set_plain_is_empty(bset))
 		return constant_on_domain(bset, 0);
 
-	if (isl_basic_set_dim(bset, isl_dim_set) == 0)
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		goto error;
+	if (dim == 0)
 		return constant_on_domain(bset, 1);
 
 	bounded = isl_basic_set_is_bounded(bset);
@@ -4535,7 +4927,7 @@
 	__isl_take isl_qpolynomial *qp, int down)
 {
 	int i;
-	struct isl_upoly *s;
+	isl_poly *s;
 
 	if (!qp)
 		return NULL;
@@ -4553,7 +4945,7 @@
 			isl_int_add_ui(qp->div->rowi1,
 				       qp->div->rowi1, 1);
 		}
-		s = isl_upoly_from_affine(qp->dim->ctx, qp->div->rowi + 1,
+		s = isl_poly_from_affine(qp->dim->ctx, qp->div->rowi + 1,
 					qp->div->rowi0, qp->div->n_col - 1);
 		qp = substitute_div(qp, i, s);
 		if (!qp)
@@ -4612,18 +5004,18 @@
 	int *signs)
 {
 	int i, j;
-	int total;
+	isl_size div_pos;
 	isl_vec *v = NULL;
-	struct isl_upoly *s;
+	isl_poly *s;
 
 	qp = isl_qpolynomial_cow(qp);
-	if (!qp)
-		return NULL;
+	div_pos = isl_qpolynomial_domain_var_offset(qp, isl_dim_div);
+	if (div_pos < 0)
+		return isl_qpolynomial_free(qp);
 	qp->div = isl_mat_cow(qp->div);
 	if (!qp->div)
 		goto error;
 
-	total = isl_space_dim(qp->dim, isl_dim_all);
 	v = isl_vec_alloc(qp->div->ctx, qp->div->n_col - 1);
 
 	for (i = 0; i < qp->div->n_row; ++i) {
@@ -4636,7 +5028,7 @@
 			isl_int_sub_ui(v->el0, v->el0, 1);
 			isl_int_submul(row1, row0, v->el0);
 		}
-		for (j = 0; j < total; ++j) {
+		for (j = 0; j < div_pos; ++j) {
 			if (isl_int_sgn(row2 + j) * signsj >= 0)
 				continue;
 			if (signsj < 0)
@@ -4646,26 +5038,27 @@
 			isl_int_submul(row2 + j, row0, v->el1 + j);
 		}
 		for (j = 0; j < i; ++j) {
-			if (isl_int_sgn(row2 + total + j) >= 0)
+			if (isl_int_sgn(row2 + div_pos + j) >= 0)
 				continue;
-			isl_int_fdiv_q(v->el1 + total + j,
-					row2 + total + j, row0);
-			isl_int_submul(row2 + total + j,
-					row0, v->el1 + total + j);
+			isl_int_fdiv_q(v->el1 + div_pos + j,
+					row2 + div_pos + j, row0);
+			isl_int_submul(row2 + div_pos + j,
+					row0, v->el1 + div_pos + j);
 		}
 		for (j = i + 1; j < qp->div->n_row; ++j) {
-			if (isl_int_is_zero(qp->div->rowj2 + total + i))
+			if (isl_int_is_zero(qp->div->rowj2 + div_pos + i))
 				continue;
 			isl_seq_combine(qp->div->rowj + 1,
 				qp->div->ctx->one, qp->div->rowj + 1,
-				qp->div->rowj2 + total + i, v->el, v->size);
+				qp->div->rowj2 + div_pos + i, v->el,
+				v->size);
 		}
-		isl_int_set_si(v->el1 + total + i, 1);
-		s = isl_upoly_from_affine(qp->dim->ctx, v->el,
+		isl_int_set_si(v->el1 + div_pos + i, 1);
+		s = isl_poly_from_affine(qp->dim->ctx, v->el,
 					qp->div->ctx->one, v->size);
-		qp->upoly = isl_upoly_subs(qp->upoly, total + i, 1, &s);
-		isl_upoly_free(s);
-		if (!qp->upoly)
+		qp->poly = isl_poly_subs(qp->poly, div_pos + i, 1, &s);
+		isl_poly_free(s);
+		if (!qp->poly)
 			goto error;
 	}
 
@@ -4691,8 +5084,8 @@
  * overapproximated by a/m, while in the second it is underapproximated
  * by (a-(m-1))/m.
  */
-static int to_polynomial_on_orthant(__isl_take isl_set *orthant, int *signs,
-	void *user)
+static isl_stat to_polynomial_on_orthant(__isl_take isl_set *orthant,
+	int *signs, void *user)
 {
 	struct isl_to_poly_data *data = user;
 	isl_pw_qpolynomial *t;
@@ -4712,7 +5105,7 @@
 	t = isl_pw_qpolynomial_alloc(orthant, qp);
 	data->res = isl_pw_qpolynomial_add_disjoint(data->res, t);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Approximate each quasipolynomial by a polynomial.  If "sign" is positive,
@@ -4766,55 +5159,47 @@
 	return NULL;
 }
 
-static int poly_entry(void **entry, void *user)
+static __isl_give isl_pw_qpolynomial *poly_entry(
+	__isl_take isl_pw_qpolynomial *pwqp, void *user)
 {
 	int *sign = user;
-	isl_pw_qpolynomial **pwqp = (isl_pw_qpolynomial **)entry;
 
-	*pwqp = isl_pw_qpolynomial_to_polynomial(*pwqp, *sign);
-
-	return *pwqp ? 0 : -1;
+	return isl_pw_qpolynomial_to_polynomial(pwqp, *sign);
 }
 
 __isl_give isl_union_pw_qpolynomial *isl_union_pw_qpolynomial_to_polynomial(
 	__isl_take isl_union_pw_qpolynomial *upwqp, int sign)
 {
-	upwqp = isl_union_pw_qpolynomial_cow(upwqp);
-	if (!upwqp)
-		return NULL;
-
-	if (isl_hash_table_foreach(upwqp->dim->ctx, &upwqp->table,
-				   &poly_entry, &sign) < 0)
-		goto error;
-
-	return upwqp;
-error:
-	isl_union_pw_qpolynomial_free(upwqp);
-	return NULL;
+	return isl_union_pw_qpolynomial_transform_inplace(upwqp,
+				   &poly_entry, &sign);
 }
 
 __isl_give isl_basic_map *isl_basic_map_from_qpolynomial(
 	__isl_take isl_qpolynomial *qp)
 {
 	int i, k;
-	isl_space *dim;
+	isl_space *space;
 	isl_vec *aff = NULL;
 	isl_basic_map *bmap = NULL;
+	isl_bool is_affine;
 	unsigned pos;
 	unsigned n_div;
 
 	if (!qp)
 		return NULL;
-	if (!isl_upoly_is_affine(qp->upoly))
+	is_affine = isl_poly_is_affine(qp->poly);
+	if (is_affine < 0)
+		goto error;
+	if (!is_affine)
 		isl_die(qp->dim->ctx, isl_error_invalid,
 			"input quasi-polynomial not affine", goto error);
 	aff = isl_qpolynomial_extract_affine(qp);
 	if (!aff)
 		goto error;
-	dim = isl_qpolynomial_get_space(qp);
-	pos = 1 + isl_space_offset(dim, isl_dim_out);
+	space = isl_qpolynomial_get_space(qp);
+	pos = 1 + isl_space_offset(space, isl_dim_out);
 	n_div = qp->div->n_row;
-	bmap = isl_basic_map_alloc_space(dim, n_div, 1, 2 * n_div);
+	bmap = isl_basic_map_alloc_space(space, n_div, 1, 2 * n_div);
 
 	for (i = 0; i < n_div; ++i) {
 		k = isl_basic_map_alloc_div(bmap);
@@ -4822,8 +5207,7 @@
 			goto error;
 		isl_seq_cpy(bmap->divk, qp->div->rowi, qp->div->n_col);
 		isl_int_set_si(bmap->divkqp->div->n_col, 0);
-		if (isl_basic_map_add_div_constraints(bmap, k) < 0)
-			goto error;
+		bmap = isl_basic_map_add_div_constraints(bmap, k);
 	}
 	k = isl_basic_map_alloc_equality(bmap);
 	if (k < 0)

_service:tar_scm:isl-0.14.tar.xz/isl_polynomial_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_polynomial_private.h Changed

@@ -5,27 +5,31 @@
 #include <isl_morph.h>
 #include <isl/polynomial.h>
 #include <isl_reordering.h>
+#include "isl_list_private.h"
 
-struct isl_upoly {
+struct isl_poly {
 	int ref;
 	struct isl_ctx *ctx;
 
 	int var;
 };
+typedef struct isl_poly isl_poly;
 
-struct isl_upoly_cst {
-	struct isl_upoly up;
+struct isl_poly_cst {
+	struct isl_poly poly;
 	isl_int n;
 	isl_int d;
 };
+typedef struct isl_poly_cst isl_poly_cst;
 
-struct isl_upoly_rec {
-	struct isl_upoly up;
+struct isl_poly_rec {
+	struct isl_poly poly;
 	int n;
 
 	size_t size;
-	struct isl_upoly *p;
+	isl_poly *p;
 };
+typedef struct isl_poly_rec isl_poly_rec;
 
 /* dim represents the domain space.
  */
@@ -34,9 +38,14 @@
 
 	isl_space *dim;
 	struct isl_mat *div;
-	struct isl_upoly *upoly;
+	isl_poly *poly;
 };
 
+#undef EL
+#define EL isl_qpolynomial
+
+#include <isl_list_templ.h>
+
 struct isl_term {
 	int ref;
 
@@ -65,6 +74,16 @@
 	struct isl_pw_qpolynomial_piece p1;
 };
 
+#undef PW
+#define PW isl_pw_qpolynomial
+
+#include <isl_pw_templ.h>
+
+#undef EL
+#define EL isl_pw_qpolynomial
+
+#include <isl_list_templ.h>
+
 /* dim represents the domain space.
  */
 struct isl_qpolynomial_fold {
@@ -73,10 +92,7 @@
 	enum isl_fold type;
 	isl_space *dim;
 
-	int n;
-
-	size_t size;
-	struct isl_qpolynomial *qp1;
+	isl_qpolynomial_list *list;
 };
 
 struct isl_pw_qpolynomial_fold_piece {
@@ -96,49 +112,67 @@
 	struct isl_pw_qpolynomial_fold_piece p1;
 };
 
+#undef PW
+#define PW isl_pw_qpolynomial_fold
+
+#include <isl_pw_templ.h>
+
+#undef EL
+#define EL isl_pw_qpolynomial_fold
+
+#include <isl_list_templ.h>
+
 void isl_term_get_num(__isl_keep isl_term *term, isl_int *n);
 
-__isl_give struct isl_upoly *isl_upoly_zero(struct isl_ctx *ctx);
-__isl_give struct isl_upoly *isl_upoly_copy(__isl_keep struct isl_upoly *up);
-__isl_give struct isl_upoly *isl_upoly_cow(__isl_take struct isl_upoly *up);
-__isl_give struct isl_upoly *isl_upoly_dup(__isl_keep struct isl_upoly *up);
-void isl_upoly_free(__isl_take struct isl_upoly *up);
-__isl_give struct isl_upoly *isl_upoly_mul(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2);
-
-int isl_upoly_is_cst(__isl_keep struct isl_upoly *up);
-int isl_upoly_is_zero(__isl_keep struct isl_upoly *up);
-int isl_upoly_is_one(__isl_keep struct isl_upoly *up);
-int isl_upoly_is_negone(__isl_keep struct isl_upoly *up);
-__isl_keep struct isl_upoly_cst *isl_upoly_as_cst(__isl_keep struct isl_upoly *up);
-__isl_keep struct isl_upoly_rec *isl_upoly_as_rec(__isl_keep struct isl_upoly *up);
-
-__isl_give struct isl_upoly *isl_upoly_sum(__isl_take struct isl_upoly *up1,
-	__isl_take struct isl_upoly *up2);
-__isl_give struct isl_upoly *isl_upoly_mul_isl_int(
-	__isl_take struct isl_upoly *up, isl_int v);
-
-__isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *dim,
-	unsigned n_div, __isl_take struct isl_upoly *up);
+__isl_give isl_poly *isl_poly_zero(struct isl_ctx *ctx);
+__isl_give isl_poly *isl_poly_copy(__isl_keep isl_poly *poly);
+__isl_give isl_poly *isl_poly_cow(__isl_take isl_poly *poly);
+__isl_give isl_poly *isl_poly_dup(__isl_keep isl_poly *poly);
+__isl_null isl_poly *isl_poly_free(__isl_take isl_poly *poly);
+__isl_give struct isl_poly *isl_poly_mul(__isl_take struct isl_poly *poly1,
+	__isl_take struct isl_poly *poly2);
+
+isl_bool isl_poly_is_cst(__isl_keep isl_poly *poly);
+isl_bool isl_poly_is_zero(__isl_keep isl_poly *poly);
+isl_bool isl_poly_is_one(__isl_keep isl_poly *poly);
+isl_bool isl_poly_is_negone(__isl_keep isl_poly *poly);
+__isl_keep isl_poly_cst *isl_poly_as_cst(__isl_keep isl_poly *poly);
+__isl_keep isl_poly_rec *isl_poly_as_rec(__isl_keep isl_poly *poly);
+
+__isl_give isl_poly *isl_poly_sum(__isl_take isl_poly *poly1,
+	__isl_take isl_poly *poly2);
+__isl_give struct isl_poly *isl_poly_mul_isl_int(
+	__isl_take isl_poly *poly, isl_int v);
+
+__isl_give isl_qpolynomial *isl_qpolynomial_alloc(__isl_take isl_space *space,
+	unsigned n_div, __isl_take isl_poly *poly);
 __isl_give isl_qpolynomial *isl_qpolynomial_cow(__isl_take isl_qpolynomial *qp);
 __isl_give isl_qpolynomial *isl_qpolynomial_dup(__isl_keep isl_qpolynomial *qp);
 
-__isl_give isl_qpolynomial *isl_qpolynomial_cst_on_domain(__isl_take isl_space *dim,
+__isl_give isl_qpolynomial *isl_qpolynomial_cst_on_domain(
+	__isl_take isl_space *domain,
 	isl_int v);
 __isl_give isl_qpolynomial *isl_qpolynomial_rat_cst_on_domain(
-	__isl_take isl_space *space, const isl_int n, const isl_int d);
-__isl_give isl_qpolynomial *isl_qpolynomial_var_pow_on_domain(__isl_take isl_space *dim,
+	__isl_take isl_space *domain, const isl_int n, const isl_int d);
+__isl_give isl_qpolynomial *isl_qpolynomial_var_pow_on_domain(
+	__isl_take isl_space *domain,
 	int pos, int power);
-int isl_qpolynomial_is_one(__isl_keep isl_qpolynomial *qp);
-int isl_qpolynomial_is_affine(__isl_keep isl_qpolynomial *qp);
-int isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
+isl_bool isl_qpolynomial_is_one(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_affine(__isl_keep isl_qpolynomial *qp);
+isl_bool isl_qpolynomial_is_cst(__isl_keep isl_qpolynomial *qp,
 	isl_int *n, isl_int *d);
 
+unsigned isl_qpolynomial_domain_offset(__isl_keep isl_qpolynomial *qp,
+	enum isl_dim_type type);
+
 __isl_give isl_qpolynomial *isl_qpolynomial_add_on_domain(
 	__isl_keep isl_set *dom,
 	__isl_take isl_qpolynomial *qp1,
 	__isl_take isl_qpolynomial *qp2);
 
+int isl_qpolynomial_plain_cmp(__isl_keep isl_qpolynomial *qp1,
+	__isl_keep isl_qpolynomial *qp2);
+
 int isl_qpolynomial_degree(__isl_keep isl_qpolynomial *poly);
 __isl_give isl_qpolynomial *isl_qpolynomial_coeff(
 	__isl_keep isl_qpolynomial *poly,
@@ -146,8 +180,8 @@
 
 __isl_give isl_vec *isl_qpolynomial_extract_affine(
 	__isl_keep isl_qpolynomial *qp);
-__isl_give isl_qpolynomial *isl_qpolynomial_from_affine(__isl_take isl_space *dim,
-	isl_int *f, isl_int denom);
+__isl_give isl_qpolynomial *isl_qpolynomial_from_affine(
+	__isl_take isl_space *space, isl_int *f, isl_int denom);
 
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_cow(
 	__isl_take isl_pw_qpolynomial *pwqp);
@@ -171,6 +205,9 @@
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_dup(
 	__isl_keep isl_qpolynomial_fold *fold);
 
+__isl_keep isl_qpolynomial_list *isl_qpolynomial_fold_peek_list(
+	__isl_keep isl_qpolynomial_fold *fold);
+
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_cow(
 	__isl_take isl_pw_qpolynomial_fold *pwf);
 
@@ -183,10 +220,14 @@
 	__isl_take isl_qpolynomial_fold *fold1,
 	__isl_take isl_qpolynomial_fold *fold2);
 
+int isl_qpolynomial_fold_plain_cmp(__isl_keep isl_qpolynomial_fold *fold1,
+	__isl_keep isl_qpolynomial_fold *fold2);
+
 __isl_give isl_val *isl_qpolynomial_fold_opt_on_domain(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_set *set, int max);
 
-int isl_pw_qpolynomial_fold_covers(__isl_keep isl_pw_qpolynomial_fold *pwf1,
+isl_bool isl_pw_qpolynomial_fold_covers(
+	__isl_keep isl_pw_qpolynomial_fold *pwf1,
 	__isl_keep isl_pw_qpolynomial_fold *pwf2);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_morph_domain(
@@ -199,9 +240,9 @@
 	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_morph *morph);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_lift(__isl_take isl_qpolynomial *qp,
-	__isl_take isl_space *dim);
+	__isl_take isl_space *space);
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_lift(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim);
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space);
 
 __isl_give isl_qpolynomial *isl_qpolynomial_substitute_equalities(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_basic_set *eq);
@@ -222,19 +263,19 @@
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_reset_space(
 	__isl_take isl_pw_qpolynomial *pwqp, __isl_take isl_space *space);
 __isl_give isl_qpolynomial *isl_qpolynomial_reset_domain_space(
-	__isl_take isl_qpolynomial *qp, __isl_take isl_space *dim);
+	__isl_take isl_qpolynomial *qp, __isl_take isl_space *space);
 __isl_give isl_qpolynomial *isl_qpolynomial_reset_space_and_domain(
 	__isl_take isl_qpolynomial *qp, __isl_take isl_space *space,
 	__isl_take isl_space *domain);
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_domain_space(
-	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *dim);
+	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space);
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_reset_space_and_domain(
 	__isl_take isl_qpolynomial_fold *fold, __isl_take isl_space *space,
 	__isl_take isl_space *domain);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_reset_domain_space(
-	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_space *dim);
+	__isl_take isl_pw_qpolynomial_fold *pwf, __isl_take isl_space *space);
 
-void isl_qpolynomial_get_den(__isl_keep isl_qpolynomial *qp, isl_int *d);
+__isl_give isl_val *isl_qpolynomial_get_den(__isl_keep isl_qpolynomial *qp);
 __isl_give isl_qpolynomial *isl_qpolynomial_add_isl_int(
 	__isl_take isl_qpolynomial *qp, isl_int v);
 __isl_give isl_qpolynomial *isl_qpolynomial_mul_isl_int(
@@ -242,6 +283,9 @@
 __isl_give isl_pw_qpolynomial *isl_pw_qpolynomial_mul_isl_int(
 	__isl_take isl_pw_qpolynomial *pwqp, isl_int v);
 
+__isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_scale(
+	__isl_take isl_qpolynomial_fold *fold, isl_int v);
+
 __isl_give isl_qpolynomial_fold *isl_qpolynomial_fold_mul_isl_int(
 	__isl_take isl_qpolynomial_fold *fold, isl_int v);
 __isl_give isl_pw_qpolynomial_fold *isl_pw_qpolynomial_fold_mul_isl_int(
@@ -251,3 +295,5 @@
 __isl_give isl_union_pw_qpolynomial_fold *
 isl_union_pw_qpolynomial_fold_mul_isl_int(
 	__isl_take isl_union_pw_qpolynomial_fold *upwf, isl_int v);
+
+ISL_DECLARE_LIST_FN_PRIVATE(qpolynomial)

_service:tar_scm:isl-0.14.tar.xz/isl_printer.c -> _service:tar_scm:isl-0.24.tar.gz/isl_printer.c Changed

@@ -1,5 +1,7 @@
 #include <string.h>
 #include <isl_int.h>
+#include <isl/id.h>
+#include <isl/id_to_id.h>
 #include <isl_printer_private.h>
 
 static __isl_give isl_printer *file_start_line(__isl_take isl_printer *p)
@@ -91,6 +93,7 @@
 		goto error;
 	for (i = 0; i < indent; ++i)
 		p->bufp->buf_n++ = ' ';
+	p->bufp->buf_n = '\0';
 	return p;
 error:
 	isl_printer_free(p);
@@ -118,6 +121,7 @@
 static __isl_give isl_printer *str_flush(__isl_take isl_printer *p)
 {
 	p->buf_n = 0;
+	p->bufp->buf_n = '\0';
 	return p;
 }
 
@@ -212,7 +216,7 @@
 
 __isl_give isl_printer *isl_printer_to_file(isl_ctx *ctx, FILE *file)
 {
-	struct isl_printer *p = isl_alloc_type(ctx, struct isl_printer);
+	struct isl_printer *p = isl_calloc_type(ctx, struct isl_printer);
 	if (!p)
 		return NULL;
 	p->ctx = ctx;
@@ -228,6 +232,7 @@
 	p->prefix = NULL;
 	p->suffix = NULL;
 	p->width = 0;
+	p->yaml_style = ISL_YAML_STYLE_FLOW;
 
 	return p;
 }
@@ -253,6 +258,7 @@
 	p->prefix = NULL;
 	p->suffix = NULL;
 	p->width = 0;
+	p->yaml_style = ISL_YAML_STYLE_FLOW;
 
 	return p;
 error:
@@ -268,6 +274,8 @@
 	free(p->indent_prefix);
 	free(p->prefix);
 	free(p->suffix);
+	free(p->yaml_state);
+	isl_id_to_id_free(p->notes);
 	isl_ctx_deref(p->ctx);
 	free(p);
 
@@ -380,6 +388,232 @@
 	return p->output_format;
 }
 
+/* Does "p" have a note with identifier "id"?
+ */
+isl_bool isl_printer_has_note(__isl_keep isl_printer *p,
+	__isl_keep isl_id *id)
+{
+	if (!p || !id)
+		return isl_bool_error;
+	if (!p->notes)
+		return isl_bool_false;
+	return isl_id_to_id_has(p->notes, id);
+}
+
+/* Retrieve the note identified by "id" from "p".
+ * The note is assumed to exist.
+ */
+__isl_give isl_id *isl_printer_get_note(__isl_keep isl_printer *p,
+	__isl_take isl_id *id)
+{
+	isl_bool has_note;
+
+	has_note = isl_printer_has_note(p, id);
+	if (has_note < 0)
+		goto error;
+	if (!has_note)
+		isl_die(isl_printer_get_ctx(p), isl_error_invalid,
+			"no such note", goto error);
+
+	return isl_id_to_id_get(p->notes, id);
+error:
+	isl_id_free(id);
+	return NULL;
+}
+
+/* Associate "note" to the identifier "id" in "p",
+ * replacing the previous note associated to the identifier, if any.
+ */
+__isl_give isl_printer *isl_printer_set_note(__isl_take isl_printer *p,
+	__isl_take isl_id *id, __isl_take isl_id *note)
+{
+	if (!p || !id || !note)
+		goto error;
+	if (!p->notes) {
+		p->notes = isl_id_to_id_alloc(isl_printer_get_ctx(p), 1);
+		if (!p->notes)
+			goto error;
+	}
+	p->notes = isl_id_to_id_set(p->notes, id, note);
+	if (!p->notes)
+		return isl_printer_free(p);
+	return p;
+error:
+	isl_printer_free(p);
+	isl_id_free(id);
+	isl_id_free(note);
+	return NULL;
+}
+
+/* Keep track of whether the printing to "p" is being performed from
+ * an isl_*_dump function as specified by "dump".
+ */
+__isl_give isl_printer *isl_printer_set_dump(__isl_take isl_printer *p,
+	int dump)
+{
+	if (!p)
+		return NULL;
+
+	p->dump = dump;
+
+	return p;
+}
+
+/* Set the YAML style of "p" to "yaml_style" and return the updated printer.
+ */
+__isl_give isl_printer *isl_printer_set_yaml_style(__isl_take isl_printer *p,
+	int yaml_style)
+{
+	if (!p)
+		return NULL;
+
+	p->yaml_style = yaml_style;
+
+	return p;
+}
+
+/* Return the YAML style of "p" or -1 on error.
+ */
+int isl_printer_get_yaml_style(__isl_keep isl_printer *p)
+{
+	if (!p)
+		return -1;
+	return p->yaml_style;
+}
+
+/* Push "state" onto the stack of currently active YAML elements and
+ * return the updated printer.
+ */
+static __isl_give isl_printer *push_state(__isl_take isl_printer *p,
+	enum isl_yaml_state state)
+{
+	if (!p)
+		return NULL;
+
+	if (p->yaml_size < p->yaml_depth + 1) {
+		enum isl_yaml_state *state;
+		state = isl_realloc_array(p->ctx, p->yaml_state,
+					enum isl_yaml_state, p->yaml_depth + 1);
+		if (!state)
+			return isl_printer_free(p);
+		p->yaml_state = state;
+		p->yaml_size = p->yaml_depth + 1;
+	}
+
+	p->yaml_statep->yaml_depth = state;
+	p->yaml_depth++;
+
+	return p;
+}
+
+/* Remove the innermost active YAML element from the stack and
+ * return the updated printer.
+ */
+static __isl_give isl_printer *pop_state(__isl_take isl_printer *p)
+{
+	if (!p)
+		return NULL;
+	p->yaml_depth--;
+	return p;
+}
+
+/* Set the state of the innermost active YAML element to "state" and
+ * return the updated printer.
+ */
+static __isl_give isl_printer *update_state(__isl_take isl_printer *p,
+	enum isl_yaml_state state)
+{
+	if (!p)
+		return NULL;
+	if (p->yaml_depth < 1)
+		isl_die(isl_printer_get_ctx(p), isl_error_invalid,
+			"not in YAML construct", return isl_printer_free(p));
+
+	p->yaml_statep->yaml_depth - 1 = state;
+
+	return p;
+}
+
+/* Return the state of the innermost active YAML element.
+ * Return isl_yaml_none if we are not inside any YAML element.
+ */
+static enum isl_yaml_state current_state(__isl_keep isl_printer *p)
+{
+	if (!p)
+		return isl_yaml_none;
+	if (p->yaml_depth < 1)
+		return isl_yaml_none;
+	return p->yaml_statep->yaml_depth - 1;
+}
+
+/* If we are printing a YAML document and we are at the start of an element,
+ * print whatever is needed before we can print the actual element and
+ * keep track of the fact that we are now printing the element.
+ * If "eol" is set, then whatever we print is going to be the last
+ * thing that gets printed on this line.
+ *
+ * If we are about the print the first key of a mapping, then nothing
+ * extra needs to be printed.  For any other key, however, we need
+ * to either move to the next line (in block format) or print a comma
+ * (in flow format).
+ * Before printing a value in a mapping, we need to print a colon.
+ *
+ * For sequences, in flow format, we only need to print a comma
+ * for each element except the first.
+ * In block format, before the first element in the sequence,
+ * we move to a new line, print a dash and increase the indentation.
+ * Before any other element, we print a dash on a new line,
+ * temporarily moving the indentation back.
+ */
+static __isl_give isl_printer *enter_state(__isl_take isl_printer *p,
+	int eol)
+{
+	enum isl_yaml_state state;
+
+	if (!p)
+		return NULL;
+
+	state = current_state(p);
+	if (state == isl_yaml_mapping_val_start) {
+		if (eol)
+			p = p->ops->print_str(p, ":");
+		else
+			p = p->ops->print_str(p, ": ");
+		p = update_state(p, isl_yaml_mapping_val);
+	} else if (state == isl_yaml_mapping_first_key_start) {
+		p = update_state(p, isl_yaml_mapping_key);
+	} else if (state == isl_yaml_mapping_key_start) {
+		if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+			p = p->ops->print_str(p, ", ");
+		else {
+			p = p->ops->end_line(p);
+			p = p->ops->start_line(p);
+		}
+		p = update_state(p, isl_yaml_mapping_key);
+	} else if (state == isl_yaml_sequence_first_start) {
+		if (p->yaml_style != ISL_YAML_STYLE_FLOW) {
+			p = p->ops->end_line(p);
+			p = p->ops->start_line(p);
+			p = p->ops->print_str(p, "- ");
+			p = isl_printer_indent(p, 2);
+		}
+		p = update_state(p, isl_yaml_sequence);
+	} else if (state == isl_yaml_sequence_start) {
+		if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+			p = p->ops->print_str(p, ", ");
+		else {
+			p = p->ops->end_line(p);
+			p = isl_printer_indent(p, -2);
+			p = p->ops->start_line(p);
+			p = p->ops->print_str(p, "- ");
+			p = isl_printer_indent(p, 2);
+		}
+		p = update_state(p, isl_yaml_sequence);
+	}
+
+	return p;
+}
+
 __isl_give isl_printer *isl_printer_print_str(__isl_take isl_printer *p,
 	const char *s)
 {
@@ -387,13 +621,16 @@
 		return NULL;
 	if (!s)
 		return isl_printer_free(p);
-
+	p = enter_state(p, 0);
+	if (!p)
+		return NULL;
 	return p->ops->print_str(p, s);
 }
 
 __isl_give isl_printer *isl_printer_print_double(__isl_take isl_printer *p,
 	double d)
 {
+	p = enter_state(p, 0);
 	if (!p)
 		return NULL;
 
@@ -402,6 +639,7 @@
 
 __isl_give isl_printer *isl_printer_print_int(__isl_take isl_printer *p, int i)
 {
+	p = enter_state(p, 0);
 	if (!p)
 		return NULL;
 
@@ -411,6 +649,7 @@
 __isl_give isl_printer *isl_printer_print_isl_int(__isl_take isl_printer *p,
 	isl_int i)
 {
+	p = enter_state(p, 0);
 	if (!p)
 		return NULL;
 
@@ -433,9 +672,17 @@
 	return p->ops->end_line(p);
 }
 
-char *isl_printer_get_str(__isl_keep isl_printer *printer)
+/* Return a copy of the string constructed by the string printer "printer".
+ */
+__isl_give char *isl_printer_get_str(__isl_keep isl_printer *printer)
 {
-	if (!printer || !printer->buf)
+	if (!printer)
+		return NULL;
+	if (printer->ops != &str_ops)
+		isl_die(isl_printer_get_ctx(printer), isl_error_invalid,
+			"isl_printer_get_str can only be called on a string "
+			"printer", return NULL);
+	if (!printer->buf)
 		return NULL;
 	return strdup(printer->buf);
 }
@@ -447,3 +694,158 @@
 
 	return p->ops->flush(p);
 }
+
+/* Start a YAML mapping and push a new state to reflect that we
+ * are about to print the first key in a mapping.
+ *
+ * In flow style, print the opening brace.
+ * In block style, move to the next line with an increased indentation,
+ * except if this is the outer mapping or if we are inside a sequence
+ * (in which case we have already increased the indentation and we want
+ * to print the first key on the same line as the dash).
+ */
+__isl_give isl_printer *isl_printer_yaml_start_mapping(
+	__isl_take isl_printer *p)
+{
+	enum isl_yaml_state state;
+
+	if (!p)
+		return NULL;
+	p = enter_state(p, p->yaml_style == ISL_YAML_STYLE_BLOCK);
+	if (!p)
+		return NULL;
+	state = current_state(p);
+	if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+		p = p->ops->print_str(p, "{ ");
+	else if (state != isl_yaml_none && state != isl_yaml_sequence) {
+		p = p->ops->end_line(p);
+		p = isl_printer_indent(p, 2);
+		p = p->ops->start_line(p);
+	}
+	p = push_state(p, isl_yaml_mapping_first_key_start);
+	return p;
+}
+
+/* Finish a YAML mapping and pop it from the state stack.
+ *
+ * In flow style, print the closing brace.
+ *
+ * In block style, first check if we are still in the
+ * isl_yaml_mapping_first_key_start state.  If so, we have not printed
+ * anything yet, so print "{}" to indicate an empty mapping.
+ * If we increased the indentation in isl_printer_yaml_start_mapping,
+ * then decrease it again.
+ * If this is the outer mapping then print a newline.
+ */
+__isl_give isl_printer *isl_printer_yaml_end_mapping(
+	__isl_take isl_printer *p)
+{
+	enum isl_yaml_state state;
+
+	state = current_state(p);
+	p = pop_state(p);
+	if (!p)
+		return NULL;
+	if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+		return p->ops->print_str(p, " }");
+	if (state == isl_yaml_mapping_first_key_start)
+		p = p->ops->print_str(p, "{}");
+	if (!p)
+		return NULL;
+	state = current_state(p);
+	if (state != isl_yaml_none && state != isl_yaml_sequence)
+		p = isl_printer_indent(p, -2);
+	if (state == isl_yaml_none)
+		p = p->ops->end_line(p);
+	return p;
+}
+
+/* Start a YAML sequence and push a new state to reflect that we
+ * are about to print the first element in a sequence.
+ *
+ * In flow style, print the opening bracket.
+ */
+__isl_give isl_printer *isl_printer_yaml_start_sequence(
+	__isl_take isl_printer *p)
+{
+	if (!p)
+		return NULL;
+	p = enter_state(p, p->yaml_style == ISL_YAML_STYLE_BLOCK);
+	p = push_state(p, isl_yaml_sequence_first_start);
+	if (!p)
+		return NULL;
+	if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+		p = p->ops->print_str(p, " ");
+	return p;
+}
+
+/* Finish a YAML sequence and pop it from the state stack.
+ *
+ * In flow style, print the closing bracket.
+ *
+ * In block style, check if we are still in the
+ * isl_yaml_sequence_first_start state.  If so, we have not printed
+ * anything yet, so print "" or " " to indicate an empty sequence.
+ * We print the extra space when we instructed enter_state not
+ * to print a space at the end of the line.
+ * Otherwise, undo the increase in indentation performed by
+ * enter_state when moving away from the isl_yaml_sequence_first_start
+ * state.
+ * If this is the outer sequence then print a newline.
+ */
+__isl_give isl_printer *isl_printer_yaml_end_sequence(
+	__isl_take isl_printer *p)
+{
+	enum isl_yaml_state state, up;
+
+	state = current_state(p);
+	p = pop_state(p);
+	if (!p)
+		return NULL;
+	if (p->yaml_style == ISL_YAML_STYLE_FLOW)
+		return p->ops->print_str(p, " ");
+	up = current_state(p);
+	if (state == isl_yaml_sequence_first_start) {
+		if (up == isl_yaml_mapping_val)
+			p = p->ops->print_str(p, " ");
+		else
+			p = p->ops->print_str(p, "");
+	} else {
+		p = isl_printer_indent(p, -2);
+	}
+	if (!p)
+		return NULL;
+	state = current_state(p);
+	if (state == isl_yaml_none)
+		p = p->ops->end_line(p);
+	return p;
+}
+
+/* Mark the fact that the current element is finished and that
+ * the next output belongs to the next element.
+ * In particular, if we are printing a key, then prepare for
+ * printing the subsequent value.  If we are printing a value,
+ * prepare for printing the next key.  If we are printing an
+ * element in a sequence, prepare for printing the next element.
+ */
+__isl_give isl_printer *isl_printer_yaml_next(__isl_take isl_printer *p)
+{
+	enum isl_yaml_state state;
+
+	if (!p)
+		return NULL;
+	if (p->yaml_depth < 1)
+		isl_die(isl_printer_get_ctx(p), isl_error_invalid,
+			"not in YAML construct", return isl_printer_free(p));
+
+	state = current_state(p);
+	if (state == isl_yaml_mapping_key)
+		state = isl_yaml_mapping_val_start;
+	else if (state == isl_yaml_mapping_val)
+		state = isl_yaml_mapping_key_start;
+	else if (state == isl_yaml_sequence)
+		state = isl_yaml_sequence_start;
+	p = update_state(p, state);
+
+	return p;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_printer_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_printer_private.h Changed

@@ -1,7 +1,28 @@
+#ifndef ISL_PRINTER_PRIVATE_H
+#define ISL_PRINTER_PRIVATE_H
+
 #include <isl/printer.h>
+#include <isl_yaml.h>
+#include <isl/id_to_id.h>
 
 struct isl_printer_ops;
 
+/* A printer to a file or a string.
+ *
+ * "dump" is set if the printing is performed from an isl_*_dump function.
+ *
+ * yaml_style is the YAML style in which the next elements should
+ * be printed and may be either ISL_YAML_STYLE_BLOCK or ISL_YAML_STYLE_FLOW,
+ * with ISL_YAML_STYLE_FLOW being the default.
+ * yaml_state keeps track of the currently active YAML elements.
+ * yaml_size is the size of this arrays, while yaml_depth
+ * is the number of elements currently in use.
+ * yaml_state may be NULL if no YAML printing is being performed.
+ *
+ * notes keeps track of arbitrary notes as a mapping between
+ * name identifiers and note identifiers.  It may be NULL
+ * if there are no notes yet.
+ */
 struct isl_printer {
 	struct isl_ctx	*ctx;
 	struct isl_printer_ops *ops;
@@ -11,8 +32,21 @@
 	char		*buf;
 	int		indent;
 	int		output_format;
+	int		dump;
 	char		*indent_prefix;
 	char		*prefix;
 	char		*suffix;
 	int		width;
+
+	int			yaml_style;
+	int			yaml_depth;
+	int			yaml_size;
+	enum isl_yaml_state	*yaml_state;
+
+	isl_id_to_id	*notes;
 };
+
+__isl_give isl_printer *isl_printer_set_dump(__isl_take isl_printer *p,
+	int dump);
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/isl_project_out_all_params_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_add_constant_multi_val_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_add_constant_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_add_constant_val_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_bind_domain_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_eval.c Added

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/val.h>
+#include <isl_space_private.h>
+#include <isl_point_private.h>
+
+#include <isl_pw_macro.h>
+
+/* Evaluate "pw" in the void point "pnt".
+ * In particular, return the value NaN.
+ */
+static __isl_give isl_val *FN(PW,eval_void)(__isl_take PW *pw,
+	__isl_take isl_point *pnt)
+{
+	isl_ctx *ctx;
+
+	ctx = isl_point_get_ctx(pnt);
+	FN(PW,free)(pw);
+	isl_point_free(pnt);
+	return isl_val_nan(ctx);
+}
+
+/* Evaluate the piecewise function "pw" in "pnt".
+ * If the point is void, then return NaN.
+ * If the point lies outside the domain of "pw", then return 0 or NaN
+ * depending on whether 0 is the default value for this type of function.
+ */
+__isl_give isl_val *FN(PW,eval)(__isl_take PW *pw, __isl_take isl_point *pnt)
+{
+	int i;
+	isl_bool is_void;
+	isl_bool found;
+	isl_ctx *ctx;
+	isl_bool ok;
+	isl_space *pnt_space, *pw_space;
+	isl_val *v;
+
+	pnt_space = isl_point_peek_space(pnt);
+	pw_space = FN(PW,peek_space)(pw);
+	ok = isl_space_is_domain_internal(pnt_space, pw_space);
+	if (ok < 0)
+		goto error;
+	ctx = isl_point_get_ctx(pnt);
+	if (!ok)
+		isl_die(ctx, isl_error_invalid,
+			"incompatible spaces", goto error);
+	is_void = isl_point_is_void(pnt);
+	if (is_void < 0)
+		goto error;
+	if (is_void)
+		return FN(PW,eval_void)(pw, pnt);
+
+	found = isl_bool_false;
+	for (i = 0; i < pw->n; ++i) {
+		found = isl_set_contains_point(pw->pi.set, pnt);
+		if (found < 0)
+			goto error;
+		if (found)
+			break;
+	}
+	if (found) {
+		v = FN(EL,eval)(FN(EL,copy)(pw->pi.FIELD),
+					    isl_point_copy(pnt));
+	} else if (DEFAULT_IS_ZERO) {
+		v = isl_val_zero(ctx);
+	} else {
+		v = isl_val_nan(ctx);
+	}
+	FN(PW,free)(pw);
+	isl_point_free(pnt);
+	return v;
+error:
+	FN(PW,free)(pw);
+	isl_point_free(pnt);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_hash.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_insert_dims_templ.c Added

@@ -0,0 +1,59 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+__isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type,
+	unsigned first, unsigned n)
+{
+	int i;
+	enum isl_dim_type set_type;
+
+	if (!pw)
+		return NULL;
+	if (n == 0 && !isl_space_is_named_or_nested(pw->dim, type))
+		return pw;
+
+	set_type = type == isl_dim_in ? isl_dim_set : type;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+
+	pw->dim = isl_space_insert_dims(pw->dim, type, first, n);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.set = isl_set_insert_dims(pw->pi.set,
+							    set_type, first, n);
+		if (!pw->pi.set)
+			goto error;
+		pw->pi.FIELD = FN(EL,insert_dims)(pw->pi.FIELD,
+								type, first, n);
+		if (!pw->pi.FIELD)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+__isl_give PW *FN(PW,add_dims)(__isl_take PW *pw, enum isl_dim_type type,
+	unsigned n)
+{
+	isl_size pos;
+
+	pos = FN(PW,dim)(pw, type);
+	if (pos < 0)
+		return FN(PW,free)(pw);
+
+	return FN(PW,insert_dims)(pw, type, pos, n);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_insert_domain_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_lift_templ.c Added

@@ -0,0 +1,76 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+#include <isl_pw_macro.h>
+
+static isl_stat foreach_lifted_subset(__isl_take isl_set *set,
+	__isl_take EL *el,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take EL *el,
+		void *user), void *user)
+{
+	int i;
+
+	if (!set || !el)
+		goto error;
+
+	for (i = 0; i < set->n; ++i) {
+		isl_set *lift;
+		EL *copy;
+
+		lift = isl_set_from_basic_set(isl_basic_set_copy(set->pi));
+		lift = isl_set_lift(lift);
+
+		copy = FN(EL,copy)(el);
+		copy = FN(EL,lift)(copy, isl_set_get_space(lift));
+
+		if (fn(lift, copy, user) < 0)
+			goto error;
+	}
+
+	isl_set_free(set);
+	FN(EL,free)(el);
+
+	return isl_stat_ok;
+error:
+	isl_set_free(set);
+	FN(EL,free)(el);
+	return isl_stat_error;
+}
+
+isl_stat FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take EL *el,
+		    void *user), void *user)
+{
+	int i;
+
+	if (!pw)
+		return isl_stat_error;
+
+	for (i = 0; i < pw->n; ++i) {
+		isl_bool any;
+		isl_set *set;
+		EL *el;
+
+		any = isl_set_involves_locals(pw->pi.set);
+		if (any < 0)
+			return isl_stat_error;
+		set = isl_set_copy(pw->pi.set);
+		el = FN(EL,copy)(pw->pi.FIELD);
+		if (!any) {
+			if (fn(set, el, user) < 0)
+				return isl_stat_error;
+			continue;
+		}
+		if (foreach_lifted_subset(set, el, fn, user) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_locals_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_macro.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_morph_templ.c Added

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+__isl_give PW *FN(PW,morph_domain)(__isl_take PW *pw,
+	__isl_take isl_morph *morph)
+{
+	int i;
+	isl_ctx *ctx;
+
+	if (!pw || !morph)
+		goto error;
+
+	ctx = isl_space_get_ctx(pw->dim);
+	isl_assert(ctx, isl_space_is_domain_internal(morph->dom->dim, pw->dim),
+		goto error);
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		goto error;
+	pw->dim = isl_space_extend_domain_with_range(
+			isl_space_copy(morph->ran->dim), pw->dim);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.set = isl_morph_set(isl_morph_copy(morph), pw->pi.set);
+		if (!pw->pi.set)
+			goto error;
+		pw->pi.FIELD = FN(EL,morph_domain)(pw->pi.FIELD,
+						isl_morph_copy(morph));
+		if (!pw->pi.FIELD)
+			goto error;
+	}
+
+	isl_morph_free(morph);
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	isl_morph_free(morph);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_move_dims_templ.c Added

@@ -0,0 +1,49 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+__isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
+	enum isl_dim_type dst_type, unsigned dst_pos,
+	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+{
+	int i;
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		return NULL;
+
+	pw->dim = isl_space_move_dims(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
+	if (!pw->dim)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.FIELD = FN(EL,move_dims)(pw->pi.FIELD,
+					dst_type, dst_pos, src_type, src_pos, n);
+		if (!pw->pi.FIELD)
+			goto error;
+	}
+
+	if (dst_type == isl_dim_in)
+		dst_type = isl_dim_set;
+	if (src_type == isl_dim_in)
+		src_type = isl_dim_set;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.set = isl_set_move_dims(pw->pi.set,
+						dst_type, dst_pos,
+						src_type, src_pos, n);
+		if (!pw->pi.set)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_neg_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_opt_templ.c Added

@@ -0,0 +1,54 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+/* Compute the maximal value attained by the piecewise quasipolynomial
+ * on its domain or zero if the domain is empty.
+ * In the worst case, the domain is scanned completely,
+ * so the domain is assumed to be bounded.
+ */
+__isl_give isl_val *FN(PW,opt)(__isl_take PW *pw, int max)
+{
+	int i;
+	isl_val *opt;
+
+	if (!pw)
+		return NULL;
+
+	if (pw->n == 0) {
+		opt = isl_val_zero(FN(PW,get_ctx)(pw));
+		FN(PW,free)(pw);
+		return opt;
+	}
+
+	opt = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p0.FIELD),
+					isl_set_copy(pw->p0.set), max);
+	for (i = 1; i < pw->n; ++i) {
+		isl_val *opt_i;
+		opt_i = FN(EL,opt_on_domain)(FN(EL,copy)(pw->pi.FIELD),
+						isl_set_copy(pw->pi.set), max);
+		if (max)
+			opt = isl_val_max(opt, opt_i);
+		else
+			opt = isl_val_min(opt, opt_i);
+	}
+
+	FN(PW,free)(pw);
+	return opt;
+}
+
+__isl_give isl_val *FN(PW,max)(__isl_take PW *pw)
+{
+	return FN(PW,opt)(pw, 1);
+}
+
+__isl_give isl_val *FN(PW,min)(__isl_take PW *pw)
+{
+	return FN(PW,opt)(pw, 0);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_pullback_templ.c Added

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl_pw_macro.h>
+
+#undef SUFFIX
+#define SUFFIX	multi_aff
+#undef ARG1
+#define ARG1	PW
+#undef ARG2
+#define ARG2	isl_multi_aff
+
+static
+#include "isl_align_params_templ.c"
+
+#undef SUFFIX
+#define SUFFIX	pw_multi_aff
+#undef ARG1
+#define ARG1	PW
+#undef ARG2
+#define ARG2	isl_pw_multi_aff
+
+static
+#include "isl_align_params_templ.c"
+
+/* Compute the pullback of "pw" by the function represented by "ma".
+ * In other words, plug in "ma" in "pw".
+ */
+__isl_give PW *FN(PW,pullback_multi_aff)(__isl_take PW *pw,
+	__isl_take isl_multi_aff *ma)
+{
+	int i;
+	isl_space *space = NULL;
+
+	FN(PW,align_params_multi_aff)(&pw, &ma);
+	ma = isl_multi_aff_align_divs(ma);
+	pw = FN(PW,cow)(pw);
+	if (!pw || !ma)
+		goto error;
+
+	space = isl_space_join(isl_multi_aff_get_space(ma),
+				FN(PW,get_space)(pw));
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.set = isl_set_preimage_multi_aff(pw->pi.set,
+						    isl_multi_aff_copy(ma));
+		if (!pw->pi.set)
+			goto error;
+		pw->pi.FIELD = FN(EL,pullback_multi_aff)(pw->pi.FIELD,
+						    isl_multi_aff_copy(ma));
+		if (!pw->pi.FIELD)
+			goto error;
+	}
+
+	pw = FN(PW,reset_space)(pw, space);
+	isl_multi_aff_free(ma);
+	return pw;
+error:
+	isl_space_free(space);
+	isl_multi_aff_free(ma);
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+/* Compute the pullback of "pw" by the function represented by "pma".
+ * In other words, plug in "pma" in "pw".
+ */
+static __isl_give PW *FN(PW,pullback_pw_multi_aff_aligned)(__isl_take PW *pw,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	int i;
+	PW *res;
+
+	if (!pma)
+		goto error;
+
+	if (pma->n == 0) {
+		isl_space *space;
+		space = isl_space_join(isl_pw_multi_aff_get_space(pma),
+					FN(PW,get_space)(pw));
+		isl_pw_multi_aff_free(pma);
+		res = FN(PW,empty)(space);
+		FN(PW,free)(pw);
+		return res;
+	}
+
+	res = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
+					isl_multi_aff_copy(pma->p0.maff));
+	res = FN(PW,intersect_domain)(res, isl_set_copy(pma->p0.set));
+
+	for (i = 1; i < pma->n; ++i) {
+		PW *res_i;
+
+		res_i = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
+					isl_multi_aff_copy(pma->pi.maff));
+		res_i = FN(PW,intersect_domain)(res_i,
+					isl_set_copy(pma->pi.set));
+		res = FN(PW,add_disjoint)(res, res_i);
+	}
+
+	isl_pw_multi_aff_free(pma);
+	FN(PW,free)(pw);
+	return res;
+error:
+	isl_pw_multi_aff_free(pma);
+	FN(PW,free)(pw);
+	return NULL;
+}
+
+__isl_give PW *FN(PW,pullback_pw_multi_aff)(__isl_take PW *pw,
+	__isl_take isl_pw_multi_aff *pma)
+{
+	FN(PW,align_params_pw_multi_aff)(&pw, &pma);
+	return FN(PW,pullback_pw_multi_aff_aligned)(pw, pma);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_range_tuple_id_templ.c Added

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2018      Sven Verdoolaege
+ * Copyright 2019      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+/* Does the (range) tuple of "pw" have an identifier?
+ *
+ * Technically, the implementation should use isl_dim_set if "pw"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+isl_bool FN(PW,has_range_tuple_id)(__isl_keep PW *pw)
+{
+	return FN(PW,has_tuple_id)(pw, isl_dim_out);
+}
+
+/* Return the identifier of the (range) tuple of "pw", assuming it has one.
+ *
+ * Technically, the implementation should use isl_dim_set if "pw"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+__isl_give isl_id *FN(PW,get_range_tuple_id)(__isl_keep PW *pw)
+{
+	return FN(PW,get_tuple_id)(pw, isl_dim_out);
+}
+
+/* Replace the identifier of the (range) tuple of "pw" by "id".
+ *
+ * Technically, the implementation should use isl_dim_set if "pw"
+ * lives in a set space and isl_dim_out if it lives in a map space.
+ * Internally, however, it can be assumed that isl_dim_set is equal
+ * to isl_dim_out.
+ */
+__isl_give PW *FN(PW,set_range_tuple_id)(__isl_take PW *pw,
+	__isl_take isl_id *id)
+{
+	return FN(PW,set_tuple_id)(pw, isl_dim_out, id);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_pw_sub_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_pw_templ.c -> _service:tar_scm:isl-0.24.tar.gz/isl_pw_templ.c Changed

@@ -11,27 +11,24 @@
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
  */
 
+#include <isl/id.h>
 #include <isl/aff.h>
+#include <isl_sort.h>
 #include <isl_val_private.h>
 
-#define xFN(TYPE,NAME) TYPE ## _ ## NAME
-#define FN(TYPE,NAME) xFN(TYPE,NAME)
-#define xS(TYPE,NAME) struct TYPE ## _ ## NAME
-#define S(TYPE,NAME) xS(TYPE,NAME)
+#include <isl_pw_macro.h>
 
-#ifdef HAS_TYPE
-__isl_give PW *FN(PW,alloc_size)(__isl_take isl_space *dim,
-	enum isl_fold type, int n)
-#else
-__isl_give PW *FN(PW,alloc_size)(__isl_take isl_space *dim, int n)
-#endif
+#include "opt_type.h"
+
+__isl_give PW *FN(PW,alloc_size)(__isl_take isl_space *space
+	OPT_TYPE_PARAM, int n)
 {
 	isl_ctx *ctx;
 	struct PW *pw;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	ctx = isl_space_get_ctx(dim);
+	ctx = isl_space_get_ctx(space);
 	isl_assert(ctx, n >= 0, goto error);
 	pw = isl_alloc(ctx, struct PW,
 			sizeof(struct PW) + (n - 1) * sizeof(S(PW,piece)));
@@ -39,31 +36,28 @@
 		goto error;
 
 	pw->ref = 1;
-#ifdef HAS_TYPE
-	pw->type = type;
-#endif
+	OPT_SET_TYPE(pw->, type);
 	pw->size = n;
 	pw->n = 0;
-	pw->dim = dim;
+	pw->dim = space;
 	return pw;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-#ifdef HAS_TYPE
-__isl_give PW *FN(PW,ZERO)(__isl_take isl_space *dim, enum isl_fold type)
-{
-	return FN(PW,alloc_size)(dim, type, 0);
-}
-#else
-__isl_give PW *FN(PW,ZERO)(__isl_take isl_space *dim)
+__isl_give PW *FN(PW,ZERO)(__isl_take isl_space *space OPT_TYPE_PARAM)
 {
-	return FN(PW,alloc_size)(dim, 0);
+	return FN(PW,alloc_size)(space OPT_TYPE_ARG(NO_LOC), 0);
 }
-#endif
 
-__isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
+/* Add a piece with domain "set" and base expression "el"
+ * to the piecewise expression "pw".
+ *
+ * Do this independently of the values of "set" and "el",
+ * such that this function can be used by isl_pw_*_dup.
+ */
+__isl_give PW *FN(PW,add_dup_piece)(__isl_take PW *pw,
 	__isl_take isl_set *set, __isl_take EL *el)
 {
 	isl_ctx *ctx;
@@ -72,18 +66,10 @@
 	if (!pw || !set || !el)
 		goto error;
 
-	if (isl_set_plain_is_empty(set) || FN(EL,EL_IS_ZERO)(el)) {
-		isl_set_free(set);
-		FN(EL,free)(el);
-		return pw;
-	}
-
 	ctx = isl_set_get_ctx(set);
-#ifdef HAS_TYPE
-	if (pw->type != el->type)
+	if (!OPT_EQUAL_TYPES(pw->, el->))
 		isl_die(ctx, isl_error_invalid, "fold types don't match",
 			goto error);
-#endif
 	el_dim = FN(EL,get_space(el));
 	isl_assert(ctx, isl_space_is_equal(pw->dim, el_dim), goto error);
 	isl_assert(ctx, pw->n < pw->size, goto error);
@@ -102,23 +88,73 @@
 	return NULL;
 }
 
-#ifdef HAS_TYPE
-__isl_give PW *FN(PW,alloc)(enum isl_fold type,
+/* Add a piece with domain "set" and base expression "el"
+ * to the piecewise expression "pw", provided the domain
+ * is not obviously empty and the base expression
+ * is not equal to the default value.
+ */
+__isl_give PW *FN(PW,add_piece)(__isl_take PW *pw,
 	__isl_take isl_set *set, __isl_take EL *el)
-#else
-__isl_give PW *FN(PW,alloc)(__isl_take isl_set *set, __isl_take EL *el)
-#endif
 {
-	PW *pw;
+	isl_bool skip;
+
+	skip = isl_set_plain_is_empty(set);
+	if (skip >= 0 && !skip)
+		skip = FN(EL,EL_IS_ZERO)(el);
+	if (skip >= 0 && !skip)
+		return FN(PW,add_dup_piece)(pw, set, el);
+
+	isl_set_free(set);
+	FN(EL,free)(el);
+	if (skip < 0)
+		return FN(PW,free)(pw);
+	return pw;
+}
+
+/* Does the space of "set" correspond to that of the domain of "el".
+ */
+static isl_bool FN(PW,compatible_domain)(__isl_keep EL *el,
+	__isl_keep isl_set *set)
+{
+	isl_bool ok;
+	isl_space *el_space, *set_space;
 
 	if (!set || !el)
+		return isl_bool_error;
+	set_space = isl_set_get_space(set);
+	el_space = FN(EL,get_space)(el);
+	ok = isl_space_is_domain_internal(set_space, el_space);
+	isl_space_free(el_space);
+	isl_space_free(set_space);
+	return ok;
+}
+
+/* Check that the space of "set" corresponds to that of the domain of "el".
+ */
+static isl_stat FN(PW,check_compatible_domain)(__isl_keep EL *el,
+	__isl_keep isl_set *set)
+{
+	isl_bool ok;
+
+	ok = FN(PW,compatible_domain)(el, set);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(isl_set_get_ctx(set), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+__isl_give PW *FN(PW,alloc)(OPT_TYPE_PARAM_FIRST
+	__isl_take isl_set *set, __isl_take EL *el)
+{
+	PW *pw;
+
+	if (FN(PW,check_compatible_domain)(el, set) < 0)
 		goto error;
 
-#ifdef HAS_TYPE
-	pw = FN(PW,alloc_size)(FN(EL,get_space)(el), type, 1);
-#else
-	pw = FN(PW,alloc_size)(FN(EL,get_space)(el), 1);
-#endif
+	pw = FN(PW,alloc_size)(FN(EL,get_space)(el) OPT_TYPE_ARG(NO_LOC), 1);
 
 	return FN(PW,add_piece)(pw, set, el);
 error:
@@ -135,16 +171,13 @@
 	if (!pw)
 		return NULL;
 
-#ifdef HAS_TYPE
-	dup = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->type, pw->n);
-#else
-	dup = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->n);
-#endif
+	dup = FN(PW,alloc_size)(isl_space_copy(pw->dim)
+				OPT_TYPE_ARG(pw->), pw->n);
 	if (!dup)
 		return NULL;
 
 	for (i = 0; i < pw->n; ++i)
-		dup = FN(PW,add_piece)(dup, isl_set_copy(pw->pi.set),
+		dup = FN(PW,add_dup_piece)(dup, isl_set_copy(pw->pi.set),
 					    FN(EL,copy)(pw->pi.FIELD));
 
 	return dup;
@@ -189,15 +222,75 @@
 	return NULL;
 }
 
+/* Create a piecewise expression with the given base expression on a universe
+ * domain.
+ */
+static __isl_give PW *FN(FN(FN(PW,from),BASE),type_base)(__isl_take EL *el
+	OPT_TYPE_PARAM)
+{
+	isl_set *dom = isl_set_universe(FN(EL,get_domain_space)(el));
+	return FN(PW,alloc)(OPT_TYPE_ARG_FIRST(NO_LOC) dom, el);
+}
+
+/* Create a piecewise expression with the given base expression on a universe
+ * domain.
+ *
+ * If the default value of this piecewise type is zero and
+ * if "el" is effectively zero, then create an empty piecewise expression
+ * instead.
+ */
+static __isl_give PW *FN(FN(FN(PW,from),BASE),type)(__isl_take EL *el
+	OPT_TYPE_PARAM)
+{
+	isl_bool is_zero;
+	isl_space *space;
+
+	if (!DEFAULT_IS_ZERO)
+		return FN(FN(FN(PW,from),BASE),type_base)(el
+							OPT_TYPE_ARG(NO_LOC));
+	is_zero = FN(EL,EL_IS_ZERO)(el);
+	if (is_zero < 0)
+		goto error;
+	if (!is_zero)
+		return FN(FN(FN(PW,from),BASE),type_base)(el
+							OPT_TYPE_ARG(NO_LOC));
+	space = FN(EL,get_space)(el);
+	FN(EL,free)(el);
+	return FN(PW,ZERO)(space OPT_TYPE_ARG(NO_LOC));
+error:
+	FN(EL,free)(el);
+	return NULL;
+}
+
+#ifdef HAS_TYPE
+/* Create a piecewise expression with the given base expression on a universe
+ * domain.
+ *
+ * Pass along the type as an extra argument for improved uniformity
+ * with piecewise types that do not have a fold type.
+ */
+__isl_give PW *FN(FN(PW,from),BASE)(__isl_take EL *el)
+{
+	enum isl_fold type = FN(EL,get_type)(el);
+	return FN(FN(FN(PW,from),BASE),type)(el, type);
+}
+#else
+__isl_give PW *FN(FN(PW,from),BASE)(__isl_take EL *el)
+{
+	return FN(FN(FN(PW,from),BASE),type)(el);
+}
+#endif
+
 const char *FN(PW,get_dim_name)(__isl_keep PW *pw, enum isl_dim_type type,
 	unsigned pos)
 {
 	return pw ? isl_space_get_dim_name(pw->dim, type, pos) : NULL;
 }
 
-int FN(PW,has_dim_id)(__isl_keep PW *pw, enum isl_dim_type type, unsigned pos)
+isl_bool FN(PW,has_dim_id)(__isl_keep PW *pw, enum isl_dim_type type,
+	unsigned pos)
 {
-	return pw ? isl_space_has_dim_id(pw->dim, type, pos) : -1;
+	return pw ? isl_space_has_dim_id(pw->dim, type, pos) : isl_bool_error;
 }
 
 __isl_give isl_id *FN(PW,get_dim_id)(__isl_keep PW *pw, enum isl_dim_type type,
@@ -206,9 +299,9 @@
 	return pw ? isl_space_get_dim_id(pw->dim, type, pos) : NULL;
 }
 
-int FN(PW,has_tuple_name)(__isl_keep PW *pw, enum isl_dim_type type)
+isl_bool FN(PW,has_tuple_name)(__isl_keep PW *pw, enum isl_dim_type type)
 {
-	return pw ? isl_space_has_tuple_name(pw->dim, type) : -1;
+	return pw ? isl_space_has_tuple_name(pw->dim, type) : isl_bool_error;
 }
 
 const char *FN(PW,get_tuple_name)(__isl_keep PW *pw, enum isl_dim_type type)
@@ -216,9 +309,9 @@
 	return pw ? isl_space_get_tuple_name(pw->dim, type) : NULL;
 }
 
-int FN(PW,has_tuple_id)(__isl_keep PW *pw, enum isl_dim_type type)
+isl_bool FN(PW,has_tuple_id)(__isl_keep PW *pw, enum isl_dim_type type)
 {
-	return pw ? isl_space_has_tuple_id(pw->dim, type) : -1;
+	return pw ? isl_space_has_tuple_id(pw->dim, type) : isl_bool_error;
 }
 
 __isl_give isl_id *FN(PW,get_tuple_id)(__isl_keep PW *pw, enum isl_dim_type type)
@@ -226,15 +319,14 @@
 	return pw ? isl_space_get_tuple_id(pw->dim, type) : NULL;
 }
 
-int FN(PW,IS_ZERO)(__isl_keep PW *pw)
+isl_bool FN(PW,IS_ZERO)(__isl_keep PW *pw)
 {
 	if (!pw)
-		return -1;
+		return isl_bool_error;
 
-	return pw->n == 0;
+	return isl_bool_ok(pw->n == 0);
 }
 
-#ifndef NO_REALIGN
 __isl_give PW *FN(PW,realign_domain)(__isl_take PW *pw,
 	__isl_take isl_reordering *exp)
 {
@@ -255,7 +347,7 @@
 			goto error;
 	}
 
-	pw = FN(PW,reset_domain_space)(pw, isl_space_copy(exp->dim));
+	pw = FN(PW,reset_domain_space)(pw, isl_reordering_get_space(exp));
 
 	isl_reordering_free(exp);
 	return pw;
@@ -265,11 +357,17 @@
 	return NULL;
 }
 
+#undef TYPE
+#define TYPE PW
+
+#include "isl_check_named_params_templ.c"
+
 /* Align the parameters of "pw" to those of "model".
  */
 __isl_give PW *FN(PW,align_params)(__isl_take PW *pw, __isl_take isl_space *model)
 {
 	isl_ctx *ctx;
+	isl_bool equal_params;
 
 	if (!pw || !model)
 		goto error;
@@ -278,16 +376,14 @@
 	if (!isl_space_has_named_params(model))
 		isl_die(ctx, isl_error_invalid,
 			"model has unnamed parameters", goto error);
-	if (!isl_space_has_named_params(pw->dim))
-		isl_die(ctx, isl_error_invalid,
-			"input has unnamed parameters", goto error);
-	if (!isl_space_match(pw->dim, isl_dim_param, model, isl_dim_param)) {
+	if (FN(PW,check_named_params)(pw) < 0)
+		goto error;
+	equal_params = isl_space_has_equal_params(pw->dim, model);
+	if (equal_params < 0)
+		goto error;
+	if (!equal_params) {
 		isl_reordering *exp;
 
-		model = isl_space_drop_dims(model, isl_dim_in,
-					0, isl_space_dim(model, isl_dim_in));
-		model = isl_space_drop_dims(model, isl_dim_out,
-					0, isl_space_dim(model, isl_dim_out));
 		exp = isl_parameter_alignment_reordering(pw->dim, model);
 		exp = isl_reordering_extend_space(exp,
 					FN(PW,get_domain_space)(pw));
@@ -302,73 +398,47 @@
 	return NULL;
 }
 
-static __isl_give PW *FN(PW,align_params_pw_pw_and)(__isl_take PW *pw1,
-	__isl_take PW *pw2,
-	__isl_give PW *(*fn)(__isl_take PW *pw1, __isl_take PW *pw2))
-{
-	isl_ctx *ctx;
+#undef TYPE
+#define TYPE	PW
 
-	if (!pw1 || !pw2)
-		goto error;
-	if (isl_space_match(pw1->dim, isl_dim_param, pw2->dim, isl_dim_param))
-		return fn(pw1, pw2);
-	ctx = FN(PW,get_ctx)(pw1);
-	if (!isl_space_has_named_params(pw1->dim) ||
-	    !isl_space_has_named_params(pw2->dim))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	pw1 = FN(PW,align_params)(pw1, FN(PW,get_space)(pw2));
-	pw2 = FN(PW,align_params)(pw2, FN(PW,get_space)(pw1));
-	return fn(pw1, pw2);
-error:
-	FN(PW,free)(pw1);
-	FN(PW,free)(pw2);
-	return NULL;
-}
+static
+#include "isl_align_params_bin_templ.c"
 
-static __isl_give PW *FN(PW,align_params_pw_set_and)(__isl_take PW *pw,
-	__isl_take isl_set *set,
-	__isl_give PW *(*fn)(__isl_take PW *pw, __isl_take isl_set *set))
-{
-	isl_ctx *ctx;
+#undef SUFFIX
+#define SUFFIX	set
+#undef ARG1
+#define ARG1	PW
+#undef ARG2
+#define ARG2	isl_set
 
-	if (!pw || !set)
-		goto error;
-	if (isl_space_match(pw->dim, isl_dim_param, set->dim, isl_dim_param))
-		return fn(pw, set);
-	ctx = FN(PW,get_ctx)(pw);
-	if (!isl_space_has_named_params(pw->dim) ||
-	    !isl_space_has_named_params(set->dim))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	pw = FN(PW,align_params)(pw, isl_set_get_space(set));
-	set = isl_set_align_params(set, FN(PW,get_space)(pw));
-	return fn(pw, set);
-error:
-	FN(PW,free)(pw);
-	isl_set_free(set);
-	return NULL;
-}
-#endif
+static
+#include "isl_align_params_templ.c"
+
+#undef TYPE
+#define TYPE	PW
+
+#include "isl_type_has_equal_space_bin_templ.c"
+#include "isl_type_check_equal_space_templ.c"
 
-static __isl_give PW *FN(PW,union_add_aligned)(__isl_take PW *pw1,
-	__isl_take PW *pw2)
+/* Private version of "union_add".  For isl_pw_qpolynomial and
+ * isl_pw_qpolynomial_fold, we prefer to simply call it "add".
+ */
+static __isl_give PW *FN(PW,union_add_)(__isl_take PW *pw1, __isl_take PW *pw2)
 {
 	int i, j, n;
 	struct PW *res;
 	isl_ctx *ctx;
 	isl_set *set;
 
-	if (!pw1 || !pw2)
+	if (FN(PW,align_params_bin)(&pw1, &pw2) < 0)
 		goto error;
 
 	ctx = isl_space_get_ctx(pw1->dim);
-#ifdef HAS_TYPE
-	if (pw1->type != pw2->type)
+	if (!OPT_EQUAL_TYPES(pw1->, pw2->))
 		isl_die(ctx, isl_error_invalid,
 			"fold types don't match", goto error);
-#endif
-	isl_assert(ctx, isl_space_is_equal(pw1->dim, pw2->dim), goto error);
+	if (FN(PW,check_equal_space)(pw1, pw2) < 0)
+		goto error;
 
 	if (FN(PW,IS_ZERO)(pw1)) {
 		FN(PW,free)(pw1);
@@ -381,11 +451,8 @@
 	}
 
 	n = (pw1->n + 1) * (pw2->n + 1);
-#ifdef HAS_TYPE
-	res = FN(PW,alloc_size)(isl_space_copy(pw1->dim), pw1->type, n);
-#else
-	res = FN(PW,alloc_size)(isl_space_copy(pw1->dim), n);
-#endif
+	res = FN(PW,alloc_size)(isl_space_copy(pw1->dim)
+				OPT_TYPE_ARG(pw1->), n);
 
 	for (i = 0; i < pw1->n; ++i) {
 		set = isl_set_copy(pw1->pi.set);
@@ -428,15 +495,6 @@
 	return NULL;
 }
 
-/* Private version of "union_add".  For isl_pw_qpolynomial and
- * isl_pw_qpolynomial_fold, we prefer to simply call it "add".
- */
-static __isl_give PW *FN(PW,union_add_)(__isl_take PW *pw1, __isl_take PW *pw2)
-{
-	return FN(PW,align_params_pw_pw_and)(pw1, pw2,
-						&FN(PW,union_add_aligned));
-}
-
 /* Make sure "pw" has room for at least "n" more pieces.
  *
  * If there is only one reference to pw, we extend it in place.
@@ -462,11 +520,7 @@
 		res->size = n;
 		return res;
 	}
-#ifdef HAS_TYPE
-	res = FN(PW,alloc_size)(isl_space_copy(pw->dim), pw->type, n);
-#else
-	res = FN(PW,alloc_size)(isl_space_copy(pw->dim), n);
-#endif
+	res = FN(PW,alloc_size)(isl_space_copy(pw->dim) OPT_TYPE_ARG(pw->), n);
 	if (!res)
 		return FN(PW,free)(pw);
 	for (i = 0; i < pw->n; ++i)
@@ -476,25 +530,23 @@
 	return res;
 }
 
-static __isl_give PW *FN(PW,add_disjoint_aligned)(__isl_take PW *pw1,
-	__isl_take PW *pw2)
+__isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
 {
 	int i;
 	isl_ctx *ctx;
 
-	if (!pw1 || !pw2)
+	if (FN(PW,align_params_bin)(&pw1, &pw2) < 0)
 		goto error;
 
 	if (pw1->size < pw1->n + pw2->n && pw1->n < pw2->n)
-		return FN(PW,add_disjoint_aligned)(pw2, pw1);
+		return FN(PW,add_disjoint)(pw2, pw1);
 
 	ctx = isl_space_get_ctx(pw1->dim);
-#ifdef HAS_TYPE
-	if (pw1->type != pw2->type)
+	if (!OPT_EQUAL_TYPES(pw1->, pw2->))
 		isl_die(ctx, isl_error_invalid,
 			"fold types don't match", goto error);
-#endif
-	isl_assert(ctx, isl_space_is_equal(pw1->dim, pw2->dim), goto error);
+	if (FN(PW,check_equal_space)(pw1, pw2) < 0)
+		goto error;
 
 	if (FN(PW,IS_ZERO)(pw1)) {
 		FN(PW,free)(pw1);
@@ -524,12 +576,6 @@
 	return NULL;
 }
 
-__isl_give PW *FN(PW,add_disjoint)(__isl_take PW *pw1, __isl_take PW *pw2)
-{
-	return FN(PW,align_params_pw_pw_and)(pw1, pw2,
-						&FN(PW,add_disjoint_aligned));
-}
-
 /* This function is currently only used from isl_aff.c
  */
 static __isl_give PW *FN(PW,on_shared_domain_in)(__isl_take PW *pw1,
@@ -551,11 +597,7 @@
 		goto error;
 
 	n = pw1->n * pw2->n;
-#ifdef HAS_TYPE
-	res = FN(PW,alloc_size)(isl_space_copy(space), pw1->type, n);
-#else
-	res = FN(PW,alloc_size)(isl_space_copy(space), n);
-#endif
+	res = FN(PW,alloc_size)(isl_space_copy(space) OPT_TYPE_ARG(pw1->), n);
 
 	for (i = 0; i < pw1->n; ++i) {
 		for (j = 0; j < pw2->n; ++j) {
@@ -610,7 +652,7 @@
 {
 	isl_space *space;
 
-	if (!pw1 || !pw2)
+	if (FN(PW,check_equal_space)(pw1, pw2) < 0)
 		goto error;
 
 	space = isl_space_copy(pw1->dim);
@@ -621,76 +663,6 @@
 	return NULL;
 }
 
-#ifndef NO_NEG
-__isl_give PW *FN(PW,neg)(__isl_take PW *pw)
-{
-	int i;
-
-	if (!pw)
-		return NULL;
-
-	if (FN(PW,IS_ZERO)(pw))
-		return pw;
-
-	pw = FN(PW,cow)(pw);
-	if (!pw)
-		return NULL;
-
-	for (i = 0; i < pw->n; ++i) {
-		pw->pi.FIELD = FN(EL,neg)(pw->pi.FIELD);
-		if (!pw->pi.FIELD)
-			return FN(PW,free)(pw);
-	}
-
-	return pw;
-}
-
-__isl_give PW *FN(PW,sub)(__isl_take PW *pw1, __isl_take PW *pw2)
-{
-	return FN(PW,add)(pw1, FN(PW,neg)(pw2));
-}
-#endif
-
-#ifndef NO_EVAL
-__isl_give isl_val *FN(PW,eval)(__isl_take PW *pw, __isl_take isl_point *pnt)
-{
-	int i;
-	int found = 0;
-	isl_ctx *ctx;
-	isl_space *pnt_dim = NULL;
-	isl_val *v;
-
-	if (!pw || !pnt)
-		goto error;
-	ctx = isl_point_get_ctx(pnt);
-	pnt_dim = isl_point_get_space(pnt);
-	isl_assert(ctx, isl_space_is_domain_internal(pnt_dim, pw->dim),
-		    goto error);
-
-	for (i = 0; i < pw->n; ++i) {
-		found = isl_set_contains_point(pw->pi.set, pnt);
-		if (found < 0)
-			goto error;
-		if (found)
-			break;
-	}
-	if (found)
-		v = FN(EL,eval)(FN(EL,copy)(pw->pi.FIELD),
-					    isl_point_copy(pnt));
-	else
-		v = isl_val_zero(ctx);
-	FN(PW,free)(pw);
-	isl_space_free(pnt_dim);
-	isl_point_free(pnt);
-	return v;
-error:
-	FN(PW,free)(pw);
-	isl_space_free(pnt_dim);
-	isl_point_free(pnt);
-	return NULL;
-}
-#endif
-
 /* Return the parameter domain of "pw".
  */
 __isl_give isl_set *FN(PW,params)(__isl_take PW *pw)
@@ -802,9 +774,10 @@
 
 /* Restrict the domain of "pw" by combining each cell
  * with "set" through a call to "fn", where "fn" may be
- * isl_set_intersect or isl_set_intersect_params.
+ * isl_set_intersect, isl_set_intersect_params, isl_set_intersect_factor_domain,
+ * isl_set_intersect_factor_range or isl_set_subtract.
  */
-static __isl_give PW *FN(PW,intersect_aligned)(__isl_take PW *pw,
+static __isl_give PW *FN(PW,restrict_domain_aligned)(__isl_take PW *pw,
 	__isl_take isl_set *set,
 	__isl_give isl_set *(*fn)(__isl_take isl_set *set1,
 				    __isl_take isl_set *set2))
@@ -837,32 +810,52 @@
 	return NULL;
 }
 
-static __isl_give PW *FN(PW,intersect_domain_aligned)(__isl_take PW *pw,
-	__isl_take isl_set *set)
+__isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw,
+	__isl_take isl_set *context)
 {
-	return FN(PW,intersect_aligned)(pw, set, &isl_set_intersect);
+	FN(PW,align_params_set)(&pw, &context);
+	return FN(PW,restrict_domain_aligned)(pw, context, &isl_set_intersect);
 }
 
-__isl_give PW *FN(PW,intersect_domain)(__isl_take PW *pw,
+/* Intersect the domain of "pw" with the parameter domain "context".
+ */
+__isl_give PW *FN(PW,intersect_params)(__isl_take PW *pw,
 	__isl_take isl_set *context)
 {
-	return FN(PW,align_params_pw_set_and)(pw, context,
-					&FN(PW,intersect_domain_aligned));
+	FN(PW,align_params_set)(&pw, &context);
+	return FN(PW,restrict_domain_aligned)(pw, context,
+					&isl_set_intersect_params);
 }
 
-static __isl_give PW *FN(PW,intersect_params_aligned)(__isl_take PW *pw,
+/* Given a piecewise expression "pw" with domain in a space A -> B and
+ * a set in the space A, intersect the domain with the set.
+ */
+__isl_give PW *FN(PW,intersect_domain_wrapped_domain)(__isl_take PW *pw,
 	__isl_take isl_set *set)
 {
-	return FN(PW,intersect_aligned)(pw, set, &isl_set_intersect_params);
+	FN(PW,align_params_set)(&pw, &set);
+	return FN(PW,restrict_domain_aligned)(pw, set,
+					    &isl_set_intersect_factor_domain);
 }
 
-/* Intersect the domain of "pw" with the parameter domain "context".
+/* Given a piecewise expression "pw" with domain in a space A -> B and
+ * a set in the space B, intersect the domain with the set.
  */
-__isl_give PW *FN(PW,intersect_params)(__isl_take PW *pw,
-	__isl_take isl_set *context)
+__isl_give PW *FN(PW,intersect_domain_wrapped_range)(__isl_take PW *pw,
+	__isl_take isl_set *set)
+{
+	FN(PW,align_params_set)(&pw, &set);
+	return FN(PW,restrict_domain_aligned)(pw, set,
+					    &isl_set_intersect_factor_range);
+}
+
+/* Subtract "domain' from the domain of "pw".
+ */
+__isl_give PW *FN(PW,subtract_domain)(__isl_take PW *pw,
+	__isl_take isl_set *domain)
 {
-	return FN(PW,align_params_pw_set_and)(pw, context,
-					&FN(PW,intersect_params_aligned));
+	FN(PW,align_params_set)(&pw, &domain);
+	return FN(PW,restrict_domain_aligned)(pw, domain, &isl_set_subtract);
 }
 
 /* Compute the gist of "pw" with respect to the domain constraints
@@ -915,6 +908,7 @@
 {
 	int i;
 	int is_universe;
+	isl_bool aligned;
 	isl_basic_set *hull = NULL;
 
 	if (!pw || !context)
@@ -933,8 +927,10 @@
 		return pw;
 	}
 
-	if (!isl_space_match(pw->dim, isl_dim_param,
-				context->dim, isl_dim_param)) {
+	aligned = isl_set_space_has_equal_params(context, pw->dim);
+	if (aligned < 0)
+		goto error;
+	if (!aligned) {
 		pw = FN(PW,align_params)(pw, isl_set_get_space(context));
 		context = isl_set_align_params(context, FN(PW,get_space)(pw));
 	}
@@ -997,66 +993,100 @@
 	return NULL;
 }
 
-static __isl_give PW *FN(PW,gist_domain_aligned)(__isl_take PW *pw,
-	__isl_take isl_set *set)
-{
-	return FN(PW,gist_aligned)(pw, set, &FN(EL,gist),
-					&isl_set_gist_basic_set);
-}
-
 __isl_give PW *FN(PW,gist)(__isl_take PW *pw, __isl_take isl_set *context)
 {
-	return FN(PW,align_params_pw_set_and)(pw, context,
-						&FN(PW,gist_domain_aligned));
+	FN(PW,align_params_set)(&pw, &context);
+	return FN(PW,gist_aligned)(pw, context, &FN(EL,gist),
+					&isl_set_gist_basic_set);
 }
 
-static __isl_give PW *FN(PW,gist_params_aligned)(__isl_take PW *pw,
-	__isl_take isl_set *set)
+__isl_give PW *FN(PW,gist_params)(__isl_take PW *pw,
+	__isl_take isl_set *context)
 {
-	return FN(PW,gist_aligned)(pw, set, &FN(EL,gist_params),
+	FN(PW,align_params_set)(&pw, &context);
+	return FN(PW,gist_aligned)(pw, context, &FN(EL,gist_params),
 					&isl_set_gist_params_basic_set);
 }
 
-__isl_give PW *FN(PW,gist_params)(__isl_take PW *pw,
-	__isl_take isl_set *context)
+/* Return -1 if the piece "p1" should be sorted before "p2"
+ * and 1 if it should be sorted after "p2".
+ * Return 0 if they do not need to be sorted in a specific order.
+ *
+ * The two pieces are compared on the basis of their function value expressions.
+ */
+static int FN(PW,sort_field_cmp)(const void *p1, const void *p2, void *arg)
 {
-	return FN(PW,align_params_pw_set_and)(pw, context,
-						&FN(PW,gist_params_aligned));
+	struct FN(PW,piece) const *pc1 = p1;
+	struct FN(PW,piece) const *pc2 = p2;
+
+	return FN(EL,plain_cmp)(pc1->FIELD, pc2->FIELD);
 }
 
-__isl_give PW *FN(PW,coalesce)(__isl_take PW *pw)
+/* Sort the pieces of "pw" according to their function value
+ * expressions and then combine pairs of adjacent pieces with
+ * the same such expression.
+ *
+ * The sorting is performed in place because it does not
+ * change the meaning of "pw", but care needs to be
+ * taken not to change any possible other copies of "pw"
+ * in case anything goes wrong.
+ */
+__isl_give PW *FN(PW,sort)(__isl_take PW *pw)
 {
 	int i, j;
+	isl_set *set;
 
 	if (!pw)
 		return NULL;
-	if (pw->n == 0)
+	if (pw->n <= 1)
 		return pw;
-
-	for (i = pw->n - 1; i >= 0; --i) {
-		for (j = i - 1; j >= 0; --j) {
-			if (!FN(EL,plain_is_equal)(pw->pi.FIELD,
-							pw->pj.FIELD))
-				continue;
-			pw->pj.set = isl_set_union(pw->pj.set,
-							pw->pi.set);
-			FN(EL,free)(pw->pi.FIELD);
-			if (i != pw->n - 1)
-				pw->pi = pw->ppw->n - 1;
-			pw->n--;
-			break;
-		}
-		if (j >= 0)
+	if (isl_sort(pw->p, pw->n, sizeof(pw->p0),
+		    &FN(PW,sort_field_cmp), NULL) < 0)
+		return FN(PW,free)(pw);
+	for (i = pw->n - 1; i >= 1; --i) {
+		if (!FN(EL,plain_is_equal)(pw->pi - 1.FIELD, pw->pi.FIELD))
 			continue;
-		pw->pi.set = isl_set_coalesce(pw->pi.set);
-		if (!pw->pi.set)
-			goto error;
+		set = isl_set_union(isl_set_copy(pw->pi - 1.set),
+				    isl_set_copy(pw->pi.set));
+		if (!set)
+			return FN(PW,free)(pw);
+		isl_set_free(pw->pi.set);
+		FN(EL,free)(pw->pi.FIELD);
+		isl_set_free(pw->pi - 1.set);
+		pw->pi - 1.set = set;
+		for (j = i + 1; j < pw->n; ++j)
+			pw->pj - 1 = pw->pj;
+		pw->n--;
 	}
 
 	return pw;
-error:
-	FN(PW,free)(pw);
-	return NULL;
+}
+
+/* Coalesce the domains of "pw".
+ *
+ * Prior to the actual coalescing, first sort the pieces such that
+ * pieces with the same function value expression are combined
+ * into a single piece, the combined domain of which can then
+ * be coalesced.
+ */
+__isl_give PW *FN(PW,coalesce)(__isl_take PW *pw)
+{
+	int i;
+
+	pw = FN(PW,sort)(pw);
+	if (!pw)
+		return NULL;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.set = isl_set_coalesce(pw->pi.set);
+		if (!pw->pi.set)
+			goto error;
+	}
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	return NULL;
 }
 
 isl_ctx *FN(PW,get_ctx)(__isl_keep PW *pw)
@@ -1064,22 +1094,21 @@
 	return pw ? isl_space_get_ctx(pw->dim) : NULL;
 }
 
-#ifndef NO_INVOLVES_DIMS
-int FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type,
+isl_bool FN(PW,involves_dims)(__isl_keep PW *pw, enum isl_dim_type type,
 	unsigned first, unsigned n)
 {
 	int i;
 	enum isl_dim_type set_type;
 
 	if (!pw)
-		return -1;
+		return isl_bool_error;
 	if (pw->n == 0 || n == 0)
-		return 0;
+		return isl_bool_false;
 
 	set_type = type == isl_dim_in ? isl_dim_set : type;
 
 	for (i = 0; i < pw->n; ++i) {
-		int involves = FN(EL,involves_dims)(pw->pi.FIELD,
+		isl_bool involves = FN(EL,involves_dims)(pw->pi.FIELD,
 							type, first, n);
 		if (involves < 0 || involves)
 			return involves;
@@ -1088,9 +1117,8 @@
 		if (involves < 0 || involves)
 			return involves;
 	}
-	return 0;
+	return isl_bool_false;
 }
-#endif
 
 __isl_give PW *FN(PW,set_dim_name)(__isl_take PW *pw,
 	enum isl_dim_type type, unsigned pos, const char *s)
@@ -1124,7 +1152,6 @@
 	return NULL;
 }
 
-#ifndef NO_DROP_DIMS
 __isl_give PW *FN(PW,drop_dims)(__isl_take PW *pw,
 	enum isl_dim_type type, unsigned first, unsigned n)
 {
@@ -1206,56 +1233,43 @@
 __isl_give PW *FN(PW,project_domain_on_params)(__isl_take PW *pw)
 {
 	isl_space *space;
-	unsigned n;
+	isl_size n;
 
 	n = FN(PW,dim)(pw, isl_dim_in);
+	if (n < 0)
+		return FN(PW,free)(pw);
 	pw = FN(PW,project_out)(pw, isl_dim_in, 0, n);
 	space = FN(PW,get_domain_space)(pw);
 	space = isl_space_params(space);
 	pw = FN(PW,reset_domain_space)(pw, space);
 	return pw;
 }
-#endif
 
-#ifndef NO_INSERT_DIMS
-__isl_give PW *FN(PW,insert_dims)(__isl_take PW *pw, enum isl_dim_type type,
-	unsigned first, unsigned n)
+/* Drop all parameters not referenced by "pw".
+ */
+__isl_give PW *FN(PW,drop_unused_params)(__isl_take PW *pw)
 {
+	isl_size n;
 	int i;
-	enum isl_dim_type set_type;
 
-	if (!pw)
-		return NULL;
-	if (n == 0 && !isl_space_is_named_or_nested(pw->dim, type))
-		return pw;
-
-	set_type = type == isl_dim_in ? isl_dim_set : type;
-
-	pw = FN(PW,cow)(pw);
-	if (!pw)
-		return NULL;
+	if (FN(PW,check_named_params)(pw) < 0)
+		return FN(PW,free)(pw);
 
-	pw->dim = isl_space_insert_dims(pw->dim, type, first, n);
-	if (!pw->dim)
-		goto error;
+	n = FN(PW,dim)(pw, isl_dim_param);
+	if (n < 0)
+		return FN(PW,free)(pw);
+	for (i = n - 1; i >= 0; i--) {
+		isl_bool involves;
 
-	for (i = 0; i < pw->n; ++i) {
-		pw->pi.set = isl_set_insert_dims(pw->pi.set,
-							    set_type, first, n);
-		if (!pw->pi.set)
-			goto error;
-		pw->pi.FIELD = FN(EL,insert_dims)(pw->pi.FIELD,
-								type, first, n);
-		if (!pw->pi.FIELD)
-			goto error;
+		involves = FN(PW,involves_dims)(pw, isl_dim_param, i, 1);
+		if (involves < 0)
+			return FN(PW,free)(pw);
+		if (!involves)
+			pw = FN(PW,drop_dims)(pw, isl_dim_param, i, 1);
 	}
 
 	return pw;
-error:
-	FN(PW,free)(pw);
-	return NULL;
 }
-#endif
 
 __isl_give PW *FN(PW,fix_dim)(__isl_take PW *pw,
 	enum isl_dim_type type, unsigned pos, isl_int v)
@@ -1301,9 +1315,9 @@
 	return FN(PW,free)(pw);
 }
 
-unsigned FN(PW,dim)(__isl_keep PW *pw, enum isl_dim_type type)
+isl_size FN(PW,dim)(__isl_keep PW *pw, enum isl_dim_type type)
 {
-	return pw ? isl_space_dim(pw->dim, type) : 0;
+	return isl_space_dim(FN(PW,peek_space)(pw), type);
 }
 
 __isl_give PW *FN(PW,split_dims)(__isl_take PW *pw,
@@ -1336,56 +1350,170 @@
 	return NULL;
 }
 
-#ifndef NO_OPT
-/* Compute the maximal value attained by the piecewise quasipolynomial
- * on its domain or zero if the domain is empty.
- * In the worst case, the domain is scanned completely,
- * so the domain is assumed to be bounded.
+/* Return the space of "pw".
  */
-__isl_give isl_val *FN(PW,opt)(__isl_take PW *pw, int max)
+__isl_keep isl_space *FN(PW,peek_space)(__isl_keep PW *pw)
 {
-	int i;
-	isl_val *opt;
+	return pw ? pw->dim : NULL;
+}
+
+__isl_give isl_space *FN(PW,get_space)(__isl_keep PW *pw)
+{
+	return isl_space_copy(FN(PW,peek_space)(pw));
+}
+
+/* Return the space of "pw".
+ * This may be either a copy or the space itself
+ * if there is only one reference to "pw".
+ * This allows the space to be modified inplace
+ * if both the piecewise expression and its space have only a single reference.
+ * The caller is not allowed to modify "pw" between this call and
+ * a subsequent call to isl_pw_*_restore_*.
+ * The only exception is that isl_pw_*_free can be called instead.
+ */
+__isl_give isl_space *FN(PW,take_space)(__isl_keep PW *pw)
+{
+	isl_space *space;
 
 	if (!pw)
 		return NULL;
+	if (pw->ref != 1)
+		return FN(PW,get_space)(pw);
+	space = pw->dim;
+	pw->dim = NULL;
+	return space;
+}
 
-	if (pw->n == 0) {
-		opt = isl_val_zero(FN(PW,get_ctx)(pw));
-		FN(PW,free)(pw);
-		return opt;
-	}
+/* Set the space of "pw" to "space", where the space of "pw" may be missing
+ * due to a preceding call to isl_pw_*_take_space.
+ * However, in this case, "pw" only has a single reference and
+ * then the call to isl_pw_*_cow has no effect.
+ */
+__isl_give PW *FN(PW,restore_space)(__isl_take PW *pw,
+	__isl_take isl_space *space)
+{
+	if (!pw || !space)
+		goto error;
 
-	opt = FN(EL,opt_on_domain)(FN(EL,copy)(pw->p0.FIELD),
-					isl_set_copy(pw->p0.set), max);
-	for (i = 1; i < pw->n; ++i) {
-		isl_val *opt_i;
-		opt_i = FN(EL,opt_on_domain)(FN(EL,copy)(pw->pi.FIELD),
-						isl_set_copy(pw->pi.set), max);
-		if (max)
-			opt = isl_val_max(opt, opt_i);
-		else
-			opt = isl_val_min(opt, opt_i);
+	if (pw->dim == space) {
+		isl_space_free(space);
+		return pw;
 	}
 
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		goto error;
+	isl_space_free(pw->dim);
+	pw->dim = space;
+
+	return pw;
+error:
 	FN(PW,free)(pw);
-	return opt;
+	isl_space_free(space);
+	return NULL;
 }
 
-__isl_give isl_val *FN(PW,max)(__isl_take PW *pw)
+/* Check that "pos" is a valid position for a cell in "pw".
+ */
+static isl_stat FN(PW,check_pos)(__isl_keep PW *pw, int pos)
 {
-	return FN(PW,opt)(pw, 1);
+	if (!pw)
+		return isl_stat_error;
+	if (pos < 0 || pos >= pw->n)
+		isl_die(FN(PW,get_ctx)(pw), isl_error_internal,
+			"position out of bounds", return isl_stat_error);
+	return isl_stat_ok;
 }
 
-__isl_give isl_val *FN(PW,min)(__isl_take PW *pw)
+/* Return the cell at position "pos" in "pw".
+ */
+static __isl_keep isl_set *FN(PW,peek_domain_at)(__isl_keep PW *pw, int pos)
 {
-	return FN(PW,opt)(pw, 0);
+	if (FN(PW,check_pos)(pw, pos) < 0)
+		return NULL;
+	return pw->ppos.set;
 }
-#endif
 
-__isl_give isl_space *FN(PW,get_space)(__isl_keep PW *pw)
+/* Return a copy of the cell at position "pos" in "pw".
+ */
+__isl_give isl_set *FN(PW,get_domain_at)(__isl_keep PW *pw, int pos)
+{
+	return isl_set_copy(FN(PW,peek_domain_at)(pw, pos));
+}
+
+/* Return the base expression associated to
+ * the cell at position "pos" in "pw".
+ */
+static __isl_keep EL *FN(PW,peek_base_at)(__isl_keep PW *pw, int pos)
+{
+	if (FN(PW,check_pos)(pw, pos) < 0)
+		return NULL;
+	return pw->ppos.FIELD;
+}
+
+/* Return a copy of the base expression associated to
+ * the cell at position "pos" in "pw".
+ */
+__isl_give EL *FN(PW,get_base_at)(__isl_keep PW *pw, int pos)
+{
+	return FN(EL,copy)(FN(PW,peek_base_at)(pw, pos));
+}
+
+/* Return the base expression associated to
+ * the cell at position "pos" in "pw".
+ * This may be either a copy or the base expression itself
+ * if there is only one reference to "pw".
+ * This allows the base expression to be modified inplace
+ * if both the piecewise expression and this base expression
+ * have only a single reference.
+ * The caller is not allowed to modify "pw" between this call and
+ * a subsequent call to isl_pw_*_restore_*.
+ * The only exception is that isl_pw_*_free can be called instead.
+ */
+__isl_give EL *FN(PW,take_base_at)(__isl_keep PW *pw, int pos)
+{
+	EL *el;
+
+	if (!pw)
+		return NULL;
+	if (pw->ref != 1)
+		return FN(PW,get_base_at)(pw, pos);
+	if (FN(PW,check_pos)(pw, pos) < 0)
+		return NULL;
+	el = pw->ppos.FIELD;
+	pw->ppos.FIELD = NULL;
+	return el;
+}
+
+/* Set the base expression associated to
+ * the cell at position "pos" in "pw" to "el",
+ * where this base expression may be missing
+ * due to a preceding call to isl_pw_*_take_base_at.
+ * However, in this case, "pw" only has a single reference and
+ * then the call to isl_pw_*_cow has no effect.
+ */
+__isl_give PW *FN(PW,restore_base_at)(__isl_take PW *pw, int pos,
+	__isl_take EL *el)
 {
-	return pw ? isl_space_copy(pw->dim) : NULL;
+	if (FN(PW,check_pos)(pw, pos) < 0 || !el)
+		goto error;
+
+	if (pw->ppos.FIELD == el) {
+		FN(EL,free)(el);
+		return pw;
+	}
+
+	pw = FN(PW,cow)(pw);
+	if (!pw)
+		goto error;
+	FN(EL,free)(pw->ppos.FIELD);
+	pw->ppos.FIELD = el;
+
+	return pw;
+error:
+	FN(PW,free)(pw);
+	FN(EL,free)(el);
+	return NULL;
 }
 
 __isl_give isl_space *FN(PW,get_domain_space)(__isl_keep PW *pw)
@@ -1393,7 +1521,49 @@
 	return pw ? isl_space_domain(isl_space_copy(pw->dim)) : NULL;
 }
 
-#ifndef NO_RESET_DIM
+/* Return the position of the dimension of the given type and name
+ * in "pw".
+ * Return -1 if no such dimension can be found.
+ */
+int FN(PW,find_dim_by_name)(__isl_keep PW *pw,
+	enum isl_dim_type type, const char *name)
+{
+	if (!pw)
+		return -1;
+	return isl_space_find_dim_by_name(pw->dim, type, name);
+}
+
+/* Return the position of the dimension of the given type and identifier
+ * in "pw".
+ * Return -1 if no such dimension can be found.
+ */
+static int FN(PW,find_dim_by_id)(__isl_keep PW *pw,
+	enum isl_dim_type type, __isl_keep isl_id *id)
+{
+	isl_space *space;
+
+	space = FN(PW,peek_space)(pw);
+	return isl_space_find_dim_by_id(space, type, id);
+}
+
+/* Does the piecewise expression "pw" depend in any way
+ * on the parameter with identifier "id"?
+ */
+isl_bool FN(PW,involves_param_id)(__isl_keep PW *pw, __isl_keep isl_id *id)
+{
+	int pos;
+
+	if (!pw || !id)
+		return isl_bool_error;
+	if (pw->n == 0)
+		return isl_bool_false;
+
+	pos = FN(PW,find_dim_by_id)(pw, isl_dim_param, id);
+	if (pos < 0)
+		return isl_bool_false;
+	return FN(PW,involves_dims)(pw, isl_dim_param, pos, 1);
+}
+
 /* Reset the space of "pw".  Since we don't know if the elements
  * represent the spaces themselves or their domains, we pass along
  * both when we call their reset_space_and_domain.
@@ -1441,12 +1611,13 @@
 	return FN(PW,reset_space_and_domain)(pw, space, domain);
 }
 
-__isl_give PW *FN(PW,reset_space)(__isl_take PW *pw, __isl_take isl_space *dim)
+__isl_give PW *FN(PW,reset_space)(__isl_take PW *pw,
+	__isl_take isl_space *space)
 {
 	isl_space *domain;
 
-	domain = isl_space_domain(isl_space_copy(dim));
-	return FN(PW,reset_space_and_domain)(pw, dim, domain);
+	domain = isl_space_domain(isl_space_copy(space));
+	return FN(PW,reset_space_and_domain)(pw, space, domain);
 }
 
 __isl_give PW *FN(PW,set_tuple_id)(__isl_take PW *pw, enum isl_dim_type type,
@@ -1500,195 +1671,176 @@
 	isl_id_free(id);
 	return FN(PW,free)(pw);
 }
-#endif
-
-int FN(PW,has_equal_space)(__isl_keep PW *pw1, __isl_keep PW *pw2)
-{
-	if (!pw1 || !pw2)
-		return -1;
 
-	return isl_space_is_equal(pw1->dim, pw2->dim);
-}
-
-#ifndef NO_MORPH
-__isl_give PW *FN(PW,morph_domain)(__isl_take PW *pw,
-	__isl_take isl_morph *morph)
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * of the space of "pw".
+ */
+__isl_give PW *FN(PW,reset_user)(__isl_take PW *pw)
 {
-	int i;
-	isl_ctx *ctx;
-
-	if (!pw || !morph)
-		goto error;
-
-	ctx = isl_space_get_ctx(pw->dim);
-	isl_assert(ctx, isl_space_is_domain_internal(morph->dom->dim, pw->dim),
-		goto error);
-
-	pw = FN(PW,cow)(pw);
-	if (!pw)
-		goto error;
-	pw->dim = isl_space_extend_domain_with_range(
-			isl_space_copy(morph->ran->dim), pw->dim);
-	if (!pw->dim)
-		goto error;
-
-	for (i = 0; i < pw->n; ++i) {
-		pw->pi.set = isl_morph_set(isl_morph_copy(morph), pw->pi.set);
-		if (!pw->pi.set)
-			goto error;
-		pw->pi.FIELD = FN(EL,morph_domain)(pw->pi.FIELD,
-						isl_morph_copy(morph));
-		if (!pw->pi.FIELD)
-			goto error;
-	}
+	isl_space *space;
 
-	isl_morph_free(morph);
+	space = FN(PW,get_space)(pw);
+	space = isl_space_reset_user(space);
 
-	return pw;
-error:
-	FN(PW,free)(pw);
-	isl_morph_free(morph);
-	return NULL;
+	return FN(PW,reset_space)(pw, space);
 }
-#endif
 
-int FN(PW,n_piece)(__isl_keep PW *pw)
+isl_size FN(PW,n_piece)(__isl_keep PW *pw)
 {
-	return pw ? pw->n : 0;
+	return pw ? pw->n : isl_size_error;
 }
 
-int FN(PW,foreach_piece)(__isl_keep PW *pw,
-	int (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
+isl_stat FN(PW,foreach_piece)(__isl_keep PW *pw,
+	isl_stat (*fn)(__isl_take isl_set *set, __isl_take EL *el, void *user),
 	void *user)
 {
 	int i;
 
 	if (!pw)
-		return -1;
+		return isl_stat_error;
 
 	for (i = 0; i < pw->n; ++i)
 		if (fn(isl_set_copy(pw->pi.set),
 				FN(EL,copy)(pw->pi.FIELD), user) < 0)
-			return -1;
+			return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-#ifndef NO_LIFT
-static int any_divs(__isl_keep isl_set *set)
+/* Does "test" succeed on every cell of "pw"?
+ */
+isl_bool FN(PW,every_piece)(__isl_keep PW *pw,
+	isl_bool (*test)(__isl_keep isl_set *set,
+		__isl_keep EL *el, void *user), void *user)
 {
 	int i;
 
-	if (!set)
-		return -1;
+	if (!pw)
+		return isl_bool_error;
 
-	for (i = 0; i < set->n; ++i)
-		if (set->pi->n_div > 0)
-			return 1;
+	for (i = 0; i < pw->n; ++i) {
+		isl_bool r;
 
-	return 0;
+		r = test(pw->pi.set, pw->pi.FIELD, user);
+		if (r < 0 || !r)
+			return r;
+	}
+
+	return isl_bool_true;
 }
 
-static int foreach_lifted_subset(__isl_take isl_set *set, __isl_take EL *el,
-	int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
-		    void *user), void *user)
+/* Is "pw" defined over a single universe domain?
+ *
+ * If the default value of this piecewise type is zero,
+ * then a "pw" with a zero number of cells is also accepted
+ * as it represents the default zero value.
+ */
+isl_bool FN(FN(PW,isa),BASE)(__isl_keep PW *pw)
 {
-	int i;
-
-	if (!set || !el)
-		goto error;
-
-	for (i = 0; i < set->n; ++i) {
-		isl_set *lift;
-		EL *copy;
+	isl_size n;
 
-		lift = isl_set_from_basic_set(isl_basic_set_copy(set->pi));
-		lift = isl_set_lift(lift);
+	n = FN(PW,n_piece)(pw);
+	if (n < 0)
+		return isl_bool_error;
+	if (DEFAULT_IS_ZERO && n == 0)
+		return isl_bool_true;
+	if (n != 1)
+		return isl_bool_false;
+	return isl_set_plain_is_universe(FN(PW,peek_domain_at)(pw, 0));
+}
 
-		copy = FN(EL,copy)(el);
-		copy = FN(EL,lift)(copy, isl_set_get_space(lift));
+/* Return a zero base expression in the same space (and of the same type)
+ * as "pw".
+ */
+static __isl_give EL *FN(EL,zero_like_type)(__isl_take PW *pw OPT_TYPE_PARAM)
+{
+	isl_space *space;
 
-		if (fn(lift, copy, user) < 0)
-			goto error;
-	}
+	space = FN(PW,get_space)(pw);
+	FN(PW,free)(pw);
+	return FN(EL,zero_in_space)(space OPT_TYPE_ARG(NO_LOC));
+}
 
-	isl_set_free(set);
-	FN(EL,free)(el);
+#ifndef HAS_TYPE
+/* Return a zero base expression in the same space as "pw".
+ */
+static __isl_give EL *FN(EL,zero_like)(__isl_take PW *pw)
+{
+	return FN(EL,zero_like_type)(pw);
+}
+#else
+/* Return a zero base expression in the same space and of the same type
+ * as "pw".
+ *
+ * Pass along the type as an explicit argument for uniform handling
+ * in isl_*_zero_like_type.
+ */
+static __isl_give EL *FN(EL,zero_like)(__isl_take PW *pw)
+{
+	enum isl_fold type;
 
-	return 0;
+	type = FN(PW,get_type)(pw);
+	if (type < 0)
+		goto error;
+	return FN(EL,zero_like_type)(pw, type);
 error:
-	isl_set_free(set);
-	FN(EL,free)(el);
-	return -1;
+	FN(PW,free)(pw);
+	return NULL;
 }
+#endif
 
-int FN(PW,foreach_lifted_piece)(__isl_keep PW *pw,
-	int (*fn)(__isl_take isl_set *set, __isl_take EL *el,
-		    void *user), void *user)
+/* Given that "pw" is defined over a single universe domain,
+ * return the base expression associated to this domain.
+ *
+ * If the number of cells is zero, then "pw" is of a piecewise type
+ * with a default zero value and effectively represents zero.
+ * In this case, create a zero base expression in the same space
+ * (and with the same type).
+ * Otherwise, simply extract the associated base expression.
+ */
+__isl_give EL *FN(FN(PW,as),BASE)(__isl_take PW *pw)
 {
-	int i;
+	isl_bool is_total;
+	isl_size n;
+	EL *el;
 
-	if (!pw)
-		return -1;
-
-	for (i = 0; i < pw->n; ++i) {
-		isl_set *set;
-		EL *el;
-
-		set = isl_set_copy(pw->pi.set);
-		el = FN(EL,copy)(pw->pi.FIELD);
-		if (!any_divs(set)) {
-			if (fn(set, el, user) < 0)
-				return -1;
-			continue;
-		}
-		if (foreach_lifted_subset(set, el, fn, user) < 0)
-			return -1;
-	}
-
-	return 0;
+	is_total = FN(FN(PW,isa),BASE)(pw);
+	if (is_total < 0)
+		goto error;
+	if (!is_total)
+		isl_die(FN(PW,get_ctx)(pw), isl_error_invalid,
+			"expecting single total function", goto error);
+	n = FN(PW,n_piece)(pw);
+	if (n < 0)
+		goto error;
+	if (n == 0)
+		return FN(EL,zero_like)(pw);
+	el = FN(PW,take_base_at)(pw, 0);
+	FN(PW,free)(pw);
+	return el;
+error:
+	FN(PW,free)(pw);
+	return NULL;
 }
-#endif
 
-#ifndef NO_MOVE_DIMS
-__isl_give PW *FN(PW,move_dims)(__isl_take PW *pw,
-	enum isl_dim_type dst_type, unsigned dst_pos,
-	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
+#ifdef HAS_TYPE
+/* Negate the type of "pw".
+ */
+static __isl_give PW *FN(PW,negate_type)(__isl_take PW *pw)
 {
-	int i;
-
 	pw = FN(PW,cow)(pw);
 	if (!pw)
 		return NULL;
-
-	pw->dim = isl_space_move_dims(pw->dim, dst_type, dst_pos, src_type, src_pos, n);
-	if (!pw->dim)
-		goto error;
-
-	for (i = 0; i < pw->n; ++i) {
-		pw->pi.FIELD = FN(EL,move_dims)(pw->pi.FIELD,
-					dst_type, dst_pos, src_type, src_pos, n);
-		if (!pw->pi.FIELD)
-			goto error;
-	}
-
-	if (dst_type == isl_dim_in)
-		dst_type = isl_dim_set;
-	if (src_type == isl_dim_in)
-		src_type = isl_dim_set;
-
-	for (i = 0; i < pw->n; ++i) {
-		pw->pi.set = isl_set_move_dims(pw->pi.set,
-						dst_type, dst_pos,
-						src_type, src_pos, n);
-		if (!pw->pi.set)
-			goto error;
-	}
-
+	pw->type = isl_fold_type_negate(pw->type);
+	return pw;
+}
+#else
+/* Negate the type of "pw".
+ * Since "pw" does not have a type, do nothing.
+ */
+static __isl_give PW *FN(PW,negate_type)(__isl_take PW *pw)
+{
 	return pw;
-error:
-	FN(PW,free)(pw);
-	return NULL;
 }
 #endif
 
@@ -1700,25 +1852,19 @@
 		return pw;
 	if (pw && DEFAULT_IS_ZERO && isl_int_is_zero(v)) {
 		PW *zero;
-		isl_space *dim = FN(PW,get_space)(pw);
-#ifdef HAS_TYPE
-		zero = FN(PW,ZERO)(dim, pw->type);
-#else
-		zero = FN(PW,ZERO)(dim);
-#endif
+		isl_space *space = FN(PW,get_space)(pw);
+		zero = FN(PW,ZERO)(space OPT_TYPE_ARG(pw->));
 		FN(PW,free)(pw);
 		return zero;
 	}
 	pw = FN(PW,cow)(pw);
+	if (isl_int_is_neg(v))
+		pw = FN(PW,negate_type)(pw);
 	if (!pw)
 		return NULL;
 	if (pw->n == 0)
 		return pw;
 
-#ifdef HAS_TYPE
-	if (isl_int_is_neg(v))
-		pw->type = isl_fold_type_negate(pw->type);
-#endif
 	for (i = 0; i < pw->n; ++i) {
 		pw->pi.FIELD = FN(EL,scale)(pw->pi.FIELD, v);
 		if (!pw->pi.FIELD)
@@ -1747,11 +1893,7 @@
 	if (pw && DEFAULT_IS_ZERO && isl_val_is_zero(v)) {
 		PW *zero;
 		isl_space *space = FN(PW,get_space)(pw);
-#ifdef HAS_TYPE
-		zero = FN(PW,ZERO)(space, pw->type);
-#else
-		zero = FN(PW,ZERO)(space);
-#endif
+		zero = FN(PW,ZERO)(space OPT_TYPE_ARG(pw->));
 		FN(PW,free)(pw);
 		isl_val_free(v);
 		return zero;
@@ -1761,13 +1903,11 @@
 		return pw;
 	}
 	pw = FN(PW,cow)(pw);
+	if (isl_val_is_neg(v))
+		pw = FN(PW,negate_type)(pw);
 	if (!pw)
 		goto error;
 
-#ifdef HAS_TYPE
-	if (isl_val_is_neg(v))
-		pw->type = isl_fold_type_negate(pw->type);
-#endif
 	for (i = 0; i < pw->n; ++i) {
 		pw->pi.FIELD = FN(EL,scale_val)(pw->pi.FIELD,
 						    isl_val_copy(v));
@@ -1783,28 +1923,72 @@
 	return NULL;
 }
 
-__isl_give PW *FN(PW,scale)(__isl_take PW *pw, isl_int v)
+/* Divide the pieces of "pw" by "v" and return the result.
+ */
+__isl_give PW *FN(PW,scale_down_val)(__isl_take PW *pw, __isl_take isl_val *v)
 {
-	return FN(PW,mul_isl_int)(pw, v);
+	int i;
+
+	if (!pw || !v)
+		goto error;
+
+	if (isl_val_is_one(v)) {
+		isl_val_free(v);
+		return pw;
+	}
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational factor", goto error);
+	if (isl_val_is_zero(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"cannot scale down by zero", goto error);
+
+	if (pw->n == 0) {
+		isl_val_free(v);
+		return pw;
+	}
+	pw = FN(PW,cow)(pw);
+	if (isl_val_is_neg(v))
+		pw = FN(PW,negate_type)(pw);
+	if (!pw)
+		goto error;
+
+	for (i = 0; i < pw->n; ++i) {
+		pw->pi.FIELD = FN(EL,scale_down_val)(pw->pi.FIELD,
+						    isl_val_copy(v));
+		if (!pw->pi.FIELD)
+			goto error;
+	}
+
+	isl_val_free(v);
+	return pw;
+error:
+	isl_val_free(v);
+	FN(PW,free)(pw);
+	return NULL;
 }
 
-static int FN(PW,qsort_set_cmp)(const void *p1, const void *p2)
+__isl_give PW *FN(PW,scale)(__isl_take PW *pw, isl_int v)
 {
-	isl_set *set1 = *(isl_set * const *)p1;
-	isl_set *set2 = *(isl_set * const *)p2;
-
-	return isl_set_plain_cmp(set1, set2);
+	return FN(PW,mul_isl_int)(pw, v);
 }
 
-/* We normalize in place, but if anything goes wrong we need
+/* Apply some normalization to "pw".
+ * In particular, sort the pieces according to their function value
+ * expressions, combining pairs of adjacent pieces with
+ * the same such expression, and then normalize the domains of the pieces.
+ *
+ * We normalize in place, but if anything goes wrong we need
  * to return NULL, so we need to make sure we don't change the
- * meaning of any possible other copies of map.
+ * meaning of any possible other copies of "pw".
  */
 __isl_give PW *FN(PW,normalize)(__isl_take PW *pw)
 {
-	int i, j;
+	int i;
 	isl_set *set;
 
+	pw = FN(PW,sort)(pw);
 	if (!pw)
 		return NULL;
 	for (i = 0; i < pw->n; ++i) {
@@ -1814,24 +1998,6 @@
 		isl_set_free(pw->pi.set);
 		pw->pi.set = set;
 	}
-	qsort(pw->p, pw->n, sizeof(pw->p0), &FN(PW,qsort_set_cmp));
-	for (i = pw->n - 1; i >= 1; --i) {
-		if (!isl_set_plain_is_equal(pw->pi - 1.set, pw->pi.set))
-			continue;
-		if (!FN(EL,plain_is_equal)(pw->pi - 1.FIELD, pw->pi.FIELD))
-			continue;
-		set = isl_set_union(isl_set_copy(pw->pi - 1.set),
-				    isl_set_copy(pw->pi.set));
-		if (!set)
-			return FN(PW,free)(pw);
-		isl_set_free(pw->pi.set);
-		FN(EL,free)(pw->pi.FIELD);
-		isl_set_free(pw->pi - 1.set);
-		pw->pi - 1.set = set;
-		for (j = i + 1; j < pw->n; ++j)
-			pw->pj - 1 = pw->pj;
-		pw->n--;
-	}
 
 	return pw;
 }
@@ -1839,19 +2005,30 @@
 /* Is pw1 obviously equal to pw2?
  * That is, do they have obviously identical cells and obviously identical
  * elements on each cell?
+ *
+ * If "pw1" or "pw2" contain any NaNs, then they are considered
+ * not to be the same.  A NaN is not equal to anything, not even
+ * to another NaN.
  */
-int FN(PW,plain_is_equal)(__isl_keep PW *pw1, __isl_keep PW *pw2)
+isl_bool FN(PW,plain_is_equal)(__isl_keep PW *pw1, __isl_keep PW *pw2)
 {
 	int i;
-	int equal;
+	isl_bool equal, has_nan;
 
 	if (!pw1 || !pw2)
-		return -1;
+		return isl_bool_error;
+
+	has_nan = FN(PW,involves_nan)(pw1);
+	if (has_nan >= 0 && !has_nan)
+		has_nan = FN(PW,involves_nan)(pw2);
+	if (has_nan < 0 || has_nan)
+		return isl_bool_not(has_nan);
 
 	if (pw1 == pw2)
-		return 1;
-	if (!isl_space_is_equal(pw1->dim, pw2->dim))
-		return 0;
+		return isl_bool_true;
+	equal = FN(PW,has_equal_space)(pw1, pw2);
+	if (equal < 0 || !equal)
+		return equal;
 
 	pw1 = FN(PW,copy)(pw1);
 	pw2 = FN(PW,copy)(pw2);
@@ -1860,7 +2037,7 @@
 	if (!pw1 || !pw2)
 		goto error;
 
-	equal = pw1->n == pw2->n;
+	equal = isl_bool_ok(pw1->n == pw2->n);
 	for (i = 0; equal && i < pw1->n; ++i) {
 		equal = isl_set_plain_is_equal(pw1->pi.set, pw2->pi.set);
 		if (equal < 0)
@@ -1878,163 +2055,25 @@
 error:
 	FN(PW,free)(pw1);
 	FN(PW,free)(pw2);
-	return -1;
-}
-
-#ifndef NO_PULLBACK
-static __isl_give PW *FN(PW,align_params_pw_multi_aff_and)(__isl_take PW *pw,
-	__isl_take isl_multi_aff *ma,
-	__isl_give PW *(*fn)(__isl_take PW *pw, __isl_take isl_multi_aff *ma))
-{
-	isl_ctx *ctx;
-	isl_space *ma_space;
-
-	ma_space = isl_multi_aff_get_space(ma);
-	if (!pw || !ma || !ma_space)
-		goto error;
-	if (isl_space_match(pw->dim, isl_dim_param, ma_space, isl_dim_param)) {
-		isl_space_free(ma_space);
-		return fn(pw, ma);
-	}
-	ctx = FN(PW,get_ctx)(pw);
-	if (!isl_space_has_named_params(pw->dim) ||
-	    !isl_space_has_named_params(ma_space))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	pw = FN(PW,align_params)(pw, ma_space);
-	ma = isl_multi_aff_align_params(ma, FN(PW,get_space)(pw));
-	return fn(pw, ma);
-error:
-	isl_space_free(ma_space);
-	FN(PW,free)(pw);
-	isl_multi_aff_free(ma);
-	return NULL;
-}
-
-static __isl_give PW *FN(PW,align_params_pw_pw_multi_aff_and)(__isl_take PW *pw,
-	__isl_take isl_pw_multi_aff *pma,
-	__isl_give PW *(*fn)(__isl_take PW *pw,
-		__isl_take isl_pw_multi_aff *ma))
-{
-	isl_ctx *ctx;
-	isl_space *pma_space;
-
-	pma_space = isl_pw_multi_aff_get_space(pma);
-	if (!pw || !pma || !pma_space)
-		goto error;
-	if (isl_space_match(pw->dim, isl_dim_param, pma_space, isl_dim_param)) {
-		isl_space_free(pma_space);
-		return fn(pw, pma);
-	}
-	ctx = FN(PW,get_ctx)(pw);
-	if (!isl_space_has_named_params(pw->dim) ||
-	    !isl_space_has_named_params(pma_space))
-		isl_die(ctx, isl_error_invalid,
-			"unaligned unnamed parameters", goto error);
-	pw = FN(PW,align_params)(pw, pma_space);
-	pma = isl_pw_multi_aff_align_params(pma, FN(PW,get_space)(pw));
-	return fn(pw, pma);
-error:
-	isl_space_free(pma_space);
-	FN(PW,free)(pw);
-	isl_pw_multi_aff_free(pma);
-	return NULL;
+	return isl_bool_error;
 }
 
-/* Compute the pullback of "pw" by the function represented by "ma".
- * In other words, plug in "ma" in "pw".
+/* Does "pw" involve any NaNs?
  */
-static __isl_give PW *FN(PW,pullback_multi_aff_aligned)(__isl_take PW *pw,
-	__isl_take isl_multi_aff *ma)
+isl_bool FN(PW,involves_nan)(__isl_keep PW *pw)
 {
 	int i;
-	isl_space *space = NULL;
 
-	ma = isl_multi_aff_align_divs(ma);
-	pw = FN(PW,cow)(pw);
-	if (!pw || !ma)
-		goto error;
-
-	space = isl_space_join(isl_multi_aff_get_space(ma),
-				FN(PW,get_space)(pw));
+	if (!pw)
+		return isl_bool_error;
+	if (pw->n == 0)
+		return isl_bool_false;
 
 	for (i = 0; i < pw->n; ++i) {
-		pw->pi.set = isl_set_preimage_multi_aff(pw->pi.set,
-						    isl_multi_aff_copy(ma));
-		if (!pw->pi.set)
-			goto error;
-		pw->pi.FIELD = FN(EL,pullback_multi_aff)(pw->pi.FIELD,
-						    isl_multi_aff_copy(ma));
-		if (!pw->pi.FIELD)
-			goto error;
+		isl_bool has_nan = FN(EL,involves_nan)(pw->pi.FIELD);
+		if (has_nan < 0 || has_nan)
+			return has_nan;
 	}
 
-	pw = FN(PW,reset_space)(pw, space);
-	isl_multi_aff_free(ma);
-	return pw;
-error:
-	isl_space_free(space);
-	isl_multi_aff_free(ma);
-	FN(PW,free)(pw);
-	return NULL;
-}
-
-__isl_give PW *FN(PW,pullback_multi_aff)(__isl_take PW *pw,
-	__isl_take isl_multi_aff *ma)
-{
-	return FN(PW,align_params_pw_multi_aff_and)(pw, ma,
-					&FN(PW,pullback_multi_aff_aligned));
+	return isl_bool_false;
 }
-
-/* Compute the pullback of "pw" by the function represented by "pma".
- * In other words, plug in "pma" in "pw".
- */
-static __isl_give PW *FN(PW,pullback_pw_multi_aff_aligned)(__isl_take PW *pw,
-	__isl_take isl_pw_multi_aff *pma)
-{
-	int i;
-	PW *res;
-
-	if (!pma)
-		goto error;
-
-	if (pma->n == 0) {
-		isl_space *space;
-		space = isl_space_join(isl_pw_multi_aff_get_space(pma),
-					FN(PW,get_space)(pw));
-		isl_pw_multi_aff_free(pma);
-		res = FN(PW,empty)(space);
-		FN(PW,free)(pw);
-		return res;
-	}
-
-	res = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
-					isl_multi_aff_copy(pma->p0.maff));
-	res = FN(PW,intersect_domain)(res, isl_set_copy(pma->p0.set));
-
-	for (i = 1; i < pma->n; ++i) {
-		PW *res_i;
-
-		res_i = FN(PW,pullback_multi_aff)(FN(PW,copy)(pw),
-					isl_multi_aff_copy(pma->pi.maff));
-		res_i = FN(PW,intersect_domain)(res_i,
-					isl_set_copy(pma->pi.set));
-		res = FN(PW,add_disjoint)(res, res_i);
-	}
-
-	isl_pw_multi_aff_free(pma);
-	FN(PW,free)(pw);
-	return res;
-error:
-	isl_pw_multi_aff_free(pma);
-	FN(PW,free)(pw);
-	return NULL;
-}
-
-__isl_give PW *FN(PW,pullback_pw_multi_aff)(__isl_take PW *pw,
-	__isl_take isl_pw_multi_aff *pma)
-{
-	return FN(PW,align_params_pw_pw_multi_aff_and)(pw, pma,
-					&FN(PW,pullback_pw_multi_aff_aligned));
-}
-#endif

_service:tar_scm:isl-0.24.tar.gz/isl_pw_templ.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_pw_union_opt.c Added

@@ -0,0 +1,359 @@
+/*
+ * Copyright 2011      INRIA Saclay
+ * Copyright 2012      Ecole Normale Superieure
+ * Copyright 2020      Cerebras Systems
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
+ */
+
+#include <isl_pw_macro.h>
+
+/* Given a function "cmp" that returns the set of elements where
+ * "el1" is "better" than "el2", return this set.
+ */
+static __isl_give isl_set *FN(PW,better)(__isl_keep EL *el1, __isl_keep EL *el2,
+	__isl_give isl_set *(*cmp)(__isl_take EL *el1, __isl_take EL *el2))
+{
+	return cmp(FN(EL,copy)(el1), FN(EL,copy)(el2));
+}
+
+/* Return a list containing the domains of the pieces of "pw".
+ */
+static __isl_give isl_set_list *FN(PW,extract_domains)(__isl_keep PW *pw)
+{
+	int i;
+	isl_ctx *ctx;
+	isl_set_list *list;
+
+	if (!pw)
+		return NULL;
+	ctx = FN(PW,get_ctx)(pw);
+	list = isl_set_list_alloc(ctx, pw->n);
+	for (i = 0; i < pw->n; ++i)
+		list = isl_set_list_add(list, isl_set_copy(pw->pi.set));
+
+	return list;
+}
+
+/* Given sets B ("set"), C ("better") and A' ("out"), return
+ *
+ *	(B \cap C) \cup ((B \setminus C) \setminus A')
+ */
+static __isl_give isl_set *FN(PW,better_or_out)(__isl_take isl_set *set,
+	__isl_take isl_set *better, __isl_take isl_set *out)
+{
+	isl_set *set_better, *set_out;
+
+	set_better = isl_set_intersect(isl_set_copy(set), isl_set_copy(better));
+	set_out = isl_set_subtract(isl_set_subtract(set, better), out);
+
+	return isl_set_union(set_better, set_out);
+}
+
+/* Given sets A ("set"), C ("better") and B' ("out"), return
+ *
+ *	(A \setminus C) \cup ((A \cap C) \setminus B')
+ */
+static __isl_give isl_set *FN(PW,worse_or_out)(__isl_take isl_set *set,
+	__isl_take isl_set *better, __isl_take isl_set *out)
+{
+	isl_set *set_worse, *set_out;
+
+	set_worse = isl_set_subtract(isl_set_copy(set), isl_set_copy(better));
+	set_out = isl_set_subtract(isl_set_intersect(set, better), out);
+
+	return isl_set_union(set_worse, set_out);
+}
+
+/* Internal data structure used by isl_pw_*_union_opt_cmp
+ * that keeps track of a piecewise expression with updated cells.
+ * "pw" holds the original piecewise expression.
+ * "list" holds the updated cells.
+ */
+S(PW,union_opt_cmp_data) {
+	PW *pw;
+	isl_set_list *cell;
+};
+
+/* Free all memory allocated for "data".
+ */
+static void FN(PW,union_opt_cmp_data_clear)(S(PW,union_opt_cmp_data) *data)
+{
+	isl_set_list_free(data->cell);
+	FN(PW,free)(data->pw);
+}
+
+/* Given (potentially) updated cells "i" of data_i->pw and "j" of data_j->pw and
+ * a set "better" where the piece from data_j->pw is better
+ * than the piece from data_i->pw,
+ * (further) update the specified cells such that only the better elements
+ * remain on the (non-empty) intersection.
+ *
+ * Let C be the set "better".
+ * Let A be the cell data_i->celli and B the cell data_j->cellj.
+ *
+ * The elements in C need to be removed from A, except for those parts
+ * that lie outside of B.  That is,
+ *
+ *	A <- (A \setminus C) \cup ((A \cap C) \setminus B')
+ *
+ * Conversely, the elements in B need to be restricted to C, except
+ * for those parts that lie outside of A.  That is
+ *
+ *	B <- (B \cap C) \cup ((B \setminus C) \setminus A')
+ *
+ * Since all pairs of pieces are considered, the domains are updated
+ * several times.  A and B refer to these updated domains
+ * (kept track of in data_i->celli and data_j->cellj), while A' and B' refer
+ * to the original domains of the pieces.  It is safe to use these
+ * original domains because the difference between, say, A' and A is
+ * the domains of pw2-pieces that have been removed before and
+ * those domains are disjoint from B.  A' is used instead of A
+ * because the continued updating of A may result in this domain
+ * getting broken up into more disjuncts.
+ */
+static isl_stat FN(PW,union_opt_cmp_split)(S(PW,union_opt_cmp_data) *data_i,
+	int i, S(PW,union_opt_cmp_data) *data_j, int j,
+	__isl_take isl_set *better)
+{
+	isl_set *set_i, *set_j;
+
+	set_i = isl_set_list_get_set(data_i->cell, i);
+	set_j = FN(PW,get_domain_at)(data_j->pw, j);
+	set_i = FN(PW,worse_or_out)(set_i, isl_set_copy(better), set_j);
+	data_i->cell = isl_set_list_set_set(data_i->cell, i, set_i);
+	set_i = FN(PW,get_domain_at)(data_i->pw, i);
+	set_j = isl_set_list_get_set(data_j->cell, j);
+	set_j = FN(PW,better_or_out)(set_j, better, set_i);
+	data_j->cell = isl_set_list_set_set(data_j->cell, j, set_j);
+
+	return isl_stat_ok;
+}
+
+/* Given (potentially) updated cells "i" of data_i->pw and "j" of data_j->pw and
+ * a function "cmp" that returns the set of elements where
+ * "el1" is "better" than "el2",
+ * (further) update the specified cells such that only the "better" elements
+ * remain on the (non-empty) intersection.
+ */
+static isl_stat FN(PW,union_opt_cmp_pair)(S(PW,union_opt_cmp_data) *data_i,
+	int i, S(PW,union_opt_cmp_data) *data_j, int j,
+	__isl_give isl_set *(*cmp)(__isl_take EL *el1, __isl_take EL *el2))
+{
+	isl_set *better;
+	EL *el_i, *el_j;
+
+	el_i = FN(PW,peek_base_at)(data_i->pw, i);
+	el_j = FN(PW,peek_base_at)(data_j->pw, j);
+	better = FN(PW,better)(el_j, el_i, cmp);
+	return FN(PW,union_opt_cmp_split)(data_i, i, data_j, j, better);
+}
+
+/* Given (potentially) updated cells "i" of data_i->pw and "j" of data_j->pw and
+ * a function "cmp" that returns the set of elements where
+ * "el1" is "better" than "el2",
+ * (further) update the specified cells such that only the "better" elements
+ * remain on the (non-empty) intersection.
+ *
+ * The base computation is performed by isl_pw_*_union_opt_cmp_pair,
+ * which splits the cells according to the set of elements
+ * where the piece from data_j->pw is better than the piece from data_i->pw.
+ *
+ * In some cases, there may be a subset of the intersection
+ * where both pieces have the same value and can therefore
+ * both be considered to be "better" than the other.
+ * This can result in unnecessary splitting on this subset.
+ * Avoid some of these cases by checking whether
+ * data_i->pw is always better than data_j->pw on the intersection.
+ * In particular, do this for the special case where this intersection
+ * is equal to the cell "j" and data_i->pw is better on its entire cell.
+ *
+ * Similarly, if data_i->pw is never better than data_j->pw,
+ * then no splitting will occur and there is no need to check
+ * where data_j->pw is better than data_i->pw.
+ */
+static isl_stat FN(PW,union_opt_cmp_two)(S(PW,union_opt_cmp_data) *data_i,
+	int i, S(PW,union_opt_cmp_data) *data_j, int j,
+	__isl_give isl_set *(*cmp)(__isl_take EL *el1, __isl_take EL *el2))
+{
+	isl_bool is_subset, is_empty;
+	isl_set *better, *set_i, *set_j;
+	EL *el_i, *el_j;
+
+	set_i = FN(PW,peek_domain_at)(data_i->pw, i);
+	set_j = FN(PW,peek_domain_at)(data_j->pw, j);
+	is_subset = isl_set_is_subset(set_j, set_i);
+	if (is_subset < 0)
+		return isl_stat_error;
+	if (!is_subset)
+		return FN(PW,union_opt_cmp_pair)(data_i, i, data_j, j, cmp);
+
+	el_i = FN(PW,peek_base_at)(data_i->pw, i);
+	el_j = FN(PW,peek_base_at)(data_j->pw, j);
+	better = FN(PW,better)(el_i, el_j, cmp);
+	is_empty = isl_set_is_empty(better);
+	if (is_empty >= 0 && is_empty)
+		return FN(PW,union_opt_cmp_split)(data_j, j, data_i, i, better);
+	is_subset = isl_set_is_subset(set_i, better);
+	if (is_subset >= 0 && is_subset)
+		return FN(PW,union_opt_cmp_split)(data_j, j, data_i, i, better);
+	isl_set_free(better);
+	if (is_empty < 0 || is_subset < 0)
+		return isl_stat_error;
+
+	return FN(PW,union_opt_cmp_pair)(data_i, i, data_j, j, cmp);
+}
+
+/* Given two piecewise expressions data1->pw and data2->pw, replace
+ * their domains
+ * by the sets in data1->cell and data2->cell and combine the results into
+ * a single piecewise expression.
+ * The pieces of data1->pw and data2->pw are assumed to have been sorted
+ * according to the function value expressions.
+ * The pieces of the result are also sorted in this way.
+ *
+ * Run through the pieces of data1->pw and data2->pw in order until they
+ * have both been exhausted, picking the piece from data1->pw or data2->pw
+ * depending on which should come first, together with the corresponding
+ * domain from data1->cell or data2->cell.  In cases where the next pieces
+ * in both data1->pw and data2->pw have the same function value expression,
+ * construct only a single piece in the result with as domain
+ * the union of the domains in data1->cell and data2->cell.
+ */
+static __isl_give PW *FN(PW,merge)(S(PW,union_opt_cmp_data) *data1,
+	S(PW,union_opt_cmp_data) *data2)
+{
+	int i, j;
+	PW *res;
+	PW *pw1 = data1->pw;
+	PW *pw2 = data2->pw;
+	isl_set_list *list1 = data1->cell;
+	isl_set_list *list2 = data2->cell;
+
+	if (!pw1 || !pw2)
+		return NULL;
+
+	res = FN(PW,alloc_size)(isl_space_copy(pw1->dim), pw1->n + pw2->n);
+
+	i = 0; j = 0;
+	while (i < pw1->n || j < pw2->n) {
+		int cmp;
+		isl_set *set;
+		EL *el;
+
+		if (i < pw1->n && j < pw2->n)
+			cmp = FN(EL,plain_cmp)(pw1->pi.FIELD,
+						pw2->pj.FIELD);
+		else
+			cmp = i < pw1->n ? -1 : 1;
+
+		if (cmp < 0) {
+			set = isl_set_list_get_set(list1, i);
+			el = FN(EL,copy)(pw1->pi.FIELD);
+			++i;
+		} else if (cmp > 0) {
+			set = isl_set_list_get_set(list2, j);
+			el = FN(EL,copy)(pw2->pj.FIELD);
+			++j;
+		} else {
+			set = isl_set_union(isl_set_list_get_set(list1, i),
+					    isl_set_list_get_set(list2, j));
+			el = FN(EL,copy)(pw1->pi.FIELD);
+			++i;
+			++j;
+		}
+		res = FN(PW,add_piece)(res, set, el);
+	}
+
+	return res;
+}
+
+/* Given a function "cmp" that returns the set of elements where
+ * "el1" is "better" than "el2", return a piecewise
+ * expression defined on the union of the definition domains
+ * of "pw1" and "pw2" that maps to the "best" of "pw1" and
+ * "pw2" on each cell.  If only one of the two input functions
+ * is defined on a given cell, then it is considered the best.
+ *
+ * Run through all pairs of pieces in "pw1" and "pw2".
+ * If the domains of these pieces intersect, then the intersection
+ * needs to be distributed over the two pieces based on "cmp".
+ *
+ * After the updated domains have been computed, the result is constructed
+ * from "pw1", "pw2", data0.cell and data1.cell.  If there are any pieces
+ * in "pw1" and "pw2" with the same function value expression, then
+ * they are combined into a single piece in the result.
+ * In order to be able to do this efficiently, the pieces of "pw1" and
+ * "pw2" are first sorted according to their function value expressions.
+ */
+static __isl_give PW *FN(PW,union_opt_cmp)(
+	__isl_take PW *pw1, __isl_take PW *pw2,
+	__isl_give isl_set *(*cmp)(__isl_take EL *el1, __isl_take EL *el2))
+{
+	S(PW,union_opt_cmp_data) data2 = { { pw1, NULL }, { pw2, NULL } };
+	int i, j;
+	isl_size n1, n2;
+	PW *res = NULL;
+	isl_ctx *ctx;
+
+	if (!pw1 || !pw2)
+		goto error;
+
+	ctx = isl_space_get_ctx(pw1->dim);
+	if (!isl_space_is_equal(pw1->dim, pw2->dim))
+		isl_die(ctx, isl_error_invalid,
+			"arguments should live in the same space", goto error);
+
+	if (FN(PW,is_empty)(pw1)) {
+		FN(PW,free)(pw1);
+		return pw2;
+	}
+
+	if (FN(PW,is_empty)(pw2)) {
+		FN(PW,free)(pw2);
+		return pw1;
+	}
+
+	for (i = 0; i < 2; ++i) {
+		datai.pw = FN(PW,sort)(datai.pw);
+		datai.cell = FN(PW,extract_domains)(datai.pw);
+	}
+
+	n1 = FN(PW,n_piece)(data0.pw);
+	n2 = FN(PW,n_piece)(data1.pw);
+	if (n1 < 0 || n2 < 0)
+		goto error;
+	for (i = 0; i < n1; ++i) {
+		for (j = 0; j < n2; ++j) {
+			isl_bool disjoint;
+			isl_set *set_i, *set_j;
+
+			set_i = FN(PW,peek_domain_at)(data0.pw, i);
+			set_j = FN(PW,peek_domain_at)(data1.pw, j);
+			disjoint = isl_set_is_disjoint(set_i, set_j);
+			if (disjoint < 0)
+				goto error;
+			if (disjoint)
+				continue;
+			if (FN(PW,union_opt_cmp_two)(&data0, i,
+							&data1, j, cmp) < 0)
+				goto error;
+		}
+	}
+
+	res = FN(PW,merge)(&data0, &data1);
+	for (i = 0; i < 2; ++i)
+		FN(PW,union_opt_cmp_data_clear)(&datai);
+
+	return res;
+error:
+	for (i = 0; i < 2; ++i)
+		FN(PW,union_opt_cmp_data_clear)(&datai);
+	return FN(PW,free)(res);
+}

_service:tar_scm:isl-0.14.tar.xz/isl_range.c -> _service:tar_scm:isl-0.24.tar.gz/isl_range.c Changed

@@ -1,4 +1,5 @@
 #include <isl_ctx_private.h>
+#include <isl/val.h>
 #include <isl_constraint_private.h>
 #include <isl/set.h>
 #include <isl_polynomial_private.h>
@@ -17,7 +18,7 @@
 	isl_pw_qpolynomial_fold *pwf_tight;
 };
 
-static int propagate_on_domain(__isl_take isl_basic_set *bset,
+static isl_stat propagate_on_domain(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, struct range_data *data);
 
 /* Check whether the polynomial "poly" has sign "sign" over "bset",
@@ -25,19 +26,19 @@
  * is non-negative and if sign == -1, check that the upper bound on
  * the polynomial is non-positive.
  */
-static int has_sign(__isl_keep isl_basic_set *bset,
+static isl_bool has_sign(__isl_keep isl_basic_set *bset,
 	__isl_keep isl_qpolynomial *poly, int sign, int *signs)
 {
 	struct range_data data_m;
-	unsigned nvar;
-	unsigned nparam;
-	isl_space *dim;
+	isl_size nparam;
+	isl_space *space;
 	isl_val *opt;
-	int r;
+	isl_bool r;
 	enum isl_fold type;
 
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nparam < 0)
+		return isl_bool_error;
 
 	bset = isl_basic_set_copy(bset);
 	poly = isl_qpolynomial_copy(poly);
@@ -47,16 +48,16 @@
 	poly = isl_qpolynomial_move_dims(poly, isl_dim_in, 0,
 					isl_dim_param, 0, nparam);
 
-	dim = isl_qpolynomial_get_space(poly);
-	dim = isl_space_params(dim);
-	dim = isl_space_from_domain(dim);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
+	space = isl_qpolynomial_get_space(poly);
+	space = isl_space_params(space);
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
 
 	data_m.test_monotonicity = 0;
 	data_m.signs = signs;
 	data_m.sign = -sign;
 	type = data_m.sign < 0 ? isl_fold_min : isl_fold_max;
-	data_m.pwf = isl_pw_qpolynomial_fold_zero(dim, type);
+	data_m.pwf = isl_pw_qpolynomial_fold_zero(space, type);
 	data_m.tight = 0;
 	data_m.pwf_tight = NULL;
 
@@ -69,20 +70,20 @@
 		opt = isl_pw_qpolynomial_fold_max(data_m.pwf);
 
 	if (!opt)
-		r = -1;
+		r = isl_bool_error;
 	else if (isl_val_is_nan(opt) ||
 		 isl_val_is_infty(opt) ||
 		 isl_val_is_neginfty(opt))
-		r = 0;
+		r = isl_bool_false;
 	else
-		r = sign * isl_val_sgn(opt) >= 0;
+		r = isl_bool_ok(sign * isl_val_sgn(opt) >= 0);
 
 	isl_val_free(opt);
 
 	return r;
 error:
 	isl_pw_qpolynomial_fold_free(data_m.pwf);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Return  1 if poly is monotonically increasing in the last set variable,
@@ -96,21 +97,24 @@
 	__isl_keep isl_qpolynomial *poly, struct range_data *data)
 {
 	isl_ctx *ctx;
-	isl_space *dim;
+	isl_space *space;
 	isl_qpolynomial *sub = NULL;
 	isl_qpolynomial *diff = NULL;
 	int result = 0;
-	int s;
-	unsigned nvar;
-
-	ctx = isl_qpolynomial_get_ctx(poly);
-	dim = isl_qpolynomial_get_domain_space(poly);
+	isl_bool s;
+	isl_size nvar;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0)
+		return -2;
+
+	ctx = isl_qpolynomial_get_ctx(poly);
+	space = isl_qpolynomial_get_domain_space(poly);
 
-	sub = isl_qpolynomial_var_on_domain(isl_space_copy(dim), isl_dim_set, nvar - 1);
+	sub = isl_qpolynomial_var_on_domain(isl_space_copy(space),
+						isl_dim_set, nvar - 1);
 	sub = isl_qpolynomial_add(sub,
-		isl_qpolynomial_rat_cst_on_domain(dim, ctx->one, ctx->one));
+		isl_qpolynomial_rat_cst_on_domain(space, ctx->one, ctx->one));
 
 	diff = isl_qpolynomial_substitute(isl_qpolynomial_copy(poly),
 			isl_dim_in, nvar - 1, 1, &sub);
@@ -139,20 +143,28 @@
 	return -2;
 }
 
+/* Return a positive ("sign" > 0) or negative ("sign" < 0) infinite polynomial
+ * with domain space "space".
+ */
+static __isl_give isl_qpolynomial *signed_infty(__isl_take isl_space *space,
+	int sign)
+{
+	if (sign > 0)
+		return isl_qpolynomial_infty_on_domain(space);
+	else
+		return isl_qpolynomial_neginfty_on_domain(space);
+}
+
 static __isl_give isl_qpolynomial *bound2poly(__isl_take isl_constraint *bound,
-	__isl_take isl_space *dim, unsigned pos, int sign)
+	__isl_take isl_space *space, unsigned pos, int sign)
 {
-	if (!bound) {
-		if (sign > 0)
-			return isl_qpolynomial_infty_on_domain(dim);
-		else
-			return isl_qpolynomial_neginfty_on_domain(dim);
-	}
-	isl_space_free(dim);
+	if (!bound)
+		return signed_infty(space, sign);
+	isl_space_free(space);
 	return isl_qpolynomial_from_constraint(bound, isl_dim_set, pos);
 }
 
-static int bound_is_integer(__isl_take isl_constraint *bound, unsigned pos)
+static int bound_is_integer(__isl_keep isl_constraint *bound, unsigned pos)
 {
 	isl_int c;
 	int is_int;
@@ -179,36 +191,42 @@
  * and variables in data->signs.  The integer divisions, if
  * any, are assumed to be non-negative.
  */
-static int collect_fixed_sign_terms(__isl_take isl_term *term, void *user)
+static isl_stat collect_fixed_sign_terms(__isl_take isl_term *term, void *user)
 {
 	struct isl_fixed_sign_data *data = (struct isl_fixed_sign_data *)user;
 	isl_int n;
 	int i;
 	int sign;
-	unsigned nparam;
-	unsigned nvar;
-
-	if (!term)
-		return -1;
+	isl_size nparam;
+	isl_size nvar;
+	isl_size exp;
 
 	nparam = isl_term_dim(term, isl_dim_param);
 	nvar = isl_term_dim(term, isl_dim_set);
+	if (nparam < 0 || nvar < 0)
+		return isl_stat_error;
 
 	isl_int_init(n);
-
 	isl_term_get_num(term, &n);
-
 	sign = isl_int_sgn(n);
+	isl_int_clear(n);
+
 	for (i = 0; i < nparam; ++i) {
 		if (data->signsi > 0)
 			continue;
-		if (isl_term_get_exp(term, isl_dim_param, i) % 2)
+		exp = isl_term_get_exp(term, isl_dim_param, i);
+		if (exp < 0)
+			return isl_stat_error;
+		if (exp % 2)
 			sign = -sign;
 	}
 	for (i = 0; i < nvar; ++i) {
 		if (data->signsnparam + i > 0)
 			continue;
-		if (isl_term_get_exp(term, isl_dim_set, i) % 2)
+		exp = isl_term_get_exp(term, isl_dim_set, i);
+		if (exp < 0)
+			return isl_stat_error;
+		if (exp % 2)
 			sign = -sign;
 	}
 
@@ -219,9 +237,7 @@
 	} else
 		isl_term_free(term);
 
-	isl_int_clear(n);
-
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Construct and return a polynomial that consists of the terms
@@ -249,7 +265,7 @@
 /* Helper function to add a guarded polynomial to either pwf_tight or pwf,
  * depending on whether the result has been determined to be tight.
  */
-static int add_guarded_poly(__isl_take isl_basic_set *bset,
+static isl_stat add_guarded_poly(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, struct range_data *data)
 {
 	enum isl_fold type = data->sign < 0 ? isl_fold_min : isl_fold_max;
@@ -269,7 +285,53 @@
 	else
 		data->pwf = isl_pw_qpolynomial_fold_fold(data->pwf, pwf);
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* Plug in "sub" for the variable at position "pos" in "poly".
+ *
+ * If "sub" is an infinite polynomial and if the variable actually
+ * appears in "poly", then calling isl_qpolynomial_substitute
+ * to perform the substitution may result in a NaN result.
+ * In such cases, return positive or negative infinity instead,
+ * depending on whether an upper bound or a lower bound is being computed,
+ * and mark the result as not being tight.
+ */
+static __isl_give isl_qpolynomial *plug_in_at_pos(
+	__isl_take isl_qpolynomial *poly, int pos,
+	__isl_take isl_qpolynomial *sub, struct range_data *data)
+{
+	isl_bool involves, infty;
+
+	involves = isl_qpolynomial_involves_dims(poly, isl_dim_in, pos, 1);
+	if (involves < 0)
+		goto error;
+	if (!involves) {
+		isl_qpolynomial_free(sub);
+		return poly;
+	}
+
+	infty = isl_qpolynomial_is_infty(sub);
+	if (infty >= 0 && !infty)
+		infty = isl_qpolynomial_is_neginfty(sub);
+	if (infty < 0)
+		goto error;
+	if (infty) {
+		isl_space *space = isl_qpolynomial_get_domain_space(poly);
+		data->tight = 0;
+		isl_qpolynomial_free(poly);
+		isl_qpolynomial_free(sub);
+		return signed_infty(space, data->sign);
+	}
+
+	poly = isl_qpolynomial_substitute(poly, isl_dim_in, pos, 1, &sub);
+	isl_qpolynomial_free(sub);
+
+	return poly;
+error:
+	isl_qpolynomial_free(poly);
+	isl_qpolynomial_free(sub);
+	return NULL;
 }
 
 /* Given a lower and upper bound on the final variable and constraints
@@ -287,63 +349,60 @@
  * If all variables have been eliminated, then record the result.
  * Ohterwise, recurse on the next variable.
  */
-static int propagate_on_bound_pair(__isl_take isl_constraint *lower,
+static isl_stat propagate_on_bound_pair(__isl_take isl_constraint *lower,
 	__isl_take isl_constraint *upper, __isl_take isl_basic_set *bset,
 	void *user)
 {
 	struct range_data *data = (struct range_data *)user;
 	int save_tight = data->tight;
 	isl_qpolynomial *poly;
-	int r;
-	unsigned nvar;
+	isl_stat r;
+	isl_size nvar, nparam;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nvar < 0 || nparam < 0)
+		goto error;
 
 	if (data->monotonicity) {
 		isl_qpolynomial *sub;
-		isl_space *dim = isl_qpolynomial_get_domain_space(data->poly);
+		isl_space *space = isl_qpolynomial_get_domain_space(data->poly);
 		if (data->monotonicity * data->sign > 0) {
 			if (data->tight)
 				data->tight = bound_is_integer(upper, nvar);
-			sub = bound2poly(upper, dim, nvar, 1);
+			sub = bound2poly(upper, space, nvar, 1);
 			isl_constraint_free(lower);
 		} else {
 			if (data->tight)
 				data->tight = bound_is_integer(lower, nvar);
-			sub = bound2poly(lower, dim, nvar, -1);
+			sub = bound2poly(lower, space, nvar, -1);
 			isl_constraint_free(upper);
 		}
 		poly = isl_qpolynomial_copy(data->poly);
-		poly = isl_qpolynomial_substitute(poly, isl_dim_in, nvar, 1, &sub);
+		poly = plug_in_at_pos(poly, nvar, sub, data);
 		poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1);
-
-		isl_qpolynomial_free(sub);
 	} else {
 		isl_qpolynomial *l, *u;
 		isl_qpolynomial *pos, *neg;
-		isl_space *dim = isl_qpolynomial_get_domain_space(data->poly);
-		unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
+		isl_space *space = isl_qpolynomial_get_domain_space(data->poly);
 		int sign = data->sign * data->signsnparam + nvar;
 
 		data->tight = 0;
 
-		u = bound2poly(upper, isl_space_copy(dim), nvar, 1);
-		l = bound2poly(lower, dim, nvar, -1);
+		u = bound2poly(upper, isl_space_copy(space), nvar, 1);
+		l = bound2poly(lower, space, nvar, -1);
 
 		pos = isl_qpolynomial_terms_of_sign(data->poly, data->signs, sign);
 		neg = isl_qpolynomial_terms_of_sign(data->poly, data->signs, -sign);
 
-		pos = isl_qpolynomial_substitute(pos, isl_dim_in, nvar, 1, &u);
-		neg = isl_qpolynomial_substitute(neg, isl_dim_in, nvar, 1, &l);
+		pos = plug_in_at_pos(pos, nvar, u, data);
+		neg = plug_in_at_pos(neg, nvar, l, data);
 
 		poly = isl_qpolynomial_add(pos, neg);
 		poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, nvar, 1);
-
-		isl_qpolynomial_free(u);
-		isl_qpolynomial_free(l);
 	}
 
-	if (isl_basic_set_dim(bset, isl_dim_set) == 0)
+	if (nvar == 0)
 		r = add_guarded_poly(bset, poly, data);
 	else
 		r = propagate_on_domain(bset, poly, data);
@@ -351,27 +410,34 @@
 	data->tight = save_tight;
 
 	return r;
+error:
+	isl_constraint_free(lower);
+	isl_constraint_free(upper);
+	isl_basic_set_free(bset);
+	return isl_stat_error;
 }
 
 /* Recursively perform range propagation on the polynomial "poly"
  * defined over the basic set "bset" and collect the results in "data".
  */
-static int propagate_on_domain(__isl_take isl_basic_set *bset,
+static isl_stat propagate_on_domain(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, struct range_data *data)
 {
+	isl_bool is_cst;
 	isl_ctx *ctx;
 	isl_qpolynomial *save_poly = data->poly;
 	int save_monotonicity = data->monotonicity;
-	unsigned d;
+	isl_size d;
 
-	if (!bset || !poly)
+	d = isl_basic_set_dim(bset, isl_dim_set);
+	is_cst = isl_qpolynomial_is_cst(poly, NULL, NULL);
+	if (d < 0 || is_cst < 0)
 		goto error;
 
 	ctx = isl_basic_set_get_ctx(bset);
-	d = isl_basic_set_dim(bset, isl_dim_set);
 	isl_assert(ctx, d >= 1, goto error);
 
-	if (isl_qpolynomial_is_cst(poly, NULL, NULL)) {
+	if (is_cst) {
 		bset = isl_basic_set_project_out(bset, isl_dim_set, 0, d);
 		poly = isl_qpolynomial_drop_dims(poly, isl_dim_in, 0, d);
 		return add_guarded_poly(bset, poly, data);
@@ -394,28 +460,32 @@
 	data->monotonicity = save_monotonicity;
 	data->poly = save_poly;
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_basic_set_free(bset);
 	isl_qpolynomial_free(poly);
 	data->monotonicity = save_monotonicity;
 	data->poly = save_poly;
-	return -1;
+	return isl_stat_error;
 }
 
-static int basic_guarded_poly_bound(__isl_take isl_basic_set *bset, void *user)
+static isl_stat basic_guarded_poly_bound(__isl_take isl_basic_set *bset,
+	void *user)
 {
 	struct range_data *data = (struct range_data *)user;
 	isl_ctx *ctx;
-	unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
-	unsigned dim = isl_basic_set_dim(bset, isl_dim_set);
-	int r;
+	isl_size nparam = isl_basic_set_dim(bset, isl_dim_param);
+	isl_size dim = isl_basic_set_dim(bset, isl_dim_set);
+	isl_size total = isl_basic_set_dim(bset, isl_dim_all);
+	isl_stat r;
 
 	data->signs = NULL;
 
+	if (nparam < 0 || dim < 0 || total < 0)
+		goto error;
+
 	ctx = isl_basic_set_get_ctx(bset);
-	data->signs = isl_alloc_array(ctx, int,
-					isl_basic_set_dim(bset, isl_dim_all));
+	data->signs = isl_alloc_array(ctx, int, total);
 
 	if (isl_basic_set_dims_get_sign(bset, isl_dim_set, 0, dim,
 					data->signs + nparam) < 0)
@@ -432,17 +502,18 @@
 error:
 	free(data->signs);
 	isl_basic_set_free(bset);
-	return -1;
+	return isl_stat_error;
 }
 
-static int qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
-	__isl_take isl_qpolynomial *poly, struct range_data *data)
+static isl_stat qpolynomial_bound_on_domain_range(
+	__isl_take isl_basic_set *bset, __isl_take isl_qpolynomial *poly,
+	struct range_data *data)
 {
-	unsigned nparam = isl_basic_set_dim(bset, isl_dim_param);
-	unsigned nvar = isl_basic_set_dim(bset, isl_dim_set);
+	isl_size nparam = isl_basic_set_dim(bset, isl_dim_param);
+	isl_size nvar = isl_basic_set_dim(bset, isl_dim_set);
 	isl_set *set = NULL;
 
-	if (!bset)
+	if (nparam < 0 || nvar < 0)
 		goto error;
 
 	if (nvar == 0)
@@ -461,18 +532,18 @@
 	isl_set_free(set);
 	isl_qpolynomial_free(poly);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(set);
 	isl_qpolynomial_free(poly);
-	return -1;
+	return isl_stat_error;
 }
 
-int isl_qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
+isl_stat isl_qpolynomial_bound_on_domain_range(__isl_take isl_basic_set *bset,
 	__isl_take isl_qpolynomial *poly, struct isl_bound *bound)
 {
 	struct range_data data;
-	int r;
+	isl_stat r;
 
 	data.pwf = bound->pwf;
 	data.pwf_tight = bound->pwf_tight;

_service:tar_scm:isl-0.14.tar.xz/isl_range.h -> _service:tar_scm:isl-0.24.tar.gz/isl_range.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_reordering.c -> _service:tar_scm:isl-0.24.tar.gz/isl_reordering.c Changed

@@ -9,6 +9,7 @@
  */
 
 #include <isl_ctx_private.h>
+#include <isl/id.h>
 #include <isl_space_private.h>
 #include <isl_reordering.h>
 
@@ -23,7 +24,7 @@
 
 	exp->ref = 1;
 	exp->len = len;
-	exp->dim = NULL;
+	exp->space = NULL;
 
 	return exp;
 }
@@ -45,12 +46,12 @@
 	if (!r)
 		return NULL;
 
-	dup = isl_reordering_alloc(r->dim->ctx, r->len);
+	dup = isl_reordering_alloc(isl_reordering_get_ctx(r), r->len);
 	if (!dup)
 		return NULL;
 
-	dup->dim = isl_space_copy(r->dim);
-	if (!dup->dim)
+	dup->space = isl_reordering_get_space(r);
+	if (!dup->space)
 		return isl_reordering_free(dup);
 	for (i = 0; i < dup->len; ++i)
 		dup->posi = r->posi;
@@ -69,7 +70,7 @@
 	return isl_reordering_dup(r);
 }
 
-void *isl_reordering_free(__isl_take isl_reordering *exp)
+__isl_null isl_reordering *isl_reordering_free(__isl_take isl_reordering *exp)
 {
 	if (!exp)
 		return NULL;
@@ -77,11 +78,34 @@
 	if (--exp->ref > 0)
 		return NULL;
 
-	isl_space_free(exp->dim);
+	isl_space_free(exp->space);
 	free(exp);
 	return NULL;
 }
 
+/* Return the isl_ctx to which "r" belongs.
+ */
+isl_ctx *isl_reordering_get_ctx(__isl_keep isl_reordering *r)
+{
+	return isl_space_get_ctx(isl_reordering_peek_space(r));
+}
+
+/* Return the space of "r".
+ */
+__isl_keep isl_space *isl_reordering_peek_space(__isl_keep isl_reordering *r)
+{
+	if (!r)
+		return NULL;
+	return r->space;
+}
+
+/* Return a copy of the space of "r".
+ */
+__isl_give isl_space *isl_reordering_get_space(__isl_keep isl_reordering *r)
+{
+	return isl_space_copy(isl_reordering_peek_space(r));
+}
+
 /* Construct a reordering that maps the parameters of "alignee"
  * to the corresponding parameters in a new dimension specification
  * that has the parameters of "aligner" first, followed by
@@ -100,7 +124,7 @@
 	if (!exp)
 		return NULL;
 
-	exp->dim = isl_space_copy(aligner);
+	exp->space = isl_space_params(isl_space_copy(aligner));
 
 	for (i = 0; i < alignee->nparam; ++i) {
 		isl_id *id_i;
@@ -119,16 +143,19 @@
 			exp->posi = j;
 			isl_id_free(id_i);
 		} else {
-			int pos;
-			pos = isl_space_dim(exp->dim, isl_dim_param);
-			exp->dim = isl_space_add_dims(exp->dim, isl_dim_param, 1);
-			exp->dim = isl_space_set_dim_id(exp->dim,
+			isl_size pos;
+			pos = isl_space_dim(exp->space, isl_dim_param);
+			if (pos < 0)
+				exp->space = isl_space_free(exp->space);
+			exp->space = isl_space_add_dims(exp->space,
+						isl_dim_param, 1);
+			exp->space = isl_space_set_dim_id(exp->space,
 						isl_dim_param, pos, id_i);
 			exp->posi = pos;
 		}
 	}
 
-	if (!exp->dim)
+	if (!exp->space)
 		return isl_reordering_free(exp);
 	return exp;
 error:
@@ -136,23 +163,101 @@
 	return NULL;
 }
 
+/* Return a reordering that moves the parameters identified by
+ * the elements of "tuple" to a domain tuple inserted into "space".
+ * The parameters that remain, are moved from their original positions
+ * in the list of parameters to their new positions in this list.
+ * The parameters that get removed, are moved to the corresponding
+ * positions in the new domain.  Note that these set dimensions
+ * do not necessarily need to appear as parameters in "space".
+ * Any other dimensions are shifted by the number of extra dimensions
+ * introduced, i.e., the number of dimensions in the new domain
+ * that did not appear as parameters in "space".
+ */
+__isl_give isl_reordering *isl_reordering_unbind_params_insert_domain(
+	__isl_keep isl_space *space, __isl_keep isl_multi_id *tuple)
+{
+	int i, n;
+	int offset, first;
+	isl_ctx *ctx;
+	isl_reordering *r;
+
+	if (!space || !tuple)
+		return NULL;
+
+	ctx = isl_space_get_ctx(space);
+	r = isl_reordering_alloc(ctx, isl_space_dim(space, isl_dim_all));
+	if (!r)
+		return NULL;
+
+	r->space = isl_space_copy(space);
+	r->space = isl_space_unbind_params_insert_domain(r->space, tuple);
+	if (!r->space)
+		return isl_reordering_free(r);
+
+	n = isl_space_dim(r->space, isl_dim_param);
+	for (i = 0; i < n; ++i) {
+		int pos;
+		isl_id *id;
+
+		id = isl_space_get_dim_id(r->space, isl_dim_param, i);
+		if (!id)
+			return isl_reordering_free(r);
+		pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
+		isl_id_free(id);
+		r->pospos = i;
+	}
+
+	offset = isl_space_dim(r->space, isl_dim_param);
+	n = isl_multi_id_size(tuple);
+	for (i = 0; i < n; ++i) {
+		int pos;
+		isl_id *id;
+
+		id = isl_multi_id_get_id(tuple, i);
+		if (!id)
+			return isl_reordering_free(r);
+		pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos < 0)
+			continue;
+		r->pospos = offset + i;
+	}
+
+	offset = isl_space_dim(r->space, isl_dim_all) - r->len;
+	first = isl_space_dim(space, isl_dim_param);
+	n = r->len - first;
+	for (i = 0; i < n; ++i)
+		r->posfirst + i = first + offset + i;
+
+	return r;
+}
+
 __isl_give isl_reordering *isl_reordering_extend(__isl_take isl_reordering *exp,
 	unsigned extra)
 {
 	int i;
+	isl_ctx *ctx;
+	isl_space *space;
 	isl_reordering *res;
 	int offset;
+	isl_size dim;
 
 	if (!exp)
 		return NULL;
 	if (extra == 0)
 		return exp;
 
-	offset = isl_space_dim(exp->dim, isl_dim_all) - exp->len;
-	res = isl_reordering_alloc(exp->dim->ctx, exp->len + extra);
+	ctx = isl_reordering_get_ctx(exp);
+	space = isl_reordering_peek_space(exp);
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		return isl_reordering_free(exp);
+	offset = dim - exp->len;
+	res = isl_reordering_alloc(ctx, exp->len + extra);
 	if (!res)
 		goto error;
-	res->dim = isl_space_copy(exp->dim);
+	res->space = isl_reordering_get_space(exp);
 	for (i = 0; i < exp->len; ++i)
 		res->posi = exp->posi;
 	for (i = exp->len; i < res->len; ++i)
@@ -167,30 +272,33 @@
 }
 
 __isl_give isl_reordering *isl_reordering_extend_space(
-	__isl_take isl_reordering *exp, __isl_take isl_space *dim)
+	__isl_take isl_reordering *exp, __isl_take isl_space *space)
 {
+	isl_space *exp_space;
 	isl_reordering *res;
+	isl_size dim;
 
-	if (!exp || !dim)
+	dim = isl_space_dim(space, isl_dim_all);
+	if (!exp || dim < 0)
 		goto error;
 
-	res = isl_reordering_extend(isl_reordering_copy(exp),
-				    isl_space_dim(dim, isl_dim_all) - exp->len);
+	res = isl_reordering_extend(isl_reordering_copy(exp), dim - exp->len);
 	res = isl_reordering_cow(res);
 	if (!res)
 		goto error;
-	isl_space_free(res->dim);
-	res->dim = isl_space_replace(dim, isl_dim_param, exp->dim);
+	isl_space_free(res->space);
+	exp_space = isl_reordering_peek_space(exp);
+	res->space = isl_space_replace_params(space, exp_space);
 
 	isl_reordering_free(exp);
 
-	if (!res->dim)
+	if (!res->space)
 		return isl_reordering_free(res);
 
 	return res;
 error:
 	isl_reordering_free(exp);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -198,7 +306,7 @@
 {
 	int i;
 
-	isl_space_dump(exp->dim);
+	isl_space_dump(exp->space);
 	for (i = 0; i < exp->len; ++i)
 		fprintf(stderr, "%d -> %d; ", i, exp->posi);
 	fprintf(stderr, "\n");

_service:tar_scm:isl-0.14.tar.xz/isl_reordering.h -> _service:tar_scm:isl-0.24.tar.gz/isl_reordering.h Changed

@@ -4,7 +4,7 @@
 #include <isl/space.h>
 
 /* pos maps original dimensions to new dimensions.
- * The final dimension is given by dim.
+ * The final space is given by "space".
  * The number of dimensions (i.e., the range of values) in the result
  * may be larger than the number of dimensions in the input.
  * In particular, the possible values of the entries in pos ranges from 0 to
@@ -13,18 +13,23 @@
  */
 struct isl_reordering {
 	int ref;
-	isl_space *dim;
+	isl_space *space;
 	unsigned len;
 	int pos1;
 };
 typedef struct isl_reordering isl_reordering;
 
+isl_ctx *isl_reordering_get_ctx(__isl_keep isl_reordering *r);
+__isl_keep isl_space *isl_reordering_peek_space(__isl_keep isl_reordering *r);
+__isl_give isl_space *isl_reordering_get_space(__isl_keep isl_reordering *r);
 __isl_give isl_reordering *isl_parameter_alignment_reordering(
 	__isl_keep isl_space *alignee, __isl_keep isl_space *aligner);
+__isl_give isl_reordering *isl_reordering_unbind_params_insert_domain(
+	__isl_keep isl_space *space, __isl_keep isl_multi_id *tuple);
 __isl_give isl_reordering *isl_reordering_copy(__isl_keep isl_reordering *exp);
-void *isl_reordering_free(__isl_take isl_reordering *exp);
+__isl_null isl_reordering *isl_reordering_free(__isl_take isl_reordering *exp);
 __isl_give isl_reordering *isl_reordering_extend_space(
-	__isl_take isl_reordering *exp, __isl_take isl_space *dim);
+	__isl_take isl_reordering *exp, __isl_take isl_space *space);
 __isl_give isl_reordering *isl_reordering_extend(__isl_take isl_reordering *exp,
 	unsigned extra);

_service:tar_scm:isl-0.14.tar.xz/isl_sample.c -> _service:tar_scm:isl-0.24.tar.gz/isl_sample.c Changed

@@ -21,7 +21,10 @@
 #include <isl_options_private.h>
 #include <isl_vec_private.h>
 
-static struct isl_vec *empty_sample(struct isl_basic_set *bset)
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
+
+static __isl_give isl_vec *empty_sample(__isl_take isl_basic_set *bset)
 {
 	struct isl_vec *vec;
 
@@ -34,12 +37,14 @@
  * As a special case, if bset is zero-dimensional, this
  * function creates a zero-dimensional sample point.
  */
-static struct isl_vec *zero_sample(struct isl_basic_set *bset)
+static __isl_give isl_vec *zero_sample(__isl_take isl_basic_set *bset)
 {
-	unsigned dim;
+	isl_size dim;
 	struct isl_vec *sample;
 
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		goto error;
 	sample = isl_vec_alloc(bset->ctx, 1 + dim);
 	if (sample) {
 		isl_int_set_si(sample->el0, 1);
@@ -47,9 +52,12 @@
 	}
 	isl_basic_set_free(bset);
 	return sample;
+error:
+	isl_basic_set_free(bset);
+	return NULL;
 }
 
-static struct isl_vec *interval_sample(struct isl_basic_set *bset)
+static __isl_give isl_vec *interval_sample(__isl_take isl_basic_set *bset)
 {
 	int i;
 	isl_int t;
@@ -116,8 +124,8 @@
  * in the resulting bset, using the specified recurse function,
  * and then transform the sample back to the original space.
  */
-static struct isl_vec *sample_eq(struct isl_basic_set *bset,
-	struct isl_vec *(*recurse)(struct isl_basic_set *))
+static __isl_give isl_vec *sample_eq(__isl_take isl_basic_set *bset,
+	__isl_give isl_vec *(*recurse)(__isl_take isl_basic_set *))
 {
 	struct isl_mat *T;
 	struct isl_vec *sample;
@@ -209,6 +217,9 @@
 
 /* Compute the minimum of the current ("level") basis row over "tab"
  * and store the result in position "level" of "min".
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 static enum isl_lp_result compute_min(isl_ctx *ctx, struct isl_tab *tab,
 	__isl_keep isl_vec *min, int level)
@@ -219,6 +230,9 @@
 
 /* Compute the maximum of the current ("level") basis row over "tab"
  * and store the result in position "level" of "max".
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 static enum isl_lp_result compute_max(isl_ctx *ctx, struct isl_tab *tab,
 	__isl_keep isl_vec *max, int level)
@@ -361,7 +375,7 @@
  * reduction computation to return early.  That is, as soon as it
  * finds a reasonable first direction.
  */ 
-struct isl_vec *isl_tab_sample(struct isl_tab *tab)
+__isl_give isl_vec *isl_tab_sample(struct isl_tab *tab)
 {
 	unsigned dim;
 	unsigned gbr;
@@ -515,7 +529,48 @@
 	return NULL;
 }
 
-static struct isl_vec *sample_bounded(struct isl_basic_set *bset);
+static __isl_give isl_vec *sample_bounded(__isl_take isl_basic_set *bset);
+
+/* Internal data for factored_sample.
+ * "sample" collects the sample and may get reset to a zero-length vector
+ * signaling the absence of a sample vector.
+ * "pos" is the position of the contribution of the next factor.
+ */
+struct isl_factored_sample_data {
+	isl_vec *sample;
+	int pos;
+};
+
+/* isl_factorizer_every_factor_basic_set callback that extends
+ * the sample in data->sample with the contribution
+ * of the factor "bset".
+ * If "bset" turns out to be empty, then the product is empty too and
+ * no further factors need to be considered.
+ */
+static isl_bool factor_sample(__isl_keep isl_basic_set *bset, void *user)
+{
+	struct isl_factored_sample_data *data = user;
+	isl_vec *sample;
+	isl_size n;
+
+	n = isl_basic_set_dim(bset, isl_dim_set);
+	if (n < 0)
+		return isl_bool_error;
+
+	sample = sample_bounded(isl_basic_set_copy(bset));
+	if (!sample)
+		return isl_bool_error;
+	if (sample->size == 0) {
+		isl_vec_free(data->sample);
+		data->sample = sample;
+		return isl_bool_false;
+	}
+	isl_seq_cpy(data->sample->el + data->pos, sample->el + 1, n);
+	isl_vec_free(sample);
+	data->pos += n;
+
+	return isl_bool_true;
+}
 
 /* Compute a sample point of the given basic set, based on the given,
  * non-trivial factorization.
@@ -523,65 +578,39 @@
 static __isl_give isl_vec *factored_sample(__isl_take isl_basic_set *bset,
 	__isl_take isl_factorizer *f)
 {
-	int i, n;
-	isl_vec *sample = NULL;
+	struct isl_factored_sample_data data = { NULL };
 	isl_ctx *ctx;
-	unsigned nparam;
-	unsigned nvar;
+	isl_size total;
+	isl_bool every;
 
 	ctx = isl_basic_set_get_ctx(bset);
-	if (!ctx)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (!ctx || total < 0)
 		goto error;
 
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-	nvar = isl_basic_set_dim(bset, isl_dim_set);
-
-	sample = isl_vec_alloc(ctx, 1 + isl_basic_set_total_dim(bset));
-	if (!sample)
+	data.sample = isl_vec_alloc(ctx, 1 + total);
+	if (!data.sample)
 		goto error;
-	isl_int_set_si(sample->el0, 1);
-
-	bset = isl_morph_basic_set(isl_morph_copy(f->morph), bset);
+	isl_int_set_si(data.sample->el0, 1);
+	data.pos = 1;
 
-	for (i = 0, n = 0; i < f->n_group; ++i) {
-		isl_basic_set *bset_i;
-		isl_vec *sample_i;
+	every = isl_factorizer_every_factor_basic_set(f, &factor_sample, &data);
+	if (every < 0) {
+		data.sample = isl_vec_free(data.sample);
+	} else if (every) {
+		isl_morph *morph;
 
-		bset_i = isl_basic_set_copy(bset);
-		bset_i = isl_basic_set_drop_constraints_involving(bset_i,
-			    nparam + n + f->leni, nvar - n - f->leni);
-		bset_i = isl_basic_set_drop_constraints_involving(bset_i,
-			    nparam, n);
-		bset_i = isl_basic_set_drop(bset_i, isl_dim_set,
-			    n + f->leni, nvar - n - f->leni);
-		bset_i = isl_basic_set_drop(bset_i, isl_dim_set, 0, n);
-
-		sample_i = sample_bounded(bset_i);
-		if (!sample_i)
-			goto error;
-		if (sample_i->size == 0) {
-			isl_basic_set_free(bset);
-			isl_factorizer_free(f);
-			isl_vec_free(sample);
-			return sample_i;
-		}
-		isl_seq_cpy(sample->el + 1 + nparam + n,
-			    sample_i->el + 1, f->leni);
-		isl_vec_free(sample_i);
-
-		n += f->leni;
+		morph = isl_morph_inverse(isl_morph_copy(f->morph));
+		data.sample = isl_morph_vec(morph, data.sample);
 	}
 
-	f->morph = isl_morph_inverse(f->morph);
-	sample = isl_morph_vec(isl_morph_copy(f->morph), sample);
-
 	isl_basic_set_free(bset);
 	isl_factorizer_free(f);
-	return sample;
+	return data.sample;
 error:
 	isl_basic_set_free(bset);
 	isl_factorizer_free(f);
-	isl_vec_free(sample);
+	isl_vec_free(data.sample);
 	return NULL;
 }
 
@@ -592,10 +621,9 @@
  * and then use isl_tab_sample to find a sample, passing it
  * the identity matrix as initial basis.
  */ 
-static struct isl_vec *sample_bounded(struct isl_basic_set *bset)
+static __isl_give isl_vec *sample_bounded(__isl_take isl_basic_set *bset)
 {
-	unsigned dim;
-	struct isl_ctx *ctx;
+	isl_size dim;
 	struct isl_vec *sample;
 	struct isl_tab *tab = NULL;
 	isl_factorizer *f;
@@ -606,7 +634,9 @@
 	if (isl_basic_set_plain_is_empty(bset))
 		return empty_sample(bset);
 
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		bset = isl_basic_set_free(bset);
 	if (dim == 0)
 		return zero_sample(bset);
 	if (dim == 1)
@@ -620,14 +650,12 @@
 	if (f->n_group != 0)
 		return factored_sample(bset, f);
 	isl_factorizer_free(f);
-		
-	ctx = bset->ctx;
 
 	tab = isl_tab_from_basic_set(bset, 1);
 	if (tab && tab->empty) {
 		isl_tab_free(tab);
 		ISL_F_SET(bset, ISL_BASIC_SET_EMPTY);
-		sample = isl_vec_alloc(bset->ctx, 0);
+		sample = isl_vec_alloc(isl_basic_set_get_ctx(bset), 0);
 		isl_basic_set_free(bset);
 		return sample;
 	}
@@ -666,17 +694,17 @@
  * where 1 s is the sample value and I is the identity matrix of the
  * appropriate dimension.
  */
-static struct isl_basic_set *plug_in(struct isl_basic_set *bset,
-	struct isl_vec *sample)
+static __isl_give isl_basic_set *plug_in(__isl_take isl_basic_set *bset,
+	__isl_take isl_vec *sample)
 {
 	int i;
-	unsigned total;
+	isl_size total;
 	struct isl_mat *T;
 
-	if (!bset || !sample)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0 || !sample)
 		goto error;
 
-	total = isl_basic_set_total_dim(bset);
 	T = isl_mat_alloc(bset->ctx, 1 + total, 1 + total - (sample->size - 1));
 	if (!T)
 		goto error;
@@ -702,7 +730,7 @@
 /* Given a basic set "bset", return any (possibly non-integer) point
  * in the basic set.
  */
-static struct isl_vec *rational_sample(struct isl_basic_set *bset)
+static __isl_give isl_vec *rational_sample(__isl_take isl_basic_set *bset)
 {
 	struct isl_tab *tab;
 	struct isl_vec *sample;
@@ -752,21 +780,20 @@
  * and we only have to add the smallest negative a_i (if any)
  * instead of the sum of all negative a_i.
  */
-static struct isl_basic_set *shift_cone(struct isl_basic_set *cone,
-	struct isl_vec *vec)
+static __isl_give isl_basic_set *shift_cone(__isl_take isl_basic_set *cone,
+	__isl_take isl_vec *vec)
 {
 	int i, j, k;
-	unsigned total;
+	isl_size total;
 
 	struct isl_basic_set *shift = NULL;
 
-	if (!cone || !vec)
+	total = isl_basic_set_dim(cone, isl_dim_all);
+	if (total < 0 || !vec)
 		goto error;
 
 	isl_assert(cone->ctx, cone->n_eq == 0, goto error);
 
-	total = isl_basic_set_total_dim(cone);
-
 	shift = isl_basic_set_alloc_space(isl_basic_set_get_space(cone),
 					0, 0, cone->n_ineq);
 
@@ -810,10 +837,10 @@
  * Then we simply round up the coordinates of x and return the
  * resulting integer point.
  */
-static struct isl_vec *round_up_in_cone(struct isl_vec *vec,
-	struct isl_basic_set *cone, struct isl_mat *U)
+static __isl_give isl_vec *round_up_in_cone(__isl_take isl_vec *vec,
+	__isl_take isl_basic_set *cone, __isl_take isl_mat *U)
 {
-	unsigned total;
+	isl_size total;
 
 	if (!vec || !cone || !U)
 		goto error;
@@ -825,7 +852,9 @@
 		return vec;
 	}
 
-	total = isl_basic_set_total_dim(cone);
+	total = isl_basic_set_dim(cone, isl_dim_all);
+	if (total < 0)
+		goto error;
 	cone = isl_basic_set_preimage(cone, U);
 	cone = isl_basic_set_remove_dims(cone, isl_dim_set,
 					 0, total - (vec->size - 1));
@@ -845,7 +874,8 @@
 /* Concatenate two integer vectors, i.e., two vectors with denominator
  * (stored in element 0) equal to 1.
  */
-static struct isl_vec *vec_concat(struct isl_vec *vec1, struct isl_vec *vec2)
+static __isl_give isl_vec *vec_concat(__isl_take isl_vec *vec1,
+	__isl_take isl_vec *vec2)
 {
 	struct isl_vec *vec;
 
@@ -913,7 +943,7 @@
 __isl_give isl_vec *isl_basic_set_sample_with_cone(
 	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *cone)
 {
-	unsigned total;
+	isl_size total;
 	unsigned cone_dim;
 	struct isl_mat *M, *U;
 	struct isl_vec *sample;
@@ -921,14 +951,14 @@
 	struct isl_ctx *ctx;
 	struct isl_basic_set *bounded;
 
-	if (!bset || !cone)
+	total = isl_basic_set_dim(cone, isl_dim_all);
+	if (!bset || total < 0)
 		goto error;
 
-	ctx = bset->ctx;
-	total = isl_basic_set_total_dim(cone);
+	ctx = isl_basic_set_get_ctx(bset);
 	cone_dim = total - cone->n_eq;
 
-	M = isl_mat_sub_alloc6(bset->ctx, cone->eq, 0, cone->n_eq, 1, total);
+	M = isl_mat_sub_alloc6(ctx, cone->eq, 0, cone->n_eq, 1, total);
 	M = isl_mat_left_hermite(M, 0, &U, NULL);
 	if (!M)
 		goto error;
@@ -960,7 +990,7 @@
 	return NULL;
 }
 
-static void vec_sum_of_neg(struct isl_vec *v, isl_int *s)
+static void vec_sum_of_neg(__isl_keep isl_vec *v, isl_int *s)
 {
 	int i;
 
@@ -1094,12 +1124,14 @@
  * sample_with_cone.  Otherwise, we directly perform generalized basis
  * reduction.
  */
-static struct isl_vec *gbr_sample(struct isl_basic_set *bset)
+static __isl_give isl_vec *gbr_sample(__isl_take isl_basic_set *bset)
 {
-	unsigned dim;
+	isl_size dim;
 	struct isl_basic_set *cone;
 
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		goto error;
 
 	cone = isl_basic_set_recession_cone(isl_basic_set_copy(bset));
 	if (!cone)
@@ -1115,10 +1147,11 @@
 	return NULL;
 }
 
-static struct isl_vec *basic_set_sample(struct isl_basic_set *bset, int bounded)
+static __isl_give isl_vec *basic_set_sample(__isl_take isl_basic_set *bset,
+	int bounded)
 {
 	struct isl_ctx *ctx;
-	unsigned dim;
+	isl_size dim;
 	if (!bset)
 		return NULL;
 
@@ -1126,9 +1159,11 @@
 	if (isl_basic_set_plain_is_empty(bset))
 		return empty_sample(bset);
 
-	dim = isl_basic_set_n_dim(bset);
-	isl_assert(ctx, isl_basic_set_n_param(bset) == 0, goto error);
-	isl_assert(ctx, bset->n_div == 0, goto error);
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0 ||
+	    isl_basic_set_check_no_params(bset) < 0 ||
+	    isl_basic_set_check_no_locals(bset) < 0)
+		goto error;
 
 	if (bset->sample && bset->sample->size == 1 + dim) {
 		int contains = isl_basic_set_contains(bset, bset->sample);
@@ -1165,7 +1200,7 @@
 /* Compute an integer sample in "bset", where the caller guarantees
  * that "bset" is bounded.
  */
-struct isl_vec *isl_basic_set_sample_bounded(struct isl_basic_set *bset)
+__isl_give isl_vec *isl_basic_set_sample_bounded(__isl_take isl_basic_set *bset)
 {
 	return basic_set_sample(bset, 1);
 }
@@ -1176,7 +1211,7 @@
 	int k;
 	struct isl_basic_set *bset = NULL;
 	struct isl_ctx *ctx;
-	unsigned dim;
+	isl_size dim;
 
 	if (!vec)
 		return NULL;
@@ -1184,9 +1219,9 @@
 	isl_assert(ctx, vec->size != 0, goto error);
 
 	bset = isl_basic_set_alloc(ctx, 0, vec->size - 1, 0, vec->size - 1, 0);
-	if (!bset)
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
 		goto error;
-	dim = isl_basic_set_n_dim(bset);
 	for (i = dim - 1; i >= 0; --i) {
 		k = isl_basic_set_alloc_equality(bset);
 		if (k < 0)
@@ -1214,12 +1249,11 @@
 	if (!sample_vec)
 		goto error;
 	if (sample_vec->size == 0) {
-		struct isl_basic_map *sample;
-		sample = isl_basic_map_empty_like(bmap);
 		isl_vec_free(sample_vec);
-		isl_basic_map_free(bmap);
-		return sample;
+		return isl_basic_map_set_to_empty(bmap);
 	}
+	isl_vec_free(bmap->sample);
+	bmap->sample = isl_vec_copy(sample_vec);
 	bset = isl_basic_set_from_vec(sample_vec);
 	return isl_basic_map_overlying_set(bset, bmap);
 error:
@@ -1249,7 +1283,7 @@
 		isl_basic_map_free(sample);
 	}
 	if (i == map->n)
-		sample = isl_basic_map_empty_like_map(map);
+		sample = isl_basic_map_empty(isl_map_get_space(map));
 	isl_map_free(map);
 	return sample;
 error:
@@ -1259,19 +1293,19 @@
 
 __isl_give isl_basic_set *isl_set_sample(__isl_take isl_set *set)
 {
-	return (isl_basic_set *) isl_map_sample((isl_map *)set);
+	return bset_from_bmap(isl_map_sample(set_to_map(set)));
 }
 
 __isl_give isl_point *isl_basic_set_sample_point(__isl_take isl_basic_set *bset)
 {
 	isl_vec *vec;
-	isl_space *dim;
+	isl_space *space;
 
-	dim = isl_basic_set_get_space(bset);
+	space = isl_basic_set_get_space(bset);
 	bset = isl_basic_set_underlying_set(bset);
 	vec = isl_basic_set_sample_vec(bset);
 
-	return isl_point_alloc(dim, vec);
+	return isl_point_alloc(space, vec);
 }
 
 __isl_give isl_point *isl_set_sample_point(__isl_take isl_set *set)

_service:tar_scm:isl-0.14.tar.xz/isl_sample.h -> _service:tar_scm:isl-0.24.tar.gz/isl_sample.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_scan.c -> _service:tar_scm:isl-0.24.tar.gz/isl_scan.c Changed

@@ -22,7 +22,7 @@
 	isl_int max;
 };
 
-static int increment_counter(struct isl_scan_callback *cb,
+static isl_stat increment_counter(struct isl_scan_callback *cb,
 	__isl_take isl_vec *sample)
 {
 	struct isl_counter *cnt = (struct isl_counter *)cb;
@@ -32,8 +32,8 @@
 	isl_vec_free(sample);
 
 	if (isl_int_is_zero(cnt->max) || isl_int_lt(cnt->count, cnt->max))
-		return 0;
-	return -1;
+		return isl_stat_ok;
+	return isl_stat_error;
 }
 
 static int increment_range(struct isl_scan_callback *cb, isl_int min, isl_int max)
@@ -65,7 +65,7 @@
 	return callback->add(callback, sample);
 }
 
-static int scan_0D(struct isl_basic_set *bset,
+static isl_stat scan_0D(__isl_take isl_basic_set *bset,
 	struct isl_scan_callback *callback)
 {
 	struct isl_vec *sample;
@@ -74,7 +74,7 @@
 	isl_basic_set_free(bset);
 
 	if (!sample)
-		return -1;
+		return isl_stat_error;
 
 	isl_int_set_si(sample->el0, 1);
 
@@ -99,10 +99,10 @@
  * Solutions are added in the leaves of the search tree, i.e., after
  * we have fixed a value in each direction of the basis.
  */
-int isl_basic_set_scan(struct isl_basic_set *bset,
+isl_stat isl_basic_set_scan(__isl_take isl_basic_set *bset,
 	struct isl_scan_callback *callback)
 {
-	unsigned dim;
+	isl_size dim;
 	struct isl_mat *B = NULL;
 	struct isl_tab *tab = NULL;
 	struct isl_vec *min;
@@ -112,10 +112,12 @@
 	int init;
 	enum isl_lp_result res;
 
-	if (!bset)
-		return -1;
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0) {
+		bset = isl_basic_set_free(bset);
+		return isl_stat_error;
+	}
 
-	dim = isl_basic_set_total_dim(bset);
 	if (dim == 0)
 		return scan_0D(bset, callback);
 
@@ -209,7 +211,7 @@
 	isl_vec_free(max);
 	isl_basic_set_free(bset);
 	isl_mat_free(B);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_tab_free(tab);
 	free(snap);
@@ -217,10 +219,11 @@
 	isl_vec_free(max);
 	isl_basic_set_free(bset);
 	isl_mat_free(B);
-	return -1;
+	return isl_stat_error;
 }
 
-int isl_set_scan(__isl_take isl_set *set, struct isl_scan_callback *callback)
+isl_stat isl_set_scan(__isl_take isl_set *set,
+	struct isl_scan_callback *callback)
 {
 	int i;
 
@@ -239,10 +242,10 @@
 			goto error;
 
 	isl_set_free(set);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_set_free(set);
-	return -1;
+	return isl_stat_error;
 }
 
 int isl_basic_set_count_upto(__isl_keep isl_basic_set *bset,

_service:tar_scm:isl-0.14.tar.xz/isl_scan.h -> _service:tar_scm:isl-0.24.tar.gz/isl_scan.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_schedule.c -> _service:tar_scm:isl-0.24.tar.gz/isl_schedule.c Changed

@@ -1,6 +1,7 @@
 /*
  * Copyright 2011      INRIA Saclay
  * Copyright 2012-2014 Ecole Normale Superieure
+ * Copyright 2016      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
@@ -11,662 +12,673 @@
  */
 
 #include <isl/ctx.h>
+#include <isl/val.h>
 #include <isl_aff_private.h>
 #include <isl/map.h>
 #include <isl/set.h>
+#include <isl/schedule.h>
+#include <isl/schedule_node.h>
 #include <isl_sort.h>
+#include <isl/printer.h>
 #include <isl_schedule_private.h>
-#include <isl_band_private.h>
+#include <isl_schedule_tree.h>
+#include <isl_schedule_node_private.h>
 
-__isl_null isl_schedule *isl_schedule_free(__isl_take isl_schedule *sched)
+/* Return a schedule encapsulating the given schedule tree.
+ *
+ * We currently only allow schedule trees with a domain or extension as root.
+ *
+ * The leaf field is initialized as a leaf node so that it can be
+ * used to represent leaves in the constructed schedule.
+ * The reference count is set to -1 since the isl_schedule_tree
+ * should never be freed.  It is up to the (internal) users of
+ * these leaves to ensure that they are only used while the schedule
+ * is still alive.
+ */
+__isl_give isl_schedule *isl_schedule_from_schedule_tree(isl_ctx *ctx,
+	__isl_take isl_schedule_tree *tree)
 {
-	int i;
-	if (!sched)
-		return NULL;
+	enum isl_schedule_node_type type;
+	isl_schedule *schedule;
 
-	if (--sched->ref > 0)
+	if (!tree)
 		return NULL;
+	type = isl_schedule_tree_get_type(tree);
+	if (type != isl_schedule_node_domain &&
+	    type != isl_schedule_node_extension)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_unsupported,
+			"root of schedule tree should be a domain or extension",
+			goto error);
+
+	schedule = isl_calloc_type(ctx, isl_schedule);
+	if (!schedule)
+		goto error;
 
-	for (i = 0; i < sched->n; ++i) {
-		isl_multi_aff_free(sched->nodei.sched);
-		free(sched->nodei.band_end);
-		free(sched->nodei.band_id);
-		free(sched->nodei.coincident);
-	}
-	isl_space_free(sched->dim);
-	isl_band_list_free(sched->band_forest);
-	free(sched);
-	return NULL;
-}
+	schedule->ref = 1;
+	schedule->root = tree;
+	schedule->leaf = isl_schedule_tree_leaf(ctx);
 
-isl_ctx *isl_schedule_get_ctx(__isl_keep isl_schedule *schedule)
-{
-	return schedule ? isl_space_get_ctx(schedule->dim) : NULL;
+	if (!schedule->leaf)
+		return isl_schedule_free(schedule);
+	return schedule;
+error:
+	isl_schedule_tree_free(tree);
+	return NULL;
 }
 
-/* Set max_out to the maximal number of output dimensions over
- * all maps.
+/* Return a pointer to a schedule with as single node
+ * a domain node with the given domain.
  */
-static int update_max_out(__isl_take isl_map *map, void *user)
+__isl_give isl_schedule *isl_schedule_from_domain(
+	__isl_take isl_union_set *domain)
 {
-	int *max_out = user;
-	int n_out = isl_map_dim(map, isl_dim_out);
-
-	if (n_out > *max_out)
-		*max_out = n_out;
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
 
-	isl_map_free(map);
-	return 0;
+	ctx = isl_union_set_get_ctx(domain);
+	tree = isl_schedule_tree_from_domain(domain);
+	return isl_schedule_from_schedule_tree(ctx, tree);
 }
 
-/* Internal data structure for map_pad_range.
- *
- * "max_out" is the maximal schedule dimension.
- * "res" collects the results.
+/* Return a pointer to a schedule with as single node
+ * a domain node with an empty domain.
  */
-struct isl_pad_schedule_map_data {
-	int max_out;
-	isl_union_map *res;
-};
+__isl_give isl_schedule *isl_schedule_empty(__isl_take isl_space *space)
+{
+	return isl_schedule_from_domain(isl_union_set_empty(space));
+}
 
-/* Pad the range of the given map with zeros to data->max_out and
- * then add the result to data->res.
+/* Return a new reference to "sched".
  */
-static int map_pad_range(__isl_take isl_map *map, void *user)
+__isl_give isl_schedule *isl_schedule_copy(__isl_keep isl_schedule *sched)
 {
-	struct isl_pad_schedule_map_data *data = user;
-	int i;
-	int n_out = isl_map_dim(map, isl_dim_out);
-
-	map = isl_map_add_dims(map, isl_dim_out, data->max_out - n_out);
-	for (i = n_out; i < data->max_out; ++i)
-		map = isl_map_fix_si(map, isl_dim_out, i, 0);
-
-	data->res = isl_union_map_add_map(data->res, map);
-	if (!data->res)
-		return -1;
+	if (!sched)
+		return NULL;
 
-	return 0;
+	sched->ref++;
+	return sched;
 }
 
-/* Pad the ranges of the maps in the union map with zeros such they all have
- * the same dimension.
+/* Return an isl_schedule that is equal to "schedule" and that has only
+ * a single reference.
  */
-static __isl_give isl_union_map *pad_schedule_map(
-	__isl_take isl_union_map *umap)
+__isl_give isl_schedule *isl_schedule_cow(__isl_take isl_schedule *schedule)
 {
-	struct isl_pad_schedule_map_data data;
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
 
-	if (!umap)
+	if (!schedule)
 		return NULL;
-	if (isl_union_map_n_map(umap) <= 1)
-		return umap;
+	if (schedule->ref == 1)
+		return schedule;
 
-	data.max_out = 0;
-	if (isl_union_map_foreach_map(umap, &update_max_out, &data.max_out) < 0)
-		return isl_union_map_free(umap);
-
-	data.res = isl_union_map_empty(isl_union_map_get_space(umap));
-	if (isl_union_map_foreach_map(umap, &map_pad_range, &data) < 0)
-		data.res = isl_union_map_free(data.res);
-
-	isl_union_map_free(umap);
-	return data.res;
+	ctx = isl_schedule_get_ctx(schedule);
+	schedule->ref--;
+	tree = isl_schedule_tree_copy(schedule->root);
+	return isl_schedule_from_schedule_tree(ctx, tree);
 }
 
-/* Return an isl_union_map of the schedule.  If we have already constructed
- * a band forest, then this band forest may have been modified so we need
- * to extract the isl_union_map from the forest rather than from
- * the originally computed schedule.  This reconstructed schedule map
- * then needs to be padded with zeros to unify the schedule space
- * since the result of isl_band_list_get_suffix_schedule may not have
- * a unified schedule space.
- */
-__isl_give isl_union_map *isl_schedule_get_map(__isl_keep isl_schedule *sched)
+__isl_null isl_schedule *isl_schedule_free(__isl_take isl_schedule *sched)
 {
-	int i;
-	isl_union_map *umap;
-
 	if (!sched)
 		return NULL;
 
-	if (sched->band_forest) {
-		umap = isl_band_list_get_suffix_schedule(sched->band_forest);
-		return pad_schedule_map(umap);
-	}
+	if (--sched->ref > 0)
+		return NULL;
 
-	umap = isl_union_map_empty(isl_space_copy(sched->dim));
-	for (i = 0; i < sched->n; ++i) {
-		isl_multi_aff *ma;
+	isl_schedule_tree_free(sched->root);
+	isl_schedule_tree_free(sched->leaf);
+	free(sched);
+	return NULL;
+}
 
-		ma = isl_multi_aff_copy(sched->nodei.sched);
-		umap = isl_union_map_add_map(umap, isl_map_from_multi_aff(ma));
+/* Replace the root of "schedule" by "tree".
+ */
+__isl_give isl_schedule *isl_schedule_set_root(
+	__isl_take isl_schedule *schedule, __isl_take isl_schedule_tree *tree)
+{
+	if (!schedule || !tree)
+		goto error;
+	if (schedule->root == tree) {
+		isl_schedule_tree_free(tree);
+		return schedule;
 	}
 
-	return umap;
+	schedule = isl_schedule_cow(schedule);
+	if (!schedule)
+		goto error;
+	isl_schedule_tree_free(schedule->root);
+	schedule->root = tree;
+
+	return schedule;
+error:
+	isl_schedule_free(schedule);
+	isl_schedule_tree_free(tree);
+	return NULL;
 }
 
-static __isl_give isl_band_list *construct_band_list(
-	__isl_keep isl_schedule *schedule, __isl_keep isl_band *parent,
-	int band_nr, int *parent_active, int n_active);
+isl_ctx *isl_schedule_get_ctx(__isl_keep isl_schedule *schedule)
+{
+	return schedule ? isl_schedule_tree_get_ctx(schedule->leaf) : NULL;
+}
 
-/* Construct an isl_band structure for the band in the given schedule
- * with sequence number band_nr for the n_active nodes marked by active.
- * If the nodes don't have a band with the given sequence number,
- * then a band without members is created.
- *
- * Because of the way the schedule is constructed, we know that
- * the position of the band inside the schedule of a node is the same
- * for all active nodes.
- *
- * The partial schedule for the band is created before the children
- * are created to that construct_band_list can refer to the partial
- * schedule of the parent.
+/* Return a pointer to the leaf of "schedule".
  */
-static __isl_give isl_band *construct_band(__isl_keep isl_schedule *schedule,
-	__isl_keep isl_band *parent,
-	int band_nr, int *active, int n_active)
+__isl_keep isl_schedule_tree *isl_schedule_peek_leaf(
+	__isl_keep isl_schedule *schedule)
 {
-	int i, j;
-	isl_ctx *ctx = isl_schedule_get_ctx(schedule);
-	isl_band *band;
-	unsigned start, end;
-
-	band = isl_band_alloc(ctx);
-	if (!band)
-		return NULL;
+	return schedule ? schedule->leaf : NULL;
+}
 
-	band->schedule = schedule;
-	band->parent = parent;
+/* Are "schedule1" and "schedule2" obviously equal to each other?
+ */
+isl_bool isl_schedule_plain_is_equal(__isl_keep isl_schedule *schedule1,
+	__isl_keep isl_schedule *schedule2)
+{
+	if (!schedule1 || !schedule2)
+		return isl_bool_error;
+	if (schedule1 == schedule2)
+		return isl_bool_true;
+	return isl_schedule_tree_plain_is_equal(schedule1->root,
+						schedule2->root);
+}
 
-	for (i = 0; i < schedule->n; ++i)
-		if (activei)
-			break;
+/* Return the (parameter) space of the schedule, i.e., the space
+ * of the root domain.
+ */
+__isl_give isl_space *isl_schedule_get_space(
+	__isl_keep isl_schedule *schedule)
+{
+	enum isl_schedule_node_type type;
+	isl_space *space;
+	isl_union_set *domain;
 
-	if (i >= schedule->n)
-		isl_die(ctx, isl_error_internal,
-			"band without active statements", goto error);
+	if (!schedule)
+		return NULL;
+	type = isl_schedule_tree_get_type(schedule->root);
+	if (type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(schedule), isl_error_internal,
+			"root node not a domain node", return NULL);
 
-	start = band_nr ? schedule->nodei.band_endband_nr - 1 : 0;
-	end = band_nr < schedule->nodei.n_band ?
-		schedule->nodei.band_endband_nr : start;
-	band->n = end - start;
+	domain = isl_schedule_tree_domain_get_domain(schedule->root);
+	space = isl_union_set_get_space(domain);
+	isl_union_set_free(domain);
 
-	band->coincident = isl_alloc_array(ctx, int, band->n);
-	if (band->n && !band->coincident)
-		goto error;
+	return space;
+}
 
-	for (j = 0; j < band->n; ++j)
-		band->coincidentj = schedule->nodei.coincidentstart + j;
-
-	band->pma = isl_union_pw_multi_aff_empty(isl_space_copy(schedule->dim));
-	for (i = 0; i < schedule->n; ++i) {
-		isl_multi_aff *ma;
-		isl_pw_multi_aff *pma;
-		unsigned n_out;
-
-		if (!activei)
-			continue;
-
-		ma = isl_multi_aff_copy(schedule->nodei.sched);
-		n_out = isl_multi_aff_dim(ma, isl_dim_out);
-		ma = isl_multi_aff_drop_dims(ma, isl_dim_out, end, n_out - end);
-		ma = isl_multi_aff_drop_dims(ma, isl_dim_out, 0, start);
-		pma = isl_pw_multi_aff_from_multi_aff(ma);
-		band->pma = isl_union_pw_multi_aff_add_pw_multi_aff(band->pma,
-								    pma);
-	}
-	if (!band->pma)
-		goto error;
+/* Return a pointer to the root of "schedule".
+ */
+__isl_give isl_schedule_node *isl_schedule_get_root(
+	__isl_keep isl_schedule *schedule)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+	isl_schedule_tree_list *ancestors;
 
-	for (i = 0; i < schedule->n; ++i)
-		if (activei && schedule->nodei.n_band > band_nr + 1)
-			break;
+	if (!schedule)
+		return NULL;
 
-	if (i < schedule->n) {
-		band->children = construct_band_list(schedule, band,
-						band_nr + 1, active, n_active);
-		if (!band->children)
-			goto error;
-	}
+	ctx = isl_schedule_get_ctx(schedule);
+	tree = isl_schedule_tree_copy(schedule->root);
+	schedule = isl_schedule_copy(schedule);
+	ancestors = isl_schedule_tree_list_alloc(ctx, 0);
+	return isl_schedule_node_alloc(schedule, tree, ancestors, NULL);
+}
 
-	return band;
-error:
-	isl_band_free(band);
-	return NULL;
+/* Return the domain of the root domain node of "schedule".
+ */
+__isl_give isl_union_set *isl_schedule_get_domain(
+	__isl_keep isl_schedule *schedule)
+{
+	if (!schedule)
+		return NULL;
+	return isl_schedule_tree_domain_get_domain(schedule->root);
 }
 
-/* Internal data structure used inside cmp_band and pw_multi_aff_extract_int.
+/* Traverse all nodes of "sched" in depth first preorder.
  *
- * r is set to a negative value if anything goes wrong.
+ * If "fn" returns -1 on any of the nodes, then the traversal is aborted.
+ * If "fn" returns 0 on any of the nodes, then the subtree rooted
+ * at that node is skipped.
  *
- * c1 stores the result of extract_int.
- * c2 is a temporary value used inside cmp_band_in_ancestor.
- * t is a temporary value used inside extract_int.
- *
- * first and equal are used inside extract_int.
- * first is set if we are looking at the first isl_multi_aff inside
- * the isl_union_pw_multi_aff.
- * equal is set if all the isl_multi_affs have been equal so far.
+ * Return 0 on success and -1 on failure.
  */
-struct isl_cmp_band_data {
-	int r;
-
-	int first;
-	int equal;
-
-	isl_int t;
-	isl_int c1;
-	isl_int c2;
-};
-
-/* Check if "ma" assigns a constant value.
- * Note that this function is only called on isl_multi_affs
- * with a single output dimension.
- *
- * If "ma" assigns a constant value then we compare it to data->c1
- * or assign it to data->c1 if this is the first isl_multi_aff we consider.
- * If "ma" does not assign a constant value or if it assigns a value
- * that is different from data->c1, then we set data->equal to zero
- * and terminate the check.
- */
-static int multi_aff_extract_int(__isl_take isl_set *set,
-	__isl_take isl_multi_aff *ma, void *user)
-{
-	isl_aff *aff;
-	struct isl_cmp_band_data *data = user;
-
-	aff = isl_multi_aff_get_aff(ma, 0);
-	data->r = isl_aff_is_cst(aff);
-	if (data->r >= 0 && data->r) {
-		isl_aff_get_constant(aff, &data->t);
-		if (data->first) {
-			isl_int_set(data->c1, data->t);
-			data->first = 0;
-		} else if (!isl_int_eq(data->c1, data->t))
-			data->equal = 0;
-	} else if (data->r >= 0 && !data->r)
-		data->equal = 0;
-
-	isl_aff_free(aff);
-	isl_set_free(set);
-	isl_multi_aff_free(ma);
-
-	if (data->r < 0)
-		return -1;
-	if (!data->equal)
-		return -1;
-	return 0;
-}
-
-/* This function is called for each isl_pw_multi_aff in
- * the isl_union_pw_multi_aff checked by extract_int.
- * Check all the isl_multi_affs inside "pma".
- */
-static int pw_multi_aff_extract_int(__isl_take isl_pw_multi_aff *pma,
+isl_stat isl_schedule_foreach_schedule_node_top_down(
+	__isl_keep isl_schedule *sched,
+	isl_bool (*fn)(__isl_keep isl_schedule_node *node, void *user),
 	void *user)
 {
-	int r;
-
-	r = isl_pw_multi_aff_foreach_piece(pma, &multi_aff_extract_int, user);
-	isl_pw_multi_aff_free(pma);
+	isl_schedule_node *node;
+	isl_stat r;
 
-	return r;
-}
+	if (!sched)
+		return isl_stat_error;
 
-/* Check if "upma" assigns a single constant value to its domain.
- * If so, return 1 and store the result in data->c1.
- * If not, return 0.
- *
- * A negative return value from isl_union_pw_multi_aff_foreach_pw_multi_aff
- * means that either an error occurred or that we have broken off the check
- * because we already know the result is going to be negative.
- * In the latter case, data->equal is set to zero.
- */
-static int extract_int(__isl_keep isl_union_pw_multi_aff *upma,
-	struct isl_cmp_band_data *data)
-{
-	data->first = 1;
-	data->equal = 1;
-
-	if (isl_union_pw_multi_aff_foreach_pw_multi_aff(upma,
-					&pw_multi_aff_extract_int, data) < 0) {
-		if (!data->equal)
-			return 0;
-		return -1;
-	}
+	node = isl_schedule_get_root(sched);
+	r = isl_schedule_node_foreach_descendant_top_down(node, fn, user);
+	isl_schedule_node_free(node);
 
-	return !data->first && data->equal;
+	return r;
 }
 
-/* Compare "b1" and "b2" based on the parent schedule of their ancestor
- * "ancestor".
- *
- * If the parent of "ancestor" also has a single member, then we
- * first try to compare the two band based on the partial schedule
- * of this parent.
- *
- * Otherwise, or if the result is inconclusive, we look at the partial schedule
- * of "ancestor" itself.
- * In particular, we specialize the parent schedule based
- * on the domains of the child schedules, check if both assign
- * a single constant value and, if so, compare the two constant values.
- * If the specialized parent schedules do not assign a constant value,
- * then they cannot be used to order the two bands and so in this case
- * we return 0.
- */
-static int cmp_band_in_ancestor(__isl_keep isl_band *b1,
-	__isl_keep isl_band *b2, struct isl_cmp_band_data *data,
-	__isl_keep isl_band *ancestor)
-{
-	isl_union_pw_multi_aff *upma;
-	isl_union_set *domain;
-	int r;
+/* Traverse the node of "sched" in depth first postorder,
+ * allowing the user to modify the visited node.
+ * The traversal continues from the node returned by the callback function.
+ * It is the responsibility of the user to ensure that this does not
+ * lead to an infinite loop.  It is safest to always return a pointer
+ * to the same position (same ancestors and child positions) as the input node.
+ */
+__isl_give isl_schedule *isl_schedule_map_schedule_node_bottom_up(
+	__isl_take isl_schedule *schedule,
+	__isl_give isl_schedule_node *(*fn)(
+		__isl_take isl_schedule_node *node, void *user), void *user)
+{
+	isl_schedule_node *node;
 
-	if (data->r < 0)
-		return 0;
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
 
-	if (ancestor->parent && ancestor->parent->n == 1) {
-		r = cmp_band_in_ancestor(b1, b2, data, ancestor->parent);
-		if (data->r < 0)
-			return 0;
-		if (r)
-			return r;
-	}
+	node = isl_schedule_node_map_descendant_bottom_up(node, fn, user);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-	upma = isl_union_pw_multi_aff_copy(b1->pma);
-	domain = isl_union_pw_multi_aff_domain(upma);
-	upma = isl_union_pw_multi_aff_copy(ancestor->pma);
-	upma = isl_union_pw_multi_aff_intersect_domain(upma, domain);
-	r = extract_int(upma, data);
-	isl_union_pw_multi_aff_free(upma);
+	return schedule;
+}
 
-	if (r < 0)
-		data->r = -1;
-	if (r < 0 || !r)
-		return 0;
+/* Wrapper around isl_schedule_node_reset_user for use as
+ * an isl_schedule_map_schedule_node_bottom_up callback.
+ */
+static __isl_give isl_schedule_node *reset_user(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	return isl_schedule_node_reset_user(node);
+}
 
-	isl_int_set(data->c2, data->c1);
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * in the schedule "schedule".
+ */
+__isl_give isl_schedule *isl_schedule_reset_user(
+	__isl_take isl_schedule *schedule)
+{
+	return isl_schedule_map_schedule_node_bottom_up(schedule, &reset_user,
+							NULL);
+}
 
-	upma = isl_union_pw_multi_aff_copy(b2->pma);
-	domain = isl_union_pw_multi_aff_domain(upma);
-	upma = isl_union_pw_multi_aff_copy(ancestor->pma);
-	upma = isl_union_pw_multi_aff_intersect_domain(upma, domain);
-	r = extract_int(upma, data);
-	isl_union_pw_multi_aff_free(upma);
+/* Wrapper around isl_schedule_node_align_params for use as
+ * an isl_schedule_map_schedule_node_bottom_up callback.
+ */
+static __isl_give isl_schedule_node *align_params(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	isl_space *space = user;
 
-	if (r < 0)
-		data->r = -1;
-	if (r < 0 || !r)
-		return 0;
+	return isl_schedule_node_align_params(node, isl_space_copy(space));
+}
 
-	return isl_int_cmp(data->c2, data->c1);
+/* Align the parameters of all nodes in schedule "schedule"
+ * to those of "space".
+ */
+__isl_give isl_schedule *isl_schedule_align_params(
+	__isl_take isl_schedule *schedule, __isl_take isl_space *space)
+{
+	schedule = isl_schedule_map_schedule_node_bottom_up(schedule,
+						    &align_params, space);
+	isl_space_free(space);
+	return schedule;
 }
 
-/* Compare "a" and "b" based on the parent schedule of their parent.
+/* Wrapper around isl_schedule_node_pullback_union_pw_multi_aff for use as
+ * an isl_schedule_map_schedule_node_bottom_up callback.
  */
-static int cmp_band(const void *a, const void *b, void *user)
+static __isl_give isl_schedule_node *pullback_upma(
+	__isl_take isl_schedule_node *node, void *user)
 {
-	isl_band *b1 = *(isl_band * const *) a;
-	isl_band *b2 = *(isl_band * const *) b;
-	struct isl_cmp_band_data *data = user;
+	isl_union_pw_multi_aff *upma = user;
 
-	return cmp_band_in_ancestor(b1, b2, data, b1->parent);
+	return isl_schedule_node_pullback_union_pw_multi_aff(node,
+					isl_union_pw_multi_aff_copy(upma));
 }
 
-/* Sort the elements in "list" based on the partial schedules of its parent
- * (and ancestors).  In particular if the parent assigns constant values
- * to the domains of the bands in "list", then the elements are sorted
- * according to that order.
- * This order should be a more "natural" order for the user, but otherwise
- * shouldn't have any effect.
- * If we would be constructing an isl_band forest directly in
- * isl_schedule_constraints_compute_schedule then there wouldn't be any need
- * for a reordering, since the children would be added to the list
- * in their natural order automatically.
+/* Compute the pullback of "schedule" by the function represented by "upma".
+ * In other words, plug in "upma" in the iteration domains of "schedule".
  *
- * If there is only one element in the list, then there is no need to sort
- * anything.
- * If the partial schedule of the parent has more than one member
- * (or if there is no parent), then it's
- * defnitely not assigning constant values to the different children in
- * the list and so we wouldn't be able to use it to sort the list.
+ * The schedule tree is not allowed to contain any expansion nodes.
  */
-static __isl_give isl_band_list *sort_band_list(__isl_take isl_band_list *list,
-	__isl_keep isl_band *parent)
+__isl_give isl_schedule *isl_schedule_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule *schedule,
+	__isl_take isl_union_pw_multi_aff *upma)
 {
-	struct isl_cmp_band_data data;
+	schedule = isl_schedule_map_schedule_node_bottom_up(schedule,
+						&pullback_upma, upma);
+	isl_union_pw_multi_aff_free(upma);
+	return schedule;
+}
 
-	if (!list)
-		return NULL;
-	if (list->n <= 1)
-		return list;
-	if (!parent || parent->n != 1)
-		return list;
-
-	data.r = 0;
-	isl_int_init(data.c1);
-	isl_int_init(data.c2);
-	isl_int_init(data.t);
-	isl_sort(list->p, list->n, sizeof(list->p0), &cmp_band, &data);
-	if (data.r < 0)
-		list = isl_band_list_free(list);
-	isl_int_clear(data.c1);
-	isl_int_clear(data.c2);
-	isl_int_clear(data.t);
-
-	return list;
-}
-
-/* Construct a list of bands that start at the same position (with
- * sequence number band_nr) in the schedules of the nodes that
- * were active in the parent band.
+/* Expand the schedule "schedule" by extending all leaves
+ * with an expansion node with as subtree the tree of "expansion".
+ * The expansion of the expansion node is determined by "contraction"
+ * and the domain of "expansion".  That is, the domain of "expansion"
+ * is contracted according to "contraction".
  *
- * A separate isl_band structure is created for each band_id
- * and for each node that does not have a band with sequence
- * number band_nr.  In the latter case, a band without members
- * is created.
- * This ensures that if a band has any children, then each node
- * that was active in the band is active in exactly one of the children.
- */
-static __isl_give isl_band_list *construct_band_list(
-	__isl_keep isl_schedule *schedule, __isl_keep isl_band *parent,
-	int band_nr, int *parent_active, int n_active)
-{
-	int i, j;
-	isl_ctx *ctx = isl_schedule_get_ctx(schedule);
-	int *active;
-	int n_band;
-	isl_band_list *list;
-
-	n_band = 0;
-	for (i = 0; i < n_active; ++i) {
-		for (j = 0; j < schedule->n; ++j) {
-			if (!parent_activej)
-				continue;
-			if (schedule->nodej.n_band <= band_nr)
-				continue;
-			if (schedule->nodej.band_idband_nr == i) {
-				n_band++;
-				break;
-			}
-		}
-	}
-	for (j = 0; j < schedule->n; ++j)
-		if (schedule->nodej.n_band <= band_nr)
-			n_band++;
-
-	if (n_band == 1) {
-		isl_band *band;
-		list = isl_band_list_alloc(ctx, n_band);
-		band = construct_band(schedule, parent, band_nr,
-					parent_active, n_active);
-		return isl_band_list_add(list, band);
-	}
+ * Call isl_schedule_node_expand after extracting the required
+ * information from "expansion".
+ */
+__isl_give isl_schedule *isl_schedule_expand(__isl_take isl_schedule *schedule,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_schedule *expansion)
+{
+	isl_union_set *domain;
+	isl_schedule_node *node;
+	isl_schedule_tree *tree;
 
-	active = isl_alloc_array(ctx, int, schedule->n);
-	if (schedule->n && !active)
-		return NULL;
+	domain = isl_schedule_get_domain(expansion);
 
-	list = isl_band_list_alloc(ctx, n_band);
+	node = isl_schedule_get_root(expansion);
+	node = isl_schedule_node_child(node, 0);
+	tree = isl_schedule_node_get_tree(node);
+	isl_schedule_node_free(node);
+	isl_schedule_free(expansion);
 
-	for (i = 0; i < n_active; ++i) {
-		int n = 0;
-		isl_band *band;
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	node = isl_schedule_node_expand(node, contraction, domain, tree);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-		for (j = 0; j < schedule->n; ++j) {
-			activej = parent_activej &&
-					schedule->nodej.n_band > band_nr &&
-					schedule->nodej.band_idband_nr == i;
-			if (activej)
-				n++;
-		}
-		if (n == 0)
-			continue;
+	return schedule;
+}
 
-		band = construct_band(schedule, parent, band_nr, active, n);
+/* Intersect the domain of the schedule "schedule" with "domain".
+ * The root of "schedule" is required to be a domain node.
+ */
+__isl_give isl_schedule *isl_schedule_intersect_domain(
+	__isl_take isl_schedule *schedule, __isl_take isl_union_set *domain)
+{
+	enum isl_schedule_node_type root_type;
+	isl_schedule_node *node;
 
-		list = isl_band_list_add(list, band);
-	}
-	for (i = 0; i < schedule->n; ++i) {
-		isl_band *band;
-		if (!parent_activei)
-			continue;
-		if (schedule->nodei.n_band > band_nr)
-			continue;
-		for (j = 0; j < schedule->n; ++j)
-			activej = j == i;
-		band = construct_band(schedule, parent, band_nr, active, 1);
-		list = isl_band_list_add(list, band);
-	}
+	if (!schedule || !domain)
+		goto error;
 
-	free(active);
+	root_type = isl_schedule_tree_get_type(schedule->root);
+	if (root_type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(schedule), isl_error_invalid,
+			"root node must be a domain node", goto error);
 
-	list = sort_band_list(list, parent);
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	node = isl_schedule_node_domain_intersect_domain(node, domain);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-	return list;
+	return schedule;
+error:
+	isl_schedule_free(schedule);
+	isl_union_set_free(domain);
+	return NULL;
 }
 
-/* Construct a band forest representation of the schedule and
- * return the list of roots.
+/* Replace the domain of the schedule "schedule" with the gist
+ * of the original domain with respect to the parameter domain "context".
  */
-static __isl_give isl_band_list *construct_forest(
-	__isl_keep isl_schedule *schedule)
+__isl_give isl_schedule *isl_schedule_gist_domain_params(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *context)
 {
-	int i;
-	isl_ctx *ctx = isl_schedule_get_ctx(schedule);
-	isl_band_list *forest;
-	int *active;
-
-	active = isl_alloc_array(ctx, int, schedule->n);
-	if (schedule->n && !active)
-		return NULL;
+	enum isl_schedule_node_type root_type;
+	isl_schedule_node *node;
 
-	for (i = 0; i < schedule->n; ++i)
-		activei = 1;
+	if (!schedule || !context)
+		goto error;
 
-	forest = construct_band_list(schedule, NULL, 0, active, schedule->n);
+	root_type = isl_schedule_tree_get_type(schedule->root);
+	if (root_type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(schedule), isl_error_invalid,
+			"root node must be a domain node", goto error);
 
-	free(active);
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	node = isl_schedule_node_domain_gist_params(node, context);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-	return forest;
+	return schedule;
+error:
+	isl_schedule_free(schedule);
+	isl_set_free(context);
+	return NULL;
 }
 
-/* Return the roots of a band forest representation of the schedule.
+/* Return an isl_union_map representation of the schedule. In particular,
+ * return an isl_union_map corresponding to the subtree schedule of the child
+ * of the root domain node.  That is, we do not intersect the domain
+ * of the returned isl_union_map with the domain constraints.
  */
-__isl_give isl_band_list *isl_schedule_get_band_forest(
-	__isl_keep isl_schedule *schedule)
+__isl_give isl_union_map *isl_schedule_get_map(__isl_keep isl_schedule *sched)
 {
-	if (!schedule)
+	enum isl_schedule_node_type type;
+	isl_schedule_node *node;
+	isl_union_map *umap;
+
+	if (!sched)
 		return NULL;
-	if (!schedule->band_forest)
-		schedule->band_forest = construct_forest(schedule);
-	return isl_band_list_dup(schedule->band_forest);
+	type = isl_schedule_tree_get_type(sched->root);
+	if (type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(sched), isl_error_internal,
+			"root node not a domain node", return NULL);
+
+	node = isl_schedule_get_root(sched);
+	node = isl_schedule_node_child(node, 0);
+	umap = isl_schedule_node_get_subtree_schedule_union_map(node);
+	isl_schedule_node_free(node);
+
+	return umap;
 }
 
-/* Call "fn" on each band in the schedule in depth-first post-order.
+/* Insert a band node with partial schedule "partial" between the domain
+ * root node of "schedule" and its single child.
+ * Return a pointer to the updated schedule.
+ *
+ * If any of the nodes in the tree depend on the set of outer band nodes
+ * then we refuse to insert the band node.
  */
-int isl_schedule_foreach_band(__isl_keep isl_schedule *sched,
-	int (*fn)(__isl_keep isl_band *band, void *user), void *user)
+__isl_give isl_schedule *isl_schedule_insert_partial_schedule(
+	__isl_take isl_schedule *schedule,
+	__isl_take isl_multi_union_pw_aff *partial)
 {
-	int r;
-	isl_band_list *forest;
+	isl_schedule_node *node;
+	int anchored;
 
-	if (!sched)
-		return -1;
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	if (!node)
+		goto error;
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_domain)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_internal,
+			"root node not a domain node", goto error);
 
-	forest = isl_schedule_get_band_forest(sched);
-	r = isl_band_list_foreach_band(forest, fn, user);
-	isl_band_list_free(forest);
+	node = isl_schedule_node_child(node, 0);
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot insert band node in anchored subtree",
+			goto error);
+	node = isl_schedule_node_insert_partial_schedule(node, partial);
 
-	return r;
-}
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-static __isl_give isl_printer *print_band_list(__isl_take isl_printer *p,
-	__isl_keep isl_band_list *list);
+	return schedule;
+error:
+	isl_schedule_node_free(node);
+	isl_multi_union_pw_aff_free(partial);
+	return NULL;
+}
 
-static __isl_give isl_printer *print_band(__isl_take isl_printer *p,
-	__isl_keep isl_band *band)
+/* Insert a context node with constraints "context" between the domain
+ * root node of "schedule" and its single child.
+ * Return a pointer to the updated schedule.
+ */
+__isl_give isl_schedule *isl_schedule_insert_context(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *context)
 {
-	isl_band_list *children;
-
-	p = isl_printer_start_line(p);
-	p = isl_printer_print_union_pw_multi_aff(p, band->pma);
-	p = isl_printer_end_line(p);
+	isl_schedule_node *node;
 
-	if (!isl_band_has_children(band))
-		return p;
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_insert_context(node, context);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-	children = isl_band_get_children(band);
+	return schedule;
+}
 
-	p = isl_printer_indent(p, 4);
-	p = print_band_list(p, children);
-	p = isl_printer_indent(p, -4);
+/* Insert a guard node with constraints "guard" between the domain
+ * root node of "schedule" and its single child.
+ * Return a pointer to the updated schedule.
+ */
+__isl_give isl_schedule *isl_schedule_insert_guard(
+	__isl_take isl_schedule *schedule, __isl_take isl_set *guard)
+{
+	isl_schedule_node *node;
 
-	isl_band_list_free(children);
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_insert_guard(node, guard);
+	schedule = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
-	return p;
+	return schedule;
 }
 
-static __isl_give isl_printer *print_band_list(__isl_take isl_printer *p,
-	__isl_keep isl_band_list *list)
+/* Return a tree with as top-level node a filter corresponding to "filter" and
+ * as child, the (single) child of "tree".
+ * However, if this single child is of type "type", then the filter is inserted
+ * in the children of this single child instead.
+ */
+static __isl_give isl_schedule_tree *insert_filter_in_child_of_type(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter,
+	enum isl_schedule_node_type type)
 {
-	int i, n;
-
-	n = isl_band_list_n_band(list);
-	for (i = 0; i < n; ++i) {
-		isl_band *band;
-		band = isl_band_list_get_band(list, i);
-		p = print_band(p, band);
-		isl_band_free(band);
+	if (!isl_schedule_tree_has_children(tree)) {
+		isl_schedule_tree_free(tree);
+		return isl_schedule_tree_from_filter(filter);
+	} else {
+		tree = isl_schedule_tree_child(tree, 0);
 	}
 
-	return p;
+	if (isl_schedule_tree_get_type(tree) == type)
+		tree = isl_schedule_tree_children_insert_filter(tree, filter);
+	else
+		tree = isl_schedule_tree_insert_filter(tree, filter);
+
+	return tree;
 }
 
-__isl_give isl_printer *isl_printer_print_schedule(__isl_take isl_printer *p,
-	__isl_keep isl_schedule *schedule)
+/* Construct a schedule that combines the schedules "schedule1" and "schedule2"
+ * with a top-level node (underneath the domain node) of type "type",
+ * either isl_schedule_node_sequence or isl_schedule_node_set.
+ * The domains of the two schedules are assumed to be disjoint.
+ *
+ * The new schedule has as domain the union of the domains of the two
+ * schedules.  The child of the domain node is a node of type "type"
+ * with two filters corresponding to the domains of the input schedules.
+ * If one (or both) of the top-level nodes of the two schedules is itself
+ * of type "type", then the filter is pushed into the children of that
+ * node and the sequence or set is flattened.
+ */
+__isl_give isl_schedule *isl_schedule_pair(enum isl_schedule_node_type type,
+	__isl_take isl_schedule *schedule1, __isl_take isl_schedule *schedule2)
 {
-	isl_band_list *forest;
-
-	forest = isl_schedule_get_band_forest(schedule);
+	int disjoint;
+	isl_ctx *ctx;
+	enum isl_schedule_node_type root_type;
+	isl_schedule_tree *tree1, *tree2;
+	isl_union_set *filter1, *filter2, *domain;
 
-	p = print_band_list(p, forest);
+	if (!schedule1 || !schedule2)
+		goto error;
 
-	isl_band_list_free(forest);
+	root_type = isl_schedule_tree_get_type(schedule1->root);
+	if (root_type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(schedule1), isl_error_internal,
+			"root node not a domain node", goto error);
+	root_type = isl_schedule_tree_get_type(schedule2->root);
+	if (root_type != isl_schedule_node_domain)
+		isl_die(isl_schedule_get_ctx(schedule1), isl_error_internal,
+			"root node not a domain node", goto error);
+
+	ctx = isl_schedule_get_ctx(schedule1);
+	tree1 = isl_schedule_tree_copy(schedule1->root);
+	filter1 = isl_schedule_tree_domain_get_domain(tree1);
+	tree2 = isl_schedule_tree_copy(schedule2->root);
+	filter2 = isl_schedule_tree_domain_get_domain(tree2);
+
+	isl_schedule_free(schedule1);
+	isl_schedule_free(schedule2);
+
+	disjoint = isl_union_set_is_disjoint(filter1, filter2);
+	if (disjoint < 0)
+		filter1 = isl_union_set_free(filter1);
+	if (!disjoint)
+		isl_die(ctx, isl_error_invalid,
+			"schedule domains not disjoint",
+			filter1 = isl_union_set_free(filter1));
+
+	domain = isl_union_set_union(isl_union_set_copy(filter1),
+				    isl_union_set_copy(filter2));
+	filter1 = isl_union_set_gist(filter1, isl_union_set_copy(domain));
+	filter2 = isl_union_set_gist(filter2, isl_union_set_copy(domain));
+
+	tree1 = insert_filter_in_child_of_type(tree1, filter1, type);
+	tree2 = insert_filter_in_child_of_type(tree2, filter2, type);
+
+	tree1 = isl_schedule_tree_from_pair(type, tree1, tree2);
+	tree1 = isl_schedule_tree_insert_domain(tree1, domain);
+
+	return isl_schedule_from_schedule_tree(ctx, tree1);
+error:
+	isl_schedule_free(schedule1);
+	isl_schedule_free(schedule2);
+	return NULL;
+}
 
-	return p;
+/* Construct a schedule that combines the schedules "schedule1" and "schedule2"
+ * through a sequence node.
+ * The domains of the input schedules are assumed to be disjoint.
+ */
+__isl_give isl_schedule *isl_schedule_sequence(
+	__isl_take isl_schedule *schedule1, __isl_take isl_schedule *schedule2)
+{
+	return isl_schedule_pair(isl_schedule_node_sequence,
+				schedule1, schedule2);
 }
 
-void isl_schedule_dump(__isl_keep isl_schedule *schedule)
+/* Construct a schedule that combines the schedules "schedule1" and "schedule2"
+ * through a set node.
+ * The domains of the input schedules are assumed to be disjoint.
+ */
+__isl_give isl_schedule *isl_schedule_set(
+	__isl_take isl_schedule *schedule1, __isl_take isl_schedule *schedule2)
 {
-	isl_printer *printer;
+	return isl_schedule_pair(isl_schedule_node_set, schedule1, schedule2);
+}
 
+/* Print "schedule" to "p".
+ */
+__isl_give isl_printer *isl_printer_print_schedule(__isl_take isl_printer *p,
+	__isl_keep isl_schedule *schedule)
+{
 	if (!schedule)
-		return;
+		return isl_printer_free(p);
 
-	printer = isl_printer_to_file(isl_schedule_get_ctx(schedule), stderr);
-	printer = isl_printer_print_schedule(printer, schedule);
-
-	isl_printer_free(printer);
+	return isl_printer_print_schedule_tree(p, schedule->root);
 }
+
+#undef BASE
+#define BASE schedule
+#include <print_templ_yaml.c>

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_band.c Added

@@ -0,0 +1,1310 @@
+/*
+ * Copyright 2013-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ */
+
+#include <string.h>
+#include <isl/val.h>
+#include <isl/space.h>
+#include <isl/map.h>
+#include <isl/schedule_node.h>
+#include <isl_schedule_band.h>
+#include <isl_schedule_private.h>
+
+isl_ctx *isl_schedule_band_get_ctx(__isl_keep isl_schedule_band *band)
+{
+	return band ? isl_multi_union_pw_aff_get_ctx(band->mupa) : NULL;
+}
+
+/* Return a new uninitialized isl_schedule_band.
+ */
+static __isl_give isl_schedule_band *isl_schedule_band_alloc(isl_ctx *ctx)
+{
+	isl_schedule_band *band;
+
+	band = isl_calloc_type(ctx, isl_schedule_band);
+	if (!band)
+		return NULL;
+
+	band->ref = 1;
+
+	return band;
+}
+
+/* Return a new isl_schedule_band with partial schedule "mupa".
+ * First replace "mupa" by its greatest integer part to ensure
+ * that the schedule is always integral.
+ * The band is not marked permutable, the dimensions are not
+ * marked coincident and the AST build options are empty.
+ * Since there are no build options, the node is not anchored.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	isl_size dim;
+	isl_ctx *ctx;
+	isl_schedule_band *band;
+	isl_space *space;
+
+	mupa = isl_multi_union_pw_aff_floor(mupa);
+	dim = isl_multi_union_pw_aff_size(mupa);
+	if (dim < 0)
+		goto error;
+	ctx = isl_multi_union_pw_aff_get_ctx(mupa);
+	band = isl_schedule_band_alloc(ctx);
+	if (!band)
+		goto error;
+
+	band->n = dim;
+	band->coincident = isl_calloc_array(ctx, int, band->n);
+	band->mupa = mupa;
+	space = isl_space_params_alloc(ctx, 0);
+	band->ast_build_options = isl_union_set_empty(space);
+	band->anchored = 0;
+
+	if ((band->n && !band->coincident) || !band->ast_build_options)
+		return isl_schedule_band_free(band);
+
+	return band;
+error:
+	isl_multi_union_pw_aff_free(mupa);
+	return NULL;
+}
+
+/* Create a duplicate of the given isl_schedule_band.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_dup(
+	__isl_keep isl_schedule_band *band)
+{
+	int i;
+	isl_ctx *ctx;
+	isl_schedule_band *dup;
+
+	if (!band)
+		return NULL;
+
+	ctx = isl_schedule_band_get_ctx(band);
+	dup = isl_schedule_band_alloc(ctx);
+	if (!dup)
+		return NULL;
+
+	dup->n = band->n;
+	dup->coincident = isl_alloc_array(ctx, int, band->n);
+	if (band->n && !dup->coincident)
+		return isl_schedule_band_free(dup);
+
+	for (i = 0; i < band->n; ++i)
+		dup->coincidenti = band->coincidenti;
+	dup->permutable = band->permutable;
+
+	dup->mupa = isl_multi_union_pw_aff_copy(band->mupa);
+	dup->ast_build_options = isl_union_set_copy(band->ast_build_options);
+	if (!dup->mupa || !dup->ast_build_options)
+		return isl_schedule_band_free(dup);
+
+	if (band->loop_type) {
+		dup->loop_type = isl_alloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !dup->loop_type)
+			return isl_schedule_band_free(dup);
+		for (i = 0; i < band->n; ++i)
+			dup->loop_typei = band->loop_typei;
+	}
+	if (band->isolate_loop_type) {
+		dup->isolate_loop_type = isl_alloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !dup->isolate_loop_type)
+			return isl_schedule_band_free(dup);
+		for (i = 0; i < band->n; ++i)
+			dup->isolate_loop_typei = band->isolate_loop_typei;
+	}
+
+	return dup;
+}
+
+/* Return an isl_schedule_band that is equal to "band" and that has only
+ * a single reference.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_cow(
+	__isl_take isl_schedule_band *band)
+{
+	if (!band)
+		return NULL;
+
+	if (band->ref == 1)
+		return band;
+	band->ref--;
+	return isl_schedule_band_dup(band);
+}
+
+/* Return a new reference to "band".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_copy(
+	__isl_keep isl_schedule_band *band)
+{
+	if (!band)
+		return NULL;
+
+	band->ref++;
+	return band;
+}
+
+/* Free a reference to "band" and return NULL.
+ */
+__isl_null isl_schedule_band *isl_schedule_band_free(
+	__isl_take isl_schedule_band *band)
+{
+	if (!band)
+		return NULL;
+
+	if (--band->ref > 0)
+		return NULL;
+
+	isl_multi_union_pw_aff_free(band->mupa);
+	isl_union_set_free(band->ast_build_options);
+	free(band->loop_type);
+	free(band->isolate_loop_type);
+	free(band->coincident);
+	free(band);
+
+	return NULL;
+}
+
+/* Are "band1" and "band2" obviously equal?
+ */
+isl_bool isl_schedule_band_plain_is_equal(__isl_keep isl_schedule_band *band1,
+	__isl_keep isl_schedule_band *band2)
+{
+	int i;
+	isl_bool equal;
+
+	if (!band1 || !band2)
+		return isl_bool_error;
+	if (band1 == band2)
+		return isl_bool_true;
+
+	if (band1->n != band2->n)
+		return isl_bool_false;
+	for (i = 0; i < band1->n; ++i)
+		if (band1->coincidenti != band2->coincidenti)
+			return isl_bool_false;
+	if (band1->permutable != band2->permutable)
+		return isl_bool_false;
+
+	equal = isl_multi_union_pw_aff_plain_is_equal(band1->mupa, band2->mupa);
+	if (equal < 0 || !equal)
+		return equal;
+
+	if (!band1->loop_type != !band2->loop_type)
+		return isl_bool_false;
+	if (band1->loop_type)
+		for (i = 0; i < band1->n; ++i)
+			if (band1->loop_typei != band2->loop_typei)
+				return isl_bool_false;
+
+	if (!band1->isolate_loop_type != !band2->isolate_loop_type)
+		return isl_bool_false;
+	if (band1->isolate_loop_type)
+		for (i = 0; i < band1->n; ++i)
+			if (band1->isolate_loop_typei !=
+						band2->isolate_loop_typei)
+				return isl_bool_false;
+
+	return isl_union_set_is_equal(band1->ast_build_options,
+					band2->ast_build_options);
+}
+
+/* Return the number of scheduling dimensions in the band.
+ */
+isl_size isl_schedule_band_n_member(__isl_keep isl_schedule_band *band)
+{
+	return band ? band->n : isl_size_error;
+}
+
+/* Is the given scheduling dimension coincident within the band and
+ * with respect to the coincidence constraints?
+ */
+isl_bool isl_schedule_band_member_get_coincident(
+	__isl_keep isl_schedule_band *band, int pos)
+{
+	if (!band)
+		return isl_bool_error;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position", return isl_bool_error);
+
+	return isl_bool_ok(band->coincidentpos);
+}
+
+/* Mark the given scheduling dimension as being coincident or not
+ * according to "coincident".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_member_set_coincident(
+	__isl_take isl_schedule_band *band, int pos, int coincident)
+{
+	if (!band)
+		return NULL;
+	if (isl_schedule_band_member_get_coincident(band, pos) == coincident)
+		return band;
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return NULL;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position",
+			return isl_schedule_band_free(band));
+
+	band->coincidentpos = coincident;
+
+	return band;
+}
+
+/* Is the schedule band mark permutable?
+ */
+isl_bool isl_schedule_band_get_permutable(__isl_keep isl_schedule_band *band)
+{
+	if (!band)
+		return isl_bool_error;
+	return isl_bool_ok(band->permutable);
+}
+
+/* Mark the schedule band permutable or not according to "permutable"?
+ */
+__isl_give isl_schedule_band *isl_schedule_band_set_permutable(
+	__isl_take isl_schedule_band *band, int permutable)
+{
+	if (!band)
+		return NULL;
+	if (band->permutable == permutable)
+		return band;
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return NULL;
+
+	band->permutable = permutable;
+
+	return band;
+}
+
+/* Is the band node "node" anchored?  That is, does it reference
+ * the outer band nodes?
+ */
+int isl_schedule_band_is_anchored(__isl_keep isl_schedule_band *band)
+{
+	return band ? band->anchored : -1;
+}
+
+/* Return the schedule space of the band.
+ */
+__isl_give isl_space *isl_schedule_band_get_space(
+	__isl_keep isl_schedule_band *band)
+{
+	if (!band)
+		return NULL;
+	return isl_multi_union_pw_aff_get_space(band->mupa);
+}
+
+/* Intersect the domain of the band schedule of "band" with "domain".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_intersect_domain(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *domain)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !domain)
+		goto error;
+
+	band->mupa = isl_multi_union_pw_aff_intersect_domain(band->mupa,
+								domain);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Return the schedule of the band in isolation.
+ */
+__isl_give isl_multi_union_pw_aff *isl_schedule_band_get_partial_schedule(
+	__isl_keep isl_schedule_band *band)
+{
+	return band ? isl_multi_union_pw_aff_copy(band->mupa) : NULL;
+}
+
+/* Replace the schedule of "band" by "schedule".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_set_partial_schedule(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_multi_union_pw_aff *schedule)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !schedule)
+		goto error;
+
+	isl_multi_union_pw_aff_free(band->mupa);
+	band->mupa = schedule;
+
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_union_pw_aff_free(schedule);
+	return NULL;
+}
+
+/* Return the loop AST generation type for the band member of "band"
+ * at position "pos".
+ */
+enum isl_ast_loop_type isl_schedule_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_band *band, int pos)
+{
+	if (!band)
+		return isl_ast_loop_error;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position", return isl_ast_loop_error);
+
+	if (!band->loop_type)
+		return isl_ast_loop_default;
+
+	return band->loop_typepos;
+}
+
+/* Set the loop AST generation type for the band member of "band"
+ * at position "pos" to "type".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_band *band, int pos,
+	enum isl_ast_loop_type type)
+{
+	if (!band)
+		return NULL;
+	if (isl_schedule_band_member_get_ast_loop_type(band, pos) == type)
+		return band;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position",
+			return isl_schedule_band_free(band));
+
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return isl_schedule_band_free(band);
+
+	if (!band->loop_type) {
+		isl_ctx *ctx;
+
+		ctx = isl_schedule_band_get_ctx(band);
+		band->loop_type = isl_calloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !band->loop_type)
+			return isl_schedule_band_free(band);
+	}
+
+	band->loop_typepos = type;
+
+	return band;
+}
+
+/* Return the loop AST generation type for the band member of "band"
+ * at position "pos" for the part that has been isolated by the isolate option.
+ */
+enum isl_ast_loop_type isl_schedule_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_band *band, int pos)
+{
+	if (!band)
+		return isl_ast_loop_error;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position", return isl_ast_loop_error);
+
+	if (!band->isolate_loop_type)
+		return isl_ast_loop_default;
+
+	return band->isolate_loop_typepos;
+}
+
+/* Set the loop AST generation type for the band member of "band"
+ * at position "pos" to "type" for the part that has been isolated
+ * by the isolate option.
+ */
+__isl_give isl_schedule_band *
+isl_schedule_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_band *band, int pos,
+	enum isl_ast_loop_type type)
+{
+	if (!band)
+		return NULL;
+	if (isl_schedule_band_member_get_isolate_ast_loop_type(band, pos) ==
+									type)
+		return band;
+
+	if (pos < 0 || pos >= band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"invalid member position",
+			return isl_schedule_band_free(band));
+
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return isl_schedule_band_free(band);
+
+	if (!band->isolate_loop_type) {
+		isl_ctx *ctx;
+
+		ctx = isl_schedule_band_get_ctx(band);
+		band->isolate_loop_type = isl_calloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !band->isolate_loop_type)
+			return isl_schedule_band_free(band);
+	}
+
+	band->isolate_loop_typepos = type;
+
+	return band;
+}
+
+static const char *option_str = {
+	isl_ast_loop_atomic = "atomic",
+	isl_ast_loop_unroll = "unroll",
+	isl_ast_loop_separate = "separate"
+};
+
+/* Given a parameter space "space", extend it to a set space
+ *
+ *	{ typex }
+ *
+ * or
+ *
+ *	{ isolate -> typex }
+ *
+ * depending on whether "isolate" is set.
+ * These can be used to encode loop AST generation options of the given type.
+ */
+static __isl_give isl_space *loop_type_space(__isl_take isl_space *space,
+	enum isl_ast_loop_type type, int isolate)
+{
+	const char *name;
+
+	name = option_strtype;
+	space = isl_space_set_from_params(space);
+	space = isl_space_add_dims(space, isl_dim_set, 1);
+	space = isl_space_set_tuple_name(space, isl_dim_set, name);
+	if (!isolate)
+		return space;
+	space = isl_space_from_range(space);
+	space = isl_space_set_tuple_name(space, isl_dim_in, "isolate");
+	space = isl_space_wrap(space);
+
+	return space;
+}
+
+/* Add encodings of the "n" loop AST generation options "type" to "options".
+ * If "isolate" is set, then these options refer to the isolated part.
+ *
+ * In particular, for each sequence of consecutive identical types "t",
+ * different from the default, add an option
+ *
+ *	{ tx : first <= x <= last }
+ *
+ * or
+ *
+ *	{ isolate -> tx : first <= x <= last }
+ */
+static __isl_give isl_union_set *add_loop_types(
+	__isl_take isl_union_set *options, int n, enum isl_ast_loop_type *type,
+	int isolate)
+{
+	int i;
+
+	if (!type)
+		return options;
+	if (!options)
+		return NULL;
+
+	for (i = 0; i < n; ++i) {
+		int first;
+		isl_space *space;
+		isl_set *option;
+
+		if (typei == isl_ast_loop_default)
+			continue;
+
+		first = i;
+		while (i + 1 < n && typei + 1 == typei)
+			++i;
+
+		space = isl_union_set_get_space(options);
+		space = loop_type_space(space, typei, isolate);
+		option = isl_set_universe(space);
+		option = isl_set_lower_bound_si(option, isl_dim_set, 0, first);
+		option = isl_set_upper_bound_si(option, isl_dim_set, 0, i);
+		options = isl_union_set_add_set(options, option);
+	}
+
+	return options;
+}
+
+/* Return the AST build options associated to "band".
+ */
+__isl_give isl_union_set *isl_schedule_band_get_ast_build_options(
+	__isl_keep isl_schedule_band *band)
+{
+	isl_union_set *options;
+
+	if (!band)
+		return NULL;
+
+	options = isl_union_set_copy(band->ast_build_options);
+	options = add_loop_types(options, band->n, band->loop_type, 0);
+	options = add_loop_types(options, band->n, band->isolate_loop_type, 1);
+
+	return options;
+}
+
+/* Internal data structure for not().
+ */
+struct isl_not_data {
+	isl_bool (*is)(__isl_keep isl_set *set);
+};
+
+/* Does "set" not satisfy data->is()?
+ */
+static isl_bool not(__isl_keep isl_set *set, void *user)
+{
+	struct isl_not_data *data = user;
+
+	return isl_bool_not(data->is(set));
+}
+
+/* Does "uset" contain any set that satisfies "is"?
+ * In other words, is it not the case that all of them do not satisfy "is"?
+ */
+static isl_bool has_any(__isl_keep isl_union_set *uset,
+	isl_bool (*is)(__isl_keep isl_set *set))
+{
+	struct isl_not_data data = { is };
+
+	return isl_bool_not(isl_union_set_every_set(uset, &not, &data));
+}
+
+/* Does "set" live in a space of the form
+ *
+ *	isolate... -> ...
+ *
+ * ?
+ */
+static isl_bool is_isolate(__isl_keep isl_set *set)
+{
+	if (isl_set_has_tuple_name(set)) {
+		const char *name;
+		name = isl_set_get_tuple_name(set);
+		if (isl_set_is_wrapping(set) && !strcmp(name, "isolate"))
+			return isl_bool_true;
+	}
+
+	return isl_bool_false;
+}
+
+/* Does "options" include an option of the ofrm
+ *
+ *	isolate... -> ...
+ *
+ * ?
+ */
+static isl_bool has_isolate_option(__isl_keep isl_union_set *options)
+{
+	return has_any(options, &is_isolate);
+}
+
+/* Does "set" encode a loop AST generation option?
+ */
+static isl_bool is_loop_type_option(__isl_keep isl_set *set)
+{
+	isl_size dim;
+
+	dim = isl_set_dim(set, isl_dim_set);
+	if (dim < 0)
+		return isl_bool_error;
+	if (dim == 1 && isl_set_has_tuple_name(set)) {
+		const char *name;
+		enum isl_ast_loop_type type;
+		name = isl_set_get_tuple_name(set);
+		for (type = isl_ast_loop_atomic;
+		    type <= isl_ast_loop_separate; ++type) {
+			if (strcmp(name, option_strtype))
+				continue;
+			return isl_bool_true;
+		}
+	}
+
+	return isl_bool_false;
+}
+
+/* Does "set" encode a loop AST generation option for the isolated part?
+ * That is, is of the form
+ *
+ *	{ isolate -> tx }
+ *
+ * with t equal to "atomic", "unroll" or "separate"?
+ */
+static isl_bool is_isolate_loop_type_option(__isl_keep isl_set *set)
+{
+	const char *name;
+	enum isl_ast_loop_type type;
+	isl_map *map;
+
+	if (!isl_set_is_wrapping(set))
+		return isl_bool_false;
+	map = isl_set_unwrap(isl_set_copy(set));
+	if (!isl_map_has_tuple_name(map, isl_dim_in) ||
+	    !isl_map_has_tuple_name(map, isl_dim_out)) {
+		isl_map_free(map);
+		return isl_bool_false;
+	}
+	name = isl_map_get_tuple_name(map, isl_dim_in);
+	if (!strcmp(name, "isolate")) {
+		name = isl_map_get_tuple_name(map, isl_dim_out);
+		for (type = isl_ast_loop_atomic;
+		    type <= isl_ast_loop_separate; ++type) {
+			if (strcmp(name, option_strtype))
+				continue;
+			isl_map_free(map);
+			return isl_bool_true;
+		}
+	}
+	isl_map_free(map);
+
+	return isl_bool_false;
+}
+
+/* Does "options" encode any loop AST generation options
+ * for the isolated part?
+ */
+static isl_bool has_isolate_loop_type_options(__isl_keep isl_union_set *options)
+{
+	return has_any(options, &is_isolate_loop_type_option);
+}
+
+/* Does "options" encode any loop AST generation options?
+ */
+static isl_bool has_loop_type_options(__isl_keep isl_union_set *options)
+{
+	return has_any(options, &is_loop_type_option);
+}
+
+/* Extract the loop AST generation type for the band member
+ * at position "pos" from "options".
+ * If "isolate" is set, then extract the loop types for the isolated part.
+ */
+static enum isl_ast_loop_type extract_loop_type(
+	__isl_keep isl_union_set *options, int pos, int isolate)
+{
+	isl_ctx *ctx;
+	enum isl_ast_loop_type type, res = isl_ast_loop_default;
+
+	ctx = isl_union_set_get_ctx(options);
+	for (type = isl_ast_loop_atomic;
+	    type <= isl_ast_loop_separate; ++type) {
+		isl_space *space;
+		isl_set *option;
+		int empty;
+
+		space = isl_union_set_get_space(options);
+		space = loop_type_space(space, type, isolate);
+		option = isl_union_set_extract_set(options, space);
+		option = isl_set_fix_si(option, isl_dim_set, 0, pos);
+		empty = isl_set_is_empty(option);
+		isl_set_free(option);
+
+		if (empty < 0)
+			return isl_ast_loop_error;
+		if (empty)
+			continue;
+		if (res != isl_ast_loop_default)
+			isl_die(ctx, isl_error_invalid,
+				"conflicting loop type options",
+				return isl_ast_loop_error);
+		res = type;
+	}
+
+	return res;
+}
+
+/* Extract the loop AST generation types for the members of "band"
+ * from "options" and store them in band->loop_type.
+ * Return -1 on error.
+ */
+static int extract_loop_types(__isl_keep isl_schedule_band *band,
+	__isl_keep isl_union_set *options)
+{
+	int i;
+
+	if (!band->loop_type) {
+		isl_ctx *ctx = isl_schedule_band_get_ctx(band);
+		band->loop_type = isl_alloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !band->loop_type)
+			return -1;
+	}
+	for (i = 0; i < band->n; ++i) {
+		band->loop_typei = extract_loop_type(options, i, 0);
+		if (band->loop_typei == isl_ast_loop_error)
+			return -1;
+	}
+
+	return 0;
+}
+
+/* Extract the loop AST generation types for the members of "band"
+ * from "options" for the isolated part and
+ * store them in band->isolate_loop_type.
+ * Return -1 on error.
+ */
+static int extract_isolate_loop_types(__isl_keep isl_schedule_band *band,
+	__isl_keep isl_union_set *options)
+{
+	int i;
+
+	if (!band->isolate_loop_type) {
+		isl_ctx *ctx = isl_schedule_band_get_ctx(band);
+		band->isolate_loop_type = isl_alloc_array(ctx,
+					    enum isl_ast_loop_type, band->n);
+		if (band->n && !band->isolate_loop_type)
+			return -1;
+	}
+	for (i = 0; i < band->n; ++i) {
+		band->isolate_loop_typei = extract_loop_type(options, i, 1);
+		if (band->isolate_loop_typei == isl_ast_loop_error)
+			return -1;
+	}
+
+	return 0;
+}
+
+/* Construct universe sets of the spaces that encode loop AST generation
+ * types (for the isolated part if "isolate" is set).  That is, construct
+ *
+ *	{ atomicx; separatex; unrollx }
+ *
+ * or
+ *
+ *	{ isolate -> atomicx; isolate -> separatex;
+ *	  isolate -> unrollx }
+ */
+static __isl_give isl_union_set *loop_types(__isl_take isl_space *space,
+	int isolate)
+{
+	enum isl_ast_loop_type type;
+	isl_union_set *types;
+
+	types = isl_union_set_empty(space);
+	for (type = isl_ast_loop_atomic;
+	    type <= isl_ast_loop_separate; ++type) {
+		isl_set *set;
+
+		space = isl_union_set_get_space(types);
+		space = loop_type_space(space, type, isolate);
+		set = isl_set_universe(space);
+		types = isl_union_set_add_set(types, set);
+	}
+
+	return types;
+}
+
+/* Remove all elements from spaces that encode loop AST generation types
+ * from "options".
+ */
+static __isl_give isl_union_set *clear_loop_types(
+	__isl_take isl_union_set *options)
+{
+	isl_union_set *types;
+
+	types = loop_types(isl_union_set_get_space(options), 0);
+	options = isl_union_set_subtract(options, types);
+
+	return options;
+}
+
+/* Remove all elements from spaces that encode loop AST generation types
+ * for the isolated part from "options".
+ */
+static __isl_give isl_union_set *clear_isolate_loop_types(
+	__isl_take isl_union_set *options)
+{
+	isl_union_set *types;
+
+	types = loop_types(isl_union_set_get_space(options), 1);
+	options = isl_union_set_subtract(options, types);
+
+	return options;
+}
+
+/* Replace the AST build options associated to "band" by "options".
+ * If there are any loop AST generation type options, then they
+ * are extracted and stored in band->loop_type.  Otherwise,
+ * band->loop_type is removed to indicate that the default applies
+ * to all members.  Similarly for the loop AST generation type options
+ * for the isolated part, which are stored in band->isolate_loop_type.
+ * The remaining options are stored in band->ast_build_options.
+ *
+ * Set anchored if the options include an isolate option since the
+ * domain of the wrapped map references the outer band node schedules.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_set_ast_build_options(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *options)
+{
+	isl_bool has_isolate, has_loop_type, has_isolate_loop_type;
+
+	band = isl_schedule_band_cow(band);
+	if (!band || !options)
+		goto error;
+	has_isolate = has_isolate_option(options);
+	if (has_isolate < 0)
+		goto error;
+	has_loop_type = has_loop_type_options(options);
+	if (has_loop_type < 0)
+		goto error;
+	has_isolate_loop_type = has_isolate_loop_type_options(options);
+	if (has_isolate_loop_type < 0)
+		goto error;
+
+	if (!has_loop_type) {
+		free(band->loop_type);
+		band->loop_type = NULL;
+	} else {
+		if (extract_loop_types(band, options) < 0)
+			goto error;
+		options = clear_loop_types(options);
+		if (!options)
+			goto error;
+	}
+
+	if (!has_isolate_loop_type) {
+		free(band->isolate_loop_type);
+		band->isolate_loop_type = NULL;
+	} else {
+		if (extract_isolate_loop_types(band, options) < 0)
+			goto error;
+		options = clear_isolate_loop_types(options);
+		if (!options)
+			goto error;
+	}
+
+	isl_union_set_free(band->ast_build_options);
+	band->ast_build_options = options;
+	band->anchored = has_isolate;
+
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_union_set_free(options);
+	return NULL;
+}
+
+/* Return the "isolate" option associated to "band", assuming
+ * it at appears at schedule depth "depth".
+ *
+ * The isolate option is of the form
+ *
+ *	isolateflattened outer bands -> band
+ */
+__isl_give isl_set *isl_schedule_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_band *band, int depth)
+{
+	isl_space *space;
+	isl_set *isolate;
+
+	if (!band)
+		return NULL;
+
+	space = isl_schedule_band_get_space(band);
+	space = isl_space_from_range(space);
+	space = isl_space_add_dims(space, isl_dim_in, depth);
+	space = isl_space_wrap(space);
+	space = isl_space_set_tuple_name(space, isl_dim_set, "isolate");
+
+	isolate = isl_union_set_extract_set(band->ast_build_options, space);
+
+	return isolate;
+}
+
+/* Replace the option "drop" in the AST build options by "add".
+ * That is, remove "drop" and add "add".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_replace_ast_build_option(
+	__isl_take isl_schedule_band *band, __isl_take isl_set *drop,
+	__isl_take isl_set *add)
+{
+	isl_union_set *options;
+
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		goto error;
+
+	options = band->ast_build_options;
+	options = isl_union_set_subtract(options, isl_union_set_from_set(drop));
+	options = isl_union_set_union(options, isl_union_set_from_set(add));
+	band->ast_build_options = options;
+
+	if (!band->ast_build_options)
+		return isl_schedule_band_free(band);
+
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_set_free(drop);
+	isl_set_free(add);
+	return NULL;
+}
+
+/* Multiply the partial schedule of "band" with the factors in "mv".
+ * Replace the result by its greatest integer part to ensure
+ * that the schedule is always integral.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_scale(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !mv)
+		goto error;
+	band->mupa = isl_multi_union_pw_aff_scale_multi_val(band->mupa, mv);
+	band->mupa = isl_multi_union_pw_aff_floor(band->mupa);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Divide the partial schedule of "band" by the factors in "mv".
+ * Replace the result by its greatest integer part to ensure
+ * that the schedule is always integral.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_scale_down(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !mv)
+		goto error;
+	band->mupa = isl_multi_union_pw_aff_scale_down_multi_val(band->mupa,
+								mv);
+	band->mupa = isl_multi_union_pw_aff_floor(band->mupa);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Reduce the partial schedule of "band" modulo the factors in "mv".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_mod(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !mv)
+		goto error;
+	band->mupa = isl_multi_union_pw_aff_mod_multi_val(band->mupa, mv);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Shift the partial schedule of "band" by "shift" after checking
+ * that the domain of the partial schedule would not be affected
+ * by this shift.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_shift(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_multi_union_pw_aff *shift)
+{
+	isl_union_set *dom1, *dom2;
+	isl_bool subset;
+
+	band = isl_schedule_band_cow(band);
+	if (!band || !shift)
+		goto error;
+	dom1 = isl_multi_union_pw_aff_domain(
+				isl_multi_union_pw_aff_copy(band->mupa));
+	dom2 = isl_multi_union_pw_aff_domain(
+				isl_multi_union_pw_aff_copy(shift));
+	subset = isl_union_set_is_subset(dom1, dom2);
+	isl_union_set_free(dom1);
+	isl_union_set_free(dom2);
+	if (subset < 0)
+		goto error;
+	if (!subset)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_invalid,
+			"domain of shift needs to include domain of "
+			"partial schedule", goto error);
+	band->mupa = isl_multi_union_pw_aff_add(band->mupa, shift);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_union_pw_aff_free(shift);
+	return NULL;
+}
+
+/* Given the schedule of a band, construct the corresponding
+ * schedule for the tile loops based on the given tile sizes
+ * and return the result.
+ *
+ * If the scale tile loops options is set, then the tile loops
+ * are scaled by the tile sizes.
+ *
+ * That is replace each schedule dimension "i" by either
+ * "floor(i/s)" or "s * floor(i/s)".
+ */
+static isl_multi_union_pw_aff *isl_multi_union_pw_aff_tile(
+	__isl_take isl_multi_union_pw_aff *sched,
+	__isl_take isl_multi_val *sizes)
+{
+	isl_ctx *ctx;
+	int i;
+	isl_size n;
+	isl_val *v;
+	int scale;
+
+	ctx = isl_multi_val_get_ctx(sizes);
+	scale = isl_options_get_tile_scale_tile_loops(ctx);
+
+	n = isl_multi_union_pw_aff_size(sched);
+	if (n < 0)
+		sched = isl_multi_union_pw_aff_free(sched);
+	for (i = 0; i < n; ++i) {
+		isl_union_pw_aff *upa;
+
+		upa = isl_multi_union_pw_aff_get_union_pw_aff(sched, i);
+		v = isl_multi_val_get_val(sizes, i);
+
+		upa = isl_union_pw_aff_scale_down_val(upa, isl_val_copy(v));
+		upa = isl_union_pw_aff_floor(upa);
+		if (scale)
+			upa = isl_union_pw_aff_scale_val(upa, isl_val_copy(v));
+		isl_val_free(v);
+
+		sched = isl_multi_union_pw_aff_set_union_pw_aff(sched, i, upa);
+	}
+
+	isl_multi_val_free(sizes);
+	return sched;
+}
+
+/* Replace "band" by a band corresponding to the tile loops of a tiling
+ * with the given tile sizes.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_tile(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *sizes)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !sizes)
+		goto error;
+	band->mupa = isl_multi_union_pw_aff_tile(band->mupa, sizes);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_val_free(sizes);
+	return NULL;
+}
+
+/* Replace "band" by a band corresponding to the point loops of a tiling
+ * with the given tile sizes.
+ * "tile" is the corresponding tile loop band.
+ *
+ * If the shift point loops option is set, then the point loops
+ * are shifted to start at zero.  That is, each schedule dimension "i"
+ * is replaced by "i - s * floor(i/s)".
+ * The expression "floor(i/s)" (or "s * floor(i/s)") is extracted from
+ * the tile band.
+ *
+ * Otherwise, the band is left untouched.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_point(
+	__isl_take isl_schedule_band *band, __isl_keep isl_schedule_band *tile,
+	__isl_take isl_multi_val *sizes)
+{
+	isl_ctx *ctx;
+	isl_multi_union_pw_aff *scaled;
+
+	if (!band || !sizes)
+		goto error;
+
+	ctx = isl_schedule_band_get_ctx(band);
+	if (!isl_options_get_tile_shift_point_loops(ctx)) {
+		isl_multi_val_free(sizes);
+		return band;
+	}
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		goto error;
+
+	scaled = isl_schedule_band_get_partial_schedule(tile);
+	if (!isl_options_get_tile_scale_tile_loops(ctx))
+		scaled = isl_multi_union_pw_aff_scale_multi_val(scaled, sizes);
+	else
+		isl_multi_val_free(sizes);
+	band->mupa = isl_multi_union_pw_aff_sub(band->mupa, scaled);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_schedule_band_free(band);
+	isl_multi_val_free(sizes);
+	return NULL;
+}
+
+/* Drop the "n" dimensions starting at "pos" from "band".
+ *
+ * We apply the transformation even if "n" is zero to ensure consistent
+ * behavior with respect to changes in the schedule space.
+ *
+ * The caller is responsible for updating the isolate option.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_drop(
+	__isl_take isl_schedule_band *band, int pos, int n)
+{
+	int i;
+
+	if (pos < 0 || n < 0 || pos + n > band->n)
+		isl_die(isl_schedule_band_get_ctx(band), isl_error_internal,
+			"range out of bounds",
+			return isl_schedule_band_free(band));
+
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return NULL;
+
+	band->mupa = isl_multi_union_pw_aff_drop_dims(band->mupa,
+							isl_dim_set, pos, n);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+
+	for (i = pos + n; i < band->n; ++i)
+		band->coincidenti - n = band->coincidenti;
+	if (band->loop_type)
+		for (i = pos + n; i < band->n; ++i)
+			band->loop_typei - n = band->loop_typei;
+	if (band->isolate_loop_type)
+		for (i = pos + n; i < band->n; ++i)
+			band->isolate_loop_typei - n =
+						    band->isolate_loop_typei;
+
+	band->n -= n;
+
+	return band;
+}
+
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * in "band".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_reset_user(
+	__isl_take isl_schedule_band *band)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		return NULL;
+
+	band->mupa = isl_multi_union_pw_aff_reset_user(band->mupa);
+	band->ast_build_options =
+		isl_union_set_reset_user(band->ast_build_options);
+	if (!band->mupa || !band->ast_build_options)
+		return isl_schedule_band_free(band);
+
+	return band;
+}
+
+/* Align the parameters of "band" to those of "space".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_align_params(
+	__isl_take isl_schedule_band *band, __isl_take isl_space *space)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !space)
+		goto error;
+
+	band->mupa = isl_multi_union_pw_aff_align_params(band->mupa,
+						isl_space_copy(space));
+	band->ast_build_options =
+		isl_union_set_align_params(band->ast_build_options, space);
+	if (!band->mupa || !band->ast_build_options)
+		return isl_schedule_band_free(band);
+
+	return band;
+error:
+	isl_space_free(space);
+	isl_schedule_band_free(band);
+	return NULL;
+}
+
+/* Compute the pullback of "band" by the function represented by "upma".
+ * In other words, plug in "upma" in the iteration domains of "band".
+ */
+__isl_give isl_schedule_band *isl_schedule_band_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	band = isl_schedule_band_cow(band);
+	if (!band || !upma)
+		goto error;
+
+	band->mupa =
+		isl_multi_union_pw_aff_pullback_union_pw_multi_aff(band->mupa,
+									upma);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+
+	return band;
+error:
+	isl_union_pw_multi_aff_free(upma);
+	isl_schedule_band_free(band);
+	return NULL;
+}
+
+/* Compute the gist of "band" with respect to "context".
+ * In particular, compute the gist of the associated partial schedule.
+ */
+__isl_give isl_schedule_band *isl_schedule_band_gist(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *context)
+{
+	if (!band || !context)
+		goto error;
+	if (band->n == 0) {
+		isl_union_set_free(context);
+		return band;
+	}
+	band = isl_schedule_band_cow(band);
+	if (!band)
+		goto error;
+	band->mupa = isl_multi_union_pw_aff_gist(band->mupa, context);
+	if (!band->mupa)
+		return isl_schedule_band_free(band);
+	return band;
+error:
+	isl_union_set_free(context);
+	isl_schedule_band_free(band);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_band.h Added

@@ -0,0 +1,125 @@
+#ifndef ISL_SCHEDULE_BAND_H
+#define ISL_SCHEDULE_BAND_H
+
+#include <isl/aff.h>
+#include <isl/ast_type.h>
+#include <isl/union_map.h>
+
+/* Information about a band within a schedule.
+ *
+ * n is the number of scheduling dimensions within the band.
+ * coincident is an array of length n, indicating whether a scheduling dimension
+ *	satisfies the coincidence constraints in the sense that
+ *	the corresponding dependence distances are zero.
+ * permutable is set if the band is permutable.
+ * mupa is the partial schedule corresponding to this band.  The dimension
+ *	of mupa is equal to n.
+ * loop_type contains the loop AST generation types for the members
+ * in the band.  It may be NULL, if all members are
+ * of type isl_ast_loop_default.
+ * isolate_loop_type contains the loop AST generation types for the members
+ * in the band for the isolated part.  It may be NULL, if all members are
+ * of type isl_ast_loop_default.
+ * ast_build_options are the remaining AST build options associated
+ * to the band.
+ * anchored is set if the node depends on its position in the schedule tree.
+ *	In particular, it is set if the AST build options include
+ *	an isolate option.
+ */
+struct isl_schedule_band {
+	int ref;
+
+	int n;
+	int *coincident;
+	int permutable;
+
+	isl_multi_union_pw_aff *mupa;
+
+	int anchored;
+	isl_union_set *ast_build_options;
+	enum isl_ast_loop_type *loop_type;
+	enum isl_ast_loop_type *isolate_loop_type;
+};
+typedef struct isl_schedule_band isl_schedule_band;
+
+__isl_give isl_schedule_band *isl_schedule_band_from_multi_union_pw_aff(
+	__isl_take isl_multi_union_pw_aff *mupa);
+__isl_give isl_schedule_band *isl_schedule_band_copy(
+	__isl_keep isl_schedule_band *band);
+__isl_null isl_schedule_band *isl_schedule_band_free(
+	__isl_take isl_schedule_band *band);
+
+isl_ctx *isl_schedule_band_get_ctx(__isl_keep isl_schedule_band *band);
+
+isl_bool isl_schedule_band_plain_is_equal(__isl_keep isl_schedule_band *band1,
+	__isl_keep isl_schedule_band *band2);
+
+int isl_schedule_band_is_anchored(__isl_keep isl_schedule_band *band);
+
+__isl_give isl_space *isl_schedule_band_get_space(
+	__isl_keep isl_schedule_band *band);
+__isl_give isl_schedule_band *isl_schedule_band_intersect_domain(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *domain);
+__isl_give isl_multi_union_pw_aff *isl_schedule_band_get_partial_schedule(
+	__isl_keep isl_schedule_band *band);
+__isl_give isl_schedule_band *isl_schedule_band_set_partial_schedule(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_multi_union_pw_aff *schedule);
+enum isl_ast_loop_type isl_schedule_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_band *band, int pos);
+__isl_give isl_schedule_band *isl_schedule_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_band *band, int pos,
+	enum isl_ast_loop_type type);
+enum isl_ast_loop_type isl_schedule_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_band *band, int pos);
+__isl_give isl_schedule_band *
+isl_schedule_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_band *band, int pos,
+	enum isl_ast_loop_type type);
+__isl_give isl_union_set *isl_schedule_band_get_ast_build_options(
+	__isl_keep isl_schedule_band *band);
+__isl_give isl_schedule_band *isl_schedule_band_set_ast_build_options(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *options);
+__isl_give isl_set *isl_schedule_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_band *band, int depth);
+__isl_give isl_schedule_band *isl_schedule_band_replace_ast_build_option(
+	__isl_take isl_schedule_band *band, __isl_take isl_set *drop,
+	__isl_take isl_set *add);
+
+isl_size isl_schedule_band_n_member(__isl_keep isl_schedule_band *band);
+isl_bool isl_schedule_band_member_get_coincident(
+	__isl_keep isl_schedule_band *band, int pos);
+__isl_give isl_schedule_band *isl_schedule_band_member_set_coincident(
+	__isl_take isl_schedule_band *band, int pos, int coincident);
+isl_bool isl_schedule_band_get_permutable(__isl_keep isl_schedule_band *band);
+__isl_give isl_schedule_band *isl_schedule_band_set_permutable(
+	__isl_take isl_schedule_band *band, int permutable);
+
+__isl_give isl_schedule_band *isl_schedule_band_scale(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_band *isl_schedule_band_scale_down(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_band *isl_schedule_band_mod(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_band *isl_schedule_band_tile(
+	__isl_take isl_schedule_band *band, __isl_take isl_multi_val *sizes);
+__isl_give isl_schedule_band *isl_schedule_band_point(
+	__isl_take isl_schedule_band *band, __isl_keep isl_schedule_band *tile,
+	__isl_take isl_multi_val *sizes);
+__isl_give isl_schedule_band *isl_schedule_band_shift(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_multi_union_pw_aff *shift);
+__isl_give isl_schedule_band *isl_schedule_band_drop(
+	__isl_take isl_schedule_band *band, int pos, int n);
+__isl_give isl_schedule_band *isl_schedule_band_gist(
+	__isl_take isl_schedule_band *band, __isl_take isl_union_set *context);
+
+__isl_give isl_schedule_band *isl_schedule_band_reset_user(
+	__isl_take isl_schedule_band *band);
+__isl_give isl_schedule_band *isl_schedule_band_align_params(
+	__isl_take isl_schedule_band *band, __isl_take isl_space *space);
+__isl_give isl_schedule_band *isl_schedule_band_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_band *band,
+	__isl_take isl_union_pw_multi_aff *upma);
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_constraints.c Added

@@ -0,0 +1,762 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ * Copyright 2015-2016 Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl_schedule_constraints.h>
+#include <isl/schedule.h>
+#include <isl/space.h>
+#include <isl/set.h>
+#include <isl/map.h>
+#include <isl/union_set.h>
+#include <isl/union_map.h>
+#include <isl/stream.h>
+
+/* The constraints that need to be satisfied by a schedule on "domain".
+ *
+ * "context" specifies extra constraints on the parameters.
+ *
+ * "validity" constraints map domain elements i to domain elements
+ * that should be scheduled after i.  (Hard constraint)
+ * "proximity" constraints map domain elements i to domains elements
+ * that should be scheduled as early as possible after i (or before i).
+ * (Soft constraint)
+ *
+ * "condition" and "conditional_validity" constraints map possibly "tagged"
+ * domain elements i -> s to "tagged" domain elements j -> t.
+ * The elements of the "conditional_validity" constraints, but without the
+ * tags (i.e., the elements i -> j) are treated as validity constraints,
+ * except that during the construction of a tilable band,
+ * the elements of the "conditional_validity" constraints may be violated
+ * provided that all adjacent elements of the "condition" constraints
+ * are local within the band.
+ * A dependence is local within a band if domain and range are mapped
+ * to the same schedule point by the band.
+ */
+struct isl_schedule_constraints {
+	isl_union_set *domain;
+	isl_set *context;
+
+	isl_union_map *constraintisl_edge_last + 1;
+};
+
+__isl_give isl_schedule_constraints *isl_schedule_constraints_copy(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	isl_ctx *ctx;
+	isl_schedule_constraints *sc_copy;
+	enum isl_edge_type i;
+
+	ctx = isl_union_set_get_ctx(sc->domain);
+	sc_copy = isl_calloc_type(ctx, struct isl_schedule_constraints);
+	if (!sc_copy)
+		return NULL;
+
+	sc_copy->domain = isl_union_set_copy(sc->domain);
+	sc_copy->context = isl_set_copy(sc->context);
+	if (!sc_copy->domain || !sc_copy->context)
+		return isl_schedule_constraints_free(sc_copy);
+
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		sc_copy->constrainti = isl_union_map_copy(sc->constrainti);
+		if (!sc_copy->constrainti)
+			return isl_schedule_constraints_free(sc_copy);
+	}
+
+	return sc_copy;
+}
+
+/* Construct an empty (invalid) isl_schedule_constraints object.
+ * The caller is responsible for setting the domain and initializing
+ * all the other fields, e.g., by calling isl_schedule_constraints_init.
+ */
+static __isl_give isl_schedule_constraints *isl_schedule_constraints_alloc(
+	isl_ctx *ctx)
+{
+	return isl_calloc_type(ctx, struct isl_schedule_constraints);
+}
+
+/* Initialize all the fields of "sc", except domain, which is assumed
+ * to have been set by the caller.
+ */
+static __isl_give isl_schedule_constraints *isl_schedule_constraints_init(
+	__isl_take isl_schedule_constraints *sc)
+{
+	isl_space *space;
+	isl_union_map *empty;
+	enum isl_edge_type i;
+
+	if (!sc)
+		return NULL;
+	if (!sc->domain)
+		return isl_schedule_constraints_free(sc);
+	space = isl_union_set_get_space(sc->domain);
+	if (!sc->context)
+		sc->context = isl_set_universe(isl_space_copy(space));
+	empty = isl_union_map_empty(space);
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		if (sc->constrainti)
+			continue;
+		sc->constrainti = isl_union_map_copy(empty);
+		if (!sc->constrainti)
+			sc->domain = isl_union_set_free(sc->domain);
+	}
+	isl_union_map_free(empty);
+
+	if (!sc->domain || !sc->context)
+		return isl_schedule_constraints_free(sc);
+
+	return sc;
+}
+
+/* Construct an isl_schedule_constraints object for computing a schedule
+ * on "domain".  The initial object does not impose any constraints.
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_on_domain(
+	__isl_take isl_union_set *domain)
+{
+	isl_ctx *ctx;
+	isl_schedule_constraints *sc;
+
+	if (!domain)
+		return NULL;
+
+	ctx = isl_union_set_get_ctx(domain);
+	sc = isl_schedule_constraints_alloc(ctx);
+	if (!sc)
+		goto error;
+
+	sc->domain = domain;
+	return isl_schedule_constraints_init(sc);
+error:
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Replace the domain of "sc" by "domain".
+ */
+static __isl_give isl_schedule_constraints *isl_schedule_constraints_set_domain(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_set *domain)
+{
+	if (!sc || !domain)
+		goto error;
+
+	isl_union_set_free(sc->domain);
+	sc->domain = domain;
+
+	return sc;
+error:
+	isl_schedule_constraints_free(sc);
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Replace the context of "sc" by "context".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_set_context(
+	__isl_take isl_schedule_constraints *sc, __isl_take isl_set *context)
+{
+	if (!sc || !context)
+		goto error;
+
+	isl_set_free(sc->context);
+	sc->context = context;
+
+	return sc;
+error:
+	isl_schedule_constraints_free(sc);
+	isl_set_free(context);
+	return NULL;
+}
+
+/* Replace the constraints of type "type" in "sc" by "c".
+ */
+static __isl_give isl_schedule_constraints *isl_schedule_constraints_set(
+	__isl_take isl_schedule_constraints *sc, enum isl_edge_type type,
+	__isl_take isl_union_map *c)
+{
+	if (!sc || !c)
+		goto error;
+
+	isl_union_map_free(sc->constrainttype);
+	sc->constrainttype = c;
+
+	return sc;
+error:
+	isl_schedule_constraints_free(sc);
+	isl_union_map_free(c);
+	return NULL;
+}
+
+/* Replace the validity constraints of "sc" by "validity".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_set_validity(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *validity)
+{
+	return isl_schedule_constraints_set(sc, isl_edge_validity, validity);
+}
+
+/* Replace the coincidence constraints of "sc" by "coincidence".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_set_coincidence(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *coincidence)
+{
+	return isl_schedule_constraints_set(sc, isl_edge_coincidence,
+						coincidence);
+}
+
+/* Replace the proximity constraints of "sc" by "proximity".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_set_proximity(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *proximity)
+{
+	return isl_schedule_constraints_set(sc, isl_edge_proximity, proximity);
+}
+
+/* Replace the conditional validity constraints of "sc" by "condition"
+ * and "validity".
+ */
+__isl_give isl_schedule_constraints *
+isl_schedule_constraints_set_conditional_validity(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *condition,
+	__isl_take isl_union_map *validity)
+{
+	sc = isl_schedule_constraints_set(sc, isl_edge_condition, condition);
+	sc = isl_schedule_constraints_set(sc, isl_edge_conditional_validity,
+						validity);
+	return sc;
+}
+
+__isl_null isl_schedule_constraints *isl_schedule_constraints_free(
+	__isl_take isl_schedule_constraints *sc)
+{
+	enum isl_edge_type i;
+
+	if (!sc)
+		return NULL;
+
+	isl_union_set_free(sc->domain);
+	isl_set_free(sc->context);
+	for (i = isl_edge_first; i <= isl_edge_last; ++i)
+		isl_union_map_free(sc->constrainti);
+
+	free(sc);
+
+	return NULL;
+}
+
+isl_ctx *isl_schedule_constraints_get_ctx(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return sc ? isl_union_set_get_ctx(sc->domain) : NULL;
+}
+
+/* Return the domain of "sc".
+ */
+__isl_give isl_union_set *isl_schedule_constraints_get_domain(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	if (!sc)
+		return NULL;
+
+	return isl_union_set_copy(sc->domain);
+}
+
+/* Return the context of "sc".
+ */
+__isl_give isl_set *isl_schedule_constraints_get_context(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	if (!sc)
+		return NULL;
+
+	return isl_set_copy(sc->context);
+}
+
+/* Return the constraints of type "type" in "sc".
+ */
+__isl_give isl_union_map *isl_schedule_constraints_get(
+	__isl_keep isl_schedule_constraints *sc, enum isl_edge_type type)
+{
+	if (!sc)
+		return NULL;
+
+	return isl_union_map_copy(sc->constrainttype);
+}
+
+/* Return the validity constraints of "sc".
+ */
+__isl_give isl_union_map *isl_schedule_constraints_get_validity(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return isl_schedule_constraints_get(sc, isl_edge_validity);
+}
+
+/* Return the coincidence constraints of "sc".
+ */
+__isl_give isl_union_map *isl_schedule_constraints_get_coincidence(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return isl_schedule_constraints_get(sc, isl_edge_coincidence);
+}
+
+/* Return the proximity constraints of "sc".
+ */
+__isl_give isl_union_map *isl_schedule_constraints_get_proximity(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return isl_schedule_constraints_get(sc, isl_edge_proximity);
+}
+
+/* Return the conditional validity constraints of "sc".
+ */
+__isl_give isl_union_map *isl_schedule_constraints_get_conditional_validity(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return isl_schedule_constraints_get(sc, isl_edge_conditional_validity);
+}
+
+/* Return the conditions for the conditional validity constraints of "sc".
+ */
+__isl_give isl_union_map *
+isl_schedule_constraints_get_conditional_validity_condition(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	return isl_schedule_constraints_get(sc, isl_edge_condition);
+}
+
+/* Add "c" to the constraints of type "type" in "sc".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_add(
+	__isl_take isl_schedule_constraints *sc, enum isl_edge_type type,
+	__isl_take isl_union_map *c)
+{
+	if (!sc || !c)
+		goto error;
+
+	c = isl_union_map_union(sc->constrainttype, c);
+	sc->constrainttype = c;
+	if (!c)
+		return isl_schedule_constraints_free(sc);
+
+	return sc;
+error:
+	isl_schedule_constraints_free(sc);
+	isl_union_map_free(c);
+	return NULL;
+}
+
+/* Can a schedule constraint of type "type" be tagged?
+ */
+static int may_be_tagged(enum isl_edge_type type)
+{
+	if (type == isl_edge_condition || type == isl_edge_conditional_validity)
+		return 1;
+	return 0;
+}
+
+/* Apply "umap" to the domains of the wrapped relations
+ * inside the domain and range of "c".
+ *
+ * That is, for each map of the form
+ *
+ *	D -> S -> E -> T
+ *
+ * in "c", apply "umap" to D and E.
+ *
+ * D is exposed by currying the relation to
+ *
+ *	D -> S -> E -> T
+ *
+ * E is exposed by doing the same to the inverse of "c".
+ */
+static __isl_give isl_union_map *apply_factor_domain(
+	__isl_take isl_union_map *c, __isl_keep isl_union_map *umap)
+{
+	c = isl_union_map_curry(c);
+	c = isl_union_map_apply_domain(c, isl_union_map_copy(umap));
+	c = isl_union_map_uncurry(c);
+
+	c = isl_union_map_reverse(c);
+	c = isl_union_map_curry(c);
+	c = isl_union_map_apply_domain(c, isl_union_map_copy(umap));
+	c = isl_union_map_uncurry(c);
+	c = isl_union_map_reverse(c);
+
+	return c;
+}
+
+/* Apply "umap" to domain and range of "c".
+ * If "tag" is set, then "c" may contain tags and then "umap"
+ * needs to be applied to the domains of the wrapped relations
+ * inside the domain and range of "c".
+ */
+static __isl_give isl_union_map *apply(__isl_take isl_union_map *c,
+	__isl_keep isl_union_map *umap, int tag)
+{
+	isl_union_map *t;
+
+	if (tag)
+		t = isl_union_map_copy(c);
+	c = isl_union_map_apply_domain(c, isl_union_map_copy(umap));
+	c = isl_union_map_apply_range(c, isl_union_map_copy(umap));
+	if (!tag)
+		return c;
+	t = apply_factor_domain(t, umap);
+	c = isl_union_map_union(c, t);
+	return c;
+}
+
+/* Apply "umap" to the domain of the schedule constraints "sc".
+ *
+ * The two sides of the various schedule constraints are adjusted
+ * accordingly.
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_apply(
+	__isl_take isl_schedule_constraints *sc,
+	__isl_take isl_union_map *umap)
+{
+	enum isl_edge_type i;
+
+	if (!sc || !umap)
+		goto error;
+
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		int tag = may_be_tagged(i);
+
+		sc->constrainti = apply(sc->constrainti, umap, tag);
+		if (!sc->constrainti)
+			goto error;
+	}
+	sc->domain = isl_union_set_apply(sc->domain, umap);
+	if (!sc->domain)
+		return isl_schedule_constraints_free(sc);
+
+	return sc;
+error:
+	isl_schedule_constraints_free(sc);
+	isl_union_map_free(umap);
+	return NULL;
+}
+
+/* An enumeration of the various keys that may appear in a YAML mapping
+ * of an isl_schedule_constraints object.
+ * The keys for the edge types are assumed to have the same values
+ * as the edge types in isl_edge_type.
+ */
+enum isl_sc_key {
+	isl_sc_key_error = -1,
+	isl_sc_key_validity = isl_edge_validity,
+	isl_sc_key_coincidence = isl_edge_coincidence,
+	isl_sc_key_condition = isl_edge_condition,
+	isl_sc_key_conditional_validity = isl_edge_conditional_validity,
+	isl_sc_key_proximity = isl_edge_proximity,
+	isl_sc_key_domain,
+	isl_sc_key_context,
+	isl_sc_key_end
+};
+
+/* Textual representations of the YAML keys for an isl_schedule_constraints
+ * object.
+ */
+static char *key_str = {
+	isl_sc_key_validity = "validity",
+	isl_sc_key_coincidence = "coincidence",
+	isl_sc_key_condition = "condition",
+	isl_sc_key_conditional_validity = "conditional_validity",
+	isl_sc_key_proximity = "proximity",
+	isl_sc_key_domain = "domain",
+	isl_sc_key_context = "context",
+};
+
+#undef BASE
+#define BASE set
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE union_set
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE union_map
+#include "print_yaml_field_templ.c"
+
+/* Print a key, value pair for the edge of type "type" in "sc" to "p".
+ *
+ * If the edge relation is empty, then it is not printed since
+ * an empty relation is the default value.
+ */
+static __isl_give isl_printer *print_constraint(__isl_take isl_printer *p,
+	__isl_keep isl_schedule_constraints *sc, enum isl_edge_type type)
+{
+	isl_bool empty;
+
+	empty = isl_union_map_plain_is_empty(sc->constrainttype);
+	if (empty < 0)
+		return isl_printer_free(p);
+	if (empty)
+		return p;
+
+	p = print_yaml_field_union_map(p, key_strtype, sc->constrainttype);
+
+	return p;
+}
+
+/* Print "sc" to "p"
+ *
+ * In particular, print the isl_schedule_constraints object as a YAML document.
+ * Fields with values that are (obviously) equal to their default values
+ * are not printed.
+ */
+__isl_give isl_printer *isl_printer_print_schedule_constraints(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_constraints *sc)
+{
+	isl_bool universe;
+
+	if (!sc)
+		return isl_printer_free(p);
+
+	p = isl_printer_yaml_start_mapping(p);
+	p = print_yaml_field_union_set(p, key_strisl_sc_key_domain,
+					sc->domain);
+	universe = isl_set_plain_is_universe(sc->context);
+	if (universe < 0)
+		return isl_printer_free(p);
+	if (!universe)
+		p = print_yaml_field_set(p, key_strisl_sc_key_context,
+						sc->context);
+	p = print_constraint(p, sc, isl_edge_validity);
+	p = print_constraint(p, sc, isl_edge_proximity);
+	p = print_constraint(p, sc, isl_edge_coincidence);
+	p = print_constraint(p, sc, isl_edge_condition);
+	p = print_constraint(p, sc, isl_edge_conditional_validity);
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+#undef BASE
+#define BASE schedule_constraints
+#include <print_templ_yaml.c>
+
+#undef KEY
+#define KEY enum isl_sc_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_sc_key_error
+#undef KEY_END
+#define KEY_END isl_sc_key_end
+#include "extract_key.c"
+
+#undef BASE
+#define BASE set
+#include "read_in_string_templ.c"
+
+#undef BASE
+#define BASE union_set
+#include "read_in_string_templ.c"
+
+#undef BASE
+#define BASE union_map
+#include "read_in_string_templ.c"
+
+/* Read an isl_schedule_constraints object from "s".
+ *
+ * Start off with an empty (invalid) isl_schedule_constraints object and
+ * then fill up the fields based on the input.
+ * The input needs to contain at least a description of the domain.
+ * The other fields are set to defaults by isl_schedule_constraints_init
+ * if they are not specified in the input.
+ */
+__isl_give isl_schedule_constraints *isl_stream_read_schedule_constraints(
+	isl_stream *s)
+{
+	isl_ctx *ctx;
+	isl_schedule_constraints *sc;
+	int more;
+	int domain_set = 0;
+
+	if (isl_stream_yaml_read_start_mapping(s))
+		return NULL;
+
+	ctx = isl_stream_get_ctx(s);
+	sc = isl_schedule_constraints_alloc(ctx);
+	while ((more = isl_stream_yaml_next(s)) > 0) {
+		enum isl_sc_key key;
+		isl_set *context;
+		isl_union_set *domain;
+		isl_union_map *constraints;
+
+		key = get_key(s);
+		if (isl_stream_yaml_next(s) < 0)
+			return isl_schedule_constraints_free(sc);
+		switch (key) {
+		case isl_sc_key_end:
+		case isl_sc_key_error:
+			return isl_schedule_constraints_free(sc);
+		case isl_sc_key_domain:
+			domain_set = 1;
+			domain = read_union_set(s);
+			sc = isl_schedule_constraints_set_domain(sc, domain);
+			if (!sc)
+				return NULL;
+			break;
+		case isl_sc_key_context:
+			context = read_set(s);
+			sc = isl_schedule_constraints_set_context(sc, context);
+			if (!sc)
+				return NULL;
+			break;
+		case isl_sc_key_validity:
+		case isl_sc_key_coincidence:
+		case isl_sc_key_condition:
+		case isl_sc_key_conditional_validity:
+		case isl_sc_key_proximity:
+			constraints = read_union_map(s);
+			sc = isl_schedule_constraints_set(sc, key, constraints);
+			if (!sc)
+				return NULL;
+			break;
+		}
+	}
+	if (more < 0)
+		return isl_schedule_constraints_free(sc);
+
+	if (isl_stream_yaml_read_end_mapping(s) < 0) {
+		isl_stream_error(s, NULL, "unexpected extra elements");
+		return isl_schedule_constraints_free(sc);
+	}
+
+	if (!domain_set) {
+		isl_stream_error(s, NULL, "no domain specified");
+		return isl_schedule_constraints_free(sc);
+	}
+
+	return isl_schedule_constraints_init(sc);
+}
+
+/* Read an isl_schedule_constraints object from the file "input".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_read_from_file(
+	isl_ctx *ctx, FILE *input)
+{
+	struct isl_stream *s;
+	isl_schedule_constraints *sc;
+
+	s = isl_stream_new_file(ctx, input);
+	if (!s)
+		return NULL;
+	sc = isl_stream_read_schedule_constraints(s);
+	isl_stream_free(s);
+
+	return sc;
+}
+
+/* Read an isl_schedule_constraints object from the string "str".
+ */
+__isl_give isl_schedule_constraints *isl_schedule_constraints_read_from_str(
+	isl_ctx *ctx, const char *str)
+{
+	struct isl_stream *s;
+	isl_schedule_constraints *sc;
+
+	s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	sc = isl_stream_read_schedule_constraints(s);
+	isl_stream_free(s);
+
+	return sc;
+}
+
+/* Align the parameters of the fields of "sc".
+ */
+__isl_give isl_schedule_constraints *
+isl_schedule_constraints_align_params(__isl_take isl_schedule_constraints *sc)
+{
+	isl_space *space;
+	enum isl_edge_type i;
+
+	if (!sc)
+		return NULL;
+
+	space = isl_union_set_get_space(sc->domain);
+	space = isl_space_align_params(space, isl_set_get_space(sc->context));
+	for (i = isl_edge_first; i <= isl_edge_last; ++i)
+		space = isl_space_align_params(space,
+				    isl_union_map_get_space(sc->constrainti));
+
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		sc->constrainti = isl_union_map_align_params(
+				    sc->constrainti, isl_space_copy(space));
+		if (!sc->constrainti)
+			space = isl_space_free(space);
+	}
+	sc->context = isl_set_align_params(sc->context, isl_space_copy(space));
+	sc->domain = isl_union_set_align_params(sc->domain, space);
+	if (!sc->context || !sc->domain)
+		return isl_schedule_constraints_free(sc);
+
+	return sc;
+}
+
+/* Add the number of basic maps in "map" to *n.
+ */
+static isl_stat add_n_basic_map(__isl_take isl_map *map, void *user)
+{
+	int *n = user;
+	isl_size n_basic_map;
+
+	n_basic_map = isl_map_n_basic_map(map);
+	*n += n_basic_map;
+	isl_map_free(map);
+
+	return n_basic_map < 0 ? isl_stat_error : isl_stat_ok;
+}
+
+/* Return the total number of isl_basic_maps in the constraints of "sc".
+ * Return -1 on error.
+ */
+int isl_schedule_constraints_n_basic_map(
+	__isl_keep isl_schedule_constraints *sc)
+{
+	enum isl_edge_type i;
+	int n = 0;
+
+	if (!sc)
+		return -1;
+	for (i = isl_edge_first; i <= isl_edge_last; ++i)
+		if (isl_union_map_foreach_map(sc->constrainti,
+						&add_n_basic_map, &n) < 0)
+			return -1;
+
+	return n;
+}
+
+/* Return the total number of isl_maps in the constraints of "sc".
+ */
+isl_size isl_schedule_constraints_n_map(__isl_keep isl_schedule_constraints *sc)
+{
+	enum isl_edge_type i;
+	int n = 0;
+
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		isl_size n_i;
+
+		n_i = isl_union_map_n_map(sc->constrainti);
+		if (n_i < 0)
+			return isl_size_error;
+		n += n_i;
+	}
+
+	return n;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_constraints.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_node.c Added

@@ -0,0 +1,4906 @@
+/*
+ * Copyright 2013-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ */
+
+#include <isl/id.h>
+#include <isl/val.h>
+#include <isl/space.h>
+#include <isl/set.h>
+#include <isl_schedule_band.h>
+#include <isl_schedule_private.h>
+#include <isl_schedule_node_private.h>
+
+/* Create a new schedule node in the given schedule, point at the given
+ * tree with given ancestors and child positions.
+ * "child_pos" may be NULL if there are no ancestors.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_alloc(
+	__isl_take isl_schedule *schedule, __isl_take isl_schedule_tree *tree,
+	__isl_take isl_schedule_tree_list *ancestors, int *child_pos)
+{
+	isl_ctx *ctx;
+	isl_schedule_node *node;
+	int i;
+	isl_size n;
+
+	n = isl_schedule_tree_list_n_schedule_tree(ancestors);
+	if (!schedule || !tree || n < 0)
+		goto error;
+	if (n > 0 && !child_pos)
+		goto error;
+	ctx = isl_schedule_get_ctx(schedule);
+	node = isl_calloc_type(ctx, isl_schedule_node);
+	if (!node)
+		goto error;
+	node->ref = 1;
+	node->schedule = schedule;
+	node->tree = tree;
+	node->ancestors = ancestors;
+	node->child_pos = isl_alloc_array(ctx, int, n);
+	if (n && !node->child_pos)
+		return isl_schedule_node_free(node);
+	for (i = 0; i < n; ++i)
+		node->child_posi = child_posi;
+
+	return node;
+error:
+	isl_schedule_free(schedule);
+	isl_schedule_tree_free(tree);
+	isl_schedule_tree_list_free(ancestors);
+	return NULL;
+}
+
+/* Return a pointer to the root of a schedule tree with as single
+ * node a domain node with the given domain.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_from_domain(
+	__isl_take isl_union_set *domain)
+{
+	isl_schedule *schedule;
+	isl_schedule_node *node;
+
+	schedule = isl_schedule_from_domain(domain);
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+
+	return node;
+}
+
+/* Return a pointer to the root of a schedule tree with as single
+ * node a extension node with the given extension.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_from_extension(
+	__isl_take isl_union_map *extension)
+{
+	isl_ctx *ctx;
+	isl_schedule *schedule;
+	isl_schedule_tree *tree;
+	isl_schedule_node *node;
+
+	if (!extension)
+		return NULL;
+
+	ctx = isl_union_map_get_ctx(extension);
+	tree = isl_schedule_tree_from_extension(extension);
+	schedule = isl_schedule_from_schedule_tree(ctx, tree);
+	node = isl_schedule_get_root(schedule);
+	isl_schedule_free(schedule);
+
+	return node;
+}
+
+/* Return the isl_ctx to which "node" belongs.
+ */
+isl_ctx *isl_schedule_node_get_ctx(__isl_keep isl_schedule_node *node)
+{
+	return node ? isl_schedule_get_ctx(node->schedule) : NULL;
+}
+
+/* Return a pointer to the leaf of the schedule into which "node" points.
+ */
+__isl_keep isl_schedule_tree *isl_schedule_node_peek_leaf(
+	__isl_keep isl_schedule_node *node)
+{
+	return node ? isl_schedule_peek_leaf(node->schedule) : NULL;
+}
+
+/* Return a copy of the leaf of the schedule into which "node" points.
+ */
+__isl_give isl_schedule_tree *isl_schedule_node_get_leaf(
+	__isl_keep isl_schedule_node *node)
+{
+	return isl_schedule_tree_copy(isl_schedule_node_peek_leaf(node));
+}
+
+/* Return the type of the node or isl_schedule_node_error on error.
+ */
+enum isl_schedule_node_type isl_schedule_node_get_type(
+	__isl_keep isl_schedule_node *node)
+{
+	return node ? isl_schedule_tree_get_type(node->tree)
+		    : isl_schedule_node_error;
+}
+
+/* Return the type of the parent of "node" or isl_schedule_node_error on error.
+ */
+enum isl_schedule_node_type isl_schedule_node_get_parent_type(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	int pos;
+	int has_parent;
+	isl_schedule_tree *parent;
+	enum isl_schedule_node_type type;
+
+	if (!node)
+		return isl_schedule_node_error;
+	has_parent = isl_schedule_node_has_parent(node);
+	if (has_parent < 0)
+		return isl_schedule_node_error;
+	if (!has_parent)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no parent", return isl_schedule_node_error);
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_schedule_node_error;
+
+	pos = n - 1;
+	parent = isl_schedule_tree_list_get_schedule_tree(node->ancestors, pos);
+	type = isl_schedule_tree_get_type(parent);
+	isl_schedule_tree_free(parent);
+
+	return type;
+}
+
+/* Return a copy of the subtree that this node points to.
+ */
+__isl_give isl_schedule_tree *isl_schedule_node_get_tree(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_copy(node->tree);
+}
+
+/* Return a copy of the schedule into which "node" points.
+ */
+__isl_give isl_schedule *isl_schedule_node_get_schedule(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+	return isl_schedule_copy(node->schedule);
+}
+
+/* Return a fresh copy of "node".
+ */
+__isl_take isl_schedule_node *isl_schedule_node_dup(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_node_alloc(isl_schedule_copy(node->schedule),
+				isl_schedule_tree_copy(node->tree),
+				isl_schedule_tree_list_copy(node->ancestors),
+				node->child_pos);
+}
+
+/* Return an isl_schedule_node that is equal to "node" and that has only
+ * a single reference.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_cow(
+	__isl_take isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	if (node->ref == 1)
+		return node;
+	node->ref--;
+	return isl_schedule_node_dup(node);
+}
+
+/* Return a new reference to "node".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_copy(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	node->ref++;
+	return node;
+}
+
+/* Free "node" and return NULL.
+ */
+__isl_null isl_schedule_node *isl_schedule_node_free(
+	__isl_take isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+	if (--node->ref > 0)
+		return NULL;
+
+	isl_schedule_tree_list_free(node->ancestors);
+	free(node->child_pos);
+	isl_schedule_tree_free(node->tree);
+	isl_schedule_free(node->schedule);
+	free(node);
+
+	return NULL;
+}
+
+/* Do "node1" and "node2" point to the same position in the same
+ * schedule?
+ */
+isl_bool isl_schedule_node_is_equal(__isl_keep isl_schedule_node *node1,
+	__isl_keep isl_schedule_node *node2)
+{
+	int i;
+	isl_size n1, n2;
+
+	if (!node1 || !node2)
+		return isl_bool_error;
+	if (node1 == node2)
+		return isl_bool_true;
+	if (node1->schedule != node2->schedule)
+		return isl_bool_false;
+
+	n1 = isl_schedule_node_get_tree_depth(node1);
+	n2 = isl_schedule_node_get_tree_depth(node2);
+	if (n1 < 0 || n2 < 0)
+		return isl_bool_error;
+	if (n1 != n2)
+		return isl_bool_false;
+	for (i = 0; i < n1; ++i)
+		if (node1->child_posi != node2->child_posi)
+			return isl_bool_false;
+
+	return isl_bool_true;
+}
+
+/* Return the number of outer schedule dimensions of "node"
+ * in its schedule tree.
+ *
+ * Return isl_size_error on error.
+ */
+isl_size isl_schedule_node_get_schedule_depth(
+	__isl_keep isl_schedule_node *node)
+{
+	int i;
+	isl_size n;
+	int depth = 0;
+
+	if (!node)
+		return isl_size_error;
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_size_error;
+	for (i = n - 1; i >= 0; --i) {
+		isl_schedule_tree *tree;
+		isl_size n;
+
+		tree = isl_schedule_tree_list_get_schedule_tree(
+						    node->ancestors, i);
+		if (!tree)
+			return isl_size_error;
+		n = 0;
+		if (tree->type == isl_schedule_node_band)
+			n = isl_schedule_tree_band_n_member(tree);
+		depth += n;
+		isl_schedule_tree_free(tree);
+		if (n < 0)
+			return isl_size_error;
+	}
+
+	return depth;
+}
+
+/* Internal data structure for
+ * isl_schedule_node_get_prefix_schedule_union_pw_multi_aff
+ *
+ * "initialized" is set if the filter field has been initialized.
+ * If "universe_domain" is not set, then the collected filter is intersected
+ * with the domain of the root domain node.
+ * "universe_filter" is set if we are only collecting the universes of filters
+ * "collect_prefix" is set if we are collecting prefixes.
+ * "filter" collects all outer filters and is NULL until "initialized" is set.
+ * "prefix" collects all outer band partial schedules (if "collect_prefix"
+ * is set).  If it is used, then it is initialized by the caller
+ * of collect_filter_prefix to a zero-dimensional function.
+ */
+struct isl_schedule_node_get_filter_prefix_data {
+	int initialized;
+	int universe_domain;
+	int universe_filter;
+	int collect_prefix;
+	isl_union_set *filter;
+	isl_multi_union_pw_aff *prefix;
+};
+
+static isl_stat collect_filter_prefix(__isl_keep isl_schedule_tree_list *list,
+	int n, struct isl_schedule_node_get_filter_prefix_data *data);
+
+/* Update the filter and prefix information in "data" based on the first "n"
+ * elements in "list" and the expansion tree root "tree".
+ *
+ * We first collect the information from the elements in "list",
+ * initializing the filter based on the domain of the expansion.
+ * Then we map the results to the expanded space and combined them
+ * with the results already in "data".
+ */
+static isl_stat collect_filter_prefix_expansion(
+	__isl_take isl_schedule_tree *tree,
+	__isl_keep isl_schedule_tree_list *list, int n,
+	struct isl_schedule_node_get_filter_prefix_data *data)
+{
+	struct isl_schedule_node_get_filter_prefix_data contracted;
+	isl_union_pw_multi_aff *c;
+	isl_union_map *exp, *universe;
+	isl_union_set *filter;
+
+	c = isl_schedule_tree_expansion_get_contraction(tree);
+	exp = isl_schedule_tree_expansion_get_expansion(tree);
+
+	contracted.initialized = 1;
+	contracted.universe_domain = data->universe_domain;
+	contracted.universe_filter = data->universe_filter;
+	contracted.collect_prefix = data->collect_prefix;
+	universe = isl_union_map_universe(isl_union_map_copy(exp));
+	filter = isl_union_map_domain(universe);
+	if (data->collect_prefix) {
+		isl_space *space = isl_union_set_get_space(filter);
+		space = isl_space_set_from_params(space);
+		contracted.prefix = isl_multi_union_pw_aff_zero(space);
+	}
+	contracted.filter = filter;
+
+	if (collect_filter_prefix(list, n, &contracted) < 0)
+		contracted.filter = isl_union_set_free(contracted.filter);
+	if (data->collect_prefix) {
+		isl_multi_union_pw_aff *prefix;
+
+		prefix = contracted.prefix;
+		prefix =
+		    isl_multi_union_pw_aff_pullback_union_pw_multi_aff(prefix,
+						isl_union_pw_multi_aff_copy(c));
+		data->prefix = isl_multi_union_pw_aff_flat_range_product(
+						prefix, data->prefix);
+	}
+	filter = contracted.filter;
+	if (data->universe_domain)
+		filter = isl_union_set_preimage_union_pw_multi_aff(filter,
+						isl_union_pw_multi_aff_copy(c));
+	else
+		filter = isl_union_set_apply(filter, isl_union_map_copy(exp));
+	if (!data->initialized)
+		data->filter = filter;
+	else
+		data->filter = isl_union_set_intersect(filter, data->filter);
+	data->initialized = 1;
+
+	isl_union_pw_multi_aff_free(c);
+	isl_union_map_free(exp);
+	isl_schedule_tree_free(tree);
+
+	return isl_stat_ok;
+}
+
+/* Update the filter information in "data" based on the first "n"
+ * elements in "list" and the extension tree root "tree", in case
+ * data->universe_domain is set and data->collect_prefix is not.
+ *
+ * We collect the universe domain of the elements in "list" and
+ * add it to the universe range of the extension (intersected
+ * with the already collected filter, if any).
+ */
+static isl_stat collect_universe_domain_extension(
+	__isl_take isl_schedule_tree *tree,
+	__isl_keep isl_schedule_tree_list *list, int n,
+	struct isl_schedule_node_get_filter_prefix_data *data)
+{
+	struct isl_schedule_node_get_filter_prefix_data data_outer;
+	isl_union_map *extension;
+	isl_union_set *filter;
+
+	data_outer.initialized = 0;
+	data_outer.universe_domain = 1;
+	data_outer.universe_filter = data->universe_filter;
+	data_outer.collect_prefix = 0;
+	data_outer.filter = NULL;
+	data_outer.prefix = NULL;
+
+	if (collect_filter_prefix(list, n, &data_outer) < 0)
+		data_outer.filter = isl_union_set_free(data_outer.filter);
+
+	extension = isl_schedule_tree_extension_get_extension(tree);
+	extension = isl_union_map_universe(extension);
+	filter = isl_union_map_range(extension);
+	if (data_outer.initialized)
+		filter = isl_union_set_union(filter, data_outer.filter);
+	if (data->initialized)
+		filter = isl_union_set_intersect(filter, data->filter);
+
+	data->filter = filter;
+
+	isl_schedule_tree_free(tree);
+
+	return isl_stat_ok;
+}
+
+/* Update "data" based on the tree node "tree" in case "data" has
+ * not been initialized yet.
+ *
+ * Return 0 on success and -1 on error.
+ *
+ * If "tree" is a filter, then we set data->filter to this filter
+ * (or its universe).
+ * If "tree" is a domain, then this means we have reached the root
+ * of the schedule tree without being able to extract any information.
+ * We therefore initialize data->filter to the universe of the domain,
+ * or the domain itself if data->universe_domain is not set.
+ * If "tree" is a band with at least one member, then we set data->filter
+ * to the universe of the schedule domain and replace the zero-dimensional
+ * data->prefix by the band schedule (if data->collect_prefix is set).
+ */
+static isl_stat collect_filter_prefix_init(__isl_keep isl_schedule_tree *tree,
+	struct isl_schedule_node_get_filter_prefix_data *data)
+{
+	enum isl_schedule_node_type type;
+	isl_multi_union_pw_aff *mupa;
+	isl_union_set *filter;
+	isl_size n;
+
+	type = isl_schedule_tree_get_type(tree);
+	switch (type) {
+	case isl_schedule_node_error:
+		return isl_stat_error;
+	case isl_schedule_node_expansion:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"should be handled by caller", return isl_stat_error);
+	case isl_schedule_node_extension:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"cannot handle extension nodes", return isl_stat_error);
+	case isl_schedule_node_context:
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		return isl_stat_ok;
+	case isl_schedule_node_domain:
+		filter = isl_schedule_tree_domain_get_domain(tree);
+		if (data->universe_domain)
+			filter = isl_union_set_universe(filter);
+		data->filter = filter;
+		break;
+	case isl_schedule_node_band:
+		n = isl_schedule_tree_band_n_member(tree);
+		if (n < 0)
+			return isl_stat_error;
+		if (n == 0)
+			return isl_stat_ok;
+		mupa = isl_schedule_tree_band_get_partial_schedule(tree);
+		if (data->collect_prefix) {
+			isl_multi_union_pw_aff_free(data->prefix);
+			mupa = isl_multi_union_pw_aff_reset_tuple_id(mupa,
+								isl_dim_set);
+			data->prefix = isl_multi_union_pw_aff_copy(mupa);
+		}
+		filter = isl_multi_union_pw_aff_domain(mupa);
+		filter = isl_union_set_universe(filter);
+		data->filter = filter;
+		break;
+	case isl_schedule_node_filter:
+		filter = isl_schedule_tree_filter_get_filter(tree);
+		if (data->universe_filter)
+			filter = isl_union_set_universe(filter);
+		data->filter = filter;
+		break;
+	}
+
+	if ((data->collect_prefix && !data->prefix) || !data->filter)
+		return isl_stat_error;
+
+	data->initialized = 1;
+
+	return isl_stat_ok;
+}
+
+/* Update "data" based on the tree node "tree" in case "data" has
+ * already been initialized.
+ *
+ * Return 0 on success and -1 on error.
+ *
+ * If "tree" is a domain and data->universe_domain is not set, then
+ * intersect data->filter with the domain.
+ * If "tree" is a filter, then we intersect data->filter with this filter
+ * (or its universe).
+ * If "tree" is a band with at least one member and data->collect_prefix
+ * is set, then we extend data->prefix with the band schedule.
+ * If "tree" is an extension, then we make sure that we are not collecting
+ * information on any extended domain elements.
+ */
+static isl_stat collect_filter_prefix_update(__isl_keep isl_schedule_tree *tree,
+	struct isl_schedule_node_get_filter_prefix_data *data)
+{
+	enum isl_schedule_node_type type;
+	isl_multi_union_pw_aff *mupa;
+	isl_union_set *filter;
+	isl_union_map *extension;
+	isl_bool empty;
+	isl_size n;
+
+	type = isl_schedule_tree_get_type(tree);
+	switch (type) {
+	case isl_schedule_node_error:
+		return isl_stat_error;
+	case isl_schedule_node_expansion:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"should be handled by caller", return isl_stat_error);
+	case isl_schedule_node_extension:
+		extension = isl_schedule_tree_extension_get_extension(tree);
+		extension = isl_union_map_intersect_range(extension,
+					isl_union_set_copy(data->filter));
+		empty = isl_union_map_is_empty(extension);
+		isl_union_map_free(extension);
+		if (empty < 0)
+			return isl_stat_error;
+		if (empty)
+			break;
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"cannot handle extension nodes", return isl_stat_error);
+	case isl_schedule_node_context:
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	case isl_schedule_node_domain:
+		if (data->universe_domain)
+			break;
+		filter = isl_schedule_tree_domain_get_domain(tree);
+		data->filter = isl_union_set_intersect(data->filter, filter);
+		break;
+	case isl_schedule_node_band:
+		n = isl_schedule_tree_band_n_member(tree);
+		if (n < 0)
+			return isl_stat_error;
+		if (n == 0)
+			break;
+		if (!data->collect_prefix)
+			break;
+		mupa = isl_schedule_tree_band_get_partial_schedule(tree);
+		data->prefix = isl_multi_union_pw_aff_flat_range_product(mupa,
+								data->prefix);
+		if (!data->prefix)
+			return isl_stat_error;
+		break;
+	case isl_schedule_node_filter:
+		filter = isl_schedule_tree_filter_get_filter(tree);
+		if (data->universe_filter)
+			filter = isl_union_set_universe(filter);
+		data->filter = isl_union_set_intersect(data->filter, filter);
+		if (!data->filter)
+			return isl_stat_error;
+		break;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Collect filter and/or prefix information from the first "n"
+ * elements in "list" (which represent the ancestors of a node).
+ * Store the results in "data".
+ *
+ * Extension nodes are only supported if they do not affect the outcome,
+ * i.e., if we are collecting information on non-extended domain elements,
+ * or if we are collecting the universe domain (without prefix).
+ *
+ * Return 0 on success and -1 on error.
+ *
+ * We traverse the list from innermost ancestor (last element)
+ * to outermost ancestor (first element), calling collect_filter_prefix_init
+ * on each node as long as we have not been able to extract any information
+ * yet and collect_filter_prefix_update afterwards.
+ * If we come across an expansion node, then we interrupt the traversal
+ * and call collect_filter_prefix_expansion to restart the traversal
+ * over the remaining ancestors and to combine the results with those
+ * that have already been collected.
+ * If we come across an extension node and we are only computing
+ * the universe domain, then we interrupt the traversal and call
+ * collect_universe_domain_extension to restart the traversal
+ * over the remaining ancestors and to combine the results with those
+ * that have already been collected.
+ * On successful return, data->initialized will be set since the outermost
+ * ancestor is a domain node, which always results in an initialization.
+ */
+static isl_stat collect_filter_prefix(__isl_keep isl_schedule_tree_list *list,
+	int n, struct isl_schedule_node_get_filter_prefix_data *data)
+{
+	int i;
+
+	if (!list)
+		return isl_stat_error;
+
+	for (i = n - 1; i >= 0; --i) {
+		isl_schedule_tree *tree;
+		enum isl_schedule_node_type type;
+		isl_stat r;
+
+		tree = isl_schedule_tree_list_get_schedule_tree(list, i);
+		if (!tree)
+			return isl_stat_error;
+		type = isl_schedule_tree_get_type(tree);
+		if (type == isl_schedule_node_expansion)
+			return collect_filter_prefix_expansion(tree, list, i,
+								data);
+		if (type == isl_schedule_node_extension &&
+		    data->universe_domain && !data->collect_prefix)
+			return collect_universe_domain_extension(tree, list, i,
+								data);
+		if (!data->initialized)
+			r = collect_filter_prefix_init(tree, data);
+		else
+			r = collect_filter_prefix_update(tree, data);
+		isl_schedule_tree_free(tree);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Return the concatenation of the partial schedules of all outer band
+ * nodes of "node" interesected with all outer filters
+ * as an isl_multi_union_pw_aff.
+ * None of the ancestors of "node" may be an extension node, unless
+ * there is also a filter ancestor that filters out all the extended
+ * domain elements.
+ *
+ * If "node" is pointing at the root of the schedule tree, then
+ * there are no domain elements reaching the current node, so
+ * we return an empty result.
+ *
+ * We collect all the filters and partial schedules in collect_filter_prefix
+ * and intersect the domain of the combined schedule with the combined filter.
+ */
+__isl_give isl_multi_union_pw_aff *
+isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	isl_space *space;
+	struct isl_schedule_node_get_filter_prefix_data data;
+
+	if (!node)
+		return NULL;
+
+	space = isl_schedule_get_space(node->schedule);
+	space = isl_space_set_from_params(space);
+	if (node->tree == node->schedule->root)
+		return isl_multi_union_pw_aff_zero(space);
+
+	data.initialized = 0;
+	data.universe_domain = 1;
+	data.universe_filter = 0;
+	data.collect_prefix = 1;
+	data.filter = NULL;
+	data.prefix = isl_multi_union_pw_aff_zero(space);
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0 || collect_filter_prefix(node->ancestors, n, &data) < 0)
+		data.prefix = isl_multi_union_pw_aff_free(data.prefix);
+
+	data.prefix = isl_multi_union_pw_aff_intersect_domain(data.prefix,
+								data.filter);
+
+	return data.prefix;
+}
+
+/* Return the concatenation of the partial schedules of all outer band
+ * nodes of "node" interesected with all outer filters
+ * as an isl_union_pw_multi_aff.
+ * None of the ancestors of "node" may be an extension node, unless
+ * there is also a filter ancestor that filters out all the extended
+ * domain elements.
+ *
+ * If "node" is pointing at the root of the schedule tree, then
+ * there are no domain elements reaching the current node, so
+ * we return an empty result.
+ *
+ * We collect all the filters and partial schedules in collect_filter_prefix.
+ * The partial schedules are collected as an isl_multi_union_pw_aff.
+ * If this isl_multi_union_pw_aff is zero-dimensional, then it does not
+ * contain any domain information, so we construct the isl_union_pw_multi_aff
+ * result as a zero-dimensional function on the collected filter.
+ * Otherwise, we convert the isl_multi_union_pw_aff to
+ * an isl_multi_union_pw_aff and intersect the domain with the filter.
+ */
+__isl_give isl_union_pw_multi_aff *
+isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n, dim;
+	isl_space *space;
+	isl_union_pw_multi_aff *prefix;
+	struct isl_schedule_node_get_filter_prefix_data data;
+
+	if (!node)
+		return NULL;
+
+	space = isl_schedule_get_space(node->schedule);
+	if (node->tree == node->schedule->root)
+		return isl_union_pw_multi_aff_empty(space);
+
+	space = isl_space_set_from_params(space);
+	data.initialized = 0;
+	data.universe_domain = 1;
+	data.universe_filter = 0;
+	data.collect_prefix = 1;
+	data.filter = NULL;
+	data.prefix = isl_multi_union_pw_aff_zero(space);
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0 || collect_filter_prefix(node->ancestors, n, &data) < 0)
+		data.prefix = isl_multi_union_pw_aff_free(data.prefix);
+
+	dim = isl_multi_union_pw_aff_dim(data.prefix, isl_dim_set);
+	if (dim < 0)
+		data.prefix = isl_multi_union_pw_aff_free(data.prefix);
+	if (data.prefix && dim == 0) {
+		isl_multi_union_pw_aff_free(data.prefix);
+		prefix = isl_union_pw_multi_aff_from_domain(data.filter);
+	} else {
+		prefix =
+		    isl_union_pw_multi_aff_from_multi_union_pw_aff(data.prefix);
+		prefix = isl_union_pw_multi_aff_intersect_domain(prefix,
+								data.filter);
+	}
+
+	return prefix;
+}
+
+/* Return the concatenation of the partial schedules of all outer band
+ * nodes of "node" interesected with all outer filters
+ * as an isl_union_map.
+ */
+__isl_give isl_union_map *isl_schedule_node_get_prefix_schedule_union_map(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_union_pw_multi_aff *upma;
+
+	upma = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node);
+	return isl_union_map_from_union_pw_multi_aff(upma);
+}
+
+/* Return the concatenation of the partial schedules of all outer band
+ * nodes of "node" intersected with all outer domain constraints.
+ * None of the ancestors of "node" may be an extension node, unless
+ * there is also a filter ancestor that filters out all the extended
+ * domain elements.
+ *
+ * Essentially, this function intersects the domain of the output
+ * of isl_schedule_node_get_prefix_schedule_union_map with the output
+ * of isl_schedule_node_get_domain, except that it only traverses
+ * the ancestors of "node" once.
+ */
+__isl_give isl_union_map *isl_schedule_node_get_prefix_schedule_relation(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n, dim;
+	isl_space *space;
+	isl_union_map *prefix;
+	struct isl_schedule_node_get_filter_prefix_data data;
+
+	if (!node)
+		return NULL;
+
+	space = isl_schedule_get_space(node->schedule);
+	if (node->tree == node->schedule->root)
+		return isl_union_map_empty(space);
+
+	space = isl_space_set_from_params(space);
+	data.initialized = 0;
+	data.universe_domain = 0;
+	data.universe_filter = 0;
+	data.collect_prefix = 1;
+	data.filter = NULL;
+	data.prefix = isl_multi_union_pw_aff_zero(space);
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0 || collect_filter_prefix(node->ancestors, n, &data) < 0)
+		data.prefix = isl_multi_union_pw_aff_free(data.prefix);
+
+	dim = isl_multi_union_pw_aff_dim(data.prefix, isl_dim_set);
+	if (dim < 0)
+		data.prefix = isl_multi_union_pw_aff_free(data.prefix);
+	if (data.prefix && dim == 0) {
+		isl_multi_union_pw_aff_free(data.prefix);
+		prefix = isl_union_map_from_domain(data.filter);
+	} else {
+		prefix = isl_union_map_from_multi_union_pw_aff(data.prefix);
+		prefix = isl_union_map_intersect_domain(prefix, data.filter);
+	}
+
+	return prefix;
+}
+
+/* Return the domain elements that reach "node".
+ *
+ * If "node" is pointing at the root of the schedule tree, then
+ * there are no domain elements reaching the current node, so
+ * we return an empty result.
+ * None of the ancestors of "node" may be an extension node, unless
+ * there is also a filter ancestor that filters out all the extended
+ * domain elements.
+ *
+ * Otherwise, we collect all filters reaching the node,
+ * intersected with the root domain in collect_filter_prefix.
+ */
+__isl_give isl_union_set *isl_schedule_node_get_domain(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	struct isl_schedule_node_get_filter_prefix_data data;
+
+	if (!node)
+		return NULL;
+
+	if (node->tree == node->schedule->root) {
+		isl_space *space;
+
+		space = isl_schedule_get_space(node->schedule);
+		return isl_union_set_empty(space);
+	}
+
+	data.initialized = 0;
+	data.universe_domain = 0;
+	data.universe_filter = 0;
+	data.collect_prefix = 0;
+	data.filter = NULL;
+	data.prefix = NULL;
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0 || collect_filter_prefix(node->ancestors, n, &data) < 0)
+		data.filter = isl_union_set_free(data.filter);
+
+	return data.filter;
+}
+
+/* Return the union of universe sets of the domain elements that reach "node".
+ *
+ * If "node" is pointing at the root of the schedule tree, then
+ * there are no domain elements reaching the current node, so
+ * we return an empty result.
+ *
+ * Otherwise, we collect the universes of all filters reaching the node
+ * in collect_filter_prefix.
+ */
+__isl_give isl_union_set *isl_schedule_node_get_universe_domain(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	struct isl_schedule_node_get_filter_prefix_data data;
+
+	if (!node)
+		return NULL;
+
+	if (node->tree == node->schedule->root) {
+		isl_space *space;
+
+		space = isl_schedule_get_space(node->schedule);
+		return isl_union_set_empty(space);
+	}
+
+	data.initialized = 0;
+	data.universe_domain = 1;
+	data.universe_filter = 1;
+	data.collect_prefix = 0;
+	data.filter = NULL;
+	data.prefix = NULL;
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0 || collect_filter_prefix(node->ancestors, n, &data) < 0)
+		data.filter = isl_union_set_free(data.filter);
+
+	return data.filter;
+}
+
+/* Return the subtree schedule of "node".
+ *
+ * Since isl_schedule_tree_get_subtree_schedule_union_map does not handle
+ * trees that do not contain any schedule information, we first
+ * move down to the first relevant descendant and handle leaves ourselves.
+ *
+ * If the subtree rooted at "node" contains any expansion nodes, then
+ * the returned subtree schedule is formulated in terms of the expanded
+ * domains.
+ * The subtree is not allowed to contain any extension nodes.
+ */
+__isl_give isl_union_map *isl_schedule_node_get_subtree_schedule_union_map(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_schedule_tree *tree, *leaf;
+	isl_union_map *umap;
+
+	tree = isl_schedule_node_get_tree(node);
+	leaf = isl_schedule_node_peek_leaf(node);
+	tree = isl_schedule_tree_first_schedule_descendant(tree, leaf);
+	if (!tree)
+		return NULL;
+	if (tree == leaf) {
+		isl_union_set *domain;
+		domain = isl_schedule_node_get_universe_domain(node);
+		isl_schedule_tree_free(tree);
+		return isl_union_map_from_domain(domain);
+	}
+
+	umap = isl_schedule_tree_get_subtree_schedule_union_map(tree);
+	isl_schedule_tree_free(tree);
+	return umap;
+}
+
+/* Return the number of ancestors of "node" in its schedule tree.
+ */
+isl_size isl_schedule_node_get_tree_depth(__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return isl_size_error;
+	return isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+}
+
+/* Does "node" have a parent?
+ *
+ * That is, does it point to any node of the schedule other than the root?
+ */
+isl_bool isl_schedule_node_has_parent(__isl_keep isl_schedule_node *node)
+{
+	isl_size depth;
+
+	depth = isl_schedule_node_get_tree_depth(node);
+	if (depth < 0)
+		return isl_bool_error;
+	return isl_bool_ok(depth != 0);
+}
+
+/* Return the position of "node" among the children of its parent.
+ */
+isl_size isl_schedule_node_get_child_position(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	isl_bool has_parent;
+
+	if (!node)
+		return isl_size_error;
+	has_parent = isl_schedule_node_has_parent(node);
+	if (has_parent < 0)
+		return isl_size_error;
+	if (!has_parent)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no parent", return isl_size_error);
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	return n < 0 ? isl_size_error : node->child_posn - 1;
+}
+
+/* Does the parent (if any) of "node" have any children with a smaller child
+ * position than this one?
+ */
+isl_bool isl_schedule_node_has_previous_sibling(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	isl_bool has_parent;
+
+	if (!node)
+		return isl_bool_error;
+	has_parent = isl_schedule_node_has_parent(node);
+	if (has_parent < 0 || !has_parent)
+		return has_parent;
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_bool_error;
+
+	return isl_bool_ok(node->child_posn - 1 > 0);
+}
+
+/* Does the parent (if any) of "node" have any children with a greater child
+ * position than this one?
+ */
+isl_bool isl_schedule_node_has_next_sibling(__isl_keep isl_schedule_node *node)
+{
+	isl_size n, n_child;
+	isl_bool has_parent;
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return isl_bool_error;
+	has_parent = isl_schedule_node_has_parent(node);
+	if (has_parent < 0 || !has_parent)
+		return has_parent;
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_bool_error;
+	tree = isl_schedule_tree_list_get_schedule_tree(node->ancestors, n - 1);
+	n_child = isl_schedule_tree_n_children(tree);
+	isl_schedule_tree_free(tree);
+	if (n_child < 0)
+		return isl_bool_error;
+
+	return isl_bool_ok(node->child_posn - 1 + 1 < n_child);
+}
+
+/* Does "node" have any children?
+ *
+ * Any node other than the leaf nodes is considered to have at least
+ * one child, even if the corresponding isl_schedule_tree does not
+ * have any children.
+ */
+isl_bool isl_schedule_node_has_children(__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return isl_bool_error;
+	return isl_bool_ok(!isl_schedule_tree_is_leaf(node->tree));
+}
+
+/* Return the number of children of "node"?
+ *
+ * Any node other than the leaf nodes is considered to have at least
+ * one child, even if the corresponding isl_schedule_tree does not
+ * have any children.  That is, the number of children of "node" is
+ * only zero if its tree is the explicit empty tree.  Otherwise,
+ * if the isl_schedule_tree has any children, then it is equal
+ * to the number of children of "node".  If it has zero children,
+ * then "node" still has a leaf node as child.
+ */
+isl_size isl_schedule_node_n_children(__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+
+	if (!node)
+		return isl_size_error;
+
+	if (isl_schedule_tree_is_leaf(node->tree))
+		return 0;
+
+	n = isl_schedule_tree_n_children(node->tree);
+	if (n < 0)
+		return isl_size_error;
+	if (n == 0)
+		return 1;
+
+	return n;
+}
+
+/* Move the "node" pointer to the ancestor of the given generation
+ * of the node it currently points to, where generation 0 is the node
+ * itself and generation 1 is its parent.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_ancestor(
+	__isl_take isl_schedule_node *node, int generation)
+{
+	isl_size n;
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+	if (generation == 0)
+		return node;
+	n = isl_schedule_node_get_tree_depth(node);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	if (generation < 0 || generation > n)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"generation out of bounds",
+			return isl_schedule_node_free(node));
+	node = isl_schedule_node_cow(node);
+	if (!node)
+		return NULL;
+
+	tree = isl_schedule_tree_list_get_schedule_tree(node->ancestors,
+							n - generation);
+	isl_schedule_tree_free(node->tree);
+	node->tree = tree;
+	node->ancestors = isl_schedule_tree_list_drop(node->ancestors,
+						    n - generation, generation);
+	if (!node->ancestors || !node->tree)
+		return isl_schedule_node_free(node);
+
+	return node;
+}
+
+/* Move the "node" pointer to the parent of the node it currently points to.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_parent(
+	__isl_take isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+	if (!isl_schedule_node_has_parent(node))
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no parent",
+			return isl_schedule_node_free(node));
+	return isl_schedule_node_ancestor(node, 1);
+}
+
+/* Move the "node" pointer to the root of its schedule tree.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_root(
+	__isl_take isl_schedule_node *node)
+{
+	isl_size n;
+
+	if (!node)
+		return NULL;
+	n = isl_schedule_node_get_tree_depth(node);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	return isl_schedule_node_ancestor(node, n);
+}
+
+/* Move the "node" pointer to the child at position "pos" of the node
+ * it currently points to.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_child(
+	__isl_take isl_schedule_node *node, int pos)
+{
+	isl_size n;
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+	int *child_pos;
+
+	node = isl_schedule_node_cow(node);
+	if (!node)
+		return NULL;
+	if (!isl_schedule_node_has_children(node))
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no children",
+			return isl_schedule_node_free(node));
+
+	ctx = isl_schedule_node_get_ctx(node);
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	child_pos = isl_realloc_array(ctx, node->child_pos, int, n + 1);
+	if (!child_pos)
+		return isl_schedule_node_free(node);
+	node->child_pos = child_pos;
+	node->child_posn = pos;
+
+	node->ancestors = isl_schedule_tree_list_add(node->ancestors,
+				isl_schedule_tree_copy(node->tree));
+	tree = node->tree;
+	if (isl_schedule_tree_has_children(tree))
+		tree = isl_schedule_tree_get_child(tree, pos);
+	else
+		tree = isl_schedule_node_get_leaf(node);
+	isl_schedule_tree_free(node->tree);
+	node->tree = tree;
+
+	if (!node->tree || !node->ancestors)
+		return isl_schedule_node_free(node);
+
+	return node;
+}
+
+/* Move the "node" pointer to the first child of the node
+ * it currently points to.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_first_child(
+	__isl_take isl_schedule_node *node)
+{
+	return isl_schedule_node_child(node, 0);
+}
+
+/* Move the "node" pointer to the child of this node's parent in
+ * the previous child position.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_previous_sibling(
+	__isl_take isl_schedule_node *node)
+{
+	isl_size n;
+	isl_schedule_tree *parent, *tree;
+
+	node = isl_schedule_node_cow(node);
+	if (!node)
+		return NULL;
+	if (!isl_schedule_node_has_previous_sibling(node))
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no previous sibling",
+			return isl_schedule_node_free(node));
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	parent = isl_schedule_tree_list_get_schedule_tree(node->ancestors,
+									n - 1);
+	if (!parent)
+		return isl_schedule_node_free(node);
+	node->child_posn - 1--;
+	tree = isl_schedule_tree_list_get_schedule_tree(parent->children,
+							node->child_posn - 1);
+	isl_schedule_tree_free(parent);
+	if (!tree)
+		return isl_schedule_node_free(node);
+	isl_schedule_tree_free(node->tree);
+	node->tree = tree;
+
+	return node;
+}
+
+/* Move the "node" pointer to the child of this node's parent in
+ * the next child position.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_next_sibling(
+	__isl_take isl_schedule_node *node)
+{
+	isl_size n;
+	isl_schedule_tree *parent, *tree;
+
+	node = isl_schedule_node_cow(node);
+	if (!node)
+		return NULL;
+	if (!isl_schedule_node_has_next_sibling(node))
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"node has no next sibling",
+			return isl_schedule_node_free(node));
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	parent = isl_schedule_tree_list_get_schedule_tree(node->ancestors,
+									n - 1);
+	if (!parent)
+		return isl_schedule_node_free(node);
+	node->child_posn - 1++;
+	tree = isl_schedule_tree_list_get_schedule_tree(parent->children,
+							node->child_posn - 1);
+	isl_schedule_tree_free(parent);
+	if (!tree)
+		return isl_schedule_node_free(node);
+	isl_schedule_tree_free(node->tree);
+	node->tree = tree;
+
+	return node;
+}
+
+/* Return a copy to the child at position "pos" of "node".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_get_child(
+	__isl_keep isl_schedule_node *node, int pos)
+{
+	return isl_schedule_node_child(isl_schedule_node_copy(node), pos);
+}
+
+/* Traverse the descendant of "node" in depth-first order, including
+ * "node" itself.  Call "enter" whenever a node is entered and "leave"
+ * whenever a node is left.  The callback "enter" is responsible
+ * for moving to the deepest initial subtree of its argument that
+ * should be traversed.
+ */
+static __isl_give isl_schedule_node *traverse(
+	__isl_take isl_schedule_node *node,
+	__isl_give isl_schedule_node *(*enter)(
+		__isl_take isl_schedule_node *node, void *user),
+	__isl_give isl_schedule_node *(*leave)(
+		__isl_take isl_schedule_node *node, void *user),
+	void *user)
+{
+	isl_size depth;
+	isl_size node_depth;
+
+	depth = isl_schedule_node_get_tree_depth(node);
+	if (depth < 0)
+		return isl_schedule_node_free(node);
+
+	do {
+		node = enter(node, user);
+		node = leave(node, user);
+		while ((node_depth = isl_schedule_node_get_tree_depth(node)) >
+				depth &&
+				!isl_schedule_node_has_next_sibling(node)) {
+			node = isl_schedule_node_parent(node);
+			node = leave(node, user);
+		}
+		if (node_depth < 0)
+			return isl_schedule_node_free(node);
+		if (node_depth > depth)
+			node = isl_schedule_node_next_sibling(node);
+	} while (node_depth > depth);
+
+	return node;
+}
+
+/* Internal data structure for isl_schedule_node_foreach_descendant_top_down.
+ *
+ * "fn" is the user-specified callback function.
+ * "user" is the user-specified argument for the callback.
+ */
+struct isl_schedule_node_preorder_data {
+	isl_bool (*fn)(__isl_keep isl_schedule_node *node, void *user);
+	void *user;
+};
+
+/* Callback for "traverse" to enter a node and to move
+ * to the deepest initial subtree that should be traversed
+ * for use in a preorder visit.
+ *
+ * If the user callback returns a negative value, then we abort
+ * the traversal.  If this callback returns zero, then we skip
+ * the subtree rooted at the current node.  Otherwise, we move
+ * down to the first child and repeat the process until a leaf
+ * is reached.
+ */
+static __isl_give isl_schedule_node *preorder_enter(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_schedule_node_preorder_data *data = user;
+
+	if (!node)
+		return NULL;
+
+	do {
+		isl_bool r;
+
+		r = data->fn(node, data->user);
+		if (r < 0)
+			return isl_schedule_node_free(node);
+		if (r == isl_bool_false)
+			return node;
+	} while (isl_schedule_node_has_children(node) &&
+		(node = isl_schedule_node_first_child(node)) != NULL);
+
+	return node;
+}
+
+/* Callback for "traverse" to leave a node
+ * for use in a preorder visit.
+ * Since we already visited the node when we entered it,
+ * we do not need to do anything here.
+ */
+static __isl_give isl_schedule_node *preorder_leave(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	return node;
+}
+
+/* Traverse the descendants of "node" (including the node itself)
+ * in depth first preorder.
+ *
+ * If "fn" returns isl_bool_error on any of the nodes,
+ * then the traversal is aborted.
+ * If "fn" returns isl_bool_false on any of the nodes, then the subtree rooted
+ * at that node is skipped.
+ *
+ * Return isl_stat_ok on success and isl_stat_error on failure.
+ */
+isl_stat isl_schedule_node_foreach_descendant_top_down(
+	__isl_keep isl_schedule_node *node,
+	isl_bool (*fn)(__isl_keep isl_schedule_node *node, void *user),
+	void *user)
+{
+	struct isl_schedule_node_preorder_data data = { fn, user };
+
+	node = isl_schedule_node_copy(node);
+	node = traverse(node, &preorder_enter, &preorder_leave, &data);
+	isl_schedule_node_free(node);
+
+	return node ? isl_stat_ok : isl_stat_error;
+}
+
+/* Internal data structure for isl_schedule_node_every_descendant.
+ *
+ * "test" is the user-specified callback function.
+ * "user" is the user-specified callback function argument.
+ *
+ * "failed" is initialized to 0 and set to 1 if "test" fails
+ * on any node.
+ */
+struct isl_union_map_every_data {
+	isl_bool (*test)(__isl_keep isl_schedule_node *node, void *user);
+	void *user;
+	int failed;
+};
+
+/* isl_schedule_node_foreach_descendant_top_down callback
+ * that sets data->failed if data->test returns false and
+ * subsequently aborts the traversal.
+ */
+static isl_bool call_every(__isl_keep isl_schedule_node *node, void *user)
+{
+	struct isl_union_map_every_data *data = user;
+	isl_bool r;
+
+	r = data->test(node, data->user);
+	if (r < 0)
+		return isl_bool_error;
+	if (r)
+		return isl_bool_true;
+	data->failed = 1;
+	return isl_bool_error;
+}
+
+/* Does "test" succeed on every descendant of "node" (including "node" itself)?
+ */
+isl_bool isl_schedule_node_every_descendant(__isl_keep isl_schedule_node *node,
+	isl_bool (*test)(__isl_keep isl_schedule_node *node, void *user),
+	void *user)
+{
+	struct isl_union_map_every_data data = { test, user, 0 };
+	isl_stat r;
+
+	r = isl_schedule_node_foreach_descendant_top_down(node, &call_every,
+							&data);
+	if (r >= 0)
+		return isl_bool_true;
+	if (data.failed)
+		return isl_bool_false;
+	return isl_bool_error;
+}
+
+/* Internal data structure for isl_schedule_node_map_descendant_bottom_up.
+ *
+ * "fn" is the user-specified callback function.
+ * "user" is the user-specified argument for the callback.
+ */
+struct isl_schedule_node_postorder_data {
+	__isl_give isl_schedule_node *(*fn)(__isl_take isl_schedule_node *node,
+		void *user);
+	void *user;
+};
+
+/* Callback for "traverse" to enter a node and to move
+ * to the deepest initial subtree that should be traversed
+ * for use in a postorder visit.
+ *
+ * Since we are performing a postorder visit, we only need
+ * to move to the deepest initial leaf here.
+ */
+static __isl_give isl_schedule_node *postorder_enter(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	while (node && isl_schedule_node_has_children(node))
+		node = isl_schedule_node_first_child(node);
+
+	return node;
+}
+
+/* Callback for "traverse" to leave a node
+ * for use in a postorder visit.
+ *
+ * Since we are performing a postorder visit, we need
+ * to call the user callback here.
+ */
+static __isl_give isl_schedule_node *postorder_leave(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_schedule_node_postorder_data *data = user;
+
+	return data->fn(node, data->user);
+}
+
+/* Traverse the descendants of "node" (including the node itself)
+ * in depth first postorder, allowing the user to modify the visited node.
+ * The traversal continues from the node returned by the callback function.
+ * It is the responsibility of the user to ensure that this does not
+ * lead to an infinite loop.  It is safest to always return a pointer
+ * to the same position (same ancestors and child positions) as the input node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_map_descendant_bottom_up(
+	__isl_take isl_schedule_node *node,
+	__isl_give isl_schedule_node *(*fn)(__isl_take isl_schedule_node *node,
+		void *user), void *user)
+{
+	struct isl_schedule_node_postorder_data data = { fn, user };
+
+	return traverse(node, &postorder_enter, &postorder_leave, &data);
+}
+
+/* Traverse the ancestors of "node" from the root down to and including
+ * the parent of "node", calling "fn" on each of them.
+ *
+ * If "fn" returns -1 on any of the nodes, then the traversal is aborted.
+ *
+ * Return 0 on success and -1 on failure.
+ */
+isl_stat isl_schedule_node_foreach_ancestor_top_down(
+	__isl_keep isl_schedule_node *node,
+	isl_stat (*fn)(__isl_keep isl_schedule_node *node, void *user),
+	void *user)
+{
+	int i;
+	isl_size n;
+
+	n = isl_schedule_node_get_tree_depth(node);
+	if (n < 0)
+		return isl_stat_error;
+
+	for (i = 0; i < n; ++i) {
+		isl_schedule_node *ancestor;
+		isl_stat r;
+
+		ancestor = isl_schedule_node_copy(node);
+		ancestor = isl_schedule_node_ancestor(ancestor, n - i);
+		r = fn(ancestor, user);
+		isl_schedule_node_free(ancestor);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Is any node in the subtree rooted at "node" anchored?
+ * That is, do any of these nodes reference the outer band nodes?
+ */
+isl_bool isl_schedule_node_is_subtree_anchored(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return isl_bool_error;
+	return isl_schedule_tree_is_subtree_anchored(node->tree);
+}
+
+/* Return the number of members in the given band node.
+ */
+isl_size isl_schedule_node_band_n_member(__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return isl_size_error;
+	return isl_schedule_tree_band_n_member(node->tree);
+}
+
+/* Is the band member at position "pos" of the band node "node"
+ * marked coincident?
+ */
+isl_bool isl_schedule_node_band_member_get_coincident(
+	__isl_keep isl_schedule_node *node, int pos)
+{
+	if (!node)
+		return isl_bool_error;
+	return isl_schedule_tree_band_member_get_coincident(node->tree, pos);
+}
+
+/* Mark the band member at position "pos" the band node "node"
+ * as being coincident or not according to "coincident".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_member_set_coincident(
+	__isl_take isl_schedule_node *node, int pos, int coincident)
+{
+	int c;
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+	c = isl_schedule_node_band_member_get_coincident(node, pos);
+	if (c == coincident)
+		return node;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_band_member_set_coincident(tree, pos,
+							    coincident);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Is the band node "node" marked permutable?
+ */
+isl_bool isl_schedule_node_band_get_permutable(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return isl_bool_error;
+
+	return isl_schedule_tree_band_get_permutable(node->tree);
+}
+
+/* Mark the band node "node" permutable or not according to "permutable"?
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_set_permutable(
+	__isl_take isl_schedule_node *node, int permutable)
+{
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+	if (isl_schedule_node_band_get_permutable(node) == permutable)
+		return node;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_band_set_permutable(tree, permutable);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Return the schedule space of the band node.
+ */
+__isl_give isl_space *isl_schedule_node_band_get_space(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_band_get_space(node->tree);
+}
+
+/* Return the schedule of the band node in isolation.
+ */
+__isl_give isl_multi_union_pw_aff *isl_schedule_node_band_get_partial_schedule(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_band_get_partial_schedule(node->tree);
+}
+
+/* Return the schedule of the band node in isolation in the form of
+ * an isl_union_map.
+ *
+ * If the band does not have any members, then we construct a universe map
+ * with the universe of the domain elements reaching the node as domain.
+ * Otherwise, we extract an isl_multi_union_pw_aff representation and
+ * convert that to an isl_union_map.
+ */
+__isl_give isl_union_map *isl_schedule_node_band_get_partial_schedule_union_map(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+	isl_multi_union_pw_aff *mupa;
+
+	if (!node)
+		return NULL;
+
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_band)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a band node", return NULL);
+	n = isl_schedule_node_band_n_member(node);
+	if (n < 0)
+		return NULL;
+	if (n == 0) {
+		isl_union_set *domain;
+
+		domain = isl_schedule_node_get_universe_domain(node);
+		return isl_union_map_from_domain(domain);
+	}
+
+	mupa = isl_schedule_node_band_get_partial_schedule(node);
+	return isl_union_map_from_multi_union_pw_aff(mupa);
+}
+
+/* Return the loop AST generation type for the band member of band node "node"
+ * at position "pos".
+ */
+enum isl_ast_loop_type isl_schedule_node_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_node *node, int pos)
+{
+	if (!node)
+		return isl_ast_loop_error;
+
+	return isl_schedule_tree_band_member_get_ast_loop_type(node->tree, pos);
+}
+
+/* Set the loop AST generation type for the band member of band node "node"
+ * at position "pos" to "type".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_node *node, int pos,
+	enum isl_ast_loop_type type)
+{
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_band_member_set_ast_loop_type(tree, pos, type);
+	return isl_schedule_node_graft_tree(node, tree);
+}
+
+/* Return the loop AST generation type for the band member of band node "node"
+ * at position "pos" for the isolated part.
+ */
+enum isl_ast_loop_type isl_schedule_node_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_node *node, int pos)
+{
+	if (!node)
+		return isl_ast_loop_error;
+
+	return isl_schedule_tree_band_member_get_isolate_ast_loop_type(
+							    node->tree, pos);
+}
+
+/* Set the loop AST generation type for the band member of band node "node"
+ * at position "pos" for the isolated part to "type".
+ */
+__isl_give isl_schedule_node *
+isl_schedule_node_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_node *node, int pos,
+	enum isl_ast_loop_type type)
+{
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_band_member_set_isolate_ast_loop_type(tree,
+								    pos, type);
+	return isl_schedule_node_graft_tree(node, tree);
+}
+
+/* Return the AST build options associated to band node "node".
+ */
+__isl_give isl_union_set *isl_schedule_node_band_get_ast_build_options(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_band_get_ast_build_options(node->tree);
+}
+
+/* Replace the AST build options associated to band node "node" by "options".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_set_ast_build_options(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *options)
+{
+	isl_schedule_tree *tree;
+
+	if (!node || !options)
+		goto error;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_band_set_ast_build_options(tree, options);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_schedule_node_free(node);
+	isl_union_set_free(options);
+	return NULL;
+}
+
+/* Return the "isolate" option associated to band node "node".
+ */
+__isl_give isl_set *isl_schedule_node_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_node *node)
+{
+	isl_size depth;
+
+	depth = isl_schedule_node_get_schedule_depth(node);
+	if (depth < 0)
+		return NULL;
+
+	return isl_schedule_tree_band_get_ast_isolate_option(node->tree, depth);
+}
+
+/* Make sure that that spaces of "node" and "mv" are the same.
+ * Return -1 on error, reporting the error to the user.
+ */
+static int check_space_multi_val(__isl_keep isl_schedule_node *node,
+	__isl_keep isl_multi_val *mv)
+{
+	isl_space *node_space, *mv_space;
+	int equal;
+
+	node_space = isl_schedule_node_band_get_space(node);
+	mv_space = isl_multi_val_get_space(mv);
+	equal = isl_space_tuple_is_equal(node_space, isl_dim_set,
+					mv_space, isl_dim_set);
+	isl_space_free(mv_space);
+	isl_space_free(node_space);
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"spaces don't match", return -1);
+
+	return 0;
+}
+
+/* Multiply the partial schedule of the band node "node"
+ * with the factors in "mv".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_scale(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv)
+{
+	isl_schedule_tree *tree;
+	int anchored;
+
+	if (!node || !mv)
+		goto error;
+	if (check_space_multi_val(node, mv) < 0)
+		goto error;
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot scale band node with anchored subtree",
+			goto error);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_scale(tree, mv);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_multi_val_free(mv);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Divide the partial schedule of the band node "node"
+ * by the factors in "mv".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_scale_down(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv)
+{
+	isl_schedule_tree *tree;
+	int anchored;
+
+	if (!node || !mv)
+		goto error;
+	if (check_space_multi_val(node, mv) < 0)
+		goto error;
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot scale down band node with anchored subtree",
+			goto error);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_scale_down(tree, mv);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_multi_val_free(mv);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Reduce the partial schedule of the band node "node"
+ * modulo the factors in "mv".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_mod(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *mv)
+{
+	isl_schedule_tree *tree;
+	isl_bool anchored;
+
+	if (!node || !mv)
+		goto error;
+	if (check_space_multi_val(node, mv) < 0)
+		goto error;
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot perform mod on band node with anchored subtree",
+			goto error);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_mod(tree, mv);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_multi_val_free(mv);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Make sure that that spaces of "node" and "mupa" are the same.
+ * Return isl_stat_error on error, reporting the error to the user.
+ */
+static isl_stat check_space_multi_union_pw_aff(
+	__isl_keep isl_schedule_node *node,
+	__isl_keep isl_multi_union_pw_aff *mupa)
+{
+	isl_space *node_space, *mupa_space;
+	isl_bool equal;
+
+	node_space = isl_schedule_node_band_get_space(node);
+	mupa_space = isl_multi_union_pw_aff_get_space(mupa);
+	equal = isl_space_tuple_is_equal(node_space, isl_dim_set,
+					mupa_space, isl_dim_set);
+	isl_space_free(mupa_space);
+	isl_space_free(node_space);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"spaces don't match", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Shift the partial schedule of the band node "node" by "shift".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_shift(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_multi_union_pw_aff *shift)
+{
+	isl_schedule_tree *tree;
+	int anchored;
+
+	if (!node || !shift)
+		goto error;
+	if (check_space_multi_union_pw_aff(node, shift) < 0)
+		goto error;
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot shift band node with anchored subtree",
+			goto error);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_shift(tree, shift);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_multi_union_pw_aff_free(shift);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Tile "node" with tile sizes "sizes".
+ *
+ * The current node is replaced by two nested nodes corresponding
+ * to the tile dimensions and the point dimensions.
+ *
+ * Return a pointer to the outer (tile) node.
+ *
+ * If any of the descendants of "node" depend on the set of outer band nodes,
+ * then we refuse to tile the node.
+ *
+ * If the scale tile loops option is set, then the tile loops
+ * are scaled by the tile sizes.  If the shift point loops option is set,
+ * then the point loops are shifted to start at zero.
+ * In particular, these options affect the tile and point loop schedules
+ * as follows
+ *
+ *	scale	shift	original	tile		point
+ *
+ *	0	0	i		floor(i/s)	i
+ *	1	0	i		s * floor(i/s)	i
+ *	0	1	i		floor(i/s)	i - s * floor(i/s)
+ *	1	1	i		s * floor(i/s)	i - s * floor(i/s)
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_tile(
+	__isl_take isl_schedule_node *node, __isl_take isl_multi_val *sizes)
+{
+	isl_schedule_tree *tree;
+	int anchored;
+
+	if (!node || !sizes)
+		goto error;
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot tile band node with anchored subtree",
+			goto error);
+
+	if (check_space_multi_val(node, sizes) < 0)
+		goto error;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_tile(tree, sizes);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_multi_val_free(sizes);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Move the band node "node" down to all the leaves in the subtree
+ * rooted at "node".
+ * Return a pointer to the node in the resulting tree that is in the same
+ * position as the node pointed to by "node" in the original tree.
+ *
+ * If the node only has a leaf child, then nothing needs to be done.
+ * Otherwise, the child of the node is removed and the result is
+ * appended to all the leaves in the subtree rooted at the original child.
+ * Since the node is moved to the leaves, it needs to be expanded
+ * according to the expansion, if any, defined by that subtree.
+ * In the end, the original node is replaced by the result of
+ * attaching copies of the expanded node to the leaves.
+ *
+ * If any of the nodes in the subtree rooted at "node" depend on
+ * the set of outer band nodes then we refuse to sink the band node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_sink(
+	__isl_take isl_schedule_node *node)
+{
+	enum isl_schedule_node_type type;
+	isl_schedule_tree *tree, *child;
+	isl_union_pw_multi_aff *contraction;
+	isl_bool anchored;
+	isl_size n;
+
+	if (!node)
+		return NULL;
+
+	type = isl_schedule_node_get_type(node);
+	if (type != isl_schedule_node_band)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a band node", return isl_schedule_node_free(node));
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		return isl_schedule_node_free(node);
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot sink band node in anchored subtree",
+			return isl_schedule_node_free(node));
+	n = isl_schedule_tree_n_children(node->tree);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	if (n == 0)
+		return node;
+
+	contraction = isl_schedule_node_get_subtree_contraction(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	child = isl_schedule_tree_get_child(tree, 0);
+	tree = isl_schedule_tree_reset_children(tree);
+	tree = isl_schedule_tree_pullback_union_pw_multi_aff(tree, contraction);
+	tree = isl_schedule_tree_append_to_leaves(child, tree);
+
+	return isl_schedule_node_graft_tree(node, tree);
+}
+
+/* Split "node" into two nested band nodes, one with the first "pos"
+ * dimensions and one with the remaining dimensions.
+ * The schedules of the two band nodes live in anonymous spaces.
+ * The loop AST generation type options and the isolate option
+ * are split over the two band nodes.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_split(
+	__isl_take isl_schedule_node *node, int pos)
+{
+	isl_size depth;
+	isl_schedule_tree *tree;
+
+	depth = isl_schedule_node_get_schedule_depth(node);
+	if (depth < 0)
+		return isl_schedule_node_free(node);
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_split(tree, pos, depth);
+	return isl_schedule_node_graft_tree(node, tree);
+}
+
+/* Return the context of the context node "node".
+ */
+__isl_give isl_set *isl_schedule_node_context_get_context(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_context_get_context(node->tree);
+}
+
+/* Return the domain of the domain node "node".
+ */
+__isl_give isl_union_set *isl_schedule_node_domain_get_domain(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_domain_get_domain(node->tree);
+}
+
+/* Return the expansion map of expansion node "node".
+ */
+__isl_give isl_union_map *isl_schedule_node_expansion_get_expansion(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_expansion_get_expansion(node->tree);
+}
+
+/* Return the contraction of expansion node "node".
+ */
+__isl_give isl_union_pw_multi_aff *isl_schedule_node_expansion_get_contraction(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_expansion_get_contraction(node->tree);
+}
+
+/* Replace the contraction and the expansion of the expansion node "node"
+ * by "contraction" and "expansion".
+ */
+__isl_give isl_schedule_node *
+isl_schedule_node_expansion_set_contraction_and_expansion(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion)
+{
+	isl_schedule_tree *tree;
+
+	if (!node || !contraction || !expansion)
+		goto error;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_expansion_set_contraction_and_expansion(tree,
+							contraction, expansion);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_schedule_node_free(node);
+	isl_union_pw_multi_aff_free(contraction);
+	isl_union_map_free(expansion);
+	return NULL;
+}
+
+/* Return the extension of the extension node "node".
+ */
+__isl_give isl_union_map *isl_schedule_node_extension_get_extension(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_extension_get_extension(node->tree);
+}
+
+/* Replace the extension of extension node "node" by "extension".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_extension_set_extension(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_map *extension)
+{
+	isl_schedule_tree *tree;
+
+	if (!node || !extension)
+		goto error;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_extension_set_extension(tree, extension);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_schedule_node_free(node);
+	isl_union_map_free(extension);
+	return NULL;
+}
+
+/* Return the filter of the filter node "node".
+ */
+__isl_give isl_union_set *isl_schedule_node_filter_get_filter(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_filter_get_filter(node->tree);
+}
+
+/* Replace the filter of filter node "node" by "filter".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_filter_set_filter(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter)
+{
+	isl_schedule_tree *tree;
+
+	if (!node || !filter)
+		goto error;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	tree = isl_schedule_tree_filter_set_filter(tree, filter);
+	return isl_schedule_node_graft_tree(node, tree);
+error:
+	isl_schedule_node_free(node);
+	isl_union_set_free(filter);
+	return NULL;
+}
+
+/* Intersect the filter of filter node "node" with "filter".
+ *
+ * If the filter of the node is already a subset of "filter",
+ * then leave the node unchanged.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_filter_intersect_filter(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter)
+{
+	isl_union_set *node_filter = NULL;
+	isl_bool subset;
+
+	if (!node || !filter)
+		goto error;
+
+	node_filter = isl_schedule_node_filter_get_filter(node);
+	subset = isl_union_set_is_subset(node_filter, filter);
+	if (subset < 0)
+		goto error;
+	if (subset) {
+		isl_union_set_free(node_filter);
+		isl_union_set_free(filter);
+		return node;
+	}
+	node_filter = isl_union_set_intersect(node_filter, filter);
+	node = isl_schedule_node_filter_set_filter(node, node_filter);
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_union_set_free(node_filter);
+	isl_union_set_free(filter);
+	return NULL;
+}
+
+/* Return the guard of the guard node "node".
+ */
+__isl_give isl_set *isl_schedule_node_guard_get_guard(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_guard_get_guard(node->tree);
+}
+
+/* Return the mark identifier of the mark node "node".
+ */
+__isl_give isl_id *isl_schedule_node_mark_get_id(
+	__isl_keep isl_schedule_node *node)
+{
+	if (!node)
+		return NULL;
+
+	return isl_schedule_tree_mark_get_id(node->tree);
+}
+
+/* Replace the child at position "pos" of the sequence node "node"
+ * by the children of sequence root node of "tree".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_sequence_splice(
+	__isl_take isl_schedule_node *node, int pos,
+	__isl_take isl_schedule_tree *tree)
+{
+	isl_schedule_tree *node_tree;
+
+	if (!node || !tree)
+		goto error;
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a sequence node", goto error);
+	if (isl_schedule_tree_get_type(tree) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a sequence node", goto error);
+	node_tree = isl_schedule_node_get_tree(node);
+	node_tree = isl_schedule_tree_sequence_splice(node_tree, pos, tree);
+	node = isl_schedule_node_graft_tree(node, node_tree);
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Given a sequence node "node", with a child at position "pos" that
+ * is also a sequence node, attach the children of that node directly
+ * as children of "node" at that position, replacing the original child.
+ *
+ * The filters of these children are intersected with the filter
+ * of the child at position "pos".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_sequence_splice_child(
+	__isl_take isl_schedule_node *node, int pos)
+{
+	int i;
+	isl_size n;
+	isl_union_set *filter;
+	isl_schedule_node *child;
+	isl_schedule_tree *tree;
+
+	if (!node)
+		return NULL;
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a sequence node",
+			return isl_schedule_node_free(node));
+	node = isl_schedule_node_child(node, pos);
+	node = isl_schedule_node_child(node, 0);
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a sequence node",
+			return isl_schedule_node_free(node));
+	n = isl_schedule_node_n_children(node);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	child = isl_schedule_node_copy(node);
+	node = isl_schedule_node_parent(node);
+	filter = isl_schedule_node_filter_get_filter(node);
+	for (i = 0; i < n; ++i) {
+		child = isl_schedule_node_child(child, i);
+		child = isl_schedule_node_filter_intersect_filter(child,
+						isl_union_set_copy(filter));
+		child = isl_schedule_node_parent(child);
+	}
+	isl_union_set_free(filter);
+	tree = isl_schedule_node_get_tree(child);
+	isl_schedule_node_free(child);
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_sequence_splice(node, pos, tree);
+
+	return node;
+}
+
+/* Update the ancestors of "node" to point to the tree that "node"
+ * now points to.
+ * That is, replace the child in the original parent that corresponds
+ * to the current tree position by node->tree and continue updating
+ * the ancestors in the same way until the root is reached.
+ *
+ * If "fn" is not NULL, then it is called on each ancestor as we move up
+ * the tree so that it can modify the ancestor before it is added
+ * to the list of ancestors of the modified node.
+ * The additional "pos" argument records the position
+ * of the "tree" argument in the original schedule tree.
+ *
+ * If "node" originally points to a leaf of the schedule tree, then make sure
+ * that in the end it points to a leaf in the updated schedule tree.
+ */
+static __isl_give isl_schedule_node *update_ancestors(
+	__isl_take isl_schedule_node *node,
+	__isl_give isl_schedule_tree *(*fn)(__isl_take isl_schedule_tree *tree,
+		__isl_keep isl_schedule_node *pos, void *user), void *user)
+{
+	int i;
+	isl_size n;
+	int is_leaf;
+	isl_schedule_tree *tree;
+	isl_schedule_node *pos = NULL;
+
+	if (fn)
+		pos = isl_schedule_node_copy(node);
+
+	node = isl_schedule_node_cow(node);
+	if (!node)
+		return isl_schedule_node_free(pos);
+
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_schedule_node_free(pos);
+	tree = isl_schedule_tree_copy(node->tree);
+
+	for (i = n - 1; i >= 0; --i) {
+		isl_schedule_tree *parent;
+
+		parent = isl_schedule_tree_list_get_schedule_tree(
+						    node->ancestors, i);
+		parent = isl_schedule_tree_replace_child(parent,
+						    node->child_posi, tree);
+		if (fn) {
+			pos = isl_schedule_node_parent(pos);
+			parent = fn(parent, pos, user);
+		}
+		node->ancestors = isl_schedule_tree_list_set_schedule_tree(
+			    node->ancestors, i, isl_schedule_tree_copy(parent));
+
+		tree = parent;
+	}
+
+	if (fn)
+		isl_schedule_node_free(pos);
+
+	is_leaf = isl_schedule_tree_is_leaf(node->tree);
+	node->schedule = isl_schedule_set_root(node->schedule, tree);
+	if (is_leaf) {
+		isl_schedule_tree_free(node->tree);
+		node->tree = isl_schedule_node_get_leaf(node);
+	}
+
+	if (!node->schedule || !node->ancestors)
+		return isl_schedule_node_free(node);
+
+	return node;
+}
+
+/* Replace the subtree that "pos" points to by "tree", updating
+ * the ancestors to maintain a consistent state.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_graft_tree(
+	__isl_take isl_schedule_node *pos, __isl_take isl_schedule_tree *tree)
+{
+	if (!tree || !pos)
+		goto error;
+	if (pos->tree == tree) {
+		isl_schedule_tree_free(tree);
+		return pos;
+	}
+
+	pos = isl_schedule_node_cow(pos);
+	if (!pos)
+		goto error;
+
+	isl_schedule_tree_free(pos->tree);
+	pos->tree = tree;
+
+	return update_ancestors(pos, NULL, NULL);
+error:
+	isl_schedule_node_free(pos);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Make sure we can insert a node between "node" and its parent.
+ * Return -1 on error, reporting the reason why we cannot insert a node.
+ */
+static int check_insert(__isl_keep isl_schedule_node *node)
+{
+	int has_parent;
+	enum isl_schedule_node_type type;
+
+	has_parent = isl_schedule_node_has_parent(node);
+	if (has_parent < 0)
+		return -1;
+	if (!has_parent)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot insert node outside of root", return -1);
+
+	type = isl_schedule_node_get_parent_type(node);
+	if (type == isl_schedule_node_error)
+		return -1;
+	if (type == isl_schedule_node_set || type == isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot insert node between set or sequence node "
+			"and its filter children", return -1);
+
+	return 0;
+}
+
+/* Insert a band node with partial schedule "mupa" between "node" and
+ * its parent.
+ * Return a pointer to the new band node.
+ *
+ * If any of the nodes in the subtree rooted at "node" depend on
+ * the set of outer band nodes then we refuse to insert the band node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_partial_schedule(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	int anchored;
+	isl_schedule_band *band;
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (anchored < 0)
+		goto error;
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot insert band node in anchored subtree",
+			goto error);
+
+	tree = isl_schedule_node_get_tree(node);
+	band = isl_schedule_band_from_multi_union_pw_aff(mupa);
+	tree = isl_schedule_tree_insert_band(tree, band);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_multi_union_pw_aff_free(mupa);
+	return NULL;
+}
+
+/* Insert a context node with context "context" between "node" and its parent.
+ * Return a pointer to the new context node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_context(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *context)
+{
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_context(tree, context);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Insert an expansion node with the given "contraction" and "expansion"
+ * between "node" and its parent.
+ * Return a pointer to the new expansion node.
+ *
+ * Typically the domain and range spaces of the expansion are different.
+ * This means that only one of them can refer to the current domain space
+ * in a consistent tree.  It is up to the caller to ensure that the tree
+ * returns to a consistent state.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_expansion(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion)
+{
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_expansion(tree, contraction, expansion);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Insert an extension node with extension "extension" between "node" and
+ * its parent.
+ * Return a pointer to the new extension node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_extension(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *extension)
+{
+	isl_schedule_tree *tree;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_extension(tree, extension);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Insert a filter node with filter "filter" between "node" and its parent.
+ * Return a pointer to the new filter node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_filter(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter)
+{
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_filter(tree, filter);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Insert a guard node with guard "guard" between "node" and its parent.
+ * Return a pointer to the new guard node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_guard(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *guard)
+{
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_guard(tree, guard);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Insert a mark node with mark identifier "mark" between "node" and
+ * its parent.
+ * Return a pointer to the new mark node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_mark(
+	__isl_take isl_schedule_node *node, __isl_take isl_id *mark)
+{
+	isl_schedule_tree *tree;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_insert_mark(tree, mark);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Attach the current subtree of "node" to a sequence of filter tree nodes
+ * with filters described by "filters", attach this sequence
+ * of filter tree nodes as children to a new tree of type "type" and
+ * replace the original subtree of "node" by this new tree.
+ * Each copy of the original subtree is simplified with respect
+ * to the corresponding filter.
+ */
+static __isl_give isl_schedule_node *isl_schedule_node_insert_children(
+	__isl_take isl_schedule_node *node,
+	enum isl_schedule_node_type type,
+	__isl_take isl_union_set_list *filters)
+{
+	int i;
+	isl_size n;
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+	isl_schedule_tree_list *list;
+
+	if (check_insert(node) < 0)
+		node = isl_schedule_node_free(node);
+
+	n = isl_union_set_list_n_union_set(filters);
+	if (!node || n < 0)
+		goto error;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	list = isl_schedule_tree_list_alloc(ctx, n);
+	for (i = 0; i < n; ++i) {
+		isl_schedule_node *node_i;
+		isl_schedule_tree *tree;
+		isl_union_set *filter;
+
+		filter = isl_union_set_list_get_union_set(filters, i);
+		node_i = isl_schedule_node_copy(node);
+		node_i = isl_schedule_node_gist(node_i,
+						isl_union_set_copy(filter));
+		tree = isl_schedule_node_get_tree(node_i);
+		isl_schedule_node_free(node_i);
+		tree = isl_schedule_tree_insert_filter(tree, filter);
+		list = isl_schedule_tree_list_add(list, tree);
+	}
+	tree = isl_schedule_tree_from_children(type, list);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	isl_union_set_list_free(filters);
+	return node;
+error:
+	isl_union_set_list_free(filters);
+	isl_schedule_node_free(node);
+	return NULL;
+}
+
+/* Insert a sequence node with child filters "filters" between "node" and
+ * its parent.  That is, the tree that "node" points to is attached
+ * to each of the child nodes of the filter nodes.
+ * Return a pointer to the new sequence node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_sequence(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_set_list *filters)
+{
+	return isl_schedule_node_insert_children(node,
+					isl_schedule_node_sequence, filters);
+}
+
+/* Insert a set node with child filters "filters" between "node" and
+ * its parent.  That is, the tree that "node" points to is attached
+ * to each of the child nodes of the filter nodes.
+ * Return a pointer to the new set node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_insert_set(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_set_list *filters)
+{
+	return isl_schedule_node_insert_children(node,
+					isl_schedule_node_set, filters);
+}
+
+/* Remove "node" from its schedule tree and return a pointer
+ * to the leaf at the same position in the updated schedule tree.
+ *
+ * It is not allowed to remove the root of a schedule tree or
+ * a child of a set or sequence node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_cut(
+	__isl_take isl_schedule_node *node)
+{
+	isl_schedule_tree *leaf;
+	enum isl_schedule_node_type parent_type;
+
+	if (!node)
+		return NULL;
+	if (!isl_schedule_node_has_parent(node))
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot cut root", return isl_schedule_node_free(node));
+
+	parent_type = isl_schedule_node_get_parent_type(node);
+	if (parent_type == isl_schedule_node_set ||
+	    parent_type == isl_schedule_node_sequence)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot cut child of set or sequence",
+			return isl_schedule_node_free(node));
+
+	leaf = isl_schedule_node_get_leaf(node);
+	return isl_schedule_node_graft_tree(node, leaf);
+}
+
+/* Remove a single node from the schedule tree, attaching the child
+ * of "node" directly to its parent.
+ * Return a pointer to this former child or to the leaf the position
+ * of the original node if there was no child.
+ * It is not allowed to remove the root of a schedule tree,
+ * a set or sequence node, a child of a set or sequence node or
+ * a band node with an anchored subtree.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_delete(
+	__isl_take isl_schedule_node *node)
+{
+	isl_size n, depth;
+	isl_schedule_tree *tree;
+	enum isl_schedule_node_type type;
+
+	depth = isl_schedule_node_get_tree_depth(node);
+	n = isl_schedule_node_n_children(node);
+	if (depth < 0 || n < 0)
+		return isl_schedule_node_free(node);
+
+	if (depth == 0)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot delete root node",
+			return isl_schedule_node_free(node));
+	if (n != 1)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"can only delete node with a single child",
+			return isl_schedule_node_free(node));
+	type = isl_schedule_node_get_parent_type(node);
+	if (type == isl_schedule_node_sequence || type == isl_schedule_node_set)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"cannot delete child of set or sequence",
+			return isl_schedule_node_free(node));
+	if (isl_schedule_node_get_type(node) == isl_schedule_node_band) {
+		int anchored;
+
+		anchored = isl_schedule_node_is_subtree_anchored(node);
+		if (anchored < 0)
+			return isl_schedule_node_free(node);
+		if (anchored)
+			isl_die(isl_schedule_node_get_ctx(node),
+				isl_error_invalid,
+				"cannot delete band node with anchored subtree",
+				return isl_schedule_node_free(node));
+	}
+
+	tree = isl_schedule_node_get_tree(node);
+	if (!tree || isl_schedule_tree_has_children(tree)) {
+		tree = isl_schedule_tree_child(tree, 0);
+	} else {
+		isl_schedule_tree_free(tree);
+		tree = isl_schedule_node_get_leaf(node);
+	}
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Internal data structure for the group_ancestor callback.
+ *
+ * If "finished" is set, then we no longer need to modify
+ * any further ancestors.
+ *
+ * "contraction" and "expansion" represent the expansion
+ * that reflects the grouping.
+ *
+ * "domain" contains the domain elements that reach the position
+ * where the grouping is performed.  That is, it is the range
+ * of the resulting expansion.
+ * "domain_universe" is the universe of "domain".
+ * "group" is the set of group elements, i.e., the domain
+ * of the resulting expansion.
+ * "group_universe" is the universe of "group".
+ *
+ * "sched" is the schedule for the group elements, in pratice
+ * an identity mapping on "group_universe".
+ * "dim" is the dimension of "sched".
+ */
+struct isl_schedule_group_data {
+	int finished;
+
+	isl_union_map *expansion;
+	isl_union_pw_multi_aff *contraction;
+
+	isl_union_set *domain;
+	isl_union_set *domain_universe;
+	isl_union_set *group;
+	isl_union_set *group_universe;
+
+	int dim;
+	isl_multi_aff *sched;
+};
+
+/* Is domain covered by data->domain within data->domain_universe?
+ */
+static isl_bool locally_covered_by_domain(__isl_keep isl_union_set *domain,
+	struct isl_schedule_group_data *data)
+{
+	isl_bool is_subset;
+	isl_union_set *test;
+
+	test = isl_union_set_copy(domain);
+	test = isl_union_set_intersect(test,
+			    isl_union_set_copy(data->domain_universe));
+	is_subset = isl_union_set_is_subset(test, data->domain);
+	isl_union_set_free(test);
+
+	return is_subset;
+}
+
+/* Update the band tree root "tree" to refer to the group instances
+ * in data->group rather than the original domain elements in data->domain.
+ * "pos" is the position in the original schedule tree where the modified
+ * "tree" will be attached.
+ *
+ * Add the part of the identity schedule on the group instances data->sched
+ * that corresponds to this band node to the band schedule.
+ * If the domain elements that reach the node and that are part
+ * of data->domain_universe are all elements of data->domain (and therefore
+ * replaced by the group instances) then this data->domain_universe
+ * is removed from the domain of the band schedule.
+ */
+static __isl_give isl_schedule_tree *group_band(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_node *pos,
+	struct isl_schedule_group_data *data)
+{
+	isl_union_set *domain;
+	isl_multi_aff *ma;
+	isl_multi_union_pw_aff *mupa, *partial;
+	isl_bool is_covered;
+	isl_size depth, n;
+	isl_bool has_id;
+
+	domain = isl_schedule_node_get_domain(pos);
+	is_covered = locally_covered_by_domain(domain, data);
+	if (is_covered >= 0 && is_covered) {
+		domain = isl_union_set_universe(domain);
+		domain = isl_union_set_subtract(domain,
+			    isl_union_set_copy(data->domain_universe));
+		tree = isl_schedule_tree_band_intersect_domain(tree, domain);
+	} else
+		isl_union_set_free(domain);
+	if (is_covered < 0)
+		return isl_schedule_tree_free(tree);
+	depth = isl_schedule_node_get_schedule_depth(pos);
+	n = isl_schedule_tree_band_n_member(tree);
+	if (depth < 0 || n < 0)
+		return isl_schedule_tree_free(tree);
+	ma = isl_multi_aff_copy(data->sched);
+	ma = isl_multi_aff_drop_dims(ma, isl_dim_out, 0, depth);
+	ma = isl_multi_aff_drop_dims(ma, isl_dim_out, n, data->dim - depth - n);
+	mupa = isl_multi_union_pw_aff_from_multi_aff(ma);
+	partial = isl_schedule_tree_band_get_partial_schedule(tree);
+	has_id = isl_multi_union_pw_aff_has_tuple_id(partial, isl_dim_set);
+	if (has_id < 0) {
+		partial = isl_multi_union_pw_aff_free(partial);
+	} else if (has_id) {
+		isl_id *id;
+		id = isl_multi_union_pw_aff_get_tuple_id(partial, isl_dim_set);
+		mupa = isl_multi_union_pw_aff_set_tuple_id(mupa,
+							    isl_dim_set, id);
+	}
+	partial = isl_multi_union_pw_aff_union_add(partial, mupa);
+	tree = isl_schedule_tree_band_set_partial_schedule(tree, partial);
+
+	return tree;
+}
+
+/* Drop the parameters in "uset" that are not also in "space".
+ * "n" is the number of parameters in "space".
+ */
+static __isl_give isl_union_set *union_set_drop_extra_params(
+	__isl_take isl_union_set *uset, __isl_keep isl_space *space, int n)
+{
+	isl_size n2;
+
+	uset = isl_union_set_align_params(uset, isl_space_copy(space));
+	n2 = isl_union_set_dim(uset, isl_dim_param);
+	if (n2 < 0)
+		return isl_union_set_free(uset);
+	uset = isl_union_set_project_out(uset, isl_dim_param, n, n2 - n);
+
+	return uset;
+}
+
+/* Update the context tree root "tree" to refer to the group instances
+ * in data->group rather than the original domain elements in data->domain.
+ * "pos" is the position in the original schedule tree where the modified
+ * "tree" will be attached.
+ *
+ * We do not actually need to update "tree" since a context node only
+ * refers to the schedule space.  However, we may need to update "data"
+ * to not refer to any parameters introduced by the context node.
+ */
+static __isl_give isl_schedule_tree *group_context(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_node *pos,
+	struct isl_schedule_group_data *data)
+{
+	isl_space *space;
+	isl_union_set *domain;
+	isl_size n1, n2;
+	isl_bool involves;
+	isl_size depth;
+
+	depth = isl_schedule_node_get_tree_depth(pos);
+	if (depth < 0)
+		return isl_schedule_tree_free(tree);
+	if (depth == 1)
+		return tree;
+
+	domain = isl_schedule_node_get_universe_domain(pos);
+	space = isl_union_set_get_space(domain);
+	isl_union_set_free(domain);
+
+	n1 = isl_space_dim(space, isl_dim_param);
+	data->expansion = isl_union_map_align_params(data->expansion, space);
+	n2 = isl_union_map_dim(data->expansion, isl_dim_param);
+
+	if (n1 < 0 || n2 < 0)
+		return isl_schedule_tree_free(tree);
+	if (n1 == n2)
+		return tree;
+
+	involves = isl_union_map_involves_dims(data->expansion,
+				isl_dim_param, n1, n2 - n1);
+	if (involves < 0)
+		return isl_schedule_tree_free(tree);
+	if (involves)
+		isl_die(isl_schedule_node_get_ctx(pos), isl_error_invalid,
+			"grouping cannot only refer to global parameters",
+			return isl_schedule_tree_free(tree));
+
+	data->expansion = isl_union_map_project_out(data->expansion,
+				isl_dim_param, n1, n2 - n1);
+	space = isl_union_map_get_space(data->expansion);
+
+	data->contraction = isl_union_pw_multi_aff_align_params(
+				data->contraction, isl_space_copy(space));
+	n2 = isl_union_pw_multi_aff_dim(data->contraction, isl_dim_param);
+	if (n2 < 0)
+		data->contraction =
+				isl_union_pw_multi_aff_free(data->contraction);
+	data->contraction = isl_union_pw_multi_aff_drop_dims(data->contraction,
+				isl_dim_param, n1, n2 - n1);
+
+	data->domain = union_set_drop_extra_params(data->domain, space, n1);
+	data->domain_universe =
+		union_set_drop_extra_params(data->domain_universe, space, n1);
+	data->group = union_set_drop_extra_params(data->group, space, n1);
+	data->group_universe =
+		union_set_drop_extra_params(data->group_universe, space, n1);
+
+	data->sched = isl_multi_aff_align_params(data->sched,
+				isl_space_copy(space));
+	n2 = isl_multi_aff_dim(data->sched, isl_dim_param);
+	if (n2 < 0)
+		data->sched = isl_multi_aff_free(data->sched);
+	data->sched = isl_multi_aff_drop_dims(data->sched,
+				isl_dim_param, n1, n2 - n1);
+
+	isl_space_free(space);
+
+	return tree;
+}
+
+/* Update the domain tree root "tree" to refer to the group instances
+ * in data->group rather than the original domain elements in data->domain.
+ * "pos" is the position in the original schedule tree where the modified
+ * "tree" will be attached.
+ *
+ * We first double-check that all grouped domain elements are actually
+ * part of the root domain and then replace those elements by the group
+ * instances.
+ */
+static __isl_give isl_schedule_tree *group_domain(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_node *pos,
+	struct isl_schedule_group_data *data)
+{
+	isl_union_set *domain;
+	isl_bool is_subset;
+
+	domain = isl_schedule_tree_domain_get_domain(tree);
+	is_subset = isl_union_set_is_subset(data->domain, domain);
+	isl_union_set_free(domain);
+	if (is_subset < 0)
+		return isl_schedule_tree_free(tree);
+	if (!is_subset)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"grouped domain should be part of outer domain",
+			return isl_schedule_tree_free(tree));
+	domain = isl_schedule_tree_domain_get_domain(tree);
+	domain = isl_union_set_subtract(domain,
+				isl_union_set_copy(data->domain));
+	domain = isl_union_set_union(domain, isl_union_set_copy(data->group));
+	tree = isl_schedule_tree_domain_set_domain(tree, domain);
+
+	return tree;
+}
+
+/* Update the expansion tree root "tree" to refer to the group instances
+ * in data->group rather than the original domain elements in data->domain.
+ * "pos" is the position in the original schedule tree where the modified
+ * "tree" will be attached.
+ *
+ * Let G_1 -> D_1 be the expansion of "tree" and G_2 -> D_2 the newly
+ * introduced expansion in a descendant of "tree".
+ * We first double-check that D_2 is a subset of D_1.
+ * Then we remove D_2 from the range of G_1 -> D_1 and add the mapping
+ * G_1 -> D_1 . D_2 -> G_2.
+ * Simmilarly, we restrict the domain of the contraction to the universe
+ * of the range of the updated expansion and add G_2 -> D_2 . D_1 -> G_1,
+ * attempting to remove the domain constraints of this additional part.
+ */
+static __isl_give isl_schedule_tree *group_expansion(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_node *pos,
+	struct isl_schedule_group_data *data)
+{
+	isl_union_set *domain;
+	isl_union_map *expansion, *umap;
+	isl_union_pw_multi_aff *contraction, *upma;
+	int is_subset;
+
+	expansion = isl_schedule_tree_expansion_get_expansion(tree);
+	domain = isl_union_map_range(expansion);
+	is_subset = isl_union_set_is_subset(data->domain, domain);
+	isl_union_set_free(domain);
+	if (is_subset < 0)
+		return isl_schedule_tree_free(tree);
+	if (!is_subset)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"grouped domain should be part "
+			"of outer expansion domain",
+			return isl_schedule_tree_free(tree));
+	expansion = isl_schedule_tree_expansion_get_expansion(tree);
+	umap = isl_union_map_from_union_pw_multi_aff(
+			isl_union_pw_multi_aff_copy(data->contraction));
+	umap = isl_union_map_apply_range(expansion, umap);
+	expansion = isl_schedule_tree_expansion_get_expansion(tree);
+	expansion = isl_union_map_subtract_range(expansion,
+				isl_union_set_copy(data->domain));
+	expansion = isl_union_map_union(expansion, umap);
+	umap = isl_union_map_universe(isl_union_map_copy(expansion));
+	domain = isl_union_map_range(umap);
+	contraction = isl_schedule_tree_expansion_get_contraction(tree);
+	umap = isl_union_map_from_union_pw_multi_aff(contraction);
+	umap = isl_union_map_apply_range(isl_union_map_copy(data->expansion),
+					umap);
+	upma = isl_union_pw_multi_aff_from_union_map(umap);
+	contraction = isl_schedule_tree_expansion_get_contraction(tree);
+	contraction = isl_union_pw_multi_aff_intersect_domain(contraction,
+								domain);
+	domain = isl_union_pw_multi_aff_domain(
+				isl_union_pw_multi_aff_copy(upma));
+	upma = isl_union_pw_multi_aff_gist(upma, domain);
+	contraction = isl_union_pw_multi_aff_union_add(contraction, upma);
+	tree = isl_schedule_tree_expansion_set_contraction_and_expansion(tree,
+							contraction, expansion);
+
+	return tree;
+}
+
+/* Update the tree root "tree" to refer to the group instances
+ * in data->group rather than the original domain elements in data->domain.
+ * "pos" is the position in the original schedule tree where the modified
+ * "tree" will be attached.
+ *
+ * If we have come across a domain or expansion node before (data->finished
+ * is set), then we no longer need perform any modifications.
+ *
+ * If "tree" is a filter, then we add data->group_universe to the filter.
+ * We also remove data->domain_universe from the filter if all the domain
+ * elements in this universe that reach the filter node are part of
+ * the elements that are being grouped by data->expansion.
+ * If "tree" is a band, domain or expansion, then it is handled
+ * in a separate function.
+ */
+static __isl_give isl_schedule_tree *group_ancestor(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_node *pos,
+	void *user)
+{
+	struct isl_schedule_group_data *data = user;
+	isl_union_set *domain;
+	isl_bool is_covered;
+
+	if (!tree || !pos)
+		return isl_schedule_tree_free(tree);
+
+	if (data->finished)
+		return tree;
+
+	switch (isl_schedule_tree_get_type(tree)) {
+	case isl_schedule_node_error:
+		return isl_schedule_tree_free(tree);
+	case isl_schedule_node_extension:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_unsupported,
+			"grouping not allowed in extended tree",
+			return isl_schedule_tree_free(tree));
+	case isl_schedule_node_band:
+		tree = group_band(tree, pos, data);
+		break;
+	case isl_schedule_node_context:
+		tree = group_context(tree, pos, data);
+		break;
+	case isl_schedule_node_domain:
+		tree = group_domain(tree, pos, data);
+		data->finished = 1;
+		break;
+	case isl_schedule_node_filter:
+		domain = isl_schedule_node_get_domain(pos);
+		is_covered = locally_covered_by_domain(domain, data);
+		isl_union_set_free(domain);
+		if (is_covered < 0)
+			return isl_schedule_tree_free(tree);
+		domain = isl_schedule_tree_filter_get_filter(tree);
+		if (is_covered)
+			domain = isl_union_set_subtract(domain,
+				    isl_union_set_copy(data->domain_universe));
+		domain = isl_union_set_union(domain,
+				    isl_union_set_copy(data->group_universe));
+		tree = isl_schedule_tree_filter_set_filter(tree, domain);
+		break;
+	case isl_schedule_node_expansion:
+		tree = group_expansion(tree, pos, data);
+		data->finished = 1;
+		break;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	}
+
+	return tree;
+}
+
+/* Group the domain elements that reach "node" into instances
+ * of a single statement with identifier "group_id".
+ * In particular, group the domain elements according to their
+ * prefix schedule.
+ *
+ * That is, introduce an expansion node with as contraction
+ * the prefix schedule (with the target space replaced by "group_id")
+ * and as expansion the inverse of this contraction (with its range
+ * intersected with the domain elements that reach "node").
+ * The outer nodes are then modified to refer to the group instances
+ * instead of the original domain elements.
+ *
+ * No instance of "group_id" is allowed to reach "node" prior
+ * to the grouping.
+ * No ancestor of "node" is allowed to be an extension node.
+ *
+ * Return a pointer to original node in tree, i.e., the child
+ * of the newly introduced expansion node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_group(
+	__isl_take isl_schedule_node *node, __isl_take isl_id *group_id)
+{
+	struct isl_schedule_group_data data = { 0 };
+	isl_space *space;
+	isl_union_set *domain;
+	isl_union_pw_multi_aff *contraction;
+	isl_union_map *expansion;
+	isl_bool disjoint;
+	isl_size depth;
+
+	depth = isl_schedule_node_get_schedule_depth(node);
+	if (depth < 0 || !group_id)
+		goto error;
+	if (check_insert(node) < 0)
+		goto error;
+
+	domain = isl_schedule_node_get_domain(node);
+	data.domain = isl_union_set_copy(domain);
+	data.domain_universe = isl_union_set_copy(domain);
+	data.domain_universe = isl_union_set_universe(data.domain_universe);
+
+	data.dim = depth;
+	if (data.dim == 0) {
+		isl_ctx *ctx;
+		isl_set *set;
+		isl_union_set *group;
+		isl_union_map *univ;
+
+		ctx = isl_schedule_node_get_ctx(node);
+		space = isl_space_set_alloc(ctx, 0, 0);
+		space = isl_space_set_tuple_id(space, isl_dim_set, group_id);
+		set = isl_set_universe(isl_space_copy(space));
+		group = isl_union_set_from_set(set);
+		expansion = isl_union_map_from_domain_and_range(domain, group);
+		univ = isl_union_map_universe(isl_union_map_copy(expansion));
+		contraction = isl_union_pw_multi_aff_from_union_map(univ);
+		expansion = isl_union_map_reverse(expansion);
+	} else {
+		isl_multi_union_pw_aff *prefix;
+		isl_union_set *univ;
+
+		prefix =
+		isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(node);
+		prefix = isl_multi_union_pw_aff_set_tuple_id(prefix,
+							isl_dim_set, group_id);
+		space = isl_multi_union_pw_aff_get_space(prefix);
+		contraction = isl_union_pw_multi_aff_from_multi_union_pw_aff(
+							prefix);
+		univ = isl_union_set_universe(isl_union_set_copy(domain));
+		contraction =
+		    isl_union_pw_multi_aff_intersect_domain(contraction, univ);
+		expansion = isl_union_map_from_union_pw_multi_aff(
+				    isl_union_pw_multi_aff_copy(contraction));
+		expansion = isl_union_map_reverse(expansion);
+		expansion = isl_union_map_intersect_range(expansion, domain);
+	}
+	space = isl_space_map_from_set(space);
+	data.sched = isl_multi_aff_identity(space);
+	data.group = isl_union_map_domain(isl_union_map_copy(expansion));
+	data.group = isl_union_set_coalesce(data.group);
+	data.group_universe = isl_union_set_copy(data.group);
+	data.group_universe = isl_union_set_universe(data.group_universe);
+	data.expansion = isl_union_map_copy(expansion);
+	data.contraction = isl_union_pw_multi_aff_copy(contraction);
+	node = isl_schedule_node_insert_expansion(node, contraction, expansion);
+
+	disjoint = isl_union_set_is_disjoint(data.domain_universe,
+					    data.group_universe);
+
+	node = update_ancestors(node, &group_ancestor, &data);
+
+	isl_union_set_free(data.domain);
+	isl_union_set_free(data.domain_universe);
+	isl_union_set_free(data.group);
+	isl_union_set_free(data.group_universe);
+	isl_multi_aff_free(data.sched);
+	isl_union_map_free(data.expansion);
+	isl_union_pw_multi_aff_free(data.contraction);
+
+	node = isl_schedule_node_child(node, 0);
+
+	if (!node || disjoint < 0)
+		return isl_schedule_node_free(node);
+	if (!disjoint)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"group instances already reach node",
+			return isl_schedule_node_free(node));
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_id_free(group_id);
+	return NULL;
+}
+
+/* Compute the gist of the given band node with respect to "context".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_band_gist(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *context)
+{
+	isl_schedule_tree *tree;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_band_gist(tree, context);
+	return isl_schedule_node_graft_tree(node, tree);
+}
+
+/* Internal data structure for isl_schedule_node_gist.
+ * "n_expansion" is the number of outer expansion nodes
+ * with respect to the current position
+ * "filters" contains an element for each outer filter, expansion or
+ * extension node with respect to the current position, each representing
+ * the intersection of the previous element and the filter on the filter node
+ * or the expansion/extension of the previous element.
+ * The first element in the original context passed to isl_schedule_node_gist.
+ */
+struct isl_node_gist_data {
+	int n_expansion;
+	isl_union_set_list *filters;
+};
+
+/* Enter the expansion node "node" during a isl_schedule_node_gist traversal.
+ *
+ * In particular, add an extra element to data->filters containing
+ * the expansion of the previous element and replace the expansion
+ * and contraction on "node" by the gist with respect to these filters.
+ * Also keep track of the fact that we have entered another expansion.
+ */
+static __isl_give isl_schedule_node *gist_enter_expansion(
+	__isl_take isl_schedule_node *node, struct isl_node_gist_data *data)
+{
+	isl_size n;
+	isl_union_set *inner;
+	isl_union_map *expansion;
+	isl_union_pw_multi_aff *contraction;
+
+	data->n_expansion++;
+
+	n = isl_union_set_list_n_union_set(data->filters);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	inner = isl_union_set_list_get_union_set(data->filters, n - 1);
+	expansion = isl_schedule_node_expansion_get_expansion(node);
+	inner = isl_union_set_apply(inner, expansion);
+
+	contraction = isl_schedule_node_expansion_get_contraction(node);
+	contraction = isl_union_pw_multi_aff_gist(contraction,
+						isl_union_set_copy(inner));
+
+	data->filters = isl_union_set_list_add(data->filters, inner);
+
+	inner = isl_union_set_list_get_union_set(data->filters, n - 1);
+	expansion = isl_schedule_node_expansion_get_expansion(node);
+	expansion = isl_union_map_gist_domain(expansion, inner);
+	node = isl_schedule_node_expansion_set_contraction_and_expansion(node,
+						contraction, expansion);
+
+	return node;
+}
+
+/* Leave the expansion node "node" during a isl_schedule_node_gist traversal.
+ *
+ * In particular, remove the element in data->filters that was added by
+ * gist_enter_expansion and decrement the number of outer expansions.
+ *
+ * The expansion has already been simplified in gist_enter_expansion.
+ * If this simplification results in an identity expansion, then
+ * it is removed here.
+ */
+static __isl_give isl_schedule_node *gist_leave_expansion(
+	__isl_take isl_schedule_node *node, struct isl_node_gist_data *data)
+{
+	isl_size n;
+	isl_bool identity;
+	isl_union_map *expansion;
+
+	expansion = isl_schedule_node_expansion_get_expansion(node);
+	identity = isl_union_map_is_identity(expansion);
+	isl_union_map_free(expansion);
+
+	if (identity < 0)
+		node = isl_schedule_node_free(node);
+	else if (identity)
+		node = isl_schedule_node_delete(node);
+
+	n = isl_union_set_list_n_union_set(data->filters);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	data->filters = isl_union_set_list_drop(data->filters, n - 1, 1);
+
+	data->n_expansion--;
+
+	return node;
+}
+
+/* Enter the extension node "node" during a isl_schedule_node_gist traversal.
+ *
+ * In particular, add an extra element to data->filters containing
+ * the union of the previous element with the additional domain elements
+ * introduced by the extension.
+ */
+static __isl_give isl_schedule_node *gist_enter_extension(
+	__isl_take isl_schedule_node *node, struct isl_node_gist_data *data)
+{
+	isl_size n;
+	isl_union_set *inner, *extra;
+	isl_union_map *extension;
+
+	n = isl_union_set_list_n_union_set(data->filters);
+	if (n < 0)
+		return isl_schedule_node_free(node);
+	inner = isl_union_set_list_get_union_set(data->filters, n - 1);
+	extension = isl_schedule_node_extension_get_extension(node);
+	extra = isl_union_map_range(extension);
+	inner = isl_union_set_union(inner, extra);
+
+	data->filters = isl_union_set_list_add(data->filters, inner);
+
+	return node;
+}
+
+/* Can we finish gisting at this node?
+ * That is, is the filter on the current filter node a subset of
+ * the original context passed to isl_schedule_node_gist?
+ * If we have gone through any expansions, then we cannot perform
+ * this test since the current domain elements are incomparable
+ * to the domain elements in the original context.
+ */
+static isl_bool gist_done(__isl_keep isl_schedule_node *node,
+	struct isl_node_gist_data *data)
+{
+	isl_union_set *filter, *outer;
+	isl_bool subset;
+
+	if (data->n_expansion != 0)
+		return isl_bool_false;
+
+	filter = isl_schedule_node_filter_get_filter(node);
+	outer = isl_union_set_list_get_union_set(data->filters, 0);
+	subset = isl_union_set_is_subset(filter, outer);
+	isl_union_set_free(outer);
+	isl_union_set_free(filter);
+
+	return subset;
+}
+
+/* Callback for "traverse" to enter a node and to move
+ * to the deepest initial subtree that should be traversed
+ * by isl_schedule_node_gist.
+ *
+ * The "filters" list is extended by one element each time
+ * we come across a filter node by the result of intersecting
+ * the last element in the list with the filter on the filter node.
+ *
+ * If the filter on the current filter node is a subset of
+ * the original context passed to isl_schedule_node_gist,
+ * then there is no need to go into its subtree since it cannot
+ * be further simplified by the context.  The "filters" list is
+ * still extended for consistency, but the actual value of the
+ * added element is immaterial since it will not be used.
+ *
+ * Otherwise, the filter on the current filter node is replaced by
+ * the gist of the original filter with respect to the intersection
+ * of the original context with the intermediate filters.
+ *
+ * If the new element in the "filters" list is empty, then no elements
+ * can reach the descendants of the current filter node.  The subtree
+ * underneath the filter node is therefore removed.
+ *
+ * Each expansion node we come across is handled by
+ * gist_enter_expansion.
+ *
+ * Each extension node we come across is handled by
+ * gist_enter_extension.
+ */
+static __isl_give isl_schedule_node *gist_enter(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_node_gist_data *data = user;
+
+	do {
+		isl_union_set *filter, *inner;
+		isl_bool done, empty;
+		isl_size n;
+
+		switch (isl_schedule_node_get_type(node)) {
+		case isl_schedule_node_error:
+			return isl_schedule_node_free(node);
+		case isl_schedule_node_expansion:
+			node = gist_enter_expansion(node, data);
+			continue;
+		case isl_schedule_node_extension:
+			node = gist_enter_extension(node, data);
+			continue;
+		case isl_schedule_node_band:
+		case isl_schedule_node_context:
+		case isl_schedule_node_domain:
+		case isl_schedule_node_guard:
+		case isl_schedule_node_leaf:
+		case isl_schedule_node_mark:
+		case isl_schedule_node_sequence:
+		case isl_schedule_node_set:
+			continue;
+		case isl_schedule_node_filter:
+			break;
+		}
+		done = gist_done(node, data);
+		filter = isl_schedule_node_filter_get_filter(node);
+		n = isl_union_set_list_n_union_set(data->filters);
+		if (n < 0 || done < 0 || done) {
+			data->filters = isl_union_set_list_add(data->filters,
+								filter);
+			if (n < 0 || done < 0)
+				return isl_schedule_node_free(node);
+			return node;
+		}
+		inner = isl_union_set_list_get_union_set(data->filters, n - 1);
+		filter = isl_union_set_gist(filter, isl_union_set_copy(inner));
+		node = isl_schedule_node_filter_set_filter(node,
+						isl_union_set_copy(filter));
+		filter = isl_union_set_intersect(filter, inner);
+		empty = isl_union_set_is_empty(filter);
+		data->filters = isl_union_set_list_add(data->filters, filter);
+		if (empty < 0)
+			return isl_schedule_node_free(node);
+		if (!empty)
+			continue;
+		node = isl_schedule_node_child(node, 0);
+		node = isl_schedule_node_cut(node);
+		node = isl_schedule_node_parent(node);
+		return node;
+	} while (isl_schedule_node_has_children(node) &&
+		(node = isl_schedule_node_first_child(node)) != NULL);
+
+	return node;
+}
+
+/* Callback for "traverse" to leave a node for isl_schedule_node_gist.
+ *
+ * In particular, if the current node is a filter node, then we remove
+ * the element on the "filters" list that was added when we entered
+ * the node.  There is no need to compute any gist here, since we
+ * already did that when we entered the node.
+ *
+ * Expansion nodes are handled by gist_leave_expansion.
+ *
+ * If the current node is an extension, then remove the element
+ * in data->filters that was added by gist_enter_extension.
+ *
+ * If the current node is a band node, then we compute the gist of
+ * the band node with respect to the intersection of the original context
+ * and the intermediate filters.
+ *
+ * If the current node is a sequence or set node, then some of
+ * the filter children may have become empty and so they are removed.
+ * If only one child is left, then the set or sequence node along with
+ * the single remaining child filter is removed.  The filter can be
+ * removed because the filters on a sequence or set node are supposed
+ * to partition the incoming domain instances.
+ * In principle, it should then be impossible for there to be zero
+ * remaining children, but should this happen, we replace the entire
+ * subtree with an empty filter.
+ */
+static __isl_give isl_schedule_node *gist_leave(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_node_gist_data *data = user;
+	isl_schedule_tree *tree;
+	int i;
+	isl_size n;
+	isl_union_set *filter;
+
+	switch (isl_schedule_node_get_type(node)) {
+	case isl_schedule_node_error:
+		return isl_schedule_node_free(node);
+	case isl_schedule_node_expansion:
+		node = gist_leave_expansion(node, data);
+		break;
+	case isl_schedule_node_extension:
+	case isl_schedule_node_filter:
+		n = isl_union_set_list_n_union_set(data->filters);
+		if (n < 0)
+			return isl_schedule_node_free(node);
+		data->filters = isl_union_set_list_drop(data->filters,
+							n - 1, 1);
+		break;
+	case isl_schedule_node_band:
+		n = isl_union_set_list_n_union_set(data->filters);
+		if (n < 0)
+			return isl_schedule_node_free(node);
+		filter = isl_union_set_list_get_union_set(data->filters, n - 1);
+		node = isl_schedule_node_band_gist(node, filter);
+		break;
+	case isl_schedule_node_set:
+	case isl_schedule_node_sequence:
+		tree = isl_schedule_node_get_tree(node);
+		n = isl_schedule_tree_n_children(tree);
+		if (n < 0)
+			tree = isl_schedule_tree_free(tree);
+		for (i = n - 1; i >= 0; --i) {
+			isl_schedule_tree *child;
+			isl_union_set *filter;
+			isl_bool empty;
+
+			child = isl_schedule_tree_get_child(tree, i);
+			filter = isl_schedule_tree_filter_get_filter(child);
+			empty = isl_union_set_is_empty(filter);
+			isl_union_set_free(filter);
+			isl_schedule_tree_free(child);
+			if (empty < 0)
+				tree = isl_schedule_tree_free(tree);
+			else if (empty)
+				tree = isl_schedule_tree_drop_child(tree, i);
+		}
+		n = isl_schedule_tree_n_children(tree);
+		if (n < 0)
+			tree = isl_schedule_tree_free(tree);
+		node = isl_schedule_node_graft_tree(node, tree);
+		if (n == 1) {
+			node = isl_schedule_node_delete(node);
+			node = isl_schedule_node_delete(node);
+		} else if (n == 0) {
+			isl_space *space;
+
+			filter =
+			    isl_union_set_list_get_union_set(data->filters, 0);
+			space = isl_union_set_get_space(filter);
+			isl_union_set_free(filter);
+			filter = isl_union_set_empty(space);
+			node = isl_schedule_node_cut(node);
+			node = isl_schedule_node_insert_filter(node, filter);
+		}
+		break;
+	case isl_schedule_node_context:
+	case isl_schedule_node_domain:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_mark:
+		break;
+	}
+
+	return node;
+}
+
+/* Compute the gist of the subtree at "node" with respect to
+ * the reaching domain elements in "context".
+ * In particular, compute the gist of all band and filter nodes
+ * in the subtree with respect to "context".  Children of set or sequence
+ * nodes that end up with an empty filter are removed completely.
+ *
+ * We keep track of the intersection of "context" with all outer filters
+ * of the current node within the subtree in the final element of "filters".
+ * Initially, this list contains the single element "context" and it is
+ * extended or shortened each time we enter or leave a filter node.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_gist(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *context)
+{
+	struct isl_node_gist_data data;
+
+	data.n_expansion = 0;
+	data.filters = isl_union_set_list_from_union_set(context);
+	node = traverse(node, &gist_enter, &gist_leave, &data);
+	isl_union_set_list_free(data.filters);
+	return node;
+}
+
+/* Intersect the domain of domain node "node" with "domain".
+ *
+ * If the domain of "node" is already a subset of "domain",
+ * then nothing needs to be changed.
+ *
+ * Otherwise, we replace the domain of the domain node by the intersection
+ * and simplify the subtree rooted at "node" with respect to this intersection.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_domain_intersect_domain(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *domain)
+{
+	isl_schedule_tree *tree;
+	isl_union_set *uset;
+	int is_subset;
+
+	if (!node || !domain)
+		goto error;
+
+	uset = isl_schedule_tree_domain_get_domain(node->tree);
+	is_subset = isl_union_set_is_subset(uset, domain);
+	isl_union_set_free(uset);
+	if (is_subset < 0)
+		goto error;
+	if (is_subset) {
+		isl_union_set_free(domain);
+		return node;
+	}
+
+	tree = isl_schedule_tree_copy(node->tree);
+	uset = isl_schedule_tree_domain_get_domain(tree);
+	uset = isl_union_set_intersect(uset, domain);
+	tree = isl_schedule_tree_domain_set_domain(tree,
+						    isl_union_set_copy(uset));
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_gist(node, uset);
+	node = isl_schedule_node_parent(node);
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Replace the domain of domain node "node" with the gist
+ * of the original domain with respect to the parameter domain "context".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_domain_gist_params(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *context)
+{
+	isl_union_set *domain;
+	isl_schedule_tree *tree;
+
+	if (!node || !context)
+		goto error;
+
+	tree = isl_schedule_tree_copy(node->tree);
+	domain = isl_schedule_tree_domain_get_domain(node->tree);
+	domain = isl_union_set_gist_params(domain, context);
+	tree = isl_schedule_tree_domain_set_domain(tree, domain);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_set_free(context);
+	return NULL;
+}
+
+/* Internal data structure for isl_schedule_node_get_subtree_expansion.
+ * "expansions" contains a list of accumulated expansions
+ * for each outer expansion, set or sequence node.  The first element
+ * in the list is an identity mapping on the reaching domain elements.
+ * "res" collects the results.
+ */
+struct isl_subtree_expansion_data {
+	isl_union_map_list *expansions;
+	isl_union_map *res;
+};
+
+/* Callback for "traverse" to enter a node and to move
+ * to the deepest initial subtree that should be traversed
+ * by isl_schedule_node_get_subtree_expansion.
+ *
+ * Whenever we come across an expansion node, the last element
+ * of data->expansions is combined with the expansion
+ * on the expansion node.
+ *
+ * Whenever we come across a filter node that is the child
+ * of a set or sequence node, data->expansions is extended
+ * with a new element that restricts the previous element
+ * to the elements selected by the filter.
+ * The previous element can then be reused while backtracking.
+ */
+static __isl_give isl_schedule_node *subtree_expansion_enter(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_subtree_expansion_data *data = user;
+
+	do {
+		enum isl_schedule_node_type type;
+		isl_union_set *filter;
+		isl_union_map *inner, *expansion;
+		isl_size n;
+
+		switch (isl_schedule_node_get_type(node)) {
+		case isl_schedule_node_error:
+			return isl_schedule_node_free(node);
+		case isl_schedule_node_filter:
+			type = isl_schedule_node_get_parent_type(node);
+			if (type != isl_schedule_node_set &&
+			    type != isl_schedule_node_sequence)
+				break;
+			filter = isl_schedule_node_filter_get_filter(node);
+			n = isl_union_map_list_n_union_map(data->expansions);
+			if (n < 0)
+				data->expansions =
+				    isl_union_map_list_free(data->expansions);
+			inner =
+			    isl_union_map_list_get_union_map(data->expansions,
+								n - 1);
+			inner = isl_union_map_intersect_range(inner, filter);
+			data->expansions =
+			    isl_union_map_list_add(data->expansions, inner);
+			break;
+		case isl_schedule_node_expansion:
+			n = isl_union_map_list_n_union_map(data->expansions);
+			if (n < 0)
+				data->expansions =
+				    isl_union_map_list_free(data->expansions);
+			expansion =
+				isl_schedule_node_expansion_get_expansion(node);
+			inner =
+			    isl_union_map_list_get_union_map(data->expansions,
+								n - 1);
+			inner = isl_union_map_apply_range(inner, expansion);
+			data->expansions =
+			    isl_union_map_list_set_union_map(data->expansions,
+								n - 1, inner);
+			break;
+		case isl_schedule_node_band:
+		case isl_schedule_node_context:
+		case isl_schedule_node_domain:
+		case isl_schedule_node_extension:
+		case isl_schedule_node_guard:
+		case isl_schedule_node_leaf:
+		case isl_schedule_node_mark:
+		case isl_schedule_node_sequence:
+		case isl_schedule_node_set:
+			break;
+		}
+	} while (isl_schedule_node_has_children(node) &&
+		(node = isl_schedule_node_first_child(node)) != NULL);
+
+	return node;
+}
+
+/* Callback for "traverse" to leave a node for
+ * isl_schedule_node_get_subtree_expansion.
+ *
+ * If we come across a filter node that is the child
+ * of a set or sequence node, then we remove the element
+ * of data->expansions that was added in subtree_expansion_enter.
+ *
+ * If we reach a leaf node, then the accumulated expansion is
+ * added to data->res.
+ */
+static __isl_give isl_schedule_node *subtree_expansion_leave(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_subtree_expansion_data *data = user;
+	isl_size n;
+	isl_union_map *inner;
+	enum isl_schedule_node_type type;
+
+	switch (isl_schedule_node_get_type(node)) {
+	case isl_schedule_node_error:
+		return isl_schedule_node_free(node);
+	case isl_schedule_node_filter:
+		type = isl_schedule_node_get_parent_type(node);
+		if (type != isl_schedule_node_set &&
+		    type != isl_schedule_node_sequence)
+			break;
+		n = isl_union_map_list_n_union_map(data->expansions);
+		if (n < 0)
+			data->expansions =
+				    isl_union_map_list_free(data->expansions);
+		data->expansions = isl_union_map_list_drop(data->expansions,
+							n - 1, 1);
+		break;
+	case isl_schedule_node_leaf:
+		n = isl_union_map_list_n_union_map(data->expansions);
+		if (n < 0)
+			data->expansions =
+				    isl_union_map_list_free(data->expansions);
+		inner = isl_union_map_list_get_union_map(data->expansions,
+							n - 1);
+		data->res = isl_union_map_union(data->res, inner);
+		break;
+	case isl_schedule_node_band:
+	case isl_schedule_node_context:
+	case isl_schedule_node_domain:
+	case isl_schedule_node_expansion:
+	case isl_schedule_node_extension:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	}
+
+	return node;
+}
+
+/* Return a mapping from the domain elements that reach "node"
+ * to the corresponding domain elements in the leaves of the subtree
+ * rooted at "node" obtained by composing the intermediate expansions.
+ *
+ * We start out with an identity mapping between the domain elements
+ * that reach "node" and compose it with all the expansions
+ * on a path from "node" to a leaf while traversing the subtree.
+ * Within the children of an a sequence or set node, the
+ * accumulated expansion is restricted to the elements selected
+ * by the filter child.
+ */
+__isl_give isl_union_map *isl_schedule_node_get_subtree_expansion(
+	__isl_keep isl_schedule_node *node)
+{
+	struct isl_subtree_expansion_data data;
+	isl_space *space;
+	isl_union_set *domain;
+	isl_union_map *expansion;
+
+	if (!node)
+		return NULL;
+
+	domain = isl_schedule_node_get_universe_domain(node);
+	space = isl_union_set_get_space(domain);
+	expansion = isl_union_set_identity(domain);
+	data.res = isl_union_map_empty(space);
+	data.expansions = isl_union_map_list_from_union_map(expansion);
+
+	node = isl_schedule_node_copy(node);
+	node = traverse(node, &subtree_expansion_enter,
+			&subtree_expansion_leave, &data);
+	if (!node)
+		data.res = isl_union_map_free(data.res);
+	isl_schedule_node_free(node);
+
+	isl_union_map_list_free(data.expansions);
+
+	return data.res;
+}
+
+/* Internal data structure for isl_schedule_node_get_subtree_contraction.
+ * "contractions" contains a list of accumulated contractions
+ * for each outer expansion, set or sequence node.  The first element
+ * in the list is an identity mapping on the reaching domain elements.
+ * "res" collects the results.
+ */
+struct isl_subtree_contraction_data {
+	isl_union_pw_multi_aff_list *contractions;
+	isl_union_pw_multi_aff *res;
+};
+
+/* Callback for "traverse" to enter a node and to move
+ * to the deepest initial subtree that should be traversed
+ * by isl_schedule_node_get_subtree_contraction.
+ *
+ * Whenever we come across an expansion node, the last element
+ * of data->contractions is combined with the contraction
+ * on the expansion node.
+ *
+ * Whenever we come across a filter node that is the child
+ * of a set or sequence node, data->contractions is extended
+ * with a new element that restricts the previous element
+ * to the elements selected by the filter.
+ * The previous element can then be reused while backtracking.
+ */
+static __isl_give isl_schedule_node *subtree_contraction_enter(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_subtree_contraction_data *data = user;
+
+	do {
+		enum isl_schedule_node_type type;
+		isl_union_set *filter;
+		isl_union_pw_multi_aff *inner, *contraction;
+		isl_size n;
+
+		switch (isl_schedule_node_get_type(node)) {
+		case isl_schedule_node_error:
+			return isl_schedule_node_free(node);
+		case isl_schedule_node_filter:
+			type = isl_schedule_node_get_parent_type(node);
+			if (type != isl_schedule_node_set &&
+			    type != isl_schedule_node_sequence)
+				break;
+			filter = isl_schedule_node_filter_get_filter(node);
+			n = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(
+						data->contractions);
+			if (n < 0)
+				data->contractions =
+				    isl_union_pw_multi_aff_list_free(
+							    data->contractions);
+			inner =
+			    isl_union_pw_multi_aff_list_get_union_pw_multi_aff(
+						data->contractions, n - 1);
+			inner = isl_union_pw_multi_aff_intersect_domain(inner,
+								filter);
+			data->contractions =
+			    isl_union_pw_multi_aff_list_add(data->contractions,
+								inner);
+			break;
+		case isl_schedule_node_expansion:
+			n = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(
+						data->contractions);
+			if (n < 0)
+				data->contractions =
+				    isl_union_pw_multi_aff_list_free(
+							    data->contractions);
+			contraction =
+			    isl_schedule_node_expansion_get_contraction(node);
+			inner =
+			    isl_union_pw_multi_aff_list_get_union_pw_multi_aff(
+						data->contractions, n - 1);
+			inner =
+			    isl_union_pw_multi_aff_pullback_union_pw_multi_aff(
+						inner, contraction);
+			data->contractions =
+			    isl_union_pw_multi_aff_list_set_union_pw_multi_aff(
+					data->contractions, n - 1, inner);
+			break;
+		case isl_schedule_node_band:
+		case isl_schedule_node_context:
+		case isl_schedule_node_domain:
+		case isl_schedule_node_extension:
+		case isl_schedule_node_guard:
+		case isl_schedule_node_leaf:
+		case isl_schedule_node_mark:
+		case isl_schedule_node_sequence:
+		case isl_schedule_node_set:
+			break;
+		}
+	} while (isl_schedule_node_has_children(node) &&
+		(node = isl_schedule_node_first_child(node)) != NULL);
+
+	return node;
+}
+
+/* Callback for "traverse" to leave a node for
+ * isl_schedule_node_get_subtree_contraction.
+ *
+ * If we come across a filter node that is the child
+ * of a set or sequence node, then we remove the element
+ * of data->contractions that was added in subtree_contraction_enter.
+ *
+ * If we reach a leaf node, then the accumulated contraction is
+ * added to data->res.
+ */
+static __isl_give isl_schedule_node *subtree_contraction_leave(
+	__isl_take isl_schedule_node *node, void *user)
+{
+	struct isl_subtree_contraction_data *data = user;
+	isl_size n;
+	isl_union_pw_multi_aff *inner;
+	enum isl_schedule_node_type type;
+
+	switch (isl_schedule_node_get_type(node)) {
+	case isl_schedule_node_error:
+		return isl_schedule_node_free(node);
+	case isl_schedule_node_filter:
+		type = isl_schedule_node_get_parent_type(node);
+		if (type != isl_schedule_node_set &&
+		    type != isl_schedule_node_sequence)
+			break;
+		n = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(
+						data->contractions);
+		if (n < 0)
+			data->contractions = isl_union_pw_multi_aff_list_free(
+							    data->contractions);
+		data->contractions =
+			isl_union_pw_multi_aff_list_drop(data->contractions,
+							n - 1, 1);
+		break;
+	case isl_schedule_node_leaf:
+		n = isl_union_pw_multi_aff_list_n_union_pw_multi_aff(
+						data->contractions);
+		if (n < 0)
+			data->contractions = isl_union_pw_multi_aff_list_free(
+							    data->contractions);
+		inner = isl_union_pw_multi_aff_list_get_union_pw_multi_aff(
+						data->contractions, n - 1);
+		data->res = isl_union_pw_multi_aff_union_add(data->res, inner);
+		break;
+	case isl_schedule_node_band:
+	case isl_schedule_node_context:
+	case isl_schedule_node_domain:
+	case isl_schedule_node_expansion:
+	case isl_schedule_node_extension:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	}
+
+	return node;
+}
+
+/* Return a mapping from the domain elements in the leaves of the subtree
+ * rooted at "node" to the corresponding domain elements that reach "node"
+ * obtained by composing the intermediate contractions.
+ *
+ * We start out with an identity mapping between the domain elements
+ * that reach "node" and compose it with all the contractions
+ * on a path from "node" to a leaf while traversing the subtree.
+ * Within the children of an a sequence or set node, the
+ * accumulated contraction is restricted to the elements selected
+ * by the filter child.
+ */
+__isl_give isl_union_pw_multi_aff *isl_schedule_node_get_subtree_contraction(
+	__isl_keep isl_schedule_node *node)
+{
+	struct isl_subtree_contraction_data data;
+	isl_space *space;
+	isl_union_set *domain;
+	isl_union_pw_multi_aff *contraction;
+
+	if (!node)
+		return NULL;
+
+	domain = isl_schedule_node_get_universe_domain(node);
+	space = isl_union_set_get_space(domain);
+	contraction = isl_union_set_identity_union_pw_multi_aff(domain);
+	data.res = isl_union_pw_multi_aff_empty(space);
+	data.contractions =
+	    isl_union_pw_multi_aff_list_from_union_pw_multi_aff(contraction);
+
+	node = isl_schedule_node_copy(node);
+	node = traverse(node, &subtree_contraction_enter,
+			&subtree_contraction_leave, &data);
+	if (!node)
+		data.res = isl_union_pw_multi_aff_free(data.res);
+	isl_schedule_node_free(node);
+
+	isl_union_pw_multi_aff_list_free(data.contractions);
+
+	return data.res;
+}
+
+/* Do the nearest "n" ancestors of "node" have the types given in "types"
+ * (starting at the parent of "node")?
+ */
+static isl_bool has_ancestors(__isl_keep isl_schedule_node *node,
+	int n, enum isl_schedule_node_type *types)
+{
+	int i;
+	isl_size n_ancestor;
+
+	if (!node)
+		return isl_bool_error;
+
+	n_ancestor = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n_ancestor < 0)
+		return isl_bool_error;
+	if (n_ancestor < n)
+		return isl_bool_false;
+
+	for (i = 0; i < n; ++i) {
+		isl_schedule_tree *tree;
+		int correct_type;
+
+		tree = isl_schedule_tree_list_get_schedule_tree(node->ancestors,
+							    n_ancestor - 1 - i);
+		if (!tree)
+			return isl_bool_error;
+		correct_type = isl_schedule_tree_get_type(tree) == typesi;
+		isl_schedule_tree_free(tree);
+		if (!correct_type)
+			return isl_bool_false;
+	}
+
+	return isl_bool_true;
+}
+
+/* Given a node "node" that appears in an extension (i.e., it is the child
+ * of a filter in a sequence inside an extension node), are the spaces
+ * of the extension specified by "extension" disjoint from those
+ * of both the original extension and the domain elements that reach
+ * that original extension?
+ */
+static int is_disjoint_extension(__isl_keep isl_schedule_node *node,
+	__isl_keep isl_union_map *extension)
+{
+	isl_union_map *old;
+	isl_union_set *domain;
+	int empty;
+
+	node = isl_schedule_node_copy(node);
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	old = isl_schedule_node_extension_get_extension(node);
+	domain = isl_schedule_node_get_universe_domain(node);
+	isl_schedule_node_free(node);
+	old = isl_union_map_universe(old);
+	domain = isl_union_set_union(domain, isl_union_map_range(old));
+	extension = isl_union_map_copy(extension);
+	extension = isl_union_map_intersect_range(extension, domain);
+	empty = isl_union_map_is_empty(extension);
+	isl_union_map_free(extension);
+
+	return empty;
+}
+
+/* Given a node "node" that is governed by an extension node, extend
+ * that extension node with "extension".
+ *
+ * In particular, "node" is the child of a filter in a sequence that
+ * is in turn a child of an extension node.  Extend that extension node
+ * with "extension".
+ *
+ * Return a pointer to the parent of the original node (i.e., a filter).
+ */
+static __isl_give isl_schedule_node *extend_extension(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_map *extension)
+{
+	isl_size pos;
+	isl_bool disjoint;
+	isl_union_map *node_extension;
+
+	node = isl_schedule_node_parent(node);
+	pos = isl_schedule_node_get_child_position(node);
+	if (pos < 0)
+		node = isl_schedule_node_free(node);
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	node_extension = isl_schedule_node_extension_get_extension(node);
+	disjoint = isl_union_map_is_disjoint(extension, node_extension);
+	extension = isl_union_map_union(extension, node_extension);
+	node = isl_schedule_node_extension_set_extension(node, extension);
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_child(node, pos);
+
+	if (disjoint < 0)
+		return isl_schedule_node_free(node);
+	if (!node)
+		return NULL;
+	if (!disjoint)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"extension domain should be disjoint from earlier "
+			"extensions", return isl_schedule_node_free(node));
+
+	return node;
+}
+
+/* Return the universe of "uset" if this universe is disjoint from "ref".
+ * Otherwise, return "uset".
+ *
+ * Also check if "uset" itself is disjoint from "ref", reporting
+ * an error if it is not.
+ */
+static __isl_give isl_union_set *replace_by_universe_if_disjoint(
+	__isl_take isl_union_set *uset, __isl_keep isl_union_set *ref)
+{
+	int disjoint;
+	isl_union_set *universe;
+
+	disjoint = isl_union_set_is_disjoint(uset, ref);
+	if (disjoint < 0)
+		return isl_union_set_free(uset);
+	if (!disjoint)
+		isl_die(isl_union_set_get_ctx(uset), isl_error_invalid,
+			"extension domain should be disjoint from "
+			"current domain", return isl_union_set_free(uset));
+
+	universe = isl_union_set_universe(isl_union_set_copy(uset));
+	disjoint = isl_union_set_is_disjoint(universe, ref);
+	if (disjoint >= 0 && disjoint) {
+		isl_union_set_free(uset);
+		return universe;
+	}
+	isl_union_set_free(universe);
+
+	if (disjoint < 0)
+		return isl_union_set_free(uset);
+	return uset;
+}
+
+/* Insert an extension node on top of "node" with extension "extension".
+ * In addition, insert a filter that separates node from the extension
+ * between the extension node and "node".
+ * Return a pointer to the inserted filter node.
+ *
+ * If "node" already appears in an extension (i.e., if it is the child
+ * of a filter in a sequence inside an extension node), then extend that
+ * extension with "extension" instead.
+ * In this case, a pointer to the original filter node is returned.
+ * Note that if some of the elements in the new extension live in the
+ * same space as those of the original extension or the domain elements
+ * reaching the original extension, then we insert a new extension anyway.
+ * Otherwise, we would have to adjust the filters in the sequence child
+ * of the extension to ensure that the elements in the new extension
+ * are filtered out.
+ */
+static __isl_give isl_schedule_node *insert_extension(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_map *extension)
+{
+	enum isl_schedule_node_type ancestors =
+		{ isl_schedule_node_filter, isl_schedule_node_sequence,
+		  isl_schedule_node_extension };
+	isl_union_set *domain;
+	isl_union_set *filter;
+	isl_bool in_ext;
+
+	in_ext = has_ancestors(node, 3, ancestors);
+	if (in_ext < 0)
+		goto error;
+	if (in_ext) {
+		int disjoint;
+
+		disjoint = is_disjoint_extension(node, extension);
+		if (disjoint < 0)
+			goto error;
+		if (disjoint)
+			return extend_extension(node, extension);
+	}
+
+	filter = isl_schedule_node_get_domain(node);
+	domain = isl_union_map_range(isl_union_map_copy(extension));
+	filter = replace_by_universe_if_disjoint(filter, domain);
+	isl_union_set_free(domain);
+
+	node = isl_schedule_node_insert_filter(node, filter);
+	node = isl_schedule_node_insert_extension(node, extension);
+	node = isl_schedule_node_child(node, 0);
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_union_map_free(extension);
+	return NULL;
+}
+
+/* Replace the subtree that "node" points to by "tree" (which has
+ * a sequence root with two children), except if the parent of "node"
+ * is a sequence as well, in which case "tree" is spliced at the position
+ * of "node" in its parent.
+ * Return a pointer to the child of the "tree_pos" (filter) child of "tree"
+ * in the updated schedule tree.
+ */
+static __isl_give isl_schedule_node *graft_or_splice(
+	__isl_take isl_schedule_node *node, __isl_take isl_schedule_tree *tree,
+	int tree_pos)
+{
+	isl_size pos;
+
+	if (isl_schedule_node_get_parent_type(node) ==
+	    isl_schedule_node_sequence) {
+		pos = isl_schedule_node_get_child_position(node);
+		if (pos < 0)
+			node = isl_schedule_node_free(node);
+		node = isl_schedule_node_parent(node);
+		node = isl_schedule_node_sequence_splice(node, pos, tree);
+	} else {
+		pos = 0;
+		node = isl_schedule_node_graft_tree(node, tree);
+	}
+	node = isl_schedule_node_child(node, pos + tree_pos);
+	node = isl_schedule_node_child(node, 0);
+
+	return node;
+}
+
+/* Insert a node "graft" into the schedule tree of "node" such that it
+ * is executed before (if "before" is set) or after (if "before" is not set)
+ * the node that "node" points to.
+ * The root of "graft" is an extension node.
+ * Return a pointer to the node that "node" pointed to.
+ *
+ * We first insert an extension node on top of "node" (or extend
+ * the extension node if there already is one), with a filter on "node"
+ * separating it from the extension.
+ * We then insert a filter in the graft to separate it from the original
+ * domain elements and combine the original and new tree in a sequence.
+ * If we have extended an extension node, then the children of this
+ * sequence are spliced in the sequence of the extended extension
+ * at the position where "node" appears in the original extension.
+ * Otherwise, the sequence pair is attached to the new extension node.
+ */
+static __isl_give isl_schedule_node *graft_extension(
+	__isl_take isl_schedule_node *node, __isl_take isl_schedule_node *graft,
+	int before)
+{
+	isl_union_map *extension;
+	isl_union_set *graft_domain;
+	isl_union_set *node_domain;
+	isl_schedule_tree *tree, *tree_graft;
+
+	extension = isl_schedule_node_extension_get_extension(graft);
+	graft_domain = isl_union_map_range(isl_union_map_copy(extension));
+	node_domain = isl_schedule_node_get_universe_domain(node);
+	node = insert_extension(node, extension);
+
+	graft_domain = replace_by_universe_if_disjoint(graft_domain,
+							node_domain);
+	isl_union_set_free(node_domain);
+
+	tree = isl_schedule_node_get_tree(node);
+	if (!isl_schedule_node_has_children(graft)) {
+		tree_graft = isl_schedule_tree_from_filter(graft_domain);
+	} else {
+		graft = isl_schedule_node_child(graft, 0);
+		tree_graft = isl_schedule_node_get_tree(graft);
+		tree_graft = isl_schedule_tree_insert_filter(tree_graft,
+								graft_domain);
+	}
+	if (before)
+		tree = isl_schedule_tree_sequence_pair(tree_graft, tree);
+	else
+		tree = isl_schedule_tree_sequence_pair(tree, tree_graft);
+	node = graft_or_splice(node, tree, before);
+
+	isl_schedule_node_free(graft);
+
+	return node;
+}
+
+/* Replace the root domain node of "node" by an extension node suitable
+ * for insertion at "pos".
+ * That is, create an extension node that maps the outer band nodes
+ * at "pos" to the domain of the root node of "node" and attach
+ * the child of this root node to the extension node.
+ */
+static __isl_give isl_schedule_node *extension_from_domain(
+	__isl_take isl_schedule_node *node, __isl_keep isl_schedule_node *pos)
+{
+	isl_union_set *universe;
+	isl_union_set *domain;
+	isl_union_map *ext;
+	isl_size depth;
+	isl_bool anchored;
+	isl_space *space;
+	isl_schedule_node *res;
+	isl_schedule_tree *tree;
+
+	depth = isl_schedule_node_get_schedule_depth(pos);
+	anchored = isl_schedule_node_is_subtree_anchored(node);
+	if (depth < 0 || anchored < 0)
+		return isl_schedule_node_free(node);
+	if (anchored)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_unsupported,
+			"cannot graft anchored tree with domain root",
+			return isl_schedule_node_free(node));
+
+	domain = isl_schedule_node_domain_get_domain(node);
+	space = isl_union_set_get_space(domain);
+	space = isl_space_set_from_params(space);
+	space = isl_space_add_dims(space, isl_dim_set, depth);
+	universe = isl_union_set_from_set(isl_set_universe(space));
+	ext = isl_union_map_from_domain_and_range(universe, domain);
+	res = isl_schedule_node_from_extension(ext);
+	node = isl_schedule_node_child(node, 0);
+	if (!node)
+		return isl_schedule_node_free(res);
+	if (!isl_schedule_tree_is_leaf(node->tree)) {
+		tree = isl_schedule_node_get_tree(node);
+		res = isl_schedule_node_child(res, 0);
+		res = isl_schedule_node_graft_tree(res, tree);
+		res = isl_schedule_node_parent(res);
+	}
+	isl_schedule_node_free(node);
+
+	return res;
+}
+
+/* Insert a node "graft" into the schedule tree of "node" such that it
+ * is executed before (if "before" is set) or after (if "before" is not set)
+ * the node that "node" points to.
+ * The root of "graft" may be either a domain or an extension node.
+ * In the latter case, the domain of the extension needs to correspond
+ * to the outer band nodes of "node".
+ * The elements of the domain or the range of the extension may not
+ * intersect with the domain elements that reach "node".
+ * The schedule tree of "graft" may not be anchored.
+ *
+ * The schedule tree of "node" is modified to include an extension node
+ * corresponding to the root node of "graft" as a child of the original
+ * parent of "node".  The original node that "node" points to and the
+ * child of the root node of "graft" are attached to this extension node
+ * through a sequence, with appropriate filters and with the child
+ * of "graft" appearing before or after the original "node".
+ *
+ * If "node" already appears inside a sequence that is the child of
+ * an extension node and if the spaces of the new domain elements
+ * do not overlap with those of the original domain elements,
+ * then that extension node is extended with the new extension
+ * rather than introducing a new segment of extension and sequence nodes.
+ *
+ * Return a pointer to the same node in the modified tree that
+ * "node" pointed to in the original tree.
+ */
+static __isl_give isl_schedule_node *isl_schedule_node_graft_before_or_after(
+	__isl_take isl_schedule_node *node, __isl_take isl_schedule_node *graft,
+	int before)
+{
+	if (!node || !graft)
+		goto error;
+	if (check_insert(node) < 0)
+		goto error;
+
+	if (isl_schedule_node_get_type(graft) == isl_schedule_node_domain)
+		graft = extension_from_domain(graft, node);
+
+	if (!graft)
+		goto error;
+	if (isl_schedule_node_get_type(graft) != isl_schedule_node_extension)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"expecting domain or extension as root of graft",
+			goto error);
+
+	return graft_extension(node, graft, before);
+error:
+	isl_schedule_node_free(node);
+	isl_schedule_node_free(graft);
+	return NULL;
+}
+
+/* Insert a node "graft" into the schedule tree of "node" such that it
+ * is executed before the node that "node" points to.
+ * The root of "graft" may be either a domain or an extension node.
+ * In the latter case, the domain of the extension needs to correspond
+ * to the outer band nodes of "node".
+ * The elements of the domain or the range of the extension may not
+ * intersect with the domain elements that reach "node".
+ * The schedule tree of "graft" may not be anchored.
+ *
+ * Return a pointer to the same node in the modified tree that
+ * "node" pointed to in the original tree.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_graft_before(
+	__isl_take isl_schedule_node *node, __isl_take isl_schedule_node *graft)
+{
+	return isl_schedule_node_graft_before_or_after(node, graft, 1);
+}
+
+/* Insert a node "graft" into the schedule tree of "node" such that it
+ * is executed after the node that "node" points to.
+ * The root of "graft" may be either a domain or an extension node.
+ * In the latter case, the domain of the extension needs to correspond
+ * to the outer band nodes of "node".
+ * The elements of the domain or the range of the extension may not
+ * intersect with the domain elements that reach "node".
+ * The schedule tree of "graft" may not be anchored.
+ *
+ * Return a pointer to the same node in the modified tree that
+ * "node" pointed to in the original tree.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_graft_after(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_schedule_node *graft)
+{
+	return isl_schedule_node_graft_before_or_after(node, graft, 0);
+}
+
+/* Split the domain elements that reach "node" into those that satisfy
+ * "filter" and those that do not.  Arrange for the first subset to be
+ * executed before or after the second subset, depending on the value
+ * of "before".
+ * Return a pointer to the tree corresponding to the second subset,
+ * except when this subset is empty in which case the original pointer
+ * is returned.
+ * If both subsets are non-empty, then a sequence node is introduced
+ * to impose the order.  If the grandparent of the original node was
+ * itself a sequence, then the original child is replaced by two children
+ * in this sequence instead.
+ * The children in the sequence are copies of the original subtree,
+ * simplified with respect to their filters.
+ */
+static __isl_give isl_schedule_node *isl_schedule_node_order_before_or_after(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter,
+	int before)
+{
+	enum isl_schedule_node_type ancestors =
+		{ isl_schedule_node_filter, isl_schedule_node_sequence };
+	isl_union_set *node_domain, *node_filter = NULL, *parent_filter;
+	isl_schedule_node *node2;
+	isl_schedule_tree *tree1, *tree2;
+	isl_bool empty1, empty2;
+	isl_bool in_seq;
+
+	if (!node || !filter)
+		goto error;
+	if (check_insert(node) < 0)
+		goto error;
+
+	in_seq = has_ancestors(node, 2, ancestors);
+	if (in_seq < 0)
+		goto error;
+	node_domain = isl_schedule_node_get_domain(node);
+	filter = isl_union_set_gist(filter, isl_union_set_copy(node_domain));
+	node_filter = isl_union_set_copy(node_domain);
+	node_filter = isl_union_set_subtract(node_filter,
+						isl_union_set_copy(filter));
+	node_filter = isl_union_set_gist(node_filter, node_domain);
+	empty1 = isl_union_set_is_empty(filter);
+	empty2 = isl_union_set_is_empty(node_filter);
+	if (empty1 < 0 || empty2 < 0)
+		goto error;
+	if (empty1 || empty2) {
+		isl_union_set_free(filter);
+		isl_union_set_free(node_filter);
+		return node;
+	}
+
+	if (in_seq) {
+		node = isl_schedule_node_parent(node);
+		parent_filter = isl_schedule_node_filter_get_filter(node);
+		node_filter = isl_union_set_intersect(node_filter,
+					    isl_union_set_copy(parent_filter));
+		filter = isl_union_set_intersect(filter, parent_filter);
+	}
+
+	node2 = isl_schedule_node_copy(node);
+	node = isl_schedule_node_gist(node, isl_union_set_copy(node_filter));
+	node2 = isl_schedule_node_gist(node2, isl_union_set_copy(filter));
+	tree1 = isl_schedule_node_get_tree(node);
+	tree2 = isl_schedule_node_get_tree(node2);
+	tree1 = isl_schedule_tree_insert_filter(tree1, node_filter);
+	tree2 = isl_schedule_tree_insert_filter(tree2, filter);
+	isl_schedule_node_free(node2);
+
+	if (before) {
+		tree1 = isl_schedule_tree_sequence_pair(tree2, tree1);
+		node = graft_or_splice(node, tree1, 1);
+	} else {
+		tree1 = isl_schedule_tree_sequence_pair(tree1, tree2);
+		node = graft_or_splice(node, tree1, 0);
+	}
+
+	return node;
+error:
+	isl_schedule_node_free(node);
+	isl_union_set_free(filter);
+	isl_union_set_free(node_filter);
+	return NULL;
+}
+
+/* Split the domain elements that reach "node" into those that satisfy
+ * "filter" and those that do not.  Arrange for the first subset to be
+ * executed before the second subset.
+ * Return a pointer to the tree corresponding to the second subset,
+ * except when this subset is empty in which case the original pointer
+ * is returned.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_order_before(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter)
+{
+	return isl_schedule_node_order_before_or_after(node, filter, 1);
+}
+
+/* Split the domain elements that reach "node" into those that satisfy
+ * "filter" and those that do not.  Arrange for the first subset to be
+ * executed after the second subset.
+ * Return a pointer to the tree corresponding to the second subset,
+ * except when this subset is empty in which case the original pointer
+ * is returned.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_order_after(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *filter)
+{
+	return isl_schedule_node_order_before_or_after(node, filter, 0);
+}
+
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * in the schedule node "node".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_reset_user(
+	__isl_take isl_schedule_node *node)
+{
+	isl_schedule_tree *tree;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_reset_user(tree);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Align the parameters of the schedule node "node" to those of "space".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_align_params(
+	__isl_take isl_schedule_node *node, __isl_take isl_space *space)
+{
+	isl_schedule_tree *tree;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_align_params(tree, space);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Compute the pullback of schedule node "node"
+ * by the function represented by "upma".
+ * In other words, plug in "upma" in the iteration domains
+ * of schedule node "node".
+ * We currently do not handle expansion nodes.
+ *
+ * Note that this is only a helper function for
+ * isl_schedule_pullback_union_pw_multi_aff.  In order to maintain consistency,
+ * this function should not be called on a single node without also
+ * calling it on all the other nodes.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	isl_schedule_tree *tree;
+
+	tree = isl_schedule_node_get_tree(node);
+	tree = isl_schedule_tree_pullback_union_pw_multi_aff(tree, upma);
+	node = isl_schedule_node_graft_tree(node, tree);
+
+	return node;
+}
+
+/* Internal data structure for isl_schedule_node_expand.
+ * "tree" is the tree that needs to be plugged in in all the leaves.
+ * "domain" is the set of domain elements in the original leaves
+ * to which the tree applies.
+ */
+struct isl_schedule_expand_data {
+	isl_schedule_tree *tree;
+	isl_union_set *domain;
+};
+
+/* If "node" is a leaf, then plug in data->tree, simplifying it
+ * within its new context.
+ *
+ * If there are any domain elements at the leaf where the tree
+ * should not be plugged in (i.e., there are elements not in data->domain)
+ * then first extend the tree to only apply to the elements in data->domain
+ * by constructing a set node that selects data->tree for elements
+ * in data->domain and a leaf for the other elements.
+ */
+static __isl_give isl_schedule_node *expand(__isl_take isl_schedule_node *node,
+	void *user)
+{
+	struct isl_schedule_expand_data *data = user;
+	isl_schedule_tree *tree, *leaf;
+	isl_union_set *domain, *left;
+	isl_bool empty;
+
+	if (isl_schedule_node_get_type(node) != isl_schedule_node_leaf)
+		return node;
+
+	domain = isl_schedule_node_get_domain(node);
+	tree = isl_schedule_tree_copy(data->tree);
+
+	left = isl_union_set_copy(domain);
+	left = isl_union_set_subtract(left, isl_union_set_copy(data->domain));
+	empty = isl_union_set_is_empty(left);
+	if (empty >= 0 && !empty) {
+		leaf = isl_schedule_node_get_leaf(node);
+		leaf = isl_schedule_tree_insert_filter(leaf, left);
+		left = isl_union_set_copy(data->domain);
+		tree = isl_schedule_tree_insert_filter(tree, left);
+		tree = isl_schedule_tree_set_pair(tree, leaf);
+	} else {
+		if (empty < 0)
+			node = isl_schedule_node_free(node);
+		isl_union_set_free(left);
+	}
+
+	node = isl_schedule_node_graft_tree(node, tree);
+	node = isl_schedule_node_gist(node, domain);
+
+	return node;
+}
+
+/* Expand the tree rooted at "node" by extending all leaves
+ * with an expansion node with as child "tree".
+ * The expansion is determined by "contraction" and "domain".
+ * That is, the elements of "domain" are contracted according
+ * to "contraction".  The expansion relation is then the inverse
+ * of "contraction" with its range intersected with "domain".
+ *
+ * Insert the appropriate expansion node on top of "tree" and
+ * then plug in the result in all leaves of "node".
+ */
+__isl_give isl_schedule_node *isl_schedule_node_expand(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_set *domain,
+	__isl_take isl_schedule_tree *tree)
+{
+	struct isl_schedule_expand_data data;
+	isl_union_map *expansion;
+	isl_union_pw_multi_aff *copy;
+
+	if (!node || !contraction || !tree)
+		node = isl_schedule_node_free(node);
+
+	copy = isl_union_pw_multi_aff_copy(contraction);
+	expansion = isl_union_map_from_union_pw_multi_aff(copy);
+	expansion = isl_union_map_reverse(expansion);
+	expansion = isl_union_map_intersect_range(expansion, domain);
+	data.domain = isl_union_map_domain(isl_union_map_copy(expansion));
+
+	tree = isl_schedule_tree_insert_expansion(tree, contraction, expansion);
+	data.tree = tree;
+
+	node = isl_schedule_node_map_descendant_bottom_up(node, &expand, &data);
+	isl_union_set_free(data.domain);
+	isl_schedule_tree_free(data.tree);
+	return node;
+}
+
+/* Return the position of the subtree containing "node" among the children
+ * of "ancestor".  "node" is assumed to be a descendant of "ancestor".
+ * In particular, both nodes should point to the same schedule tree.
+ *
+ * Return isl_size_error on error.
+ */
+isl_size isl_schedule_node_get_ancestor_child_position(
+	__isl_keep isl_schedule_node *node,
+	__isl_keep isl_schedule_node *ancestor)
+{
+	isl_size n1, n2;
+	isl_schedule_tree *tree;
+
+	n1 = isl_schedule_node_get_tree_depth(ancestor);
+	n2 = isl_schedule_node_get_tree_depth(node);
+	if (n1 < 0 || n2 < 0)
+		return isl_size_error;
+
+	if (node->schedule != ancestor->schedule)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a descendant", return isl_size_error);
+
+	if (n1 >= n2)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a descendant", return isl_size_error);
+	tree = isl_schedule_tree_list_get_schedule_tree(node->ancestors, n1);
+	isl_schedule_tree_free(tree);
+	if (tree != ancestor->tree)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_invalid,
+			"not a descendant", return isl_size_error);
+
+	return node->child_posn1;
+}
+
+/* Given two nodes that point to the same schedule tree, return their
+ * closest shared ancestor.
+ *
+ * Since the two nodes point to the same schedule, they share at least
+ * one ancestor, the root of the schedule.  We move down from the root
+ * to the first ancestor where the respective children have a different
+ * child position.  This is the requested ancestor.
+ * If there is no ancestor where the children have a different position,
+ * then one node is an ancestor of the other and then this node is
+ * the requested ancestor.
+ */
+__isl_give isl_schedule_node *isl_schedule_node_get_shared_ancestor(
+	__isl_keep isl_schedule_node *node1,
+	__isl_keep isl_schedule_node *node2)
+{
+	int i;
+	isl_size n1, n2;
+
+	n1 = isl_schedule_node_get_tree_depth(node1);
+	n2 = isl_schedule_node_get_tree_depth(node2);
+	if (n1 < 0 || n2 < 0)
+		return NULL;
+	if (node1->schedule != node2->schedule)
+		isl_die(isl_schedule_node_get_ctx(node1), isl_error_invalid,
+			"not part of same schedule", return NULL);
+	if (n2 < n1)
+		return isl_schedule_node_get_shared_ancestor(node2, node1);
+	if (n1 == 0)
+		return isl_schedule_node_copy(node1);
+	if (isl_schedule_node_is_equal(node1, node2))
+		return isl_schedule_node_copy(node1);
+
+	for (i = 0; i < n1; ++i)
+		if (node1->child_posi != node2->child_posi)
+			break;
+
+	node1 = isl_schedule_node_copy(node1);
+	return isl_schedule_node_ancestor(node1, n1 - i);
+}
+
+/* Print "node" to "p".
+ */
+__isl_give isl_printer *isl_printer_print_schedule_node(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_node *node)
+{
+	isl_size n;
+
+	if (!node)
+		return isl_printer_free(p);
+	n = isl_schedule_tree_list_n_schedule_tree(node->ancestors);
+	if (n < 0)
+		return isl_printer_free(p);
+	return isl_printer_print_schedule_tree_mark(p, node->schedule->root, n,
+			node->child_pos);
+}
+
+void isl_schedule_node_dump(__isl_keep isl_schedule_node *node)
+{
+	isl_ctx *ctx;
+	isl_printer *printer;
+
+	if (!node)
+		return;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	printer = isl_printer_to_file(ctx, stderr);
+	printer = isl_printer_set_yaml_style(printer, ISL_YAML_STYLE_BLOCK);
+	printer = isl_printer_print_schedule_node(printer, node);
+
+	isl_printer_free(printer);
+}
+
+/* Return a string representation of "node".
+ * Print the schedule node in block format as it would otherwise
+ * look identical to the entire schedule.
+ */
+__isl_give char *isl_schedule_node_to_str(__isl_keep isl_schedule_node *node)
+{
+	isl_printer *printer;
+	char *s;
+
+	if (!node)
+		return NULL;
+
+	printer = isl_printer_to_str(isl_schedule_node_get_ctx(node));
+	printer = isl_printer_set_yaml_style(printer, ISL_YAML_STYLE_BLOCK);
+	printer = isl_printer_print_schedule_node(printer, node);
+	s = isl_printer_get_str(printer);
+	isl_printer_free(printer);
+
+	return s;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_node_private.h Added

@@ -0,0 +1,68 @@
+#ifndef ISL_SCHEDLUE_NODE_PRIVATE_H
+#define ISL_SCHEDLUE_NODE_PRIVATE_H
+
+#include <isl/schedule_node.h>
+#include <isl_schedule_band.h>
+#include <isl_schedule_tree.h>
+
+/* An isl_schedule_node points to a particular location in a schedule tree.
+ *
+ * "schedule" is the schedule that the node is pointing to.
+ * "ancestors" is a list of the n ancestors of the node
+ * that is being pointed to.
+ * The first ancestor is the root of "schedule", while the last ancestor
+ * is the parent of the specified location.
+ * "child_pos" is an array of child positions of the same length as "ancestors",
+ * where ancestor i (i > 0) appears in child_posi - 1 of ancestor i - 1 and
+ * "tree" appears in child_posn - 1 of ancestor n - 1.
+ * "tree" is the subtree at the specified location.
+ *
+ * Note that the same isl_schedule_tree object may appear several times
+ * in a schedule tree and therefore does not uniquely identify a position
+ * in the schedule tree.
+ */
+struct isl_schedule_node {
+	int ref;
+
+	isl_schedule *schedule;
+	isl_schedule_tree_list *ancestors;
+	int *child_pos;
+	isl_schedule_tree *tree;
+};
+
+__isl_give isl_schedule_node *isl_schedule_node_alloc(
+	__isl_take isl_schedule *schedule, __isl_take isl_schedule_tree *tree,
+	__isl_take isl_schedule_tree_list *ancestors, int *child_pos);
+__isl_give isl_schedule_node *isl_schedule_node_graft_tree(
+	__isl_take isl_schedule_node *pos, __isl_take isl_schedule_tree *tree);
+
+__isl_give isl_schedule_tree *isl_schedule_node_get_tree(
+	__isl_keep isl_schedule_node *node);
+
+__isl_give isl_schedule_node *isl_schedule_node_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_give isl_schedule_node *isl_schedule_node_expand(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_set *domain,
+	__isl_take isl_schedule_tree *tree);
+
+__isl_give isl_schedule_node *isl_schedule_node_gist(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *context);
+
+__isl_give isl_schedule_node *isl_schedule_node_domain_intersect_domain(
+	__isl_take isl_schedule_node *node, __isl_take isl_union_set *domain);
+__isl_give isl_schedule_node *isl_schedule_node_domain_gist_params(
+	__isl_take isl_schedule_node *node, __isl_take isl_set *context);
+
+__isl_give isl_schedule_node *isl_schedule_node_insert_expansion(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion);
+__isl_give isl_schedule_node *isl_schedule_node_insert_extension(
+	__isl_take isl_schedule_node *node,
+	__isl_take isl_union_map *extension);
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/isl_schedule_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_schedule_private.h Changed

@@ -3,42 +3,34 @@
 
 #include <isl/aff.h>
 #include <isl/schedule.h>
+#include <isl_schedule_tree.h>
 
-/* The schedule for an individual domain, plus information about the bands
- * and scheduling dimensions.
- * In particular, we keep track of the number of bands and for each
- * band, the starting position of the next band.  The first band starts at
- * position 0.
- * For each scheduling dimension, we keep track of whether it satisfies
- * the coincidence constraints (within its band).
- */
-struct isl_schedule_node {
-	isl_multi_aff *sched;
-	int	 n_band;
-	int	*band_end;
-	int	*band_id;
-	int	*coincident;
-};
-
-/* Information about the computed schedule.
- * n is the number of nodes/domains/statements.
- * n_band is the maximal number of bands.
- * n_total_row is the number of coordinates of the schedule.
- * dim contains a description of the parameters.
- * band_forest points to a band forest representation of the schedule
- * and may be NULL if the forest hasn't been created yet.
+/* A complete schedule tree.
+ *
+ * "root" is the root of the schedule tree.
+ *
+ * "leaf" may be used to represent a leaf of the schedule.
+ * It should not appear as a child to any other isl_schedule_tree objects,
+ * but an isl_schedule_node may have "leaf" as its tree if it refers to
+ * a leaf of this schedule tree.
  */
 struct isl_schedule {
 	int ref;
 
-	int n;
-	int n_band;
-	int n_total_row;
-	isl_space *dim;
+	isl_schedule_tree *root;
 
-	isl_band_list *band_forest;
-
-	struct isl_schedule_node node1;
+	struct isl_schedule_tree *leaf;
 };
 
+__isl_give isl_schedule *isl_schedule_from_schedule_tree(isl_ctx *ctx,
+	__isl_take isl_schedule_tree *tree);
+__isl_give isl_schedule *isl_schedule_set_root(
+	__isl_take isl_schedule *schedule, __isl_take isl_schedule_tree *tree);
+__isl_give isl_space *isl_schedule_get_space(
+	__isl_keep isl_schedule *schedule);
+__isl_give isl_union_set *isl_schedule_get_domain(
+	__isl_keep isl_schedule *schedule);
+__isl_keep isl_schedule_tree *isl_schedule_peek_leaf(
+	__isl_keep isl_schedule *schedule);
+
 #endif

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_read.c Added

@@ -0,0 +1,779 @@
+#include <isl/id.h>
+#include <isl/val.h>
+#include <isl/schedule.h>
+#include <isl/stream.h>
+#include <isl_schedule_private.h>
+#include <isl_schedule_tree.h>
+
+/* An enumeration of the various keys that may appear in a YAML mapping
+ * of a schedule.
+ */
+enum isl_schedule_key {
+	isl_schedule_key_error = -1,
+	isl_schedule_key_child,
+	isl_schedule_key_coincident,
+	isl_schedule_key_context,
+	isl_schedule_key_contraction,
+	isl_schedule_key_domain,
+	isl_schedule_key_expansion,
+	isl_schedule_key_extension,
+	isl_schedule_key_filter,
+	isl_schedule_key_guard,
+	isl_schedule_key_leaf,
+	isl_schedule_key_mark,
+	isl_schedule_key_options,
+	isl_schedule_key_permutable,
+	isl_schedule_key_schedule,
+	isl_schedule_key_sequence,
+	isl_schedule_key_set,
+	isl_schedule_key_end
+};
+
+/* Textual representations of the YAML keys for an isl_schedule object.
+ */
+static char *key_str = {
+	isl_schedule_key_child = "child",
+	isl_schedule_key_coincident = "coincident",
+	isl_schedule_key_context = "context",
+	isl_schedule_key_contraction = "contraction",
+	isl_schedule_key_domain = "domain",
+	isl_schedule_key_expansion = "expansion",
+	isl_schedule_key_extension = "extension",
+	isl_schedule_key_filter = "filter",
+	isl_schedule_key_guard = "guard",
+	isl_schedule_key_leaf = "leaf",
+	isl_schedule_key_mark = "mark",
+	isl_schedule_key_options = "options",
+	isl_schedule_key_permutable = "permutable",
+	isl_schedule_key_schedule = "schedule",
+	isl_schedule_key_sequence = "sequence",
+	isl_schedule_key_set = "set",
+};
+
+#undef KEY
+#define KEY enum isl_schedule_key
+#undef KEY_ERROR
+#define KEY_ERROR isl_schedule_key_error
+#undef KEY_END
+#define KEY_END isl_schedule_key_end
+#include "extract_key.c"
+
+static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
+	__isl_keep isl_stream *s);
+
+/* Read a subtree with context root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_context(__isl_keep isl_stream *s)
+{
+	isl_set *context = NULL;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	context = isl_set_read_from_str(ctx, str);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		tree = isl_schedule_tree_from_context(context);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_context(tree, context);
+	}
+
+	return tree;
+error:
+	isl_set_free(context);
+	return NULL;
+}
+
+/* Read a subtree with domain root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_domain(__isl_keep isl_stream *s)
+{
+	isl_union_set *domain = NULL;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	domain = isl_union_set_read_from_str(ctx, str);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		tree = isl_schedule_tree_from_domain(domain);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_domain(tree, domain);
+	}
+
+	return tree;
+error:
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Read a subtree with expansion root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_expansion(isl_stream *s)
+{
+	isl_ctx *ctx;
+	isl_union_pw_multi_aff *contraction = NULL;
+	isl_union_map *expansion = NULL;
+	isl_schedule_tree *tree = NULL;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	do {
+		struct isl_token *tok;
+		enum isl_schedule_key key;
+		char *str;
+
+		key = get_key(s);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+
+		switch (key) {
+		case isl_schedule_key_contraction:
+			isl_union_pw_multi_aff_free(contraction);
+			tok = isl_stream_next_token(s);
+			str = isl_token_get_str(ctx, tok);
+			contraction = isl_union_pw_multi_aff_read_from_str(ctx,
+									str);
+			free(str);
+			isl_token_free(tok);
+			if (!contraction)
+				goto error;
+			break;
+		case isl_schedule_key_expansion:
+			isl_union_map_free(expansion);
+			tok = isl_stream_next_token(s);
+			str = isl_token_get_str(ctx, tok);
+			expansion = isl_union_map_read_from_str(ctx, str);
+			free(str);
+			isl_token_free(tok);
+			if (!expansion)
+				goto error;
+			break;
+		case isl_schedule_key_child:
+			isl_schedule_tree_free(tree);
+			tree = isl_stream_read_schedule_tree(s);
+			if (!tree)
+				goto error;
+			break;
+		default:
+			isl_die(ctx, isl_error_invalid, "unexpected key",
+				goto error);
+		}
+	} while ((more = isl_stream_yaml_next(s)) > 0);
+
+	if (more < 0)
+		goto error;
+
+	if (!contraction)
+		isl_die(ctx, isl_error_invalid, "missing contraction",
+			goto error);
+	if (!expansion)
+		isl_die(ctx, isl_error_invalid, "missing expansion",
+			goto error);
+
+	if (!tree)
+		return isl_schedule_tree_from_expansion(contraction, expansion);
+	return isl_schedule_tree_insert_expansion(tree, contraction, expansion);
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_pw_multi_aff_free(contraction);
+	isl_union_map_free(expansion);
+	return NULL;
+}
+
+/* Read a subtree with extension root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_extension(isl_stream *s)
+{
+	isl_union_map *extension = NULL;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	extension = isl_union_map_read_from_str(ctx, str);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		tree = isl_schedule_tree_from_extension(extension);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_extension(tree, extension);
+	}
+
+	return tree;
+error:
+	isl_union_map_free(extension);
+	return NULL;
+}
+
+/* Read a subtree with filter root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_filter(__isl_keep isl_stream *s)
+{
+	isl_union_set *filter = NULL;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	filter = isl_union_set_read_from_str(ctx, str);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		tree = isl_schedule_tree_from_filter(filter);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_filter(tree, filter);
+	}
+
+	return tree;
+error:
+	isl_union_set_free(filter);
+	return NULL;
+}
+
+/* Read a subtree with guard root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_guard(isl_stream *s)
+{
+	isl_set *guard = NULL;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	guard = isl_set_read_from_str(ctx, str);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		tree = isl_schedule_tree_from_guard(guard);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_guard(tree, guard);
+	}
+
+	return tree;
+error:
+	isl_set_free(guard);
+	return NULL;
+}
+
+/* Read a subtree with mark root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_mark(isl_stream *s)
+{
+	isl_id *mark;
+	isl_schedule_tree *tree;
+	isl_ctx *ctx;
+	struct isl_token *tok;
+	enum isl_schedule_key key;
+	char *str;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	key = get_key(s);
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		isl_stream_error(s, NULL, "unexpected EOF");
+		return NULL;
+	}
+	str = isl_token_get_str(ctx, tok);
+	mark = isl_id_alloc(ctx, str, NULL);
+	free(str);
+	isl_token_free(tok);
+
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		goto error;
+	if (!more) {
+		isl_die(ctx, isl_error_invalid, "expecting child",
+			goto error);
+	} else {
+		key = get_key(s);
+		if (key != isl_schedule_key_child)
+			isl_die(ctx, isl_error_invalid, "expecting child",
+				goto error);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+		tree = isl_stream_read_schedule_tree(s);
+		tree = isl_schedule_tree_insert_mark(tree, mark);
+	}
+
+	return tree;
+error:
+	isl_id_free(mark);
+	return NULL;
+}
+
+/* Read a sequence of integers from "s" (representing the coincident
+ * property of a band node).
+ */
+static __isl_give isl_val_list *read_coincident(__isl_keep isl_stream *s)
+{
+	isl_ctx *ctx;
+	isl_val_list *list;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	if (isl_stream_yaml_read_start_sequence(s) < 0)
+		return NULL;
+
+	list = isl_val_list_alloc(ctx, 0);
+	while  ((more = isl_stream_yaml_next(s)) > 0) {
+		isl_val *val;
+
+		val = isl_stream_read_val(s);
+		list = isl_val_list_add(list, val);
+	}
+
+	if (more < 0 || isl_stream_yaml_read_end_sequence(s))
+		list = isl_val_list_free(list);
+
+	return list;
+}
+
+/* Set the (initial) coincident properties of "band" according to
+ * the (initial) elements of "coincident".
+ */
+static __isl_give isl_schedule_band *set_coincident(
+	__isl_take isl_schedule_band *band, __isl_take isl_val_list *coincident)
+{
+	int i;
+	isl_size n, m;
+
+	n = isl_schedule_band_n_member(band);
+	m = isl_val_list_n_val(coincident);
+	if (n < 0 || m < 0)
+		band = isl_schedule_band_free(band);
+
+	for (i = 0; i < n && i < m; ++i) {
+		isl_val *v;
+
+		v = isl_val_list_get_val(coincident, i);
+		if (!v)
+			band = isl_schedule_band_free(band);
+		band = isl_schedule_band_member_set_coincident(band, i,
+							!isl_val_is_zero(v));
+		isl_val_free(v);
+	}
+	isl_val_list_free(coincident);
+	return band;
+}
+
+/* Read a subtree with band root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_band(isl_stream *s)
+{
+	isl_multi_union_pw_aff *schedule = NULL;
+	isl_schedule_tree *tree = NULL;
+	isl_val_list *coincident = NULL;
+	isl_union_set *options = NULL;
+	isl_ctx *ctx;
+	isl_schedule_band *band;
+	int permutable = 0;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	do {
+		struct isl_token *tok;
+		enum isl_schedule_key key;
+		char *str;
+		isl_val *v;
+
+		key = get_key(s);
+		if (isl_stream_yaml_next(s) < 0)
+			goto error;
+
+		switch (key) {
+		case isl_schedule_key_schedule:
+			schedule = isl_multi_union_pw_aff_free(schedule);
+			tok = isl_stream_next_token(s);
+			if (!tok) {
+				isl_stream_error(s, NULL, "unexpected EOF");
+				goto error;
+			}
+			str = isl_token_get_str(ctx, tok);
+			schedule = isl_multi_union_pw_aff_read_from_str(ctx,
+									str);
+			free(str);
+			isl_token_free(tok);
+			if (!schedule)
+				goto error;
+			break;
+		case isl_schedule_key_coincident:
+			coincident = read_coincident(s);
+			if (!coincident)
+				goto error;
+			break;
+		case isl_schedule_key_permutable:
+			v = isl_stream_read_val(s);
+			permutable = !isl_val_is_zero(v);
+			isl_val_free(v);
+			break;
+		case isl_schedule_key_options:
+			isl_union_set_free(options);
+			tok = isl_stream_next_token(s);
+			str = isl_token_get_str(ctx, tok);
+			options = isl_union_set_read_from_str(ctx, str);
+			free(str);
+			isl_token_free(tok);
+			if (!options)
+				goto error;
+			break;
+		case isl_schedule_key_child:
+			isl_schedule_tree_free(tree);
+			tree = isl_stream_read_schedule_tree(s);
+			if (!tree)
+				goto error;
+			break;
+		default:
+			isl_die(ctx, isl_error_invalid, "unexpected key",
+				goto error);
+		}
+	} while ((more = isl_stream_yaml_next(s)) > 0);
+
+	if (more < 0)
+		goto error;
+
+	if (!schedule)
+		isl_die(ctx, isl_error_invalid, "missing schedule", goto error);
+
+	band = isl_schedule_band_from_multi_union_pw_aff(schedule);
+	band = isl_schedule_band_set_permutable(band, permutable);
+	if (coincident)
+		band = set_coincident(band, coincident);
+	if (options)
+		band = isl_schedule_band_set_ast_build_options(band, options);
+	if (tree)
+		tree = isl_schedule_tree_insert_band(tree, band);
+	else
+		tree = isl_schedule_tree_from_band(band);
+
+	return tree;
+error:
+	isl_val_list_free(coincident);
+	isl_union_set_free(options);
+	isl_schedule_tree_free(tree);
+	isl_multi_union_pw_aff_free(schedule);
+	return NULL;
+}
+
+/* Read a subtree with root node of type "type" from "s".
+ * The node is represented by a sequence of children.
+ */
+static __isl_give isl_schedule_tree *read_children(isl_stream *s,
+	enum isl_schedule_node_type type)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree_list *list;
+	int more;
+
+	ctx = isl_stream_get_ctx(s);
+
+	isl_token_free(isl_stream_next_token(s));
+
+	if (isl_stream_yaml_next(s) < 0)
+		return NULL;
+
+	if (isl_stream_yaml_read_start_sequence(s))
+		return NULL;
+
+	list = isl_schedule_tree_list_alloc(ctx, 0);
+	while ((more = isl_stream_yaml_next(s)) > 0) {
+		isl_schedule_tree *tree;
+
+		tree = isl_stream_read_schedule_tree(s);
+		list = isl_schedule_tree_list_add(list, tree);
+	}
+
+	if (more < 0 || isl_stream_yaml_read_end_sequence(s))
+		list = isl_schedule_tree_list_free(list);
+
+	return isl_schedule_tree_from_children(type, list);
+}
+
+/* Read a subtree with sequence root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_sequence(isl_stream *s)
+{
+	return read_children(s, isl_schedule_node_sequence);
+}
+
+/* Read a subtree with set root node from "s".
+ */
+static __isl_give isl_schedule_tree *read_set(isl_stream *s)
+{
+	return read_children(s, isl_schedule_node_set);
+}
+
+/* Read a schedule (sub)tree from "s".
+ *
+ * We first determine the type of the root node based on the first
+ * mapping key and then hand over to a function tailored to reading
+ * nodes of this type.
+ */
+static __isl_give isl_schedule_tree *isl_stream_read_schedule_tree(
+	struct isl_stream *s)
+{
+	enum isl_schedule_key key;
+	struct isl_token *tok;
+	isl_schedule_tree *tree = NULL;
+	int more;
+
+	if (isl_stream_yaml_read_start_mapping(s))
+		return NULL;
+	more = isl_stream_yaml_next(s);
+	if (more < 0)
+		return NULL;
+	if (!more) {
+		isl_stream_error(s, NULL, "missing key");
+		return NULL;
+	}
+
+	tok = isl_stream_next_token(s);
+	key = extract_key(s, tok);
+	isl_stream_push_token(s, tok);
+	if (key < 0)
+		return NULL;
+	switch (key) {
+	case isl_schedule_key_context:
+		tree = read_context(s);
+		break;
+	case isl_schedule_key_domain:
+		tree = read_domain(s);
+		break;
+	case isl_schedule_key_contraction:
+	case isl_schedule_key_expansion:
+		tree = read_expansion(s);
+		break;
+	case isl_schedule_key_extension:
+		tree = read_extension(s);
+		break;
+	case isl_schedule_key_filter:
+		tree = read_filter(s);
+		break;
+	case isl_schedule_key_guard:
+		tree = read_guard(s);
+		break;
+	case isl_schedule_key_leaf:
+		isl_token_free(isl_stream_next_token(s));
+		tree = isl_schedule_tree_leaf(isl_stream_get_ctx(s));
+		break;
+	case isl_schedule_key_mark:
+		tree = read_mark(s);
+		break;
+	case isl_schedule_key_sequence:
+		tree = read_sequence(s);
+		break;
+	case isl_schedule_key_set:
+		tree = read_set(s);
+		break;
+	case isl_schedule_key_schedule:
+	case isl_schedule_key_coincident:
+	case isl_schedule_key_options:
+	case isl_schedule_key_permutable:
+		tree = read_band(s);
+		break;
+	case isl_schedule_key_child:
+		isl_die(isl_stream_get_ctx(s), isl_error_unsupported,
+			"cannot identify node type", return NULL);
+	case isl_schedule_key_end:
+	case isl_schedule_key_error:
+		return NULL;
+	}
+
+	if (isl_stream_yaml_read_end_mapping(s) < 0) {
+		isl_stream_error(s, NULL, "unexpected extra elements");
+		return isl_schedule_tree_free(tree);
+	}
+
+	return tree;
+}
+
+/* Read an isl_schedule from "s".
+ */
+__isl_give isl_schedule *isl_stream_read_schedule(isl_stream *s)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!s)
+		return NULL;
+
+	ctx = isl_stream_get_ctx(s);
+	tree = isl_stream_read_schedule_tree(s);
+	return isl_schedule_from_schedule_tree(ctx, tree);
+}
+
+/* Read an isl_schedule from "input".
+ */
+__isl_give isl_schedule *isl_schedule_read_from_file(isl_ctx *ctx, FILE *input)
+{
+	struct isl_stream *s;
+	isl_schedule *schedule;
+
+	s = isl_stream_new_file(ctx, input);
+	if (!s)
+		return NULL;
+	schedule = isl_stream_read_schedule(s);
+	isl_stream_free(s);
+
+	return schedule;
+}
+
+/* Read an isl_schedule from "str".
+ */
+__isl_give isl_schedule *isl_schedule_read_from_str(isl_ctx *ctx,
+	const char *str)
+{
+	struct isl_stream *s;
+	isl_schedule *schedule;
+
+	s = isl_stream_new_str(ctx, str);
+	if (!s)
+		return NULL;
+	schedule = isl_stream_read_schedule(s);
+	isl_stream_free(s);
+
+	return schedule;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_tree.c Added

@@ -0,0 +1,2906 @@
+/*
+ * Copyright 2013-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      INRIA Paris
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
+ * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
+ * CS 42112, 75589 Paris Cedex 12, France
+ */
+
+#include <isl/id.h>
+#include <isl/val.h>
+#include <isl/space.h>
+#include <isl/map.h>
+#include <isl_schedule_band.h>
+#include <isl_schedule_private.h>
+
+#undef EL
+#define EL isl_schedule_tree
+
+#include <isl_list_templ.h>
+
+#undef EL_BASE
+#define EL_BASE schedule_tree
+
+#include <isl_list_templ.c>
+
+/* Is "tree" the leaf of a schedule tree?
+ */
+int isl_schedule_tree_is_leaf(__isl_keep isl_schedule_tree *tree)
+{
+	return isl_schedule_tree_get_type(tree) == isl_schedule_node_leaf;
+}
+
+/* Create a new schedule tree of type "type".
+ * The caller is responsible for filling in the type specific fields and
+ * the children.
+ *
+ * By default, the single node tree does not have any anchored nodes.
+ * The caller is responsible for updating the anchored field if needed.
+ */
+static __isl_give isl_schedule_tree *isl_schedule_tree_alloc(isl_ctx *ctx,
+	enum isl_schedule_node_type type)
+{
+	isl_schedule_tree *tree;
+
+	if (type == isl_schedule_node_error)
+		return NULL;
+
+	tree = isl_calloc_type(ctx, isl_schedule_tree);
+	if (!tree)
+		return NULL;
+
+	tree->ref = 1;
+	tree->ctx = ctx;
+	isl_ctx_ref(ctx);
+	tree->type = type;
+	tree->anchored = 0;
+
+	return tree;
+}
+
+/* Return a fresh copy of "tree".
+ */
+__isl_take isl_schedule_tree *isl_schedule_tree_dup(
+	__isl_keep isl_schedule_tree *tree)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *dup;
+
+	if (!tree)
+		return NULL;
+
+	ctx = isl_schedule_tree_get_ctx(tree);
+	dup = isl_schedule_tree_alloc(ctx, tree->type);
+	if (!dup)
+		return NULL;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		isl_die(ctx, isl_error_internal,
+			"allocation should have failed",
+			return isl_schedule_tree_free(dup));
+	case isl_schedule_node_band:
+		dup->band = isl_schedule_band_copy(tree->band);
+		if (!dup->band)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_context:
+		dup->context = isl_set_copy(tree->context);
+		if (!dup->context)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_domain:
+		dup->domain = isl_union_set_copy(tree->domain);
+		if (!dup->domain)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_expansion:
+		dup->contraction =
+			isl_union_pw_multi_aff_copy(tree->contraction);
+		dup->expansion = isl_union_map_copy(tree->expansion);
+		if (!dup->contraction || !dup->expansion)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_extension:
+		dup->extension = isl_union_map_copy(tree->extension);
+		if (!dup->extension)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_filter:
+		dup->filter = isl_union_set_copy(tree->filter);
+		if (!dup->filter)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_guard:
+		dup->guard = isl_set_copy(tree->guard);
+		if (!dup->guard)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_mark:
+		dup->mark = isl_id_copy(tree->mark);
+		if (!dup->mark)
+			return isl_schedule_tree_free(dup);
+		break;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	}
+
+	if (tree->children) {
+		dup->children = isl_schedule_tree_list_copy(tree->children);
+		if (!dup->children)
+			return isl_schedule_tree_free(dup);
+	}
+	dup->anchored = tree->anchored;
+
+	return dup;
+}
+
+/* Return an isl_schedule_tree that is equal to "tree" and that has only
+ * a single reference.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_cow(
+	__isl_take isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->ref == 1)
+		return tree;
+	tree->ref--;
+	return isl_schedule_tree_dup(tree);
+}
+
+/* Return a new reference to "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_copy(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	tree->ref++;
+	return tree;
+}
+
+/* Free "tree" and return NULL.
+ */
+__isl_null isl_schedule_tree *isl_schedule_tree_free(
+	__isl_take isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+	if (--tree->ref > 0)
+		return NULL;
+
+	switch (tree->type) {
+	case isl_schedule_node_band:
+		isl_schedule_band_free(tree->band);
+		break;
+	case isl_schedule_node_context:
+		isl_set_free(tree->context);
+		break;
+	case isl_schedule_node_domain:
+		isl_union_set_free(tree->domain);
+		break;
+	case isl_schedule_node_expansion:
+		isl_union_pw_multi_aff_free(tree->contraction);
+		isl_union_map_free(tree->expansion);
+		break;
+	case isl_schedule_node_extension:
+		isl_union_map_free(tree->extension);
+		break;
+	case isl_schedule_node_filter:
+		isl_union_set_free(tree->filter);
+		break;
+	case isl_schedule_node_guard:
+		isl_set_free(tree->guard);
+		break;
+	case isl_schedule_node_mark:
+		isl_id_free(tree->mark);
+		break;
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+	case isl_schedule_node_error:
+	case isl_schedule_node_leaf:
+		break;
+	}
+	isl_schedule_tree_list_free(tree->children);
+	isl_ctx_deref(tree->ctx);
+	free(tree);
+
+	return NULL;
+}
+
+/* Create and return a new leaf schedule tree.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_leaf(isl_ctx *ctx)
+{
+	return isl_schedule_tree_alloc(ctx, isl_schedule_node_leaf);
+}
+
+/* Create a new band schedule tree referring to "band"
+ * with no children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_band(
+	__isl_take isl_schedule_band *band)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!band)
+		return NULL;
+
+	ctx = isl_schedule_band_get_ctx(band);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_band);
+	if (!tree)
+		goto error;
+
+	tree->band = band;
+	tree->anchored = isl_schedule_band_is_anchored(band);
+
+	return tree;
+error:
+	isl_schedule_band_free(band);
+	return NULL;
+}
+
+/* Create a new context schedule tree with the given context and no children.
+ * Since the context references the outer schedule dimension,
+ * the tree is anchored.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_context(
+	__isl_take isl_set *context)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!context)
+		return NULL;
+
+	ctx = isl_set_get_ctx(context);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_context);
+	if (!tree)
+		goto error;
+
+	tree->context = context;
+	tree->anchored = 1;
+
+	return tree;
+error:
+	isl_set_free(context);
+	return NULL;
+}
+
+/* Create a new domain schedule tree with the given domain and no children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_domain(
+	__isl_take isl_union_set *domain)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!domain)
+		return NULL;
+
+	ctx = isl_union_set_get_ctx(domain);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_domain);
+	if (!tree)
+		goto error;
+
+	tree->domain = domain;
+
+	return tree;
+error:
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Create a new expansion schedule tree with the given contraction and
+ * expansion and no children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_expansion(
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!contraction || !expansion)
+		goto error;
+
+	ctx = isl_union_map_get_ctx(expansion);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_expansion);
+	if (!tree)
+		goto error;
+
+	tree->contraction = contraction;
+	tree->expansion = expansion;
+
+	return tree;
+error:
+	isl_union_pw_multi_aff_free(contraction);
+	isl_union_map_free(expansion);
+	return NULL;
+}
+
+/* Create a new extension schedule tree with the given extension and
+ * no children.
+ * Since the domain of the extension refers to the outer schedule dimension,
+ * the tree is anchored.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_extension(
+	__isl_take isl_union_map *extension)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!extension)
+		return NULL;
+
+	ctx = isl_union_map_get_ctx(extension);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_extension);
+	if (!tree)
+		goto error;
+
+	tree->extension = extension;
+	tree->anchored = 1;
+
+	return tree;
+error:
+	isl_union_map_free(extension);
+	return NULL;
+}
+
+/* Create a new filter schedule tree with the given filter and no children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_filter(
+	__isl_take isl_union_set *filter)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!filter)
+		return NULL;
+
+	ctx = isl_union_set_get_ctx(filter);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_filter);
+	if (!tree)
+		goto error;
+
+	tree->filter = filter;
+
+	return tree;
+error:
+	isl_union_set_free(filter);
+	return NULL;
+}
+
+/* Create a new guard schedule tree with the given guard and no children.
+ * Since the guard references the outer schedule dimension,
+ * the tree is anchored.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_guard(
+	__isl_take isl_set *guard)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!guard)
+		return NULL;
+
+	ctx = isl_set_get_ctx(guard);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_guard);
+	if (!tree)
+		goto error;
+
+	tree->guard = guard;
+	tree->anchored = 1;
+
+	return tree;
+error:
+	isl_set_free(guard);
+	return NULL;
+}
+
+/* Create a new mark schedule tree with the given mark identifier and
+ * no children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_mark(
+	__isl_take isl_id *mark)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!mark)
+		return NULL;
+
+	ctx = isl_id_get_ctx(mark);
+	tree = isl_schedule_tree_alloc(ctx, isl_schedule_node_mark);
+	if (!tree)
+		goto error;
+
+	tree->mark = mark;
+
+	return tree;
+error:
+	isl_id_free(mark);
+	return NULL;
+}
+
+/* Does "tree" have any node that depends on its position
+ * in the complete schedule tree?
+ */
+isl_bool isl_schedule_tree_is_subtree_anchored(
+	__isl_keep isl_schedule_tree *tree)
+{
+	return tree ? isl_bool_ok(tree->anchored) : isl_bool_error;
+}
+
+/* Does the root node of "tree" depend on its position in the complete
+ * schedule tree?
+ * Band nodes may be anchored depending on the associated AST build options.
+ * Context, extension and guard nodes are always anchored.
+ */
+int isl_schedule_tree_is_anchored(__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return -1;
+
+	switch (isl_schedule_tree_get_type(tree)) {
+	case isl_schedule_node_error:
+		return -1;
+	case isl_schedule_node_band:
+		return isl_schedule_band_is_anchored(tree->band);
+	case isl_schedule_node_context:
+	case isl_schedule_node_extension:
+	case isl_schedule_node_guard:
+		return 1;
+	case isl_schedule_node_domain:
+	case isl_schedule_node_expansion:
+	case isl_schedule_node_filter:
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		return 0;
+	}
+
+	isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+		"unhandled case", return -1);
+}
+
+/* Update the anchored field of "tree" based on whether the root node
+ * itself in anchored and the anchored fields of the children.
+ *
+ * This function should be called whenever the children of a tree node
+ * are changed or the anchoredness of the tree root itself changes.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_update_anchored(
+	__isl_take isl_schedule_tree *tree)
+{
+	int i;
+	isl_size n;
+	int anchored;
+
+	anchored = isl_schedule_tree_is_anchored(tree);
+	n = isl_schedule_tree_n_children(tree);
+	if (anchored < 0 || n < 0)
+		return isl_schedule_tree_free(tree);
+
+	for (i = 0; !anchored && i < n; ++i) {
+		isl_schedule_tree *child;
+
+		child = isl_schedule_tree_get_child(tree, i);
+		if (!child)
+			return isl_schedule_tree_free(tree);
+		anchored = child->anchored;
+		isl_schedule_tree_free(child);
+	}
+
+	if (anchored == tree->anchored)
+		return tree;
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+	tree->anchored = anchored;
+	return tree;
+}
+
+/* Create a new tree of the given type (isl_schedule_node_sequence or
+ * isl_schedule_node_set) with the given children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_children(
+	enum isl_schedule_node_type type,
+	__isl_take isl_schedule_tree_list *list)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree *tree;
+
+	if (!list)
+		return NULL;
+
+	ctx = isl_schedule_tree_list_get_ctx(list);
+	tree = isl_schedule_tree_alloc(ctx, type);
+	if (!tree)
+		goto error;
+
+	tree->children = list;
+	tree = isl_schedule_tree_update_anchored(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_list_free(list);
+	return NULL;
+}
+
+/* Construct a tree with a root node of type "type" and as children
+ * "tree1" and "tree2".
+ * If the root of one (or both) of the input trees is itself of type "type",
+ * then the tree is replaced by its children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_from_pair(
+	enum isl_schedule_node_type type, __isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2)
+{
+	isl_ctx *ctx;
+	isl_schedule_tree_list *list;
+
+	if (!tree1 || !tree2)
+		goto error;
+
+	ctx = isl_schedule_tree_get_ctx(tree1);
+	if (isl_schedule_tree_get_type(tree1) == type) {
+		list = isl_schedule_tree_list_copy(tree1->children);
+		isl_schedule_tree_free(tree1);
+	} else {
+		list = isl_schedule_tree_list_alloc(ctx, 2);
+		list = isl_schedule_tree_list_add(list, tree1);
+	}
+	if (isl_schedule_tree_get_type(tree2) == type) {
+		isl_schedule_tree_list *children;
+
+		children = isl_schedule_tree_list_copy(tree2->children);
+		list = isl_schedule_tree_list_concat(list, children);
+		isl_schedule_tree_free(tree2);
+	} else {
+		list = isl_schedule_tree_list_add(list, tree2);
+	}
+
+	return isl_schedule_tree_from_children(type, list);
+error:
+	isl_schedule_tree_free(tree1);
+	isl_schedule_tree_free(tree2);
+	return NULL;
+}
+
+/* Construct a tree with a sequence root node and as children
+ * "tree1" and "tree2".
+ * If the root of one (or both) of the input trees is itself a sequence,
+ * then the tree is replaced by its children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_sequence_pair(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2)
+{
+	return isl_schedule_tree_from_pair(isl_schedule_node_sequence,
+						tree1, tree2);
+}
+
+/* Construct a tree with a set root node and as children
+ * "tree1" and "tree2".
+ * If the root of one (or both) of the input trees is itself a set,
+ * then the tree is replaced by its children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_set_pair(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2)
+{
+	return isl_schedule_tree_from_pair(isl_schedule_node_set, tree1, tree2);
+}
+
+/* Return the isl_ctx to which "tree" belongs.
+ */
+isl_ctx *isl_schedule_tree_get_ctx(__isl_keep isl_schedule_tree *tree)
+{
+	return tree ? tree->ctx : NULL;
+}
+
+/* Return the type of the root of the tree or isl_schedule_node_error
+ * on error.
+ */
+enum isl_schedule_node_type isl_schedule_tree_get_type(
+	__isl_keep isl_schedule_tree *tree)
+{
+	return tree ? tree->type : isl_schedule_node_error;
+}
+
+/* Are "tree1" and "tree2" obviously equal to each other?
+ */
+isl_bool isl_schedule_tree_plain_is_equal(__isl_keep isl_schedule_tree *tree1,
+	__isl_keep isl_schedule_tree *tree2)
+{
+	isl_bool equal;
+	int i;
+	isl_size n1, n2;
+
+	if (!tree1 || !tree2)
+		return isl_bool_error;
+	if (tree1 == tree2)
+		return isl_bool_true;
+	if (tree1->type != tree2->type)
+		return isl_bool_false;
+
+	switch (tree1->type) {
+	case isl_schedule_node_band:
+		equal = isl_schedule_band_plain_is_equal(tree1->band,
+							tree2->band);
+		break;
+	case isl_schedule_node_context:
+		equal = isl_set_is_equal(tree1->context, tree2->context);
+		break;
+	case isl_schedule_node_domain:
+		equal = isl_union_set_is_equal(tree1->domain, tree2->domain);
+		break;
+	case isl_schedule_node_expansion:
+		equal = isl_union_map_is_equal(tree1->expansion,
+						tree2->expansion);
+		if (equal >= 0 && equal)
+			equal = isl_union_pw_multi_aff_plain_is_equal(
+				    tree1->contraction, tree2->contraction);
+		break;
+	case isl_schedule_node_extension:
+		equal = isl_union_map_is_equal(tree1->extension,
+						tree2->extension);
+		break;
+	case isl_schedule_node_filter:
+		equal = isl_union_set_is_equal(tree1->filter, tree2->filter);
+		break;
+	case isl_schedule_node_guard:
+		equal = isl_set_is_equal(tree1->guard, tree2->guard);
+		break;
+	case isl_schedule_node_mark:
+		equal = isl_bool_ok(tree1->mark == tree2->mark);
+		break;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		equal = isl_bool_true;
+		break;
+	case isl_schedule_node_error:
+		equal = isl_bool_error;
+		break;
+	}
+
+	if (equal < 0 || !equal)
+		return equal;
+
+	n1 = isl_schedule_tree_n_children(tree1);
+	n2 = isl_schedule_tree_n_children(tree2);
+	if (n1 < 0 || n2 < 0)
+		return isl_bool_error;
+	if (n1 != n2)
+		return isl_bool_false;
+	for (i = 0; i < n1; ++i) {
+		isl_schedule_tree *child1, *child2;
+
+		child1 = isl_schedule_tree_get_child(tree1, i);
+		child2 = isl_schedule_tree_get_child(tree2, i);
+		equal = isl_schedule_tree_plain_is_equal(child1, child2);
+		isl_schedule_tree_free(child1);
+		isl_schedule_tree_free(child2);
+
+		if (equal < 0 || !equal)
+			return equal;
+	}
+
+	return isl_bool_true;
+}
+
+/* Does "tree" have any children, other than an implicit leaf.
+ */
+int isl_schedule_tree_has_children(__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return -1;
+
+	return tree->children != NULL;
+}
+
+/* Return the number of children of "tree", excluding implicit leaves.
+ * The "children" field is NULL if there are
+ * no children (except for the implicit leaves).
+ */
+isl_size isl_schedule_tree_n_children(__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return isl_size_error;
+
+	if (!tree->children)
+		return 0;
+	return isl_schedule_tree_list_n_schedule_tree(tree->children);
+}
+
+/* Return a copy of the (explicit) child at position "pos" of "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_get_child(
+	__isl_keep isl_schedule_tree *tree, int pos)
+{
+	if (!tree)
+		return NULL;
+	if (!tree->children)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"schedule tree has no explicit children", return NULL);
+	return isl_schedule_tree_list_get_schedule_tree(tree->children, pos);
+}
+
+/* Return a copy of the (explicit) child at position "pos" of "tree" and
+ * free "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_child(
+	__isl_take isl_schedule_tree *tree, int pos)
+{
+	isl_schedule_tree *child;
+
+	child = isl_schedule_tree_get_child(tree, pos);
+	isl_schedule_tree_free(tree);
+	return child;
+}
+
+/* Remove all (explicit) children from "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_reset_children(
+	__isl_take isl_schedule_tree *tree)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+	tree->children = isl_schedule_tree_list_free(tree->children);
+	return tree;
+}
+
+/* Remove the child at position "pos" from the children of "tree".
+ * If there was only one child to begin with, then remove all children.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_drop_child(
+	__isl_take isl_schedule_tree *tree, int pos)
+{
+	isl_size n;
+
+	tree = isl_schedule_tree_cow(tree);
+
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0)
+		return isl_schedule_tree_free(tree);
+	if (n == 0)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"tree does not have any explicit children",
+			return isl_schedule_tree_free(tree));
+	if (pos < 0 || pos >= n)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"position out of bounds",
+			return isl_schedule_tree_free(tree));
+	if (n == 1)
+		return isl_schedule_tree_reset_children(tree);
+
+	tree->children = isl_schedule_tree_list_drop(tree->children, pos, 1);
+	if (!tree->children)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+}
+
+/* Replace the child at position "pos" of "tree" by "child".
+ *
+ * If the new child is a leaf, then it is not explicitly
+ * recorded in the list of children.  Instead, the list of children
+ * (which is assumed to have only one element) is removed.
+ * Note that the children of set and sequence nodes are always
+ * filters, so they cannot be replaced by empty trees.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_replace_child(
+	__isl_take isl_schedule_tree *tree, int pos,
+	__isl_take isl_schedule_tree *child)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !child)
+		goto error;
+
+	if (isl_schedule_tree_is_leaf(child)) {
+		isl_size n;
+
+		isl_schedule_tree_free(child);
+		if (!tree->children && pos == 0)
+			return tree;
+		n = isl_schedule_tree_n_children(tree);
+		if (n < 0)
+			return isl_schedule_tree_free(tree);
+		if (n != 1)
+			isl_die(isl_schedule_tree_get_ctx(tree),
+				isl_error_internal,
+				"can only replace single child by leaf",
+				goto error);
+		return isl_schedule_tree_reset_children(tree);
+	}
+
+	if (!tree->children && pos == 0)
+		tree->children =
+			isl_schedule_tree_list_from_schedule_tree(child);
+	else
+		tree->children = isl_schedule_tree_list_set_schedule_tree(
+				tree->children, pos, child);
+
+	if (!tree->children)
+		return isl_schedule_tree_free(tree);
+	tree = isl_schedule_tree_update_anchored(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_schedule_tree_free(child);
+	return NULL;
+}
+
+/* Replace the (explicit) children of "tree" by "children"?
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_set_children(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_schedule_tree_list *children)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !children)
+		goto error;
+	isl_schedule_tree_list_free(tree->children);
+	tree->children = children;
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_schedule_tree_list_free(children);
+	return NULL;
+}
+
+/* Create a new band schedule tree referring to "band"
+ * with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_band(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_schedule_band *band)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_band(band);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new context schedule tree with the given context and
+ * with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_context(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_set *context)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_context(context);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new domain schedule tree with the given domain and
+ * with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_domain(domain);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new expansion schedule tree with the given contraction and
+ * expansion and with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_expansion(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_expansion(contraction, expansion);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new extension schedule tree with the given extension and
+ * with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_extension(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_map *extension)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_extension(extension);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new filter schedule tree with the given filter and single child.
+ *
+ * If the root of "tree" is itself a filter node, then the two
+ * filter nodes are merged into one node.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter)
+{
+	isl_schedule_tree *res;
+
+	if (isl_schedule_tree_get_type(tree) == isl_schedule_node_filter) {
+		isl_union_set *tree_filter;
+
+		tree_filter = isl_schedule_tree_filter_get_filter(tree);
+		tree_filter = isl_union_set_intersect(tree_filter, filter);
+		tree = isl_schedule_tree_filter_set_filter(tree, tree_filter);
+		return tree;
+	}
+
+	res = isl_schedule_tree_from_filter(filter);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Insert a filter node with filter set "filter"
+ * in each of the children of "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_children_insert_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter)
+{
+	int i;
+	isl_size n;
+
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0 || !filter)
+		goto error;
+
+	for (i = 0; i < n; ++i) {
+		isl_schedule_tree *child;
+
+		child = isl_schedule_tree_get_child(tree, i);
+		child = isl_schedule_tree_insert_filter(child,
+						    isl_union_set_copy(filter));
+		tree = isl_schedule_tree_replace_child(tree, i, child);
+	}
+
+	isl_union_set_free(filter);
+	return tree;
+error:
+	isl_union_set_free(filter);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Create a new guard schedule tree with the given guard and
+ * with "tree" as single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_guard(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_set *guard)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_guard(guard);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Create a new mark schedule tree with the given mark identifier and
+ * single child.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_mark(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_id *mark)
+{
+	isl_schedule_tree *res;
+
+	res = isl_schedule_tree_from_mark(mark);
+	return isl_schedule_tree_replace_child(res, 0, tree);
+}
+
+/* Return the number of members in the band tree root.
+ */
+isl_size isl_schedule_tree_band_n_member(__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return isl_size_error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_size_error);
+
+	return isl_schedule_band_n_member(tree->band);
+}
+
+/* Is the band member at position "pos" of the band tree root
+ * marked coincident?
+ */
+isl_bool isl_schedule_tree_band_member_get_coincident(
+	__isl_keep isl_schedule_tree *tree, int pos)
+{
+	if (!tree)
+		return isl_bool_error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_bool_error);
+
+	return isl_schedule_band_member_get_coincident(tree->band, pos);
+}
+
+/* Mark the given band member as being coincident or not
+ * according to "coincident".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_member_set_coincident(
+	__isl_take isl_schedule_tree *tree, int pos, int coincident)
+{
+	if (!tree)
+		return NULL;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_schedule_tree_free(tree));
+	if (isl_schedule_tree_band_member_get_coincident(tree, pos) ==
+								    coincident)
+		return tree;
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+
+	tree->band = isl_schedule_band_member_set_coincident(tree->band, pos,
+							coincident);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+	return tree;
+}
+
+/* Is the band tree root marked permutable?
+ */
+isl_bool isl_schedule_tree_band_get_permutable(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return isl_bool_error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_bool_error);
+
+	return isl_schedule_band_get_permutable(tree->band);
+}
+
+/* Mark the band tree root permutable or not according to "permutable"?
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_permutable(
+	__isl_take isl_schedule_tree *tree, int permutable)
+{
+	if (!tree)
+		return NULL;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_schedule_tree_free(tree));
+	if (isl_schedule_tree_band_get_permutable(tree) == permutable)
+		return tree;
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+
+	tree->band = isl_schedule_band_set_permutable(tree->band, permutable);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+	return tree;
+}
+
+/* Return the schedule space of the band tree root.
+ */
+__isl_give isl_space *isl_schedule_tree_band_get_space(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return NULL);
+
+	return isl_schedule_band_get_space(tree->band);
+}
+
+/* Intersect the domain of the band schedule of the band tree root
+ * with "domain".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_intersect_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain)
+{
+	if (!tree || !domain)
+		goto error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	tree->band = isl_schedule_band_intersect_domain(tree->band, domain);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Return the schedule of the band tree root in isolation.
+ */
+__isl_give isl_multi_union_pw_aff *isl_schedule_tree_band_get_partial_schedule(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return NULL);
+
+	return isl_schedule_band_get_partial_schedule(tree->band);
+}
+
+/* Replace the schedule of the band tree root by "schedule".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_partial_schedule(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_multi_union_pw_aff *schedule)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !schedule)
+		goto error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return NULL);
+	tree->band = isl_schedule_band_set_partial_schedule(tree->band,
+								schedule);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_multi_union_pw_aff_free(schedule);
+	return NULL;
+}
+
+/* Return the loop AST generation type for the band member
+ * of the band tree root at position "pos".
+ */
+enum isl_ast_loop_type isl_schedule_tree_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_tree *tree, int pos)
+{
+	if (!tree)
+		return isl_ast_loop_error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_ast_loop_error);
+
+	return isl_schedule_band_member_get_ast_loop_type(tree->band, pos);
+}
+
+/* Set the loop AST generation type for the band member of the band tree root
+ * at position "pos" to "type".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_tree *tree, int pos,
+	enum isl_ast_loop_type type)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_schedule_tree_free(tree));
+
+	tree->band = isl_schedule_band_member_set_ast_loop_type(tree->band,
+								pos, type);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+}
+
+/* Return the loop AST generation type for the band member
+ * of the band tree root at position "pos" for the isolated part.
+ */
+enum isl_ast_loop_type isl_schedule_tree_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_tree *tree, int pos)
+{
+	if (!tree)
+		return isl_ast_loop_error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_ast_loop_error);
+
+	return isl_schedule_band_member_get_isolate_ast_loop_type(tree->band,
+									pos);
+}
+
+/* Set the loop AST generation type for the band member of the band tree root
+ * at position "pos" for the isolated part to "type".
+ */
+__isl_give isl_schedule_tree *
+isl_schedule_tree_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_tree *tree, int pos,
+	enum isl_ast_loop_type type)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_schedule_tree_free(tree));
+
+	tree->band = isl_schedule_band_member_set_isolate_ast_loop_type(
+							tree->band, pos, type);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+}
+
+/* Return the AST build options associated to the band tree root.
+ */
+__isl_give isl_union_set *isl_schedule_tree_band_get_ast_build_options(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return NULL);
+
+	return isl_schedule_band_get_ast_build_options(tree->band);
+}
+
+/* Replace the AST build options associated to band tree root by "options".
+ * Updated the anchored field if the anchoredness of the root node itself
+ * changes.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_ast_build_options(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *options)
+{
+	int was_anchored;
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !options)
+		goto error;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	was_anchored = isl_schedule_tree_is_anchored(tree);
+	tree->band = isl_schedule_band_set_ast_build_options(tree->band,
+								options);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+	if (isl_schedule_tree_is_anchored(tree) != was_anchored)
+		tree = isl_schedule_tree_update_anchored(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_set_free(options);
+	return NULL;
+}
+
+/* Return the "isolate" option associated to the band tree root of "tree",
+ * which is assumed to appear at schedule depth "depth".
+ */
+__isl_give isl_set *isl_schedule_tree_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_tree *tree, int depth)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return NULL);
+
+	return isl_schedule_band_get_ast_isolate_option(tree->band, depth);
+}
+
+/* Return the context of the context tree root.
+ */
+__isl_give isl_set *isl_schedule_tree_context_get_context(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_context)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a context node", return NULL);
+
+	return isl_set_copy(tree->context);
+}
+
+/* Return the domain of the domain tree root.
+ */
+__isl_give isl_union_set *isl_schedule_tree_domain_get_domain(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_domain)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a domain node", return NULL);
+
+	return isl_union_set_copy(tree->domain);
+}
+
+/* Replace the domain of domain tree root "tree" by "domain".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_domain_set_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !domain)
+		goto error;
+
+	if (tree->type != isl_schedule_node_domain)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a domain node", goto error);
+
+	isl_union_set_free(tree->domain);
+	tree->domain = domain;
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_set_free(domain);
+	return NULL;
+}
+
+/* Return the contraction of the expansion tree root.
+ */
+__isl_give isl_union_pw_multi_aff *isl_schedule_tree_expansion_get_contraction(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_expansion)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not an expansion node", return NULL);
+
+	return isl_union_pw_multi_aff_copy(tree->contraction);
+}
+
+/* Return the expansion of the expansion tree root.
+ */
+__isl_give isl_union_map *isl_schedule_tree_expansion_get_expansion(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_expansion)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not an expansion node", return NULL);
+
+	return isl_union_map_copy(tree->expansion);
+}
+
+/* Replace the contraction and the expansion of the expansion tree root "tree"
+ * by "contraction" and "expansion".
+ */
+__isl_give isl_schedule_tree *
+isl_schedule_tree_expansion_set_contraction_and_expansion(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !contraction || !expansion)
+		goto error;
+
+	if (tree->type != isl_schedule_node_expansion)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not an expansion node", return NULL);
+
+	isl_union_pw_multi_aff_free(tree->contraction);
+	tree->contraction = contraction;
+	isl_union_map_free(tree->expansion);
+	tree->expansion = expansion;
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_pw_multi_aff_free(contraction);
+	isl_union_map_free(expansion);
+	return NULL;
+}
+
+/* Return the extension of the extension tree root.
+ */
+__isl_give isl_union_map *isl_schedule_tree_extension_get_extension(
+	__isl_take isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_extension)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not an extension node", return NULL);
+
+	return isl_union_map_copy(tree->extension);
+}
+
+/* Replace the extension of extension tree root "tree" by "extension".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_extension_set_extension(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_map *extension)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !extension)
+		goto error;
+
+	if (tree->type != isl_schedule_node_extension)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not an extension node", return NULL);
+	isl_union_map_free(tree->extension);
+	tree->extension = extension;
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_map_free(extension);
+	return NULL;
+}
+
+/* Return the filter of the filter tree root.
+ */
+__isl_give isl_union_set *isl_schedule_tree_filter_get_filter(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_filter)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a filter node", return NULL);
+
+	return isl_union_set_copy(tree->filter);
+}
+
+/* Replace the filter of the filter tree root by "filter".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_filter_set_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter)
+{
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !filter)
+		goto error;
+
+	if (tree->type != isl_schedule_node_filter)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a filter node", return NULL);
+
+	isl_union_set_free(tree->filter);
+	tree->filter = filter;
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_union_set_free(filter);
+	return NULL;
+}
+
+/* Return the guard of the guard tree root.
+ */
+__isl_give isl_set *isl_schedule_tree_guard_get_guard(
+	__isl_take isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_guard)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a guard node", return NULL);
+
+	return isl_set_copy(tree->guard);
+}
+
+/* Return the mark identifier of the mark tree root "tree".
+ */
+__isl_give isl_id *isl_schedule_tree_mark_get_id(
+	__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return NULL;
+
+	if (tree->type != isl_schedule_node_mark)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a mark node", return NULL);
+
+	return isl_id_copy(tree->mark);
+}
+
+/* Set dim to the range dimension of "map" and abort the search.
+ */
+static isl_stat set_range_dim(__isl_take isl_map *map, void *user)
+{
+	isl_size *dim = user;
+
+	*dim = isl_map_dim(map, isl_dim_out);
+	isl_map_free(map);
+
+	return isl_stat_error;
+}
+
+/* Return the dimension of the range of "umap".
+ * "umap" is assumed not to be empty and
+ * all maps inside "umap" are assumed to have the same range.
+ *
+ * We extract the range dimension from the first map in "umap".
+ */
+static isl_size range_dim(__isl_keep isl_union_map *umap)
+{
+	isl_size dim = isl_size_error;
+	isl_size n;
+
+	n = isl_union_map_n_map(umap);
+	if (n < 0)
+		return isl_size_error;
+	if (n == 0)
+		isl_die(isl_union_map_get_ctx(umap), isl_error_internal,
+			"unexpected empty input", return isl_size_error);
+
+	isl_union_map_foreach_map(umap, &set_range_dim, &dim);
+
+	return dim;
+}
+
+/* Append an "extra" number of zeros to the range of "umap" and
+ * return the result.
+ */
+static __isl_give isl_union_map *append_range(__isl_take isl_union_map *umap,
+	int extra)
+{
+	isl_union_set *dom;
+	isl_space *space;
+	isl_multi_val *mv;
+	isl_union_pw_multi_aff *suffix;
+	isl_union_map *universe;
+	isl_union_map *suffix_umap;
+
+	universe = isl_union_map_universe(isl_union_map_copy(umap));
+	dom = isl_union_map_domain(universe);
+	space = isl_union_set_get_space(dom);
+	space = isl_space_set_from_params(space);
+	space = isl_space_add_dims(space, isl_dim_set, extra);
+	mv = isl_multi_val_zero(space);
+
+	suffix = isl_union_pw_multi_aff_multi_val_on_domain(dom, mv);
+	suffix_umap = isl_union_map_from_union_pw_multi_aff(suffix);
+	umap = isl_union_map_flat_range_product(umap, suffix_umap);
+
+	return umap;
+}
+
+/* Should we skip the root of "tree" while looking for the first
+ * descendant with schedule information?
+ * That is, is it impossible to derive any information about
+ * the iteration domain from this node?
+ *
+ * We do not want to skip leaf or error nodes because there is
+ * no point in looking any deeper from these nodes.
+ * We can only extract partial iteration domain information
+ * from an extension node, but extension nodes are not supported
+ * by the caller and it will error out on them.
+ */
+static isl_bool domain_less(__isl_keep isl_schedule_tree *tree)
+{
+	enum isl_schedule_node_type type;
+	isl_size n;
+
+	type = isl_schedule_tree_get_type(tree);
+	switch (type) {
+	case isl_schedule_node_band:
+		n = isl_schedule_tree_band_n_member(tree);
+		return n < 0 ? isl_bool_error : isl_bool_ok(n == 0);
+	case isl_schedule_node_context:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+		return isl_bool_true;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_error:
+	case isl_schedule_node_domain:
+	case isl_schedule_node_expansion:
+	case isl_schedule_node_extension:
+	case isl_schedule_node_filter:
+	case isl_schedule_node_set:
+	case isl_schedule_node_sequence:
+		return isl_bool_false;
+	}
+
+	isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+		"unhandled case", return isl_bool_error);
+}
+
+/* Move down to the first descendant of "tree" that contains any schedule
+ * information or return "leaf" if there is no such descendant.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_first_schedule_descendant(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_tree *leaf)
+{
+	isl_bool down;
+
+	while ((down = domain_less(tree)) == isl_bool_true) {
+		if (!isl_schedule_tree_has_children(tree)) {
+			isl_schedule_tree_free(tree);
+			return isl_schedule_tree_copy(leaf);
+		}
+		tree = isl_schedule_tree_child(tree, 0);
+	}
+
+	if (down < 0)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+}
+
+static __isl_give isl_union_map *subtree_schedule_extend(
+	__isl_keep isl_schedule_tree *tree, __isl_take isl_union_map *outer);
+
+/* Extend the schedule map "outer" with the subtree schedule
+ * of the (single) child of "tree", if any.
+ *
+ * If "tree" does not have any descendants (apart from those that
+ * do not carry any schedule information), then we simply return "outer".
+ * Otherwise, we extend the schedule map "outer" with the subtree schedule
+ * of the single child.
+ */
+static __isl_give isl_union_map *subtree_schedule_extend_child(
+	__isl_keep isl_schedule_tree *tree, __isl_take isl_union_map *outer)
+{
+	isl_schedule_tree *child;
+	isl_union_map *res;
+
+	if (!tree)
+		return isl_union_map_free(outer);
+	if (!isl_schedule_tree_has_children(tree))
+		return outer;
+	child = isl_schedule_tree_get_child(tree, 0);
+	if (!child)
+		return isl_union_map_free(outer);
+	res = subtree_schedule_extend(child, outer);
+	isl_schedule_tree_free(child);
+	return res;
+}
+
+/* Extract the parameter space from one of the children of "tree",
+ * which are assumed to be filters.
+ */
+static __isl_give isl_space *extract_space_from_filter_child(
+	__isl_keep isl_schedule_tree *tree)
+{
+	isl_space *space;
+	isl_union_set *dom;
+	isl_schedule_tree *child;
+
+	child = isl_schedule_tree_list_get_schedule_tree(tree->children, 0);
+	dom = isl_schedule_tree_filter_get_filter(child);
+	space = isl_union_set_get_space(dom);
+	isl_union_set_free(dom);
+	isl_schedule_tree_free(child);
+
+	return space;
+}
+
+/* Extend the schedule map "outer" with the subtree schedule
+ * of a set or sequence node.
+ *
+ * The schedule for the set or sequence node itself is composed of
+ * pieces of the form
+ *
+ *	filter -> 
+ *
+ * or
+ *
+ *	filter -> index
+ *
+ * The first form is used if there is only a single child or
+ * if the current node is a set node and the schedule_separate_components
+ * option is not set.
+ *
+ * Each of the pieces above is extended with the subtree schedule of
+ * the child of the corresponding filter, if any, padded with zeros
+ * to ensure that all pieces have the same range dimension.
+ */
+static __isl_give isl_union_map *subtree_schedule_extend_from_children(
+	__isl_keep isl_schedule_tree *tree, __isl_take isl_union_map *outer)
+{
+	int i;
+	isl_size n;
+	isl_size dim;
+	int separate;
+	isl_ctx *ctx;
+	isl_val *v = NULL;
+	isl_multi_val *mv;
+	isl_space *space;
+	isl_union_map *umap;
+
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0)
+		return isl_union_map_free(outer);
+	if (n == 0)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"missing children", return isl_union_map_free(outer));
+
+	ctx = isl_schedule_tree_get_ctx(tree);
+	separate = n > 1 && (tree->type == isl_schedule_node_sequence ||
+			    isl_options_get_schedule_separate_components(ctx));
+
+	space = isl_space_params_alloc(ctx, 0);
+
+	umap = isl_union_map_empty(isl_space_copy(space));
+	space = isl_space_set_from_params(space);
+	if (separate) {
+		space = isl_space_add_dims(space, isl_dim_set, 1);
+		v = isl_val_zero(ctx);
+	}
+	mv = isl_multi_val_zero(space);
+
+	dim = isl_multi_val_dim(mv, isl_dim_set);
+	if (dim < 0)
+		umap = isl_union_map_free(umap);
+	for (i = 0; i < n; ++i) {
+		isl_multi_val *mv_copy;
+		isl_union_pw_multi_aff *upma;
+		isl_union_map *umap_i;
+		isl_union_set *dom;
+		isl_schedule_tree *child;
+		isl_size dim_i;
+		isl_bool empty;
+
+		child = isl_schedule_tree_list_get_schedule_tree(
+							tree->children, i);
+		dom = isl_schedule_tree_filter_get_filter(child);
+
+		if (separate) {
+			mv = isl_multi_val_set_val(mv, 0, isl_val_copy(v));
+			v = isl_val_add_ui(v, 1);
+		}
+		mv_copy = isl_multi_val_copy(mv);
+		space = isl_union_set_get_space(dom);
+		mv_copy = isl_multi_val_align_params(mv_copy, space);
+		upma = isl_union_pw_multi_aff_multi_val_on_domain(dom, mv_copy);
+		umap_i = isl_union_map_from_union_pw_multi_aff(upma);
+		umap_i = isl_union_map_flat_range_product(
+					    isl_union_map_copy(outer), umap_i);
+		umap_i = subtree_schedule_extend_child(child, umap_i);
+		isl_schedule_tree_free(child);
+
+		empty = isl_union_map_is_empty(umap_i);
+		if (empty < 0)
+			umap_i = isl_union_map_free(umap_i);
+		else if (empty) {
+			isl_union_map_free(umap_i);
+			continue;
+		}
+
+		dim_i = range_dim(umap_i);
+		if (dim_i < 0) {
+			umap = isl_union_map_free(umap);
+		} else if (dim < dim_i) {
+			umap = append_range(umap, dim_i - dim);
+			dim = dim_i;
+		} else if (dim_i < dim) {
+			umap_i = append_range(umap_i, dim - dim_i);
+		}
+		umap = isl_union_map_union(umap, umap_i);
+	}
+
+	isl_val_free(v);
+	isl_multi_val_free(mv);
+	isl_union_map_free(outer);
+
+	return umap;
+}
+
+/* Extend the schedule map "outer" with the subtree schedule of "tree".
+ *
+ * If the root of the tree is a set or a sequence, then we extend
+ * the schedule map in subtree_schedule_extend_from_children.
+ * Otherwise, we extend the schedule map with the partial schedule
+ * corresponding to the root of the tree and then continue with
+ * the single child of this root.
+ * In the special case of an expansion, the schedule map is "extended"
+ * by applying the expansion to the domain of the schedule map.
+ */
+static __isl_give isl_union_map *subtree_schedule_extend(
+	__isl_keep isl_schedule_tree *tree, __isl_take isl_union_map *outer)
+{
+	isl_multi_union_pw_aff *mupa;
+	isl_union_map *umap;
+	isl_union_set *domain;
+	isl_size n;
+
+	if (!tree)
+		return NULL;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		return isl_union_map_free(outer);
+	case isl_schedule_node_extension:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"cannot construct subtree schedule of tree "
+			"with extension nodes",
+			return isl_union_map_free(outer));
+	case isl_schedule_node_context:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+		return subtree_schedule_extend_child(tree, outer);
+	case isl_schedule_node_band:
+		n = isl_schedule_tree_band_n_member(tree);
+		if (n < 0)
+			return isl_union_map_free(outer);
+		if (n == 0)
+			return subtree_schedule_extend_child(tree, outer);
+		mupa = isl_schedule_band_get_partial_schedule(tree->band);
+		umap = isl_union_map_from_multi_union_pw_aff(mupa);
+		outer = isl_union_map_flat_range_product(outer, umap);
+		umap = subtree_schedule_extend_child(tree, outer);
+		break;
+	case isl_schedule_node_domain:
+		domain = isl_schedule_tree_domain_get_domain(tree);
+		umap = isl_union_map_from_domain(domain);
+		outer = isl_union_map_flat_range_product(outer, umap);
+		umap = subtree_schedule_extend_child(tree, outer);
+		break;
+	case isl_schedule_node_expansion:
+		umap = isl_schedule_tree_expansion_get_expansion(tree);
+		outer = isl_union_map_apply_domain(outer, umap);
+		umap = subtree_schedule_extend_child(tree, outer);
+		break;
+	case isl_schedule_node_filter:
+		domain = isl_schedule_tree_filter_get_filter(tree);
+		umap = isl_union_map_from_domain(domain);
+		outer = isl_union_map_flat_range_product(outer, umap);
+		umap = subtree_schedule_extend_child(tree, outer);
+		break;
+	case isl_schedule_node_leaf:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"leaf node should be handled by caller", return NULL);
+	case isl_schedule_node_set:
+	case isl_schedule_node_sequence:
+		umap = subtree_schedule_extend_from_children(tree, outer);
+		break;
+	}
+
+	return umap;
+}
+
+static __isl_give isl_union_set *initial_domain(
+	__isl_keep isl_schedule_tree *tree);
+
+/* Extract a universe domain from the children of the tree root "tree",
+ * which is a set or sequence, meaning that its children are filters.
+ * In particular, return the union of the universes of the filters.
+ */
+static __isl_give isl_union_set *initial_domain_from_children(
+	__isl_keep isl_schedule_tree *tree)
+{
+	int i;
+	isl_size n;
+	isl_space *space;
+	isl_union_set *domain;
+
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0)
+		return NULL;
+	if (n == 0)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"missing children", return NULL);
+
+	space = extract_space_from_filter_child(tree);
+	domain = isl_union_set_empty(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_schedule_tree *child;
+		isl_union_set *domain_i;
+
+		child = isl_schedule_tree_get_child(tree, i);
+		domain_i = initial_domain(child);
+		domain = isl_union_set_union(domain, domain_i);
+		isl_schedule_tree_free(child);
+	}
+
+	return domain;
+}
+
+/* Extract a universe domain from the tree root "tree".
+ * The caller is responsible for making sure that this node
+ * would not be skipped by isl_schedule_tree_first_schedule_descendant
+ * and that it is not a leaf node.
+ */
+static __isl_give isl_union_set *initial_domain(
+	__isl_keep isl_schedule_tree *tree)
+{
+	isl_multi_union_pw_aff *mupa;
+	isl_union_set *domain;
+	isl_union_map *exp;
+	isl_size n;
+
+	if (!tree)
+		return NULL;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		return NULL;
+	case isl_schedule_node_context:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"context node should be handled by caller",
+			return NULL);
+	case isl_schedule_node_guard:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"guard node should be handled by caller",
+			return NULL);
+	case isl_schedule_node_mark:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"mark node should be handled by caller",
+			return NULL);
+	case isl_schedule_node_extension:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"cannot construct subtree schedule of tree "
+			"with extension nodes", return NULL);
+	case isl_schedule_node_band:
+		n = isl_schedule_tree_band_n_member(tree);
+		if (n < 0)
+			return NULL;
+		if (n == 0)
+			isl_die(isl_schedule_tree_get_ctx(tree),
+				isl_error_internal,
+				"0D band should be handled by caller",
+				return NULL);
+		mupa = isl_schedule_band_get_partial_schedule(tree->band);
+		domain = isl_multi_union_pw_aff_domain(mupa);
+		domain = isl_union_set_universe(domain);
+		break;
+	case isl_schedule_node_domain:
+		domain = isl_schedule_tree_domain_get_domain(tree);
+		domain = isl_union_set_universe(domain);
+		break;
+	case isl_schedule_node_expansion:
+		exp = isl_schedule_tree_expansion_get_expansion(tree);
+		exp = isl_union_map_universe(exp);
+		domain = isl_union_map_domain(exp);
+		break;
+	case isl_schedule_node_filter:
+		domain = isl_schedule_tree_filter_get_filter(tree);
+		domain = isl_union_set_universe(domain);
+		break;
+	case isl_schedule_node_leaf:
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+			"leaf node should be handled by caller", return NULL);
+	case isl_schedule_node_set:
+	case isl_schedule_node_sequence:
+		domain = initial_domain_from_children(tree);
+		break;
+	}
+
+	return domain;
+}
+
+/* Return the subtree schedule of a node that contains some schedule
+ * information, i.e., a node that would not be skipped by
+ * isl_schedule_tree_first_schedule_descendant and that is not a leaf.
+ *
+ * If the tree contains any expansions, then the returned subtree
+ * schedule is formulated in terms of the expanded domains.
+ * The tree is not allowed to contain any extension nodes.
+ *
+ * We start with an initial zero-dimensional subtree schedule based
+ * on the domain information in the root node and then extend it
+ * based on the schedule information in the root node and its descendants.
+ */
+__isl_give isl_union_map *isl_schedule_tree_get_subtree_schedule_union_map(
+	__isl_keep isl_schedule_tree *tree)
+{
+	isl_union_set *domain;
+	isl_union_map *umap;
+
+	domain = initial_domain(tree);
+	umap = isl_union_map_from_domain(domain);
+	return subtree_schedule_extend(tree, umap);
+}
+
+/* Multiply the partial schedule of the band root node of "tree"
+ * with the factors in "mv".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_scale(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv)
+{
+	if (!tree || !mv)
+		goto error;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	tree->band = isl_schedule_band_scale(tree->band, mv);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Divide the partial schedule of the band root node of "tree"
+ * by the factors in "mv".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_scale_down(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv)
+{
+	if (!tree || !mv)
+		goto error;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	tree->band = isl_schedule_band_scale_down(tree->band, mv);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Reduce the partial schedule of the band root node of "tree"
+ * modulo the factors in "mv".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_mod(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv)
+{
+	if (!tree || !mv)
+		goto error;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	tree->band = isl_schedule_band_mod(tree->band, mv);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_multi_val_free(mv);
+	return NULL;
+}
+
+/* Shift the partial schedule of the band root node of "tree" by "shift".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_shift(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_multi_union_pw_aff *shift)
+{
+	if (!tree || !shift)
+		goto error;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	tree->band = isl_schedule_band_shift(tree->band, shift);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+
+	return tree;
+error:
+	isl_schedule_tree_free(tree);
+	isl_multi_union_pw_aff_free(shift);
+	return NULL;
+}
+
+/* Given two trees with sequence roots, replace the child at position
+ * "pos" of "tree" with the children of "child".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_sequence_splice(
+	__isl_take isl_schedule_tree *tree, int pos,
+	__isl_take isl_schedule_tree *child)
+{
+	isl_size n;
+	isl_schedule_tree_list *list1, *list2;
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree || !child)
+		goto error;
+	if (isl_schedule_tree_get_type(tree) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a sequence node", goto error);
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0)
+		goto error;
+	if (pos < 0 || pos >= n)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"position out of bounds", goto error);
+	if (isl_schedule_tree_get_type(child) != isl_schedule_node_sequence)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a sequence node", goto error);
+
+	list1 = isl_schedule_tree_list_copy(tree->children);
+	list1 = isl_schedule_tree_list_drop(list1, pos, n - pos);
+	list2 = isl_schedule_tree_list_copy(tree->children);
+	list2 = isl_schedule_tree_list_drop(list2, 0, pos + 1);
+	list1 = isl_schedule_tree_list_concat(list1,
+				isl_schedule_tree_list_copy(child->children));
+	list1 = isl_schedule_tree_list_concat(list1, list2);
+
+	isl_schedule_tree_free(tree);
+	isl_schedule_tree_free(child);
+	return isl_schedule_tree_from_children(isl_schedule_node_sequence,
+						list1);
+error:
+	isl_schedule_tree_free(tree);
+	isl_schedule_tree_free(child);
+	return NULL;
+}
+
+/* Tile the band root node of "tree" with tile sizes "sizes".
+ *
+ * We duplicate the band node, change the schedule of one of them
+ * to the tile schedule and the other to the point schedule and then
+ * attach the point band as a child to the tile band.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_tile(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *sizes)
+{
+	isl_schedule_tree *child = NULL;
+
+	if (!tree || !sizes)
+		goto error;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+
+	child = isl_schedule_tree_copy(tree);
+	tree = isl_schedule_tree_cow(tree);
+	child = isl_schedule_tree_cow(child);
+	if (!tree || !child)
+		goto error;
+
+	tree->band = isl_schedule_band_tile(tree->band,
+					    isl_multi_val_copy(sizes));
+	if (!tree->band)
+		goto error;
+	child->band = isl_schedule_band_point(child->band, tree->band, sizes);
+	if (!child->band)
+		child = isl_schedule_tree_free(child);
+
+	tree = isl_schedule_tree_replace_child(tree, 0, child);
+
+	return tree;
+error:
+	isl_schedule_tree_free(child);
+	isl_schedule_tree_free(tree);
+	isl_multi_val_free(sizes);
+	return NULL;
+}
+
+/* Given an isolate AST generation option "isolate" for a band of size pos + n,
+ * return the corresponding option for a band covering the first "pos"
+ * members.
+ *
+ * The input isolate option is of the form
+ *
+ *	isolateflattened outer bands -> pos; n
+ *
+ * The output isolate option is of the form
+ *
+ *	isolateflattened outer bands -> pos
+ */
+static __isl_give isl_set *isolate_initial(__isl_keep isl_set *isolate,
+	int pos, int n)
+{
+	isl_id *id;
+	isl_map *map;
+
+	isolate = isl_set_copy(isolate);
+	id = isl_set_get_tuple_id(isolate);
+	map = isl_set_unwrap(isolate);
+	map = isl_map_project_out(map, isl_dim_out, pos, n);
+	isolate = isl_map_wrap(map);
+	isolate = isl_set_set_tuple_id(isolate, id);
+
+	return isolate;
+}
+
+/* Given an isolate AST generation option "isolate" for a band of size pos + n,
+ * return the corresponding option for a band covering the final "n"
+ * members within a band covering the first "pos" members.
+ *
+ * The input isolate option is of the form
+ *
+ *	isolateflattened outer bands -> pos; n
+ *
+ * The output isolate option is of the form
+ *
+ *	isolateflattened outer bands; pos -> n
+ *
+ *
+ * The range is first split into
+ *
+ *	isolateflattened outer bands -> pos -> n
+ *
+ * and then the first pos members are moved to the domain
+ *
+ *	isolateflattened outer bands -> pos -> n
+ *
+ * after which the domain is flattened to obtain the desired output.
+ */
+static __isl_give isl_set *isolate_final(__isl_keep isl_set *isolate,
+	int pos, int n)
+{
+	isl_id *id;
+	isl_space *space;
+	isl_multi_aff *ma1, *ma2;
+	isl_map *map;
+
+	isolate = isl_set_copy(isolate);
+	id = isl_set_get_tuple_id(isolate);
+	map = isl_set_unwrap(isolate);
+	space = isl_space_range(isl_map_get_space(map));
+	ma1 = isl_multi_aff_project_out_map(isl_space_copy(space),
+						   isl_dim_set, pos, n);
+	ma2 = isl_multi_aff_project_out_map(space, isl_dim_set, 0, pos);
+	ma1 = isl_multi_aff_range_product(ma1, ma2);
+	map = isl_map_apply_range(map, isl_map_from_multi_aff(ma1));
+	map = isl_map_uncurry(map);
+	map = isl_map_flatten_domain(map);
+	isolate = isl_map_wrap(map);
+	isolate = isl_set_set_tuple_id(isolate, id);
+
+	return isolate;
+}
+
+/* Split the band root node of "tree" into two nested band nodes,
+ * one with the first "pos" dimensions and
+ * one with the remaining dimensions.
+ * The tree is itself positioned at schedule depth "depth".
+ *
+ * The loop AST generation type options and the isolate option
+ * are split over the two band nodes.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_split(
+	__isl_take isl_schedule_tree *tree, int pos, int depth)
+{
+	isl_size n;
+	isl_set *isolate, *tree_isolate, *child_isolate;
+	isl_schedule_tree *child;
+
+	if (!tree)
+		return NULL;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", return isl_schedule_tree_free(tree));
+
+	n = isl_schedule_tree_band_n_member(tree);
+	if (n < 0)
+		return isl_schedule_tree_free(tree);
+	if (pos < 0 || pos > n)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"position out of bounds",
+			return isl_schedule_tree_free(tree));
+
+	child = isl_schedule_tree_copy(tree);
+	tree = isl_schedule_tree_cow(tree);
+	child = isl_schedule_tree_cow(child);
+	if (!tree || !child)
+		goto error;
+
+	isolate = isl_schedule_tree_band_get_ast_isolate_option(tree, depth);
+	tree_isolate = isolate_initial(isolate, pos, n - pos);
+	child_isolate = isolate_final(isolate, pos, n - pos);
+	child->band = isl_schedule_band_drop(child->band, 0, pos);
+	child->band = isl_schedule_band_replace_ast_build_option(child->band,
+					isl_set_copy(isolate), child_isolate);
+	tree->band = isl_schedule_band_drop(tree->band, pos, n - pos);
+	tree->band = isl_schedule_band_replace_ast_build_option(tree->band,
+					isl_set_copy(isolate), tree_isolate);
+	isl_set_free(isolate);
+	if (!child->band || !tree->band)
+		goto error;
+
+	tree = isl_schedule_tree_replace_child(tree, 0, child);
+
+	return tree;
+error:
+	isl_schedule_tree_free(child);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Attach "tree2" at each of the leaves of "tree1".
+ *
+ * If "tree1" does not have any explicit children, then make "tree2"
+ * its single child.  Otherwise, attach "tree2" to the leaves of
+ * each of the children of "tree1".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_append_to_leaves(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2)
+{
+	int i;
+	isl_size n;
+
+	n = isl_schedule_tree_n_children(tree1);
+	if (n < 0 || !tree2)
+		goto error;
+	if (n == 0) {
+		isl_schedule_tree_list *list;
+		list = isl_schedule_tree_list_from_schedule_tree(tree2);
+		tree1 = isl_schedule_tree_set_children(tree1, list);
+		return tree1;
+	}
+	for (i = 0; i < n; ++i) {
+		isl_schedule_tree *child;
+
+		child = isl_schedule_tree_get_child(tree1, i);
+		child = isl_schedule_tree_append_to_leaves(child,
+					isl_schedule_tree_copy(tree2));
+		tree1 = isl_schedule_tree_replace_child(tree1, i, child);
+	}
+
+	isl_schedule_tree_free(tree2);
+	return tree1;
+error:
+	isl_schedule_tree_free(tree1);
+	isl_schedule_tree_free(tree2);
+	return NULL;
+}
+
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * in the root of "tree".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_reset_user(
+	__isl_take isl_schedule_tree *tree)
+{
+	if (isl_schedule_tree_is_leaf(tree))
+		return tree;
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		return NULL;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		return isl_schedule_tree_free(tree);
+	case isl_schedule_node_band:
+		tree->band = isl_schedule_band_reset_user(tree->band);
+		if (!tree->band)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_context:
+		tree->context = isl_set_reset_user(tree->context);
+		if (!tree->context)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_domain:
+		tree->domain = isl_union_set_reset_user(tree->domain);
+		if (!tree->domain)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_expansion:
+		tree->contraction =
+			isl_union_pw_multi_aff_reset_user(tree->contraction);
+		tree->expansion = isl_union_map_reset_user(tree->expansion);
+		if (!tree->contraction || !tree->expansion)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_extension:
+		tree->extension = isl_union_map_reset_user(tree->extension);
+		if (!tree->extension)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_filter:
+		tree->filter = isl_union_set_reset_user(tree->filter);
+		if (!tree->filter)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_guard:
+		tree->guard = isl_set_reset_user(tree->guard);
+		if (!tree->guard)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		break;
+	}
+
+	return tree;
+}
+
+/* Align the parameters of the root of "tree" to those of "space".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_align_params(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_space *space)
+{
+	if (!space)
+		goto error;
+
+	if (isl_schedule_tree_is_leaf(tree)) {
+		isl_space_free(space);
+		return tree;
+	}
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		goto error;
+	case isl_schedule_node_band:
+		tree->band = isl_schedule_band_align_params(tree->band, space);
+		if (!tree->band)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_context:
+		tree->context = isl_set_align_params(tree->context, space);
+		if (!tree->context)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_domain:
+		tree->domain = isl_union_set_align_params(tree->domain, space);
+		if (!tree->domain)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_expansion:
+		tree->contraction =
+			isl_union_pw_multi_aff_align_params(tree->contraction,
+							isl_space_copy(space));
+		tree->expansion = isl_union_map_align_params(tree->expansion,
+								space);
+		if (!tree->contraction || !tree->expansion)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_extension:
+		tree->extension = isl_union_map_align_params(tree->extension,
+								space);
+		if (!tree->extension)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_filter:
+		tree->filter = isl_union_set_align_params(tree->filter, space);
+		if (!tree->filter)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_guard:
+		tree->guard = isl_set_align_params(tree->guard, space);
+		if (!tree->guard)
+			return isl_schedule_tree_free(tree);
+		break;
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		isl_space_free(space);
+		break;
+	}
+
+	return tree;
+error:
+	isl_space_free(space);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Does "tree" involve the iteration domain?
+ * That is, does it need to be modified
+ * by isl_schedule_tree_pullback_union_pw_multi_aff?
+ */
+static int involves_iteration_domain(__isl_keep isl_schedule_tree *tree)
+{
+	if (!tree)
+		return -1;
+
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		return -1;
+	case isl_schedule_node_band:
+	case isl_schedule_node_domain:
+	case isl_schedule_node_expansion:
+	case isl_schedule_node_extension:
+	case isl_schedule_node_filter:
+		return 1;
+	case isl_schedule_node_context:
+	case isl_schedule_node_leaf:
+	case isl_schedule_node_guard:
+	case isl_schedule_node_mark:
+	case isl_schedule_node_sequence:
+	case isl_schedule_node_set:
+		return 0;
+	}
+
+	isl_die(isl_schedule_tree_get_ctx(tree), isl_error_internal,
+		"unhandled case", return -1);
+}
+
+/* Compute the pullback of the root node of "tree" by the function
+ * represented by "upma".
+ * In other words, plug in "upma" in the iteration domains of
+ * the root node of "tree".
+ * We currently do not handle expansion nodes.
+ *
+ * We first check if the root node involves any iteration domains.
+ * If so, we handle the specific cases.
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *upma)
+{
+	int involves;
+
+	if (!tree || !upma)
+		goto error;
+
+	involves = involves_iteration_domain(tree);
+	if (involves < 0)
+		goto error;
+	if (!involves) {
+		isl_union_pw_multi_aff_free(upma);
+		return tree;
+	}
+
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	if (tree->type == isl_schedule_node_band) {
+		tree->band = isl_schedule_band_pullback_union_pw_multi_aff(
+							    tree->band, upma);
+		if (!tree->band)
+			return isl_schedule_tree_free(tree);
+	} else if (tree->type == isl_schedule_node_domain) {
+		tree->domain =
+			isl_union_set_preimage_union_pw_multi_aff(tree->domain,
+									upma);
+		if (!tree->domain)
+			return isl_schedule_tree_free(tree);
+	} else if (tree->type == isl_schedule_node_expansion) {
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_unsupported,
+			"cannot pullback expansion node", goto error);
+	} else if (tree->type == isl_schedule_node_extension) {
+		tree->extension =
+			isl_union_map_preimage_range_union_pw_multi_aff(
+			    tree->extension, upma);
+		if (!tree->extension)
+			return isl_schedule_tree_free(tree);
+	} else if (tree->type == isl_schedule_node_filter) {
+		tree->filter =
+			isl_union_set_preimage_union_pw_multi_aff(tree->filter,
+									upma);
+		if (!tree->filter)
+			return isl_schedule_tree_free(tree);
+	}
+
+	return tree;
+error:
+	isl_union_pw_multi_aff_free(upma);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Compute the gist of the band tree root with respect to "context".
+ */
+__isl_give isl_schedule_tree *isl_schedule_tree_band_gist(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *context)
+{
+	if (!tree)
+		return NULL;
+	if (tree->type != isl_schedule_node_band)
+		isl_die(isl_schedule_tree_get_ctx(tree), isl_error_invalid,
+			"not a band node", goto error);
+	tree = isl_schedule_tree_cow(tree);
+	if (!tree)
+		goto error;
+
+	tree->band = isl_schedule_band_gist(tree->band, context);
+	if (!tree->band)
+		return isl_schedule_tree_free(tree);
+	return tree;
+error:
+	isl_union_set_free(context);
+	isl_schedule_tree_free(tree);
+	return NULL;
+}
+
+/* Are any members in "band" marked coincident?
+ */
+static isl_bool any_coincident(__isl_keep isl_schedule_band *band)
+{
+	int i;
+	isl_size n;
+
+	n = isl_schedule_band_n_member(band);
+	if (n < 0)
+		return isl_bool_error;
+	for (i = 0; i < n; ++i) {
+		isl_bool coincident;
+
+		coincident = isl_schedule_band_member_get_coincident(band, i);
+		if (coincident < 0 || coincident)
+			return coincident;
+	}
+
+	return isl_bool_false;
+}
+
+/* Print the band node "band" to "p".
+ *
+ * The permutable and coincident properties are only printed if they
+ * are different from the defaults.
+ * The coincident property is always printed in YAML flow style.
+ */
+static __isl_give isl_printer *print_tree_band(__isl_take isl_printer *p,
+	__isl_keep isl_schedule_band *band)
+{
+	isl_union_set *options;
+	isl_bool empty;
+	isl_bool coincident;
+
+	p = isl_printer_print_str(p, "schedule");
+	p = isl_printer_yaml_next(p);
+	p = isl_printer_print_str(p, "\"");
+	p = isl_printer_print_multi_union_pw_aff(p, band->mupa);
+	p = isl_printer_print_str(p, "\"");
+	if (isl_schedule_band_get_permutable(band)) {
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, "permutable");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_int(p, 1);
+	}
+	coincident = any_coincident(band);
+	if (coincident < 0)
+		return isl_printer_free(p);
+	if (coincident) {
+		int i;
+		isl_size n;
+		int style;
+
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, "coincident");
+		p = isl_printer_yaml_next(p);
+		style = isl_printer_get_yaml_style(p);
+		p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_FLOW);
+		p = isl_printer_yaml_start_sequence(p);
+		n = isl_schedule_band_n_member(band);
+		if (n < 0)
+			return isl_printer_free(p);
+		for (i = 0; i < n; ++i) {
+			p = isl_printer_print_int(p,
+			    isl_schedule_band_member_get_coincident(band, i));
+			p = isl_printer_yaml_next(p);
+		}
+		p = isl_printer_yaml_end_sequence(p);
+		p = isl_printer_set_yaml_style(p, style);
+	}
+	options = isl_schedule_band_get_ast_build_options(band);
+	empty = isl_union_set_is_empty(options);
+	if (empty < 0)
+		p = isl_printer_free(p);
+	if (!empty) {
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, "options");
+		p = isl_printer_yaml_next(p);
+		p = isl_printer_print_str(p, "\"");
+		p = isl_printer_print_union_set(p, options);
+		p = isl_printer_print_str(p, "\"");
+	}
+	isl_union_set_free(options);
+
+	return p;
+}
+
+#undef BASE
+#define BASE str
+#define isl_str const char
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE set
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE union_set
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE union_map
+#include "print_yaml_field_templ.c"
+
+#undef BASE
+#define BASE union_pw_multi_aff
+#include "print_yaml_field_templ.c"
+
+/* Print "tree" to "p".
+ *
+ * If "n_ancestor" is non-negative, then "child_pos" contains the child
+ * positions of a descendant of the current node that should be marked
+ * (by the comment "YOU ARE HERE").  In particular, if "n_ancestor"
+ * is zero, then the current node should be marked.
+ * The marking is only printed in YAML block format.
+ *
+ * Implicit leaf nodes are not printed, except if they correspond
+ * to the node that should be marked.
+ */
+__isl_give isl_printer *isl_printer_print_schedule_tree_mark(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_tree *tree,
+	int n_ancestor, int *child_pos)
+{
+	int i;
+	isl_size n;
+	int sequence = 0;
+	int block;
+
+	block = isl_printer_get_yaml_style(p) == ISL_YAML_STYLE_BLOCK;
+
+	p = isl_printer_yaml_start_mapping(p);
+	if (n_ancestor == 0 && block) {
+		p = isl_printer_print_str(p, "# YOU ARE HERE");
+		p = isl_printer_end_line(p);
+		p = isl_printer_start_line(p);
+	}
+	switch (tree->type) {
+	case isl_schedule_node_error:
+		p = isl_printer_print_str(p, "ERROR");
+		p = isl_printer_yaml_next(p);
+		break;
+	case isl_schedule_node_leaf:
+		p = isl_printer_print_str(p, "leaf");
+		p = isl_printer_yaml_next(p);
+		break;
+	case isl_schedule_node_sequence:
+		p = isl_printer_print_str(p, "sequence");
+		p = isl_printer_yaml_next(p);
+		sequence = 1;
+		break;
+	case isl_schedule_node_set:
+		p = isl_printer_print_str(p, "set");
+		p = isl_printer_yaml_next(p);
+		sequence = 1;
+		break;
+	case isl_schedule_node_context:
+		p = print_yaml_field_set(p, "context", tree->context);
+		break;
+	case isl_schedule_node_domain:
+		p = print_yaml_field_union_set(p, "domain", tree->domain);
+		break;
+	case isl_schedule_node_expansion:
+		p = print_yaml_field_union_pw_multi_aff(p, "contraction",
+							tree->contraction);
+		p = print_yaml_field_union_map(p, "expansion", tree->expansion);
+		break;
+	case isl_schedule_node_extension:
+		p = print_yaml_field_union_map(p, "extension", tree->extension);
+		break;
+	case isl_schedule_node_filter:
+		p = print_yaml_field_union_set(p, "filter", tree->filter);
+		break;
+	case isl_schedule_node_guard:
+		p = print_yaml_field_set(p, "guard", tree->guard);
+		break;
+	case isl_schedule_node_mark:
+		p = print_yaml_field_str(p, "mark",
+					isl_id_get_name(tree->mark));
+		break;
+	case isl_schedule_node_band:
+		p = print_tree_band(p, tree->band);
+		p = isl_printer_yaml_next(p);
+		break;
+	}
+
+	n = isl_schedule_tree_n_children(tree);
+	if (n < 0)
+		return isl_printer_free(p);
+	if (n == 0) {
+		if (n_ancestor > 0 && block) {
+			isl_schedule_tree *leaf;
+
+			p = isl_printer_print_str(p, "child");
+			p = isl_printer_yaml_next(p);
+			leaf = isl_schedule_tree_leaf(isl_printer_get_ctx(p));
+			p = isl_printer_print_schedule_tree_mark(p,
+					leaf, 0, NULL);
+			isl_schedule_tree_free(leaf);
+			p = isl_printer_yaml_next(p);
+		}
+		return isl_printer_yaml_end_mapping(p);
+	}
+
+	if (sequence) {
+		p = isl_printer_yaml_start_sequence(p);
+	} else {
+		p = isl_printer_print_str(p, "child");
+		p = isl_printer_yaml_next(p);
+	}
+
+	for (i = 0; i < n; ++i) {
+		isl_schedule_tree *t;
+
+		t = isl_schedule_tree_get_child(tree, i);
+		if (n_ancestor > 0 && child_pos0 == i)
+			p = isl_printer_print_schedule_tree_mark(p, t,
+						n_ancestor - 1, child_pos + 1);
+		else
+			p = isl_printer_print_schedule_tree_mark(p, t,
+						-1, NULL);
+		isl_schedule_tree_free(t);
+
+		p = isl_printer_yaml_next(p);
+	}
+
+	if (sequence)
+		p = isl_printer_yaml_end_sequence(p);
+	p = isl_printer_yaml_end_mapping(p);
+
+	return p;
+}
+
+/* Print "tree" to "p".
+ */
+__isl_give isl_printer *isl_printer_print_schedule_tree(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_tree *tree)
+{
+	return isl_printer_print_schedule_tree_mark(p, tree, -1, NULL);
+}
+
+void isl_schedule_tree_dump(__isl_keep isl_schedule_tree *tree)
+{
+	isl_ctx *ctx;
+	isl_printer *printer;
+
+	if (!tree)
+		return;
+
+	ctx = isl_schedule_tree_get_ctx(tree);
+	printer = isl_printer_to_file(ctx, stderr);
+	printer = isl_printer_set_yaml_style(printer, ISL_YAML_STYLE_BLOCK);
+	printer = isl_printer_print_schedule_tree(printer, tree);
+
+	isl_printer_free(printer);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_schedule_tree.h Added

@@ -0,0 +1,266 @@
+#ifndef ISL_SCHEDLUE_TREE_H
+#define ISL_SCHEDLUE_TREE_H
+
+#include <isl_schedule_band.h>
+#include <isl/schedule.h>
+#include <isl/set.h>
+#include <isl/union_set.h>
+
+struct isl_schedule_tree;
+typedef struct isl_schedule_tree isl_schedule_tree;
+
+ISL_DECLARE_LIST(schedule_tree)
+
+/* A schedule (sub)tree.
+ *
+ * The leaves of a tree are not explicitly represented inside
+ * the isl_schedule_tree, except when the tree consists of only a leaf.
+ *
+ * The "band" field is valid when type is isl_schedule_node_band.
+ * The "context" field is valid when type is isl_schedule_node_context
+ * and represents constraints on the flat product of the outer band nodes,
+ * possibly introducing additional parameters.
+ * The "domain" field is valid when type is isl_schedule_node_domain
+ * and introduces the statement instances scheduled by the tree.
+ *
+ * The "contraction" and "expansion" fields are valid when type
+ * is isl_schedule_node_expansion.
+ * "expansion" expands the reaching domain elements to one or more
+ * domain elements for the subtree.
+ * "contraction" maps these elements back to the corresponding
+ * reaching domain element.  It does not involve any domain constraints.
+ *
+ * The "extension" field is valid when the is isl_schedule_node_extension
+ * maps outer schedule dimensions (the flat product of the outer band nodes)
+ * to additional iteration domains.
+ *
+ * The "filter" field is valid when type is isl_schedule_node_filter
+ * and represents the statement instances selected by the node.
+ *
+ * The "guard" field is valid when type is isl_schedule_node_guard
+ * and represents constraints on the flat product of the outer band nodes
+ * that need to be enforced by the outer nodes in the generated AST.
+ *
+ * The "mark" field is valid when type is isl_schedule_node_mark and
+ * identifies the mark.
+ *
+ * The "children" field is valid for all types except
+ * isl_schedule_node_leaf.  This field is NULL if there are
+ * no children (except for the implicit leaves).
+ *
+ * anchored is set if the node or any of its descendants depends
+ * on its position in the schedule tree.
+ */
+struct isl_schedule_tree {
+	int ref;
+	isl_ctx *ctx;
+	int anchored;
+	enum isl_schedule_node_type type;
+	union {
+		isl_schedule_band *band;
+		isl_set *context;
+		isl_union_set *domain;
+		struct {
+			isl_union_pw_multi_aff *contraction;
+			isl_union_map *expansion;
+		};
+		isl_union_map *extension;
+		isl_union_set *filter;
+		isl_set *guard;
+		isl_id *mark;
+	};
+	isl_schedule_tree_list *children;
+};
+
+isl_ctx *isl_schedule_tree_get_ctx(__isl_keep isl_schedule_tree *tree);
+enum isl_schedule_node_type isl_schedule_tree_get_type(
+	__isl_keep isl_schedule_tree *tree);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_leaf(isl_ctx *ctx);
+int isl_schedule_tree_is_leaf(__isl_keep isl_schedule_tree *tree);
+
+isl_bool isl_schedule_tree_plain_is_equal(__isl_keep isl_schedule_tree *tree1,
+	__isl_keep isl_schedule_tree *tree2);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_copy(
+	__isl_keep isl_schedule_tree *tree);
+__isl_null isl_schedule_tree *isl_schedule_tree_free(
+	__isl_take isl_schedule_tree *tree);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_from_band(
+	__isl_take isl_schedule_band *band);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_context(
+	__isl_take isl_set *context);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_domain(
+	__isl_take isl_union_set *domain);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_expansion(
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_extension(
+	__isl_take isl_union_map *extension);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_filter(
+	__isl_take isl_union_set *filter);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_guard(
+	__isl_take isl_set *guard);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_children(
+	enum isl_schedule_node_type type,
+	__isl_take isl_schedule_tree_list *list);
+__isl_give isl_schedule_tree *isl_schedule_tree_from_pair(
+	enum isl_schedule_node_type type, __isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2);
+__isl_give isl_schedule_tree *isl_schedule_tree_sequence_pair(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2);
+__isl_give isl_schedule_tree *isl_schedule_tree_set_pair(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2);
+
+isl_bool isl_schedule_tree_is_subtree_anchored(
+	__isl_keep isl_schedule_tree *tree);
+
+__isl_give isl_space *isl_schedule_tree_band_get_space(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_intersect_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain);
+__isl_give isl_multi_union_pw_aff *isl_schedule_tree_band_get_partial_schedule(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_partial_schedule(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_multi_union_pw_aff *schedule);
+enum isl_ast_loop_type isl_schedule_tree_band_member_get_ast_loop_type(
+	__isl_keep isl_schedule_tree *tree, int pos);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_member_set_ast_loop_type(
+	__isl_take isl_schedule_tree *tree, int pos,
+	enum isl_ast_loop_type type);
+enum isl_ast_loop_type isl_schedule_tree_band_member_get_isolate_ast_loop_type(
+	__isl_keep isl_schedule_tree *tree, int pos);
+__isl_give isl_schedule_tree *
+isl_schedule_tree_band_member_set_isolate_ast_loop_type(
+	__isl_take isl_schedule_tree *tree, int pos,
+	enum isl_ast_loop_type type);
+__isl_give isl_union_set *isl_schedule_tree_band_get_ast_build_options(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_ast_build_options(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *options);
+__isl_give isl_set *isl_schedule_tree_band_get_ast_isolate_option(
+	__isl_keep isl_schedule_tree *tree, int depth);
+__isl_give isl_set *isl_schedule_tree_context_get_context(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_union_set *isl_schedule_tree_domain_get_domain(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_domain_set_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain);
+__isl_give isl_union_pw_multi_aff *isl_schedule_tree_expansion_get_contraction(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_union_map *isl_schedule_tree_expansion_get_expansion(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *
+isl_schedule_tree_expansion_set_contraction_and_expansion(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion);
+__isl_give isl_union_map *isl_schedule_tree_extension_get_extension(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_extension_set_extension(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_map *extension);
+__isl_give isl_union_set *isl_schedule_tree_filter_get_filter(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_filter_set_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter);
+__isl_give isl_set *isl_schedule_tree_guard_get_guard(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_id *isl_schedule_tree_mark_get_id(
+	__isl_keep isl_schedule_tree *tree);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_first_schedule_descendant(
+	__isl_take isl_schedule_tree *tree, __isl_keep isl_schedule_tree *leaf);
+__isl_give isl_union_map *isl_schedule_tree_get_subtree_schedule_union_map(
+	__isl_keep isl_schedule_tree *tree);
+
+isl_size isl_schedule_tree_band_n_member(__isl_keep isl_schedule_tree *tree);
+
+isl_bool isl_schedule_tree_band_member_get_coincident(
+	__isl_keep isl_schedule_tree *tree, int pos);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_member_set_coincident(
+	__isl_take isl_schedule_tree *tree, int pos, int coincident);
+isl_bool isl_schedule_tree_band_get_permutable(
+	__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_set_permutable(
+	__isl_take isl_schedule_tree *tree, int permutable);
+
+int isl_schedule_tree_has_children(__isl_keep isl_schedule_tree *tree);
+isl_size isl_schedule_tree_n_children(__isl_keep isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_get_child(
+	__isl_keep isl_schedule_tree *tree, int pos);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_band(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_schedule_band *band);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_context(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_set *context);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_domain(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *domain);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_expansion(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *contraction,
+	__isl_take isl_union_map *expansion);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_extension(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_map *extension);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter);
+__isl_give isl_schedule_tree *isl_schedule_tree_children_insert_filter(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *filter);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_guard(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_set *guard);
+__isl_give isl_schedule_tree *isl_schedule_tree_insert_mark(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_id *mark);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_append_to_leaves(
+	__isl_take isl_schedule_tree *tree1,
+	__isl_take isl_schedule_tree *tree2);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_band_scale(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_scale_down(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_mod(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *mv);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_tile(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_multi_val *sizes);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_shift(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_multi_union_pw_aff *shift);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_split(
+	__isl_take isl_schedule_tree *tree, int pos, int depth);
+__isl_give isl_schedule_tree *isl_schedule_tree_band_gist(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_union_set *context);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_child(
+	__isl_take isl_schedule_tree *tree, int pos);
+__isl_give isl_schedule_tree *isl_schedule_tree_reset_children(
+	__isl_take isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_drop_child(
+	__isl_take isl_schedule_tree *tree, int pos);
+__isl_give isl_schedule_tree *isl_schedule_tree_replace_child(
+	__isl_take isl_schedule_tree *tree, int pos,
+	__isl_take isl_schedule_tree *new_child);
+__isl_give isl_schedule_tree *isl_schedule_tree_sequence_splice(
+	__isl_take isl_schedule_tree *tree, int pos,
+	__isl_take isl_schedule_tree *child);
+
+__isl_give isl_schedule_tree *isl_schedule_tree_reset_user(
+	__isl_take isl_schedule_tree *tree);
+__isl_give isl_schedule_tree *isl_schedule_tree_align_params(
+	__isl_take isl_schedule_tree *tree, __isl_take isl_space *space);
+__isl_give isl_schedule_tree *isl_schedule_tree_pullback_union_pw_multi_aff(
+	__isl_take isl_schedule_tree *tree,
+	__isl_take isl_union_pw_multi_aff *upma);
+
+__isl_give isl_printer *isl_printer_print_schedule_tree(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_tree *tree);
+__isl_give isl_printer *isl_printer_print_schedule_tree_mark(
+	__isl_take isl_printer *p, __isl_keep isl_schedule_tree *tree,
+	int n_ancestor, int *child_pos);
+
+#endif

_service:tar_scm:isl-0.14.tar.xz/isl_scheduler.c -> _service:tar_scm:isl-0.24.tar.gz/isl_scheduler.c Changed

@@ -1,6 +1,9 @@
 /*
  * Copyright 2011      INRIA Saclay
  * Copyright 2012-2014 Ecole Normale Superieure
+ * Copyright 2015-2016 Sven Verdoolaege
+ * Copyright 2016      INRIA Paris
+ * Copyright 2017      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
@@ -8,6 +11,8 @@
  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
  * 91893 Orsay, France
  * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Centre de Recherche Inria de Paris, 2 rue Simone Iff - Voie DQ12,
+ * CS 42112, 75589 Paris Cedex 12, France
  */
 
 #include <isl_ctx_private.h>
@@ -15,297 +20,40 @@
 #include <isl_space_private.h>
 #include <isl_aff_private.h>
 #include <isl/hash.h>
+#include <isl/id.h>
 #include <isl/constraint.h>
 #include <isl/schedule.h>
+#include <isl_schedule_constraints.h>
+#include <isl/schedule_node.h>
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 #include <isl/set.h>
+#include <isl_union_set_private.h>
 #include <isl_seq.h>
 #include <isl_tab.h>
 #include <isl_dim_map.h>
 #include <isl/map_to_basic_set.h>
 #include <isl_sort.h>
-#include <isl_schedule_private.h>
 #include <isl_options_private.h>
 #include <isl_tarjan.h>
 #include <isl_morph.h>
+#include <isl/ilp.h>
+#include <isl_val_private.h>
 
 /*
  * The scheduling algorithm implemented in this file was inspired by
  * Bondhugula et al., "Automatic Transformations for Communication-Minimized
  * Parallelization and Locality Optimization in the Polyhedral Model".
- */
-
-enum isl_edge_type {
-	isl_edge_validity = 0,
-	isl_edge_first = isl_edge_validity,
-	isl_edge_coincidence,
-	isl_edge_condition,
-	isl_edge_conditional_validity,
-	isl_edge_proximity,
-	isl_edge_last = isl_edge_proximity
-};
-
-/* The constraints that need to be satisfied by a schedule on "domain".
  *
- * "validity" constraints map domain elements i to domain elements
- * that should be scheduled after i.  (Hard constraint)
- * "proximity" constraints map domain elements i to domains elements
- * that should be scheduled as early as possible after i (or before i).
- * (Soft constraint)
- *
- * "condition" and "conditional_validity" constraints map possibly "tagged"
- * domain elements i -> s to "tagged" domain elements j -> t.
- * The elements of the "conditional_validity" constraints, but without the
- * tags (i.e., the elements i -> j) are treated as validity constraints,
- * except that during the construction of a tilable band,
- * the elements of the "conditional_validity" constraints may be violated
- * provided that all adjacent elements of the "condition" constraints
- * are local within the band.
- * A dependence is local within a band if domain and range are mapped
- * to the same schedule point by the band.
+ * For a detailed description of the variant implemented in isl,
+ * see Verdoolaege and Janssens, "Scheduling for PPCG" (2017).
  */
-struct isl_schedule_constraints {
-	isl_union_set *domain;
 
-	isl_union_map *constraintisl_edge_last + 1;
-};
-
- __isl_give isl_schedule_constraints *isl_schedule_constraints_copy(
-	__isl_keep isl_schedule_constraints *sc)
-{
-	isl_ctx *ctx;
-	isl_schedule_constraints *sc_copy;
-	enum isl_edge_type i;
-
-	ctx = isl_union_set_get_ctx(sc->domain);
-	sc_copy = isl_calloc_type(ctx, struct isl_schedule_constraints);
-	if (!sc_copy)
-		return NULL;
-
-	sc_copy->domain = isl_union_set_copy(sc->domain);
-	if (!sc_copy->domain)
-		return isl_schedule_constraints_free(sc_copy);
-
-	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
-		sc_copy->constrainti = isl_union_map_copy(sc->constrainti);
-		if (!sc_copy->constrainti)
-			return isl_schedule_constraints_free(sc_copy);
-	}
-
-	return sc_copy;
-}
-
-
-/* Construct an isl_schedule_constraints object for computing a schedule
- * on "domain".  The initial object does not impose any constraints.
- */
-__isl_give isl_schedule_constraints *isl_schedule_constraints_on_domain(
-	__isl_take isl_union_set *domain)
-{
-	isl_ctx *ctx;
-	isl_space *space;
-	isl_schedule_constraints *sc;
-	isl_union_map *empty;
-	enum isl_edge_type i;
-
-	if (!domain)
-		return NULL;
-
-	ctx = isl_union_set_get_ctx(domain);
-	sc = isl_calloc_type(ctx, struct isl_schedule_constraints);
-	if (!sc)
-		goto error;
-
-	space = isl_union_set_get_space(domain);
-	sc->domain = domain;
-	empty = isl_union_map_empty(space);
-	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
-		sc->constrainti = isl_union_map_copy(empty);
-		if (!sc->constrainti)
-			sc->domain = isl_union_set_free(sc->domain);
-	}
-	isl_union_map_free(empty);
-
-	if (!sc->domain)
-		return isl_schedule_constraints_free(sc);
-
-	return sc;
-error:
-	isl_union_set_free(domain);
-	return NULL;
-}
-
-/* Replace the validity constraints of "sc" by "validity".
- */
-__isl_give isl_schedule_constraints *isl_schedule_constraints_set_validity(
-	__isl_take isl_schedule_constraints *sc,
-	__isl_take isl_union_map *validity)
-{
-	if (!sc || !validity)
-		goto error;
-
-	isl_union_map_free(sc->constraintisl_edge_validity);
-	sc->constraintisl_edge_validity = validity;
-
-	return sc;
-error:
-	isl_schedule_constraints_free(sc);
-	isl_union_map_free(validity);
-	return NULL;
-}
-
-/* Replace the coincidence constraints of "sc" by "coincidence".
- */
-__isl_give isl_schedule_constraints *isl_schedule_constraints_set_coincidence(
-	__isl_take isl_schedule_constraints *sc,
-	__isl_take isl_union_map *coincidence)
-{
-	if (!sc || !coincidence)
-		goto error;
-
-	isl_union_map_free(sc->constraintisl_edge_coincidence);
-	sc->constraintisl_edge_coincidence = coincidence;
-
-	return sc;
-error:
-	isl_schedule_constraints_free(sc);
-	isl_union_map_free(coincidence);
-	return NULL;
-}
-
-/* Replace the proximity constraints of "sc" by "proximity".
- */
-__isl_give isl_schedule_constraints *isl_schedule_constraints_set_proximity(
-	__isl_take isl_schedule_constraints *sc,
-	__isl_take isl_union_map *proximity)
-{
-	if (!sc || !proximity)
-		goto error;
-
-	isl_union_map_free(sc->constraintisl_edge_proximity);
-	sc->constraintisl_edge_proximity = proximity;
-
-	return sc;
-error:
-	isl_schedule_constraints_free(sc);
-	isl_union_map_free(proximity);
-	return NULL;
-}
-
-/* Replace the conditional validity constraints of "sc" by "condition"
- * and "validity".
- */
-__isl_give isl_schedule_constraints *
-isl_schedule_constraints_set_conditional_validity(
-	__isl_take isl_schedule_constraints *sc,
-	__isl_take isl_union_map *condition,
-	__isl_take isl_union_map *validity)
-{
-	if (!sc || !condition || !validity)
-		goto error;
-
-	isl_union_map_free(sc->constraintisl_edge_condition);
-	sc->constraintisl_edge_condition = condition;
-	isl_union_map_free(sc->constraintisl_edge_conditional_validity);
-	sc->constraintisl_edge_conditional_validity = validity;
-
-	return sc;
-error:
-	isl_schedule_constraints_free(sc);
-	isl_union_map_free(condition);
-	isl_union_map_free(validity);
-	return NULL;
-}
-
-__isl_null isl_schedule_constraints *isl_schedule_constraints_free(
-	__isl_take isl_schedule_constraints *sc)
-{
-	enum isl_edge_type i;
-
-	if (!sc)
-		return NULL;
-
-	isl_union_set_free(sc->domain);
-	for (i = isl_edge_first; i <= isl_edge_last; ++i)
-		isl_union_map_free(sc->constrainti);
-
-	free(sc);
-
-	return NULL;
-}
-
-isl_ctx *isl_schedule_constraints_get_ctx(
-	__isl_keep isl_schedule_constraints *sc)
-{
-	return sc ? isl_union_set_get_ctx(sc->domain) : NULL;
-}
-
-void isl_schedule_constraints_dump(__isl_keep isl_schedule_constraints *sc)
-{
-	if (!sc)
-		return;
-
-	fprintf(stderr, "domain: ");
-	isl_union_set_dump(sc->domain);
-	fprintf(stderr, "validity: ");
-	isl_union_map_dump(sc->constraintisl_edge_validity);
-	fprintf(stderr, "proximity: ");
-	isl_union_map_dump(sc->constraintisl_edge_proximity);
-	fprintf(stderr, "coincidence: ");
-	isl_union_map_dump(sc->constraintisl_edge_coincidence);
-	fprintf(stderr, "condition: ");
-	isl_union_map_dump(sc->constraintisl_edge_condition);
-	fprintf(stderr, "conditional_validity: ");
-	isl_union_map_dump(sc->constraintisl_edge_conditional_validity);
-}
-
-/* Align the parameters of the fields of "sc".
- */
-static __isl_give isl_schedule_constraints *
-isl_schedule_constraints_align_params(__isl_take isl_schedule_constraints *sc)
-{
-	isl_space *space;
-	enum isl_edge_type i;
-
-	if (!sc)
-		return NULL;
-
-	space = isl_union_set_get_space(sc->domain);
-	for (i = isl_edge_first; i <= isl_edge_last; ++i)
-		space = isl_space_align_params(space,
-				    isl_union_map_get_space(sc->constrainti));
-
-	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
-		sc->constrainti = isl_union_map_align_params(
-				    sc->constrainti, isl_space_copy(space));
-		if (!sc->constrainti)
-			space = isl_space_free(space);
-	}
-	sc->domain = isl_union_set_align_params(sc->domain, space);
-	if (!sc->domain)
-		return isl_schedule_constraints_free(sc);
-
-	return sc;
-}
-
-/* Return the total number of isl_maps in the constraints of "sc".
- */
-static __isl_give int isl_schedule_constraints_n_map(
-	__isl_keep isl_schedule_constraints *sc)
-{
-	enum isl_edge_type i;
-	int n = 0;
-
-	for (i = isl_edge_first; i <= isl_edge_last; ++i)
-		n += isl_union_map_n_map(sc->constrainti);
-
-	return n;
-}
 
 /* Internal information about a node that is used during the construction
  * of a schedule.
- * space represents the space in which the domain lives
+ * space represents the original space in which the domain lives;
+ *	that is, the space is not affected by compression
  * sched is a matrix representation of the schedule being constructed
  *	for this node; if compressed is set, then this schedule is
  *	defined over the compressed domain space
@@ -314,13 +62,15 @@
  *	is defined over the uncompressed domain space
  * rank is the number of linearly independent rows in the linear part
  *	of sched
- * the columns of cmap represent a change of basis for the schedule
- *	coefficients; the first rank columns span the linear part of
- *	the schedule rows
- * cinv is the inverse of cmap.
+ * the rows of "vmap" represent a change of basis for the node
+ *	variables; the first rank rows span the linear part of
+ *	the schedule rows; the remaining rows are linearly independent
+ * the rows of "indep" represent linear combinations of the schedule
+ * coefficients that are non-zero when the schedule coefficients are
+ * linearly independent of previously computed schedule rows.
  * start is the first variable in the LP problem in the sequences that
  *	represents the schedule coefficients of this node
- * nvar is the dimension of the domain
+ * nvar is the dimension of the (compressed) domain
  * nparam is the number of parameters or 0 if we are not constructing
  *	a parametric schedule
  *
@@ -331,43 +81,72 @@
  *
  * scc is the index of SCC (or WCC) this node belongs to
  *
- * band contains the band index for each of the rows of the schedule.
- * band_id is used to differentiate between separate bands at the same
- * level within the same parent band, i.e., bands that are separated
- * by the parent band or bands that are independent of each other.
+ * "cluster" is only used inside extract_clusters and identifies
+ * the cluster of SCCs that the node belongs to.
+ *
  * coincident contains a boolean for each of the rows of the schedule,
  * indicating whether the corresponding scheduling dimension satisfies
  * the coincidence constraints in the sense that the corresponding
  * dependence distances are zero.
+ *
+ * If the schedule_treat_coalescing option is set, then
+ * "sizes" contains the sizes of the (compressed) instance set
+ * in each direction.  If there is no fixed size in a given direction,
+ * then the corresponding size value is set to infinity.
+ * If the schedule_treat_coalescing option or the schedule_max_coefficient
+ * option is set, then "max" contains the maximal values for
+ * schedule coefficients of the (compressed) variables.  If no bound
+ * needs to be imposed on a particular variable, then the corresponding
+ * value is negative.
+ * If not NULL, then "bounds" contains a non-parametric set
+ * in the compressed space that is bounded by the size in each direction.
  */
 struct isl_sched_node {
 	isl_space *space;
 	int	compressed;
 	isl_set	*hull;
 	isl_multi_aff *compress;
-	isl_multi_aff *decompress;
+	isl_pw_multi_aff *decompress;
 	isl_mat *sched;
 	isl_map *sched_map;
 	int	 rank;
-	isl_mat *cmap;
-	isl_mat *cinv;
+	isl_mat *indep;
+	isl_mat *vmap;
 	int	 start;
 	int	 nvar;
 	int	 nparam;
 
 	int	 scc;
+	int	 cluster;
 
-	int	*band;
-	int	*band_id;
 	int	*coincident;
+
+	isl_multi_val *sizes;
+	isl_basic_set *bounds;
+	isl_vec *max;
 };
 
-static int node_has_space(const void *entry, const void *val)
+static isl_bool node_has_tuples(const void *entry, const void *val)
 {
 	struct isl_sched_node *node = (struct isl_sched_node *)entry;
-	isl_space *dim = (isl_space *)val;
+	isl_space *space = (isl_space *) val;
+
+	return isl_space_has_equal_tuples(node->space, space);
+}
+
+static int node_scc_exactly(struct isl_sched_node *node, int scc)
+{
+	return node->scc == scc;
+}
 
-	return isl_space_is_equal(node->space, dim);
+static int node_scc_at_most(struct isl_sched_node *node, int scc)
+{
+	return node->scc <= scc;
+}
+
+static int node_scc_at_least(struct isl_sched_node *node, int scc)
+{
+	return node->scc >= scc;
 }
 
 /* An edge in the dependence graph.  An edge may be used to
@@ -383,6 +162,8 @@
  *	If these fields are NULL, then they represent the empty relation.
  * src is the source node
  * dst is the sink node
+ *
+ * types is a bit vector containing the types of this edge.
  * validity is set if the edge is used to ensure correctness
  * coincidence is used to enforce zero dependence distances
  * proximity is set if the edge is used to minimize dependence distances
@@ -396,6 +177,16 @@
  * For validity edges, start and end mark the sequence of inequality
  * constraints in the LP problem that encode the validity constraint
  * corresponding to this edge.
+ *
+ * During clustering, an edge may be marked "no_merge" if it should
+ * not be used to merge clusters.
+ * The weight is also only used during clustering and it is
+ * an indication of how many schedule dimensions on either side
+ * of the schedule constraints can be aligned.
+ * If the weight is negative, then this means that this edge was postponed
+ * by has_bounded_distances or any_no_merge.  The original weight can
+ * be retrieved by adding 1 + graph->max_weight, with "graph"
+ * the graph containing this edge.
  */
 struct isl_sched_edge {
 	isl_map *map;
@@ -405,26 +196,124 @@
 	struct isl_sched_node *src;
 	struct isl_sched_node *dst;
 
-	unsigned validity : 1;
-	unsigned coincidence : 1;
-	unsigned proximity : 1;
-	unsigned local : 1;
-	unsigned condition : 1;
-	unsigned conditional_validity : 1;
+	unsigned types;
 
 	int start;
 	int end;
+
+	int no_merge;
+	int weight;
 };
 
+/* Is "edge" marked as being of type "type"?
+ */
+static int is_type(struct isl_sched_edge *edge, enum isl_edge_type type)
+{
+	return ISL_FL_ISSET(edge->types, 1 << type);
+}
+
+/* Mark "edge" as being of type "type".
+ */
+static void set_type(struct isl_sched_edge *edge, enum isl_edge_type type)
+{
+	ISL_FL_SET(edge->types, 1 << type);
+}
+
+/* No longer mark "edge" as being of type "type"?
+ */
+static void clear_type(struct isl_sched_edge *edge, enum isl_edge_type type)
+{
+	ISL_FL_CLR(edge->types, 1 << type);
+}
+
+/* Is "edge" marked as a validity edge?
+ */
+static int is_validity(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_validity);
+}
+
+/* Mark "edge" as a validity edge.
+ */
+static void set_validity(struct isl_sched_edge *edge)
+{
+	set_type(edge, isl_edge_validity);
+}
+
+/* Is "edge" marked as a proximity edge?
+ */
+static int is_proximity(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_proximity);
+}
+
+/* Is "edge" marked as a local edge?
+ */
+static int is_local(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_local);
+}
+
+/* Mark "edge" as a local edge.
+ */
+static void set_local(struct isl_sched_edge *edge)
+{
+	set_type(edge, isl_edge_local);
+}
+
+/* No longer mark "edge" as a local edge.
+ */
+static void clear_local(struct isl_sched_edge *edge)
+{
+	clear_type(edge, isl_edge_local);
+}
+
+/* Is "edge" marked as a coincidence edge?
+ */
+static int is_coincidence(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_coincidence);
+}
+
+/* Is "edge" marked as a condition edge?
+ */
+static int is_condition(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_condition);
+}
+
+/* Is "edge" marked as a conditional validity edge?
+ */
+static int is_conditional_validity(struct isl_sched_edge *edge)
+{
+	return is_type(edge, isl_edge_conditional_validity);
+}
+
+/* Is "edge" of a type that can appear multiple times between
+ * the same pair of nodes?
+ *
+ * Condition edges and conditional validity edges may have tagged
+ * dependence relations, in which case an edge is added for each
+ * pair of tags.
+ */
+static int is_multi_edge_type(struct isl_sched_edge *edge)
+{
+	return is_condition(edge) || is_conditional_validity(edge);
+}
+
 /* Internal information about the dependence graph used during
  * the construction of the schedule.
  *
  * intra_hmap is a cache, mapping dependence relations to their dual,
- *	for dependences from a node to itself
+ *	for dependences from a node to itself, possibly without
+ *	coefficients for the parameters
+ * intra_hmap_param is a cache, mapping dependence relations to their dual,
+ *	for dependences from a node to itself, including coefficients
+ *	for the parameters
  * inter_hmap is a cache, mapping dependence relations to their dual,
  *	for dependences between distinct nodes
  * if compression is involved then the key for these maps
- * it the original, uncompressed dependence relation, while
+ * is the original, uncompressed dependence relation, while
  * the value is the dual of the compressed dependence relation.
  *
  * n is the number of nodes
@@ -434,10 +323,10 @@
  * n_row is the current (maximal) number of linearly independent
  *	rows in the node schedules
  * n_total_row is the current number of rows in the node schedules
- * n_band is the current number of completed bands
  * band_start is the starting row in the node schedules of the current band
- * root is set if this graph is the original dependence graph,
- *	without any splitting
+ * root is set to the original dependence graph from which this graph
+ *	is derived through splitting.  If this graph is not the result of
+ *	splitting, then the root field points to the graph itself.
  *
  * sorted contains a list of node indices sorted according to the
  *	SCC to which a node belongs
@@ -449,10 +338,12 @@
  * edge_table contains pointers into the edge array, hashed on the source
  *	and sink spaces; there is one such table for each type;
  *	a given edge may be referenced from more than one table
- *	if the corresponding relation appears in more than of the
- *	sets of dependences
+ *	if the corresponding relation appears in more than one of the
+ *	sets of dependences; however, for each type there is only
+ *	a single edge between a given pair of source and sink space
+ *	in the entire graph
  *
- * node_table contains pointers into the node array, hashed on the space
+ * node_table contains pointers into the node array, hashed on the space tuples
  *
  * region contains a list of variable sequences that should be non-trivial
  *
@@ -462,9 +353,14 @@
  *	conflicting constraints
  *
  * scc represents the number of components
+ * weak is set if the components are weakly connected
+ *
+ * max_weight is used during clustering and represents the maximal
+ * weight of the relevant proximity edges.
  */
 struct isl_sched_graph {
 	isl_map_to_basic_set *intra_hmap;
+	isl_map_to_basic_set *intra_hmap_param;
 	isl_map_to_basic_set *inter_hmap;
 
 	struct isl_sched_node *node;
@@ -475,11 +371,10 @@
 
 	int *sorted;
 
-	int n_band;
 	int n_total_row;
 	int band_start;
 
-	int root;
+	struct isl_sched_graph *root;
 
 	struct isl_sched_edge *edge;
 	int n_edge;
@@ -487,7 +382,7 @@
 	struct isl_hash_table *edge_tableisl_edge_last + 1;
 
 	struct isl_hash_table *node_table;
-	struct isl_region *region;
+	struct isl_trivial_region *region;
 
 	isl_basic_set *lp;
 
@@ -495,6 +390,9 @@
 	int dst_scc;
 
 	int scc;
+	int weak;
+
+	int max_weight;
 };
 
 /* Initialize node_table based on the list of nodes.
@@ -511,9 +409,9 @@
 		struct isl_hash_table_entry *entry;
 		uint32_t hash;
 
-		hash = isl_space_get_hash(graph->nodei.space);
+		hash = isl_space_get_tuple_hash(graph->nodei.space);
 		entry = isl_hash_table_find(ctx, graph->node_table, hash,
-					    &node_has_space,
+					    &node_has_tuples,
 					    graph->nodei.space, 1);
 		if (!entry)
 			return -1;
@@ -524,33 +422,49 @@
 }
 
 /* Return a pointer to the node that lives within the given space,
- * or NULL if there is no such node.
+ * an invalid node if there is no such node, or NULL in case of error.
  */
 static struct isl_sched_node *graph_find_node(isl_ctx *ctx,
-	struct isl_sched_graph *graph, __isl_keep isl_space *dim)
+	struct isl_sched_graph *graph, __isl_keep isl_space *space)
 {
 	struct isl_hash_table_entry *entry;
 	uint32_t hash;
 
-	hash = isl_space_get_hash(dim);
+	if (!space)
+		return NULL;
+
+	hash = isl_space_get_tuple_hash(space);
 	entry = isl_hash_table_find(ctx, graph->node_table, hash,
-				    &node_has_space, dim, 0);
+				    &node_has_tuples, space, 0);
+	if (!entry)
+		return NULL;
+	if (entry == isl_hash_table_entry_none)
+		return graph->node + graph->n;
 
-	return entry ? entry->data : NULL;
+	return entry->data;
 }
 
-static int edge_has_src_and_dst(const void *entry, const void *val)
+/* Is "node" a node in "graph"?
+ */
+static int is_node(struct isl_sched_graph *graph,
+	struct isl_sched_node *node)
+{
+	return node && node >= &graph->node0 && node < &graph->nodegraph->n;
+}
+
+static isl_bool edge_has_src_and_dst(const void *entry, const void *val)
 {
 	const struct isl_sched_edge *edge = entry;
 	const struct isl_sched_edge *temp = val;
 
-	return edge->src == temp->src && edge->dst == temp->dst;
+	return isl_bool_ok(edge->src == temp->src && edge->dst == temp->dst);
 }
 
 /* Add the given edge to graph->edge_tabletype.
  */
-static int graph_edge_table_add(isl_ctx *ctx, struct isl_sched_graph *graph,
-	enum isl_edge_type type, struct isl_sched_edge *edge)
+static isl_stat graph_edge_table_add(isl_ctx *ctx,
+	struct isl_sched_graph *graph, enum isl_edge_type type,
+	struct isl_sched_edge *edge)
 {
 	struct isl_hash_table_entry *entry;
 	uint32_t hash;
@@ -561,10 +475,28 @@
 	entry = isl_hash_table_find(ctx, graph->edge_tabletype, hash,
 				    &edge_has_src_and_dst, edge, 1);
 	if (!entry)
-		return -1;
+		return isl_stat_error;
 	entry->data = edge;
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* Add "edge" to all relevant edge tables.
+ * That is, for every type of the edge, add it to the corresponding table.
+ */
+static isl_stat graph_edge_tables_add(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_sched_edge *edge)
+{
+	enum isl_edge_type t;
+
+	for (t = isl_edge_first; t <= isl_edge_last; ++t) {
+		if (!is_type(edge, t))
+			continue;
+		if (graph_edge_table_add(ctx, graph, t, edge) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
 }
 
 /* Allocate the edge_tables based on the maximal number of edges of
@@ -607,17 +539,21 @@
 
 /* If graph->edge_tabletype contains an edge from the given source
  * to the given destination, then return this edge.
- * Otherwise, return NULL.
+ * Return "none" if no such edge can be found.
+ * Return NULL on error.
  */
 static struct isl_sched_edge *graph_find_edge(struct isl_sched_graph *graph,
 	enum isl_edge_type type,
-	struct isl_sched_node *src, struct isl_sched_node *dst)
+	struct isl_sched_node *src, struct isl_sched_node *dst,
+	struct isl_sched_edge *none)
 {
 	struct isl_hash_table_entry *entry;
 
 	entry = graph_find_edge_entry(graph, type, src, dst);
 	if (!entry)
 		return NULL;
+	if (entry == isl_hash_table_entry_none)
+		return none;
 
 	return entry->data;
 }
@@ -625,22 +561,23 @@
 /* Check whether the dependence graph has an edge of the given type
  * between the given two nodes.
  */
-static int graph_has_edge(struct isl_sched_graph *graph,
+static isl_bool graph_has_edge(struct isl_sched_graph *graph,
 	enum isl_edge_type type,
 	struct isl_sched_node *src, struct isl_sched_node *dst)
 {
+	struct isl_sched_edge dummy;
 	struct isl_sched_edge *edge;
-	int empty;
+	isl_bool empty;
 
-	edge = graph_find_edge(graph, type, src, dst);
+	edge = graph_find_edge(graph, type, src, dst, &dummy);
 	if (!edge)
-		return 0;
+		return isl_bool_error;
+	if (edge == &dummy)
+		return isl_bool_false;
 
 	empty = isl_map_plain_is_empty(edge->map);
-	if (empty < 0)
-		return -1;
 
-	return !empty;
+	return isl_bool_not(empty);
 }
 
 /* Look for any edge with the same src, dst and map fields as "model".
@@ -658,8 +595,10 @@
 	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
 		int is_equal;
 
-		edge = graph_find_edge(graph, i, model->src, model->dst);
+		edge = graph_find_edge(graph, i, model->src, model->dst, model);
 		if (!edge)
+			return NULL;
+		if (edge == model)
 			continue;
 		is_equal = isl_map_plain_is_equal(model->map, edge->map);
 		if (is_equal < 0)
@@ -673,7 +612,7 @@
 
 /* Remove the given edge from all the edge_tables that refer to it.
  */
-static void graph_remove_edge(struct isl_sched_graph *graph,
+static isl_stat graph_remove_edge(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge)
 {
 	isl_ctx *ctx = isl_map_get_ctx(edge->map);
@@ -684,21 +623,25 @@
 
 		entry = graph_find_edge_entry(graph, i, edge->src, edge->dst);
 		if (!entry)
+			return isl_stat_error;
+		if (entry == isl_hash_table_entry_none)
 			continue;
 		if (entry->data != edge)
 			continue;
 		isl_hash_table_remove(ctx, graph->edge_tablei, entry);
 	}
+
+	return isl_stat_ok;
 }
 
 /* Check whether the dependence graph has any edge
  * between the given two nodes.
  */
-static int graph_has_any_edge(struct isl_sched_graph *graph,
+static isl_bool graph_has_any_edge(struct isl_sched_graph *graph,
 	struct isl_sched_node *src, struct isl_sched_node *dst)
 {
 	enum isl_edge_type i;
-	int r;
+	isl_bool r;
 
 	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
 		r = graph_has_edge(graph, i, src, dst);
@@ -720,10 +663,10 @@
  * of strongly connected components and we cannot ignore
  * conditional validity edges during this detection.
  */
-static int graph_has_validity_edge(struct isl_sched_graph *graph,
+static isl_bool graph_has_validity_edge(struct isl_sched_graph *graph,
 	struct isl_sched_node *src, struct isl_sched_node *dst)
 {
-	int r;
+	isl_bool r;
 
 	r = graph_has_edge(graph, isl_edge_validity, src, dst);
 	if (r < 0 || r)
@@ -732,7 +675,11 @@
 	return graph_has_edge(graph, isl_edge_conditional_validity, src, dst);
 }
 
-static int graph_alloc(isl_ctx *ctx, struct isl_sched_graph *graph,
+/* Perform all the required memory allocations for a schedule graph "graph"
+ * with "n_node" nodes and "n_edge" edge and initialize the corresponding
+ * fields.
+ */
+static isl_stat graph_alloc(isl_ctx *ctx, struct isl_sched_graph *graph,
 	int n_node, int n_edge)
 {
 	int i;
@@ -741,21 +688,46 @@
 	graph->n_edge = n_edge;
 	graph->node = isl_calloc_array(ctx, struct isl_sched_node, graph->n);
 	graph->sorted = isl_calloc_array(ctx, int, graph->n);
-	graph->region = isl_alloc_array(ctx, struct isl_region, graph->n);
+	graph->region = isl_alloc_array(ctx,
+					struct isl_trivial_region, graph->n);
 	graph->edge = isl_calloc_array(ctx,
 					struct isl_sched_edge, graph->n_edge);
 
 	graph->intra_hmap = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
+	graph->intra_hmap_param = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
 	graph->inter_hmap = isl_map_to_basic_set_alloc(ctx, 2 * n_edge);
 
 	if (!graph->node || !graph->region || (graph->n_edge && !graph->edge) ||
 	    !graph->sorted)
-		return -1;
+		return isl_stat_error;
 
 	for(i = 0; i < graph->n; ++i)
 		graph->sortedi = i;
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* Free the memory associated to node "node" in "graph".
+ * The "coincident" field is shared by nodes in a graph and its subgraph.
+ * It therefore only needs to be freed for the original dependence graph,
+ * i.e., one that is not the result of splitting.
+ */
+static void clear_node(struct isl_sched_graph *graph,
+	struct isl_sched_node *node)
+{
+	isl_space_free(node->space);
+	isl_set_free(node->hull);
+	isl_multi_aff_free(node->compress);
+	isl_pw_multi_aff_free(node->decompress);
+	isl_mat_free(node->sched);
+	isl_map_free(node->sched_map);
+	isl_mat_free(node->indep);
+	isl_mat_free(node->vmap);
+	if (graph->root == graph)
+		free(node->coincident);
+	isl_multi_val_free(node->sizes);
+	isl_basic_set_free(node->bounds);
+	isl_vec_free(node->max);
 }
 
 static void graph_free(isl_ctx *ctx, struct isl_sched_graph *graph)
@@ -763,24 +735,12 @@
 	int i;
 
 	isl_map_to_basic_set_free(graph->intra_hmap);
+	isl_map_to_basic_set_free(graph->intra_hmap_param);
 	isl_map_to_basic_set_free(graph->inter_hmap);
 
 	if (graph->node)
-		for (i = 0; i < graph->n; ++i) {
-			isl_space_free(graph->nodei.space);
-			isl_set_free(graph->nodei.hull);
-			isl_multi_aff_free(graph->nodei.compress);
-			isl_multi_aff_free(graph->nodei.decompress);
-			isl_mat_free(graph->nodei.sched);
-			isl_map_free(graph->nodei.sched_map);
-			isl_mat_free(graph->nodei.cmap);
-			isl_mat_free(graph->nodei.cinv);
-			if (graph->root) {
-				free(graph->nodei.band);
-				free(graph->nodei.band_id);
-				free(graph->nodei.coincident);
-			}
-		}
+		for (i = 0; i < graph->n; ++i)
+			clear_node(graph, &graph->nodei);
 	free(graph->node);
 	free(graph->sorted);
 	if (graph->edge)
@@ -800,10 +760,10 @@
 /* For each "set" on which this function is called, increment
  * graph->n by one and update graph->maxvar.
  */
-static int init_n_maxvar(__isl_take isl_set *set, void *user)
+static isl_stat init_n_maxvar(__isl_take isl_set *set, void *user)
 {
 	struct isl_sched_graph *graph = user;
-	int nvar = isl_set_dim(set, isl_dim_set);
+	isl_size nvar = isl_set_dim(set, isl_dim_set);
 
 	graph->n++;
 	if (nvar > graph->maxvar)
@@ -811,64 +771,52 @@
 
 	isl_set_free(set);
 
-	return 0;
-}
-
-/* Add the number of basic maps in "map" to *n.
- */
-static int add_n_basic_map(__isl_take isl_map *map, void *user)
-{
-	int *n = user;
-
-	*n += isl_map_n_basic_map(map);
-	isl_map_free(map);
-
-	return 0;
+	if (nvar < 0)
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* Compute the number of rows that should be allocated for the schedule.
- * The graph can be split at most "n - 1" times, there can be at most
- * one row for each dimension in the iteration domains plus two rows
- * for each basic map in the dependences (in particular,
- * we usually have one row, but it may be split by split_scaled),
- * and there can be one extra row for ordering the statements.
- * Note that if we have actually split "n - 1" times, then no ordering
- * is needed, so in principle we could use "graph->n + 2 * graph->maxvar - 1".
- * It is also practically impossible to exhaust both the number of dependences
- * and the number of variables.
+ * In particular, we need one row for each variable or one row
+ * for each basic map in the dependences.
+ * Note that it is practically impossible to exhaust both
+ * the number of dependences and the number of variables.
  */
-static int compute_max_row(struct isl_sched_graph *graph,
+static isl_stat compute_max_row(struct isl_sched_graph *graph,
 	__isl_keep isl_schedule_constraints *sc)
 {
-	enum isl_edge_type i;
 	int n_edge;
+	isl_stat r;
+	isl_union_set *domain;
 
 	graph->n = 0;
 	graph->maxvar = 0;
-	if (isl_union_set_foreach_set(sc->domain, &init_n_maxvar, graph) < 0)
-		return -1;
-	n_edge = 0;
-	for (i = isl_edge_first; i <= isl_edge_last; ++i)
-		if (isl_union_map_foreach_map(sc->constrainti,
-						&add_n_basic_map, &n_edge) < 0)
-			return -1;
-	graph->max_row = graph->n + 2 * n_edge + graph->maxvar;
+	domain = isl_schedule_constraints_get_domain(sc);
+	r = isl_union_set_foreach_set(domain, &init_n_maxvar, graph);
+	isl_union_set_free(domain);
+	if (r < 0)
+		return isl_stat_error;
+	n_edge = isl_schedule_constraints_n_basic_map(sc);
+	if (n_edge < 0)
+		return isl_stat_error;
+	graph->max_row = n_edge + graph->maxvar;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Does "bset" have any defining equalities for its set variables?
  */
-static int has_any_defining_equality(__isl_keep isl_basic_set *bset)
+static isl_bool has_any_defining_equality(__isl_keep isl_basic_set *bset)
 {
-	int i, n;
-
-	if (!bset)
-		return -1;
+	int i;
+	isl_size n;
 
 	n = isl_basic_set_dim(bset, isl_dim_set);
+	if (n < 0)
+		return isl_bool_error;
+
 	for (i = 0; i < n; ++i) {
-		int has;
+		isl_bool has;
 
 		has = isl_basic_set_has_defining_equality(bset, isl_dim_set, i,
 							NULL);
@@ -876,12 +824,361 @@
 			return has;
 	}
 
-	return 0;
+	return isl_bool_false;
+}
+
+/* Set the entries of node->max to the value of the schedule_max_coefficient
+ * option, if set.
+ */
+static isl_stat set_max_coefficient(isl_ctx *ctx, struct isl_sched_node *node)
+{
+	int max;
+
+	max = isl_options_get_schedule_max_coefficient(ctx);
+	if (max == -1)
+		return isl_stat_ok;
+
+	node->max = isl_vec_alloc(ctx, node->nvar);
+	node->max = isl_vec_set_si(node->max, max);
+	if (!node->max)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Set the entries of node->max to the minimum of the schedule_max_coefficient
+ * option (if set) and half of the minimum of the sizes in the other
+ * dimensions.  Round up when computing the half such that
+ * if the minimum of the sizes is one, half of the size is taken to be one
+ * rather than zero.
+ * If the global minimum is unbounded (i.e., if both
+ * the schedule_max_coefficient is not set and the sizes in the other
+ * dimensions are unbounded), then store a negative value.
+ * If the schedule coefficient is close to the size of the instance set
+ * in another dimension, then the schedule may represent a loop
+ * coalescing transformation (especially if the coefficient
+ * in that other dimension is one).  Forcing the coefficient to be
+ * smaller than or equal to half the minimal size should avoid this
+ * situation.
+ */
+static isl_stat compute_max_coefficient(isl_ctx *ctx,
+	struct isl_sched_node *node)
+{
+	int max;
+	int i, j;
+	isl_vec *v;
+
+	max = isl_options_get_schedule_max_coefficient(ctx);
+	v = isl_vec_alloc(ctx, node->nvar);
+	if (!v)
+		return isl_stat_error;
+
+	for (i = 0; i < node->nvar; ++i) {
+		isl_int_set_si(v->eli, max);
+		isl_int_mul_si(v->eli, v->eli, 2);
+	}
+
+	for (i = 0; i < node->nvar; ++i) {
+		isl_val *size;
+
+		size = isl_multi_val_get_val(node->sizes, i);
+		if (!size)
+			goto error;
+		if (!isl_val_is_int(size)) {
+			isl_val_free(size);
+			continue;
+		}
+		for (j = 0; j < node->nvar; ++j) {
+			if (j == i)
+				continue;
+			if (isl_int_is_neg(v->elj) ||
+			    isl_int_gt(v->elj, size->n))
+				isl_int_set(v->elj, size->n);
+		}
+		isl_val_free(size);
+	}
+
+	for (i = 0; i < node->nvar; ++i)
+		isl_int_cdiv_q_ui(v->eli, v->eli, 2);
+
+	node->max = v;
+	return isl_stat_ok;
+error:
+	isl_vec_free(v);
+	return isl_stat_error;
 }
 
-/* Add a new node to the graph representing the given space.
+/* Construct an identifier for node "node", which will represent "set".
+ * The name of the identifier is either "compressed" or
+ * "compressed_<name>", with <name> the name of the space of "set".
+ * The user pointer of the identifier points to "node".
+ */
+static __isl_give isl_id *construct_compressed_id(__isl_keep isl_set *set,
+	struct isl_sched_node *node)
+{
+	isl_bool has_name;
+	isl_ctx *ctx;
+	isl_id *id;
+	isl_printer *p;
+	const char *name;
+	char *id_name;
+
+	has_name = isl_set_has_tuple_name(set);
+	if (has_name < 0)
+		return NULL;
+
+	ctx = isl_set_get_ctx(set);
+	if (!has_name)
+		return isl_id_alloc(ctx, "compressed", node);
+
+	p = isl_printer_to_str(ctx);
+	name = isl_set_get_tuple_name(set);
+	p = isl_printer_print_str(p, "compressed_");
+	p = isl_printer_print_str(p, name);
+	id_name = isl_printer_get_str(p);
+	isl_printer_free(p);
+
+	id = isl_id_alloc(ctx, id_name, node);
+	free(id_name);
+
+	return id;
+}
+
+/* Construct a map that isolates the variable in position "pos" in "set".
+ *
+ * That is, construct
+ *
+ *	i_0, ..., i_pos-1, i_pos+1, ... -> i_pos
+ */
+static __isl_give isl_map *isolate(__isl_take isl_set *set, int pos)
+{
+	isl_map *map;
+
+	map = isl_set_project_onto_map(set, isl_dim_set, pos, 1);
+	map = isl_map_project_out(map, isl_dim_in, pos, 1);
+	return map;
+}
+
+/* Compute and return the size of "set" in dimension "dim".
+ * The size is taken to be the difference in values for that variable
+ * for fixed values of the other variables.
+ * This assumes that "set" is convex.
+ * In particular, the variable is first isolated from the other variables
+ * in the range of a map
+ *
+ *	i_0, ..., i_dim-1, i_dim+1, ... -> i_dim
+ *
+ * and then duplicated
+ *
+ *	i_0, ..., i_dim-1, i_dim+1, ... -> i_dim -> i_dim'
+ *
+ * The shared variables are then projected out and the maximal value
+ * of i_dim' - i_dim is computed.
+ */
+static __isl_give isl_val *compute_size(__isl_take isl_set *set, int dim)
+{
+	isl_map *map;
+	isl_local_space *ls;
+	isl_aff *obj;
+	isl_val *v;
+
+	map = isolate(set, dim);
+	map = isl_map_range_product(map, isl_map_copy(map));
+	map = isl_set_unwrap(isl_map_range(map));
+	set = isl_map_deltas(map);
+	ls = isl_local_space_from_space(isl_set_get_space(set));
+	obj = isl_aff_var_on_domain(ls, isl_dim_set, 0);
+	v = isl_set_max_val(set, obj);
+	isl_aff_free(obj);
+	isl_set_free(set);
+
+	return v;
+}
+
+/* Perform a compression on "node" where "hull" represents the constraints
+ * that were used to derive the compression, while "compress" and
+ * "decompress" map the original space to the compressed space and
+ * vice versa.
+ *
+ * If "node" was not compressed already, then simply store
+ * the compression information.
+ * Otherwise the "original" space is actually the result
+ * of a previous compression, which is then combined
+ * with the present compression.
+ *
+ * The dimensionality of the compressed domain is also adjusted.
+ * Other information, such as the sizes and the maximal coefficient values,
+ * has not been computed yet and therefore does not need to be adjusted.
+ */
+static isl_stat compress_node(struct isl_sched_node *node,
+	__isl_take isl_set *hull, __isl_take isl_multi_aff *compress,
+	__isl_take isl_pw_multi_aff *decompress)
+{
+	node->nvar = isl_multi_aff_dim(compress, isl_dim_out);
+	if (!node->compressed) {
+		node->compressed = 1;
+		node->hull = hull;
+		node->compress = compress;
+		node->decompress = decompress;
+	} else {
+		hull = isl_set_preimage_multi_aff(hull,
+					    isl_multi_aff_copy(node->compress));
+		node->hull = isl_set_intersect(node->hull, hull);
+		node->compress = isl_multi_aff_pullback_multi_aff(
+						compress, node->compress);
+		node->decompress = isl_pw_multi_aff_pullback_pw_multi_aff(
+						node->decompress, decompress);
+	}
+
+	if (!node->hull || !node->compress || !node->decompress)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Given that dimension "pos" in "set" has a fixed value
+ * in terms of the other dimensions, (further) compress "node"
+ * by projecting out this dimension.
+ * "set" may be the result of a previous compression.
+ * "uncompressed" is the original domain (without compression).
+ *
+ * The compression function simply projects out the dimension.
+ * The decompression function adds back the dimension
+ * in the right position as an expression of the other dimensions
+ * derived from "set".
+ * As in extract_node, the compressed space has an identifier
+ * that references "node" such that each compressed space is unique and
+ * such that the node can be recovered from the compressed space.
+ *
+ * The constraint removed through the compression is added to the "hull"
+ * such that only edges that relate to the original domains
+ * are taken into account.
+ * In particular, it is obtained by composing compression and decompression and
+ * taking the relation among the variables in the range.
+ */
+static isl_stat project_out_fixed(struct isl_sched_node *node,
+	__isl_keep isl_set *uncompressed, __isl_take isl_set *set, int pos)
+{
+	isl_id *id;
+	isl_space *space;
+	isl_set *domain;
+	isl_map *map;
+	isl_multi_aff *compress;
+	isl_pw_multi_aff *decompress, *pma;
+	isl_multi_pw_aff *mpa;
+	isl_set *hull;
+
+	map = isolate(isl_set_copy(set), pos);
+	pma = isl_pw_multi_aff_from_map(map);
+	domain = isl_pw_multi_aff_domain(isl_pw_multi_aff_copy(pma));
+	pma = isl_pw_multi_aff_gist(pma, domain);
+	space = isl_pw_multi_aff_get_domain_space(pma);
+	mpa = isl_multi_pw_aff_identity(isl_space_map_from_set(space));
+	mpa = isl_multi_pw_aff_range_splice(mpa, pos,
+				    isl_multi_pw_aff_from_pw_multi_aff(pma));
+	decompress = isl_pw_multi_aff_from_multi_pw_aff(mpa);
+	space = isl_set_get_space(set);
+	compress = isl_multi_aff_project_out_map(space, isl_dim_set, pos, 1);
+	id = construct_compressed_id(uncompressed, node);
+	compress = isl_multi_aff_set_tuple_id(compress, isl_dim_out, id);
+	space = isl_space_reverse(isl_multi_aff_get_space(compress));
+	decompress = isl_pw_multi_aff_reset_space(decompress, space);
+	pma = isl_pw_multi_aff_pullback_multi_aff(
+	    isl_pw_multi_aff_copy(decompress), isl_multi_aff_copy(compress));
+	hull = isl_map_range(isl_map_from_pw_multi_aff(pma));
+
+	isl_set_free(set);
+
+	return compress_node(node, hull, compress, decompress);
+}
+
+/* Compute the size of the compressed domain in each dimension and
+ * store the results in node->sizes.
+ * "uncompressed" is the original domain (without compression).
+ *
+ * First compress the domain if needed and then compute the size
+ * in each direction.
+ * If the domain is not convex, then the sizes are computed
+ * on a convex superset in order to avoid picking up sizes
+ * that are valid for the individual disjuncts, but not for
+ * the domain as a whole.
+ *
+ * If any of the sizes turns out to be zero, then this means
+ * that this dimension has a fixed value in terms of
+ * the other dimensions.  Perform an (extra) compression
+ * to remove this dimensions.
+ */
+static isl_stat compute_sizes(struct isl_sched_node *node,
+	__isl_keep isl_set *uncompressed)
+{
+	int j;
+	isl_size n;
+	isl_multi_val *mv;
+	isl_set *set = isl_set_copy(uncompressed);
+
+	if (node->compressed)
+		set = isl_set_preimage_pw_multi_aff(set,
+				    isl_pw_multi_aff_copy(node->decompress));
+	set = isl_set_from_basic_set(isl_set_simple_hull(set));
+	mv = isl_multi_val_zero(isl_set_get_space(set));
+	n = isl_set_dim(set, isl_dim_set);
+	if (n < 0)
+		mv = isl_multi_val_free(mv);
+	for (j = 0; j < n; ++j) {
+		isl_bool is_zero;
+		isl_val *v;
+
+		v = compute_size(isl_set_copy(set), j);
+		is_zero = isl_val_is_zero(v);
+		mv = isl_multi_val_set_val(mv, j, v);
+		if (is_zero >= 0 && is_zero) {
+			isl_multi_val_free(mv);
+			if (project_out_fixed(node, uncompressed, set, j) < 0)
+				return isl_stat_error;
+			return compute_sizes(node, uncompressed);
+		}
+	}
+	node->sizes = mv;
+	isl_set_free(set);
+	if (!node->sizes)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Compute the size of the instance set "set" of "node", after compression,
+ * as well as bounds on the corresponding coefficients, if needed.
+ *
+ * The sizes are needed when the schedule_treat_coalescing option is set.
+ * The bounds are needed when the schedule_treat_coalescing option or
+ * the schedule_max_coefficient option is set.
+ *
+ * If the schedule_treat_coalescing option is not set, then at most
+ * the bounds need to be set and this is done in set_max_coefficient.
+ * Otherwise, compute the size of the compressed domain
+ * in each direction and store the results in node->size.
+ * Finally, set the bounds on the coefficients based on the sizes
+ * and the schedule_max_coefficient option in compute_max_coefficient.
+ */
+static isl_stat compute_sizes_and_max(isl_ctx *ctx, struct isl_sched_node *node,
+	__isl_take isl_set *set)
+{
+	isl_stat r;
+
+	if (!isl_options_get_schedule_treat_coalescing(ctx)) {
+		isl_set_free(set);
+		return set_max_coefficient(ctx, node);
+	}
+
+	r = compute_sizes(node, set);
+	isl_set_free(set);
+	if (r < 0)
+		return isl_stat_error;
+	return compute_max_coefficient(ctx, node);
+}
+
+/* Add a new node to the graph representing the given instance set.
  * "nvar" is the (possibly compressed) number of variables and
- * may be smaller than then number of set variables in "space"
+ * may be smaller than then number of set variables in "set"
  * if "compressed" is set.
  * If "compressed" is set, then "hull" represents the constraints
  * that were used to derive the compression, while "compress" and
@@ -889,49 +1186,59 @@
  * vice versa.
  * If "compressed" is not set, then "hull", "compress" and "decompress"
  * should be NULL.
+ *
+ * Compute the size of the instance set and bounds on the coefficients,
+ * if needed.
  */
-static int add_node(struct isl_sched_graph *graph, __isl_take isl_space *space,
-	int nvar, int compressed, __isl_take isl_set *hull,
-	__isl_take isl_multi_aff *compress,
-	__isl_take isl_multi_aff *decompress)
+static isl_stat add_node(struct isl_sched_graph *graph,
+	__isl_take isl_set *set, int nvar, int compressed,
+	__isl_take isl_set *hull, __isl_take isl_multi_aff *compress,
+	__isl_take isl_pw_multi_aff *decompress)
 {
-	int nparam;
+	isl_size nparam;
 	isl_ctx *ctx;
 	isl_mat *sched;
-	int *band, *band_id, *coincident;
+	isl_space *space;
+	int *coincident;
+	struct isl_sched_node *node;
 
-	if (!space)
-		return -1;
+	nparam = isl_set_dim(set, isl_dim_param);
+	if (nparam < 0)
+		goto error;
 
-	ctx = isl_space_get_ctx(space);
-	nparam = isl_space_dim(space, isl_dim_param);
+	ctx = isl_set_get_ctx(set);
 	if (!ctx->opt->schedule_parametric)
 		nparam = 0;
 	sched = isl_mat_alloc(ctx, 0, 1 + nparam + nvar);
-	graph->nodegraph->n.space = space;
-	graph->nodegraph->n.nvar = nvar;
-	graph->nodegraph->n.nparam = nparam;
-	graph->nodegraph->n.sched = sched;
-	graph->nodegraph->n.sched_map = NULL;
-	band = isl_alloc_array(ctx, int, graph->max_row);
-	graph->nodegraph->n.band = band;
-	band_id = isl_calloc_array(ctx, int, graph->max_row);
-	graph->nodegraph->n.band_id = band_id;
-	coincident = isl_calloc_array(ctx, int, graph->max_row);
-	graph->nodegraph->n.coincident = coincident;
-	graph->nodegraph->n.compressed = compressed;
-	graph->nodegraph->n.hull = hull;
-	graph->nodegraph->n.compress = compress;
-	graph->nodegraph->n.decompress = decompress;
+	node = &graph->nodegraph->n;
 	graph->n++;
+	space = isl_set_get_space(set);
+	node->space = space;
+	node->nvar = nvar;
+	node->nparam = nparam;
+	node->sched = sched;
+	node->sched_map = NULL;
+	coincident = isl_calloc_array(ctx, int, graph->max_row);
+	node->coincident = coincident;
+	node->compressed = compressed;
+	node->hull = hull;
+	node->compress = compress;
+	node->decompress = decompress;
+	if (compute_sizes_and_max(ctx, node, set) < 0)
+		return isl_stat_error;
 
-	if (!space || !sched ||
-	    (graph->max_row && (!band || !band_id || !coincident)))
-		return -1;
+	if (!space || !sched || (graph->max_row && !coincident))
+		return isl_stat_error;
 	if (compressed && (!hull || !compress || !decompress))
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
+error:
+	isl_set_free(set);
+	isl_set_free(hull);
+	isl_multi_aff_free(compress);
+	isl_pw_multi_aff_free(decompress);
+	return isl_stat_error;
 }
 
 /* Add a new node to the graph representing the given set.
@@ -939,44 +1246,52 @@
  * If any of the set variables is defined by an equality, then
  * we perform variable compression such that we can perform
  * the scheduling on the compressed domain.
+ * In this case, an identifier is used that references the new node
+ * such that each compressed space is unique and
+ * such that the node can be recovered from the compressed space.
  */
-static int extract_node(__isl_take isl_set *set, void *user)
+static isl_stat extract_node(__isl_take isl_set *set, void *user)
 {
-	int nvar;
-	int has_equality;
-	isl_space *space;
+	isl_size nvar;
+	isl_bool has_equality;
+	isl_id *id;
 	isl_basic_set *hull;
 	isl_set *hull_set;
 	isl_morph *morph;
-	isl_multi_aff *compress, *decompress;
+	isl_multi_aff *compress, *decompress_ma;
+	isl_pw_multi_aff *decompress;
 	struct isl_sched_graph *graph = user;
 
-	space = isl_set_get_space(set);
-	hull = isl_set_affine_hull(set);
+	hull = isl_set_affine_hull(isl_set_copy(set));
 	hull = isl_basic_set_remove_divs(hull);
-	nvar = isl_space_dim(space, isl_dim_set);
+	nvar = isl_set_dim(set, isl_dim_set);
 	has_equality = has_any_defining_equality(hull);
 
-	if (has_equality < 0)
+	if (nvar < 0 || has_equality < 0)
 		goto error;
 	if (!has_equality) {
 		isl_basic_set_free(hull);
-		return add_node(graph, space, nvar, 0, NULL, NULL, NULL);
+		return add_node(graph, set, nvar, 0, NULL, NULL, NULL);
 	}
 
-	morph = isl_basic_set_variable_compression(hull, isl_dim_set);
+	id = construct_compressed_id(set, &graph->nodegraph->n);
+	morph = isl_basic_set_variable_compression_with_id(hull, id);
+	isl_id_free(id);
 	nvar = isl_morph_ran_dim(morph, isl_dim_set);
+	if (nvar < 0)
+		set = isl_set_free(set);
 	compress = isl_morph_get_var_multi_aff(morph);
 	morph = isl_morph_inverse(morph);
-	decompress = isl_morph_get_var_multi_aff(morph);
+	decompress_ma = isl_morph_get_var_multi_aff(morph);
+	decompress = isl_pw_multi_aff_from_multi_aff(decompress_ma);
 	isl_morph_free(morph);
 
 	hull_set = isl_set_from_basic_set(hull);
-	return add_node(graph, space, nvar, 1, hull_set, compress, decompress);
+	return add_node(graph, set, nvar, 1, hull_set, compress, decompress);
 error:
 	isl_basic_set_free(hull);
-	isl_space_free(space);
-	return -1;
+	isl_set_free(set);
+	return isl_stat_error;
 }
 
 struct isl_extract_edge_data {
@@ -985,23 +1300,17 @@
 };
 
 /* Merge edge2 into edge1, freeing the contents of edge2.
- * "type" is the type of the schedule constraint from which edge2 was
- * extracted.
  * Return 0 on success and -1 on failure.
  *
  * edge1 and edge2 are assumed to have the same value for the map field.
  */
-static int merge_edge(enum isl_edge_type type, struct isl_sched_edge *edge1,
+static int merge_edge(struct isl_sched_edge *edge1,
 	struct isl_sched_edge *edge2)
 {
-	edge1->validity |= edge2->validity;
-	edge1->coincidence |= edge2->coincidence;
-	edge1->proximity |= edge2->proximity;
-	edge1->condition |= edge2->condition;
-	edge1->conditional_validity |= edge2->conditional_validity;
+	edge1->types |= edge2->types;
 	isl_map_free(edge2->map);
 
-	if (type == isl_edge_condition) {
+	if (is_condition(edge2)) {
 		if (!edge1->tagged_condition)
 			edge1->tagged_condition = edge2->tagged_condition;
 		else
@@ -1010,7 +1319,7 @@
 						    edge2->tagged_condition);
 	}
 
-	if (type == isl_edge_conditional_validity) {
+	if (is_conditional_validity(edge2)) {
 		if (!edge1->tagged_validity)
 			edge1->tagged_validity = edge2->tagged_validity;
 		else
@@ -1019,9 +1328,9 @@
 						    edge2->tagged_validity);
 	}
 
-	if (type == isl_edge_condition && !edge1->tagged_condition)
+	if (is_condition(edge2) && !edge1->tagged_condition)
 		return -1;
-	if (type == isl_edge_conditional_validity && !edge1->tagged_validity)
+	if (is_conditional_validity(edge2) && !edge1->tagged_validity)
 		return -1;
 
 	return 0;
@@ -1100,6 +1409,50 @@
 	return tagged;
 }
 
+/* Return a pointer to the node that lives in the domain space of "map",
+ * an invalid node if there is no such node, or NULL in case of error.
+ */
+static struct isl_sched_node *find_domain_node(isl_ctx *ctx,
+	struct isl_sched_graph *graph, __isl_keep isl_map *map)
+{
+	struct isl_sched_node *node;
+	isl_space *space;
+
+	space = isl_space_domain(isl_map_get_space(map));
+	node = graph_find_node(ctx, graph, space);
+	isl_space_free(space);
+
+	return node;
+}
+
+/* Return a pointer to the node that lives in the range space of "map",
+ * an invalid node if there is no such node, or NULL in case of error.
+ */
+static struct isl_sched_node *find_range_node(isl_ctx *ctx,
+	struct isl_sched_graph *graph, __isl_keep isl_map *map)
+{
+	struct isl_sched_node *node;
+	isl_space *space;
+
+	space = isl_space_range(isl_map_get_space(map));
+	node = graph_find_node(ctx, graph, space);
+	isl_space_free(space);
+
+	return node;
+}
+
+/* Refrain from adding a new edge based on "map".
+ * Instead, just free the map.
+ * "tagged" is either a copy of "map" with additional tags or NULL.
+ */
+static isl_stat skip_edge(__isl_take isl_map *map, __isl_take isl_map *tagged)
+{
+	isl_map_free(map);
+	isl_map_free(tagged);
+
+	return isl_stat_ok;
+}
+
 /* Add a new edge to the graph based on the given map
  * and add it to data->graph->edge_tabledata->type.
  * If a dependence relation of a given type happens to be identical
@@ -1123,13 +1476,13 @@
  * outside of these domains, while the scheduler no longer has
  * any control over those outside parts.
  */
-static int extract_edge(__isl_take isl_map *map, void *user)
+static isl_stat extract_edge(__isl_take isl_map *map, void *user)
 {
+	isl_bool empty;
 	isl_ctx *ctx = isl_map_get_ctx(map);
 	struct isl_extract_edge_data *data = user;
 	struct isl_sched_graph *graph = data->graph;
 	struct isl_sched_node *src, *dst;
-	isl_space *dim;
 	struct isl_sched_edge *edge;
 	isl_map *tagged = NULL;
 
@@ -1143,18 +1496,13 @@
 		}
 	}
 
-	dim = isl_space_domain(isl_map_get_space(map));
-	src = graph_find_node(ctx, graph, dim);
-	isl_space_free(dim);
-	dim = isl_space_range(isl_map_get_space(map));
-	dst = graph_find_node(ctx, graph, dim);
-	isl_space_free(dim);
+	src = find_domain_node(ctx, graph, map);
+	dst = find_range_node(ctx, graph, map);
 
-	if (!src || !dst) {
-		isl_map_free(map);
-		isl_map_free(tagged);
-		return 0;
-	}
+	if (!src || !dst)
+		goto error;
+	if (!is_node(graph, src) || !is_node(graph, dst))
+		return skip_edge(map, tagged);
 
 	if (src->compressed || dst->compressed) {
 		isl_map *hull;
@@ -1164,55 +1512,126 @@
 		map = isl_map_intersect(map, hull);
 	}
 
+	empty = isl_map_plain_is_empty(map);
+	if (empty < 0)
+		goto error;
+	if (empty)
+		return skip_edge(map, tagged);
+
 	graph->edgegraph->n_edge.src = src;
 	graph->edgegraph->n_edge.dst = dst;
 	graph->edgegraph->n_edge.map = map;
-	graph->edgegraph->n_edge.validity = 0;
-	graph->edgegraph->n_edge.coincidence = 0;
-	graph->edgegraph->n_edge.proximity = 0;
-	graph->edgegraph->n_edge.condition = 0;
-	graph->edgegraph->n_edge.local = 0;
-	graph->edgegraph->n_edge.conditional_validity = 0;
+	graph->edgegraph->n_edge.types = 0;
 	graph->edgegraph->n_edge.tagged_condition = NULL;
 	graph->edgegraph->n_edge.tagged_validity = NULL;
-	if (data->type == isl_edge_validity)
-		graph->edgegraph->n_edge.validity = 1;
-	if (data->type == isl_edge_coincidence)
-		graph->edgegraph->n_edge.coincidence = 1;
-	if (data->type == isl_edge_proximity)
-		graph->edgegraph->n_edge.proximity = 1;
-	if (data->type == isl_edge_condition) {
-		graph->edgegraph->n_edge.condition = 1;
+	set_type(&graph->edgegraph->n_edge, data->type);
+	if (data->type == isl_edge_condition)
 		graph->edgegraph->n_edge.tagged_condition =
 					isl_union_map_from_map(tagged);
-	}
-	if (data->type == isl_edge_conditional_validity) {
-		graph->edgegraph->n_edge.conditional_validity = 1;
+	if (data->type == isl_edge_conditional_validity)
 		graph->edgegraph->n_edge.tagged_validity =
 					isl_union_map_from_map(tagged);
-	}
 
 	edge = graph_find_matching_edge(graph, &graph->edgegraph->n_edge);
 	if (!edge) {
 		graph->n_edge++;
-		return -1;
+		return isl_stat_error;
 	}
 	if (edge == &graph->edgegraph->n_edge)
 		return graph_edge_table_add(ctx, graph, data->type,
 				    &graph->edgegraph->n_edge++);
 
-	if (merge_edge(data->type, edge, &graph->edgegraph->n_edge) < 0)
-		return -1;
+	if (merge_edge(edge, &graph->edgegraph->n_edge) < 0)
+		return isl_stat_error;
 
 	return graph_edge_table_add(ctx, graph, data->type, edge);
+error:
+	isl_map_free(map);
+	isl_map_free(tagged);
+	return isl_stat_error;
+}
+
+/* Initialize the schedule graph "graph" from the schedule constraints "sc".
+ *
+ * The context is included in the domain before the nodes of
+ * the graphs are extracted in order to be able to exploit
+ * any possible additional equalities.
+ * Note that this intersection is only performed locally here.
+ */
+static isl_stat graph_init(struct isl_sched_graph *graph,
+	__isl_keep isl_schedule_constraints *sc)
+{
+	isl_ctx *ctx;
+	isl_union_set *domain;
+	isl_union_map *c;
+	struct isl_extract_edge_data data;
+	enum isl_edge_type i;
+	isl_stat r;
+	isl_size n;
+
+	if (!sc)
+		return isl_stat_error;
+
+	ctx = isl_schedule_constraints_get_ctx(sc);
+
+	domain = isl_schedule_constraints_get_domain(sc);
+	n = isl_union_set_n_set(domain);
+	graph->n = n;
+	isl_union_set_free(domain);
+	if (n < 0)
+		return isl_stat_error;
+
+	n = isl_schedule_constraints_n_map(sc);
+	if (n < 0 || graph_alloc(ctx, graph, graph->n, n) < 0)
+		return isl_stat_error;
+
+	if (compute_max_row(graph, sc) < 0)
+		return isl_stat_error;
+	graph->root = graph;
+	graph->n = 0;
+	domain = isl_schedule_constraints_get_domain(sc);
+	domain = isl_union_set_intersect_params(domain,
+				    isl_schedule_constraints_get_context(sc));
+	r = isl_union_set_foreach_set(domain, &extract_node, graph);
+	isl_union_set_free(domain);
+	if (r < 0)
+		return isl_stat_error;
+	if (graph_init_table(ctx, graph) < 0)
+		return isl_stat_error;
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		isl_size n;
+
+		c = isl_schedule_constraints_get(sc, i);
+		n = isl_union_map_n_map(c);
+		graph->max_edgei = n;
+		isl_union_map_free(c);
+		if (n < 0)
+			return isl_stat_error;
+	}
+	if (graph_init_edge_tables(ctx, graph) < 0)
+		return isl_stat_error;
+	graph->n_edge = 0;
+	data.graph = graph;
+	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
+		isl_stat r;
+
+		data.type = i;
+		c = isl_schedule_constraints_get(sc, i);
+		r = isl_union_map_foreach_map(c, &extract_edge, &data);
+		isl_union_map_free(c);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
 }
 
 /* Check whether there is any dependence from nodej to nodei
  * or from nodei to nodej.
  */
-static int node_follows_weak(int i, int j, void *user)
+static isl_bool node_follows_weak(int i, int j, void *user)
 {
-	int f;
+	isl_bool f;
 	struct isl_sched_graph *graph = user;
 
 	f = graph_has_any_edge(graph, &graph->nodej, &graph->nodei);
@@ -1224,7 +1643,7 @@
 /* Check whether there is a (conditional) validity dependence from nodej
  * to nodei, forcing nodei to follow nodej.
  */
-static int node_follows_strong(int i, int j, void *user)
+static isl_bool node_follows_strong(int i, int j, void *user)
 {
 	struct isl_sched_graph *graph = user;
 
@@ -1232,20 +1651,17 @@
 }
 
 /* Use Tarjan's algorithm for computing the strongly connected components
- * in the dependence graph (only validity edges).
- * If weak is set, we consider the graph to be undirected and
- * we effectively compute the (weakly) connected components.
- * Additionally, we also consider other edges when weak is set.
+ * in the dependence graph only considering those edges defined by "follows".
  */
-static int detect_ccs(isl_ctx *ctx, struct isl_sched_graph *graph, int weak)
+static isl_stat detect_ccs(isl_ctx *ctx, struct isl_sched_graph *graph,
+	isl_bool (*follows)(int i, int j, void *user))
 {
 	int i, n;
 	struct isl_tarjan_graph *g = NULL;
 
-	g = isl_tarjan_graph_init(ctx, graph->n,
-		weak ? &node_follows_weak : &node_follows_strong, graph);
+	g = isl_tarjan_graph_init(ctx, graph->n, follows, graph);
 	if (!g)
-		return -1;
+		return isl_stat_error;
 
 	graph->scc = 0;
 	i = 0;
@@ -1262,23 +1678,27 @@
 
 	isl_tarjan_graph_free(g);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Apply Tarjan's algorithm to detect the strongly connected components
  * in the dependence graph.
+ * Only consider the (conditional) validity dependences and clear "weak".
  */
-static int detect_sccs(isl_ctx *ctx, struct isl_sched_graph *graph)
+static isl_stat detect_sccs(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
-	return detect_ccs(ctx, graph, 0);
+	graph->weak = 0;
+	return detect_ccs(ctx, graph, &node_follows_strong);
 }
 
 /* Apply Tarjan's algorithm to detect the (weakly) connected components
  * in the dependence graph.
+ * Consider all dependences and set "weak".
  */
-static int detect_wccs(isl_ctx *ctx, struct isl_sched_graph *graph)
+static isl_stat detect_wccs(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
-	return detect_ccs(ctx, graph, 1);
+	graph->weak = 1;
+	return detect_ccs(ctx, graph, &node_follows_weak);
 }
 
 static int cmp_scc(const void *a, const void *b, void *data)
@@ -1297,6 +1717,92 @@
 	return isl_sort(graph->sorted, graph->n, sizeof(int), &cmp_scc, graph);
 }
 
+/* Return a non-parametric set in the compressed space of "node" that is
+ * bounded by the size in each direction
+ *
+ *	{ x : -S_i <= x_i <= S_i }
+ *
+ * If S_i is infinity in direction i, then there are no constraints
+ * in that direction.
+ *
+ * Cache the result in node->bounds.
+ */
+static __isl_give isl_basic_set *get_size_bounds(struct isl_sched_node *node)
+{
+	isl_space *space;
+	isl_basic_set *bounds;
+	int i;
+
+	if (node->bounds)
+		return isl_basic_set_copy(node->bounds);
+
+	if (node->compressed)
+		space = isl_pw_multi_aff_get_domain_space(node->decompress);
+	else
+		space = isl_space_copy(node->space);
+	space = isl_space_drop_all_params(space);
+	bounds = isl_basic_set_universe(space);
+
+	for (i = 0; i < node->nvar; ++i) {
+		isl_val *size;
+
+		size = isl_multi_val_get_val(node->sizes, i);
+		if (!size)
+			return isl_basic_set_free(bounds);
+		if (!isl_val_is_int(size)) {
+			isl_val_free(size);
+			continue;
+		}
+		bounds = isl_basic_set_upper_bound_val(bounds, isl_dim_set, i,
+							isl_val_copy(size));
+		bounds = isl_basic_set_lower_bound_val(bounds, isl_dim_set, i,
+							isl_val_neg(size));
+	}
+
+	node->bounds = isl_basic_set_copy(bounds);
+	return bounds;
+}
+
+/* Compress the dependence relation "map", if needed, i.e.,
+ * when the source node "src" and/or the destination node "dst"
+ * has been compressed.
+ */
+static __isl_give isl_map *compress(__isl_take isl_map *map,
+	struct isl_sched_node *src, struct isl_sched_node *dst)
+{
+	if (src->compressed)
+		map = isl_map_preimage_domain_pw_multi_aff(map,
+					isl_pw_multi_aff_copy(src->decompress));
+	if (dst->compressed)
+		map = isl_map_preimage_range_pw_multi_aff(map,
+					isl_pw_multi_aff_copy(dst->decompress));
+	return map;
+}
+
+/* Drop some constraints from "delta" that could be exploited
+ * to construct loop coalescing schedules.
+ * In particular, drop those constraint that bound the difference
+ * to the size of the domain.
+ * First project out the parameters to improve the effectiveness.
+ */
+static __isl_give isl_set *drop_coalescing_constraints(
+	__isl_take isl_set *delta, struct isl_sched_node *node)
+{
+	isl_size nparam;
+	isl_basic_set *bounds;
+
+	nparam = isl_set_dim(delta, isl_dim_param);
+	if (nparam < 0)
+		return isl_set_free(delta);
+
+	bounds = get_size_bounds(node);
+
+	delta = isl_set_project_out(delta, isl_dim_param, 0, nparam);
+	delta = isl_set_remove_divs(delta);
+	delta = isl_set_plain_gist_basic_set(delta, bounds);
+	return delta;
+}
+
 /* Given a dependence relation R from "node" to itself,
  * construct the set of coefficients of valid constraints for elements
  * in that dependence relation.
@@ -1314,31 +1820,53 @@
  * in a set of tuples c_0, c_n, c_x, c_y, and then
  * plugged in (c_0, c_n, c_x, -c_x).
  *
+ * If "need_param" is set, then the resulting coefficients effectively
+ * include coefficients for the parameters c_n.  Otherwise, they may
+ * have been projected out already.
+ * Since the constraints may be different for these two cases,
+ * they are stored in separate caches.
+ * In particular, if no parameter coefficients are required and
+ * the schedule_treat_coalescing option is set, then the parameters
+ * are projected out and some constraints that could be exploited
+ * to construct coalescing schedules are removed before the dual
+ * is computed.
+ *
  * If "node" has been compressed, then the dependence relation
  * is also compressed before the set of coefficients is computed.
  */
 static __isl_give isl_basic_set *intra_coefficients(
 	struct isl_sched_graph *graph, struct isl_sched_node *node,
-	__isl_take isl_map *map)
+	__isl_take isl_map *map, int need_param)
 {
+	isl_ctx *ctx;
 	isl_set *delta;
 	isl_map *key;
 	isl_basic_set *coef;
+	isl_maybe_isl_basic_set m;
+	isl_map_to_basic_set **hmap = &graph->intra_hmap;
+	int treat;
 
-	if (isl_map_to_basic_set_has(graph->intra_hmap, map))
-		return isl_map_to_basic_set_get(graph->intra_hmap, map);
+	if (!map)
+		return NULL;
 
-	key = isl_map_copy(map);
-	if (node->compressed) {
-		map = isl_map_preimage_domain_multi_aff(map,
-				    isl_multi_aff_copy(node->decompress));
-		map = isl_map_preimage_range_multi_aff(map,
-				    isl_multi_aff_copy(node->decompress));
+	ctx = isl_map_get_ctx(map);
+	treat = !need_param && isl_options_get_schedule_treat_coalescing(ctx);
+	if (!treat)
+		hmap = &graph->intra_hmap_param;
+	m = isl_map_to_basic_set_try_get(*hmap, map);
+	if (m.valid < 0 || m.valid) {
+		isl_map_free(map);
+		return m.value;
 	}
-	delta = isl_set_remove_divs(isl_map_deltas(map));
+
+	key = isl_map_copy(map);
+	map = compress(map, node, node);
+	delta = isl_map_deltas(map);
+	if (treat)
+		delta = drop_coalescing_constraints(delta, node);
+	delta = isl_set_remove_divs(delta);
 	coef = isl_set_coefficients(delta);
-	graph->intra_hmap = isl_map_to_basic_set_set(graph->intra_hmap, key,
-					isl_basic_set_copy(coef));
+	*hmap = isl_map_to_basic_set_set(*hmap, key, isl_basic_set_copy(coef));
 
 	return coef;
 }
@@ -1361,17 +1889,16 @@
 	isl_set *set;
 	isl_map *key;
 	isl_basic_set *coef;
+	isl_maybe_isl_basic_set m;
 
-	if (isl_map_to_basic_set_has(graph->inter_hmap, map))
-		return isl_map_to_basic_set_get(graph->inter_hmap, map);
+	m = isl_map_to_basic_set_try_get(graph->inter_hmap, map);
+	if (m.valid < 0 || m.valid) {
+		isl_map_free(map);
+		return m.value;
+	}
 
 	key = isl_map_copy(map);
-	if (edge->src->compressed)
-		map = isl_map_preimage_domain_multi_aff(map,
-				    isl_multi_aff_copy(edge->src->decompress));
-	if (edge->dst->compressed)
-		map = isl_map_preimage_range_multi_aff(map,
-				    isl_multi_aff_copy(edge->dst->decompress));
+	map = compress(map, edge->src, edge->dst);
 	set = isl_map_wrap(isl_map_remove_divs(map));
 	coef = isl_set_coefficients(set);
 	graph->inter_hmap = isl_map_to_basic_set_set(graph->inter_hmap, key,
@@ -1380,6 +1907,190 @@
 	return coef;
 }
 
+/* Return the position of the coefficients of the variables in
+ * the coefficients constraints "coef".
+ *
+ * The space of "coef" is of the form
+ *
+ *	{ coefficientscst, params -> S }
+ *
+ * Return the position of S.
+ */
+static isl_size coef_var_offset(__isl_keep isl_basic_set *coef)
+{
+	isl_size offset;
+	isl_space *space;
+
+	space = isl_space_unwrap(isl_basic_set_get_space(coef));
+	offset = isl_space_dim(space, isl_dim_in);
+	isl_space_free(space);
+
+	return offset;
+}
+
+/* Return the offset of the coefficient of the constant term of "node"
+ * within the (I)LP.
+ *
+ * Within each node, the coefficients have the following order:
+ *	- positive and negative parts of c_i_x
+ *	- c_i_n (if parametric)
+ *	- c_i_0
+ */
+static int node_cst_coef_offset(struct isl_sched_node *node)
+{
+	return node->start + 2 * node->nvar + node->nparam;
+}
+
+/* Return the offset of the coefficients of the parameters of "node"
+ * within the (I)LP.
+ *
+ * Within each node, the coefficients have the following order:
+ *	- positive and negative parts of c_i_x
+ *	- c_i_n (if parametric)
+ *	- c_i_0
+ */
+static int node_par_coef_offset(struct isl_sched_node *node)
+{
+	return node->start + 2 * node->nvar;
+}
+
+/* Return the offset of the coefficients of the variables of "node"
+ * within the (I)LP.
+ *
+ * Within each node, the coefficients have the following order:
+ *	- positive and negative parts of c_i_x
+ *	- c_i_n (if parametric)
+ *	- c_i_0
+ */
+static int node_var_coef_offset(struct isl_sched_node *node)
+{
+	return node->start;
+}
+
+/* Return the position of the pair of variables encoding
+ * coefficient "i" of "node".
+ *
+ * The order of these variable pairs is the opposite of
+ * that of the coefficients, with 2 variables per coefficient.
+ */
+static int node_var_coef_pos(struct isl_sched_node *node, int i)
+{
+	return node_var_coef_offset(node) + 2 * (node->nvar - 1 - i);
+}
+
+/* Construct an isl_dim_map for mapping constraints on coefficients
+ * for "node" to the corresponding positions in graph->lp.
+ * "offset" is the offset of the coefficients for the variables
+ * in the input constraints.
+ * "s" is the sign of the mapping.
+ *
+ * The input constraints are given in terms of the coefficients
+ * (c_0, c_x) or (c_0, c_n, c_x).
+ * The mapping produced by this function essentially plugs in
+ * (0, c_i_x^+ - c_i_x^-) if s = 1 and
+ * (0, -c_i_x^+ + c_i_x^-) if s = -1 or
+ * (0, 0, c_i_x^+ - c_i_x^-) if s = 1 and
+ * (0, 0, -c_i_x^+ + c_i_x^-) if s = -1.
+ * In graph->lp, the c_i_x^- appear before their c_i_x^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
+ *
+ * The caller can extend the mapping to also map the other coefficients
+ * (and therefore not plug in 0).
+ */
+static __isl_give isl_dim_map *intra_dim_map(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_sched_node *node,
+	int offset, int s)
+{
+	int pos;
+	isl_size total;
+	isl_dim_map *dim_map;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_all);
+	if (!node || total < 0)
+		return NULL;
+
+	pos = node_var_coef_pos(node, 0);
+	dim_map = isl_dim_map_alloc(ctx, total);
+	isl_dim_map_range(dim_map, pos, -2, offset, 1, node->nvar, -s);
+	isl_dim_map_range(dim_map, pos + 1, -2, offset, 1, node->nvar, s);
+
+	return dim_map;
+}
+
+/* Construct an isl_dim_map for mapping constraints on coefficients
+ * for "src" (node i) and "dst" (node j) to the corresponding positions
+ * in graph->lp.
+ * "offset" is the offset of the coefficients for the variables of "src"
+ * in the input constraints.
+ * "s" is the sign of the mapping.
+ *
+ * The input constraints are given in terms of the coefficients
+ * (c_0, c_n, c_x, c_y).
+ * The mapping produced by this function essentially plugs in
+ * (c_j_0 - c_i_0, c_j_n - c_i_n,
+ *  -(c_i_x^+ - c_i_x^-), c_j_x^+ - c_j_x^-) if s = 1 and
+ * (-c_j_0 + c_i_0, -c_j_n + c_i_n,
+ *  c_i_x^+ - c_i_x^-, -(c_j_x^+ - c_j_x^-)) if s = -1.
+ * In graph->lp, the c_*^- appear before their c_*^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
+ *
+ * The caller can further extend the mapping.
+ */
+static __isl_give isl_dim_map *inter_dim_map(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_sched_node *src,
+	struct isl_sched_node *dst, int offset, int s)
+{
+	int pos;
+	isl_size total;
+	isl_dim_map *dim_map;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_all);
+	if (!src || !dst || total < 0)
+		return NULL;
+
+	dim_map = isl_dim_map_alloc(ctx, total);
+
+	pos = node_cst_coef_offset(dst);
+	isl_dim_map_range(dim_map, pos, 0, 0, 0, 1, s);
+	pos = node_par_coef_offset(dst);
+	isl_dim_map_range(dim_map, pos, 1, 1, 1, dst->nparam, s);
+	pos = node_var_coef_pos(dst, 0);
+	isl_dim_map_range(dim_map, pos, -2, offset + src->nvar, 1,
+			  dst->nvar, -s);
+	isl_dim_map_range(dim_map, pos + 1, -2, offset + src->nvar, 1,
+			  dst->nvar, s);
+
+	pos = node_cst_coef_offset(src);
+	isl_dim_map_range(dim_map, pos, 0, 0, 0, 1, -s);
+	pos = node_par_coef_offset(src);
+	isl_dim_map_range(dim_map, pos, 1, 1, 1, src->nparam, -s);
+	pos = node_var_coef_pos(src, 0);
+	isl_dim_map_range(dim_map, pos, -2, offset, 1, src->nvar, s);
+	isl_dim_map_range(dim_map, pos + 1, -2, offset, 1, src->nvar, -s);
+
+	return dim_map;
+}
+
+/* Add the constraints from "src" to "dst" using "dim_map",
+ * after making sure there is enough room in "dst" for the extra constraints.
+ */
+static __isl_give isl_basic_set *add_constraints_dim_map(
+	__isl_take isl_basic_set *dst, __isl_take isl_basic_set *src,
+	__isl_take isl_dim_map *dim_map)
+{
+	isl_size n_eq, n_ineq;
+
+	n_eq = isl_basic_set_n_equality(src);
+	n_ineq = isl_basic_set_n_inequality(src);
+	if (n_eq < 0 || n_ineq < 0)
+		dst = isl_basic_set_free(dst);
+	dst = isl_basic_set_extend_constraints(dst, n_eq, n_ineq);
+	dst = isl_basic_set_add_constraints_dim_map(dst, src, dim_map);
+	return dst;
+}
+
 /* Add constraints to graph->lp that force validity for the given
  * dependence from a node i to itself.
  * That is, add constraints that enforce
@@ -1388,53 +2099,35 @@
  *	= c_i_x (y - x) >= 0
  *
  * for each (x,y) in R.
- * We obtain general constraints on coefficients (c_0, c_n, c_x)
- * of valid constraints for (y - x) and then plug in (0, 0, c_i_x^+ - c_i_x^-),
+ * We obtain general constraints on coefficients (c_0, c_x)
+ * of valid constraints for (y - x) and then plug in (0, c_i_x^+ - c_i_x^-),
  * where c_i_x = c_i_x^+ - c_i_x^-, with c_i_x^+ and c_i_x^- non-negative.
  * In graph->lp, the c_i_x^- appear before their c_i_x^+ counterpart.
- *
- * Actually, we do not construct constraints for the c_i_x themselves,
- * but for the coefficients of c_i_x written as a linear combination
- * of the columns in node->cmap.
+ * Note that the result of intra_coefficients may also contain
+ * parameter coefficients c_n, in which case 0 is plugged in for them as well.
  */
-static int add_intra_validity_constraints(struct isl_sched_graph *graph,
+static isl_stat add_intra_validity_constraints(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge)
 {
-	unsigned total;
+	isl_size offset;
 	isl_map *map = isl_map_copy(edge->map);
 	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
 	isl_dim_map *dim_map;
 	isl_basic_set *coef;
 	struct isl_sched_node *node = edge->src;
 
-	coef = intra_coefficients(graph, node, map);
+	coef = intra_coefficients(graph, node, map, 0);
 
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
-
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set), isl_mat_copy(node->cmap));
+	offset = coef_var_offset(coef);
+	if (offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		goto error;
+		return isl_stat_error;
 
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, -1);
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, 1);
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
-	isl_space_free(dim);
+	dim_map = intra_dim_map(ctx, graph, node, offset, 1);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
-	return 0;
-error:
-	isl_space_free(dim);
-	return -1;
+	return isl_stat_ok;
 }
 
 /* Add constraints to graph->lp that force validity for the given
@@ -1446,76 +2139,43 @@
  * for each (x,y) in R.
  * We obtain general constraints on coefficients (c_0, c_n, c_x, c_y)
  * of valid constraints for R and then plug in
- * (c_j_0 - c_i_0, c_j_n^+ - c_j_n^- - (c_i_n^+ - c_i_n^-),
- *  c_j_x^+ - c_j_x^- - (c_i_x^+ - c_i_x^-)),
+ * (c_j_0 - c_i_0, c_j_n - c_i_n, -(c_i_x^+ - c_i_x^-), c_j_x^+ - c_j_x^-),
  * where c_* = c_*^+ - c_*^-, with c_*^+ and c_*^- non-negative.
  * In graph->lp, the c_*^- appear before their c_*^+ counterpart.
- *
- * Actually, we do not construct constraints for the c_*_x themselves,
- * but for the coefficients of c_*_x written as a linear combination
- * of the columns in node->cmap.
  */
-static int add_inter_validity_constraints(struct isl_sched_graph *graph,
+static isl_stat add_inter_validity_constraints(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge)
 {
-	unsigned total;
-	isl_map *map = isl_map_copy(edge->map);
-	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
+	isl_size offset;
+	isl_map *map;
+	isl_ctx *ctx;
 	isl_dim_map *dim_map;
 	isl_basic_set *coef;
 	struct isl_sched_node *src = edge->src;
 	struct isl_sched_node *dst = edge->dst;
 
-	coef = inter_coefficients(graph, edge, map);
+	if (!graph->lp)
+		return isl_stat_error;
 
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
+	map = isl_map_copy(edge->map);
+	ctx = isl_map_get_ctx(map);
+	coef = inter_coefficients(graph, edge, map);
 
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set), isl_mat_copy(src->cmap));
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set) + src->nvar,
-		    isl_mat_copy(dst->cmap));
+	offset = coef_var_offset(coef);
+	if (offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		goto error;
-
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
+		return isl_stat_error;
 
-	isl_dim_map_range(dim_map, dst->start, 0, 0, 0, 1, 1);
-	isl_dim_map_range(dim_map, dst->start + 1, 2, 1, 1, dst->nparam, -1);
-	isl_dim_map_range(dim_map, dst->start + 2, 2, 1, 1, dst->nparam, 1);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, -1);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, 1);
-
-	isl_dim_map_range(dim_map, src->start, 0, 0, 0, 1, -1);
-	isl_dim_map_range(dim_map, src->start + 1, 2, 1, 1, src->nparam, 1);
-	isl_dim_map_range(dim_map, src->start + 2, 2, 1, 1, src->nparam, -1);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, 1);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, -1);
+	dim_map = inter_dim_map(ctx, graph, src, dst, offset, 1);
 
 	edge->start = graph->lp->n_ineq;
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 	if (!graph->lp)
-		goto error;
-	isl_space_free(dim);
+		return isl_stat_error;
 	edge->end = graph->lp->n_ineq;
 
-	return 0;
-error:
-	isl_space_free(dim);
-	return -1;
+	return isl_stat_ok;
 }
 
 /* Add constraints to graph->lp that bound the dependence distance for the given
@@ -1543,10 +2203,6 @@
  * with each coefficient (except m_0) represented as a pair of non-negative
  * coefficients.
  *
- * Actually, we do not construct constraints for the c_i_x themselves,
- * but for the coefficients of c_i_x written as a linear combination
- * of the columns in node->cmap.
- *
  *
  * If "local" is set, then we add constraints
  *
@@ -1558,56 +2214,42 @@
  *
  * instead, forcing the dependence distance to be (less than or) equal to 0.
  * That is, we plug in (0, 0, -s * c_i_x),
+ * intra_coefficients is not required to have c_n in its result when
+ * "local" is set.  If they are missing, then (0, -s * c_i_x) is plugged in.
  * Note that dependences marked local are treated as validity constraints
  * by add_all_validity_constraints and therefore also have
  * their distances bounded by 0 from below.
  */
-static int add_intra_proximity_constraints(struct isl_sched_graph *graph,
+static isl_stat add_intra_proximity_constraints(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge, int s, int local)
 {
-	unsigned total;
-	unsigned nparam;
+	isl_size offset;
+	isl_size nparam;
 	isl_map *map = isl_map_copy(edge->map);
 	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
 	isl_dim_map *dim_map;
 	isl_basic_set *coef;
 	struct isl_sched_node *node = edge->src;
 
-	coef = intra_coefficients(graph, node, map);
-
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
+	coef = intra_coefficients(graph, node, map, !local);
+	nparam = isl_space_dim(node->space, isl_dim_param);
 
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set), isl_mat_copy(node->cmap));
+	offset = coef_var_offset(coef);
+	if (nparam < 0 || offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		goto error;
+		return isl_stat_error;
 
-	nparam = isl_space_dim(node->space, isl_dim_param);
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
+	dim_map = intra_dim_map(ctx, graph, node, offset, -s);
 
 	if (!local) {
 		isl_dim_map_range(dim_map, 1, 0, 0, 0, 1, 1);
 		isl_dim_map_range(dim_map, 4, 2, 1, 1, nparam, -1);
 		isl_dim_map_range(dim_map, 5, 2, 1, 1, nparam, 1);
 	}
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, s);
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, -s);
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
-	isl_space_free(dim);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
-	return 0;
-error:
-	isl_space_free(dim);
-	return -1;
+	return isl_stat_ok;
 }
 
 /* Add constraints to graph->lp that bound the dependence distance for the given
@@ -1637,58 +2279,48 @@
  * We obtain general constraints on coefficients (c_0, c_n, c_x, c_y)
  * of valid constraints for R and then plug in
  * (m_0 - s*c_j_0 + s*c_i_0, m_n - s*c_j_n + s*c_i_n,
- *  -s*c_j_x+s*c_i_x)
- * with each coefficient (except m_0, c_j_0 and c_i_0)
+ *  s*c_i_x, -s*c_j_x)
+ * with each coefficient (except m_0, c_*_0 and c_*_n)
  * represented as a pair of non-negative coefficients.
  *
- * Actually, we do not construct constraints for the c_*_x themselves,
- * but for the coefficients of c_*_x written as a linear combination
- * of the columns in node->cmap.
  *
- *
- * If "local" is set, then we add constraints
+ * If "local" is set (and s = 1), then we add constraints
  *
  *	(c_j_0 + c_j_n n + c_j_x y) - (c_i_0 + c_i_n n + c_i_x x) <= 0
  *
  * or
  *
- *	-((c_j_0 + c_j_n n + c_j_x y) - (c_i_0 + c_i_n n + c_i_x x)) <= 0
+ *	-((c_j_0 + c_j_n n + c_j_x y) + (c_i_0 + c_i_n n + c_i_x x)) >= 0
  *
  * instead, forcing the dependence distance to be (less than or) equal to 0.
  * That is, we plug in
- * (-s*c_j_0 + s*c_i_0, -s*c_j_n + s*c_i_n, -s*c_j_x+s*c_i_x).
+ * (-s*c_j_0 + s*c_i_0, -s*c_j_n + s*c_i_n, s*c_i_x, -s*c_j_x).
  * Note that dependences marked local are treated as validity constraints
  * by add_all_validity_constraints and therefore also have
  * their distances bounded by 0 from below.
  */
-static int add_inter_proximity_constraints(struct isl_sched_graph *graph,
+static isl_stat add_inter_proximity_constraints(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge, int s, int local)
 {
-	unsigned total;
-	unsigned nparam;
+	isl_size offset;
+	isl_size nparam;
 	isl_map *map = isl_map_copy(edge->map);
 	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
 	isl_dim_map *dim_map;
 	isl_basic_set *coef;
 	struct isl_sched_node *src = edge->src;
 	struct isl_sched_node *dst = edge->dst;
 
 	coef = inter_coefficients(graph, edge, map);
+	nparam = isl_space_dim(src->space, isl_dim_param);
 
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
-
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set), isl_mat_copy(src->cmap));
-	coef = isl_basic_set_transform_dims(coef, isl_dim_set,
-		    isl_space_dim(dim, isl_dim_set) + src->nvar,
-		    isl_mat_copy(dst->cmap));
+	offset = coef_var_offset(coef);
+	if (nparam < 0 || offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		goto error;
+		return isl_stat_error;
 
-	nparam = isl_space_dim(src->space, isl_dim_param);
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
+	dim_map = inter_dim_map(ctx, graph, src, dst, offset, -s);
 
 	if (!local) {
 		isl_dim_map_range(dim_map, 1, 0, 0, 0, 1, 1);
@@ -1696,36 +2328,19 @@
 		isl_dim_map_range(dim_map, 5, 2, 1, 1, nparam, 1);
 	}
 
-	isl_dim_map_range(dim_map, dst->start, 0, 0, 0, 1, -s);
-	isl_dim_map_range(dim_map, dst->start + 1, 2, 1, 1, dst->nparam, s);
-	isl_dim_map_range(dim_map, dst->start + 2, 2, 1, 1, dst->nparam, -s);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, s);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, -s);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
-	isl_dim_map_range(dim_map, src->start, 0, 0, 0, 1, s);
-	isl_dim_map_range(dim_map, src->start + 1, 2, 1, 1, src->nparam, -s);
-	isl_dim_map_range(dim_map, src->start + 2, 2, 1, 1, src->nparam, s);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, -s);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, s);
-
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
-	isl_space_free(dim);
+	return isl_stat_ok;
+}
 
-	return 0;
-error:
-	isl_space_free(dim);
-	return -1;
+/* Should the distance over "edge" be forced to zero?
+ * That is, is it marked as a local edge?
+ * If "use_coincidence" is set, then coincidence edges are treated
+ * as local edges.
+ */
+static int force_zero(struct isl_sched_edge *edge, int use_coincidence)
+{
+	return is_local(edge) || (use_coincidence && is_coincidence(edge));
 }
 
 /* Add all validity constraints to graph->lp.
@@ -1744,11 +2359,11 @@
 	int i;
 
 	for (i = 0; i < graph->n_edge; ++i) {
-		struct isl_sched_edge *edge= &graph->edgei;
-		int local;
+		struct isl_sched_edge *edge = &graph->edgei;
+		int zero;
 
-		local = edge->local || (edge->coincidence && use_coincidence);
-		if (!edge->validity && !local)
+		zero = force_zero(edge, use_coincidence);
+		if (!is_validity(edge) && !zero)
 			continue;
 		if (edge->src != edge->dst)
 			continue;
@@ -1758,10 +2373,10 @@
 
 	for (i = 0; i < graph->n_edge; ++i) {
 		struct isl_sched_edge *edge = &graph->edgei;
-		int local;
+		int zero;
 
-		local = edge->local || (edge->coincidence && use_coincidence);
-		if (!edge->validity && !local)
+		zero = force_zero(edge, use_coincidence);
+		if (!is_validity(edge) && !zero)
 			continue;
 		if (edge->src == edge->dst)
 			continue;
@@ -1790,19 +2405,19 @@
 	int i;
 
 	for (i = 0; i < graph->n_edge; ++i) {
-		struct isl_sched_edge *edge= &graph->edgei;
-		int local;
+		struct isl_sched_edge *edge = &graph->edgei;
+		int zero;
 
-		local = edge->local || (edge->coincidence && use_coincidence);
-		if (!edge->proximity && !local)
+		zero = force_zero(edge, use_coincidence);
+		if (!is_proximity(edge) && !zero)
 			continue;
 		if (edge->src == edge->dst &&
-		    add_intra_proximity_constraints(graph, edge, 1, local) < 0)
+		    add_intra_proximity_constraints(graph, edge, 1, zero) < 0)
 			return -1;
 		if (edge->src != edge->dst &&
-		    add_inter_proximity_constraints(graph, edge, 1, local) < 0)
+		    add_inter_proximity_constraints(graph, edge, 1, zero) < 0)
 			return -1;
-		if (edge->validity || local)
+		if (is_validity(edge) || zero)
 			continue;
 		if (edge->src == edge->dst &&
 		    add_intra_proximity_constraints(graph, edge, -1, 0) < 0)
@@ -1815,6 +2430,30 @@
 	return 0;
 }
 
+/* Normalize the rows of "indep" such that all rows are lexicographically
+ * positive and such that each row contains as many final zeros as possible,
+ * given the choice for the previous rows.
+ * Do this by performing elementary row operations.
+ */
+static __isl_give isl_mat *normalize_independent(__isl_take isl_mat *indep)
+{
+	indep = isl_mat_reverse_gauss(indep);
+	indep = isl_mat_lexnonneg_rows(indep);
+	return indep;
+}
+
+/* Extract the linear part of the current schedule for node "node".
+ */
+static __isl_give isl_mat *extract_linear_schedule(struct isl_sched_node *node)
+{
+	isl_size n_row = isl_mat_rows(node->sched);
+
+	if (n_row < 0)
+		return NULL;
+	return isl_mat_sub_alloc(node->sched, 0, n_row,
+			      1 + node->nparam, node->nvar);
+}
+
 /* Compute a basis for the rows in the linear part of the schedule
  * and extend this basis to a full basis.  The remaining rows
  * can then be used to force linear independence from the rows
@@ -1828,41 +2467,52 @@
  * with H the Hermite normal form of S.  That is, all but the
  * first rank columns of H are zero and so each row in S is
  * a linear combination of the first rank rows of Q.
- * The matrix Q is then transposed because we will write the
- * coefficients of the next schedule row as a column vector s
- * and express this s as a linear combination s = Q c of the
- * computed basis.
- * Similarly, the matrix U is transposed such that we can
- * compute the coefficients c = U s from a schedule row s.
+ * The matrix Q can be used as a variable transformation
+ * that isolates the directions of S in the first rank rows.
+ * Transposing S U = H yields
+ *
+ *	U^T S^T = H^T
+ *
+ * with all but the first rank rows of H^T zero.
+ * The last rows of U^T are therefore linear combinations
+ * of schedule coefficients that are all zero on schedule
+ * coefficients that are linearly dependent on the rows of S.
+ * At least one of these combinations is non-zero on
+ * linearly independent schedule coefficients.
+ * The rows are normalized to involve as few of the last
+ * coefficients as possible and to have a positive initial value.
  */
-static int node_update_cmap(struct isl_sched_node *node)
+static int node_update_vmap(struct isl_sched_node *node)
 {
 	isl_mat *H, *U, *Q;
-	int n_row = isl_mat_rows(node->sched);
 
-	H = isl_mat_sub_alloc(node->sched, 0, n_row,
-			      1 + node->nparam, node->nvar);
+	H = extract_linear_schedule(node);
 
 	H = isl_mat_left_hermite(H, 0, &U, &Q);
-	isl_mat_free(node->cmap);
-	isl_mat_free(node->cinv);
-	node->cmap = isl_mat_transpose(Q);
-	node->cinv = isl_mat_transpose(U);
+	isl_mat_free(node->indep);
+	isl_mat_free(node->vmap);
+	node->vmap = Q;
+	node->indep = isl_mat_transpose(U);
 	node->rank = isl_mat_initial_non_zero_cols(H);
+	node->indep = isl_mat_drop_rows(node->indep, 0, node->rank);
+	node->indep = normalize_independent(node->indep);
 	isl_mat_free(H);
 
-	if (!node->cmap || !node->cinv || node->rank < 0)
+	if (!node->indep || !node->vmap || node->rank < 0)
 		return -1;
 	return 0;
 }
 
+/* Is "edge" marked as a validity or a conditional validity edge?
+ */
+static int is_any_validity(struct isl_sched_edge *edge)
+{
+	return is_validity(edge) || is_conditional_validity(edge);
+}
+
 /* How many times should we count the constraints in "edge"?
  *
- * If carry is set, then we are counting the number of
- * (validity or conditional validity) constraints that will be added
- * in setup_carry_lp and we count each edge exactly once.
- *
- * Otherwise, we count as follows
+ * We count as follows
  * validity		-> 1 (>= 0)
  * validity+proximity	-> 2 (>= 0 and upper bound)
  * proximity		-> 2 (lower and upper bound)
@@ -1874,50 +2524,105 @@
  * If "use_coincidence" is set, then we treat coincidence edges as local edges.
  * Otherwise, we ignore them.
  */
-static int edge_multiplicity(struct isl_sched_edge *edge, int carry,
+static int edge_multiplicity(struct isl_sched_edge *edge, int use_coincidence)
+{
+	if (is_proximity(edge) || force_zero(edge, use_coincidence))
+		return 2;
+	if (is_validity(edge))
+		return 1;
+	return 0;
+}
+
+/* How many times should the constraints in "edge" be counted
+ * as a parametric intra-node constraint?
+ *
+ * Only proximity edges that are not forced zero need
+ * coefficient constraints that include coefficients for parameters.
+ * If the edge is also a validity edge, then only
+ * an upper bound is introduced.  Otherwise, both lower and upper bounds
+ * are introduced.
+ */
+static int parametric_intra_edge_multiplicity(struct isl_sched_edge *edge,
 	int use_coincidence)
 {
-	if (carry && !edge->validity && !edge->conditional_validity)
+	if (edge->src != edge->dst)
+		return 0;
+	if (!is_proximity(edge))
 		return 0;
-	if (carry)
+	if (force_zero(edge, use_coincidence))
+		return 0;
+	if (is_validity(edge))
 		return 1;
-	if (edge->proximity || edge->local)
-		return 2;
-	if (use_coincidence && edge->coincidence)
+	else
 		return 2;
-	if (edge->validity)
-		return 1;
-	return 0;
+}
+
+/* Add "f" times the number of equality and inequality constraints of "bset"
+ * to "n_eq" and "n_ineq" and free "bset".
+ */
+static isl_stat update_count(__isl_take isl_basic_set *bset,
+	int f, int *n_eq, int *n_ineq)
+{
+	isl_size eq, ineq;
+
+	eq = isl_basic_set_n_equality(bset);
+	ineq = isl_basic_set_n_inequality(bset);
+	isl_basic_set_free(bset);
+
+	if (eq < 0 || ineq < 0)
+		return isl_stat_error;
+
+	*n_eq += eq;
+	*n_ineq += ineq;
+
+	return isl_stat_ok;
 }
 
 /* Count the number of equality and inequality constraints
  * that will be added for the given map.
  *
+ * The edges that require parameter coefficients are counted separately.
+ *
  * "use_coincidence" is set if we should take into account coincidence edges.
  */
-static int count_map_constraints(struct isl_sched_graph *graph,
+static isl_stat count_map_constraints(struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge, __isl_take isl_map *map,
-	int *n_eq, int *n_ineq, int carry, int use_coincidence)
+	int *n_eq, int *n_ineq, int use_coincidence)
 {
+	isl_map *copy;
 	isl_basic_set *coef;
-	int f = edge_multiplicity(edge, carry, use_coincidence);
+	int f = edge_multiplicity(edge, use_coincidence);
+	int fp = parametric_intra_edge_multiplicity(edge, use_coincidence);
 
 	if (f == 0) {
 		isl_map_free(map);
-		return 0;
+		return isl_stat_ok;
 	}
 
-	if (edge->src == edge->dst)
-		coef = intra_coefficients(graph, edge->src, map);
-	else
+	if (edge->src != edge->dst) {
 		coef = inter_coefficients(graph, edge, map);
-	if (!coef)
-		return -1;
-	*n_eq += f * coef->n_eq;
-	*n_ineq += f * coef->n_ineq;
-	isl_basic_set_free(coef);
+		return update_count(coef, f, n_eq, n_ineq);
+	}
 
-	return 0;
+	if (fp > 0) {
+		copy = isl_map_copy(map);
+		coef = intra_coefficients(graph, edge->src, copy, 1);
+		if (update_count(coef, fp, n_eq, n_ineq) < 0)
+			goto error;
+	}
+
+	if (f > fp) {
+		copy = isl_map_copy(map);
+		coef = intra_coefficients(graph, edge->src, copy, 0);
+		if (update_count(coef, f - fp, n_eq, n_ineq) < 0)
+			goto error;
+	}
+
+	isl_map_free(map);
+	return isl_stat_ok;
+error:
+	isl_map_free(map);
+	return isl_stat_error;
 }
 
 /* Count the number of equality and inequality constraints
@@ -1938,11 +2643,11 @@
 
 	*n_eq = *n_ineq = 0;
 	for (i = 0; i < graph->n_edge; ++i) {
-		struct isl_sched_edge *edge= &graph->edgei;
+		struct isl_sched_edge *edge = &graph->edgei;
 		isl_map *map = isl_map_copy(edge->map);
 
 		if (count_map_constraints(graph, edge, map, n_eq, n_ineq,
-					    0, use_coincidence) < 0)
+					    use_coincidence) < 0)
 			return -1;
 	}
 
@@ -1950,6 +2655,60 @@
 }
 
 /* Count the number of constraints that will be added by
+ * add_bound_constant_constraints to bound the values of the constant terms
+ * and increment *n_eq and *n_ineq accordingly.
+ *
+ * In practice, add_bound_constant_constraints only adds inequalities.
+ */
+static isl_stat count_bound_constant_constraints(isl_ctx *ctx,
+	struct isl_sched_graph *graph, int *n_eq, int *n_ineq)
+{
+	if (isl_options_get_schedule_max_constant_term(ctx) == -1)
+		return isl_stat_ok;
+
+	*n_ineq += graph->n;
+
+	return isl_stat_ok;
+}
+
+/* Add constraints to bound the values of the constant terms in the schedule,
+ * if requested by the user.
+ *
+ * The maximal value of the constant terms is defined by the option
+ * "schedule_max_constant_term".
+ */
+static isl_stat add_bound_constant_constraints(isl_ctx *ctx,
+	struct isl_sched_graph *graph)
+{
+	int i, k;
+	int max;
+	isl_size total;
+
+	max = isl_options_get_schedule_max_constant_term(ctx);
+	if (max == -1)
+		return isl_stat_ok;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
+
+	for (i = 0; i < graph->n; ++i) {
+		struct isl_sched_node *node = &graph->nodei;
+		int pos;
+
+		k = isl_basic_set_alloc_inequality(graph->lp);
+		if (k < 0)
+			return isl_stat_error;
+		isl_seq_clr(graph->lp->ineqk, 1 + total);
+		pos = node_cst_coef_offset(node);
+		isl_int_set_si(graph->lp->ineqk1 + pos, -1);
+		isl_int_set_si(graph->lp->ineqk0, max);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Count the number of constraints that will be added by
  * add_bound_coefficient_constraints and increment *n_eq and *n_ineq
  * accordingly.
  *
@@ -1960,50 +2719,215 @@
 {
 	int i;
 
-	if (ctx->opt->schedule_max_coefficient == -1)
+	if (isl_options_get_schedule_max_coefficient(ctx) == -1 &&
+	    !isl_options_get_schedule_treat_coalescing(ctx))
 		return 0;
 
 	for (i = 0; i < graph->n; ++i)
-		*n_ineq += 2 * graph->nodei.nparam + 2 * graph->nodei.nvar;
+		*n_ineq += graph->nodei.nparam + 2 * graph->nodei.nvar;
 
 	return 0;
 }
 
+/* Add constraints to graph->lp that bound the values of
+ * the parameter schedule coefficients of "node" to "max" and
+ * the variable schedule coefficients to the corresponding entry
+ * in node->max.
+ * In either case, a negative value means that no bound needs to be imposed.
+ *
+ * For parameter coefficients, this amounts to adding a constraint
+ *
+ *	c_n <= max
+ *
+ * i.e.,
+ *
+ *	-c_n + max >= 0
+ *
+ * The variables coefficients are, however, not represented directly.
+ * Instead, the variable coefficients c_x are written as differences
+ * c_x = c_x^+ - c_x^-.
+ * That is,
+ *
+ *	-max_i <= c_x_i <= max_i
+ *
+ * is encoded as
+ *
+ *	-max_i <= c_x_i^+ - c_x_i^- <= max_i
+ *
+ * or
+ *
+ *	-(c_x_i^+ - c_x_i^-) + max_i >= 0
+ *	c_x_i^+ - c_x_i^- + max_i >= 0
+ */
+static isl_stat node_add_coefficient_constraints(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_sched_node *node, int max)
+{
+	int i, j, k;
+	isl_size total;
+	isl_vec *ineq;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
+
+	for (j = 0; j < node->nparam; ++j) {
+		int dim;
+
+		if (max < 0)
+			continue;
+
+		k = isl_basic_set_alloc_inequality(graph->lp);
+		if (k < 0)
+			return isl_stat_error;
+		dim = 1 + node_par_coef_offset(node) + j;
+		isl_seq_clr(graph->lp->ineqk, 1 + total);
+		isl_int_set_si(graph->lp->ineqkdim, -1);
+		isl_int_set_si(graph->lp->ineqk0, max);
+	}
+
+	ineq = isl_vec_alloc(ctx, 1 + total);
+	ineq = isl_vec_clr(ineq);
+	if (!ineq)
+		return isl_stat_error;
+	for (i = 0; i < node->nvar; ++i) {
+		int pos = 1 + node_var_coef_pos(node, i);
+
+		if (isl_int_is_neg(node->max->eli))
+			continue;
+
+		isl_int_set_si(ineq->elpos, 1);
+		isl_int_set_si(ineq->elpos + 1, -1);
+		isl_int_set(ineq->el0, node->max->eli);
+
+		k = isl_basic_set_alloc_inequality(graph->lp);
+		if (k < 0)
+			goto error;
+		isl_seq_cpy(graph->lp->ineqk, ineq->el, 1 + total);
+
+		isl_seq_neg(ineq->el + pos, ineq->el + pos, 2);
+		k = isl_basic_set_alloc_inequality(graph->lp);
+		if (k < 0)
+			goto error;
+		isl_seq_cpy(graph->lp->ineqk, ineq->el, 1 + total);
+
+		isl_seq_clr(ineq->el + pos, 2);
+	}
+	isl_vec_free(ineq);
+
+	return isl_stat_ok;
+error:
+	isl_vec_free(ineq);
+	return isl_stat_error;
+}
+
 /* Add constraints that bound the values of the variable and parameter
  * coefficients of the schedule.
  *
  * The maximal value of the coefficients is defined by the option
- * 'schedule_max_coefficient'.
+ * 'schedule_max_coefficient' and the entries in node->max.
+ * These latter entries are only set if either the schedule_max_coefficient
+ * option or the schedule_treat_coalescing option is set.
  */
-static int add_bound_coefficient_constraints(isl_ctx *ctx,
+static isl_stat add_bound_coefficient_constraints(isl_ctx *ctx,
 	struct isl_sched_graph *graph)
 {
+	int i;
+	int max;
+
+	max = isl_options_get_schedule_max_coefficient(ctx);
+
+	if (max == -1 && !isl_options_get_schedule_treat_coalescing(ctx))
+		return isl_stat_ok;
+
+	for (i = 0; i < graph->n; ++i) {
+		struct isl_sched_node *node = &graph->nodei;
+
+		if (node_add_coefficient_constraints(ctx, graph, node, max) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Add a constraint to graph->lp that equates the value at position
+ * "sum_pos" to the sum of the "n" values starting at "first".
+ */
+static isl_stat add_sum_constraint(struct isl_sched_graph *graph,
+	int sum_pos, int first, int n)
+{
+	int i, k;
+	isl_size total;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
+
+	k = isl_basic_set_alloc_equality(graph->lp);
+	if (k < 0)
+		return isl_stat_error;
+	isl_seq_clr(graph->lp->eqk, 1 + total);
+	isl_int_set_si(graph->lp->eqk1 + sum_pos, -1);
+	for (i = 0; i < n; ++i)
+		isl_int_set_si(graph->lp->eqk1 + first + i, 1);
+
+	return isl_stat_ok;
+}
+
+/* Add a constraint to graph->lp that equates the value at position
+ * "sum_pos" to the sum of the parameter coefficients of all nodes.
+ */
+static isl_stat add_param_sum_constraint(struct isl_sched_graph *graph,
+	int sum_pos)
+{
 	int i, j, k;
-	int max_coefficient;
-	int total;
+	isl_size total;
 
-	max_coefficient = ctx->opt->schedule_max_coefficient;
+	total = isl_basic_set_dim(graph->lp, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
 
-	if (max_coefficient == -1)
-		return 0;
+	k = isl_basic_set_alloc_equality(graph->lp);
+	if (k < 0)
+		return isl_stat_error;
+	isl_seq_clr(graph->lp->eqk, 1 + total);
+	isl_int_set_si(graph->lp->eqk1 + sum_pos, -1);
+	for (i = 0; i < graph->n; ++i) {
+		int pos = 1 + node_par_coef_offset(&graph->nodei);
+
+		for (j = 0; j < graph->nodei.nparam; ++j)
+			isl_int_set_si(graph->lp->eqkpos + j, 1);
+	}
 
-	total = isl_basic_set_total_dim(graph->lp);
+	return isl_stat_ok;
+}
 
+/* Add a constraint to graph->lp that equates the value at position
+ * "sum_pos" to the sum of the variable coefficients of all nodes.
+ */
+static isl_stat add_var_sum_constraint(struct isl_sched_graph *graph,
+	int sum_pos)
+{
+	int i, j, k;
+	isl_size total;
+
+	total = isl_basic_set_dim(graph->lp, isl_dim_set);
+	if (total < 0)
+		return isl_stat_error;
+
+	k = isl_basic_set_alloc_equality(graph->lp);
+	if (k < 0)
+		return isl_stat_error;
+	isl_seq_clr(graph->lp->eqk, 1 + total);
+	isl_int_set_si(graph->lp->eqk1 + sum_pos, -1);
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
-		for (j = 0; j < 2 * node->nparam + 2 * node->nvar; ++j) {
-			int dim;
-			k = isl_basic_set_alloc_inequality(graph->lp);
-			if (k < 0)
-				return -1;
-			dim = 1 + node->start + 1 + j;
-			isl_seq_clr(graph->lp->ineqk, 1 +  total);
-			isl_int_set_si(graph->lp->ineqkdim, -1);
-			isl_int_set_si(graph->lp->ineqk0, max_coefficient);
-		}
+		int pos = 1 + node_var_coef_offset(node);
+
+		for (j = 0; j < 2 * node->nvar; ++j)
+			isl_int_set_si(graph->lp->eqkpos + j, 1);
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Construct an ILP problem for finding schedule coefficients
@@ -2021,18 +2945,14 @@
  *
  *	- sum of positive and negative parts of m_n coefficients
  *	- m_0
- *	- sum of positive and negative parts of all c_n coefficients
+ *	- sum of all c_n coefficients
  *		(unconstrained when computing non-parametric schedules)
  *	- sum of positive and negative parts of all c_x coefficients
  *	- positive and negative parts of m_n coefficients
  *	- for each node
+ *		- positive and negative parts of c_i_x, in opposite order
+ *		- c_i_n (if parametric)
  *		- c_i_0
- *		- positive and negative parts of c_i_n (if parametric)
- *		- positive and negative parts of c_i_x
- *
- * The c_i_x are not represented directly, but through the columns of
- * node->cmap.  That is, the computed values are for variable t_i_x
- * such that c_i_x = Q t_i_x with Q equal to node->cmap.
  *
  * The constraints are those from the edges plus two or three equalities
  * to express the sums.
@@ -2040,100 +2960,60 @@
  * If "use_coincidence" is set, then we treat coincidence edges as local edges.
  * Otherwise, we ignore them.
  */
-static int setup_lp(isl_ctx *ctx, struct isl_sched_graph *graph,
+static isl_stat setup_lp(isl_ctx *ctx, struct isl_sched_graph *graph,
 	int use_coincidence)
 {
-	int i, j;
-	int k;
-	unsigned nparam;
+	int i;
+	isl_size nparam;
 	unsigned total;
-	isl_space *dim;
+	isl_space *space;
 	int parametric;
 	int param_pos;
 	int n_eq, n_ineq;
-	int max_constant_term;
-
-	max_constant_term = ctx->opt->schedule_max_constant_term;
 
 	parametric = ctx->opt->schedule_parametric;
 	nparam = isl_space_dim(graph->node0.space, isl_dim_param);
+	if (nparam < 0)
+		return isl_stat_error;
 	param_pos = 4;
 	total = param_pos + 2 * nparam;
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodegraph->sortedi;
-		if (node_update_cmap(node) < 0)
-			return -1;
+		if (node_update_vmap(node) < 0)
+			return isl_stat_error;
 		node->start = total;
-		total += 1 + 2 * (node->nparam + node->nvar);
+		total += 1 + node->nparam + 2 * node->nvar;
 	}
 
 	if (count_constraints(graph, &n_eq, &n_ineq, use_coincidence) < 0)
-		return -1;
+		return isl_stat_error;
+	if (count_bound_constant_constraints(ctx, graph, &n_eq, &n_ineq) < 0)
+		return isl_stat_error;
 	if (count_bound_coefficient_constraints(ctx, graph, &n_eq, &n_ineq) < 0)
-		return -1;
+		return isl_stat_error;
 
-	dim = isl_space_set_alloc(ctx, 0, total);
+	space = isl_space_set_alloc(ctx, 0, total);
 	isl_basic_set_free(graph->lp);
 	n_eq += 2 + parametric;
-	if (max_constant_term != -1)
-		n_ineq += graph->n;
-
-	graph->lp = isl_basic_set_alloc_space(dim, 0, n_eq, n_ineq);
-
-	k = isl_basic_set_alloc_equality(graph->lp);
-	if (k < 0)
-		return -1;
-	isl_seq_clr(graph->lp->eqk, 1 +  total);
-	isl_int_set_si(graph->lp->eqk1, -1);
-	for (i = 0; i < 2 * nparam; ++i)
-		isl_int_set_si(graph->lp->eqk1 + param_pos + i, 1);
-
-	if (parametric) {
-		k = isl_basic_set_alloc_equality(graph->lp);
-		if (k < 0)
-			return -1;
-		isl_seq_clr(graph->lp->eqk, 1 +  total);
-		isl_int_set_si(graph->lp->eqk3, -1);
-		for (i = 0; i < graph->n; ++i) {
-			int pos = 1 + graph->nodei.start + 1;
-
-			for (j = 0; j < 2 * graph->nodei.nparam; ++j)
-				isl_int_set_si(graph->lp->eqkpos + j, 1);
-		}
-	}
-
-	k = isl_basic_set_alloc_equality(graph->lp);
-	if (k < 0)
-		return -1;
-	isl_seq_clr(graph->lp->eqk, 1 +  total);
-	isl_int_set_si(graph->lp->eqk4, -1);
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		int pos = 1 + node->start + 1 + 2 * node->nparam;
-
-		for (j = 0; j < 2 * node->nvar; ++j)
-			isl_int_set_si(graph->lp->eqkpos + j, 1);
-	}
 
-	if (max_constant_term != -1)
-		for (i = 0; i < graph->n; ++i) {
-			struct isl_sched_node *node = &graph->nodei;
-			k = isl_basic_set_alloc_inequality(graph->lp);
-			if (k < 0)
-				return -1;
-			isl_seq_clr(graph->lp->ineqk, 1 +  total);
-			isl_int_set_si(graph->lp->ineqk1 + node->start, -1);
-			isl_int_set_si(graph->lp->ineqk0, max_constant_term);
-		}
+	graph->lp = isl_basic_set_alloc_space(space, 0, n_eq, n_ineq);
 
+	if (add_sum_constraint(graph, 0, param_pos, 2 * nparam) < 0)
+		return isl_stat_error;
+	if (parametric && add_param_sum_constraint(graph, 2) < 0)
+		return isl_stat_error;
+	if (add_var_sum_constraint(graph, 3) < 0)
+		return isl_stat_error;
+	if (add_bound_constant_constraints(ctx, graph) < 0)
+		return isl_stat_error;
 	if (add_bound_coefficient_constraints(ctx, graph) < 0)
-		return -1;
+		return isl_stat_error;
 	if (add_all_validity_constraints(graph, use_coincidence) < 0)
-		return -1;
+		return isl_stat_error;
 	if (add_all_proximity_constraints(graph, use_coincidence) < 0)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Analyze the conflicting constraint found by
@@ -2156,7 +3036,7 @@
 		return 0;
 
 	for (i = 0; i < graph->n_edge; ++i) {
-		if (!graph->edgei.validity)
+		if (!is_validity(&graph->edgei))
 			continue;
 		if (graph->edgei.src == graph->edgei.dst)
 			continue;
@@ -2184,19 +3064,50 @@
 	return node->nvar - node->rank >= graph->maxvar - graph->n_row;
 }
 
+/* Construct a non-triviality region with triviality directions
+ * corresponding to the rows of "indep".
+ * The rows of "indep" are expressed in terms of the schedule coefficients c_i,
+ * while the triviality directions are expressed in terms of
+ * pairs of non-negative variables c^+_i - c^-_i, with c^-_i appearing
+ * before c^+_i.  Furthermore,
+ * the pairs of non-negative variables representing the coefficients
+ * are stored in the opposite order.
+ */
+static __isl_give isl_mat *construct_trivial(__isl_keep isl_mat *indep)
+{
+	isl_ctx *ctx;
+	isl_mat *mat;
+	int i, j;
+	isl_size n, n_var;
+
+	n = isl_mat_rows(indep);
+	n_var = isl_mat_cols(indep);
+	if (n < 0 || n_var < 0)
+		return NULL;
+
+	ctx = isl_mat_get_ctx(indep);
+	mat = isl_mat_alloc(ctx, n, 2 * n_var);
+	if (!mat)
+		return NULL;
+	for (i = 0; i < n; ++i) {
+		for (j = 0; j < n_var; ++j) {
+			int nj = n_var - 1 - j;
+			isl_int_neg(mat->rowi2 * nj, indep->rowij);
+			isl_int_set(mat->rowi2 * nj + 1, indep->rowij);
+		}
+	}
+
+	return mat;
+}
+
 /* Solve the ILP problem constructed in setup_lp.
  * For each node such that all the remaining rows of its schedule
  * need to be non-trivial, we construct a non-triviality region.
  * This region imposes that the next row is independent of previous rows.
- * In particular the coefficients c_i_x are represented by t_i_x
- * variables with c_i_x = Q t_i_x and Q a unimodular matrix such that
- * its first columns span the rows of the previously computed part
- * of the schedule.  The non-triviality region enforces that at least
- * one of the remaining components of t_i_x is non-zero, i.e.,
- * that the new schedule row depends on at least one of the remaining
- * columns of Q.
+ * In particular, the non-triviality region enforces that at least
+ * one of the linear combinations in the rows of node->indep is non-zero.
  */
-static __isl_give isl_vec *solve_lp(struct isl_sched_graph *graph)
+static __isl_give isl_vec *solve_lp(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
 	int i;
 	isl_vec *sol;
@@ -2204,35 +3115,66 @@
 
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
-		int skip = node->rank;
-		graph->regioni.pos = node->start + 1 + 2*(node->nparam+skip);
+		isl_mat *trivial;
+
+		graph->regioni.pos = node_var_coef_offset(node);
 		if (needs_row(graph, node))
-			graph->regioni.len = 2 * (node->nvar - skip);
+			trivial = construct_trivial(node->indep);
 		else
-			graph->regioni.len = 0;
+			trivial = isl_mat_zero(ctx, 0, 0);
+		graph->regioni.trivial = trivial;
 	}
 	lp = isl_basic_set_copy(graph->lp);
 	sol = isl_tab_basic_set_non_trivial_lexmin(lp, 2, graph->n,
 				       graph->region, &check_conflict, graph);
+	for (i = 0; i < graph->n; ++i)
+		isl_mat_free(graph->regioni.trivial);
 	return sol;
 }
 
+/* Extract the coefficients for the variables of "node" from "sol".
+ *
+ * Each schedule coefficient c_i_x is represented as the difference
+ * between two non-negative variables c_i_x^+ - c_i_x^-.
+ * The c_i_x^- appear before their c_i_x^+ counterpart.
+ * Furthermore, the order of these pairs is the opposite of that
+ * of the corresponding coefficients.
+ *
+ * Return c_i_x = c_i_x^+ - c_i_x^-
+ */
+static __isl_give isl_vec *extract_var_coef(struct isl_sched_node *node,
+	__isl_keep isl_vec *sol)
+{
+	int i;
+	int pos;
+	isl_vec *csol;
+
+	if (!sol)
+		return NULL;
+	csol = isl_vec_alloc(isl_vec_get_ctx(sol), node->nvar);
+	if (!csol)
+		return NULL;
+
+	pos = 1 + node_var_coef_offset(node);
+	for (i = 0; i < node->nvar; ++i)
+		isl_int_sub(csol->elnode->nvar - 1 - i,
+			    sol->elpos + 2 * i + 1, sol->elpos + 2 * i);
+
+	return csol;
+}
+
 /* Update the schedules of all nodes based on the given solution
  * of the LP problem.
  * The new row is added to the current band.
  * All possibly negative coefficients are encoded as a difference
  * of two non-negative variables, so we need to perform the subtraction
- * here.  Moreover, if use_cmap is set, then the solution does
- * not refer to the actual coefficients c_i_x, but instead to variables
- * t_i_x such that c_i_x = Q t_i_x and Q is equal to node->cmap.
- * In this case, we then also need to perform this multiplication
- * to obtain the values of c_i_x.
+ * here.
  *
  * If coincident is set, then the caller guarantees that the new
  * row satisfies the coincidence constraints.
  */
 static int update_schedule(struct isl_sched_graph *graph,
-	__isl_take isl_vec *sol, int use_cmap, int coincident)
+	__isl_take isl_vec *sol, int coincident)
 {
 	int i, j;
 	isl_vec *csol = NULL;
@@ -2248,12 +3190,12 @@
 
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
-		int pos = node->start;
-		int row = isl_mat_rows(node->sched);
+		int pos;
+		isl_size row = isl_mat_rows(node->sched);
 
 		isl_vec_free(csol);
-		csol = isl_vec_alloc(sol->ctx, node->nvar);
-		if (!csol)
+		csol = extract_var_coef(node, sol);
+		if (row < 0 || !csol)
 			goto error;
 
 		isl_map_free(node->sched_map);
@@ -2261,27 +3203,16 @@
 		node->sched = isl_mat_add_rows(node->sched, 1);
 		if (!node->sched)
 			goto error;
-		node->sched = isl_mat_set_element(node->sched, row, 0,
-						  sol->el1 + pos);
-		for (j = 0; j < node->nparam + node->nvar; ++j)
-			isl_int_sub(sol->el1 + pos + 1 + 2 * j + 1,
-				    sol->el1 + pos + 1 + 2 * j + 1,
-				    sol->el1 + pos + 1 + 2 * j);
+		pos = node_cst_coef_offset(node);
+		node->sched = isl_mat_set_element(node->sched,
+					row, 0, sol->el1 + pos);
+		pos = node_par_coef_offset(node);
 		for (j = 0; j < node->nparam; ++j)
 			node->sched = isl_mat_set_element(node->sched,
-					row, 1 + j, sol->el1+pos+1+2*j+1);
-		for (j = 0; j < node->nvar; ++j)
-			isl_int_set(csol->elj,
-				    sol->el1+pos+1+2*(node->nparam+j)+1);
-		if (use_cmap)
-			csol = isl_mat_vec_product(isl_mat_copy(node->cmap),
-						   csol);
-		if (!csol)
-			goto error;
+					row, 1 + j, sol->el1 + pos + j);
 		for (j = 0; j < node->nvar; ++j)
 			node->sched = isl_mat_set_element(node->sched,
 					row, 1 + node->nparam + j, csol->elj);
-		node->bandgraph->n_total_row = graph->n_band;
 		node->coincidentgraph->n_total_row = coincident;
 	}
 	isl_vec_free(sol);
@@ -2310,50 +3241,62 @@
 	isl_int_init(v);
 
 	aff = isl_aff_zero_on_domain(ls);
-	isl_mat_get_element(node->sched, row, 0, &v);
+	if (isl_mat_get_element(node->sched, row, 0, &v) < 0)
+		goto error;
 	aff = isl_aff_set_constant(aff, v);
 	for (j = 0; j < node->nparam; ++j) {
-		isl_mat_get_element(node->sched, row, 1 + j, &v);
+		if (isl_mat_get_element(node->sched, row, 1 + j, &v) < 0)
+			goto error;
 		aff = isl_aff_set_coefficient(aff, isl_dim_param, j, v);
 	}
 	for (j = 0; j < node->nvar; ++j) {
-		isl_mat_get_element(node->sched, row, 1 + node->nparam + j, &v);
+		if (isl_mat_get_element(node->sched, row,
+					1 + node->nparam + j, &v) < 0)
+			goto error;
 		aff = isl_aff_set_coefficient(aff, isl_dim_in, j, v);
 	}
 
 	isl_int_clear(v);
 
 	return aff;
+error:
+	isl_int_clear(v);
+	isl_aff_free(aff);
+	return NULL;
 }
 
-/* Convert node->sched into a multi_aff and return this multi_aff.
+/* Convert the "n" rows starting at "first" of node->sched into a multi_aff
+ * and return this multi_aff.
  *
  * The result is defined over the uncompressed node domain.
  */
-static __isl_give isl_multi_aff *node_extract_schedule_multi_aff(
-	struct isl_sched_node *node)
+static __isl_give isl_multi_aff *node_extract_partial_schedule_multi_aff(
+	struct isl_sched_node *node, int first, int n)
 {
 	int i;
 	isl_space *space;
 	isl_local_space *ls;
 	isl_aff *aff;
 	isl_multi_aff *ma;
-	int nrow, ncol;
+	isl_size nrow;
 
+	if (!node)
+		return NULL;
 	nrow = isl_mat_rows(node->sched);
-	ncol = isl_mat_cols(node->sched) - 1;
+	if (nrow < 0)
+		return NULL;
 	if (node->compressed)
-		space = isl_multi_aff_get_domain_space(node->decompress);
+		space = isl_pw_multi_aff_get_domain_space(node->decompress);
 	else
 		space = isl_space_copy(node->space);
 	ls = isl_local_space_from_space(isl_space_copy(space));
 	space = isl_space_from_domain(space);
-	space = isl_space_add_dims(space, isl_dim_out, nrow);
+	space = isl_space_add_dims(space, isl_dim_out, n);
 	ma = isl_multi_aff_zero(space);
 
-	for (i = 0; i < nrow; ++i) {
+	for (i = first; i < first + n; ++i) {
 		aff = extract_schedule_row(isl_local_space_copy(ls), node, i);
-		ma = isl_multi_aff_set_aff(ma, i, aff);
+		ma = isl_multi_aff_set_aff(ma, i - first, aff);
 	}
 
 	isl_local_space_free(ls);
@@ -2365,6 +3308,21 @@
 	return ma;
 }
 
+/* Convert node->sched into a multi_aff and return this multi_aff.
+ *
+ * The result is defined over the uncompressed node domain.
+ */
+static __isl_give isl_multi_aff *node_extract_schedule_multi_aff(
+	struct isl_sched_node *node)
+{
+	isl_size nrow;
+
+	nrow = isl_mat_rows(node->sched);
+	if (nrow < 0)
+		return NULL;
+	return node_extract_partial_schedule_multi_aff(node, 0, nrow);
+}
+
 /* Convert node->sched into a map and return this map.
  *
  * The result is cached in node->sched_map, which needs to be released
@@ -2421,10 +3379,18 @@
  * If the dependence is carried completely by the current schedule, then
  * it is removed from the edge_tables.  It is kept in the list of edges
  * as otherwise all edge_tables would have to be recomputed.
+ *
+ * If the edge is of a type that can appear multiple times
+ * between the same pair of nodes, then it is added to
+ * the edge table (again).  This prevents the situation
+ * where none of these edges is referenced from the edge table
+ * because the one that was referenced turned out to be empty and
+ * was therefore removed from the table.
  */
-static int update_edge(struct isl_sched_graph *graph,
+static isl_stat update_edge(isl_ctx *ctx, struct isl_sched_graph *graph,
 	struct isl_sched_edge *edge)
 {
+	int empty;
 	isl_map *id;
 
 	id = specializer(edge->src, edge->dst);
@@ -2445,159 +3411,279 @@
 			goto error;
 	}
 
-	isl_map_free(id);
-	if (isl_map_plain_is_empty(edge->map))
-		graph_remove_edge(graph, edge);
+	empty = isl_map_plain_is_empty(edge->map);
+	if (empty < 0)
+		goto error;
+	if (empty) {
+		if (graph_remove_edge(graph, edge) < 0)
+			goto error;
+	} else if (is_multi_edge_type(edge)) {
+		if (graph_edge_tables_add(ctx, graph, edge) < 0)
+			goto error;
+	}
 
-	return 0;
+	isl_map_free(id);
+	return isl_stat_ok;
 error:
 	isl_map_free(id);
-	return -1;
+	return isl_stat_error;
 }
 
-/* Update the dependence relations of all edges based on the current schedule.
+/* Does the domain of "umap" intersect "uset"?
  */
-static int update_edges(isl_ctx *ctx, struct isl_sched_graph *graph)
+static int domain_intersects(__isl_keep isl_union_map *umap,
+	__isl_keep isl_union_set *uset)
 {
-	int i;
+	int empty;
 
-	for (i = graph->n_edge - 1; i >= 0; --i) {
-		if (update_edge(graph, &graph->edgei) < 0)
-			return -1;
-	}
+	umap = isl_union_map_copy(umap);
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(uset));
+	empty = isl_union_map_is_empty(umap);
+	isl_union_map_free(umap);
 
-	return 0;
+	return empty < 0 ? -1 : !empty;
 }
 
-static void next_band(struct isl_sched_graph *graph)
+/* Does the range of "umap" intersect "uset"?
+ */
+static int range_intersects(__isl_keep isl_union_map *umap,
+	__isl_keep isl_union_set *uset)
 {
-	graph->band_start = graph->n_total_row;
-	graph->n_band++;
+	int empty;
+
+	umap = isl_union_map_copy(umap);
+	umap = isl_union_map_intersect_range(umap, isl_union_set_copy(uset));
+	empty = isl_union_map_is_empty(umap);
+	isl_union_map_free(umap);
+
+	return empty < 0 ? -1 : !empty;
 }
 
-/* Topologically sort statements mapped to the same schedule iteration
- * and add a row to the schedule corresponding to this order.
+/* Are the condition dependences of "edge" local with respect to
+ * the current schedule?
+ *
+ * That is, are domain and range of the condition dependences mapped
+ * to the same point?
+ *
+ * In other words, is the condition false?
  */
-static int sort_statements(isl_ctx *ctx, struct isl_sched_graph *graph)
+static int is_condition_false(struct isl_sched_edge *edge)
 {
-	int i, j;
+	isl_union_map *umap;
+	isl_map *map, *sched, *test;
+	int empty, local;
 
-	if (graph->n <= 1)
-		return 0;
+	empty = isl_union_map_is_empty(edge->tagged_condition);
+	if (empty < 0 || empty)
+		return empty;
 
-	if (update_edges(ctx, graph) < 0)
-		return -1;
+	umap = isl_union_map_copy(edge->tagged_condition);
+	umap = isl_union_map_zip(umap);
+	umap = isl_union_set_unwrap(isl_union_map_domain(umap));
+	map = isl_map_from_union_map(umap);
 
-	if (graph->n_edge == 0)
-		return 0;
+	sched = node_extract_schedule(edge->src);
+	map = isl_map_apply_domain(map, sched);
+	sched = node_extract_schedule(edge->dst);
+	map = isl_map_apply_range(map, sched);
 
-	if (detect_sccs(ctx, graph) < 0)
-		return -1;
+	test = isl_map_identity(isl_map_get_space(map));
+	local = isl_map_is_subset(map, test);
+	isl_map_free(map);
+	isl_map_free(test);
 
-	if (graph->n_total_row >= graph->max_row)
-		isl_die(ctx, isl_error_internal,
-			"too many schedule rows", return -1);
+	return local;
+}
 
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		int row = isl_mat_rows(node->sched);
-		int cols = isl_mat_cols(node->sched);
+/* For each conditional validity constraint that is adjacent
+ * to a condition with domain in condition_source or range in condition_sink,
+ * turn it into an unconditional validity constraint.
+ */
+static int unconditionalize_adjacent_validity(struct isl_sched_graph *graph,
+	__isl_take isl_union_set *condition_source,
+	__isl_take isl_union_set *condition_sink)
+{
+	int i;
 
-		isl_map_free(node->sched_map);
-		node->sched_map = NULL;
-		node->sched = isl_mat_add_rows(node->sched, 1);
-		if (!node->sched)
-			return -1;
-		node->sched = isl_mat_set_element_si(node->sched, row, 0,
-						     node->scc);
-		for (j = 1; j < cols; ++j)
-			node->sched = isl_mat_set_element_si(node->sched,
-							     row, j, 0);
-		node->bandgraph->n_total_row = graph->n_band;
-	}
+	condition_source = isl_union_set_coalesce(condition_source);
+	condition_sink = isl_union_set_coalesce(condition_sink);
 
-	graph->n_total_row++;
-	next_band(graph);
+	for (i = 0; i < graph->n_edge; ++i) {
+		int adjacent;
+		isl_union_map *validity;
+
+		if (!is_conditional_validity(&graph->edgei))
+			continue;
+		if (is_validity(&graph->edgei))
+			continue;
+
+		validity = graph->edgei.tagged_validity;
+		adjacent = domain_intersects(validity, condition_sink);
+		if (adjacent >= 0 && !adjacent)
+			adjacent = range_intersects(validity, condition_source);
+		if (adjacent < 0)
+			goto error;
+		if (!adjacent)
+			continue;
+
+		set_validity(&graph->edgei);
+	}
 
+	isl_union_set_free(condition_source);
+	isl_union_set_free(condition_sink);
 	return 0;
+error:
+	isl_union_set_free(condition_source);
+	isl_union_set_free(condition_sink);
+	return -1;
 }
 
-/* Construct an isl_schedule based on the computed schedule stored
- * in graph and with parameters specified by dim.
+/* Update the dependence relations of all edges based on the current schedule
+ * and enforce conditional validity constraints that are adjacent
+ * to satisfied condition constraints.
+ *
+ * First check if any of the condition constraints are satisfied
+ * (i.e., not local to the outer schedule) and keep track of
+ * their domain and range.
+ * Then update all dependence relations (which removes the non-local
+ * constraints).
+ * Finally, if any condition constraints turned out to be satisfied,
+ * then turn all adjacent conditional validity constraints into
+ * unconditional validity constraints.
  */
-static __isl_give isl_schedule *extract_schedule(struct isl_sched_graph *graph,
-	__isl_take isl_space *dim)
+static int update_edges(isl_ctx *ctx, struct isl_sched_graph *graph)
 {
 	int i;
-	isl_ctx *ctx;
-	isl_schedule *sched = NULL;
+	int any = 0;
+	isl_union_set *source, *sink;
 
-	if (!dim)
-		return NULL;
+	source = isl_union_set_empty(isl_space_params_alloc(ctx, 0));
+	sink = isl_union_set_empty(isl_space_params_alloc(ctx, 0));
+	for (i = 0; i < graph->n_edge; ++i) {
+		int local;
+		isl_union_set *uset;
+		isl_union_map *umap;
 
-	ctx = isl_space_get_ctx(dim);
-	sched = isl_calloc(ctx, struct isl_schedule,
-			   sizeof(struct isl_schedule) +
-			   (graph->n - 1) * sizeof(struct isl_schedule_node));
-	if (!sched)
-		goto error;
+		if (!is_condition(&graph->edgei))
+			continue;
+		if (is_local(&graph->edgei))
+			continue;
+		local = is_condition_false(&graph->edgei);
+		if (local < 0)
+			goto error;
+		if (local)
+			continue;
+
+		any = 1;
 
-	sched->ref = 1;
-	sched->n = graph->n;
-	sched->n_band = graph->n_band;
-	sched->n_total_row = graph->n_total_row;
-
-	for (i = 0; i < sched->n; ++i) {
-		int r, b;
-		int *band_end, *band_id, *coincident;
-
-		sched->nodei.sched =
-			node_extract_schedule_multi_aff(&graph->nodei);
-		if (!sched->nodei.sched)
+		umap = isl_union_map_copy(graph->edgei.tagged_condition);
+		uset = isl_union_map_domain(umap);
+		source = isl_union_set_union(source, uset);
+
+		umap = isl_union_map_copy(graph->edgei.tagged_condition);
+		uset = isl_union_map_range(umap);
+		sink = isl_union_set_union(sink, uset);
+	}
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		if (update_edge(ctx, graph, &graph->edgei) < 0)
 			goto error;
+	}
 
-		sched->nodei.n_band = graph->n_band;
-		if (graph->n_band == 0)
+	if (any)
+		return unconditionalize_adjacent_validity(graph, source, sink);
+
+	isl_union_set_free(source);
+	isl_union_set_free(sink);
+	return 0;
+error:
+	isl_union_set_free(source);
+	isl_union_set_free(sink);
+	return -1;
+}
+
+static void next_band(struct isl_sched_graph *graph)
+{
+	graph->band_start = graph->n_total_row;
+}
+
+/* Return the union of the universe domains of the nodes in "graph"
+ * that satisfy "pred".
+ */
+static __isl_give isl_union_set *isl_sched_graph_domain(isl_ctx *ctx,
+	struct isl_sched_graph *graph,
+	int (*pred)(struct isl_sched_node *node, int data), int data)
+{
+	int i;
+	isl_set *set;
+	isl_union_set *dom;
+
+	for (i = 0; i < graph->n; ++i)
+		if (pred(&graph->nodei, data))
+			break;
+
+	if (i >= graph->n)
+		isl_die(ctx, isl_error_internal,
+			"empty component", return NULL);
+
+	set = isl_set_universe(isl_space_copy(graph->nodei.space));
+	dom = isl_union_set_from_set(set);
+
+	for (i = i + 1; i < graph->n; ++i) {
+		if (!pred(&graph->nodei, data))
 			continue;
+		set = isl_set_universe(isl_space_copy(graph->nodei.space));
+		dom = isl_union_set_union(dom, isl_union_set_from_set(set));
+	}
 
-		band_end = isl_alloc_array(ctx, int, graph->n_band);
-		band_id = isl_alloc_array(ctx, int, graph->n_band);
-		coincident = isl_alloc_array(ctx, int, graph->n_total_row);
-		sched->nodei.band_end = band_end;
-		sched->nodei.band_id = band_id;
-		sched->nodei.coincident = coincident;
-		if (!band_end || !band_id || !coincident)
-			goto error;
+	return dom;
+}
 
-		for (r = 0; r < graph->n_total_row; ++r)
-			coincidentr = graph->nodei.coincidentr;
-		for (r = b = 0; r < graph->n_total_row; ++r) {
-			if (graph->nodei.bandr == b)
-				continue;
-			band_endb++ = r;
-			if (graph->nodei.bandr == -1)
-				break;
-		}
-		if (r == graph->n_total_row)
-			band_endb++ = r;
-		sched->nodei.n_band = b;
-		for (--b; b >= 0; --b)
-			band_idb = graph->nodei.band_idb;
+/* Return a list of unions of universe domains, where each element
+ * in the list corresponds to an SCC (or WCC) indexed by node->scc.
+ */
+static __isl_give isl_union_set_list *extract_sccs(isl_ctx *ctx,
+	struct isl_sched_graph *graph)
+{
+	int i;
+	isl_union_set_list *filters;
+
+	filters = isl_union_set_list_alloc(ctx, graph->scc);
+	for (i = 0; i < graph->scc; ++i) {
+		isl_union_set *dom;
+
+		dom = isl_sched_graph_domain(ctx, graph, &node_scc_exactly, i);
+		filters = isl_union_set_list_add(filters, dom);
 	}
 
-	sched->dim = dim;
+	return filters;
+}
 
-	return sched;
-error:
-	isl_space_free(dim);
-	isl_schedule_free(sched);
-	return NULL;
+/* Return a list of two unions of universe domains, one for the SCCs up
+ * to and including graph->src_scc and another for the other SCCs.
+ */
+static __isl_give isl_union_set_list *extract_split(isl_ctx *ctx,
+	struct isl_sched_graph *graph)
+{
+	isl_union_set *dom;
+	isl_union_set_list *filters;
+
+	filters = isl_union_set_list_alloc(ctx, 2);
+	dom = isl_sched_graph_domain(ctx, graph,
+					&node_scc_at_most, graph->src_scc);
+	filters = isl_union_set_list_add(filters, dom);
+	dom = isl_sched_graph_domain(ctx, graph,
+					&node_scc_at_least, graph->src_scc + 1);
+	filters = isl_union_set_list_add(filters, dom);
+
+	return filters;
 }
 
 /* Copy nodes that satisfy node_pred from the src dependence graph
  * to the dst dependence graph.
  */
-static int copy_nodes(struct isl_sched_graph *dst, struct isl_sched_graph *src,
+static isl_stat copy_nodes(struct isl_sched_graph *dst,
+	struct isl_sched_graph *src,
 	int (*node_pred)(struct isl_sched_node *node, int data), int data)
 {
 	int i;
@@ -2616,25 +3702,26 @@
 		dst->nodej.compress =
 			isl_multi_aff_copy(src->nodei.compress);
 		dst->nodej.decompress =
-			isl_multi_aff_copy(src->nodei.decompress);
+			isl_pw_multi_aff_copy(src->nodei.decompress);
 		dst->nodej.nvar = src->nodei.nvar;
 		dst->nodej.nparam = src->nodei.nparam;
 		dst->nodej.sched = isl_mat_copy(src->nodei.sched);
 		dst->nodej.sched_map = isl_map_copy(src->nodei.sched_map);
-		dst->nodej.band = src->nodei.band;
-		dst->nodej.band_id = src->nodei.band_id;
 		dst->nodej.coincident = src->nodei.coincident;
+		dst->nodej.sizes = isl_multi_val_copy(src->nodei.sizes);
+		dst->nodej.bounds = isl_basic_set_copy(src->nodei.bounds);
+		dst->nodej.max = isl_vec_copy(src->nodei.max);
 		dst->n++;
 
 		if (!dst->nodej.space || !dst->nodej.sched)
-			return -1;
+			return isl_stat_error;
 		if (dst->nodej.compressed &&
 		    (!dst->nodej.hull || !dst->nodej.compress ||
 		     !dst->nodej.decompress))
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Copy non-empty edges that satisfy edge_pred from the src dependence graph
@@ -2643,12 +3730,11 @@
  * graph, then it must be a backward proximity edge and it should simply
  * be ignored.
  */
-static int copy_edges(isl_ctx *ctx, struct isl_sched_graph *dst,
+static isl_stat copy_edges(isl_ctx *ctx, struct isl_sched_graph *dst,
 	struct isl_sched_graph *src,
 	int (*edge_pred)(struct isl_sched_edge *edge, int data), int data)
 {
 	int i;
-	enum isl_edge_type t;
 
 	dst->n_edge = 0;
 	for (i = 0; i < src->n_edge; ++i) {
@@ -2666,11 +3752,13 @@
 
 		dst_src = graph_find_node(ctx, dst, edge->src->space);
 		dst_dst = graph_find_node(ctx, dst, edge->dst->space);
-		if (!dst_src || !dst_dst) {
-			if (edge->validity || edge->conditional_validity)
+		if (!dst_src || !dst_dst)
+			return isl_stat_error;
+		if (!is_node(dst, dst_src) || !is_node(dst, dst_dst)) {
+			if (is_validity(edge) || is_conditional_validity(edge))
 				isl_die(ctx, isl_error_internal,
 					"backward (conditional) validity edge",
-					return -1);
+					return isl_stat_error);
 			continue;
 		}
 
@@ -2683,59 +3771,20 @@
 		dst->edgedst->n_edge.map = map;
 		dst->edgedst->n_edge.tagged_condition = tagged_condition;
 		dst->edgedst->n_edge.tagged_validity = tagged_validity;
-		dst->edgedst->n_edge.validity = edge->validity;
-		dst->edgedst->n_edge.proximity = edge->proximity;
-		dst->edgedst->n_edge.coincidence = edge->coincidence;
-		dst->edgedst->n_edge.condition = edge->condition;
-		dst->edgedst->n_edge.conditional_validity =
-						edge->conditional_validity;
+		dst->edgedst->n_edge.types = edge->types;
 		dst->n_edge++;
 
 		if (edge->tagged_condition && !tagged_condition)
-			return -1;
+			return isl_stat_error;
 		if (edge->tagged_validity && !tagged_validity)
-			return -1;
+			return isl_stat_error;
 
-		for (t = isl_edge_first; t <= isl_edge_last; ++t) {
-			if (edge !=
-			    graph_find_edge(src, t, edge->src, edge->dst))
-				continue;
-			if (graph_edge_table_add(ctx, dst, t,
+		if (graph_edge_tables_add(ctx, dst,
 					    &dst->edgedst->n_edge - 1) < 0)
-				return -1;
-		}
-	}
-
-	return 0;
-}
-
-/* Given a "src" dependence graph that contains the nodes from "dst"
- * that satisfy node_pred, copy the schedule computed in "src"
- * for those nodes back to "dst".
- */
-static int copy_schedule(struct isl_sched_graph *dst,
-	struct isl_sched_graph *src,
-	int (*node_pred)(struct isl_sched_node *node, int data), int data)
-{
-	int i;
-
-	src->n = 0;
-	for (i = 0; i < dst->n; ++i) {
-		if (!node_pred(&dst->nodei, data))
-			continue;
-		isl_mat_free(dst->nodei.sched);
-		isl_map_free(dst->nodei.sched_map);
-		dst->nodei.sched = isl_mat_copy(src->nodesrc->n.sched);
-		dst->nodei.sched_map =
-			isl_map_copy(src->nodesrc->n.sched_map);
-		src->n++;
+			return isl_stat_error;
 	}
 
-	dst->max_row = src->max_row;
-	dst->n_total_row = src->n_total_row;
-	dst->n_band = src->n_band;
-
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Compute the maximal number of variables over all nodes.
@@ -2754,7 +3803,7 @@
 		struct isl_sched_node *node = &graph->nodei;
 		int nvar;
 
-		if (node_update_cmap(node) < 0)
+		if (node_update_vmap(node) < 0)
 			return -1;
 		nvar = node->nvar + graph->n_row - node->rank;
 		if (nvar > graph->maxvar)
@@ -2764,73 +3813,84 @@
 	return 0;
 }
 
-static int compute_schedule(isl_ctx *ctx, struct isl_sched_graph *graph);
-static int compute_schedule_wcc(isl_ctx *ctx, struct isl_sched_graph *graph);
+/* Extract the subgraph of "graph" that consists of the nodes satisfying
+ * "node_pred" and the edges satisfying "edge_pred" and store
+ * the result in "sub".
+ */
+static isl_stat extract_sub_graph(isl_ctx *ctx, struct isl_sched_graph *graph,
+	int (*node_pred)(struct isl_sched_node *node, int data),
+	int (*edge_pred)(struct isl_sched_edge *edge, int data),
+	int data, struct isl_sched_graph *sub)
+{
+	int i, n = 0, n_edge = 0;
+	int t;
+
+	for (i = 0; i < graph->n; ++i)
+		if (node_pred(&graph->nodei, data))
+			++n;
+	for (i = 0; i < graph->n_edge; ++i)
+		if (edge_pred(&graph->edgei, data))
+			++n_edge;
+	if (graph_alloc(ctx, sub, n, n_edge) < 0)
+		return isl_stat_error;
+	sub->root = graph->root;
+	if (copy_nodes(sub, graph, node_pred, data) < 0)
+		return isl_stat_error;
+	if (graph_init_table(ctx, sub) < 0)
+		return isl_stat_error;
+	for (t = 0; t <= isl_edge_last; ++t)
+		sub->max_edget = graph->max_edget;
+	if (graph_init_edge_tables(ctx, sub) < 0)
+		return isl_stat_error;
+	if (copy_edges(ctx, sub, graph, edge_pred, data) < 0)
+		return isl_stat_error;
+	sub->n_row = graph->n_row;
+	sub->max_row = graph->max_row;
+	sub->n_total_row = graph->n_total_row;
+	sub->band_start = graph->band_start;
+
+	return isl_stat_ok;
+}
+
+static __isl_give isl_schedule_node *compute_schedule(isl_schedule_node *node,
+	struct isl_sched_graph *graph);
+static __isl_give isl_schedule_node *compute_schedule_wcc(
+	isl_schedule_node *node, struct isl_sched_graph *graph);
 
 /* Compute a schedule for a subgraph of "graph".  In particular, for
  * the graph composed of nodes that satisfy node_pred and edges that
- * that satisfy edge_pred.  The caller should precompute the number
- * of nodes and edges that satisfy these predicates and pass them along
- * as "n" and "n_edge".
+ * that satisfy edge_pred.
  * If the subgraph is known to consist of a single component, then wcc should
  * be set and then we call compute_schedule_wcc on the constructed subgraph.
  * Otherwise, we call compute_schedule, which will check whether the subgraph
  * is connected.
+ *
+ * The schedule is inserted at "node" and the updated schedule node
+ * is returned.
  */
-static int compute_sub_schedule(isl_ctx *ctx,
-	struct isl_sched_graph *graph, int n, int n_edge,
+static __isl_give isl_schedule_node *compute_sub_schedule(
+	__isl_take isl_schedule_node *node, isl_ctx *ctx,
+	struct isl_sched_graph *graph,
 	int (*node_pred)(struct isl_sched_node *node, int data),
 	int (*edge_pred)(struct isl_sched_edge *edge, int data),
 	int data, int wcc)
 {
 	struct isl_sched_graph split = { 0 };
-	int t;
-
-	if (graph_alloc(ctx, &split, n, n_edge) < 0)
-		goto error;
-	if (copy_nodes(&split, graph, node_pred, data) < 0)
-		goto error;
-	if (graph_init_table(ctx, &split) < 0)
-		goto error;
-	for (t = 0; t <= isl_edge_last; ++t)
-		split.max_edget = graph->max_edget;
-	if (graph_init_edge_tables(ctx, &split) < 0)
-		goto error;
-	if (copy_edges(ctx, &split, graph, edge_pred, data) < 0)
-		goto error;
-	split.n_row = graph->n_row;
-	split.max_row = graph->max_row;
-	split.n_total_row = graph->n_total_row;
-	split.n_band = graph->n_band;
-	split.band_start = graph->band_start;
 
-	if (wcc && compute_schedule_wcc(ctx, &split) < 0)
-		goto error;
-	if (!wcc && compute_schedule(ctx, &split) < 0)
+	if (extract_sub_graph(ctx, graph, node_pred, edge_pred, data,
+				&split) < 0)
 		goto error;
 
-	copy_schedule(graph, &split, node_pred, data);
+	if (wcc)
+		node = compute_schedule_wcc(node, &split);
+	else
+		node = compute_schedule(node, &split);
 
 	graph_free(ctx, &split);
-	return 0;
+	return node;
 error:
 	graph_free(ctx, &split);
-	return -1;
-}
-
-static int node_scc_exactly(struct isl_sched_node *node, int scc)
-{
-	return node->scc == scc;
-}
-
-static int node_scc_at_most(struct isl_sched_node *node, int scc)
-{
-	return node->scc <= scc;
-}
-
-static int node_scc_at_least(struct isl_sched_node *node, int scc)
-{
-	return node->scc >= scc;
+	return isl_schedule_node_free(node);
 }
 
 static int edge_scc_exactly(struct isl_sched_edge *edge, int scc)
@@ -2848,35 +3908,9 @@
 	return edge->src->scc >= scc;
 }
 
-/* Pad the schedules of all nodes with zero rows such that in the end
- * they all have graph->n_total_row rows.
- * The extra rows don't belong to any band, so they get assigned band number -1.
- */
-static int pad_schedule(struct isl_sched_graph *graph)
-{
-	int i, j;
-
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		int row = isl_mat_rows(node->sched);
-		if (graph->n_total_row > row) {
-			isl_map_free(node->sched_map);
-			node->sched_map = NULL;
-		}
-		node->sched = isl_mat_add_zero_rows(node->sched,
-						    graph->n_total_row - row);
-		if (!node->sched)
-			return -1;
-		for (j = row; j < graph->n_total_row; ++j)
-			node->bandj = -1;
-	}
-
-	return 0;
-}
-
 /* Reset the current band by dropping all its schedule rows.
  */
-static int reset_band(struct isl_sched_graph *graph)
+static isl_stat reset_band(struct isl_sched_graph *graph)
 {
 	int i;
 	int drop;
@@ -2895,309 +3929,461 @@
 						graph->band_start, drop);
 
 		if (!node->sched)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Split the current graph into two parts and compute a schedule for each
  * part individually.  In particular, one part consists of all SCCs up
  * to and including graph->src_scc, while the other part contains the other
- * SCCS.
+ * SCCs.  The split is enforced by a sequence node inserted at position "node"
+ * in the schedule tree.  Return the updated schedule node.
+ * If either of these two parts consists of a sequence, then it is spliced
+ * into the sequence containing the two parts.
  *
- * The split is enforced in the schedule by constant rows with two different
- * values (0 and 1).  These constant rows replace the previously computed rows
- * in the current band.
- * It would be possible to reuse them as the first rows in the next
+ * The current band is reset. It would be possible to reuse
+ * the previously computed rows as the first rows in the next
  * band, but recomputing them may result in better rows as we are looking
  * at a smaller part of the dependence graph.
- *
- * Since we do not enforce coincidence, we conservatively mark the
- * splitting row as not coincident.
- *
- * The band_id of the second group is set to n, where n is the number
- * of nodes in the first group.  This ensures that the band_ids over
- * the two groups remain disjoint, even if either or both of the two
- * groups contain independent components.
- */
-static int compute_split_schedule(isl_ctx *ctx, struct isl_sched_graph *graph)
-{
-	int i, j, n, e1, e2;
-	int n_total_row, orig_total_row;
-	int n_band, orig_band;
+ */
+static __isl_give isl_schedule_node *compute_split_schedule(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	int is_seq;
+	isl_ctx *ctx;
+	isl_union_set_list *filters;
 
-	if (graph->n_total_row >= graph->max_row)
-		isl_die(ctx, isl_error_internal,
-			"too many schedule rows", return -1);
+	if (!node)
+		return NULL;
 
 	if (reset_band(graph) < 0)
-		return -1;
+		return isl_schedule_node_free(node);
 
-	n = 0;
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		int row = isl_mat_rows(node->sched);
-		int cols = isl_mat_cols(node->sched);
-		int before = node->scc <= graph->src_scc;
-
-		if (before)
-			n++;
-
-		isl_map_free(node->sched_map);
-		node->sched_map = NULL;
-		node->sched = isl_mat_add_rows(node->sched, 1);
-		if (!node->sched)
-			return -1;
-		node->sched = isl_mat_set_element_si(node->sched, row, 0,
-						     !before);
-		for (j = 1; j < cols; ++j)
-			node->sched = isl_mat_set_element_si(node->sched,
-							     row, j, 0);
-		node->bandgraph->n_total_row = graph->n_band;
-		node->coincidentgraph->n_total_row = 0;
-	}
-
-	e1 = e2 = 0;
-	for (i = 0; i < graph->n_edge; ++i) {
-		if (graph->edgei.dst->scc <= graph->src_scc)
-			e1++;
-		if (graph->edgei.src->scc > graph->src_scc)
-			e2++;
-	}
-
-	graph->n_total_row++;
 	next_band(graph);
 
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		if (node->scc > graph->src_scc)
-			node->band_idgraph->n_band = n;
-	}
+	ctx = isl_schedule_node_get_ctx(node);
+	filters = extract_split(ctx, graph);
+	node = isl_schedule_node_insert_sequence(node, filters);
+	node = isl_schedule_node_child(node, 1);
+	node = isl_schedule_node_child(node, 0);
 
-	orig_total_row = graph->n_total_row;
-	orig_band = graph->n_band;
-	if (compute_sub_schedule(ctx, graph, n, e1,
-				&node_scc_at_most, &edge_dst_scc_at_most,
-				graph->src_scc, 0) < 0)
-		return -1;
-	n_total_row = graph->n_total_row;
-	graph->n_total_row = orig_total_row;
-	n_band = graph->n_band;
-	graph->n_band = orig_band;
-	if (compute_sub_schedule(ctx, graph, graph->n - n, e2,
+	node = compute_sub_schedule(node, ctx, graph,
 				&node_scc_at_least, &edge_src_scc_at_least,
-				graph->src_scc + 1, 0) < 0)
-		return -1;
-	if (n_total_row > graph->n_total_row)
-		graph->n_total_row = n_total_row;
-	if (n_band > graph->n_band)
-		graph->n_band = n_band;
+				graph->src_scc + 1, 0);
+	is_seq = isl_schedule_node_get_type(node) == isl_schedule_node_sequence;
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	if (is_seq)
+		node = isl_schedule_node_sequence_splice_child(node, 1);
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_child(node, 0);
+	node = compute_sub_schedule(node, ctx, graph,
+				&node_scc_at_most, &edge_dst_scc_at_most,
+				graph->src_scc, 0);
+	is_seq = isl_schedule_node_get_type(node) == isl_schedule_node_sequence;
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	if (is_seq)
+		node = isl_schedule_node_sequence_splice_child(node, 0);
+
+	return node;
+}
+
+/* Insert a band node at position "node" in the schedule tree corresponding
+ * to the current band in "graph".  Mark the band node permutable
+ * if "permutable" is set.
+ * The partial schedules and the coincidence property are extracted
+ * from the graph nodes.
+ * Return the updated schedule node.
+ */
+static __isl_give isl_schedule_node *insert_current_band(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int permutable)
+{
+	int i;
+	int start, end, n;
+	isl_multi_aff *ma;
+	isl_multi_pw_aff *mpa;
+	isl_multi_union_pw_aff *mupa;
 
-	return pad_schedule(graph);
-}
+	if (!node)
+		return NULL;
 
-/* Compute the next band of the schedule after updating the dependence
- * relations based on the the current schedule.
- */
-static int compute_next_band(isl_ctx *ctx, struct isl_sched_graph *graph)
+	if (graph->n < 1)
+		isl_die(isl_schedule_node_get_ctx(node), isl_error_internal,
+			"graph should have at least one node",
+			return isl_schedule_node_free(node));
+
+	start = graph->band_start;
+	end = graph->n_total_row;
+	n = end - start;
+
+	ma = node_extract_partial_schedule_multi_aff(&graph->node0, start, n);
+	mpa = isl_multi_pw_aff_from_multi_aff(ma);
+	mupa = isl_multi_union_pw_aff_from_multi_pw_aff(mpa);
+
+	for (i = 1; i < graph->n; ++i) {
+		isl_multi_union_pw_aff *mupa_i;
+
+		ma = node_extract_partial_schedule_multi_aff(&graph->nodei,
+								start, n);
+		mpa = isl_multi_pw_aff_from_multi_aff(ma);
+		mupa_i = isl_multi_union_pw_aff_from_multi_pw_aff(mpa);
+		mupa = isl_multi_union_pw_aff_union_add(mupa, mupa_i);
+	}
+	node = isl_schedule_node_insert_partial_schedule(node, mupa);
+
+	for (i = 0; i < n; ++i)
+		node = isl_schedule_node_band_member_set_coincident(node, i,
+					graph->node0.coincidentstart + i);
+	node = isl_schedule_node_band_set_permutable(node, permutable);
+
+	return node;
+}
+
+/* Update the dependence relations based on the current schedule,
+ * add the current band to "node" and then continue with the computation
+ * of the next band.
+ * Return the updated schedule node.
+ */
+static __isl_give isl_schedule_node *compute_next_band(
+	__isl_take isl_schedule_node *node,
+	struct isl_sched_graph *graph, int permutable)
 {
+	isl_ctx *ctx;
+
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
 	if (update_edges(ctx, graph) < 0)
-		return -1;
+		return isl_schedule_node_free(node);
+	node = insert_current_band(node, graph, permutable);
 	next_band(graph);
 
-	return compute_schedule(ctx, graph);
+	node = isl_schedule_node_child(node, 0);
+	node = compute_schedule(node, graph);
+	node = isl_schedule_node_parent(node);
+
+	return node;
 }
 
-/* Add constraints to graph->lp that force the dependence "map" (which
- * is part of the dependence relation of "edge")
- * to be respected and attempt to carry it, where the edge is one from
- * a node j to itself.  "pos" is the sequence number of the given map.
- * That is, add constraints that enforce
+/* Add the constraints "coef" derived from an edge from "node" to itself
+ * to graph->lp in order to respect the dependences and to try and carry them.
+ * "pos" is the sequence number of the edge that needs to be carried.
+ * "coef" represents general constraints on coefficients (c_0, c_x)
+ * of valid constraints for (y - x) with x and y instances of the node.
+ *
+ * The constraints added to graph->lp need to enforce
  *
- *	(c_j_0 + c_j_n n + c_j_x y) - (c_j_0 + c_j_n n + c_j_x x)
+ *	(c_j_0 + c_j_x y) - (c_j_0 + c_j_x x)
  *	= c_j_x (y - x) >= e_i
  *
- * for each (x,y) in R.
- * We obtain general constraints on coefficients (c_0, c_n, c_x)
- * of valid constraints for (y - x) and then plug in (-e_i, 0, c_j_x),
- * with each coefficient in c_j_x represented as a pair of non-negative
- * coefficients.
+ * for each (x,y) in the dependence relation of the edge.
+ * That is, (-e_i, c_j_x) needs to be plugged in for (c_0, c_x),
+ * taking into account that each coefficient in c_j_x is represented
+ * as a pair of non-negative coefficients.
  */
-static int add_intra_constraints(struct isl_sched_graph *graph,
-	struct isl_sched_edge *edge, __isl_take isl_map *map, int pos)
+static isl_stat add_intra_constraints(struct isl_sched_graph *graph,
+	struct isl_sched_node *node, __isl_take isl_basic_set *coef, int pos)
 {
-	unsigned total;
-	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
+	isl_size offset;
+	isl_ctx *ctx;
 	isl_dim_map *dim_map;
-	isl_basic_set *coef;
-	struct isl_sched_node *node = edge->src;
 
-	coef = intra_coefficients(graph, node, map);
+	offset = coef_var_offset(coef);
+	if (offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		return -1;
-
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
+		return isl_stat_error;
 
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
+	ctx = isl_basic_set_get_ctx(coef);
+	dim_map = intra_dim_map(ctx, graph, node, offset, 1);
 	isl_dim_map_range(dim_map, 3 + pos, 0, 0, 0, 1, -1);
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, -1);
-	isl_dim_map_range(dim_map, node->start + 2 * node->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  node->nvar, 1);
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
-	isl_space_free(dim);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-/* Add constraints to graph->lp that force the dependence "map" (which
- * is part of the dependence relation of "edge")
- * to be respected and attempt to carry it, where the edge is one from
- * node j to node k.  "pos" is the sequence number of the given map.
- * That is, add constraints that enforce
+/* Add the constraints "coef" derived from an edge from "src" to "dst"
+ * to graph->lp in order to respect the dependences and to try and carry them.
+ * "pos" is the sequence number of the edge that needs to be carried or
+ * -1 if no attempt should be made to carry the dependences.
+ * "coef" represents general constraints on coefficients (c_0, c_n, c_x, c_y)
+ * of valid constraints for (x, y) with x and y instances of "src" and "dst".
+ *
+ * The constraints added to graph->lp need to enforce
  *
  *	(c_k_0 + c_k_n n + c_k_x y) - (c_j_0 + c_j_n n + c_j_x x) >= e_i
  *
- * for each (x,y) in R.
- * We obtain general constraints on coefficients (c_0, c_n, c_x)
- * of valid constraints for R and then plug in
- * (-e_i + c_k_0 - c_j_0, c_k_n - c_j_n, c_k_x - c_j_x)
- * with each coefficient (except e_i, c_k_0 and c_j_0)
- * represented as a pair of non-negative coefficients.
- */
-static int add_inter_constraints(struct isl_sched_graph *graph,
-	struct isl_sched_edge *edge, __isl_take isl_map *map, int pos)
+ * for each (x,y) in the dependence relation of the edge or
+ *
+ *	(c_k_0 + c_k_n n + c_k_x y) - (c_j_0 + c_j_n n + c_j_x x) >= 0
+ *
+ * if pos is -1.
+ * That is,
+ * (-e_i + c_k_0 - c_j_0, c_k_n - c_j_n, -c_j_x, c_k_x)
+ * or
+ * (c_k_0 - c_j_0, c_k_n - c_j_n, -c_j_x, c_k_x)
+ * needs to be plugged in for (c_0, c_n, c_x, c_y),
+ * taking into account that each coefficient in c_j_x and c_k_x is represented
+ * as a pair of non-negative coefficients.
+ */
+static isl_stat add_inter_constraints(struct isl_sched_graph *graph,
+	struct isl_sched_node *src, struct isl_sched_node *dst,
+	__isl_take isl_basic_set *coef, int pos)
 {
-	unsigned total;
-	isl_ctx *ctx = isl_map_get_ctx(map);
-	isl_space *dim;
+	isl_size offset;
+	isl_ctx *ctx;
 	isl_dim_map *dim_map;
-	isl_basic_set *coef;
-	struct isl_sched_node *src = edge->src;
-	struct isl_sched_node *dst = edge->dst;
 
-	coef = inter_coefficients(graph, edge, map);
+	offset = coef_var_offset(coef);
+	if (offset < 0)
+		coef = isl_basic_set_free(coef);
 	if (!coef)
-		return -1;
+		return isl_stat_error;
 
-	dim = isl_space_domain(isl_space_unwrap(isl_basic_set_get_space(coef)));
+	ctx = isl_basic_set_get_ctx(coef);
+	dim_map = inter_dim_map(ctx, graph, src, dst, offset, 1);
+	if (pos >= 0)
+		isl_dim_map_range(dim_map, 3 + pos, 0, 0, 0, 1, -1);
+	graph->lp = add_constraints_dim_map(graph->lp, coef, dim_map);
+
+	return isl_stat_ok;
+}
+
+/* Data structure for keeping track of the data needed
+ * to exploit non-trivial lineality spaces.
+ *
+ * "any_non_trivial" is true if there are any non-trivial lineality spaces.
+ * If "any_non_trivial" is not true, then "equivalent" and "mask" may be NULL.
+ * "equivalent" connects instances to other instances on the same line(s).
+ * "mask" contains the domain spaces of "equivalent".
+ * Any instance set not in "mask" does not have a non-trivial lineality space.
+ */
+struct isl_exploit_lineality_data {
+	isl_bool any_non_trivial;
+	isl_union_map *equivalent;
+	isl_union_set *mask;
+};
 
-	total = isl_basic_set_total_dim(graph->lp);
-	dim_map = isl_dim_map_alloc(ctx, total);
+/* Data structure collecting information used during the construction
+ * of an LP for carrying dependences.
+ *
+ * "intra" is a sequence of coefficient constraints for intra-node edges.
+ * "inter" is a sequence of coefficient constraints for inter-node edges.
+ * "lineality" contains data used to exploit non-trivial lineality spaces.
+ */
+struct isl_carry {
+	isl_basic_set_list *intra;
+	isl_basic_set_list *inter;
+	struct isl_exploit_lineality_data lineality;
+};
 
-	isl_dim_map_range(dim_map, 3 + pos, 0, 0, 0, 1, -1);
+/* Free all the data stored in "carry".
+ */
+static void isl_carry_clear(struct isl_carry *carry)
+{
+	isl_basic_set_list_free(carry->intra);
+	isl_basic_set_list_free(carry->inter);
+	isl_union_map_free(carry->lineality.equivalent);
+	isl_union_set_free(carry->lineality.mask);
+}
+
+/* Return a pointer to the node in "graph" that lives in "space".
+ * If the requested node has been compressed, then "space"
+ * corresponds to the compressed space.
+ * The graph is assumed to have such a node.
+ * Return NULL in case of error.
+ *
+ * First try and see if "space" is the space of an uncompressed node.
+ * If so, return that node.
+ * Otherwise, "space" was constructed by construct_compressed_id and
+ * contains a user pointer pointing to the node in the tuple id.
+ * However, this node belongs to the original dependence graph.
+ * If "graph" is a subgraph of this original dependence graph,
+ * then the node with the same space still needs to be looked up
+ * in the current graph.
+ */
+static struct isl_sched_node *graph_find_compressed_node(isl_ctx *ctx,
+	struct isl_sched_graph *graph, __isl_keep isl_space *space)
+{
+	isl_id *id;
+	struct isl_sched_node *node;
 
-	isl_dim_map_range(dim_map, dst->start, 0, 0, 0, 1, 1);
-	isl_dim_map_range(dim_map, dst->start + 1, 2, 1, 1, dst->nparam, -1);
-	isl_dim_map_range(dim_map, dst->start + 2, 2, 1, 1, dst->nparam, 1);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, -1);
-	isl_dim_map_range(dim_map, dst->start + 2 * dst->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set) + src->nvar, 1,
-			  dst->nvar, 1);
-
-	isl_dim_map_range(dim_map, src->start, 0, 0, 0, 1, -1);
-	isl_dim_map_range(dim_map, src->start + 1, 2, 1, 1, src->nparam, 1);
-	isl_dim_map_range(dim_map, src->start + 2, 2, 1, 1, src->nparam, -1);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 1, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, 1);
-	isl_dim_map_range(dim_map, src->start + 2 * src->nparam + 2, 2,
-			  isl_space_dim(dim, isl_dim_set), 1,
-			  src->nvar, -1);
-
-	graph->lp = isl_basic_set_extend_constraints(graph->lp,
-			coef->n_eq, coef->n_ineq);
-	graph->lp = isl_basic_set_add_constraints_dim_map(graph->lp,
-							   coef, dim_map);
-	isl_space_free(dim);
+	if (!space)
+		return NULL;
 
-	return 0;
+	node = graph_find_node(ctx, graph, space);
+	if (!node)
+		return NULL;
+	if (is_node(graph, node))
+		return node;
+
+	id = isl_space_get_tuple_id(space, isl_dim_set);
+	node = isl_id_get_user(id);
+	isl_id_free(id);
+
+	if (!node)
+		return NULL;
+
+	if (!is_node(graph->root, node))
+		isl_die(ctx, isl_error_internal,
+			"space points to invalid node", return NULL);
+	if (graph != graph->root)
+		node = graph_find_node(ctx, graph, node->space);
+	if (!is_node(graph, node))
+		isl_die(ctx, isl_error_internal,
+			"unable to find node", return NULL);
+
+	return node;
 }
 
-/* Add constraints to graph->lp that force all (conditional) validity
- * dependences to be respected and attempt to carry them.
+/* Internal data structure for add_all_constraints.
+ *
+ * "graph" is the schedule constraint graph for which an LP problem
+ * is being constructed.
+ * "carry_inter" indicates whether inter-node edges should be carried.
+ * "pos" is the position of the next edge that needs to be carried.
  */
-static int add_all_constraints(struct isl_sched_graph *graph)
-{
-	int i, j;
+struct isl_add_all_constraints_data {
+	isl_ctx *ctx;
+	struct isl_sched_graph *graph;
+	int carry_inter;
 	int pos;
+};
 
-	pos = 0;
-	for (i = 0; i < graph->n_edge; ++i) {
-		struct isl_sched_edge *edge= &graph->edgei;
+/* Add the constraints "coef" derived from an edge from a node to itself
+ * to data->graph->lp in order to respect the dependences and
+ * to try and carry them.
+ *
+ * The space of "coef" is of the form
+ *
+ *	coefficientsc_cst -> Sc_x
+ *
+ * with Sc_x the (compressed) space of the node.
+ * Extract the node from the space and call add_intra_constraints.
+ */
+static isl_stat lp_add_intra(__isl_take isl_basic_set *coef, void *user)
+{
+	struct isl_add_all_constraints_data *data = user;
+	isl_space *space;
+	struct isl_sched_node *node;
 
-		if (!edge->validity && !edge->conditional_validity)
-			continue;
+	space = isl_basic_set_get_space(coef);
+	space = isl_space_range(isl_space_unwrap(space));
+	node = graph_find_compressed_node(data->ctx, data->graph, space);
+	isl_space_free(space);
+	return add_intra_constraints(data->graph, node, coef, data->pos++);
+}
 
-		for (j = 0; j < edge->map->n; ++j) {
-			isl_basic_map *bmap;
-			isl_map *map;
+/* Add the constraints "coef" derived from an edge from a node j
+ * to a node k to data->graph->lp in order to respect the dependences and
+ * to try and carry them (provided data->carry_inter is set).
+ *
+ * The space of "coef" is of the form
+ *
+ *	coefficientsc_cst, c_n -> S_jc_x -> S_kc_y
+ *
+ * with S_jc_x and S_kc_y the (compressed) spaces of the nodes.
+ * Extract the nodes from the space and call add_inter_constraints.
+ */
+static isl_stat lp_add_inter(__isl_take isl_basic_set *coef, void *user)
+{
+	struct isl_add_all_constraints_data *data = user;
+	isl_space *space, *dom;
+	struct isl_sched_node *src, *dst;
+	int pos;
 
-			bmap = isl_basic_map_copy(edge->map->pj);
-			map = isl_map_from_basic_map(bmap);
+	space = isl_basic_set_get_space(coef);
+	space = isl_space_unwrap(isl_space_range(isl_space_unwrap(space)));
+	dom = isl_space_domain(isl_space_copy(space));
+	src = graph_find_compressed_node(data->ctx, data->graph, dom);
+	isl_space_free(dom);
+	space = isl_space_range(space);
+	dst = graph_find_compressed_node(data->ctx, data->graph, space);
+	isl_space_free(space);
 
-			if (edge->src == edge->dst &&
-			    add_intra_constraints(graph, edge, map, pos) < 0)
-				return -1;
-			if (edge->src != edge->dst &&
-			    add_inter_constraints(graph, edge, map, pos) < 0)
-				return -1;
-			++pos;
-		}
-	}
+	pos = data->carry_inter ? data->pos++ : -1;
+	return add_inter_constraints(data->graph, src, dst, coef, pos);
+}
 
-	return 0;
+/* Add constraints to graph->lp that force all (conditional) validity
+ * dependences to be respected and attempt to carry them.
+ * "intra" is the sequence of coefficient constraints for intra-node edges.
+ * "inter" is the sequence of coefficient constraints for inter-node edges.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.
+ */
+static isl_stat add_all_constraints(isl_ctx *ctx, struct isl_sched_graph *graph,
+	__isl_keep isl_basic_set_list *intra,
+	__isl_keep isl_basic_set_list *inter, int carry_inter)
+{
+	struct isl_add_all_constraints_data data = { ctx, graph, carry_inter };
+
+	data.pos = 0;
+	if (isl_basic_set_list_foreach(intra, &lp_add_intra, &data) < 0)
+		return isl_stat_error;
+	if (isl_basic_set_list_foreach(inter, &lp_add_inter, &data) < 0)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Internal data structure for count_all_constraints
+ * for keeping track of the number of equality and inequality constraints.
+ */
+struct isl_sched_count {
+	int n_eq;
+	int n_ineq;
+};
+
+/* Add the number of equality and inequality constraints of "bset"
+ * to data->n_eq and data->n_ineq.
+ */
+static isl_stat bset_update_count(__isl_take isl_basic_set *bset, void *user)
+{
+	struct isl_sched_count *data = user;
+
+	return update_count(bset, 1, &data->n_eq, &data->n_ineq);
 }
 
 /* Count the number of equality and inequality constraints
  * that will be added to the carry_lp problem.
  * We count each edge exactly once.
+ * "intra" is the sequence of coefficient constraints for intra-node edges.
+ * "inter" is the sequence of coefficient constraints for inter-node edges.
  */
-static int count_all_constraints(struct isl_sched_graph *graph,
-	int *n_eq, int *n_ineq)
+static isl_stat count_all_constraints(__isl_keep isl_basic_set_list *intra,
+	__isl_keep isl_basic_set_list *inter, int *n_eq, int *n_ineq)
 {
-	int i, j;
-
-	*n_eq = *n_ineq = 0;
-	for (i = 0; i < graph->n_edge; ++i) {
-		struct isl_sched_edge *edge= &graph->edgei;
-		for (j = 0; j < edge->map->n; ++j) {
-			isl_basic_map *bmap;
-			isl_map *map;
+	struct isl_sched_count data;
 
-			bmap = isl_basic_map_copy(edge->map->pj);
-			map = isl_map_from_basic_map(bmap);
+	data.n_eq = data.n_ineq = 0;
+	if (isl_basic_set_list_foreach(inter, &bset_update_count, &data) < 0)
+		return isl_stat_error;
+	if (isl_basic_set_list_foreach(intra, &bset_update_count, &data) < 0)
+		return isl_stat_error;
 
-			if (count_map_constraints(graph, edge, map,
-						  n_eq, n_ineq, 1, 0) < 0)
-				    return -1;
-		}
-	}
+	*n_eq = data.n_eq;
+	*n_ineq = data.n_ineq;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Construct an LP problem for finding schedule coefficients
- * such that the schedule carries as many dependences as possible.
+ * such that the schedule carries as many validity dependences as possible.
  * In particular, for each dependence i, we bound the dependence distance
  * from below by e_i, with 0 <= e_i <= 1 and then maximize the sum
- * of all e_i's.  Dependence with e_i = 0 in the solution are simply
+ * of all e_i's.  Dependences with e_i = 0 in the solution are simply
  * respected, while those with e_i > 0 (in practice e_i = 1) are carried.
- * Note that if the dependence relation is a union of basic maps,
- * then we have to consider each basic map individually as it may only
- * be possible to carry the dependences expressed by some of those
- * basic maps and not all off them.
- * Below, we consider each of those basic maps as a separate "edge".
+ * "intra" is the sequence of coefficient constraints for intra-node edges.
+ * "inter" is the sequence of coefficient constraints for inter-node edges.
+ * "n_edge" is the total number of edges.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.  That is, if "carry_inter" is not set, then
+ * no e_i variables are introduced for the inter-node edges.
  *
  * All variables of the LP are non-negative.  The actual coefficients
  * may be negative, so each coefficient is represented as the difference
@@ -3206,158 +4392,145 @@
  * Other than that, the variables have the following order
  *
  *	- sum of (1 - e_i) over all edges
- *	- sum of positive and negative parts of all c_n coefficients
+ *	- sum of all c_n coefficients
  *		(unconstrained when computing non-parametric schedules)
  *	- sum of positive and negative parts of all c_x coefficients
  *	- for each edge
  *		- e_i
  *	- for each node
+ *		- positive and negative parts of c_i_x, in opposite order
+ *		- c_i_n (if parametric)
  *		- c_i_0
- *		- positive and negative parts of c_i_n (if parametric)
- *		- positive and negative parts of c_i_x
  *
  * The constraints are those from the (validity) edges plus three equalities
  * to express the sums and n_edge inequalities to express e_i <= 1.
  */
-static int setup_carry_lp(isl_ctx *ctx, struct isl_sched_graph *graph)
+static isl_stat setup_carry_lp(isl_ctx *ctx, struct isl_sched_graph *graph,
+	int n_edge, __isl_keep isl_basic_set_list *intra,
+	__isl_keep isl_basic_set_list *inter, int carry_inter)
 {
-	int i, j;
+	int i;
 	int k;
-	isl_space *dim;
+	isl_space *space;
 	unsigned total;
 	int n_eq, n_ineq;
-	int n_edge;
-
-	n_edge = 0;
-	for (i = 0; i < graph->n_edge; ++i)
-		n_edge += graph->edgei.map->n;
 
 	total = 3 + n_edge;
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodegraph->sortedi;
 		node->start = total;
-		total += 1 + 2 * (node->nparam + node->nvar);
+		total += 1 + node->nparam + 2 * node->nvar;
 	}
 
-	if (count_all_constraints(graph, &n_eq, &n_ineq) < 0)
-		return -1;
-	if (count_bound_coefficient_constraints(ctx, graph, &n_eq, &n_ineq) < 0)
-		return -1;
+	if (count_all_constraints(intra, inter, &n_eq, &n_ineq) < 0)
+		return isl_stat_error;
 
-	dim = isl_space_set_alloc(ctx, 0, total);
+	space = isl_space_set_alloc(ctx, 0, total);
 	isl_basic_set_free(graph->lp);
 	n_eq += 3;
 	n_ineq += n_edge;
-	graph->lp = isl_basic_set_alloc_space(dim, 0, n_eq, n_ineq);
+	graph->lp = isl_basic_set_alloc_space(space, 0, n_eq, n_ineq);
 	graph->lp = isl_basic_set_set_rational(graph->lp);
 
 	k = isl_basic_set_alloc_equality(graph->lp);
 	if (k < 0)
-		return -1;
-	isl_seq_clr(graph->lp->eqk, 1 +  total);
+		return isl_stat_error;
+	isl_seq_clr(graph->lp->eqk, 1 + total);
 	isl_int_set_si(graph->lp->eqk0, -n_edge);
 	isl_int_set_si(graph->lp->eqk1, 1);
 	for (i = 0; i < n_edge; ++i)
 		isl_int_set_si(graph->lp->eqk4 + i, 1);
 
-	k = isl_basic_set_alloc_equality(graph->lp);
-	if (k < 0)
-		return -1;
-	isl_seq_clr(graph->lp->eqk, 1 +  total);
-	isl_int_set_si(graph->lp->eqk2, -1);
-	for (i = 0; i < graph->n; ++i) {
-		int pos = 1 + graph->nodei.start + 1;
-
-		for (j = 0; j < 2 * graph->nodei.nparam; ++j)
-			isl_int_set_si(graph->lp->eqkpos + j, 1);
-	}
-
-	k = isl_basic_set_alloc_equality(graph->lp);
-	if (k < 0)
-		return -1;
-	isl_seq_clr(graph->lp->eqk, 1 +  total);
-	isl_int_set_si(graph->lp->eqk3, -1);
-	for (i = 0; i < graph->n; ++i) {
-		struct isl_sched_node *node = &graph->nodei;
-		int pos = 1 + node->start + 1 + 2 * node->nparam;
-
-		for (j = 0; j < 2 * node->nvar; ++j)
-			isl_int_set_si(graph->lp->eqkpos + j, 1);
-	}
+	if (add_param_sum_constraint(graph, 1) < 0)
+		return isl_stat_error;
+	if (add_var_sum_constraint(graph, 2) < 0)
+		return isl_stat_error;
 
 	for (i = 0; i < n_edge; ++i) {
 		k = isl_basic_set_alloc_inequality(graph->lp);
 		if (k < 0)
-			return -1;
-		isl_seq_clr(graph->lp->ineqk, 1 +  total);
+			return isl_stat_error;
+		isl_seq_clr(graph->lp->ineqk, 1 + total);
 		isl_int_set_si(graph->lp->ineqk4 + i, -1);
 		isl_int_set_si(graph->lp->ineqk0, 1);
 	}
 
-	if (add_bound_coefficient_constraints(ctx, graph) < 0)
-		return -1;
-	if (add_all_constraints(graph) < 0)
-		return -1;
+	if (add_all_constraints(ctx, graph, intra, inter, carry_inter) < 0)
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
+static __isl_give isl_schedule_node *compute_component_schedule(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int wcc);
+
 /* If the schedule_split_scaled option is set and if the linear
  * parts of the scheduling rows for all nodes in the graphs have
- * non-trivial common divisor, then split off the constant term
- * from the linear part.
- * The constant term is then placed in a separate band and
- * the linear part is reduced.
+ * a non-trivial common divisor, then remove this
+ * common divisor from the linear part.
+ * Otherwise, insert a band node directly and continue with
+ * the construction of the schedule.
+ *
+ * If a non-trivial common divisor is found, then
+ * the linear part is reduced and the remainder is ignored.
+ * The pieces of the graph that are assigned different remainders
+ * form (groups of) strongly connected components within
+ * the scaled down band.  If needed, they can therefore
+ * be ordered along this remainder in a sequence node.
+ * However, this ordering is not enforced here in order to allow
+ * the scheduler to combine some of the strongly connected components.
  */
-static int split_scaled(isl_ctx *ctx, struct isl_sched_graph *graph)
+static __isl_give isl_schedule_node *split_scaled(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
 {
 	int i;
 	int row;
+	isl_ctx *ctx;
 	isl_int gcd, gcd_i;
+	isl_size n_row;
 
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
 	if (!ctx->opt->schedule_split_scaled)
-		return 0;
+		return compute_next_band(node, graph, 0);
 	if (graph->n <= 1)
-		return 0;
-
-	if (graph->n_total_row >= graph->max_row)
-		isl_die(ctx, isl_error_internal,
-			"too many schedule rows", return -1);
+		return compute_next_band(node, graph, 0);
+	n_row = isl_mat_rows(graph->node0.sched);
+	if (n_row < 0)
+		return isl_schedule_node_free(node);
 
 	isl_int_init(gcd);
 	isl_int_init(gcd_i);
 
 	isl_int_set_si(gcd, 0);
 
-	row = isl_mat_rows(graph->node0.sched) - 1;
+	row = n_row - 1;
 
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
-		int cols = isl_mat_cols(node->sched);
+		isl_size cols = isl_mat_cols(node->sched);
 
+		if (cols < 0)
+			break;
 		isl_seq_gcd(node->sched->rowrow + 1, cols - 1, &gcd_i);
 		isl_int_gcd(gcd, gcd, gcd_i);
 	}
 
 	isl_int_clear(gcd_i);
+	if (i < graph->n)
+		goto error;
 
 	if (isl_int_cmp_si(gcd, 1) <= 0) {
 		isl_int_clear(gcd);
-		return 0;
+		return compute_next_band(node, graph, 0);
 	}
 
-	next_band(graph);
-
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
 
-		isl_map_free(node->sched_map);
-		node->sched_map = NULL;
-		node->sched = isl_mat_add_zero_rows(node->sched, 1);
-		if (!node->sched)
-			goto error;
-		isl_int_fdiv_r(node->sched->rowrow + 10,
-			       node->sched->rowrow0, gcd);
 		isl_int_fdiv_q(node->sched->rowrow0,
 			       node->sched->rowrow0, gcd);
 		isl_int_mul(node->sched->rowrow0,
@@ -3365,40 +4538,32 @@
 		node->sched = isl_mat_scale_down_row(node->sched, row, gcd);
 		if (!node->sched)
 			goto error;
-		node->bandgraph->n_total_row = graph->n_band;
 	}
 
-	graph->n_total_row++;
-
 	isl_int_clear(gcd);
-	return 0;
+
+	return compute_next_band(node, graph, 0);
 error:
 	isl_int_clear(gcd);
-	return -1;
+	return isl_schedule_node_free(node);
 }
 
-static int compute_component_schedule(isl_ctx *ctx,
-	struct isl_sched_graph *graph);
-
 /* Is the schedule row "sol" trivial on node "node"?
- * That is, is the solution zero on the dimensions orthogonal to
+ * That is, is the solution zero on the dimensions linearly independent of
  * the previously found solutions?
  * Return 1 if the solution is trivial, 0 if it is not and -1 on error.
  *
  * Each coefficient is represented as the difference between
- * two non-negative values in "sol".  "sol" has been computed
- * in terms of the original iterators (i.e., without use of cmap).
- * We construct the schedule row s and write it as a linear
- * combination of (linear combinations of) previously computed schedule rows.
- * s = Q c or c = U s.
- * If the final entries of c are all zero, then the solution is trivial.
+ * two non-negative values in "sol".
+ * We construct the schedule row s and check if it is linearly
+ * independent of previously computed schedule rows
+ * by computing T s, with T the linear combinations that are zero
+ * on linearly dependent schedule rows.
+ * If the result consists of all zeros, then the solution is trivial.
  */
 static int is_trivial(struct isl_sched_node *node, __isl_keep isl_vec *sol)
 {
-	int i;
-	int pos;
 	int trivial;
-	isl_ctx *ctx;
 	isl_vec *node_sol;
 
 	if (!sol)
@@ -3406,23 +4571,12 @@
 	if (node->nvar == node->rank)
 		return 0;
 
-	ctx = isl_vec_get_ctx(sol);
-	node_sol = isl_vec_alloc(ctx, node->nvar);
-	if (!node_sol)
-		return -1;
-
-	pos = 1 + node->start + 1 + 2 * node->nparam;
-
-	for (i = 0; i < node->nvar; ++i)
-		isl_int_sub(node_sol->eli,
-			    sol->elpos + 2 * i + 1, sol->elpos + 2 * i);
-
-	node_sol = isl_mat_vec_product(isl_mat_copy(node->cinv), node_sol);
-
+	node_sol = extract_var_coef(node, sol);
+	node_sol = isl_mat_vec_product(isl_mat_copy(node->indep), node_sol);
 	if (!node_sol)
 		return -1;
 
-	trivial = isl_seq_first_non_zero(node_sol->el + node->rank,
+	trivial = isl_seq_first_non_zero(node_sol->el,
 					node->nvar - node->rank) == -1;
 
 	isl_vec_free(node_sol);
@@ -3432,8 +4586,6 @@
 
 /* Is the schedule row "sol" trivial on any node where it should
  * not be trivial?
- * "sol" has been computed in terms of the original iterators
- * (i.e., without use of cmap).
  * Return 1 if any solution is trivial, 0 if they are not and -1 on error.
  */
 static int is_any_trivial(struct isl_sched_graph *graph,
@@ -3455,8 +4607,758 @@
 	return 0;
 }
 
-/* Construct a schedule row for each node such that as many dependences
+/* Does the schedule represented by "sol" perform loop coalescing on "node"?
+ * If so, return the position of the coalesced dimension.
+ * Otherwise, return node->nvar or -1 on error.
+ *
+ * In particular, look for pairs of coefficients c_i and c_j such that
+ * |c_j/c_i| > ceil(size_i/2), i.e., |c_j| > |c_i * ceil(size_i/2)|.
+ * If any such pair is found, then return i.
+ * If size_i is infinity, then no check on c_i needs to be performed.
+ */
+static int find_node_coalescing(struct isl_sched_node *node,
+	__isl_keep isl_vec *sol)
+{
+	int i, j;
+	isl_int max;
+	isl_vec *csol;
+
+	if (node->nvar <= 1)
+		return node->nvar;
+
+	csol = extract_var_coef(node, sol);
+	if (!csol)
+		return -1;
+	isl_int_init(max);
+	for (i = 0; i < node->nvar; ++i) {
+		isl_val *v;
+
+		if (isl_int_is_zero(csol->eli))
+			continue;
+		v = isl_multi_val_get_val(node->sizes, i);
+		if (!v)
+			goto error;
+		if (!isl_val_is_int(v)) {
+			isl_val_free(v);
+			continue;
+		}
+		v = isl_val_div_ui(v, 2);
+		v = isl_val_ceil(v);
+		if (!v)
+			goto error;
+		isl_int_mul(max, v->n, csol->eli);
+		isl_val_free(v);
+
+		for (j = 0; j < node->nvar; ++j) {
+			if (j == i)
+				continue;
+			if (isl_int_abs_gt(csol->elj, max))
+				break;
+		}
+		if (j < node->nvar)
+			break;
+	}
+
+	isl_int_clear(max);
+	isl_vec_free(csol);
+	return i;
+error:
+	isl_int_clear(max);
+	isl_vec_free(csol);
+	return -1;
+}
+
+/* Force the schedule coefficient at position "pos" of "node" to be zero
+ * in "tl".
+ * The coefficient is encoded as the difference between two non-negative
+ * variables.  Force these two variables to have the same value.
+ */
+static __isl_give isl_tab_lexmin *zero_out_node_coef(
+	__isl_take isl_tab_lexmin *tl, struct isl_sched_node *node, int pos)
+{
+	int dim;
+	isl_ctx *ctx;
+	isl_vec *eq;
+
+	ctx = isl_space_get_ctx(node->space);
+	dim = isl_tab_lexmin_dim(tl);
+	if (dim < 0)
+		return isl_tab_lexmin_free(tl);
+	eq = isl_vec_alloc(ctx, 1 + dim);
+	eq = isl_vec_clr(eq);
+	if (!eq)
+		return isl_tab_lexmin_free(tl);
+
+	pos = 1 + node_var_coef_pos(node, pos);
+	isl_int_set_si(eq->elpos, 1);
+	isl_int_set_si(eq->elpos + 1, -1);
+	tl = isl_tab_lexmin_add_eq(tl, eq->el);
+	isl_vec_free(eq);
+
+	return tl;
+}
+
+/* Return the lexicographically smallest rational point in the basic set
+ * from which "tl" was constructed, double checking that this input set
+ * was not empty.
+ */
+static __isl_give isl_vec *non_empty_solution(__isl_keep isl_tab_lexmin *tl)
+{
+	isl_vec *sol;
+
+	sol = isl_tab_lexmin_get_solution(tl);
+	if (!sol)
+		return NULL;
+	if (sol->size == 0)
+		isl_die(isl_vec_get_ctx(sol), isl_error_internal,
+			"error in schedule construction",
+			return isl_vec_free(sol));
+	return sol;
+}
+
+/* Does the solution "sol" of the LP problem constructed by setup_carry_lp
+ * carry any of the "n_edge" groups of dependences?
+ * The value in the first position is the sum of (1 - e_i) over all "n_edge"
+ * edges, with 0 <= e_i <= 1 equal to 1 when the dependences represented
+ * by the edge are carried by the solution.
+ * If the sum of the (1 - e_i) is smaller than "n_edge" then at least
+ * one of those is carried.
+ *
+ * Note that despite the fact that the problem is solved using a rational
+ * solver, the solution is guaranteed to be integral.
+ * Specifically, the dependence distance lower bounds e_i (and therefore
+ * also their sum) are integers.  See Lemma 5 of 1.
+ *
+ * Any potential denominator of the sum is cleared by this function.
+ * The denominator is not relevant for any of the other elements
+ * in the solution.
+ *
+ * 1 P. Feautrier, Some Efficient Solutions to the Affine Scheduling
+ *     Problem, Part II: Multi-Dimensional Time.
+ *     In Intl. Journal of Parallel Programming, 1992.
+ */
+static int carries_dependences(__isl_keep isl_vec *sol, int n_edge)
+{
+	isl_int_divexact(sol->el1, sol->el1, sol->el0);
+	isl_int_set_si(sol->el0, 1);
+	return isl_int_cmp_si(sol->el1, n_edge) < 0;
+}
+
+/* Return the lexicographically smallest rational point in "lp",
+ * assuming that all variables are non-negative and performing some
+ * additional sanity checks.
+ * If "want_integral" is set, then compute the lexicographically smallest
+ * integer point instead.
+ * In particular, "lp" should not be empty by construction.
+ * Double check that this is the case.
+ * If dependences are not carried for any of the "n_edge" edges,
+ * then return an empty vector.
+ *
+ * If the schedule_treat_coalescing option is set and
+ * if the computed schedule performs loop coalescing on a given node,
+ * i.e., if it is of the form
+ *
+ *	c_i i + c_j j + ...
+ *
+ * with |c_j/c_i| >= size_i, then force the coefficient c_i to be zero
+ * to cut out this solution.  Repeat this process until no more loop
+ * coalescing occurs or until no more dependences can be carried.
+ * In the latter case, revert to the previously computed solution.
+ *
+ * If the caller requests an integral solution and if coalescing should
+ * be treated, then perform the coalescing treatment first as
+ * an integral solution computed before coalescing treatment
+ * would carry the same number of edges and would therefore probably
+ * also be coalescing.
+ *
+ * To allow the coalescing treatment to be performed first,
+ * the initial solution is allowed to be rational and it is only
+ * cut out (if needed) in the next iteration, if no coalescing measures
+ * were taken.
+ */
+static __isl_give isl_vec *non_neg_lexmin(struct isl_sched_graph *graph,
+	__isl_take isl_basic_set *lp, int n_edge, int want_integral)
+{
+	int i, pos, cut;
+	isl_ctx *ctx;
+	isl_tab_lexmin *tl;
+	isl_vec *sol = NULL, *prev;
+	int treat_coalescing;
+	int try_again;
+
+	if (!lp)
+		return NULL;
+	ctx = isl_basic_set_get_ctx(lp);
+	treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
+	tl = isl_tab_lexmin_from_basic_set(lp);
+
+	cut = 0;
+	do {
+		int integral;
+
+		try_again = 0;
+		if (cut)
+			tl = isl_tab_lexmin_cut_to_integer(tl);
+		prev = sol;
+		sol = non_empty_solution(tl);
+		if (!sol)
+			goto error;
+
+		integral = isl_int_is_one(sol->el0);
+		if (!carries_dependences(sol, n_edge)) {
+			if (!prev)
+				prev = isl_vec_alloc(ctx, 0);
+			isl_vec_free(sol);
+			sol = prev;
+			break;
+		}
+		prev = isl_vec_free(prev);
+		cut = want_integral && !integral;
+		if (cut)
+			try_again = 1;
+		if (!treat_coalescing)
+			continue;
+		for (i = 0; i < graph->n; ++i) {
+			struct isl_sched_node *node = &graph->nodei;
+
+			pos = find_node_coalescing(node, sol);
+			if (pos < 0)
+				goto error;
+			if (pos < node->nvar)
+				break;
+		}
+		if (i < graph->n) {
+			try_again = 1;
+			tl = zero_out_node_coef(tl, &graph->nodei, pos);
+			cut = 0;
+		}
+	} while (try_again);
+
+	isl_tab_lexmin_free(tl);
+
+	return sol;
+error:
+	isl_tab_lexmin_free(tl);
+	isl_vec_free(prev);
+	isl_vec_free(sol);
+	return NULL;
+}
+
+/* If "edge" is an edge from a node to itself, then add the corresponding
+ * dependence relation to "umap".
+ * If "node" has been compressed, then the dependence relation
+ * is also compressed first.
+ */
+static __isl_give isl_union_map *add_intra(__isl_take isl_union_map *umap,
+	struct isl_sched_edge *edge)
+{
+	isl_map *map;
+	struct isl_sched_node *node = edge->src;
+
+	if (edge->src != edge->dst)
+		return umap;
+
+	map = isl_map_copy(edge->map);
+	map = compress(map, node, node);
+	umap = isl_union_map_add_map(umap, map);
+	return umap;
+}
+
+/* If "edge" is an edge from a node to another node, then add the corresponding
+ * dependence relation to "umap".
+ * If the source or destination nodes of "edge" have been compressed,
+ * then the dependence relation is also compressed first.
+ */
+static __isl_give isl_union_map *add_inter(__isl_take isl_union_map *umap,
+	struct isl_sched_edge *edge)
+{
+	isl_map *map;
+
+	if (edge->src == edge->dst)
+		return umap;
+
+	map = isl_map_copy(edge->map);
+	map = compress(map, edge->src, edge->dst);
+	umap = isl_union_map_add_map(umap, map);
+	return umap;
+}
+
+/* Internal data structure used by union_drop_coalescing_constraints
+ * to collect bounds on all relevant statements.
+ *
+ * "graph" is the schedule constraint graph for which an LP problem
+ * is being constructed.
+ * "bounds" collects the bounds.
+ */
+struct isl_collect_bounds_data {
+	isl_ctx *ctx;
+	struct isl_sched_graph *graph;
+	isl_union_set *bounds;
+};
+
+/* Add the size bounds for the node with instance deltas in "set"
+ * to data->bounds.
+ */
+static isl_stat collect_bounds(__isl_take isl_set *set, void *user)
+{
+	struct isl_collect_bounds_data *data = user;
+	struct isl_sched_node *node;
+	isl_space *space;
+	isl_set *bounds;
+
+	space = isl_set_get_space(set);
+	isl_set_free(set);
+
+	node = graph_find_compressed_node(data->ctx, data->graph, space);
+	isl_space_free(space);
+
+	bounds = isl_set_from_basic_set(get_size_bounds(node));
+	data->bounds = isl_union_set_add_set(data->bounds, bounds);
+
+	return isl_stat_ok;
+}
+
+/* Drop some constraints from "delta" that could be exploited
+ * to construct loop coalescing schedules.
+ * In particular, drop those constraint that bound the difference
+ * to the size of the domain.
+ * Do this for each set/node in "delta" separately.
+ * The parameters are assumed to have been projected out by the caller.
+ */
+static __isl_give isl_union_set *union_drop_coalescing_constraints(isl_ctx *ctx,
+	struct isl_sched_graph *graph, __isl_take isl_union_set *delta)
+{
+	struct isl_collect_bounds_data data = { ctx, graph };
+
+	data.bounds = isl_union_set_empty(isl_space_params_alloc(ctx, 0));
+	if (isl_union_set_foreach_set(delta, &collect_bounds, &data) < 0)
+		data.bounds = isl_union_set_free(data.bounds);
+	delta = isl_union_set_plain_gist(delta, data.bounds);
+
+	return delta;
+}
+
+/* Given a non-trivial lineality space "lineality", add the corresponding
+ * universe set to data->mask and add a map from elements to
+ * other elements along the lines in "lineality" to data->equivalent.
+ * If this is the first time this function gets called
+ * (data->any_non_trivial is still false), then set data->any_non_trivial and
+ * initialize data->mask and data->equivalent.
+ *
+ * In particular, if the lineality space is defined by equality constraints
+ *
+ *	E x = 0
+ *
+ * then construct an affine mapping
+ *
+ *	f : x -> E x
+ *
+ * and compute the equivalence relation of having the same image under f:
+ *
+ *	{ x -> x' : E x = E x' }
+ */
+static isl_stat add_non_trivial_lineality(__isl_take isl_basic_set *lineality,
+	struct isl_exploit_lineality_data *data)
+{
+	isl_mat *eq;
+	isl_space *space;
+	isl_set *univ;
+	isl_multi_aff *ma;
+	isl_multi_pw_aff *mpa;
+	isl_map *map;
+	isl_size n;
+
+	if (isl_basic_set_check_no_locals(lineality) < 0)
+		goto error;
+
+	space = isl_basic_set_get_space(lineality);
+	if (!data->any_non_trivial) {
+		data->equivalent = isl_union_map_empty(isl_space_copy(space));
+		data->mask = isl_union_set_empty(isl_space_copy(space));
+	}
+	data->any_non_trivial = isl_bool_true;
+
+	univ = isl_set_universe(isl_space_copy(space));
+	data->mask = isl_union_set_add_set(data->mask, univ);
+
+	eq = isl_basic_set_extract_equalities(lineality);
+	n = isl_mat_rows(eq);
+	if (n < 0)
+		space = isl_space_free(space);
+	eq = isl_mat_insert_zero_rows(eq, 0, 1);
+	eq = isl_mat_set_element_si(eq, 0, 0, 1);
+	space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, n);
+	ma = isl_multi_aff_from_aff_mat(space, eq);
+	mpa = isl_multi_pw_aff_from_multi_aff(ma);
+	map = isl_multi_pw_aff_eq_map(mpa, isl_multi_pw_aff_copy(mpa));
+	data->equivalent = isl_union_map_add_map(data->equivalent, map);
+
+	isl_basic_set_free(lineality);
+	return isl_stat_ok;
+error:
+	isl_basic_set_free(lineality);
+	return isl_stat_error;
+}
+
+/* Check if the lineality space "set" is non-trivial (i.e., is not just
+ * the origin or, in other words, satisfies a number of equality constraints
+ * that is smaller than the dimension of the set).
+ * If so, extend data->mask and data->equivalent accordingly.
+ *
+ * The input should not have any local variables already, but
+ * isl_set_remove_divs is called to make sure it does not.
+ */
+static isl_stat add_lineality(__isl_take isl_set *set, void *user)
+{
+	struct isl_exploit_lineality_data *data = user;
+	isl_basic_set *hull;
+	isl_size dim;
+	isl_size n_eq;
+
+	set = isl_set_remove_divs(set);
+	hull = isl_set_unshifted_simple_hull(set);
+	dim = isl_basic_set_dim(hull, isl_dim_set);
+	n_eq = isl_basic_set_n_equality(hull);
+	if (dim < 0 || n_eq < 0)
+		goto error;
+	if (dim != n_eq)
+		return add_non_trivial_lineality(hull, data);
+	isl_basic_set_free(hull);
+	return isl_stat_ok;
+error:
+	isl_basic_set_free(hull);
+	return isl_stat_error;
+}
+
+/* Check if the difference set on intra-node schedule constraints "intra"
+ * has any non-trivial lineality space.
+ * If so, then extend the difference set to a difference set
+ * on equivalent elements.  That is, if "intra" is
+ *
+ *	{ y - x : (x,y) \in V }
+ *
+ * and elements are equivalent if they have the same image under f,
+ * then return
+ *
+ *	{ y' - x' : (x,y) \in V and f(x) = f(x') and f(y) = f(y') }
+ *
+ * or, since f is linear,
+ *
+ *	{ y' - x' : (x,y) \in V and f(y - x) = f(y' - x') }
+ *
+ * The results of the search for non-trivial lineality spaces is stored
+ * in "data".
+ */
+static __isl_give isl_union_set *exploit_intra_lineality(
+	__isl_take isl_union_set *intra,
+	struct isl_exploit_lineality_data *data)
+{
+	isl_union_set *lineality;
+	isl_union_set *uset;
+
+	data->any_non_trivial = isl_bool_false;
+	lineality = isl_union_set_copy(intra);
+	lineality = isl_union_set_combined_lineality_space(lineality);
+	if (isl_union_set_foreach_set(lineality, &add_lineality, data) < 0)
+		data->any_non_trivial = isl_bool_error;
+	isl_union_set_free(lineality);
+
+	if (data->any_non_trivial < 0)
+		return isl_union_set_free(intra);
+	if (!data->any_non_trivial)
+		return intra;
+
+	uset = isl_union_set_copy(intra);
+	intra = isl_union_set_subtract(intra, isl_union_set_copy(data->mask));
+	uset = isl_union_set_apply(uset, isl_union_map_copy(data->equivalent));
+	intra = isl_union_set_union(intra, uset);
+
+	intra = isl_union_set_remove_divs(intra);
+
+	return intra;
+}
+
+/* If the difference set on intra-node schedule constraints was found to have
+ * any non-trivial lineality space by exploit_intra_lineality,
+ * as recorded in "data", then extend the inter-node
+ * schedule constraints "inter" to schedule constraints on equivalent elements.
+ * That is, if "inter" is V and
+ * elements are equivalent if they have the same image under f, then return
+ *
+ *	{ (x', y') : (x,y) \in V and f(x) = f(x') and f(y) = f(y') }
+ */
+static __isl_give isl_union_map *exploit_inter_lineality(
+	__isl_take isl_union_map *inter,
+	struct isl_exploit_lineality_data *data)
+{
+	isl_union_map *umap;
+
+	if (data->any_non_trivial < 0)
+		return isl_union_map_free(inter);
+	if (!data->any_non_trivial)
+		return inter;
+
+	umap = isl_union_map_copy(inter);
+	inter = isl_union_map_subtract_range(inter,
+				isl_union_set_copy(data->mask));
+	umap = isl_union_map_apply_range(umap,
+				isl_union_map_copy(data->equivalent));
+	inter = isl_union_map_union(inter, umap);
+	umap = isl_union_map_copy(inter);
+	inter = isl_union_map_subtract_domain(inter,
+				isl_union_set_copy(data->mask));
+	umap = isl_union_map_apply_range(isl_union_map_copy(data->equivalent),
+				umap);
+	inter = isl_union_map_union(inter, umap);
+
+	inter = isl_union_map_remove_divs(inter);
+
+	return inter;
+}
+
+/* For each (conditional) validity edge in "graph",
+ * add the corresponding dependence relation using "add"
+ * to a collection of dependence relations and return the result.
+ * If "coincidence" is set, then coincidence edges are considered as well.
+ */
+static __isl_give isl_union_map *collect_validity(struct isl_sched_graph *graph,
+	__isl_give isl_union_map *(*add)(__isl_take isl_union_map *umap,
+		struct isl_sched_edge *edge), int coincidence)
+{
+	int i;
+	isl_space *space;
+	isl_union_map *umap;
+
+	space = isl_space_copy(graph->node0.space);
+	umap = isl_union_map_empty(space);
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+
+		if (!is_any_validity(edge) &&
+		    (!coincidence || !is_coincidence(edge)))
+			continue;
+
+		umap = add(umap, edge);
+	}
+
+	return umap;
+}
+
+/* For each dependence relation on a (conditional) validity edge
+ * from a node to itself,
+ * construct the set of coefficients of valid constraints for elements
+ * in that dependence relation and collect the results.
+ * If "coincidence" is set, then coincidence edges are considered as well.
+ *
+ * In particular, for each dependence relation R, constraints
+ * on coefficients (c_0, c_x) are constructed such that
+ *
+ *	c_0 + c_x d >= 0 for each d in delta R = { y - x | (x,y) in R }
+ *
+ * If the schedule_treat_coalescing option is set, then some constraints
+ * that could be exploited to construct coalescing schedules
+ * are removed before the dual is computed, but after the parameters
+ * have been projected out.
+ * The entire computation is essentially the same as that performed
+ * by intra_coefficients, except that it operates on multiple
+ * edges together and that the parameters are always projected out.
+ *
+ * Additionally, exploit any non-trivial lineality space
+ * in the difference set after removing coalescing constraints and
+ * store the results of the non-trivial lineality space detection in "data".
+ * The procedure is currently run unconditionally, but it is unlikely
+ * to find any non-trivial lineality spaces if no coalescing constraints
+ * have been removed.
+ *
+ * Note that if a dependence relation is a union of basic maps,
+ * then each basic map needs to be treated individually as it may only
+ * be possible to carry the dependences expressed by some of those
+ * basic maps and not all of them.
+ * The collected validity constraints are therefore not coalesced and
+ * it is assumed that they are not coalesced automatically.
+ * Duplicate basic maps can be removed, however.
+ * In particular, if the same basic map appears as a disjunct
+ * in multiple edges, then it only needs to be carried once.
+ */
+static __isl_give isl_basic_set_list *collect_intra_validity(isl_ctx *ctx,
+	struct isl_sched_graph *graph, int coincidence,
+	struct isl_exploit_lineality_data *data)
+{
+	isl_union_map *intra;
+	isl_union_set *delta;
+	isl_basic_set_list *list;
+
+	intra = collect_validity(graph, &add_intra, coincidence);
+	delta = isl_union_map_deltas(intra);
+	delta = isl_union_set_project_out_all_params(delta);
+	delta = isl_union_set_remove_divs(delta);
+	if (isl_options_get_schedule_treat_coalescing(ctx))
+		delta = union_drop_coalescing_constraints(ctx, graph, delta);
+	delta = exploit_intra_lineality(delta, data);
+	list = isl_union_set_get_basic_set_list(delta);
+	isl_union_set_free(delta);
+
+	return isl_basic_set_list_coefficients(list);
+}
+
+/* For each dependence relation on a (conditional) validity edge
+ * from a node to some other node,
+ * construct the set of coefficients of valid constraints for elements
+ * in that dependence relation and collect the results.
+ * If "coincidence" is set, then coincidence edges are considered as well.
+ *
+ * In particular, for each dependence relation R, constraints
+ * on coefficients (c_0, c_n, c_x, c_y) are constructed such that
+ *
+ *	c_0 + c_n n + c_x x + c_y y >= 0 for each (x,y) in R
+ *
+ * This computation is essentially the same as that performed
+ * by inter_coefficients, except that it operates on multiple
+ * edges together.
+ *
+ * Additionally, exploit any non-trivial lineality space
+ * that may have been discovered by collect_intra_validity
+ * (as stored in "data").
+ *
+ * Note that if a dependence relation is a union of basic maps,
+ * then each basic map needs to be treated individually as it may only
+ * be possible to carry the dependences expressed by some of those
+ * basic maps and not all of them.
+ * The collected validity constraints are therefore not coalesced and
+ * it is assumed that they are not coalesced automatically.
+ * Duplicate basic maps can be removed, however.
+ * In particular, if the same basic map appears as a disjunct
+ * in multiple edges, then it only needs to be carried once.
+ */
+static __isl_give isl_basic_set_list *collect_inter_validity(
+	struct isl_sched_graph *graph, int coincidence,
+	struct isl_exploit_lineality_data *data)
+{
+	isl_union_map *inter;
+	isl_union_set *wrap;
+	isl_basic_set_list *list;
+
+	inter = collect_validity(graph, &add_inter, coincidence);
+	inter = exploit_inter_lineality(inter, data);
+	inter = isl_union_map_remove_divs(inter);
+	wrap = isl_union_map_wrap(inter);
+	list = isl_union_set_get_basic_set_list(wrap);
+	isl_union_set_free(wrap);
+	return isl_basic_set_list_coefficients(list);
+}
+
+/* Construct an LP problem for finding schedule coefficients
+ * such that the schedule carries as many of the "n_edge" groups of
+ * dependences as possible based on the corresponding coefficient
+ * constraints and return the lexicographically smallest non-trivial solution.
+ * "intra" is the sequence of coefficient constraints for intra-node edges.
+ * "inter" is the sequence of coefficient constraints for inter-node edges.
+ * If "want_integral" is set, then compute an integral solution
+ * for the coefficients rather than using the numerators
+ * of a rational solution.
+ * "carry_inter" indicates whether inter-node edges should be carried or
+ * only respected.
+ *
+ * If none of the "n_edge" groups can be carried
+ * then return an empty vector.
+ */
+static __isl_give isl_vec *compute_carrying_sol_coef(isl_ctx *ctx,
+	struct isl_sched_graph *graph, int n_edge,
+	__isl_keep isl_basic_set_list *intra,
+	__isl_keep isl_basic_set_list *inter, int want_integral,
+	int carry_inter)
+{
+	isl_basic_set *lp;
+
+	if (setup_carry_lp(ctx, graph, n_edge, intra, inter, carry_inter) < 0)
+		return NULL;
+
+	lp = isl_basic_set_copy(graph->lp);
+	return non_neg_lexmin(graph, lp, n_edge, want_integral);
+}
+
+/* Construct an LP problem for finding schedule coefficients
+ * such that the schedule carries as many of the validity dependences
+ * as possible and
+ * return the lexicographically smallest non-trivial solution.
+ * If "fallback" is set, then the carrying is performed as a fallback
+ * for the Pluto-like scheduler.
+ * If "coincidence" is set, then try and carry coincidence edges as well.
+ *
+ * The variable "n_edge" stores the number of groups that should be carried.
+ * If none of the "n_edge" groups can be carried
+ * then return an empty vector.
+ * If, moreover, "n_edge" is zero, then the LP problem does not even
+ * need to be constructed.
+ *
+ * If a fallback solution is being computed, then compute an integral solution
+ * for the coefficients rather than using the numerators
+ * of a rational solution.
+ *
+ * If a fallback solution is being computed, if there are any intra-node
+ * dependences, and if requested by the user, then first try
+ * to only carry those intra-node dependences.
+ * If this fails to carry any dependences, then try again
+ * with the inter-node dependences included.
+ */
+static __isl_give isl_vec *compute_carrying_sol(isl_ctx *ctx,
+	struct isl_sched_graph *graph, int fallback, int coincidence)
+{
+	isl_size n_intra, n_inter;
+	int n_edge;
+	struct isl_carry carry = { 0 };
+	isl_vec *sol;
+
+	carry.intra = collect_intra_validity(ctx, graph, coincidence,
+						&carry.lineality);
+	carry.inter = collect_inter_validity(graph, coincidence,
+						&carry.lineality);
+	n_intra = isl_basic_set_list_n_basic_set(carry.intra);
+	n_inter = isl_basic_set_list_n_basic_set(carry.inter);
+	if (n_intra < 0 || n_inter < 0)
+		goto error;
+
+	if (fallback && n_intra > 0 &&
+	    isl_options_get_schedule_carry_self_first(ctx)) {
+		sol = compute_carrying_sol_coef(ctx, graph, n_intra,
+				carry.intra, carry.inter, fallback, 0);
+		if (!sol || sol->size != 0 || n_inter == 0) {
+			isl_carry_clear(&carry);
+			return sol;
+		}
+		isl_vec_free(sol);
+	}
+
+	n_edge = n_intra + n_inter;
+	if (n_edge == 0) {
+		isl_carry_clear(&carry);
+		return isl_vec_alloc(ctx, 0);
+	}
+
+	sol = compute_carrying_sol_coef(ctx, graph, n_edge,
+				carry.intra, carry.inter, fallback, 1);
+	isl_carry_clear(&carry);
+	return sol;
+error:
+	isl_carry_clear(&carry);
+	return NULL;
+}
+
+/* Construct a schedule row for each node such that as many validity dependences
  * as possible are carried and then continue with the next band.
+ * If "fallback" is set, then the carrying is performed as a fallback
+ * for the Pluto-like scheduler.
+ * If "coincidence" is set, then try and carry coincidence edges as well.
+ *
+ * If there are no validity dependences, then no dependence can be carried and
+ * the procedure is guaranteed to fail.  If there is more than one component,
+ * then try computing a schedule on each component separately
+ * to prevent or at least postpone this failure.
+ *
+ * If a schedule row is computed, then check that dependences are carried
+ * for at least one of the edges.
  *
  * If the computed schedule row turns out to be trivial on one or
  * more nodes where it should not be trivial, then we throw it away
@@ -3469,38 +5371,32 @@
  * graph->maxvar is computed based on these ranks.  The test for
  * whether more schedule rows are required in compute_schedule_wcc
  * is therefore not affected.
+ *
+ * Insert a band corresponding to the schedule row at position "node"
+ * of the schedule tree and continue with the construction of the schedule.
+ * This insertion and the continued construction is performed by split_scaled
+ * after optionally checking for non-trivial common divisors.
  */
-static int carry_dependences(isl_ctx *ctx, struct isl_sched_graph *graph)
+static __isl_give isl_schedule_node *carry(__isl_take isl_schedule_node *node,
+	struct isl_sched_graph *graph, int fallback, int coincidence)
 {
-	int i;
-	int n_edge;
 	int trivial;
+	isl_ctx *ctx;
 	isl_vec *sol;
-	isl_basic_set *lp;
 
-	n_edge = 0;
-	for (i = 0; i < graph->n_edge; ++i)
-		n_edge += graph->edgei.map->n;
-
-	if (setup_carry_lp(ctx, graph) < 0)
-		return -1;
+	if (!node)
+		return NULL;
 
-	lp = isl_basic_set_copy(graph->lp);
-	sol = isl_tab_basic_set_non_neg_lexmin(lp);
+	ctx = isl_schedule_node_get_ctx(node);
+	sol = compute_carrying_sol(ctx, graph, fallback, coincidence);
 	if (!sol)
-		return -1;
-
+		return isl_schedule_node_free(node);
 	if (sol->size == 0) {
 		isl_vec_free(sol);
-		isl_die(ctx, isl_error_internal,
-			"error in schedule construction", return -1);
-	}
-
-	isl_int_divexact(sol->el1, sol->el1, sol->el0);
-	if (isl_int_cmp_si(sol->el1, n_edge) >= 0) {
-		isl_vec_free(sol);
-		isl_die(ctx, isl_error_unknown,
-			"unable to carry dependences", return -1);
+		if (graph->scc > 1)
+			return compute_component_schedule(node, graph, 1);
+		isl_die(ctx, isl_error_unknown, "unable to carry dependences",
+			return isl_schedule_node_free(node));
 	}
 
 	trivial = is_any_trivial(graph, sol);
@@ -3508,18 +5404,112 @@
 		sol = isl_vec_free(sol);
 	} else if (trivial && graph->scc > 1) {
 		isl_vec_free(sol);
-		return compute_component_schedule(ctx, graph);
+		return compute_component_schedule(node, graph, 1);
 	}
 
-	if (update_schedule(graph, sol, 0, 0) < 0)
-		return -1;
+	if (update_schedule(graph, sol, 0) < 0)
+		return isl_schedule_node_free(node);
 	if (trivial)
 		graph->n_row--;
 
-	if (split_scaled(ctx, graph) < 0)
-		return -1;
+	return split_scaled(node, graph);
+}
+
+/* Construct a schedule row for each node such that as many validity dependences
+ * as possible are carried and then continue with the next band.
+ * Do so as a fallback for the Pluto-like scheduler.
+ * If "coincidence" is set, then try and carry coincidence edges as well.
+ */
+static __isl_give isl_schedule_node *carry_fallback(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int coincidence)
+{
+	return carry(node, graph, 1, coincidence);
+}
+
+/* Construct a schedule row for each node such that as many validity dependences
+ * as possible are carried and then continue with the next band.
+ * Do so for the case where the Feautrier scheduler was selected
+ * by the user.
+ */
+static __isl_give isl_schedule_node *carry_feautrier(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	return carry(node, graph, 0, 0);
+}
+
+/* Construct a schedule row for each node such that as many validity dependences
+ * as possible are carried and then continue with the next band.
+ * Do so as a fallback for the Pluto-like scheduler.
+ */
+static __isl_give isl_schedule_node *carry_dependences(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	return carry_fallback(node, graph, 0);
+}
+
+/* Construct a schedule row for each node such that as many validity or
+ * coincidence dependences as possible are carried and
+ * then continue with the next band.
+ * Do so as a fallback for the Pluto-like scheduler.
+ */
+static __isl_give isl_schedule_node *carry_coincidence(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	return carry_fallback(node, graph, 1);
+}
 
-	return compute_next_band(ctx, graph);
+/* Topologically sort statements mapped to the same schedule iteration
+ * and add insert a sequence node in front of "node"
+ * corresponding to this order.
+ * If "initialized" is set, then it may be assumed that compute_maxvar
+ * has been called on the current band.  Otherwise, call
+ * compute_maxvar if and before carry_dependences gets called.
+ *
+ * If it turns out to be impossible to sort the statements apart,
+ * because different dependences impose different orderings
+ * on the statements, then we extend the schedule such that
+ * it carries at least one more dependence.
+ */
+static __isl_give isl_schedule_node *sort_statements(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int initialized)
+{
+	isl_ctx *ctx;
+	isl_union_set_list *filters;
+
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	if (graph->n < 1)
+		isl_die(ctx, isl_error_internal,
+			"graph should have at least one node",
+			return isl_schedule_node_free(node));
+
+	if (graph->n == 1)
+		return node;
+
+	if (update_edges(ctx, graph) < 0)
+		return isl_schedule_node_free(node);
+
+	if (graph->n_edge == 0)
+		return node;
+
+	if (detect_sccs(ctx, graph) < 0)
+		return isl_schedule_node_free(node);
+
+	next_band(graph);
+	if (graph->scc < graph->n) {
+		if (!initialized && compute_maxvar(graph) < 0)
+			return isl_schedule_node_free(node);
+		return carry_dependences(node, graph);
+	}
+
+	filters = extract_sccs(ctx, graph);
+	node = isl_schedule_node_insert_sequence(node, filters);
+
+	return node;
 }
 
 /* Are there any (non-empty) (conditional) validity edges in the graph?
@@ -3536,8 +5526,7 @@
 			return -1;
 		if (empty)
 			continue;
-		if (graph->edgei.validity ||
-		    graph->edgei.conditional_validity)
+		if (is_any_validity(&graph->edgei))
 			return 1;
 	}
 
@@ -3557,7 +5546,8 @@
 }
 
 /* Compute a schedule for a connected dependence graph using Feautrier's
- * multi-dimensional scheduling algorithm.
+ * multi-dimensional scheduling algorithm and return the updated schedule node.
+ *
  * The original algorithm is described in 1.
  * The main idea is to minimize the number of scheduling dimensions, by
  * trying to satisfy as many dependences as possible per scheduling dimension.
@@ -3566,10 +5556,10 @@
  *     Problem, Part II: Multi-Dimensional Time.
  *     In Intl. Journal of Parallel Programming, 1992.
  */
-static int compute_schedule_wcc_feautrier(isl_ctx *ctx,
-	struct isl_sched_graph *graph)
+static __isl_give isl_schedule_node *compute_schedule_wcc_feautrier(
+	isl_schedule_node *node, struct isl_sched_graph *graph)
 {
-	return carry_dependences(ctx, graph);
+	return carry_feautrier(node, graph);
 }
 
 /* Turn off the "local" bit on all (condition) edges.
@@ -3579,8 +5569,8 @@
 	int i;
 
 	for (i = 0; i < graph->n_edge; ++i)
-		if (graph->edgei.condition)
-			graph->edgei.local = 0;
+		if (is_condition(&graph->edgei))
+			clear_local(&graph->edgei);
 }
 
 /* Does "graph" have both condition and conditional validity edges?
@@ -3592,9 +5582,9 @@
 	int any_conditional_validity = 0;
 
 	for (i = 0; i < graph->n_edge; ++i) {
-		if (graph->edgei.condition)
+		if (is_condition(&graph->edgei))
 			any_condition = 1;
-		if (graph->edgei.conditional_validity)
+		if (is_conditional_validity(&graph->edgei))
 			any_conditional_validity = 1;
 	}
 
@@ -3608,7 +5598,7 @@
 	int i;
 
 	for (i = 0; i < graph->n_edge; ++i)
-		if (graph->edgei.coincidence)
+		if (is_coincidence(&graph->edgei))
 			return 1;
 
 	return 0;
@@ -3619,14 +5609,14 @@
  */
 static __isl_give isl_map *final_row(struct isl_sched_node *node)
 {
-	isl_local_space *ls;
-	isl_aff *aff;
-	int row;
+	isl_multi_aff *ma;
+	isl_size n_row;
 
-	row = isl_mat_rows(node->sched) - 1;
-	ls = isl_local_space_from_space(isl_space_copy(node->space));
-	aff = extract_schedule_row(ls, node, row);
-	return isl_map_from_aff(aff);
+	n_row = isl_mat_rows(node->sched);
+	if (n_row < 0)
+		return NULL;
+	ma = node_extract_partial_schedule_multi_aff(node, n_row - 1, 1);
+	return isl_map_from_multi_aff(ma);
 }
 
 /* Is the conditional validity dependence in the edge with index "edge_index"
@@ -3655,68 +5645,6 @@
 	return !empty;
 }
 
-/* Does the domain of "umap" intersect "uset"?
- */
-static int domain_intersects(__isl_keep isl_union_map *umap,
-	__isl_keep isl_union_set *uset)
-{
-	int empty;
-
-	umap = isl_union_map_copy(umap);
-	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(uset));
-	empty = isl_union_map_is_empty(umap);
-	isl_union_map_free(umap);
-
-	return empty < 0 ? -1 : !empty;
-}
-
-/* Does the range of "umap" intersect "uset"?
- */
-static int range_intersects(__isl_keep isl_union_map *umap,
-	__isl_keep isl_union_set *uset)
-{
-	int empty;
-
-	umap = isl_union_map_copy(umap);
-	umap = isl_union_map_intersect_range(umap, isl_union_set_copy(uset));
-	empty = isl_union_map_is_empty(umap);
-	isl_union_map_free(umap);
-
-	return empty < 0 ? -1 : !empty;
-}
-
-/* Are the condition dependences of "edge" local with respect to
- * the current schedule?
- *
- * That is, are domain and range of the condition dependences mapped
- * to the same point?
- *
- * In other words, is the condition false?
- */
-static int is_condition_false(struct isl_sched_edge *edge)
-{
-	isl_union_map *umap;
-	isl_map *map, *sched, *test;
-	int local;
-
-	umap = isl_union_map_copy(edge->tagged_condition);
-	umap = isl_union_map_zip(umap);
-	umap = isl_union_set_unwrap(isl_union_map_domain(umap));
-	map = isl_map_from_union_map(umap);
-
-	sched = node_extract_schedule(edge->src);
-	map = isl_map_apply_domain(map, sched);
-	sched = node_extract_schedule(edge->dst);
-	map = isl_map_apply_range(map, sched);
-
-	test = isl_map_identity(isl_map_get_space(map));
-	local = isl_map_is_subset(map, test);
-	isl_map_free(map);
-	isl_map_free(test);
-
-	return local;
-}
-
 /* Does "graph" have any satisfied condition edges that
  * are adjacent to the conditional validity constraint with
  * domain "conditional_source" and range "conditional_sink"?
@@ -3738,9 +5666,9 @@
 		int adjacent, local;
 		isl_union_map *condition;
 
-		if (!graph->edgei.condition)
+		if (!is_condition(&graph->edgei))
 			continue;
-		if (graph->edgei.local)
+		if (is_local(&graph->edgei))
 			continue;
 
 		condition = graph->edgei.tagged_condition;
@@ -3753,7 +5681,7 @@
 		if (!adjacent)
 			continue;
 
-		graph->edgei.local = 1;
+		set_local(&graph->edgei);
 
 		local = is_condition_false(&graph->edgei);
 		if (local < 0)
@@ -3793,7 +5721,7 @@
 		isl_union_map *umap;
 		int violated;
 
-		if (!graph->edgei.conditional_validity)
+		if (!is_conditional_validity(&graph->edgei))
 			continue;
 
 		violated = is_violated(graph, i);
@@ -3827,25 +5755,82 @@
 	return -1;
 }
 
-/* Compute a schedule for a connected dependence graph.
- * We try to find a sequence of as many schedule rows as possible that result
- * in non-negative dependence distances (independent of the previous rows
- * in the sequence, i.e., such that the sequence is tilable), with as
- * many of the initial rows as possible satisfying the coincidence constraints.
- * If we can't find any more rows we either
+/* Examine the current band (the rows between graph->band_start and
+ * graph->n_total_row), deciding whether to drop it or add it to "node"
+ * and then continue with the computation of the next band, if any.
+ * If "initialized" is set, then it may be assumed that compute_maxvar
+ * has been called on the current band.  Otherwise, call
+ * compute_maxvar if and before carry_dependences gets called.
+ *
+ * The caller keeps looking for a new row as long as
+ * graph->n_row < graph->maxvar.  If the latest attempt to find
+ * such a row failed (i.e., we still have graph->n_row < graph->maxvar),
+ * then we either
  * - split between SCCs and start over (assuming we found an interesting
  *	pair of SCCs between which to split)
  * - continue with the next band (assuming the current band has at least
  *	one row)
- * - try to carry as many dependences as possible and continue with the next
- *	band
- *
- * If Feautrier's algorithm is selected, we first recursively try to satisfy
- * as many validity dependences as possible. When all validity dependences
- * are satisfied we extend the schedule to a full-dimensional schedule.
+ * - if there is more than one SCC left, then split along all SCCs
+ * - if outer coincidence needs to be enforced, then try to carry as many
+ *	validity or coincidence dependences as possible and
+ *	continue with the next band
+ * - try to carry as many validity dependences as possible and
+ *	continue with the next band
+ * In each case, we first insert a band node in the schedule tree
+ * if any rows have been computed.
  *
- * If we manage to complete the schedule, we finish off by topologically
+ * If the caller managed to complete the schedule and the current band
+ * is empty, then finish off by topologically
  * sorting the statements based on the remaining dependences.
+ * If, on the other hand, the current band has at least one row,
+ * then continue with the next band.  Note that this next band
+ * will necessarily be empty, but the graph may still be split up
+ * into weakly connected components before arriving back here.
+ */
+static __isl_give isl_schedule_node *compute_schedule_finish_band(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int initialized)
+{
+	int empty;
+
+	if (!node)
+		return NULL;
+
+	empty = graph->n_total_row == graph->band_start;
+	if (graph->n_row < graph->maxvar) {
+		isl_ctx *ctx;
+
+		ctx = isl_schedule_node_get_ctx(node);
+		if (!ctx->opt->schedule_maximize_band_depth && !empty)
+			return compute_next_band(node, graph, 1);
+		if (graph->src_scc >= 0)
+			return compute_split_schedule(node, graph);
+		if (!empty)
+			return compute_next_band(node, graph, 1);
+		if (graph->scc > 1)
+			return compute_component_schedule(node, graph, 1);
+		if (!initialized && compute_maxvar(graph) < 0)
+			return isl_schedule_node_free(node);
+		if (isl_options_get_schedule_outer_coincidence(ctx))
+			return carry_coincidence(node, graph);
+		return carry_dependences(node, graph);
+	}
+
+	if (!empty)
+		return compute_next_band(node, graph, 1);
+	return sort_statements(node, graph, initialized);
+}
+
+/* Construct a band of schedule rows for a connected dependence graph.
+ * The caller is responsible for determining the strongly connected
+ * components and calling compute_maxvar first.
+ *
+ * We try to find a sequence of as many schedule rows as possible that result
+ * in non-negative dependence distances (independent of the previous rows
+ * in the sequence, i.e., such that the sequence is tilable), with as
+ * many of the initial rows as possible satisfying the coincidence constraints.
+ * The computation stops if we can't find any more rows or if we have found
+ * all the rows we wanted to find.
  *
  * If ctx->opt->schedule_outer_coincidence is set, then we force the
  * outermost dimension to satisfy the coincidence constraints.  If this
@@ -3868,23 +5853,16 @@
  * Since there are only a finite number of dependences,
  * there will only be a finite number of iterations.
  */
-static int compute_schedule_wcc(isl_ctx *ctx, struct isl_sched_graph *graph)
+static isl_stat compute_schedule_wcc_band(isl_ctx *ctx,
+	struct isl_sched_graph *graph)
 {
 	int has_coincidence;
 	int use_coincidence;
 	int force_coincidence = 0;
 	int check_conditional;
 
-	if (detect_sccs(ctx, graph) < 0)
-		return -1;
 	if (sort_sccs(graph) < 0)
-		return -1;
-
-	if (compute_maxvar(graph) < 0)
-		return -1;
-
-	if (need_feautrier_step(ctx, graph))
-		return compute_schedule_wcc_feautrier(ctx, graph);
+		return isl_stat_error;
 
 	clear_local_edges(graph);
 	check_conditional = need_condition_check(graph);
@@ -3903,10 +5881,10 @@
 		graph->dst_scc = -1;
 
 		if (setup_lp(ctx, graph, use_coincidence) < 0)
-			return -1;
-		sol = solve_lp(graph);
+			return isl_stat_error;
+		sol = solve_lp(ctx, graph);
 		if (!sol)
-			return -1;
+			return isl_stat_error;
 		if (sol->size == 0) {
 			int empty = graph->n_total_row == graph->band_start;
 
@@ -3915,145 +5893,1701 @@
 				use_coincidence = 0;
 				continue;
 			}
-			if (!ctx->opt->schedule_maximize_band_depth && !empty)
-				return compute_next_band(ctx, graph);
-			if (graph->src_scc >= 0)
-				return compute_split_schedule(ctx, graph);
-			if (!empty)
-				return compute_next_band(ctx, graph);
-			return carry_dependences(ctx, graph);
+			return isl_stat_ok;
 		}
 		coincident = !has_coincidence || use_coincidence;
-		if (update_schedule(graph, sol, 1, coincident) < 0)
-			return -1;
+		if (update_schedule(graph, sol, coincident) < 0)
+			return isl_stat_error;
 
 		if (!check_conditional)
 			continue;
 		violated = has_violated_conditional_constraint(ctx, graph);
 		if (violated < 0)
-			return -1;
+			return isl_stat_error;
 		if (!violated)
 			continue;
 		if (reset_band(graph) < 0)
-			return -1;
+			return isl_stat_error;
 		use_coincidence = has_coincidence;
 	}
 
-	if (graph->n_total_row > graph->band_start)
-		next_band(graph);
-	return sort_statements(ctx, graph);
+	return isl_stat_ok;
 }
 
-/* Add a row to the schedules that separates the SCCs and move
- * to the next band.
+/* Compute a schedule for a connected dependence graph by considering
+ * the graph as a whole and return the updated schedule node.
+ *
+ * The actual schedule rows of the current band are computed by
+ * compute_schedule_wcc_band.  compute_schedule_finish_band takes
+ * care of integrating the band into "node" and continuing
+ * the computation.
  */
-static int split_on_scc(isl_ctx *ctx, struct isl_sched_graph *graph)
+static __isl_give isl_schedule_node *compute_schedule_wcc_whole(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	isl_ctx *ctx;
+
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	if (compute_schedule_wcc_band(ctx, graph) < 0)
+		return isl_schedule_node_free(node);
+
+	return compute_schedule_finish_band(node, graph, 1);
+}
+
+/* Clustering information used by compute_schedule_wcc_clustering.
+ *
+ * "n" is the number of SCCs in the original dependence graph
+ * "scc" is an array of "n" elements, each representing an SCC
+ * of the original dependence graph.  All entries in the same cluster
+ * have the same number of schedule rows.
+ * "scc_cluster" maps each SCC index to the cluster to which it belongs,
+ * where each cluster is represented by the index of the first SCC
+ * in the cluster.  Initially, each SCC belongs to a cluster containing
+ * only that SCC.
+ *
+ * "scc_in_merge" is used by merge_clusters_along_edge to keep
+ * track of which SCCs need to be merged.
+ *
+ * "cluster" contains the merged clusters of SCCs after the clustering
+ * has completed.
+ *
+ * "scc_node" is a temporary data structure used inside copy_partial.
+ * For each SCC, it keeps track of the number of nodes in the SCC
+ * that have already been copied.
+ */
+struct isl_clustering {
+	int n;
+	struct isl_sched_graph *scc;
+	struct isl_sched_graph *cluster;
+	int *scc_cluster;
+	int *scc_node;
+	int *scc_in_merge;
+};
+
+/* Initialize the clustering data structure "c" from "graph".
+ *
+ * In particular, allocate memory, extract the SCCs from "graph"
+ * into c->scc, initialize scc_cluster and construct
+ * a band of schedule rows for each SCC.
+ * Within each SCC, there is only one SCC by definition.
+ * Each SCC initially belongs to a cluster containing only that SCC.
+ */
+static isl_stat clustering_init(isl_ctx *ctx, struct isl_clustering *c,
+	struct isl_sched_graph *graph)
 {
 	int i;
 
-	if (graph->n_total_row >= graph->max_row)
+	c->n = graph->scc;
+	c->scc = isl_calloc_array(ctx, struct isl_sched_graph, c->n);
+	c->cluster = isl_calloc_array(ctx, struct isl_sched_graph, c->n);
+	c->scc_cluster = isl_calloc_array(ctx, int, c->n);
+	c->scc_node = isl_calloc_array(ctx, int, c->n);
+	c->scc_in_merge = isl_calloc_array(ctx, int, c->n);
+	if (!c->scc || !c->cluster ||
+	    !c->scc_cluster || !c->scc_node || !c->scc_in_merge)
+		return isl_stat_error;
+
+	for (i = 0; i < c->n; ++i) {
+		if (extract_sub_graph(ctx, graph, &node_scc_exactly,
+					&edge_scc_exactly, i, &c->scci) < 0)
+			return isl_stat_error;
+		c->scci.scc = 1;
+		if (compute_maxvar(&c->scci) < 0)
+			return isl_stat_error;
+		if (compute_schedule_wcc_band(ctx, &c->scci) < 0)
+			return isl_stat_error;
+		c->scc_clusteri = i;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Free all memory allocated for "c".
+ */
+static void clustering_free(isl_ctx *ctx, struct isl_clustering *c)
+{
+	int i;
+
+	if (c->scc)
+		for (i = 0; i < c->n; ++i)
+			graph_free(ctx, &c->scci);
+	free(c->scc);
+	if (c->cluster)
+		for (i = 0; i < c->n; ++i)
+			graph_free(ctx, &c->clusteri);
+	free(c->cluster);
+	free(c->scc_cluster);
+	free(c->scc_node);
+	free(c->scc_in_merge);
+}
+
+/* Should we refrain from merging the cluster in "graph" with
+ * any other cluster?
+ * In particular, is its current schedule band empty and incomplete.
+ */
+static int bad_cluster(struct isl_sched_graph *graph)
+{
+	return graph->n_row < graph->maxvar &&
+		graph->n_total_row == graph->band_start;
+}
+
+/* Is "edge" a proximity edge with a non-empty dependence relation?
+ */
+static isl_bool is_non_empty_proximity(struct isl_sched_edge *edge)
+{
+	if (!is_proximity(edge))
+		return isl_bool_false;
+	return isl_bool_not(isl_map_plain_is_empty(edge->map));
+}
+
+/* Return the index of an edge in "graph" that can be used to merge
+ * two clusters in "c".
+ * Return graph->n_edge if no such edge can be found.
+ * Return -1 on error.
+ *
+ * In particular, return a proximity edge between two clusters
+ * that is not marked "no_merge" and such that neither of the
+ * two clusters has an incomplete, empty band.
+ *
+ * If there are multiple such edges, then try and find the most
+ * appropriate edge to use for merging.  In particular, pick the edge
+ * with the greatest weight.  If there are multiple of those,
+ * then pick one with the shortest distance between
+ * the two cluster representatives.
+ */
+static int find_proximity(struct isl_sched_graph *graph,
+	struct isl_clustering *c)
+{
+	int i, best = graph->n_edge, best_dist, best_weight;
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+		int dist, weight;
+		isl_bool prox;
+
+		prox = is_non_empty_proximity(edge);
+		if (prox < 0)
+			return -1;
+		if (!prox)
+			continue;
+		if (edge->no_merge)
+			continue;
+		if (bad_cluster(&c->sccedge->src->scc) ||
+		    bad_cluster(&c->sccedge->dst->scc))
+			continue;
+		dist = c->scc_clusteredge->dst->scc -
+			c->scc_clusteredge->src->scc;
+		if (dist == 0)
+			continue;
+		weight = edge->weight;
+		if (best < graph->n_edge) {
+			if (best_weight > weight)
+				continue;
+			if (best_weight == weight && best_dist <= dist)
+				continue;
+		}
+		best = i;
+		best_dist = dist;
+		best_weight = weight;
+	}
+
+	return best;
+}
+
+/* Internal data structure used in mark_merge_sccs.
+ *
+ * "graph" is the dependence graph in which a strongly connected
+ * component is constructed.
+ * "scc_cluster" maps each SCC index to the cluster to which it belongs.
+ * "src" and "dst" are the indices of the nodes that are being merged.
+ */
+struct isl_mark_merge_sccs_data {
+	struct isl_sched_graph *graph;
+	int *scc_cluster;
+	int src;
+	int dst;
+};
+
+/* Check whether the cluster containing node "i" depends on the cluster
+ * containing node "j".  If "i" and "j" belong to the same cluster,
+ * then they are taken to depend on each other to ensure that
+ * the resulting strongly connected component consists of complete
+ * clusters.  Furthermore, if "i" and "j" are the two nodes that
+ * are being merged, then they are taken to depend on each other as well.
+ * Otherwise, check if there is a (conditional) validity dependence
+ * from nodej to nodei, forcing nodei to follow nodej.
+ */
+static isl_bool cluster_follows(int i, int j, void *user)
+{
+	struct isl_mark_merge_sccs_data *data = user;
+	struct isl_sched_graph *graph = data->graph;
+	int *scc_cluster = data->scc_cluster;
+
+	if (data->src == i && data->dst == j)
+		return isl_bool_true;
+	if (data->src == j && data->dst == i)
+		return isl_bool_true;
+	if (scc_clustergraph->nodei.scc == scc_clustergraph->nodej.scc)
+		return isl_bool_true;
+
+	return graph_has_validity_edge(graph, &graph->nodej, &graph->nodei);
+}
+
+/* Mark all SCCs that belong to either of the two clusters in "c"
+ * connected by the edge in "graph" with index "edge", or to any
+ * of the intermediate clusters.
+ * The marking is recorded in c->scc_in_merge.
+ *
+ * The given edge has been selected for merging two clusters,
+ * meaning that there is at least a proximity edge between the two nodes.
+ * However, there may also be (indirect) validity dependences
+ * between the two nodes.  When merging the two clusters, all clusters
+ * containing one or more of the intermediate nodes along the
+ * indirect validity dependences need to be merged in as well.
+ *
+ * First collect all such nodes by computing the strongly connected
+ * component (SCC) containing the two nodes connected by the edge, where
+ * the two nodes are considered to depend on each other to make
+ * sure they end up in the same SCC.  Similarly, each node is considered
+ * to depend on every other node in the same cluster to ensure
+ * that the SCC consists of complete clusters.
+ *
+ * Then the original SCCs that contain any of these nodes are marked
+ * in c->scc_in_merge.
+ */
+static isl_stat mark_merge_sccs(isl_ctx *ctx, struct isl_sched_graph *graph,
+	int edge, struct isl_clustering *c)
+{
+	struct isl_mark_merge_sccs_data data;
+	struct isl_tarjan_graph *g;
+	int i;
+
+	for (i = 0; i < c->n; ++i)
+		c->scc_in_mergei = 0;
+
+	data.graph = graph;
+	data.scc_cluster = c->scc_cluster;
+	data.src = graph->edgeedge.src - graph->node;
+	data.dst = graph->edgeedge.dst - graph->node;
+
+	g = isl_tarjan_graph_component(ctx, graph->n, data.dst,
+					&cluster_follows, &data);
+	if (!g)
+		goto error;
+
+	i = g->op;
+	if (i < 3)
+		isl_die(ctx, isl_error_internal,
+			"expecting at least two nodes in component",
+			goto error);
+	if (g->order--i != -1)
 		isl_die(ctx, isl_error_internal,
-			"too many schedule rows", return -1);
+			"expecting end of component marker", goto error);
+
+	for (--i; i >= 0 && g->orderi != -1; --i) {
+		int scc = graph->nodeg->orderi.scc;
+		c->scc_in_mergescc = 1;
+	}
+
+	isl_tarjan_graph_free(g);
+	return isl_stat_ok;
+error:
+	isl_tarjan_graph_free(g);
+	return isl_stat_error;
+}
+
+/* Construct the identifier "cluster_i".
+ */
+static __isl_give isl_id *cluster_id(isl_ctx *ctx, int i)
+{
+	char name40;
+
+	snprintf(name, sizeof(name), "cluster_%d", i);
+	return isl_id_alloc(ctx, name, NULL);
+}
+
+/* Construct the space of the cluster with index "i" containing
+ * the strongly connected component "scc".
+ *
+ * In particular, construct a space called cluster_i with dimension equal
+ * to the number of schedule rows in the current band of "scc".
+ */
+static __isl_give isl_space *cluster_space(struct isl_sched_graph *scc, int i)
+{
+	int nvar;
+	isl_space *space;
+	isl_id *id;
+
+	nvar = scc->n_total_row - scc->band_start;
+	space = isl_space_copy(scc->node0.space);
+	space = isl_space_params(space);
+	space = isl_space_set_from_params(space);
+	space = isl_space_add_dims(space, isl_dim_set, nvar);
+	id = cluster_id(isl_space_get_ctx(space), i);
+	space = isl_space_set_tuple_id(space, isl_dim_set, id);
+
+	return space;
+}
+
+/* Collect the domain of the graph for merging clusters.
+ *
+ * In particular, for each cluster with first SCC "i", construct
+ * a set in the space called cluster_i with dimension equal
+ * to the number of schedule rows in the current band of the cluster.
+ */
+static __isl_give isl_union_set *collect_domain(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_clustering *c)
+{
+	int i;
+	isl_space *space;
+	isl_union_set *domain;
+
+	space = isl_space_params_alloc(ctx, 0);
+	domain = isl_union_set_empty(space);
+
+	for (i = 0; i < graph->scc; ++i) {
+		isl_space *space;
 
+		if (!c->scc_in_mergei)
+			continue;
+		if (c->scc_clusteri != i)
+			continue;
+		space = cluster_space(&c->scci, i);
+		domain = isl_union_set_add_set(domain, isl_set_universe(space));
+	}
+
+	return domain;
+}
+
+/* Construct a map from the original instances to the corresponding
+ * cluster instance in the current bands of the clusters in "c".
+ */
+static __isl_give isl_union_map *collect_cluster_map(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_clustering *c)
+{
+	int i, j;
+	isl_space *space;
+	isl_union_map *cluster_map;
+
+	space = isl_space_params_alloc(ctx, 0);
+	cluster_map = isl_union_map_empty(space);
+	for (i = 0; i < graph->scc; ++i) {
+		int start, n;
+		isl_id *id;
+
+		if (!c->scc_in_mergei)
+			continue;
+
+		id = cluster_id(ctx, c->scc_clusteri);
+		start = c->scci.band_start;
+		n = c->scci.n_total_row - start;
+		for (j = 0; j < c->scci.n; ++j) {
+			isl_multi_aff *ma;
+			isl_map *map;
+			struct isl_sched_node *node = &c->scci.nodej;
+
+			ma = node_extract_partial_schedule_multi_aff(node,
+								    start, n);
+			ma = isl_multi_aff_set_tuple_id(ma, isl_dim_out,
+							    isl_id_copy(id));
+			map = isl_map_from_multi_aff(ma);
+			cluster_map = isl_union_map_add_map(cluster_map, map);
+		}
+		isl_id_free(id);
+	}
+
+	return cluster_map;
+}
+
+/* Add "umap" to the schedule constraints "sc" of all types of "edge"
+ * that are not isl_edge_condition or isl_edge_conditional_validity.
+ */
+static __isl_give isl_schedule_constraints *add_non_conditional_constraints(
+	struct isl_sched_edge *edge, __isl_keep isl_union_map *umap,
+	__isl_take isl_schedule_constraints *sc)
+{
+	enum isl_edge_type t;
+
+	if (!sc)
+		return NULL;
+
+	for (t = isl_edge_first; t <= isl_edge_last; ++t) {
+		if (t == isl_edge_condition ||
+		    t == isl_edge_conditional_validity)
+			continue;
+		if (!is_type(edge, t))
+			continue;
+		sc = isl_schedule_constraints_add(sc, t,
+						    isl_union_map_copy(umap));
+	}
+
+	return sc;
+}
+
+/* Add schedule constraints of types isl_edge_condition and
+ * isl_edge_conditional_validity to "sc" by applying "umap" to
+ * the domains of the wrapped relations in domain and range
+ * of the corresponding tagged constraints of "edge".
+ */
+static __isl_give isl_schedule_constraints *add_conditional_constraints(
+	struct isl_sched_edge *edge, __isl_keep isl_union_map *umap,
+	__isl_take isl_schedule_constraints *sc)
+{
+	enum isl_edge_type t;
+	isl_union_map *tagged;
+
+	for (t = isl_edge_condition; t <= isl_edge_conditional_validity; ++t) {
+		if (!is_type(edge, t))
+			continue;
+		if (t == isl_edge_condition)
+			tagged = isl_union_map_copy(edge->tagged_condition);
+		else
+			tagged = isl_union_map_copy(edge->tagged_validity);
+		tagged = isl_union_map_zip(tagged);
+		tagged = isl_union_map_apply_domain(tagged,
+					isl_union_map_copy(umap));
+		tagged = isl_union_map_zip(tagged);
+		sc = isl_schedule_constraints_add(sc, t, tagged);
+		if (!sc)
+			return NULL;
+	}
+
+	return sc;
+}
+
+/* Given a mapping "cluster_map" from the original instances to
+ * the cluster instances, add schedule constraints on the clusters
+ * to "sc" corresponding to the original constraints represented by "edge".
+ *
+ * For non-tagged dependence constraints, the cluster constraints
+ * are obtained by applying "cluster_map" to the edge->map.
+ *
+ * For tagged dependence constraints, "cluster_map" needs to be applied
+ * to the domains of the wrapped relations in domain and range
+ * of the tagged dependence constraints.  Pick out the mappings
+ * from these domains from "cluster_map" and construct their product.
+ * This mapping can then be applied to the pair of domains.
+ */
+static __isl_give isl_schedule_constraints *collect_edge_constraints(
+	struct isl_sched_edge *edge, __isl_keep isl_union_map *cluster_map,
+	__isl_take isl_schedule_constraints *sc)
+{
+	isl_union_map *umap;
+	isl_space *space;
+	isl_union_set *uset;
+	isl_union_map *umap1, *umap2;
+
+	if (!sc)
+		return NULL;
+
+	umap = isl_union_map_from_map(isl_map_copy(edge->map));
+	umap = isl_union_map_apply_domain(umap,
+				isl_union_map_copy(cluster_map));
+	umap = isl_union_map_apply_range(umap,
+				isl_union_map_copy(cluster_map));
+	sc = add_non_conditional_constraints(edge, umap, sc);
+	isl_union_map_free(umap);
+
+	if (!sc || (!is_condition(edge) && !is_conditional_validity(edge)))
+		return sc;
+
+	space = isl_space_domain(isl_map_get_space(edge->map));
+	uset = isl_union_set_from_set(isl_set_universe(space));
+	umap1 = isl_union_map_copy(cluster_map);
+	umap1 = isl_union_map_intersect_domain(umap1, uset);
+	space = isl_space_range(isl_map_get_space(edge->map));
+	uset = isl_union_set_from_set(isl_set_universe(space));
+	umap2 = isl_union_map_copy(cluster_map);
+	umap2 = isl_union_map_intersect_domain(umap2, uset);
+	umap = isl_union_map_product(umap1, umap2);
+
+	sc = add_conditional_constraints(edge, umap, sc);
+
+	isl_union_map_free(umap);
+	return sc;
+}
+
+/* Given a mapping "cluster_map" from the original instances to
+ * the cluster instances, add schedule constraints on the clusters
+ * to "sc" corresponding to all edges in "graph" between nodes that
+ * belong to SCCs that are marked for merging in "scc_in_merge".
+ */
+static __isl_give isl_schedule_constraints *collect_constraints(
+	struct isl_sched_graph *graph, int *scc_in_merge,
+	__isl_keep isl_union_map *cluster_map,
+	__isl_take isl_schedule_constraints *sc)
+{
+	int i;
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+
+		if (!scc_in_mergeedge->src->scc)
+			continue;
+		if (!scc_in_mergeedge->dst->scc)
+			continue;
+		sc = collect_edge_constraints(edge, cluster_map, sc);
+	}
+
+	return sc;
+}
+
+/* Construct a dependence graph for scheduling clusters with respect
+ * to each other and store the result in "merge_graph".
+ * In particular, the nodes of the graph correspond to the schedule
+ * dimensions of the current bands of those clusters that have been
+ * marked for merging in "c".
+ *
+ * First construct an isl_schedule_constraints object for this domain
+ * by transforming the edges in "graph" to the domain.
+ * Then initialize a dependence graph for scheduling from these
+ * constraints.
+ */
+static isl_stat init_merge_graph(isl_ctx *ctx, struct isl_sched_graph *graph,
+	struct isl_clustering *c, struct isl_sched_graph *merge_graph)
+{
+	isl_union_set *domain;
+	isl_union_map *cluster_map;
+	isl_schedule_constraints *sc;
+	isl_stat r;
+
+	domain = collect_domain(ctx, graph, c);
+	sc = isl_schedule_constraints_on_domain(domain);
+	if (!sc)
+		return isl_stat_error;
+	cluster_map = collect_cluster_map(ctx, graph, c);
+	sc = collect_constraints(graph, c->scc_in_merge, cluster_map, sc);
+	isl_union_map_free(cluster_map);
+
+	r = graph_init(merge_graph, sc);
+
+	isl_schedule_constraints_free(sc);
+
+	return r;
+}
+
+/* Compute the maximal number of remaining schedule rows that still need
+ * to be computed for the nodes that belong to clusters with the maximal
+ * dimension for the current band (i.e., the band that is to be merged).
+ * Only clusters that are about to be merged are considered.
+ * "maxvar" is the maximal dimension for the current band.
+ * "c" contains information about the clusters.
+ *
+ * Return the maximal number of remaining schedule rows or -1 on error.
+ */
+static int compute_maxvar_max_slack(int maxvar, struct isl_clustering *c)
+{
+	int i, j;
+	int max_slack;
+
+	max_slack = 0;
+	for (i = 0; i < c->n; ++i) {
+		int nvar;
+		struct isl_sched_graph *scc;
+
+		if (!c->scc_in_mergei)
+			continue;
+		scc = &c->scci;
+		nvar = scc->n_total_row - scc->band_start;
+		if (nvar != maxvar)
+			continue;
+		for (j = 0; j < scc->n; ++j) {
+			struct isl_sched_node *node = &scc->nodej;
+			int slack;
+
+			if (node_update_vmap(node) < 0)
+				return -1;
+			slack = node->nvar - node->rank;
+			if (slack > max_slack)
+				max_slack = slack;
+		}
+	}
+
+	return max_slack;
+}
+
+/* If there are any clusters where the dimension of the current band
+ * (i.e., the band that is to be merged) is smaller than "maxvar" and
+ * if there are any nodes in such a cluster where the number
+ * of remaining schedule rows that still need to be computed
+ * is greater than "max_slack", then return the smallest current band
+ * dimension of all these clusters.  Otherwise return the original value
+ * of "maxvar".  Return -1 in case of any error.
+ * Only clusters that are about to be merged are considered.
+ * "c" contains information about the clusters.
+ */
+static int limit_maxvar_to_slack(int maxvar, int max_slack,
+	struct isl_clustering *c)
+{
+	int i, j;
+
+	for (i = 0; i < c->n; ++i) {
+		int nvar;
+		struct isl_sched_graph *scc;
+
+		if (!c->scc_in_mergei)
+			continue;
+		scc = &c->scci;
+		nvar = scc->n_total_row - scc->band_start;
+		if (nvar >= maxvar)
+			continue;
+		for (j = 0; j < scc->n; ++j) {
+			struct isl_sched_node *node = &scc->nodej;
+			int slack;
+
+			if (node_update_vmap(node) < 0)
+				return -1;
+			slack = node->nvar - node->rank;
+			if (slack > max_slack) {
+				maxvar = nvar;
+				break;
+			}
+		}
+	}
+
+	return maxvar;
+}
+
+/* Adjust merge_graph->maxvar based on the number of remaining schedule rows
+ * that still need to be computed.  In particular, if there is a node
+ * in a cluster where the dimension of the current band is smaller
+ * than merge_graph->maxvar, but the number of remaining schedule rows
+ * is greater than that of any node in a cluster with the maximal
+ * dimension for the current band (i.e., merge_graph->maxvar),
+ * then adjust merge_graph->maxvar to the (smallest) current band dimension
+ * of those clusters.  Without this adjustment, the total number of
+ * schedule dimensions would be increased, resulting in a skewed view
+ * of the number of coincident dimensions.
+ * "c" contains information about the clusters.
+ *
+ * If the maximize_band_depth option is set and merge_graph->maxvar is reduced,
+ * then there is no point in attempting any merge since it will be rejected
+ * anyway.  Set merge_graph->maxvar to zero in such cases.
+ */
+static isl_stat adjust_maxvar_to_slack(isl_ctx *ctx,
+	struct isl_sched_graph *merge_graph, struct isl_clustering *c)
+{
+	int max_slack, maxvar;
+
+	max_slack = compute_maxvar_max_slack(merge_graph->maxvar, c);
+	if (max_slack < 0)
+		return isl_stat_error;
+	maxvar = limit_maxvar_to_slack(merge_graph->maxvar, max_slack, c);
+	if (maxvar < 0)
+		return isl_stat_error;
+
+	if (maxvar < merge_graph->maxvar) {
+		if (isl_options_get_schedule_maximize_band_depth(ctx))
+			merge_graph->maxvar = 0;
+		else
+			merge_graph->maxvar = maxvar;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Return the number of coincident dimensions in the current band of "graph",
+ * where the nodes of "graph" are assumed to be scheduled by a single band.
+ */
+static int get_n_coincident(struct isl_sched_graph *graph)
+{
+	int i;
+
+	for (i = graph->band_start; i < graph->n_total_row; ++i)
+		if (!graph->node0.coincidenti)
+			break;
+
+	return i - graph->band_start;
+}
+
+/* Should the clusters be merged based on the cluster schedule
+ * in the current (and only) band of "merge_graph", given that
+ * coincidence should be maximized?
+ *
+ * If the number of coincident schedule dimensions in the merged band
+ * would be less than the maximal number of coincident schedule dimensions
+ * in any of the merged clusters, then the clusters should not be merged.
+ */
+static isl_bool ok_to_merge_coincident(struct isl_clustering *c,
+	struct isl_sched_graph *merge_graph)
+{
+	int i;
+	int n_coincident;
+	int max_coincident;
+
+	max_coincident = 0;
+	for (i = 0; i < c->n; ++i) {
+		if (!c->scc_in_mergei)
+			continue;
+		n_coincident = get_n_coincident(&c->scci);
+		if (n_coincident > max_coincident)
+			max_coincident = n_coincident;
+	}
+
+	n_coincident = get_n_coincident(merge_graph);
+
+	return isl_bool_ok(n_coincident >= max_coincident);
+}
+
+/* Return the transformation on "node" expressed by the current (and only)
+ * band of "merge_graph" applied to the clusters in "c".
+ *
+ * First find the representation of "node" in its SCC in "c" and
+ * extract the transformation expressed by the current band.
+ * Then extract the transformation applied by "merge_graph"
+ * to the cluster to which this SCC belongs.
+ * Combine the two to obtain the complete transformation on the node.
+ *
+ * Note that the range of the first transformation is an anonymous space,
+ * while the domain of the second is named "cluster_X".  The range
+ * of the former therefore needs to be adjusted before the two
+ * can be combined.
+ */
+static __isl_give isl_map *extract_node_transformation(isl_ctx *ctx,
+	struct isl_sched_node *node, struct isl_clustering *c,
+	struct isl_sched_graph *merge_graph)
+{
+	struct isl_sched_node *scc_node, *cluster_node;
+	int start, n;
+	isl_id *id;
+	isl_space *space;
+	isl_multi_aff *ma, *ma2;
+
+	scc_node = graph_find_node(ctx, &c->sccnode->scc, node->space);
+	if (scc_node && !is_node(&c->sccnode->scc, scc_node))
+		isl_die(ctx, isl_error_internal, "unable to find node",
+			return NULL);
+	start = c->sccnode->scc.band_start;
+	n = c->sccnode->scc.n_total_row - start;
+	ma = node_extract_partial_schedule_multi_aff(scc_node, start, n);
+	space = cluster_space(&c->sccnode->scc, c->scc_clusternode->scc);
+	cluster_node = graph_find_node(ctx, merge_graph, space);
+	if (cluster_node && !is_node(merge_graph, cluster_node))
+		isl_die(ctx, isl_error_internal, "unable to find cluster",
+			space = isl_space_free(space));
+	id = isl_space_get_tuple_id(space, isl_dim_set);
+	ma = isl_multi_aff_set_tuple_id(ma, isl_dim_out, id);
+	isl_space_free(space);
+	n = merge_graph->n_total_row;
+	ma2 = node_extract_partial_schedule_multi_aff(cluster_node, 0, n);
+	ma = isl_multi_aff_pullback_multi_aff(ma2, ma);
+
+	return isl_map_from_multi_aff(ma);
+}
+
+/* Give a set of distances "set", are they bounded by a small constant
+ * in direction "pos"?
+ * In practice, check if they are bounded by 2 by checking that there
+ * are no elements with a value greater than or equal to 3 or
+ * smaller than or equal to -3.
+ */
+static isl_bool distance_is_bounded(__isl_keep isl_set *set, int pos)
+{
+	isl_bool bounded;
+	isl_set *test;
+
+	if (!set)
+		return isl_bool_error;
+
+	test = isl_set_copy(set);
+	test = isl_set_lower_bound_si(test, isl_dim_set, pos, 3);
+	bounded = isl_set_is_empty(test);
+	isl_set_free(test);
+
+	if (bounded < 0 || !bounded)
+		return bounded;
+
+	test = isl_set_copy(set);
+	test = isl_set_upper_bound_si(test, isl_dim_set, pos, -3);
+	bounded = isl_set_is_empty(test);
+	isl_set_free(test);
+
+	return bounded;
+}
+
+/* Does the set "set" have a fixed (but possible parametric) value
+ * at dimension "pos"?
+ */
+static isl_bool has_single_value(__isl_keep isl_set *set, int pos)
+{
+	isl_size n;
+	isl_bool single;
+
+	n = isl_set_dim(set, isl_dim_set);
+	if (n < 0)
+		return isl_bool_error;
+	set = isl_set_copy(set);
+	set = isl_set_project_out(set, isl_dim_set, pos + 1, n - (pos + 1));
+	set = isl_set_project_out(set, isl_dim_set, 0, pos);
+	single = isl_set_is_singleton(set);
+	isl_set_free(set);
+
+	return single;
+}
+
+/* Does "map" have a fixed (but possible parametric) value
+ * at dimension "pos" of either its domain or its range?
+ */
+static isl_bool has_singular_src_or_dst(__isl_keep isl_map *map, int pos)
+{
+	isl_set *set;
+	isl_bool single;
+
+	set = isl_map_domain(isl_map_copy(map));
+	single = has_single_value(set, pos);
+	isl_set_free(set);
+
+	if (single < 0 || single)
+		return single;
+
+	set = isl_map_range(isl_map_copy(map));
+	single = has_single_value(set, pos);
+	isl_set_free(set);
+
+	return single;
+}
+
+/* Does the edge "edge" from "graph" have bounded dependence distances
+ * in the merged graph "merge_graph" of a selection of clusters in "c"?
+ *
+ * Extract the complete transformations of the source and destination
+ * nodes of the edge, apply them to the edge constraints and
+ * compute the differences.  Finally, check if these differences are bounded
+ * in each direction.
+ *
+ * If the dimension of the band is greater than the number of
+ * dimensions that can be expected to be optimized by the edge
+ * (based on its weight), then also allow the differences to be unbounded
+ * in the remaining dimensions, but only if either the source or
+ * the destination has a fixed value in that direction.
+ * This allows a statement that produces values that are used by
+ * several instances of another statement to be merged with that
+ * other statement.
+ * However, merging such clusters will introduce an inherently
+ * large proximity distance inside the merged cluster, meaning
+ * that proximity distances will no longer be optimized in
+ * subsequent merges.  These merges are therefore only allowed
+ * after all other possible merges have been tried.
+ * The first time such a merge is encountered, the weight of the edge
+ * is replaced by a negative weight.  The second time (i.e., after
+ * all merges over edges with a non-negative weight have been tried),
+ * the merge is allowed.
+ */
+static isl_bool has_bounded_distances(isl_ctx *ctx, struct isl_sched_edge *edge,
+	struct isl_sched_graph *graph, struct isl_clustering *c,
+	struct isl_sched_graph *merge_graph)
+{
+	int i, n_slack;
+	isl_size n;
+	isl_bool bounded;
+	isl_map *map, *t;
+	isl_set *dist;
+
+	map = isl_map_copy(edge->map);
+	t = extract_node_transformation(ctx, edge->src, c, merge_graph);
+	map = isl_map_apply_domain(map, t);
+	t = extract_node_transformation(ctx, edge->dst, c, merge_graph);
+	map = isl_map_apply_range(map, t);
+	dist = isl_map_deltas(isl_map_copy(map));
+
+	bounded = isl_bool_true;
+	n = isl_set_dim(dist, isl_dim_set);
+	if (n < 0)
+		goto error;
+	n_slack = n - edge->weight;
+	if (edge->weight < 0)
+		n_slack -= graph->max_weight + 1;
+	for (i = 0; i < n; ++i) {
+		isl_bool bounded_i, singular_i;
+
+		bounded_i = distance_is_bounded(dist, i);
+		if (bounded_i < 0)
+			goto error;
+		if (bounded_i)
+			continue;
+		if (edge->weight >= 0)
+			bounded = isl_bool_false;
+		n_slack--;
+		if (n_slack < 0)
+			break;
+		singular_i = has_singular_src_or_dst(map, i);
+		if (singular_i < 0)
+			goto error;
+		if (singular_i)
+			continue;
+		bounded = isl_bool_false;
+		break;
+	}
+	if (!bounded && i >= n && edge->weight >= 0)
+		edge->weight -= graph->max_weight + 1;
+	isl_map_free(map);
+	isl_set_free(dist);
+
+	return bounded;
+error:
+	isl_map_free(map);
+	isl_set_free(dist);
+	return isl_bool_error;
+}
+
+/* Should the clusters be merged based on the cluster schedule
+ * in the current (and only) band of "merge_graph"?
+ * "graph" is the original dependence graph, while "c" records
+ * which SCCs are involved in the latest merge.
+ *
+ * In particular, is there at least one proximity constraint
+ * that is optimized by the merge?
+ *
+ * A proximity constraint is considered to be optimized
+ * if the dependence distances are small.
+ */
+static isl_bool ok_to_merge_proximity(isl_ctx *ctx,
+	struct isl_sched_graph *graph, struct isl_clustering *c,
+	struct isl_sched_graph *merge_graph)
+{
+	int i;
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+		isl_bool bounded;
+
+		if (!is_proximity(edge))
+			continue;
+		if (!c->scc_in_mergeedge->src->scc)
+			continue;
+		if (!c->scc_in_mergeedge->dst->scc)
+			continue;
+		if (c->scc_clusteredge->dst->scc ==
+		    c->scc_clusteredge->src->scc)
+			continue;
+		bounded = has_bounded_distances(ctx, edge, graph, c,
+						merge_graph);
+		if (bounded < 0 || bounded)
+			return bounded;
+	}
+
+	return isl_bool_false;
+}
+
+/* Should the clusters be merged based on the cluster schedule
+ * in the current (and only) band of "merge_graph"?
+ * "graph" is the original dependence graph, while "c" records
+ * which SCCs are involved in the latest merge.
+ *
+ * If the current band is empty, then the clusters should not be merged.
+ *
+ * If the band depth should be maximized and the merge schedule
+ * is incomplete (meaning that the dimension of some of the schedule
+ * bands in the original schedule will be reduced), then the clusters
+ * should not be merged.
+ *
+ * If the schedule_maximize_coincidence option is set, then check that
+ * the number of coincident schedule dimensions is not reduced.
+ *
+ * Finally, only allow the merge if at least one proximity
+ * constraint is optimized.
+ */
+static isl_bool ok_to_merge(isl_ctx *ctx, struct isl_sched_graph *graph,
+	struct isl_clustering *c, struct isl_sched_graph *merge_graph)
+{
+	if (merge_graph->n_total_row == merge_graph->band_start)
+		return isl_bool_false;
+
+	if (isl_options_get_schedule_maximize_band_depth(ctx) &&
+	    merge_graph->n_total_row < merge_graph->maxvar)
+		return isl_bool_false;
+
+	if (isl_options_get_schedule_maximize_coincidence(ctx)) {
+		isl_bool ok;
+
+		ok = ok_to_merge_coincident(c, merge_graph);
+		if (ok < 0 || !ok)
+			return ok;
+	}
+
+	return ok_to_merge_proximity(ctx, graph, c, merge_graph);
+}
+
+/* Apply the schedule in "t_node" to the "n" rows starting at "first"
+ * of the schedule in "node" and return the result.
+ *
+ * That is, essentially compute
+ *
+ *	T * N(first:first+n-1)
+ *
+ * taking into account the constant term and the parameter coefficients
+ * in "t_node".
+ */
+static __isl_give isl_mat *node_transformation(isl_ctx *ctx,
+	struct isl_sched_node *t_node, struct isl_sched_node *node,
+	int first, int n)
+{
+	int i, j;
+	isl_mat *t;
+	isl_size n_row, n_col;
+	int n_param, n_var;
+
+	n_param = node->nparam;
+	n_var = node->nvar;
+	n_row = isl_mat_rows(t_node->sched);
+	n_col = isl_mat_cols(node->sched);
+	if (n_row < 0 || n_col < 0)
+		return NULL;
+	t = isl_mat_alloc(ctx, n_row, n_col);
+	if (!t)
+		return NULL;
+	for (i = 0; i < n_row; ++i) {
+		isl_seq_cpy(t->rowi, t_node->sched->rowi, 1 + n_param);
+		isl_seq_clr(t->rowi + 1 + n_param, n_var);
+		for (j = 0; j < n; ++j)
+			isl_seq_addmul(t->rowi,
+					t_node->sched->rowi1 + n_param + j,
+					node->sched->rowfirst + j,
+					1 + n_param + n_var);
+	}
+	return t;
+}
+
+/* Apply the cluster schedule in "t_node" to the current band
+ * schedule of the nodes in "graph".
+ *
+ * In particular, replace the rows starting at band_start
+ * by the result of applying the cluster schedule in "t_node"
+ * to the original rows.
+ *
+ * The coincidence of the schedule is determined by the coincidence
+ * of the cluster schedule.
+ */
+static isl_stat transform(isl_ctx *ctx, struct isl_sched_graph *graph,
+	struct isl_sched_node *t_node)
+{
+	int i, j;
+	isl_size n_new;
+	int start, n;
+
+	start = graph->band_start;
+	n = graph->n_total_row - start;
+
+	n_new = isl_mat_rows(t_node->sched);
+	if (n_new < 0)
+		return isl_stat_error;
 	for (i = 0; i < graph->n; ++i) {
 		struct isl_sched_node *node = &graph->nodei;
-		int row = isl_mat_rows(node->sched);
+		isl_mat *t;
 
-		isl_map_free(node->sched_map);
-		node->sched_map = NULL;
-		node->sched = isl_mat_add_zero_rows(node->sched, 1);
-		node->sched = isl_mat_set_element_si(node->sched, row, 0,
-						     node->scc);
+		t = node_transformation(ctx, t_node, node, start, n);
+		node->sched = isl_mat_drop_rows(node->sched, start, n);
+		node->sched = isl_mat_concat(node->sched, t);
+		node->sched_map = isl_map_free(node->sched_map);
 		if (!node->sched)
-			return -1;
-		node->bandgraph->n_total_row = graph->n_band;
-	}
+			return isl_stat_error;
+		for (j = 0; j < n_new; ++j)
+			node->coincidentstart + j = t_node->coincidentj;
+	}
+	graph->n_total_row -= n;
+	graph->n_row -= n;
+	graph->n_total_row += n_new;
+	graph->n_row += n_new;
+
+	return isl_stat_ok;
+}
+
+/* Merge the clusters marked for merging in "c" into a single
+ * cluster using the cluster schedule in the current band of "merge_graph".
+ * The representative SCC for the new cluster is the SCC with
+ * the smallest index.
+ *
+ * The current band schedule of each SCC in the new cluster is obtained
+ * by applying the schedule of the corresponding original cluster
+ * to the original band schedule.
+ * All SCCs in the new cluster have the same number of schedule rows.
+ */
+static isl_stat merge(isl_ctx *ctx, struct isl_clustering *c,
+	struct isl_sched_graph *merge_graph)
+{
+	int i;
+	int cluster = -1;
+	isl_space *space;
 
-	graph->n_total_row++;
-	next_band(graph);
+	for (i = 0; i < c->n; ++i) {
+		struct isl_sched_node *node;
+
+		if (!c->scc_in_mergei)
+			continue;
+		if (cluster < 0)
+			cluster = i;
+		space = cluster_space(&c->scci, c->scc_clusteri);
+		node = graph_find_node(ctx, merge_graph, space);
+		isl_space_free(space);
+		if (!node)
+			return isl_stat_error;
+		if (!is_node(merge_graph, node))
+			isl_die(ctx, isl_error_internal,
+				"unable to find cluster",
+				return isl_stat_error);
+		if (transform(ctx, &c->scci, node) < 0)
+			return isl_stat_error;
+		c->scc_clusteri = cluster;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Try and merge the clusters of SCCs marked in c->scc_in_merge
+ * by scheduling the current cluster bands with respect to each other.
+ *
+ * Construct a dependence graph with a space for each cluster and
+ * with the coordinates of each space corresponding to the schedule
+ * dimensions of the current band of that cluster.
+ * Construct a cluster schedule in this cluster dependence graph and
+ * apply it to the current cluster bands if it is applicable
+ * according to ok_to_merge.
+ *
+ * If the number of remaining schedule dimensions in a cluster
+ * with a non-maximal current schedule dimension is greater than
+ * the number of remaining schedule dimensions in clusters
+ * with a maximal current schedule dimension, then restrict
+ * the number of rows to be computed in the cluster schedule
+ * to the minimal such non-maximal current schedule dimension.
+ * Do this by adjusting merge_graph.maxvar.
+ *
+ * Return isl_bool_true if the clusters have effectively been merged
+ * into a single cluster.
+ *
+ * Note that since the standard scheduling algorithm minimizes the maximal
+ * distance over proximity constraints, the proximity constraints between
+ * the merged clusters may not be optimized any further than what is
+ * sufficient to bring the distances within the limits of the internal
+ * proximity constraints inside the individual clusters.
+ * It may therefore make sense to perform an additional translation step
+ * to bring the clusters closer to each other, while maintaining
+ * the linear part of the merging schedule found using the standard
+ * scheduling algorithm.
+ */
+static isl_bool try_merge(isl_ctx *ctx, struct isl_sched_graph *graph,
+	struct isl_clustering *c)
+{
+	struct isl_sched_graph merge_graph = { 0 };
+	isl_bool merged;
+
+	if (init_merge_graph(ctx, graph, c, &merge_graph) < 0)
+		goto error;
+
+	if (compute_maxvar(&merge_graph) < 0)
+		goto error;
+	if (adjust_maxvar_to_slack(ctx, &merge_graph,c) < 0)
+		goto error;
+	if (compute_schedule_wcc_band(ctx, &merge_graph) < 0)
+		goto error;
+	merged = ok_to_merge(ctx, graph, c, &merge_graph);
+	if (merged && merge(ctx, c, &merge_graph) < 0)
+		goto error;
+
+	graph_free(ctx, &merge_graph);
+	return merged;
+error:
+	graph_free(ctx, &merge_graph);
+	return isl_bool_error;
+}
+
+/* Is there any edge marked "no_merge" between two SCCs that are
+ * about to be merged (i.e., that are set in "scc_in_merge")?
+ * "merge_edge" is the proximity edge along which the clusters of SCCs
+ * are going to be merged.
+ *
+ * If there is any edge between two SCCs with a negative weight,
+ * while the weight of "merge_edge" is non-negative, then this
+ * means that the edge was postponed.  "merge_edge" should then
+ * also be postponed since merging along the edge with negative weight should
+ * be postponed until all edges with non-negative weight have been tried.
+ * Replace the weight of "merge_edge" by a negative weight as well and
+ * tell the caller not to attempt a merge.
+ */
+static int any_no_merge(struct isl_sched_graph *graph, int *scc_in_merge,
+	struct isl_sched_edge *merge_edge)
+{
+	int i;
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+
+		if (!scc_in_mergeedge->src->scc)
+			continue;
+		if (!scc_in_mergeedge->dst->scc)
+			continue;
+		if (edge->no_merge)
+			return 1;
+		if (merge_edge->weight >= 0 && edge->weight < 0) {
+			merge_edge->weight -= graph->max_weight + 1;
+			return 1;
+		}
+	}
 
 	return 0;
 }
 
-/* Compute a schedule for each component (identified by node->scc)
- * of the dependence graph separately and then combine the results.
- * Depending on the setting of schedule_fuse, a component may be
- * either weakly or strongly connected.
- *
- * The band_id is adjusted such that each component has a separate id.
- * Note that the band_id may have already been set to a value different
- * from zero by compute_split_schedule.
+/* Merge the two clusters in "c" connected by the edge in "graph"
+ * with index "edge" into a single cluster.
+ * If it turns out to be impossible to merge these two clusters,
+ * then mark the edge as "no_merge" such that it will not be
+ * considered again.
+ *
+ * First mark all SCCs that need to be merged.  This includes the SCCs
+ * in the two clusters, but it may also include the SCCs
+ * of intermediate clusters.
+ * If there is already a no_merge edge between any pair of such SCCs,
+ * then simply mark the current edge as no_merge as well.
+ * Likewise, if any of those edges was postponed by has_bounded_distances,
+ * then postpone the current edge as well.
+ * Otherwise, try and merge the clusters and mark "edge" as "no_merge"
+ * if the clusters did not end up getting merged, unless the non-merge
+ * is due to the fact that the edge was postponed.  This postponement
+ * can be recognized by a change in weight (from non-negative to negative).
+ */
+static isl_stat merge_clusters_along_edge(isl_ctx *ctx,
+	struct isl_sched_graph *graph, int edge, struct isl_clustering *c)
+{
+	isl_bool merged;
+	int edge_weight = graph->edgeedge.weight;
+
+	if (mark_merge_sccs(ctx, graph, edge, c) < 0)
+		return isl_stat_error;
+
+	if (any_no_merge(graph, c->scc_in_merge, &graph->edgeedge))
+		merged = isl_bool_false;
+	else
+		merged = try_merge(ctx, graph, c);
+	if (merged < 0)
+		return isl_stat_error;
+	if (!merged && edge_weight == graph->edgeedge.weight)
+		graph->edgeedge.no_merge = 1;
+
+	return isl_stat_ok;
+}
+
+/* Does "node" belong to the cluster identified by "cluster"?
  */
-static int compute_component_schedule(isl_ctx *ctx,
-	struct isl_sched_graph *graph)
+static int node_cluster_exactly(struct isl_sched_node *node, int cluster)
 {
-	int wcc, i;
-	int n, n_edge;
-	int n_total_row, orig_total_row;
-	int n_band, orig_band;
-
-	if (ctx->opt->schedule_fuse == ISL_SCHEDULE_FUSE_MIN ||
-	    ctx->opt->schedule_separate_components)
-		if (split_on_scc(ctx, graph) < 0)
-			return -1;
+	return node->cluster == cluster;
+}
+
+/* Does "edge" connect two nodes belonging to the cluster
+ * identified by "cluster"?
+ */
+static int edge_cluster_exactly(struct isl_sched_edge *edge, int cluster)
+{
+	return edge->src->cluster == cluster && edge->dst->cluster == cluster;
+}
+
+/* Swap the schedule of "node1" and "node2".
+ * Both nodes have been derived from the same node in a common parent graph.
+ * Since the "coincident" field is shared with that node
+ * in the parent graph, there is no need to also swap this field.
+ */
+static void swap_sched(struct isl_sched_node *node1,
+	struct isl_sched_node *node2)
+{
+	isl_mat *sched;
+	isl_map *sched_map;
+
+	sched = node1->sched;
+	node1->sched = node2->sched;
+	node2->sched = sched;
+
+	sched_map = node1->sched_map;
+	node1->sched_map = node2->sched_map;
+	node2->sched_map = sched_map;
+}
+
+/* Copy the current band schedule from the SCCs that form the cluster
+ * with index "pos" to the actual cluster at position "pos".
+ * By construction, the index of the first SCC that belongs to the cluster
+ * is also "pos".
+ *
+ * The order of the nodes inside both the SCCs and the cluster
+ * is assumed to be same as the order in the original "graph".
+ *
+ * Since the SCC graphs will no longer be used after this function,
+ * the schedules are actually swapped rather than copied.
+ */
+static isl_stat copy_partial(struct isl_sched_graph *graph,
+	struct isl_clustering *c, int pos)
+{
+	int i, j;
+
+	c->clusterpos.n_total_row = c->sccpos.n_total_row;
+	c->clusterpos.n_row = c->sccpos.n_row;
+	c->clusterpos.maxvar = c->sccpos.maxvar;
+	j = 0;
+	for (i = 0; i < graph->n; ++i) {
+		int k;
+		int s;
+
+		if (graph->nodei.cluster != pos)
+			continue;
+		s = graph->nodei.scc;
+		k = c->scc_nodes++;
+		swap_sched(&c->clusterpos.nodej, &c->sccs.nodek);
+		if (c->sccs.maxvar > c->clusterpos.maxvar)
+			c->clusterpos.maxvar = c->sccs.maxvar;
+		++j;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Is there a (conditional) validity dependence from nodej to nodei,
+ * forcing nodei to follow nodej or do the nodes belong to the same
+ * cluster?
+ */
+static isl_bool node_follows_strong_or_same_cluster(int i, int j, void *user)
+{
+	struct isl_sched_graph *graph = user;
+
+	if (graph->nodei.cluster == graph->nodej.cluster)
+		return isl_bool_true;
+	return graph_has_validity_edge(graph, &graph->nodej, &graph->nodei);
+}
+
+/* Extract the merged clusters of SCCs in "graph", sort them, and
+ * store them in c->clusters.  Update c->scc_cluster accordingly.
+ *
+ * First keep track of the cluster containing the SCC to which a node
+ * belongs in the node itself.
+ * Then extract the clusters into c->clusters, copying the current
+ * band schedule from the SCCs that belong to the cluster.
+ * Do this only once per cluster.
+ *
+ * Finally, topologically sort the clusters and update c->scc_cluster
+ * to match the new scc numbering.  While the SCCs were originally
+ * sorted already, some SCCs that depend on some other SCCs may
+ * have been merged with SCCs that appear before these other SCCs.
+ * A reordering may therefore be required.
+ */
+static isl_stat extract_clusters(isl_ctx *ctx, struct isl_sched_graph *graph,
+	struct isl_clustering *c)
+{
+	int i;
 
-	n_total_row = 0;
-	orig_total_row = graph->n_total_row;
-	n_band = 0;
-	orig_band = graph->n_band;
 	for (i = 0; i < graph->n; ++i)
-		graph->nodei.band_idgraph->n_band += graph->nodei.scc;
-	for (wcc = 0; wcc < graph->scc; ++wcc) {
-		n = 0;
-		for (i = 0; i < graph->n; ++i)
-			if (graph->nodei.scc == wcc)
-				n++;
-		n_edge = 0;
-		for (i = 0; i < graph->n_edge; ++i)
-			if (graph->edgei.src->scc == wcc &&
-			    graph->edgei.dst->scc == wcc)
-				n_edge++;
+		graph->nodei.cluster = c->scc_clustergraph->nodei.scc;
 
-		if (compute_sub_schedule(ctx, graph, n, n_edge,
-				    &node_scc_exactly,
-				    &edge_scc_exactly, wcc, 1) < 0)
-			return -1;
-		if (graph->n_total_row > n_total_row)
-			n_total_row = graph->n_total_row;
-		graph->n_total_row = orig_total_row;
-		if (graph->n_band > n_band)
-			n_band = graph->n_band;
-		graph->n_band = orig_band;
+	for (i = 0; i < graph->scc; ++i) {
+		if (c->scc_clusteri != i)
+			continue;
+		if (extract_sub_graph(ctx, graph, &node_cluster_exactly,
+				&edge_cluster_exactly, i, &c->clusteri) < 0)
+			return isl_stat_error;
+		c->clusteri.src_scc = -1;
+		c->clusteri.dst_scc = -1;
+		if (copy_partial(graph, c, i) < 0)
+			return isl_stat_error;
+	}
+
+	if (detect_ccs(ctx, graph, &node_follows_strong_or_same_cluster) < 0)
+		return isl_stat_error;
+	for (i = 0; i < graph->n; ++i)
+		c->scc_clustergraph->nodei.scc = graph->nodei.cluster;
+
+	return isl_stat_ok;
+}
+
+/* Compute weights on the proximity edges of "graph" that can
+ * be used by find_proximity to find the most appropriate
+ * proximity edge to use to merge two clusters in "c".
+ * The weights are also used by has_bounded_distances to determine
+ * whether the merge should be allowed.
+ * Store the maximum of the computed weights in graph->max_weight.
+ *
+ * The computed weight is a measure for the number of remaining schedule
+ * dimensions that can still be completely aligned.
+ * In particular, compute the number of equalities between
+ * input dimensions and output dimensions in the proximity constraints.
+ * The directions that are already handled by outer schedule bands
+ * are projected out prior to determining this number.
+ *
+ * Edges that will never be considered by find_proximity are ignored.
+ */
+static isl_stat compute_weights(struct isl_sched_graph *graph,
+	struct isl_clustering *c)
+{
+	int i;
+
+	graph->max_weight = 0;
+
+	for (i = 0; i < graph->n_edge; ++i) {
+		struct isl_sched_edge *edge = &graph->edgei;
+		struct isl_sched_node *src = edge->src;
+		struct isl_sched_node *dst = edge->dst;
+		isl_basic_map *hull;
+		isl_bool prox;
+		isl_size n_in, n_out, n;
+
+		prox = is_non_empty_proximity(edge);
+		if (prox < 0)
+			return isl_stat_error;
+		if (!prox)
+			continue;
+		if (bad_cluster(&c->sccedge->src->scc) ||
+		    bad_cluster(&c->sccedge->dst->scc))
+			continue;
+		if (c->scc_clusteredge->dst->scc ==
+		    c->scc_clusteredge->src->scc)
+			continue;
+
+		hull = isl_map_affine_hull(isl_map_copy(edge->map));
+		hull = isl_basic_map_transform_dims(hull, isl_dim_in, 0,
+						    isl_mat_copy(src->vmap));
+		hull = isl_basic_map_transform_dims(hull, isl_dim_out, 0,
+						    isl_mat_copy(dst->vmap));
+		hull = isl_basic_map_project_out(hull,
+						isl_dim_in, 0, src->rank);
+		hull = isl_basic_map_project_out(hull,
+						isl_dim_out, 0, dst->rank);
+		hull = isl_basic_map_remove_divs(hull);
+		n_in = isl_basic_map_dim(hull, isl_dim_in);
+		n_out = isl_basic_map_dim(hull, isl_dim_out);
+		if (n_in < 0 || n_out < 0)
+			hull = isl_basic_map_free(hull);
+		hull = isl_basic_map_drop_constraints_not_involving_dims(hull,
+							isl_dim_in, 0, n_in);
+		hull = isl_basic_map_drop_constraints_not_involving_dims(hull,
+							isl_dim_out, 0, n_out);
+		n = isl_basic_map_n_equality(hull);
+		isl_basic_map_free(hull);
+		if (n < 0)
+			return isl_stat_error;
+		edge->weight = n;
+
+		if (edge->weight > graph->max_weight)
+			graph->max_weight = edge->weight;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Call compute_schedule_finish_band on each of the clusters in "c"
+ * in their topological order.  This order is determined by the scc
+ * fields of the nodes in "graph".
+ * Combine the results in a sequence expressing the topological order.
+ *
+ * If there is only one cluster left, then there is no need to introduce
+ * a sequence node.  Also, in this case, the cluster necessarily contains
+ * the SCC at position 0 in the original graph and is therefore also
+ * stored in the first cluster of "c".
+ */
+static __isl_give isl_schedule_node *finish_bands_clustering(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	struct isl_clustering *c)
+{
+	int i;
+	isl_ctx *ctx;
+	isl_union_set_list *filters;
+
+	if (graph->scc == 1)
+		return compute_schedule_finish_band(node, &c->cluster0, 0);
+
+	ctx = isl_schedule_node_get_ctx(node);
+
+	filters = extract_sccs(ctx, graph);
+	node = isl_schedule_node_insert_sequence(node, filters);
+
+	for (i = 0; i < graph->scc; ++i) {
+		int j = c->scc_clusteri;
+		node = isl_schedule_node_child(node, i);
+		node = isl_schedule_node_child(node, 0);
+		node = compute_schedule_finish_band(node, &c->clusterj, 0);
+		node = isl_schedule_node_parent(node);
+		node = isl_schedule_node_parent(node);
+	}
+
+	return node;
+}
+
+/* Compute a schedule for a connected dependence graph by first considering
+ * each strongly connected component (SCC) in the graph separately and then
+ * incrementally combining them into clusters.
+ * Return the updated schedule node.
+ *
+ * Initially, each cluster consists of a single SCC, each with its
+ * own band schedule.  The algorithm then tries to merge pairs
+ * of clusters along a proximity edge until no more suitable
+ * proximity edges can be found.  During this merging, the schedule
+ * is maintained in the individual SCCs.
+ * After the merging is completed, the full resulting clusters
+ * are extracted and in finish_bands_clustering,
+ * compute_schedule_finish_band is called on each of them to integrate
+ * the band into "node" and to continue the computation.
+ *
+ * compute_weights initializes the weights that are used by find_proximity.
+ */
+static __isl_give isl_schedule_node *compute_schedule_wcc_clustering(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	isl_ctx *ctx;
+	struct isl_clustering c;
+	int i;
+
+	ctx = isl_schedule_node_get_ctx(node);
+
+	if (clustering_init(ctx, &c, graph) < 0)
+		goto error;
+
+	if (compute_weights(graph, &c) < 0)
+		goto error;
+
+	for (;;) {
+		i = find_proximity(graph, &c);
+		if (i < 0)
+			goto error;
+		if (i >= graph->n_edge)
+			break;
+		if (merge_clusters_along_edge(ctx, graph, i, &c) < 0)
+			goto error;
+	}
+
+	if (extract_clusters(ctx, graph, &c) < 0)
+		goto error;
+
+	node = finish_bands_clustering(node, graph, &c);
+
+	clustering_free(ctx, &c);
+	return node;
+error:
+	clustering_free(ctx, &c);
+	return isl_schedule_node_free(node);
+}
+
+/* Compute a schedule for a connected dependence graph and return
+ * the updated schedule node.
+ *
+ * If Feautrier's algorithm is selected, we first recursively try to satisfy
+ * as many validity dependences as possible. When all validity dependences
+ * are satisfied we extend the schedule to a full-dimensional schedule.
+ *
+ * Call compute_schedule_wcc_whole or compute_schedule_wcc_clustering
+ * depending on whether the user has selected the option to try and
+ * compute a schedule for the entire (weakly connected) component first.
+ * If there is only a single strongly connected component (SCC), then
+ * there is no point in trying to combine SCCs
+ * in compute_schedule_wcc_clustering, so compute_schedule_wcc_whole
+ * is called instead.
+ */
+static __isl_give isl_schedule_node *compute_schedule_wcc(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph)
+{
+	isl_ctx *ctx;
+
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	if (detect_sccs(ctx, graph) < 0)
+		return isl_schedule_node_free(node);
+
+	if (compute_maxvar(graph) < 0)
+		return isl_schedule_node_free(node);
+
+	if (need_feautrier_step(ctx, graph))
+		return compute_schedule_wcc_feautrier(node, graph);
+
+	if (graph->scc <= 1 || isl_options_get_schedule_whole_component(ctx))
+		return compute_schedule_wcc_whole(node, graph);
+	else
+		return compute_schedule_wcc_clustering(node, graph);
+}
+
+/* Compute a schedule for each group of nodes identified by node->scc
+ * separately and then combine them in a sequence node (or as set node
+ * if graph->weak is set) inserted at position "node" of the schedule tree.
+ * Return the updated schedule node.
+ *
+ * If "wcc" is set then each of the groups belongs to a single
+ * weakly connected component in the dependence graph so that
+ * there is no need for compute_sub_schedule to look for weakly
+ * connected components.
+ *
+ * If a set node would be introduced and if the number of components
+ * is equal to the number of nodes, then check if the schedule
+ * is already complete.  If so, a redundant set node would be introduced
+ * (without any further descendants) stating that the statements
+ * can be executed in arbitrary order, which is also expressed
+ * by the absence of any node.  Refrain from inserting any nodes
+ * in this case and simply return.
+ */
+static __isl_give isl_schedule_node *compute_component_schedule(
+	__isl_take isl_schedule_node *node, struct isl_sched_graph *graph,
+	int wcc)
+{
+	int component;
+	isl_ctx *ctx;
+	isl_union_set_list *filters;
+
+	if (!node)
+		return NULL;
+
+	if (graph->weak && graph->scc == graph->n) {
+		if (compute_maxvar(graph) < 0)
+			return isl_schedule_node_free(node);
+		if (graph->n_row >= graph->maxvar)
+			return node;
 	}
 
-	graph->n_total_row = n_total_row;
-	graph->n_band = n_band;
+	ctx = isl_schedule_node_get_ctx(node);
+	filters = extract_sccs(ctx, graph);
+	if (graph->weak)
+		node = isl_schedule_node_insert_set(node, filters);
+	else
+		node = isl_schedule_node_insert_sequence(node, filters);
 
-	return pad_schedule(graph);
+	for (component = 0; component < graph->scc; ++component) {
+		node = isl_schedule_node_child(node, component);
+		node = isl_schedule_node_child(node, 0);
+		node = compute_sub_schedule(node, ctx, graph,
+				    &node_scc_exactly,
+				    &edge_scc_exactly, component, wcc);
+		node = isl_schedule_node_parent(node);
+		node = isl_schedule_node_parent(node);
+	}
+
+	return node;
 }
 
-/* Compute a schedule for the given dependence graph.
+/* Compute a schedule for the given dependence graph and insert it at "node".
+ * Return the updated schedule node.
+ *
  * We first check if the graph is connected (through validity and conditional
  * validity dependences) and, if not, compute a schedule
  * for each component separately.
- * If schedule_fuse is set to minimal fusion, then we check for strongly
+ * If the schedule_serialize_sccs option is set, then we check for strongly
  * connected components instead and compute a separate schedule for
  * each such strongly connected component.
  */
-static int compute_schedule(isl_ctx *ctx, struct isl_sched_graph *graph)
+static __isl_give isl_schedule_node *compute_schedule(isl_schedule_node *node,
+	struct isl_sched_graph *graph)
 {
-	if (ctx->opt->schedule_fuse == ISL_SCHEDULE_FUSE_MIN) {
+	isl_ctx *ctx;
+
+	if (!node)
+		return NULL;
+
+	ctx = isl_schedule_node_get_ctx(node);
+	if (isl_options_get_schedule_serialize_sccs(ctx)) {
 		if (detect_sccs(ctx, graph) < 0)
-			return -1;
+			return isl_schedule_node_free(node);
 	} else {
 		if (detect_wccs(ctx, graph) < 0)
-			return -1;
+			return isl_schedule_node_free(node);
 	}
 
 	if (graph->scc > 1)
-		return compute_component_schedule(ctx, graph);
+		return compute_component_schedule(node, graph, 1);
 
-	return compute_schedule_wcc(ctx, graph);
+	return compute_schedule_wcc(node, graph);
 }
 
 /* Compute a schedule on sc->domain that respects the given schedule
@@ -4077,54 +7611,33 @@
 	isl_ctx *ctx = isl_schedule_constraints_get_ctx(sc);
 	struct isl_sched_graph graph = { 0 };
 	isl_schedule *sched;
-	struct isl_extract_edge_data data;
-	enum isl_edge_type i;
+	isl_schedule_node *node;
+	isl_union_set *domain;
+	isl_size n;
 
 	sc = isl_schedule_constraints_align_params(sc);
-	if (!sc)
-		return NULL;
-
-	graph.n = isl_union_set_n_set(sc->domain);
-	if (graph.n == 0)
-		goto empty;
-	if (graph_alloc(ctx, &graph, graph.n,
-	    isl_schedule_constraints_n_map(sc)) < 0)
-		goto error;
-	if (compute_max_row(&graph, sc) < 0)
-		goto error;
-	graph.root = 1;
-	graph.n = 0;
-	if (isl_union_set_foreach_set(sc->domain, &extract_node, &graph) < 0)
-		goto error;
-	if (graph_init_table(ctx, &graph) < 0)
-		goto error;
-	for (i = isl_edge_first; i <= isl_edge_last; ++i)
-		graph.max_edgei = isl_union_map_n_map(sc->constrainti);
-	if (graph_init_edge_tables(ctx, &graph) < 0)
-		goto error;
-	graph.n_edge = 0;
-	data.graph = &graph;
-	for (i = isl_edge_first; i <= isl_edge_last; ++i) {
-		data.type = i;
-		if (isl_union_map_foreach_map(sc->constrainti,
-						&extract_edge, &data) < 0)
-			goto error;
-	}
-
-	if (compute_schedule(ctx, &graph) < 0)
-		goto error;
 
-empty:
-	sched = extract_schedule(&graph, isl_union_set_get_space(sc->domain));
+	domain = isl_schedule_constraints_get_domain(sc);
+	n = isl_union_set_n_set(domain);
+	if (n == 0) {
+		isl_schedule_constraints_free(sc);
+		return isl_schedule_from_domain(domain);
+	}
+
+	if (n < 0 || graph_init(&graph, sc) < 0)
+		domain = isl_union_set_free(domain);
+
+	node = isl_schedule_node_from_domain(domain);
+	node = isl_schedule_node_child(node, 0);
+	if (graph.n > 0)
+		node = compute_schedule(node, &graph);
+	sched = isl_schedule_node_get_schedule(node);
+	isl_schedule_node_free(node);
 
 	graph_free(ctx, &graph);
 	isl_schedule_constraints_free(sc);
 
 	return sched;
-error:
-	graph_free(ctx, &graph);
-	isl_schedule_constraints_free(sc);
-	return NULL;
 }
 
 /* Compute a schedule for the given union of domains that respects

_service:tar_scm:isl-0.14.tar.xz/isl_seq.c -> _service:tar_scm:isl-0.24.tar.gz/isl_seq.c Changed

@@ -1,5 +1,6 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
+ * Copyright 2011      INRIA Saclay
  *
  * Use of this software is governed by the MIT license
  *
@@ -107,6 +108,14 @@
 	int i;
 	isl_int tmp;
 
+	if (dst == src1 && isl_int_is_one(m1)) {
+		if (isl_int_is_zero(m2))
+			return;
+		for (i = 0; i < len; ++i)
+			isl_int_addmul(src1i, m2, src2i);
+		return;
+	}
+
 	isl_int_init(tmp);
 	for (i = 0; i < len; ++i) {
 		isl_int_mul(tmp, m1, src1i);
@@ -116,9 +125,12 @@
 	isl_int_clear(tmp);
 }
 
-/*
- * Let d = dstpos and s = srcpos
- * dst is replaced by |s| dst - sgn(s)d src
+/* Eliminate element "pos" from "dst" using "src".
+ * In particular, let d = dstpos and s = srcpos, then
+ * dst is replaced by (|s| dst - sgn(s)d src)/gcd(s,d),
+ * such that dstpos is zero after the elimination.
+ * If "m" is not NULL, then *m is multiplied by |s|/gcd(s,d).
+ * That is, it is multiplied by the same factor as "dst".
  */
 void isl_seq_elim(isl_int *dst, isl_int *src, unsigned pos, unsigned len,
 		  isl_int *m)
@@ -293,6 +305,36 @@
 	return hash;
 }
 
+/* Given two affine expressions "p" of length p_len (including the
+ * denominator and the constant term) and "subs" of length subs_len,
+ * plug in "subs" for the variable at position "pos".
+ * The variables of "subs" and "p" are assumed to match up to subs_len,
+ * but "p" may have additional variables.
+ * "v" is an initialized isl_int that can be used internally.
+ *
+ * In particular, if "p" represents the expression
+ *
+ *	(a i + g)/m
+ *
+ * with i the variable at position "pos" and "subs" represents the expression
+ *
+ *	f/d
+ *
+ * then the result represents the expression
+ *
+ *	(a f + d g)/(m d)
+ *
+ */
+void isl_seq_substitute(isl_int *p, int pos, isl_int *subs,
+	int p_len, int subs_len, isl_int v)
+{
+	isl_int_set(v, p1 + pos);
+	isl_int_set_si(p1 + pos, 0);
+	isl_seq_combine(p + 1, subs0, p + 1, v, subs + 1, subs_len - 1);
+	isl_seq_scale(p + subs_len, p + subs_len, subs0, p_len - subs_len);
+	isl_int_mul(p0, p0, subs0);
+}
+
 uint32_t isl_seq_get_hash(isl_int *p, unsigned len)
 {
 	uint32_t hash = isl_hash_init();

_service:tar_scm:isl-0.14.tar.xz/isl_seq.h -> _service:tar_scm:isl-0.24.tar.gz/isl_seq.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_set_list.c -> _service:tar_scm:isl-0.24.tar.gz/isl_set_list.c Changed

_service:tar_scm:isl-0.24.tar.gz/isl_set_to_ast_graft_list.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_set_to_ast_graft_list.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_space.c -> _service:tar_scm:isl-0.24.tar.gz/isl_space.c Changed

@@ -2,6 +2,7 @@
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
  * Copyright 2013-2014 Ecole Normale Superieure
+ * Copyright 2018-2019 Cerebras Systems
  *
  * Use of this software is governed by the MIT license
  *
@@ -10,6 +11,7 @@
  * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
  * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France 
  * and Ecole Normale Superieure, 45 rue d’Ulm, 75230 Paris, France
+ * and Cerebras Systems, 175 S San Antonio Rd, Los Altos, CA, USA
  */
 
 #include <stdlib.h>
@@ -18,37 +20,37 @@
 #include <isl_id_private.h>
 #include <isl_reordering.h>
 
-isl_ctx *isl_space_get_ctx(__isl_keep isl_space *dim)
+isl_ctx *isl_space_get_ctx(__isl_keep isl_space *space)
 {
-	return dim ? dim->ctx : NULL;
+	return space ? space->ctx : NULL;
 }
 
 __isl_give isl_space *isl_space_alloc(isl_ctx *ctx,
 			unsigned nparam, unsigned n_in, unsigned n_out)
 {
-	isl_space *dim;
+	isl_space *space;
 
-	dim = isl_alloc_type(ctx, struct isl_space);
-	if (!dim)
+	space = isl_alloc_type(ctx, struct isl_space);
+	if (!space)
 		return NULL;
 
-	dim->ctx = ctx;
+	space->ctx = ctx;
 	isl_ctx_ref(ctx);
-	dim->ref = 1;
-	dim->nparam = nparam;
-	dim->n_in = n_in;
-	dim->n_out = n_out;
+	space->ref = 1;
+	space->nparam = nparam;
+	space->n_in = n_in;
+	space->n_out = n_out;
 
-	dim->tuple_id0 = NULL;
-	dim->tuple_id1 = NULL;
+	space->tuple_id0 = NULL;
+	space->tuple_id1 = NULL;
 
-	dim->nested0 = NULL;
-	dim->nested1 = NULL;
+	space->nested0 = NULL;
+	space->nested1 = NULL;
 
-	dim->n_id = 0;
-	dim->ids = NULL;
+	space->n_id = 0;
+	space->ids = NULL;
 
-	return dim;
+	return space;
 }
 
 /* Mark the space as being that of a set, by setting the domain tuple
@@ -65,25 +67,90 @@
 
 /* Is the space that of a set?
  */
-int isl_space_is_set(__isl_keep isl_space *space)
+isl_bool isl_space_is_set(__isl_keep isl_space *space)
 {
 	if (!space)
-		return -1;
+		return isl_bool_error;
 	if (space->n_in != 0 || space->nested0)
-		return 0;
+		return isl_bool_false;
 	if (space->tuple_id0 != &isl_id_none)
-		return 0;
-	return 1;
+		return isl_bool_false;
+	return isl_bool_true;
+}
+
+/* Check that "space" is a set space.
+ */
+isl_stat isl_space_check_is_set(__isl_keep isl_space *space)
+{
+	isl_bool is_set;
+
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_stat_error;
+	if (!is_set)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"space is not a set", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 /* Is the given space that of a map?
  */
-int isl_space_is_map(__isl_keep isl_space *space)
+isl_bool isl_space_is_map(__isl_keep isl_space *space)
 {
+	int r;
+
 	if (!space)
-		return -1;
-	return space->tuple_id0 != &isl_id_none &&
-		space->tuple_id1 != &isl_id_none;
+		return isl_bool_error;
+	r = space->tuple_id0 != &isl_id_none &&
+	    space->tuple_id1 != &isl_id_none;
+	return isl_bool_ok(r);
+}
+
+/* Check that "space" is the space of a map.
+ */
+static isl_stat isl_space_check_is_map(__isl_keep isl_space *space)
+{
+	isl_bool is_space;
+
+	is_space = isl_space_is_map(space);
+	if (is_space < 0)
+		return isl_stat_error;
+	if (!is_space)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"expecting map space", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that "space" is the space of a map
+ * where the domain is a wrapped map space.
+ */
+isl_stat isl_space_check_domain_is_wrapping(__isl_keep isl_space *space)
+{
+	isl_bool wrapping;
+
+	wrapping = isl_space_domain_is_wrapping(space);
+	if (wrapping < 0)
+		return isl_stat_error;
+	if (!wrapping)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"domain not a product", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that "space" is the space of a map
+ * where the range is a wrapped map space.
+ */
+isl_stat isl_space_check_range_is_wrapping(__isl_keep isl_space *space)
+{
+	isl_bool wrapping;
+
+	wrapping = isl_space_range_is_wrapping(space);
+	if (wrapping < 0)
+		return isl_stat_error;
+	if (!wrapping)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"range not a product", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 __isl_give isl_space *isl_space_set_alloc(isl_ctx *ctx,
@@ -109,18 +176,18 @@
 
 /* Is the space that of a parameter domain?
  */
-int isl_space_is_params(__isl_keep isl_space *space)
+isl_bool isl_space_is_params(__isl_keep isl_space *space)
 {
 	if (!space)
-		return -1;
+		return isl_bool_error;
 	if (space->n_in != 0 || space->nested0 ||
 	    space->n_out != 0 || space->nested1)
-		return 0;
+		return isl_bool_false;
 	if (space->tuple_id0 != &isl_id_none)
-		return 0;
+		return isl_bool_false;
 	if (space->tuple_id1 != &isl_id_none)
-		return 0;
-	return 1;
+		return isl_bool_false;
+	return isl_bool_true;
 }
 
 /* Create a space for a parameter domain.
@@ -133,139 +200,173 @@
 	return space;
 }
 
-static unsigned global_pos(__isl_keep isl_space *dim,
+/* Create a space for a parameter domain, without any parameters.
+ */
+__isl_give isl_space *isl_space_unit(isl_ctx *ctx)
+{
+	return isl_space_params_alloc(ctx, 0);
+}
+
+static isl_size global_pos(__isl_keep isl_space *space,
 				 enum isl_dim_type type, unsigned pos)
 {
-	struct isl_ctx *ctx = dim->ctx;
+	if (isl_space_check_range(space, type, pos, 1) < 0)
+		return isl_size_error;
 
 	switch (type) {
 	case isl_dim_param:
-		isl_assert(ctx, pos < dim->nparam,
-			    return isl_space_dim(dim, isl_dim_all));
 		return pos;
 	case isl_dim_in:
-		isl_assert(ctx, pos < dim->n_in,
-			    return isl_space_dim(dim, isl_dim_all));
-		return pos + dim->nparam;
+		return pos + space->nparam;
 	case isl_dim_out:
-		isl_assert(ctx, pos < dim->n_out,
-			    return isl_space_dim(dim, isl_dim_all));
-		return pos + dim->nparam + dim->n_in;
+		return pos + space->nparam + space->n_in;
 	default:
-		isl_assert(ctx, 0, return isl_space_dim(dim, isl_dim_all));
+		isl_assert(isl_space_get_ctx(space), 0, return isl_size_error);
 	}
-	return isl_space_dim(dim, isl_dim_all);
+	return isl_size_error;
 }
 
 /* Extend length of ids array to the total number of dimensions.
  */
-static __isl_give isl_space *extend_ids(__isl_take isl_space *dim)
+static __isl_give isl_space *extend_ids(__isl_take isl_space *space)
 {
 	isl_id **ids;
 	int i;
+	isl_size dim;
 
-	if (isl_space_dim(dim, isl_dim_all) <= dim->n_id)
-		return dim;
+	dim = isl_space_dim(space, isl_dim_all);
+	if (dim < 0)
+		return isl_space_free(space);
+	if (dim <= space->n_id)
+		return space;
 
-	if (!dim->ids) {
-		dim->ids = isl_calloc_array(dim->ctx,
-				isl_id *, isl_space_dim(dim, isl_dim_all));
-		if (!dim->ids)
+	if (!space->ids) {
+		space->ids = isl_calloc_array(space->ctx, isl_id *, dim);
+		if (!space->ids)
 			goto error;
 	} else {
-		ids = isl_realloc_array(dim->ctx, dim->ids,
-				isl_id *, isl_space_dim(dim, isl_dim_all));
+		ids = isl_realloc_array(space->ctx, space->ids, isl_id *, dim);
 		if (!ids)
 			goto error;
-		dim->ids = ids;
-		for (i = dim->n_id; i < isl_space_dim(dim, isl_dim_all); ++i)
-			dim->idsi = NULL;
+		space->ids = ids;
+		for (i = space->n_id; i < dim; ++i)
+			space->idsi = NULL;
 	}
 
-	dim->n_id = isl_space_dim(dim, isl_dim_all);
+	space->n_id = dim;
 
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-static __isl_give isl_space *set_id(__isl_take isl_space *dim,
+static __isl_give isl_space *set_id(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned pos, __isl_take isl_id *id)
 {
-	dim = isl_space_cow(dim);
+	isl_size gpos;
 
-	if (!dim)
-		goto error;
+	space = isl_space_cow(space);
 
-	pos = global_pos(dim, type, pos);
-	if (pos == isl_space_dim(dim, isl_dim_all))
+	gpos = global_pos(space, type, pos);
+	if (gpos < 0)
 		goto error;
 
-	if (pos >= dim->n_id) {
+	if (gpos >= space->n_id) {
 		if (!id)
-			return dim;
-		dim = extend_ids(dim);
-		if (!dim)
+			return space;
+		space = extend_ids(space);
+		if (!space)
 			goto error;
 	}
 
-	dim->idspos = id;
+	space->idsgpos = id;
 
-	return dim;
+	return space;
 error:
 	isl_id_free(id);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-static __isl_keep isl_id *get_id(__isl_keep isl_space *dim,
+static __isl_keep isl_id *get_id(__isl_keep isl_space *space,
 				 enum isl_dim_type type, unsigned pos)
 {
-	if (!dim)
-		return NULL;
+	isl_size gpos;
 
-	pos = global_pos(dim, type, pos);
-	if (pos == isl_space_dim(dim, isl_dim_all))
+	gpos = global_pos(space, type, pos);
+	if (gpos < 0)
 		return NULL;
-	if (pos >= dim->n_id)
+	if (gpos >= space->n_id)
+		return NULL;
+	return space->idsgpos;
+}
+
+/* Return the nested space at the given position.
+ */
+static __isl_keep isl_space *isl_space_peek_nested(__isl_keep isl_space *space,
+	int pos)
+{
+	if (!space)
 		return NULL;
-	return dim->idspos;
+	if (!space->nestedpos)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"no nested space", return NULL);
+	return space->nestedpos;
 }
 
-static unsigned offset(__isl_keep isl_space *dim, enum isl_dim_type type)
+static unsigned offset(__isl_keep isl_space *space, enum isl_dim_type type)
 {
 	switch (type) {
 	case isl_dim_param:	return 0;
-	case isl_dim_in:	return dim->nparam;
-	case isl_dim_out:	return dim->nparam + dim->n_in;
+	case isl_dim_in:	return space->nparam;
+	case isl_dim_out:	return space->nparam + space->n_in;
 	default:		return 0;
 	}
 }
 
-static unsigned n(__isl_keep isl_space *dim, enum isl_dim_type type)
+static unsigned n(__isl_keep isl_space *space, enum isl_dim_type type)
 {
 	switch (type) {
-	case isl_dim_param:	return dim->nparam;
-	case isl_dim_in:	return dim->n_in;
-	case isl_dim_out:	return dim->n_out;
-	case isl_dim_all:	return dim->nparam + dim->n_in + dim->n_out;
+	case isl_dim_param:	return space->nparam;
+	case isl_dim_in:	return space->n_in;
+	case isl_dim_out:	return space->n_out;
+	case isl_dim_all:
+		return space->nparam + space->n_in + space->n_out;
 	default:		return 0;
 	}
 }
 
-unsigned isl_space_dim(__isl_keep isl_space *dim, enum isl_dim_type type)
+isl_size isl_space_dim(__isl_keep isl_space *space, enum isl_dim_type type)
 {
-	if (!dim)
-		return 0;
-	return n(dim, type);
+	if (!space)
+		return isl_size_error;
+	return n(space, type);
+}
+
+/* Return the dimensionality of tuple "inner" within the wrapped relation
+ * inside tuple "outer".
+ */
+isl_size isl_space_wrapped_dim(__isl_keep isl_space *space,
+	enum isl_dim_type outer, enum isl_dim_type inner)
+{
+	int pos;
+
+	if (!space)
+		return isl_size_error;
+	if (outer != isl_dim_in && outer != isl_dim_out)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"only input, output and set tuples "
+			"can have nested relations", return isl_size_error);
+	pos = outer - isl_dim_in;
+	return isl_space_dim(isl_space_peek_nested(space, pos), inner);
 }
 
-unsigned isl_space_offset(__isl_keep isl_space *dim, enum isl_dim_type type)
+unsigned isl_space_offset(__isl_keep isl_space *space, enum isl_dim_type type)
 {
-	if (!dim)
+	if (!space)
 		return 0;
-	return offset(dim, type);
+	return offset(space, type);
 }
 
 static __isl_give isl_space *copy_ids(__isl_take isl_space *dst,
@@ -289,53 +390,56 @@
 	return dst;
 }
 
-__isl_take isl_space *isl_space_dup(__isl_keep isl_space *dim)
+__isl_take isl_space *isl_space_dup(__isl_keep isl_space *space)
 {
 	isl_space *dup;
-	if (!dim)
+	if (!space)
 		return NULL;
-	dup = isl_space_alloc(dim->ctx, dim->nparam, dim->n_in, dim->n_out);
+	dup = isl_space_alloc(space->ctx,
+				space->nparam, space->n_in, space->n_out);
 	if (!dup)
 		return NULL;
-	if (dim->tuple_id0 &&
-	    !(dup->tuple_id0 = isl_id_copy(dim->tuple_id0)))
+	if (space->tuple_id0 &&
+	    !(dup->tuple_id0 = isl_id_copy(space->tuple_id0)))
 		goto error;
-	if (dim->tuple_id1 &&
-	    !(dup->tuple_id1 = isl_id_copy(dim->tuple_id1)))
+	if (space->tuple_id1 &&
+	    !(dup->tuple_id1 = isl_id_copy(space->tuple_id1)))
 		goto error;
-	if (dim->nested0 && !(dup->nested0 = isl_space_copy(dim->nested0)))
+	if (space->nested0 &&
+	    !(dup->nested0 = isl_space_copy(space->nested0)))
 		goto error;
-	if (dim->nested1 && !(dup->nested1 = isl_space_copy(dim->nested1)))
+	if (space->nested1 &&
+	    !(dup->nested1 = isl_space_copy(space->nested1)))
 		goto error;
-	if (!dim->ids)
+	if (!space->ids)
 		return dup;
-	dup = copy_ids(dup, isl_dim_param, 0, dim, isl_dim_param);
-	dup = copy_ids(dup, isl_dim_in, 0, dim, isl_dim_in);
-	dup = copy_ids(dup, isl_dim_out, 0, dim, isl_dim_out);
+	dup = copy_ids(dup, isl_dim_param, 0, space, isl_dim_param);
+	dup = copy_ids(dup, isl_dim_in, 0, space, isl_dim_in);
+	dup = copy_ids(dup, isl_dim_out, 0, space, isl_dim_out);
 	return dup;
 error:
 	isl_space_free(dup);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_cow(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_cow(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	if (dim->ref == 1)
-		return dim;
-	dim->ref--;
-	return isl_space_dup(dim);
+	if (space->ref == 1)
+		return space;
+	space->ref--;
+	return isl_space_dup(space);
 }
 
-__isl_give isl_space *isl_space_copy(__isl_keep isl_space *dim)
+__isl_give isl_space *isl_space_copy(__isl_keep isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	dim->ref++;
-	return dim;
+	space->ref++;
+	return space;
 }
 
 __isl_null isl_space *isl_space_free(__isl_take isl_space *space)
@@ -382,6 +486,67 @@
 	return 1;
 }
 
+/* Return a copy of the nested space at the given position.
+ */
+static __isl_keep isl_space *isl_space_get_nested(__isl_keep isl_space *space,
+	int pos)
+{
+	return isl_space_copy(isl_space_peek_nested(space, pos));
+}
+
+/* Return the nested space at the given position.
+ * This may be either a copy or the nested space itself
+ * if there is only one reference to "space".
+ * This allows the nested space to be modified inplace
+ * if both "space" and the nested space have only a single reference.
+ * The caller is not allowed to modify "space" between this call and
+ * a subsequent call to isl_space_restore_nested.
+ * The only exception is that isl_space_free can be called instead.
+ */
+static __isl_give isl_space *isl_space_take_nested(__isl_keep isl_space *space,
+	int pos)
+{
+	isl_space *nested;
+
+	if (!space)
+		return NULL;
+	if (space->ref != 1)
+		return isl_space_get_nested(space, pos);
+	nested = space->nestedpos;
+	space->nestedpos = NULL;
+	return nested;
+}
+
+/* Replace the nested space at the given position by "nested",
+ * where this nested space of "space" may be missing
+ * due to a preceding call to isl_space_take_nested.
+ * However, in this case, "space" only has a single reference and
+ * then the call to isl_space_cow has no effect.
+ */
+static __isl_give isl_space *isl_space_restore_nested(
+	__isl_take isl_space *space, int pos, __isl_take isl_space *nested)
+{
+	if (!space || !nested)
+		goto error;
+
+	if (space->nestedpos == nested) {
+		isl_space_free(nested);
+		return space;
+	}
+
+	space = isl_space_cow(space);
+	if (!space)
+		goto error;
+	isl_space_free(space->nestedpos);
+	space->nestedpos = nested;
+
+	return space;
+error:
+	isl_space_free(space);
+	isl_space_free(nested);
+	return NULL;
+}
+
 /* Is it possible for the given dimension type to have a tuple id?
  */
 static int space_can_have_id(__isl_keep isl_space *space,
@@ -405,67 +570,130 @@
 
 /* Does the tuple have an id?
  */
-int isl_space_has_tuple_id(__isl_keep isl_space *dim, enum isl_dim_type type)
+isl_bool isl_space_has_tuple_id(__isl_keep isl_space *space,
+	enum isl_dim_type type)
 {
-	if (!space_can_have_id(dim, type))
-		return -1;
-	return dim->tuple_idtype - isl_dim_in != NULL;
+	if (!space_can_have_id(space, type))
+		return isl_bool_error;
+	return isl_bool_ok(space->tuple_idtype - isl_dim_in != NULL);
+}
+
+/* Does the domain tuple of the map space "space" have an identifier?
+ */
+isl_bool isl_space_has_domain_tuple_id(__isl_keep isl_space *space)
+{
+	if (isl_space_check_is_map(space) < 0)
+		return isl_bool_error;
+	return isl_space_has_tuple_id(space, isl_dim_in);
+}
+
+/* Does the range tuple of the map space "space" have an identifier?
+ */
+isl_bool isl_space_has_range_tuple_id(__isl_keep isl_space *space)
+{
+	if (isl_space_check_is_map(space) < 0)
+		return isl_bool_error;
+	return isl_space_has_tuple_id(space, isl_dim_out);
 }
 
-__isl_give isl_id *isl_space_get_tuple_id(__isl_keep isl_space *dim,
+__isl_give isl_id *isl_space_get_tuple_id(__isl_keep isl_space *space,
 	enum isl_dim_type type)
 {
 	int has_id;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	has_id = isl_space_has_tuple_id(dim, type);
+	has_id = isl_space_has_tuple_id(space, type);
 	if (has_id < 0)
 		return NULL;
 	if (!has_id)
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"tuple has no id", return NULL);
-	return isl_id_copy(dim->tuple_idtype - isl_dim_in);
+	return isl_id_copy(space->tuple_idtype - isl_dim_in);
+}
+
+/* Return the identifier of the domain tuple of the map space "space",
+ * assuming it has one.
+ */
+__isl_give isl_id *isl_space_get_domain_tuple_id(
+	__isl_keep isl_space *space)
+{
+	if (isl_space_check_is_map(space) < 0)
+		return NULL;
+	return isl_space_get_tuple_id(space, isl_dim_in);
+}
+
+/* Return the identifier of the range tuple of the map space "space",
+ * assuming it has one.
+ */
+__isl_give isl_id *isl_space_get_range_tuple_id(
+	__isl_keep isl_space *space)
+{
+	if (isl_space_check_is_map(space) < 0)
+		return NULL;
+	return isl_space_get_tuple_id(space, isl_dim_out);
 }
 
-__isl_give isl_space *isl_space_set_tuple_id(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_tuple_id(__isl_take isl_space *space,
 	enum isl_dim_type type, __isl_take isl_id *id)
 {
-	dim = isl_space_cow(dim);
-	if (!dim || !id)
+	space = isl_space_cow(space);
+	if (!space || !id)
 		goto error;
 	if (type != isl_dim_in && type != isl_dim_out)
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"only input, output and set tuples can have names",
 			goto error);
 
-	isl_id_free(dim->tuple_idtype - isl_dim_in);
-	dim->tuple_idtype - isl_dim_in = id;
+	isl_id_free(space->tuple_idtype - isl_dim_in);
+	space->tuple_idtype - isl_dim_in = id;
 
-	return dim;
+	return space;
 error:
 	isl_id_free(id);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_reset_tuple_id(__isl_take isl_space *dim,
+/* Replace the identifier of the domain tuple of the map space "space"
+ * by "id".
+ */
+__isl_give isl_space *isl_space_set_domain_tuple_id(
+	__isl_take isl_space *space, __isl_take isl_id *id)
+{
+	if (isl_space_check_is_map(space) < 0)
+		space = isl_space_free(space);
+	return isl_space_set_tuple_id(space, isl_dim_in, id);
+}
+
+/* Replace the identifier of the range tuple of the map space "space"
+ * by "id".
+ */
+__isl_give isl_space *isl_space_set_range_tuple_id(
+	__isl_take isl_space *space, __isl_take isl_id *id)
+{
+	if (isl_space_check_is_map(space) < 0)
+		space = isl_space_free(space);
+	return isl_space_set_tuple_id(space, isl_dim_out, id);
+}
+
+__isl_give isl_space *isl_space_reset_tuple_id(__isl_take isl_space *space,
 	enum isl_dim_type type)
 {
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
 	if (type != isl_dim_in && type != isl_dim_out)
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"only input, output and set tuples can have names",
 			goto error);
 
-	isl_id_free(dim->tuple_idtype - isl_dim_in);
-	dim->tuple_idtype - isl_dim_in = NULL;
+	isl_id_free(space->tuple_idtype - isl_dim_in);
+	space->tuple_idtype - isl_dim_in = NULL;
 
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -536,124 +764,124 @@
 	return NULL;
 }
 
-int isl_space_has_dim_id(__isl_keep isl_space *dim,
+isl_bool isl_space_has_dim_id(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos)
 {
-	if (!dim)
-		return -1;
-	return get_id(dim, type, pos) != NULL;
+	if (!space)
+		return isl_bool_error;
+	return isl_bool_ok(get_id(space, type, pos) != NULL);
 }
 
-__isl_give isl_id *isl_space_get_dim_id(__isl_keep isl_space *dim,
+__isl_give isl_id *isl_space_get_dim_id(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!get_id(dim, type, pos))
-		isl_die(dim->ctx, isl_error_invalid,
+	if (!get_id(space, type, pos))
+		isl_die(space->ctx, isl_error_invalid,
 			"dim has no id", return NULL);
-	return isl_id_copy(get_id(dim, type, pos));
+	return isl_id_copy(get_id(space, type, pos));
 }
 
-__isl_give isl_space *isl_space_set_tuple_name(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_tuple_name(__isl_take isl_space *space,
 	enum isl_dim_type type, const char *s)
 {
 	isl_id *id;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
 	if (!s)
-		return isl_space_reset_tuple_id(dim, type);
+		return isl_space_reset_tuple_id(space, type);
 
-	if (!name_ok(dim->ctx, s))
+	if (!name_ok(space->ctx, s))
 		goto error;
 
-	id = isl_id_alloc(dim->ctx, s, NULL);
-	return isl_space_set_tuple_id(dim, type, id);
+	id = isl_id_alloc(space->ctx, s, NULL);
+	return isl_space_set_tuple_id(space, type, id);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
 /* Does the tuple have a name?
  */
-int isl_space_has_tuple_name(__isl_keep isl_space *space,
+isl_bool isl_space_has_tuple_name(__isl_keep isl_space *space,
 	enum isl_dim_type type)
 {
 	isl_id *id;
 
 	if (!space_can_have_id(space, type))
-		return -1;
+		return isl_bool_error;
 	id = space->tuple_idtype - isl_dim_in;
-	return id && id->name;
+	return isl_bool_ok(id && id->name);
 }
 
-const char *isl_space_get_tuple_name(__isl_keep isl_space *dim,
+__isl_keep const char *isl_space_get_tuple_name(__isl_keep isl_space *space,
 	 enum isl_dim_type type)
 {
 	isl_id *id;
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (type != isl_dim_in && type != isl_dim_out)
 		return NULL;
-	id = dim->tuple_idtype - isl_dim_in;
+	id = space->tuple_idtype - isl_dim_in;
 	return id ? id->name : NULL;
 }
 
-__isl_give isl_space *isl_space_set_dim_name(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_set_dim_name(__isl_take isl_space *space,
 				 enum isl_dim_type type, unsigned pos,
 				 const char *s)
 {
 	isl_id *id;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (!s)
-		return isl_space_reset_dim_id(dim, type, pos);
-	if (!name_ok(dim->ctx, s))
+		return isl_space_reset_dim_id(space, type, pos);
+	if (!name_ok(space->ctx, s))
 		goto error;
-	id = isl_id_alloc(dim->ctx, s, NULL);
-	return isl_space_set_dim_id(dim, type, pos, id);
+	id = isl_id_alloc(space->ctx, s, NULL);
+	return isl_space_set_dim_id(space, type, pos, id);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
 /* Does the given dimension have a name?
  */
-int isl_space_has_dim_name(__isl_keep isl_space *space,
+isl_bool isl_space_has_dim_name(__isl_keep isl_space *space,
 	enum isl_dim_type type, unsigned pos)
 {
 	isl_id *id;
 
 	if (!space)
-		return -1;
+		return isl_bool_error;
 	id = get_id(space, type, pos);
-	return id && id->name;
+	return isl_bool_ok(id && id->name);
 }
 
-__isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *dim,
+__isl_keep const char *isl_space_get_dim_name(__isl_keep isl_space *space,
 				 enum isl_dim_type type, unsigned pos)
 {
-	isl_id *id = get_id(dim, type, pos);
+	isl_id *id = get_id(space, type, pos);
 	return id ? id->name : NULL;
 }
 
-int isl_space_find_dim_by_id(__isl_keep isl_space *dim, enum isl_dim_type type,
-	__isl_keep isl_id *id)
+int isl_space_find_dim_by_id(__isl_keep isl_space *space,
+	enum isl_dim_type type, __isl_keep isl_id *id)
 {
 	int i;
 	int offset;
-	int n;
+	isl_size n;
 
-	if (!dim || !id)
+	n = isl_space_dim(space, type);
+	if (n < 0 || !id)
 		return -1;
 
-	offset = isl_space_offset(dim, type);
-	n = isl_space_dim(dim, type);
-	for (i = 0; i < n && offset + i < dim->n_id; ++i)
-		if (dim->idsoffset + i == id)
+	offset = isl_space_offset(space, type);
+	for (i = 0; i < n && offset + i < space->n_id; ++i)
+		if (space->idsoffset + i == id)
 			return i;
 
 	return -1;
@@ -664,17 +892,18 @@
 {
 	int i;
 	int offset;
-	int n;
+	isl_size n;
 
-	if (!space || !name)
+	n = isl_space_dim(space, type);
+	if (n < 0 || !name)
 		return -1;
 
 	offset = isl_space_offset(space, type);
-	n = isl_space_dim(space, type);
-	for (i = 0; i < n && offset + i < space->n_id; ++i)
-		if (space->idsoffset + i->name &&
-		    !strcmp(space->idsoffset + i->name, name))
+	for (i = 0; i < n && offset + i < space->n_id; ++i) {
+		isl_id *id = get_id(space, type, i);
+		if (id && id->name && !strcmp(id->name, name))
 			return i;
+	}
 
 	return -1;
 }
@@ -725,58 +954,85 @@
 	}
 
 	for (i = 0; i < 2; ++i) {
+		isl_space *nested;
+
 		if (!space->nestedi)
 			continue;
-		space = isl_space_cow(space);
+		nested = isl_space_take_nested(space, i);
+		nested = isl_space_reset_user(nested);
+		space = isl_space_restore_nested(space, i, nested);
 		if (!space)
 			return NULL;
-		space->nestedi = isl_space_reset_user(space->nestedi);
-		if (!space->nestedi)
-			return isl_space_free(space);
 	}
 
 	return space;
 }
 
-static __isl_keep isl_id *tuple_id(__isl_keep isl_space *dim,
+static __isl_keep isl_id *tuple_id(__isl_keep isl_space *space,
 	enum isl_dim_type type)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (type == isl_dim_in)
-		return dim->tuple_id0;
+		return space->tuple_id0;
 	if (type == isl_dim_out)
-		return dim->tuple_id1;
+		return space->tuple_id1;
 	return NULL;
 }
 
-static __isl_keep isl_space *nested(__isl_keep isl_space *dim,
+static __isl_keep isl_space *nested(__isl_keep isl_space *space,
 	enum isl_dim_type type)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (type == isl_dim_in)
-		return dim->nested0;
+		return space->nested0;
 	if (type == isl_dim_out)
-		return dim->nested1;
+		return space->nested1;
 	return NULL;
 }
 
 /* Are the two spaces the same, apart from positions and names of parameters?
  */
-static int isl_space_has_equal_tuples(__isl_keep isl_space *space1,
+isl_bool isl_space_has_equal_tuples(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2)
 {
 	if (!space1 || !space2)
-		return -1;
+		return isl_bool_error;
 	if (space1 == space2)
-		return 1;
+		return isl_bool_true;
 	return isl_space_tuple_is_equal(space1, isl_dim_in,
 					space2, isl_dim_in) &&
 	       isl_space_tuple_is_equal(space1, isl_dim_out,
 					space2, isl_dim_out);
 }
 
+/* Check that a match involving "space" was successful.
+ * That is, check that "match" is equal to isl_bool_true.
+ */
+static isl_stat check_match(__isl_keep isl_space *space, isl_bool match)
+{
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"incompatible spaces", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Check that the two spaces are the same,
+ * apart from positions and names of parameters.
+ */
+isl_stat isl_space_check_equal_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool is_equal;
+
+	is_equal = isl_space_has_equal_tuples(space1, space2);
+	return check_match(space1, is_equal);
+}
+
 /* Check if the tuple of type "type1" of "space1" is the same as
  * the tuple of type "type2" of "space2".
  *
@@ -789,7 +1045,7 @@
  * to have result affected by possibly differing parameters
  * in those nested tuples.
  */
-int isl_space_tuple_is_equal(__isl_keep isl_space *space1,
+isl_bool isl_space_tuple_is_equal(__isl_keep isl_space *space1,
 	enum isl_dim_type type1, __isl_keep isl_space *space2,
 	enum isl_dim_type type2)
 {
@@ -797,148 +1053,240 @@
 	isl_space *nested1, *nested2;
 
 	if (!space1 || !space2)
-		return -1;
+		return isl_bool_error;
 
 	if (space1 == space2 && type1 == type2)
-		return 1;
+		return isl_bool_true;
 
 	if (n(space1, type1) != n(space2, type2))
-		return 0;
+		return isl_bool_false;
 	id1 = tuple_id(space1, type1);
 	id2 = tuple_id(space2, type2);
 	if (!id1 ^ !id2)
-		return 0;
+		return isl_bool_false;
 	if (id1 && id1 != id2)
-		return 0;
+		return isl_bool_false;
 	nested1 = nested(space1, type1);
 	nested2 = nested(space2, type2);
 	if (!nested1 ^ !nested2)
-		return 0;
+		return isl_bool_false;
 	if (nested1 && !isl_space_has_equal_tuples(nested1, nested2))
-		return 0;
-	return 1;
+		return isl_bool_false;
+	return isl_bool_true;
 }
 
-/* This is the old, undocumented, name for isl_space_tuple_is_equal.
- * It will be removed at some point.
+/* Is the tuple "inner" within the wrapped relation inside tuple "outer"
+ * of "space1" equal to tuple "type2" of "space2"?
+ */
+isl_bool isl_space_wrapped_tuple_is_equal(__isl_keep isl_space *space1,
+	enum isl_dim_type outer, enum isl_dim_type inner,
+	__isl_keep isl_space *space2, enum isl_dim_type type2)
+{
+	int pos;
+	isl_space *nested;
+
+	if (!space1)
+		return isl_bool_error;
+	if (outer != isl_dim_in && outer != isl_dim_out)
+		isl_die(isl_space_get_ctx(space1), isl_error_invalid,
+			"only input, output and set tuples "
+			"can have nested relations", return isl_bool_error);
+	pos = outer - isl_dim_in;
+	nested = isl_space_peek_nested(space1, pos);
+	return isl_space_tuple_is_equal(nested, inner, space2, type2);
+}
+
+/* Check that the tuple "inner" within the wrapped relation inside tuple "outer"
+ * of "space1" is equal to tuple "type2" of "space2".
  */
-int isl_space_tuple_match(__isl_keep isl_space *space1, enum isl_dim_type type1,
+isl_stat isl_space_check_wrapped_tuple_is_equal(__isl_keep isl_space *space1,
+	enum isl_dim_type outer, enum isl_dim_type inner,
 	__isl_keep isl_space *space2, enum isl_dim_type type2)
 {
-	return isl_space_tuple_is_equal(space1, type1, space2, type2);
+	isl_bool is_equal;
+
+	is_equal = isl_space_wrapped_tuple_is_equal(space1, outer, inner,
+							space2, type2);
+	return check_match(space1, is_equal);
 }
 
-static int match(__isl_keep isl_space *dim1, enum isl_dim_type dim1_type,
-	__isl_keep isl_space *dim2, enum isl_dim_type dim2_type)
+static isl_bool match(__isl_keep isl_space *space1, enum isl_dim_type type1,
+	__isl_keep isl_space *space2, enum isl_dim_type type2)
 {
 	int i;
+	isl_bool equal;
 
-	if (dim1 == dim2 && dim1_type == dim2_type)
-		return 1;
+	if (!space1 || !space2)
+		return isl_bool_error;
 
-	if (!isl_space_tuple_is_equal(dim1, dim1_type, dim2, dim2_type))
-		return 0;
+	if (space1 == space2 && type1 == type2)
+		return isl_bool_true;
 
-	if (!dim1->ids && !dim2->ids)
-		return 1;
+	equal = isl_space_tuple_is_equal(space1, type1, space2, type2);
+	if (equal < 0 || !equal)
+		return equal;
+
+	if (!space1->ids && !space2->ids)
+		return isl_bool_true;
 
-	for (i = 0; i < n(dim1, dim1_type); ++i) {
-		if (get_id(dim1, dim1_type, i) != get_id(dim2, dim2_type, i))
-			return 0;
+	for (i = 0; i < n(space1, type1); ++i) {
+		if (get_id(space1, type1, i) != get_id(space2, type2, i))
+			return isl_bool_false;
 	}
-	return 1;
+	return isl_bool_true;
 }
 
-int isl_space_match(__isl_keep isl_space *dim1, enum isl_dim_type dim1_type,
-	__isl_keep isl_space *dim2, enum isl_dim_type dim2_type)
+/* Do "space1" and "space2" have the same parameters?
+ */
+isl_bool isl_space_has_equal_params(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
 {
-	if (!dim1 || !dim2)
-		return -1;
+	return match(space1, isl_dim_param, space2, isl_dim_param);
+}
+
+/* Do "space1" and "space2" have the same identifiers for all
+ * the tuple variables?
+ */
+isl_bool isl_space_has_equal_ids(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool equal;
+
+	equal = match(space1, isl_dim_in, space2, isl_dim_in);
+	if (equal < 0 || !equal)
+		return equal;
+	return match(space1, isl_dim_out, space2, isl_dim_out);
+}
 
-	return match(dim1, dim1_type, dim2, dim2_type);
+isl_bool isl_space_match(__isl_keep isl_space *space1, enum isl_dim_type type1,
+	__isl_keep isl_space *space2, enum isl_dim_type type2)
+{
+	return match(space1, type1, space2, type2);
 }
 
-static void get_ids(__isl_keep isl_space *dim, enum isl_dim_type type,
+static void get_ids(__isl_keep isl_space *space, enum isl_dim_type type,
 	unsigned first, unsigned n, __isl_keep isl_id **ids)
 {
 	int i;
 
 	for (i = 0; i < n ; ++i)
-		idsi = get_id(dim, type, first + i);
+		idsi = get_id(space, type, first + i);
 }
 
-__isl_give isl_space *isl_space_extend(__isl_take isl_space *dim,
+static __isl_give isl_space *space_extend(__isl_take isl_space *space,
 			unsigned nparam, unsigned n_in, unsigned n_out)
 {
 	isl_id **ids = NULL;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (dim->nparam == nparam && dim->n_in == n_in && dim->n_out == n_out)
-		return dim;
+	if (space->nparam == nparam &&
+	    space->n_in == n_in && space->n_out == n_out)
+		return space;
 
-	isl_assert(dim->ctx, dim->nparam <= nparam, goto error);
-	isl_assert(dim->ctx, dim->n_in <= n_in, goto error);
-	isl_assert(dim->ctx, dim->n_out <= n_out, goto error);
+	isl_assert(space->ctx, space->nparam <= nparam, goto error);
+	isl_assert(space->ctx, space->n_in <= n_in, goto error);
+	isl_assert(space->ctx, space->n_out <= n_out, goto error);
 
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		goto error;
 
-	if (dim->ids) {
-		ids = isl_calloc_array(dim->ctx, isl_id *,
-					 nparam + n_in + n_out);
+	if (space->ids) {
+		unsigned n;
+		n = nparam + n_in + n_out;
+		if (n < nparam || n < n_in || n < n_out)
+			isl_die(isl_space_get_ctx(space), isl_error_invalid,
+				"overflow in total number of dimensions",
+				goto error);
+		ids = isl_calloc_array(space->ctx, isl_id *, n);
 		if (!ids)
 			goto error;
-		get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
-		get_ids(dim, isl_dim_in, 0, dim->n_in, ids + nparam);
-		get_ids(dim, isl_dim_out, 0, dim->n_out, ids + nparam + n_in);
-		free(dim->ids);
-		dim->ids = ids;
-		dim->n_id = nparam + n_in + n_out;
+		get_ids(space, isl_dim_param, 0, space->nparam, ids);
+		get_ids(space, isl_dim_in, 0, space->n_in, ids + nparam);
+		get_ids(space, isl_dim_out, 0, space->n_out,
+			ids + nparam + n_in);
+		free(space->ids);
+		space->ids = ids;
+		space->n_id = nparam + n_in + n_out;
 	}
-	dim->nparam = nparam;
-	dim->n_in = n_in;
-	dim->n_out = n_out;
+	space->nparam = nparam;
+	space->n_in = n_in;
+	space->n_out = n_out;
 
-	return dim;
+	return space;
 error:
 	free(ids);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_extend(__isl_take isl_space *space,
+	unsigned nparam, unsigned n_in, unsigned n_out)
+{
+	return space_extend(space, nparam, n_in, n_out);
+}
+
+__isl_give isl_space *isl_space_add_dims(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned n)
 {
-	if (!dim)
+	space = isl_space_reset(space, type);
+	if (!space)
 		return NULL;
-	dim = isl_space_reset(dim, type);
 	switch (type) {
 	case isl_dim_param:
-		dim = isl_space_extend(dim,
-					dim->nparam + n, dim->n_in, dim->n_out);
-		if (dim && dim->nested0 &&
-		    !(dim->nested0 = isl_space_add_dims(dim->nested0,
+		space = space_extend(space,
+				space->nparam + n, space->n_in, space->n_out);
+		if (space && space->nested0 &&
+		    !(space->nested0 = isl_space_add_dims(space->nested0,
 						    isl_dim_param, n)))
 			goto error;
-		if (dim && dim->nested1 &&
-		    !(dim->nested1 = isl_space_add_dims(dim->nested1,
+		if (space && space->nested1 &&
+		    !(space->nested1 = isl_space_add_dims(space->nested1,
 						    isl_dim_param, n)))
 			goto error;
-		return dim;
+		return space;
 	case isl_dim_in:
-		return isl_space_extend(dim,
-					dim->nparam, dim->n_in + n, dim->n_out);
+		return space_extend(space,
+				space->nparam, space->n_in + n, space->n_out);
 	case isl_dim_out:
-		return isl_space_extend(dim,
-					dim->nparam, dim->n_in, dim->n_out + n);
+		return space_extend(space,
+				space->nparam, space->n_in, space->n_out + n);
 	default:
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"cannot add dimensions of specified type", goto error);
 	}
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Add a parameter with identifier "id" to "space", provided
+ * it does not already appear in "space".
+ */
+__isl_give isl_space *isl_space_add_param_id(__isl_take isl_space *space,
+	__isl_take isl_id *id)
+{
+	isl_size pos;
+
+	if (!space || !id)
+		goto error;
+
+	if (isl_space_find_dim_by_id(space, isl_dim_param, id) >= 0) {
+		isl_id_free(id);
+		return space;
+	}
+
+	pos = isl_space_dim(space, isl_dim_param);
+	if (pos < 0)
+		goto error;
+	space = isl_space_add_dims(space, isl_dim_param, 1);
+	space = isl_space_set_dim_id(space, isl_dim_param, pos, id);
+
+	return space;
+error:
+	isl_space_free(space);
+	isl_id_free(id);
 	return NULL;
 }
 
@@ -954,220 +1302,244 @@
 	}
 }
 
+#undef TYPE
+#define TYPE	isl_space
+#include "check_type_range_templ.c"
+
 /* Insert "n" dimensions of type "type" at position "pos".
  * If we are inserting parameters, then they are also inserted in
  * any nested spaces.
  */
-__isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_insert_dims(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned pos, unsigned n)
 {
+	isl_ctx *ctx;
 	isl_id **ids = NULL;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 	if (n == 0)
-		return isl_space_reset(dim, type);
+		return isl_space_reset(space, type);
 
+	ctx = isl_space_get_ctx(space);
 	if (!valid_dim_type(type))
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(ctx, isl_error_invalid,
 			"cannot insert dimensions of specified type",
 			goto error);
 
-	isl_assert(dim->ctx, pos <= isl_space_dim(dim, type), goto error);
+	if (isl_space_check_range(space, type, pos, 0) < 0)
+		return isl_space_free(space);
 
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
 
-	if (dim->ids) {
+	if (space->ids) {
 		enum isl_dim_type t, o = isl_dim_param;
 		int off;
 		int s3;
-		ids = isl_calloc_array(dim->ctx, isl_id *,
-				     dim->nparam + dim->n_in + dim->n_out + n);
+		ids = isl_calloc_array(ctx, isl_id *,
+			     space->nparam + space->n_in + space->n_out + n);
 		if (!ids)
 			goto error;
 		off = 0;
-		sisl_dim_param - o = dim->nparam;
-		sisl_dim_in - o = dim->n_in;
-		sisl_dim_out - o = dim->n_out;
+		sisl_dim_param - o = space->nparam;
+		sisl_dim_in - o = space->n_in;
+		sisl_dim_out - o = space->n_out;
 		for (t = isl_dim_param; t <= isl_dim_out; ++t) {
 			if (t != type) {
-				get_ids(dim, t, 0, st - o, ids + off);
+				get_ids(space, t, 0, st - o, ids + off);
 				off += st - o;
 			} else {
-				get_ids(dim, t, 0, pos, ids + off);
+				get_ids(space, t, 0, pos, ids + off);
 				off += pos + n;
-				get_ids(dim, t, pos, st - o - pos, ids + off);
+				get_ids(space, t, pos, st - o - pos,
+					ids + off);
 				off += st - o - pos;
 			}
 		}
-		free(dim->ids);
-		dim->ids = ids;
-		dim->n_id = dim->nparam + dim->n_in + dim->n_out + n;
+		free(space->ids);
+		space->ids = ids;
+		space->n_id = space->nparam + space->n_in + space->n_out + n;
 	}
 	switch (type) {
-	case isl_dim_param:	dim->nparam += n; break;
-	case isl_dim_in:	dim->n_in += n; break;
-	case isl_dim_out:	dim->n_out += n; break;
+	case isl_dim_param:	space->nparam += n; break;
+	case isl_dim_in:	space->n_in += n; break;
+	case isl_dim_out:	space->n_out += n; break;
 	default:		;
 	}
-	dim = isl_space_reset(dim, type);
+	space = isl_space_reset(space, type);
 
 	if (type == isl_dim_param) {
-		if (dim && dim->nested0 &&
-		    !(dim->nested0 = isl_space_insert_dims(dim->nested0,
+		if (space && space->nested0 &&
+		    !(space->nested0 = isl_space_insert_dims(space->nested0,
 						    isl_dim_param, pos, n)))
 			goto error;
-		if (dim && dim->nested1 &&
-		    !(dim->nested1 = isl_space_insert_dims(dim->nested1,
+		if (space && space->nested1 &&
+		    !(space->nested1 = isl_space_insert_dims(space->nested1,
 						    isl_dim_param, pos, n)))
 			goto error;
 	}
 
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_move_dims(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_move_dims(__isl_take isl_space *space,
 	enum isl_dim_type dst_type, unsigned dst_pos,
 	enum isl_dim_type src_type, unsigned src_pos, unsigned n)
 {
 	int i;
 
-	if (!dim)
+	space = isl_space_reset(space, src_type);
+	space = isl_space_reset(space, dst_type);
+	if (!space)
 		return NULL;
-	if (n == 0) {
-		dim = isl_space_reset(dim, src_type);
-		return isl_space_reset(dim, dst_type);
-	}
+	if (n == 0)
+		return space;
 
-	isl_assert(dim->ctx, src_pos + n <= isl_space_dim(dim, src_type),
-		goto error);
+	if (isl_space_check_range(space, src_type, src_pos, n) < 0)
+		return isl_space_free(space);
 
 	if (dst_type == src_type && dst_pos == src_pos)
-		return dim;
-
-	isl_assert(dim->ctx, dst_type != src_type, goto error);
+		return space;
 
-	dim = isl_space_reset(dim, src_type);
-	dim = isl_space_reset(dim, dst_type);
+	isl_assert(space->ctx, dst_type != src_type, goto error);
 
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
 
-	if (dim->ids) {
+	if (space->ids) {
 		isl_id **ids;
 		enum isl_dim_type t, o = isl_dim_param;
 		int off;
 		int s3;
-		ids = isl_calloc_array(dim->ctx, isl_id *,
-					 dim->nparam + dim->n_in + dim->n_out);
+		ids = isl_calloc_array(space->ctx, isl_id *,
+				 space->nparam + space->n_in + space->n_out);
 		if (!ids)
 			goto error;
 		off = 0;
-		sisl_dim_param - o = dim->nparam;
-		sisl_dim_in - o = dim->n_in;
-		sisl_dim_out - o = dim->n_out;
+		sisl_dim_param - o = space->nparam;
+		sisl_dim_in - o = space->n_in;
+		sisl_dim_out - o = space->n_out;
 		for (t = isl_dim_param; t <= isl_dim_out; ++t) {
 			if (t == dst_type) {
-				get_ids(dim, t, 0, dst_pos, ids + off);
+				get_ids(space, t, 0, dst_pos, ids + off);
 				off += dst_pos;
-				get_ids(dim, src_type, src_pos, n, ids + off);
+				get_ids(space, src_type, src_pos, n, ids + off);
 				off += n;
-				get_ids(dim, t, dst_pos, st - o - dst_pos,
+				get_ids(space, t, dst_pos, st - o - dst_pos,
 						ids + off);
 				off += st - o - dst_pos;
 			} else if (t == src_type) {
-				get_ids(dim, t, 0, src_pos, ids + off);
+				get_ids(space, t, 0, src_pos, ids + off);
 				off += src_pos;
-				get_ids(dim, t, src_pos + n,
+				get_ids(space, t, src_pos + n,
 					    st - o - src_pos - n, ids + off);
 				off += st - o - src_pos - n;
 			} else {
-				get_ids(dim, t, 0, st - o, ids + off);
+				get_ids(space, t, 0, st - o, ids + off);
 				off += st - o;
 			}
 		}
-		free(dim->ids);
-		dim->ids = ids;
-		dim->n_id = dim->nparam + dim->n_in + dim->n_out;
+		free(space->ids);
+		space->ids = ids;
+		space->n_id = space->nparam + space->n_in + space->n_out;
 	}
 
 	switch (dst_type) {
-	case isl_dim_param:	dim->nparam += n; break;
-	case isl_dim_in:	dim->n_in += n; break;
-	case isl_dim_out:	dim->n_out += n; break;
+	case isl_dim_param:	space->nparam += n; break;
+	case isl_dim_in:	space->n_in += n; break;
+	case isl_dim_out:	space->n_out += n; break;
 	default:		;
 	}
 
 	switch (src_type) {
-	case isl_dim_param:	dim->nparam -= n; break;
-	case isl_dim_in:	dim->n_in -= n; break;
-	case isl_dim_out:	dim->n_out -= n; break;
+	case isl_dim_param:	space->nparam -= n; break;
+	case isl_dim_in:	space->n_in -= n; break;
+	case isl_dim_out:	space->n_out -= n; break;
 	default:		;
 	}
 
 	if (dst_type != isl_dim_param && src_type != isl_dim_param)
-		return dim;
+		return space;
 
 	for (i = 0; i < 2; ++i) {
-		if (!dim->nestedi)
+		isl_space *nested;
+
+		if (!space->nestedi)
 			continue;
-		dim->nestedi = isl_space_replace(dim->nestedi,
-						 isl_dim_param, dim);
-		if (!dim->nestedi)
-			goto error;
+		nested = isl_space_take_nested(space, i);
+		nested = isl_space_replace_params(nested, space);
+		space = isl_space_restore_nested(space, i, nested);
+		if (!space)
+			return NULL;
 	}
 
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
+/* Check that "space1" and "space2" have the same parameters,
+ * reporting an error if they do not.
+ */
+isl_stat isl_space_check_equal_params(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool equal;
+
+	equal = isl_space_has_equal_params(space1, space2);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_space_get_ctx(space1), isl_error_invalid,
+			"parameters need to match", return isl_stat_error);
+	return isl_stat_ok;
+}
+
 __isl_give isl_space *isl_space_join(__isl_take isl_space *left,
 	__isl_take isl_space *right)
 {
-	isl_space *dim;
+	isl_space *space;
 
-	if (!left || !right)
+	if (isl_space_check_equal_params(left, right) < 0)
 		goto error;
 
-	isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
-			goto error);
 	isl_assert(left->ctx,
 		isl_space_tuple_is_equal(left, isl_dim_out, right, isl_dim_in),
 		goto error);
 
-	dim = isl_space_alloc(left->ctx, left->nparam, left->n_in, right->n_out);
-	if (!dim)
+	space = isl_space_alloc(left->ctx,
+				left->nparam, left->n_in, right->n_out);
+	if (!space)
 		goto error;
 
-	dim = copy_ids(dim, isl_dim_param, 0, left, isl_dim_param);
-	dim = copy_ids(dim, isl_dim_in, 0, left, isl_dim_in);
-	dim = copy_ids(dim, isl_dim_out, 0, right, isl_dim_out);
+	space = copy_ids(space, isl_dim_param, 0, left, isl_dim_param);
+	space = copy_ids(space, isl_dim_in, 0, left, isl_dim_in);
+	space = copy_ids(space, isl_dim_out, 0, right, isl_dim_out);
 
-	if (dim && left->tuple_id0 &&
-	    !(dim->tuple_id0 = isl_id_copy(left->tuple_id0)))
+	if (space && left->tuple_id0 &&
+	    !(space->tuple_id0 = isl_id_copy(left->tuple_id0)))
 		goto error;
-	if (dim && right->tuple_id1 &&
-	    !(dim->tuple_id1 = isl_id_copy(right->tuple_id1)))
+	if (space && right->tuple_id1 &&
+	    !(space->tuple_id1 = isl_id_copy(right->tuple_id1)))
 		goto error;
-	if (dim && left->nested0 &&
-	    !(dim->nested0 = isl_space_copy(left->nested0)))
+	if (space && left->nested0 &&
+	    !(space->nested0 = isl_space_copy(left->nested0)))
 		goto error;
-	if (dim && right->nested1 &&
-	    !(dim->nested1 = isl_space_copy(right->nested1)))
+	if (space && right->nested1 &&
+	    !(space->nested1 = isl_space_copy(right->nested1)))
 		goto error;
 
 	isl_space_free(left);
 	isl_space_free(right);
 
-	return dim;
+	return space;
 error:
 	isl_space_free(left);
 	isl_space_free(right);
@@ -1195,8 +1567,8 @@
 	if (is_set)
 		return isl_space_range_product(left, right);
 
-	isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
-			goto error);
+	if (isl_space_check_equal_params(left, right) < 0)
+		goto error;
 
 	dom1 = isl_space_domain(isl_space_copy(left));
 	dom2 = isl_space_domain(isl_space_copy(right));
@@ -1221,12 +1593,9 @@
 {
 	isl_space *ran, *dom1, *dom2, *nest;
 
-	if (!left || !right)
+	if (isl_space_check_equal_params(left, right) < 0)
 		goto error;
 
-	if (!match(left, isl_dim_param, right, isl_dim_param))
-		isl_die(left->ctx, isl_error_invalid,
-			"parameters need to match", goto error);
 	if (!isl_space_tuple_is_equal(left, isl_dim_out, right, isl_dim_out))
 		isl_die(left->ctx, isl_error_invalid,
 			"ranges need to match", goto error);
@@ -1249,11 +1618,9 @@
 {
 	isl_space *dom, *ran1, *ran2, *nest;
 
-	if (!left || !right)
+	if (isl_space_check_equal_params(left, right) < 0)
 		goto error;
 
-	isl_assert(left->ctx, match(left, isl_dim_param, right, isl_dim_param),
-			goto error);
 	if (!isl_space_tuple_is_equal(left, isl_dim_in, right, isl_dim_in))
 		isl_die(left->ctx, isl_error_invalid,
 			"domains need to match", goto error);
@@ -1279,15 +1646,12 @@
 	isl_space *nested;
 	isl_space *domain;
 
-	if (!space)
-		return NULL;
-	if (!isl_space_domain_is_wrapping(space))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"domain not a product", return isl_space_free(space));
+	if (isl_space_check_domain_is_wrapping(space) < 0)
+		return isl_space_free(space);
 
 	nested = space->nested0;
 	domain = isl_space_copy(space);
-	domain = isl_space_drop_dims(space, isl_dim_in,
+	domain = isl_space_drop_dims(domain, isl_dim_in,
 					nested->n_in, nested->n_out);
 	if (!domain)
 		return isl_space_free(space);
@@ -1310,23 +1674,57 @@
 	return NULL;
 }
 
-/* Given a space of the form A -> B -> C, return the space A -> B.
+/* Given a space of the form A -> B -> C, return the space B -> C.
  */
-__isl_give isl_space *isl_space_range_factor_domain(
+__isl_give isl_space *isl_space_domain_factor_range(
 	__isl_take isl_space *space)
 {
 	isl_space *nested;
+	isl_space *range;
+
+	if (isl_space_check_domain_is_wrapping(space) < 0)
+		return isl_space_free(space);
+
+	nested = space->nested0;
+	range = isl_space_copy(space);
+	range = isl_space_drop_dims(range, isl_dim_in, 0, nested->n_in);
+	if (!range)
+		return isl_space_free(space);
+	if (nested->tuple_id1) {
+		range->tuple_id0 = isl_id_copy(nested->tuple_id1);
+		if (!range->tuple_id0)
+			goto error;
+	}
+	if (nested->nested1) {
+		range->nested0 = isl_space_copy(nested->nested1);
+		if (!range->nested0)
+			goto error;
+	}
+
+	isl_space_free(space);
+	return range;
+error:
+	isl_space_free(space);
+	isl_space_free(range);
+	return NULL;
+}
+
+/* Internal function that selects the domain of the map that is
+ * embedded in either a set space or the range of a map space.
+ * In particular, given a space of the form A -> B, return the space A.
+ * Given a space of the form A -> B -> C, return the space A -> B.
+ */
+static __isl_give isl_space *range_factor_domain(__isl_take isl_space *space)
+{
+	isl_space *nested;
 	isl_space *domain;
 
 	if (!space)
 		return NULL;
-	if (!isl_space_range_is_wrapping(space))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"range not a product", return isl_space_free(space));
 
 	nested = space->nested1;
 	domain = isl_space_copy(space);
-	domain = isl_space_drop_dims(space, isl_dim_out,
+	domain = isl_space_drop_dims(domain, isl_dim_out,
 					nested->n_in, nested->n_out);
 	if (!domain)
 		return isl_space_free(space);
@@ -1349,23 +1747,60 @@
 	return NULL;
 }
 
-/* Given a space of the form A -> B -> C, return the space A -> C.
+/* Given a space of the form A -> B -> C, return the space A -> B.
  */
-__isl_give isl_space *isl_space_range_factor_range(
+__isl_give isl_space *isl_space_range_factor_domain(
 	__isl_take isl_space *space)
 {
+	if (isl_space_check_range_is_wrapping(space) < 0)
+		return isl_space_free(space);
+
+	return range_factor_domain(space);
+}
+
+/* Given a space of the form A -> B, return the space A.
+ */
+static __isl_give isl_space *set_factor_domain(__isl_take isl_space *space)
+{
+	if (!space)
+		return NULL;
+	if (!isl_space_is_wrapping(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"not a product", return isl_space_free(space));
+
+	return range_factor_domain(space);
+}
+
+/* Given a space of the form A -> B -> C -> D, return the space A -> C.
+ * Given a space of the form A -> B, return the space A.
+ */
+__isl_give isl_space *isl_space_factor_domain(__isl_take isl_space *space)
+{
+	if (!space)
+		return NULL;
+	if (isl_space_is_set(space))
+		return set_factor_domain(space);
+	space = isl_space_domain_factor_domain(space);
+	space = isl_space_range_factor_domain(space);
+	return space;
+}
+
+/* Internal function that selects the range of the map that is
+ * embedded in either a set space or the range of a map space.
+ * In particular, given a space of the form A -> B, return the space B.
+ * Given a space of the form A -> B -> C, return the space A -> C.
+ */
+static __isl_give isl_space *range_factor_range(__isl_take isl_space *space)
+{
 	isl_space *nested;
 	isl_space *range;
 
 	if (!space)
 		return NULL;
-	if (!isl_space_range_is_wrapping(space))
-		isl_die(isl_space_get_ctx(space), isl_error_invalid,
-			"range not a product", return isl_space_free(space));
 
 	nested = space->nested1;
 	range = isl_space_copy(space);
-	range = isl_space_drop_dims(space, isl_dim_out, 0, nested->n_in);
+	range = isl_space_drop_dims(range, isl_dim_out, 0, nested->n_in);
 	if (!range)
 		return isl_space_free(space);
 	if (nested->tuple_id1) {
@@ -1387,41 +1822,81 @@
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_map_from_set(__isl_take isl_space *dim)
+/* Given a space of the form A -> B -> C, return the space A -> C.
+ */
+__isl_give isl_space *isl_space_range_factor_range(
+	__isl_take isl_space *space)
+{
+	if (isl_space_check_range_is_wrapping(space) < 0)
+		return isl_space_free(space);
+
+	return range_factor_range(space);
+}
+
+/* Given a space of the form A -> B, return the space B.
+ */
+static __isl_give isl_space *set_factor_range(__isl_take isl_space *space)
+{
+	if (!space)
+		return NULL;
+	if (!isl_space_is_wrapping(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"not a product", return isl_space_free(space));
+
+	return range_factor_range(space);
+}
+
+/* Given a space of the form A -> B -> C -> D, return the space B -> D.
+ * Given a space of the form A -> B, return the space B.
+ */
+__isl_give isl_space *isl_space_factor_range(__isl_take isl_space *space)
+{
+	if (!space)
+		return NULL;
+	if (isl_space_is_set(space))
+		return set_factor_range(space);
+	space = isl_space_domain_factor_range(space);
+	space = isl_space_range_factor_range(space);
+	return space;
+}
+
+__isl_give isl_space *isl_space_map_from_set(__isl_take isl_space *space)
 {
 	isl_ctx *ctx;
 	isl_id **ids = NULL;
+	int n_id;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	ctx = isl_space_get_ctx(dim);
-	if (!isl_space_is_set(dim))
+	ctx = isl_space_get_ctx(space);
+	if (!isl_space_is_set(space))
 		isl_die(ctx, isl_error_invalid, "not a set space", goto error);
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
-	if (dim->ids) {
-		ids = isl_calloc_array(dim->ctx, isl_id *,
-					dim->nparam + dim->n_out + dim->n_out);
+	n_id = space->nparam + space->n_out + space->n_out;
+	if (n_id > 0 && space->ids) {
+		ids = isl_calloc_array(space->ctx, isl_id *, n_id);
 		if (!ids)
 			goto error;
-		get_ids(dim, isl_dim_param, 0, dim->nparam, ids);
-		get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->nparam);
+		get_ids(space, isl_dim_param, 0, space->nparam, ids);
+		get_ids(space, isl_dim_out, 0, space->n_out,
+			ids + space->nparam);
 	}
-	dim->n_in = dim->n_out;
+	space->n_in = space->n_out;
 	if (ids) {
-		free(dim->ids);
-		dim->ids = ids;
-		dim->n_id = dim->nparam + dim->n_out + dim->n_out;
-		dim = copy_ids(dim, isl_dim_out, 0, dim, isl_dim_in);
+		free(space->ids);
+		space->ids = ids;
+		space->n_id = n_id;
+		space = copy_ids(space, isl_dim_out, 0, space, isl_dim_in);
 	}
-	isl_id_free(dim->tuple_id0);
-	dim->tuple_id0 = isl_id_copy(dim->tuple_id1);
-	isl_space_free(dim->nested0);
-	dim->nested0 = isl_space_copy(dim->nested1);
-	return dim;
+	isl_id_free(space->tuple_id0);
+	space->tuple_id0 = isl_id_copy(space->tuple_id1);
+	isl_space_free(space->nested0);
+	space->nested0 = isl_space_copy(space->nested1);
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -1443,192 +1918,236 @@
 	return NULL;
 }
 
-static __isl_give isl_space *set_ids(__isl_take isl_space *dim,
+static __isl_give isl_space *set_ids(__isl_take isl_space *space,
 	enum isl_dim_type type,
 	unsigned first, unsigned n, __isl_take isl_id **ids)
 {
 	int i;
 
 	for (i = 0; i < n ; ++i)
-		dim = set_id(dim, type, first + i, idsi);
+		space = set_id(space, type, first + i, idsi);
 
-	return dim;
+	return space;
 }
 
-__isl_give isl_space *isl_space_reverse(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_reverse(__isl_take isl_space *space)
 {
 	unsigned t;
+	isl_bool equal;
 	isl_space *nested;
 	isl_id **ids = NULL;
 	isl_id *id;
 
-	if (!dim)
-		return NULL;
-	if (match(dim, isl_dim_in, dim, isl_dim_out))
-		return dim;
+	equal = match(space, isl_dim_in, space, isl_dim_out);
+	if (equal < 0)
+		return isl_space_free(space);
+	if (equal)
+		return space;
 
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
 
-	id = dim->tuple_id0;
-	dim->tuple_id0 = dim->tuple_id1;
-	dim->tuple_id1 = id;
+	id = space->tuple_id0;
+	space->tuple_id0 = space->tuple_id1;
+	space->tuple_id1 = id;
 
-	nested = dim->nested0;
-	dim->nested0 = dim->nested1;
-	dim->nested1 = nested;
+	nested = space->nested0;
+	space->nested0 = space->nested1;
+	space->nested1 = nested;
 
-	if (dim->ids) {
-		int n_id = dim->n_in + dim->n_out;
-		ids = isl_alloc_array(dim->ctx, isl_id *, n_id);
+	if (space->ids) {
+		int n_id = space->n_in + space->n_out;
+		ids = isl_alloc_array(space->ctx, isl_id *, n_id);
 		if (n_id && !ids)
 			goto error;
-		get_ids(dim, isl_dim_in, 0, dim->n_in, ids);
-		get_ids(dim, isl_dim_out, 0, dim->n_out, ids + dim->n_in);
+		get_ids(space, isl_dim_in, 0, space->n_in, ids);
+		get_ids(space, isl_dim_out, 0, space->n_out, ids + space->n_in);
 	}
 
-	t = dim->n_in;
-	dim->n_in = dim->n_out;
-	dim->n_out = t;
+	t = space->n_in;
+	space->n_in = space->n_out;
+	space->n_out = t;
 
-	if (dim->ids) {
-		dim = set_ids(dim, isl_dim_out, 0, dim->n_out, ids);
-		dim = set_ids(dim, isl_dim_in, 0, dim->n_in, ids + dim->n_out);
+	if (space->ids) {
+		space = set_ids(space, isl_dim_out, 0, space->n_out, ids);
+		space = set_ids(space, isl_dim_in, 0, space->n_in,
+				ids + space->n_out);
 		free(ids);
 	}
 
-	return dim;
+	return space;
 error:
 	free(ids);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *dim,
+/* Given a space A -> (B -> C), return the corresponding space
+ * A -> (C -> B).
+ *
+ * If the range tuple is named, then the name is only preserved
+ * if B and C are equal tuples, in which case the output
+ * of this function is identical to the input.
+ */
+__isl_give isl_space *isl_space_range_reverse(__isl_take isl_space *space)
+{
+	isl_space *nested;
+	isl_bool equal;
+
+	if (isl_space_check_range_is_wrapping(space) < 0)
+		return isl_space_free(space);
+
+	nested = isl_space_peek_nested(space, 1);
+	equal = isl_space_tuple_is_equal(nested, isl_dim_in,
+					nested, isl_dim_out);
+	if (equal < 0)
+		return isl_space_free(space);
+
+	nested = isl_space_take_nested(space, 1);
+	nested = isl_space_reverse(nested);
+	space = isl_space_restore_nested(space, 1, nested);
+	if (!equal)
+		space = isl_space_reset_tuple_id(space, isl_dim_out);
+
+	return space;
+}
+
+__isl_give isl_space *isl_space_drop_dims(__isl_take isl_space *space,
 	enum isl_dim_type type, unsigned first, unsigned num)
 {
 	int i;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
 	if (num == 0)
-		return isl_space_reset(dim, type);
+		return isl_space_reset(space, type);
 
 	if (!valid_dim_type(type))
-		isl_die(dim->ctx, isl_error_invalid,
+		isl_die(space->ctx, isl_error_invalid,
 			"cannot drop dimensions of specified type", goto error);
 
-	if (first + num > n(dim, type) || first + num < first)
-		isl_die(isl_space_get_ctx(dim), isl_error_invalid,
-			"index out of bounds", return isl_space_free(dim));
-	dim = isl_space_cow(dim);
-	if (!dim)
+	if (isl_space_check_range(space, type, first, num) < 0)
+		return isl_space_free(space);
+	space = isl_space_cow(space);
+	if (!space)
 		goto error;
-	if (dim->ids) {
-		dim = extend_ids(dim);
-		if (!dim)
+	if (space->ids) {
+		space = extend_ids(space);
+		if (!space)
 			goto error;
 		for (i = 0; i < num; ++i)
-			isl_id_free(get_id(dim, type, first + i));
-		for (i = first+num; i < n(dim, type); ++i)
-			set_id(dim, type, i - num, get_id(dim, type, i));
+			isl_id_free(get_id(space, type, first + i));
+		for (i = first+num; i < n(space, type); ++i)
+			set_id(space, type, i - num, get_id(space, type, i));
 		switch (type) {
 		case isl_dim_param:
-			get_ids(dim, isl_dim_in, 0, dim->n_in,
-				dim->ids + offset(dim, isl_dim_in) - num);
+			get_ids(space, isl_dim_in, 0, space->n_in,
+				space->ids + offset(space, isl_dim_in) - num);
 		case isl_dim_in:
-			get_ids(dim, isl_dim_out, 0, dim->n_out,
-				dim->ids + offset(dim, isl_dim_out) - num);
+			get_ids(space, isl_dim_out, 0, space->n_out,
+				space->ids + offset(space, isl_dim_out) - num);
 		default:
 			;
 		}
-		dim->n_id -= num;
+		space->n_id -= num;
 	}
 	switch (type) {
-	case isl_dim_param:	dim->nparam -= num; break;
-	case isl_dim_in:	dim->n_in -= num; break;
-	case isl_dim_out:	dim->n_out -= num; break;
+	case isl_dim_param:	space->nparam -= num; break;
+	case isl_dim_in:	space->n_in -= num; break;
+	case isl_dim_out:	space->n_out -= num; break;
 	default:		;
 	}
-	dim = isl_space_reset(dim, type);
+	space = isl_space_reset(space, type);
 	if (type == isl_dim_param) {
-		if (dim && dim->nested0 &&
-		    !(dim->nested0 = isl_space_drop_dims(dim->nested0,
+		if (space && space->nested0 &&
+		    !(space->nested0 = isl_space_drop_dims(space->nested0,
 						    isl_dim_param, first, num)))
 			goto error;
-		if (dim && dim->nested1 &&
-		    !(dim->nested1 = isl_space_drop_dims(dim->nested1,
+		if (space && space->nested1 &&
+		    !(space->nested1 = isl_space_drop_dims(space->nested1,
 						    isl_dim_param, first, num)))
 			goto error;
 	}
-	return dim;
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_drop_inputs(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_drop_inputs(__isl_take isl_space *space,
 		unsigned first, unsigned n)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	return isl_space_drop_dims(dim, isl_dim_in, first, n);
+	return isl_space_drop_dims(space, isl_dim_in, first, n);
 }
 
-__isl_give isl_space *isl_space_drop_outputs(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_drop_outputs(__isl_take isl_space *space,
 		unsigned first, unsigned n)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	return isl_space_drop_dims(dim, isl_dim_out, first, n);
+	return isl_space_drop_dims(space, isl_dim_out, first, n);
+}
+
+/* Remove all parameters from "space".
+ */
+__isl_give isl_space *isl_space_drop_all_params(__isl_take isl_space *space)
+{
+	isl_size nparam;
+
+	nparam = isl_space_dim(space, isl_dim_param);
+	if (nparam < 0)
+		return isl_space_free(space);
+	return isl_space_drop_dims(space, isl_dim_param, 0, nparam);
 }
 
-__isl_give isl_space *isl_space_domain(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_domain(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	dim = isl_space_drop_outputs(dim, 0, dim->n_out);
-	dim = isl_space_reverse(dim);
-	dim = mark_as_set(dim);
-	return dim;
+	space = isl_space_drop_dims(space, isl_dim_out, 0, space->n_out);
+	space = isl_space_reverse(space);
+	space = mark_as_set(space);
+	return space;
 }
 
-__isl_give isl_space *isl_space_from_domain(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_from_domain(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!isl_space_is_set(dim))
-		isl_die(isl_space_get_ctx(dim), isl_error_invalid,
+	if (!isl_space_is_set(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
 			"not a set space", goto error);
-	dim = isl_space_reverse(dim);
-	dim = isl_space_reset(dim, isl_dim_out);
-	return dim;
+	space = isl_space_reverse(space);
+	space = isl_space_reset(space, isl_dim_out);
+	return space;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_range(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_range(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	dim = isl_space_drop_inputs(dim, 0, dim->n_in);
-	dim = mark_as_set(dim);
-	return dim;
+	space = isl_space_drop_dims(space, isl_dim_in, 0, space->n_in);
+	space = mark_as_set(space);
+	return space;
 }
 
-__isl_give isl_space *isl_space_from_range(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_from_range(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!isl_space_is_set(dim))
-		isl_die(isl_space_get_ctx(dim), isl_error_invalid,
+	if (!isl_space_is_set(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
 			"not a set space", goto error);
-	return isl_space_reset(dim, isl_dim_in);
+	return isl_space_reset(space, isl_dim_in);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -1660,12 +2179,16 @@
 
 __isl_give isl_space *isl_space_params(__isl_take isl_space *space)
 {
+	isl_size n_in, n_out;
+
 	if (isl_space_is_params(space))
 		return space;
-	space = isl_space_drop_dims(space,
-			    isl_dim_in, 0, isl_space_dim(space, isl_dim_in));
-	space = isl_space_drop_dims(space,
-			    isl_dim_out, 0, isl_space_dim(space, isl_dim_out));
+	n_in = isl_space_dim(space, isl_dim_in);
+	n_out = isl_space_dim(space, isl_dim_out);
+	if (n_in < 0 || n_out < 0)
+		return isl_space_free(space);
+	space = isl_space_drop_dims(space, isl_dim_in, 0, n_in);
+	space = isl_space_drop_dims(space, isl_dim_out, 0, n_out);
 	space = mark_as_params(space);
 	return space;
 }
@@ -1683,57 +2206,358 @@
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_as_set_space(__isl_take isl_space *dim)
+/* Add an unnamed tuple of dimension "dim" to "space".
+ * This requires "space" to be a parameter or set space.
+ *
+ * In particular, if "space" is a parameter space, then return
+ * a set space with the given dimension.
+ * If "space" is a set space, then return a map space
+ * with "space" as domain and a range of the given dimension.
+ */
+__isl_give isl_space *isl_space_add_unnamed_tuple_ui(
+	__isl_take isl_space *space, unsigned dim)
 {
-	dim = isl_space_cow(dim);
-	if (!dim)
-		return NULL;
+	isl_bool is_params, is_set;
 
-	dim->n_out += dim->n_in;
-	dim->n_in = 0;
-	dim = isl_space_reset(dim, isl_dim_in);
-	dim = isl_space_reset(dim, isl_dim_out);
+	is_params = isl_space_is_params(space);
+	is_set = isl_space_is_set(space);
+	if (is_params < 0 || is_set < 0)
+		return isl_space_free(space);
+	if (!is_params && !is_set)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"cannot add tuple to map space",
+			return isl_space_free(space));
+	if (is_params)
+		space = isl_space_set_from_params(space);
+	else
+		space = isl_space_from_domain(space);
+	space = isl_space_add_dims(space, isl_dim_out, dim);
+	return space;
+}
 
-	return dim;
+/* Add a tuple of dimension "dim" and with tuple identifier "tuple_id"
+ * to "space".
+ * This requires "space" to be a parameter or set space.
+ */
+__isl_give isl_space *isl_space_add_named_tuple_id_ui(
+	__isl_take isl_space *space, __isl_take isl_id *tuple_id, unsigned dim)
+{
+	space = isl_space_add_unnamed_tuple_ui(space, dim);
+	space = isl_space_set_tuple_id(space, isl_dim_out, tuple_id);
+	return space;
 }
 
-__isl_give isl_space *isl_space_underlying(__isl_take isl_space *dim,
+/* Check that the identifiers in "tuple" do not appear as parameters
+ * in "space".
+ */
+static isl_stat check_fresh_params(__isl_keep isl_space *space,
+	__isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size n;
+
+	n = isl_multi_id_size(tuple);
+	if (n < 0)
+		return isl_stat_error;
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+		int pos;
+
+		id = isl_multi_id_get_at(tuple, i);
+		if (!id)
+			return isl_stat_error;
+		pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos >= 0)
+			isl_die(isl_space_get_ctx(space), isl_error_invalid,
+				"parameters not unique", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Add the identifiers in "tuple" as parameters of "space"
+ * that are known to be fresh.
+ */
+static __isl_give isl_space *add_bind_params(__isl_take isl_space *space,
+	__isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size first, n;
+
+	first = isl_space_dim(space, isl_dim_param);
+	n = isl_multi_id_size(tuple);
+	if (first < 0 || n < 0)
+		return isl_space_free(space);
+	space = isl_space_add_dims(space, isl_dim_param, n);
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+
+		id = isl_multi_id_get_at(tuple, i);
+		space = isl_space_set_dim_id(space,
+						isl_dim_param, first + i, id);
+	}
+
+	return space;
+}
+
+/* Internal function that removes the set tuple of "space",
+ * which is assumed to correspond to the range space of "tuple", and
+ * adds the identifiers in "tuple" as fresh parameters.
+ * In other words, the set dimensions of "space" are reinterpreted
+ * as parameters, but stay in the same global positions.
+ */
+__isl_give isl_space *isl_space_bind_set(__isl_take isl_space *space,
+	__isl_keep isl_multi_id *tuple)
+{
+	isl_space *tuple_space;
+
+	if (isl_space_check_is_set(space) < 0)
+		return isl_space_free(space);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	if (isl_space_check_equal_tuples(tuple_space, space) < 0)
+		return isl_space_free(space);
+	if (check_fresh_params(space, tuple) < 0)
+		return isl_space_free(space);
+	space = isl_space_params(space);
+	space = add_bind_params(space, tuple);
+	return space;
+}
+
+/* Internal function that removes the domain tuple of the map space "space",
+ * which is assumed to correspond to the range space of "tuple", and
+ * adds the identifiers in "tuple" as fresh parameters.
+ * In other words, the domain dimensions of "space" are reinterpreted
+ * as parameters, but stay in the same global positions.
+ */
+__isl_give isl_space *isl_space_bind_map_domain(__isl_take isl_space *space,
+	__isl_keep isl_multi_id *tuple)
+{
+	isl_space *tuple_space;
+
+	if (isl_space_check_is_map(space) < 0)
+		return isl_space_free(space);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	if (isl_space_check_domain_tuples(tuple_space, space) < 0)
+		return isl_space_free(space);
+	if (check_fresh_params(space, tuple) < 0)
+		return isl_space_free(space);
+	space = isl_space_range(space);
+	space = add_bind_params(space, tuple);
+	return space;
+}
+
+/* Internal function that, given a space of the form A -> B -> C and
+ * a tuple of identifiers in A, returns a space B -> C with
+ * the identifiers in "tuple" added as fresh parameters.
+ * In other words, the domain dimensions of the wrapped relation
+ * in the domain of "space" are reinterpreted
+ * as parameters, but stay in the same global positions.
+ */
+__isl_give isl_space *isl_space_bind_domain_wrapped_domain(
+	__isl_take isl_space *space, __isl_keep isl_multi_id *tuple)
+{
+	isl_space *tuple_space;
+
+	if (isl_space_check_is_map(space) < 0)
+		return isl_space_free(space);
+	tuple_space = isl_multi_id_peek_space(tuple);
+	if (isl_space_check_domain_wrapped_domain_tuples(tuple_space,
+							space) < 0)
+		  return isl_space_free(space);
+	if (check_fresh_params(space, tuple) < 0)
+		return isl_space_free(space);
+	space = isl_space_domain_factor_range(space);
+	space = add_bind_params(space, tuple);
+	return space;
+}
+
+/* Insert a domain tuple in "space" corresponding to the set space "domain".
+ * In particular, if "space" is a parameter space, then the result
+ * is the set space "domain" combined with the parameters of "space".
+ * If "space" is a set space, then the result
+ * is a map space with "domain" as domain and the original space as range.
+ */
+static __isl_give isl_space *isl_space_insert_domain(
+	__isl_take isl_space *space, __isl_take isl_space *domain)
+{
+	isl_bool is_params;
+
+	domain = isl_space_replace_params(domain, space);
+
+	is_params = isl_space_is_params(space);
+	if (is_params < 0) {
+		isl_space_free(domain);
+		space = isl_space_free(space);
+	} else if (is_params) {
+		isl_space_free(space);
+		space = domain;
+	} else {
+		space = isl_space_map_from_domain_and_range(domain, space);
+	}
+	return space;
+}
+
+/* Internal function that introduces a domain in "space"
+ * corresponding to the range space of "tuple".
+ * In particular, if "space" is a parameter space, then the result
+ * is a set space.  If "space" is a set space, then the result
+ * is a map space with the original space as range.
+ * Parameters that correspond to the identifiers in "tuple" are removed.
+ *
+ * The parameters are removed in reverse order (under the assumption
+ * that they appear in the same order in "multi") because
+ * it is slightly more efficient to remove parameters at the end.
+ *
+ * For pretty-printing purposes, the identifiers of the set dimensions
+ * of the introduced domain are set to the identifiers in "tuple".
+ */
+__isl_give isl_space *isl_space_unbind_params_insert_domain(
+	__isl_take isl_space *space, __isl_keep isl_multi_id *tuple)
+{
+	int i;
+	isl_size n;
+	isl_space *tuple_space;
+
+	n = isl_multi_id_size(tuple);
+	if (!space || n < 0)
+		return isl_space_free(space);
+	for (i = n - 1; i >= 0; --i) {
+		isl_id *id;
+		int pos;
+
+		id = isl_multi_id_get_id(tuple, i);
+		if (!id)
+			return isl_space_free(space);
+		pos = isl_space_find_dim_by_id(space, isl_dim_param, id);
+		isl_id_free(id);
+		if (pos < 0)
+			continue;
+		space = isl_space_drop_dims(space, isl_dim_param, pos, 1);
+	}
+	tuple_space = isl_multi_id_get_space(tuple);
+	for (i = 0; i < n; ++i) {
+		isl_id *id;
+
+		id = isl_multi_id_get_id(tuple, i);
+		tuple_space = isl_space_set_dim_id(tuple_space,
+						    isl_dim_set, i, id);
+	}
+	return isl_space_insert_domain(space, tuple_space);
+}
+
+__isl_give isl_space *isl_space_underlying(__isl_take isl_space *space,
 	unsigned n_div)
 {
 	int i;
+	isl_bool is_set;
 
-	if (!dim)
-		return NULL;
-	if (n_div == 0 &&
-	    dim->nparam == 0 && dim->n_in == 0 && dim->n_id == 0)
-		return isl_space_reset(isl_space_reset(dim, isl_dim_in), isl_dim_out);
-	dim = isl_space_cow(dim);
-	if (!dim)
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_space_free(space);
+	if (n_div == 0 && is_set &&
+	    space->nparam == 0 && space->n_in == 0 && space->n_id == 0)
+		return isl_space_reset(space, isl_dim_out);
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
-	dim->n_out += dim->nparam + dim->n_in + n_div;
-	dim->nparam = 0;
-	dim->n_in = 0;
+	space->n_out += space->nparam + space->n_in + n_div;
+	space->nparam = 0;
+	space->n_in = 0;
 
-	for (i = 0; i < dim->n_id; ++i)
-		isl_id_free(get_id(dim, isl_dim_out, i));
-	dim->n_id = 0;
-	dim = isl_space_reset(dim, isl_dim_in);
-	dim = isl_space_reset(dim, isl_dim_out);
+	for (i = 0; i < space->n_id; ++i)
+		isl_id_free(get_id(space, isl_dim_out, i));
+	space->n_id = 0;
+	space = isl_space_reset(space, isl_dim_in);
+	space = isl_space_reset(space, isl_dim_out);
+	space = mark_as_set(space);
 
-	return dim;
+	return space;
 }
 
 /* Are the two spaces the same, including positions and names of parameters?
  */
-int isl_space_is_equal(__isl_keep isl_space *dim1, __isl_keep isl_space *dim2)
+isl_bool isl_space_is_equal(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
 {
-	if (!dim1 || !dim2)
-		return -1;
-	if (dim1 == dim2)
-		return 1;
-	return match(dim1, isl_dim_param, dim2, isl_dim_param) &&
-	       isl_space_tuple_is_equal(dim1, isl_dim_in, dim2, isl_dim_in) &&
-	       isl_space_tuple_is_equal(dim1, isl_dim_out, dim2, isl_dim_out);
+	isl_bool equal;
+
+	if (!space1 || !space2)
+		return isl_bool_error;
+	if (space1 == space2)
+		return isl_bool_true;
+	equal = isl_space_has_equal_params(space1, space2);
+	if (equal < 0 || !equal)
+		return equal;
+	return isl_space_has_equal_tuples(space1, space2);
+}
+
+/* Do the tuples of "space1" correspond to those of the domain of "space2"?
+ * That is, is "space1" equal to the domain of "space2", ignoring parameters.
+ *
+ * "space2" is allowed to be a set space, in which case "space1"
+ * should be a parameter space.
+ */
+isl_bool isl_space_has_domain_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool is_set;
+
+	is_set = isl_space_is_set(space1);
+	if (is_set < 0 || !is_set)
+		return is_set;
+	return isl_space_tuple_is_equal(space1, isl_dim_set,
+					space2, isl_dim_in);
+}
+
+/* Do the tuples of "space1" correspond to those of the range of "space2"?
+ * That is, is "space1" equal to the range of "space2", ignoring parameters.
+ *
+ * "space2" is allowed to be the space of a set,
+ * in which case it should be equal to "space1", ignoring parameters.
+ */
+isl_bool isl_space_has_range_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool is_set;
+
+	is_set = isl_space_is_set(space1);
+	if (is_set < 0 || !is_set)
+		return is_set;
+	return isl_space_tuple_is_equal(space1, isl_dim_set,
+					space2, isl_dim_out);
+}
+
+/* Check that the tuples of "space1" correspond to those
+ * of the domain of "space2".
+ * That is, check that "space1" is equal to the domain of "space2",
+ * ignoring parameters.
+ */
+isl_stat isl_space_check_domain_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2)
+{
+	isl_bool is_equal;
+
+	is_equal = isl_space_has_domain_tuples(space1, space2);
+	return check_match(space1, is_equal);
+}
+
+/* Check that the tuples of "space1" correspond to those
+ * of the domain of the wrapped relation in the domain of "space2".
+ * That is, check that "space1" is equal to this domain,
+ * ignoring parameters.
+ */
+isl_stat isl_space_check_domain_wrapped_domain_tuples(
+	__isl_keep isl_space *space1, __isl_keep isl_space *space2)
+{
+	isl_space *domain;
+	isl_stat r;
+
+	domain = isl_space_unwrap(isl_space_domain(isl_space_copy(space2)));
+	r = isl_space_check_domain_tuples(space1, domain);
+	isl_space_free(domain);
+
+	return r;
 }
 
 /* Is space1 equal to the domain of space2?
@@ -1741,27 +2565,28 @@
  * In the internal version we also allow space2 to be the space of a set,
  * provided space1 is a parameter space.
  */
-int isl_space_is_domain_internal(__isl_keep isl_space *space1,
+isl_bool isl_space_is_domain_internal(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2)
 {
+	isl_bool equal_params;
+
 	if (!space1 || !space2)
-		return -1;
-	if (!isl_space_is_set(space1))
-		return 0;
-	return match(space1, isl_dim_param, space2, isl_dim_param) &&
-	       isl_space_tuple_is_equal(space1, isl_dim_set,
-					space2, isl_dim_in);
+		return isl_bool_error;
+	equal_params = isl_space_has_equal_params(space1, space2);
+	if (equal_params < 0 || !equal_params)
+		return equal_params;
+	return isl_space_has_domain_tuples(space1, space2);
 }
 
 /* Is space1 equal to the domain of space2?
  */
-int isl_space_is_domain(__isl_keep isl_space *space1,
+isl_bool isl_space_is_domain(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2)
 {
 	if (!space2)
-		return -1;
+		return isl_bool_error;
 	if (!isl_space_is_map(space2))
-		return 0;
+		return isl_bool_false;
 	return isl_space_is_domain_internal(space1, space2);
 }
 
@@ -1770,262 +2595,379 @@
  * In the internal version, space2 is allowed to be the space of a set,
  * in which case it should be equal to space1.
  */
-int isl_space_is_range_internal(__isl_keep isl_space *space1,
+isl_bool isl_space_is_range_internal(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2)
 {
+	isl_bool equal_params;
+
 	if (!space1 || !space2)
-		return -1;
-	if (!isl_space_is_set(space1))
-		return 0;
-	return match(space1, isl_dim_param, space2, isl_dim_param) &&
-	       isl_space_tuple_is_equal(space1, isl_dim_set,
-					space2, isl_dim_out);
+		return isl_bool_error;
+	equal_params = isl_space_has_equal_params(space1, space2);
+	if (equal_params < 0 || !equal_params)
+		return equal_params;
+	return isl_space_has_range_tuples(space1, space2);
 }
 
 /* Is space1 equal to the range of space2?
  */
-int isl_space_is_range(__isl_keep isl_space *space1,
+isl_bool isl_space_is_range(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2)
 {
 	if (!space2)
-		return -1;
+		return isl_bool_error;
 	if (!isl_space_is_map(space2))
-		return 0;
+		return isl_bool_false;
 	return isl_space_is_range_internal(space1, space2);
 }
 
-int isl_space_compatible(__isl_keep isl_space *dim1,
-	__isl_keep isl_space *dim2)
-{
-	return dim1->nparam == dim2->nparam &&
-	       dim1->n_in + dim1->n_out == dim2->n_in + dim2->n_out;
-}
-
-static uint32_t isl_hash_dim(uint32_t hash, __isl_keep isl_space *dim)
+/* Update "hash" by hashing in the parameters of "space".
+ */
+static uint32_t isl_hash_params(uint32_t hash, __isl_keep isl_space *space)
 {
 	int i;
 	isl_id *id;
 
-	if (!dim)
+	if (!space)
 		return hash;
 
-	isl_hash_byte(hash, dim->nparam % 256);
-	isl_hash_byte(hash, dim->n_in % 256);
-	isl_hash_byte(hash, dim->n_out % 256);
+	isl_hash_byte(hash, space->nparam % 256);
 
-	for (i = 0; i < dim->nparam; ++i) {
-		id = get_id(dim, isl_dim_param, i);
+	for (i = 0; i < space->nparam; ++i) {
+		id = get_id(space, isl_dim_param, i);
 		hash = isl_hash_id(hash, id);
 	}
 
-	id = tuple_id(dim, isl_dim_in);
+	return hash;
+}
+
+/* Update "hash" by hashing in the tuples of "space".
+ * Changes in this function should be reflected in isl_hash_tuples_domain.
+ */
+static uint32_t isl_hash_tuples(uint32_t hash, __isl_keep isl_space *space)
+{
+	isl_id *id;
+
+	if (!space)
+		return hash;
+
+	isl_hash_byte(hash, space->n_in % 256);
+	isl_hash_byte(hash, space->n_out % 256);
+
+	id = tuple_id(space, isl_dim_in);
+	hash = isl_hash_id(hash, id);
+	id = tuple_id(space, isl_dim_out);
 	hash = isl_hash_id(hash, id);
-	id = tuple_id(dim, isl_dim_out);
+
+	hash = isl_hash_tuples(hash, space->nested0);
+	hash = isl_hash_tuples(hash, space->nested1);
+
+	return hash;
+}
+
+/* Update "hash" by hashing in the domain tuple of "space".
+ * The result of this function is equal to the result of applying
+ * isl_hash_tuples to the domain of "space".
+ */
+static uint32_t isl_hash_tuples_domain(uint32_t hash,
+	__isl_keep isl_space *space)
+{
+	isl_id *id;
+
+	if (!space)
+		return hash;
+
+	isl_hash_byte(hash, 0);
+	isl_hash_byte(hash, space->n_in % 256);
+
+	hash = isl_hash_id(hash, &isl_id_none);
+	id = tuple_id(space, isl_dim_in);
 	hash = isl_hash_id(hash, id);
 
-	hash = isl_hash_dim(hash, dim->nested0);
-	hash = isl_hash_dim(hash, dim->nested1);
+	hash = isl_hash_tuples(hash, space->nested0);
 
 	return hash;
 }
 
-uint32_t isl_space_get_hash(__isl_keep isl_space *dim)
+/* Return a hash value that digests the tuples of "space",
+ * i.e., that ignores the parameters.
+ * Changes in this function should be reflected
+ * in isl_space_get_tuple_domain_hash.
+ */
+uint32_t isl_space_get_tuple_hash(__isl_keep isl_space *space)
 {
 	uint32_t hash;
 
-	if (!dim)
+	if (!space)
 		return 0;
 
 	hash = isl_hash_init();
-	hash = isl_hash_dim(hash, dim);
+	hash = isl_hash_tuples(hash, space);
 
 	return hash;
 }
 
-int isl_space_is_wrapping(__isl_keep isl_space *dim)
+/* Return the hash value of "space".
+ */
+uint32_t isl_space_get_full_hash(__isl_keep isl_space *space)
 {
-	if (!dim)
-		return -1;
+	uint32_t hash;
 
-	if (!isl_space_is_set(dim))
+	if (!space)
 		return 0;
 
-	return dim->nested1 != NULL;
+	hash = isl_hash_init();
+	hash = isl_hash_params(hash, space);
+	hash = isl_hash_tuples(hash, space);
+
+	return hash;
+}
+
+/* Return the hash value of the domain tuple of "space".
+ * That is, isl_space_get_tuple_domain_hash(space) is equal to
+ * isl_space_get_tuple_hash(isl_space_domain(space)).
+ */
+uint32_t isl_space_get_tuple_domain_hash(__isl_keep isl_space *space)
+{
+	uint32_t hash;
+
+	if (!space)
+		return 0;
+
+	hash = isl_hash_init();
+	hash = isl_hash_tuples_domain(hash, space);
+
+	return hash;
+}
+
+/* Is "space" the space of a set wrapping a map space?
+ */
+isl_bool isl_space_is_wrapping(__isl_keep isl_space *space)
+{
+	if (!space)
+		return isl_bool_error;
+
+	if (!isl_space_is_set(space))
+		return isl_bool_false;
+
+	return isl_bool_ok(space->nested1 != NULL);
 }
 
 /* Is "space" the space of a map where the domain is a wrapped map space?
  */
-int isl_space_domain_is_wrapping(__isl_keep isl_space *space)
+isl_bool isl_space_domain_is_wrapping(__isl_keep isl_space *space)
 {
 	if (!space)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_space_is_set(space))
-		return 0;
+		return isl_bool_false;
 
-	return space->nested0 != NULL;
+	return isl_bool_ok(space->nested0 != NULL);
 }
 
 /* Is "space" the space of a map where the range is a wrapped map space?
  */
-int isl_space_range_is_wrapping(__isl_keep isl_space *space)
+isl_bool isl_space_range_is_wrapping(__isl_keep isl_space *space)
 {
 	if (!space)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_space_is_set(space))
-		return 0;
+		return isl_bool_false;
+
+	return isl_bool_ok(space->nested1 != NULL);
+}
+
+/* Is "space" a product of two spaces?
+ * That is, is it a wrapping set space or a map space
+ * with wrapping domain and range?
+ */
+isl_bool isl_space_is_product(__isl_keep isl_space *space)
+{
+	isl_bool is_set;
+	isl_bool is_product;
 
-	return space->nested1 != NULL;
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_bool_error;
+	if (is_set)
+		return isl_space_is_wrapping(space);
+	is_product = isl_space_domain_is_wrapping(space);
+	if (is_product < 0 || !is_product)
+		return is_product;
+	return isl_space_range_is_wrapping(space);
 }
 
-__isl_give isl_space *isl_space_wrap(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_wrap(__isl_take isl_space *space)
 {
 	isl_space *wrap;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	wrap = isl_space_set_alloc(dim->ctx,
-				    dim->nparam, dim->n_in + dim->n_out);
+	wrap = isl_space_set_alloc(space->ctx,
+				    space->nparam, space->n_in + space->n_out);
 
-	wrap = copy_ids(wrap, isl_dim_param, 0, dim, isl_dim_param);
-	wrap = copy_ids(wrap, isl_dim_set, 0, dim, isl_dim_in);
-	wrap = copy_ids(wrap, isl_dim_set, dim->n_in, dim, isl_dim_out);
+	wrap = copy_ids(wrap, isl_dim_param, 0, space, isl_dim_param);
+	wrap = copy_ids(wrap, isl_dim_set, 0, space, isl_dim_in);
+	wrap = copy_ids(wrap, isl_dim_set, space->n_in, space, isl_dim_out);
 
 	if (!wrap)
 		goto error;
 
-	wrap->nested1 = dim;
+	wrap->nested1 = space;
 
 	return wrap;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give isl_space *isl_space_unwrap(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_unwrap(__isl_take isl_space *space)
 {
 	isl_space *unwrap;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	if (!isl_space_is_wrapping(dim))
-		isl_die(dim->ctx, isl_error_invalid, "not a wrapping space",
+	if (!isl_space_is_wrapping(space))
+		isl_die(space->ctx, isl_error_invalid, "not a wrapping space",
 			goto error);
 
-	unwrap = isl_space_copy(dim->nested1);
-	isl_space_free(dim);
+	unwrap = isl_space_copy(space->nested1);
+	isl_space_free(space);
 
 	return unwrap;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-int isl_space_is_named_or_nested(__isl_keep isl_space *dim, enum isl_dim_type type)
+isl_bool isl_space_is_named_or_nested(__isl_keep isl_space *space,
+	enum isl_dim_type type)
 {
 	if (type != isl_dim_in && type != isl_dim_out)
-		return 0;
-	if (!dim)
-		return -1;
-	if (dim->tuple_idtype - isl_dim_in)
-		return 1;
-	if (dim->nestedtype - isl_dim_in)
-		return 1;
-	return 0;
+		return isl_bool_false;
+	if (!space)
+		return isl_bool_error;
+	if (space->tuple_idtype - isl_dim_in)
+		return isl_bool_true;
+	if (space->nestedtype - isl_dim_in)
+		return isl_bool_true;
+	return isl_bool_false;
 }
 
-int isl_space_may_be_set(__isl_keep isl_space *dim)
+isl_bool isl_space_may_be_set(__isl_keep isl_space *space)
 {
-	if (!dim)
-		return -1;
-	if (isl_space_is_set(dim))
-		return 1;
-	if (isl_space_dim(dim, isl_dim_in) != 0)
-		return 0;
-	if (isl_space_is_named_or_nested(dim, isl_dim_in))
-		return 0;
-	return 1;
-}
+	isl_bool nested;
+	isl_size n_in;
 
-__isl_give isl_space *isl_space_reset(__isl_take isl_space *dim,
+	if (!space)
+		return isl_bool_error;
+	if (isl_space_is_set(space))
+		return isl_bool_true;
+	n_in = isl_space_dim(space, isl_dim_in);
+	if (n_in < 0)
+		return isl_bool_error;
+	if (n_in != 0)
+		return isl_bool_false;
+	nested = isl_space_is_named_or_nested(space, isl_dim_in);
+	if (nested < 0 || nested)
+		return isl_bool_not(nested);
+	return isl_bool_true;
+}
+
+__isl_give isl_space *isl_space_reset(__isl_take isl_space *space,
 	enum isl_dim_type type)
 {
-	if (!isl_space_is_named_or_nested(dim, type))
-		return dim;
+	if (!isl_space_is_named_or_nested(space, type))
+		return space;
 
-	dim = isl_space_cow(dim);
-	if (!dim)
+	space = isl_space_cow(space);
+	if (!space)
 		return NULL;
 
-	isl_id_free(dim->tuple_idtype - isl_dim_in);
-	dim->tuple_idtype - isl_dim_in = NULL;
-	isl_space_free(dim->nestedtype - isl_dim_in);
-	dim->nestedtype - isl_dim_in = NULL;
+	isl_id_free(space->tuple_idtype - isl_dim_in);
+	space->tuple_idtype - isl_dim_in = NULL;
+	isl_space_free(space->nestedtype - isl_dim_in);
+	space->nestedtype - isl_dim_in = NULL;
 
-	return dim;
+	return space;
 }
 
-__isl_give isl_space *isl_space_flatten(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_flatten(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!dim->nested0 && !dim->nested1)
-		return dim;
+	if (!space->nested0 && !space->nested1)
+		return space;
 
-	if (dim->nested0)
-		dim = isl_space_reset(dim, isl_dim_in);
-	if (dim && dim->nested1)
-		dim = isl_space_reset(dim, isl_dim_out);
+	if (space->nested0)
+		space = isl_space_reset(space, isl_dim_in);
+	if (space && space->nested1)
+		space = isl_space_reset(space, isl_dim_out);
 
-	return dim;
+	return space;
 }
 
-__isl_give isl_space *isl_space_flatten_domain(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_flatten_domain(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!dim->nested0)
-		return dim;
+	if (!space->nested0)
+		return space;
 
-	return isl_space_reset(dim, isl_dim_in);
+	return isl_space_reset(space, isl_dim_in);
 }
 
-__isl_give isl_space *isl_space_flatten_range(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_flatten_range(__isl_take isl_space *space)
 {
-	if (!dim)
+	if (!space)
 		return NULL;
-	if (!dim->nested1)
-		return dim;
+	if (!space->nested1)
+		return space;
 
-	return isl_space_reset(dim, isl_dim_out);
+	return isl_space_reset(space, isl_dim_out);
 }
 
-/* Replace the dimensions of the given type of dst by those of src.
+/* Replace the parameters of dst by those of src.
  */
-__isl_give isl_space *isl_space_replace(__isl_take isl_space *dst,
-	enum isl_dim_type type, __isl_keep isl_space *src)
+__isl_give isl_space *isl_space_replace_params(__isl_take isl_space *dst,
+	__isl_keep isl_space *src)
 {
+	isl_size dst_dim, src_dim;
+	isl_bool equal_params;
+	enum isl_dim_type type = isl_dim_param;
+
+	equal_params = isl_space_has_equal_params(dst, src);
+	if (equal_params < 0)
+		return isl_space_free(dst);
+	if (equal_params)
+		return dst;
+
 	dst = isl_space_cow(dst);
 
-	if (!dst || !src)
+	dst_dim = isl_space_dim(dst, type);
+	src_dim = isl_space_dim(src, type);
+	if (dst_dim < 0 || src_dim < 0)
 		goto error;
 
-	dst = isl_space_drop_dims(dst, type, 0, isl_space_dim(dst, type));
-	dst = isl_space_add_dims(dst, type, isl_space_dim(src, type));
+	dst = isl_space_drop_dims(dst, type, 0, dst_dim);
+	dst = isl_space_add_dims(dst, type, src_dim);
 	dst = copy_ids(dst, type, 0, src, type);
 
-	if (dst && type == isl_dim_param) {
+	if (dst) {
 		int i;
 		for (i = 0; i <= 1; ++i) {
+			isl_space *nested;
+
 			if (!dst->nestedi)
 				continue;
-			dst->nestedi = isl_space_replace(dst->nestedi,
-							 type, src);
-			if (!dst->nestedi)
-				goto error;
+			nested = isl_space_take_nested(dst, i);
+			nested = isl_space_replace_params(nested, src);
+			dst = isl_space_restore_nested(dst, i, nested);
+			if (!dst)
+				return NULL;
 		}
 	}
 
@@ -2035,51 +2977,97 @@
 	return NULL;
 }
 
-/* Given a dimension specification "dim" of a set, create a dimension
- * specification for the lift of the set.  In particular, the result
- * is of the form dim -> local.., with n_local variables in the
+/* Given two tuples ("dst_type" in "dst" and "src_type" in "src")
+ * of the same size, check if any of the dimensions in the "dst" tuple
+ * have no identifier, while the corresponding dimensions in "src"
+ * does have an identifier,
+ * If so, copy the identifier over to "dst".
+ */
+__isl_give isl_space *isl_space_copy_ids_if_unset(__isl_take isl_space *dst,
+	enum isl_dim_type dst_type, __isl_keep isl_space *src,
+	enum isl_dim_type src_type)
+{
+	int i;
+	isl_size n;
+
+	n = isl_space_dim(dst, dst_type);
+	if (n < 0)
+		return isl_space_free(dst);
+	for (i = 0; i < n; ++i) {
+		isl_bool set;
+		isl_id *id;
+
+		set = isl_space_has_dim_id(dst, dst_type, i);
+		if (set < 0)
+			return isl_space_free(dst);
+		if (set)
+			continue;
+
+		set = isl_space_has_dim_id(src, src_type, i);
+		if (set < 0)
+			return isl_space_free(dst);
+		if (!set)
+			continue;
+
+		id = isl_space_get_dim_id(src, src_type, i);
+		dst = isl_space_set_dim_id(dst, dst_type, i, id);
+	}
+
+	return dst;
+}
+
+/* Given a space "space" of a set, create a space
+ * for the lift of the set.  In particular, the result
+ * is of the form liftedspace -> local.., with n_local variables in the
  * range of the wrapped map.
  */
-__isl_give isl_space *isl_space_lift(__isl_take isl_space *dim, unsigned n_local)
+__isl_give isl_space *isl_space_lift(__isl_take isl_space *space,
+	unsigned n_local)
 {
-	isl_space *local_dim;
+	isl_space *local_space;
 
-	if (!dim)
+	if (!space)
 		return NULL;
 
-	local_dim = isl_space_dup(dim);
-	local_dim = isl_space_drop_dims(local_dim, isl_dim_set, 0, dim->n_out);
-	local_dim = isl_space_add_dims(local_dim, isl_dim_set, n_local);
-	local_dim = isl_space_set_tuple_name(local_dim, isl_dim_set, "local");
-	dim = isl_space_join(isl_space_from_domain(dim),
-			    isl_space_from_range(local_dim));
-	dim = isl_space_wrap(dim);
-	dim = isl_space_set_tuple_name(dim, isl_dim_set, "lifted");
+	local_space = isl_space_dup(space);
+	local_space = isl_space_drop_dims(local_space, isl_dim_set, 0,
+					space->n_out);
+	local_space = isl_space_add_dims(local_space, isl_dim_set, n_local);
+	local_space = isl_space_set_tuple_name(local_space,
+						isl_dim_set, "local");
+	space = isl_space_join(isl_space_from_domain(space),
+			    isl_space_from_range(local_space));
+	space = isl_space_wrap(space);
+	space = isl_space_set_tuple_name(space, isl_dim_set, "lifted");
 
-	return dim;
+	return space;
 }
 
-int isl_space_can_zip(__isl_keep isl_space *dim)
+isl_bool isl_space_can_zip(__isl_keep isl_space *space)
 {
-	if (!dim)
-		return -1;
+	isl_bool is_set;
 
-	return dim->nested0 && dim->nested1;
+	is_set = isl_space_is_set(space);
+	if (is_set < 0)
+		return isl_bool_error;
+	if (is_set)
+		return isl_bool_false;
+	return isl_space_is_product(space);
 }
 
-__isl_give isl_space *isl_space_zip(__isl_take isl_space *dim)
+__isl_give isl_space *isl_space_zip(__isl_take isl_space *space)
 {
 	isl_space *dom, *ran;
 	isl_space *dom_dom, *dom_ran, *ran_dom, *ran_ran;
 
-	if (!isl_space_can_zip(dim))
-		isl_die(dim->ctx, isl_error_invalid, "dim cannot be zipped",
+	if (!isl_space_can_zip(space))
+		isl_die(space->ctx, isl_error_invalid, "space cannot be zipped",
 			goto error);
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	dom = isl_space_unwrap(isl_space_domain(isl_space_copy(dim)));
-	ran = isl_space_unwrap(isl_space_range(dim));
+	dom = isl_space_unwrap(isl_space_domain(isl_space_copy(space)));
+	ran = isl_space_unwrap(isl_space_range(space));
 	dom_dom = isl_space_domain(isl_space_copy(dom));
 	dom_ran = isl_space_range(dom);
 	ran_dom = isl_space_domain(isl_space_copy(ran));
@@ -2091,19 +3079,16 @@
 	return isl_space_join(isl_space_from_domain(isl_space_wrap(dom)),
 			    isl_space_from_range(isl_space_wrap(ran)));
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
 /* Can we apply isl_space_curry to "space"?
- * That is, does it have a nested relation in its domain?
+ * That is, does is it have a map space with a nested relation in its domain?
  */
-int isl_space_can_curry(__isl_keep isl_space *space)
+isl_bool isl_space_can_curry(__isl_keep isl_space *space)
 {
-	if (!space)
-		return -1;
-
-	return !!space->nested0;
+	return isl_space_domain_is_wrapping(space);
 }
 
 /* Given a space (A -> B) -> C, return the corresponding space
@@ -2134,15 +3119,50 @@
 	return NULL;
 }
 
-/* Can we apply isl_space_uncurry to "space"?
- * That is, does it have a nested relation in its range?
+/* Can isl_space_range_curry be applied to "space"?
+ * That is, does it have a nested relation in its range,
+ * the domain of which is itself a nested relation?
  */
-int isl_space_can_uncurry(__isl_keep isl_space *space)
+isl_bool isl_space_can_range_curry(__isl_keep isl_space *space)
 {
+	isl_bool can;
+
 	if (!space)
-		return -1;
+		return isl_bool_error;
+	can = isl_space_range_is_wrapping(space);
+	if (can < 0 || !can)
+		return can;
+	return isl_space_can_curry(space->nested1);
+}
+
+/* Given a space A -> ((B -> C) -> D), return the corresponding space
+ * A -> (B -> (C -> D)).
+ */
+__isl_give isl_space *isl_space_range_curry(__isl_take isl_space *space)
+{
+	isl_space *nested;
 
-	return !!space->nested1;
+	if (!space)
+		return NULL;
+
+	if (!isl_space_can_range_curry(space))
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"space range cannot be curried",
+			return isl_space_free(space));
+
+	nested = isl_space_take_nested(space, 1);
+	nested = isl_space_curry(nested);
+	space = isl_space_restore_nested(space, 1, nested);
+
+	return space;
+}
+
+/* Can we apply isl_space_uncurry to "space"?
+ * That is, does it have a map space with a nested relation in its range?
+ */
+isl_bool isl_space_can_uncurry(__isl_keep isl_space *space)
+{
+	return isl_space_range_is_wrapping(space);
 }
 
 /* Given a space A -> (B -> C), return the corresponding space
@@ -2171,48 +3191,61 @@
 			    isl_space_from_range(ran_ran));
 }
 
-int isl_space_has_named_params(__isl_keep isl_space *dim)
+isl_bool isl_space_has_named_params(__isl_keep isl_space *space)
 {
 	int i;
 	unsigned off;
 
-	if (!dim)
-		return -1;
-	if (dim->nparam == 0)
-		return 1;
-	off = isl_space_offset(dim, isl_dim_param);
-	if (off + dim->nparam > dim->n_id)
-		return 0;
-	for (i = 0; i < dim->nparam; ++i)
-		if (!dim->idsoff + i)
-			return 0;
-	return 1;
+	if (!space)
+		return isl_bool_error;
+	if (space->nparam == 0)
+		return isl_bool_true;
+	off = isl_space_offset(space, isl_dim_param);
+	if (off + space->nparam > space->n_id)
+		return isl_bool_false;
+	for (i = 0; i < space->nparam; ++i)
+		if (!space->idsoff + i)
+			return isl_bool_false;
+	return isl_bool_true;
+}
+
+/* Check that "space" has only named parameters, reporting an error
+ * if it does not.
+ */
+isl_stat isl_space_check_named_params(__isl_keep isl_space *space)
+{
+	isl_bool named;
+
+	named = isl_space_has_named_params(space);
+	if (named < 0)
+		return isl_stat_error;
+	if (!named)
+		isl_die(isl_space_get_ctx(space), isl_error_invalid,
+			"unexpected unnamed parameters", return isl_stat_error);
+
+	return isl_stat_ok;
 }
 
-/* Align the initial parameters of dim1 to match the order in dim2.
+/* Align the initial parameters of space1 to match the order in space2.
  */
-__isl_give isl_space *isl_space_align_params(__isl_take isl_space *dim1,
-	__isl_take isl_space *dim2)
+__isl_give isl_space *isl_space_align_params(__isl_take isl_space *space1,
+	__isl_take isl_space *space2)
 {
 	isl_reordering *exp;
 
-	if (!isl_space_has_named_params(dim1) || !isl_space_has_named_params(dim2))
-		isl_die(isl_space_get_ctx(dim1), isl_error_invalid,
-			"parameter alignment requires named parameters",
-			goto error);
+	if (isl_space_check_named_params(space1) < 0 ||
+	    isl_space_check_named_params(space2) < 0)
+		goto error;
 
-	dim2 = isl_space_params(dim2);
-	exp = isl_parameter_alignment_reordering(dim1, dim2);
-	exp = isl_reordering_extend_space(exp, dim1);
-	isl_space_free(dim2);
-	if (!exp)
-		return NULL;
-	dim1 = isl_space_copy(exp->dim);
+	exp = isl_parameter_alignment_reordering(space1, space2);
+	exp = isl_reordering_extend_space(exp, space1);
+	isl_space_free(space2);
+	space1 = isl_reordering_get_space(exp);
 	isl_reordering_free(exp);
-	return dim1;
+	return space1;
 error:
-	isl_space_free(dim1);
-	isl_space_free(dim2);
+	isl_space_free(space1);
+	isl_space_free(space2);
 	return NULL;
 }
 
@@ -2222,12 +3255,16 @@
 __isl_give isl_space *isl_space_extend_domain_with_range(
 	__isl_take isl_space *space, __isl_take isl_space *model)
 {
+	isl_size n_out;
+
 	if (!model)
 		goto error;
 
 	space = isl_space_from_domain(space);
-	space = isl_space_add_dims(space, isl_dim_out,
-				    isl_space_dim(model, isl_dim_out));
+	n_out = isl_space_dim(model, isl_dim_out);
+	if (n_out < 0)
+		goto error;
+	space = isl_space_add_dims(space, isl_dim_out, n_out);
 	if (isl_space_has_tuple_id(model, isl_dim_out))
 		space = isl_space_set_tuple_id(space, isl_dim_out,
 				isl_space_get_tuple_id(model, isl_dim_out));
@@ -2235,10 +3272,12 @@
 		goto error;
 	if (model->nested1) {
 		isl_space *nested = isl_space_copy(model->nested1);
-		int n_nested, n_space;
+		isl_size n_nested, n_space;
 		nested = isl_space_align_params(nested, isl_space_copy(space));
 		n_nested = isl_space_dim(nested, isl_dim_param);
 		n_space = isl_space_dim(space, isl_dim_param);
+		if (n_nested < 0 || n_space < 0)
+			goto error;
 		if (n_nested > n_space)
 			nested = isl_space_drop_dims(nested, isl_dim_param,
 						n_space, n_nested - n_space);
@@ -2262,11 +3301,15 @@
 	__isl_keep isl_space *space2, enum isl_dim_type type)
 {
 	int cmp;
+	isl_size dim1, dim2;
 	isl_space *nested1, *nested2;
 
-	if (isl_space_dim(space1, type) != isl_space_dim(space2, type))
-		return isl_space_dim(space1, type) -
-			isl_space_dim(space2, type);
+	dim1 = isl_space_dim(space1, type);
+	dim2 = isl_space_dim(space2, type);
+	if (dim1 < 0 || dim2 < 0)
+		return 0;
+	if (dim1 != dim2)
+		return dim1 - dim2;
 
 	cmp = isl_id_cmp(tuple_id(space1, type), tuple_id(space2, type));
 	if (cmp != 0)

_service:tar_scm:isl-0.14.tar.xz/isl_space_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_space_private.h Changed

@@ -3,7 +3,7 @@
 
 #include <isl/space.h>
 #include <isl/hash.h>
-#include <isl/id.h>
+#include <isl/id_type.h>
 
 struct isl_name;
 struct isl_space {
@@ -22,38 +22,78 @@
 	isl_id **ids;
 };
 
-__isl_give isl_space *isl_space_cow(__isl_take isl_space *dim);
+__isl_give isl_space *isl_space_cow(__isl_take isl_space *space);
 
-__isl_give isl_space *isl_space_underlying(__isl_take isl_space *dim,
+__isl_give isl_space *isl_space_underlying(__isl_take isl_space *space,
 	unsigned n_div);
 
-uint32_t isl_space_get_hash(__isl_keep isl_space *dim);
+uint32_t isl_space_get_tuple_hash(__isl_keep isl_space *space);
+uint32_t isl_space_get_tuple_domain_hash(__isl_keep isl_space *space);
+uint32_t isl_space_get_full_hash(__isl_keep isl_space *space);
 
-int isl_space_is_domain_internal(__isl_keep isl_space *space1,
+isl_bool isl_space_has_domain_tuples(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2);
-int isl_space_is_range_internal(__isl_keep isl_space *space1,
+isl_bool isl_space_has_range_tuples(__isl_keep isl_space *space1,
 	__isl_keep isl_space *space2);
-
-__isl_give isl_space *isl_space_as_set_space(__isl_take isl_space *dim);
-
-unsigned isl_space_offset(__isl_keep isl_space *dim, enum isl_dim_type type);
-
-int isl_space_may_be_set(__isl_keep isl_space *dim);
-int isl_space_is_named_or_nested(__isl_keep isl_space *dim, enum isl_dim_type type);
-int isl_space_has_named_params(__isl_keep isl_space *dim);
-__isl_give isl_space *isl_space_reset(__isl_take isl_space *dim,
+isl_stat isl_space_check_domain_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_bool isl_space_is_domain_internal(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_bool isl_space_is_range_internal(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_stat isl_space_check_domain_wrapped_domain_tuples(
+	__isl_keep isl_space *space1, __isl_keep isl_space *space2);
+isl_bool isl_space_wrapped_tuple_is_equal(__isl_keep isl_space *space1,
+	enum isl_dim_type outer, enum isl_dim_type inner,
+	__isl_keep isl_space *space2, enum isl_dim_type type2);
+isl_stat isl_space_check_wrapped_tuple_is_equal(__isl_keep isl_space *space1,
+	enum isl_dim_type outer, enum isl_dim_type inner,
+	__isl_keep isl_space *space2, enum isl_dim_type type2);
+
+isl_size isl_space_wrapped_dim(__isl_keep isl_space *space,
+	enum isl_dim_type outer, enum isl_dim_type inner);
+unsigned isl_space_offset(__isl_keep isl_space *space, enum isl_dim_type type);
+
+isl_stat isl_space_check_range(__isl_keep isl_space *space,
+	enum isl_dim_type type, unsigned first, unsigned n);
+isl_stat isl_space_check_is_set(__isl_keep isl_space *space);
+isl_bool isl_space_may_be_set(__isl_keep isl_space *space);
+isl_bool isl_space_is_named_or_nested(__isl_keep isl_space *space,
 	enum isl_dim_type type);
-__isl_give isl_space *isl_space_flatten(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_flatten_domain(__isl_take isl_space *dim);
-__isl_give isl_space *isl_space_flatten_range(__isl_take isl_space *dim);
+isl_bool isl_space_has_equal_ids(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_bool isl_space_has_named_params(__isl_keep isl_space *space);
+isl_stat isl_space_check_named_params(__isl_keep isl_space *space);
+isl_stat isl_space_check_equal_params(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+isl_stat isl_space_check_equal_tuples(__isl_keep isl_space *space1,
+	__isl_keep isl_space *space2);
+__isl_give isl_space *isl_space_reset(__isl_take isl_space *space,
+	enum isl_dim_type type);
+__isl_give isl_space *isl_space_flatten(__isl_take isl_space *space);
+
+isl_stat isl_space_check_domain_is_wrapping(__isl_keep isl_space *space);
+isl_stat isl_space_check_range_is_wrapping(__isl_keep isl_space *space);
 
-__isl_give isl_space *isl_space_replace(__isl_take isl_space *dst,
-	enum isl_dim_type type, __isl_keep isl_space *src);
+__isl_give isl_space *isl_space_replace_params(__isl_take isl_space *dst,
+	__isl_keep isl_space *src);
+__isl_give isl_space *isl_space_copy_ids_if_unset(__isl_take isl_space *dst,
+	enum isl_dim_type dst_type, __isl_keep isl_space *src,
+	enum isl_dim_type src_type);
 
-__isl_give isl_space *isl_space_lift(__isl_take isl_space *dim, unsigned n_local);
+__isl_give isl_space *isl_space_lift(__isl_take isl_space *space,
+	unsigned n_local);
 
 __isl_give isl_space *isl_space_extend_domain_with_range(
 	__isl_take isl_space *domain, __isl_take isl_space *model);
+__isl_give isl_space *isl_space_bind_set(__isl_take isl_space *space,
+	__isl_keep isl_multi_id *tuple);
+__isl_give isl_space *isl_space_bind_map_domain(__isl_take isl_space *space,
+	__isl_keep isl_multi_id *tuple);
+__isl_give isl_space *isl_space_bind_domain_wrapped_domain(
+	__isl_take isl_space *space, __isl_keep isl_multi_id *tuple);
+__isl_give isl_space *isl_space_unbind_params_insert_domain(
+	__isl_take isl_space *space, __isl_keep isl_multi_id *tuple);
 
 int isl_space_cmp(__isl_keep isl_space *space1, __isl_keep isl_space *space2);

_service:tar_scm:isl-0.24.tar.gz/isl_srcdir.c.in Added

_service:tar_scm:isl-0.14.tar.xz/isl_stream.c -> _service:tar_scm:isl-0.24.tar.gz/isl_stream.c Changed

@@ -9,7 +9,6 @@
 
 #include <ctype.h>
 #include <string.h>
-#include <strings.h>
 #include <isl/ctx.h>
 #include <isl_stream_private.h>
 #include <isl/map.h>
@@ -21,14 +20,14 @@
 	enum isl_token_type	type;
 };
 
-static int same_name(const void *entry, const void *val)
+static isl_bool same_name(const void *entry, const void *val)
 {
 	const struct isl_keyword *keyword = (const struct isl_keyword *)entry;
 
-	return !strcmp(keyword->name, val);
+	return isl_bool_ok(!strcmp(keyword->name, val));
 }
 
-enum isl_token_type isl_stream_register_keyword(struct isl_stream *s,
+enum isl_token_type isl_stream_register_keyword(__isl_keep isl_stream *s,
 	const char *name)
 {
 	struct isl_hash_table_entry *entry;
@@ -101,14 +100,15 @@
 	return isl_val_int_from_isl_int(ctx, tok->u.v);
 }
 
-/* Given a token of type ISL_TOKEN_STRING, return the string it represents.
+/* Given a token with a string representation, return a copy of this string.
  */
 __isl_give char *isl_token_get_str(isl_ctx *ctx, struct isl_token *tok)
 {
 	if (!tok)
 		return NULL;
-	if (tok->type != ISL_TOKEN_STRING)
-		isl_die(ctx, isl_error_invalid, "not a string token",
+	if (!tok->u.s)
+		isl_die(ctx, isl_error_invalid,
+			"token does not have a string representation",
 			return NULL);
 
 	return strdup(tok->u.s);
@@ -129,7 +129,8 @@
 	free(tok);
 }
 
-void isl_stream_error(struct isl_stream *s, struct isl_token *tok, char *msg)
+void isl_stream_error(__isl_keep isl_stream *s, struct isl_token *tok,
+	char *msg)
 {
 	int line = tok ? tok->line : s->line;
 	int col = tok ? tok->col : s->col;
@@ -166,10 +167,10 @@
 	}
 }
 
-static struct isl_stream* isl_stream_new(struct isl_ctx *ctx)
+static __isl_give isl_stream* isl_stream_new(struct isl_ctx *ctx)
 {
 	int i;
-	struct isl_stream *s = isl_alloc_type(ctx, struct isl_stream);
+	isl_stream *s = isl_calloc_type(ctx, struct isl_stream);
 	if (!s)
 		return NULL;
 	s->ctx = ctx;
@@ -178,8 +179,9 @@
 	s->str = NULL;
 	s->len = 0;
 	s->line = 1;
-	s->col = 0;
+	s->col = 1;
 	s->eof = 0;
+	s->last_line = 0;
 	s->c = -1;
 	s->n_un = 0;
 	for (i = 0; i < 5; ++i)
@@ -196,18 +198,18 @@
 	return NULL;
 }
 
-struct isl_stream* isl_stream_new_file(struct isl_ctx *ctx, FILE *file)
+__isl_give isl_stream* isl_stream_new_file(struct isl_ctx *ctx, FILE *file)
 {
-	struct isl_stream *s = isl_stream_new(ctx);
+	isl_stream *s = isl_stream_new(ctx);
 	if (!s)
 		return NULL;
 	s->file = file;
 	return s;
 }
 
-struct isl_stream* isl_stream_new_str(struct isl_ctx *ctx, const char *str)
+__isl_give isl_stream* isl_stream_new_str(struct isl_ctx *ctx, const char *str)
 {
-	struct isl_stream *s;
+	isl_stream *s;
 	if (!str)
 		return NULL;
 	s = isl_stream_new(ctx);
@@ -217,7 +219,10 @@
 	return s;
 }
 
-static int stream_getc(struct isl_stream *s)
+/* Read a character from the stream and advance s->line and s->col
+ * to point to the next character.
+ */
+static int stream_getc(__isl_keep isl_stream *s)
 {
 	int c;
 	if (s->eof)
@@ -233,29 +238,33 @@
 	}
 	if (c == -1)
 		s->eof = 1;
-	if (!s->eof) {
-		if (s->c == '\n') {
-			s->line++;
-			s->col = 0;
-		} else
-			s->col++;
-	}
+	else if (c == '\n') {
+		s->line++;
+		s->col = 1;
+	} else
+		s->col++;
 	s->c = c;
 	return c;
 }
 
-static void isl_stream_ungetc(struct isl_stream *s, int c)
+static void isl_stream_ungetc(__isl_keep isl_stream *s, int c)
 {
 	isl_assert(s->ctx, s->n_un < 5, return);
 	s->uns->n_un++ = c;
 	s->c = -1;
 }
 
-static int isl_stream_getc(struct isl_stream *s)
+/* Read a character from the stream, skipping pairs of '\\' and '\n'.
+ * Set s->start_line and s->start_col to the line and column
+ * of the returned character.
+ */
+static int isl_stream_getc(__isl_keep isl_stream *s)
 {
 	int c;
 
 	do {
+		s->start_line = s->line;
+		s->start_col = s->col;
 		c = stream_getc(s);
 		if (c != '\\')
 			return c;
@@ -267,7 +276,7 @@
 	return '\\';
 }
 
-static int isl_stream_push_char(struct isl_stream *s, int c)
+static int isl_stream_push_char(__isl_keep isl_stream *s, int c)
 {
 	if (s->len >= s->size) {
 		char *buffer;
@@ -281,13 +290,13 @@
 	return 0;
 }
 
-void isl_stream_push_token(struct isl_stream *s, struct isl_token *tok)
+void isl_stream_push_token(__isl_keep isl_stream *s, struct isl_token *tok)
 {
 	isl_assert(s->ctx, s->n_token < 5, return);
 	s->tokenss->n_token++ = tok;
 }
 
-static enum isl_token_type check_keywords(struct isl_stream *s)
+static enum isl_token_type check_keywords(__isl_keep isl_stream *s)
 {
 	struct isl_hash_table_entry *entry;
 	struct isl_keyword *keyword;
@@ -336,7 +345,9 @@
 	name_hash = isl_hash_string(isl_hash_init(), s->buffer);
 	entry = isl_hash_table_find(s->ctx, s->keywords, name_hash, same_name,
 					s->buffer, 0);
-	if (entry) {
+	if (!entry)
+		return ISL_TOKEN_ERROR;
+	if (entry != isl_hash_table_entry_none) {
 		keyword = entry->data;
 		return keyword->type;
 	}
@@ -344,7 +355,7 @@
 	return ISL_TOKEN_IDENT;
 }
 
-int isl_stream_skip_line(struct isl_stream *s)
+int isl_stream_skip_line(__isl_keep isl_stream *s)
 {
 	int c;
 
@@ -355,12 +366,12 @@
 	return c == -1 ? -1 : 0;
 }
 
-static struct isl_token *next_token(struct isl_stream *s, int same_line)
+static struct isl_token *next_token(__isl_keep isl_stream *s, int same_line)
 {
 	int c;
 	struct isl_token *tok = NULL;
 	int line, col;
-	int old_line = s->line;
+	int old_line = s->last_line;
 
 	if (s->n_token) {
 		if (same_line && s->tokenss->n_token - 1->on_new_line)
@@ -385,11 +396,13 @@
 			break;
 	}
 
-	line = s->line;
-	col = s->col;
+	line = s->start_line;
+	col = s->start_col;
 
 	if (c == -1 || (same_line && c == '\n'))
 		return NULL;
+	s->last_line = line;
+
 	if (c == '(' ||
 	    c == ')' ||
 	    c == '+' ||
@@ -606,13 +619,19 @@
 		tok = isl_token_new(s->ctx, line, col, old_line != line);
 		if (!tok)
 			return NULL;
-		if ((c = isl_stream_getc(s)) != '\\' && c != -1) {
-			tok->type = (enum isl_token_type) '/';
-			isl_stream_ungetc(s, c);
-		} else {
+		if ((c = isl_stream_getc(s)) == '\\') {
 			tok->u.s = strdup("/\\");
 			tok->type = ISL_TOKEN_AND;
+			return tok;
+		} else if (c == '/') {
+			tok->u.s = strdup("//");
+			tok->type = ISL_TOKEN_INT_DIV;
+			return tok;
+		} else {
+			tok->type = (enum isl_token_type) '/';
 		}
+		if (c != -1)
+			isl_stream_ungetc(s, c);
 		return tok;
 	}
 	if (c == '\\') {
@@ -655,17 +674,17 @@
 	return NULL;
 }
 
-struct isl_token *isl_stream_next_token(struct isl_stream *s)
+struct isl_token *isl_stream_next_token(__isl_keep isl_stream *s)
 {
 	return next_token(s, 0);
 }
 
-struct isl_token *isl_stream_next_token_on_same_line(struct isl_stream *s)
+struct isl_token *isl_stream_next_token_on_same_line(__isl_keep isl_stream *s)
 {
 	return next_token(s, 1);
 }
 
-int isl_stream_eat_if_available(struct isl_stream *s, int type)
+int isl_stream_eat_if_available(__isl_keep isl_stream *s, int type)
 {
 	struct isl_token *tok;
 
@@ -680,7 +699,7 @@
 	return 0;
 }
 
-int isl_stream_next_token_is(struct isl_stream *s, int type)
+int isl_stream_next_token_is(__isl_keep isl_stream *s, int type)
 {
 	struct isl_token *tok;
 	int r;
@@ -693,7 +712,7 @@
 	return r;
 }
 
-char *isl_stream_read_ident_if_available(struct isl_stream *s)
+char *isl_stream_read_ident_if_available(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok;
 
@@ -709,13 +728,16 @@
 	return NULL;
 }
 
-int isl_stream_eat(struct isl_stream *s, int type)
+int isl_stream_eat(__isl_keep isl_stream *s, int type)
 {
 	struct isl_token *tok;
 
 	tok = isl_stream_next_token(s);
-	if (!tok)
+	if (!tok) {
+		if (s->eof)
+			isl_stream_error(s, NULL, "unexpected EOF");
 		return -1;
+	}
 	if (tok->type == type) {
 		isl_token_free(tok);
 		return 0;
@@ -725,7 +747,7 @@
 	return -1;
 }
 
-int isl_stream_is_empty(struct isl_stream *s)
+int isl_stream_is_empty(__isl_keep isl_stream *s)
 {
 	struct isl_token *tok;
 
@@ -738,17 +760,17 @@
 	return 0;
 }
 
-static int free_keyword(void **p, void *user)
+static isl_stat free_keyword(void **p, void *user)
 {
 	struct isl_keyword *keyword = *p;
 
 	free(keyword->name);
 	free(keyword);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-void isl_stream_flush_tokens(struct isl_stream *s)
+void isl_stream_flush_tokens(__isl_keep isl_stream *s)
 {
 	int i;
 
@@ -759,7 +781,12 @@
 	s->n_token = 0;
 }
 
-void isl_stream_free(struct isl_stream *s)
+isl_ctx *isl_stream_get_ctx(__isl_keep isl_stream *s)
+{
+	return s ? s->ctx : NULL;
+}
+
+void isl_stream_free(__isl_take isl_stream *s)
 {
 	if (!s)
 		return;
@@ -773,6 +800,382 @@
 		isl_hash_table_foreach(s->ctx, s->keywords, &free_keyword, NULL);
 		isl_hash_table_free(s->ctx, s->keywords);
 	}
+	free(s->yaml_state);
+	free(s->yaml_indent);
 	isl_ctx_deref(s->ctx);
 	free(s);
 }
+
+/* Push "state" onto the stack of currently active YAML elements.
+ * The caller is responsible for setting the corresponding indentation.
+ * Return 0 on success and -1 on failure.
+ */
+static int push_state(__isl_keep isl_stream *s, enum isl_yaml_state state)
+{
+	if (s->yaml_size < s->yaml_depth + 1) {
+		int *indent;
+		enum isl_yaml_state *state;
+
+		state = isl_realloc_array(s->ctx, s->yaml_state,
+					enum isl_yaml_state, s->yaml_depth + 1);
+		if (!state)
+			return -1;
+		s->yaml_state = state;
+
+		indent = isl_realloc_array(s->ctx, s->yaml_indent,
+					int, s->yaml_depth + 1);
+		if (!indent)
+			return -1;
+		s->yaml_indent = indent;
+
+		s->yaml_size = s->yaml_depth + 1;
+	}
+
+	s->yaml_states->yaml_depth = state;
+	s->yaml_depth++;
+
+	return 0;
+}
+
+/* Remove the innermost active YAML element from the stack.
+ * Return 0 on success and -1 on failure.
+ */
+static int pop_state(__isl_keep isl_stream *s)
+{
+	if (!s)
+		return -1;
+	if (s->yaml_depth < 1)
+		isl_die(isl_stream_get_ctx(s), isl_error_invalid,
+			"not in YAML construct", return -1);
+
+	s->yaml_depth--;
+
+	return 0;
+}
+
+/* Set the state of the innermost active YAML element to "state".
+ * Return 0 on success and -1 on failure.
+ */
+static int update_state(__isl_keep isl_stream *s, enum isl_yaml_state state)
+{
+	if (!s)
+		return -1;
+	if (s->yaml_depth < 1)
+		isl_die(isl_stream_get_ctx(s), isl_error_invalid,
+			"not in YAML construct", return -1);
+
+	s->yaml_states->yaml_depth - 1 = state;
+
+	return 0;
+}
+
+/* Return the state of the innermost active YAML element.
+ * Return isl_yaml_none if we are not inside any YAML element.
+ */
+static enum isl_yaml_state current_state(__isl_keep isl_stream *s)
+{
+	if (!s)
+		return isl_yaml_none;
+	if (s->yaml_depth < 1)
+		return isl_yaml_none;
+	return s->yaml_states->yaml_depth - 1;
+}
+
+/* Set the indentation of the innermost active YAML element to "indent".
+ * If "indent" is equal to ISL_YAML_INDENT_FLOW, then this means
+ * that the current elemient is in flow format.
+ */
+static int set_yaml_indent(__isl_keep isl_stream *s, int indent)
+{
+	if (s->yaml_depth < 1)
+		isl_die(s->ctx, isl_error_internal,
+			"not in YAML element", return -1);
+
+	s->yaml_indents->yaml_depth - 1 = indent;
+
+	return 0;
+}
+
+/* Return the indentation of the innermost active YAML element
+ * of -1 on error.
+ */
+static int get_yaml_indent(__isl_keep isl_stream *s)
+{
+	if (s->yaml_depth < 1)
+		isl_die(s->ctx, isl_error_internal,
+			"not in YAML element", return -1);
+
+	return s->yaml_indents->yaml_depth - 1;
+}
+
+/* Move to the next state at the innermost level.
+ * Return 1 if successful.
+ * Return 0 if we are at the end of the innermost level.
+ * Return -1 on error.
+ *
+ * If we are in state isl_yaml_mapping_key_start, then we have just
+ * started a mapping and we are expecting a key.  If the mapping started
+ * with a '{', then we check if the next token is a '}'.  If so,
+ * then the mapping is empty and there is no next state at this level.
+ * Otherwise, we assume that there is at least one key (the one from
+ * which we derived the indentation in isl_stream_yaml_read_start_mapping.
+ *
+ * If we are in state isl_yaml_mapping_key, then the we expect a colon
+ * followed by a value, so there is always a next state unless
+ * some error occurs.
+ *
+ * If we are in state isl_yaml_mapping_val, then there may or may
+ * not be a subsequent key in the same mapping.
+ * In flow format, the next key is preceded by a comma.
+ * In block format, the next key has the same indentation as the first key.
+ * If the first token has a smaller indentation, then we have reached
+ * the end of the current mapping.
+ *
+ * If we are in state isl_yaml_sequence_start, then we have just
+ * started a sequence.  If the sequence started with a '',
+ * then we check if the next token is a ''.  If so, then the sequence
+ * is empty and there is no next state at this level.
+ * Otherwise, we assume that there is at least one element in the sequence
+ * (the one from which we derived the indentation in
+ * isl_stream_yaml_read_start_sequence.
+ *
+ * If we are in state isl_yaml_sequence, then there may or may
+ * not be a subsequent element in the same sequence.
+ * In flow format, the next element is preceded by a comma.
+ * In block format, the next element is introduced by a dash with
+ * the same indentation as that of the first element.
+ * If the first token is not a dash or if it has a smaller indentation,
+ * then we have reached the end of the current sequence.
+ */
+int isl_stream_yaml_next(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	enum isl_yaml_state state;
+	int indent;
+
+	state = current_state(s);
+	if (state == isl_yaml_none)
+		isl_die(s->ctx, isl_error_invalid,
+			"not in YAML element", return -1);
+	switch (state) {
+	case isl_yaml_mapping_key_start:
+		if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW &&
+		    isl_stream_next_token_is(s, '}'))
+			return 0;
+		if (update_state(s, isl_yaml_mapping_key) < 0)
+			return -1;
+		return 1;
+	case isl_yaml_mapping_key:
+		tok = isl_stream_next_token(s);
+		if (!tok) {
+			if (s->eof)
+				isl_stream_error(s, NULL, "unexpected EOF");
+			return -1;
+		}
+		if (tok->type == ':') {
+			isl_token_free(tok);
+			if (update_state(s, isl_yaml_mapping_val) < 0)
+				return -1;
+			return 1;
+		}
+		isl_stream_error(s, tok, "expecting ':'");
+		isl_stream_push_token(s, tok);
+		return -1;
+	case isl_yaml_mapping_val:
+		if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW) {
+			if (!isl_stream_eat_if_available(s, ','))
+				return 0;
+			if (update_state(s, isl_yaml_mapping_key) < 0)
+				return -1;
+			return 1;
+		}
+		tok = isl_stream_next_token(s);
+		if (!tok)
+			return 0;
+		indent = tok->col - 1;
+		isl_stream_push_token(s, tok);
+		if (indent < get_yaml_indent(s))
+			return 0;
+		if (update_state(s, isl_yaml_mapping_key) < 0)
+			return -1;
+		return 1;
+	case isl_yaml_sequence_start:
+		if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW) {
+			if (isl_stream_next_token_is(s, ''))
+				return 0;
+			if (update_state(s, isl_yaml_sequence) < 0)
+				return -1;
+			return 1;
+		}
+		tok = isl_stream_next_token(s);
+		if (!tok) {
+			if (s->eof)
+				isl_stream_error(s, NULL, "unexpected EOF");
+			return -1;
+		}
+		if (tok->type == '-') {
+			isl_token_free(tok);
+			if (update_state(s, isl_yaml_sequence) < 0)
+				return -1;
+			return 1;
+		}
+		isl_stream_error(s, tok, "expecting '-'");
+		isl_stream_push_token(s, tok);
+		return 0;
+	case isl_yaml_sequence:
+		if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW)
+			return isl_stream_eat_if_available(s, ',');
+		tok = isl_stream_next_token(s);
+		if (!tok)
+			return 0;
+		indent = tok->col - 1;
+		if (indent < get_yaml_indent(s) || tok->type != '-') {
+			isl_stream_push_token(s, tok);
+			return 0;
+		}
+		isl_token_free(tok);
+		return 1;
+	default:
+		isl_die(s->ctx, isl_error_internal,
+			"unexpected state", return 0);
+	}
+}
+
+/* Start reading a YAML mapping.
+ * Return 0 on success and -1 on error.
+ *
+ * If the first token on the stream is a '{' then we remove this token
+ * from the stream and keep track of the fact that the mapping
+ * is given in flow format.
+ * Otherwise, we assume the first token is the first key of the mapping and
+ * keep track of its indentation, but keep the token on the stream.
+ * In both cases, the next token we expect is the first key of the mapping.
+ */
+int isl_stream_yaml_read_start_mapping(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int indent;
+
+	if (push_state(s, isl_yaml_mapping_key_start) < 0)
+		return -1;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		if (s->eof)
+			isl_stream_error(s, NULL, "unexpected EOF");
+		return -1;
+	}
+	if (isl_token_get_type(tok) == '{') {
+		isl_token_free(tok);
+		return set_yaml_indent(s, ISL_YAML_INDENT_FLOW);
+	}
+	indent = tok->col - 1;
+	isl_stream_push_token(s, tok);
+
+	return set_yaml_indent(s, indent);
+}
+
+/* Finish reading a YAML mapping.
+ * Return 0 on success and -1 on error.
+ *
+ * If the mapping started with a '{', then we expect a '}' to close
+ * the mapping.
+ * Otherwise, we double-check that the next token (if any)
+ * has a smaller indentation than that of the current mapping.
+ */
+int isl_stream_yaml_read_end_mapping(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int indent;
+
+	if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW) {
+		if (isl_stream_eat(s, '}') < 0)
+			return -1;
+		return pop_state(s);
+	}
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return pop_state(s);
+
+	indent = tok->col - 1;
+	isl_stream_push_token(s, tok);
+
+	if (indent >= get_yaml_indent(s))
+		isl_die(isl_stream_get_ctx(s), isl_error_invalid,
+			"mapping not finished", return -1);
+
+	return pop_state(s);
+}
+
+/* Start reading a YAML sequence.
+ * Return 0 on success and -1 on error.
+ *
+ * If the first token on the stream is a '' then we remove this token
+ * from the stream and keep track of the fact that the sequence
+ * is given in flow format.
+ * Otherwise, we assume the first token is the dash that introduces
+ * the first element of the sequence and keep track of its indentation,
+ * but keep the token on the stream.
+ * In both cases, the next token we expect is the first element
+ * of the sequence.
+ */
+int isl_stream_yaml_read_start_sequence(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int indent;
+
+	if (push_state(s, isl_yaml_sequence_start) < 0)
+		return -1;
+
+	tok = isl_stream_next_token(s);
+	if (!tok) {
+		if (s->eof)
+			isl_stream_error(s, NULL, "unexpected EOF");
+		return -1;
+	}
+	if (isl_token_get_type(tok) == '') {
+		isl_token_free(tok);
+		return set_yaml_indent(s, ISL_YAML_INDENT_FLOW);
+	}
+	indent = tok->col - 1;
+	isl_stream_push_token(s, tok);
+
+	return set_yaml_indent(s, indent);
+}
+
+/* Finish reading a YAML sequence.
+ * Return 0 on success and -1 on error.
+ *
+ * If the sequence started with a '', then we expect a '' to close
+ * the sequence.
+ * Otherwise, we double-check that the next token (if any)
+ * is not a dash or that it has a smaller indentation than
+ * that of the current sequence.
+ */
+int isl_stream_yaml_read_end_sequence(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int indent;
+	int dash;
+
+	if (get_yaml_indent(s) == ISL_YAML_INDENT_FLOW) {
+		if (isl_stream_eat(s, '') < 0)
+			return -1;
+		return pop_state(s);
+	}
+
+	tok = isl_stream_next_token(s);
+	if (!tok)
+		return pop_state(s);
+
+	indent = tok->col - 1;
+	dash = tok->type == '-';
+	isl_stream_push_token(s, tok);
+
+	if (indent >= get_yaml_indent(s) && dash)
+		isl_die(isl_stream_get_ctx(s), isl_error_invalid,
+			"sequence not finished", return -1);
+
+	return pop_state(s);
+}

_service:tar_scm:isl-0.14.tar.xz/isl_stream_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_stream_private.h Changed

@@ -1,5 +1,6 @@
 #include <isl_int.h>
 #include <isl/stream.h>
+#include <isl_yaml.h>
 
 struct isl_token {
 	int type;
@@ -19,3 +20,50 @@
 
 struct isl_token *isl_token_new(isl_ctx *ctx,
 	int line, int col, unsigned on_new_line);
+
+/* An input stream that may be either a file or a string.
+ *
+ * line and col are the line and column number of the next character (1-based).
+ * start_line and start_col are set by isl_stream_getc to point
+ * to the position of the returned character.
+ * last_line is the line number of the previous token.
+ *
+ * yaml_state and yaml_indent keep track of the currently active YAML
+ * elements.  yaml_size is the size of these arrays, while yaml_depth
+ * is the number of elements currently in use.
+ * yaml_state and yaml_indent may be NULL if no YAML parsing is being
+ * performed.
+ * yaml_state keeps track of what is expected next at each level.
+ * yaml_indent keeps track of the indentation at each level, with
+ * ISL_YAML_INDENT_FLOW meaning that the element is in flow format
+ * (such that the indentation is not relevant).
+ */
+struct isl_stream {
+	struct isl_ctx	*ctx;
+	FILE        	*file;
+	const char  	*str;
+	int	    	line;
+	int	    	col;
+	int		start_line;
+	int		start_col;
+	int		last_line;
+	int	    	eof;
+
+	char	    	*buffer;
+	size_t	    	size;
+	size_t	    	len;
+	int	    	c;
+	int		un5;
+	int		n_un;
+
+	struct isl_token	*tokens5;
+	int	    	n_token;
+
+	struct isl_hash_table	*keywords;
+	enum isl_token_type	 next_type;
+
+	int			yaml_depth;
+	int			yaml_size;
+	enum isl_yaml_state	*yaml_state;
+	int			*yaml_indent;
+};

_service:tar_scm:isl-0.24.tar.gz/isl_stride.c Added

@@ -0,0 +1,393 @@
+/*
+ * Copyright 2012-2013 Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/val.h>
+#include <isl_map_private.h>
+#include <isl_aff_private.h>
+#include <isl/constraint.h>
+#include <isl/set.h>
+
+/* Stride information about a specific set dimension.
+ * The values of the set dimension are equal to
+ * "offset" plus a multiple of "stride".
+ */
+struct isl_stride_info {
+	isl_val *stride;
+	isl_aff *offset;
+};
+
+/* Return the ctx to which "si" belongs.
+ */
+isl_ctx *isl_stride_info_get_ctx(__isl_keep isl_stride_info *si)
+{
+	if (!si)
+		return NULL;
+
+	return isl_val_get_ctx(si->stride);
+}
+
+/* Free "si" and return NULL.
+ */
+__isl_null isl_stride_info *isl_stride_info_free(
+	__isl_take isl_stride_info *si)
+{
+	if (!si)
+		return NULL;
+	isl_val_free(si->stride);
+	isl_aff_free(si->offset);
+	free(si);
+	return NULL;
+}
+
+/* Construct an isl_stride_info object with given offset and stride.
+ */
+__isl_give isl_stride_info *isl_stride_info_alloc(
+	__isl_take isl_val *stride, __isl_take isl_aff *offset)
+{
+	struct isl_stride_info *si;
+
+	if (!stride || !offset)
+		goto error;
+	si = isl_alloc_type(isl_val_get_ctx(stride), struct isl_stride_info);
+	if (!si)
+		goto error;
+	si->stride = stride;
+	si->offset = offset;
+	return si;
+error:
+	isl_val_free(stride);
+	isl_aff_free(offset);
+	return NULL;
+}
+
+/* Make a copy of "si" and return it.
+ */
+__isl_give isl_stride_info *isl_stride_info_copy(
+	__isl_keep isl_stride_info *si)
+{
+	if (!si)
+		return NULL;
+
+	return isl_stride_info_alloc(isl_val_copy(si->stride),
+		isl_aff_copy(si->offset));
+}
+
+/* Return the stride of "si".
+ */
+__isl_give isl_val *isl_stride_info_get_stride(__isl_keep isl_stride_info *si)
+{
+	if (!si)
+		return NULL;
+	return isl_val_copy(si->stride);
+}
+
+/* Return the offset of "si".
+ */
+__isl_give isl_aff *isl_stride_info_get_offset(__isl_keep isl_stride_info *si)
+{
+	if (!si)
+		return NULL;
+	return isl_aff_copy(si->offset);
+}
+
+/* Information used inside detect_stride.
+ *
+ * "pos" is the set dimension at which the stride is being determined.
+ * "want_offset" is set if the offset should be computed.
+ * "found" is set if some stride was found already.
+ * "stride" and "offset" contain the (combined) stride and offset
+ * found so far and are NULL when "found" is not set.
+ * If "want_offset" is not set, then "offset" remains NULL.
+ */
+struct isl_detect_stride_data {
+	int pos;
+	int want_offset;
+	int found;
+	isl_val *stride;
+	isl_aff *offset;
+};
+
+/* Set the stride and offset of data->pos to the given
+ * value and expression.
+ *
+ * If we had already found a stride before, then the two strides
+ * are combined into a single stride.
+ *
+ * In particular, if the new stride information is of the form
+ *
+ *	i = f + s (...)
+ *
+ * and the old stride information is of the form
+ *
+ *	i = f2 + s2 (...)
+ *
+ * then we compute the extended gcd of s and s2
+ *
+ *	a s + b s2 = g,
+ *
+ * with g = gcd(s,s2), multiply the first equation with t1 = b s2/g
+ * and the second with t2 = a s1/g.
+ * This results in
+ *
+ *	i = (b s2 + a s1)/g i = t1 f + t2 f2 + (s s2)/g (...)
+ *
+ * so that t1 f + t2 f2 is the combined offset and (s s2)/g = lcm(s,s2)
+ * is the combined stride.
+ */
+static isl_stat set_stride(struct isl_detect_stride_data *data,
+	__isl_take isl_val *stride, __isl_take isl_aff *offset)
+{
+	int pos;
+
+	if (!stride || !offset)
+		goto error;
+
+	pos = data->pos;
+
+	if (data->found) {
+		isl_val *stride2, *a, *b, *g;
+		isl_aff *offset2;
+
+		stride2 = data->stride;
+		g = isl_val_gcdext(isl_val_copy(stride), isl_val_copy(stride2),
+					&a, &b);
+		a = isl_val_mul(a, isl_val_copy(stride));
+		a = isl_val_div(a, isl_val_copy(g));
+		stride2 = isl_val_div(stride2, g);
+		b = isl_val_mul(b, isl_val_copy(stride2));
+		stride = isl_val_mul(stride, stride2);
+
+		if (!data->want_offset) {
+			isl_val_free(a);
+			isl_val_free(b);
+		} else {
+			offset2 = data->offset;
+			offset2 = isl_aff_scale_val(offset2, a);
+			offset = isl_aff_scale_val(offset, b);
+			offset = isl_aff_add(offset, offset2);
+		}
+	}
+
+	data->found = 1;
+	data->stride = stride;
+	if (data->want_offset)
+		data->offset = offset;
+	else
+		isl_aff_free(offset);
+	if (!data->stride || (data->want_offset && !data->offset))
+		return isl_stat_error;
+
+	return isl_stat_ok;
+error:
+	isl_val_free(stride);
+	isl_aff_free(offset);
+	return isl_stat_error;
+}
+
+/* Check if constraint "c" imposes any stride on dimension data->pos
+ * and, if so, update the stride information in "data".
+ *
+ * In order to impose a stride on the dimension, "c" needs to be an equality
+ * and it needs to involve the dimension.  Note that "c" may also be
+ * a div constraint and thus an inequality that we cannot use.
+ *
+ * Let c be of the form
+ *
+ *	h(p) + g * v * i + g * stride * f(alpha) = 0
+ *
+ * with h(p) an expression in terms of the parameters and other dimensions
+ * and f(alpha) an expression in terms of the existentially quantified
+ * variables.
+ *
+ * If "stride" is not zero and not one, then it represents a non-trivial stride
+ * on "i".  We compute a and b such that
+ *
+ *	a v + b stride = 1
+ *
+ * We have
+ *
+ *	g v i = -h(p) + g stride f(alpha)
+ *
+ *	a g v i = -a h(p) + g stride f(alpha)
+ *
+ *	a g v i + b g stride i = -a h(p) + g stride * (...)
+ *
+ *	g i = -a h(p) + g stride * (...)
+ *
+ *	i = -a h(p)/g + stride * (...)
+ *
+ * The expression "-a h(p)/g" can therefore be used as offset.
+ */
+static isl_stat detect_stride(__isl_take isl_constraint *c, void *user)
+{
+	struct isl_detect_stride_data *data = user;
+	int i;
+	isl_size n_div;
+	isl_ctx *ctx;
+	isl_stat r = isl_stat_ok;
+	isl_val *v, *stride, *m;
+	isl_bool is_eq, relevant, has_stride;
+
+	is_eq = isl_constraint_is_equality(c);
+	relevant = isl_constraint_involves_dims(c, isl_dim_set, data->pos, 1);
+	if (is_eq < 0 || relevant < 0)
+		goto error;
+	if (!is_eq || !relevant) {
+		isl_constraint_free(c);
+		return isl_stat_ok;
+	}
+
+	n_div = isl_constraint_dim(c, isl_dim_div);
+	if (n_div < 0)
+		goto error;
+	ctx = isl_constraint_get_ctx(c);
+	stride = isl_val_zero(ctx);
+	for (i = 0; i < n_div; ++i) {
+		v = isl_constraint_get_coefficient_val(c, isl_dim_div, i);
+		stride = isl_val_gcd(stride, v);
+	}
+
+	v = isl_constraint_get_coefficient_val(c, isl_dim_set, data->pos);
+	m = isl_val_gcd(isl_val_copy(stride), isl_val_copy(v));
+	stride = isl_val_div(stride, isl_val_copy(m));
+	v = isl_val_div(v, isl_val_copy(m));
+
+	has_stride = isl_val_gt_si(stride, 1);
+	if (has_stride >= 0 && has_stride) {
+		isl_aff *aff;
+		isl_val *gcd, *a, *b;
+
+		gcd = isl_val_gcdext(v, isl_val_copy(stride), &a, &b);
+		isl_val_free(gcd);
+		isl_val_free(b);
+
+		aff = isl_constraint_get_aff(c);
+		for (i = 0; i < n_div; ++i)
+			aff = isl_aff_set_coefficient_si(aff,
+							 isl_dim_div, i, 0);
+		aff = isl_aff_set_coefficient_si(aff, isl_dim_in, data->pos, 0);
+		aff = isl_aff_remove_unused_divs(aff);
+		a = isl_val_neg(a);
+		aff = isl_aff_scale_val(aff, a);
+		aff = isl_aff_scale_down_val(aff, m);
+		r = set_stride(data, stride, aff);
+	} else {
+		isl_val_free(stride);
+		isl_val_free(m);
+		isl_val_free(v);
+	}
+
+	isl_constraint_free(c);
+	if (has_stride < 0)
+		return isl_stat_error;
+	return r;
+error:
+	isl_constraint_free(c);
+	return isl_stat_error;
+}
+
+/* Check if the constraints in "set" imply any stride on set dimension "pos" and
+ * store the results in data->stride and data->offset.
+ *
+ * In particular, compute the affine hull and then check if
+ * any of the constraints in the hull impose any stride on the dimension.
+ * If no such constraint can be found, then the offset is taken
+ * to be the zero expression and the stride is taken to be one.
+ */
+static void set_detect_stride(__isl_keep isl_set *set, int pos,
+	struct isl_detect_stride_data *data)
+{
+	isl_basic_set *hull;
+
+	hull = isl_set_affine_hull(isl_set_copy(set));
+
+	data->pos = pos;
+	data->found = 0;
+	data->stride = NULL;
+	data->offset = NULL;
+	if (isl_basic_set_foreach_constraint(hull, &detect_stride, data) < 0)
+		goto error;
+
+	if (!data->found) {
+		data->stride = isl_val_one(isl_set_get_ctx(set));
+		if (data->want_offset) {
+			isl_space *space;
+			isl_local_space *ls;
+
+			space = isl_set_get_space(set);
+			ls = isl_local_space_from_space(space);
+			data->offset = isl_aff_zero_on_domain(ls);
+		}
+	}
+	isl_basic_set_free(hull);
+	return;
+error:
+	isl_basic_set_free(hull);
+	data->stride = isl_val_free(data->stride);
+	data->offset = isl_aff_free(data->offset);
+}
+
+/* Check if the constraints in "set" imply any stride on set dimension "pos" and
+ * return the results in the form of an offset and a stride.
+ */
+__isl_give isl_stride_info *isl_set_get_stride_info(__isl_keep isl_set *set,
+	int pos)
+{
+	struct isl_detect_stride_data data;
+
+	data.want_offset = 1;
+	set_detect_stride(set, pos, &data);
+
+	return isl_stride_info_alloc(data.stride, data.offset);
+}
+
+/* Check if the constraints in "set" imply any stride on set dimension "pos" and
+ * return this stride.
+ */
+__isl_give isl_val *isl_set_get_stride(__isl_keep isl_set *set, int pos)
+{
+	struct isl_detect_stride_data data;
+
+	data.want_offset = 0;
+	set_detect_stride(set, pos, &data);
+
+	return data.stride;
+}
+
+/* Check if the constraints in "map" imply any stride on output dimension "pos",
+ * independently of any other output dimensions, and
+ * return the results in the form of an offset and a stride.
+ *
+ * Convert the input to a set with only the input dimensions and
+ * the single output dimension such that it be passed to
+ * isl_set_get_stride_info and convert the result back to
+ * an expression defined over the domain of "map".
+ */
+__isl_give isl_stride_info *isl_map_get_range_stride_info(
+	__isl_keep isl_map *map, int pos)
+{
+	isl_stride_info *si;
+	isl_set *set;
+	isl_size n_in;
+
+	n_in = isl_map_dim(map, isl_dim_in);
+	if (n_in < 0)
+		return NULL;
+	map = isl_map_copy(map);
+	map = isl_map_project_onto(map, isl_dim_out, pos, 1);
+	set = isl_map_wrap(map);
+	si = isl_set_get_stride_info(set, n_in);
+	isl_set_free(set);
+	if (!si)
+		return NULL;
+	si->offset = isl_aff_domain_factor_domain(si->offset);
+	if (!si->offset)
+		return isl_stride_info_free(si);
+	return si;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_tab.c -> _service:tar_scm:isl-0.24.tar.gz/isl_tab.c Changed

@@ -1,12 +1,16 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2013      Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016      Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege, K.U.Leuven, Departement
  * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
  * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
  */
 
 #include <isl_ctx_private.h>
@@ -17,6 +21,9 @@
 #include <isl_seq.h>
 #include <isl_config.h>
 
+#include <bset_to_bmap.c>
+#include <bset_from_bmap.c>
+
 /*
  * The implementation of tableaus in this file was inspired by Section 8
  * of David Detlefs, Greg Nelson and James B. Saxe, "Simplify: a theorem
@@ -152,7 +159,7 @@
 		if (!var)
 			return -1;
 		tab->var = var;
-		tab->max_var += n_new;
+		tab->max_var = tab->n_var + n_new;
 	}
 
 	if (tab->mat->n_col < off + tab->n_col + n_new) {
@@ -285,7 +292,7 @@
 	dup->need_undo = 0;
 	dup->in_undo = 0;
 	dup->M = tab->M;
-	tab->cone = tab->cone;
+	dup->cone = tab->cone;
 	dup->bottom.type = isl_tab_undo_bottom;
 	dup->bottom.next = NULL;
 	dup->top = &dup->bottom;
@@ -313,8 +320,8 @@
  * The order of the rows and columns in the result is as explained
  * in isl_tab_product.
  */
-static struct isl_mat *tab_mat_product(struct isl_mat *mat1,
-	struct isl_mat *mat2, unsigned row1, unsigned row2,
+static __isl_give isl_mat *tab_mat_product(__isl_keep isl_mat *mat1,
+	__isl_keep isl_mat *mat2, unsigned row1, unsigned row2,
 	unsigned col1, unsigned col2,
 	unsigned off, unsigned r1, unsigned r2, unsigned d1, unsigned d2)
 {
@@ -613,21 +620,21 @@
 	return 1;
 }
 
-static int row_cmp(struct isl_tab *tab, int r1, int r2, int c, isl_int t)
+static int row_cmp(struct isl_tab *tab, int r1, int r2, int c, isl_int *t)
 {
 	unsigned off = 2 + tab->M;
 
 	if (tab->M) {
 		int s;
-		isl_int_mul(t, tab->mat->rowr12, tab->mat->rowr2off+c);
-		isl_int_submul(t, tab->mat->rowr22, tab->mat->rowr1off+c);
-		s = isl_int_sgn(t);
+		isl_int_mul(*t, tab->mat->rowr12, tab->mat->rowr2off+c);
+		isl_int_submul(*t, tab->mat->rowr22, tab->mat->rowr1off+c);
+		s = isl_int_sgn(*t);
 		if (s)
 			return s;
 	}
-	isl_int_mul(t, tab->mat->rowr11, tab->mat->rowr2off + c);
-	isl_int_submul(t, tab->mat->rowr21, tab->mat->rowr1off + c);
-	return isl_int_sgn(t);
+	isl_int_mul(*t, tab->mat->rowr11, tab->mat->rowr2off + c);
+	isl_int_submul(*t, tab->mat->rowr21, tab->mat->rowr1off + c);
+	return isl_int_sgn(*t);
 }
 
 /* Given the index of a column "c", return the index of a row
@@ -670,7 +677,7 @@
 			r = j;
 			continue;
 		}
-		tsgn = sgn * row_cmp(tab, r, j, c, t);
+		tsgn = sgn * row_cmp(tab, r, j, c, &t);
 		if (tsgn < 0 || (tsgn == 0 &&
 					    tab->row_varj < tab->row_varr))
 			r = j;
@@ -779,30 +786,42 @@
 	tab->row_signrow2 = s;
 }
 
-static int push_union(struct isl_tab *tab,
+static isl_stat push_union(struct isl_tab *tab,
 	enum isl_tab_undo_type type, union isl_tab_undo_val u) WARN_UNUSED;
-static int push_union(struct isl_tab *tab,
+
+/* Push record "u" onto the undo stack of "tab", provided "tab"
+ * keeps track of undo information.
+ *
+ * If the record cannot be pushed, then mark the undo stack as invalid
+ * such that a later rollback attempt will not try to undo earlier
+ * records without having been able to undo the current record.
+ */
+static isl_stat push_union(struct isl_tab *tab,
 	enum isl_tab_undo_type type, union isl_tab_undo_val u)
 {
 	struct isl_tab_undo *undo;
 
 	if (!tab)
-		return -1;
+		return isl_stat_error;
 	if (!tab->need_undo)
-		return 0;
+		return isl_stat_ok;
 
 	undo = isl_alloc_type(tab->mat->ctx, struct isl_tab_undo);
 	if (!undo)
-		return -1;
+		goto error;
 	undo->type = type;
 	undo->u = u;
 	undo->next = tab->top;
 	tab->top = undo;
 
-	return 0;
+	return isl_stat_ok;
+error:
+	free_undo(tab);
+	tab->top = NULL;
+	return isl_stat_error;
 }
 
-int isl_tab_push_var(struct isl_tab *tab,
+isl_stat isl_tab_push_var(struct isl_tab *tab,
 	enum isl_tab_undo_type type, struct isl_tab_var *var)
 {
 	union isl_tab_undo_val u;
@@ -813,7 +832,7 @@
 	return push_union(tab, type, u);
 }
 
-int isl_tab_push(struct isl_tab *tab, enum isl_tab_undo_type type)
+isl_stat isl_tab_push(struct isl_tab *tab, enum isl_tab_undo_type type)
 {
 	union isl_tab_undo_val u = { 0 };
 	return push_union(tab, type, u);
@@ -822,20 +841,21 @@
 /* Push a record on the undo stack describing the current basic
  * variables, so that the this state can be restored during rollback.
  */
-int isl_tab_push_basis(struct isl_tab *tab)
+isl_stat isl_tab_push_basis(struct isl_tab *tab)
 {
 	int i;
 	union isl_tab_undo_val u;
 
 	u.col_var = isl_alloc_array(tab->mat->ctx, int, tab->n_col);
 	if (tab->n_col && !u.col_var)
-		return -1;
+		return isl_stat_error;
 	for (i = 0; i < tab->n_col; ++i)
 		u.col_vari = tab->col_vari;
 	return push_union(tab, isl_tab_undo_saved_basis, u);
 }
 
-int isl_tab_push_callback(struct isl_tab *tab, struct isl_tab_callback *callback)
+isl_stat isl_tab_push_callback(struct isl_tab *tab,
+	struct isl_tab_callback *callback)
 {
 	union isl_tab_undo_val u;
 	u.callback = callback;
@@ -910,12 +930,12 @@
 /* Record the current number of samples so that we can remove newer
  * samples during a rollback.
  */
-int isl_tab_save_samples(struct isl_tab *tab)
+isl_stat isl_tab_save_samples(struct isl_tab *tab)
 {
 	union isl_tab_undo_val u;
 
 	if (!tab)
-		return -1;
+		return isl_stat_error;
 
 	u.n = tab->n_sample;
 	return push_union(tab, isl_tab_undo_saved_samples, u);
@@ -957,15 +977,31 @@
 	}
 }
 
-int isl_tab_mark_empty(struct isl_tab *tab)
+/* Mark "tab" as a rational tableau.
+ * If it wasn't marked as a rational tableau already and if we may
+ * need to undo changes, then arrange for the marking to be undone
+ * during the undo.
+ */
+int isl_tab_mark_rational(struct isl_tab *tab)
 {
 	if (!tab)
 		return -1;
+	if (!tab->rational && tab->need_undo)
+		if (isl_tab_push(tab, isl_tab_undo_rational) < 0)
+			return -1;
+	tab->rational = 1;
+	return 0;
+}
+
+isl_stat isl_tab_mark_empty(struct isl_tab *tab)
+{
+	if (!tab)
+		return isl_stat_error;
 	if (!tab->empty && tab->need_undo)
 		if (isl_tab_push(tab, isl_tab_undo_empty) < 0)
-			return -1;
+			return isl_stat_error;
 	tab->empty = 1;
-	return 0;
+	return isl_stat_ok;
 }
 
 int isl_tab_freeze_constraint(struct isl_tab *tab, int con)
@@ -1409,7 +1445,8 @@
 /* Return 1 if "var" can attain values <= -1.
  * Return 0 otherwise.
  *
- * The sample value of "var" is assumed to be non-negative when the
+ * If the variable "var" is supposed to be non-negative (is_nonneg is set),
+ * then the sample value of "var" is assumed to be non-negative when the
  * the function is called.  If 1 is returned then the constraint
  * is not redundant and the sample value is made non-negative again before
  * the function returns.
@@ -1447,7 +1484,7 @@
 	do {
 		find_pivot(tab, var, var, -1, &row, &col);
 		if (row == var->index) {
-			if (restore_row(tab, var) < -1)
+			if (var->is_nonneg && restore_row(tab, var) < -1)
 				return -1;
 			return 1;
 		}
@@ -1583,40 +1620,59 @@
  * Each of the non-negative variables with a negative coefficient can
  * then also be written as the negative sum of non-negative variables
  * and must therefore also be zero.
- */
-static int close_row(struct isl_tab *tab, struct isl_tab_var *var) WARN_UNUSED;
-static int close_row(struct isl_tab *tab, struct isl_tab_var *var)
+ *
+ * If "temp_var" is set, then "var" is a temporary variable that
+ * will be removed after this function returns and for which
+ * no information is recorded on the undo stack.
+ * Do not add any undo records involving this variable in this case
+ * since the variable will have been removed before any future undo
+ * operations.  Also avoid marking the variable as redundant,
+ * since that either adds an undo record or needlessly removes the row
+ * (the caller will take care of removing the row).
+ */
+static isl_stat close_row(struct isl_tab *tab, struct isl_tab_var *var,
+	int temp_var) WARN_UNUSED;
+static isl_stat close_row(struct isl_tab *tab, struct isl_tab_var *var,
+	int temp_var)
 {
 	int j;
 	struct isl_mat *mat = tab->mat;
 	unsigned off = 2 + tab->M;
 
-	isl_assert(tab->mat->ctx, var->is_nonneg, return -1);
+	if (!var->is_nonneg)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"expecting non-negative variable",
+			return isl_stat_error);
 	var->is_zero = 1;
-	if (tab->need_undo)
+	if (!temp_var && tab->need_undo)
 		if (isl_tab_push_var(tab, isl_tab_undo_zero, var) < 0)
-			return -1;
+			return isl_stat_error;
 	for (j = tab->n_dead; j < tab->n_col; ++j) {
 		int recheck;
 		if (isl_int_is_zero(mat->rowvar->indexoff + j))
 			continue;
-		isl_assert(tab->mat->ctx,
-		    isl_int_is_neg(mat->rowvar->indexoff + j), return -1);
+		if (isl_int_is_pos(mat->rowvar->indexoff + j))
+			isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+				"row cannot have positive coefficients",
+				return isl_stat_error);
 		recheck = isl_tab_kill_col(tab, j);
 		if (recheck < 0)
-			return -1;
+			return isl_stat_error;
 		if (recheck)
 			--j;
 	}
-	if (isl_tab_mark_redundant(tab, var->index) < 0)
-		return -1;
+	if (!temp_var && isl_tab_mark_redundant(tab, var->index) < 0)
+		return isl_stat_error;
 	if (tab_is_manifestly_empty(tab) && isl_tab_mark_empty(tab) < 0)
-		return -1;
-	return 0;
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* Add a constraint to the tableau and allocate a row for it.
  * Return the index into the constraint array "con".
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 int isl_tab_allocate_con(struct isl_tab *tab)
 {
@@ -1643,19 +1699,75 @@
 	return r;
 }
 
-/* Add a variable to the tableau and allocate a column for it.
- * Return the index into the variable array "var".
+/* Move the entries in tab->var up one position, starting at "first",
+ * creating room for an extra entry at position "first".
+ * Since some of the entries of tab->row_var and tab->col_var contain
+ * indices into this array, they have to be updated accordingly.
  */
-int isl_tab_allocate_var(struct isl_tab *tab)
+static int var_insert_entry(struct isl_tab *tab, int first)
+{
+	int i;
+
+	if (tab->n_var >= tab->max_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"not enough room for new variable", return -1);
+	if (first > tab->n_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"invalid initial position", return -1);
+
+	for (i = tab->n_var - 1; i >= first; --i) {
+		tab->vari + 1 = tab->vari;
+		if (tab->vari + 1.is_row)
+			tab->row_vartab->vari + 1.index++;
+		else
+			tab->col_vartab->vari + 1.index++;
+	}
+
+	tab->n_var++;
+
+	return 0;
+}
+
+/* Drop the entry at position "first" in tab->var, moving all
+ * subsequent entries down.
+ * Since some of the entries of tab->row_var and tab->col_var contain
+ * indices into this array, they have to be updated accordingly.
+ */
+static int var_drop_entry(struct isl_tab *tab, int first)
+{
+	int i;
+
+	if (first >= tab->n_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"invalid initial position", return -1);
+
+	tab->n_var--;
+
+	for (i = first; i < tab->n_var; ++i) {
+		tab->vari = tab->vari + 1;
+		if (tab->vari + 1.is_row)
+			tab->row_vartab->vari.index--;
+		else
+			tab->col_vartab->vari.index--;
+	}
+
+	return 0;
+}
+
+/* Add a variable to the tableau at position "r" and allocate a column for it.
+ * Return the index into the variable array "var", i.e., "r",
+ * or -1 on error.
+ */
+int isl_tab_insert_var(struct isl_tab *tab, int r)
 {
-	int r;
 	int i;
 	unsigned off = 2 + tab->M;
 
 	isl_assert(tab->mat->ctx, tab->n_col < tab->mat->n_col, return -1);
-	isl_assert(tab->mat->ctx, tab->n_var < tab->max_var, return -1);
 
-	r = tab->n_var;
+	if (var_insert_entry(tab, r) < 0)
+		return -1;
+
 	tab->varr.index = tab->n_col;
 	tab->varr.is_row = 0;
 	tab->varr.is_nonneg = 0;
@@ -1668,7 +1780,6 @@
 	for (i = 0; i < tab->n_row; ++i)
 		isl_int_set_si(tab->mat->rowioff + tab->n_col, 0);
 
-	tab->n_var++;
 	tab->n_col++;
 	if (isl_tab_push_var(tab, isl_tab_undo_allocate, &tab->varr) < 0)
 		return -1;
@@ -1680,6 +1791,9 @@
  * of the original variables and needs to be expressed in terms of the
  * column variables.
  *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
+ *
  * We add each term in turn.
  * If r = n/d_r is the current sum and we need to add k x, then
  * 	if x is a column variable, we increase the numerator of
@@ -1743,51 +1857,67 @@
 	return r;
 }
 
-static int drop_row(struct isl_tab *tab, int row)
+static isl_stat drop_row(struct isl_tab *tab, int row)
 {
-	isl_assert(tab->mat->ctx, ~tab->row_varrow == tab->n_con - 1, return -1);
+	isl_assert(tab->mat->ctx, ~tab->row_varrow == tab->n_con - 1,
+		return isl_stat_error);
 	if (row != tab->n_row - 1)
 		swap_rows(tab, row, tab->n_row - 1);
 	tab->n_row--;
 	tab->n_con--;
-	return 0;
+	return isl_stat_ok;
 }
 
-static int drop_col(struct isl_tab *tab, int col)
+/* Drop the variable in column "col" along with the column.
+ * The column is removed first because it may need to be moved
+ * into the last position and this process requires
+ * the contents of the col_var array in a state
+ * before the removal of the variable.
+ */
+static isl_stat drop_col(struct isl_tab *tab, int col)
 {
-	isl_assert(tab->mat->ctx, tab->col_varcol == tab->n_var - 1, return -1);
+	int var;
+
+	var = tab->col_varcol;
 	if (col != tab->n_col - 1)
 		swap_cols(tab, col, tab->n_col - 1);
 	tab->n_col--;
-	tab->n_var--;
-	return 0;
+	if (var_drop_entry(tab, var) < 0)
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* Add inequality "ineq" and check if it conflicts with the
  * previously added constraints or if it is obviously redundant.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
-int isl_tab_add_ineq(struct isl_tab *tab, isl_int *ineq)
+isl_stat isl_tab_add_ineq(struct isl_tab *tab, isl_int *ineq)
 {
 	int r;
 	int sgn;
 	isl_int cst;
 
 	if (!tab)
-		return -1;
+		return isl_stat_error;
 	if (tab->bmap) {
 		struct isl_basic_map *bmap = tab->bmap;
 
-		isl_assert(tab->mat->ctx, tab->n_eq == bmap->n_eq, return -1);
+		isl_assert(tab->mat->ctx, tab->n_eq == bmap->n_eq,
+			return isl_stat_error);
 		isl_assert(tab->mat->ctx,
-			    tab->n_con == bmap->n_eq + bmap->n_ineq, return -1);
+			    tab->n_con == bmap->n_eq + bmap->n_ineq,
+			    return isl_stat_error);
 		tab->bmap = isl_basic_map_add_ineq(tab->bmap, ineq);
 		if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
-			return -1;
+			return isl_stat_error;
 		if (!tab->bmap)
-			return -1;
+			return isl_stat_error;
 	}
 	if (tab->cone) {
 		isl_int_init(cst);
+		isl_int_set_si(cst, 0);
 		isl_int_swap(ineq0, cst);
 	}
 	r = isl_tab_add_row(tab, ineq);
@@ -1796,25 +1926,25 @@
 		isl_int_clear(cst);
 	}
 	if (r < 0)
-		return -1;
+		return isl_stat_error;
 	tab->conr.is_nonneg = 1;
 	if (isl_tab_push_var(tab, isl_tab_undo_nonneg, &tab->conr) < 0)
-		return -1;
+		return isl_stat_error;
 	if (isl_tab_row_is_redundant(tab, tab->conr.index)) {
 		if (isl_tab_mark_redundant(tab, tab->conr.index) < 0)
-			return -1;
-		return 0;
+			return isl_stat_error;
+		return isl_stat_ok;
 	}
 
 	sgn = restore_row(tab, &tab->conr);
 	if (sgn < -1)
-		return -1;
+		return isl_stat_error;
 	if (sgn < 0)
 		return isl_tab_mark_empty(tab);
 	if (tab->conr.is_row && isl_tab_row_is_redundant(tab, tab->conr.index))
 		if (isl_tab_mark_redundant(tab, tab->conr.index) < 0)
-			return -1;
-	return 0;
+			return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* Pivot a non-negative variable down until it reaches the value zero
@@ -1854,6 +1984,9 @@
  * The equalities can therefore never conflict.
  * Adding the equalities is currently only really useful for a later call
  * to isl_tab_ineq_type.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 static struct isl_tab *add_eq(struct isl_tab *tab, isl_int *eq)
 {
@@ -1883,19 +2016,30 @@
 	return NULL;
 }
 
+/* Does the sample value of row "row" of "tab" involve the big parameter,
+ * if any?
+ */
+static int row_is_big(struct isl_tab *tab, int row)
+{
+	return tab->M && !isl_int_is_zero(tab->mat->rowrow2);
+}
+
 static int row_is_manifestly_zero(struct isl_tab *tab, int row)
 {
 	unsigned off = 2 + tab->M;
 
 	if (!isl_int_is_zero(tab->mat->rowrow1))
 		return 0;
-	if (tab->M && !isl_int_is_zero(tab->mat->rowrow2))
+	if (row_is_big(tab, row))
 		return 0;
 	return isl_seq_first_non_zero(tab->mat->rowrow + off + tab->n_dead,
 					tab->n_col - tab->n_dead) == -1;
 }
 
 /* Add an equality that is known to be valid for the given tableau.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 int isl_tab_add_valid_eq(struct isl_tab *tab, isl_int *eq)
 {
@@ -1932,6 +2076,12 @@
 	return 0;
 }
 
+/* Add a zero row to "tab" and return the corresponding index
+ * in the constraint array.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
+ */
 static int add_zero_row(struct isl_tab *tab)
 {
 	int r;
@@ -1950,8 +2100,12 @@
 
 /* Add equality "eq" and check if it conflicts with the
  * previously added constraints or if it is obviously redundant.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
+ * If tab->bmap is set, then two rows are needed instead of one.
  */
-int isl_tab_add_eq(struct isl_tab *tab, isl_int *eq)
+isl_stat isl_tab_add_eq(struct isl_tab *tab, isl_int *eq)
 {
 	struct isl_tab_undo *snap = NULL;
 	struct isl_tab_var *var;
@@ -1961,14 +2115,15 @@
 	isl_int cst;
 
 	if (!tab)
-		return -1;
-	isl_assert(tab->mat->ctx, !tab->M, return -1);
+		return isl_stat_error;
+	isl_assert(tab->mat->ctx, !tab->M, return isl_stat_error);
 
 	if (tab->need_undo)
 		snap = isl_tab_snap(tab);
 
 	if (tab->cone) {
 		isl_int_init(cst);
+		isl_int_set_si(cst, 0);
 		isl_int_swap(eq0, cst);
 	}
 	r = isl_tab_add_row(tab, eq);
@@ -1977,32 +2132,29 @@
 		isl_int_clear(cst);
 	}
 	if (r < 0)
-		return -1;
+		return isl_stat_error;
 
 	var = &tab->conr;
 	row = var->index;
 	if (row_is_manifestly_zero(tab, row)) {
-		if (snap) {
-			if (isl_tab_rollback(tab, snap) < 0)
-				return -1;
-		} else
-			drop_row(tab, row);
-		return 0;
+		if (snap)
+			return isl_tab_rollback(tab, snap);
+		return drop_row(tab, row);
 	}
 
 	if (tab->bmap) {
 		tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
 		if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
-			return -1;
+			return isl_stat_error;
 		isl_seq_neg(eq, eq, 1 + tab->n_var);
 		tab->bmap = isl_basic_map_add_ineq(tab->bmap, eq);
 		isl_seq_neg(eq, eq, 1 + tab->n_var);
 		if (isl_tab_push(tab, isl_tab_undo_bmap_ineq) < 0)
-			return -1;
+			return isl_stat_error;
 		if (!tab->bmap)
-			return -1;
+			return isl_stat_error;
 		if (add_zero_row(tab) < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
 	sgn = isl_int_sgn(tab->mat->rowrow1);
@@ -2017,22 +2169,22 @@
 	if (sgn < 0) {
 		sgn = sign_of_max(tab, var);
 		if (sgn < -1)
-			return -1;
+			return isl_stat_error;
 		if (sgn < 0) {
 			if (isl_tab_mark_empty(tab) < 0)
-				return -1;
-			return 0;
+				return isl_stat_error;
+			return isl_stat_ok;
 		}
 	}
 
 	var->is_nonneg = 1;
 	if (to_col(tab, var) < 0)
-		return -1;
+		return isl_stat_error;
 	var->is_nonneg = 0;
 	if (isl_tab_kill_col(tab, var->index) < 0)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Construct and return an inequality that expresses an upper bound
@@ -2045,16 +2197,17 @@
  *
  *	m d <= e
  */
-static struct isl_vec *ineq_for_div(struct isl_basic_map *bmap, unsigned div)
+static __isl_give isl_vec *ineq_for_div(__isl_keep isl_basic_map *bmap,
+	unsigned div)
 {
-	unsigned total;
+	isl_size total;
 	unsigned div_pos;
 	struct isl_vec *ineq;
 
-	if (!bmap)
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return NULL;
 
-	total = isl_basic_map_total_dim(bmap);
 	div_pos = 1 + total - bmap->n_div + div;
 
 	ineq = isl_vec_alloc(bmap->ctx, 1 + total);
@@ -2077,15 +2230,20 @@
  *
  * If add_ineq is not NULL, then this function is used
  * instead of isl_tab_add_ineq to effectively add the inequalities.
+ *
+ * This function assumes that at least two more rows and at least
+ * two more elements in the constraint array are available in the tableau.
  */
-static int add_div_constraints(struct isl_tab *tab, unsigned div,
-	int (*add_ineq)(void *user, isl_int *), void *user)
+static isl_stat add_div_constraints(struct isl_tab *tab, unsigned div,
+	isl_stat (*add_ineq)(void *user, isl_int *), void *user)
 {
-	unsigned total;
+	isl_size total;
 	unsigned div_pos;
 	struct isl_vec *ineq;
 
-	total = isl_basic_map_total_dim(tab->bmap);
+	total = isl_basic_map_dim(tab->bmap, isl_dim_all);
+	if (total < 0)
+		return isl_stat_error;
 	div_pos = 1 + total - tab->bmap->n_div + div;
 
 	ineq = ineq_for_div(tab->bmap, div);
@@ -2115,10 +2273,10 @@
 
 	isl_vec_free(ineq);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_vec_free(ineq);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Check whether the div described by "div" is obviously non-negative.
@@ -2149,8 +2307,10 @@
 	return 1;
 }
 
-/* Add an extra div, prescribed by "div" to the tableau and
+/* Insert an extra div, prescribed by "div", to the tableau and
  * the associated bmap (which is assumed to be non-NULL).
+ * The extra integer division is inserted at (tableau) position "pos".
+ * Return "pos" or -1 if an error occurred.
  *
  * If add_ineq is not NULL, then this function is used instead
  * of isl_tab_add_ineq to add the div constraints.
@@ -2158,17 +2318,28 @@
  * wants to perform some extra processing when an inequality
  * is added to the tableau.
  */
-int isl_tab_add_div(struct isl_tab *tab, __isl_keep isl_vec *div,
-	int (*add_ineq)(void *user, isl_int *), void *user)
+int isl_tab_insert_div(struct isl_tab *tab, int pos, __isl_keep isl_vec *div,
+	isl_stat (*add_ineq)(void *user, isl_int *), void *user)
 {
 	int r;
-	int k;
 	int nonneg;
+	isl_size n_div;
+	int o_div;
 
 	if (!tab || !div)
 		return -1;
 
-	isl_assert(tab->mat->ctx, tab->bmap, return -1);
+	if (div->size != 1 + 1 + tab->n_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"unexpected size", return -1);
+
+	n_div = isl_basic_map_dim(tab->bmap, isl_dim_div);
+	if (n_div < 0)
+		return -1;
+	o_div = tab->n_var - n_div;
+	if (pos < o_div || pos > tab->n_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"invalid position", return -1);
 
 	nonneg = div_is_nonneg(tab, div);
 
@@ -2176,28 +2347,35 @@
 		return -1;
 	if (isl_tab_extend_vars(tab, 1) < 0)
 		return -1;
-	r = isl_tab_allocate_var(tab);
+	r = isl_tab_insert_var(tab, pos);
 	if (r < 0)
 		return -1;
 
 	if (nonneg)
 		tab->varr.is_nonneg = 1;
 
-	tab->bmap = isl_basic_map_extend_space(tab->bmap,
-		isl_basic_map_get_space(tab->bmap), 1, 0, 2);
-	k = isl_basic_map_alloc_div(tab->bmap);
-	if (k < 0)
+	tab->bmap = isl_basic_map_insert_div(tab->bmap, pos - o_div, div);
+	if (!tab->bmap)
 		return -1;
-	isl_seq_cpy(tab->bmap->divk, div->el, div->size);
-	if (isl_tab_push(tab, isl_tab_undo_bmap_div) < 0)
+	if (isl_tab_push_var(tab, isl_tab_undo_bmap_div, &tab->varr) < 0)
 		return -1;
 
-	if (add_div_constraints(tab, k, add_ineq, user) < 0)
+	if (add_div_constraints(tab, pos - o_div, add_ineq, user) < 0)
 		return -1;
 
 	return r;
 }
 
+/* Add an extra div, prescribed by "div", to the tableau and
+ * the associated bmap (which is assumed to be non-NULL).
+ */
+int isl_tab_add_div(struct isl_tab *tab, __isl_keep isl_vec *div)
+{
+	if (!tab)
+		return -1;
+	return isl_tab_insert_div(tab, tab->n_var, div, NULL, NULL);
+}
+
 /* If "track" is set, then we want to keep track of all constraints in tab
  * in its bmap field.  This field is initialized from a copy of "bmap",
  * so we need to make sure that all constraints in "bmap" also appear
@@ -2208,12 +2386,12 @@
 {
 	int i;
 	struct isl_tab *tab;
+	isl_size total;
 
-	if (!bmap)
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
 		return NULL;
-	tab = isl_tab_alloc(bmap->ctx,
-			    isl_basic_map_total_dim(bmap) + bmap->n_ineq + 1,
-			    isl_basic_map_total_dim(bmap), 0);
+	tab = isl_tab_alloc(bmap->ctx, total + bmap->n_ineq + 1, total, 0);
 	if (!tab)
 		return NULL;
 	tab->preserve = track;
@@ -2257,20 +2435,23 @@
 	isl_int cst;
 	int i;
 	struct isl_tab *tab;
-	unsigned offset = 0;
+	isl_size offset = 0;
+	isl_size total;
 
-	if (!bset)
-		return NULL;
+	total = isl_basic_set_dim(bset, isl_dim_all);
 	if (parametric)
 		offset = isl_basic_set_dim(bset, isl_dim_param);
+	if (total < 0 || offset < 0)
+		return NULL;
 	tab = isl_tab_alloc(bset->ctx, bset->n_eq + bset->n_ineq,
-				isl_basic_set_total_dim(bset) - offset, 0);
+				total - offset, 0);
 	if (!tab)
 		return NULL;
 	tab->rational = ISL_F_ISSET(bset, ISL_BASIC_SET_RATIONAL);
 	tab->cone = 1;
 
 	isl_int_init(cst);
+	isl_int_set_si(cst, 0);
 	for (i = 0; i < bset->n_eq; ++i) {
 		isl_int_swap(bset->eqioffset, cst);
 		if (offset > 0) {
@@ -2305,16 +2486,16 @@
 /* Assuming "tab" is the tableau of a cone, check if the cone is
  * bounded, i.e., if it is empty or only contains the origin.
  */
-int isl_tab_cone_is_bounded(struct isl_tab *tab)
+isl_bool isl_tab_cone_is_bounded(struct isl_tab *tab)
 {
 	int i;
 
 	if (!tab)
-		return -1;
+		return isl_bool_error;
 	if (tab->empty)
-		return 1;
+		return isl_bool_true;
 	if (tab->n_dead == tab->n_col)
-		return 1;
+		return isl_bool_true;
 
 	for (;;) {
 		for (i = tab->n_redundant; i < tab->n_row; ++i) {
@@ -2325,17 +2506,17 @@
 				continue;
 			sgn = sign_of_max(tab, var);
 			if (sgn < -1)
-				return -1;
+				return isl_bool_error;
 			if (sgn != 0)
-				return 0;
-			if (close_row(tab, var) < 0)
-				return -1;
+				return isl_bool_false;
+			if (close_row(tab, var, 0) < 0)
+				return isl_bool_error;
 			break;
 		}
 		if (tab->n_dead == tab->n_col)
-			return 1;
+			return isl_bool_true;
 		if (i == tab->n_row)
-			return 0;
+			return isl_bool_false;
 	}
 }
 
@@ -2381,7 +2562,7 @@
 	return vec;
 }
 
-struct isl_vec *isl_tab_get_sample_value(struct isl_tab *tab)
+__isl_give isl_vec *isl_tab_get_sample_value(struct isl_tab *tab)
 {
 	int i;
 	struct isl_vec *vec;
@@ -2416,6 +2597,22 @@
 	return vec;
 }
 
+/* Store the sample value of "var" of "tab" rounded up (if sgn > 0)
+ * or down (if sgn < 0) to the nearest integer in *v.
+ */
+static void get_rounded_sample_value(struct isl_tab *tab,
+	struct isl_tab_var *var, int sgn, isl_int *v)
+{
+	if (!var->is_row)
+		isl_int_set_si(*v, 0);
+	else if (sgn > 0)
+		isl_int_cdiv_q(*v, tab->mat->rowvar->index1,
+				   tab->mat->rowvar->index0);
+	else
+		isl_int_fdiv_q(*v, tab->mat->rowvar->index1,
+				   tab->mat->rowvar->index0);
+}
+
 /* Update "bmap" based on the results of the tableau "tab".
  * In particular, implicit equalities are made explicit, redundant constraints
  * are removed and if the sample value happens to be integer, it is stored
@@ -2424,8 +2621,8 @@
  * The tableau is assumed to have been created from "bmap" using
  * isl_tab_from_basic_map.
  */
-struct isl_basic_map *isl_basic_map_update_from_tab(struct isl_basic_map *bmap,
-	struct isl_tab *tab)
+__isl_give isl_basic_map *isl_basic_map_update_from_tab(
+	__isl_take isl_basic_map *bmap, struct isl_tab *tab)
 {
 	int i;
 	unsigned n_eq;
@@ -2446,30 +2643,49 @@
 				isl_basic_map_drop_inequality(bmap, i);
 		}
 	if (bmap->n_eq != n_eq)
-		isl_basic_map_gauss(bmap, NULL);
+		bmap = isl_basic_map_gauss(bmap, NULL);
 	if (!tab->rational &&
-	    !bmap->sample && isl_tab_sample_is_integer(tab))
+	    bmap && !bmap->sample && isl_tab_sample_is_integer(tab))
 		bmap->sample = extract_integer_sample(tab);
 	return bmap;
 }
 
-struct isl_basic_set *isl_basic_set_update_from_tab(struct isl_basic_set *bset,
-	struct isl_tab *tab)
+__isl_give isl_basic_set *isl_basic_set_update_from_tab(
+	__isl_take isl_basic_set *bset, struct isl_tab *tab)
 {
-	return (struct isl_basic_set *)isl_basic_map_update_from_tab(
-		(struct isl_basic_map *)bset, tab);
+	return bset_from_bmap(isl_basic_map_update_from_tab(bset_to_bmap(bset),
+								tab));
 }
 
-/* Given a non-negative variable "var", add a new non-negative variable
- * that is the opposite of "var", ensuring that var can only attain the
- * value zero.
+/* Drop the last constraint added to "tab" in position "r".
+ * The constraint is expected to have remained in a row.
+ */
+static isl_stat drop_last_con_in_row(struct isl_tab *tab, int r)
+{
+	if (!tab->conr.is_row)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"row unexpectedly moved to column",
+			return isl_stat_error);
+	if (r + 1 != tab->n_con)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"additional constraints added", return isl_stat_error);
+	if (drop_row(tab, tab->conr.index) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Given a non-negative variable "var", temporarily add a new non-negative
+ * variable that is the opposite of "var", ensuring that "var" can only attain
+ * the value zero.  The new variable is removed again before this function
+ * returns.  However, the effect of forcing "var" to be zero remains.
  * If var = n/d is a row variable, then the new variable = -n/d.
  * If var is a column variables, then the new variable = -var.
  * If the new variable cannot attain non-negative values, then
  * the resulting tableau is empty.
  * Otherwise, we know the value will be zero and we close the row.
  */
-static int cut_to_hyperplane(struct isl_tab *tab, struct isl_tab_var *var)
+static isl_stat cut_to_hyperplane(struct isl_tab *tab, struct isl_tab_var *var)
 {
 	unsigned r;
 	isl_int *row;
@@ -2477,12 +2693,14 @@
 	unsigned off = 2 + tab->M;
 
 	if (var->is_zero)
-		return 0;
-	isl_assert(tab->mat->ctx, !var->is_redundant, return -1);
-	isl_assert(tab->mat->ctx, var->is_nonneg, return -1);
+		return isl_stat_ok;
+	if (var->is_redundant || !var->is_nonneg)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"expecting non-redundant non-negative variable",
+			return isl_stat_error);
 
 	if (isl_tab_extend_cons(tab, 1) < 0)
-		return -1;
+		return isl_stat_error;
 
 	r = tab->n_con;
 	tab->conr.index = tab->n_row;
@@ -2507,25 +2725,37 @@
 
 	tab->n_row++;
 	tab->n_con++;
-	if (isl_tab_push_var(tab, isl_tab_undo_allocate, &tab->conr) < 0)
-		return -1;
 
 	sgn = sign_of_max(tab, &tab->conr);
 	if (sgn < -1)
-		return -1;
+		return isl_stat_error;
 	if (sgn < 0) {
+		if (drop_last_con_in_row(tab, r) < 0)
+			return isl_stat_error;
 		if (isl_tab_mark_empty(tab) < 0)
-			return -1;
-		return 0;
+			return isl_stat_error;
+		return isl_stat_ok;
 	}
 	tab->conr.is_nonneg = 1;
-	if (isl_tab_push_var(tab, isl_tab_undo_nonneg, &tab->conr) < 0)
-		return -1;
 	/* sgn == 0 */
-	if (close_row(tab, &tab->conr) < 0)
-		return -1;
+	if (close_row(tab, &tab->conr, 1) < 0)
+		return isl_stat_error;
+	if (drop_last_con_in_row(tab, r) < 0)
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* Check that "con" is a valid constraint position for "tab".
+ */
+static isl_stat isl_tab_check_con(struct isl_tab *tab, int con)
+{
+	if (!tab)
+		return isl_stat_error;
+	if (con < 0 || con >= tab->n_con)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"position out of bounds", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 /* Given a tableau "tab" and an inequality constraint "con" of the tableau,
@@ -2545,37 +2775,37 @@
  * even after the relaxation, so we need to restore it.
  * We therefore prefer to pivot a column up to a row, if possible.
  */
-struct isl_tab *isl_tab_relax(struct isl_tab *tab, int con)
+int isl_tab_relax(struct isl_tab *tab, int con)
 {
 	struct isl_tab_var *var;
-	unsigned off = 2 + tab->M;
 
 	if (!tab)
-		return NULL;
+		return -1;
 
 	var = &tab->concon;
 
 	if (var->is_row && (var->index < 0 || var->index < tab->n_redundant))
 		isl_die(tab->mat->ctx, isl_error_invalid,
-			"cannot relax redundant constraint", goto error);
+			"cannot relax redundant constraint", return -1);
 	if (!var->is_row && (var->index < 0 || var->index < tab->n_dead))
 		isl_die(tab->mat->ctx, isl_error_invalid,
-			"cannot relax dead constraint", goto error);
+			"cannot relax dead constraint", return -1);
 
 	if (!var->is_row && !max_is_manifestly_unbounded(tab, var))
 		if (to_row(tab, var, 1) < 0)
-			goto error;
+			return -1;
 	if (!var->is_row && !min_is_manifestly_unbounded(tab, var))
 		if (to_row(tab, var, -1) < 0)
-			goto error;
+			return -1;
 
 	if (var->is_row) {
 		isl_int_add(tab->mat->rowvar->index1,
 		    tab->mat->rowvar->index1, tab->mat->rowvar->index0);
 		if (restore_row(tab, var) < 0)
-			goto error;
+			return -1;
 	} else {
 		int i;
+		unsigned off = 2 + tab->M;
 
 		for (i = 0; i < tab->n_row; ++i) {
 			if (isl_int_is_zero(tab->mat->rowioff + var->index))
@@ -2587,12 +2817,67 @@
 	}
 
 	if (isl_tab_push_var(tab, isl_tab_undo_relax, var) < 0)
-		goto error;
+		return -1;
 
-	return tab;
-error:
-	isl_tab_free(tab);
-	return NULL;
+	return 0;
+}
+
+/* Replace the variable v at position "pos" in the tableau "tab"
+ * by v' = v + shift.
+ *
+ * If the variable is in a column, then we first check if we can
+ * simply plug in v = v' - shift.  The effect on a row with
+ * coefficient f/d for variable v is that the constant term c/d
+ * is replaced by (c - f * shift)/d.  If shift is positive and
+ * f is negative for each row that needs to remain non-negative,
+ * then this is clearly safe.  In other words, if the minimum of v
+ * is manifestly unbounded, then we can keep v in a column position.
+ * Otherwise, we can pivot it down to a row.
+ * Similarly, if shift is negative, we need to check if the maximum
+ * of is manifestly unbounded.
+ *
+ * If the variable is in a row (from the start or after pivoting),
+ * then the constant term c/d is replaced by (c + d * shift)/d.
+ */
+int isl_tab_shift_var(struct isl_tab *tab, int pos, isl_int shift)
+{
+	struct isl_tab_var *var;
+
+	if (!tab)
+		return -1;
+	if (isl_int_is_zero(shift))
+		return 0;
+
+	var = &tab->varpos;
+	if (!var->is_row) {
+		if (isl_int_is_neg(shift)) {
+			if (!max_is_manifestly_unbounded(tab, var))
+				if (to_row(tab, var, 1) < 0)
+					return -1;
+		} else {
+			if (!min_is_manifestly_unbounded(tab, var))
+				if (to_row(tab, var, -1) < 0)
+					return -1;
+		}
+	}
+
+	if (var->is_row) {
+		isl_int_addmul(tab->mat->rowvar->index1,
+				shift, tab->mat->rowvar->index0);
+	} else {
+		int i;
+		unsigned off = 2 + tab->M;
+
+		for (i = 0; i < tab->n_row; ++i) {
+			if (isl_int_is_zero(tab->mat->rowioff + var->index))
+				continue;
+			isl_int_submul(tab->mat->rowi1,
+				    shift, tab->mat->rowioff + var->index);
+		}
+
+	}
+
+	return 0;
 }
 
 /* Remove the sign constraint from constraint "con".
@@ -2633,6 +2918,37 @@
 					    tab->mat->rowrow0);
 }
 
+/* Return an isl_tab_var that has been marked or NULL if no such
+ * variable can be found.
+ * The marked field has only been set for variables that
+ * appear in non-redundant rows or non-dead columns.
+ *
+ * Pick the last constraint variable that is marked and
+ * that appears in either a non-redundant row or a non-dead columns.
+ * Since the returned variable is tested for being a redundant constraint or
+ * an implicit equality, there is no need to return any tab variable that
+ * corresponds to a variable.
+ */
+static struct isl_tab_var *select_marked(struct isl_tab *tab)
+{
+	int i;
+	struct isl_tab_var *var;
+
+	for (i = tab->n_con - 1; i >= 0; --i) {
+		var = &tab->coni;
+		if (var->index < 0)
+			continue;
+		if (var->is_row && var->index < tab->n_redundant)
+			continue;
+		if (!var->is_row && var->index < tab->n_dead)
+			continue;
+		if (var->marked)
+			return var;
+	}
+
+	return NULL;
+}
+
 /* Check for (near) equalities among the constraints.
  * A constraint is an equality if it is non-negative and if
  * its maximal value is either
@@ -2648,6 +2964,7 @@
  * Otherwise, if the maximal value is strictly less than one (and the
  * tableau is integer), then we restrict the value to being zero
  * by adding an opposite non-negative variable.
+ * The order in which the variables are considered is not important.
  */
 int isl_tab_detect_implicit_equalities(struct isl_tab *tab)
 {
@@ -2678,27 +2995,16 @@
 	while (n_marked) {
 		struct isl_tab_var *var;
 		int sgn;
-		for (i = tab->n_redundant; i < tab->n_row; ++i) {
-			var = isl_tab_var_from_row(tab, i);
-			if (var->marked)
-				break;
-		}
-		if (i == tab->n_row) {
-			for (i = tab->n_dead; i < tab->n_col; ++i) {
-				var = var_from_col(tab, i);
-				if (var->marked)
-					break;
-			}
-			if (i == tab->n_col)
-				break;
-		}
+		var = select_marked(tab);
+		if (!var)
+			break;
 		var->marked = 0;
 		n_marked--;
 		sgn = sign_of_max(tab, var);
 		if (sgn < 0)
 			return -1;
 		if (sgn == 0) {
-			if (close_row(tab, var) < 0)
+			if (close_row(tab, var, 0) < 0)
 				return -1;
 		} else if (!tab->rational && !at_least_one(tab, var)) {
 			if (cut_to_hyperplane(tab, var) < 0)
@@ -2739,6 +3045,30 @@
 	return 0;
 }
 
+/* Interchange constraints "con1" and "con2" in "tab".
+ * In particular, interchange the contents of these entries in tab->con.
+ * Since tab->col_var and tab->row_var point back into this array,
+ * they need to be updated accordingly.
+ */
+isl_stat isl_tab_swap_constraints(struct isl_tab *tab, int con1, int con2)
+{
+	struct isl_tab_var var;
+
+	if (isl_tab_check_con(tab, con1) < 0 ||
+	    isl_tab_check_con(tab, con2) < 0)
+		return isl_stat_error;
+
+	var = tab->concon1;
+	tab->concon1 = tab->concon2;
+	if (update_con_after_move(tab, con1, con2) < 0)
+		return isl_stat_error;
+	tab->concon2 = var;
+	if (update_con_after_move(tab, con2, con1) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
 /* Rotate the "n" constraints starting at "first" to the right,
  * putting the last constraint in the position of the first constraint.
  */
@@ -2764,6 +3094,77 @@
 	return 0;
 }
 
+/* Drop the "n" entries starting at position "first" in tab->con, moving all
+ * subsequent entries down.
+ * Since some of the entries of tab->row_var and tab->col_var contain
+ * indices into this array, they have to be updated accordingly.
+ */
+static isl_stat con_drop_entries(struct isl_tab *tab,
+	unsigned first, unsigned n)
+{
+	int i;
+
+	if (first + n > tab->n_con || first + n < first)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"invalid range", return isl_stat_error);
+
+	tab->n_con -= n;
+
+	for (i = first; i < tab->n_con; ++i) {
+		tab->coni = tab->coni + n;
+		if (update_con_after_move(tab, i, i + n) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* isl_basic_map_gauss5 callback that gets called when
+ * two (equality) constraints "a" and "b" get interchanged
+ * in the basic map.  Perform the same interchange in "tab".
+ */
+static isl_stat swap_eq(unsigned a, unsigned b, void *user)
+{
+	struct isl_tab *tab = user;
+
+	return isl_tab_swap_constraints(tab, a, b);
+}
+
+/* isl_basic_map_gauss5 callback that gets called when
+ * the final "n" equality constraints get removed.
+ * As a special case, if "n" is equal to the total number
+ * of equality constraints, then this means the basic map
+ * turned out to be empty.
+ * Drop the same number of equality constraints from "tab" or
+ * mark it empty in the special case.
+ */
+static isl_stat drop_eq(unsigned n, void *user)
+{
+	struct isl_tab *tab = user;
+
+	if (tab->n_eq == n)
+		return isl_tab_mark_empty(tab);
+
+	tab->n_eq -= n;
+	return con_drop_entries(tab, tab->n_eq, n);
+}
+
+/* If "bmap" has more than a single reference, then call
+ * isl_basic_map_gauss on it, updating "tab" accordingly.
+ */
+static __isl_give isl_basic_map *gauss_if_shared(__isl_take isl_basic_map *bmap,
+	struct isl_tab *tab)
+{
+	isl_bool single;
+
+	single = isl_basic_map_has_single_reference(bmap);
+	if (single < 0)
+		return isl_basic_map_free(bmap);
+	if (single)
+		return bmap;
+	return isl_basic_map_gauss5(bmap, NULL, &swap_eq, &drop_eq, tab);
+}
+
 /* Make the equalities that are implicit in "bmap" but that have been
  * detected in the corresponding "tab" explicit in "bmap" and update
  * "tab" to reflect the new order of the constraints.
@@ -2790,20 +3191,25 @@
  * If "tab" contains any constraints that are not in "bmap" then they
  * appear after those in "bmap" and they should be left untouched.
  *
- * Note that this function leaves "bmap" in a temporary state
- * as it does not call isl_basic_map_gauss.  Calling this function
- * is the responsibility of the caller.
+ * Note that this function only calls isl_basic_map_gauss
+ * (in case some equality constraints got detected)
+ * if "bmap" has more than one reference.
+ * If it only has a single reference, then it is left in a temporary state,
+ * because the caller may require this state.
+ * Calling isl_basic_map_gauss is then the responsibility of the caller.
  */
 __isl_give isl_basic_map *isl_tab_make_equalities_explicit(struct isl_tab *tab,
 	__isl_take isl_basic_map *bmap)
 {
 	int i;
+	unsigned n_eq;
 
 	if (!tab || !bmap)
 		return isl_basic_map_free(bmap);
 	if (tab->empty)
 		return bmap;
 
+	n_eq = tab->n_eq;
 	for (i = bmap->n_ineq - 1; i >= 0; --i) {
 		if (!isl_tab_is_equality(tab, bmap->n_eq + i))
 			continue;
@@ -2816,6 +3222,9 @@
 		tab->n_eq++;
 	}
 
+	if (n_eq != tab->n_eq)
+		bmap = gauss_if_shared(bmap, tab);
+
 	return bmap;
 }
 
@@ -2878,20 +3287,9 @@
 	while (n_marked) {
 		struct isl_tab_var *var;
 		int red;
-		for (i = tab->n_redundant; i < tab->n_row; ++i) {
-			var = isl_tab_var_from_row(tab, i);
-			if (var->marked)
-				break;
-		}
-		if (i == tab->n_row) {
-			for (i = tab->n_dead; i < tab->n_col; ++i) {
-				var = var_from_col(tab, i);
-				if (var->marked)
-					break;
-			}
-			if (i == tab->n_col)
-				break;
-		}
+		var = select_marked(tab);
+		if (!var)
+			break;
 		var->marked = 0;
 		n_marked--;
 		red = con_is_redundant(tab, var);
@@ -2932,7 +3330,7 @@
 
 	off = 2 + tab->M;
 	return isl_int_is_zero(tab->mat->rowrow1) &&
-		(!tab->M || isl_int_is_zero(tab->mat->rowrow2)) &&
+		!row_is_big(tab, row) &&
 		isl_seq_first_non_zero(tab->mat->rowrow + off + tab->n_dead,
 					tab->n_col - tab->n_dead) == -1;
 }
@@ -2943,6 +3341,9 @@
  * If opt_denom is NULL, then *opt is rounded up to the nearest integer.
  * The return value reflects the nature of the result (empty, unbounded,
  * minimal value returned in *opt).
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 enum isl_lp_result isl_tab_min(struct isl_tab *tab,
 	isl_int *f, isl_int denom, isl_int *opt, isl_int *opt_denom,
@@ -3006,17 +3407,24 @@
 			isl_int_set(*opt, tab->mat->rowvar->index1);
 			isl_int_set(*opt_denom, tab->mat->rowvar->index0);
 		} else
-			isl_int_cdiv_q(*opt, tab->mat->rowvar->index1,
-					     tab->mat->rowvar->index0);
+			get_rounded_sample_value(tab, var, 1, opt);
 	}
 	if (isl_tab_rollback(tab, snap) < 0)
 		return isl_lp_error;
 	return res;
 }
 
+/* Is the constraint at position "con" marked as being redundant?
+ * If it is marked as representing an equality, then it is not
+ * considered to be redundant.
+ * Note that isl_tab_mark_redundant marks both the isl_tab_var as
+ * redundant and moves the corresponding row into the first
+ * tab->n_redundant positions (or removes the row, assigning it index -1),
+ * so the final test is actually redundant itself.
+ */
 int isl_tab_is_redundant(struct isl_tab *tab, int con)
 {
-	if (!tab)
+	if (isl_tab_check_con(tab, con) < 0)
 		return -1;
 	if (tab->concon.is_zero)
 		return 0;
@@ -3025,7 +3433,242 @@
 	return tab->concon.is_row && tab->concon.index < tab->n_redundant;
 }
 
-/* Take a snapshot of the tableau that can be restored by s call to
+/* Is variable "var" of "tab" fixed to a constant value by its row
+ * in the tableau?
+ * If so and if "value" is not NULL, then store this constant value
+ * in "value".
+ *
+ * That is, is it a row variable that only has non-zero coefficients
+ * for dead columns?
+ */
+static isl_bool is_constant(struct isl_tab *tab, struct isl_tab_var *var,
+	isl_int *value)
+{
+	unsigned off = 2 + tab->M;
+	isl_mat *mat = tab->mat;
+	int n;
+	int row;
+	int pos;
+
+	if (!var->is_row)
+		return isl_bool_false;
+	row = var->index;
+	if (row_is_big(tab, row))
+		return isl_bool_false;
+	n = tab->n_col - tab->n_dead;
+	pos = isl_seq_first_non_zero(mat->rowrow + off + tab->n_dead, n);
+	if (pos != -1)
+		return isl_bool_false;
+	if (value)
+		isl_int_divexact(*value, mat->rowrow1, mat->rowrow0);
+	return isl_bool_true;
+}
+
+/* Has the variable "var' of "tab" reached a value that is greater than
+ * or equal (if sgn > 0) or smaller than or equal (if sgn < 0) to "target"?
+ * "tmp" has been initialized by the caller and can be used
+ * to perform local computations.
+ *
+ * If the sample value involves the big parameter, then any value
+ * is reached.
+ * Otherwise check if n/d >= t, i.e., n >= d * t (if sgn > 0)
+ * or n/d <= t, i.e., n <= d * t (if sgn < 0).
+ */
+static int reached(struct isl_tab *tab, struct isl_tab_var *var, int sgn,
+	isl_int target, isl_int *tmp)
+{
+	if (row_is_big(tab, var->index))
+		return 1;
+	isl_int_mul(*tmp, tab->mat->rowvar->index0, target);
+	if (sgn > 0)
+		return isl_int_ge(tab->mat->rowvar->index1, *tmp);
+	else
+		return isl_int_le(tab->mat->rowvar->index1, *tmp);
+}
+
+/* Can variable "var" of "tab" attain the value "target" by
+ * pivoting up (if sgn > 0) or down (if sgn < 0)?
+ * If not, then pivot up down to the greatest smallest
+ * rational value.
+ * "tmp" has been initialized by the caller and can be used
+ * to perform local computations.
+ *
+ * If the variable is manifestly unbounded in the desired direction,
+ * then it can attain any value.
+ * Otherwise, it can be moved to a row.
+ * Continue pivoting until the target is reached.
+ * If no more pivoting can be performed, the maximal minimal
+ * rational value has been reached and the target cannot be reached.
+ * If the variable would be pivoted into a manifestly unbounded column,
+ * then the target can be reached.
+ */
+static isl_bool var_reaches(struct isl_tab *tab, struct isl_tab_var *var,
+	int sgn, isl_int target, isl_int *tmp)
+{
+	int row, col;
+
+	if (sgn < 0 && min_is_manifestly_unbounded(tab, var))
+		return isl_bool_true;
+	if (sgn > 0 && max_is_manifestly_unbounded(tab, var))
+		return isl_bool_true;
+	if (to_row(tab, var, sgn) < 0)
+		return isl_bool_error;
+	while (!reached(tab, var, sgn, target, tmp)) {
+		find_pivot(tab, var, var, sgn, &row, &col);
+		if (row == -1)
+			return isl_bool_false;
+		if (row == var->index)
+			return isl_bool_true;
+		if (isl_tab_pivot(tab, row, col) < 0)
+			return isl_bool_error;
+	}
+
+	return isl_bool_true;
+}
+
+/* Check if variable "var" of "tab" can only attain a single (integer)
+ * value, and, if so, add an equality constraint to fix the variable
+ * to this single value and store the result in "target".
+ * "target" and "tmp" have been initialized by the caller.
+ *
+ * Given the current sample value, round it down and check
+ * whether it is possible to attain a strictly smaller integer value.
+ * If so, the variable is not restricted to a single integer value.
+ * Otherwise, the search stops at the smallest rational value.
+ * Round up this value and check whether it is possible to attain
+ * a strictly greater integer value.
+ * If so, the variable is not restricted to a single integer value.
+ * Otherwise, the search stops at the greatest rational value.
+ * If rounding down this value yields a value that is different
+ * from rounding up the smallest rational value, then the variable
+ * cannot attain any integer value.  Mark the tableau empty.
+ * Otherwise, add an equality constraint that fixes the variable
+ * to the single integer value found.
+ */
+static isl_bool detect_constant_with_tmp(struct isl_tab *tab,
+	struct isl_tab_var *var, isl_int *target, isl_int *tmp)
+{
+	isl_bool reached;
+	isl_vec *eq;
+	int pos;
+	isl_stat r;
+
+	get_rounded_sample_value(tab, var, -1, target);
+	isl_int_sub_ui(*target, *target, 1);
+	reached = var_reaches(tab, var, -1, *target, tmp);
+	if (reached < 0 || reached)
+		return isl_bool_not(reached);
+	get_rounded_sample_value(tab, var, 1, target);
+	isl_int_add_ui(*target, *target, 1);
+	reached = var_reaches(tab, var, 1, *target, tmp);
+	if (reached < 0 || reached)
+		return isl_bool_not(reached);
+	get_rounded_sample_value(tab, var, -1, tmp);
+	isl_int_sub_ui(*target, *target, 1);
+	if (isl_int_ne(*target, *tmp)) {
+		if (isl_tab_mark_empty(tab) < 0)
+			return isl_bool_error;
+		return isl_bool_false;
+	}
+
+	if (isl_tab_extend_cons(tab, 1) < 0)
+		return isl_bool_error;
+	eq = isl_vec_alloc(isl_tab_get_ctx(tab), 1 + tab->n_var);
+	if (!eq)
+		return isl_bool_error;
+	pos = var - tab->var;
+	isl_seq_clr(eq->el + 1, tab->n_var);
+	isl_int_set_si(eq->el1 + pos, -1);
+	isl_int_set(eq->el0, *target);
+	r = isl_tab_add_eq(tab, eq->el);
+	isl_vec_free(eq);
+
+	return r < 0 ? isl_bool_error : isl_bool_true;
+}
+
+/* Check if variable "var" of "tab" can only attain a single (integer)
+ * value, and, if so, add an equality constraint to fix the variable
+ * to this single value and store the result in "value" (if "value"
+ * is not NULL).
+ *
+ * If the current sample value involves the big parameter,
+ * then the variable cannot have a fixed integer value.
+ * If the variable is already fixed to a single value by its row, then
+ * there is no need to add another equality constraint.
+ *
+ * Otherwise, allocate some temporary variables and continue
+ * with detect_constant_with_tmp.
+ */
+static isl_bool get_constant(struct isl_tab *tab, struct isl_tab_var *var,
+	isl_int *value)
+{
+	isl_int target, tmp;
+	isl_bool is_cst;
+
+	if (var->is_row && row_is_big(tab, var->index))
+		return isl_bool_false;
+	is_cst = is_constant(tab, var, value);
+	if (is_cst < 0 || is_cst)
+		return is_cst;
+
+	if (!value)
+		isl_int_init(target);
+	isl_int_init(tmp);
+
+	is_cst = detect_constant_with_tmp(tab, var,
+					    value ? value : &target, &tmp);
+
+	isl_int_clear(tmp);
+	if (!value)
+		isl_int_clear(target);
+
+	return is_cst;
+}
+
+/* Check if variable "var" of "tab" can only attain a single (integer)
+ * value, and, if so, add an equality constraint to fix the variable
+ * to this single value and store the result in "value" (if "value"
+ * is not NULL).
+ *
+ * For rational tableaus, nothing needs to be done.
+ */
+isl_bool isl_tab_is_constant(struct isl_tab *tab, int var, isl_int *value)
+{
+	if (!tab)
+		return isl_bool_error;
+	if (var < 0 || var >= tab->n_var)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"position out of bounds", return isl_bool_error);
+	if (tab->rational)
+		return isl_bool_false;
+
+	return get_constant(tab, &tab->varvar, value);
+}
+
+/* Check if any of the variables of "tab" can only attain a single (integer)
+ * value, and, if so, add equality constraints to fix those variables
+ * to these single values.
+ *
+ * For rational tableaus, nothing needs to be done.
+ */
+isl_stat isl_tab_detect_constants(struct isl_tab *tab)
+{
+	int i;
+
+	if (!tab)
+		return isl_stat_error;
+	if (tab->rational)
+		return isl_stat_ok;
+
+	for (i = 0; i < tab->n_var; ++i) {
+		if (get_constant(tab, &tab->vari, NULL) < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Take a snapshot of the tableau that can be restored by a call to
  * isl_tab_rollback.
  */
 struct isl_tab_undo *isl_tab_snap(struct isl_tab *tab)
@@ -3036,23 +3679,50 @@
 	return tab->top;
 }
 
+/* Does "tab" need to keep track of undo information?
+ * That is, was a snapshot taken that may need to be restored?
+ */
+isl_bool isl_tab_need_undo(struct isl_tab *tab)
+{
+	if (!tab)
+		return isl_bool_error;
+
+	return isl_bool_ok(tab->need_undo);
+}
+
+/* Remove all tracking of undo information from "tab", invalidating
+ * any snapshots that may have been taken of the tableau.
+ * Since all snapshots have been invalidated, there is also
+ * no need to start keeping track of undo information again.
+ */
+void isl_tab_clear_undo(struct isl_tab *tab)
+{
+	if (!tab)
+		return;
+
+	free_undo(tab);
+	tab->need_undo = 0;
+}
+
 /* Undo the operation performed by isl_tab_relax.
  */
-static int unrelax(struct isl_tab *tab, struct isl_tab_var *var) WARN_UNUSED;
-static int unrelax(struct isl_tab *tab, struct isl_tab_var *var)
+static isl_stat unrelax(struct isl_tab *tab, struct isl_tab_var *var)
+	WARN_UNUSED;
+static isl_stat unrelax(struct isl_tab *tab, struct isl_tab_var *var)
 {
 	unsigned off = 2 + tab->M;
 
 	if (!var->is_row && !max_is_manifestly_unbounded(tab, var))
 		if (to_row(tab, var, 1) < 0)
-			return -1;
+			return isl_stat_error;
 
 	if (var->is_row) {
 		isl_int_sub(tab->mat->rowvar->index1,
 		    tab->mat->rowvar->index1, tab->mat->rowvar->index0);
 		if (var->is_nonneg) {
 			int sgn = restore_row(tab, var);
-			isl_assert(tab->mat->ctx, sgn >= 0, return -1);
+			isl_assert(tab->mat->ctx, sgn >= 0,
+				return isl_stat_error);
 		}
 	} else {
 		int i;
@@ -3066,7 +3736,7 @@
 
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Undo the operation performed by isl_tab_unrestrict.
@@ -3074,18 +3744,42 @@
  * In particular, mark the variable as being non-negative and make
  * sure the sample value respects this constraint.
  */
-static int ununrestrict(struct isl_tab *tab, struct isl_tab_var *var)
+static isl_stat ununrestrict(struct isl_tab *tab, struct isl_tab_var *var)
 {
 	var->is_nonneg = 1;
 
 	if (var->is_row && restore_row(tab, var) < -1)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int perform_undo_var(struct isl_tab *tab, struct isl_tab_undo *undo) WARN_UNUSED;
-static int perform_undo_var(struct isl_tab *tab, struct isl_tab_undo *undo)
+/* Unmark the last redundant row in "tab" as being redundant.
+ * This undoes part of the modifications performed by isl_tab_mark_redundant.
+ * In particular, remove the redundant mark and make
+ * sure the sample value respects the constraint again.
+ * A variable that is marked non-negative by isl_tab_mark_redundant
+ * is covered by a separate undo record.
+ */
+static isl_stat restore_last_redundant(struct isl_tab *tab)
+{
+	struct isl_tab_var *var;
+
+	if (tab->n_redundant < 1)
+		isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+			"no redundant rows", return isl_stat_error);
+
+	var = isl_tab_var_from_row(tab, tab->n_redundant - 1);
+	var->is_redundant = 0;
+	tab->n_redundant--;
+	restore_row(tab, var);
+
+	return isl_stat_ok;
+}
+
+static isl_stat perform_undo_var(struct isl_tab *tab, struct isl_tab_undo *undo)
+	WARN_UNUSED;
+static isl_stat perform_undo_var(struct isl_tab *tab, struct isl_tab_undo *undo)
 {
 	struct isl_tab_var *var = var_from_index(tab, undo->u.var_index);
 	switch (undo->type) {
@@ -3093,10 +3787,11 @@
 		var->is_nonneg = 0;
 		break;
 	case isl_tab_undo_redundant:
-		var->is_redundant = 0;
-		tab->n_redundant--;
-		restore_row(tab, isl_tab_var_from_row(tab, tab->n_redundant));
-		break;
+		if (!var->is_row || var->index != tab->n_redundant - 1)
+			isl_die(isl_tab_get_ctx(tab), isl_error_internal,
+				"not undoing last redundant row",
+				return isl_stat_error);
+		return restore_last_redundant(tab);
 	case isl_tab_undo_freeze:
 		var->frozen = 0;
 		break;
@@ -3107,23 +3802,22 @@
 		break;
 	case isl_tab_undo_allocate:
 		if (undo->u.var_index >= 0) {
-			isl_assert(tab->mat->ctx, !var->is_row, return -1);
-			drop_col(tab, var->index);
-			break;
+			isl_assert(tab->mat->ctx, !var->is_row,
+				return isl_stat_error);
+			return drop_col(tab, var->index);
 		}
 		if (!var->is_row) {
 			if (!max_is_manifestly_unbounded(tab, var)) {
 				if (to_row(tab, var, 1) < 0)
-					return -1;
+					return isl_stat_error;
 			} else if (!min_is_manifestly_unbounded(tab, var)) {
 				if (to_row(tab, var, -1) < 0)
-					return -1;
+					return isl_stat_error;
 			} else
 				if (to_row(tab, var, 0) < 0)
-					return -1;
+					return isl_stat_error;
 		}
-		drop_row(tab, var->index);
-		break;
+		return drop_row(tab, var->index);
 	case isl_tab_undo_relax:
 		return unrelax(tab, var);
 	case isl_tab_undo_unrestrict:
@@ -3131,10 +3825,64 @@
 	default:
 		isl_die(tab->mat->ctx, isl_error_internal,
 			"perform_undo_var called on invalid undo record",
-			return -1);
+			return isl_stat_error);
 	}
 
-	return 0;
+	return isl_stat_ok;
+}
+
+/* Restore all rows that have been marked redundant by isl_tab_mark_redundant
+ * and that have been preserved in the tableau.
+ * Note that isl_tab_mark_redundant may also have marked some variables
+ * as being non-negative before marking them redundant.  These need
+ * to be removed as well as otherwise some constraints could end up
+ * getting marked redundant with respect to the variable.
+ */
+isl_stat isl_tab_restore_redundant(struct isl_tab *tab)
+{
+	if (!tab)
+		return isl_stat_error;
+
+	if (tab->need_undo)
+		isl_die(isl_tab_get_ctx(tab), isl_error_invalid,
+			"manually restoring redundant constraints "
+			"interferes with undo history",
+			return isl_stat_error);
+
+	while (tab->n_redundant > 0) {
+		if (tab->row_vartab->n_redundant - 1 >= 0) {
+			struct isl_tab_var *var;
+
+			var = isl_tab_var_from_row(tab, tab->n_redundant - 1);
+			var->is_nonneg = 0;
+		}
+		restore_last_redundant(tab);
+	}
+	return isl_stat_ok;
+}
+
+/* Undo the addition of an integer division to the basic map representation
+ * of "tab" in position "pos".
+ */
+static isl_stat drop_bmap_div(struct isl_tab *tab, int pos)
+{
+	int off;
+	isl_size n_div;
+
+	n_div = isl_basic_map_dim(tab->bmap, isl_dim_div);
+	if (n_div < 0)
+		return isl_stat_error;
+	off = tab->n_var - n_div;
+	tab->bmap = isl_basic_map_drop_div(tab->bmap, pos - off);
+	if (!tab->bmap)
+		return isl_stat_error;
+	if (tab->samples) {
+		tab->samples = isl_mat_drop_cols(tab->samples, 1 + pos, 1);
+		if (!tab->samples)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
 }
 
 /* Restore the tableau to the state where the basic variables
@@ -3215,10 +3963,14 @@
 	}
 }
 
-static int perform_undo(struct isl_tab *tab, struct isl_tab_undo *undo) WARN_UNUSED;
-static int perform_undo(struct isl_tab *tab, struct isl_tab_undo *undo)
+static isl_stat perform_undo(struct isl_tab *tab, struct isl_tab_undo *undo)
+	WARN_UNUSED;
+static isl_stat perform_undo(struct isl_tab *tab, struct isl_tab_undo *undo)
 {
 	switch (undo->type) {
+	case isl_tab_undo_rational:
+		tab->rational = 0;
+		break;
 	case isl_tab_undo_empty:
 		tab->empty = 0;
 		break;
@@ -3231,18 +3983,16 @@
 	case isl_tab_undo_unrestrict:
 		return perform_undo_var(tab, undo);
 	case isl_tab_undo_bmap_eq:
-		return isl_basic_map_free_equality(tab->bmap, 1);
+		tab->bmap = isl_basic_map_free_equality(tab->bmap, 1);
+		return tab->bmap ? isl_stat_ok : isl_stat_error;
 	case isl_tab_undo_bmap_ineq:
-		return isl_basic_map_free_inequality(tab->bmap, 1);
+		tab->bmap = isl_basic_map_free_inequality(tab->bmap, 1);
+		return tab->bmap ? isl_stat_ok : isl_stat_error;
 	case isl_tab_undo_bmap_div:
-		if (isl_basic_map_free_div(tab->bmap, 1) < 0)
-			return -1;
-		if (tab->samples)
-			tab->samples->n_col--;
-		break;
+		return drop_bmap_div(tab, undo->u.var_index);
 	case isl_tab_undo_saved_basis:
 		if (restore_basis(tab, undo->u.col_var) < 0)
-			return -1;
+			return isl_stat_error;
 		break;
 	case isl_tab_undo_drop_sample:
 		tab->n_outside--;
@@ -3253,20 +4003,20 @@
 	case isl_tab_undo_callback:
 		return undo->u.callback->run(undo->u.callback);
 	default:
-		isl_assert(tab->mat->ctx, 0, return -1);
+		isl_assert(tab->mat->ctx, 0, return isl_stat_error);
 	}
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Return the tableau to the state it was in when the snapshot "snap"
  * was taken.
  */
-int isl_tab_rollback(struct isl_tab *tab, struct isl_tab_undo *snap)
+isl_stat isl_tab_rollback(struct isl_tab *tab, struct isl_tab_undo *snap)
 {
 	struct isl_tab_undo *undo, *next;
 
 	if (!tab)
-		return -1;
+		return isl_stat_error;
 
 	tab->in_undo = 1;
 	for (undo = tab->top; undo && undo != &tab->bottom; undo = next) {
@@ -3277,15 +4027,15 @@
 			tab->top = undo;
 			free_undo(tab);
 			tab->in_undo = 0;
-			return -1;
+			return isl_stat_error;
 		}
 		free_undo_record(undo);
 	}
 	tab->in_undo = 0;
 	tab->top = undo;
 	if (!undo)
-		return -1;
-	return 0;
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* The given row "row" represents an inequality violated by all
@@ -3387,7 +4137,7 @@
 	return isl_ineq_error;
 }
 
-int isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap)
+isl_stat isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap)
 {
 	bmap = isl_basic_map_cow(bmap);
 	if (!tab || !bmap)
@@ -3398,7 +4148,7 @@
 		if (!bmap)
 			goto error;
 		tab->bmap = bmap;
-		return 0;
+		return isl_stat_ok;
 	}
 
 	isl_assert(tab->mat->ctx, tab->n_eq == bmap->n_eq, goto error);
@@ -3407,15 +4157,15 @@
 
 	tab->bmap = bmap;
 
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_basic_map_free(bmap);
-	return -1;
+	return isl_stat_error;
 }
 
-int isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset)
+isl_stat isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset)
 {
-	return isl_tab_track_bmap(tab, (isl_basic_map *)bset);
+	return isl_tab_track_bmap(tab, bset_to_bmap(bset));
 }
 
 __isl_keep isl_basic_set *isl_tab_peek_bset(struct isl_tab *tab)
@@ -3423,7 +4173,7 @@
 	if (!tab)
 		return NULL;
 
-	return (isl_basic_set *)tab->bmap;
+	return bset_from_bmap(tab->bmap);
 }
 
 static void isl_tab_print_internal(__isl_keep struct isl_tab *tab,

_service:tar_scm:isl-0.14.tar.xz/isl_tab.h -> _service:tar_scm:isl-0.24.tar.gz/isl_tab.h Changed

@@ -29,6 +29,7 @@
 
 enum isl_tab_undo_type {
 	isl_tab_undo_bottom,
+	isl_tab_undo_rational,
 	isl_tab_undo_empty,
 	isl_tab_undo_nonneg,
 	isl_tab_undo_redundant,
@@ -47,7 +48,7 @@
 };
 
 struct isl_tab_callback {
-	int (*run)(struct isl_tab_callback *cb);
+	isl_stat (*run)(struct isl_tab_callback *cb);
 };
 
 union isl_tab_undo_val {
@@ -112,7 +113,7 @@
  * However, the basic operations do not ensure that all dead columns
  * or all redundant rows are detected.
  * isl_tab_detect_implicit_equalities and isl_tab_detect_redundant can be used
- * to perform and exhaustive search for dead columns and redundant rows.
+ * to perform an exhaustive search for dead columns and redundant rows.
  *
  * The samples matrix contains "n_sample" integer points that have at some
  * point been elements satisfying the tableau.  The first "n_outside"
@@ -189,37 +190,40 @@
 	__isl_keep isl_basic_map *bmap, int track);
 __isl_give struct isl_tab *isl_tab_from_basic_set(
 	__isl_keep isl_basic_set *bset, int track);
-struct isl_tab *isl_tab_from_recession_cone(struct isl_basic_set *bset,
+struct isl_tab *isl_tab_from_recession_cone(__isl_keep isl_basic_set *bset,
 	int parametric);
-int isl_tab_cone_is_bounded(struct isl_tab *tab);
-struct isl_basic_map *isl_basic_map_update_from_tab(struct isl_basic_map *bmap,
-	struct isl_tab *tab);
-struct isl_basic_set *isl_basic_set_update_from_tab(struct isl_basic_set *bset,
-	struct isl_tab *tab);
+isl_bool isl_tab_cone_is_bounded(struct isl_tab *tab);
+__isl_give isl_basic_map *isl_basic_map_update_from_tab(
+	__isl_take isl_basic_map *bmap, struct isl_tab *tab);
+__isl_give isl_basic_set *isl_basic_set_update_from_tab(
+	__isl_take isl_basic_set *bset, struct isl_tab *tab);
 int isl_tab_detect_implicit_equalities(struct isl_tab *tab) WARN_UNUSED;
 __isl_give isl_basic_map *isl_tab_make_equalities_explicit(struct isl_tab *tab,
 	__isl_take isl_basic_map *bmap);
 int isl_tab_detect_redundant(struct isl_tab *tab) WARN_UNUSED;
+isl_stat isl_tab_restore_redundant(struct isl_tab *tab);
 #define ISL_TAB_SAVE_DUAL	(1 << 0)
 enum isl_lp_result isl_tab_min(struct isl_tab *tab,
 	isl_int *f, isl_int denom, isl_int *opt, isl_int *opt_denom,
 	unsigned flags) WARN_UNUSED;
 
-int isl_tab_add_ineq(struct isl_tab *tab, isl_int *ineq) WARN_UNUSED;
-int isl_tab_add_eq(struct isl_tab *tab, isl_int *eq) WARN_UNUSED;
+isl_stat isl_tab_add_ineq(struct isl_tab *tab, isl_int *ineq) WARN_UNUSED;
+isl_stat isl_tab_add_eq(struct isl_tab *tab, isl_int *eq) WARN_UNUSED;
 int isl_tab_add_valid_eq(struct isl_tab *tab, isl_int *eq) WARN_UNUSED;
 
 int isl_tab_freeze_constraint(struct isl_tab *tab, int con) WARN_UNUSED;
 
-int isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap) WARN_UNUSED;
-int isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset) WARN_UNUSED;
+isl_stat isl_tab_track_bmap(struct isl_tab *tab, __isl_take isl_basic_map *bmap)
+	WARN_UNUSED;
+isl_stat isl_tab_track_bset(struct isl_tab *tab, __isl_take isl_basic_set *bset)
+	WARN_UNUSED;
 __isl_keep isl_basic_set *isl_tab_peek_bset(struct isl_tab *tab);
 
 int isl_tab_is_equality(struct isl_tab *tab, int con);
 int isl_tab_is_redundant(struct isl_tab *tab, int con);
 
 int isl_tab_sample_is_integer(struct isl_tab *tab);
-struct isl_vec *isl_tab_get_sample_value(struct isl_tab *tab);
+__isl_give isl_vec *isl_tab_get_sample_value(struct isl_tab *tab);
 
 enum isl_ineq_type {
 	isl_ineq_error = -1,
@@ -233,47 +237,69 @@
 enum isl_ineq_type isl_tab_ineq_type(struct isl_tab *tab, isl_int *ineq);
 
 struct isl_tab_undo *isl_tab_snap(struct isl_tab *tab);
-int isl_tab_rollback(struct isl_tab *tab, struct isl_tab_undo *snap) WARN_UNUSED;
+isl_stat isl_tab_rollback(struct isl_tab *tab, struct isl_tab_undo *snap) WARN_UNUSED;
+isl_bool isl_tab_need_undo(struct isl_tab *tab);
+void isl_tab_clear_undo(struct isl_tab *tab);
 
-struct isl_tab *isl_tab_relax(struct isl_tab *tab, int con) WARN_UNUSED;
+int isl_tab_relax(struct isl_tab *tab, int con) WARN_UNUSED;
 int isl_tab_select_facet(struct isl_tab *tab, int con) WARN_UNUSED;
 int isl_tab_unrestrict(struct isl_tab *tab, int con) WARN_UNUSED;
 
 void isl_tab_dump(__isl_keep struct isl_tab *tab);
 
-struct isl_map *isl_tab_basic_map_partial_lexopt(
-		struct isl_basic_map *bmap, struct isl_basic_set *dom,
-		struct isl_set **empty, int max);
-__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexopt_pw_multi_aff(
+/* Compute maximum instead of minimum. */
+#define ISL_OPT_MAX		(1 << 0)
+/* Compute full instead of partial optimum; also, domain argument is NULL. */
+#define ISL_OPT_FULL		(1 << 1)
+/* Result should be free of (unknown) quantified variables. */
+#define ISL_OPT_QE		(1 << 2)
+__isl_give isl_map *isl_tab_basic_map_partial_lexopt(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max);
+	__isl_give isl_set **empty, unsigned flags);
+__isl_give isl_pw_multi_aff *isl_tab_basic_map_partial_lexopt_pw_multi_aff(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty, unsigned flags);
 
-/* An isl_region represents a sequence of consecutive variables.
+/* An isl_trivial_region represents a non-triviality region.
+ * The region is trivial if applying "trivial" to a given sequence
+ * of variables results in a zero vector.
  * pos is the location (starting at 0) of the first variable in the sequence.
  */
-struct isl_region {
+struct isl_trivial_region {
 	int pos;
-	int len;
+	isl_mat *trivial;
 };
 
 __isl_give isl_vec *isl_tab_basic_set_non_trivial_lexmin(
 	__isl_take isl_basic_set *bset, int n_op, int n_region,
-	struct isl_region *region,
+	struct isl_trivial_region *region,
 	int (*conflict)(int con, void *user), void *user);
-__isl_give isl_vec *isl_tab_basic_set_non_neg_lexmin(
+
+struct isl_tab_lexmin;
+typedef struct isl_tab_lexmin isl_tab_lexmin;
+
+__isl_give isl_tab_lexmin *isl_tab_lexmin_from_basic_set(
 	__isl_take isl_basic_set *bset);
+int isl_tab_lexmin_dim(__isl_keep isl_tab_lexmin *tl);
+__isl_give isl_tab_lexmin *isl_tab_lexmin_add_eq(__isl_take isl_tab_lexmin *tl,
+	isl_int *eq);
+__isl_give isl_tab_lexmin *isl_tab_lexmin_cut_to_integer(
+	__isl_take isl_tab_lexmin *tl);
+__isl_give isl_vec *isl_tab_lexmin_get_solution(__isl_keep isl_tab_lexmin *tl);
+__isl_null isl_tab_lexmin *isl_tab_lexmin_free(__isl_take isl_tab_lexmin *tl);
 
 /* private */
 
 struct isl_tab_var *isl_tab_var_from_row(struct isl_tab *tab, int i);
 int isl_tab_mark_redundant(struct isl_tab *tab, int row) WARN_UNUSED;
-int isl_tab_mark_empty(struct isl_tab *tab) WARN_UNUSED;
+int isl_tab_mark_rational(struct isl_tab *tab) WARN_UNUSED;
+isl_stat isl_tab_mark_empty(struct isl_tab *tab) WARN_UNUSED;
 struct isl_tab *isl_tab_dup(struct isl_tab *tab);
 struct isl_tab *isl_tab_product(struct isl_tab *tab1, struct isl_tab *tab2);
 int isl_tab_extend_cons(struct isl_tab *tab, unsigned n_new) WARN_UNUSED;
 int isl_tab_allocate_con(struct isl_tab *tab) WARN_UNUSED;
 int isl_tab_extend_vars(struct isl_tab *tab, unsigned n_new) WARN_UNUSED;
-int isl_tab_allocate_var(struct isl_tab *tab) WARN_UNUSED;
+int isl_tab_insert_var(struct isl_tab *tab, int pos) WARN_UNUSED;
 int isl_tab_pivot(struct isl_tab *tab, int row, int col) WARN_UNUSED;
 int isl_tab_add_row(struct isl_tab *tab, isl_int *line) WARN_UNUSED;
 int isl_tab_row_is_redundant(struct isl_tab *tab, int row);
@@ -281,24 +307,32 @@
 int isl_tab_sign_of_max(struct isl_tab *tab, int con);
 int isl_tab_kill_col(struct isl_tab *tab, int col) WARN_UNUSED;
 
-int isl_tab_push(struct isl_tab *tab, enum isl_tab_undo_type type) WARN_UNUSED;
-int isl_tab_push_var(struct isl_tab *tab,
+isl_stat isl_tab_push(struct isl_tab *tab, enum isl_tab_undo_type type)
+	WARN_UNUSED;
+isl_stat isl_tab_push_var(struct isl_tab *tab,
 	enum isl_tab_undo_type type, struct isl_tab_var *var) WARN_UNUSED;
-int isl_tab_push_basis(struct isl_tab *tab) WARN_UNUSED;
+isl_stat isl_tab_push_basis(struct isl_tab *tab) WARN_UNUSED;
 
 struct isl_tab *isl_tab_init_samples(struct isl_tab *tab) WARN_UNUSED;
 int isl_tab_add_sample(struct isl_tab *tab,
 	__isl_take isl_vec *sample) WARN_UNUSED;
 struct isl_tab *isl_tab_drop_sample(struct isl_tab *tab, int s);
-int isl_tab_save_samples(struct isl_tab *tab) WARN_UNUSED;
+isl_stat isl_tab_save_samples(struct isl_tab *tab) WARN_UNUSED;
 
 struct isl_tab *isl_tab_detect_equalities(struct isl_tab *tab,
 	struct isl_tab *tab_cone) WARN_UNUSED;
+isl_bool isl_tab_is_constant(struct isl_tab *tab, int var, isl_int *value);
+isl_stat isl_tab_detect_constants(struct isl_tab *tab);
 
-int isl_tab_push_callback(struct isl_tab *tab,
+isl_stat isl_tab_push_callback(struct isl_tab *tab,
 	struct isl_tab_callback *callback) WARN_UNUSED;
 
-int isl_tab_add_div(struct isl_tab *tab, __isl_keep isl_vec *div,
-	int (*add_ineq)(void *user, isl_int *), void *user);
+int isl_tab_insert_div(struct isl_tab *tab, int pos, __isl_keep isl_vec *div,
+	isl_stat (*add_ineq)(void *user, isl_int *), void *user);
+int isl_tab_add_div(struct isl_tab *tab, __isl_keep isl_vec *div);
+
+int isl_tab_shift_var(struct isl_tab *tab, int pos, isl_int shift) WARN_UNUSED;
+
+isl_stat isl_tab_swap_constraints(struct isl_tab *tab, int con1, int con2);
 
 #endif

_service:tar_scm:isl-0.24.tar.gz/isl_tab_lexopt_templ.c Added

@@ -0,0 +1,235 @@
+/*
+ * Copyright 2008-2009 Katholieke Universiteit Leuven
+ * Copyright 2010      INRIA Saclay
+ * Copyright 2011      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, K.U.Leuven, Departement
+ * Computerwetenschappen, Celestijnenlaan 200A, B-3001 Leuven, Belgium
+ * and INRIA Saclay - Ile-de-France, Parc Club Orsay Universite,
+ * ZAC des vignes, 4 rue Jacques Monod, 91893 Orsay, France
+ */
+
+#define xSF(TYPE,SUFFIX) TYPE ## SUFFIX
+#define SF(TYPE,SUFFIX) xSF(TYPE,SUFFIX)
+
+/* Given a basic map with at least two parallel constraints (as found
+ * by the function parallel_constraints), first look for more constraints
+ * parallel to the two constraint and replace the found list of parallel
+ * constraints by a single constraint with as "input" part the minimum
+ * of the input parts of the list of constraints.  Then, recursively call
+ * basic_map_partial_lexopt (possibly finding more parallel constraints)
+ * and plug in the definition of the minimum in the result.
+ *
+ * As in parallel_constraints, only inequality constraints that only
+ * involve input variables that do not occur in any other inequality
+ * constraints are considered.
+ *
+ * More specifically, given a set of constraints
+ *
+ *	a x + b_i(p) >= 0
+ *
+ * Replace this set by a single constraint
+ *
+ *	a x + u >= 0
+ *
+ * with u a new parameter with constraints
+ *
+ *	u <= b_i(p)
+ *
+ * Any solution to the new system is also a solution for the original system
+ * since
+ *
+ *	a x >= -u >= -b_i(p)
+ *
+ * Moreover, m = min_i(b_i(p)) satisfies the constraints on u and can
+ * therefore be plugged into the solution.
+ */
+static TYPE *SF(basic_map_partial_lexopt_symm,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty, int max, int first, int second)
+{
+	int i, n, k;
+	int *list = NULL;
+	isl_size bmap_in, bmap_param, bmap_all;
+	unsigned n_in, n_out, n_div;
+	isl_ctx *ctx;
+	isl_vec *var = NULL;
+	isl_mat *cst = NULL;
+	isl_space *map_space, *set_space;
+
+	map_space = isl_basic_map_get_space(bmap);
+	set_space = empty ? isl_basic_set_get_space(dom) : NULL;
+
+	bmap_in = isl_basic_map_dim(bmap, isl_dim_in);
+	bmap_param = isl_basic_map_dim(bmap, isl_dim_param);
+	bmap_all = isl_basic_map_dim(bmap, isl_dim_all);
+	if (bmap_in < 0 || bmap_param < 0 || bmap_all < 0)
+		goto error;
+	n_in = bmap_param + bmap_in;
+	n_out = bmap_all - n_in;
+
+	ctx = isl_basic_map_get_ctx(bmap);
+	list = isl_alloc_array(ctx, int, bmap->n_ineq);
+	var = isl_vec_alloc(ctx, n_out);
+	if ((bmap->n_ineq && !list) || (n_out && !var))
+		goto error;
+
+	list0 = first;
+	list1 = second;
+	isl_seq_cpy(var->el, bmap->ineqfirst + 1 + n_in, n_out);
+	for (i = second + 1, n = 2; i < bmap->n_ineq; ++i) {
+		if (isl_seq_eq(var->el, bmap->ineqi + 1 + n_in, n_out) &&
+		    all_single_occurrence(bmap, i, n_in))
+			listn++ = i;
+	}
+
+	cst = isl_mat_alloc(ctx, n, 1 + n_in);
+	if (!cst)
+		goto error;
+
+	for (i = 0; i < n; ++i)
+		isl_seq_cpy(cst->rowi, bmap->ineqlisti, 1 + n_in);
+
+	bmap = isl_basic_map_cow(bmap);
+	if (!bmap)
+		goto error;
+	for (i = n - 1; i >= 0; --i)
+		if (isl_basic_map_drop_inequality(bmap, listi) < 0)
+			goto error;
+
+	bmap = isl_basic_map_add_dims(bmap, isl_dim_in, 1);
+	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
+	k = isl_basic_map_alloc_inequality(bmap);
+	if (k < 0)
+		goto error;
+	isl_seq_clr(bmap->ineqk, 1 + n_in);
+	isl_int_set_si(bmap->ineqk1 + n_in, 1);
+	isl_seq_cpy(bmap->ineqk + 1 + n_in + 1, var->el, n_out);
+	bmap = isl_basic_map_finalize(bmap);
+
+	n_div = isl_basic_set_dim(dom, isl_dim_div);
+	dom = isl_basic_set_add_dims(dom, isl_dim_set, 1);
+	dom = isl_basic_set_extend_constraints(dom, 0, n);
+	for (i = 0; i < n; ++i) {
+		k = isl_basic_set_alloc_inequality(dom);
+		if (k < 0)
+			goto error;
+		isl_seq_cpy(dom->ineqk, cst->rowi, 1 + n_in);
+		isl_int_set_si(dom->ineqk1 + n_in, -1);
+		isl_seq_clr(dom->ineqk + 1 + n_in + 1, n_div);
+	}
+
+	isl_vec_free(var);
+	free(list);
+
+	return SF(basic_map_partial_lexopt_symm_core,SUFFIX)(bmap, dom, empty,
+						max, cst, map_space, set_space);
+error:
+	isl_space_free(map_space);
+	isl_space_free(set_space);
+	isl_mat_free(cst);
+	isl_vec_free(var);
+	free(list);
+	isl_basic_set_free(dom);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Recursive part of isl_tab_basic_map_partial_lexopt*, after detecting
+ * equalities and removing redundant constraints.
+ *
+ * We first check if there are any parallel constraints (left).
+ * If not, we are in the base case.
+ * If there are parallel constraints, we replace them by a single
+ * constraint in basic_map_partial_lexopt_symm_pma and then call
+ * this function recursively to look for more parallel constraints.
+ */
+static __isl_give TYPE *SF(basic_map_partial_lexopt,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty, int max)
+{
+	isl_bool par = isl_bool_false;
+	int first, second;
+
+	if (!bmap)
+		goto error;
+
+	if (bmap->ctx->opt->pip_symmetry)
+		par = parallel_constraints(bmap, &first, &second);
+	if (par < 0)
+		goto error;
+	if (!par)
+		return SF(basic_map_partial_lexopt_base,SUFFIX)(bmap, dom,
+								empty, max);
+
+	return SF(basic_map_partial_lexopt_symm,SUFFIX)(bmap, dom, empty, max,
+							 first, second);
+error:
+	isl_basic_set_free(dom);
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
+/* Compute the lexicographic minimum (or maximum if "flags" includes
+ * ISL_OPT_MAX) of "bmap" over the domain "dom" and return the result as
+ * either a map or a piecewise multi-affine expression depending on TYPE.
+ * If "empty" is not NULL, then *empty is assigned a set that
+ * contains those parts of the domain where there is no solution.
+ * If "flags" includes ISL_OPT_FULL, then "dom" is NULL and the optimum
+ * should be computed over the domain of "bmap".  "empty" is also NULL
+ * in this case.
+ * If "bmap" is marked as rational (ISL_BASIC_MAP_RATIONAL),
+ * then we compute the rational optimum.  Otherwise, we compute
+ * the integral optimum.
+ *
+ * We perform some preprocessing.  As the PILP solver does not
+ * handle implicit equalities very well, we first make sure all
+ * the equalities are explicitly available.
+ *
+ * We also add context constraints to the basic map and remove
+ * redundant constraints.  This is only needed because of the
+ * way we handle simple symmetries.  In particular, we currently look
+ * for symmetries on the constraints, before we set up the main tableau.
+ * It is then no good to look for symmetries on possibly redundant constraints.
+ * If the domain was extracted from the basic map, then there is
+ * no need to add back those constraints again.
+ */
+__isl_give TYPE *SF(isl_tab_basic_map_partial_lexopt,SUFFIX)(
+	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
+	__isl_give isl_set **empty, unsigned flags)
+{
+	int max, full;
+	isl_bool compatible;
+
+	if (empty)
+		*empty = NULL;
+
+	full = ISL_FL_ISSET(flags, ISL_OPT_FULL);
+	if (full)
+		dom = extract_domain(bmap, flags);
+	compatible = isl_basic_map_compatible_domain(bmap, dom);
+	if (compatible < 0)
+		goto error;
+	if (!compatible)
+		isl_die(isl_basic_map_get_ctx(bmap), isl_error_invalid,
+			"domain does not match input", goto error);
+
+	max = ISL_FL_ISSET(flags, ISL_OPT_MAX);
+	if (isl_basic_set_dim(dom, isl_dim_all) == 0)
+		return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty,
+							    max);
+
+	if (!full)
+		bmap = isl_basic_map_intersect_domain(bmap,
+						    isl_basic_set_copy(dom));
+	bmap = isl_basic_map_detect_equalities(bmap);
+	bmap = isl_basic_map_remove_redundancies(bmap);
+
+	return SF(basic_map_partial_lexopt,SUFFIX)(bmap, dom, empty, max);
+error:
+	isl_basic_set_free(dom);
+	isl_basic_map_free(bmap);
+	return NULL;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_tab_pip.c -> _service:tar_scm:isl-0.24.tar.gz/isl_tab_pip.c Changed

@@ -1,6 +1,7 @@
 /*
  * Copyright 2008-2009 Katholieke Universiteit Leuven
  * Copyright 2010      INRIA Saclay
+ * Copyright 2016-2017 Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
@@ -18,9 +19,12 @@
 #include <isl_mat_private.h>
 #include <isl_vec_private.h>
 #include <isl_aff_private.h>
+#include <isl_constraint_private.h>
 #include <isl_options_private.h>
 #include <isl_config.h>
 
+#include <bset_to_bmap.c>
+
 /*
  * The implementation of parametric integer linear programming in this file
  * was inspired by the paper "Parametric Integer Programming" and the
@@ -89,8 +93,9 @@
 	/* return index of a div that corresponds to "div" */
 	int (*get_div)(struct isl_context *context, struct isl_tab *tab,
 			struct isl_vec *div);
-	/* add div "div" to context and return non-negativity */
-	int (*add_div)(struct isl_context *context, struct isl_vec *div);
+	/* insert div "div" to context at "pos" and return non-negativity */
+	isl_bool (*insert_div)(struct isl_context *context, int pos,
+		__isl_keep isl_vec *div);
 	int (*detect_equalities)(struct isl_context *context,
 			struct isl_tab *tab);
 	/* return row index of "best" split */
@@ -108,11 +113,17 @@
 	/* invalidate context */
 	void (*invalidate)(struct isl_context *context);
 	/* free context */
-	void (*free)(struct isl_context *context);
+	__isl_null struct isl_context *(*free)(struct isl_context *context);
 };
 
+/* Shared parts of context representation.
+ *
+ * "n_unknown" is the number of final unknown integer divisions
+ * in the input domain.
+ */
 struct isl_context {
 	struct isl_context_op *op;
+	int n_unknown;
 };
 
 struct isl_context_lex {
@@ -122,16 +133,15 @@
 
 /* A stack (linked list) of solutions of subtrees of the search space.
  *
- * "M" describes the solution in terms of the dimensions of "dom".
- * The number of columns of "M" is one more than the total number
- * of dimensions of "dom".
+ * "ma" describes the solution as a function of "dom".
+ * In particular, the domain space of "ma" is equal to the space of "dom".
  *
- * If "M" is NULL, then there is no solution on "dom".
+ * If "ma" is NULL, then there is no solution on "dom".
  */
 struct isl_partial_sol {
 	int level;
 	struct isl_basic_set *dom;
-	struct isl_mat *M;
+	isl_multi_aff *ma;
 
 	struct isl_partial_sol *next;
 };
@@ -145,9 +155,21 @@
 /* isl_sol is an interface for constructing a solution to
  * a parametric integer linear programming problem.
  * Every time the algorithm reaches a state where a solution
- * can be read off from the tableau (including cases where the tableau
- * is empty), the function "add" is called on the isl_sol passed
- * to find_solutions_main.
+ * can be read off from the tableau, the function "add" is called
+ * on the isl_sol passed to find_solutions_main.  In a state where
+ * the tableau is empty, "add_empty" is called instead.
+ * "free" is called to free the implementation specific fields, if any.
+ *
+ * "error" is set if some error has occurred.  This flag invalidates
+ * the remainder of the data structure.
+ * If "rational" is set, then a rational optimization is being performed.
+ * "level" is the current level in the tree with nodes for each
+ * split in the context.
+ * If "max" is set, then a maximization problem is being solved, rather than
+ * a minimization problem, which means that the variables in the
+ * tableau have value "M - x" rather than "M + x".
+ * "n_out" is the number of output dimensions in the input.
+ * "space" is the space in which the solution (and also the input) lives.
  *
  * The context tableau is owned by isl_sol and is updated incrementally.
  *
@@ -155,19 +177,19 @@
  * isl_sol_map, which simply collects the solutions in an isl_map
  * and (optionally) the parts of the context where there is no solution
  * in an isl_set, and
- * isl_sol_for, which calls a user-defined function for each part of
- * the solution.
+ * isl_sol_pma, which collects an isl_pw_multi_aff instead.
  */
 struct isl_sol {
 	int error;
 	int rational;
 	int level;
 	int max;
-	int n_out;
+	isl_size n_out;
+	isl_space *space;
 	struct isl_context *context;
 	struct isl_partial_sol *partial;
 	void (*add)(struct isl_sol *sol,
-			    struct isl_basic_set *dom, struct isl_mat *M);
+		__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *ma);
 	void (*add_empty)(struct isl_sol *sol, struct isl_basic_set *bset);
 	void (*free)(struct isl_sol *sol);
 	struct isl_sol_callback	dec_level;
@@ -181,17 +203,23 @@
 	for (partial = sol->partial; partial; partial = next) {
 		next = partial->next;
 		isl_basic_set_free(partial->dom);
-		isl_mat_free(partial->M);
+		isl_multi_aff_free(partial->ma);
 		free(partial);
 	}
+	isl_space_free(sol->space);
+	if (sol->context)
+		sol->context->op->free(sol->context);
 	sol->free(sol);
+	free(sol);
 }
 
-/* Push a partial solution represented by a domain and mapping M
+/* Push a partial solution represented by a domain and function "ma"
  * onto the stack of partial solutions.
+ * If "ma" is NULL, then "dom" represents a part of the domain
+ * with no solution.
  */
 static void sol_push_sol(struct isl_sol *sol,
-	struct isl_basic_set *dom, struct isl_mat *M)
+	__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *ma)
 {
 	struct isl_partial_sol *partial;
 
@@ -204,7 +232,7 @@
 
 	partial->level = sol->level;
 	partial->dom = dom;
-	partial->M = M;
+	partial->ma = ma;
 	partial->next = sol->partial;
 
 	sol->partial = partial;
@@ -212,10 +240,120 @@
 	return;
 error:
 	isl_basic_set_free(dom);
-	isl_mat_free(M);
+	isl_multi_aff_free(ma);
 	sol->error = 1;
 }
 
+/* Check that the final columns of "M", starting at "first", are zero.
+ */
+static isl_stat check_final_columns_are_zero(__isl_keep isl_mat *M,
+	unsigned first)
+{
+	int i;
+	isl_size rows, cols;
+	unsigned n;
+
+	rows = isl_mat_rows(M);
+	cols = isl_mat_cols(M);
+	if (rows < 0 || cols < 0)
+		return isl_stat_error;
+	n = cols - first;
+	for (i = 0; i < rows; ++i)
+		if (isl_seq_first_non_zero(M->rowi + first, n) != -1)
+			isl_die(isl_mat_get_ctx(M), isl_error_internal,
+				"final columns should be zero",
+				return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Set the affine expressions in "ma" according to the rows in "M", which
+ * are defined over the local space "ls".
+ * The matrix "M" may have extra (zero) columns beyond the number
+ * of variables in "ls".
+ */
+static __isl_give isl_multi_aff *set_from_affine_matrix(
+	__isl_take isl_multi_aff *ma, __isl_take isl_local_space *ls,
+	__isl_take isl_mat *M)
+{
+	int i;
+	isl_size dim;
+	isl_aff *aff;
+
+	dim = isl_local_space_dim(ls, isl_dim_all);
+	if (!ma || dim < 0 || !M)
+		goto error;
+
+	if (check_final_columns_are_zero(M, 1 + dim) < 0)
+		goto error;
+	for (i = 1; i < M->n_row; ++i) {
+		aff = isl_aff_alloc(isl_local_space_copy(ls));
+		if (aff) {
+			isl_int_set(aff->v->el0, M->row00);
+			isl_seq_cpy(aff->v->el + 1, M->rowi, 1 + dim);
+		}
+		aff = isl_aff_normalize(aff);
+		ma = isl_multi_aff_set_aff(ma, i - 1, aff);
+	}
+	isl_local_space_free(ls);
+	isl_mat_free(M);
+
+	return ma;
+error:
+	isl_local_space_free(ls);
+	isl_mat_free(M);
+	isl_multi_aff_free(ma);
+	return NULL;
+}
+
+/* Push a partial solution represented by a domain and mapping M
+ * onto the stack of partial solutions.
+ *
+ * The affine matrix "M" maps the dimensions of the context
+ * to the output variables.  Convert it into an isl_multi_aff and
+ * then call sol_push_sol.
+ *
+ * Note that the description of the initial context may have involved
+ * existentially quantified variables, in which case they also appear
+ * in "dom".  These need to be removed before creating the affine
+ * expression because an affine expression cannot be defined in terms
+ * of existentially quantified variables without a known representation.
+ * Since newly added integer divisions are inserted before these
+ * existentially quantified variables, they are still in the final
+ * positions and the corresponding final columns of "M" are zero
+ * because align_context_divs adds the existentially quantified
+ * variables of the context to the main tableau without any constraints and
+ * any equality constraints that are added later on can only serve
+ * to eliminate these existentially quantified variables.
+ */
+static void sol_push_sol_mat(struct isl_sol *sol,
+	__isl_take isl_basic_set *dom, __isl_take isl_mat *M)
+{
+	isl_local_space *ls;
+	isl_multi_aff *ma;
+	isl_size n_div;
+	int n_known;
+
+	n_div = isl_basic_set_dim(dom, isl_dim_div);
+	if (n_div < 0)
+		goto error;
+	n_known = n_div - sol->context->n_unknown;
+
+	ma = isl_multi_aff_alloc(isl_space_copy(sol->space));
+	ls = isl_basic_set_get_local_space(dom);
+	ls = isl_local_space_drop_dims(ls, isl_dim_div,
+					n_known, n_div - n_known);
+	ma = set_from_affine_matrix(ma, ls, M);
+
+	if (!ma)
+		dom = isl_basic_set_free(dom);
+	sol_push_sol(sol, dom, ma);
+	return;
+error:
+	isl_basic_set_free(dom);
+	isl_mat_free(M);
+	sol_push_sol(sol, NULL, NULL);
+}
+
 /* Pop one partial solution from the partial solution stack and
  * pass it on to sol->add or sol->add_empty.
  */
@@ -226,8 +364,8 @@
 	partial = sol->partial;
 	sol->partial = partial->next;
 
-	if (partial->M)
-		sol->add(sol, partial->dom, partial->M);
+	if (partial->ma)
+		sol->add(sol, partial->dom, partial->ma);
 	else
 		sol->add_empty(sol, partial->dom);
 	free(partial);
@@ -249,33 +387,143 @@
 	return bset;
 }
 
-/* Check whether two partial solutions have the same mapping, where n_div
- * is the number of divs that the two partial solutions have in common.
+/* Check whether two partial solutions have the same affine expressions.
  */
-static int same_solution(struct isl_partial_sol *s1, struct isl_partial_sol *s2,
-	unsigned n_div)
+static isl_bool same_solution(struct isl_partial_sol *s1,
+	struct isl_partial_sol *s2)
 {
-	int i;
-	unsigned dim;
+	if (!s1->ma != !s2->ma)
+		return isl_bool_false;
+	if (!s1->ma)
+		return isl_bool_true;
 
-	if (!s1->M != !s2->M)
-		return 0;
-	if (!s1->M)
-		return 1;
+	return isl_multi_aff_plain_is_equal(s1->ma, s2->ma);
+}
 
-	dim = isl_basic_set_total_dim(s1->dom) - s1->dom->n_div;
+/* Swap the initial two partial solutions in "sol".
+ *
+ * That is, go from
+ *
+ *	sol->partial = p1; p1->next = p2; p2->next = p3
+ *
+ * to
+ *
+ *	sol->partial = p2; p2->next = p1; p1->next = p3
+ */
+static void swap_initial(struct isl_sol *sol)
+{
+	struct isl_partial_sol *partial;
 
-	for (i = 0; i < s1->M->n_row; ++i) {
-		if (isl_seq_first_non_zero(s1->M->rowi+1+dim+n_div,
-					    s1->M->n_col-1-dim-n_div) != -1)
-			return 0;
-		if (isl_seq_first_non_zero(s2->M->rowi+1+dim+n_div,
-					    s2->M->n_col-1-dim-n_div) != -1)
-			return 0;
-		if (!isl_seq_eq(s1->M->rowi, s2->M->rowi, 1+dim+n_div))
-			return 0;
+	partial = sol->partial;
+	sol->partial = partial->next;
+	partial->next = partial->next->next;
+	sol->partial->next = partial;
+}
+
+/* Combine the initial two partial solution of "sol" into
+ * a partial solution with the current context domain of "sol" and
+ * the function description of the second partial solution in the list.
+ * The level of the new partial solution is set to the current level.
+ *
+ * That is, the first two partial solutions (D1,M1) and (D2,M2) are
+ * replaced by (D,M2), where D is the domain of "sol", which is assumed
+ * to be the union of D1 and D2, while M1 is assumed to be equal to M2
+ * (at least on D1).
+ */
+static isl_stat combine_initial_into_second(struct isl_sol *sol)
+{
+	struct isl_partial_sol *partial;
+	isl_basic_set *bset;
+
+	partial = sol->partial;
+
+	bset = sol_domain(sol);
+	isl_basic_set_free(partial->next->dom);
+	partial->next->dom = bset;
+	partial->next->level = sol->level;
+
+	if (!bset)
+		return isl_stat_error;
+
+	sol->partial = partial->next;
+	isl_basic_set_free(partial->dom);
+	isl_multi_aff_free(partial->ma);
+	free(partial);
+
+	return isl_stat_ok;
+}
+
+/* Are "ma1" and "ma2" equal to each other on "dom"?
+ *
+ * Combine "ma1" and "ma2" with "dom" and check if the results are the same.
+ * "dom" may have existentially quantified variables.  Eliminate them first
+ * as otherwise they would have to be eliminated twice, in a more complicated
+ * context.
+ */
+static isl_bool equal_on_domain(__isl_keep isl_multi_aff *ma1,
+	__isl_keep isl_multi_aff *ma2, __isl_keep isl_basic_set *dom)
+{
+	isl_set *set;
+	isl_pw_multi_aff *pma1, *pma2;
+	isl_bool equal;
+
+	set = isl_basic_set_compute_divs(isl_basic_set_copy(dom));
+	pma1 = isl_pw_multi_aff_alloc(isl_set_copy(set),
+					isl_multi_aff_copy(ma1));
+	pma2 = isl_pw_multi_aff_alloc(set, isl_multi_aff_copy(ma2));
+	equal = isl_pw_multi_aff_is_equal(pma1, pma2);
+	isl_pw_multi_aff_free(pma1);
+	isl_pw_multi_aff_free(pma2);
+
+	return equal;
+}
+
+/* The initial two partial solutions of "sol" are known to be at
+ * the same level.
+ * If they represent the same solution (on different parts of the domain),
+ * then combine them into a single solution at the current level.
+ * Otherwise, pop them both.
+ *
+ * Even if the two partial solution are not obviously the same,
+ * one may still be a simplification of the other over its own domain.
+ * Also check if the two sets of affine functions are equal when
+ * restricted to one of the domains.  If so, combine the two
+ * using the set of affine functions on the other domain.
+ * That is, for two partial solutions (D1,M1) and (D2,M2),
+ * if M1 = M2 on D1, then the pair of partial solutions can
+ * be replaced by (D1+D2,M2) and similarly when M1 = M2 on D2.
+ */
+static isl_stat combine_initial_if_equal(struct isl_sol *sol)
+{
+	struct isl_partial_sol *partial;
+	isl_bool same;
+
+	partial = sol->partial;
+
+	same = same_solution(partial, partial->next);
+	if (same < 0)
+		return isl_stat_error;
+	if (same)
+		return combine_initial_into_second(sol);
+	if (partial->ma && partial->next->ma) {
+		same = equal_on_domain(partial->ma, partial->next->ma,
+					partial->dom);
+		if (same < 0)
+			return isl_stat_error;
+		if (same)
+			return combine_initial_into_second(sol);
+		same = equal_on_domain(partial->ma, partial->next->ma,
+					partial->next->dom);
+		if (same) {
+			swap_initial(sol);
+			return combine_initial_into_second(sol);
+		}
 	}
-	return 1;
+
+	sol_pop_one(sol);
+	sol_pop_one(sol);
+
+	return isl_stat_ok;
 }
 
 /* Pop all solutions from the partial solution stack that were pushed onto
@@ -284,66 +532,41 @@
  * and represent the same solution, then their domains are combined.
  * This combined domain is the same as the current context domain
  * as sol_pop is called each time we move back to a higher level.
+ * If the outer level (0) has been reached, then all partial solutions
+ * at the current level are also popped off.
  */
 static void sol_pop(struct isl_sol *sol)
 {
 	struct isl_partial_sol *partial;
-	unsigned n_div;
 
 	if (sol->error)
 		return;
 
-	if (sol->level == 0) {
+	partial = sol->partial;
+	if (!partial)
+		return;
+
+	if (partial->level == 0 && sol->level == 0) {
 		for (partial = sol->partial; partial; partial = sol->partial)
 			sol_pop_one(sol);
 		return;
 	}
 
-	partial = sol->partial;
-	if (!partial)
-		return;
-
 	if (partial->level <= sol->level)
 		return;
 
 	if (partial->next && partial->next->level == partial->level) {
-		n_div = isl_basic_set_dim(
-				sol->context->op->peek_basic_set(sol->context),
-				isl_dim_div);
-
-		if (!same_solution(partial, partial->next, n_div)) {
-			sol_pop_one(sol);
-			sol_pop_one(sol);
-		} else {
-			struct isl_basic_set *bset;
-			isl_mat *M;
-			unsigned n;
-
-			n = isl_basic_set_dim(partial->next->dom, isl_dim_div);
-			n -= n_div;
-			bset = sol_domain(sol);
-			isl_basic_set_free(partial->next->dom);
-			partial->next->dom = bset;
-			M = partial->next->M;
-			if (M) {
-				M = isl_mat_drop_cols(M, M->n_col - n, n);
-				partial->next->M = M;
-				if (!M)
-					goto error;
-			}
-			partial->next->level = sol->level;
-
-			if (!bset)
-				goto error;
-
-			sol->partial = partial->next;
-			isl_basic_set_free(partial->dom);
-			isl_mat_free(partial->M);
-			free(partial);
-		}
+		if (combine_initial_if_equal(sol) < 0)
+			goto error;
 	} else
 		sol_pop_one(sol);
 
+	if (sol->level == 0) {
+		for (partial = sol->partial; partial; partial = sol->partial)
+			sol_pop_one(sol);
+		return;
+	}
+
 	if (0)
 error:		sol->error = 1;
 }
@@ -358,13 +581,13 @@
 	sol_pop(sol);
 }
 
-static int sol_dec_level_wrap(struct isl_tab_callback *cb)
+static isl_stat sol_dec_level_wrap(struct isl_tab_callback *cb)
 {
 	struct isl_sol_callback *callback = (struct isl_sol_callback *)cb;
 
 	sol_dec_level(callback->sol);
 
-	return callback->sol->error ? -1 : 0;
+	return callback->sol->error ? isl_stat_error : isl_stat_ok;
 }
 
 /* Move down to next level and push callback onto context tableau
@@ -525,7 +748,7 @@
 
 	isl_int_clear(m);
 
-	sol_push_sol(sol, bset, mat);
+	sol_push_sol_mat(sol, bset, mat);
 	return;
 error2:
 	isl_int_clear(m);
@@ -541,20 +764,11 @@
 	struct isl_set	*empty;
 };
 
-static void sol_map_free(struct isl_sol_map *sol_map)
+static void sol_map_free(struct isl_sol *sol)
 {
-	if (!sol_map)
-		return;
-	if (sol_map->sol.context)
-		sol_map->sol.context->op->free(sol_map->sol.context);
+	struct isl_sol_map *sol_map = (struct isl_sol_map *) sol;
 	isl_map_free(sol_map->map);
 	isl_set_free(sol_map->empty);
-	free(sol_map);
-}
-
-static void sol_map_free_wrap(struct isl_sol *sol)
-{
-	sol_map_free((struct isl_sol_map *)sol);
 }
 
 /* This function is called for parts of the context where there is
@@ -564,9 +778,8 @@
 static void sol_map_add_empty(struct isl_sol_map *sol,
 	struct isl_basic_set *bset)
 {
-	if (!bset)
+	if (!bset || !sol->empty)
 		goto error;
-	isl_assert(bset->ctx, sol->empty, goto error);
 
 	sol->empty = isl_set_grow(sol->empty, 1);
 	bset = isl_basic_set_simplify(bset);
@@ -587,104 +800,35 @@
 	sol_map_add_empty((struct isl_sol_map *)sol, bset);
 }
 
-/* Given a basic map "dom" that represents the context and an affine
- * matrix "M" that maps the dimensions of the context to the
- * output variables, construct a basic map with the same parameters
- * and divs as the context, the dimensions of the context as input
- * dimensions and a number of output dimensions that is equal to
- * the number of output dimensions in the input map.
- *
- * The constraints and divs of the context are simply copied
- * from "dom".  For each row
- *	x = c + e(y)
- * an equality
- *	c + e(y) - d x = 0
- * is added, with d the common denominator of M.
+/* Given a basic set "dom" that represents the context and a tuple of
+ * affine expressions "ma" defined over this domain, construct a basic map
+ * that expresses this function on the domain.
  */
 static void sol_map_add(struct isl_sol_map *sol,
-	struct isl_basic_set *dom, struct isl_mat *M)
+	__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *ma)
 {
-	int i;
-	struct isl_basic_map *bmap = NULL;
-	unsigned n_eq;
-	unsigned n_ineq;
-	unsigned nparam;
-	unsigned total;
-	unsigned n_div;
-	unsigned n_out;
+	isl_basic_map *bmap;
 
-	if (sol->sol.error || !dom || !M)
+	if (sol->sol.error || !dom || !ma)
 		goto error;
 
-	n_out = sol->sol.n_out;
-	n_eq = dom->n_eq + n_out;
-	n_ineq = dom->n_ineq;
-	n_div = dom->n_div;
-	nparam = isl_basic_set_total_dim(dom) - n_div;
-	total = isl_map_dim(sol->map, isl_dim_all);
-	bmap = isl_basic_map_alloc_space(isl_map_get_space(sol->map),
-					n_div, n_eq, 2 * n_div + n_ineq);
-	if (!bmap)
-		goto error;
-	if (sol->sol.rational)
-		ISL_F_SET(bmap, ISL_BASIC_MAP_RATIONAL);
-	for (i = 0; i < dom->n_div; ++i) {
-		int k = isl_basic_map_alloc_div(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bmap->divk, dom->divi, 1 + 1 + nparam);
-		isl_seq_clr(bmap->divk + 1 + 1 + nparam, total - nparam);
-		isl_seq_cpy(bmap->divk + 1 + 1 + total,
-			    dom->divi + 1 + 1 + nparam, i);
-	}
-	for (i = 0; i < dom->n_eq; ++i) {
-		int k = isl_basic_map_alloc_equality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bmap->eqk, dom->eqi, 1 + nparam);
-		isl_seq_clr(bmap->eqk + 1 + nparam, total - nparam);
-		isl_seq_cpy(bmap->eqk + 1 + total,
-			    dom->eqi + 1 + nparam, n_div);
-	}
-	for (i = 0; i < dom->n_ineq; ++i) {
-		int k = isl_basic_map_alloc_inequality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bmap->ineqk, dom->ineqi, 1 + nparam);
-		isl_seq_clr(bmap->ineqk + 1 + nparam, total - nparam);
-		isl_seq_cpy(bmap->ineqk + 1 + total,
-			dom->ineqi + 1 + nparam, n_div);
-	}
-	for (i = 0; i < M->n_row - 1; ++i) {
-		int k = isl_basic_map_alloc_equality(bmap);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(bmap->eqk, M->row1 + i, 1 + nparam);
-		isl_seq_clr(bmap->eqk + 1 + nparam, n_out);
-		isl_int_neg(bmap->eqk1 + nparam + i, M->row00);
-		isl_seq_cpy(bmap->eqk + 1 + nparam + n_out,
-			    M->row1 + i + 1 + nparam, n_div);
-	}
-	bmap = isl_basic_map_simplify(bmap);
-	bmap = isl_basic_map_finalize(bmap);
+	bmap = isl_basic_map_from_multi_aff2(ma, sol->sol.rational);
+	bmap = isl_basic_map_intersect_domain(bmap, dom);
 	sol->map = isl_map_grow(sol->map, 1);
 	sol->map = isl_map_add_basic_map(sol->map, bmap);
-	isl_basic_set_free(dom);
-	isl_mat_free(M);
 	if (!sol->map)
 		sol->sol.error = 1;
 	return;
 error:
 	isl_basic_set_free(dom);
-	isl_mat_free(M);
-	isl_basic_map_free(bmap);
+	isl_multi_aff_free(ma);
 	sol->sol.error = 1;
 }
 
 static void sol_map_add_wrap(struct isl_sol *sol,
-	struct isl_basic_set *dom, struct isl_mat *M)
+	__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *ma)
 {
-	sol_map_add((struct isl_sol_map *)sol, dom, M);
+	sol_map_add((struct isl_sol_map *)sol, dom, ma);
 }
 
 
@@ -797,7 +941,8 @@
 	isl_seq_scale_down(div->el + 2, div->el + 2, ctx->normalize_gcd, len);
 }
 
-/* Return a integer division for use in a parametric cut based on the given row.
+/* Return an integer division for use in a parametric cut based
+ * on the given row.
  * In particular, let the parametric constant of the row be
  *
  *		\sum_i a_i y_i
@@ -824,7 +969,7 @@
 	return div;
 }
 
-/* Return a integer division for use in transferring an integrality constraint
+/* Return an integer division for use in transferring an integrality constraint
  * to the context.
  * In particular, let the parametric constant of the row be
  *
@@ -861,16 +1006,17 @@
  *
  *	m d <= e
  */
-static struct isl_vec *ineq_for_div(struct isl_basic_set *bset, unsigned div)
+static __isl_give isl_vec *ineq_for_div(__isl_keep isl_basic_set *bset,
+	unsigned div)
 {
-	unsigned total;
+	isl_size total;
 	unsigned div_pos;
 	struct isl_vec *ineq;
 
-	if (!bset)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
 		return NULL;
 
-	total = isl_basic_set_total_dim(bset);
 	div_pos = 1 + total - bset->n_div + div;
 
 	ineq = isl_vec_alloc(bset->ctx, 1 + total);
@@ -1028,7 +1174,7 @@
  * Pivoting with column c will increment the sample value by a non-negative
  * constant times a_{V,c}/a_{r,c}, with a_{V,c} the elements of column c
  * corresponding to the non-parametric variables.
- * If variable v appears in a column c_v, the a_{v,c} = 1 iff c = c_v,
+ * If variable v appears in a column c_v, then a_{v,c} = 1 iff c = c_v,
  * with all other entries in this virtual row equal to zero.
  * If variable v appears in a row, then a_{v,c} is the element in column c
  * of that row.
@@ -1081,6 +1227,37 @@
 	return -1;
 }
 
+/* Does the index into the tab->var or tab->con array "index"
+ * correspond to a variable in the context tableau?
+ * In particular, it needs to be an index into the tab->var array and
+ * it needs to refer to either one of the first tab->n_param variables or
+ * one of the last tab->n_div variables.
+ */
+static int is_parameter_var(struct isl_tab *tab, int index)
+{
+	if (index < 0)
+		return 0;
+	if (index < tab->n_param)
+		return 1;
+	if (index >= tab->n_var - tab->n_div)
+		return 1;
+	return 0;
+}
+
+/* Does column "col" of "tab" refer to a variable in the context tableau?
+ */
+static int col_is_parameter_var(struct isl_tab *tab, int col)
+{
+	return is_parameter_var(tab, tab->col_varcol);
+}
+
+/* Does row "row" of "tab" refer to a variable in the context tableau?
+ */
+static int row_is_parameter_var(struct isl_tab *tab, int row)
+{
+	return is_parameter_var(tab, tab->row_varrow);
+}
+
 /* Given a row in the tableau, find and return the column that would
  * result in the lexicographically smallest, but positive, increment
  * in the sample point.
@@ -1099,9 +1276,7 @@
 	isl_int_init(tmp);
 
 	for (j = tab->n_dead; j < tab->n_col; ++j) {
-		if (tab->col_varj >= 0 &&
-		    (tab->col_varj < tab->n_param  ||
-		    tab->col_varj >= tab->n_var - tab->n_div))
+		if (col_is_parameter_var(tab, j))
 			continue;
 
 		if (!isl_int_is_pos(trj))
@@ -1171,9 +1346,7 @@
 	int row;
 
 	for (col = tab->n_dead; col < tab->n_col; ++col) {
-		if (tab->col_varcol >= 0 &&
-		    (tab->col_varcol < tab->n_param ||
-		     tab->col_varcol >= tab->n_var - tab->n_div))
+		if (col_is_parameter_var(tab, col))
 			continue;
 		for (var = tab->n_param; var < tab->n_var - tab->n_div; ++var) {
 			if (!tab->varvar.is_row) {
@@ -1223,9 +1396,7 @@
 	tr = tab->mat->rowrow + 2 + tab->M;
 
 	for (j = tab->n_dead; j < tab->n_col; ++j) {
-		if (tab->col_varj >= 0 &&
-		    (tab->col_varj < tab->n_param  ||
-		    tab->col_varj >= tab->n_var - tab->n_div))
+		if (col_is_parameter_var(tab, j))
 			continue;
 
 		if (!isl_int_is_neg(trj))
@@ -1321,6 +1492,9 @@
  * If not, we add the equality as two inequalities.
  * In this case, the equality was a pure parameter equality and there
  * is no need to resolve any constraint violations.
+ *
+ * This function assumes that at least two more rows and at least
+ * two more elements in the constraint array are available in the tableau.
  */
 static struct isl_tab *add_lexmin_valid_eq(struct isl_tab *tab, isl_int *eq)
 {
@@ -1370,6 +1544,25 @@
 					tab->n_col - tab->n_dead) == -1;
 }
 
+/* Is the given row a parametric constant?
+ * That is, does it only involve variables that also appear in the context?
+ */
+static int is_parametric_constant(struct isl_tab *tab, int row)
+{
+	unsigned off = 2 + tab->M;
+	int col;
+
+	for (col = tab->n_dead; col < tab->n_col; ++col) {
+		if (col_is_parameter_var(tab, col))
+			continue;
+		if (isl_int_is_zero(tab->mat->rowrowoff + col))
+			continue;
+		return 0;
+	}
+
+	return 1;
+}
+
 /* Add an equality that may or may not be valid to the tableau.
  * If the resulting row is a pure constant, then it must be zero.
  * Otherwise, the resulting tableau is empty.
@@ -1378,6 +1571,9 @@
  * each time checking that they can be satisfied.
  * In the end we try to use one of the two constraints to eliminate
  * a column.
+ *
+ * This function assumes that at least two more rows and at least
+ * two more elements in the constraint array are available in the tableau.
  */
 static int add_lexmin_eq(struct isl_tab *tab, isl_int *eq) WARN_UNUSED;
 static int add_lexmin_eq(struct isl_tab *tab, isl_int *eq)
@@ -1454,6 +1650,9 @@
 
 /* Add an inequality to the tableau, resolving violations using
  * restore_lexmin.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
  */
 static struct isl_tab *add_lexmin_ineq(struct isl_tab *tab, isl_int *ineq)
 {
@@ -1528,9 +1727,7 @@
 	unsigned off = 2 + tab->M;
 
 	for (i = tab->n_dead; i < tab->n_col; ++i) {
-		if (tab->col_vari >= 0 &&
-		    (tab->col_vari < tab->n_param ||
-		     tab->col_vari >= tab->n_var - tab->n_div))
+		if (col_is_parameter_var(tab, i))
 			continue;
 		if (!isl_int_is_divisible_by(tab->mat->rowrowoff + i,
 						tab->mat->rowrow0))
@@ -1842,20 +2039,21 @@
 	return i < tab->n_sample;
 }
 
-/* Add a div specified by "div" to the tableau "tab" and return
- * 1 if the div is obviously non-negative.
+/* Insert a div specified by "div" to the tableau "tab" at position "pos" and
+ * return isl_bool_true if the div is obviously non-negative.
  */
-static int context_tab_add_div(struct isl_tab *tab, struct isl_vec *div,
-	int (*add_ineq)(void *user, isl_int *), void *user)
+static isl_bool context_tab_insert_div(struct isl_tab *tab, int pos,
+	__isl_keep isl_vec *div,
+	isl_stat (*add_ineq)(void *user, isl_int *), void *user)
 {
 	int i;
 	int r;
 	struct isl_mat *samples;
 	int nonneg;
 
-	r = isl_tab_add_div(tab, div, add_ineq, user);
+	r = isl_tab_insert_div(tab, pos, div, add_ineq, user);
 	if (r < 0)
-		return -1;
+		return isl_bool_error;
 	nonneg = tab->varr.is_nonneg;
 	tab->varr.frozen = 1;
 
@@ -1863,15 +2061,19 @@
 			tab->n_sample, 1 + tab->n_var);
 	tab->samples = samples;
 	if (!samples)
-		return -1;
+		return isl_bool_error;
 	for (i = tab->n_outside; i < samples->n_row; ++i) {
 		isl_seq_inner_product(div->el + 1, samples->rowi,
 			div->size - 1, &samples->rowisamples->n_col - 1);
 		isl_int_fdiv_q(samples->rowisamples->n_col - 1,
 			       samples->rowisamples->n_col - 1, div->el0);
 	}
+	tab->samples = isl_mat_move_cols(tab->samples, 1 + pos,
+					1 + tab->n_var - 1, 1);
+	if (!tab->samples)
+		return isl_bool_error;
 
-	return nonneg;
+	return isl_bool_ok(nonneg);
 }
 
 /* Add a div specified by "div" to both the main tableau and
@@ -1879,22 +2081,34 @@
  * need to add an extra div.  In the context tableau, we also
  * need to express the meaning of the div.
  * Return the index of the div or -1 if anything went wrong.
+ *
+ * The new integer division is added before any unknown integer
+ * divisions in the context to ensure that it does not get
+ * equated to some linear combination involving unknown integer
+ * divisions.
  */
 static int add_div(struct isl_tab *tab, struct isl_context *context,
-	struct isl_vec *div)
+	__isl_keep isl_vec *div)
 {
 	int r;
-	int nonneg;
+	int pos;
+	isl_bool nonneg;
+	struct isl_tab *context_tab = context->op->peek_tab(context);
+
+	if (!tab || !context_tab)
+		goto error;
 
-	if ((nonneg = context->op->add_div(context, div)) < 0)
+	pos = context_tab->n_var - context->n_unknown;
+	if ((nonneg = context->op->insert_div(context, pos, div)) < 0)
 		goto error;
 
 	if (!context->op->is_ok(context))
 		goto error;
 
+	pos = tab->n_var - context->n_unknown;
 	if (isl_tab_extend_vars(tab, 1) < 0)
 		goto error;
-	r = isl_tab_allocate_var(tab);
+	r = isl_tab_insert_var(tab, pos);
 	if (r < 0)
 		goto error;
 	if (nonneg)
@@ -1902,25 +2116,32 @@
 	tab->varr.frozen = 1;
 	tab->n_div++;
 
-	return tab->n_div - 1;
+	return tab->n_div - 1 - context->n_unknown;
 error:
 	context->op->invalidate(context);
 	return -1;
 }
 
+/* Return the position of the integer division that is equal to div/denom
+ * if there is one.  Otherwise, return a position beyond the integer divisions.
+ */
 static int find_div(struct isl_tab *tab, isl_int *div, isl_int denom)
 {
 	int i;
-	unsigned total = isl_basic_map_total_dim(tab->bmap);
+	isl_size total = isl_basic_map_dim(tab->bmap, isl_dim_all);
+	isl_size n_div;
 
-	for (i = 0; i < tab->bmap->n_div; ++i) {
+	n_div = isl_basic_map_dim(tab->bmap, isl_dim_div);
+	if (total < 0 || n_div < 0)
+		return -1;
+	for (i = 0; i < n_div; ++i) {
 		if (isl_int_ne(tab->bmap->divi0, denom))
 			continue;
 		if (!isl_seq_eq(tab->bmap->divi + 1, div, 1 + total))
 			continue;
 		return i;
 	}
-	return -1;
+	return n_div;
 }
 
 /* Return the index of a div that corresponds to "div".
@@ -1931,19 +2152,23 @@
 {
 	int d;
 	struct isl_tab *context_tab = context->op->peek_tab(context);
+	unsigned n_div;
 
 	if (!context_tab)
 		return -1;
 
+	n_div = isl_basic_map_dim(context_tab->bmap, isl_dim_div);
 	d = find_div(context_tab, div->el + 1, div->el0);
-	if (d != -1)
+	if (d < 0)
+		return -1;
+	if (d < n_div)
 		return d;
 
 	return add_div(tab, context, div);
 }
 
 /* Add a parametric cut to cut away the non-integral sample value
- * of the give row.
+ * of the given row.
  * Let a_i be the coefficients of the constant term and the parameters
  * and let b_i be the coefficients of the variables or constraints
  * in basis of the tableau.
@@ -1984,7 +2209,7 @@
 	if (!div)
 		return -1;
 
-	n = tab->n_div;
+	n = tab->n_div - context->n_unknown;
 	d = context->op->get_div(context, tab, div);
 	isl_vec_free(div);
 	if (d < 0)
@@ -2072,22 +2297,30 @@
  * of the variables in all constraints are negated prior to adding them
  * to the tableau.
  */
-static struct isl_tab *tab_for_lexmin(struct isl_basic_map *bmap,
-	struct isl_basic_set *dom, unsigned M, int max)
+static __isl_give struct isl_tab *tab_for_lexmin(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *dom, unsigned M, int max)
 {
 	int i;
 	struct isl_tab *tab;
 	unsigned n_var;
 	unsigned o_var;
+	isl_size total;
 
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return NULL;
 	tab = isl_tab_alloc(bmap->ctx, 2 * bmap->n_eq + bmap->n_ineq + 1,
-			    isl_basic_map_total_dim(bmap), M);
+			    total, M);
 	if (!tab)
 		return NULL;
 
 	tab->rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
 	if (dom) {
-		tab->n_param = isl_basic_set_total_dim(dom) - dom->n_div;
+		isl_size dom_total;
+		dom_total = isl_basic_set_dim(dom, isl_dim_all);
+		if (dom_total < 0)
+			goto error;
+		tab->n_param = dom_total - dom->n_div;
 		tab->n_div = dom->n_div;
 		tab->row_sign = isl_calloc_array(bmap->ctx,
 					enum isl_tab_row_sign, tab->mat->n_row);
@@ -2139,10 +2372,16 @@
 /* Given a main tableau where more than one row requires a split,
  * determine and return the "best" row to split on.
  *
- * Given two rows in the main tableau, if the inequality corresponding
+ * If any of the rows requiring a split only involves
+ * variables that also appear in the context tableau,
+ * then the negative part is guaranteed not to have a solution.
+ * It is therefore best to split on any of these rows first.
+ *
+ * Otherwise,
+ * given two rows in the main tableau, if the inequality corresponding
  * to the first row is redundant with respect to that of the second row
  * in the current tableau, then it is better to split on the second row,
- * since in the positive part, both row will be positive.
+ * since in the positive part, both rows will be positive.
  * (In the negative part a pivot will have to be performed and just about
  * anything can happen to the sign of the other row.)
  *
@@ -2183,6 +2422,9 @@
 		if (tab->row_signsplit != isl_tab_row_any)
 			continue;
 
+		if (is_parametric_constant(tab, split))
+			return split;
+
 		ineq = get_row_parameter_ineq(tab, split);
 		if (!ineq)
 			return -1;
@@ -2288,11 +2530,11 @@
 	clex->tab = NULL;
 }
 
-static int context_lex_add_ineq_wrap(void *user, isl_int *ineq)
+static isl_stat context_lex_add_ineq_wrap(void *user, isl_int *ineq)
 {
 	struct isl_context *context = (struct isl_context *)user;
 	context_lex_add_ineq(context, ineq, 0, 0);
-	return context->op->is_ok(context) ? 0 : -1;
+	return context->op->is_ok(context) ? isl_stat_ok : isl_stat_error;
 }
 
 /* Check which signs can be obtained by "ineq" on all the currently
@@ -2377,24 +2619,25 @@
 	return get_div(tab, context, div);
 }
 
-/* Add a div specified by "div" to the context tableau and return
- * 1 if the div is obviously non-negative.
- * context_tab_add_div will always return 1, because all variables
+/* Insert a div specified by "div" to the context tableau at position "pos" and
+ * return isl_bool_true if the div is obviously non-negative.
+ * context_tab_add_div will always return isl_bool_true, because all variables
  * in a isl_context_lex tableau are non-negative.
  * However, if we are using a big parameter in the context, then this only
  * reflects the non-negativity of the variable used to _encode_ the
  * div, i.e., div' = M + div, so we can't draw any conclusions.
  */
-static int context_lex_add_div(struct isl_context *context, struct isl_vec *div)
+static isl_bool context_lex_insert_div(struct isl_context *context, int pos,
+	__isl_keep isl_vec *div)
 {
 	struct isl_context_lex *clex = (struct isl_context_lex *)context;
-	int nonneg;
-	nonneg = context_tab_add_div(clex->tab, div,
+	isl_bool nonneg;
+	nonneg = context_tab_insert_div(clex->tab, pos, div,
 					context_lex_add_ineq_wrap, context);
 	if (nonneg < 0)
-		return -1;
+		return isl_bool_error;
 	if (clex->tab->M)
-		return 0;
+		return isl_bool_false;
 	return nonneg;
 }
 
@@ -2553,11 +2796,14 @@
 	clex->tab = NULL;
 }
 
-static void context_lex_free(struct isl_context *context)
+static __isl_null struct isl_context *context_lex_free(
+	struct isl_context *context)
 {
 	struct isl_context_lex *clex = (struct isl_context_lex *)context;
 	isl_tab_free(clex->tab);
 	free(clex);
+
+	return NULL;
 }
 
 struct isl_context_op isl_context_lex_op = {
@@ -2569,7 +2815,7 @@
 	context_lex_ineq_sign,
 	context_lex_test_ineq,
 	context_lex_get_div,
-	context_lex_add_div,
+	context_lex_insert_div,
 	context_lex_detect_equalities,
 	context_lex_best_split,
 	context_lex_is_empty,
@@ -2581,21 +2827,19 @@
 	context_lex_free,
 };
 
-static struct isl_tab *context_tab_for_lexmin(struct isl_basic_set *bset)
+static struct isl_tab *context_tab_for_lexmin(__isl_take isl_basic_set *bset)
 {
 	struct isl_tab *tab;
 
 	if (!bset)
 		return NULL;
-	tab = tab_for_lexmin((struct isl_basic_map *)bset, NULL, 1, 0);
-	if (!tab)
-		goto error;
+	tab = tab_for_lexmin(bset_to_bmap(bset), NULL, 1, 0);
 	if (isl_tab_track_bset(tab, bset) < 0)
 		goto error;
 	tab = isl_tab_init_samples(tab);
 	return tab;
 error:
-	isl_basic_set_free(bset);
+	isl_tab_free(tab);
 	return NULL;
 }
 
@@ -2675,8 +2919,10 @@
 	int i, j;
 	struct isl_vec *cst;
 	struct isl_basic_set *bset = isl_tab_peek_bset(cgbr->tab);
-	unsigned dim = isl_basic_set_total_dim(bset);
+	isl_size dim = isl_basic_set_dim(bset, isl_dim_all);
 
+	if (dim < 0)
+		return;
 	cst = isl_vec_alloc(cgbr->tab->mat->ctx, bset->n_ineq);
 	if (!cst)
 		return;
@@ -2720,7 +2966,8 @@
 	return sample;
 }
 
-static struct isl_basic_set *drop_constant_terms(struct isl_basic_set *bset)
+static __isl_give isl_basic_set *drop_constant_terms(
+	__isl_take isl_basic_set *bset)
 {
 	int i;
 
@@ -2790,7 +3037,7 @@
 
 		sample = isl_tab_sample(cgbr->tab);
 
-		if (isl_tab_rollback(cgbr->tab, snap) < 0) {
+		if (!sample || isl_tab_rollback(cgbr->tab, snap) < 0) {
 			isl_vec_free(sample);
 			return NULL;
 		}
@@ -2915,8 +3162,10 @@
 
 	if (cgbr->shifted && !cgbr->shifted->empty && use_shifted(cgbr)) {
 		int i;
-		unsigned dim;
-		dim = isl_basic_map_total_dim(cgbr->tab->bmap);
+		isl_size dim;
+		dim = isl_basic_map_dim(cgbr->tab->bmap, isl_dim_all);
+		if (dim < 0)
+			goto error;
 
 		if (isl_tab_extend_cons(cgbr->shifted, 1) < 0)
 			goto error;
@@ -2974,11 +3223,11 @@
 	cgbr->tab = NULL;
 }
 
-static int context_gbr_add_ineq_wrap(void *user, isl_int *ineq)
+static isl_stat context_gbr_add_ineq_wrap(void *user, isl_int *ineq)
 {
 	struct isl_context *context = (struct isl_context *)user;
 	context_gbr_add_ineq(context, ineq, 0, 0);
-	return context->op->is_ok(context) ? 0 : -1;
+	return context->op->is_ok(context) ? isl_stat_ok : isl_stat_error;
 }
 
 static enum isl_tab_row_sign context_gbr_ineq_sign(struct isl_context *context,
@@ -3072,6 +3321,9 @@
  * that is one or negative one, we use it to kill a column
  * in the main tableau.  Otherwise, we discard the tentatively
  * added row.
+ * This tentative addition of equality constraints turns
+ * on the undo facility of the tableau.  Turn it off again
+ * at the end, assuming it was turned off to begin with.
  *
  * Return 0 on success and -1 on failure.
  */
@@ -3080,7 +3332,11 @@
 {
 	int i;
 	struct isl_vec *eq = NULL;
+	isl_bool needs_undo;
 
+	needs_undo = isl_tab_need_undo(tab);
+	if (needs_undo < 0)
+		goto error;
 	eq = isl_vec_alloc(tab->mat->ctx, 1 + tab->n_var);
 	if (!eq)
 		goto error;
@@ -3123,6 +3379,8 @@
 			goto error;
 	}
 
+	if (!needs_undo)
+		isl_tab_clear_undo(tab);
 	isl_vec_free(eq);
 
 	return 0;
@@ -3137,11 +3395,8 @@
 	struct isl_tab *tab)
 {
 	struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
-	struct isl_ctx *ctx;
 	unsigned n_ineq;
 
-	ctx = cgbr->tab->mat->ctx;
-
 	if (!cgbr->cone) {
 		struct isl_basic_set *bset = isl_tab_peek_bset(cgbr->tab);
 		cgbr->cone = isl_tab_from_recession_cone(bset, 0);
@@ -3175,29 +3430,35 @@
 	return get_div(tab, context, div);
 }
 
-static int context_gbr_add_div(struct isl_context *context, struct isl_vec *div)
+static isl_bool context_gbr_insert_div(struct isl_context *context, int pos,
+	__isl_keep isl_vec *div)
 {
 	struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
 	if (cgbr->cone) {
-		int k;
+		int r, o_div;
+		isl_size n_div;
+
+		n_div = isl_basic_map_dim(cgbr->cone->bmap, isl_dim_div);
+		if (n_div < 0)
+			return isl_bool_error;
+		o_div = cgbr->cone->n_var - n_div;
 
 		if (isl_tab_extend_cons(cgbr->cone, 3) < 0)
-			return -1;
+			return isl_bool_error;
 		if (isl_tab_extend_vars(cgbr->cone, 1) < 0)
-			return -1;
-		if (isl_tab_allocate_var(cgbr->cone) <0)
-			return -1;
-
-		cgbr->cone->bmap = isl_basic_map_extend_space(cgbr->cone->bmap,
-			isl_basic_map_get_space(cgbr->cone->bmap), 1, 0, 2);
-		k = isl_basic_map_alloc_div(cgbr->cone->bmap);
-		if (k < 0)
-			return -1;
-		isl_seq_cpy(cgbr->cone->bmap->divk, div->el, div->size);
-		if (isl_tab_push(cgbr->cone, isl_tab_undo_bmap_div) < 0)
-			return -1;
+			return isl_bool_error;
+		if ((r = isl_tab_insert_var(cgbr->cone, pos)) <0)
+			return isl_bool_error;
+
+		cgbr->cone->bmap = isl_basic_map_insert_div(cgbr->cone->bmap,
+						    r - o_div, div);
+		if (!cgbr->cone->bmap)
+			return isl_bool_error;
+		if (isl_tab_push_var(cgbr->cone, isl_tab_undo_bmap_div,
+				    &cgbr->cone->varr) < 0)
+			return isl_bool_error;
 	}
-	return context_tab_add_div(cgbr->tab, div,
+	return context_tab_insert_div(cgbr->tab, pos, div,
 					context_gbr_add_ineq_wrap, context);
 }
 
@@ -3269,10 +3530,8 @@
 	struct isl_gbr_tab_undo *snap = (struct isl_gbr_tab_undo *)save;
 	if (!snap)
 		goto error;
-	if (isl_tab_rollback(cgbr->tab, snap->tab_snap) < 0) {
-		isl_tab_free(cgbr->tab);
-		cgbr->tab = NULL;
-	}
+	if (isl_tab_rollback(cgbr->tab, snap->tab_snap) < 0)
+		goto error;
 
 	if (snap->shifted_snap) {
 		if (isl_tab_rollback(cgbr->shifted, snap->shifted_snap) < 0)
@@ -3318,13 +3577,16 @@
 	cgbr->tab = NULL;
 }
 
-static void context_gbr_free(struct isl_context *context)
+static __isl_null struct isl_context *context_gbr_free(
+	struct isl_context *context)
 {
 	struct isl_context_gbr *cgbr = (struct isl_context_gbr *)context;
 	isl_tab_free(cgbr->tab);
 	isl_tab_free(cgbr->shifted);
 	isl_tab_free(cgbr->cone);
 	free(cgbr);
+
+	return NULL;
 }
 
 struct isl_context_op isl_context_gbr_op = {
@@ -3336,7 +3598,7 @@
 	context_gbr_ineq_sign,
 	context_gbr_test_ineq,
 	context_gbr_get_div,
-	context_gbr_add_div,
+	context_gbr_insert_div,
 	context_gbr_detect_equalities,
 	context_gbr_best_split,
 	context_gbr_is_empty,
@@ -3348,7 +3610,7 @@
 	context_gbr_free,
 };
 
-static struct isl_context *isl_context_gbr_alloc(struct isl_basic_set *dom)
+static struct isl_context *isl_context_gbr_alloc(__isl_keep isl_basic_set *dom)
 {
 	struct isl_context_gbr *cgbr;
 
@@ -3375,15 +3637,60 @@
 	return NULL;
 }
 
-static struct isl_context *isl_context_alloc(struct isl_basic_set *dom)
+/* Allocate a context corresponding to "dom".
+ * The representation specific fields are initialized by
+ * isl_context_lex_alloc or isl_context_gbr_alloc.
+ * The shared "n_unknown" field is initialized to the number
+ * of final unknown integer divisions in "dom".
+ */
+static struct isl_context *isl_context_alloc(__isl_keep isl_basic_set *dom)
 {
+	struct isl_context *context;
+	int first;
+	isl_size n_div;
+
 	if (!dom)
 		return NULL;
 
 	if (dom->ctx->opt->context == ISL_CONTEXT_LEXMIN)
-		return isl_context_lex_alloc(dom);
+		context = isl_context_lex_alloc(dom);
 	else
-		return isl_context_gbr_alloc(dom);
+		context = isl_context_gbr_alloc(dom);
+
+	if (!context)
+		return NULL;
+
+	first = isl_basic_set_first_unknown_div(dom);
+	n_div = isl_basic_set_dim(dom, isl_dim_div);
+	if (first < 0 || n_div < 0)
+		return context->op->free(context);
+	context->n_unknown = n_div - first;
+
+	return context;
+}
+
+/* Initialize some common fields of "sol", which keeps track
+ * of the solution of an optimization problem on "bmap" over
+ * the domain "dom".
+ * If "max" is set, then a maximization problem is being solved, rather than
+ * a minimization problem, which means that the variables in the
+ * tableau have value "M - x" rather than "M + x".
+ */
+static isl_stat sol_init(struct isl_sol *sol, __isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *dom, int max)
+{
+	sol->rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
+	sol->dec_level.callback.run = &sol_dec_level_wrap;
+	sol->dec_level.sol = sol;
+	sol->max = max;
+	sol->n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	sol->space = isl_basic_map_get_space(bmap);
+
+	sol->context = isl_context_alloc(dom);
+	if (sol->n_out < 0 || !sol->space || !sol->context)
+		return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
 /* Construct an isl_sol_map structure for accumulating the solution.
@@ -3393,10 +3700,11 @@
  * a minimization problem, which means that the variables in the
  * tableau have value "M - x" rather than "M + x".
  */
-static struct isl_sol *sol_map_init(struct isl_basic_map *bmap,
-	struct isl_basic_set *dom, int track_empty, int max)
+static struct isl_sol *sol_map_init(__isl_keep isl_basic_map *bmap,
+	__isl_take isl_basic_set *dom, int track_empty, int max)
 {
 	struct isl_sol_map *sol_map = NULL;
+	isl_space *space;
 
 	if (!bmap)
 		goto error;
@@ -3405,23 +3713,16 @@
 	if (!sol_map)
 		goto error;
 
-	sol_map->sol.rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
-	sol_map->sol.dec_level.callback.run = &sol_dec_level_wrap;
-	sol_map->sol.dec_level.sol = &sol_map->sol;
-	sol_map->sol.max = max;
-	sol_map->sol.n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	sol_map->sol.free = &sol_map_free;
+	if (sol_init(&sol_map->sol, bmap, dom, max) < 0)
+		goto error;
 	sol_map->sol.add = &sol_map_add_wrap;
 	sol_map->sol.add_empty = track_empty ? &sol_map_add_empty_wrap : NULL;
-	sol_map->sol.free = &sol_map_free_wrap;
-	sol_map->map = isl_map_alloc_space(isl_basic_map_get_space(bmap), 1,
-					    ISL_MAP_DISJOINT);
+	space = isl_space_copy(sol_map->sol.space);
+	sol_map->map = isl_map_alloc_space(space, 1, ISL_MAP_DISJOINT);
 	if (!sol_map->map)
 		goto error;
 
-	sol_map->sol.context = isl_context_alloc(dom);
-	if (!sol_map->sol.context)
-		goto error;
-
 	if (track_empty) {
 		sol_map->empty = isl_set_alloc_space(isl_basic_set_get_space(dom),
 							1, ISL_SET_DISJOINT);
@@ -3433,7 +3734,7 @@
 	return &sol_map->sol;
 error:
 	isl_basic_set_free(dom);
-	sol_map_free(sol_map);
+	sol_free(&sol_map->sol);
 	return NULL;
 }
 
@@ -3446,9 +3747,7 @@
 	unsigned off = 2 + tab->M;
 
 	for (j = tab->n_dead; j < tab->n_col; ++j) {
-		if (tab->col_varj >= 0 &&
-		    (tab->col_varj < tab->n_param  ||
-		    tab->col_varj >= tab->n_var - tab->n_div))
+		if (col_is_parameter_var(tab, j))
 			continue;
 
 		if (isl_int_is_pos(tab->mat->rowrowoff + j))
@@ -3681,6 +3980,21 @@
 	sol->error = 1;
 }
 
+/* Reset all row variables that are marked to have a sign that may
+ * be both positive and negative to have an unknown sign.
+ */
+static void reset_any_to_unknown(struct isl_tab *tab)
+{
+	int row;
+
+	for (row = tab->n_redundant; row < tab->n_row; ++row) {
+		if (!isl_tab_var_from_row(tab, row)->is_nonneg)
+			continue;
+		if (tab->row_signrow == isl_tab_row_any)
+			tab->row_signrow = isl_tab_row_unknown;
+	}
+}
+
 /* Compute the lexicographic minimum of the set represented by the main
  * tableau "tab" within the context "sol->context_tab".
  * On entry the sample value of the main tableau is lexicographically
@@ -3823,17 +4137,11 @@
 			if (!ineq)
 				goto error;
 			is_strict(ineq);
-			for (row = tab->n_redundant; row < tab->n_row; ++row) {
-				if (!isl_tab_var_from_row(tab, row)->is_nonneg)
-					continue;
-				if (tab->row_signrow == isl_tab_row_any)
-					tab->row_signrow = isl_tab_row_unknown;
-			}
+			reset_any_to_unknown(tab);
 			tab->row_signsplit = isl_tab_row_pos;
 			sol_inc_level(sol);
 			find_in_pos(sol, tab, ineq->el);
 			tab->row_signsplit = isl_tab_row_neg;
-			row = split;
 			isl_seq_neg(ineq->el, ineq->el, ineq->size);
 			isl_int_sub_ui(ineq->el0, ineq->el0, 1);
 			if (!sol->error)
@@ -3947,10 +4255,7 @@
 		int p;
 		struct isl_vec *eq;
 
-		if (tab->row_varrow < 0)
-			continue;
-		if (tab->row_varrow >= tab->n_param &&
-		    tab->row_varrow < tab->n_var - tab->n_div)
+		if (!row_is_parameter_var(tab, row))
 			continue;
 		if (tab->row_varrow < tab->n_param)
 			p = tab->row_varrow;
@@ -4006,30 +4311,37 @@
 
 /* Check if integer division "div" of "dom" also occurs in "bmap".
  * If so, return its position within the divs.
- * If not, return -1.
+ * Otherwise, return a position beyond the integer divisions.
  */
-static int find_context_div(struct isl_basic_map *bmap,
-	struct isl_basic_set *dom, unsigned div)
+static int find_context_div(__isl_keep isl_basic_map *bmap,
+	__isl_keep isl_basic_set *dom, unsigned div)
 {
 	int i;
-	unsigned b_dim = isl_space_dim(bmap->dim, isl_dim_all);
-	unsigned d_dim = isl_space_dim(dom->dim, isl_dim_all);
+	isl_size b_v_div, d_v_div;
+	isl_size n_div;
 
-	if (isl_int_is_zero(dom->divdiv0))
-		return -1;
-	if (isl_seq_first_non_zero(dom->divdiv + 2 + d_dim, dom->n_div) != -1)
+	b_v_div = isl_basic_map_var_offset(bmap, isl_dim_div);
+	d_v_div = isl_basic_set_var_offset(dom, isl_dim_div);
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (b_v_div < 0 || d_v_div < 0 || n_div < 0)
 		return -1;
 
-	for (i = 0; i < bmap->n_div; ++i) {
+	if (isl_int_is_zero(dom->divdiv0))
+		return n_div;
+	if (isl_seq_first_non_zero(dom->divdiv + 2 + d_v_div,
+				    dom->n_div) != -1)
+		return n_div;
+
+	for (i = 0; i < n_div; ++i) {
 		if (isl_int_is_zero(bmap->divi0))
 			continue;
-		if (isl_seq_first_non_zero(bmap->divi + 2 + d_dim,
-					   (b_dim - d_dim) + bmap->n_div) != -1)
+		if (isl_seq_first_non_zero(bmap->divi + 2 + d_v_div,
+					   (b_v_div - d_v_div) + n_div) != -1)
 			continue;
-		if (isl_seq_eq(bmap->divi, dom->divdiv, 2 + d_dim))
+		if (isl_seq_eq(bmap->divi, dom->divdiv, 2 + d_v_div))
 			return i;
 	}
-	return -1;
+	return n_div;
 }
 
 /* The correspondence between the variables in the main tableau,
@@ -4046,33 +4358,45 @@
  * after any other integer divisions that the map may have.
  * This function performs the required reordering.
  */
-static struct isl_basic_map *align_context_divs(struct isl_basic_map *bmap,
-	struct isl_basic_set *dom)
+static __isl_give isl_basic_map *align_context_divs(
+	__isl_take isl_basic_map *bmap, __isl_keep isl_basic_set *dom)
 {
 	int i;
 	int common = 0;
 	int other;
+	unsigned bmap_n_div;
+
+	bmap_n_div = isl_basic_map_dim(bmap, isl_dim_div);
 
-	for (i = 0; i < dom->n_div; ++i)
-		if (find_context_div(bmap, dom, i) != -1)
+	for (i = 0; i < dom->n_div; ++i) {
+		int pos;
+
+		pos = find_context_div(bmap, dom, i);
+		if (pos < 0)
+			return isl_basic_map_free(bmap);
+		if (pos < bmap_n_div)
 			common++;
-	other = bmap->n_div - common;
+	}
+	other = bmap_n_div - common;
 	if (dom->n_div - common > 0) {
-		bmap = isl_basic_map_extend_space(bmap, isl_space_copy(bmap->dim),
-				dom->n_div - common, 0, 0);
+		bmap = isl_basic_map_cow(bmap);
+		bmap = isl_basic_map_extend(bmap, dom->n_div - common, 0, 0);
 		if (!bmap)
 			return NULL;
 	}
 	for (i = 0; i < dom->n_div; ++i) {
 		int pos = find_context_div(bmap, dom, i);
-		if (pos < 0) {
+		if (pos < 0)
+			bmap = isl_basic_map_free(bmap);
+		if (pos >= bmap_n_div) {
 			pos = isl_basic_map_alloc_div(bmap);
 			if (pos < 0)
 				goto error;
 			isl_int_set_si(bmap->divpos0, 0);
+			bmap_n_div++;
 		}
 		if (pos != other + i)
-			isl_basic_map_swap_div(bmap, pos, other + i);
+			bmap = isl_basic_map_swap_div(bmap, pos, other + i);
 	}
 	return bmap;
 error:
@@ -4086,8 +4410,13 @@
  * We make sure the divs in the domain are properly ordered,
  * because they will be added one by one in the given order
  * during the construction of the solution map.
+ * Furthermore, make sure that the known integer divisions
+ * appear before any unknown integer division because the solution
+ * may depend on the known integer divisions, while anything that
+ * depends on any variable starting from the first unknown integer
+ * division is ignored in sol_pma_add.
  */
-static struct isl_sol *basic_map_partial_lexopt_base(
+static struct isl_sol *basic_map_partial_lexopt_base_sol(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max,
 	struct isl_sol *(*init)(__isl_keep isl_basic_map *bmap,
@@ -4098,7 +4427,7 @@
 	struct isl_context *context;
 
 	if (dom->n_div) {
-		dom = isl_basic_set_order_divs(dom);
+		dom = isl_basic_set_sort_divs(dom);
 		bmap = align_context_divs(bmap, dom);
 	}
 	sol = init(bmap, dom, !!empty, max);
@@ -4132,9 +4461,9 @@
 /* Base case of isl_tab_basic_map_partial_lexopt, after removing
  * some obvious symmetries.
  *
- * We call basic_map_partial_lexopt_base and extract the results.
+ * We call basic_map_partial_lexopt_base_sol and extract the results.
  */
-static __isl_give isl_map *basic_map_partial_lexopt_base_map(
+static __isl_give isl_map *basic_map_partial_lexopt_base(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max)
 {
@@ -4142,8 +4471,8 @@
 	struct isl_sol *sol;
 	struct isl_sol_map *sol_map;
 
-	sol = basic_map_partial_lexopt_base(bmap, dom, empty, max,
-					    &sol_map_init);
+	sol = basic_map_partial_lexopt_base_sol(bmap, dom, empty, max,
+						&sol_map_init);
 	if (!sol)
 		return NULL;
 	sol_map = (struct isl_sol_map *) sol;
@@ -4155,13 +4484,80 @@
 	return result;
 }
 
+/* Return a count of the number of occurrences of the "n" first
+ * variables in the inequality constraints of "bmap".
+ */
+static __isl_give int *count_occurrences(__isl_keep isl_basic_map *bmap,
+	int n)
+{
+	int i, j;
+	isl_ctx *ctx;
+	int *occurrences;
+
+	if (!bmap)
+		return NULL;
+	ctx = isl_basic_map_get_ctx(bmap);
+	occurrences = isl_calloc_array(ctx, int, n);
+	if (!occurrences)
+		return NULL;
+
+	for (i = 0; i < bmap->n_ineq; ++i) {
+		for (j = 0; j < n; ++j) {
+			if (!isl_int_is_zero(bmap->ineqi1 + j))
+				occurrencesj++;
+		}
+	}
+
+	return occurrences;
+}
+
+/* Do all of the "n" variables with non-zero coefficients in "c"
+ * occur in exactly a single constraint.
+ * "occurrences" is an array of length "n" containing the number
+ * of occurrences of each of the variables in the inequality constraints.
+ */
+static int single_occurrence(int n, isl_int *c, int *occurrences)
+{
+	int i;
+
+	for (i = 0; i < n; ++i) {
+		if (isl_int_is_zero(ci))
+			continue;
+		if (occurrencesi != 1)
+			return 0;
+	}
+
+	return 1;
+}
+
+/* Do all of the "n" initial variables that occur in inequality constraint
+ * "ineq" of "bmap" only occur in that constraint?
+ */
+static int all_single_occurrence(__isl_keep isl_basic_map *bmap, int ineq,
+	int n)
+{
+	int i, j;
+
+	for (i = 0; i < n; ++i) {
+		if (isl_int_is_zero(bmap->ineqineq1 + i))
+			continue;
+		for (j = 0; j < bmap->n_ineq; ++j) {
+			if (j == ineq)
+				continue;
+			if (!isl_int_is_zero(bmap->ineqj1 + i))
+				return 0;
+		}
+	}
+
+	return 1;
+}
+
 /* Structure used during detection of parallel constraints.
  * n_in: number of "input" variables: isl_dim_param + isl_dim_in
  * n_out: number of "output" variables: isl_dim_out + isl_dim_div
  * val: the coefficients of the output variables
  */
 struct isl_constraint_equal_info {
-	isl_basic_map *bmap;
 	unsigned n_in;
 	unsigned n_out;
 	isl_int *val;
@@ -4170,12 +4566,14 @@
 /* Check whether the coefficients of the output variables
  * of the constraint in "entry" are equal to info->val.
  */
-static int constraint_equal(const void *entry, const void *val)
+static isl_bool constraint_equal(const void *entry, const void *val)
 {
 	isl_int **row = (isl_int **)entry;
 	const struct isl_constraint_equal_info *info = val;
+	int eq;
 
-	return isl_seq_eq((*row) + 1 + info->n_in, info->val, info->n_out);
+	eq = isl_seq_eq((*row) + 1 + info->n_in, info->val, info->n_out);
+	return isl_bool_ok(eq);
 }
 
 /* Check whether "bmap" has a pair of constraints that have
@@ -4183,31 +4581,37 @@
  * Note that the coefficients of the existentially quantified
  * variables need to be zero since the existentially quantified
  * of the result are usually not the same as those of the input.
- * the isl_dim_out and isl_dim_div dimensions.
- * If so, return 1 and return the row indices of the two constraints
+ * Furthermore, check that each of the input variables that occur
+ * in those constraints does not occur in any other constraint.
+ * If so, return true and return the row indices of the two constraints
  * in *first and *second.
  */
-static int parallel_constraints(__isl_keep isl_basic_map *bmap,
+static isl_bool parallel_constraints(__isl_keep isl_basic_map *bmap,
 	int *first, int *second)
 {
 	int i;
-	isl_ctx *ctx = isl_basic_map_get_ctx(bmap);
+	isl_ctx *ctx;
+	int *occurrences = NULL;
 	struct isl_hash_table *table = NULL;
 	struct isl_hash_table_entry *entry;
 	struct isl_constraint_equal_info info;
-	unsigned n_out;
-	unsigned n_div;
+	isl_size nparam, n_in, n_out, n_div;
 
 	ctx = isl_basic_map_get_ctx(bmap);
 	table = isl_hash_table_alloc(ctx, bmap->n_ineq);
 	if (!table)
 		goto error;
 
-	info.n_in = isl_basic_map_dim(bmap, isl_dim_param) +
-		    isl_basic_map_dim(bmap, isl_dim_in);
-	info.bmap = bmap;
+	nparam = isl_basic_map_dim(bmap, isl_dim_param);
+	n_in = isl_basic_map_dim(bmap, isl_dim_in);
 	n_out = isl_basic_map_dim(bmap, isl_dim_out);
 	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	if (nparam < 0 || n_in < 0 || n_out < 0 || n_div < 0)
+		goto error;
+	info.n_in = nparam + n_in;
+	occurrences = count_occurrences(bmap, info.n_in);
+	if (info.n_in && !occurrences)
+		goto error;
 	info.n_out = n_out + n_div;
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		uint32_t hash;
@@ -4217,6 +4621,9 @@
 			continue;
 		if (isl_seq_first_non_zero(info.val + n_out, n_div) >= 0)
 			continue;
+		if (!single_occurrence(info.n_in, bmap->ineqi + 1,
+					occurrences))
+			continue;
 		hash = isl_seq_get_hash(info.val, info.n_out);
 		entry = isl_hash_table_find(ctx, table, hash,
 					    constraint_equal, &info, 1);
@@ -4233,11 +4640,13 @@
 	}
 
 	isl_hash_table_free(ctx, table);
+	free(occurrences);
 
-	return i < bmap->n_ineq;
+	return isl_bool_ok(i < bmap->n_ineq);
 error:
 	isl_hash_table_free(ctx, table);
-	return -1;
+	free(occurrences);
+	return isl_bool_error;
 }
 
 /* Given a set of upper bounds in "var", add constraints to "bset"
@@ -4290,23 +4699,21 @@
  *	b_i <= b_j	for j > i
  *	b_i <  b_j	for j < i
  */
-static __isl_give isl_set *set_minimum(__isl_take isl_space *dim,
+static __isl_give isl_set *set_minimum(__isl_take isl_space *space,
 	__isl_take isl_mat *var)
 {
 	int i, k;
 	isl_basic_set *bset = NULL;
-	isl_ctx *ctx;
 	isl_set *set = NULL;
 
-	if (!dim || !var)
+	if (!space || !var)
 		goto error;
 
-	ctx = isl_space_get_ctx(dim);
-	set = isl_set_alloc_space(isl_space_copy(dim),
+	set = isl_set_alloc_space(isl_space_copy(space),
 				var->n_row, ISL_SET_DISJOINT);
 
 	for (i = 0; i < var->n_row; ++i) {
-		bset = isl_basic_set_alloc_space(isl_space_copy(dim), 0,
+		bset = isl_basic_set_alloc_space(isl_space_copy(space), 0,
 					       1, var->n_row - 1);
 		k = isl_basic_set_alloc_equality(bset);
 		if (k < 0)
@@ -4317,13 +4724,13 @@
 		set = isl_set_add_basic_set(set, bset);
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(var);
 	return set;
 error:
 	isl_basic_set_free(bset);
 	isl_set_free(set);
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(var);
 	return NULL;
 }
@@ -4337,41 +4744,43 @@
  * an upper bound that is different from the upper bounds on which it
  * is defined.
  */
-static int need_split_basic_map(__isl_keep isl_basic_map *bmap,
+static isl_bool need_split_basic_map(__isl_keep isl_basic_map *bmap,
 	__isl_keep isl_mat *cst)
 {
 	int i, j;
-	unsigned total;
+	isl_size total;
 	unsigned pos;
 
 	pos = cst->n_col - 1;
 	total = isl_basic_map_dim(bmap, isl_dim_all);
+	if (total < 0)
+		return isl_bool_error;
 
 	for (i = 0; i < bmap->n_div; ++i)
 		if (!isl_int_is_zero(bmap->divi2 + pos))
-			return 1;
+			return isl_bool_true;
 
 	for (i = 0; i < bmap->n_eq; ++i)
 		if (!isl_int_is_zero(bmap->eqi1 + pos))
-			return 1;
+			return isl_bool_true;
 
 	for (i = 0; i < bmap->n_ineq; ++i) {
 		if (isl_int_is_nonneg(bmap->ineqi1 + pos))
 			continue;
 		if (!isl_int_is_negone(bmap->ineqi1 + pos))
-			return 1;
+			return isl_bool_true;
 		if (isl_seq_first_non_zero(bmap->ineqi + 1 + pos + 1,
 					   total - pos - 1) >= 0)
-			return 1;
+			return isl_bool_true;
 
 		for (j = 0; j < cst->n_row; ++j)
 			if (isl_seq_eq(bmap->ineqi, cst->rowj, cst->n_col))
 				break;
 		if (j >= cst->n_row)
-			return 1;
+			return isl_bool_true;
 	}
 
-	return 0;
+	return isl_bool_false;
 }
 
 /* Given that the last set variable of "bset" represents the minimum
@@ -4382,28 +4791,32 @@
  * the position of the minimum is computed from "cst" and not
  * from "bmap".
  */
-static int need_split_basic_set(__isl_keep isl_basic_set *bset,
+static isl_bool need_split_basic_set(__isl_keep isl_basic_set *bset,
 	__isl_keep isl_mat *cst)
 {
-	return need_split_basic_map((isl_basic_map *)bset, cst);
+	return need_split_basic_map(bset_to_bmap(bset), cst);
 }
 
 /* Given that the last set variable of "set" represents the minimum
  * of the bounds in "cst", check whether we need to split the domain
  * based on which bound attains the minimum.
  */
-static int need_split_set(__isl_keep isl_set *set, __isl_keep isl_mat *cst)
+static isl_bool need_split_set(__isl_keep isl_set *set, __isl_keep isl_mat *cst)
 {
 	int i;
 
-	for (i = 0; i < set->n; ++i)
-		if (need_split_basic_set(set->pi, cst))
-			return 1;
+	for (i = 0; i < set->n; ++i) {
+		isl_bool split;
 
-	return 0;
+		split = need_split_basic_set(set->pi, cst);
+		if (split < 0 || split)
+			return split;
+	}
+
+	return isl_bool_false;
 }
 
-/* Given a set of which the last set variable is the minimum
+/* Given a map of which the last input variable is the minimum
  * of the bounds in "cst", split each basic set in the set
  * in pieces where one of the bounds is (strictly) smaller than the others.
  * This subdivision is given in "min_expr".
@@ -4416,73 +4829,31 @@
  * to obtain l <= a and l <= b, without having to split on whether
  * m is equal to a or b.
  */
-static __isl_give isl_set *split(__isl_take isl_set *empty,
-	__isl_take isl_set *min_expr, __isl_take isl_mat *cst)
-{
-	int n_in;
-	int i;
-	isl_space *dim;
-	isl_set *res;
-
-	if (!empty || !min_expr || !cst)
-		goto error;
-
-	n_in = isl_set_dim(empty, isl_dim_set);
-	dim = isl_set_get_space(empty);
-	dim = isl_space_drop_dims(dim, isl_dim_set, n_in - 1, 1);
-	res = isl_set_empty(dim);
-
-	for (i = 0; i < empty->n; ++i) {
-		isl_set *set;
-
-		set = isl_set_from_basic_set(isl_basic_set_copy(empty->pi));
-		if (need_split_basic_set(empty->pi, cst))
-			set = isl_set_intersect(set, isl_set_copy(min_expr));
-		set = isl_set_remove_dims(set, isl_dim_set, n_in - 1, 1);
-
-		res = isl_set_union_disjoint(res, set);
-	}
-
-	isl_set_free(empty);
-	isl_set_free(min_expr);
-	isl_mat_free(cst);
-	return res;
-error:
-	isl_set_free(empty);
-	isl_set_free(min_expr);
-	isl_mat_free(cst);
-	return NULL;
-}
-
-/* Given a map of which the last input variable is the minimum
- * of the bounds in "cst", split each basic set in the set
- * in pieces where one of the bounds is (strictly) smaller than the others.
- * This subdivision is given in "min_expr".
- * The variable is subsequently projected out.
- *
- * The implementation is essentially the same as that of "split".
- */
 static __isl_give isl_map *split_domain(__isl_take isl_map *opt,
 	__isl_take isl_set *min_expr, __isl_take isl_mat *cst)
 {
-	int n_in;
+	isl_size n_in;
 	int i;
-	isl_space *dim;
+	isl_space *space;
 	isl_map *res;
 
-	if (!opt || !min_expr || !cst)
+	n_in = isl_map_dim(opt, isl_dim_in);
+	if (n_in < 0 || !min_expr || !cst)
 		goto error;
 
-	n_in = isl_map_dim(opt, isl_dim_in);
-	dim = isl_map_get_space(opt);
-	dim = isl_space_drop_dims(dim, isl_dim_in, n_in - 1, 1);
-	res = isl_map_empty(dim);
+	space = isl_map_get_space(opt);
+	space = isl_space_drop_dims(space, isl_dim_in, n_in - 1, 1);
+	res = isl_map_empty(space);
 
 	for (i = 0; i < opt->n; ++i) {
 		isl_map *map;
+		isl_bool split;
 
 		map = isl_map_from_basic_map(isl_basic_map_copy(opt->pi));
-		if (need_split_basic_map(opt->pi, cst))
+		split = need_split_basic_map(opt->pi, cst);
+		if (split < 0)
+			map = isl_map_free(map);
+		else if (split)
 			map = isl_map_intersect_domain(map,
 						       isl_set_copy(min_expr));
 		map = isl_map_remove_dims(map, isl_dim_in, n_in - 1, 1);
@@ -4501,16 +4872,28 @@
 	return NULL;
 }
 
+/* Given a set of which the last set variable is the minimum
+ * of the bounds in "cst", split each basic set in the set
+ * in pieces where one of the bounds is (strictly) smaller than the others.
+ * This subdivision is given in "min_expr".
+ * The variable is subsequently projected out.
+ */
+static __isl_give isl_set *split(__isl_take isl_set *empty,
+	__isl_take isl_set *min_expr, __isl_take isl_mat *cst)
+{
+	isl_map *map;
+
+	map = isl_map_from_domain(empty);
+	map = split_domain(map, min_expr, cst);
+	empty = isl_map_domain(map);
+
+	return empty;
+}
+
 static __isl_give isl_map *basic_map_partial_lexopt(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max);
 
-union isl_lex_res {
-	void *p;
-	isl_map *map;
-	isl_pw_multi_aff *pma;
-};
-
 /* This function is called from basic_map_partial_lexopt_symm.
  * The last variable of "bmap" and "dom" corresponds to the minimum
  * of the bounds in "cst".  "map_space" is the space of the original
@@ -4520,14 +4903,13 @@
  * We recursively call basic_map_partial_lexopt and then plug in
  * the definition of the minimum in the result.
  */
-static __isl_give union isl_lex_res basic_map_partial_lexopt_symm_map_core(
+static __isl_give isl_map *basic_map_partial_lexopt_symm_core(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max, __isl_take isl_mat *cst,
 	__isl_take isl_space *map_space, __isl_take isl_space *set_space)
 {
 	isl_map *opt;
 	isl_set *min_expr;
-	union isl_lex_res res;
 
 	min_expr = set_minimum(isl_basic_set_get_space(dom), isl_mat_copy(cst));
 
@@ -4542,439 +4924,163 @@
 	opt = split_domain(opt, min_expr, cst);
 	opt = isl_map_reset_space(opt, map_space);
 
-	res.map = opt;
-	return res;
+	return opt;
 }
 
-/* Given a basic map with at least two parallel constraints (as found
- * by the function parallel_constraints), first look for more constraints
- * parallel to the two constraint and replace the found list of parallel
- * constraints by a single constraint with as "input" part the minimum
- * of the input parts of the list of constraints.  Then, recursively call
- * basic_map_partial_lexopt (possibly finding more parallel constraints)
- * and plug in the definition of the minimum in the result.
- *
- * More specifically, given a set of constraints
- *
- *	a x + b_i(p) >= 0
- *
- * Replace this set by a single constraint
- *
- *	a x + u >= 0
- *
- * with u a new parameter with constraints
- *
- *	u <= b_i(p)
+/* Extract a domain from "bmap" for the purpose of computing
+ * a lexicographic optimum.
  *
- * Any solution to the new system is also a solution for the original system
- * since
- *
- *	a x >= -u >= -b_i(p)
- *
- * Moreover, m = min_i(b_i(p)) satisfies the constraints on u and can
- * therefore be plugged into the solution.
- */
-static union isl_lex_res basic_map_partial_lexopt_symm(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max, int first, int second,
-	__isl_give union isl_lex_res (*core)(__isl_take isl_basic_map *bmap,
-					    __isl_take isl_basic_set *dom,
-					    __isl_give isl_set **empty,
-					    int max, __isl_take isl_mat *cst,
-					    __isl_take isl_space *map_space,
-					    __isl_take isl_space *set_space))
-{
-	int i, n, k;
-	int *list = NULL;
-	unsigned n_in, n_out, n_div;
-	isl_ctx *ctx;
-	isl_vec *var = NULL;
-	isl_mat *cst = NULL;
-	isl_space *map_space, *set_space;
-	union isl_lex_res res;
-
-	map_space = isl_basic_map_get_space(bmap);
-	set_space = empty ? isl_basic_set_get_space(dom) : NULL;
-
-	n_in = isl_basic_map_dim(bmap, isl_dim_param) +
-	       isl_basic_map_dim(bmap, isl_dim_in);
-	n_out = isl_basic_map_dim(bmap, isl_dim_all) - n_in;
-
-	ctx = isl_basic_map_get_ctx(bmap);
-	list = isl_alloc_array(ctx, int, bmap->n_ineq);
-	var = isl_vec_alloc(ctx, n_out);
-	if ((bmap->n_ineq && !list) || (n_out && !var))
-		goto error;
-
-	list0 = first;
-	list1 = second;
-	isl_seq_cpy(var->el, bmap->ineqfirst + 1 + n_in, n_out);
-	for (i = second + 1, n = 2; i < bmap->n_ineq; ++i) {
-		if (isl_seq_eq(var->el, bmap->ineqi + 1 + n_in, n_out))
-			listn++ = i;
-	}
-
-	cst = isl_mat_alloc(ctx, n, 1 + n_in);
-	if (!cst)
-		goto error;
-
-	for (i = 0; i < n; ++i)
-		isl_seq_cpy(cst->rowi, bmap->ineqlisti, 1 + n_in);
-
-	bmap = isl_basic_map_cow(bmap);
-	if (!bmap)
-		goto error;
-	for (i = n - 1; i >= 0; --i)
-		if (isl_basic_map_drop_inequality(bmap, listi) < 0)
-			goto error;
-
-	bmap = isl_basic_map_add(bmap, isl_dim_in, 1);
-	bmap = isl_basic_map_extend_constraints(bmap, 0, 1);
-	k = isl_basic_map_alloc_inequality(bmap);
-	if (k < 0)
-		goto error;
-	isl_seq_clr(bmap->ineqk, 1 + n_in);
-	isl_int_set_si(bmap->ineqk1 + n_in, 1);
-	isl_seq_cpy(bmap->ineqk + 1 + n_in + 1, var->el, n_out);
-	bmap = isl_basic_map_finalize(bmap);
-
-	n_div = isl_basic_set_dim(dom, isl_dim_div);
-	dom = isl_basic_set_add_dims(dom, isl_dim_set, 1);
-	dom = isl_basic_set_extend_constraints(dom, 0, n);
-	for (i = 0; i < n; ++i) {
-		k = isl_basic_set_alloc_inequality(dom);
-		if (k < 0)
-			goto error;
-		isl_seq_cpy(dom->ineqk, cst->rowi, 1 + n_in);
-		isl_int_set_si(dom->ineqk1 + n_in, -1);
-		isl_seq_clr(dom->ineqk + 1 + n_in + 1, n_div);
-	}
-
-	isl_vec_free(var);
-	free(list);
-
-	return core(bmap, dom, empty, max, cst, map_space, set_space);
-error:
-	isl_space_free(map_space);
-	isl_space_free(set_space);
-	isl_mat_free(cst);
-	isl_vec_free(var);
-	free(list);
-	isl_basic_set_free(dom);
-	isl_basic_map_free(bmap);
-	res.p = NULL;
-	return res;
-}
-
-static __isl_give isl_map *basic_map_partial_lexopt_symm_map(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max, int first, int second)
-{
-	return basic_map_partial_lexopt_symm(bmap, dom, empty, max,
-		    first, second, &basic_map_partial_lexopt_symm_map_core).map;
-}
-
-/* Recursive part of isl_tab_basic_map_partial_lexopt, after detecting
- * equalities and removing redundant constraints.
- *
- * We first check if there are any parallel constraints (left).
- * If not, we are in the base case.
- * If there are parallel constraints, we replace them by a single
- * constraint in basic_map_partial_lexopt_symm and then call
- * this function recursively to look for more parallel constraints.
+ * This function is only called when the caller wants to compute a full
+ * lexicographic optimum, i.e., without specifying a domain.  In this case,
+ * the caller is not interested in the part of the domain space where
+ * there is no solution and the domain can be initialized to those constraints
+ * of "bmap" that only involve the parameters and the input dimensions.
+ * This relieves the parametric programming engine from detecting those
+ * inequalities and transferring them to the context.  More importantly,
+ * it ensures that those inequalities are transferred first and not
+ * intermixed with inequalities that actually split the domain.
+ *
+ * If the caller does not require the absence of existentially quantified
+ * variables in the result (i.e., if ISL_OPT_QE is not set in "flags"),
+ * then the actual domain of "bmap" can be used.  This ensures that
+ * the domain does not need to be split at all just to separate out
+ * pieces of the domain that do not have a solution from piece that do.
+ * This domain cannot be used in general because it may involve
+ * (unknown) existentially quantified variables which will then also
+ * appear in the solution.
  */
-static __isl_give isl_map *basic_map_partial_lexopt(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max)
+static __isl_give isl_basic_set *extract_domain(__isl_keep isl_basic_map *bmap,
+	unsigned flags)
 {
-	int par = 0;
-	int first, second;
+	isl_size n_div;
+	isl_size n_out;
 
-	if (!bmap)
-		goto error;
-
-	if (bmap->ctx->opt->pip_symmetry)
-		par = parallel_constraints(bmap, &first, &second);
-	if (par < 0)
-		goto error;
-	if (!par)
-		return basic_map_partial_lexopt_base_map(bmap, dom, empty, max);
-	
-	return basic_map_partial_lexopt_symm_map(bmap, dom, empty, max,
-						 first, second);
-error:
-	isl_basic_set_free(dom);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-/* Compute the lexicographic minimum (or maximum if "max" is set)
- * of "bmap" over the domain "dom" and return the result as a map.
- * If "empty" is not NULL, then *empty is assigned a set that
- * contains those parts of the domain where there is no solution.
- * If "bmap" is marked as rational (ISL_BASIC_MAP_RATIONAL),
- * then we compute the rational optimum.  Otherwise, we compute
- * the integral optimum.
- *
- * We perform some preprocessing.  As the PILP solver does not
- * handle implicit equalities very well, we first make sure all
- * the equalities are explicitly available.
- *
- * We also add context constraints to the basic map and remove
- * redundant constraints.  This is only needed because of the
- * way we handle simple symmetries.  In particular, we currently look
- * for symmetries on the constraints, before we set up the main tableau.
- * It is then no good to look for symmetries on possibly redundant constraints.
- */
-struct isl_map *isl_tab_basic_map_partial_lexopt(
-		struct isl_basic_map *bmap, struct isl_basic_set *dom,
-		struct isl_set **empty, int max)
-{
-	if (empty)
-		*empty = NULL;
-	if (!bmap || !dom)
-		goto error;
-
-	isl_assert(bmap->ctx,
-	    isl_basic_map_compatible_domain(bmap, dom), goto error);
-
-	if (isl_basic_set_dim(dom, isl_dim_all) == 0)
-		return basic_map_partial_lexopt(bmap, dom, empty, max);
-
-	bmap = isl_basic_map_intersect_domain(bmap, isl_basic_set_copy(dom));
-	bmap = isl_basic_map_detect_equalities(bmap);
-	bmap = isl_basic_map_remove_redundancies(bmap);
-
-	return basic_map_partial_lexopt(bmap, dom, empty, max);
-error:
-	isl_basic_set_free(dom);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-struct isl_sol_for {
-	struct isl_sol	sol;
-	int		(*fn)(__isl_take isl_basic_set *dom,
-				__isl_take isl_aff_list *list, void *user);
-	void		*user;
-};
-
-static void sol_for_free(struct isl_sol_for *sol_for)
-{
-	if (!sol_for)
-		return;
-	if (sol_for->sol.context)
-		sol_for->sol.context->op->free(sol_for->sol.context);
-	free(sol_for);
-}
-
-static void sol_for_free_wrap(struct isl_sol *sol)
-{
-	sol_for_free((struct isl_sol_for *)sol);
-}
+	n_div = isl_basic_map_dim(bmap, isl_dim_div);
+	n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	if (n_div < 0 || n_out < 0)
+		return NULL;
+	bmap = isl_basic_map_copy(bmap);
+	if (ISL_FL_ISSET(flags, ISL_OPT_QE)) {
+		bmap = isl_basic_map_drop_constraints_involving_dims(bmap,
+							isl_dim_div, 0, n_div);
+		bmap = isl_basic_map_drop_constraints_involving_dims(bmap,
+							isl_dim_out, 0, n_out);
+	}
+	return isl_basic_map_domain(bmap);
+}
+
+#undef TYPE
+#define TYPE	isl_map
+#undef SUFFIX
+#define SUFFIX
+#include "isl_tab_lexopt_templ.c"
 
-/* Add the solution identified by the tableau and the context tableau.
- *
- * See documentation of sol_add for more details.
- *
- * Instead of constructing a basic map, this function calls a user
- * defined function with the current context as a basic set and
- * a list of affine expressions representing the relation between
- * the input and output.  The space over which the affine expressions
- * are defined is the same as that of the domain.  The number of
- * affine expressions in the list is equal to the number of output variables.
+/* Extract the subsequence of the sample value of "tab"
+ * starting at "pos" and of length "len".
  */
-static void sol_for_add(struct isl_sol_for *sol,
-	struct isl_basic_set *dom, struct isl_mat *M)
+static __isl_give isl_vec *extract_sample_sequence(struct isl_tab *tab,
+	int pos, int len)
 {
 	int i;
 	isl_ctx *ctx;
-	isl_local_space *ls;
-	isl_aff *aff;
-	isl_aff_list *list;
+	isl_vec *v;
 
-	if (sol->sol.error || !dom || !M)
-		goto error;
+	ctx = isl_tab_get_ctx(tab);
+	v = isl_vec_alloc(ctx, len);
+	if (!v)
+		return NULL;
+	for (i = 0; i < len; ++i) {
+		if (!tab->varpos + i.is_row) {
+			isl_int_set_si(v->eli, 0);
+		} else {
+			int row;
 
-	ctx = isl_basic_set_get_ctx(dom);
-	ls = isl_basic_set_get_local_space(dom);
-	list = isl_aff_list_alloc(ctx, M->n_row - 1);
-	for (i = 1; i < M->n_row; ++i) {
-		aff = isl_aff_alloc(isl_local_space_copy(ls));
-		if (aff) {
-			isl_int_set(aff->v->el0, M->row00);
-			isl_seq_cpy(aff->v->el + 1, M->rowi, M->n_col);
+			row = tab->varpos + i.index;
+			isl_int_divexact(v->eli, tab->mat->rowrow1,
+					tab->mat->rowrow0);
 		}
-		aff = isl_aff_normalize(aff);
-		list = isl_aff_list_add(list, aff);
 	}
-	isl_local_space_free(ls);
-
-	dom = isl_basic_set_finalize(dom);
-
-	if (sol->fn(isl_basic_set_copy(dom), list, sol->user) < 0)
-		goto error;
 
-	isl_basic_set_free(dom);
-	isl_mat_free(M);
-	return;
-error:
-	isl_basic_set_free(dom);
-	isl_mat_free(M);
-	sol->sol.error = 1;
-}
-
-static void sol_for_add_wrap(struct isl_sol *sol,
-	struct isl_basic_set *dom, struct isl_mat *M)
-{
-	sol_for_add((struct isl_sol_for *)sol, dom, M);
-}
-
-static struct isl_sol_for *sol_for_init(struct isl_basic_map *bmap, int max,
-	int (*fn)(__isl_take isl_basic_set *dom, __isl_take isl_aff_list *list,
-		  void *user),
-	void *user)
-{
-	struct isl_sol_for *sol_for = NULL;
-	isl_space *dom_dim;
-	struct isl_basic_set *dom = NULL;
-
-	sol_for = isl_calloc_type(bmap->ctx, struct isl_sol_for);
-	if (!sol_for)
-		goto error;
-
-	dom_dim = isl_space_domain(isl_space_copy(bmap->dim));
-	dom = isl_basic_set_universe(dom_dim);
-
-	sol_for->sol.rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
-	sol_for->sol.dec_level.callback.run = &sol_dec_level_wrap;
-	sol_for->sol.dec_level.sol = &sol_for->sol;
-	sol_for->fn = fn;
-	sol_for->user = user;
-	sol_for->sol.max = max;
-	sol_for->sol.n_out = isl_basic_map_dim(bmap, isl_dim_out);
-	sol_for->sol.add = &sol_for_add_wrap;
-	sol_for->sol.add_empty = NULL;
-	sol_for->sol.free = &sol_for_free_wrap;
-
-	sol_for->sol.context = isl_context_alloc(dom);
-	if (!sol_for->sol.context)
-		goto error;
-
-	isl_basic_set_free(dom);
-	return sol_for;
-error:
-	isl_basic_set_free(dom);
-	sol_for_free(sol_for);
-	return NULL;
+	return v;
 }
 
-static void sol_for_find_solutions(struct isl_sol_for *sol_for,
-	struct isl_tab *tab)
-{
-	find_solutions_main(&sol_for->sol, tab);
-}
-
-int isl_basic_map_foreach_lexopt(__isl_keep isl_basic_map *bmap, int max,
-	int (*fn)(__isl_take isl_basic_set *dom, __isl_take isl_aff_list *list,
-		  void *user),
-	void *user)
-{
-	struct isl_sol_for *sol_for = NULL;
-
-	bmap = isl_basic_map_copy(bmap);
-	bmap = isl_basic_map_detect_equalities(bmap);
-	if (!bmap)
-		return -1;
-
-	sol_for = sol_for_init(bmap, max, fn, user);
-	if (!sol_for)
-		goto error;
-
-	if (isl_basic_map_plain_is_empty(bmap))
-		/* nothing */;
-	else {
-		struct isl_tab *tab;
-		struct isl_context *context = sol_for->sol.context;
-		tab = tab_for_lexmin(bmap,
-				context->op->peek_basic_set(context), 1, max);
-		tab = context->op->detect_nonnegative_parameters(context, tab);
-		sol_for_find_solutions(sol_for, tab);
-		if (sol_for->sol.error)
-			goto error;
-	}
+/* Check if the sequence of variables starting at "pos"
+ * represents a trivial solution according to "trivial".
+ * That is, is the result of applying "trivial" to this sequence
+ * equal to the zero vector?
+ */
+static isl_bool region_is_trivial(struct isl_tab *tab, int pos,
+	__isl_keep isl_mat *trivial)
+{
+	isl_size n, len;
+	isl_vec *v;
+	isl_bool is_trivial;
+
+	n = isl_mat_rows(trivial);
+	if (n < 0)
+		return isl_bool_error;
+
+	if (n == 0)
+		return isl_bool_false;
+
+	len = isl_mat_cols(trivial);
+	if (len < 0)
+		return isl_bool_error;
+	v = extract_sample_sequence(tab, pos, len);
+	v = isl_mat_vec_product(isl_mat_copy(trivial), v);
+	is_trivial = isl_vec_is_zero(v);
+	isl_vec_free(v);
 
-	sol_free(&sol_for->sol);
-	isl_basic_map_free(bmap);
-	return 0;
-error:
-	sol_free(&sol_for->sol);
-	isl_basic_map_free(bmap);
-	return -1;
+	return is_trivial;
 }
 
-int isl_basic_set_foreach_lexopt(__isl_keep isl_basic_set *bset, int max,
-	int (*fn)(__isl_take isl_basic_set *dom, __isl_take isl_aff_list *list,
-		  void *user),
-	void *user)
-{
-	return isl_basic_map_foreach_lexopt(bset, max, fn, user);
-}
-
-/* Check if the given sequence of len variables starting at pos
- * represents a trivial (i.e., zero) solution.
- * The variables are assumed to be non-negative and to come in pairs,
- * with each pair representing a variable of unrestricted sign.
- * The solution is trivial if each such pair in the sequence consists
- * of two identical values, meaning that the variable being represented
- * has value zero.
- */
-static int region_is_trivial(struct isl_tab *tab, int pos, int len)
-{
-	int i;
-
-	if (len == 0)
-		return 0;
-
-	for (i = 0; i < len; i +=  2) {
-		int neg_row;
-		int pos_row;
-
-		neg_row = tab->varpos + i.is_row ?
-				tab->varpos + i.index : -1;
-		pos_row = tab->varpos + i + 1.is_row ?
-				tab->varpos + i + 1.index : -1;
-
-		if ((neg_row < 0 ||
-		     isl_int_is_zero(tab->mat->rowneg_row1)) &&
-		    (pos_row < 0 ||
-		     isl_int_is_zero(tab->mat->rowpos_row1)))
-			continue;
+/* Global internal data for isl_tab_basic_set_non_trivial_lexmin.
+ *
+ * "n_op" is the number of initial coordinates to optimize,
+ * as passed to isl_tab_basic_set_non_trivial_lexmin.
+ * "region" is the "n_region"-sized array of regions passed
+ * to isl_tab_basic_set_non_trivial_lexmin.
+ *
+ * "tab" is the tableau that corresponds to the ILP problem.
+ * "local" is an array of local data structure, one for each
+ * (potential) level of the backtracking procedure of
+ * isl_tab_basic_set_non_trivial_lexmin.
+ * "v" is a pre-allocated vector that can be used for adding
+ * constraints to the tableau.
+ *
+ * "sol" contains the best solution found so far.
+ * It is initialized to a vector of size zero.
+ */
+struct isl_lexmin_data {
+	int n_op;
+	int n_region;
+	struct isl_trivial_region *region;
 
-		if (neg_row < 0 || pos_row < 0)
-			return 0;
-		if (isl_int_ne(tab->mat->rowneg_row1,
-			       tab->mat->rowpos_row1))
-			return 0;
-	}
+	struct isl_tab *tab;
+	struct isl_local_region *local;
+	isl_vec *v;
 
-	return 1;
-}
+	isl_vec *sol;
+};
 
-/* Return the index of the first trivial region or -1 if all regions
- * are non-trivial.
+/* Return the index of the first trivial region, "n_region" if all regions
+ * are non-trivial or -1 in case of error.
  */
-static int first_trivial_region(struct isl_tab *tab,
-	int n_region, struct isl_region *region)
+static int first_trivial_region(struct isl_lexmin_data *data)
 {
 	int i;
 
-	for (i = 0; i < n_region; ++i) {
-		if (region_is_trivial(tab, regioni.pos, regioni.len))
+	for (i = 0; i < data->n_region; ++i) {
+		isl_bool trivial;
+		trivial = region_is_trivial(data->tab, data->regioni.pos,
+					data->regioni.trivial);
+		if (trivial < 0)
+			return -1;
+		if (trivial)
 			return i;
 	}
 
-	return -1;
+	return data->n_region;
 }
 
 /* Check if the solution is optimal, i.e., whether the first
@@ -4991,30 +5097,37 @@
 }
 
 /* Add constraints to "tab" that ensure that any solution is significantly
- * better that that represented by "sol".  That is, find the first
+ * better than that represented by "sol".  That is, find the first
  * relevant (within first n_op) non-zero coefficient and force it (along
  * with all previous coefficients) to be zero.
  * If the solution is already optimal (all relevant coefficients are zero),
  * then just mark the table as empty.
+ * "n_zero" is the number of coefficients that have been forced zero
+ * by previous calls to this function at the same level.
+ * Return the updated number of forced zero coefficients or -1 on error.
+ *
+ * This function assumes that at least 2 * (n_op - n_zero) more rows and
+ * at least 2 * (n_op - n_zero) more elements in the constraint array
+ * are available in the tableau.
  */
 static int force_better_solution(struct isl_tab *tab,
-	__isl_keep isl_vec *sol, int n_op)
+	__isl_keep isl_vec *sol, int n_op, int n_zero)
 {
-	int i;
+	int i, n;
 	isl_ctx *ctx;
 	isl_vec *v = NULL;
 
 	if (!sol)
 		return -1;
 
-	for (i = 0; i < n_op; ++i)
+	for (i = n_zero; i < n_op; ++i)
 		if (!isl_int_is_zero(sol->el1 + i))
 			break;
 
 	if (i == n_op) {
 		if (isl_tab_mark_empty(tab) < 0)
 			return -1;
-		return 0;
+		return n_op;
 	}
 
 	ctx = isl_vec_get_ctx(sol);
@@ -5022,7 +5135,8 @@
 	if (!v)
 		return -1;
 
-	for (; i >= 0; --i) {
+	n = i + 1;
+	for (; i >= n_zero; --i) {
 		v = isl_vec_clr(v);
 		isl_int_set_si(v->el1 + i, -1);
 		if (add_lexmin_eq(tab, v->el) < 0)
@@ -5030,19 +5144,317 @@
 	}
 
 	isl_vec_free(v);
-	return 0;
+	return n;
 error:
 	isl_vec_free(v);
 	return -1;
 }
 
-struct isl_trivial {
+/* Fix triviality direction "dir" of the given region to zero.
+ *
+ * This function assumes that at least two more rows and at least
+ * two more elements in the constraint array are available in the tableau.
+ */
+static isl_stat fix_zero(struct isl_tab *tab, struct isl_trivial_region *region,
+	int dir, struct isl_lexmin_data *data)
+{
+	isl_size len;
+
+	data->v = isl_vec_clr(data->v);
+	if (!data->v)
+		return isl_stat_error;
+	len = isl_mat_cols(region->trivial);
+	if (len < 0)
+		return isl_stat_error;
+	isl_seq_cpy(data->v->el + 1 + region->pos, region->trivial->rowdir,
+		    len);
+	if (add_lexmin_eq(tab, data->v->el) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* This function selects case "side" for non-triviality region "region",
+ * assuming all the equality constraints have been imposed already.
+ * In particular, the triviality direction side/2 is made positive
+ * if side is even and made negative if side is odd.
+ *
+ * This function assumes that at least one more row and at least
+ * one more element in the constraint array are available in the tableau.
+ */
+static struct isl_tab *pos_neg(struct isl_tab *tab,
+	struct isl_trivial_region *region,
+	int side, struct isl_lexmin_data *data)
+{
+	isl_size len;
+
+	data->v = isl_vec_clr(data->v);
+	if (!data->v)
+		goto error;
+	isl_int_set_si(data->v->el0, -1);
+	len = isl_mat_cols(region->trivial);
+	if (len < 0)
+		goto error;
+	if (side % 2 == 0)
+		isl_seq_cpy(data->v->el + 1 + region->pos,
+			    region->trivial->rowside / 2, len);
+	else
+		isl_seq_neg(data->v->el + 1 + region->pos,
+			    region->trivial->rowside / 2, len);
+	return add_lexmin_ineq(tab, data->v->el);
+error:
+	isl_tab_free(tab);
+	return NULL;
+}
+
+/* Local data at each level of the backtracking procedure of
+ * isl_tab_basic_set_non_trivial_lexmin.
+ *
+ * "update" is set if a solution has been found in the current case
+ * of this level, such that a better solution needs to be enforced
+ * in the next case.
+ * "n_zero" is the number of initial coordinates that have already
+ * been forced to be zero at this level.
+ * "region" is the non-triviality region considered at this level.
+ * "side" is the index of the current case at this level.
+ * "n" is the number of triviality directions.
+ * "snap" is a snapshot of the tableau holding a state that needs
+ * to be satisfied by all subsequent cases.
+ */
+struct isl_local_region {
 	int update;
+	int n_zero;
 	int region;
 	int side;
+	int n;
 	struct isl_tab_undo *snap;
 };
 
+/* Initialize the global data structure "data" used while solving
+ * the ILP problem "bset".
+ */
+static isl_stat init_lexmin_data(struct isl_lexmin_data *data,
+	__isl_keep isl_basic_set *bset)
+{
+	isl_ctx *ctx;
+
+	ctx = isl_basic_set_get_ctx(bset);
+
+	data->tab = tab_for_lexmin(bset, NULL, 0, 0);
+	if (!data->tab)
+		return isl_stat_error;
+
+	data->v = isl_vec_alloc(ctx, 1 + data->tab->n_var);
+	if (!data->v)
+		return isl_stat_error;
+	data->local = isl_calloc_array(ctx, struct isl_local_region,
+					data->n_region);
+	if (data->n_region && !data->local)
+		return isl_stat_error;
+
+	data->sol = isl_vec_alloc(ctx, 0);
+
+	return isl_stat_ok;
+}
+
+/* Mark all outer levels as requiring a better solution
+ * in the next cases.
+ */
+static void update_outer_levels(struct isl_lexmin_data *data, int level)
+{
+	int i;
+
+	for (i = 0; i < level; ++i)
+		data->locali.update = 1;
+}
+
+/* Initialize "local" to refer to region "region" and
+ * to initiate processing at this level.
+ */
+static isl_stat init_local_region(struct isl_local_region *local, int region,
+	struct isl_lexmin_data *data)
+{
+	isl_size n = isl_mat_rows(data->regionregion.trivial);
+
+	if (n < 0)
+		return isl_stat_error;
+	local->n = n;
+	local->region = region;
+	local->side = 0;
+	local->update = 0;
+	local->n_zero = 0;
+
+	return isl_stat_ok;
+}
+
+/* What to do next after entering a level of the backtracking procedure.
+ *
+ * error: some error has occurred; abort
+ * done: an optimal solution has been found; stop search
+ * backtrack: backtrack to the previous level
+ * handle: add the constraints for the current level and
+ * 	move to the next level
+ */
+enum isl_next {
+	isl_next_error = -1,
+	isl_next_done,
+	isl_next_backtrack,
+	isl_next_handle,
+};
+
+/* Have all cases of the current region been considered?
+ * If there are n directions, then there are 2n cases.
+ *
+ * The constraints in the current tableau are imposed
+ * in all subsequent cases.  This means that if the current
+ * tableau is empty, then none of those cases should be considered
+ * anymore and all cases have effectively been considered.
+ */
+static int finished_all_cases(struct isl_local_region *local,
+	struct isl_lexmin_data *data)
+{
+	if (data->tab->empty)
+		return 1;
+	return local->side >= 2 * local->n;
+}
+
+/* Enter level "level" of the backtracking search and figure out
+ * what to do next.  "init" is set if the level was entered
+ * from a higher level and needs to be initialized.
+ * Otherwise, the level is entered as a result of backtracking and
+ * the tableau needs to be restored to a position that can
+ * be used for the next case at this level.
+ * The snapshot is assumed to have been saved in the previous case,
+ * before the constraints specific to that case were added.
+ *
+ * In the initialization case, the local region is initialized
+ * to point to the first violated region.
+ * If the constraints of all regions are satisfied by the current
+ * sample of the tableau, then tell the caller to continue looking
+ * for a better solution or to stop searching if an optimal solution
+ * has been found.
+ *
+ * If the tableau is empty or if all cases at the current level
+ * have been considered, then the caller needs to backtrack as well.
+ */
+static enum isl_next enter_level(int level, int init,
+	struct isl_lexmin_data *data)
+{
+	struct isl_local_region *local = &data->locallevel;
+
+	if (init) {
+		int r;
+
+		data->tab = cut_to_integer_lexmin(data->tab, CUT_ONE);
+		if (!data->tab)
+			return isl_next_error;
+		if (data->tab->empty)
+			return isl_next_backtrack;
+		r = first_trivial_region(data);
+		if (r < 0)
+			return isl_next_error;
+		if (r == data->n_region) {
+			update_outer_levels(data, level);
+			isl_vec_free(data->sol);
+			data->sol = isl_tab_get_sample_value(data->tab);
+			if (!data->sol)
+				return isl_next_error;
+			if (is_optimal(data->sol, data->n_op))
+				return isl_next_done;
+			return isl_next_backtrack;
+		}
+		if (level >= data->n_region)
+			isl_die(isl_vec_get_ctx(data->v), isl_error_internal,
+				"nesting level too deep",
+				return isl_next_error);
+		if (init_local_region(local, r, data) < 0)
+			return isl_next_error;
+		if (isl_tab_extend_cons(data->tab,
+				    2 * local->n + 2 * data->n_op) < 0)
+			return isl_next_error;
+	} else {
+		if (isl_tab_rollback(data->tab, local->snap) < 0)
+			return isl_next_error;
+	}
+
+	if (finished_all_cases(local, data))
+		return isl_next_backtrack;
+	return isl_next_handle;
+}
+
+/* If a solution has been found in the previous case at this level
+ * (marked by local->update being set), then add constraints
+ * that enforce a better solution in the present and all following cases.
+ * The constraints only need to be imposed once because they are
+ * included in the snapshot (taken in pick_side) that will be used in
+ * subsequent cases.
+ */
+static isl_stat better_next_side(struct isl_local_region *local,
+	struct isl_lexmin_data *data)
+{
+	if (!local->update)
+		return isl_stat_ok;
+
+	local->n_zero = force_better_solution(data->tab,
+				data->sol, data->n_op, local->n_zero);
+	if (local->n_zero < 0)
+		return isl_stat_error;
+
+	local->update = 0;
+
+	return isl_stat_ok;
+}
+
+/* Add constraints to data->tab that select the current case (local->side)
+ * at the current level.
+ *
+ * If the linear combinations v should not be zero, then the cases are
+ *	v_0 >= 1
+ *	v_0 <= -1
+ *	v_0 = 0 and v_1 >= 1
+ *	v_0 = 0 and v_1 <= -1
+ *	v_0 = 0 and v_1 = 0 and v_2 >= 1
+ *	v_0 = 0 and v_1 = 0 and v_2 <= -1
+ *	...
+ * in this order.
+ *
+ * A snapshot is taken after the equality constraint (if any) has been added
+ * such that the next case can start off from this position.
+ * The rollback to this position is performed in enter_level.
+ */
+static isl_stat pick_side(struct isl_local_region *local,
+	struct isl_lexmin_data *data)
+{
+	struct isl_trivial_region *region;
+	int side, base;
+
+	region = &data->regionlocal->region;
+	side = local->side;
+	base = 2 * (side/2);
+
+	if (side == base && base >= 2 &&
+	    fix_zero(data->tab, region, base / 2 - 1, data) < 0)
+		return isl_stat_error;
+
+	local->snap = isl_tab_snap(data->tab);
+	if (isl_tab_push_basis(data->tab) < 0)
+		return isl_stat_error;
+
+	data->tab = pos_neg(data->tab, region, side, data);
+	if (!data->tab)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Free the memory associated to "data".
+ */
+static void clear_lexmin_data(struct isl_lexmin_data *data)
+{
+	free(data->local);
+	isl_vec_free(data->v);
+	isl_tab_free(data->tab);
+}
+
 /* Return the lexicographically smallest non-trivial solution of the
  * given ILP problem.
  *
@@ -5050,206 +5462,215 @@
  *
  * n_op is the number of initial coordinates to optimize.
  * That is, once a solution has been found, we will only continue looking
- * for solution that result in significantly better values for those
+ * for solutions that result in significantly better values for those
  * initial coordinates.  That is, we only continue looking for solutions
  * that increase the number of initial zeros in this sequence.
  *
  * A solution is non-trivial, if it is non-trivial on each of the
- * specified regions.  Each region represents a sequence of pairs
- * of variables.  A solution is non-trivial on such a region if
- * at least one of these pairs consists of different values, i.e.,
- * such that the non-negative variable represented by the pair is non-zero.
+ * specified regions.  Each region represents a sequence of
+ * triviality directions on a sequence of variables that starts
+ * at a given position.  A solution is non-trivial on such a region if
+ * at least one of the triviality directions is non-zero
+ * on that sequence of variables.
  *
  * Whenever a conflict is encountered, all constraints involved are
  * reported to the caller through a call to "conflict".
  *
  * We perform a simple branch-and-bound backtracking search.
- * Each level in the search represents initially trivial region that is forced
- * to be non-trivial.
- * At each level we consider n cases, where n is the length of the region.
- * In terms of the n/2 variables of unrestricted signs being encoded by
- * the region, we consider the cases
- *	x_0 >= 1
- *	x_0 <= -1
- *	x_0 = 0 and x_1 >= 1
- *	x_0 = 0 and x_1 <= -1
- *	x_0 = 0 and x_1 = 0 and x_2 >= 1
- *	x_0 = 0 and x_1 = 0 and x_2 <= -1
+ * Each level in the search represents an initially trivial region
+ * that is forced to be non-trivial.
+ * At each level we consider 2 * n cases, where n
+ * is the number of triviality directions.
+ * In terms of those n directions v_i, we consider the cases
+ *	v_0 >= 1
+ *	v_0 <= -1
+ *	v_0 = 0 and v_1 >= 1
+ *	v_0 = 0 and v_1 <= -1
+ *	v_0 = 0 and v_1 = 0 and v_2 >= 1
+ *	v_0 = 0 and v_1 = 0 and v_2 <= -1
  *	...
- * The cases are considered in this order, assuming that each pair
- * x_i_a x_i_b represents the value x_i_b - x_i_a.
- * That is, x_0 >= 1 is enforced by adding the constraint
- *	x_0_b - x_0_a >= 1
+ * in this order.
  */
 __isl_give isl_vec *isl_tab_basic_set_non_trivial_lexmin(
 	__isl_take isl_basic_set *bset, int n_op, int n_region,
-	struct isl_region *region,
+	struct isl_trivial_region *region,
 	int (*conflict)(int con, void *user), void *user)
 {
-	int i, j;
-	int r;
-	isl_ctx *ctx;
-	isl_vec *v = NULL;
-	isl_vec *sol = NULL;
-	struct isl_tab *tab;
-	struct isl_trivial *triv = NULL;
+	struct isl_lexmin_data data = { n_op, n_region, region };
 	int level, init;
 
 	if (!bset)
 		return NULL;
 
-	ctx = isl_basic_set_get_ctx(bset);
-	sol = isl_vec_alloc(ctx, 0);
-
-	tab = tab_for_lexmin(bset, NULL, 0, 0);
-	if (!tab)
-		goto error;
-	tab->conflict = conflict;
-	tab->conflict_user = user;
-
-	v = isl_vec_alloc(ctx, 1 + tab->n_var);
-	triv = isl_calloc_array(ctx, struct isl_trivial, n_region);
-	if (!v || (n_region && !triv))
+	if (init_lexmin_data(&data, bset) < 0)
 		goto error;
+	data.tab->conflict = conflict;
+	data.tab->conflict_user = user;
 
 	level = 0;
 	init = 1;
 
 	while (level >= 0) {
-		int side, base;
-
-		if (init) {
-			tab = cut_to_integer_lexmin(tab, CUT_ONE);
-			if (!tab)
-				goto error;
-			if (tab->empty)
-				goto backtrack;
-			r = first_trivial_region(tab, n_region, region);
-			if (r < 0) {
-				for (i = 0; i < level; ++i)
-					trivi.update = 1;
-				isl_vec_free(sol);
-				sol = isl_tab_get_sample_value(tab);
-				if (!sol)
-					goto error;
-				if (is_optimal(sol, n_op))
-					break;
-				goto backtrack;
-			}
-			if (level >= n_region)
-				isl_die(ctx, isl_error_internal,
-					"nesting level too deep", goto error);
-			if (isl_tab_extend_cons(tab,
-					    2 * regionr.len + 2 * n_op) < 0)
-				goto error;
-			trivlevel.region = r;
-			trivlevel.side = 0;
-		}
-
-		r = trivlevel.region;
-		side = trivlevel.side;
-		base = 2 * (side/2);
+		enum isl_next next;
+		struct isl_local_region *local = &data.locallevel;
 
-		if (side >= regionr.len) {
-backtrack:
+		next = enter_level(level, init, &data);
+		if (next < 0)
+			goto error;
+		if (next == isl_next_done)
+			break;
+		if (next == isl_next_backtrack) {
 			level--;
 			init = 0;
-			if (level >= 0)
-				if (isl_tab_rollback(tab, trivlevel.snap) < 0)
-					goto error;
 			continue;
 		}
 
-		if (trivlevel.update) {
-			if (force_better_solution(tab, sol, n_op) < 0)
-				goto error;
-			trivlevel.update = 0;
-		}
-
-		if (side == base && base >= 2) {
-			for (j = base - 2; j < base; ++j) {
-				v = isl_vec_clr(v);
-				isl_int_set_si(v->el1 + regionr.pos + j, 1);
-				if (add_lexmin_eq(tab, v->el) < 0)
-					goto error;
-			}
-		}
-
-		trivlevel.snap = isl_tab_snap(tab);
-		if (isl_tab_push_basis(tab) < 0)
+		if (better_next_side(local, &data) < 0)
+			goto error;
+		if (pick_side(local, &data) < 0)
 			goto error;
 
-		v = isl_vec_clr(v);
-		isl_int_set_si(v->el0, -1);
-		isl_int_set_si(v->el1 + regionr.pos + side, -1);
-		isl_int_set_si(v->el1 + regionr.pos + (side ^ 1), 1);
-		tab = add_lexmin_ineq(tab, v->el);
-
-		trivlevel.side++;
+		local->side++;
 		level++;
 		init = 1;
 	}
 
-	free(triv);
-	isl_vec_free(v);
-	isl_tab_free(tab);
+	clear_lexmin_data(&data);
 	isl_basic_set_free(bset);
 
-	return sol;
+	return data.sol;
 error:
-	free(triv);
-	isl_vec_free(v);
-	isl_tab_free(tab);
+	clear_lexmin_data(&data);
 	isl_basic_set_free(bset);
-	isl_vec_free(sol);
+	isl_vec_free(data.sol);
 	return NULL;
 }
 
-/* Return the lexicographically smallest rational point in "bset",
+/* Wrapper for a tableau that is used for computing
+ * the lexicographically smallest rational point of a non-negative set.
+ * This point is represented by the sample value of "tab",
+ * unless "tab" is empty.
+ */
+struct isl_tab_lexmin {
+	isl_ctx *ctx;
+	struct isl_tab *tab;
+};
+
+/* Free "tl" and return NULL.
+ */
+__isl_null isl_tab_lexmin *isl_tab_lexmin_free(__isl_take isl_tab_lexmin *tl)
+{
+	if (!tl)
+		return NULL;
+	isl_ctx_deref(tl->ctx);
+	isl_tab_free(tl->tab);
+	free(tl);
+
+	return NULL;
+}
+
+/* Construct an isl_tab_lexmin for computing
+ * the lexicographically smallest rational point in "bset",
  * assuming that all variables are non-negative.
- * If "bset" is empty, then return a zero-length vector.
  */
-__isl_give isl_vec *isl_tab_basic_set_non_neg_lexmin(
+__isl_give isl_tab_lexmin *isl_tab_lexmin_from_basic_set(
 	__isl_take isl_basic_set *bset)
 {
-	struct isl_tab *tab;
-	isl_ctx *ctx = isl_basic_set_get_ctx(bset);
-	isl_vec *sol;
+	isl_ctx *ctx;
+	isl_tab_lexmin *tl;
 
 	if (!bset)
 		return NULL;
 
-	tab = tab_for_lexmin(bset, NULL, 0, 0);
-	if (!tab)
+	ctx = isl_basic_set_get_ctx(bset);
+	tl = isl_calloc_type(ctx, struct isl_tab_lexmin);
+	if (!tl)
 		goto error;
-	if (tab->empty)
-		sol = isl_vec_alloc(ctx, 0);
-	else
-		sol = isl_tab_get_sample_value(tab);
-	isl_tab_free(tab);
+	tl->ctx = ctx;
+	isl_ctx_ref(ctx);
+	tl->tab = tab_for_lexmin(bset, NULL, 0, 0);
 	isl_basic_set_free(bset);
-	return sol;
+	if (!tl->tab)
+		return isl_tab_lexmin_free(tl);
+	return tl;
 error:
-	isl_tab_free(tab);
 	isl_basic_set_free(bset);
+	isl_tab_lexmin_free(tl);
 	return NULL;
 }
 
+/* Return the dimension of the set represented by "tl".
+ */
+int isl_tab_lexmin_dim(__isl_keep isl_tab_lexmin *tl)
+{
+	return tl ? tl->tab->n_var : -1;
+}
+
+/* Add the equality with coefficients "eq" to "tl", updating the optimal
+ * solution if needed.
+ * The equality is added as two opposite inequality constraints.
+ */
+__isl_give isl_tab_lexmin *isl_tab_lexmin_add_eq(__isl_take isl_tab_lexmin *tl,
+	isl_int *eq)
+{
+	unsigned n_var;
+
+	if (!tl || !eq)
+		return isl_tab_lexmin_free(tl);
+
+	if (isl_tab_extend_cons(tl->tab, 2) < 0)
+		return isl_tab_lexmin_free(tl);
+	n_var = tl->tab->n_var;
+	isl_seq_neg(eq, eq, 1 + n_var);
+	tl->tab = add_lexmin_ineq(tl->tab, eq);
+	isl_seq_neg(eq, eq, 1 + n_var);
+	tl->tab = add_lexmin_ineq(tl->tab, eq);
+
+	if (!tl->tab)
+		return isl_tab_lexmin_free(tl);
+
+	return tl;
+}
+
+/* Add cuts to "tl" until the sample value reaches an integer value or
+ * until the result becomes empty.
+ */
+__isl_give isl_tab_lexmin *isl_tab_lexmin_cut_to_integer(
+	__isl_take isl_tab_lexmin *tl)
+{
+	if (!tl)
+		return NULL;
+	tl->tab = cut_to_integer_lexmin(tl->tab, CUT_ONE);
+	if (!tl->tab)
+		return isl_tab_lexmin_free(tl);
+	return tl;
+}
+
+/* Return the lexicographically smallest rational point in the basic set
+ * from which "tl" was constructed.
+ * If the original input was empty, then return a zero-length vector.
+ */
+__isl_give isl_vec *isl_tab_lexmin_get_solution(__isl_keep isl_tab_lexmin *tl)
+{
+	if (!tl)
+		return NULL;
+	if (tl->tab->empty)
+		return isl_vec_alloc(tl->ctx, 0);
+	else
+		return isl_tab_get_sample_value(tl->tab);
+}
+
 struct isl_sol_pma {
 	struct isl_sol	sol;
 	isl_pw_multi_aff *pma;
 	isl_set *empty;
 };
 
-static void sol_pma_free(struct isl_sol_pma *sol_pma)
+static void sol_pma_free(struct isl_sol *sol)
 {
-	if (!sol_pma)
-		return;
-	if (sol_pma->sol.context)
-		sol_pma->sol.context->op->free(sol_pma->sol.context);
+	struct isl_sol_pma *sol_pma = (struct isl_sol_pma *) sol;
 	isl_pw_multi_aff_free(sol_pma->pma);
 	isl_set_free(sol_pma->empty);
-	free(sol_pma);
 }
 
 /* This function is called for parts of the context where there is
@@ -5259,9 +5680,8 @@
 static void sol_pma_add_empty(struct isl_sol_pma *sol,
 	__isl_take isl_basic_set *bset)
 {
-	if (!bset)
+	if (!bset || !sol->empty)
 		goto error;
-	isl_assert(bset->ctx, sol->empty, goto error);
 
 	sol->empty = isl_set_grow(sol->empty, 1);
 	bset = isl_basic_set_simplify(bset);
@@ -5275,33 +5695,16 @@
 	sol->sol.error = 1;
 }
 
-/* Given a basic map "dom" that represents the context and an affine
- * matrix "M" that maps the dimensions of the context to the
- * output variables, construct an isl_pw_multi_aff with a single
- * cell corresponding to "dom" and affine expressions copied from "M".
+/* Given a basic set "dom" that represents the context and a tuple of
+ * affine expressions "maff" defined over this domain, construct
+ * an isl_pw_multi_aff with a single cell corresponding to "dom" and
+ * the affine expressions in "maff".
  */
 static void sol_pma_add(struct isl_sol_pma *sol,
-	__isl_take isl_basic_set *dom, __isl_take isl_mat *M)
+	__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *maff)
 {
-	int i;
-	isl_local_space *ls;
-	isl_aff *aff;
-	isl_multi_aff *maff;
 	isl_pw_multi_aff *pma;
 
-	maff = isl_multi_aff_alloc(isl_pw_multi_aff_get_space(sol->pma));
-	ls = isl_basic_set_get_local_space(dom);
-	for (i = 1; i < M->n_row; ++i) {
-		aff = isl_aff_alloc(isl_local_space_copy(ls));
-		if (aff) {
-			isl_int_set(aff->v->el0, M->row00);
-			isl_seq_cpy(aff->v->el + 1, M->rowi, M->n_col);
-		}
-		aff = isl_aff_normalize(aff);
-		maff = isl_multi_aff_set_aff(maff, i - 1, aff);
-	}
-	isl_local_space_free(ls);
-	isl_mat_free(M);
 	dom = isl_basic_set_simplify(dom);
 	dom = isl_basic_set_finalize(dom);
 	pma = isl_pw_multi_aff_alloc(isl_set_from_basic_set(dom), maff);
@@ -5310,11 +5713,6 @@
 		sol->sol.error = 1;
 }
 
-static void sol_pma_free_wrap(struct isl_sol *sol)
-{
-	sol_pma_free((struct isl_sol_pma *)sol);
-}
-
 static void sol_pma_add_empty_wrap(struct isl_sol *sol,
 	__isl_take isl_basic_set *bset)
 {
@@ -5322,9 +5720,9 @@
 }
 
 static void sol_pma_add_wrap(struct isl_sol *sol,
-	__isl_take isl_basic_set *dom, __isl_take isl_mat *M)
+	__isl_take isl_basic_set *dom, __isl_take isl_multi_aff *ma)
 {
-	sol_pma_add((struct isl_sol_pma *)sol, dom, M);
+	sol_pma_add((struct isl_sol_pma *)sol, dom, ma);
 }
 
 /* Construct an isl_sol_pma structure for accumulating the solution.
@@ -5338,6 +5736,7 @@
 	__isl_take isl_basic_set *dom, int track_empty, int max)
 {
 	struct isl_sol_pma *sol_pma = NULL;
+	isl_space *space;
 
 	if (!bmap)
 		goto error;
@@ -5346,22 +5745,16 @@
 	if (!sol_pma)
 		goto error;
 
-	sol_pma->sol.rational = ISL_F_ISSET(bmap, ISL_BASIC_MAP_RATIONAL);
-	sol_pma->sol.dec_level.callback.run = &sol_dec_level_wrap;
-	sol_pma->sol.dec_level.sol = &sol_pma->sol;
-	sol_pma->sol.max = max;
-	sol_pma->sol.n_out = isl_basic_map_dim(bmap, isl_dim_out);
+	sol_pma->sol.free = &sol_pma_free;
+	if (sol_init(&sol_pma->sol, bmap, dom, max) < 0)
+		goto error;
 	sol_pma->sol.add = &sol_pma_add_wrap;
 	sol_pma->sol.add_empty = track_empty ? &sol_pma_add_empty_wrap : NULL;
-	sol_pma->sol.free = &sol_pma_free_wrap;
-	sol_pma->pma = isl_pw_multi_aff_empty(isl_basic_map_get_space(bmap));
+	space = isl_space_copy(sol_pma->sol.space);
+	sol_pma->pma = isl_pw_multi_aff_empty(space);
 	if (!sol_pma->pma)
 		goto error;
 
-	sol_pma->sol.context = isl_context_alloc(dom);
-	if (!sol_pma->sol.context)
-		goto error;
-
 	if (track_empty) {
 		sol_pma->empty = isl_set_alloc_space(isl_basic_set_get_space(dom),
 							1, ISL_SET_DISJOINT);
@@ -5373,16 +5766,16 @@
 	return &sol_pma->sol;
 error:
 	isl_basic_set_free(dom);
-	sol_pma_free(sol_pma);
+	sol_free(&sol_pma->sol);
 	return NULL;
 }
 
 /* Base case of isl_tab_basic_map_partial_lexopt, after removing
  * some obvious symmetries.
  *
- * We call basic_map_partial_lexopt_base and extract the results.
+ * We call basic_map_partial_lexopt_base_sol and extract the results.
  */
-static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_base_pma(
+static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_base_pw_multi_aff(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max)
 {
@@ -5390,8 +5783,8 @@
 	struct isl_sol *sol;
 	struct isl_sol_pma *sol_pma;
 
-	sol = basic_map_partial_lexopt_base(bmap, dom, empty, max,
-					    &sol_pma_init);
+	sol = basic_map_partial_lexopt_base_sol(bmap, dom, empty, max,
+						&sol_pma_init);
 	if (!sol)
 		return NULL;
 	sol_pma = (struct isl_sol_pma *) sol;
@@ -5410,18 +5803,27 @@
  * In particular, check if the last input variable appears in any
  * of the expressions in "maff".
  */
-static int need_substitution(__isl_keep isl_multi_aff *maff)
+static isl_bool need_substitution(__isl_keep isl_multi_aff *maff)
 {
 	int i;
+	isl_size n_in;
 	unsigned pos;
 
-	pos = isl_multi_aff_dim(maff, isl_dim_in) - 1;
+	n_in = isl_multi_aff_dim(maff, isl_dim_in);
+	if (n_in < 0)
+		return isl_bool_error;
+	pos = n_in - 1;
 
-	for (i = 0; i < maff->n; ++i)
-		if (isl_aff_involves_dims(maff->pi, isl_dim_in, pos, 1))
-			return 1;
+	for (i = 0; i < maff->n; ++i) {
+		isl_bool involves;
 
-	return 0;
+		involves = isl_aff_involves_dims(maff->u.pi,
+						isl_dim_in, pos, 1);
+		if (involves < 0 || involves)
+			return involves;
+	}
+
+	return isl_bool_false;
 }
 
 /* Given a set of upper bounds on the last "input" variable m,
@@ -5447,7 +5849,6 @@
 	int i;
 	isl_aff *aff = NULL;
 	isl_basic_set *bset = NULL;
-	isl_ctx *ctx;
 	isl_pw_aff *paff = NULL;
 	isl_space *pw_space;
 	isl_local_space *ls = NULL;
@@ -5455,7 +5856,6 @@
 	if (!space || !var)
 		goto error;
 
-	ctx = isl_space_get_ctx(space);
 	ls = isl_local_space_from_space(isl_space_copy(space));
 	pw_space = isl_space_copy(space);
 	pw_space = isl_space_from_domain(pw_space);
@@ -5508,7 +5908,7 @@
 	__isl_take isl_pw_multi_aff *opt, __isl_take isl_pw_aff *min_expr_pa,
 	__isl_take isl_set *min_expr, __isl_take isl_mat *cst)
 {
-	int n_in;
+	isl_size n_in;
 	int i;
 	isl_space *space;
 	isl_pw_multi_aff *res;
@@ -5517,21 +5917,33 @@
 		goto error;
 
 	n_in = isl_pw_multi_aff_dim(opt, isl_dim_in);
+	if (n_in < 0)
+		goto error;
 	space = isl_pw_multi_aff_get_space(opt);
 	space = isl_space_drop_dims(space, isl_dim_in, n_in - 1, 1);
 	res = isl_pw_multi_aff_empty(space);
 
 	for (i = 0; i < opt->n; ++i) {
+		isl_bool subs;
 		isl_pw_multi_aff *pma;
 
 		pma = isl_pw_multi_aff_alloc(isl_set_copy(opt->pi.set),
 					 isl_multi_aff_copy(opt->pi.maff));
-		if (need_substitution(opt->pi.maff))
+		subs = need_substitution(opt->pi.maff);
+		if (subs < 0) {
+			pma = isl_pw_multi_aff_free(pma);
+		} else if (subs) {
 			pma = isl_pw_multi_aff_substitute(pma,
 					isl_dim_in, n_in - 1, min_expr_pa);
-		else if (need_split_set(opt->pi.set, cst))
-			pma = isl_pw_multi_aff_intersect_domain(pma,
+		} else {
+			isl_bool split;
+			split = need_split_set(opt->pi.set, cst);
+			if (split < 0)
+				pma = isl_pw_multi_aff_free(pma);
+			else if (split)
+				pma = isl_pw_multi_aff_intersect_domain(pma,
 						       isl_set_copy(min_expr));
+		}
 		pma = isl_pw_multi_aff_project_out(pma,
 						    isl_dim_in, n_in - 1, 1);
 
@@ -5551,7 +5963,7 @@
 	return NULL;
 }
 
-static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_pma(
+static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_pw_multi_aff(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max);
 
@@ -5564,7 +5976,8 @@
  * We recursively call basic_map_partial_lexopt and then plug in
  * the definition of the minimum in the result.
  */
-static __isl_give union isl_lex_res basic_map_partial_lexopt_symm_pma_core(
+static __isl_give isl_pw_multi_aff *
+basic_map_partial_lexopt_symm_core_pw_multi_aff(
 	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
 	__isl_give isl_set **empty, int max, __isl_take isl_mat *cst,
 	__isl_take isl_space *map_space, __isl_take isl_space *set_space)
@@ -5572,13 +5985,12 @@
 	isl_pw_multi_aff *opt;
 	isl_pw_aff *min_expr_pa;
 	isl_set *min_expr;
-	union isl_lex_res res;
 
 	min_expr = set_minimum(isl_basic_set_get_space(dom), isl_mat_copy(cst));
 	min_expr_pa = set_minimum_pa(isl_basic_set_get_space(dom),
 					isl_mat_copy(cst));
 
-	opt = basic_map_partial_lexopt_pma(bmap, dom, empty, max);
+	opt = basic_map_partial_lexopt_pw_multi_aff(bmap, dom, empty, max);
 
 	if (empty) {
 		*empty = split(*empty,
@@ -5589,93 +6001,11 @@
 	opt = split_domain_pma(opt, min_expr_pa, min_expr, cst);
 	opt = isl_pw_multi_aff_reset_space(opt, map_space);
 
-	res.pma = opt;
-	return res;
+	return opt;
 }
 
-static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_symm_pma(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max, int first, int second)
-{
-	return basic_map_partial_lexopt_symm(bmap, dom, empty, max,
-		    first, second, &basic_map_partial_lexopt_symm_pma_core).pma;
-}
-
-/* Recursive part of isl_basic_map_partial_lexopt_pw_multi_aff, after detecting
- * equalities and removing redundant constraints.
- *
- * We first check if there are any parallel constraints (left).
- * If not, we are in the base case.
- * If there are parallel constraints, we replace them by a single
- * constraint in basic_map_partial_lexopt_symm_pma and then call
- * this function recursively to look for more parallel constraints.
- */
-static __isl_give isl_pw_multi_aff *basic_map_partial_lexopt_pma(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max)
-{
-	int par = 0;
-	int first, second;
-
-	if (!bmap)
-		goto error;
-
-	if (bmap->ctx->opt->pip_symmetry)
-		par = parallel_constraints(bmap, &first, &second);
-	if (par < 0)
-		goto error;
-	if (!par)
-		return basic_map_partial_lexopt_base_pma(bmap, dom, empty, max);
-	
-	return basic_map_partial_lexopt_symm_pma(bmap, dom, empty, max,
-						 first, second);
-error:
-	isl_basic_set_free(dom);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
-
-/* Compute the lexicographic minimum (or maximum if "max" is set)
- * of "bmap" over the domain "dom" and return the result as a piecewise
- * multi-affine expression.
- * If "empty" is not NULL, then *empty is assigned a set that
- * contains those parts of the domain where there is no solution.
- * If "bmap" is marked as rational (ISL_BASIC_MAP_RATIONAL),
- * then we compute the rational optimum.  Otherwise, we compute
- * the integral optimum.
- *
- * We perform some preprocessing.  As the PILP solver does not
- * handle implicit equalities very well, we first make sure all
- * the equalities are explicitly available.
- *
- * We also add context constraints to the basic map and remove
- * redundant constraints.  This is only needed because of the
- * way we handle simple symmetries.  In particular, we currently look
- * for symmetries on the constraints, before we set up the main tableau.
- * It is then no good to look for symmetries on possibly redundant constraints.
- */
-__isl_give isl_pw_multi_aff *isl_basic_map_partial_lexopt_pw_multi_aff(
-	__isl_take isl_basic_map *bmap, __isl_take isl_basic_set *dom,
-	__isl_give isl_set **empty, int max)
-{
-	if (empty)
-		*empty = NULL;
-	if (!bmap || !dom)
-		goto error;
-
-	isl_assert(bmap->ctx,
-	    isl_basic_map_compatible_domain(bmap, dom), goto error);
-
-	if (isl_basic_set_dim(dom, isl_dim_all) == 0)
-		return basic_map_partial_lexopt_pma(bmap, dom, empty, max);
-
-	bmap = isl_basic_map_intersect_domain(bmap, isl_basic_set_copy(dom));
-	bmap = isl_basic_map_detect_equalities(bmap);
-	bmap = isl_basic_map_remove_redundancies(bmap);
-
-	return basic_map_partial_lexopt_pma(bmap, dom, empty, max);
-error:
-	isl_basic_set_free(dom);
-	isl_basic_map_free(bmap);
-	return NULL;
-}
+#undef TYPE
+#define TYPE	isl_pw_multi_aff
+#undef SUFFIX
+#define SUFFIX	_pw_multi_aff
+#include "isl_tab_lexopt_templ.c"

_service:tar_scm:isl-0.14.tar.xz/isl_tarjan.c -> _service:tar_scm:isl-0.24.tar.gz/isl_tarjan.c Changed

@@ -14,14 +14,15 @@
 #include <isl/ctx.h>
 #include <isl_tarjan.h>
 
-void isl_tarjan_graph_free(struct isl_tarjan_graph *g)
+struct isl_tarjan_graph *isl_tarjan_graph_free(struct isl_tarjan_graph *g)
 {
 	if (!g)
-		return;
+		return NULL;
 	free(g->node);
 	free(g->stack);
 	free(g->order);
 	free(g);
+	return NULL;
 }
 
 static struct isl_tarjan_graph *isl_tarjan_graph_alloc(isl_ctx *ctx, int len)
@@ -58,8 +59,8 @@
 /* Perform Tarjan's algorithm for computing the strongly connected components
  * in the graph with g->len nodes and with edges defined by "follows".
  */
-static int isl_tarjan_components(struct isl_tarjan_graph *g, int i,
-	int (*follows)(int i, int j, void *user), void *user)
+static isl_stat isl_tarjan_components(struct isl_tarjan_graph *g, int i,
+	isl_bool (*follows)(int i, int j, void *user), void *user)
 {
 	int j;
 
@@ -70,7 +71,7 @@
 	g->stackg->sp++ = i;
 
 	for (j = g->len - 1; j >= 0; --j) {
-		int f;
+		isl_bool f;
 
 		if (j == i)
 			continue;
@@ -81,7 +82,7 @@
 
 		f = follows(i, j, user);
 		if (f < 0)
-			return -1;
+			return isl_stat_error;
 		if (!f)
 			continue;
 
@@ -94,7 +95,7 @@
 	}
 
 	if (g->nodei.index != g->nodei.min_index)
-		return 0;
+		return isl_stat_ok;
 
 	do {
 		j = g->stack--g->sp;
@@ -103,7 +104,7 @@
 	} while (j != i);
 	g->orderg->op++ = -1;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Decompose the graph with "len" nodes and edges defined by "follows"
@@ -116,7 +117,7 @@
  * in the result.
  */
 struct isl_tarjan_graph *isl_tarjan_graph_init(isl_ctx *ctx, int len,
-	int (*follows)(int i, int j, void *user), void *user)
+	isl_bool (*follows)(int i, int j, void *user), void *user)
 {
 	int i;
 	struct isl_tarjan_graph *g = NULL;
@@ -128,11 +129,31 @@
 		if (g->nodei.index >= 0)
 			continue;
 		if (isl_tarjan_components(g, i, follows, user) < 0)
-			goto error;
+			return isl_tarjan_graph_free(g);
 	}
 
 	return g;
-error:
-	isl_tarjan_graph_free(g);
-	return NULL;
+}
+
+/* Decompose the graph with "len" nodes and edges defined by "follows"
+ * into the strongly connected component (SCC) that contains "node"
+ * as well as all SCCs that are followed by this SCC.
+ * follows(i, j, user) should return 1 if "i" follows "j" and 0 otherwise.
+ * It should return -1 on error.
+ *
+ * The SCC containing "node" will appear as the last component
+ * in g->order.
+ */
+struct isl_tarjan_graph *isl_tarjan_graph_component(isl_ctx *ctx, int len,
+	int node, isl_bool (*follows)(int i, int j, void *user), void *user)
+{
+	struct isl_tarjan_graph *g;
+
+	g = isl_tarjan_graph_alloc(ctx, len);
+	if (!g)
+		return NULL;
+	if (isl_tarjan_components(g, node, follows, user) < 0)
+		return isl_tarjan_graph_free(g);
+
+	return g;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_tarjan.h -> _service:tar_scm:isl-0.24.tar.gz/isl_tarjan.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_test.c -> _service:tar_scm:isl-0.24.tar.gz/isl_test.c Changed

@@ -21,24 +21,28 @@
 #include <isl_ctx_private.h>
 #include <isl_map_private.h>
 #include <isl_aff_private.h>
+#include <isl_space_private.h>
+#include <isl/id.h>
 #include <isl/set.h>
 #include <isl/flow.h>
 #include <isl_constraint_private.h>
 #include <isl/polynomial.h>
+#include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl_factorization.h>
 #include <isl/schedule.h>
+#include <isl/schedule_node.h>
 #include <isl_options_private.h>
-#include <isl/vertices.h>
+#include <isl_vertices_private.h>
 #include <isl/ast_build.h>
 #include <isl/val.h>
 #include <isl/ilp.h>
 #include <isl_ast_build_expr.h>
 #include <isl/options.h>
 
-#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
+#include "isl_srcdir.c"
 
-static char *srcdir;
+#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
 
 static char *get_filename(isl_ctx *ctx, const char *name, const char *suffix) {
 	char *filename;
@@ -104,11 +108,317 @@
 	isl_pw_aff_free(pwaff);
 }
 
+/* Check that we can read an isl_multi_val from "str" without errors.
+ */
+static int test_parse_multi_val(isl_ctx *ctx, const char *str)
+{
+	isl_multi_val *mv;
+
+	mv = isl_multi_val_read_from_str(ctx, str);
+	isl_multi_val_free(mv);
+
+	return mv ? 0 : -1;
+}
+
+/* String descriptions of multi piecewise affine expressions
+ * that are used for testing printing and parsing.
+ */
+static const char *reparse_multi_pw_aff_tests = {
+	"{ Ax, y ->  : x + y >= 0 }",
+	"{ Ax, y -> B : x + y >= 0 }",
+	"{ Ax, y -> x : x + y >= 0 }",
+	"N -> { Ax, y -> x : x + y <= N }",
+	"{ Ax, y -> x, y : x + y >= 0 }",
+	"{ Ax, y -> (x : x >= 0), (y : y >= 0) : x + y >= 0 }",
+	"N -> {  : N >= 0 }",
+	"N -> {  : N >= 0 }",
+	"N -> { N : N >= 0 }",
+	"N -> { N, N + 1 : N >= 0 }",
+	"N, M -> { (N : N >= 0), (M : M >= 0) : N + M >= 0 }",
+};
+
+#undef BASE
+#define BASE multi_pw_aff
+
+#include "check_reparse_templ.c"
+#include "check_reparse_test_templ.c"
+
+/* String descriptions of piecewise multi affine expressions
+ * that are used for testing printing and parsing.
+ */
+static const char *reparse_pw_multi_aff_tests = {
+	"{ x -> x }",
+	"{ x -> x % 4 }",
+	"{ x -> x % 4 : x mod 3 = 1 }",
+	"{ x, x -> x % 4 }",
+	"{ x, x + 1 -> x % 4 : x mod 3 = 1 }",
+	"{ x, x mod 2 -> x % 4 }",
+};
+
+#undef BASE
+#define BASE pw_multi_aff
+
+#include "check_reparse_templ.c"
+#include "check_reparse_test_templ.c"
+
+/* Test parsing of piecewise multi affine expressions by printing
+ * the expressions and checking that parsing the output results
+ * in the same expression.
+ * Do this for an expression converted from a map with an output
+ * dimension name that is equal to an automatically generated name, and
+ * a set of expressions parsed from strings.
+ */
+static isl_stat test_parse_pma(isl_ctx *ctx)
+{
+	isl_map *map;
+	isl_pw_multi_aff *pma;
+
+	map = isl_map_read_from_str(ctx, "{ a, a -> i1 = a + 1 }");
+	pma = isl_pw_multi_aff_from_map(map);
+	if (check_reparse_pw_multi_aff(ctx, pma) < 0)
+		return isl_stat_error;
+
+	if (check_reparse_pw_multi_aff_tests(ctx) < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Test parsing of multi piecewise affine expressions by printing
+ * the expressions and checking that parsing the output results
+ * in the same expression.
+ * Do this for a couple of manually constructed expressions,
+ * an expression converted from a map with an output dimension name
+ * that is equal to an automatically generated name, and
+ * a set of expressions parsed from strings.
+ */
+static int test_parse_mpa(isl_ctx *ctx)
+{
+	isl_space *space;
+	isl_set *dom;
+	isl_map *map;
+	isl_pw_multi_aff *pma;
+	isl_multi_pw_aff *mpa;
+	isl_stat r;
+
+	space = isl_space_set_alloc(ctx, 0, 0);
+	space = isl_space_set_tuple_name(space, isl_dim_set, "A");
+	mpa = isl_multi_pw_aff_zero(space);
+	r = check_reparse_multi_pw_aff(ctx, mpa);
+	if (r < 0)
+		return -1;
+
+	space = isl_space_set_alloc(ctx, 1, 0);
+	space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
+	space = isl_space_set_tuple_name(space, isl_dim_set, "A");
+	dom = isl_set_universe(isl_space_params(isl_space_copy(space)));
+	dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5);
+	mpa = isl_multi_pw_aff_zero(space);
+	mpa = isl_multi_pw_aff_intersect_domain(mpa, dom);
+	r = check_reparse_multi_pw_aff(ctx, mpa);
+	if (r < 0)
+		return -1;
+
+	map = isl_map_read_from_str(ctx, "{ a, a -> i1 = a + 1 }");
+	pma = isl_pw_multi_aff_from_map(map);
+	mpa = isl_multi_pw_aff_from_pw_multi_aff(pma);
+	if (check_reparse_multi_pw_aff(ctx, mpa) < 0)
+		return -1;
+
+	if (check_reparse_multi_pw_aff_tests(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* String descriptions of multi union piecewise affine expressions
+ * that are used for testing printing and parsing.
+ */
+static const char *reparse_multi_union_pw_aff_tests = {
+	"",
+	"A",
+	"AB -> C",
+	"(A : { Sx : x > 0; Ty : y >= 0 })",
+	"(A : { })",
+	"N -> (A : { })",
+	"N -> (A : { : N >= 0 })",
+	"N -> (A : { Sx : x > N; Ty : y >= 0 })",
+	"(A : N -> { Sx : x > N; Ty : y >= 0 })",
+	"A{ Sx -> x + 1; Tx -> x }",
+	"(A{ Sx -> x + 1; Tx -> x } : "
+		"{ Sx : x > 0; Ty : y >= 0 })",
+};
+
+#undef BASE
+#define BASE multi_union_pw_aff
+
+#include "check_reparse_templ.c"
+#include "check_reparse_test_templ.c"
+
+/* Test parsing of multi union piecewise affine expressions by printing
+ * the expressions and checking that parsing the output results
+ * in the same expression.
+ * Do this for a couple of manually constructed expressions and
+ * a set of expressions parsed from strings.
+ */
+static int test_parse_mupa(isl_ctx *ctx)
+{
+	isl_space *space;
+	isl_multi_union_pw_aff *mupa;
+	isl_set *dom;
+	isl_union_set *uset;
+	isl_stat r;
+
+	space = isl_space_set_alloc(ctx, 0, 0);
+	space = isl_space_set_tuple_name(space, isl_dim_set, "A");
+	mupa = isl_multi_union_pw_aff_zero(space);
+	r = check_reparse_multi_union_pw_aff(ctx, mupa);
+	if (r < 0)
+		return -1;
+
+	space = isl_space_set_alloc(ctx, 1, 0);
+	space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
+	space = isl_space_set_tuple_name(space, isl_dim_set, "A");
+	dom = isl_set_universe(space);
+	dom = isl_set_lower_bound_si(dom, isl_dim_param, 0, 5);
+	uset = isl_union_set_from_set(dom);
+	space = isl_space_set_alloc(ctx, 1, 0);
+	space = isl_space_set_dim_name(space, isl_dim_param, 0, "N");
+	space = isl_space_set_tuple_name(space, isl_dim_set, "B");
+	mupa = isl_multi_union_pw_aff_zero(space);
+	mupa = isl_multi_union_pw_aff_intersect_domain(mupa, uset);
+	r = check_reparse_multi_union_pw_aff(ctx, mupa);
+	if (r < 0)
+		return -1;
+
+	if (check_reparse_multi_union_pw_aff_tests(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Test parsing of multi expressions.
+ */
+static int test_parse_multi(isl_ctx *ctx)
+{
+	if (test_parse_mpa(ctx) < 0)
+		return -1;
+	if (test_parse_mupa(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Pairs of binary relation representations that should represent
+ * the same binary relations.
+ */
+struct {
+	const char *map1;
+	const char *map2;
+} parse_map_equal_tests = {
+	{ "{ x,y  : (x/2+y)/3 >= 1 }",
+	  "{ x, y : 2y >= 6 - x }" },
+	{ "{ x,y : x <= min(y, 2*y+3) }",
+	  "{ x,y : x <= y, 2*y + 3 }" },
+	{ "{ x,y : x >= min(y, 2*y+3) }",
+	  "{ x, y : (y <= x and y >= -3) or (2y <= -3 + x and y <= -4) }" },
+	{ "n -> { c1 : c1>=0 and c1<=floord(n-4,3) }",
+	  "n -> { c1 : c1 >= 0 and 3c1 <= -4 + n }" },
+	{ "{ i,j -> i : i < j; i,j -> j : j <= i }",
+	  "{ i,j -> min(i,j) }" },
+	{ "{ i,j : i != j }",
+	  "{ i,j : i < j or i > j }" },
+	{ "{ i,j : (i+1)*2 >= j }",
+	  "{ i, j : j <= 2 + 2i }" },
+	{ "{ i -> i > 0 ? 4 : 5 }",
+	  "{ i -> 5 : i <= 0; i -> 4 : i >= 1 }" },
+	{ "N=2,M -> { i=(M+N)/4 }",
+	  "N, M -> { i : N = 2 and 4i <= 2 + M and 4i >= -1 + M }" },
+	{ "{ x : x >= 0 }",
+	  "{ x : x-0 >= 0 }" },
+	{ "{ i : ((i > 10)) }",
+	  "{ i : i >= 11 }" },
+	{ "{ i -> 0 }",
+	  "{ i -> 0 * i }" },
+	{ "{ a -> b : (not false) }",
+	  "{ a -> b : true }" },
+	{ "{ i : i/2 <= 5 }",
+	  "{ i : i <= 10 }" },
+	{ "{Sym=n i : i <= n }",
+	  "n -> { i : i <= n }" },
+	{ "{ * }",
+	  "{ a }" },
+	{ "{ i : 2*floor(i/2) = i }",
+	  "{ i : exists a : i = 2 a }" },
+	{ "{ a -> b : a = 5 implies b = 5 }",
+	  "{ a -> b : a != 5 or b = 5 }" },
+	{ "{ a -> a - 1 : a > 0 }",
+	  "{ a -> a - 1 : a > 0 }" },
+	{ "{ a -> a - 1 : a > 0; a : a <= 0 }",
+	  "{ a -> a - 1 : a > 0; a -> a : a <= 0 }" },
+	{ "{ a -> (a) * 2 : a >= 0; 0 : a < 0 }",
+	  "{ a -> 2a : a >= 0; a -> 0 : a < 0 }" },
+	{ "{ a -> (a * 2) : a >= 0; 0 : a < 0 }",
+	  "{ a -> 2a : a >= 0; a -> 0 : a < 0 }" },
+	{ "{ a -> (a * 2 : a >= 0); 0 : a < 0 }",
+	  "{ a -> 2a : a >= 0; a -> 0 : a < 0 }" },
+	{ "{ a -> (a * 2 : a >= 0; 0 : a < 0) }",
+	  "{ a -> 2a : a >= 0; a -> 0 : a < 0 }" },
+	{ "{ a,b -> i,j : a,b << i,j }",
+	  "{ a,b -> i,j : a < i or (a = i and b < j) }" },
+	{ "{ a,b -> i,j : a,b <<= i,j }",
+	  "{ a,b -> i,j : a < i or (a = i and b <= j) }" },
+	{ "{ a,b -> i,j : a,b >> i,j }",
+	  "{ a,b -> i,j : a > i or (a = i and b > j) }" },
+	{ "{ a,b -> i,j : a,b >>= i,j }",
+	  "{ a,b -> i,j : a > i or (a = i and b >= j) }" },
+	{ "{ n -> i : exists (a, b, c: 8b <= i - 32a and "
+			    "8b >= -7 + i - 32 a and b >= 0 and b <= 3 and "
+			    "8c < n - 32a and i < n and c >= 0 and "
+			    "c <= 3 and c >= -4a) }",
+	  "{ n -> i : 0 <= i < n }" },
+	{ "{ x ->  : exists (a, b: 0 <= a <= 1 and 0 <= b <= 3 and "
+			    "2b <= x - 8a and 2b >= -1 + x - 8a) }",
+	  "{ x ->  : 0 <= x <= 15 }" },
+	{ "{ x -> x : }",
+	  "{ x -> x }" },
+	{ "{ x=4:5 -> x + 1 }",
+	  "{ x -> x + 1 : 4 <= x <= 5 }" },
+	{ "{ x=4:5 -> x + 1 : x + 1 }",
+	  "{ x=4:5 -> x + 1 }" },
+	{ "{ x -> x - 1 : x + 1 }",
+	  "{ x -> y : x - 1 <= y <= x + 1 }" },
+	{ "{ x=4: -> x + 1 }",
+	  "{ x -> x + 1 : 4 <= x }" },
+	{ "{ x=:5 -> x + 1 }",
+	  "{ x -> x + 1 : x <= 5 }" },
+	{ "{ x=: -> x + 1 }",
+	  "{ x -> x + 1 }" },
+	{ "{ : -> : }",
+	  "{ x -> y }" },
+	{ "{ x, x//4 }",
+	  "{ x, floor(x/4) }" },
+	{ "{ 10//4 }",
+	  "{ 2 }" },
+};
+
 int test_parse(struct isl_ctx *ctx)
 {
+	int i;
 	isl_map *map, *map2;
 	const char *str, *str2;
 
+	if (test_parse_multi_val(ctx, "{ AB2 -> C5, 7 }") < 0)
+		return -1;
+	if (test_parse_multi_val(ctx, "n -> { 2 }") < 0)
+		return -1;
+	if (test_parse_multi_val(ctx, "{ A4, infty, NaN, -1/2, 2/3 }") < 0)
+		return -1;
+	if (test_parse_multi(ctx) < 0)
+		return -1;
+	if (test_parse_pma(ctx) < 0)
+		return -1;
+
 	str = "{ i -> -i }";
 	map = isl_map_read_from_str(ctx, str);
 	assert(map);
@@ -123,18 +433,12 @@
 	test_parse_map(ctx, "{ p1, y1, y2 -> 2, y1, y2 : "
 				"p1 = 1 && (y1 <= y2 || y2 = 0) }");
 
-	str = "{ x,y  : (x/2+y)/3 >= 1 }";
-	str2 = "{ x, y : 2y >= 6 - x }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ x,y : x <= min(y, 2*y+3) }",
-				      "{ x,y : x <= y, 2*y + 3 }") < 0)
-		return -1;
-	str = "{ x, y : (y <= x and y >= -3) or (2y <= -3 + x and y <= -4) }";
-	if (test_parse_map_equal(ctx, "{ x,y : x >= min(y, 2*y+3) }",
-					str) < 0)
-		return -1;
+	for (i = 0; i < ARRAY_SIZE(parse_map_equal_tests); ++i) {
+		str = parse_map_equal_testsi.map1;
+		str2 = parse_map_equal_testsi.map2;
+		if (test_parse_map_equal(ctx, str, str2) < 0)
+			return -1;
+	}
 
 	str = "{new,old -> new+1-2*(new+1)/2,old+1-2*(old+1)/2}";
 	map = isl_map_read_from_str(ctx, str);
@@ -155,112 +459,22 @@
 	isl_map_free(map);
 	isl_map_free(map2);
 
-	str = "n -> { c1 : c1>=0 and c1<=floord(n-4,3) }";
-	str2 = "n -> { c1 : c1 >= 0 and 3c1 <= -4 + n }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i,j -> i : i < j; i,j -> j : j <= i }";
-	str2 = "{ i,j -> min(i,j) }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i,j : i != j }";
-	str2 = "{ i,j : i < j or i > j }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i,j : (i+1)*2 >= j }";
-	str2 = "{ i, j : j <= 2 + 2i }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i -> i > 0 ? 4 : 5 }";
-	str2 = "{ i -> 5 : i <= 0; i -> 4 : i >= 1 }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "N=2,M -> { i=(M+N)/4 }";
-	str2 = "N, M -> { i : N = 2 and 4i <= 2 + M and 4i >= -1 + M }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ x : x >= 0 }";
-	str2 = "{ x : x-0 >= 0 }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i : ((i > 10)) }";
-	str2 = "{ i : i >= 11 }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
-	str = "{ i -> 0 }";
-	str2 = "{ i -> 0 * i }";
-	if (test_parse_map_equal(ctx, str, str2) < 0)
-		return -1;
-
 	test_parse_pwqp(ctx, "{ i -> i +  (i + i/3)/2  }");
 	test_parse_map(ctx, "{ S1i -> (i/10),i%10 : 0 <= i <= 45 }");
 	test_parse_pwaff(ctx, "{ i -> i + 1 : i > 0; a -> a : a < 0 }");
 	test_parse_pwqp(ctx, "{ x -> ((x)/2 * (x)/3) }");
-
-	if (test_parse_map_equal(ctx, "{ a -> b : (not false) }",
-				      "{ a -> b : true }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ i : i/2 <= 5 }",
-				      "{ i : i <= 10 }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{Sym=n i : i <= n }",
-				      "n -> { i : i <= n }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ * }", "{ a }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ i : 2*floor(i/2) = i }",
-				      "{ i : exists a : i = 2 a }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ a -> b : a = 5 implies b = 5 }",
-				      "{ a -> b : a != 5 or b = 5 }") < 0)
-		return -1;
-
-	if (test_parse_map_equal(ctx, "{ a -> a - 1 : a > 0 }",
-				      "{ a -> a - 1 : a > 0 }") < 0)
-		return -1;
-	if (test_parse_map_equal(ctx,
-	    "{ a -> a - 1 : a > 0; a : a <= 0 }",
-	    "{ a -> a - 1 : a > 0; a -> a : a <= 0 }") < 0)
-		return -1;
-	if (test_parse_map_equal(ctx,
-	    "{ a -> (a) * 2 : a >= 0; 0 : a < 0 }",
-	    "{ a -> 2a : a >= 0; a -> 0 : a < 0 }") < 0)
-		return -1;
-	if (test_parse_map_equal(ctx,
-	    "{ a -> (a * 2) : a >= 0; 0 : a < 0 }",
-	    "{ a -> 2a : a >= 0; a -> 0 : a < 0 }") < 0)
-		return -1;
-	if (test_parse_map_equal(ctx,
-	    "{ a -> (a * 2 : a >= 0); 0 : a < 0 }",
-	    "{ a -> 2a : a >= 0; a -> 0 : a < 0 }") < 0)
-		return -1;
-	if (test_parse_map_equal(ctx,
-	    "{ a -> (a * 2 : a >= 0; 0 : a < 0) }",
-	    "{ a -> 2a : a >= 0; a -> 0 : a < 0 }") < 0)
-		return -1;
+	test_parse_pwaff(ctx, "{  -> (100) }");
 
 	return 0;
 }
 
-void test_read(struct isl_ctx *ctx)
+static int test_read(isl_ctx *ctx)
 {
 	char *filename;
 	FILE *input;
-	struct isl_basic_set *bset1, *bset2;
+	isl_basic_set *bset1, *bset2;
 	const char *str = "{y: Exists ( alpha : 2alpha = y)}";
+	int equal;
 
 	filename = get_filename(ctx, "set", "omega");
 	assert(filename);
@@ -270,100 +484,215 @@
 	bset1 = isl_basic_set_read_from_file(ctx, input);
 	bset2 = isl_basic_set_read_from_str(ctx, str);
 
-	assert(isl_basic_set_is_equal(bset1, bset2) == 1);
+	equal = isl_basic_set_is_equal(bset1, bset2);
 
 	isl_basic_set_free(bset1);
 	isl_basic_set_free(bset2);
 	free(filename);
 
 	fclose(input);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"read sets not equal", return -1);
+
+	return 0;
 }
 
-void test_bounded(struct isl_ctx *ctx)
+static int test_bounded(isl_ctx *ctx)
 {
 	isl_set *set;
-	int bounded;
+	isl_bool bounded;
 
 	set = isl_set_read_from_str(ctx, "n -> {i : 0 <= i <= n }");
 	bounded = isl_set_is_bounded(set);
-	assert(bounded);
 	isl_set_free(set);
 
+	if (bounded < 0)
+		return -1;
+	if (!bounded)
+		isl_die(ctx, isl_error_unknown,
+			"set not considered bounded", return -1);
+
 	set = isl_set_read_from_str(ctx, "{n, i : 0 <= i <= n }");
 	bounded = isl_set_is_bounded(set);
 	assert(!bounded);
 	isl_set_free(set);
 
+	if (bounded < 0)
+		return -1;
+	if (bounded)
+		isl_die(ctx, isl_error_unknown,
+			"set considered bounded", return -1);
+
 	set = isl_set_read_from_str(ctx, "n -> {i : i <= n }");
 	bounded = isl_set_is_bounded(set);
-	assert(!bounded);
 	isl_set_free(set);
+
+	if (bounded < 0)
+		return -1;
+	if (bounded)
+		isl_die(ctx, isl_error_unknown,
+			"set considered bounded", return -1);
+
+	return 0;
 }
 
 /* Construct the basic set { i : 5 <= i <= N } */
-void test_construction(struct isl_ctx *ctx)
+static int test_construction_1(isl_ctx *ctx)
 {
-	isl_int v;
-	isl_space *dim;
+	isl_space *space;
 	isl_local_space *ls;
-	struct isl_basic_set *bset;
-	struct isl_constraint *c;
+	isl_basic_set *bset;
+	isl_constraint *c;
 
-	isl_int_init(v);
+	space = isl_space_set_alloc(ctx, 1, 1);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
 
-	dim = isl_space_set_alloc(ctx, 1, 1);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_inequality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_param, 0, v);
+	c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_param, 0, 1);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_inequality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -5);
-	isl_constraint_set_constant(c, v);
+	c = isl_constraint_alloc_inequality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_constant_si(c, -5);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	isl_local_space_free(ls);
 	isl_basic_set_free(bset);
 
-	isl_int_clear(v);
+	return 0;
+}
+
+/* Construct the basic set { x : -100 <= x <= 100 }
+ * using isl_basic_set_{lower,upper}_bound_val and
+ * check that it is equal the same basic set parsed from a string.
+ */
+static int test_construction_2(isl_ctx *ctx)
+{
+	isl_bool equal;
+	isl_val *v;
+	isl_space *space;
+	isl_basic_set *bset1, *bset2;
+
+	v = isl_val_int_from_si(ctx, 100);
+	space = isl_space_set_alloc(ctx, 0, 1);
+	bset1 = isl_basic_set_universe(space);
+	bset1 = isl_basic_set_upper_bound_val(bset1, isl_dim_set, 0,
+						isl_val_copy(v));
+	bset1 = isl_basic_set_lower_bound_val(bset1, isl_dim_set, 0,
+						isl_val_neg(v));
+	bset2 = isl_basic_set_read_from_str(ctx, "{ x : -100 <= x <= 100 }");
+	equal = isl_basic_set_is_equal(bset1, bset2);
+	isl_basic_set_free(bset1);
+	isl_basic_set_free(bset2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"failed construction", return -1);
+
+	return 0;
+}
+
+/* Basic tests for constructing basic sets.
+ */
+static int test_construction(isl_ctx *ctx)
+{
+	if (test_construction_1(ctx) < 0)
+		return -1;
+	if (test_construction_2(ctx) < 0)
+		return -1;
+	return 0;
 }
 
-void test_dim(struct isl_ctx *ctx)
+static int test_dim(isl_ctx *ctx)
 {
 	const char *str;
 	isl_map *map1, *map2;
+	int equal;
 
 	map1 = isl_map_read_from_str(ctx,
 	    "n -> { i -> j : exists (a = i/10 : i - 10a <= n ) }");
 	map1 = isl_map_add_dims(map1, isl_dim_in, 1);
 	map2 = isl_map_read_from_str(ctx,
 	    "n -> { i,k -> j : exists (a = i/10 : i - 10a <= n ) }");
-	assert(isl_map_is_equal(map1, map2));
+	equal = isl_map_is_equal(map1, map2);
 	isl_map_free(map2);
 
 	map1 = isl_map_project_out(map1, isl_dim_in, 0, 1);
 	map2 = isl_map_read_from_str(ctx, "n -> { i -> j : n >= 0 }");
-	assert(isl_map_is_equal(map1, map2));
+	if (equal >= 0 && equal)
+		equal = isl_map_is_equal(map1, map2);
 
 	isl_map_free(map1);
 	isl_map_free(map2);
 
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"unexpected result", return -1);
+
 	str = "n -> { i ->  : exists a : 0 <= i <= n and i = 2 a }";
 	map1 = isl_map_read_from_str(ctx, str);
 	str = "{ i -> j : exists a : 0 <= i <= j and i = 2 a }";
 	map2 = isl_map_read_from_str(ctx, str);
 	map1 = isl_map_move_dims(map1, isl_dim_out, 0, isl_dim_param, 0, 1);
-	assert(isl_map_is_equal(map1, map2));
-
+	equal = isl_map_is_equal(map1, map2);
 	isl_map_free(map1);
 	isl_map_free(map2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"unexpected result", return -1);
+
+	return 0;
+}
+
+#undef BASE
+#define BASE	multi_val
+#include "isl_test_plain_equal_templ.c"
+
+#undef BASE
+#define BASE	multi_aff
+#include "isl_test_plain_equal_templ.c"
+
+/* Check that "val" is equal to the value described by "str".
+ * If "str" is "NaN", then check for a NaN value explicitly.
+ */
+static isl_stat val_check_equal(__isl_keep isl_val *val, const char *str)
+{
+	isl_bool ok, is_nan;
+	isl_ctx *ctx;
+	isl_val *res;
+
+	if (!val)
+		return isl_stat_error;
+
+	ctx = isl_val_get_ctx(val);
+	res = isl_val_read_from_str(ctx, str);
+	is_nan = isl_val_is_nan(res);
+	if (is_nan < 0)
+		ok = isl_bool_error;
+	else if (is_nan)
+		ok = isl_val_is_nan(val);
+	else
+		ok = isl_val_eq(val, res);
+	isl_val_free(res);
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(ctx, isl_error_unknown,
+			"unexpected result", return isl_stat_error);
+	return isl_stat_ok;
 }
 
 struct {
@@ -373,7 +702,7 @@
 } val_un_tests = {
 	{ &isl_val_neg, "0", "0" },
 	{ &isl_val_abs, "0", "0" },
-	{ &isl_val_2exp, "0", "1" },
+	{ &isl_val_pow2, "0", "1" },
 	{ &isl_val_floor, "0", "0" },
 	{ &isl_val_ceil, "0", "0" },
 	{ &isl_val_neg, "1", "-1" },
@@ -404,11 +733,20 @@
 	{ &isl_val_ceil, "infty", "infty" },
 	{ &isl_val_ceil, "-infty", "-infty" },
 	{ &isl_val_ceil, "NaN", "NaN" },
-	{ &isl_val_2exp, "-3", "1/8" },
-	{ &isl_val_2exp, "-1", "1/2" },
-	{ &isl_val_2exp, "1", "2" },
-	{ &isl_val_2exp, "2", "4" },
-	{ &isl_val_2exp, "3", "8" },
+	{ &isl_val_pow2, "-3", "1/8" },
+	{ &isl_val_pow2, "-1", "1/2" },
+	{ &isl_val_pow2, "1", "2" },
+	{ &isl_val_pow2, "2", "4" },
+	{ &isl_val_pow2, "3", "8" },
+	{ &isl_val_inv, "1", "1" },
+	{ &isl_val_inv, "2", "1/2" },
+	{ &isl_val_inv, "1/2", "2" },
+	{ &isl_val_inv, "-2", "-1/2" },
+	{ &isl_val_inv, "-1/2", "-2" },
+	{ &isl_val_inv, "0", "NaN" },
+	{ &isl_val_inv, "NaN", "NaN" },
+	{ &isl_val_inv, "infty", "0" },
+	{ &isl_val_inv, "-infty", "0" },
 };
 
 /* Perform some basic tests of unary operations on isl_val objects.
@@ -416,26 +754,19 @@
 static int test_un_val(isl_ctx *ctx)
 {
 	int i;
-	isl_val *v, *res;
+	isl_val *v;
 	__isl_give isl_val *(*fn)(__isl_take isl_val *v);
-	int ok;
 
 	for (i = 0; i < ARRAY_SIZE(val_un_tests); ++i) {
+		isl_stat r;
+
 		v = isl_val_read_from_str(ctx, val_un_testsi.arg);
-		res = isl_val_read_from_str(ctx, val_un_testsi.res);
 		fn = val_un_testsi.op;
 		v = fn(v);
-		if (isl_val_is_nan(res))
-			ok = isl_val_is_nan(v);
-		else
-			ok = isl_val_eq(v, res);
+		r = val_check_equal(v, val_un_testsi.res);
 		isl_val_free(v);
-		isl_val_free(res);
-		if (ok < 0)
+		if (r < 0)
 			return -1;
-		if (!ok)
-			isl_die(ctx, isl_error_unknown,
-				"unexpected result", return -1);
 	}
 
 	return 0;
@@ -581,41 +912,63 @@
 	return 0;
 }
 
+/* Sets described using existentially quantified variables that
+ * can also be described without.
+ */
+static const char *elimination_tests = {
+	"{ i,j : 2 * i/2 + 3 * j/4 <= 10 and 2 i = j }",
+	"{ m, w : exists a : w - 2m - 5 <= 3a <= m - 2w }",
+	"{ m, w : exists a : w >= 0 and a < m and -1 + w <= a <= 2m - w }",
+};
+
+/* Check that redundant existentially quantified variables are
+ * getting removed.
+ */
+static int test_elimination(isl_ctx *ctx)
+{
+	int i;
+	isl_size n;
+	isl_basic_set *bset;
+
+	for (i = 0; i < ARRAY_SIZE(elimination_tests); ++i) {
+		bset = isl_basic_set_read_from_str(ctx, elimination_testsi);
+		n = isl_basic_set_dim(bset, isl_dim_div);
+		isl_basic_set_free(bset);
+		if (n < 0)
+			return -1;
+		if (n != 0)
+			isl_die(ctx, isl_error_unknown,
+				"expecting no existentials", return -1);
+	}
+
+	return 0;
+}
+
 static int test_div(isl_ctx *ctx)
 {
-	unsigned n;
 	const char *str;
 	int empty;
-	isl_int v;
-	isl_space *dim;
+	isl_space *space;
 	isl_set *set;
 	isl_local_space *ls;
 	struct isl_basic_set *bset;
 	struct isl_constraint *c;
 
-	isl_int_init(v);
-
 	/* test 1 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
@@ -625,26 +978,20 @@
 	isl_basic_set_free(bset);
 
 	/* test 2 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
@@ -654,26 +1001,20 @@
 	isl_basic_set_free(bset);
 
 	/* test 3 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -3);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 4);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, -3);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 4);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
@@ -683,26 +1024,20 @@
 	isl_basic_set_free(bset);
 
 	/* test 4 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 2);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, 2);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_constant(c, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 6);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_constant_si(c, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 1, 2);
@@ -712,22 +1047,18 @@
 	isl_basic_set_free(bset);
 
 	/* test 5 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
@@ -737,22 +1068,18 @@
 	isl_local_space_free(ls);
 
 	/* test 6 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 6);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 6);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
@@ -771,19 +1098,15 @@
 	 * and we end up with the original equality and div again.
 	 * Perhaps we can avoid the introduction of this temporary div.
 	 */
-	dim = isl_space_set_alloc(ctx, 0, 4);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
-	isl_int_set_si(v, 6);
-	isl_constraint_set_coefficient(c, isl_dim_set, 3, v);
+	space = isl_space_set_alloc(ctx, 0, 4);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -3);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 6);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 3, 1);
@@ -796,28 +1119,21 @@
 	isl_basic_set_free(bset);
 
 	/* test 8 */
-	dim = isl_space_set_alloc(ctx, 0, 5);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
-	isl_int_set_si(v, -3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 3, v);
-	isl_int_set_si(v, 6);
-	isl_constraint_set_coefficient(c, isl_dim_set, 4, v);
+	space = isl_space_set_alloc(ctx, 0, 5);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -3);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, -3);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 4, 6);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
-	isl_int_set_si(v, 1);
-	isl_constraint_set_constant(c, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, 1);
+	c = isl_constraint_set_constant_si(c, 1);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 4, 1);
@@ -830,26 +1146,20 @@
 	isl_basic_set_free(bset);
 
 	/* test 9 */
-	dim = isl_space_set_alloc(ctx, 0, 4);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 1, v);
-	isl_int_set_si(v, -2);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	space = isl_space_set_alloc(ctx, 0, 4);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 1, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2);
 	bset = isl_basic_set_add_constraint(bset, c);
 
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, -1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, 3);
-	isl_constraint_set_coefficient(c, isl_dim_set, 3, v);
-	isl_int_set_si(v, 2);
-	isl_constraint_set_constant(c, v);
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, -1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 3, 3);
+	c = isl_constraint_set_constant_si(c, 2);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 2);
@@ -862,15 +1172,13 @@
 	isl_basic_set_free(bset);
 
 	/* test 10 */
-	dim = isl_space_set_alloc(ctx, 0, 3);
-	bset = isl_basic_set_universe(isl_space_copy(dim));
-	ls = isl_local_space_from_space(dim);
-
-	c = isl_equality_alloc(isl_local_space_copy(ls));
-	isl_int_set_si(v, 1);
-	isl_constraint_set_coefficient(c, isl_dim_set, 0, v);
-	isl_int_set_si(v, -2);
-	isl_constraint_set_coefficient(c, isl_dim_set, 2, v);
+	space = isl_space_set_alloc(ctx, 0, 3);
+	bset = isl_basic_set_universe(isl_space_copy(space));
+	ls = isl_local_space_from_space(space);
+
+	c = isl_constraint_alloc_equality(isl_local_space_copy(ls));
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 0, 1);
+	c = isl_constraint_set_coefficient_si(c, isl_dim_set, 2, -2);
 	bset = isl_basic_set_add_constraint(bset, c);
 
 	bset = isl_basic_set_project_out(bset, isl_dim_set, 2, 1);
@@ -880,8 +1188,6 @@
 	isl_local_space_free(ls);
 	isl_basic_set_free(bset);
 
-	isl_int_clear(v);
-
 	str = "{ i : exists (e0, e1: 3e1 >= 1 + 2e0 and "
 	    "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }";
 	set = isl_set_read_from_str(ctx, str);
@@ -890,15 +1196,8 @@
 	if (!set)
 		return -1;
 
-	str = "{ i,j : 2*i/2 + 3 * j/4 <= 10 and 2 i = j }";
-	bset = isl_basic_set_read_from_str(ctx, str);
-	n = isl_basic_set_dim(bset, isl_dim_div);
-	isl_basic_set_free(bset);
-	if (!bset)
+	if (test_elimination(ctx) < 0)
 		return -1;
-	if (n != 0)
-		isl_die(ctx, isl_error_unknown,
-			"expecting no existentials", return -1);
 
 	str = "{ i,j,k : 3 + i + 2j >= 0 and 2 * (i+2j)/4 <= k }";
 	set = isl_set_read_from_str(ctx, str);
@@ -943,10 +1242,12 @@
 	fclose(input);
 }
 
-void test_application(struct isl_ctx *ctx)
+static int test_application(isl_ctx *ctx)
 {
 	test_application_case(ctx, "application");
 	test_application_case(ctx, "application2");
+
+	return 0;
 }
 
 void test_affine_hull_case(struct isl_ctx *ctx, const char *name)
@@ -974,13 +1275,56 @@
 	fclose(input);
 }
 
+/* Pairs of sets and the corresponding expected results of
+ * isl_basic_set_recession_cone.
+ */
+struct {
+	const char *set;
+	const char *cone;
+} recession_cone_tests = {
+	{ "{ i : 0 <= i <= 10 }", "{ 0 }" },
+	{ "{ i : 0 <= i }", "{ i : 0 <= i }" },
+	{ "{ i : i <= 10 }", "{ i : i <= 0 }" },
+	{ "{ i : false }", "{ i : false }" },
+};
+
+/* Perform some basic isl_basic_set_recession_cone tests.
+ */
+static int test_recession_cone(struct isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(recession_cone_tests); ++i) {
+		const char *str;
+		isl_basic_set *bset;
+		isl_basic_set *cone, *expected;
+		isl_bool equal;
+
+		str = recession_cone_testsi.set;
+		bset = isl_basic_set_read_from_str(ctx, str);
+		str = recession_cone_testsi.cone;
+		expected = isl_basic_set_read_from_str(ctx, str);
+		cone = isl_basic_set_recession_cone(bset);
+		equal = isl_basic_set_is_equal(cone, expected);
+		isl_basic_set_free(cone);
+		isl_basic_set_free(expected);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown, "unexpected cone",
+				return -1);
+	}
+
+	return 0;
+}
+
 int test_affine_hull(struct isl_ctx *ctx)
 {
 	const char *str;
 	isl_set *set;
 	isl_basic_set *bset, *bset2;
-	int n;
-	int subset;
+	isl_size n;
+	isl_bool subset;
 
 	test_affine_hull_case(ctx, "affine2");
 	test_affine_hull_case(ctx, "affine");
@@ -994,6 +1338,8 @@
 	bset = isl_set_affine_hull(set);
 	n = isl_basic_set_dim(bset, isl_dim_div);
 	isl_basic_set_free(bset);
+	if (n < 0)
+		return -1;
 	if (n != 0)
 		isl_die(ctx, isl_error_unknown, "not expecting any divs",
 			return -1);
@@ -1028,6 +1374,174 @@
 	return 0;
 }
 
+/* Test a special case of isl_set_plain_unshifted_simple_hull
+ * where older versions of isl would include a redundant constraint
+ * in the result.
+ * Check that the result does not have any constraints.
+ */
+static isl_stat test_plain_unshifted_simple_hull_special(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool is_universe;
+	isl_set *set;
+	isl_basic_set *bset;
+
+	str = "{x, y : x = 0 or 2*((x+y)//2) <= y + 2 }";
+	set = isl_set_read_from_str(ctx, str);
+	bset = isl_set_plain_unshifted_simple_hull(set);
+	is_universe = isl_basic_set_plain_is_universe(bset);
+	isl_basic_set_free(bset);
+
+	if (is_universe < 0)
+		return isl_stat_error;
+	if (!is_universe)
+		isl_die(ctx, isl_error_unknown,
+			"hull should not have any constraints",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Inputs for simple hull tests, consisting of
+ * the specific simple hull function, the input set and the expected result.
+ */
+struct {
+	__isl_give isl_basic_set *(*fn)(__isl_take isl_set *set);
+	const char *set;
+	const char *hull;
+} simple_hull_tests = {
+	{ &isl_set_plain_unshifted_simple_hull,
+	  "{ i,j : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
+	  "{ i,j : i >= 1 }" },
+	{ &isl_set_plain_unshifted_simple_hull,
+	  "{ n,i,j,k : (i mod 3 = 2 and j mod 4 = 2) or "
+		"(j mod 4 = 2 and k mod 6 = n) }",
+	  "{ n,i,j,k : j mod 4 = 2 }" },
+	{ &isl_set_unshifted_simple_hull,
+	  "{ 0,x,y : x <= -1; 1,x,y : x <= y <= -x; 2,x,y : x <= 1 }",
+	  "{ t,x,y : 0 <= t <= 2 and x <= 1 }" },
+	{ &isl_set_simple_hull,
+	  "{ a, b : b <= 0 and "
+			"2*floor((-2*floor((b)/2))/5) >= a - floor((b)/2); "
+	    "a, b : a mod 2 = 0 }",
+	  "{ a, b }" },
+};
+
+/* Basic tests for various simple hull functions.
+ */
+static int test_various_simple_hull(isl_ctx *ctx)
+{
+	int i;
+	isl_set *set;
+	isl_basic_set *hull, *expected;
+	isl_bool equal;
+
+	for (i = 0; i < ARRAY_SIZE(simple_hull_tests); ++i) {
+		const char *str;
+		str = simple_hull_testsi.set;
+		set = isl_set_read_from_str(ctx, str);
+		str = simple_hull_testsi.hull;
+		expected = isl_basic_set_read_from_str(ctx, str);
+		hull = simple_hull_testsi.fn(set);
+		equal = isl_basic_set_is_equal(hull, expected);
+		isl_basic_set_free(hull);
+		isl_basic_set_free(expected);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown, "unexpected hull",
+				return -1);
+	}
+
+	return 0;
+}
+
+static int test_simple_hull(struct isl_ctx *ctx)
+{
+	const char *str;
+	isl_set *set;
+	isl_basic_set *bset;
+	isl_bool is_empty;
+
+	str = "{ x, y : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x;"
+		"y, x : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }";
+	set = isl_set_read_from_str(ctx, str);
+	bset = isl_set_simple_hull(set);
+	is_empty = isl_basic_set_is_empty(bset);
+	isl_basic_set_free(bset);
+
+	if (is_empty == isl_bool_error)
+		return -1;
+
+	if (is_empty == isl_bool_false)
+		isl_die(ctx, isl_error_unknown, "Empty set should be detected",
+			return -1);
+
+	if (test_plain_unshifted_simple_hull_special(ctx) < 0)
+		return -1;
+	if (test_various_simple_hull(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Inputs for isl_set_get_simple_fixed_box_hull tests.
+ * "set" is the input set.
+ * "offset" is the expected box offset.
+ * "size" is the expected box size.
+ */
+static struct {
+	const char *set;
+	const char *offset;
+	const char *size;
+} box_hull_tests = {
+	{ "{ Sx, y : 0 <= x, y < 10 }", "{ S0, 0 }", "{ S10, 10 }" },
+	{ "N -> { Sx, y : N <= x, y < N + 10 }",
+	  "N -> { SN, N }", "{ S10, 10 }" },
+	{ "{ Sx, y : 0 <= x + y, x - y < 10 }",
+	  "{ S0, -4 }", "{ S10, 9 }" },
+	{ "{ i=0:10 : exists (e0, e1: 3e1 >= 1 + 2e0 and "
+	    "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
+	  "{ 3 }", "{ 8 }" },
+	{ "N -> { w = 0:17 : exists (e0: w < 2N and "
+	    "-1 + w <= e0 <= w and 2e0 >= N + w and w <= 2e0 <= 15 + w) }",
+	  "N -> { N }", "{ 9 }" },
+};
+
+/* Perform basic isl_set_get_simple_fixed_box_hull tests.
+ */
+static int test_box_hull(struct isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(box_hull_tests); ++i) {
+		const char *str;
+		isl_stat r;
+		isl_set *set;
+		isl_multi_aff *offset;
+		isl_multi_val *size;
+		isl_fixed_box *box;
+
+		set = isl_set_read_from_str(ctx, box_hull_testsi.set);
+		box = isl_set_get_simple_fixed_box_hull(set);
+		offset = isl_fixed_box_get_offset(box);
+		size = isl_fixed_box_get_size(box);
+		str = box_hull_testsi.offset;
+		r = multi_aff_check_plain_equal(offset, str);
+		str = box_hull_testsi.size;
+		if (r >= 0)
+			r = multi_val_check_plain_equal(size, str);
+		isl_multi_aff_free(offset);
+		isl_multi_val_free(size);
+		isl_fixed_box_free(box);
+		isl_set_free(set);
+		if (r < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
 void test_convex_hull_case(struct isl_ctx *ctx, const char *name)
 {
 	char *filename;
@@ -1073,9 +1587,17 @@
 	    "i2 <= 5 + i0 and i2 >= i0 }" },
 	{ "{ x, y : 3y <= 2x and y >= -2 + 2x and 2y >= 2 - x }",
 	    "{ x, y : 1 = 0 }" },
+	{ "{ x, y, z : 0 <= x, y, z <= 10; x, y, 0 : x >= 0 and y > 0; "
+	    "x, y, 0 : x >= 0 and y < 0 }",
+	    "{ x, y, z : x >= 0 and 0 <= z <= 10 }" },
+	{ "{ a, b, c : a <= 1 and -a < b <= 1 and 0 <= c <= 2 - a - b and "
+			    "c <= a; "
+	    "0, 2, 0; 3, 1, 0 }",
+	    "{ a, b, c : b > -a and 2b >= -1 + a and 0 <= c <= a and "
+			    "5c <= 6 - a - 3b }" },
 };
 
-void test_convex_hull_algo(struct isl_ctx *ctx, int convex)
+static int test_convex_hull_algo(isl_ctx *ctx, int convex)
 {
 	int i;
 	int orig_convex = ctx->opt->convex;
@@ -1100,49 +1622,177 @@
 
 	for (i = 0; i < ARRAY_SIZE(convex_hull_tests); ++i) {
 		isl_set *set1, *set2;
+		int equal;
 
 		set1 = isl_set_read_from_str(ctx, convex_hull_testsi.set);
 		set2 = isl_set_read_from_str(ctx, convex_hull_testsi.hull);
 		set1 = isl_set_from_basic_set(isl_set_convex_hull(set1));
-		assert(isl_set_is_equal(set1, set2));
+		equal = isl_set_is_equal(set1, set2);
 		isl_set_free(set1);
 		isl_set_free(set2);
+
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected convex hull", return -1);
 	}
 
 	ctx->opt->convex = orig_convex;
+
+	return 0;
 }
 
-void test_convex_hull(struct isl_ctx *ctx)
+static int test_convex_hull(isl_ctx *ctx)
 {
-	test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM);
-	test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP);
+	if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_FM) < 0)
+		return -1;
+	if (test_convex_hull_algo(ctx, ISL_CONVEX_HULL_WRAP) < 0)
+		return -1;
+	return 0;
 }
 
-void test_gist_case(struct isl_ctx *ctx, const char *name)
+/* Check that computing the gist of "map" with respect to "context"
+ * does not make any copy of "map" get marked empty.
+ * Earlier versions of isl would end up doing that.
+ */
+static isl_stat test_gist_empty_pair(isl_ctx *ctx, const char *map,
+	const char *context)
 {
-	char *filename;
-	FILE *input;
-	struct isl_basic_set *bset1, *bset2;
+	isl_map *m1, *m2, *m3;
+	isl_bool empty_before, empty_after;
 
-	filename = get_filename(ctx, name, "polylib");
-	assert(filename);
-	input = fopen(filename, "r");
-	assert(input);
+	m1 = isl_map_read_from_str(ctx, map);
+	m2 = isl_map_read_from_str(ctx, context);
+	m3 = isl_map_copy(m1);
+	empty_before = isl_map_is_empty(m3);
+	m1 = isl_map_gist(m1, m2);
+	empty_after = isl_map_is_empty(m3);
+	isl_map_free(m1);
+	isl_map_free(m3);
+
+	if (empty_before < 0 || empty_after < 0)
+		return isl_stat_error;
+	if (empty_before)
+		isl_die(ctx, isl_error_unknown, "map should not be empty",
+			return isl_stat_error);
+	if (empty_after)
+		isl_die(ctx, isl_error_unknown, "map should still not be empty",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Check that computing a gist does not make any copy of the input
+ * get marked empty.
+ * Earlier versions of isl would end up doing that on some pairs of inputs.
+ */
+static isl_stat test_gist_empty(isl_ctx *ctx)
+{
+	const char *map, *context;
 
-	bset1 = isl_basic_set_read_from_file(ctx, input);
-	bset2 = isl_basic_set_read_from_file(ctx, input);
+	map = "{  -> a, b, c : 2b = 1 + a }";
+	context = "{  -> a, b, c : 2c = 2 + a }";
+	if (test_gist_empty_pair(ctx, map, context) < 0)
+		return isl_stat_error;
+	map = "{  -> 0, 0 }";
+	context = "{  -> a, b : a > b }";
+	if (test_gist_empty_pair(ctx, map, context) < 0)
+		return isl_stat_error;
 
-	bset1 = isl_basic_set_gist(bset1, bset2);
+	return isl_stat_ok;
+}
 
-	bset2 = isl_basic_set_read_from_file(ctx, input);
+/* Inputs to isl_map_plain_gist_basic_map, along with the expected output.
+ */
+struct {
+	const char *map;
+	const char *context;
+	const char *gist;
+} plain_gist_tests = {
+	{ "{ i -> j : i >= 1 and j >= 1 or i >= 2 and j <= 10 }",
+	  "{ i -> j : i >= 1 }",
+	  "{ i -> j : j >= 1 or i >= 2 and j <= 10 }" },
+	{ "{ n -> i,j,k : (i mod 3 = 2 and j mod 4 = 2) or "
+		"(j mod 4 = 2 and k mod 6 = n) }",
+	  "{ n -> i,j,k : j mod 4 = 2 }",
+	  "{ n -> i,j,k : (i mod 3 = 2) or (k mod 6 = n) }" },
+	{ "{ i -> j : i > j and (exists a,b : i <= 2a + 5b <= 2) }",
+	  "{ i -> j : i > j }",
+	  "{ i -> j : exists a,b : i <= 2a + 5b <= 2 }" },
+};
 
-	assert(isl_basic_set_is_equal(bset1, bset2) == 1);
+/* Basic tests for isl_map_plain_gist_basic_map.
+ */
+static int test_plain_gist(isl_ctx *ctx)
+{
+	int i;
 
-	isl_basic_set_free(bset1);
-	isl_basic_set_free(bset2);
-	free(filename);
+	for (i = 0; i < ARRAY_SIZE(plain_gist_tests); ++i) {
+		const char *str;
+		int equal;
+		isl_map *map, *gist;
+		isl_basic_map *context;
 
-	fclose(input);
+		map = isl_map_read_from_str(ctx, plain_gist_testsi.map);
+		str = plain_gist_testsi.context;
+		context = isl_basic_map_read_from_str(ctx, str);
+		map = isl_map_plain_gist_basic_map(map, context);
+		gist = isl_map_read_from_str(ctx, plain_gist_testsi.gist);
+		equal = isl_map_is_equal(map, gist);
+		isl_map_free(map);
+		isl_map_free(gist);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"incorrect gist result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for isl_basic_set_gist tests that are expected to fail.
+ */
+struct {
+	const char *set;
+	const char *context;
+} gist_fail_tests = {
+	{ "{ i : exists (e0, e1: 3e1 >= 1 + 2e0 and "
+	    "8e1 <= -1 + 5i - 5e0 and 2e1 >= 1 + 2i - 5e0) }",
+	  "{ i : i >= 0 }" },
+};
+
+/* Check that isl_basic_set_gist fails (gracefully) when expected.
+ * In particular, the user should be able to recover from the failure.
+ */
+static isl_stat test_gist_fail(struct isl_ctx *ctx)
+{
+	int i, n;
+	int on_error;
+
+	on_error = isl_options_get_on_error(ctx);
+	isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE);
+	n = ARRAY_SIZE(gist_fail_tests);
+	for (i = 0; i < n; ++i) {
+		const char *str;
+		isl_basic_set *bset, *context;
+
+		bset = isl_basic_set_read_from_str(ctx, gist_fail_testsi.set);
+		str = gist_fail_testsi.context;
+		context = isl_basic_set_read_from_str(ctx, str);
+		bset = isl_basic_set_gist(bset, context);
+		isl_basic_set_free(bset);
+		if (bset)
+			break;
+	}
+	isl_options_set_on_error(ctx, on_error);
+	if (i < n)
+		isl_die(ctx, isl_error_unknown,
+			"operation not expected to succeed",
+			return isl_stat_error);
+
+	return isl_stat_ok;
 }
 
 struct {
@@ -1150,38 +1800,132 @@
 	const char *context;
 	const char *gist;
 } gist_tests = {
+	{ "{ 1, -1, 3 }",
+	  "{ 1, b, 2 - b : -1 <= b <= 2 }",
+	  "{ a, -1, c }" },
 	{ "{ a, b, c : a <= 15 and a >= 1 }",
 	  "{ a, b, c : exists (e0 = floor((-1 + a)/16): a >= 1 and "
 			"c <= 30 and 32e0 >= -62 + 2a + 2b - c and b >= 0) }",
 	  "{ a, b, c : a <= 15 }" },
 	{ "{ : }", "{ : 1 = 0 }", "{ : }" },
 	{ "{ : 1 = 0 }", "{ : 1 = 0 }", "{ : }" },
+	{ "M -> { x : exists (e0 = floor((-2 + x)/3): 3e0 = -2 + x) }",
+	  "M -> { 3M }" , "M -> { x : 1 = 0 }" },
+	{ "{ m, n, a, b : a <= 2147 + n }",
+	  "{ m, n, a, b : (m >= 1 and n >= 1 and a <= 2148 - m and "
+			"b <= 2148 - n and b >= 0 and b >= 2149 - n - a) or "
+			"(n >= 1 and a >= 0 and b <= 2148 - n - a and "
+			"b >= 0) }",
+	  "{ m, n, ku, kl }" },
+	{ "{ a, a, b : a >= 10 }",
+	  "{ a, b, c : c >= a and c <= b and c >= 2 }",
+	  "{ a, a, b : a >= 10 }" },
+	{ "{ i, j : i >= 0 and i + j >= 0 }", "{ i, j : i <= 0 }",
+	  "{ 0, j : j >= 0 }" },
+	/* Check that no constraints on i6 are introduced in the gist */
+	{ "t1 -> { i4, i6 : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
+		"20e0 <= 1530 - 4t1 - 5i4 and 20e0 >= 1511 - 4t1 - 5i4 and "
+		"5e0 <= 381 - t1 and i4 <= 1) }",
+	  "t1 -> { i4, i6 : exists (e0 = floor((-t1 + i6)/5): "
+		"5e0 = -t1 + i6 and i6 <= 6 and i6 >= 3) }",
+	  "t1 -> { i4, i6 : exists (e0 = floor((1530 - 4t1 - 5i4)/20): "
+		"i4 <= 1 and 5e0 <= 381 - t1 and 20e0 <= 1530 - 4t1 - 5i4 and "
+		"20e0 >= 1511 - 4t1 - 5i4) }" },
+	/* Check that no constraints on i6 are introduced in the gist */
+	{ "t1, t2 -> { i4, i5, i6 : exists (e0 = floor((1 + i4)/2), "
+		"e1 = floor((1530 - 4t1 - 5i4)/20), "
+		"e2 = floor((-4t1 - 5i4 + 10*floor((1 + i4)/2))/20), "
+		"e3 = floor((-1 + i4)/2): t2 = 0 and 2e3 = -1 + i4 and "
+			"20e2 >= -19 - 4t1 - 5i4 + 10e0 and 5e2 <= 1 - t1 and "
+			"2e0 <= 1 + i4 and 2e0 >= i4 and "
+			"20e1 <= 1530 - 4t1 - 5i4 and "
+			"20e1 >= 1511 - 4t1 - 5i4 and i4 <= 1 and "
+			"5e1 <= 381 - t1 and 20e2 <= -4t1 - 5i4 + 10e0) }",
+	  "t1, t2 -> { i4, i5, i6 : exists (e0 = floor((-17 + i4)/2), "
+		"e1 = floor((-t1 + i6)/5): 5e1 = -t1 + i6 and "
+			"2e0 <= -17 + i4 and 2e0 >= -18 + i4 and "
+			"10e0 <= -91 + 5i4 + 4i6 and "
+			"10e0 >= -105 + 5i4 + 4i6) }",
+	  "t1, t2 -> { i4, i5, i6 : exists (e0 = floor((381 - t1)/5), "
+		"e1 = floor((-1 + i4)/2): t2 = 0 and 2e1 = -1 + i4 and "
+		"i4 <= 1 and 5e0 <= 381 - t1 and 20e0 >= 1511 - 4t1 - 5i4) }" },
+	{ "{ 0, 0, q, p : -5 <= q <= 5 and p >= 0 }",
+	  "{ a, b, q, p : b >= 1 + a }",
+	  "{ a, b, q, p : false }" },
+	{ "n -> { x : x = n && x mod 32 = 0 }",
+	  "n -> { x : x mod 32 = 0 }",
+	  "n -> { x = n }" },
+	{ "{ x : x mod 6 = 0 }", "{ x : x mod 3 = 0 }",
+	  "{ x : x mod 2 = 0 }" },
+	{ "{ x : x mod 3200 = 0 }", "{ x : x mod 10000 = 0 }",
+	  "{ x : x mod 128 = 0 }" },
+	{ "{ x : x mod 3200 = 0 }", "{ x : x mod 10 = 0 }",
+	  "{ x : x mod 3200 = 0 }" },
+	{ "{ a, b, c : a mod 2 = 0 and a = c }",
+	  "{ a, b, c : b mod 2 = 0 and b = c }",
+	  "{ a, b, c = a }" },
+	{ "{ a, b, c : a mod 6 = 0 and a = c }",
+	  "{ a, b, c : b mod 2 = 0 and b = c }",
+	  "{ a, b, c = a : a mod 3 = 0 }" },
+	{ "{ x : 0 <= x <= 4 or 6 <= x <= 9 }",
+	  "{ x : 1 <= x <= 3 or 7 <= x <= 8 }",
+	  "{ x }" },
+	{ "{ x,y : x < 0 and 0 <= y <= 4 or x >= -2 and -x <= y <= 10 + x }",
+	  "{ x,y : 1 <= y <= 3 }",
+	  "{ x,y }" },
 };
 
+/* Check that isl_set_gist behaves as expected.
+ *
+ * For the test cases in gist_tests, besides checking that the result
+ * is as expected, also check that applying the gist operation does
+ * not modify the input set (an earlier version of isl would do that) and
+ * that the test case is consistent, i.e., that the gist has the same
+ * intersection with the context as the input set.
+ */
 static int test_gist(struct isl_ctx *ctx)
 {
 	int i;
 	const char *str;
 	isl_basic_set *bset1, *bset2;
 	isl_map *map1, *map2;
-	int equal;
+	isl_bool equal;
+	isl_size n_div;
 
 	for (i = 0; i < ARRAY_SIZE(gist_tests); ++i) {
-		bset1 = isl_basic_set_read_from_str(ctx, gist_testsi.set);
-		bset2 = isl_basic_set_read_from_str(ctx, gist_testsi.context);
-		bset1 = isl_basic_set_gist(bset1, bset2);
-		bset2 = isl_basic_set_read_from_str(ctx, gist_testsi.gist);
-		equal = isl_basic_set_is_equal(bset1, bset2);
-		isl_basic_set_free(bset1);
-		isl_basic_set_free(bset2);
-		if (equal < 0)
+		isl_bool equal_input, equal_intersection;
+		isl_set *set1, *set2, *copy, *context;
+
+		set1 = isl_set_read_from_str(ctx, gist_testsi.set);
+		context = isl_set_read_from_str(ctx, gist_testsi.context);
+		copy = isl_set_copy(set1);
+		set1 = isl_set_gist(set1, isl_set_copy(context));
+		set2 = isl_set_read_from_str(ctx, gist_testsi.gist);
+		equal = isl_set_is_equal(set1, set2);
+		isl_set_free(set1);
+		set1 = isl_set_read_from_str(ctx, gist_testsi.set);
+		equal_input = isl_set_is_equal(set1, copy);
+		isl_set_free(copy);
+		set1 = isl_set_intersect(set1, isl_set_copy(context));
+		set2 = isl_set_intersect(set2, context);
+		equal_intersection = isl_set_is_equal(set1, set2);
+		isl_set_free(set2);
+		isl_set_free(set1);
+		if (equal < 0 || equal_input < 0 || equal_intersection < 0)
 			return -1;
 		if (!equal)
 			isl_die(ctx, isl_error_unknown,
 				"incorrect gist result", return -1);
+		if (!equal_input)
+			isl_die(ctx, isl_error_unknown,
+				"gist modified input", return -1);
+		if (!equal_input)
+			isl_die(ctx, isl_error_unknown,
+				"inconsistent gist test case", return -1);
 	}
 
-	test_gist_case(ctx, "gist1");
+	if (test_gist_fail(ctx) < 0)
+		return -1;
 
 	str = "p0, p2, p3, p5, p6, p10 -> {  : "
 	    "exists (e0 = (15 + p0 + 15p6 + 15p10)/16, e1 = (p5)/8, "
@@ -1225,10 +1969,18 @@
 	if (map1->n != 1)
 		isl_die(ctx, isl_error_unknown, "expecting single disjunct",
 			isl_map_free(map1); return -1);
-	if (isl_basic_map_dim(map1->p0, isl_dim_div) != 1)
-		isl_die(ctx, isl_error_unknown, "expecting single div",
-			isl_map_free(map1); return -1);
+	n_div = isl_basic_map_dim(map1->p0, isl_dim_div);
 	isl_map_free(map1);
+	if (n_div < 0)
+		return -1;
+	if (n_div != 1)
+		isl_die(ctx, isl_error_unknown, "expecting single div",
+			return -1);
+
+	if (test_gist_empty(ctx) < 0)
+		return -1;
+	if (test_plain_gist(ctx) < 0)
+		return -1;
 
 	return 0;
 }
@@ -1259,31 +2011,54 @@
 	return 0;
 }
 
+/* Inputs for coalescing tests with unbounded wrapping.
+ * "str" is a string representation of the input set.
+ * "single_disjunct" is set if we expect the result to consist of
+ *	a single disjunct.
+ */
+struct {
+	int single_disjunct;
+	const char *str;
+} coalesce_unbounded_tests = {
+	{ 1, "{ x,y,z : y + 2 >= 0 and x - y + 1 >= 0 and "
+			"-x - y + 1 >= 0 and -3 <= z <= 3;"
+		"x,y,z : -x+z + 20 >= 0 and -x-z + 20 >= 0 and "
+			"x-z + 20 >= 0 and x+z + 20 >= 0 and "
+			"-10 <= y <= 0}" },
+	{ 1, "{ x,y : 0 <= x,y <= 10; 5,y: 4 <= y <= 11 }" },
+	{ 1, "{ x,0,0 : -5 <= x <= 5; 0,y,1 : -5 <= y <= 5 }" },
+	{ 1, "{ x,y : 0 <= x <= 10 and 0 >= y >= -1 and x+y >= 0; 0,1 }" },
+	{ 1, "{ x,y : (0 <= x,y <= 4) or (2 <= x,y <= 5 and x + y <= 9) }" },
+	{ 0, "{ x, y, z : 0 <= x,y,z <= 100 and 0 < z <= 2 + 2x + 2y; "
+		"x, y, 0 : x,y <= 100 and y <= 9 + 11x and x <= 9 + 11y }" },
+	{ 1, "{ 0:1, 0:1; 0, 2:3 }" },
+	{ 1, "{ 0:1, 0:1; 0, 2:3; 1, -2:-1 }" },
+	{ 1, "{ 0:3, 0:1; 1:2, 2:5 }" },
+	{ 1, "{ 0:3, 0:1; 0:2, 2:5 }" },
+	{ 1, "{ 0:3, 0:1; 1:3, 2:5 }" },
+	{ 0, "{ 0:3, 0:1; 1:4, 2:5 }" },
+	{ 0, "{ 0:3, 0:1; 1:5, 2:5 }" },
+};
+
+/* Test the functionality of isl_set_coalesce with the bounded wrapping
+ * option turned off.
+ */
 int test_coalesce_unbounded_wrapping(isl_ctx *ctx)
 {
+	int i;
 	int r = 0;
 	int bounded;
 
 	bounded = isl_options_get_coalesce_bounded_wrapping(ctx);
 	isl_options_set_coalesce_bounded_wrapping(ctx, 0);
 
-	if (test_coalesce_set(ctx,
-		"{x,y,z : y + 2 >= 0 and x - y + 1 >= 0 and "
-			"-x - y + 1 >= 0 and -3 <= z <= 3;"
-		"x,y,z : -x+z + 20 >= 0 and -x-z + 20 >= 0 and "
-			"x-z + 20 >= 0 and x+z + 20 >= 0 and "
-			"-10 <= y <= 0}", 1) < 0)
-		goto error;
-	if (test_coalesce_set(ctx,
-		"{x,y : 0 <= x,y <= 10; 5,y: 4 <=y <= 11}", 1) < 0)
-		goto error;
-	if (test_coalesce_set(ctx,
-		"{x,0,0 : -5 <= x <= 5; 0,y,1 : -5 <= y <= 5 }", 1) < 0)
-		goto error;
-
-	if (0) {
-error:
+	for (i = 0; i < ARRAY_SIZE(coalesce_unbounded_tests); ++i) {
+		const char *str = coalesce_unbounded_testsi.str;
+		int check_one = coalesce_unbounded_testsi.single_disjunct;
+		if (test_coalesce_set(ctx, str, check_one) >= 0)
+			continue;
 		r = -1;
+		break;
 	}
 
 	isl_options_set_coalesce_bounded_wrapping(ctx, bounded);
@@ -1409,11 +2184,332 @@
 		"x,0 : 3 <= x <= 5 }" },
 	{ 0, "{ x,y : 0 <= x <= 2 and y >= 0 and x + y <= 4; "
 		"x,0 : 3 <= x <= 4 }" },
-	{ 1 , "{ i0, i1 : i0 <= 122 and i0 >= 1 and 128i1 >= -249 + i0 and "
+	{ 1, "{ i0, i1 : i0 <= 122 and i0 >= 1 and 128i1 >= -249 + i0 and "
 			"i1 <= 0; "
 		"i0, 0 : i0 >= 123 and i0 <= 124 }" },
+	{ 1, "{ 0,0; 1,1 }" },
+	{ 1, "n -> { k : 16k <= -1 + n and k >= 1; 0 : n >= 2 }" },
+	{ 1, "{ k, ii, k - ii : ii >= -6 + k and ii <= 6 and ii >= 1 and "
+				"ii <= k;"
+		"k, 0, k : k <= 6 and k >= 1 }" },
+	{ 1, "{ i,j : i = 4 j and 0 <= i <= 100;"
+		"i,j : 1 <= i <= 100 and i >= 4j + 1 and i <= 4j + 2 }" },
+	{ 1, "{ x,y : x % 2 = 0 and y % 2 = 0; x,x : x % 2 = 0 }" },
+	{ 1, "n -> { 1 : n >= 0;"
+		    "x : exists (e0 = floor((x)/2): x >= 2 and "
+			"2e0 >= -1 + x and 2e0 <= x and 2e0 <= n) }" },
+	{ 1, "n -> { x, y : exists (e0 = floor((x)/2), e1 = floor((y)/3): "
+			"3e1 = y and x >= 2 and 2e0 >= -1 + x and "
+			"2e0 <= x and 2e0 <= n);"
+		    "1, y : exists (e0 = floor((y)/3): 3e0 = y and "
+			"n >= 0) }" },
+	{ 1, "t1 -> { i0 : (exists (e0 = floor((63t1)/64): "
+				"128e0 >= -134 + 127t1 and t1 >= 2 and "
+				"64e0 <= 63t1 and 64e0 >= -63 + 63t1)) or "
+				"t1 = 1 }" },
+	{ 1, "{ i, i : exists (e0 = floor((1 + 2i)/3): 3e0 <= 2i and "
+				"3e0 >= -1 + 2i and i <= 9 and i >= 1);"
+		"0, 0 }" },
+	{ 1, "{ t1 : exists (e0 = floor((-11 + t1)/2): 2e0 = -11 + t1 and "
+				"t1 >= 13 and t1 <= 16);"
+		"t1 : t1 <= 15 and t1 >= 12 }" },
+	{ 1, "{ x,y : x = 3y and 0 <= y <= 2; -3,-1 }" },
+	{ 1, "{ x,y : 2x = 3y and 0 <= y <= 4; -3,-2 }" },
+	{ 0, "{ x,y : 2x = 3y and 0 <= y <= 4; -2,-2 }" },
+	{ 0, "{ x,y : 2x = 3y and 0 <= y <= 4; -3,-1 }" },
+	{ 1, "{ i : exists j : i = 4 j and 0 <= i <= 100;"
+		"i : exists j : 1 <= i <= 100 and i >= 4j + 1 and "
+				"i <= 4j + 2 }" },
+	{ 1, "{ c0 : (exists (e0 : c0 - 1 <= 3e0 <= c0)) or "
+		"(exists (e0 : 3e0 = -2 + c0)) }" },
+	{ 0, "n, b0, t0 -> "
+		"{ i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12 : "
+		"(exists (e0 = floor((-32b0 + i4)/1048576), "
+		"e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
+		"n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
+		"32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 >= 8 + n and "
+		"3i4 <= -96 + 3t0 + i0 and 3i4 >= -95 - n + 3t0 + i0 and "
+		"i8 >= -157 + i0 - 4i4 and i8 >= 0 and "
+		"i8 <= -33 + i0 - 4i4 and 3i8 <= -91 + 4n - i0)) or "
+		"(exists (e0 = floor((-32b0 + i4)/1048576), "
+		"e1 = floor((i8)/32): 1048576e0 = -32b0 + i4 and 32e1 = i8 and "
+		"n <= 2147483647 and b0 <= 32767 and b0 >= 0 and "
+		"32b0 <= -2 + n and t0 <= 31 and t0 >= 0 and i0 <= 7 + n and "
+		"4i4 <= -3 + i0 and 3i4 <= -96 + 3t0 + i0 and "
+		"3i4 >= -95 - n + 3t0 + i0 and i8 >= -157 + i0 - 4i4 and "
+		"i8 >= 0 and i8 <= -4 + i0 - 3i4 and i8 <= -41 + i0));"
+		"i0, i1, i2, i3, 0, i5, i6, i7, i8, i9, i10, i11, i12 : "
+		"(exists (e0 = floor((i8)/32): b0 = 0 and 32e0 = i8 and "
+		"n <= 2147483647 and t0 <= 31 and t0 >= 0 and i0 >= 11 and "
+		"i0 >= 96 - 3t0 and i0 <= 95 + n - 3t0 and i0 <= 7 + n and "
+		"i8 >= -40 + i0 and i8 <= -10 + i0)) }" },
+	{ 0, "{ i0, i1, i2 : "
+		"(exists (e0, e1 = floor((i0)/32), e2 = floor((i1)/32): "
+		"32e1 = i0 and 32e2 = i1 and i1 >= -31 + i0 and "
+		"i1 <= 31 + i0 and i2 >= -30 + i0 and i2 >= -30 + i1 and "
+		"32e0 >= -30 + i0 and 32e0 >= -30 + i1 and "
+		"32e0 >= -31 + i2 and 32e0 <= 30 + i2 and 32e0 <= 31 + i1 and "
+		"32e0 <= 31 + i0)) or "
+		"i0 >= 0 }" },
+	{ 1, "{ a, b, c : 2b = 1 + a and 2c = 2 + a; 0, 0, 0 }" },
+	{ 1, "{ a, a, b, c : 32*floor((a)/32) = a and 2*floor((b)/2) = b and "
+				"2*floor((c)/2) = c and 0 <= a <= 192;"
+		"224, 224, b, c : 2*floor((b)/2) = b and 2*floor((c)/2) = c }"
+	},
+	{ 1, "n -> { a,b : (exists e : 1 <= a <= 7e and 9e <= b <= n) or "
+				"(0 <= a <= b <= n) }" },
+	{ 1, "{ a, b : 0 <= a <= 2 and b >= 0 and "
+		"((0 < b <= 13) or (2*floor((a + b)/2) >= -5 + a + 2b)) }" },
+	{ 1, "{ a : (2 <= a <= 5) or (a mod 2 = 1 and 1 <= a <= 5) }" },
+	{ 1, "{ a, b, c : (b = -1 + a and 0 < a <= 3 and "
+				"9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
+			"(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
+				"b = 3 and 9e0 <= -19 + 2c)) }" },
+	{ 1, "{ a, b, c : (b = -1 + a and 0 < a <= 3 and "
+				"9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
+			"(a = 4 and b = 3 and "
+				"9*floor((-16 + 2c)/9) <= -19 + 2c) }" },
+	{ 0, "{ a, b, c : (b <= 2 and b <= -2 + a) or "
+			"(b = -1 + a and 0 < a <= 3 and "
+				"9*floor((-4a + 2c)/9) <= -3 - 4a + 2c) or "
+			"(exists (e0 = floor((-16 + 2c)/9): a = 4 and "
+				"b = 3 and 9e0 <= -19 + 2c)) }" },
+	{ 1, "{ y, x : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
+		"1, 0 }" },
+	{ 1, "{ x, y : (x - y) mod 3 = 2 and 2 <= y <= 200 and 0 <= x <= 2;"
+		"0, 1 }" },
+	{ 1, "{ 1, y : -1 <= y <= 1; x, -x : 0 <= x <= 1 }" },
+	{ 1, "{ 1, y : 0 <= y <= 1; x, -x : 0 <= x <= 1 }" },
+	{ 1, "{ x, y : 0 <= x <= 10 and x - 4*floor(x/4) <= 1 and y <= 0; "
+	       "x, y : 0 <= x <= 10 and x - 4*floor(x/4) > 1 and y <= 0; "
+	       "x, y : 0 <= x <= 10 and x - 5*floor(x/5) <= 1 and 0 < y; "
+	       "x, y : 0 <= x <= 10 and x - 5*floor(x/5) > 1 and 0 < y }" },
+	{ 1, "{ x, 0 : 0 <= x <= 10 and x mod 2 = 0; "
+	       "x, 0 : 0 <= x <= 10 and x mod 2 = 1; "
+	       "x, y : 0 <= x <= 10 and 1 <= y <= 10 }" },
+	{ 1, "{ a : a <= 8 and "
+			"(a mod 10 = 7 or a mod 10 = 8 or a mod 10 = 9) }" },
+	{ 1, "{ x, y : 2y = -x and x <= 0 or "
+			"x <= -1 and 2y <= -x - 1 and 2y >= x - 1 }" },
+	{ 0, "{ x, y : 2y = -x and x <= 0 or "
+			"x <= -2 and 2y <= -x - 1 and 2y >= x - 1 }" },
+	{ 1, "{ a : (a <= 0 and 3*floor((a)/3) = a) or "
+			"(a < 0 and 3*floor((a)/3) < a) }" },
+	{ 1, "{ a : (a <= 0 and 3*floor((a)/3) = a) or "
+			"(a < -1 and 3*floor((a)/3) < a) }" },
+	{ 1, "{ a, b : a <= 1024 and b >= 0 and "
+		"((-31 - a + b <= 32*floor((-1 - a)/32) <= -33 + b and "
+		  "32*floor((-1 - a)/32) <= -16 + b + 16*floor((-1 - a)/16))"
+		"or (2 <= a <= 15 and b < a)) }" },
+	{ 1, "{ a : a > 0 and ((16*floor((a)/16) < a and "
+			"32*floor((a)/32) < a) or a <= 15) }" },
+	{ 1, "{ a, b, c, d : (-a + d) mod 64 = 0 and a <= 8 and b <= 1 and "
+			"10 - a <= c <= 3 and d >= 5 and 9 - 64b <= d <= 70;"
+	    "a, b = 1, c, d : (-a + d) mod 64 = 0 and a <= 8 and c >= 4 and "
+			"10 - a <= c <= 5 and 5 <= d <= 73 - c }" },
+	{ 1, "n, m -> { S_0i : (-n + i) mod 3 = 0 and m >= 3 + n and "
+			    "i >= n and 3*floor((2 + n + 2m)/3) <= n + 3m - i; "
+			 "S_0n : n <= m <= 2 + n }" },
+	{ 1, "{ a, b : exists (e0: 0 <= a <= 1 and b >= 0 and "
+			"2e0 >= -5 + a + 2b and 2e0 >= -1 + a + b and "
+			"2e0 <= a + b); "
+		"a, b : exists (e0: 0 <= a <= 1 and 2e0 >= -5 + a + 2b and "
+			"2e0 >= -1 - a + b and 2e0 <= -a + b and "
+			"2e0 < -a + 2b) }" },
+	{ 1, "{ i, j, i - 8j : 8 <= i <= 63 and -7 + i <= 8j <= i; "
+		"i, 0, i : 0 <= i <= 7 }" },
+	{ 1, "{ a, b : a >= 0 and 0 <= b <= 1 - a; 1, 1 }" },
+	{ 0, "{ a, b : a >= 0 and 0 <= b <= 1 - a; 0, 2 }" },
+	{ 0, "{ a, b : a >= 0 and 0 <= b <= 1 - a; -1, 3 }" },
+	{ 1, "{ a, b : a, b >= 0 and a + 2b <= 2; 1, 1 }" },
+	{ 0, "{ a, b : a, b >= 0 and a + 2b <= 2; 2, 1 }" },
+	{ 0, "{ a, c : (2 + a) mod 4 = 0 or "
+		"(c = 4 + a and 4 * floor((a)/4) = a and a >= 0 and a <= 4) or "
+		"(c = 3 + a and 4 * floor((-1 + a)/4) = -1 + a and "
+		    "a > 0 and a <= 5) }" },
+	{ 1, "{ 1, 0, 0; a, b, c : -1 <= -a < b <= 0 and 2c > b }" },
+	{ 0, "{ j, a, l : a mod 2 = 0 and j <= 29 and a >= 2 and "
+			"2a <= -5 + j and 32j + 2a + 2 <= 4l < 33j; "
+		"j, 0, l : 4 <= j <= 29 and -3 + 33j <= 4l <= 33j }" },
+	{ 0, "{ 0:1, 0:1; 0, 2:3 }" },
+	{ 1, "{ a : (a = 0 or ((1 + a) mod 2 = 0 and 0 < a <= 15) or "
+		"((a) mod 2 = 0 and 0 < a <= 15)) }" },
 };
 
+/* A specialized coalescing test case that would result
+ * in a segmentation fault or a failed assertion in earlier versions of isl.
+ */
+static int test_coalesce_special(struct isl_ctx *ctx)
+{
+	const char *str;
+	isl_map *map1, *map2;
+
+	str = "y -> { S_L220_OUT -> T7 -> "
+	    "S_L309_IN -> T11 -> ce_imag21, o1 : "
+	    "(y = 201 and o1 <= 239 and o1 >= 212) or "
+	    "(exists (e0 = (y)/3: 3e0 = y and y <= 198 and y >= 3 and "
+		"o1 <= 239 and o1 >= 212)) or "
+	    "(exists (e0 = (y)/3: 3e0 = y and y <= 201 and y >= 3 and "
+		"o1 <= 241 and o1 >= 240));"
+	    "S_L220_OUT -> T7 -> "
+	    "S_L309_IN -> T11 -> ce_imag20, o1 : "
+	    "(y = 2 and o1 <= 241 and o1 >= 212) or "
+	    "(exists (e0 = (-2 + y)/3: 3e0 = -2 + y and y <= 200 and "
+		"y >= 5 and o1 <= 241 and o1 >= 212)) }";
+	map1 = isl_map_read_from_str(ctx, str);
+	map1 = isl_map_align_divs_internal(map1);
+	map1 = isl_map_coalesce(map1);
+	str = "y -> { S_L220_OUT -> T7 -> "
+	    "S_L309_IN -> T11 -> ce_imag2o0, o1 : "
+	    "exists (e0 = (-1 - y + o0)/3: 3e0 = -1 - y + o0 and "
+		"y <= 201 and o0 <= 2 and o1 >= 212 and o1 <= 241 and "
+		"o0 >= 3 - y and o0 <= -2 + y and o0 >= 0) }";
+	map2 = isl_map_read_from_str(ctx, str);
+	map2 = isl_map_union(map2, map1);
+	map2 = isl_map_align_divs_internal(map2);
+	map2 = isl_map_coalesce(map2);
+	isl_map_free(map2);
+	if (!map2)
+		return -1;
+
+	return 0;
+}
+
+/* A specialized coalescing test case that would result in an assertion
+ * in an earlier version of isl.
+ * The explicit call to isl_basic_set_union prevents the implicit
+ * equality constraints in the first basic map from being detected prior
+ * to the call to isl_set_coalesce, at least at the point
+ * where this test case was introduced.
+ */
+static int test_coalesce_special2(struct isl_ctx *ctx)
+{
+	const char *str;
+	isl_basic_set *bset1, *bset2;
+	isl_set *set;
+
+	str = "{ x, y : x, y >= 0 and x + 2y <= 1 and 2x + y <= 1 }";
+	bset1 = isl_basic_set_read_from_str(ctx, str);
+	str = "{ x,0 : -1 <= x <= 1 and x mod 2 = 1 }" ;
+	bset2 = isl_basic_set_read_from_str(ctx, str);
+	set = isl_basic_set_union(bset1, bset2);
+	set = isl_set_coalesce(set);
+	isl_set_free(set);
+
+	if (!set)
+		return -1;
+	return 0;
+}
+
+/* Check that calling isl_set_coalesce does not leave other sets
+ * that may share some information with the input to isl_set_coalesce
+ * in an inconsistent state.
+ * In particular, older versions of isl would modify all copies
+ * of the basic sets in the isl_set_coalesce input in a way
+ * that could leave them in an inconsistent state.
+ * The result of printing any other set containing one of these
+ * basic sets would then result in an invalid set description.
+ */
+static int test_coalesce_special3(isl_ctx *ctx)
+{
+	const char *str;
+	char *s;
+	isl_set *set1, *set2;
+	isl_printer *p;
+
+	set1 = isl_set_read_from_str(ctx, "{ 0, 0, 0 }");
+	str = "{ a, b, a + b : a >= 0 and b >= 0 and 0 < a + b }";
+	set2 = isl_set_read_from_str(ctx, str);
+	set1 = isl_set_union(set1, isl_set_copy(set2));
+	set1 = isl_set_coalesce(set1);
+	isl_set_free(set1);
+
+	p = isl_printer_to_str(ctx);
+	p = isl_printer_print_set(p, set2);
+	isl_set_free(set2);
+	s = isl_printer_get_str(p);
+	isl_printer_free(p);
+	set1 = isl_set_read_from_str(ctx, s);
+	free(s);
+	isl_set_free(set1);
+
+	if (!set1)
+		return -1;
+
+	return 0;
+}
+
+/* Check that calling isl_set_coalesce on the intersection of
+ * the sets described by "s1" and "s2" does not leave other sets
+ * that may share some information with the input to isl_set_coalesce
+ * in an inconsistent state.
+ * In particular, when isl_set_coalesce detects equality constraints,
+ * it does not immediately perform Gaussian elimination on them,
+ * but then it needs to ensure that it is performed at some point.
+ * The input set has implicit equality constraints in the first disjunct.
+ * It is constructed as an intersection, because otherwise
+ * those equality constraints would already be detected during parsing.
+ */
+static isl_stat test_coalesce_intersection(isl_ctx *ctx,
+	const char *s1, const char *s2)
+{
+	isl_set *set1, *set2;
+
+	set1 = isl_set_read_from_str(ctx, s1);
+	set2 = isl_set_read_from_str(ctx, s2);
+	set1 = isl_set_intersect(set1, set2);
+	isl_set_free(isl_set_coalesce(isl_set_copy(set1)));
+	set1 = isl_set_coalesce(set1);
+	isl_set_free(set1);
+
+	if (!set1)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Check that calling isl_set_coalesce does not leave other sets
+ * that may share some information with the input to isl_set_coalesce
+ * in an inconsistent state, for the case where one disjunct
+ * is a subset of the other.
+ */
+static isl_stat test_coalesce_special4(isl_ctx *ctx)
+{
+	const char *s1, *s2;
+
+	s1 = "{ a, b : b <= 0 or a <= 1 }";
+	s2 = "{ a, b : -1 <= -a < b }";
+	return test_coalesce_intersection(ctx, s1, s2);
+}
+
+/* Check that calling isl_set_coalesce does not leave other sets
+ * that may share some information with the input to isl_set_coalesce
+ * in an inconsistent state, for the case where two disjuncts
+ * can be fused.
+ */
+static isl_stat test_coalesce_special5(isl_ctx *ctx)
+{
+	const char *s1, *s2;
+
+	s1 = "{ a, b, c : b <= 0 }";
+	s2 = "{ a, b, c : -1 <= -a < b and (c >= 0 or c < 0) }";
+	return test_coalesce_intersection(ctx, s1, s2);
+}
+
+/* Check that calling isl_set_coalesce does not leave other sets
+ * that may share some information with the input to isl_set_coalesce
+ * in an inconsistent state, for the case where two disjuncts
+ * can be fused and where both disjuncts have implicit equality constraints.
+ */
+static isl_stat test_coalesce_special6(isl_ctx *ctx)
+{
+	const char *s1, *s2;
+
+	s1 = "{ a, b, c : c <= 0 }";
+	s2 = "{ a, b, c : 0 <= a <= b <= c or (0 <= b <= c and a > 0) }";
+	return test_coalesce_intersection(ctx, s1, s2);
+}
+
 /* Test the functionality of isl_set_coalesce.
  * That is, check that the output is always equal to the input
  * and in some cases that the result consists of a single disjunct.
@@ -1431,17 +2527,72 @@
 
 	if (test_coalesce_unbounded_wrapping(ctx) < 0)
 		return -1;
+	if (test_coalesce_special(ctx) < 0)
+		return -1;
+	if (test_coalesce_special2(ctx) < 0)
+		return -1;
+	if (test_coalesce_special3(ctx) < 0)
+		return -1;
+	if (test_coalesce_special4(ctx) < 0)
+		return -1;
+	if (test_coalesce_special5(ctx) < 0)
+		return -1;
+	if (test_coalesce_special6(ctx) < 0)
+		return -1;
+
 
 	return 0;
 }
 
-void test_closure(struct isl_ctx *ctx)
+/* Construct a representation of the graph on the right of Figure 1
+ * in "Computing the Transitive Closure of a Union of
+ * Affine Integer Tuple Relations".
+ */
+static __isl_give isl_map *cocoa_fig_1_right_graph(isl_ctx *ctx)
 {
-	const char *str;
 	isl_set *dom;
 	isl_map *up, *right;
+
+	dom = isl_set_read_from_str(ctx,
+		"{ x,y : x >= 0 and -2 x + 3 y >= 0 and x <= 3 and "
+			"2 x - 3 y + 3 >= 0 }");
+	right = isl_map_read_from_str(ctx,
+		"{ x,y -> x2,y2 : x2 = x + 1 and y2 = y }");
+	up = isl_map_read_from_str(ctx,
+		"{ x,y -> x2,y2 : x2 = x and y2 = y + 1 }");
+	right = isl_map_intersect_domain(right, isl_set_copy(dom));
+	right = isl_map_intersect_range(right, isl_set_copy(dom));
+	up = isl_map_intersect_domain(up, isl_set_copy(dom));
+	up = isl_map_intersect_range(up, dom);
+	return isl_map_union(up, right);
+}
+
+/* Construct a representation of the power of the graph
+ * on the right of Figure 1 in "Computing the Transitive Closure of
+ * a Union of Affine Integer Tuple Relations".
+ */
+static __isl_give isl_map *cocoa_fig_1_right_power(isl_ctx *ctx)
+{
+	return isl_map_read_from_str(ctx,
+		"{ 1 -> 0,0 -> 0,1; 2 -> 0,0 -> 1,1; "
+		"  1 -> 0,1 -> 1,1; 1 -> 2,2 -> 3,2; "
+		"  2 -> 2,2 -> 3,3; 1 -> 3,2 -> 3,3 }");
+}
+
+/* Construct a representation of the transitive closure of the graph
+ * on the right of Figure 1 in "Computing the Transitive Closure of
+ * a Union of Affine Integer Tuple Relations".
+ */
+static __isl_give isl_map *cocoa_fig_1_right_tc(isl_ctx *ctx)
+{
+	return isl_set_unwrap(isl_map_range(cocoa_fig_1_right_power(ctx)));
+}
+
+static int test_closure(isl_ctx *ctx)
+{
+	const char *str;
 	isl_map *map, *map2;
-	int exact;
+	isl_bool exact, equal;
 
 	/* COCOA example 1 */
 	map = isl_map_read_from_str(ctx,
@@ -1550,28 +2701,27 @@
 	isl_map_free(map2);
 	isl_map_free(map);
 
-	/* COCOA Fig.1 right */
-	dom = isl_set_read_from_str(ctx,
-		"{ x,y : x >= 0 and -2 x + 3 y >= 0 and x <= 3 and "
-			"2 x - 3 y + 3 >= 0 }");
-	right = isl_map_read_from_str(ctx,
-		"{ x,y -> x2,y2 : x2 = x + 1 and y2 = y }");
-	up = isl_map_read_from_str(ctx,
-		"{ x,y -> x2,y2 : x2 = x and y2 = y + 1 }");
-	right = isl_map_intersect_domain(right, isl_set_copy(dom));
-	right = isl_map_intersect_range(right, isl_set_copy(dom));
-	up = isl_map_intersect_domain(up, isl_set_copy(dom));
-	up = isl_map_intersect_range(up, dom);
-	map = isl_map_union(up, right);
+	map = cocoa_fig_1_right_graph(ctx);
 	map = isl_map_transitive_closure(map, &exact);
 	assert(exact);
-	map2 = isl_map_read_from_str(ctx,
-		"{ 0,0 -> 0,1; 0,0 -> 1,1; 0,1 -> 1,1; "
-		"  2,2 -> 3,2; 2,2 -> 3,3; 3,2 -> 3,3 }");
+	map2 = cocoa_fig_1_right_tc(ctx);
 	assert(isl_map_is_equal(map, map2));
 	isl_map_free(map2);
 	isl_map_free(map);
 
+	map = cocoa_fig_1_right_graph(ctx);
+	map = isl_map_power(map, &exact);
+	map2 = cocoa_fig_1_right_power(ctx);
+	equal = isl_map_is_equal(map, map2);
+	isl_map_free(map2);
+	isl_map_free(map);
+	if (equal < 0)
+		return -1;
+	if (!exact)
+		isl_die(ctx, isl_error_unknown, "power not exact", return -1);
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "unexpected power", return -1);
+
 	/* COCOA Theorem 1 counter example */
 	map = isl_map_read_from_str(ctx,
 		"{ i,j -> i2,j2 : i = 0 and 0 <= j and j <= 1 and "
@@ -1672,21 +2822,122 @@
 	map = isl_map_transitive_closure(map, NULL);
 	assert(map);
 	isl_map_free(map);
+
+	return 0;
 }
 
-void test_lex(struct isl_ctx *ctx)
+/* Check that the actual result of a boolean operation is equal
+ * to the expected result.
+ */
+static isl_stat check_bool(isl_ctx *ctx, isl_bool actual, isl_bool expected)
 {
-	isl_space *dim;
+	if (actual != expected)
+		isl_die(ctx, isl_error_unknown,
+			"incorrect boolean operation", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Test operations on isl_bool values.
+ *
+ * This tests:
+ *
+ * 	isl_bool_not
+ * 	isl_bool_ok
+ */
+static int test_isl_bool(isl_ctx *ctx)
+{
+	if (check_bool(ctx, isl_bool_not(isl_bool_true), isl_bool_false) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_not(isl_bool_false), isl_bool_true) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_not(isl_bool_error), isl_bool_error) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_ok(0), isl_bool_false) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_ok(1), isl_bool_true) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_ok(-1), isl_bool_true) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_ok(2), isl_bool_true) < 0)
+		return -1;
+	if (check_bool(ctx, isl_bool_ok(-2), isl_bool_true) < 0)
+		return -1;
+
+	return 0;
+}
+
+static int test_lex(struct isl_ctx *ctx)
+{
+	isl_space *space;
 	isl_map *map;
+	int empty;
 
-	dim = isl_space_set_alloc(ctx, 0, 0);
-	map = isl_map_lex_le(dim);
-	assert(!isl_map_is_empty(map));
+	space = isl_space_set_alloc(ctx, 0, 0);
+	map = isl_map_lex_le(space);
+	empty = isl_map_is_empty(map);
 	isl_map_free(map);
+
+	if (empty < 0)
+		return -1;
+	if (empty)
+		isl_die(ctx, isl_error_unknown,
+			"expecting non-empty result", return -1);
+
+	return 0;
 }
 
+/* Inputs for isl_map_lexmin tests.
+ * "map" is the input and "lexmin" is the expected result.
+ */
+struct {
+	const char *map;
+	const char *lexmin;
+} lexmin_tests  = {
+	{ "{ x -> y : x <= y <= 10; x -> 5 : -8 <= x <= 8 }",
+	  "{ x -> 5 : 6 <= x <= 8; "
+	    "x -> x : x <= 5 or (9 <= x <= 10) }" },
+	{ "{ x -> y : 4y = x or 4y = -1 + x or 4y = -2 + x }",
+	  "{ x -> y : 4y = x or 4y = -1 + x or 4y = -2 + x }" },
+	{ "{ x -> y : x = 4y; x -> y : x = 2y }",
+	  "{ x -> y : (4y = x and x >= 0) or "
+		"(exists (e0 = (x)/4, e1 = (-2 + x)/4: 2y = x and "
+		"4e1 = -2 + x and 4e0 <= -1 + x and 4e0 >= -3 + x)) or "
+		"(exists (e0 = (x)/4: 2y = x and 4e0 = x and x <= -4)) }" },
+	{ "{ Ta -> Sb, c : a = 4b-2c and c >= b }",
+	  "{ Ta -> Sb, c : 2b = a and 2c = a }" },
+	/* Check that empty pieces are properly combined. */
+	{ "K, N -> { x, y -> a, b : K+2<=N<=K+4 and x>=4 and "
+		"2N-6<=x<K+N and N-1<=a<=K+N-1 and N+b-6<=a<=2N-4 and "
+		"b<=2N-3K+a and 3b<=4N-K+1 and b>=N and a>=x+1 }",
+	  "K, N -> { x, y -> 1 + x, N : x >= -6 + 2N and "
+		"x <= -5 + 2N and x >= -1 + 3K - N and x <= -2 + K + N and "
+		"x >= 4 }" },
+	{ "{ i, k, j -> a, b, c, d : 8*floor((b)/8) = b and k <= 255 and "
+		"a <= 255 and c <= 255 and d <= 255 - j and "
+		"255 - j <= 7d <= 7 - i and 240d <= 239 + a and "
+		"247d <= 247 + k - j and 247d <= 247 + k - b and "
+		"247d <= 247 + i and 248 - b <= 248d <= c and "
+		"254d >= i - a + b and 254d >= -a + b and "
+		"255d >= -i + a - b and 1792d >= -63736 + 257b }",
+	  "{ i, k, j -> "
+	    "-127762 + i + 502j, -62992 + 248j, 63240 - 248j, 255 - j : "
+		"k <= 255 and 7j >= 1778 + i and 246j >= 62738 - k and "
+		"247j >= 62738 - i and 509j <= 129795 + i and "
+		"742j >= 188724 - i; "
+	    "0, k, j -> 1, 0, 248, 1 : k <= 255 and 248 <= j <= 254, k }" },
+	{ "{ a -> b : 0 <= b <= 255 and -509 + a <= 512b < a and "
+			"16*floor((8 + b)/16) <= 7 + b; "
+	    "a -> 1 }",
+	  "{ a -> b = 1 : a >= 510 or a <= 0; "
+	    "a -> b = 0 : 0 < a <= 509 }" },
+	{ "{ rat: i : 1 <= 2i <= 9 }", "{ rat: i : 2i = 1 }" },
+	{ "{ rat: i : 1 <= 2i <= 9 or i >= 10 }", "{ rat: i : 2i = 1 }" },
+	{ "{ rat: i : 21 <= 2i <= 29 or i = 5 }", "{ rat: 5 }" },
+};
+
 static int test_lexmin(struct isl_ctx *ctx)
 {
+	int i;
 	int equal;
 	const char *str;
 	isl_basic_map *bmap;
@@ -1710,6 +2961,8 @@
 	map = isl_map_read_from_str(ctx, str);
 	map = isl_map_lexmin(map);
 	isl_map_free(map);
+	if (!map)
+		return -1;
 
 	str = "C -> { obj,a,b,c : obj <= 38 a + 7 b + 10 c and "
 	    "a + b <= 1 and c <= 10 b and c <= C and a,b,c,C >= 0 }";
@@ -1721,35 +2974,20 @@
 	assert(!isl_set_is_empty(set));
 	isl_set_free(set);
 
-	str = "{ x -> y : x <= y <= 10; x -> 5 : -8 <= x <= 8 }";
-	map = isl_map_read_from_str(ctx, str);
-	map = isl_map_lexmin(map);
-	str = "{ x -> 5 : 6 <= x <= 8; "
-		"x -> x : x <= 5 or (9 <= x <= 10) }";
-	map2 = isl_map_read_from_str(ctx, str);
-	assert(isl_map_is_equal(map, map2));
-	isl_map_free(map);
-	isl_map_free(map2);
-
-	str = "{ x -> y : 4y = x or 4y = -1 + x or 4y = -2 + x }";
-	map = isl_map_read_from_str(ctx, str);
-	map2 = isl_map_copy(map);
-	map = isl_map_lexmin(map);
-	assert(isl_map_is_equal(map, map2));
-	isl_map_free(map);
-	isl_map_free(map2);
+	for (i = 0; i < ARRAY_SIZE(lexmin_tests); ++i) {
+		map = isl_map_read_from_str(ctx, lexmin_testsi.map);
+		map = isl_map_lexmin(map);
+		map2 = isl_map_read_from_str(ctx, lexmin_testsi.lexmin);
+		equal = isl_map_is_equal(map, map2);
+		isl_map_free(map);
+		isl_map_free(map2);
 
-	str = "{ x -> y : x = 4y; x -> y : x = 2y }";
-	map = isl_map_read_from_str(ctx, str);
-	map = isl_map_lexmin(map);
-	str = "{ x -> y : (4y = x and x >= 0) or "
-		"(exists (e0 = (x)/4, e1 = (-2 + x)/4: 2y = x and "
-		"4e1 = -2 + x and 4e0 <= -1 + x and 4e0 >= -3 + x)) or "
-		"(exists (e0 = (x)/4: 2y = x and 4e0 = x and x <= -4)) }";
-	map2 = isl_map_read_from_str(ctx, str);
-	assert(isl_map_is_equal(map, map2));
-	isl_map_free(map);
-	isl_map_free(map2);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
 
 	str = "{ i -> i', j : j = i - 8i' and i' >= 0 and i' <= 7 and "
 				" 8i' <= i and 8i' >= -7 + i }";
@@ -1761,29 +2999,6 @@
 	isl_map_free(map);
 	isl_map_free(map2);
 
-	str = "{ Ta -> Sb, c : a = 4b-2c and c >= b }";
-	map = isl_map_read_from_str(ctx, str);
-	map = isl_map_lexmin(map);
-	str = "{ Ta -> Sb, c : 2b = a and 2c = a }";
-	map2 = isl_map_read_from_str(ctx, str);
-	assert(isl_map_is_equal(map, map2));
-	isl_map_free(map);
-	isl_map_free(map2);
-
-	/* Check that empty pieces are properly combined. */
-	str = "K, N -> { x, y -> a, b : K+2<=N<=K+4 and x>=4 and "
-		"2N-6<=x<K+N and N-1<=a<=K+N-1 and N+b-6<=a<=2N-4 and "
-		"b<=2N-3K+a and 3b<=4N-K+1 and b>=N and a>=x+1 }";
-	map = isl_map_read_from_str(ctx, str);
-	map = isl_map_lexmin(map);
-	str = "K, N -> { x, y -> 1 + x, N : x >= -6 + 2N and "
-		"x <= -5 + 2N and x >= -1 + 3K - N and x <= -2 + K + N and "
-		"x >= 4 }";
-	map2 = isl_map_read_from_str(ctx, str);
-	assert(isl_map_is_equal(map, map2));
-	isl_map_free(map);
-	isl_map_free(map2);
-
 	str = "i -> { i', j : j = i - 8i' and i' >= 0 and i' <= 7 and "
 				" 8i' <= i and 8i' >= -7 + i }";
 	set = isl_set_read_from_str(ctx, str);
@@ -1802,35 +3017,206 @@
 	return 0;
 }
 
-/* Check that isl_set_min_val and isl_set_max_val compute the correct
- * result on non-convex inputs.
+/* Inputs for isl_pw_multi_aff_max_multi_val tests.
+ * "pma" is the input.
+ * "res" is the expected result.
  */
-static int test_min(struct isl_ctx *ctx)
+static struct {
+	const char *pma;
+	const char *res;
+} opt_pw_tests = {
+	{ "{ -1 -> -1; 1 -> 1 }", "{ 1 }" },
+	{ "{ a, b -> floor((b - 2*floor((-a)/4))/5) : "
+	    "0 <= a, b <= 100 and b mod 2 = 0}", "{ 30 }" },
+	{ "N -> { i,j -> Ai, -i, i + j : 0 <= i,j <= N <= 10 }",
+	  "{ A10, 0, 20 }" },
+	{ "N -> {AN, -N, 2N : 0 <= N }", "{ Ainfty, 0, infty }" },
+};
+
+/* Perform basic isl_pw_multi_aff_max_multi_val tests.
+ */
+static isl_stat test_pw_max(struct isl_ctx *ctx)
 {
+	int i;
+	isl_pw_multi_aff *pma;
+	isl_multi_val *mv;
+	isl_stat r;
+
+	for (i = 0; i < ARRAY_SIZE(opt_pw_tests); ++i) {
+		pma = isl_pw_multi_aff_read_from_str(ctx, opt_pw_testsi.pma);
+		mv = isl_pw_multi_aff_max_multi_val(pma);
+		r = multi_val_check_plain_equal(mv, opt_pw_testsi.res);
+		isl_multi_val_free(mv);
+
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* A specialized isl_set_min_val test case that would return the wrong result
+ * in earlier versions of isl.
+ * The explicit call to isl_basic_set_union prevents the second basic set
+ * from being determined to be empty prior to the call to isl_set_min_val,
+ * at least at the point where this test case was introduced.
+ */
+static int test_min_special(isl_ctx *ctx)
+{
+	const char *str;
+	isl_basic_set *bset1, *bset2;
 	isl_set *set;
-	isl_aff *aff;
-	isl_val *val;
-	int min_ok, max_ok;
+	isl_aff *obj;
+	isl_val *res;
+	int ok;
 
-	set = isl_set_read_from_str(ctx, "{ -1; 1 }");
-	aff = isl_aff_read_from_str(ctx, "{ x -> x }");
-	val = isl_set_min_val(set, aff);
-	min_ok = isl_val_is_negone(val);
-	isl_val_free(val);
-	val = isl_set_max_val(set, aff);
-	max_ok = isl_val_is_one(val);
-	isl_val_free(val);
-	isl_aff_free(aff);
+	str = "{ a, b : a >= 2 and b >= 0 and 14 - a <= b <= 9 }";
+	bset1 = isl_basic_set_read_from_str(ctx, str);
+	str = "{ a, b : 1 <= a, b and a + b <= 1 }";
+	bset2 = isl_basic_set_read_from_str(ctx, str);
+	set = isl_basic_set_union(bset1, bset2);
+	obj = isl_aff_read_from_str(ctx, "{ a, b -> a }");
+
+	res = isl_set_min_val(set, obj);
+	ok = isl_val_cmp_si(res, 5) == 0;
+
+	isl_aff_free(obj);
 	isl_set_free(set);
+	isl_val_free(res);
 
-	if (min_ok < 0 || max_ok < 0)
+	if (!res)
+		return -1;
+	if (!ok)
+		isl_die(ctx, isl_error_unknown, "unexpected minimum",
+			return -1);
+
+	return 0;
+}
+
+/* A specialized isl_set_min_val test case that would return an error
+ * in earlier versions of isl.
+ */
+static int test_min_special2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_basic_set *bset;
+	isl_aff *obj;
+	isl_val *res;
+
+	str = "{ i, j, k : 2j = i and 2k = i + 1 and i >= 2 }";
+	bset = isl_basic_set_read_from_str(ctx, str);
+
+	obj = isl_aff_read_from_str(ctx, "{ i, j, k -> i }");
+
+	res = isl_basic_set_max_val(bset, obj);
+
+	isl_basic_set_free(bset);
+	isl_aff_free(obj);
+	isl_val_free(res);
+
+	if (!res)
+		return -1;
+
+	return 0;
+}
+
+/* Check that the result of isl_set_min_multi_pw_aff
+ * on the union of the sets with string descriptions "s1" and "s2"
+ * consists of a single expression (on a single cell).
+ */
+static isl_stat check_single_expr_min(isl_ctx *ctx, const char *s1,
+	const char *s2)
+{
+	isl_size n;
+	isl_set *set1, *set2;
+	isl_multi_pw_aff *mpa;
+	isl_pw_multi_aff *pma;
+
+	set1 = isl_set_read_from_str(ctx, s1);
+	set2 = isl_set_read_from_str(ctx, s2);
+	set1 = isl_set_union(set1, set2);
+	mpa = isl_set_min_multi_pw_aff(set1);
+	pma = isl_pw_multi_aff_from_multi_pw_aff(mpa);
+	n = isl_pw_multi_aff_n_piece(pma);
+	isl_pw_multi_aff_free(pma);
+
+	if (n < 0)
+		return isl_stat_error;
+	if (n != 1)
+		isl_die(ctx, isl_error_unknown, "expecting single expression",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* A specialized isl_set_min_multi_pw_aff test that checks
+ * that the minimum of 2N and 3N for N >= 0 is represented
+ * by a single expression, without splitting off the special case N = 0.
+ * Do this for both orderings.
+ */
+static int test_min_mpa(isl_ctx *ctx)
+{
+	const char *s1, *s2;
+
+	s1 = "N=0: -> { 1, 3N: }";
+	s2 = "N=0: -> { 10, 2N: }";
+	if (check_single_expr_min(ctx, s1, s2) < 0)
+		return -1;
+	if (check_single_expr_min(ctx, s2, s1) < 0)
+		return -1;
+
+	return 0;
+}
+
+struct {
+	const char *set;
+	const char *obj;
+	__isl_give isl_val *(*fn)(__isl_keep isl_set *set,
+		__isl_keep isl_aff *obj);
+	const char *res;
+} opt_tests = {
+	{ "{ -1; 1 }", "{ x -> x }", &isl_set_min_val, "-1" },
+	{ "{ -1; 1 }", "{ x -> x }", &isl_set_max_val, "1" },
+	{ "{ a, b : 0 <= a, b <= 100 and b mod 2 = 0}",
+	  "{ a, b -> floor((b - 2*floor((-a)/4))/5) }",
+	  &isl_set_max_val, "30" },
+
+};
+
+/* Perform basic isl_set_min_val and isl_set_max_val tests.
+ * In particular, check the results on non-convex inputs.
+ */
+static int test_min(struct isl_ctx *ctx)
+{
+	int i;
+	isl_set *set;
+	isl_aff *obj;
+	isl_val *val, *res;
+	isl_bool ok;
+
+	for (i = 0; i < ARRAY_SIZE(opt_tests); ++i) {
+		set = isl_set_read_from_str(ctx, opt_testsi.set);
+		obj = isl_aff_read_from_str(ctx, opt_testsi.obj);
+		res = isl_val_read_from_str(ctx, opt_testsi.res);
+		val = opt_testsi.fn(set, obj);
+		ok = isl_val_eq(res, val);
+		isl_val_free(res);
+		isl_val_free(val);
+		isl_aff_free(obj);
+		isl_set_free(set);
+
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected optimum", return -1);
+	}
+
+	if (test_pw_max(ctx) < 0)
+		return -1;
+	if (test_min_special(ctx) < 0)
+		return -1;
+	if (test_min_special2(ctx) < 0)
 		return -1;
-	if (!min_ok)
-		isl_die(ctx, isl_error_unknown,
-			"unexpected minimum", return -1);
-	if (!max_ok)
-		isl_die(ctx, isl_error_unknown,
-			"unexpected maximum", return -1);
 
 	return 0;
 }
@@ -1840,7 +3226,7 @@
 	isl_map *may;
 };
 
-static int collect_must_may(__isl_take isl_map *dep, int must,
+static isl_stat collect_must_may(__isl_take isl_map *dep, int must,
 	void *dep_user, void *user)
 {
 	struct must_may *mm = (struct must_may *)user;
@@ -1850,7 +3236,7 @@
 	else
 		mm->may = isl_map_union(mm->may, dep);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static int common_space(void *first, void *second)
@@ -1887,10 +3273,75 @@
 	return 0;
 }
 
-void test_dep(struct isl_ctx *ctx)
+/* Is "set" equal to the set described by "str"?
+ */
+static isl_bool set_is_equal(__isl_keep isl_set *set, const char *str)
+{
+	isl_set *set2;
+	isl_bool equal;
+
+	if (!set)
+		return isl_bool_error;
+
+	set2 = isl_set_read_from_str(isl_set_get_ctx(set), str);
+	equal = isl_set_is_equal(set, set2);
+	isl_set_free(set2);
+
+	return equal;
+}
+
+/* Check that "set" is equal to the set described by "str".
+ */
+static isl_stat set_check_equal(__isl_keep isl_set *set, const char *str)
+{
+	isl_bool equal;
+
+	equal = set_is_equal(set, str);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_set_get_ctx(set), isl_error_unknown,
+			"result not as expected", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Is "uset" equal to the union set described by "str"?
+ */
+static isl_bool uset_is_equal(__isl_keep isl_union_set *uset, const char *str)
+{
+	isl_union_set *uset2;
+	isl_bool equal;
+
+	if (!uset)
+		return isl_bool_error;
+
+	uset2 = isl_union_set_read_from_str(isl_union_set_get_ctx(uset), str);
+	equal = isl_union_set_is_equal(uset, uset2);
+	isl_union_set_free(uset2);
+
+	return equal;
+}
+
+/* Check that "uset" is equal to the union set described by "str".
+ */
+static isl_stat uset_check_equal(__isl_keep isl_union_set *uset,
+	const char *str)
+{
+	isl_bool equal;
+
+	equal = uset_is_equal(uset, str);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(isl_union_set_get_ctx(uset), isl_error_unknown,
+			"result not as expected", return isl_stat_error);
+	return isl_stat_ok;
+}
+
+static int test_dep(struct isl_ctx *ctx)
 {
 	const char *str;
-	isl_space *dim;
+	isl_space *space;
 	isl_map *map;
 	isl_access_info *ai;
 	isl_flow *flow;
@@ -1912,9 +3363,9 @@
 	ai = isl_access_info_add_source(ai, map, 1, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 3, 3);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 3, 3);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -1942,9 +3393,9 @@
 	ai = isl_access_info_add_source(ai, map, 0, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 3, 3);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 3, 3);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -1971,9 +3422,9 @@
 	ai = isl_access_info_add_source(ai, map, 0, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 3, 3);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 3, 3);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -2001,9 +3452,9 @@
 	ai = isl_access_info_add_source(ai, map, 0, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 3, 3);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 3, 3);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -2031,9 +3482,9 @@
 	ai = isl_access_info_add_source(ai, map, 0, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 3, 3);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 3, 3);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -2059,9 +3510,9 @@
 	ai = isl_access_info_add_source(ai, map, 1, &depth);
 
 	flow = isl_access_info_compute_flow(ai);
-	dim = isl_space_alloc(ctx, 0, 5, 5);
-	mm.must = isl_map_empty(isl_space_copy(dim));
-	mm.may = isl_map_empty(dim);
+	space = isl_space_alloc(ctx, 0, 5, 5);
+	mm.must = isl_map_empty(isl_space_copy(space));
+	mm.may = isl_map_empty(space);
 
 	isl_flow_foreach(flow, collect_must_may, &mm);
 
@@ -2073,6 +3524,8 @@
 	isl_map_free(mm.must);
 	isl_map_free(mm.may);
 	isl_flow_free(flow);
+
+	return 0;
 }
 
 /* Check that the dependence analysis proceeds without errors.
@@ -2140,33 +3593,46 @@
 	return 0;
 }
 
-void test_bijective_case(struct isl_ctx *ctx, const char *str, int bijective)
+struct {
+	const char *str;
+	int bijective;
+} bijective_tests = {
+	{ "N,M->{i,j -> i}", 0 },
+	{ "N,M->{i,j -> i : j=i}", 1 },
+	{ "N,M->{i,j -> i : j=0}", 1 },
+	{ "N,M->{i,j -> i : j=N}", 1 },
+	{ "N,M->{i,j -> j,i}", 1 },
+	{ "N,M->{i,j -> i+j}", 0 },
+	{ "N,M->{i,j -> }", 0 },
+	{ "N,M->{i,j -> i,j,N}", 1 },
+	{ "N,M->{i,j -> 2i}", 0 },
+	{ "N,M->{i,j -> i,i}", 0 },
+	{ "N,M->{i,j -> 2i,i}", 0 },
+	{ "N,M->{i,j -> 2i,j}", 1 },
+	{ "N,M->{i,j -> x,y : 2x=i & y =j}", 1 },
+};
+
+static int test_bijective(struct isl_ctx *ctx)
 {
 	isl_map *map;
+	int i;
+	int bijective;
 
-	map = isl_map_read_from_str(ctx, str);
-	if (bijective)
-		assert(isl_map_is_bijective(map));
-	else
-		assert(!isl_map_is_bijective(map));
-	isl_map_free(map);
-}
+	for (i = 0; i < ARRAY_SIZE(bijective_tests); ++i) {
+		map = isl_map_read_from_str(ctx, bijective_testsi.str);
+		bijective = isl_map_is_bijective(map);
+		isl_map_free(map);
+		if (bijective < 0)
+			return -1;
+		if (bijective_testsi.bijective && !bijective)
+			isl_die(ctx, isl_error_internal,
+				"map not detected as bijective", return -1);
+		if (!bijective_testsi.bijective && bijective)
+			isl_die(ctx, isl_error_internal,
+				"map detected as bijective", return -1);
+	}
 
-void test_bijective(struct isl_ctx *ctx)
-{
-	test_bijective_case(ctx, "N,M->{i,j -> i}", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> i : j=i}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> i : j=0}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> i : j=N}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> j,i}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> i+j}", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> }", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> i,j,N}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> 2i}", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> i,i}", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> 2i,i}", 0);
-	test_bijective_case(ctx, "N,M->{i,j -> 2i,j}", 1);
-	test_bijective_case(ctx, "N,M->{i,j -> x,y : 2x=i & y =j}", 1);
+	return 0;
 }
 
 /* Inputs for isl_pw_qpolynomial_gist tests.
@@ -2184,28 +3650,15 @@
 	{ "{ i -> i^2 : i != 0 }", "{ i : i != 0 }", "{ i -> i^2 }" },
 };
 
-static int test_pwqp(struct isl_ctx *ctx)
+/* Perform some basic isl_pw_qpolynomial_gist tests.
+ */
+static isl_stat test_pwqp_gist(isl_ctx *ctx)
 {
 	int i;
 	const char *str;
 	isl_set *set;
 	isl_pw_qpolynomial *pwqp1, *pwqp2;
-	int equal;
-
-	str = "{ i,j,k -> 1 + 9 * i/5 + 7 * j/11 + 4 * k/13 }";
-	pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
-
-	pwqp1 = isl_pw_qpolynomial_move_dims(pwqp1, isl_dim_param, 0,
-						isl_dim_in, 1, 1);
-
-	str = "j -> { i,k -> 1 + 9 * i/5 + 7 * j/11 + 4 * k/13 }";
-	pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
-
-	pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
-
-	assert(isl_pw_qpolynomial_is_zero(pwqp1));
-
-	isl_pw_qpolynomial_free(pwqp1);
+	isl_bool equal;
 
 	for (i = 0; i < ARRAY_SIZE(pwqp_gist_tests); ++i) {
 		str = pwqp_gist_testsi.pwqp;
@@ -2220,12 +3673,64 @@
 		isl_pw_qpolynomial_free(pwqp1);
 
 		if (equal < 0)
-			return -1;
+			return isl_stat_error;
 		if (!equal)
 			isl_die(ctx, isl_error_unknown,
-				"unexpected result", return -1);
+				"unexpected result", return isl_stat_error);
 	}
 
+	return isl_stat_ok;
+}
+
+/* Perform a basic isl_pw_qpolynomial_max test.
+ */
+static isl_stat test_pwqp_max(isl_ctx *ctx)
+{
+	const char *str;
+	isl_pw_qpolynomial *pwqp;
+	isl_val *v;
+	int ok;
+
+	str = "{ x=2:9, y -> floor((x + 1)/4)^3 - floor((2x)/3)^2 }";
+	pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
+	v = isl_pw_qpolynomial_max(pwqp);
+	ok = isl_val_cmp_si(v, -1) == 0;
+	isl_val_free(v);
+
+	if (!v)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(ctx, isl_error_unknown, "unexpected maximum",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+static int test_pwqp(struct isl_ctx *ctx)
+{
+	const char *str;
+	isl_set *set;
+	isl_pw_qpolynomial *pwqp1, *pwqp2;
+	int equal;
+
+	str = "{ i,j,k -> 1 + 9 * i/5 + 7 * j/11 + 4 * k/13 }";
+	pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
+
+	pwqp1 = isl_pw_qpolynomial_move_dims(pwqp1, isl_dim_param, 0,
+						isl_dim_in, 1, 1);
+
+	str = "j -> { i,k -> 1 + 9 * i/5 + 7 * j/11 + 4 * k/13 }";
+	pwqp2 = isl_pw_qpolynomial_read_from_str(ctx, str);
+
+	pwqp1 = isl_pw_qpolynomial_sub(pwqp1, pwqp2);
+
+	assert(isl_pw_qpolynomial_is_zero(pwqp1));
+
+	isl_pw_qpolynomial_free(pwqp1);
+
+	if (test_pwqp_gist(ctx) < 0)
+		return -1;
+
 	str = "{ i -> ((i/2 + i/2)/5) }";
 	pwqp1 = isl_pw_qpolynomial_read_from_str(ctx, str);
 	str = "{ i -> ((2 * i/2)/5) }";
@@ -2284,10 +3789,13 @@
 	if (!equal)
 		isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
 
+	if (test_pwqp_max(ctx) < 0)
+		return -1;
+
 	return 0;
 }
 
-void test_split_periods(isl_ctx *ctx)
+static int test_split_periods(isl_ctx *ctx)
 {
 	const char *str;
 	isl_pw_qpolynomial *pwqp;
@@ -2298,16 +3806,21 @@
 	pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
 
 	pwqp = isl_pw_qpolynomial_split_periods(pwqp, 2);
-	assert(pwqp);
 
 	isl_pw_qpolynomial_free(pwqp);
+
+	if (!pwqp)
+		return -1;
+
+	return 0;
 }
 
-void test_union(isl_ctx *ctx)
+static int test_union(isl_ctx *ctx)
 {
 	const char *str;
 	isl_union_set *uset1, *uset2;
 	isl_union_map *umap1, *umap2;
+	int equal;
 
 	str = "{ i : 0 <= i <= 1 }";
 	uset1 = isl_union_set_read_from_str(ctx, str);
@@ -2315,11 +3828,17 @@
 	umap1 = isl_union_map_read_from_str(ctx, str);
 
 	umap2 = isl_union_set_lex_gt_union_set(isl_union_set_copy(uset1), uset1);
-	assert(isl_union_map_is_equal(umap1, umap2));
+	equal = isl_union_map_is_equal(umap1, umap2);
 
 	isl_union_map_free(umap1);
 	isl_union_map_free(umap2);
 
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "union maps not equal",
+			return -1);
+
 	str = "{ Ai -> Bi; Bi -> Ci; A0 -> C1 }";
 	umap1 = isl_union_map_read_from_str(ctx, str);
 	str = "{ Ai; Bi }";
@@ -2327,32 +3846,160 @@
 
 	uset2 = isl_union_map_domain(umap1);
 
-	assert(isl_union_set_is_equal(uset1, uset2));
+	equal = isl_union_set_is_equal(uset1, uset2);
 
 	isl_union_set_free(uset1);
 	isl_union_set_free(uset2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "union sets not equal",
+			return -1);
+
+	return 0;
 }
 
-void test_bound(isl_ctx *ctx)
+/* Inputs for basic isl_pw_qpolynomial_bound tests.
+ * "type" is the type of bound that should be computed.
+ * "poly" is a string representation of the input.
+ * "bound" is a string representation of the expected result.
+ * "tight" is set if the result is expected to be tight.
+ */
+static struct {
+	int tight;
+	enum isl_fold type;
+	const char *poly;
+	const char *bound;
+} bound_tests = {
+	/* Check that computing a bound of a non-zero polynomial
+	 * over an unbounded domain does not produce a rational value.
+	 * In particular, check that the upper bound is infinity.
+	 */
+	{ 0, isl_fold_max, "{ m, n -> -m * n }", "{ max(infty) }" },
+	{ 1, isl_fold_max, "{ a, b, c, d -> e -> 0 }",
+	  "{ a, b, c, d -> max(0) }" },
+	{ 1, isl_fold_max, "{ x -> x -> 1 : exists a : x = 2 a }",
+	  "{ x -> max(1) : x mod 2 = 0 }" },
+	{ 1, isl_fold_min, "{ x=5:10 -> (x + 2)^2 }", "{ min(49) }" },
+	{ 1, isl_fold_max, "{ 0:10 -> 1 }", "{ max(1) }" },
+	{ 1, isl_fold_max, "{ m -> 0:m -> m^2 }",
+	  "{ m -> max(m^2) : m >= 0 }" },
+};
+
+/* Check that the bound computation can handle differences
+ * in domain dimension names of the input polynomial and its domain.
+ */
+static isl_stat test_bound_space(isl_ctx *ctx)
 {
 	const char *str;
+	isl_set *set;
 	isl_pw_qpolynomial *pwqp;
 	isl_pw_qpolynomial_fold *pwf;
 
-	str = "{ a, b, c, d -> e -> 0 }";
+	str = "{ c -> c }";
+	set = isl_set_read_from_str(ctx, str);
+	str = "{ a -> b -> 1 }";
 	pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
+	pwqp = isl_pw_qpolynomial_intersect_domain(pwqp, set);
 	pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL);
-	assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 4);
 	isl_pw_qpolynomial_fold_free(pwf);
 
-	str = "{ x->x -> 1 : exists a : x = 2 a }";
-	pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
-	pwf = isl_pw_qpolynomial_bound(pwqp, isl_fold_max, NULL);
-	assert(isl_pw_qpolynomial_fold_dim(pwf, isl_dim_in) == 1);
-	isl_pw_qpolynomial_fold_free(pwf);
+	return isl_stat_non_null(pwf);
+}
+
+/* Perform basic isl_pw_qpolynomial_bound tests.
+ */
+static int test_bound(isl_ctx *ctx)
+{
+	int i;
+
+	if (test_bound_space(ctx) < 0)
+		return -1;
+
+	for (i = 0; i < ARRAY_SIZE(bound_tests); ++i) {
+		const char *str;
+		enum isl_fold type;
+		isl_bool equal, tight;
+		isl_pw_qpolynomial *pwqp;
+		isl_pw_qpolynomial_fold *pwf1, *pwf2;
+
+		str = bound_testsi.poly;
+		pwqp = isl_pw_qpolynomial_read_from_str(ctx, str);
+		type = bound_testsi.type;
+		pwf1 = isl_pw_qpolynomial_bound(pwqp, type, &tight);
+		str = bound_testsi.bound;
+		pwf2 = isl_pw_qpolynomial_fold_read_from_str(ctx, str);
+		equal = isl_pw_qpolynomial_fold_plain_is_equal(pwf1, pwf2);
+		isl_pw_qpolynomial_fold_free(pwf2);
+		isl_pw_qpolynomial_fold_free(pwf1);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"incorrect bound result", return -1);
+		if (bound_testsi.tight && !tight)
+			isl_die(ctx, isl_error_unknown,
+				"bound unexpectedly not tight", return -1);
+	}
+
+	return 0;
+}
+
+/* isl_set is defined to isl_map internally, so the corresponding elements
+ * are isl_basic_map objects.
+ */
+#undef EL_BASE
+#undef SET_BASE
+#define EL_BASE		basic_map
+#define SET_BASE	set
+#include "isl_test_list_templ.c"
+
+#undef EL_BASE
+#undef SET_BASE
+#define EL_BASE		basic_set
+#define SET_BASE	union_set
+#include "isl_test_list_templ.c"
+
+#undef EL_BASE
+#undef SET_BASE
+#define EL_BASE		set
+#define SET_BASE	union_set
+#include "isl_test_list_templ.c"
+
+#undef EL_BASE
+#undef SET_BASE
+#define EL_BASE		basic_map
+#define SET_BASE	map
+#include "isl_test_list_templ.c"
+
+#undef EL_BASE
+#undef SET_BASE
+#define EL_BASE		map
+#define SET_BASE	union_map
+#include "isl_test_list_templ.c"
+
+/* Check that the conversion from isl objects to lists works as expected.
+ */
+static int test_get_list(isl_ctx *ctx)
+{
+	if (test_get_list_basic_map_from_set(ctx, "{ 0; 2; 3 }"))
+		return -1;
+	if (test_get_list_basic_set_from_union_set(ctx, "{ A0; B2; B3 }"))
+		return -1;
+	if (test_get_list_set_from_union_set(ctx, "{ A0; A2; B3 }"))
+		return -1;
+	if (test_get_list_basic_map_from_map(ctx,
+				"{ 0 -> 0; 2 -> 0; 3 -> 0 }"))
+		return -1;
+	if (test_get_list_map_from_union_map(ctx,
+				"{ A0 -> 0; A2 -> 0; B3 -> 0 }"))
+		return -1;
+
+	return 0;
 }
 
-void test_lift(isl_ctx *ctx)
+static int test_lift(isl_ctx *ctx)
 {
 	const char *str;
 	isl_basic_map *bmap;
@@ -2364,6 +4011,46 @@
 	bmap = isl_basic_map_from_range(bset);
 	bset = isl_basic_map_domain(bmap);
 	isl_basic_set_free(bset);
+
+	return 0;
+}
+
+/* Check that isl_set_is_subset is not confused by identical
+ * integer divisions.
+ * The call to isl_set_normalize ensures that the equality constraints
+ * a = b = 0 are discovered, turning e0 and e1 into identical
+ * integer divisions.  Any further simplification would remove
+ * the duplicate integer divisions.
+ */
+static isl_stat test_subset_duplicate_integer_divisions(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool is_subset;
+	isl_set *set1, *set2;
+
+	str = "{ a, b, c, d : "
+	    "exists (e0 = floor((a + d)/4), e1 = floor((d)/4), "
+		    "e2 = floor((-a - d + 4 *floor((a + d)/4))/10), "
+		    "e3 = floor((-d + 4*floor((d)/4))/10): "
+		"10e2 = -a - 2c - d + 4e0 and 10e3 = -2c - d + 4e1 and "
+		"b >= 0 and a <= 0 and b <= a) }";
+	set1 = isl_set_read_from_str(ctx, str);
+	set2 = isl_set_read_from_str(ctx, str);
+	set2 = isl_set_normalize(set2);
+
+	is_subset = isl_set_is_subset(set1, set2);
+
+	isl_set_free(set1);
+	isl_set_free(set2);
+
+	if (is_subset < 0)
+		return isl_stat_error;
+	if (!is_subset)
+		isl_die(ctx, isl_error_unknown,
+			"set is not considered to be a subset of itself",
+			return isl_stat_error);
+
+	return isl_stat_ok;
 }
 
 struct {
@@ -2401,6 +4088,7 @@
 			"4e0 >= 58 + i0 - i1 and i0 >= 2 and i0 <= 511 and "
 			"4e0 >= -61 + i0 + i1)) or "
 		"(i1 <= 66 - i0 and i0 >= 2 and i1 >= 59 + i0) }", 1 },
+	{ "a, b -> { : a = 0 and b = -1 }", "b, a -> { : b >= -10 }", 1 },
 };
 
 static int test_subset(isl_ctx *ctx)
@@ -2409,6 +4097,9 @@
 	isl_set *set1, *set2;
 	int subset;
 
+	if (test_subset_duplicate_integer_divisions(ctx) < 0)
+		return -1;
+
 	for (i = 0; i < ARRAY_SIZE(subset_tests); ++i) {
 		set1 = isl_set_read_from_str(ctx, subset_testsi.set1);
 		set2 = isl_set_read_from_str(ctx, subset_testsi.set2);
@@ -2425,6 +4116,26 @@
 	return 0;
 }
 
+/* Perform a set subtraction with a set that has a non-obviously empty disjunct.
+ * Older versions of isl would fail on such cases.
+ */
+static isl_stat test_subtract_empty(isl_ctx *ctx)
+{
+	const char *str;
+	isl_set *s1, *s2;
+
+	s1 = isl_set_read_from_str(ctx, "{ 0 }");
+	str = "{ a : (exists (e0, e1, e2: 1056e1 <= 32 + a - 33e0 and "
+			"1089e1 >= a - 33e0 and 1089e1 <= 1 + a - 33e0 and "
+			"33e2 >= -a + 33e0 + 1056e1 and "
+			"33e2 < -2a + 66e0 + 2112e1)) or a = 0 }";
+	s2 = isl_set_read_from_str(ctx, str);
+	s1 = isl_set_subtract(s1, s2);
+	isl_set_free(s1);
+
+	return isl_stat_non_null(s1);
+}
+
 struct {
 	const char *minuend;
 	const char *subtrahend;
@@ -2439,9 +4150,13 @@
 {
 	int i;
 	isl_union_map *umap1, *umap2;
+	isl_union_pw_multi_aff *upma1, *upma2;
 	isl_union_set *uset;
 	int equal;
 
+	if (test_subtract_empty(ctx) < 0)
+		return -1;
+
 	for (i = 0; i < ARRAY_SIZE(subtract_domain_tests); ++i) {
 		umap1 = isl_union_map_read_from_str(ctx,
 				subtract_domain_testsi.minuend);
@@ -2460,6 +4175,78 @@
 				"incorrect subtract domain result", return -1);
 	}
 
+	for (i = 0; i < ARRAY_SIZE(subtract_domain_tests); ++i) {
+		upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
+				subtract_domain_testsi.minuend);
+		uset = isl_union_set_read_from_str(ctx,
+				subtract_domain_testsi.subtrahend);
+		upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
+				subtract_domain_testsi.difference);
+		upma1 = isl_union_pw_multi_aff_subtract_domain(upma1, uset);
+		equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2);
+		isl_union_pw_multi_aff_free(upma1);
+		isl_union_pw_multi_aff_free(upma2);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"incorrect subtract domain result", return -1);
+	}
+
+	return 0;
+}
+
+/* Check that intersecting the empty basic set with another basic set
+ * does not increase the number of constraints.  In particular,
+ * the empty basic set should maintain its canonical representation.
+ */
+static int test_intersect_1(isl_ctx *ctx)
+{
+	isl_size n1, n2;
+	isl_basic_set *bset1, *bset2;
+
+	bset1 = isl_basic_set_read_from_str(ctx, "{ a,b,c : 1 = 0 }");
+	bset2 = isl_basic_set_read_from_str(ctx, "{ 1,2,3 }");
+	n1 = isl_basic_set_n_constraint(bset1);
+	bset1 = isl_basic_set_intersect(bset1, bset2);
+	n2 = isl_basic_set_n_constraint(bset1);
+	isl_basic_set_free(bset1);
+	if (n1 < 0 || n2 < 0)
+		return -1;
+	if (n1 != n2)
+		isl_die(ctx, isl_error_unknown,
+			"number of constraints of empty set changed",
+			return -1);
+
+	return 0;
+}
+
+/* Check that intersecting a set with itself does not cause
+ * an explosion in the number of disjuncts.
+ */
+static isl_stat test_intersect_2(isl_ctx *ctx)
+{
+	int i;
+	isl_set *set;
+
+	set = isl_set_read_from_str(ctx, "{ x,y : x >= 0 or y >= 0 }");
+	for (i = 0; i < 100; ++i)
+		set = isl_set_intersect(set, isl_set_copy(set));
+	isl_set_free(set);
+	if (!set)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Perform some intersection tests.
+ */
+static int test_intersect(isl_ctx *ctx)
+{
+	if (test_intersect_1(ctx) < 0)
+		return -1;
+	if (test_intersect_2(ctx) < 0)
+		return -1;
+
 	return 0;
 }
 
@@ -2505,7 +4292,7 @@
 	return 0;
 }
 
-static int check_injective(__isl_take isl_map *map, void *user)
+static isl_stat check_injective(__isl_take isl_map *map, void *user)
 {
 	int *injective = user;
 
@@ -2513,9 +4300,9 @@
 	isl_map_free(map);
 
 	if (*injective < 0 || !*injective)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 int test_one_schedule(isl_ctx *ctx, const char *d, const char *w,
@@ -2537,6 +4324,7 @@
 	isl_schedule_constraints *sc;
 	isl_schedule *sched;
 	int is_nonneg, is_parallel, is_tilable, is_injection, is_complete;
+	isl_size n;
 
 	D = isl_union_set_read_from_str(ctx, d);
 	W = isl_union_map_read_from_str(ctx, w);
@@ -2587,12 +4375,19 @@
 	test = isl_union_map_apply_range(test, schedule);
 
 	delta = isl_union_map_deltas(test);
-	if (isl_union_set_n_set(delta) == 0) {
+	n = isl_union_set_n_set(delta);
+	if (n < 0) {
+		isl_union_set_free(delta);
+		return -1;
+	}
+	if (n == 0) {
 		is_tilable = 1;
 		is_parallel = 1;
 		is_nonneg = 1;
 		isl_union_set_free(delta);
 	} else {
+		isl_size dim;
+
 		delta_set = isl_set_from_union_set(delta);
 
 		slice = isl_set_universe(isl_set_get_space(delta_set));
@@ -2608,7 +4403,10 @@
 		isl_set_free(slice);
 
 		origin = isl_set_universe(isl_set_get_space(delta_set));
-		for (i = 0; i < isl_set_dim(origin, isl_dim_set); ++i)
+		dim = isl_set_dim(origin, isl_dim_set);
+		if (dim < 0)
+			origin = isl_set_free(origin);
+		for (i = 0; i < dim; ++i)
 			origin = isl_set_fix_si(origin, isl_dim_set, i, 0);
 
 		delta_set = isl_set_union(delta_set, isl_set_copy(origin));
@@ -2646,9 +4444,15 @@
 	return 0;
 }
 
-static __isl_give isl_union_map *compute_schedule(isl_ctx *ctx,
-	const char *domain, const char *validity, const char *proximity)
+/* Compute a schedule for the given instance set, validity constraints,
+ * proximity constraints and context and return a corresponding union map
+ * representation.
+ */
+static __isl_give isl_union_map *compute_schedule_with_context(isl_ctx *ctx,
+	const char *domain, const char *validity, const char *proximity,
+	const char *context)
 {
+	isl_set *con;
 	isl_union_set *dom;
 	isl_union_map *dep;
 	isl_union_map *prox;
@@ -2656,10 +4460,12 @@
 	isl_schedule *schedule;
 	isl_union_map *sched;
 
+	con = isl_set_read_from_str(ctx, context);
 	dom = isl_union_set_read_from_str(ctx, domain);
 	dep = isl_union_map_read_from_str(ctx, validity);
 	prox = isl_union_map_read_from_str(ctx, proximity);
 	sc = isl_schedule_constraints_on_domain(dom);
+	sc = isl_schedule_constraints_set_context(sc, con);
 	sc = isl_schedule_constraints_set_validity(sc, dep);
 	sc = isl_schedule_constraints_set_proximity(sc, prox);
 	schedule = isl_schedule_constraints_compute_schedule(sc);
@@ -2669,6 +4475,16 @@
 	return sched;
 }
 
+/* Compute a schedule for the given instance set, validity constraints and
+ * proximity constraints and return a corresponding union map representation.
+ */
+static __isl_give isl_union_map *compute_schedule(isl_ctx *ctx,
+	const char *domain, const char *validity, const char *proximity)
+{
+	return compute_schedule_with_context(ctx, domain, validity, proximity,
+						"{ : }");
+}
+
 /* Check that a schedule can be constructed on the given domain
  * with the given validity and proximity constraints.
  */
@@ -2707,8 +4523,8 @@
 	return 0;
 }
 
-/* Check that the schedule map is properly padded, even after being
- * reconstructed from the band forest.
+/* Check that the schedule map is properly padded, i.e., that the range
+ * lives in a single space.
  */
 static int test_padded_schedule(isl_ctx *ctx)
 {
@@ -2717,9 +4533,9 @@
 	isl_union_map *validity, *proximity;
 	isl_schedule_constraints *sc;
 	isl_schedule *sched;
-	isl_union_map *map1, *map2;
-	isl_band_list *list;
-	int equal;
+	isl_union_map *umap;
+	isl_union_set *range;
+	isl_set *set;
 
 	str = "N -> { S0i : 0 <= i <= N; S1i, j : 0 <= i, j <= N }";
 	D = isl_union_set_read_from_str(ctx, str);
@@ -2729,20 +4545,140 @@
 	sc = isl_schedule_constraints_set_validity(sc, validity);
 	sc = isl_schedule_constraints_set_proximity(sc, proximity);
 	sched = isl_schedule_constraints_compute_schedule(sc);
-	map1 = isl_schedule_get_map(sched);
-	list = isl_schedule_get_band_forest(sched);
-	isl_band_list_free(list);
-	map2 = isl_schedule_get_map(sched);
+	umap = isl_schedule_get_map(sched);
 	isl_schedule_free(sched);
-	equal = isl_union_map_is_equal(map1, map2);
-	isl_union_map_free(map1);
-	isl_union_map_free(map2);
+	range = isl_union_map_range(umap);
+	set = isl_set_from_union_set(range);
+	isl_set_free(set);
 
-	if (equal < 0)
+	if (!set)
 		return -1;
-	if (!equal)
+
+	return 0;
+}
+
+/* Check that conditional validity constraints are also taken into
+ * account across bands.
+ * In particular, try to make sure that live ranges D1,0->C2,1 and
+ * D2,0->C3,0 are not local in the outer band of the generated schedule
+ * and then check that the adjacent order constraint C2,1->D2,0
+ * is enforced by the rest of the schedule.
+ */
+static int test_special_conditional_schedule_constraints(isl_ctx *ctx)
+{
+	const char *str;
+	isl_union_set *domain;
+	isl_union_map *validity, *proximity, *condition;
+	isl_union_map *sink, *source, *dep;
+	isl_schedule_constraints *sc;
+	isl_schedule *schedule;
+	isl_union_access_info *access;
+	isl_union_flow *flow;
+	int empty;
+
+	str = "n -> { Ck, i : k <= -1 + n and i >= 0 and i <= -1 + k; "
+	    "Ak : k >= 1 and k <= -1 + n; "
+	    "Bk, i : k <= -1 + n and i >= 0 and i <= -1 + k; "
+	    "Dk, i : k <= -1 + n and i >= 0 and i <= -1 + k }";
+	domain = isl_union_set_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_on_domain(domain);
+	str = "n -> { Dk, i -> C1 + k, k - i : "
+		"k <= -2 + n and i >= 1 and i <= -1 + k; "
+		"Dk, i -> C1 + k, i : "
+		"k <= -2 + n and i >= 1 and i <= -1 + k; "
+		"Dk, 0 -> C1 + k, k : k >= 1 and k <= -2 + n; "
+		"Dk, 0 -> C1 + k, 0 : k >= 1 and k <= -2 + n }";
+	validity = isl_union_map_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_set_validity(sc, validity);
+	str = "n -> { Ck, i -> Dk, i : "
+		"0 <= i <= -1 + k and k <= -1 + n }";
+	proximity = isl_union_map_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_set_proximity(sc, proximity);
+	str = "n -> { Dk, i -> a -> C1 + k, k - i -> b : "
+		"i <= -1 + k and i >= 1 and k <= -2 + n; "
+		"Bk, i -> c -> Bk, 1 + i -> c : "
+		"k <= -1 + n and i >= 0 and i <= -2 + k }";
+	condition = isl_union_map_read_from_str(ctx, str);
+	str = "n -> { Bk, i -> e -> Dk, i -> a : "
+		"i >= 0 and i <= -1 + k and k <= -1 + n; "
+		"Ck, i -> b -> Dk', -1 + k - i -> a : "
+		"i >= 0 and i <= -1 + k and k <= -1 + n and "
+		"k' <= -1 + n and k' >= k - i and k' >= 1 + k; "
+		"Ck, i -> b -> Dk, -1 + k - i -> a : "
+		"i >= 0 and i <= -1 + k and k <= -1 + n; "
+		"Bk, i -> c -> Ak' -> d : "
+		"k <= -1 + n and i >= 0 and i <= -1 + k and "
+		"k' >= 1 and k' <= -1 + n and k' >= 1 + k }";
+	validity = isl_union_map_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
+								validity);
+	schedule = isl_schedule_constraints_compute_schedule(sc);
+	str = "{ D2,0 ->  }";
+	sink = isl_union_map_read_from_str(ctx, str);
+	access = isl_union_access_info_from_sink(sink);
+	str = "{ C2,1 ->  }";
+	source = isl_union_map_read_from_str(ctx, str);
+	access = isl_union_access_info_set_must_source(access, source);
+	access = isl_union_access_info_set_schedule(access, schedule);
+	flow = isl_union_access_info_compute_flow(access);
+	dep = isl_union_flow_get_must_dependence(flow);
+	isl_union_flow_free(flow);
+	empty = isl_union_map_is_empty(dep);
+	isl_union_map_free(dep);
+
+	if (empty < 0)
+		return -1;
+	if (empty)
 		isl_die(ctx, isl_error_unknown,
-			"reconstructed schedule map not the same as original",
+			"conditional validity not respected", return -1);
+
+	return 0;
+}
+
+/* Check that the test for violated conditional validity constraints
+ * is not confused by domain compression.
+ * In particular, earlier versions of isl would apply
+ * a schedule on the compressed domains to the original domains,
+ * resulting in a failure to detect that the default schedule
+ * violates the conditional validity constraints.
+ */
+static int test_special_conditional_schedule_constraints_2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool empty;
+	isl_union_set *domain;
+	isl_union_map *validity, *condition;
+	isl_schedule_constraints *sc;
+	isl_schedule *schedule;
+	isl_union_map *umap;
+	isl_map *map, *ge;
+
+	str = "{ A0, i : 0 <= i <= 10; B1, i : 0 <= i <= 10 }";
+	domain = isl_union_set_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_on_domain(domain);
+	str = "{ B1, i -> A0, i + 1 }";
+	condition = isl_union_map_read_from_str(ctx, str);
+	str = "{ A0, i -> B1, i - 1 }";
+	validity = isl_union_map_read_from_str(ctx, str);
+	sc = isl_schedule_constraints_set_conditional_validity(sc, condition,
+						isl_union_map_copy(validity));
+	schedule = isl_schedule_constraints_compute_schedule(sc);
+	umap = isl_schedule_get_map(schedule);
+	isl_schedule_free(schedule);
+	validity = isl_union_map_apply_domain(validity,
+						isl_union_map_copy(umap));
+	validity = isl_union_map_apply_range(validity, umap);
+	map = isl_map_from_union_map(validity);
+	ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map)));
+	map = isl_map_intersect(map, ge);
+	empty = isl_map_is_empty(map);
+	isl_map_free(map);
+
+	if (empty < 0)
+		return -1;
+	if (!empty)
+		isl_die(ctx, isl_error_unknown,
+			"conditional validity constraints not satisfied",
 			return -1);
 
 	return 0;
@@ -2835,7 +4771,7 @@
 };
 
 /* Test schedule construction based on conditional constraints.
- * In particular, check the number of members in the outer band
+ * In particular, check the number of members in the outer band node
  * as an indication of whether tiling is possible or not.
  */
 static int test_conditional_schedule_constraints(isl_ctx *ctx)
@@ -2847,9 +4783,13 @@
 	isl_union_map *validity;
 	isl_schedule_constraints *sc;
 	isl_schedule *schedule;
-	isl_band_list *list;
-	isl_band *band;
-	int n_member;
+	isl_schedule_node *node;
+	isl_size n_member;
+
+	if (test_special_conditional_schedule_constraints(ctx) < 0)
+		return -1;
+	if (test_special_conditional_schedule_constraints_2(ctx) < 0)
+		return -1;
 
 	for (i = 0; i < ARRAY_SIZE(live_range_tests); ++i) {
 		domain = isl_union_set_read_from_str(ctx,
@@ -2867,14 +4807,15 @@
 		sc = isl_schedule_constraints_set_conditional_validity(sc,
 				condition, validity);
 		schedule = isl_schedule_constraints_compute_schedule(sc);
-		list = isl_schedule_get_band_forest(schedule);
-		band = isl_band_list_get_band(list, 0);
-		n_member = isl_band_n_member(band);
-		isl_band_free(band);
-		isl_band_list_free(list);
+		node = isl_schedule_get_root(schedule);
+		while (node &&
+		    isl_schedule_node_get_type(node) != isl_schedule_node_band)
+			node = isl_schedule_node_first_child(node);
+		n_member = isl_schedule_node_band_n_member(node);
+		isl_schedule_node_free(node);
 		isl_schedule_free(schedule);
 
-		if (!schedule)
+		if (!schedule || n_member < 0)
 			return -1;
 		if (n_member != live_range_testsi.outer_band_n)
 			isl_die(ctx, isl_error_unknown,
@@ -2884,9 +4825,121 @@
 	return 0;
 }
 
+/* Check that the schedule computed for the given instance set and
+ * dependence relation strongly satisfies the dependences.
+ * In particular, check that no instance is scheduled before
+ * or together with an instance on which it depends.
+ * Earlier versions of isl would produce a schedule that
+ * only weakly satisfies the dependences.
+ */
+static int test_strongly_satisfying_schedule(isl_ctx *ctx)
+{
+	const char *domain, *dep;
+	isl_union_map *D, *schedule;
+	isl_map *map, *ge;
+	int empty;
+
+	domain = "{ Bi0, i1 : 0 <= i0 <= 1 and 0 <= i1 <= 11; "
+		    "Ai0 : 0 <= i0 <= 1 }";
+	dep = "{ Bi0, i1 -> Bi0, 1 + i1 : 0 <= i0 <= 1 and 0 <= i1 <= 10; "
+		"B0, 11 -> A1; Ai0 -> Bi0, 0 : 0 <= i0 <= 1 }";
+	schedule = compute_schedule(ctx, domain, dep, dep);
+	D = isl_union_map_read_from_str(ctx, dep);
+	D = isl_union_map_apply_domain(D, isl_union_map_copy(schedule));
+	D = isl_union_map_apply_range(D, schedule);
+	map = isl_map_from_union_map(D);
+	ge = isl_map_lex_ge(isl_space_domain(isl_map_get_space(map)));
+	map = isl_map_intersect(map, ge);
+	empty = isl_map_is_empty(map);
+	isl_map_free(map);
+
+	if (empty < 0)
+		return -1;
+	if (!empty)
+		isl_die(ctx, isl_error_unknown,
+			"dependences not strongly satisfied", return -1);
+
+	return 0;
+}
+
+/* Compute a schedule for input where the instance set constraints
+ * conflict with the context constraints.
+ * Earlier versions of isl did not properly handle this situation.
+ */
+static int test_conflicting_context_schedule(isl_ctx *ctx)
+{
+	isl_union_map *schedule;
+	const char *domain, *context;
+
+	domain = "n -> { A : n >= 0 }";
+	context = "n -> { : n < 0 }";
+	schedule = compute_schedule_with_context(ctx,
+						domain, "{}", "{}", context);
+	isl_union_map_free(schedule);
+
+	if (!schedule)
+		return -1;
+
+	return 0;
+}
+
+/* Check that a set of schedule constraints that only allow for
+ * a coalescing schedule still produces a schedule even if the user
+ * request a non-coalescing schedule.  Earlier versions of isl
+ * would not handle this case correctly.
+ */
+static int test_coalescing_schedule(isl_ctx *ctx)
+{
+	const char *domain, *dep;
+	isl_union_set *I;
+	isl_union_map *D;
+	isl_schedule_constraints *sc;
+	isl_schedule *schedule;
+	int treat_coalescing;
+
+	domain = "{ Sa, b : 0 <= a <= 1 and 0 <= b <= 1 }";
+	dep = "{ Sa, b -> Sa + b, 1 - b }";
+	I = isl_union_set_read_from_str(ctx, domain);
+	D = isl_union_map_read_from_str(ctx, dep);
+	sc = isl_schedule_constraints_on_domain(I);
+	sc = isl_schedule_constraints_set_validity(sc, D);
+	treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
+	isl_options_set_schedule_treat_coalescing(ctx, 1);
+	schedule = isl_schedule_constraints_compute_schedule(sc);
+	isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
+	isl_schedule_free(schedule);
+	if (!schedule)
+		return -1;
+	return 0;
+}
+
+/* Check that the scheduler does not perform any needless
+ * compound skewing.  Earlier versions of isl would compute
+ * schedules in terms of transformed schedule coefficients and
+ * would not accurately keep track of the sum of the original
+ * schedule coefficients.  It could then produce the schedule
+ * St,i,j,k -> t, 2t + i, 2t + i + j, 2t + i + j + k
+ * for the input below instead of the schedule below.
+ */
+static int test_skewing_schedule(isl_ctx *ctx)
+{
+	const char *D, *V, *P, *S;
+
+	D = "n -> { St,i,j,k : 0 <= t,i,j,k < n }";
+	V = "n -> { St,i,j,k -> St+1,a,b,c : 0 <= t,i,j,k,a,b,c < n and "
+		"-2 <= a-i <= 2 and -1 <= a-i + b-j <= 1 and "
+		"-1 <= a-i + b-j + c-k <= 1 }";
+	P = "{ }";
+	S = "{ St,i,j,k -> t, 2t + i, t + i + j, 2t + k }";
+
+	return test_special_schedule(ctx, D, V, P, S);
+}
+
 int test_schedule(isl_ctx *ctx)
 {
 	const char *D, *W, *R, *V, *P, *S;
+	int max_coincidence;
+	int treat_coalescing;
 
 	/* Handle resulting schedule with zero bands. */
 	if (test_one_schedule(ctx, "{}", "{}", "{}", "{ -> }", 0, 0) < 0)
@@ -2976,8 +5029,11 @@
 		    "S4i -> ai,N }";
 	S = "{ S1i -> 0,i,0; S2i -> 1,i,0; S3i,j -> 2,i,j; "
 		"S4i -> 4,i,0 }";
+	max_coincidence = isl_options_get_schedule_maximize_coincidence(ctx);
+	isl_options_set_schedule_maximize_coincidence(ctx, 0);
 	if (test_one_schedule(ctx, D, W, R, S, 2, 0) < 0)
 		return -1;
+	isl_options_set_schedule_maximize_coincidence(ctx, max_coincidence);
 
 	D = "N -> { S_0i, j : i >= 1 and i <= N and j >= 1 and j <= N }";
 	W = "N -> { S_0i, j -> s0 : i >= 1 and i <= N and j >= 1 and "
@@ -3093,12 +5149,12 @@
 		"i0 >= 0 and i0 <= 1 and i1 >= 0 and o2 >= -i1 + i2 and "
 		"o2 >= 1 and o2 <= 6 - i1 and i2 >= 1 + i1 }";
 	P = V;
-	S = "{ Stmt_for_body24i0, i1, i2, i3 -> "
-		"i0, 5i0 + i1, 6i0 + i1 + i2, 1 + 6i0 + i1 + i2 + i3, 1;"
-	    "Stmt_for_body7i0, i1, i2 -> 0, 5i0, 6i0 + i1, 6i0 + i2, 0 }";
 
-	if (test_special_schedule(ctx, D, V, P, S) < 0)
+	treat_coalescing = isl_options_get_schedule_treat_coalescing(ctx);
+	isl_options_set_schedule_treat_coalescing(ctx, 0);
+	if (test_has_schedule(ctx, D, V, P) < 0)
 		return -1;
+	isl_options_set_schedule_treat_coalescing(ctx, treat_coalescing);
 
 	D = "{ S_0i, j : i >= 1 and i <= 10 and j >= 1 and j <= 8 }";
 	V = "{ S_0i, j -> S_0i, 1 + j : i >= 1 and i <= 10 and "
@@ -3106,7 +5162,7 @@
 		"S_0i, j -> S_01 + i, j : i >= 1 and i <= 9 and "
 					     "j >= 1 and j <= 8 }";
 	P = "{ }";
-	S = "{ S_0i, j -> i + j, j }";
+	S = "{ S_0i, j -> i + j, i }";
 	ctx->opt->schedule_algorithm = ISL_SCHEDULE_ALGORITHM_FEAUTRIER;
 	if (test_special_schedule(ctx, D, V, P, S) < 0)
 		return -1;
@@ -3176,9 +5232,50 @@
 	if (test_conditional_schedule_constraints(ctx) < 0)
 		return -1;
 
+	if (test_strongly_satisfying_schedule(ctx) < 0)
+		return -1;
+
+	if (test_conflicting_context_schedule(ctx) < 0)
+		return -1;
+
+	if (test_coalescing_schedule(ctx) < 0)
+		return -1;
+	if (test_skewing_schedule(ctx) < 0)
+		return -1;
+
 	return 0;
 }
 
+/* Perform scheduling tests using the whole component scheduler.
+ */
+static int test_schedule_whole(isl_ctx *ctx)
+{
+	int whole;
+	int r;
+
+	whole = isl_options_get_schedule_whole_component(ctx);
+	isl_options_set_schedule_whole_component(ctx, 1);
+	r = test_schedule(ctx);
+	isl_options_set_schedule_whole_component(ctx, whole);
+
+	return r;
+}
+
+/* Perform scheduling tests using the incremental scheduler.
+ */
+static int test_schedule_incremental(isl_ctx *ctx)
+{
+	int whole;
+	int r;
+
+	whole = isl_options_get_schedule_whole_component(ctx);
+	isl_options_set_schedule_whole_component(ctx, 0);
+	r = test_schedule(ctx);
+	isl_options_set_schedule_whole_component(ctx, whole);
+
+	return r;
+}
+
 int test_plain_injective(isl_ctx *ctx, const char *str, int injective)
 {
 	isl_union_map *umap;
@@ -3230,31 +5327,54 @@
 	return 0;
 }
 
-static int aff_plain_is_equal(__isl_keep isl_aff *aff, const char *str)
+#undef BASE
+#define BASE	aff
+#include "isl_test_plain_equal_templ.c"
+
+#undef BASE
+#define BASE	pw_multi_aff
+#include "isl_test_plain_equal_templ.c"
+
+#undef BASE
+#define BASE	union_pw_aff
+#include "isl_test_plain_equal_templ.c"
+
+/* Basic tests on isl_union_pw_aff.
+ *
+ * In particular, check that isl_union_pw_aff_aff_on_domain
+ * aligns the parameters of the input objects and
+ * that isl_union_pw_aff_param_on_domain_id properly
+ * introduces the parameter.
+ */
+static int test_upa(isl_ctx *ctx)
 {
-	isl_aff *aff2;
-	int equal;
+	const char *str;
+	isl_id *id;
+	isl_aff *aff;
+	isl_union_set *domain;
+	isl_union_pw_aff *upa;
+	isl_stat ok;
 
-	if (!aff)
+	aff = isl_aff_read_from_str(ctx, "N -> { N }");
+	str = "M -> { Ai : 0 <= i < M; B }";
+	domain = isl_union_set_read_from_str(ctx, str);
+	upa = isl_union_pw_aff_aff_on_domain(domain, aff);
+	str = "N, M -> { Ai -> N : 0 <= i < M; B -> N }";
+	ok = union_pw_aff_check_plain_equal(upa, str);
+	isl_union_pw_aff_free(upa);
+	if (ok < 0)
 		return -1;
 
-	aff2 = isl_aff_read_from_str(isl_aff_get_ctx(aff), str);
-	equal = isl_aff_plain_is_equal(aff, aff2);
-	isl_aff_free(aff2);
-
-	return equal;
-}
-
-static int aff_check_plain_equal(__isl_keep isl_aff *aff, const char *str)
-{
-	int equal;
-
-	equal = aff_plain_is_equal(aff, str);
-	if (equal < 0)
+	id = isl_id_alloc(ctx, "N", NULL);
+	str = "M -> { Ai : 0 <= i < M; B }";
+	domain = isl_union_set_read_from_str(ctx, str);
+	upa = isl_union_pw_aff_param_on_domain_id(domain, id);
+	str = "N, M -> { Ai -> N : 0 <= i < M; B -> N }";
+	ok = union_pw_aff_check_plain_equal(upa, str);
+	isl_union_pw_aff_free(upa);
+	if (ok < 0)
 		return -1;
-	if (!equal)
-		isl_die(isl_aff_get_ctx(aff), isl_error_unknown,
-			"result not as expected", return -1);
+
 	return 0;
 }
 
@@ -3310,6 +5430,8 @@
 	  "{ i -> NaN }" },
 	{ "{ i -> NaN }", '/', "{ i -> i }",
 	  "{ i -> NaN }" },
+	{ "{ i -> i }", '/', "{ i -> 0 }",
+	  "{ i -> NaN }" },
 };
 
 /* Perform some basic tests of binary operations on isl_aff objects.
@@ -3344,6 +5466,1305 @@
 	return 0;
 }
 
+struct {
+	__isl_give isl_pw_aff *(*fn)(__isl_take isl_pw_aff *pa1,
+				     __isl_take isl_pw_aff *pa2);
+} pw_aff_bin_op = {
+	'm' = { &isl_pw_aff_min },
+	'M' = { &isl_pw_aff_max },
+};
+
+/* Inputs for binary isl_pw_aff operation tests.
+ * "arg1" and "arg2" are the two arguments, "op" identifies the operation
+ * defined by pw_aff_bin_op, and "res" is the expected result.
+ */
+struct {
+	const char *arg1;
+	unsigned char op;
+	const char *arg2;
+	const char *res;
+} pw_aff_bin_tests = {
+	{ "{ i -> i }", 'm', "{ i -> i }",
+	  "{ i -> i }" },
+	{ "{ i -> i }", 'M', "{ i -> i }",
+	  "{ i -> i }" },
+	{ "{ i -> i }", 'm', "{ i -> 0 }",
+	  "{ i -> i : i <= 0; i -> 0 : i > 0 }" },
+	{ "{ i -> i }", 'M', "{ i -> 0 }",
+	  "{ i -> i : i >= 0; i -> 0 : i < 0 }" },
+	{ "{ i -> i }", 'm', "{ i -> NaN }",
+	  "{ i -> NaN }" },
+	{ "{ i -> NaN }", 'm', "{ i -> i }",
+	  "{ i -> NaN }" },
+};
+
+/* Perform some basic tests of binary operations on isl_pw_aff objects.
+ */
+static int test_bin_pw_aff(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_pw_aff *pa1, *pa2, *res;
+
+	for (i = 0; i < ARRAY_SIZE(pw_aff_bin_tests); ++i) {
+		pa1 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_testsi.arg1);
+		pa2 = isl_pw_aff_read_from_str(ctx, pw_aff_bin_testsi.arg2);
+		res = isl_pw_aff_read_from_str(ctx, pw_aff_bin_testsi.res);
+		pa1 = pw_aff_bin_oppw_aff_bin_testsi.op.fn(pa1, pa2);
+		if (isl_pw_aff_involves_nan(res))
+			ok = isl_pw_aff_involves_nan(pa1);
+		else
+			ok = isl_pw_aff_plain_is_equal(pa1, res);
+		isl_pw_aff_free(pa1);
+		isl_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of test operations on
+ * isl_union_pw_multi_aff objects.
+ * "fn" is the function that is being tested.
+ * "arg" is a string description of the input.
+ * "res" is the expected result.
+ */
+static struct {
+	isl_bool (*fn)(__isl_keep isl_union_pw_multi_aff *upma1);
+	const char *arg;
+	isl_bool res;
+} upma_test_tests = {
+	{ &isl_union_pw_multi_aff_involves_nan, "{ A -> 0; B0 -> 1 }",
+	  isl_bool_false },
+	{ &isl_union_pw_multi_aff_involves_nan, "{ A -> NaN; B0 -> 1 }",
+	  isl_bool_true },
+	{ &isl_union_pw_multi_aff_involves_nan, "{ A -> 0; B0 -> NaN }",
+	  isl_bool_true },
+	{ &isl_union_pw_multi_aff_involves_nan,
+	  "{ A -> 0; B0 -> 1, NaN, 5 }",
+	  isl_bool_true },
+	{ &isl_union_pw_multi_aff_involves_locals,
+	  "{ A -> 0; B0 -> 1 }",
+	  isl_bool_false },
+	{ &isl_union_pw_multi_aff_involves_locals,
+	  "{ A -> 0; Bx -> 1 : x mod 2 = 0 }",
+	  isl_bool_true },
+	{ &isl_union_pw_multi_aff_involves_locals,
+	  "{ A -> 0; Bx -> x // 2 }",
+	  isl_bool_true },
+	{ &isl_union_pw_multi_aff_involves_locals,
+	  "{ Ai -> i // 2; B0 -> 1 }",
+	  isl_bool_true },
+};
+
+/* Perform some basic tests of test operations on
+ * isl_union_pw_multi_aff objects.
+ */
+static isl_stat test_upma_test(isl_ctx *ctx)
+{
+	int i;
+	isl_union_pw_multi_aff *upma;
+	isl_bool res;
+
+	for (i = 0; i < ARRAY_SIZE(upma_test_tests); ++i) {
+		const char *str;
+
+		str = upma_test_testsi.arg;
+		upma = isl_union_pw_multi_aff_read_from_str(ctx, str);
+		res = upma_test_testsi.fn(upma);
+		isl_union_pw_multi_aff_free(upma);
+		if (res < 0)
+			return isl_stat_error;
+		if (res != upma_test_testsi.res)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+struct {
+	__isl_give isl_union_pw_multi_aff *(*fn)(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} upma_bin_tests = {
+	{ &isl_union_pw_multi_aff_add, "{ A -> 0; B0 -> 1 }",
+	  "{ Bx -> 2 : x >= 0 }", "{ B0 -> 3 }" },
+	{ &isl_union_pw_multi_aff_union_add, "{ A -> 0; B0 -> 1 }",
+	  "{ Bx -> 2 : x >= 0 }",
+	  "{ A -> 0; B0 -> 3; Bx -> 2 : x >= 1 }" },
+	{ &isl_union_pw_multi_aff_pullback_union_pw_multi_aff,
+	  "{ A -> B0; Cx -> B1 : x < 10; Cy -> B2 : y >= 10 }",
+	  "{ Di -> A : i < 0; Di -> Ci + 5 : i >= 0 }",
+	  "{ Di -> B0 : i < 0; Di -> B1 : 0 <= i < 5; "
+	    "Di -> B2 : i >= 5 }" },
+	{ &isl_union_pw_multi_aff_union_add, "{ Bx -> A1 : x <= 0 }",
+	  "{ Bx -> C2 : x > 0 }",
+	  "{ Bx -> A1 : x <= 0; Bx -> C2 : x > 0 }" },
+	{ &isl_union_pw_multi_aff_union_add, "{ Bx -> A1 : x <= 0 }",
+	  "{ Bx -> A2 : x >= 0 }",
+	  "{ Bx -> A1 : x < 0; Bx -> A2 : x > 0; B0 -> A3 }" },
+	{
+  &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
+	  "{ Bx -> Cx + 2 }",
+	  "{ Dy -> B2y }",
+	  "{ }" },
+	{
+  &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
+	  "{ Ax -> Bx + 1 -> Cx + 2 }",
+	  "{ Dy -> B2y }",
+	  "{ }" },
+	{
+  &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
+	  "{ Ax -> Bx + 1 -> Cx + 2; Bx -> Cx + 2 }",
+	  "{ Dy -> A2y }",
+	  "{ Dy -> B2y + 1 -> C2y + 2 }" },
+	{
+  &isl_union_pw_multi_aff_preimage_domain_wrapped_domain_union_pw_multi_aff,
+	  "{ TAx -> Bx + 1 -> Cx + 2; Bx -> Cx + 2 }",
+	  "{ Dy -> A2y }",
+	  "{ TDy -> B2y + 1 -> C2y + 2 }" },
+};
+
+/* Perform some basic tests of binary operations on
+ * isl_union_pw_multi_aff objects.
+ */
+static int test_bin_upma(isl_ctx *ctx)
+{
+	int i;
+	isl_union_pw_multi_aff *upma1, *upma2, *res;
+	int ok;
+
+	for (i = 0; i < ARRAY_SIZE(upma_bin_tests); ++i) {
+		upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
+							upma_bin_testsi.arg1);
+		upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
+							upma_bin_testsi.arg2);
+		res = isl_union_pw_multi_aff_read_from_str(ctx,
+							upma_bin_testsi.res);
+		upma1 = upma_bin_testsi.fn(upma1, upma2);
+		ok = isl_union_pw_multi_aff_plain_is_equal(upma1, res);
+		isl_union_pw_multi_aff_free(upma1);
+		isl_union_pw_multi_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+struct {
+	__isl_give isl_union_pw_multi_aff *(*fn)(
+		__isl_take isl_union_pw_multi_aff *upma1,
+		__isl_take isl_union_pw_multi_aff *upma2);
+	const char *arg1;
+	const char *arg2;
+} upma_bin_fail_tests = {
+	{ &isl_union_pw_multi_aff_union_add, "{ Bx -> A1 : x <= 0 }",
+	  "{ Bx -> C2 : x >= 0 }" },
+};
+
+/* Perform some basic tests of binary operations on
+ * isl_union_pw_multi_aff objects that are expected to fail.
+ */
+static int test_bin_upma_fail(isl_ctx *ctx)
+{
+	int i, n;
+	isl_union_pw_multi_aff *upma1, *upma2;
+	int on_error;
+
+	on_error = isl_options_get_on_error(ctx);
+	isl_options_set_on_error(ctx, ISL_ON_ERROR_CONTINUE);
+	n = ARRAY_SIZE(upma_bin_fail_tests);
+	for (i = 0; i < n; ++i) {
+		upma1 = isl_union_pw_multi_aff_read_from_str(ctx,
+						upma_bin_fail_testsi.arg1);
+		upma2 = isl_union_pw_multi_aff_read_from_str(ctx,
+						upma_bin_fail_testsi.arg2);
+		upma1 = upma_bin_fail_testsi.fn(upma1, upma2);
+		isl_union_pw_multi_aff_free(upma1);
+		if (upma1)
+			break;
+	}
+	isl_options_set_on_error(ctx, on_error);
+	if (i < n)
+		isl_die(ctx, isl_error_unknown,
+			"operation not expected to succeed", return -1);
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_union_pw_multi_aff and isl_union_set objects.
+ * "fn" is the function that is being tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_union_pw_multi_aff *(*fn)(
+		__isl_take isl_union_pw_multi_aff *upma,
+		__isl_take isl_union_set *uset);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} upma_uset_tests = {
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
+	  "{ Ai -> Bi }", "{ B0 }",
+	  "{ }" },
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_domain,
+	  "{ Ai -> Bi -> Ci + 1 }", "{ A1; B0 }",
+	  "{ A1 -> B1 -> C2 }" },
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
+	  "{ Ai -> Bi -> Ci + 1 }", "{ A1; B0 }",
+	  "{ A0 -> B0 -> C1 }" },
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
+	  "{ Ai -> Bi -> Ci + 1 }", "N -> { BN }",
+	  "N -> { AN -> BN -> CN + 1 }" },
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
+	  "M -> { AM -> BM -> CM + 1 }", "N -> { BN }",
+	  "N, M -> { AN -> BN -> CN + 1 : N = M }" },
+	{ &isl_union_pw_multi_aff_intersect_domain_wrapped_range,
+	  "{ A -> B -> C; NA -> B -> D; B -> A -> E }",
+	  "{ B }",
+	  "{ A -> B -> C; NA -> B -> D }" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_union_pw_multi_aff and isl_union_set objects.
+ */
+static isl_stat test_upma_uset(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_union_pw_multi_aff *upma, *res;
+	isl_union_set *uset;
+
+	for (i = 0; i < ARRAY_SIZE(upma_uset_tests); ++i) {
+		upma = isl_union_pw_multi_aff_read_from_str(ctx,
+						    upma_uset_testsi.arg1);
+		uset = isl_union_set_read_from_str(ctx,
+						    upma_uset_testsi.arg2);
+		res = isl_union_pw_multi_aff_read_from_str(ctx,
+						    upma_uset_testsi.res);
+		upma = upma_uset_testsi.fn(upma, uset);
+		ok = isl_union_pw_multi_aff_plain_is_equal(upma, res);
+		isl_union_pw_multi_aff_free(upma);
+		isl_union_pw_multi_aff_free(res);
+		if (ok < 0)
+			return isl_stat_error;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for basic tests of unary operations on isl_multi_pw_aff objects.
+ * "fn" is the function that is tested.
+ * "arg" is a string description of the input.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_pw_aff *(*fn)(__isl_take isl_multi_pw_aff *mpa);
+	const char *arg;
+	const char *res;
+} mpa_un_tests = {
+	{ &isl_multi_pw_aff_range_factor_domain,
+	  "{ Ax -> B(1 : x >= 5) -> C(2 : x <= 10) }",
+	  "{ Ax -> B(1 : x >= 5) }" },
+	{ &isl_multi_pw_aff_range_factor_range,
+	  "{ Ax -> B(1 : x >= 5) -> C(2 : x <= 10) }",
+	  "{ Ay -> C(2 : y <= 10) }" },
+	{ &isl_multi_pw_aff_range_factor_domain,
+	  "{ Ax -> B(1 : x >= 5) -> C }",
+	  "{ Ax -> B(1 : x >= 5) }" },
+	{ &isl_multi_pw_aff_range_factor_range,
+	  "{ Ax -> B(1 : x >= 5) -> C }",
+	  "{ Ay -> C }" },
+	{ &isl_multi_pw_aff_range_factor_domain,
+	  "{ Ax -> B -> C(2 : x <= 10) }",
+	  "{ Ax -> B }" },
+	{ &isl_multi_pw_aff_range_factor_range,
+	  "{ Ax -> B -> C(2 : x <= 10) }",
+	  "{ Ay -> C(2 : y <= 10) }" },
+	{ &isl_multi_pw_aff_range_factor_domain,
+	  "{ Ax -> B -> C }",
+	  "{ Ax -> B }" },
+	{ &isl_multi_pw_aff_range_factor_range,
+	  "{ Ax -> B -> C }",
+	  "{ Ay -> C }" },
+	{ &isl_multi_pw_aff_factor_range,
+	  "{ B -> C }",
+	  "{ C }" },
+	{ &isl_multi_pw_aff_range_factor_domain,
+	  "{ Ax -> B -> C : x >= 0 }",
+	  "{ Ax -> B : x >= 0 }" },
+	{ &isl_multi_pw_aff_range_factor_range,
+	  "{ Ax -> B -> C : x >= 0 }",
+	  "{ Ay -> C : y >= 0 }" },
+	{ &isl_multi_pw_aff_factor_range,
+	  "N -> { B -> C : N >= 0 }",
+	  "N -> { C : N >= 0 }" },
+};
+
+/* Perform some basic tests of unary operations on isl_multi_pw_aff objects.
+ */
+static int test_un_mpa(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_pw_aff *mpa, *res;
+
+	for (i = 0; i < ARRAY_SIZE(mpa_un_tests); ++i) {
+		mpa = isl_multi_pw_aff_read_from_str(ctx, mpa_un_testsi.arg);
+		res = isl_multi_pw_aff_read_from_str(ctx, mpa_un_testsi.res);
+		mpa = mpa_un_testsi.fn(mpa);
+		ok = isl_multi_pw_aff_plain_is_equal(mpa, res);
+		isl_multi_pw_aff_free(mpa);
+		isl_multi_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on isl_multi_pw_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_pw_aff *(*fn)(
+		__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mpa_bin_tests = {
+	{ &isl_multi_pw_aff_add, "{ A -> 1 }", "{ A -> 2 }",
+	  "{ A -> 3 }" },
+	{ &isl_multi_pw_aff_add, "{ Ax -> (1 : x >= 5) }",
+	  "{ Ax -> (x : x <= 10) }",
+	  "{ Ax -> (1 + x : 5 <= x <= 10) }" },
+	{ &isl_multi_pw_aff_add, "{ Ax ->  : x >= 5 }",
+	  "{ Ax ->  : x <= 10 }",
+	  "{ Ax ->  : 5 <= x <= 10 }" },
+	{ &isl_multi_pw_aff_add, "{ Ax ->  : x >= 5 }",
+	  "N -> { Ax ->  : x <= N }",
+	  "N -> { Ax ->  : 5 <= x <= N }" },
+	{ &isl_multi_pw_aff_add,
+	  "N -> { Ax ->  : x <= N }",
+	  "{ Ax ->  : x >= 5 }",
+	  "N -> { Ax ->  : 5 <= x <= N }" },
+	{ &isl_multi_pw_aff_range_product, "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ay -> C(2 : y <= 10) }",
+	  "{ Ax -> B(1 : x >= 5) -> C(2 : x <= 10) }" },
+	{ &isl_multi_pw_aff_range_product, "{ Ax -> B1 : x >= 5 }",
+	  "{ Ay -> C2 : y <= 10 }",
+	  "{ Ax -> B(1 : x >= 5) -> C(2 : x <= 10) }" },
+	{ &isl_multi_pw_aff_range_product, "{ Ax -> B1 : x >= 5 }",
+	  "N -> { Ay -> C2 : y <= N }",
+	  "N -> { Ax -> B(1 : x >= 5) -> C(2 : x <= N) }" },
+	{ &isl_multi_pw_aff_range_product, "N -> { Ax -> B1 : x >= N }",
+	  "{ Ay -> C2 : y <= 10 }",
+	  "N -> { Ax -> B(1 : x >= N) -> C(2 : x <= 10) }" },
+	{ &isl_multi_pw_aff_range_product, "{ A -> B1 }", "{ A -> C2 }",
+	  "{ A -> B1 -> C2 }" },
+	{ &isl_multi_pw_aff_range_product, "{ A -> B }", "{ A -> C }",
+	  "{ A -> B -> C }" },
+	{ &isl_multi_pw_aff_range_product, "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ay -> C : y <= 10 }",
+	  "{ Ax -> B(1 : x >= 5) -> C : x <= 10 }" },
+	{ &isl_multi_pw_aff_range_product, "{ Ay -> C : y <= 10 }",
+	  "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ax -> C -> B(1 : x >= 5) : x <= 10 }" },
+	{ &isl_multi_pw_aff_product, "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ay -> C(2 : y <= 10) }",
+	  "{ Ax -> Ay -> B(1 : x >= 5) -> C(2 : y <= 10) }" },
+	{ &isl_multi_pw_aff_product, "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ay -> C : y <= 10 }",
+	  "{ Ax -> Ay -> B(1 : x >= 5) -> C : y <= 10 }" },
+	{ &isl_multi_pw_aff_product, "{ Ay -> C : y <= 10 }",
+	  "{ Ax -> B(1 : x >= 5) }",
+	  "{ Ay -> Ax -> C -> B(1 : x >= 5) : y <= 10 }" },
+	{ &isl_multi_pw_aff_product, "{ Ax -> B(1 : x >= 5) }",
+	  "N -> { Ay -> C : y <= N }",
+	  "N -> { Ax -> Ay -> B(1 : x >= 5) -> C : y <= N }" },
+	{ &isl_multi_pw_aff_product, "N -> { Ay -> C : y <= N }",
+	  "{ Ax -> B(1 : x >= 5) }",
+	  "N -> { Ay -> Ax -> C -> B(1 : x >= 5) : y <= N }" },
+	{ &isl_multi_pw_aff_product, "{ Ax -> B : x >= 5 }",
+	  "{ Ay -> C : y <= 10 }",
+	  "{ Ax -> Ay -> B -> C : x >= 5 and y <= 10 }" },
+	{ &isl_multi_pw_aff_product, "{ A -> B1 }", "{ A -> C2 }",
+	  "{ A -> A -> B1 -> C2 }" },
+	{ &isl_multi_pw_aff_product, "{ A -> B }", "{ A -> C }",
+	  "{ A -> A -> B -> C }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> Ci + 2j }", "{ Aa,b -> Bb,a }",
+	  "{ Aa,b -> Cb + 2a }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> Ci + 2j }",
+	  "{ Aa,b -> B(b : b > a),(a : b > a) }",
+	  "{ Aa,b -> C(b + 2a : b > a) }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> C(i + 2j : j > 4) }",
+	  "{ Aa,b -> B(b : b > a),(a : b > a) }",
+	  "{ Aa,b -> C(b + 2a : b > a > 4) }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> C }",
+	  "{ Aa,b -> B(b : b > a),(a : b > a) }",
+	  "{ Aa,b -> C }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> C : i > j }",
+	  "{ Aa,b -> Bb,a }",
+	  "{ Aa,b -> C : b > a }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "{ Bi,j -> C : j > 5 }",
+	  "{ Aa,b -> B(b : b > a),(a : b > a) }",
+	  "{ Aa,b -> C : b > a > 5 }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "N -> { Bi,j -> C : j > N }",
+	  "{ Aa,b -> B(b : b > a),(a : b > a) }",
+	  "N -> { Aa,b -> C : b > a > N }" },
+	{ &isl_multi_pw_aff_pullback_multi_pw_aff,
+	  "M,N -> { B -> C : N > 5 }",
+	  "M,N -> { A -> B : M > N }",
+	  "M,N -> { A -> C : M > N > 5 }" },
+};
+
+/* Perform some basic tests of binary operations on isl_multi_pw_aff objects.
+ */
+static int test_bin_mpa(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_pw_aff *mpa1, *mpa2, *res;
+
+	for (i = 0; i < ARRAY_SIZE(mpa_bin_tests); ++i) {
+		mpa1 = isl_multi_pw_aff_read_from_str(ctx,
+							mpa_bin_testsi.arg1);
+		mpa2 = isl_multi_pw_aff_read_from_str(ctx,
+							mpa_bin_testsi.arg2);
+		res = isl_multi_pw_aff_read_from_str(ctx,
+							mpa_bin_testsi.res);
+		mpa1 = mpa_bin_testsi.fn(mpa1, mpa2);
+		ok = isl_multi_pw_aff_plain_is_equal(mpa1, res);
+		isl_multi_pw_aff_free(mpa1);
+		isl_multi_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of unary operations on
+ * isl_multi_union_pw_aff objects.
+ * "fn" is the function that is tested.
+ * "arg" is a string description of the input.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	const char *arg;
+	const char *res;
+} mupa_un_tests = {
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "B{ A -> 1 } -> C{ A -> 2 }",
+	  "C{ A -> 2 }" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "B -> C{ A -> 2 }",
+	  "C{ A -> 2 }" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "B{ A -> 1 } -> C",
+	  "C" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "B -> C",
+	  "C" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "(B -> C : { Ax : x >= 0 })",
+	  "(C : { Ax : x >= 0 })" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "N -> (B -> C : { Ax : x <= N })",
+	  "N -> (C : { Ax : x <= N })" },
+	{ &isl_multi_union_pw_aff_factor_range,
+	  "N -> (B -> C : { : N >= 0 })",
+	  "N -> (C : { : N >= 0 })" },
+};
+
+/* Perform some basic tests of unary operations on
+ * isl_multi_union_pw_aff objects.
+ */
+static int test_un_mupa(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_un_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+							mupa_un_testsi.arg);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+							mupa_un_testsi.res);
+		mupa = mupa_un_testsi.fn(mupa);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * isl_multi_union_pw_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa1,
+		__isl_take isl_multi_union_pw_aff *mupa2);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_bin_tests = {
+	{ &isl_multi_union_pw_aff_add, "{ A -> 1 }", "{ A -> 2 }",
+	  "{ A -> 3 }" },
+	{ &isl_multi_union_pw_aff_sub, "{ A -> 1 }", "{ A -> 2 }",
+	  "{ A -> -1 }" },
+	{ &isl_multi_union_pw_aff_add,
+	  "{ A -> 1; B -> 4 }",
+	  "{ A -> 2; C -> 5 }",
+	  "{ A -> 3 }" },
+	{ &isl_multi_union_pw_aff_union_add,
+	  "{ A -> 1; B -> 4 }",
+	  "{ A -> 2; C -> 5 }",
+	  "{ A -> 3; B -> 4; C -> 5 }" },
+	{ &isl_multi_union_pw_aff_add, "{ Ax -> (1) : x >= 5 }",
+	  "{ Ax -> (x) : x <= 10 }",
+	  "{ Ax -> (1 + x) : 5 <= x <= 10 }" },
+	{ &isl_multi_union_pw_aff_add, "( : { Ax : x >= 5 })",
+	  "( : { Ax : x <= 10 })",
+	  "( : { Ax : 5 <= x <= 10 })" },
+	{ &isl_multi_union_pw_aff_add, "( : { Ax : x >= 5 })",
+	  "N -> ( : { Ax : x <= N })",
+	  "N -> ( : { Ax : 5 <= x <= N })" },
+	{ &isl_multi_union_pw_aff_add, "N -> ( : { Ax : x >= N })",
+	  "( : { Ax : x <= 10 })",
+	  "N -> ( : { Ax : N <= x <= 10 })" },
+	{ &isl_multi_union_pw_aff_union_add, "{ Ax -> (1) : x >= 5 }",
+	  "{ Ax -> (x) : x <= 10 }",
+	  "{ Ax -> (1 + x) : 5 <= x <= 10; "
+	     "Ax -> (1) : x > 10; Ax -> (x) : x < 5 }" },
+	{ &isl_multi_union_pw_aff_union_add, "( : { Ax : x >= 5 })",
+	  "( : { Ax : x <= 10 })",
+	  "( : { Ax })" },
+	{ &isl_multi_union_pw_aff_union_add, "( : { Ax : x >= 0 })",
+	  "N -> ( : { Ax : x >= N })",
+	  "N -> ( : { Ax : x >= 0 or x >= N })" },
+	{ &isl_multi_union_pw_aff_union_add,
+	  "N -> ( : { A : N >= 0})",
+	  "N -> ( : { A : N <= 0})",
+	  "N -> ( : { A })" },
+	{ &isl_multi_union_pw_aff_union_add,
+	  "N -> ( : { A })",
+	  "N -> ( : { : })",
+	  "N -> ( : { : })" },
+	{ &isl_multi_union_pw_aff_union_add,
+	  "N -> ( : { : })",
+	  "N -> ( : { A })",
+	  "N -> ( : { : })" },
+	{ &isl_multi_union_pw_aff_union_add,
+	  "N -> ( : { : N >= 0})",
+	  "N -> ( : { : N <= 0})",
+	  "N -> ( : { : })" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "B{ A -> 1 }",
+	  "C{ A -> 2 }",
+	  "B{ A -> 1 } -> C{ A -> 2 }" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "(B : { Ax : x >= 5 })",
+	  "(C : { Ax : x <= 10 })",
+	  "(B -> C : { Ax : 5 <= x <= 10 })" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "B{ Ax -> x + 1 : x >= 5 }",
+	  "(C : { Ax : x <= 10 })",
+	  "B{ Ax -> x + 1 : 5 <= x <= 10 } -> C" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "(C : { Ax : x <= 10 })",
+	  "B{ Ax -> x + 1 : x >= 5 }",
+	  "C -> B{ Ax -> x + 1 : 5 <= x <= 10 }" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "B{ Ax -> x + 1 : x >= 5 }",
+	  "N -> (C : { Ax : x <= N })",
+	  "N -> B{ Ax -> x + 1 : 5 <= x <= N } -> C" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "N -> (C : { Ax : x <= N })",
+	  "B{ Ax -> x + 1 : x >= 5 }",
+	  "N -> C -> B{ Ax -> x + 1 : 5 <= x <= N }" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "B{ A -> 1; D -> 3 }",
+	  "C{ A -> 2 }",
+	  "B{ A -> 1; D -> 3 } -> C{ A -> 2 }" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "B }",
+	  "(C : { Ax })",
+	  "(B -> C : { Ax })" },
+	{ &isl_multi_union_pw_aff_range_product,
+	  "(B : { Ax })",
+	  "C }",
+	  "(B -> C : { Ax })" },
+};
+
+/* Perform some basic tests of binary operations on
+ * isl_multi_union_pw_aff objects.
+ */
+static int test_bin_mupa(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa1, *mupa2, *res;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_bin_tests); ++i) {
+		mupa1 = isl_multi_union_pw_aff_read_from_str(ctx,
+							mupa_bin_testsi.arg1);
+		mupa2 = isl_multi_union_pw_aff_read_from_str(ctx,
+							mupa_bin_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+							mupa_bin_testsi.res);
+		mupa1 = mupa_bin_testsi.fn(mupa1, mupa2);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa1, res);
+		isl_multi_union_pw_aff_free(mupa1);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_set objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_set *set);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_set_tests = {
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "C{ Bi,j -> i + 2j }", "{ C1 }",
+	  "C{ Bi,j -> i + 2j : i + 2j = 1 }" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "C{ Bi,j -> i + 2j }", "N -> { CN }",
+	  "N -> C{ Bi,j -> i + 2j : i + 2j = N }" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "N -> C{ Bi,j -> i + 2j + N }", "{ C1 }",
+	  "N -> C{ Bi,j -> i + 2j + N : i + 2j + N = 1 }" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "C{ Bi,j -> i + 2j }", "N -> { Cx : N >= 0 }",
+	  "N -> C{ Bi,j -> i + 2j : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "C", "{ C }", "C" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "N -> (C : { : N >= 0 })",
+	  "{ C }",
+	  "N -> (C : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "(C : { Aa,b })",
+	  "{ C }",
+	  "(C : { Aa,b })" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "N -> (C : { Aa,b : a,b <= N })",
+	  "{ C }",
+	  "N -> (C : { Aa,b : a,b <= N })" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "C",
+	  "N -> { C : N >= 0 }",
+	  "N -> (C : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "(C : { Aa,b })",
+	  "N -> { C : N >= 0 }",
+	  "N -> (C : { Aa,b : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_intersect_range,
+	  "N -> (C : { : N >= 0 })",
+	  "N -> { C : N < 1024 }",
+	  "N -> (C : { : 0 <= N < 1024 })" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "C{ Bi,j -> i + 2j }", "N -> { : N >= 0 }",
+	  "N -> C{ Bi,j -> i + 2j : N >= 0}" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "N -> C{ Bi,j -> i + 2j : N <= 256 }", "N -> { : N >= 0 }",
+	  "N -> C{ Bi,j -> i + 2j : 0 <= N <= 256 }" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "N -> C{ Bi,j -> i + 2j : N <= 256 }", "{ : }",
+	  "N -> C{ Bi,j -> i + 2j : N <= 256 }" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "C", "N -> { : N >= 0 }",
+	  "N -> (C : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "(C : { Aa,b })", "N -> { : N >= 0 }",
+	  "N -> (C : { Aa,b : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "N -> (C : { Aa,N })", "{ : }",
+	  "N -> (C : { Aa,N })" },
+	{ &isl_multi_union_pw_aff_intersect_params,
+	  "N -> (C : { Aa,b : N <= 256 })", "N -> { : N >= 0 }",
+	  "N -> (C : { Aa,b : 0 <= N <= 256 })" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_set objects.
+ */
+static int test_mupa_set(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+	isl_set *set;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_set_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_set_testsi.arg1);
+		set = isl_set_read_from_str(ctx, mupa_set_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_set_testsi.res);
+		mupa = mupa_set_testsi.fn(mupa, set);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_union_set objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_union_set *uset);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_uset_tests = {
+	{ &isl_multi_union_pw_aff_intersect_domain,
+	  "C{ Bi,j -> i + 2j }", "{ Bi,i }",
+	  "C{ Bi,i -> 3i }" },
+	{ &isl_multi_union_pw_aff_intersect_domain,
+	  "(C : { Bi,j })", "{ Bi,i }",
+	  "(C : { Bi,i })" },
+	{ &isl_multi_union_pw_aff_intersect_domain,
+	  "(C : { Bi,j })", "N -> { BN,N }",
+	  "N -> (C : { BN,N })" },
+	{ &isl_multi_union_pw_aff_intersect_domain,
+	  "C", "{ Bi,i }",
+	  "(C : { Bi,i })" },
+	{ &isl_multi_union_pw_aff_intersect_domain,
+	  "N -> (C : { : N >= 0 })", "{ Bi,i }",
+	  "N -> (C : { Bi,i : N >= 0 })" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_union_set objects.
+ */
+static int test_mupa_uset(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+	isl_union_set *uset;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_uset_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_uset_testsi.arg1);
+		uset = isl_union_set_read_from_str(ctx,
+						    mupa_uset_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_uset_testsi.res);
+		mupa = mupa_uset_testsi.fn(mupa, uset);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_multi_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_multi_aff *ma);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_ma_tests = {
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }, "
+	    "{ Ai,j -> j; Bi,j -> i }",
+	  "{ Ca,b -> Db,a }",
+	  "D{ Ai,j -> j; Bi,j -> i }, "
+	    "{ Ai,j -> i; Bi,j -> j }" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "C{ Ai,j -> i : i >= 0; Bi,j -> j }, "
+	    "{ Ai,j -> j; Bi,j -> i }",
+	  "{ Ca,b -> Db,a }",
+	  "D{ Ai,j -> j : i >= 0; Bi,j -> i }, "
+	    "{ Ai,j -> i : i >= 0; Bi,j -> j }" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }",
+	  "N -> { Ca -> Da + N }",
+	  "N -> D{ Ai,j -> i + N; Bi,j -> j + N } " },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "C",
+	  "{ C -> D }",
+	  "D" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "{ C -> D }",
+	  "N -> (D : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "C",
+	  "N -> { C -> DN }",
+	  "N -> D{ N }" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "{ C -> D }",
+	  "(D : { Ai,j : i >= j })" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "N -> (C : { Ai,j : N >= 0 })",
+	  "{ C -> D }",
+	  "N -> (D : { Ai,j : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_apply_multi_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "N -> { C -> DN }",
+	  "N -> (D{ Ai,j -> N : i >= j })" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_multi_aff objects.
+ */
+static int test_mupa_ma(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+	isl_multi_aff *ma;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_ma_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_ma_testsi.arg1);
+		ma = isl_multi_aff_read_from_str(ctx, mupa_ma_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_ma_testsi.res);
+		mupa = mupa_ma_testsi.fn(mupa, ma);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_pw_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_pw_aff *pa);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_pa_tests = {
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }",
+	  "N -> { Ca -> a + N }",
+	  "N -> { Ai,j -> i + N; Bi,j -> j + N }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }",
+	  "{ Ca -> a : a >= 0; Ca -> -a : a < 0 }",
+	  "{ Ai,j -> i : i >= 0; Ai,j -> -i : i < 0; "
+	    "Bi,j -> j : j >= 0; Bi,j -> -j : j < 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "C",
+	  "N -> { C -> N }",
+	  "N -> { N }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "C",
+	  "N -> { C -> N : N >= 0; C -> -N : N < 0 }",
+	  "N -> { N : N >= 0; -N : N < 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "N -> { C -> N }",
+	  "N -> { N : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "N -> { C -> N : N >= 0; C -> -N : N < 0 }",
+	  "N -> { N : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "{ C -> 0 }",
+	  "N -> { 0 : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "N -> { C -> N }",
+	  "N -> { Ai,j -> N : i >= j }" },
+	{ &isl_multi_union_pw_aff_apply_pw_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "N -> { C -> N : N >= 0 }",
+	  "N -> { Ai,j -> N : i >= j and N >= 0 }" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_pw_aff objects.
+ */
+static int test_mupa_pa(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa;
+	isl_union_pw_aff *upa, *res;
+	isl_pw_aff *pa;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_pa_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_pa_testsi.arg1);
+		pa = isl_pw_aff_read_from_str(ctx, mupa_pa_testsi.arg2);
+		res = isl_union_pw_aff_read_from_str(ctx,
+						    mupa_pa_testsi.res);
+		upa = mupa_pa_testsi.fn(mupa, pa);
+		ok = isl_union_pw_aff_plain_is_equal(upa, res);
+		isl_union_pw_aff_free(upa);
+		isl_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_pw_multi_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_pw_multi_aff *pma);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_pma_tests = {
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }, "
+	    "{ Ai,j -> j; Bi,j -> i }",
+	  "{ Ca,b -> Db,a }",
+	  "D{ Ai,j -> j; Bi,j -> i }, "
+	    "{ Ai,j -> i; Bi,j -> j }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C{ Ai,j -> i : i >= 0; Bi,j -> j }, "
+	    "{ Ai,j -> j; Bi,j -> i }",
+	  "{ Ca,b -> Db,a }",
+	  "D{ Ai,j -> j : i >= 0; Bi,j -> i }, "
+	    "{ Ai,j -> i : i >= 0; Bi,j -> j }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }",
+	  "N -> { Ca -> Da + N }",
+	  "N -> D{ Ai,j -> i + N; Bi,j -> j + N }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }",
+	  "{ Ca -> Da : a >= 0; Ca -> D-a : a < 0 }",
+	  "D{ Ai,j -> i : i >= 0; Ai,j -> -i : i < 0; "
+	      "Bi,j -> j : j >= 0; Bi,j -> -j : j < 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C{ Ai,j -> i; Bi,j -> j }, "
+	    "{ Ai,j -> j; Bi,j -> i }",
+	  "{ Ca,b -> Da,b : a >= b; Ca,b -> Db,a : a < b }",
+	  "D{ Ai,j -> i : i >= j; Ai,j -> j : i < j; "
+	      "Bi,j -> j : i <= j; Bi,j -> i : i > j }, "
+	    "{ Ai,j -> j : i >= j; Ai,j -> i : i < j; "
+	      "Bi,j -> i : i <= j; Bi,j -> j : i > j }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C",
+	  "{ C -> D }",
+	  "D" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "{ C -> D }",
+	  "N -> (D : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C",
+	  "N -> { C -> DN }",
+	  "N -> D{ N }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "{ C -> D }",
+	  "(D : { Ai,j : i >= j })" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "N -> (C : { Ai,j : N >= 0 })",
+	  "{ C -> D }",
+	  "N -> (D : { Ai,j : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "N -> { C -> DN }",
+	  "N -> (D{ Ai,j -> N : i >= j })" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "C",
+	  "N -> { C -> DN : N >= 0; C -> D-N : N < 0 }",
+	  "N -> D{ N : N >= 0; -N : N < 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "N -> { C -> DN }",
+	  "N -> D{ N : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "N -> { C -> DN : N >= 0; C -> D-N : N < 0 }",
+	  "N -> D{ N : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "{ C -> D0 }",
+	  "N -> D{ 0 : N >= 0 }" },
+	{ &isl_multi_union_pw_aff_apply_pw_multi_aff,
+	  "(C : { Ai,j : i >= j })",
+	  "N -> { C -> DN : N >= 0 }",
+	  "N -> D{ Ai,j -> N : i >= j and N >= 0 }" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_pw_multi_aff objects.
+ */
+static int test_mupa_pma(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+	isl_pw_multi_aff *pma;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_pma_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_pma_testsi.arg1);
+		pma = isl_pw_multi_aff_read_from_str(ctx,
+						    mupa_pma_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_pma_testsi.res);
+		mupa = mupa_pma_testsi.fn(mupa, pma);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_union_pw_multi_aff objects.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_multi_union_pw_aff *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa,
+		__isl_take isl_union_pw_multi_aff *upma);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} mupa_upma_tests = {
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C{ Bi,j -> i + 2j }", "{ Aa,b -> Bb,a }",
+	  "C{ Aa,b -> b + 2a }" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C{ Bi,j -> i + 2j }",
+	  "{ Aa,b -> Bb,a : b > a }",
+	  "C{ Aa,b -> b + 2a : b > a }" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C{ Bi,j -> i + 2j : j > 4 }",
+	  "{ Aa,b -> Bb,a : b > a }",
+	  "C{ Aa,b -> b + 2a : b > a > 4 }" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C{ Bi,j -> i + 2j }",
+	  "{ Aa,b -> Bb,a : a > b; Aa,b -> Ba,b : a <= b }",
+	  "C{ Aa,b -> b + 2a : a > b; Aa,b -> a + 2b : a <= b }" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "(C : { Ba,b })",
+	  "{ Aa,b -> Bb,a }",
+	  "(C : { Aa,b })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "(C : { Ba,b })",
+	  "{ Ba,b -> Ab,a }",
+	  "(C : { })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "(C : { Ba,b })",
+	  "{ Aa,b -> Bb,a : a > b }",
+	  "(C : { Aa,b : a > b })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "(C : { Ba,b : a > b })",
+	  "{ Aa,b -> Bb,a }",
+	  "(C : { Aa,b : b > a })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "N -> (C : { Ba,b : a > N })",
+	  "{ Aa,b -> Bb,a : a > b }",
+	  "N -> (C : { Aa,b : a > b > N })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "(C : { Ba,b : a > b })",
+	  "N -> { Aa,b -> Bb,a : a > N }",
+	  "N -> (C : { Aa,b : b > a > N })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C",
+	  "{ Aa,b -> Bb,a }",
+	  "C" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "N -> (C : { : N >= 0 })",
+	  "{ Aa,b -> Bb,a }",
+	  "N -> (C : { : N >= 0 })" },
+	{ &isl_multi_union_pw_aff_pullback_union_pw_multi_aff,
+	  "C",
+	  "N -> { Aa,b -> Bb,a : N >= 0 }",
+	  "N -> (C : { : N >= 0 })" },
+};
+
+/* Perform some basic tests of binary operations on
+ * pairs of isl_multi_union_pw_aff and isl_union_pw_multi_aff objects.
+ */
+static int test_mupa_upma(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_multi_union_pw_aff *mupa, *res;
+	isl_union_pw_multi_aff *upma;
+
+	for (i = 0; i < ARRAY_SIZE(mupa_upma_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_upma_testsi.arg1);
+		upma = isl_union_pw_multi_aff_read_from_str(ctx,
+						    mupa_upma_testsi.arg2);
+		res = isl_multi_union_pw_aff_read_from_str(ctx,
+						    mupa_upma_testsi.res);
+		mupa = mupa_upma_testsi.fn(mupa, upma);
+		ok = isl_multi_union_pw_aff_plain_is_equal(mupa, res);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Check that the input tuple of an isl_aff can be set properly.
+ */
+static isl_stat test_aff_set_tuple_id(isl_ctx *ctx)
+{
+	isl_id *id;
+	isl_aff *aff;
+	isl_stat equal;
+
+	aff = isl_aff_read_from_str(ctx, "{ x -> x + 1 }");
+	id = isl_id_alloc(ctx, "A", NULL);
+	aff = isl_aff_set_tuple_id(aff, isl_dim_in, id);
+	equal = aff_check_plain_equal(aff, "{ Ax -> x + 1 }");
+	isl_aff_free(aff);
+	if (equal < 0)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Check that affine expressions get normalized on addition/subtraction.
+ * In particular, check that (final) unused integer divisions get removed
+ * such that an expression derived from expressions with integer divisions
+ * is found to be obviously equal to one that is created directly.
+ */
+static isl_stat test_aff_normalize(isl_ctx *ctx)
+{
+	isl_aff *aff, *aff2;
+	isl_stat ok;
+
+	aff = isl_aff_read_from_str(ctx, "{ x -> x//2 }");
+	aff2 = isl_aff_read_from_str(ctx, "{ x -> 1 + x//2 }");
+	aff = isl_aff_sub(aff2, aff);
+	ok = aff_check_plain_equal(aff, "{ x -> 1 }");
+	isl_aff_free(aff);
+
+	return ok;
+}
+
 int test_aff(isl_ctx *ctx)
 {
 	const char *str;
@@ -3351,10 +6772,43 @@
 	isl_space *space;
 	isl_local_space *ls;
 	isl_aff *aff;
-	int zero, equal;
+	int zero;
+	isl_stat equal;
 
+	if (test_upa(ctx) < 0)
+		return -1;
 	if (test_bin_aff(ctx) < 0)
 		return -1;
+	if (test_bin_pw_aff(ctx) < 0)
+		return -1;
+	if (test_upma_test(ctx) < 0)
+		return -1;
+	if (test_bin_upma(ctx) < 0)
+		return -1;
+	if (test_bin_upma_fail(ctx) < 0)
+		return -1;
+	if (test_upma_uset(ctx) < 0)
+		return -1;
+	if (test_un_mpa(ctx) < 0)
+		return -1;
+	if (test_bin_mpa(ctx) < 0)
+		return -1;
+	if (test_un_mupa(ctx) < 0)
+		return -1;
+	if (test_bin_mupa(ctx) < 0)
+		return -1;
+	if (test_mupa_set(ctx) < 0)
+		return -1;
+	if (test_mupa_uset(ctx) < 0)
+		return -1;
+	if (test_mupa_ma(ctx) < 0)
+		return -1;
+	if (test_mupa_pa(ctx) < 0)
+		return -1;
+	if (test_mupa_pma(ctx) < 0)
+		return -1;
+	if (test_mupa_upma(ctx) < 0)
+		return -1;
 
 	space = isl_space_set_alloc(ctx, 0, 1);
 	ls = isl_local_space_from_space(space);
@@ -3389,9 +6843,670 @@
 	if (equal < 0)
 		return -1;
 
+	if (test_aff_set_tuple_id(ctx) < 0)
+		return -1;
+	if (test_aff_normalize(ctx) < 0)
+		return -1;
+
 	return 0;
 }
 
+/* Inputs for isl_set_bind tests.
+ * "set" is the input set.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+static
+struct {
+	const char *set;
+	const char *tuple;
+	const char *res;
+} bind_set_tests = {
+	{ "{ AM, N : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ AM, N }",
+	  "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "{ BN, M : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ BN, M }",
+	  "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "M -> { CN : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ CN }",
+	  "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "M -> { Dx, N : x mod 2 = 0 and N mod 8 = 3 and M >= 0 }",
+	  "{ DM, N }",
+	  "M, N -> { : M mod 2 = 0 and N mod 8 = 3 and M >= 0 }" },
+};
+
+/* Perform basic isl_set_bind tests.
+ */
+static isl_stat test_bind_set(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_set_tests); ++i) {
+		const char *str;
+		isl_set *set;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		set = isl_set_read_from_str(ctx, bind_set_testsi.set);
+		str = bind_set_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		set = isl_set_bind(set, tuple);
+		r = set_check_equal(set, bind_set_testsi.res);
+		isl_set_free(set);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_map_bind_domain tests.
+ * "map" is the input map.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+struct {
+	const char *map;
+	const char *tuple;
+	const char *res;
+} bind_map_domain_tests = {
+	{ "{ AM, N -> M + floor(N/2) }",
+	  "{ AM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "{ BN, M -> M + floor(N/2) }",
+	  "{ BN, M }",
+	  "N, M -> { M + floor(N/2) }" },
+	{ "M -> { CN -> M + floor(N/2) }",
+	  "{ CN }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "M -> { Cx, N -> x + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "M -> { Cx, N -> M + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "A, M -> { CN, x -> x + floor(N/2) }",
+	  "{ CN, M }",
+	  "A, N, M -> { M + floor(N/2) }" },
+};
+
+/* Perform basic isl_map_bind_domain tests.
+ */
+static isl_stat test_bind_map_domain(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_map_domain_tests); ++i) {
+		const char *str;
+		isl_map *map;
+		isl_set *set;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = bind_map_domain_testsi.map;
+		map = isl_map_read_from_str(ctx, str);
+		str = bind_map_domain_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		set = isl_map_bind_domain(map, tuple);
+		str = bind_map_domain_testsi.res;
+		r = set_check_equal(set, str);
+		isl_set_free(set);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_union_map_bind_range tests.
+ * "map" is the input union map.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+struct {
+	const char *map;
+	const char *tuple;
+	const char *res;
+} bind_umap_range_tests = {
+	{ "{ BN, M -> AM, N : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ AM, N }",
+	  "M, N -> { BN, M : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "{ BN, M -> AM, N : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ BM, N }",
+	  "{ }" },
+	{ "{ A -> B; C -> D; E -> B }",
+	  "{ B }",
+	  "{ A; E }" },
+};
+
+/* Perform basic isl_union_map_bind_range tests.
+ */
+static isl_stat test_bind_umap_range(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_umap_range_tests); ++i) {
+		const char *str;
+		isl_union_map *umap;
+		isl_union_set *uset;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = bind_umap_range_testsi.map;
+		umap = isl_union_map_read_from_str(ctx, str);
+		str = bind_umap_range_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		uset = isl_union_map_bind_range(umap, tuple);
+		str = bind_umap_range_testsi.res;
+		r = uset_check_equal(uset, str);
+		isl_union_set_free(uset);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_pw_multi_aff_bind_domain tests.
+ * "pma" is the input expression.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+struct {
+	const char *pma;
+	const char *tuple;
+	const char *res;
+} bind_pma_domain_tests = {
+	{ "{ AM, N -> M + floor(N/2) }",
+	  "{ AM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "{ BN, M -> M + floor(N/2) }",
+	  "{ BN, M }",
+	  "N, M -> { M + floor(N/2) }" },
+	{ "M -> { CN -> M + floor(N/2) }",
+	  "{ CN }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "M -> { Cx, N -> x + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "M -> { Cx, N -> M + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { M + floor(N/2) }" },
+	{ "A, M -> { CN, x -> x + floor(N/2) }",
+	  "{ CN, M }",
+	  "A, N, M -> { M + floor(N/2) }" },
+};
+
+/* Perform basic isl_pw_multi_aff_bind_domain tests.
+ */
+static isl_stat test_bind_pma_domain(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_pma_domain_tests); ++i) {
+		const char *str;
+		isl_pw_multi_aff *pma;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = bind_pma_domain_testsi.pma;
+		pma = isl_pw_multi_aff_read_from_str(ctx, str);
+		str = bind_pma_domain_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		pma = isl_pw_multi_aff_bind_domain(pma, tuple);
+		str = bind_pma_domain_testsi.res;
+		r = pw_multi_aff_check_plain_equal(pma, str);
+		isl_pw_multi_aff_free(pma);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_pw_multi_aff_bind_domain_wrapped_domain tests.
+ * "pma" is the input expression.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+struct {
+	const char *pma;
+	const char *tuple;
+	const char *res;
+} bind_pma_domain_wrapped_tests = {
+	{ "{ AM, N -> B -> M + floor(N/2) }",
+	  "{ AM, N }",
+	  "M, N -> { B -> M + floor(N/2) }" },
+	{ "{ BN, M -> D -> M + floor(N/2) }",
+	  "{ BN, M }",
+	  "N, M -> { D -> M + floor(N/2) }" },
+	{ "M -> { CN -> Bx -> x + M + floor(N/2) }",
+	  "{ CN }",
+	  "M, N -> { Bx -> x + M + floor(N/2) }" },
+	{ "M -> { Cx, N -> B -> x + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { B -> M + floor(N/2) }" },
+	{ "M -> { Cx, N -> B -> M + floor(N/2) }",
+	  "{ CM, N }",
+	  "M, N -> { B -> M + floor(N/2) }" },
+	{ "A, M -> { CN, x -> B -> x + floor(N/2) }",
+	  "{ CN, M }",
+	  "A, N, M -> { B -> M + floor(N/2) }" },
+};
+
+/* Perform basic isl_pw_multi_aff_bind_domain_wrapped_domain tests.
+ */
+static isl_stat test_bind_pma_domain_wrapped(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_pma_domain_wrapped_tests); ++i) {
+		const char *str;
+		isl_pw_multi_aff *pma;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = bind_pma_domain_wrapped_testsi.pma;
+		pma = isl_pw_multi_aff_read_from_str(ctx, str);
+		str = bind_pma_domain_wrapped_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		pma = isl_pw_multi_aff_bind_domain_wrapped_domain(pma, tuple);
+		str = bind_pma_domain_wrapped_testsi.res;
+		r = pw_multi_aff_check_plain_equal(pma, str);
+		isl_pw_multi_aff_free(pma);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_aff_bind_id tests.
+ * "aff" is the input expression.
+ * "id" is the binding id.
+ * "res" is the expected result.
+ */
+static
+struct {
+	const char *aff;
+	const char *id;
+	const char *res;
+} bind_aff_tests = {
+	{ "{ 4 }", "M", "M = 4 -> { : }" },
+	{ "{ Bx -> floor(x/2) }", "M", "M -> { Bx : M = floor(x/2) }" },
+	{ "M -> { 4 }", "M", "M = 4 -> { : }" },
+	{ "M -> { floor(M/2) }", "M", "M -> { : floor(M/2) = M }" },
+	{ "{ NaN }", "M", "{ : false }" },
+	{ "{ Ax -> NaN }", "M", "{ Ax : false }" },
+};
+
+/* Perform basic isl_aff_bind_id tests.
+ */
+static isl_stat test_bind_aff(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_aff_tests); ++i) {
+		isl_aff *aff;
+		isl_set *res;
+		isl_id *id;
+		isl_stat r;
+
+		aff = isl_aff_read_from_str(ctx, bind_aff_testsi.aff);
+		id = isl_id_read_from_str(ctx, bind_aff_testsi.id);
+		res = isl_set_from_basic_set(isl_aff_bind_id(aff, id));
+		r = set_check_equal(res, bind_aff_testsi.res);
+		isl_set_free(res);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_pw_aff_bind_id tests.
+ * "pa" is the input expression.
+ * "id" is the binding id.
+ * "res" is the expected result.
+ */
+static
+struct {
+	const char *pa;
+	const char *id;
+	const char *res;
+} bind_pa_tests = {
+	{ "{ 4 }", "M", "M = 4 -> { : }" },
+	{ "{ Bx -> floor(x/2) }", "M", "M -> { Bx : M = floor(x/2) }" },
+	{ "M -> { 4 }", "M", "M = 4 -> { : }" },
+	{ "M -> { floor(M/2) }", "M", "M -> { : floor(M/2) = M }" },
+	{ "M -> { M : M >= 0; -M : M < 0 }", "M", "M -> { : M >= 0 }" },
+	{ "{ NaN }", "M", "{ : false }" },
+	{ "{ Ax -> NaN }", "M", "{ Ax : false }" },
+};
+
+/* Perform basic isl_pw_aff_bind_id tests.
+ */
+static isl_stat test_bind_pa(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_pa_tests); ++i) {
+		isl_pw_aff *pa;
+		isl_set *res;
+		isl_id *id;
+		isl_stat r;
+
+		pa = isl_pw_aff_read_from_str(ctx, bind_pa_testsi.pa);
+		id = isl_id_read_from_str(ctx, bind_pa_testsi.id);
+		res = isl_pw_aff_bind_id(pa, id);
+		r = set_check_equal(res, bind_pa_testsi.res);
+		isl_set_free(res);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_multi_union_pw_aff_bind tests.
+ * "mupa" is the input expression.
+ * "tuple" is the binding tuple.
+ * "res" is the expected result.
+ */
+static
+struct {
+	const char *mupa;
+	const char *tuple;
+	const char *res;
+} bind_mupa_tests = {
+	{ "A{ 4 }, { 5 }",
+	  "{ AM, N }",
+	  "M = 4, N = 5 -> { : }" },
+	{ "A{ Bx -> floor(x/2) }, { By -> y + 5 }",
+	  "{ AM, N }",
+	  "M, N -> { Bx : M = floor(x/2) and N = x + 5 }" },
+	{ "M -> A{ 4 }, { M + 1 }",
+	  "{ AM, N }",
+	  "M = 4, N = 5 -> { : }" },
+};
+
+/* Perform basic isl_multi_union_pw_aff_bind tests.
+ */
+static isl_stat test_bind_mupa(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bind_mupa_tests); ++i) {
+		const char *str;
+		isl_multi_union_pw_aff *mupa;
+		isl_union_set *res;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = bind_mupa_testsi.mupa;
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+		str = bind_mupa_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		res = isl_multi_union_pw_aff_bind(mupa, tuple);
+		r = uset_check_equal(res, bind_mupa_testsi.res);
+		isl_union_set_free(res);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Perform tests that reinterpret dimensions as parameters.
+ */
+static int test_bind(isl_ctx *ctx)
+{
+	if (test_bind_set(ctx) < 0)
+		return -1;
+	if (test_bind_map_domain(ctx) < 0)
+		return -1;
+	if (test_bind_umap_range(ctx) < 0)
+		return -1;
+	if (test_bind_pma_domain(ctx) < 0)
+		return -1;
+	if (test_bind_pma_domain_wrapped(ctx) < 0)
+		return -1;
+	if (test_bind_aff(ctx) < 0)
+		return -1;
+	if (test_bind_pa(ctx) < 0)
+		return -1;
+	if (test_bind_mupa(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Inputs for isl_set_unbind_params tests.
+ * "set" is the input parameter domain.
+ * "tuple" is the tuple of the constructed set.
+ * "res" is the expected result.
+ */
+struct {
+	const char *set;
+	const char *tuple;
+	const char *res;
+} unbind_set_tests = {
+	{ "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ AM, N }",
+	  "{ AM, N : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ BN, M }",
+	  "{ BN, M : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ CN }",
+	  "M -> { CN : M mod 2 = 0 and N mod 8 = 3 }" },
+	{ "M, N -> { : M mod 2 = 0 and N mod 8 = 3 }",
+	  "{ DT, N }",
+	  "M -> { Dx, N : M mod 2 = 0 and N mod 8 = 3 }" },
+};
+
+/* Perform basic isl_set_unbind_params tests.
+ */
+static isl_stat test_unbind_set(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(unbind_set_tests); ++i) {
+		const char *str;
+		isl_set *set;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		set = isl_set_read_from_str(ctx, unbind_set_testsi.set);
+		str = unbind_set_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		set = isl_set_unbind_params(set, tuple);
+		r = set_check_equal(set, unbind_set_testsi.res);
+		isl_set_free(set);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_aff_unbind_params_insert_domain tests.
+ * "aff" is the input affine expression defined over a parameter domain.
+ * "tuple" is the tuple of the domain that gets introduced.
+ * "res" is the expected result.
+ */
+struct {
+	const char *aff;
+	const char *tuple;
+	const char *res;
+} unbind_aff_tests = {
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ AM, N }",
+	  "{ AM, N -> M + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ BN, M }",
+	  "{ BN, M -> M + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ CN }",
+	  "M -> { CN -> M + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ DA, B, C, N, Z }",
+	  "M -> { DA, B, C, N, Z -> M + floor(N/2) }" },
+};
+
+/* Perform basic isl_aff_unbind_params_insert_domain tests.
+ */
+static isl_stat test_unbind_aff(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(unbind_aff_tests); ++i) {
+		const char *str;
+		isl_aff *aff;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		aff = isl_aff_read_from_str(ctx, unbind_aff_testsi.aff);
+		str = unbind_aff_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		aff = isl_aff_unbind_params_insert_domain(aff, tuple);
+		r = aff_check_plain_equal(aff, unbind_aff_testsi.res);
+		isl_aff_free(aff);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for isl_multi_aff_unbind_params_insert_domain tests.
+ * "ma" is the input multi affine expression defined over a parameter domain.
+ * "tuple" is the tuple of the domain that gets introduced.
+ * "res" is the expected result.
+ */
+static struct {
+	const char *ma;
+	const char *tuple;
+	const char *res;
+} unbind_multi_aff_tests = {
+	{ "M, N -> { TM + floor(N/2) }",
+	  "{ AM, N }",
+	  "{ AM, N -> TM + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ BN, M }",
+	  "{ BN, M -> M + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ CN }",
+	  "M -> { CN -> M + floor(N/2) }" },
+	{ "M, N -> { M + floor(N/2) }",
+	  "{ DA, B, C, N, Z }",
+	  "M -> { DA, B, C, N, Z -> M + floor(N/2) }" },
+	{ "M, N -> { TM + floor(N/2), N + floor(M/3) }",
+	  "{ AM, N }",
+	  "{ AM, N -> TM + floor(N/2), N + floor(M/3) }" },
+};
+
+/* Perform basic isl_multi_aff_unbind_params_insert_domain tests.
+ */
+static isl_stat test_unbind_multi_aff(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(unbind_multi_aff_tests); ++i) {
+		const char *str;
+		isl_multi_aff *ma;
+		isl_multi_id *tuple;
+		isl_stat r;
+
+		str = unbind_multi_aff_testsi.ma;
+		ma = isl_multi_aff_read_from_str(ctx, str);
+		str = unbind_multi_aff_testsi.tuple;
+		tuple = isl_multi_id_read_from_str(ctx, str);
+		ma = isl_multi_aff_unbind_params_insert_domain(ma, tuple);
+		str = unbind_multi_aff_testsi.res;
+		r = multi_aff_check_plain_equal(ma, str);
+		isl_multi_aff_free(ma);
+		if (r < 0)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Perform tests that reinterpret parameters.
+ */
+static int test_unbind(isl_ctx *ctx)
+{
+	if (test_unbind_set(ctx) < 0)
+		return -1;
+	if (test_unbind_aff(ctx) < 0)
+		return -1;
+	if (test_unbind_multi_aff(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Check that "pa" consists of a single expression.
+ */
+static int check_single_piece(isl_ctx *ctx, __isl_take isl_pw_aff *pa)
+{
+	isl_size n;
+
+	n = isl_pw_aff_n_piece(pa);
+	isl_pw_aff_free(pa);
+
+	if (n < 0)
+		return -1;
+	if (n != 1)
+		isl_die(ctx, isl_error_unknown, "expecting single expression",
+			return -1);
+
+	return 0;
+}
+
+/* Check that the computation below results in a single expression.
+ * One or two expressions may result depending on which constraint
+ * ends up being considered as redundant with respect to the other
+ * constraints after the projection that is performed internally
+ * by isl_set_dim_min.
+ */
+static int test_dim_max_1(isl_ctx *ctx)
+{
+	const char *str;
+	isl_set *set;
+	isl_pw_aff *pa;
+
+	str = "n -> { a, b : n >= 0 and 4a >= -4 + n and b >= 0 and "
+				"-4a <= b <= 3 and b < n - 4a }";
+	set = isl_set_read_from_str(ctx, str);
+	pa = isl_set_dim_min(set, 0);
+	return check_single_piece(ctx, pa);
+}
+
+/* Check that the computation below results in a single expression.
+ * The PIP problem corresponding to these constraints has a row
+ * that causes a split of the solution domain.  The solver should
+ * first pick rows that split off empty parts such that the actual
+ * solution domain does not get split.
+ * Note that the description contains some redundant constraints.
+ * If these constraints get removed first, then the row mentioned
+ * above does not appear in the PIP problem.
+ */
+static int test_dim_max_2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_set *set;
+	isl_pw_aff *pa;
+
+	str = "P, N -> { a : a < N and a >= 0 and N > P and a <= P and "
+				"N > 0 and P >= 0 }";
+	set = isl_set_read_from_str(ctx, str);
+	pa = isl_set_dim_max(set, 0);
+	return check_single_piece(ctx, pa);
+}
+
 int test_dim_max(isl_ctx *ctx)
 {
 	int equal;
@@ -3401,6 +7516,11 @@
 	isl_map *map;
 	isl_pw_aff *pwaff;
 
+	if (test_dim_max_1(ctx) < 0)
+		return -1;
+	if (test_dim_max_2(ctx) < 0)
+		return -1;
+
 	str = "N -> { i : 0 <= i <= min(N,10) }";
 	set = isl_set_read_from_str(ctx, str);
 	pwaff = isl_set_dim_max(set, 0);
@@ -3509,50 +7629,13 @@
 	return 0;
 }
 
-/* Is "pma" obviously equal to the isl_pw_multi_aff represented by "str"?
- */
-static int pw_multi_aff_plain_is_equal(__isl_keep isl_pw_multi_aff *pma,
-	const char *str)
-{
-	isl_ctx *ctx;
-	isl_pw_multi_aff *pma2;
-	int equal;
-
-	if (!pma)
-		return -1;
-
-	ctx = isl_pw_multi_aff_get_ctx(pma);
-	pma2 = isl_pw_multi_aff_read_from_str(ctx, str);
-	equal = isl_pw_multi_aff_plain_is_equal(pma, pma2);
-	isl_pw_multi_aff_free(pma2);
-
-	return equal;
-}
-
-/* Check that "pma" is obviously equal to the isl_pw_multi_aff
- * represented by "str".
- */
-static int pw_multi_aff_check_plain_equal(__isl_keep isl_pw_multi_aff *pma,
-	const char *str)
-{
-	int equal;
-
-	equal = pw_multi_aff_plain_is_equal(pma, str);
-	if (equal < 0)
-		return -1;
-	if (!equal)
-		isl_die(isl_pw_multi_aff_get_ctx(pma), isl_error_unknown,
-			"result not as expected", return -1);
-	return 0;
-}
-
 /* Basic test for isl_pw_multi_aff_product.
  *
  * Check that multiple pieces are properly handled.
  */
 static int test_product_pma(isl_ctx *ctx)
 {
-	int equal;
+	isl_stat equal;
 	const char *str;
 	isl_pw_multi_aff *pma1, *pma2;
 
@@ -3631,8 +7714,27 @@
 	return 0;
 }
 
+/* Inputs for isl_pw_multi_aff_is_equal tests.
+ * "f1" and "f2" are the two function that need to be compared.
+ * "equal" is the expected result.
+ */
+struct {
+	int equal;
+	const char *f1;
+	const char *f2;
+} pma_equal_tests = {
+	{ 1, "N -> { floor(N/2) : 0 <= N <= 1 }",
+	     "N -> { 0 : 0 <= N <= 1 }" },
+	{ 1, "N -> { floor(N/2) : 0 <= N <= 2 }",
+	     "N -> { 0 : 0 <= N <= 1; 1 : N = 2 }" },
+	{ 0, "N -> { floor(N/2) : 0 <= N <= 2 }",
+	     "N -> { 0 : 0 <= N <= 1 }" },
+	{ 0, "{ NaN }", "{ NaN }" },
+};
+
 int test_equal(isl_ctx *ctx)
 {
+	int i;
 	const char *str;
 	isl_set *set, *set2;
 	int equal;
@@ -3649,13 +7751,29 @@
 	if (equal)
 		isl_die(ctx, isl_error_unknown, "unexpected result", return -1);
 
+	for (i = 0; i < ARRAY_SIZE(pma_equal_tests); ++i) {
+		int expected = pma_equal_testsi.equal;
+		isl_pw_multi_aff *f1, *f2;
+
+		f1 = isl_pw_multi_aff_read_from_str(ctx, pma_equal_testsi.f1);
+		f2 = isl_pw_multi_aff_read_from_str(ctx, pma_equal_testsi.f2);
+		equal = isl_pw_multi_aff_is_equal(f1, f2);
+		isl_pw_multi_aff_free(f1);
+		isl_pw_multi_aff_free(f2);
+		if (equal < 0)
+			return -1;
+		if (equal != expected)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected equality result", return -1);
+	}
+
 	return 0;
 }
 
 static int test_plain_fixed(isl_ctx *ctx, __isl_take isl_map *map,
 	enum isl_dim_type type, unsigned pos, int fixed)
 {
-	int test;
+	isl_bool test;
 
 	test = isl_map_plain_is_fixed(map, type, pos, NULL);
 	isl_map_free(map);
@@ -3699,17 +7817,36 @@
 struct isl_vertices_test_data {
 	const char *set;
 	int n;
-	const char *vertex2;
+	const char *vertex6;
 } vertices_tests = {
 	{ "{ At, i : t = 12 and i >= 4 and i <= 12 }",
 	  2, { "{ A12, 4 }", "{ A12, 12 }" } },
 	{ "{ At, i : t = 14 and i = 1 }",
 	  1, { "{ A14, 1 }" } },
+	{ "n, m -> { a, b, c : b <= a and a <= n and b > 0 and c >= b and "
+				"c <= m and m <= n and m > 0 }",
+	  6, {
+		"n, m -> { n, m, m : 0 < m <= n }",
+		"n, m -> { n, 1, m : 0 < m <= n }",
+		"n, m -> { n, 1, 1 : 0 < m <= n }",
+		"n, m -> { m, m, m : 0 < m <= n }",
+		"n, m -> { 1, 1, m : 0 < m <= n }",
+		"n, m -> { 1, 1, 1 : 0 < m <= n }"
+	    } },
+	/* An input with implicit equality constraints among the parameters. */
+	{ "N, M -> { a, b : M >= 3 and 9 + 3M <= a <= 29 + 2N + 11M and "
+			    "2b >= M + a and 5 - 2N - M + a <= 2b <= 3 + a and "
+			    "3b >= 15 + a }",
+	  2, {
+		"N, M -> { (21), (12) : M = 3 and N >= 0 }",
+		"N, M -> { (61 + 2N), (32 + N) : M = 3 and N >= 0 }",
+	     }
+	},
 };
 
 /* Check that "vertex" corresponds to one of the vertices in data->vertex.
  */
-static int find_vertex(__isl_take isl_vertex *vertex, void *user)
+static isl_stat find_vertex(__isl_take isl_vertex *vertex, void *user)
 {
 	struct isl_vertices_test_data *data = user;
 	isl_ctx *ctx;
@@ -3717,7 +7854,7 @@
 	isl_basic_set *bset;
 	isl_pw_multi_aff *pma;
 	int i;
-	int equal;
+	isl_bool equal;
 
 	ctx = isl_vertex_get_ctx(vertex);
 	bset = isl_vertex_get_domain(vertex);
@@ -3739,9 +7876,9 @@
 	isl_vertex_free(vertex);
 
 	if (equal < 0)
-		return -1;
+		return isl_stat_error;
 
-	return equal ? 0 : - 1;
+	return equal ? isl_stat_ok : isl_stat_error;
 }
 
 int test_vertices(isl_ctx *ctx)
@@ -3752,7 +7889,7 @@
 		isl_basic_set *bset;
 		isl_vertices *vertices;
 		int ok = 1;
-		int n;
+		isl_size n;
 
 		bset = isl_basic_set_read_from_str(ctx, vertices_testsi.set);
 		vertices = isl_basic_set_compute_vertices(bset);
@@ -3765,7 +7902,7 @@
 		isl_vertices_free(vertices);
 		isl_basic_set_free(bset);
 
-		if (!vertices)
+		if (n < 0)
 			return -1;
 		if (!ok)
 			isl_die(ctx, isl_error_unknown, "unexpected vertices",
@@ -3775,6 +7912,195 @@
 	return 0;
 }
 
+/* Inputs for basic tests of unary operations on isl_union_map.
+ * "fn" is the function that is being tested.
+ * "arg" is a string description of the input.
+ * "res" is a string description of the expected result.
+ */
+static struct {
+	__isl_give isl_union_map *(*fn)(__isl_take isl_union_map *umap);
+	const char *arg;
+	const char *res;
+} umap_un_tests = {
+	{ &isl_union_map_range_reverse,
+	  "{ A -> B -> C; A -> B; A0 -> NB1 -> B2 }",
+	  "{ A -> C -> B; A0 -> NB2 -> B1 }" },
+	{ &isl_union_map_range_reverse,
+	  "{ A -> NB -> C }",
+	  "{ A -> C -> B }" },
+	{ &isl_union_map_range_reverse,
+	  "{ A -> NBx -> By }",
+	  "{ A -> NB* -> B* }" },
+};
+
+/* Perform basic tests of unary operations on isl_union_map.
+ */
+static isl_stat test_un_union_map(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(umap_un_tests); ++i) {
+		const char *str;
+		isl_union_map *umap, *res;
+		isl_bool equal;
+
+		str = umap_un_testsi.arg;
+		umap = isl_union_map_read_from_str(ctx, str);
+		str = umap_un_testsi.res;
+		res = isl_union_map_read_from_str(ctx, str);
+		umap = umap_un_testsi.fn(umap);
+		equal = isl_union_map_is_equal(umap, res);
+		isl_union_map_free(umap);
+		isl_union_map_free(res);
+		if (equal < 0)
+			return isl_stat_error;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Inputs for basic tests of binary operations on isl_union_map.
+ * "fn" is the function that is being tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+static struct {
+	__isl_give isl_union_map *(*fn)(__isl_take isl_union_map *umap1,
+				__isl_take isl_union_map *umap2);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} umap_bin_tests = {
+	{ &isl_union_map_intersect,
+	  "n -> { Ai ->  : 0 <= i <= n; B ->  }",
+	  "m -> { Ai ->  : 0 <= i <= m; C ->  }",
+	  "m, n -> { Ai ->  : 0 <= i <= n and i <= m }" },
+	{ &isl_union_map_intersect_domain_factor_domain,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Bi -> CN }",
+	  "{ }" },
+	{ &isl_union_map_intersect_domain_factor_domain,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "N -> { AN - 2 -> BN - 1 -> CN }" },
+	{ &isl_union_map_intersect_domain_factor_domain,
+	  "{ TAi -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "N -> { TAN - 2 -> BN - 1 -> CN }" },
+	{ &isl_union_map_intersect_domain_factor_range,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Bi -> CN }",
+	  "N -> { AN - 2 -> BN - 1 -> CN }" },
+	{ &isl_union_map_intersect_domain_factor_range,
+	  "{ TAi -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Bi -> CN }",
+	  "N -> { TAN - 2 -> BN - 1 -> CN }" },
+	{ &isl_union_map_intersect_domain_factor_range,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "{ }" },
+	{ &isl_union_map_intersect_range_factor_domain,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> BN }",
+	  "N -> { AN - 1 -> BN -> CN + 1 }" },
+	{ &isl_union_map_intersect_range_factor_domain,
+	  "{ Ai -> TBi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> BN }",
+	  "N -> { AN - 1 -> TBN -> CN + 1 }" },
+	{ &isl_union_map_intersect_range_factor_domain,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "{ }" },
+	{ &isl_union_map_intersect_range_factor_range,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "N -> { AN - 2 -> BN - 1 -> CN }" },
+	{ &isl_union_map_intersect_range_factor_range,
+	  "{ Ai -> TBi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> CN }",
+	  "N -> { AN - 2 -> TBN - 1 -> CN }" },
+	{ &isl_union_map_intersect_range_factor_range,
+	  "{ Ai -> Bi + 1 -> Ci + 2 }",
+	  "N -> { Ai -> BN }",
+	  "{ }" },
+};
+
+/* Perform basic tests of binary operations on isl_union_map.
+ */
+static isl_stat test_bin_union_map(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(umap_bin_tests); ++i) {
+		const char *str;
+		isl_union_map *umap1, *umap2, *res;
+		isl_bool equal;
+
+		str = umap_bin_testsi.arg1;
+		umap1 = isl_union_map_read_from_str(ctx, str);
+		str = umap_bin_testsi.arg2;
+		umap2 = isl_union_map_read_from_str(ctx, str);
+		str = umap_bin_testsi.res;
+		res = isl_union_map_read_from_str(ctx, str);
+		umap1 = umap_bin_testsi.fn(umap1, umap2);
+		equal = isl_union_map_is_equal(umap1, res);
+		isl_union_map_free(umap1);
+		isl_union_map_free(res);
+		if (equal < 0)
+			return isl_stat_error;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Check that isl_union_set_contains finds space independently
+ * of the parameters.
+ */
+static isl_stat test_union_set_contains(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool ok;
+	isl_space *space;
+	isl_id *id;
+	isl_union_set *uset;
+
+	str = "N -> { A0:N; B*,* }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	space = isl_space_unit(ctx);
+	id = isl_id_alloc(ctx, "A", NULL);
+	space = isl_space_add_named_tuple_id_ui(space, id, 1);
+	ok = isl_union_set_contains(uset, space);
+	isl_space_free(space);
+	isl_union_set_free(uset);
+
+	if (ok < 0)
+		return isl_stat_error;
+	if (!ok)
+		isl_die(ctx, isl_error_unknown,
+			"unexpected result", return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Perform basic tests of operations on isl_union_map or isl_union_set.
+ */
+static int test_union_map(isl_ctx *ctx)
+{
+	if (test_un_union_map(ctx) < 0)
+		return -1;
+	if (test_bin_union_map(ctx) < 0)
+		return -1;
+	if (test_union_set_contains(ctx) < 0)
+		return -1;
+	return 0;
+}
+
 int test_union_pw(isl_ctx *ctx)
 {
 	int equal;
@@ -3799,6 +8125,498 @@
 	return 0;
 }
 
+/* Inputs for basic tests of functions that select
+ * subparts of the domain of an isl_multi_union_pw_aff.
+ * "fn" is the function that is tested.
+ * "arg" is a string description of the input.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_union_set *(*fn)(
+		__isl_take isl_multi_union_pw_aff *mupa);
+	const char *arg;
+	const char *res;
+} un_locus_tests = {
+	{ &isl_multi_union_pw_aff_zero_union_set,
+	  "F{ Ai,j -> i; Bi,j -> i }",
+	  "{ A0,j; B0,j }" },
+	{ &isl_multi_union_pw_aff_zero_union_set,
+	  "F{ Ai,j -> i-j; Bi,j -> i-j : i >= 0 }",
+	  "{ Ai,i; Bi,i : i >= 0 }" },
+	{ &isl_multi_union_pw_aff_zero_union_set,
+	  "(F : { Ai,j; Bi,i : i >= 0 })",
+	  "{ Ai,j; Bi,i : i >= 0 }" },
+};
+
+/* Perform some basic tests of functions that select
+ * subparts of the domain of an isl_multi_union_pw_aff.
+ */
+static int test_un_locus(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_union_set *uset, *res;
+	isl_multi_union_pw_aff *mupa;
+
+	for (i = 0; i < ARRAY_SIZE(un_locus_tests); ++i) {
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    un_locus_testsi.arg);
+		res = isl_union_set_read_from_str(ctx, un_locus_testsi.res);
+		uset = un_locus_testsi.fn(mupa);
+		ok = isl_union_set_is_equal(uset, res);
+		isl_union_set_free(uset);
+		isl_union_set_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of functions that select
+ * subparts of an isl_union_map based on a relation
+ * specified by an isl_multi_union_pw_aff.
+ * "fn" is the function that is tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+struct {
+	__isl_give isl_union_map *(*fn)(
+		__isl_take isl_union_map *umap,
+		__isl_take isl_multi_union_pw_aff *mupa);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} bin_locus_tests = {
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }",
+	  "{ Ai,j -> Bi,j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }, "
+	    "{ Ai,j -> j; Bi,j -> j }",
+	  "{ Ai,j -> Bi,j }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j'; Ai,j -> Ci',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }",
+	  "{ Ai,j -> Bi,j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j'; Ai,j -> Ci',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i; Ci,j -> 0 }",
+	  "{ Ai,j -> Bi,j'; A0,j -> Ci',j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i : i > j; Bi,j -> i }",
+	  "{ Ai,j -> Bi,j' : i > j }" },
+	{ &isl_union_map_lex_le_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }, "
+	    "{ Ai,j -> j; Bi,j -> j }",
+	  "{ Ai,j -> Bi',j' : i,j <<= i',j' }" },
+	{ &isl_union_map_lex_lt_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }, "
+	    "{ Ai,j -> j; Bi,j -> j }",
+	  "{ Ai,j -> Bi',j' : i,j << i',j' }" },
+	{ &isl_union_map_lex_ge_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }, "
+	    "{ Ai,j -> j; Bi,j -> j }",
+	  "{ Ai,j -> Bi',j' : i,j >>= i',j' }" },
+	{ &isl_union_map_lex_gt_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "F{ Ai,j -> i; Bi,j -> i }, "
+	    "{ Ai,j -> j; Bi,j -> j }",
+	  "{ Ai,j -> Bi',j' : i,j >> i',j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j'; Ai,j -> Ci',j' }",
+	  "(F : { Ai,j; Bi,j })",
+	  "{ Ai,j -> Bi',j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "(F : { Ai,j : i > j; Bi,j : i < j })",
+	  "{ Ai,j -> Bi',j' : i > j and i' < j' }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "N -> { Ai,j -> Bi',j' : i,i' <= N }",
+	  "(F : { Ai,j : i > j; Bi,j : i < j })",
+	  "N -> { Ai,j -> Bi',j' : i > j and i' < j' and i,i' <= N }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "N -> (F : { Ai,j : i < N; Bi,j : i < N })",
+	  "N -> { Ai,j -> Bi',j' : i,i' < N }" },
+	{ &isl_union_map_eq_at_multi_union_pw_aff,
+	  "{ Ai,j -> Bi',j' }",
+	  "N -> (F : { : N >= 0 })",
+	  "N -> { Ai,j -> Bi',j' : N >= 0 }" },
+};
+
+/* Perform some basic tests of functions that select
+ * subparts of an isl_union_map based on a relation
+ * specified by an isl_multi_union_pw_aff.
+ */
+static int test_bin_locus(isl_ctx *ctx)
+{
+	int i;
+	isl_bool ok;
+	isl_union_map *umap, *res;
+	isl_multi_union_pw_aff *mupa;
+
+	for (i = 0; i < ARRAY_SIZE(bin_locus_tests); ++i) {
+		umap = isl_union_map_read_from_str(ctx,
+						    bin_locus_testsi.arg1);
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx,
+						    bin_locus_testsi.arg2);
+		res = isl_union_map_read_from_str(ctx, bin_locus_testsi.res);
+		umap = bin_locus_testsi.fn(umap, mupa);
+		ok = isl_union_map_is_equal(umap, res);
+		isl_union_map_free(umap);
+		isl_union_map_free(res);
+		if (ok < 0)
+			return -1;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	return 0;
+}
+
+/* Inputs for basic tests of functions that determine
+ * the part of the domain where two isl_multi_aff objects
+ * related to each other in a specific way.
+ * "fn" is the function that is being tested.
+ * "arg1" and "arg2" are string descriptions of the inputs.
+ * "res" is a string description of the expected result.
+ */
+static struct {
+	__isl_give isl_set *(*fn)(__isl_take isl_multi_aff *ma1,
+		__isl_take isl_multi_aff *ma2);
+	const char *arg1;
+	const char *arg2;
+	const char *res;
+} bin_locus_ma_tests = {
+	{ &isl_multi_aff_lex_le_set, "{  }", "{  }", "{ : }" },
+	{ &isl_multi_aff_lex_lt_set, "{  }", "{  }", "{ : false }" },
+	{ &isl_multi_aff_lex_le_set,
+	  "{ Ai -> i }", "{ Ai -> 0 }",
+	  "{ Ai : i <= 0 }" },
+	{ &isl_multi_aff_lex_lt_set,
+	  "{ Ai -> i }", "{ Ai -> 0 }",
+	  "{ Ai : i < 0 }" },
+	{ &isl_multi_aff_lex_le_set,
+	  "{ Ai -> i, i }", "{ Ai -> 0, 0 }",
+	  "{ Ai : i <= 0 }" },
+	{ &isl_multi_aff_lex_le_set,
+	  "{ Ai -> i, 0 }", "{ Ai -> 0, 0 }",
+	  "{ Ai : i <= 0 }" },
+	{ &isl_multi_aff_lex_le_set,
+	  "{ Ai -> i, 1 }", "{ Ai -> 0, 0 }",
+	  "{ Ai : i < 0 }" },
+};
+
+/* Perform some basic tests of functions that determine
+ * the part of the domain where two isl_multi_aff objects
+ * related to each other in a specific way.
+ */
+static isl_stat test_bin_locus_ma(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(bin_locus_ma_tests); ++i) {
+		const char *str;
+		isl_bool ok;
+		isl_multi_aff *ma1, *ma2;
+		isl_set *set, *res;
+
+		str = bin_locus_ma_testsi.arg1;
+		ma1 = isl_multi_aff_read_from_str(ctx, str);
+		str = bin_locus_ma_testsi.arg2;
+		ma2 = isl_multi_aff_read_from_str(ctx, str);
+		res = isl_set_read_from_str(ctx, bin_locus_ma_testsi.res);
+		set = bin_locus_ma_testsi.fn(ma1, ma2);
+		ok = isl_set_is_equal(set, res);
+		isl_set_free(set);
+		isl_set_free(res);
+		if (ok < 0)
+			return isl_stat_error;
+		if (!ok)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Perform basic locus tests.
+ */
+static int test_locus(isl_ctx *ctx)
+{
+	if (test_un_locus(ctx) < 0)
+		return -1;
+	if (test_bin_locus(ctx) < 0)
+		return -1;
+	if (test_bin_locus_ma(ctx) < 0)
+		return -1;
+	return 0;
+}
+
+/* Test that isl_union_pw_qpolynomial_eval picks up the function
+ * defined over the correct domain space.
+ */
+static int test_eval_1(isl_ctx *ctx)
+{
+	const char *str;
+	isl_point *pnt;
+	isl_set *set;
+	isl_union_pw_qpolynomial *upwqp;
+	isl_val *v;
+	int cmp;
+
+	str = "{ Ax -> x^2; Bx -> -x^2 }";
+	upwqp = isl_union_pw_qpolynomial_read_from_str(ctx, str);
+	str = "{ A6 }";
+	set = isl_set_read_from_str(ctx, str);
+	pnt = isl_set_sample_point(set);
+	v = isl_union_pw_qpolynomial_eval(upwqp, pnt);
+	cmp = isl_val_cmp_si(v, 36);
+	isl_val_free(v);
+
+	if (!v)
+		return -1;
+	if (cmp != 0)
+		isl_die(ctx, isl_error_unknown, "unexpected value", return -1);
+
+	return 0;
+}
+
+/* Check that isl_qpolynomial_eval handles getting called on a void point.
+ */
+static int test_eval_2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_point *pnt;
+	isl_set *set;
+	isl_qpolynomial *qp;
+	isl_val *v;
+	isl_bool ok;
+
+	str = "{ Ax -> x }";
+	qp = isl_qpolynomial_from_aff(isl_aff_read_from_str(ctx, str));
+	str = "{ Ax : false }";
+	set = isl_set_read_from_str(ctx, str);
+	pnt = isl_set_sample_point(set);
+	v = isl_qpolynomial_eval(qp, pnt);
+	ok = isl_val_is_nan(v);
+	isl_val_free(v);
+
+	if (ok < 0)
+		return -1;
+	if (!ok)
+		isl_die(ctx, isl_error_unknown, "expecting NaN", return -1);
+
+	return 0;
+}
+
+/* Check that a polynomial (without local variables) can be evaluated
+ * in a rational point.
+ */
+static isl_stat test_eval_3(isl_ctx *ctx)
+{
+	isl_pw_qpolynomial *pwqp;
+	isl_point *pnt;
+	isl_val *v;
+	isl_stat r;
+
+	pwqp = isl_pw_qpolynomial_read_from_str(ctx, "{ x -> x^2 }");
+	pnt = isl_point_zero(isl_pw_qpolynomial_get_domain_space(pwqp));
+	v = isl_val_read_from_str(ctx, "1/2");
+	pnt = isl_point_set_coordinate_val(pnt, isl_dim_set, 0, v);
+	v = isl_pw_qpolynomial_eval(pwqp, pnt);
+	r = val_check_equal(v, "1/4");
+	isl_val_free(v);
+
+	return r;
+}
+
+/* Inputs for isl_pw_aff_eval test.
+ * "f" is the affine function.
+ * "p" is the point where the function should be evaluated.
+ * "res" is the expected result.
+ */
+struct {
+	const char *f;
+	const char *p;
+	const char *res;
+} aff_eval_tests = {
+	{ "{ i -> 2 * i }", "{ 4 }", "8" },
+	{ "{ i -> 2 * i }", "{ x : false }", "NaN" },
+	{ "{ i -> i + floor(i/2) + floor(i/3) }", "{ 0 }", "0" },
+	{ "{ i -> i + floor(i/2) + floor(i/3) }", "{ 1 }", "1" },
+	{ "{ i -> i + floor(i/2) + floor(i/3) }", "{ 2 }", "3" },
+	{ "{ i -> i + floor(i/2) + floor(i/3) }", "{ 3 }", "5" },
+	{ "{ i -> i + floor(i/2) + floor(i/3) }", "{ 4 }", "7" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 0 }", "0" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 1 }", "0" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 2 }", "0" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 3 }", "0" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 4 }", "1" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 6 }", "1" },
+	{ "{ i -> floor((3 * floor(i/2))/5) }", "{ 8 }", "2" },
+	{ "{ i -> i : i > 0; i -> -i : i < 0 }", "{ 4 }", "4" },
+	{ "{ i -> i : i > 0; i -> -i : i < 0 }", "{ -2 }", "2" },
+	{ "{ i -> i : i > 0; i -> -i : i < 0 }", "{ 0 }", "NaN" },
+	{ "N -> { 2 * N }", "N -> { : N = 4 }", "8" },
+	{ "{ i, j -> (i + j)/2 }", "{ 1, 1 }", "1" },
+	{ "{ i, j -> (i + j)/2 }", "{ 1, 2 }", "3/2" },
+	{ "{ i -> i : i mod 2 = 0 }", "{ 4 }", "4" },
+	{ "{ i -> i : i mod 2 = 0 }", "{ 3 }", "NaN" },
+	{ "{ i -> i : i mod 2 = 0 }", "{ x : false }", "NaN" },
+};
+
+/* Perform basic isl_pw_aff_eval tests.
+ */
+static int test_eval_aff(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(aff_eval_tests); ++i) {
+		isl_stat r;
+		isl_pw_aff *pa;
+		isl_set *set;
+		isl_point *pnt;
+		isl_val *v;
+
+		pa = isl_pw_aff_read_from_str(ctx, aff_eval_testsi.f);
+		set = isl_set_read_from_str(ctx, aff_eval_testsi.p);
+		pnt = isl_set_sample_point(set);
+		v = isl_pw_aff_eval(pa, pnt);
+		r = val_check_equal(v, aff_eval_testsi.res);
+		isl_val_free(v);
+		if (r < 0)
+			return -1;
+	}
+	return 0;
+}
+
+/* Perform basic evaluation tests.
+ */
+static int test_eval(isl_ctx *ctx)
+{
+	if (test_eval_1(ctx) < 0)
+		return -1;
+	if (test_eval_2(ctx) < 0)
+		return -1;
+	if (test_eval_3(ctx) < 0)
+		return -1;
+	if (test_eval_aff(ctx) < 0)
+		return -1;
+	return 0;
+}
+
+/* Descriptions of sets that are tested for reparsing after printing.
+ */
+const char *output_tests = {
+	"{ 1, y : 0 <= y <= 1; x, -x : 0 <= x <= 1 }",
+	"{ x : 1 = 0 }",
+	"{ x : false }",
+	"{ x : x mod 2 = 0 }",
+	"{ x : x mod 2 = 1 }",
+	"{ x, y : x mod 2 = 0 and 3*floor(y/2) < x }",
+	"{ y, x : x mod 2 = 0 and 3*floor(y/2) < x }",
+	"{ x, y : x mod 2 = 0 and 3*floor(y/2) = x + y }",
+	"{ y, x : x mod 2 = 0 and 3*floor(y/2) = x + y }",
+	"n -> { y, x : 2*((x + 2y) mod 3) = n }",
+	"{ x, y : (2*floor(x/3) + 3*floor(y/4)) mod 5 = x }",
+};
+
+/* Check that printing a set and reparsing a set from the printed output
+ * results in the same set.
+ */
+static int test_output_set(isl_ctx *ctx)
+{
+	int i;
+	char *str;
+	isl_set *set1, *set2;
+	isl_bool equal;
+
+	for (i = 0; i < ARRAY_SIZE(output_tests); ++i) {
+		set1 = isl_set_read_from_str(ctx, output_testsi);
+		str = isl_set_to_str(set1);
+		set2 = isl_set_read_from_str(ctx, str);
+		free(str);
+		equal = isl_set_is_equal(set1, set2);
+		isl_set_free(set1);
+		isl_set_free(set2);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"parsed output not the same", return -1);
+	}
+
+	return 0;
+}
+
+/* Check that an isl_multi_aff is printed using a consistent space.
+ */
+static isl_stat test_output_ma(isl_ctx *ctx)
+{
+	char *str;
+	isl_bool equal;
+	isl_aff *aff;
+	isl_multi_aff *ma, *ma2;
+
+	ma = isl_multi_aff_read_from_str(ctx, "{ a, b -> a + b }");
+	aff = isl_aff_read_from_str(ctx, "{ c, d -> c + d }");
+	ma = isl_multi_aff_set_aff(ma, 0, aff);
+	str = isl_multi_aff_to_str(ma);
+	ma2 = isl_multi_aff_read_from_str(ctx, str);
+	free(str);
+	equal = isl_multi_aff_plain_is_equal(ma, ma2);
+	isl_multi_aff_free(ma2);
+	isl_multi_aff_free(ma);
+
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "bad conversion",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
+/* Check that an isl_multi_pw_aff is printed using a consistent space.
+ */
+static isl_stat test_output_mpa(isl_ctx *ctx)
+{
+	char *str;
+	isl_bool equal;
+	isl_pw_aff *pa;
+	isl_multi_pw_aff *mpa, *mpa2;
+
+	mpa = isl_multi_pw_aff_read_from_str(ctx, "{ a, b -> a + b }");
+	pa = isl_pw_aff_read_from_str(ctx, "{ c, d -> c + d }");
+	mpa = isl_multi_pw_aff_set_pw_aff(mpa, 0, pa);
+	str = isl_multi_pw_aff_to_str(mpa);
+	mpa2 = isl_multi_pw_aff_read_from_str(ctx, str);
+	free(str);
+	equal = isl_multi_pw_aff_plain_is_equal(mpa, mpa2);
+	isl_multi_pw_aff_free(mpa2);
+	isl_multi_pw_aff_free(mpa);
+
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "bad conversion",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}
+
 int test_output(isl_ctx *ctx)
 {
 	char *s;
@@ -3807,6 +8625,13 @@
 	isl_printer *p;
 	int equal;
 
+	if (test_output_set(ctx) < 0)
+		return -1;
+	if (test_output_ma(ctx) < 0)
+		return -1;
+	if (test_output_mpa(ctx) < 0)
+		return -1;
+
 	str = "x -> { 1 : x % 4 <= 2; 2 : x = 3 }";
 	pa = isl_pw_aff_read_from_str(ctx, str);
 
@@ -3877,20 +8702,46 @@
 	return 0;
 }
 
+/* Perform a projection on a basic set that is known to be empty
+ * but that has not been assigned a canonical representation.
+ * Earlier versions of isl would run into a stack overflow
+ * on this example.
+ */
+static int test_empty_projection(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool empty;
+	isl_basic_set *bset;
+
+	str = "{ a, b, c, d, e, f, g, h : 5f = 1 + 4a - b + 5c - d - 2e and "
+		"3h = 2 + b + c and 14c >= 9 - 3a + 25b and "
+		"4c <= 50 - 3a + 23b and 6b <= -39 + a and "
+		"9g >= -6 + 3a + b + c and e < a + b - 2d and "
+		"7d >= -5 + 2a + 2b and 5g >= -14 + a - 4b + d + 2e and "
+		"9g <= -28 - 5b - 2c + 3d + 6e }";
+	bset = isl_basic_set_read_from_str(ctx, str);
+	empty = isl_basic_set_is_empty(bset);
+	bset = isl_basic_set_params(bset);
+	isl_basic_set_free(bset);
+
+	if (empty < 0)
+		return -1;
+
+	return 0;
+}
+
 int test_fixed_power(isl_ctx *ctx)
 {
 	const char *str;
 	isl_map *map;
-	isl_int exp;
+	isl_val *exp;
 	int equal;
 
-	isl_int_init(exp);
 	str = "{ i -> i + 1 }";
 	map = isl_map_read_from_str(ctx, str);
-	isl_int_set_si(exp, 23);
-	map = isl_map_fixed_power(map, exp);
+	exp = isl_val_int_from_si(ctx, 23);
+	map = isl_map_fixed_power_val(map, exp);
 	equal = map_check_equal(map, "{ i -> i + 23 }");
-	isl_int_clear(exp);
 	isl_map_free(map);
 	if (equal < 0)
 		return -1;
@@ -3972,6 +8823,25 @@
 	return 0;
 }
 
+/* Check basic functionality of isl_map_deltas_map.
+ */
+static int test_deltas_map(isl_ctx *ctx)
+{
+	const char *str;
+	isl_map *map;
+	int equal;
+
+	str = "{ Ai -> Ai + 1 }";
+	map = isl_map_read_from_str(ctx, str);
+	map = isl_map_deltas_map(map);
+	equal = map_check_equal(map, "{ Ai -> Ai + 1 -> A1 }");
+	isl_map_free(map);
+	if (equal < 0)
+		return -1;
+
+	return 0;
+}
+
 /* Check that isl_set_dim_residue_class detects that the values of j
  * in the set below are all odd and that it does not detect any spurious
  * strides.
@@ -3981,7 +8851,7 @@
 	const char *str;
 	isl_set *set;
 	isl_int m, r;
-	int res;
+	isl_stat res;
 
 	str = "{ i,j : j = 4 i + 1 and 0 <= i <= 100; "
 		"i,j : j = 4 i + 3 and 500 <= i <= 600 }";
@@ -3992,7 +8862,7 @@
 	if (res >= 0 &&
 	    (isl_int_cmp_si(m, 2) != 0 || isl_int_cmp_si(r, 1) != 0))
 		isl_die(ctx, isl_error_unknown, "incorrect residue class",
-			res = -1);
+			res = isl_stat_error);
 	isl_int_clear(r);
 	isl_int_clear(m);
 	isl_set_free(set);
@@ -4000,7 +8870,7 @@
 	return res;
 }
 
-int test_align_parameters(isl_ctx *ctx)
+static int test_align_parameters_1(isl_ctx *ctx)
 {
 	const char *str;
 	isl_space *space;
@@ -4031,10 +8901,106 @@
 	return 0;
 }
 
+/* Check the isl_multi_*_from_*_list operation in case inputs
+ * have unaligned parameters.
+ * In particular, older versions of isl would simply fail
+ * (without printing any error message).
+ */
+static isl_stat test_align_parameters_2(isl_ctx *ctx)
+{
+	isl_space *space;
+	isl_map *map;
+	isl_aff *aff;
+	isl_multi_aff *ma;
+
+	map = isl_map_read_from_str(ctx, "{ A -> Mx }");
+	space = isl_map_get_space(map);
+	isl_map_free(map);
+
+	aff = isl_aff_read_from_str(ctx, "N -> { A -> N }");
+	ma = isl_multi_aff_from_aff_list(space, isl_aff_list_from_aff(aff));
+	isl_multi_aff_free(ma);
+
+	if (!ma)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Perform basic parameter alignment tests.
+ */
+static int test_align_parameters(isl_ctx *ctx)
+{
+	if (test_align_parameters_1(ctx) < 0)
+		return -1;
+	if (test_align_parameters_2(ctx) < 0)
+		return -1;
+
+	return 0;
+}
+
+/* Check that isl_*_drop_unused_params actually drops the unused parameters
+ * by comparing the result using isl_*_plain_is_equal.
+ * Note that this assumes that isl_*_plain_is_equal does not consider
+ * objects that only differ by unused parameters to be equal.
+ */
+int test_drop_unused_parameters(isl_ctx *ctx)
+{
+	const char *str_with, *str_without;
+	isl_basic_set *bset1, *bset2;
+	isl_set *set1, *set2;
+	isl_pw_aff *pwa1, *pwa2;
+	int equal;
+
+	str_with = "n, m, o -> { m }";
+	str_without = "m -> { m }";
+
+	bset1 = isl_basic_set_read_from_str(ctx, str_with);
+	bset2 = isl_basic_set_read_from_str(ctx, str_without);
+	bset1 = isl_basic_set_drop_unused_params(bset1);
+	equal = isl_basic_set_plain_is_equal(bset1, bset2);
+	isl_basic_set_free(bset1);
+	isl_basic_set_free(bset2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"result not as expected", return -1);
+
+	set1 = isl_set_read_from_str(ctx, str_with);
+	set2 = isl_set_read_from_str(ctx, str_without);
+	set1 = isl_set_drop_unused_params(set1);
+	equal = isl_set_plain_is_equal(set1, set2);
+	isl_set_free(set1);
+	isl_set_free(set2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"result not as expected", return -1);
+
+	pwa1 = isl_pw_aff_read_from_str(ctx, str_with);
+	pwa2 = isl_pw_aff_read_from_str(ctx, str_without);
+	pwa1 = isl_pw_aff_drop_unused_params(pwa1);
+	equal = isl_pw_aff_plain_is_equal(pwa1, pwa2);
+	isl_pw_aff_free(pwa1);
+	isl_pw_aff_free(pwa2);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"result not as expected", return -1);
+
+	return 0;
+}
+
 static int test_list(isl_ctx *ctx)
 {
 	isl_id *a, *b, *c, *d, *id;
 	isl_id_list *list;
+	isl_size n;
 	int ok;
 
 	a = isl_id_alloc(ctx, "a", NULL);
@@ -4043,13 +9009,16 @@
 	d = isl_id_alloc(ctx, "d", NULL);
 
 	list = isl_id_list_alloc(ctx, 4);
-	list = isl_id_list_add(list, a);
 	list = isl_id_list_add(list, b);
+	list = isl_id_list_insert(list, 0, a);
 	list = isl_id_list_add(list, c);
 	list = isl_id_list_add(list, d);
 	list = isl_id_list_drop(list, 1, 1);
 
-	if (isl_id_list_n_id(list) != 3) {
+	n = isl_id_list_n_id(list);
+	if (n < 0)
+		return -1;
+	if (n != 3) {
 		isl_id_list_free(list);
 		isl_die(ctx, isl_error_unknown,
 			"unexpected number of elements in list", return -1);
@@ -4074,12 +9043,39 @@
 	return 0;
 }
 
+/* Check the conversion from an isl_multi_aff to an isl_basic_set.
+ */
+static isl_stat test_ma_conversion(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool equal;
+	isl_multi_aff *ma;
+	isl_basic_set *bset1, *bset2;
+
+	str = "N -> { A0, N + 1 }";
+	ma = isl_multi_aff_read_from_str(ctx, str);
+	bset1 = isl_basic_set_read_from_str(ctx, str);
+	bset2 = isl_basic_set_from_multi_aff(ma);
+	equal = isl_basic_set_is_equal(bset1, bset2);
+	isl_basic_set_free(bset1);
+	isl_basic_set_free(bset2);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "bad conversion",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
 const char *set_conversion_tests = {
 	"N -> { i : N - 1 <= 2 i <= N }",
 	"N -> { i : exists a : i = 4 a and N - 1 <= i <= N }",
 	"N -> { i,j : exists a : i = 4 a and N - 1 <= i, 2j <= N }",
 	"N -> { i->j : exists a : i = 4 a and N - 1 <= i, 2j <= N }",
 	"N -> { 3*floor(N/2) + 5*floor(N/3) }",
+	"a, b -> { c, d : (4*floor((-a + c)/4) = -a + c and "
+			"32*floor((-b + d)/32) = -b + d and 5 <= c <= 8 and "
+			"-3 + c <= d <= 28 + c) }",
 };
 
 /* Check that converting from isl_set to isl_pw_multi_aff and back
@@ -4112,42 +9108,147 @@
 	return 0;
 }
 
+const char *conversion_tests = {
+	"{ a, b, c, d -> s0a, b, e, f : "
+	    "exists (e0 = (a - 2c)/3, e1 = (-4 + b - 5d)/9, "
+	    "e2 = (-d + f)/9: 3e0 = a - 2c and 9e1 = -4 + b - 5d and "
+	    "9e2 = -d + f and f >= 0 and f <= 8 and 9e >= -5 - 2a and "
+	    "9e <= -2 - 2a) }",
+	"{ a, b -> c : exists (e0 = floor((-a - b + c)/5): "
+	    "5e0 = -a - b + c and c >= -a and c <= 4 - a) }",
+	"{ a, b -> c : exists d : 18 * d = -3 - a + 2c and 1 <= c <= 3 }",
+};
+
 /* Check that converting from isl_map to isl_pw_multi_aff and back
  * to isl_map produces the original isl_map.
  */
 static int test_map_conversion(isl_ctx *ctx)
 {
-	const char *str;
+	int i;
 	isl_map *map1, *map2;
 	isl_pw_multi_aff *pma;
 	int equal;
 
-	str = "{ a, b, c, d -> s0a, b, e, f : "
-		"exists (e0 = (a - 2c)/3, e1 = (-4 + b - 5d)/9, "
-		"e2 = (-d + f)/9: 3e0 = a - 2c and 9e1 = -4 + b - 5d and "
-		"9e2 = -d + f and f >= 0 and f <= 8 and 9e >= -5 - 2a and "
-		"9e <= -2 - 2a) }";
-	map1 = isl_map_read_from_str(ctx, str);
-	pma = isl_pw_multi_aff_from_map(isl_map_copy(map1));
-	map2 = isl_map_from_pw_multi_aff(pma);
-	equal = isl_map_is_equal(map1, map2);
-	isl_map_free(map1);
-	isl_map_free(map2);
+	for (i = 0; i < ARRAY_SIZE(conversion_tests); ++i) {
+		map1 = isl_map_read_from_str(ctx, conversion_testsi);
+		pma = isl_pw_multi_aff_from_map(isl_map_copy(map1));
+		map2 = isl_map_from_pw_multi_aff(pma);
+		equal = isl_map_is_equal(map1, map2);
+		isl_map_free(map1);
+		isl_map_free(map2);
 
-	if (equal < 0)
-		return -1;
-	if (!equal)
-		isl_die(ctx, isl_error_unknown, "bad conversion", return -1);
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown, "bad conversion",
+				return -1);
+	}
+
+	return 0;
+}
+
+/* Descriptions of isl_pw_multi_aff objects for testing conversion
+ * to isl_multi_pw_aff and back.
+ */
+const char *mpa_conversion_tests = {
+	"{ x -> Ax }",
+	"{ x -> Ax : x >= 0 }",
+	"{ x -> Ax : x >= 0; x -> A-x : x < 0 }",
+	"{ x -> Ax, x + 1 }",
+	"{ x -> A }",
+	"{ x -> A : x >= 0 }",
+};
+
+/* Check that conversion from isl_pw_multi_aff to isl_multi_pw_aff and
+ * back to isl_pw_multi_aff preserves the original meaning.
+ */
+static int test_mpa_conversion(isl_ctx *ctx)
+{
+	int i;
+	isl_pw_multi_aff *pma1, *pma2;
+	isl_multi_pw_aff *mpa;
+	int equal;
+
+	for (i = 0; i < ARRAY_SIZE(mpa_conversion_tests); ++i) {
+		const char *str;
+		str = mpa_conversion_testsi;
+		pma1 = isl_pw_multi_aff_read_from_str(ctx, str);
+		pma2 = isl_pw_multi_aff_copy(pma1);
+		mpa = isl_multi_pw_aff_from_pw_multi_aff(pma1);
+		pma1 = isl_pw_multi_aff_from_multi_pw_aff(mpa);
+		equal = isl_pw_multi_aff_plain_is_equal(pma1, pma2);
+		isl_pw_multi_aff_free(pma1);
+		isl_pw_multi_aff_free(pma2);
+
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown, "bad conversion",
+				return -1);
+	}
+
+	return 0;
+}
+
+/* Descriptions of union maps that should be convertible
+ * to an isl_multi_union_pw_aff.
+ */
+const char *umap_mupa_conversion_tests = {
+	"{ a, b, c, d -> s0a, b, e, f : "
+	    "exists (e0 = (a - 2c)/3, e1 = (-4 + b - 5d)/9, "
+	    "e2 = (-d + f)/9: 3e0 = a - 2c and 9e1 = -4 + b - 5d and "
+	    "9e2 = -d + f and f >= 0 and f <= 8 and 9e >= -5 - 2a and "
+	    "9e <= -2 - 2a) }",
+	"{ a, b -> c : exists (e0 = floor((-a - b + c)/5): "
+	    "5e0 = -a - b + c and c >= -a and c <= 4 - a) }",
+	"{ a, b -> c : exists d : 18 * d = -3 - a + 2c and 1 <= c <= 3 }",
+	"{ A -> B0; C -> B1 }",
+	"{ A -> B; C -> B }",
+};
+
+/* Check that converting from isl_union_map to isl_multi_union_pw_aff and back
+ * to isl_union_map produces the original isl_union_map.
+ */
+static int test_union_map_mupa_conversion(isl_ctx *ctx)
+{
+	int i;
+	isl_union_map *umap1, *umap2;
+	isl_multi_union_pw_aff *mupa;
+	int equal;
+
+	for (i = 0; i < ARRAY_SIZE(umap_mupa_conversion_tests); ++i) {
+		const char *str;
+		str = umap_mupa_conversion_testsi;
+		umap1 = isl_union_map_read_from_str(ctx, str);
+		umap2 = isl_union_map_copy(umap1);
+		mupa = isl_multi_union_pw_aff_from_union_map(umap2);
+		umap2 = isl_union_map_from_multi_union_pw_aff(mupa);
+		equal = isl_union_map_is_equal(umap1, umap2);
+		isl_union_map_free(umap1);
+		isl_union_map_free(umap2);
+
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown, "bad conversion",
+				return -1);
+	}
 
 	return 0;
 }
 
 static int test_conversion(isl_ctx *ctx)
 {
+	if (test_ma_conversion(ctx) < 0)
+		return -1;
 	if (test_set_conversion(ctx) < 0)
 		return -1;
 	if (test_map_conversion(ctx) < 0)
 		return -1;
+	if (test_mpa_conversion(ctx) < 0)
+		return -1;
+	if (test_union_map_mupa_conversion(ctx) < 0)
+		return -1;
 	return 0;
 }
 
@@ -4261,6 +9362,8 @@
 	    "Bi -> Di : exists a : i = 2 a + 1 }",
 	  "{ Ai -> B2i }",
 	  "{ Ai -> C2i }" },
+	{ "{ Ai -> Bi }", "{ Ci -> A(i + floor(i/3))/2 }",
+	  "{ Ci -> Bj : 2j = i + floor(i/3) }" },
 };
 
 static int test_preimage_union_map(isl_ctx *ctx)
@@ -4321,6 +9424,9 @@
 	{ "{ Bi -> C(i/2) }", "{ B5 }", "{ C2 }" },
 	{ "n -> { Bi,j -> C(i/2) + 2j }",
 	  "n -> { Bn,n/3 }", "n -> { C(n/2) + 2*n/3 }", },
+	{ "{ i, j -> floor((i)/4) + floor((2*i+j)/5) }",
+	  "{ i, j -> floor((i)/3), j }",
+	  "{ i, j -> (floor((i)/12) + floor((j + 2*floor((i)/3))/5)) }" },
 };
 
 static int test_pullback(isl_ctx *ctx)
@@ -4348,25 +9454,33 @@
 	return 0;
 }
 
-/* Check that negation is printed correctly.
+/* Check that negation is printed correctly and that equal expressions
+ * are correctly identified.
  */
 static int test_ast(isl_ctx *ctx)
 {
 	isl_ast_expr *expr, *expr1, *expr2, *expr3;
 	char *str;
-	int ok;
+	int ok, equal;
 
 	expr1 = isl_ast_expr_from_id(isl_id_alloc(ctx, "A", NULL));
 	expr2 = isl_ast_expr_from_id(isl_id_alloc(ctx, "B", NULL));
 	expr = isl_ast_expr_add(expr1, expr2);
+	expr2 = isl_ast_expr_copy(expr);
 	expr = isl_ast_expr_neg(expr);
-	str = isl_ast_expr_to_str(expr);
+	expr2 = isl_ast_expr_neg(expr2);
+	equal = isl_ast_expr_is_equal(expr, expr2);
+	str = isl_ast_expr_to_C_str(expr);
 	ok = str ? !strcmp(str, "-(A + B)") : -1;
 	free(str);
 	isl_ast_expr_free(expr);
+	isl_ast_expr_free(expr2);
 
-	if (ok < 0)
+	if (ok < 0 || equal < 0)
 		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"equal expressions not considered equal", return -1);
 	if (!ok)
 		isl_die(ctx, isl_error_unknown,
 			"isl_ast_expr printed incorrectly", return -1);
@@ -4376,7 +9490,7 @@
 	expr = isl_ast_expr_add(expr1, expr2);
 	expr3 = isl_ast_expr_from_id(isl_id_alloc(ctx, "C", NULL));
 	expr = isl_ast_expr_sub(expr3, expr);
-	str = isl_ast_expr_to_str(expr);
+	str = isl_ast_expr_to_C_str(expr);
 	ok = str ? !strcmp(str, "C - (A + B)") : -1;
 	free(str);
 	isl_ast_expr_free(expr);
@@ -4446,7 +9560,8 @@
 	isl_union_map *schedule;
 	isl_union_set *uset;
 	isl_set *set;
-	int empty;
+	isl_bool empty;
+	isl_size n;
 	char name = "d0";
 
 	ctx = isl_ast_build_get_ctx(build);
@@ -4454,7 +9569,7 @@
 	if (data->before >= 3)
 		isl_die(ctx, isl_error_unknown,
 			"unexpected number of for nodes", return NULL);
-	if (data->depth >= 2)
+	if (data->depth < 0 || data->depth >= 2)
 		isl_die(ctx, isl_error_unknown,
 			"unexpected depth", return NULL);
 
@@ -4464,10 +9579,11 @@
 
 	schedule = isl_ast_build_get_schedule(build);
 	uset = isl_union_map_range(schedule);
-	if (!uset)
-		return NULL;
-	if (isl_union_set_n_set(uset) != 1) {
+	n = isl_union_set_n_set(uset);
+	if (n != 1) {
 		isl_union_set_free(uset);
+		if (n < 0)
+			return NULL;
 		isl_die(ctx, isl_error_unknown,
 			"expecting single range space", return NULL);
 	}
@@ -4555,7 +9671,7 @@
 			&before_for, &data);
 	build = isl_ast_build_set_after_each_for(build,
 			&after_for, &data);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	if (!tree)
 		return -1;
@@ -4570,7 +9686,7 @@
 }
 
 /* Check that the AST generator handles domains that are integrally disjoint
- * but not ratinoally disjoint.
+ * but not rationally disjoint.
  */
 static int test_ast_gen2(isl_ctx *ctx)
 {
@@ -4589,7 +9705,7 @@
 	str = "{ i,j -> atomic1 : i + j = 1; i,j -> unroll1 : i = j }";
 	options = isl_union_map_read_from_str(ctx, str);
 	build = isl_ast_build_set_options(build, options);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	if (!tree)
 		return -1;
@@ -4635,7 +9751,7 @@
 	build = isl_ast_build_set_options(build, options);
 	build = isl_ast_build_set_at_each_domain(build,
 			&count_domains, &n_domain);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	if (!tree)
 		return -1;
@@ -4671,7 +9787,7 @@
 	schedule = isl_union_map_read_from_str(ctx, str);
 	set = isl_set_universe(isl_space_params_alloc(ctx, 0));
 	build = isl_ast_build_from_context(set);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	if (!tree)
 		return -1;
@@ -4688,7 +9804,7 @@
 	schedule = isl_union_map_read_from_str(ctx, str);
 	set = isl_set_universe(isl_space_params_alloc(ctx, 0));
 	build = isl_ast_build_from_context(set);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	if (!tree)
 		return -1;
@@ -4723,7 +9839,7 @@
 	extra = isl_union_map_copy(schedule);
 	extra = isl_union_map_from_domain(isl_union_map_domain(extra));
 	schedule = isl_union_map_range_product(schedule, extra);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 
 	if (!tree)
@@ -4766,7 +9882,7 @@
 	build = isl_ast_build_from_context(set);
 	build = isl_ast_build_set_options(build, options);
         build = isl_ast_build_set_create_leaf(build, &create_leaf, NULL);
-	tree = isl_ast_build_ast_from_schedule(build, schedule);
+	tree = isl_ast_build_node_from_schedule_map(build, schedule);
 	isl_ast_build_free(build);
 	isl_ast_node_free(tree);
 	if (!tree)
@@ -4775,6 +9891,49 @@
 	return 0;
 }
 
+/* Check that the expression
+ *
+ *	n -> { n/2 : n <= 0 and n % 2 = 0; 0 : n > 0 }
+ *
+ * is not combined into
+ *
+ *	min(n/2, 0)
+ *
+ * as this would result in n/2 being evaluated in parts of
+ * the definition domain where n is not a multiple of 2.
+ */
+static int test_ast_expr(isl_ctx *ctx)
+{
+	const char *str;
+	isl_pw_aff *pa;
+	isl_ast_build *build;
+	isl_ast_expr *expr;
+	int min_max;
+	int is_min;
+
+	min_max = isl_options_get_ast_build_detect_min_max(ctx);
+	isl_options_set_ast_build_detect_min_max(ctx, 1);
+
+	str = "n -> { n/2 : n <= 0 and n % 2 = 0; 0 : n > 0 }";
+	pa = isl_pw_aff_read_from_str(ctx, str);
+	build = isl_ast_build_alloc(ctx);
+	expr = isl_ast_build_expr_from_pw_aff(build, pa);
+	is_min = isl_ast_expr_get_type(expr) == isl_ast_expr_op &&
+		 isl_ast_expr_get_op_type(expr) == isl_ast_expr_op_min;
+	isl_ast_build_free(build);
+	isl_ast_expr_free(expr);
+
+	isl_options_set_ast_build_detect_min_max(ctx, min_max);
+
+	if (!expr)
+		return -1;
+	if (is_min)
+		isl_die(ctx, isl_error_unknown,
+			"expressions should not be combined", return -1);
+
+	return 0;
+}
+
 static int test_ast_gen(isl_ctx *ctx)
 {
 	if (test_ast_gen1(ctx) < 0)
@@ -4787,6 +9946,8 @@
 		return -1;
 	if (test_ast_gen5(ctx) < 0)
 		return -1;
+	if (test_ast_expr(ctx) < 0)
+		return -1;
 	return 0;
 }
 
@@ -4822,7 +9983,7 @@
 /* Check that we can properly parse multi piecewise affine expressions
  * where the piecewise affine expressions have different domains.
  */
-static int test_multi_pw_aff(isl_ctx *ctx)
+static int test_multi_pw_aff_1(isl_ctx *ctx)
 {
 	const char *str;
 	isl_set *dom, *dom2;
@@ -4867,6 +10028,131 @@
 	return 0;
 }
 
+/* Check that the dimensions in the explicit domain
+ * of a multi piecewise affine expression are properly
+ * taken into account.
+ */
+static int test_multi_pw_aff_2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool involves1, involves2, involves3, equal;
+	isl_multi_pw_aff *mpa, *mpa1, *mpa2;
+
+	str = "{ Ax,y -> B : x >= y }";
+	mpa = isl_multi_pw_aff_read_from_str(ctx, str);
+	involves1 = isl_multi_pw_aff_involves_dims(mpa, isl_dim_in, 0, 2);
+	mpa1 = isl_multi_pw_aff_copy(mpa);
+
+	mpa = isl_multi_pw_aff_insert_dims(mpa, isl_dim_in, 0, 1);
+	involves2 = isl_multi_pw_aff_involves_dims(mpa, isl_dim_in, 0, 1);
+	involves3 = isl_multi_pw_aff_involves_dims(mpa, isl_dim_in, 1, 2);
+	str = "{ a,x,y -> B : x >= y }";
+	mpa2 = isl_multi_pw_aff_read_from_str(ctx, str);
+	equal = isl_multi_pw_aff_plain_is_equal(mpa, mpa2);
+	isl_multi_pw_aff_free(mpa2);
+
+	mpa = isl_multi_pw_aff_drop_dims(mpa, isl_dim_in, 0, 1);
+	mpa = isl_multi_pw_aff_set_tuple_name(mpa, isl_dim_in, "A");
+	if (equal >= 0 && equal)
+		equal = isl_multi_pw_aff_plain_is_equal(mpa, mpa1);
+	isl_multi_pw_aff_free(mpa1);
+	isl_multi_pw_aff_free(mpa);
+
+	if (involves1 < 0 || involves2 < 0 || involves3 < 0 || equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"incorrect result of dimension insertion/removal",
+			return isl_stat_error);
+	if (!involves1 || involves2 || !involves3)
+		isl_die(ctx, isl_error_unknown,
+			"incorrect characterization of involved dimensions",
+			return isl_stat_error);
+
+	return 0;
+}
+
+/* Check that isl_multi_union_pw_aff_multi_val_on_domain
+ * sets the explicit domain of a zero-dimensional result,
+ * such that it can be converted to an isl_union_map.
+ */
+static isl_stat test_multi_pw_aff_3(isl_ctx *ctx)
+{
+	isl_space *space;
+	isl_union_set *dom;
+	isl_multi_val *mv;
+	isl_multi_union_pw_aff *mupa;
+	isl_union_map *umap;
+
+	dom = isl_union_set_read_from_str(ctx, "{ A; B }");
+	space = isl_union_set_get_space(dom);
+	mv = isl_multi_val_zero(isl_space_set_from_params(space));
+	mupa = isl_multi_union_pw_aff_multi_val_on_domain(dom, mv);
+	umap = isl_union_map_from_multi_union_pw_aff(mupa);
+	isl_union_map_free(umap);
+	if (!umap)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* String descriptions of boxes that
+ * are used for reconstructing box maps from their lower and upper bounds.
+ */
+static const char *multi_pw_aff_box_tests = {
+	"{ Ax, y ->  : x + y >= 0 }",
+	"N -> { Ax, y -> x : x + y <= N }",
+	"N -> { Ax, y -> x : y : x + y <= N }",
+};
+
+/* Check that map representations of boxes can be reconstructed
+ * from their lower and upper bounds.
+ */
+static isl_stat test_multi_pw_aff_box(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(multi_pw_aff_box_tests); ++i) {
+		const char *str;
+		isl_bool equal;
+		isl_map *map, *box;
+		isl_multi_pw_aff *min, *max;
+
+		str = multi_pw_aff_box_testsi;
+		map = isl_map_read_from_str(ctx, str);
+		min = isl_map_min_multi_pw_aff(isl_map_copy(map));
+		max = isl_map_max_multi_pw_aff(isl_map_copy(map));
+		box = isl_map_universe(isl_map_get_space(map));
+		box = isl_map_lower_bound_multi_pw_aff(box, min);
+		box = isl_map_upper_bound_multi_pw_aff(box, max);
+		equal = isl_map_is_equal(map, box);
+		isl_map_free(map);
+		isl_map_free(box);
+		if (equal < 0)
+			return isl_stat_error;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return isl_stat_error);
+	}
+
+	return isl_stat_ok;
+}
+
+/* Perform some tests on multi piecewise affine expressions.
+ */
+static int test_multi_pw_aff(isl_ctx *ctx)
+{
+	if (test_multi_pw_aff_1(ctx) < 0)
+		return -1;
+	if (test_multi_pw_aff_2(ctx) < 0)
+		return -1;
+	if (test_multi_pw_aff_3(ctx) < 0)
+		return -1;
+	if (test_multi_pw_aff_box(ctx) < 0)
+		return -1;
+	return 0;
+}
+
 /* This is a regression test for a bug where isl_basic_map_simplify
  * would end up in an infinite loop.  In particular, we construct
  * an empty basic set that is not obviously empty.
@@ -4876,7 +10162,7 @@
  * is empty and would end up in an infinite loop if it didn't test
  * explicitly for empty basic maps in the outer loop.
  */
-static int test_simplify(isl_ctx *ctx)
+static int test_simplify_1(isl_ctx *ctx)
 {
 	const char *str;
 	isl_basic_set *bset;
@@ -4899,6 +10185,39 @@
 	return 0;
 }
 
+/* Check that the equality in the set description below
+ * is simplified away.
+ */
+static int test_simplify_2(isl_ctx *ctx)
+{
+	const char *str;
+	isl_basic_set *bset;
+	isl_bool universe;
+
+	str = "{ a : exists e0, e1: 32e1 = 31 + 31a + 31e0 }";
+	bset = isl_basic_set_read_from_str(ctx, str);
+	universe = isl_basic_set_plain_is_universe(bset);
+	isl_basic_set_free(bset);
+
+	if (universe < 0)
+		return -1;
+	if (!universe)
+		isl_die(ctx, isl_error_unknown,
+			"equality not simplified away", return -1);
+	return 0;
+}
+
+/* Some simplification tests.
+ */
+static int test_simplify(isl_ctx *ctx)
+{
+	if (test_simplify_1(ctx) < 0)
+		return -1;
+	if (test_simplify_2(ctx) < 0)
+		return -1;
+	return 0;
+}
+
 /* This is a regression test for a bug where isl_tab_basic_map_partial_lexopt
  * with gbr context would fail to disable the use of the shifted tableau
  * when transferring equalities for the input to the context, resulting
@@ -4947,6 +10266,247 @@
 	return 0;
 }
 
+/* Check that isl_schedule_get_map is not confused by a schedule tree
+ * with divergent filter node parameters, as can result from a call
+ * to isl_schedule_intersect_domain.
+ */
+static int test_schedule_tree(isl_ctx *ctx)
+{
+	const char *str;
+	isl_union_set *uset;
+	isl_schedule *sched1, *sched2;
+	isl_union_map *umap;
+
+	uset = isl_union_set_read_from_str(ctx, "{ Ai }");
+	sched1 = isl_schedule_from_domain(uset);
+	uset = isl_union_set_read_from_str(ctx, "{ B }");
+	sched2 = isl_schedule_from_domain(uset);
+
+	sched1 = isl_schedule_sequence(sched1, sched2);
+	str = "n -> { Ai : 0 <= i < n; B }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	sched1 = isl_schedule_intersect_domain(sched1, uset);
+	umap = isl_schedule_get_map(sched1);
+	isl_schedule_free(sched1);
+	isl_union_map_free(umap);
+	if (!umap)
+		return -1;
+
+	return 0;
+}
+
+/* Check that a zero-dimensional prefix schedule keeps track
+ * of the domain and outer filters.
+ */
+static int test_schedule_tree_prefix(isl_ctx *ctx)
+{
+	const char *str;
+	isl_bool equal;
+	isl_union_set *uset;
+	isl_union_set_list *filters;
+	isl_multi_union_pw_aff *mupa, *mupa2;
+	isl_schedule_node *node;
+
+	str = "{ S1i,j : 0 <= i,j < 10; S2i,j : 0 <= i,j < 10 }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	node = isl_schedule_node_from_domain(uset);
+	node = isl_schedule_node_child(node, 0);
+
+	str = "{ S1i,j : i > j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_from_union_set(uset);
+	str = "{ S1i,j : i <= j; S2i,j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_add(filters, uset);
+	node = isl_schedule_node_insert_sequence(node, filters);
+
+	node = isl_schedule_node_child(node, 0);
+	node = isl_schedule_node_child(node, 0);
+	mupa = isl_schedule_node_get_prefix_schedule_multi_union_pw_aff(node);
+	str = "( : { S1i,j : i > j })";
+	mupa2 = isl_multi_union_pw_aff_read_from_str(ctx, str);
+	equal = isl_multi_union_pw_aff_plain_is_equal(mupa, mupa2);
+	isl_multi_union_pw_aff_free(mupa2);
+	isl_multi_union_pw_aff_free(mupa);
+	isl_schedule_node_free(node);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "unexpected prefix schedule",
+			return -1);
+
+	return 0;
+}
+
+/* Check that the reaching domain elements and the prefix schedule
+ * at a leaf node are the same before and after grouping.
+ */
+static int test_schedule_tree_group_1(isl_ctx *ctx)
+{
+	int equal;
+	const char *str;
+	isl_id *id;
+	isl_union_set *uset;
+	isl_multi_union_pw_aff *mupa;
+	isl_union_pw_multi_aff *upma1, *upma2;
+	isl_union_set *domain1, *domain2;
+	isl_union_map *umap1, *umap2;
+	isl_schedule_node *node;
+
+	str = "{ S1i,j : 0 <= i,j < 10; S2i,j : 0 <= i,j < 10 }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	node = isl_schedule_node_from_domain(uset);
+	node = isl_schedule_node_child(node, 0);
+	str = "{ S1i,j -> i; S2i,j -> 9 - i }";
+	mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+	node = isl_schedule_node_insert_partial_schedule(node, mupa);
+	node = isl_schedule_node_child(node, 0);
+	str = "{ S1i,j -> j; S2i,j -> j }";
+	mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+	node = isl_schedule_node_insert_partial_schedule(node, mupa);
+	node = isl_schedule_node_child(node, 0);
+	umap1 = isl_schedule_node_get_prefix_schedule_union_map(node);
+	upma1 = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node);
+	domain1 = isl_schedule_node_get_domain(node);
+	id = isl_id_alloc(ctx, "group", NULL);
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_group(node, id);
+	node = isl_schedule_node_child(node, 0);
+	umap2 = isl_schedule_node_get_prefix_schedule_union_map(node);
+	upma2 = isl_schedule_node_get_prefix_schedule_union_pw_multi_aff(node);
+	domain2 = isl_schedule_node_get_domain(node);
+	equal = isl_union_pw_multi_aff_plain_is_equal(upma1, upma2);
+	if (equal >= 0 && equal)
+		equal = isl_union_set_is_equal(domain1, domain2);
+	if (equal >= 0 && equal)
+		equal = isl_union_map_is_equal(umap1, umap2);
+	isl_union_map_free(umap1);
+	isl_union_map_free(umap2);
+	isl_union_set_free(domain1);
+	isl_union_set_free(domain2);
+	isl_union_pw_multi_aff_free(upma1);
+	isl_union_pw_multi_aff_free(upma2);
+	isl_schedule_node_free(node);
+
+	if (equal < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"expressions not equal", return -1);
+
+	return 0;
+}
+
+/* Check that we can have nested groupings and that the union map
+ * schedule representation is the same before and after the grouping.
+ * Note that after the grouping, the union map representation contains
+ * the domain constraints from the ranges of the expansion nodes,
+ * while they are missing from the union map representation of
+ * the tree without expansion nodes.
+ *
+ * Also check that the global expansion is as expected.
+ */
+static int test_schedule_tree_group_2(isl_ctx *ctx)
+{
+	int equal, equal_expansion;
+	const char *str;
+	isl_id *id;
+	isl_union_set *uset;
+	isl_union_map *umap1, *umap2;
+	isl_union_map *expansion1, *expansion2;
+	isl_union_set_list *filters;
+	isl_multi_union_pw_aff *mupa;
+	isl_schedule *schedule;
+	isl_schedule_node *node;
+
+	str = "{ S1i,j : 0 <= i,j < 10; S2i,j : 0 <= i,j < 10; "
+		"S3i,j : 0 <= i,j < 10 }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	node = isl_schedule_node_from_domain(uset);
+	node = isl_schedule_node_child(node, 0);
+	str = "{ S1i,j -> i; S2i,j -> i; S3i,j -> i }";
+	mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+	node = isl_schedule_node_insert_partial_schedule(node, mupa);
+	node = isl_schedule_node_child(node, 0);
+	str = "{ S1i,j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_from_union_set(uset);
+	str = "{ S2i,j; S3i,j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_add(filters, uset);
+	node = isl_schedule_node_insert_sequence(node, filters);
+	node = isl_schedule_node_child(node, 1);
+	node = isl_schedule_node_child(node, 0);
+	str = "{ S2i,j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_from_union_set(uset);
+	str = "{ S3i,j }";
+	uset = isl_union_set_read_from_str(ctx, str);
+	filters = isl_union_set_list_add(filters, uset);
+	node = isl_schedule_node_insert_sequence(node, filters);
+
+	schedule = isl_schedule_node_get_schedule(node);
+	umap1 = isl_schedule_get_map(schedule);
+	uset = isl_schedule_get_domain(schedule);
+	umap1 = isl_union_map_intersect_domain(umap1, uset);
+	isl_schedule_free(schedule);
+
+	node = isl_schedule_node_parent(node);
+	node = isl_schedule_node_parent(node);
+	id = isl_id_alloc(ctx, "group1", NULL);
+	node = isl_schedule_node_group(node, id);
+	node = isl_schedule_node_child(node, 1);
+	node = isl_schedule_node_child(node, 0);
+	id = isl_id_alloc(ctx, "group2", NULL);
+	node = isl_schedule_node_group(node, id);
+
+	schedule = isl_schedule_node_get_schedule(node);
+	umap2 = isl_schedule_get_map(schedule);
+	isl_schedule_free(schedule);
+
+	node = isl_schedule_node_root(node);
+	node = isl_schedule_node_child(node, 0);
+	expansion1 = isl_schedule_node_get_subtree_expansion(node);
+	isl_schedule_node_free(node);
+
+	str = "{ group1i -> S1i,j : 0 <= i,j < 10; "
+		"group1i -> S2i,j : 0 <= i,j < 10; "
+		"group1i -> S3i,j : 0 <= i,j < 10 }";
+
+	expansion2 = isl_union_map_read_from_str(ctx, str);
+
+	equal = isl_union_map_is_equal(umap1, umap2);
+	equal_expansion = isl_union_map_is_equal(expansion1, expansion2);
+
+	isl_union_map_free(umap1);
+	isl_union_map_free(umap2);
+	isl_union_map_free(expansion1);
+	isl_union_map_free(expansion2);
+
+	if (equal < 0 || equal_expansion < 0)
+		return -1;
+	if (!equal)
+		isl_die(ctx, isl_error_unknown,
+			"expressions not equal", return -1);
+	if (!equal_expansion)
+		isl_die(ctx, isl_error_unknown,
+			"unexpected expansion", return -1);
+
+	return 0;
+}
+
+/* Some tests for the isl_schedule_node_group function.
+ */
+static int test_schedule_tree_group(isl_ctx *ctx)
+{
+	if (test_schedule_tree_group_1(ctx) < 0)
+		return -1;
+	if (test_schedule_tree_group_2(ctx) < 0)
+		return -1;
+	return 0;
+}
+
 struct {
 	const char *set;
 	const char *dual;
@@ -4957,6 +10517,18 @@
 	  "{ rat: coefficientscst -> a }" },
 	{ "{ rat: i : }",
 	  "{ rat: coefficientscst -> 0 : cst >= 0 }" },
+	{ "{ 0:,1,2:3 }",
+	  "{ rat: coefficientsc_cst -> a, b, c : "
+		"a >= 0 and 2c >= -c_cst - b and 3c >= -c_cst - b }" },
+	{ "M, N -> { x = (1 - N):-1, -4x:(M - 4x) }",
+	  "{ rat: coefficientsc_cst, c_M = 0:, c_N = 0: -> a, b = -c_M: :"
+		"4b >= -c_N + a and 4b >= -c_cst - 2c_N + a }" },
+	{ "{ rat : x, y : 1 <= 2x <= 9 and 2 <= 3y <= 16 }",
+	  "{ rat: coefficientsc_cst -> c_x, c_y : "
+		"4c_y >= -6c_cst - 3c_x and 4c_y >= -6c_cst - 27c_x and "
+		"32c_y >= -6c_cst - 3c_x and 32c_y >= -6c_cst - 27c_x }" },
+	{ "{ x, y, z : 3y <= 2x - 2 and y >= -2 + 2x and 2y >= 2 - x }",
+	  "{ rat: coefficientscst -> a, b, c }" },
 };
 
 struct {
@@ -5016,9 +10588,255 @@
 }
 
 struct {
+	int scale_tile;
+	int shift_point;
+	const char *domain;
+	const char *schedule;
+	const char *sizes;
+	const char *tile;
+	const char *point;
+} tile_tests = {
+	{ 0, 0, "n -> { Si,j : 0 <= i,j < n }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	  "{ 32,32 }",
+	  "{ Si,j -> floor(i/32) }, { Si,j -> floor(j/32) }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	},
+	{ 1, 0, "n -> { Si,j : 0 <= i,j < n }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	  "{ 32,32 }",
+	  "{ Si,j -> 32*floor(i/32) }, { Si,j -> 32*floor(j/32) }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	},
+	{ 0, 1, "n -> { Si,j : 0 <= i,j < n }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	  "{ 32,32 }",
+	  "{ Si,j -> floor(i/32) }, { Si,j -> floor(j/32) }",
+	  "{ Si,j -> i%32 }, { Si,j -> j%32 }",
+	},
+	{ 1, 1, "n -> { Si,j : 0 <= i,j < n }",
+	  "{ Si,j -> i }, { Si,j -> j }",
+	  "{ 32,32 }",
+	  "{ Si,j -> 32*floor(i/32) }, { Si,j -> 32*floor(j/32) }",
+	  "{ Si,j -> i%32 }, { Si,j -> j%32 }",
+	},
+};
+
+/* Basic tiling tests.  Create a schedule tree with a domain and a band node,
+ * tile the band and then check if the tile and point bands have the
+ * expected partial schedule.
+ */
+static int test_tile(isl_ctx *ctx)
+{
+	int i;
+	int scale;
+	int shift;
+
+	scale = isl_options_get_tile_scale_tile_loops(ctx);
+	shift = isl_options_get_tile_shift_point_loops(ctx);
+
+	for (i = 0; i < ARRAY_SIZE(tile_tests); ++i) {
+		int opt;
+		int equal;
+		const char *str;
+		isl_union_set *domain;
+		isl_multi_union_pw_aff *mupa, *mupa2;
+		isl_schedule_node *node;
+		isl_multi_val *sizes;
+
+		opt = tile_testsi.scale_tile;
+		isl_options_set_tile_scale_tile_loops(ctx, opt);
+		opt = tile_testsi.shift_point;
+		isl_options_set_tile_shift_point_loops(ctx, opt);
+
+		str = tile_testsi.domain;
+		domain = isl_union_set_read_from_str(ctx, str);
+		node = isl_schedule_node_from_domain(domain);
+		node = isl_schedule_node_child(node, 0);
+		str = tile_testsi.schedule;
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+		node = isl_schedule_node_insert_partial_schedule(node, mupa);
+		str = tile_testsi.sizes;
+		sizes = isl_multi_val_read_from_str(ctx, str);
+		node = isl_schedule_node_band_tile(node, sizes);
+
+		str = tile_testsi.tile;
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+		mupa2 = isl_schedule_node_band_get_partial_schedule(node);
+		equal = isl_multi_union_pw_aff_plain_is_equal(mupa, mupa2);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(mupa2);
+
+		node = isl_schedule_node_child(node, 0);
+
+		str = tile_testsi.point;
+		mupa = isl_multi_union_pw_aff_read_from_str(ctx, str);
+		mupa2 = isl_schedule_node_band_get_partial_schedule(node);
+		if (equal >= 0 && equal)
+			equal = isl_multi_union_pw_aff_plain_is_equal(mupa,
+									mupa2);
+		isl_multi_union_pw_aff_free(mupa);
+		isl_multi_union_pw_aff_free(mupa2);
+
+		isl_schedule_node_free(node);
+
+		if (equal < 0)
+			return -1;
+		if (!equal)
+			isl_die(ctx, isl_error_unknown,
+				"unexpected result", return -1);
+	}
+
+	isl_options_set_tile_scale_tile_loops(ctx, scale);
+	isl_options_set_tile_shift_point_loops(ctx, shift);
+
+	return 0;
+}
+
+/* Check that the domain hash of a space is equal to the hash
+ * of the domain of the space, both ignoring parameters.
+ */
+static int test_domain_hash(isl_ctx *ctx)
+{
+	isl_map *map;
+	isl_space *space;
+	uint32_t hash1, hash2;
+
+	map = isl_map_read_from_str(ctx, "n -> { ABx -> C -> D }");
+	space = isl_map_get_space(map);
+	isl_map_free(map);
+	hash1 = isl_space_get_tuple_domain_hash(space);
+	space = isl_space_domain(space);
+	hash2 = isl_space_get_tuple_hash(space);
+	isl_space_free(space);
+
+	if (!space)
+		return -1;
+	if (hash1 != hash2)
+		isl_die(ctx, isl_error_unknown,
+			"domain hash not equal to hash of domain", return -1);
+
+	return 0;
+}
+
+/* Check that a universe basic set that is not obviously equal to the universe
+ * is still recognized as being equal to the universe.
+ */
+static int test_universe(isl_ctx *ctx)
+{
+	const char *s;
+	isl_basic_set *bset;
+	isl_bool is_univ;
+
+	s = "{  : exists x, y : 3y <= 2x and y >= -3 + 2x and 2y >= 2 - x }";
+	bset = isl_basic_set_read_from_str(ctx, s);
+	is_univ = isl_basic_set_is_universe(bset);
+	isl_basic_set_free(bset);
+
+	if (is_univ < 0)
+		return -1;
+	if (!is_univ)
+		isl_die(ctx, isl_error_unknown,
+			"not recognized as universe set", return -1);
+
+	return 0;
+}
+
+/* Sets for which chambers are computed and checked.
+ */
+const char *chambers_tests = {
+	"A, B, C -> { x, y, z : x >= 0 and y >= 0 and y <= A - x and "
+				"z >= 0 and z <= C - y and z <= B - x - y }",
+};
+
+/* Add the domain of "cell" to "cells".
+ */
+static isl_stat add_cell(__isl_take isl_cell *cell, void *user)
+{
+	isl_basic_set_list **cells = user;
+	isl_basic_set *dom;
+
+	dom = isl_cell_get_domain(cell);
+	isl_cell_free(cell);
+	*cells = isl_basic_set_list_add(*cells, dom);
+
+	return *cells ? isl_stat_ok : isl_stat_error;
+}
+
+/* Check that the elements of "list" are pairwise disjoint.
+ */
+static isl_stat check_pairwise_disjoint(__isl_keep isl_basic_set_list *list)
+{
+	int i, j;
+	isl_size n;
+
+	n = isl_basic_set_list_n_basic_set(list);
+	if (n < 0)
+		return isl_stat_error;
+
+	for (i = 0; i < n; ++i) {
+		isl_basic_set *bset_i;
+
+		bset_i = isl_basic_set_list_get_basic_set(list, i);
+		for (j = i + 1; j < n; ++j) {
+			isl_basic_set *bset_j;
+			isl_bool disjoint;
+
+			bset_j = isl_basic_set_list_get_basic_set(list, j);
+			disjoint = isl_basic_set_is_disjoint(bset_i, bset_j);
+			isl_basic_set_free(bset_j);
+			if (!disjoint)
+				isl_die(isl_basic_set_list_get_ctx(list),
+					isl_error_unknown, "not disjoint",
+					break);
+			if (disjoint < 0 || !disjoint)
+				break;
+		}
+		isl_basic_set_free(bset_i);
+		if (j < n)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
+}
+
+/* Check that the chambers computed by isl_vertices_foreach_disjoint_cell
+ * are pairwise disjoint.
+ */
+static int test_chambers(isl_ctx *ctx)
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(chambers_tests); ++i) {
+		isl_basic_set *bset;
+		isl_vertices *vertices;
+		isl_basic_set_list *cells;
+		isl_stat ok;
+
+		bset = isl_basic_set_read_from_str(ctx, chambers_testsi);
+		vertices = isl_basic_set_compute_vertices(bset);
+		cells = isl_basic_set_list_alloc(ctx, 0);
+		if (isl_vertices_foreach_disjoint_cell(vertices, &add_cell,
+							&cells) < 0)
+			cells = isl_basic_set_list_free(cells);
+		ok = check_pairwise_disjoint(cells);
+		isl_basic_set_list_free(cells);
+		isl_vertices_free(vertices);
+		isl_basic_set_free(bset);
+
+		if (ok < 0)
+			return -1;
+	}
+
+	return 0;
+}
+
+struct {
 	const char *name;
 	int (*fn)(isl_ctx *ctx);
 } tests  = {
+	{ "universe", &test_universe },
+	{ "domain hash", &test_domain_hash },
 	{ "dual", &test_dual },
 	{ "dependence analysis", &test_flow },
 	{ "val", &test_val },
@@ -5031,19 +10849,23 @@
 	{ "conversion", &test_conversion },
 	{ "list", &test_list },
 	{ "align parameters", &test_align_parameters },
+	{ "drop unused parameters", &test_drop_unused_parameters },
 	{ "preimage", &test_preimage },
 	{ "pullback", &test_pullback },
 	{ "AST", &test_ast },
 	{ "AST build", &test_ast_build },
 	{ "AST generation", &test_ast_gen },
 	{ "eliminate", &test_eliminate },
+	{ "deltas_map", &test_deltas_map },
 	{ "residue class", &test_residue_class },
 	{ "div", &test_div },
 	{ "slice", &test_slice },
 	{ "fixed power", &test_fixed_power },
 	{ "sample", &test_sample },
+	{ "empty projection", &test_empty_projection },
 	{ "output", &test_output },
 	{ "vertices", &test_vertices },
+	{ "chambers", &test_chambers },
 	{ "fixed", &test_fixed },
 	{ "equal", &test_equal },
 	{ "disjoint", &test_disjoint },
@@ -5051,19 +10873,50 @@
 	{ "dim_max", &test_dim_max },
 	{ "affine", &test_aff },
 	{ "injective", &test_injective },
-	{ "schedule", &test_schedule },
+	{ "schedule (whole component)", &test_schedule_whole },
+	{ "schedule (incremental)", &test_schedule_incremental },
+	{ "schedule tree", &test_schedule_tree },
+	{ "schedule tree prefix", &test_schedule_tree_prefix },
+	{ "schedule tree grouping", &test_schedule_tree_group },
+	{ "tile", &test_tile },
+	{ "union map", &test_union_map },
 	{ "union_pw", &test_union_pw },
+	{ "locus", &test_locus },
+	{ "eval", &test_eval },
 	{ "parse", &test_parse },
 	{ "single-valued", &test_sv },
+	{ "recession cone", &test_recession_cone },
 	{ "affine hull", &test_affine_hull },
+	{ "simple_hull", &test_simple_hull },
+	{ "box hull", &test_box_hull },
 	{ "coalesce", &test_coalesce },
 	{ "factorize", &test_factorize },
 	{ "subset", &test_subset },
 	{ "subtract", &test_subtract },
+	{ "intersect", &test_intersect },
 	{ "lexmin", &test_lexmin },
 	{ "min", &test_min },
+	{ "set lower bounds", &test_min_mpa },
 	{ "gist", &test_gist },
 	{ "piecewise quasi-polynomials", &test_pwqp },
+	{ "lift", &test_lift },
+	{ "bind parameters", &test_bind },
+	{ "unbind parameters", &test_unbind },
+	{ "bound", &test_bound },
+	{ "get lists", &test_get_list },
+	{ "union", &test_union },
+	{ "split periods", &test_split_periods },
+	{ "lexicographic order", &test_lex },
+	{ "bijectivity", &test_bijective },
+	{ "dataflow analysis", &test_dep },
+	{ "reading", &test_read },
+	{ "bounded", &test_bounded },
+	{ "construction", &test_construction },
+	{ "dimension manipulation", &test_dim },
+	{ "map application", &test_application },
+	{ "convex hull", &test_convex_hull },
+	{ "transitive closure", &test_closure },
+	{ "isl_bool", &test_isl_bool},
 };
 
 int main(int argc, char **argv)
@@ -5072,9 +10925,6 @@
 	struct isl_ctx *ctx;
 	struct isl_options *options;
 
-	srcdir = getenv("srcdir");
-	assert(srcdir);
-
 	options = isl_options_new_with_defaults();
 	assert(options);
 	argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
@@ -5085,20 +10935,6 @@
 		if (testsi.fn(ctx) < 0)
 			goto error;
 	}
-	test_lift(ctx);
-	test_bound(ctx);
-	test_union(ctx);
-	test_split_periods(ctx);
-	test_lex(ctx);
-	test_bijective(ctx);
-	test_dep(ctx);
-	test_read(ctx);
-	test_bounded(ctx);
-	test_construction(ctx);
-	test_dim(ctx);
-	test_application(ctx);
-	test_convex_hull(ctx);
-	test_closure(ctx);
 	isl_ctx_free(ctx);
 	return 0;
 error:

_service:tar_scm:isl-0.24.tar.gz/isl_test_cpp-checked-conversion.cc Added

@@ -0,0 +1,99 @@
+/*
+ * Copyright 2018      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <stdlib.h>
+
+#include <isl/ctx.h>
+#include <isl/options.h>
+#include <isl/cpp-checked-conversion.h>
+
+/* Check that converting a NULL object from the checked C++ bindings
+ * (where the user is expected to check for NULL return values)
+ * to the default C++ bindings (where exceptions are raised
+ * instead of returning a NULL object) raises an exception.
+ */
+static void check_conversion_null(isl_ctx *ctx)
+{
+	isl::checked::set checked_set;
+	isl::set set;
+
+	bool caught = false;
+	try {
+		set = isl::uncheck(checked_set);
+		isl_die(ctx, isl_error_unknown, "no exception raised", return);
+	} catch (const isl::exception &e) {
+		caught = true;
+	}
+	if (!caught)
+		isl_die(ctx, isl_error_unknown, "no exception raised", return);
+}
+
+/* Dummy function on a set in the checked C++ bindings.
+ */
+static void f_checked(isl::checked::set set)
+{
+}
+
+/* Dummy function on a set in the default C++ bindings.
+ */
+static void f_unchecked(isl::set set)
+{
+}
+
+/* Check the conversion between C++ bindings in function calls.
+ * An incorrect call will result in a compiler error.
+ */
+static void check_conversion_call(isl_ctx *ctx)
+{
+	isl::set set(ctx, "{ Si : 0 <= i < 10 }");
+	isl::checked::set checked_set(ctx, "{ Si : 0 <= i < 10 }");
+
+	f_unchecked(set);
+	f_checked(isl::check(set));
+	f_unchecked(isl::uncheck(checked_set));
+	f_checked(checked_set);
+}
+
+/* Check that a double conversion results in the original set,
+ * or at least something that is equal to the original set.
+ */
+static void check_conversion_equal(isl_ctx *ctx)
+{
+	isl::set set(ctx, "{ Si : 0 <= i < 10 }");
+	isl::set set2;
+	isl::checked::set checked_set;
+
+	checked_set = isl::check(set);
+	set2 = isl::uncheck(checked_set);
+
+	if (!set.is_equal(set2))
+		isl_die(ctx, isl_error_unknown, "bad conversion", return);
+}
+
+/* Perform some tests on the conversion between the default C++ bindings and
+ * the checked C++ bindings.
+ */
+static void check_conversion(isl_ctx *ctx)
+{
+	check_conversion_null(ctx);
+	check_conversion_call(ctx);
+	check_conversion_equal(ctx);
+}
+
+int main()
+{
+	isl_ctx *ctx = isl_ctx_alloc();
+
+	isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
+
+	check_conversion(ctx);
+
+	isl_ctx_free(ctx);
+
+	return EXIT_SUCCESS;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_cpp-checked.cc Added

@@ -0,0 +1,312 @@
+/* Copyright 2016-2017 Tobias Grosser
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
+ */
+
+#include <vector>
+#include <string>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#include <isl/options.h>
+#include <isl/cpp-checked.h>
+
+namespace isl { using namespace checked; }
+
+static void assert_impl(bool condition, const char *file, int line,
+	const char *message)
+{
+	if (condition)
+		return;
+
+	fprintf(stderr, "Assertion failed in %s:%d %s\n", file, line, message);
+	exit(EXIT_FAILURE);
+}
+
+static void assert_impl(isl::boolean condition, const char *file, int line,
+	const char *message)
+{
+	assert_impl(bool(condition), file, line, message);
+}
+
+/* Return the value encapsulated by "s".
+ */
+static int size_val(isl::size s)
+{
+	return s.is_error() ? -1 : unsigned(s);
+}
+
+#undef assert
+#define assert(exp) assert_impl(exp, __FILE__, __LINE__, #exp)
+#define IS_TRUE(b)	(b).is_true()
+#define SIZE_VAL(s)	size_val(s)
+
+#include "isl_test_cpp-generic.cc"
+
+/* Test that isl_bool values are returned correctly.
+ *
+ * We check in detail the following parts of the isl::boolean class:
+ *  - The is_true, is_false, and is_error functions return true in case they
+ *    are called on a true, false, or error instance of isl::boolean,
+ *    respectively
+ *  - Explicit conversion to 'bool'
+ *  - Implicit conversion to 'bool'
+ *  - The complement operator
+ *  - Explicit construction from 'true' and 'false'
+ *  - Explicit construction form isl_bool
+ */
+void test_return_bool(isl::ctx ctx)
+{
+	isl::set empty(ctx, "{ : false }");
+	isl::set univ(ctx, "{ : }");
+	isl::set null;
+
+	isl::boolean b_true = empty.is_empty();
+	isl::boolean b_false = univ.is_empty();
+	isl::boolean b_error = null.is_empty();
+
+	assert(b_true.is_true());
+	assert(!b_true.is_false());
+	assert(!b_true.is_error());
+
+	assert(!b_false.is_true());
+	assert(b_false.is_false());
+	assert(!b_false.is_error());
+
+	assert(!b_error.is_true());
+	assert(!b_error.is_false());
+	assert(b_error.is_error());
+
+	assert(bool(b_true) == true);
+	assert(bool(b_false) == false);
+
+	assert(b_true);
+
+	assert((!b_false).is_true());
+	assert((!b_true).is_false());
+	assert((!b_error).is_error());
+
+	assert(isl::boolean(true).is_true());
+	assert(!isl::boolean(true).is_false());
+	assert(!isl::boolean(true).is_error());
+
+	assert(isl::boolean(false).is_false());
+	assert(!isl::boolean(false).is_true());
+	assert(!isl::boolean(false).is_error());
+
+	assert(isl::manage(isl_bool_true).is_true());
+	assert(!isl::manage(isl_bool_true).is_false());
+	assert(!isl::manage(isl_bool_true).is_error());
+
+	assert(isl::manage(isl_bool_false).is_false());
+	assert(!isl::manage(isl_bool_false).is_true());
+	assert(!isl::manage(isl_bool_false).is_error());
+
+	assert(isl::manage(isl_bool_error).is_error());
+	assert(!isl::manage(isl_bool_error).is_true());
+	assert(!isl::manage(isl_bool_error).is_false());
+}
+
+/* Test that return values are handled correctly.
+ *
+ * Test that isl C++ objects, integers, boolean values, and strings are
+ * returned correctly.
+ */
+void test_return(isl::ctx ctx)
+{
+	test_return_obj(ctx);
+	test_return_int(ctx);
+	test_return_bool(ctx);
+	test_return_string(ctx);
+}
+
+/* Test that foreach functions are modeled correctly.
+ *
+ * Verify that lambdas are correctly called as callback of a 'foreach'
+ * function and that variables captured by the lambda work correctly. Also
+ * check that the foreach function takes account of the return value of the
+ * lambda and aborts in case isl::stat::error is returned and then returns
+ * isl::stat::error itself.
+ */
+void test_foreach(isl::ctx ctx)
+{
+	isl::set s(ctx, "{ 0; 1; 2 }");
+
+	std::vector<isl::basic_set> basic_sets;
+
+	auto add_to_vector = & (isl::basic_set bs) {
+		basic_sets.push_back(bs);
+		return isl::stat::ok();
+	};
+
+	isl::stat ret1 = s.foreach_basic_set(add_to_vector);
+
+	assert(ret1.is_ok());
+	assert(basic_sets.size() == 3);
+	assert(isl::set(basic_sets0).is_subset(s).is_true());
+	assert(isl::set(basic_sets1).is_subset(s).is_true());
+	assert(isl::set(basic_sets2).is_subset(s).is_true());
+	assert(!basic_sets0.is_equal(basic_sets1).is_true());
+
+	auto fail = & (isl::basic_set bs) {
+		return isl::stat::error();
+	};
+
+	isl::stat ret2 = s.foreach_basic_set(fail);
+
+	assert(ret2.is_error());
+}
+
+/* Test the functionality of "every" functions.
+ *
+ * In particular, test the generic functionality and
+ * test that error conditions are properly propagated.
+ */
+static void test_every(isl::ctx ctx)
+{
+	isl::union_set us(ctx, "{ Ai; Bj }");
+
+	test_every_generic(ctx);
+
+	auto fail =  (isl::set s){
+		return isl::boolean::error();
+	};
+	assert(us.every_set(fail).is_error());
+}
+
+/* Test basic schedule tree functionality.
+ *
+ * In particular, create a simple schedule tree and
+ * - perform some generic tests
+ * - test map_descendant_bottom_up in the failing case
+ * - test foreach_descendant_top_down
+ * - test every_descendant
+ */
+static void test_schedule_tree(isl::ctx ctx)
+{
+	auto root = test_schedule_tree_generic(ctx);
+
+	auto fail_map = (isl::schedule_node node) {
+		return isl::schedule_node();
+	};
+	assert(root.map_descendant_bottom_up(fail_map).is_null());
+
+	int count = 0;
+	auto inc_count = &count(isl::schedule_node node) {
+		count++;
+		return isl::boolean(true);
+	};
+	assert(root.foreach_descendant_top_down(inc_count).is_ok());
+	assert(count == 8);
+
+	count = 0;
+	auto inc_count_once = &count(isl::schedule_node node) {
+		count++;
+		return isl::boolean(false);
+	};
+	assert(root.foreach_descendant_top_down(inc_count_once).is_ok());
+	assert(count == 1);
+
+	auto is_not_domain = (isl::schedule_node node) {
+		return !node.isa<isl::schedule_node_domain>();
+	};
+	assert(root.child(0).every_descendant(is_not_domain).is_true());
+	assert(root.every_descendant(is_not_domain).is_false());
+
+	auto fail = (isl::schedule_node node) {
+		return isl::boolean();
+	};
+	assert(root.every_descendant(fail).is_error());
+
+	auto domain = root.as<isl::schedule_node_domain>().domain();
+	auto filters = isl::union_set(ctx, "{}");
+	auto collect_filters = &filters(isl::schedule_node node) {
+		if (node.isa<isl::schedule_node_filter>().is_true()) {
+			auto filter = node.as<isl::schedule_node_filter>();
+			filters = filters.unite(filter.filter());
+		}
+		return isl::boolean(true);
+	};
+	assert(!root.every_descendant(collect_filters).is_error());
+	assert(domain.is_equal(filters).is_true());
+}
+
+/* Test basic AST generation from a schedule tree.
+ *
+ * In particular, create a simple schedule tree and
+ * - perform some generic tests
+ * - test at_each_domain in the failing case
+ */
+static void test_ast_build(isl::ctx ctx)
+{
+	auto schedule = test_ast_build_generic(ctx);
+
+	bool do_fail = true;
+	int count_ast_fail = 0;
+	auto fail_inc_count_ast =
+	    &count_ast_fail, &do_fail(isl::ast_node node,
+					isl::ast_build build) {
+		count_ast_fail++;
+		return do_fail ? isl::ast_node() : node;
+	};
+	auto build = isl::ast_build(ctx);
+	build = build.set_at_each_domain(fail_inc_count_ast);
+	auto ast = build.node_from(schedule);
+	assert(ast.is_null());
+	assert(count_ast_fail > 0);
+	auto build_copy = build;
+	int count_ast = 0;
+	auto inc_count_ast =
+	    &count_ast(isl::ast_node node, isl::ast_build build) {
+		count_ast++;
+		return node;
+	};
+	build_copy = build_copy.set_at_each_domain(inc_count_ast);
+	ast = build_copy.node_from(schedule);
+	assert(!ast.is_null());
+	assert(count_ast == 2);
+	count_ast_fail = 0;
+	do_fail = false;
+	ast = build.node_from(schedule);
+	assert(!ast.is_null());
+	assert(count_ast_fail == 2);
+}
+
+/* Test the isl checked C++ interface
+ *
+ * This includes:
+ *  - The isl C <-> C++ pointer interface
+ *  - Object construction
+ *  - Different parameter types
+ *  - Different return types
+ *  - Foreach functions
+ *  - Every functions
+ *  - Spaces
+ *  - Schedule trees
+ *  - AST generation
+ *  - AST expression generation
+ */
+int main()
+{
+	isl_ctx *ctx = isl_ctx_alloc();
+
+	isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
+
+	test_pointer(ctx);
+	test_constructors(ctx);
+	test_parameters(ctx);
+	test_return(ctx);
+	test_foreach(ctx);
+	test_every(ctx);
+	test_space(ctx);
+	test_schedule_tree(ctx);
+	test_ast_build(ctx);
+	test_ast_build_expr(ctx);
+
+	isl_ctx_free(ctx);
+
+	return EXIT_SUCCESS;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_cpp-generic.cc Added

@@ -0,0 +1,374 @@
+/* Copyright 2016-2017 Tobias Grosser
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
+ */
+
+#ifndef IS_TRUE
+#define IS_TRUE(b)	(b)
+#endif
+#ifndef SIZE_VAL
+#define SIZE_VAL(s)	(s)
+#endif
+
+/* Test the pointer interface for interaction between isl C and C++ types.
+ *
+ * This tests:
+ * - construction from an isl C object
+ * - check that constructed objects are non-null
+ * - get a non-owned C pointer from an isl C++ object usable in __isl_keep
+ *   methods
+ * - use copy to get an owned C pointer from an isl C++ object which is usable
+ *   in __isl_take methods. Verify that the original C++ object retains a valid
+ *   pointer.
+ * - use release to get an owned C pointer from an isl C++ object which is
+ *   usable in __isl_take methods. Verify that the original C++ object gave up
+ *   its pointer and now is null.
+ */
+void test_pointer(isl::ctx ctx)
+{
+	isl_set *c_empty = isl_set_read_from_str(ctx.get(), "{ : false }");
+	isl::set empty = isl::manage(c_empty);
+	assert(IS_TRUE(empty.is_empty()));
+	assert(isl_set_is_empty(empty.get()));
+
+	assert(!empty.is_null());
+	isl_set_free(empty.copy());
+	assert(!empty.is_null());
+	isl_set_free(empty.release());
+	assert(empty.is_null());
+}
+
+/* Test that isl objects can be constructed.
+ *
+ * This tests:
+ *  - construction of a null object
+ *  - construction from a string
+ *  - construction from an integer
+ *  - static constructor without a parameter
+ *  - conversion construction (implicit)
+ *  - conversion construction (explicit)
+ *  - construction of empty union set
+ *
+ *  The tests to construct from integers and strings cover functionality that
+ *  is also tested in the parameter type tests, but here we verify that
+ *  multiple overloaded constructors are available and that overload resolution
+ *  works as expected.
+ *
+ *  Construction from an isl C pointer is tested in test_pointer.
+ */
+void test_constructors(isl::ctx ctx)
+{
+	isl::val null;
+	assert(null.is_null());
+
+	isl::val zero_from_str = isl::val(ctx, "0");
+	assert(IS_TRUE(zero_from_str.is_zero()));
+
+	isl::val zero_int_con = isl::val(ctx, 0);
+	assert(IS_TRUE(zero_int_con.is_zero()));
+
+	isl::val zero_static_con = isl::val::zero(ctx);
+	assert(IS_TRUE(zero_static_con.is_zero()));
+
+	isl::basic_set bs(ctx, "{ 1 }");
+	isl::set result(ctx, "{ 1 }");
+	isl::set s = bs;
+	assert(IS_TRUE(s.is_equal(result)));
+	isl::set s2(bs);
+	assert(IS_TRUE(s.unite(s2).is_equal(result)));
+
+	isl::union_set us(ctx, "{ A1; B2, 3 }");
+	isl::union_set empty = isl::union_set::empty(ctx);
+	assert(IS_TRUE(us.is_equal(us.unite(empty))));
+}
+
+/* Test integer function parameters.
+ *
+ * Verify that extreme values and zero work.
+ */
+void test_parameters_int(isl::ctx ctx)
+{
+	isl::val long_max_str(ctx, std::to_string(LONG_MAX));
+	isl::val long_max_int(ctx, LONG_MAX);
+	assert(IS_TRUE(long_max_str.eq(long_max_int)));
+
+	isl::val long_min_str(ctx, std::to_string(LONG_MIN));
+	isl::val long_min_int(ctx, LONG_MIN);
+	assert(IS_TRUE(long_min_str.eq(long_min_int)));
+
+	isl::val long_zero_str = isl::val(ctx, std::to_string(0));
+	isl::val long_zero_int = isl::val(ctx, 0);
+	assert(IS_TRUE(long_zero_str.eq(long_zero_int)));
+}
+
+/* Test isl objects parameters.
+ *
+ * Verify that isl objects can be passed as lvalue and rvalue parameters.
+ * Also verify that isl object parameters are automatically type converted if
+ * there is an inheritance relation. Finally, test function calls without
+ * any additional parameters, apart from the isl object on which
+ * the method is called.
+ */
+void test_parameters_obj(isl::ctx ctx)
+{
+	isl::set a(ctx, "{ 0 }");
+	isl::set b(ctx, "{ 1 }");
+	isl::set c(ctx, "{ 2 }");
+	isl::set expected(ctx, "{ i : 0 <= i <= 2 }");
+
+	isl::set tmp = a.unite(b);
+	isl::set res_lvalue_param = tmp.unite(c);
+	assert(IS_TRUE(res_lvalue_param.is_equal(expected)));
+
+	isl::set res_rvalue_param = a.unite(b).unite(c);
+	assert(IS_TRUE(res_rvalue_param.is_equal(expected)));
+
+	isl::basic_set a2(ctx, "{ 0 }");
+	assert(IS_TRUE(a.is_equal(a2)));
+
+	isl::val two(ctx, 2);
+	isl::val half(ctx, "1/2");
+	isl::val res_only_this_param = two.inv();
+	assert(IS_TRUE(res_only_this_param.eq(half)));
+}
+
+/* Test different kinds of parameters to be passed to functions.
+ *
+ * This includes integer and isl C++ object parameters.
+ */
+void test_parameters(isl::ctx ctx)
+{
+	test_parameters_int(ctx);
+	test_parameters_obj(ctx);
+}
+
+/* Test that isl objects are returned correctly.
+ *
+ * This only tests that after combining two objects, the result is successfully
+ * returned.
+ */
+void test_return_obj(isl::ctx ctx)
+{
+	isl::val one(ctx, "1");
+	isl::val two(ctx, "2");
+	isl::val three(ctx, "3");
+
+	isl::val res = one.add(two);
+
+	assert(IS_TRUE(res.eq(three)));
+}
+
+/* Test that integer values are returned correctly.
+ */
+void test_return_int(isl::ctx ctx)
+{
+	isl::val one(ctx, "1");
+	isl::val neg_one(ctx, "-1");
+	isl::val zero(ctx, "0");
+
+	assert(one.sgn() > 0);
+	assert(neg_one.sgn() < 0);
+	assert(zero.sgn() == 0);
+}
+
+/* Test that strings are returned correctly.
+ * Do so by calling overloaded isl::ast_build::from_expr methods.
+ */
+void test_return_string(isl::ctx ctx)
+{
+	isl::set context(ctx, "n -> { : }");
+	isl::ast_build build = isl::ast_build::from_context(context);
+	isl::pw_aff pw_aff(ctx, "n -> { n }");
+	isl::set set(ctx, "n -> { : n >= 0 }");
+
+	isl::ast_expr expr = build.expr_from(pw_aff);
+	const char *expected_string = "n";
+	assert(expected_string == expr.to_C_str());
+
+	expr = build.expr_from(set);
+	expected_string = "n >= 0";
+	assert(expected_string == expr.to_C_str());
+}
+
+/* Test the functionality of "every" functions
+ * that does not depend on the type of C++ bindings.
+ */
+static void test_every_generic(isl::ctx ctx)
+{
+	isl::union_set us(ctx, "{ Ai; Bj }");
+
+	auto is_empty =  (isl::set s) {
+		return s.is_empty();
+	};
+	assert(!IS_TRUE(us.every_set(is_empty)));
+
+	auto is_non_empty =  (isl::set s) {
+		return !s.is_empty();
+	};
+	assert(IS_TRUE(us.every_set(is_non_empty)));
+
+	auto in_A =  (isl::set s) {
+		return s.is_subset(isl::set(s.ctx(), "{ Ax }"));
+	};
+	assert(!IS_TRUE(us.every_set(in_A)));
+
+	auto not_in_A =  (isl::set s) {
+		return !s.is_subset(isl::set(s.ctx(), "{ Ax }"));
+	};
+	assert(!IS_TRUE(us.every_set(not_in_A)));
+}
+
+/* Check basic construction of spaces.
+ */
+static void test_space(isl::ctx ctx)
+{
+	isl::space unit = isl::space::unit(ctx);
+	isl::space set_space = unit.add_named_tuple("A", 3);
+	isl::space map_space = set_space.add_named_tuple("B", 2);
+
+	isl::set set = isl::set::universe(set_space);
+	isl::map map = isl::map::universe(map_space);
+	assert(IS_TRUE(set.is_equal(isl::set(ctx, "{ A*,*,* }"))));
+	assert(IS_TRUE(map.is_equal(isl::map(ctx, "{ A*,*,* -> B*,* }"))));
+}
+
+/* Construct a simple schedule tree with an outer sequence node and
+ * a single-dimensional band node in each branch, with one of them
+ * marked coincident.
+ */
+static isl::schedule construct_schedule_tree(isl::ctx ctx)
+{
+	isl::union_set A(ctx, "{ Ai : 0 <= i < 10 }");
+	isl::union_set B(ctx, "{ Bi : 0 <= i < 20 }");
+
+	auto node = isl::schedule_node::from_domain(A.unite(B));
+	node = node.child(0);
+
+	isl::union_set_list filters(ctx, 0);
+	filters = filters.add(A).add(B);
+	node = node.insert_sequence(filters);
+
+	isl::multi_union_pw_aff f_A(ctx, " { Ai -> i } ");
+	node = node.child(0);
+	node = node.child(0);
+	node = node.insert_partial_schedule(f_A);
+	auto band = node.as<isl::schedule_node_band>();
+	band = band.member_set_coincident(0, true);
+	node = band.ancestor(2);
+
+	isl::multi_union_pw_aff f_B(ctx, " { Bi -> i } ");
+	node = node.child(1);
+	node = node.child(0);
+	node = node.insert_partial_schedule(f_B);
+	node = node.ancestor(2);
+
+	return node.schedule();
+}
+
+/* Test basic schedule tree functionality that is independent
+ * of the type of bindings.
+ *
+ * In particular, create a simple schedule tree and
+ * - check that the root node is a domain node
+ * - check that an object of a subclass can be used as one of the superclass
+ * - test map_descendant_bottom_up in the successful case
+ */
+static isl::schedule_node test_schedule_tree_generic(isl::ctx ctx)
+{
+	auto schedule = construct_schedule_tree(ctx);
+	auto root = schedule.root();
+
+	assert(IS_TRUE(root.isa<isl::schedule_node_domain>()));
+	root = root.as<isl::schedule_node_domain>().child(0).parent();
+
+	int count = 0;
+	auto inc_count = &count(isl::schedule_node node) {
+		count++;
+		return node;
+	};
+	root = root.map_descendant_bottom_up(inc_count);
+	assert(count == 8);
+
+	return root;
+}
+
+/* Test marking band members for unrolling.
+ * "schedule" is the schedule created by construct_schedule_tree.
+ * It schedules two statements, with 10 and 20 instances, respectively.
+ * Unrolling all band members therefore results in 30 at-domain calls
+ * by the AST generator.
+ */
+static void test_ast_build_unroll(isl::schedule schedule)
+{
+	auto root = schedule.root();
+	auto mark_unroll = (isl::schedule_node node) {
+		if (IS_TRUE(node.isa<isl::schedule_node_band>())) {
+			auto band = node.as<isl::schedule_node_band>();
+			node = band.member_set_ast_loop_unroll(0);
+		}
+		return node;
+	};
+	root = root.map_descendant_bottom_up(mark_unroll);
+	schedule = root.schedule();
+
+	int count_ast = 0;
+	auto inc_count_ast =
+	    &count_ast(isl::ast_node node, isl::ast_build build) {
+		count_ast++;
+		return node;
+	};
+	auto build = isl::ast_build(schedule.ctx());
+	build = build.set_at_each_domain(inc_count_ast);
+	auto ast = build.node_from(schedule);
+	assert(count_ast == 30);
+}
+
+/* Test basic AST generation from a schedule tree that is independent
+ * of the type of bindings.
+ *
+ * In particular, create a simple schedule tree and
+ * - generate an AST from the schedule tree
+ * - test at_each_domain in the successful case
+ * - test unrolling
+ */
+static isl::schedule test_ast_build_generic(isl::ctx ctx)
+{
+	auto schedule = construct_schedule_tree(ctx);
+
+	int count_ast = 0;
+	auto inc_count_ast =
+	    &count_ast(isl::ast_node node, isl::ast_build build) {
+		count_ast++;
+		return node;
+	};
+	auto build = isl::ast_build(ctx);
+	auto build_copy = build.set_at_each_domain(inc_count_ast);
+	auto ast = build.node_from(schedule);
+	assert(count_ast == 0);
+	count_ast = 0;
+	ast = build_copy.node_from(schedule);
+	assert(count_ast == 2);
+	build = build_copy;
+	count_ast = 0;
+	ast = build.node_from(schedule);
+	assert(count_ast == 2);
+
+	test_ast_build_unroll(schedule);
+
+	return schedule;
+}
+
+/* Test basic AST expression generation from an affine expression.
+ */
+static void test_ast_build_expr(isl::ctx ctx)
+{
+	isl::pw_aff pa(ctx, "n -> { n + 1 }");
+	isl::ast_build build = isl::ast_build::from_context(pa.domain());
+
+	auto expr = build.expr_from(pa);
+	auto op = expr.as<isl::ast_expr_op>();
+	assert(IS_TRUE(op.isa<isl::ast_expr_op_add>()));
+	assert(SIZE_VAL(op.n_arg()) == 2);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_cpp.cc Added

@@ -0,0 +1,345 @@
+/* Copyright 2016-2017 Tobias Grosser
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
+ */
+
+#include <vector>
+#include <string>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <isl/options.h>
+#include <isl/typed_cpp.h>
+
+static void die_impl(const char *file, int line, const char *message)
+{
+	fprintf(stderr, "Assertion failed in %s:%d %s\n", file, line, message);
+	exit(EXIT_FAILURE);
+}
+
+static void assert_impl(bool condition, const char *file, int line,
+	const char *message)
+{
+	if (condition)
+		return;
+
+	return die_impl(file, line, message);
+}
+
+#define die(msg) die_impl(__FILE__, __LINE__, msg)
+#undef assert
+#define assert(exp) assert_impl(exp, __FILE__, __LINE__, #exp)
+
+#include "isl_test_cpp-generic.cc"
+
+/* Test that isl_bool values are returned correctly.
+ *
+ * In particular, check the conversion to bool in case of true and false, and
+ * exception throwing in case of error.
+ */
+static void test_return_bool(isl::ctx ctx)
+{
+	isl::set empty(ctx, "{ : false }");
+	isl::set univ(ctx, "{ : }");
+	isl::set null;
+
+	bool b_true = empty.is_empty();
+	bool b_false = univ.is_empty();
+	bool caught = false;
+	try {
+		null.is_empty();
+		die("no exception raised");
+	} catch (const isl::exception_invalid &e) {
+		caught = true;
+	}
+
+	assert(b_true);
+	assert(!b_false);
+	assert(caught);
+}
+
+/* Test that return values are handled correctly.
+ *
+ * Test that isl C++ objects, integers, boolean values, and strings are
+ * returned correctly.
+ */
+static void test_return(isl::ctx ctx)
+{
+	test_return_obj(ctx);
+	test_return_int(ctx);
+	test_return_bool(ctx);
+	test_return_string(ctx);
+}
+
+/* Test that foreach functions are modeled correctly.
+ *
+ * Verify that lambdas are correctly called as callback of a 'foreach'
+ * function and that variables captured by the lambda work correctly. Also
+ * check that the foreach function handles exceptions thrown from
+ * the lambda and that it propagates the exception.
+ */
+static void test_foreach(isl::ctx ctx)
+{
+	isl::set s(ctx, "{ 0; 1; 2 }");
+
+	std::vector<isl::basic_set> basic_sets;
+
+	auto add_to_vector = & (isl::basic_set bs) {
+		basic_sets.push_back(bs);
+	};
+
+	s.foreach_basic_set(add_to_vector);
+
+	assert(basic_sets.size() == 3);
+	assert(isl::set(basic_sets0).is_subset(s));
+	assert(isl::set(basic_sets1).is_subset(s));
+	assert(isl::set(basic_sets2).is_subset(s));
+	assert(!basic_sets0.is_equal(basic_sets1));
+
+	auto fail = & (isl::basic_set bs) {
+		throw "fail";
+	};
+
+	bool caught = false;
+	try {
+		s.foreach_basic_set(fail);
+		die("no exception raised");
+	} catch (char const *s) {
+		caught = true;
+	}
+	assert(caught);
+}
+
+/* Test the functionality of "every" functions.
+ *
+ * In particular, test the generic functionality and
+ * test that exceptions are properly propagated.
+ */
+static void test_every(isl::ctx ctx)
+{
+	isl::union_set us(ctx, "{ Ai; Bj }");
+
+	test_every_generic(ctx);
+
+	auto fail =  (isl::set s) -> bool {
+		throw "fail";
+	};
+	bool caught = false;
+	try {
+		us.every_set(fail);
+		die("no exception raised");
+	} catch (char const *s) {
+		caught = true;
+	}
+	assert(caught);
+}
+
+/* Test that an exception is generated for an isl error and
+ * that the error message is captured by the exception.
+ * Also check that the exception can be copied and that copying
+ * does not throw any exceptions.
+ */
+static void test_exception(isl::ctx ctx)
+{
+	isl::multi_union_pw_aff mupa(ctx, "");
+	isl::exception copy;
+
+	static_assert(std::is_nothrow_copy_constructible<isl::exception>::value,
+		"exceptions must be nothrow-copy-constructible");
+	static_assert(std::is_nothrow_assignable<isl::exception,
+						isl::exception>::value,
+		"exceptions must be nothrow-assignable");
+
+	try {
+		auto umap = isl::union_map::from(mupa);
+	} catch (const isl::exception_unsupported &error) {
+		die("caught wrong exception");
+	} catch (const isl::exception &error) {
+		assert(strstr(error.what(), "without explicit domain"));
+		copy = error;
+	}
+	assert(strstr(copy.what(), "without explicit domain"));
+}
+
+/* Test basic schedule tree functionality.
+ *
+ * In particular, create a simple schedule tree and
+ * - perform some generic tests
+ * - test map_descendant_bottom_up in the failing case
+ * - test foreach_descendant_top_down
+ * - test every_descendant
+ */
+static void test_schedule_tree(isl::ctx ctx)
+{
+	auto root = test_schedule_tree_generic(ctx);
+
+	auto fail_map = (isl::schedule_node node) {
+		throw "fail";
+		return node;
+	};
+	auto caught = false;
+	try {
+		root.map_descendant_bottom_up(fail_map);
+		die("no exception raised");
+	} catch (char const *s) {
+		caught = true;
+	}
+	assert(caught);
+
+	int count = 0;
+	auto inc_count = &count(isl::schedule_node node) {
+		count++;
+		return true;
+	};
+	root.foreach_descendant_top_down(inc_count);
+	assert(count == 8);
+
+	count = 0;
+	auto inc_count_once = &count(isl::schedule_node node) {
+		count++;
+		return false;
+	};
+	root.foreach_descendant_top_down(inc_count_once);
+	assert(count == 1);
+
+	auto is_not_domain = (isl::schedule_node node) {
+		return !node.isa<isl::schedule_node_domain>();
+	};
+	assert(root.child(0).every_descendant(is_not_domain));
+	assert(!root.every_descendant(is_not_domain));
+
+	auto fail = (isl::schedule_node node) {
+		throw "fail";
+		return true;
+	};
+	caught = false;
+	try {
+		root.every_descendant(fail);
+		die("no exception raised");
+	} catch (char const *s) {
+		caught = true;
+	}
+	assert(caught);
+
+	auto domain = root.as<isl::schedule_node_domain>().domain();
+	auto filters = isl::union_set(ctx, "{}");
+	auto collect_filters = &filters(isl::schedule_node node) {
+		if (node.isa<isl::schedule_node_filter>()) {
+			auto filter = node.as<isl::schedule_node_filter>();
+			filters = filters.unite(filter.filter());
+		}
+		return true;
+	};
+	root.every_descendant(collect_filters);
+	assert(domain.is_equal(filters));
+}
+
+/* Test basic AST generation from a schedule tree.
+ *
+ * In particular, create a simple schedule tree and
+ * - perform some generic tests
+ * - test at_each_domain in the failing case
+ */
+static void test_ast_build(isl::ctx ctx)
+{
+	auto schedule = test_ast_build_generic(ctx);
+
+	bool do_fail = true;
+	int count_ast_fail = 0;
+	auto fail_inc_count_ast =
+	    &count_ast_fail, &do_fail(isl::ast_node node,
+					isl::ast_build build) {
+		count_ast_fail++;
+		if (do_fail)
+			throw "fail";
+		return node;
+	};
+	auto build = isl::ast_build(ctx);
+	build = build.set_at_each_domain(fail_inc_count_ast);
+	auto caught = false;
+	try {
+		auto ast = build.node_from(schedule);
+	} catch (char const *s) {
+		caught = true;
+	}
+	assert(caught);
+	assert(count_ast_fail > 0);
+	auto build_copy = build;
+	int count_ast = 0;
+	auto inc_count_ast =
+	    &count_ast(isl::ast_node node, isl::ast_build build) {
+		count_ast++;
+		return node;
+	};
+	build_copy = build_copy.set_at_each_domain(inc_count_ast);
+	auto ast = build_copy.node_from(schedule);
+	assert(count_ast == 2);
+	count_ast_fail = 0;
+	do_fail = false;
+	ast = build.node_from(schedule);
+	assert(count_ast_fail == 2);
+}
+
+/* Basic test of the templated interface.
+ *
+ * Intersecting the domain of an access relation
+ * with statement instances should be allowed,
+ * while intersecting the range with statement instances
+ * should result in a compile-time error.
+ */
+static void test_typed(isl::ctx ctx)
+{
+	struct ST {};
+	struct AR {};
+	isl::typed::map<ST, AR> access(ctx, "{ Si, j -> Ai }");
+	isl::typed::set<ST> instances(ctx, "{ Si, j : 0 <= i, j < 10 }");
+
+#ifndef COMPILE_ERROR
+	access.intersect_domain(instances);
+#else
+	access.intersect_range(instances);
+#endif
+}
+
+/* Test the (unchecked) isl C++ interface
+ *
+ * This includes:
+ *  - The isl C <-> C++ pointer interface
+ *  - Object construction
+ *  - Different parameter types
+ *  - Different return types
+ *  - Foreach functions
+ *  - Exceptions
+ *  - Spaces
+ *  - Schedule trees
+ *  - AST generation
+ *  - AST expression generation
+ *  - Templated interface
+ */
+int main()
+{
+	isl_ctx *ctx = isl_ctx_alloc();
+
+	isl_options_set_on_error(ctx, ISL_ON_ERROR_ABORT);
+
+	test_pointer(ctx);
+	test_constructors(ctx);
+	test_parameters(ctx);
+	test_return(ctx);
+	test_foreach(ctx);
+	test_every(ctx);
+	test_exception(ctx);
+	test_space(ctx);
+	test_schedule_tree(ctx);
+	test_ast_build(ctx);
+	test_ast_build_expr(ctx);
+	test_typed(ctx);
+
+	isl_ctx_free(ctx);
+
+	return EXIT_SUCCESS;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_cpp_failed.sh Added

_service:tar_scm:isl-0.24.tar.gz/isl_test_imath.c Added

@@ -0,0 +1,78 @@
+/*
+ * Copyright 2015 INRIA Paris-Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Michael Kruse, INRIA Paris-Rocquencourt,
+ * Domaine de Voluceau, Rocquenqourt, B.P. 105,
+ * 78153 Le Chesnay Cedex France
+ */
+
+#include <limits.h>
+#include <assert.h>
+#include <isl_imath.h>
+
+/* This constant is not defined in limits.h, but IMath uses it */
+#define ULONG_MIN 0ul
+
+/* Test the IMath internals assumed by the imath implementation of isl_int.
+ *
+ * In particular, we test the ranges of IMath-defined types.
+ *
+ * Also, isl uses the existence and function of imath's struct
+ * fields. The digits are stored with less significant digits at lower array
+ * indices. Where they are stored (on the heap or in the field 'single') does
+ * not matter.
+ */
+int test_imath_internals()
+{
+	mpz_t val;
+	mp_result retval;
+
+	assert(sizeof(mp_small) == sizeof(long));
+	assert(MP_SMALL_MIN == LONG_MIN);
+	assert(MP_SMALL_MAX == LONG_MAX);
+
+	assert(sizeof(mp_usmall) == sizeof(unsigned long));
+	assert(MP_USMALL_MAX == ULONG_MAX);
+
+	retval = mp_int_init_value(&val, 0);
+	assert(retval == MP_OK);
+	assert(val.alloc >= val.used);
+	assert(val.used == 1);
+	assert(val.sign == MP_ZPOS);
+	assert(val.digits0 == 0);
+
+	retval = mp_int_set_value(&val, -1);
+	assert(retval == MP_OK);
+	assert(val.alloc >= val.used);
+	assert(val.used == 1);
+	assert(val.sign == MP_NEG);
+	assert(val.digits0 == 1);
+
+	retval = mp_int_set_value(&val, 1);
+	assert(retval == MP_OK);
+	assert(val.alloc >= val.used);
+	assert(val.used == 1);
+	assert(val.sign == MP_ZPOS);
+	assert(val.digits0 == 1);
+
+	retval = mp_int_mul_pow2(&val, sizeof(mp_digit) * CHAR_BIT, &val);
+	assert(retval == MP_OK);
+	assert(val.alloc >= val.used);
+	assert(val.used == 2);
+	assert(val.sign == MP_ZPOS);
+	assert(val.digits0 == 0);
+	assert(val.digits1 == 1);
+
+	mp_int_clear(&val);
+	return 0;
+}
+
+int main()
+{
+	if (test_imath_internals() < 0)
+		return -1;
+
+	return 0;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_int.c Added

@@ -0,0 +1,669 @@
+/*
+ * Copyright 2015 INRIA Paris-Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Michael Kruse, INRIA Paris-Rocquencourt,
+ * Domaine de Voluceau, Rocquenqourt, B.P. 105,
+ * 78153 Le Chesnay Cedex France
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <isl_int.h>
+
+#define ARRAY_SIZE(array) (sizeof(array)/sizeof(*array))
+
+#ifdef USE_SMALL_INT_OPT
+/* Test whether small and big representation of the same number have the same
+ * hash.
+ */
+static void int_test_hash(isl_int val)
+{
+	uint32_t demotedhash, promotedhash;
+	isl_int demoted, promoted;
+
+	isl_int_init(demoted);
+	isl_int_set(demoted, val);
+
+	isl_int_init(promoted);
+	isl_int_set(promoted, val);
+
+	isl_sioimath_try_demote(demoted);
+	isl_sioimath_promote(promoted);
+
+	assert(isl_int_eq(demoted, promoted));
+
+	demotedhash = isl_int_hash(demoted, 0);
+	promotedhash = isl_int_hash(promoted, 0);
+	assert(demotedhash == promotedhash);
+
+	isl_int_clear(demoted);
+	isl_int_clear(promoted);
+}
+
+struct {
+	void (*fn)(isl_int);
+	char *val;
+} int_single_value_tests = {
+	{ &int_test_hash, "0" },
+	{ &int_test_hash, "1" },
+	{ &int_test_hash, "-1" },
+	{ &int_test_hash, "23" },
+	{ &int_test_hash, "-23" },
+	{ &int_test_hash, "107" },
+	{ &int_test_hash, "32768" },
+	{ &int_test_hash, "2147483647" },
+	{ &int_test_hash, "-2147483647" },
+	{ &int_test_hash, "2147483648" },
+	{ &int_test_hash, "-2147483648" },
+};
+
+static void int_test_single_value()
+{
+	int i;
+
+	for (i = 0; i < ARRAY_SIZE(int_single_value_tests); i += 1) {
+		isl_int val;
+
+		isl_int_init(val);
+		isl_int_read(val, int_single_value_testsi.val);
+
+		(*int_single_value_testsi.fn)(val);
+
+		isl_int_clear(val);
+	}
+}
+
+static void invoke_alternate_representations_2args(char *arg1, char *arg2,
+	void (*fn)(isl_int, isl_int))
+{
+	int j;
+	isl_int int1, int2;
+
+	isl_int_init(int1);
+	isl_int_init(int2);
+
+	for (j = 0; j < 4; ++j) {
+		isl_int_read(int1, arg1);
+		isl_int_read(int2, arg2);
+
+		if (j & 1)
+			isl_sioimath_promote(int1);
+		else
+			isl_sioimath_try_demote(int1);
+
+		if (j & 2)
+			isl_sioimath_promote(int2);
+		else
+			isl_sioimath_try_demote(int2);
+
+		(*fn)(int1, int2);
+	}
+
+	isl_int_clear(int1);
+	isl_int_clear(int2);
+}
+
+static void invoke_alternate_representations_3args(char *arg1, char *arg2,
+	char *arg3, void (*fn)(isl_int, isl_int, isl_int))
+{
+	int j;
+	isl_int int1, int2, int3;
+
+	isl_int_init(int1);
+	isl_int_init(int2);
+	isl_int_init(int3);
+
+	for (j = 0; j < 8; ++j) {
+		isl_int_read(int1, arg1);
+		isl_int_read(int2, arg2);
+		isl_int_read(int3, arg3);
+
+		if (j & 1)
+			isl_sioimath_promote(int1);
+		else
+			isl_sioimath_try_demote(int1);
+
+		if (j & 2)
+			isl_sioimath_promote(int2);
+		else
+			isl_sioimath_try_demote(int2);
+
+		if (j & 4)
+			isl_sioimath_promote(int3);
+		else
+			isl_sioimath_try_demote(int3);
+
+		(*fn)(int1, int2, int3);
+	}
+
+	isl_int_clear(int1);
+	isl_int_clear(int2);
+	isl_int_clear(int3);
+}
+#else  /* USE_SMALL_INT_OPT */
+
+static void int_test_single_value()
+{
+}
+
+static void invoke_alternate_representations_2args(char *arg1, char *arg2,
+	void (*fn)(isl_int, isl_int))
+{
+	isl_int int1, int2;
+
+	isl_int_init(int1);
+	isl_int_init(int2);
+
+	isl_int_read(int1, arg1);
+	isl_int_read(int2, arg2);
+
+	(*fn)(int1, int2);
+
+	isl_int_clear(int1);
+	isl_int_clear(int2);
+}
+
+static void invoke_alternate_representations_3args(char *arg1, char *arg2,
+	char *arg3, void (*fn)(isl_int, isl_int, isl_int))
+{
+	isl_int int1, int2, int3;
+
+	isl_int_init(int1);
+	isl_int_init(int2);
+	isl_int_init(int3);
+
+	isl_int_read(int1, arg1);
+	isl_int_read(int2, arg2);
+	isl_int_read(int3, arg3);
+
+	(*fn)(int1, int2, int3);
+
+	isl_int_clear(int1);
+	isl_int_clear(int2);
+	isl_int_clear(int3);
+}
+#endif /* USE_SMALL_INT_OPT */
+
+static void int_test_neg(isl_int expected, isl_int arg)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_neg(result, arg);
+	assert(isl_int_eq(result, expected));
+
+	isl_int_neg(result, expected);
+	assert(isl_int_eq(result, arg));
+
+	isl_int_clear(result);
+}
+
+static void int_test_abs(isl_int expected, isl_int arg)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_abs(result, arg);
+	assert(isl_int_eq(result, expected));
+
+	isl_int_clear(result);
+}
+
+struct {
+	void (*fn)(isl_int, isl_int);
+	char *expected, *arg;
+} int_unary_tests = {
+	{ &int_test_neg, "0", "0" },
+	{ &int_test_neg, "-1", "1" },
+	{ &int_test_neg, "-2147483647", "2147483647" },
+	{ &int_test_neg, "-2147483648", "2147483648" },
+	{ &int_test_neg, "-9223372036854775807", "9223372036854775807" },
+	{ &int_test_neg, "-9223372036854775808", "9223372036854775808" },
+
+	{ &int_test_abs, "0", "0" },
+	{ &int_test_abs, "1", "1" },
+	{ &int_test_abs, "1", "-1" },
+	{ &int_test_abs, "2147483647", "2147483647" },
+	{ &int_test_abs, "2147483648", "-2147483648" },
+	{ &int_test_abs, "9223372036854775807", "9223372036854775807" },
+	{ &int_test_abs, "9223372036854775808", "-9223372036854775808" },
+};
+
+static void int_test_divexact(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	unsigned long rhsulong;
+
+	if (isl_int_sgn(rhs) == 0)
+		return;
+
+	isl_int_init(result);
+
+	isl_int_divexact(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_tdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_fdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_cdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	if (isl_int_fits_ulong(rhs)) {
+		rhsulong = isl_int_get_ui(rhs);
+
+		isl_int_divexact_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+
+		isl_int_fdiv_q_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+
+		isl_int_cdiv_q_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+	}
+
+	isl_int_clear(result);
+}
+
+static void int_test_mul(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_mul(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	if (isl_int_fits_ulong(rhs)) {
+		unsigned long rhsulong = isl_int_get_ui(rhs);
+
+		isl_int_mul_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+	}
+
+	if (isl_int_fits_slong(rhs)) {
+		unsigned long rhsslong = isl_int_get_si(rhs);
+
+		isl_int_mul_si(result, lhs, rhsslong);
+		assert(isl_int_eq(expected, result));
+	}
+
+	isl_int_clear(result);
+}
+
+/* Use a triple that satisfies 'product = factor1 * factor2' to check the
+ * operations mul, divexact, tdiv, fdiv and cdiv.
+ */
+static void int_test_product(isl_int product, isl_int factor1, isl_int factor2)
+{
+	int_test_divexact(factor1, product, factor2);
+	int_test_divexact(factor2, product, factor1);
+
+	int_test_mul(product, factor1, factor2);
+	int_test_mul(product, factor2, factor1);
+}
+
+static void int_test_add(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_add(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+static void int_test_sub(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_sub(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+/* Use a triple that satisfies 'sum = term1 + term2' to check the operations add
+ * and sub.
+ */
+static void int_test_sum(isl_int sum, isl_int term1, isl_int term2)
+{
+	int_test_sub(term1, sum, term2);
+	int_test_sub(term2, sum, term1);
+
+	int_test_add(sum, term1, term2);
+	int_test_add(sum, term2, term1);
+}
+
+static void int_test_fdiv(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	unsigned long rhsulong;
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_fdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	if (isl_int_fits_ulong(rhs)) {
+		rhsulong = isl_int_get_ui(rhs);
+
+		isl_int_fdiv_q_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+	}
+
+	isl_int_clear(result);
+}
+
+static void int_test_cdiv(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	unsigned long rhsulong;
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_cdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	if (isl_int_fits_ulong(rhs)) {
+		rhsulong = isl_int_get_ui(rhs);
+
+		isl_int_cdiv_q_ui(result, lhs, rhsulong);
+		assert(isl_int_eq(expected, result));
+	}
+
+	isl_int_clear(result);
+}
+
+static void int_test_tdiv(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_tdiv_q(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+static void int_test_fdiv_r(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_fdiv_r(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+static void int_test_gcd(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_gcd(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_gcd(result, rhs, lhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+static void int_test_lcm(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	isl_int result;
+	isl_int_init(result);
+
+	isl_int_lcm(result, lhs, rhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_lcm(result, rhs, lhs);
+	assert(isl_int_eq(expected, result));
+
+	isl_int_clear(result);
+}
+
+static int sgn(int val)
+{
+	if (val > 0)
+		return 1;
+	if (val < 0)
+		return -1;
+	return 0;
+}
+
+static void int_test_cmp(int exp, isl_int lhs, isl_int rhs)
+{
+	long rhslong;
+
+	assert(exp == sgn(isl_int_cmp(lhs, rhs)));
+
+	if (isl_int_fits_slong(rhs)) {
+		rhslong = isl_int_get_si(rhs);
+		assert(exp == sgn(isl_int_cmp_si(lhs, rhslong)));
+	}
+}
+
+/* Test the comparison relations over two numbers.
+ * expected is the sign (1, 0 or -1) of 'lhs - rhs'.
+ */
+static void int_test_cmps(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	int exp;
+	isl_int diff;
+
+	exp = isl_int_get_si(expected);
+
+	isl_int_init(diff);
+	isl_int_sub(diff, lhs, rhs);
+	assert(exp == isl_int_sgn(diff));
+	isl_int_clear(diff);
+
+	int_test_cmp(exp, lhs, rhs);
+	int_test_cmp(-exp, rhs, lhs);
+}
+
+static void int_test_abs_cmp(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	int exp;
+
+	exp = isl_int_get_si(expected);
+	assert(exp == sgn(isl_int_abs_cmp(lhs, rhs)));
+	assert(-exp == sgn(isl_int_abs_cmp(rhs, lhs)));
+}
+
+/* If "expected" is equal to 1, then check that "rhs" divides "lhs".
+ * If "expected" is equal to 0, then check that "rhs" does not divide "lhs".
+ */
+static void int_test_divisible(isl_int expected, isl_int lhs, isl_int rhs)
+{
+	int exp;
+
+	exp = isl_int_get_si(expected);
+	assert(isl_int_is_divisible_by(lhs, rhs) == exp);
+}
+
+struct {
+	void (*fn)(isl_int, isl_int, isl_int);
+	char *expected, *lhs, *rhs;
+} int_binary_tests = {
+	{ &int_test_sum, "0", "0", "0" },
+	{ &int_test_sum, "1", "1", "0" },
+	{ &int_test_sum, "2", "1", "1" },
+	{ &int_test_sum, "-1", "0", "-1" },
+	{ &int_test_sum, "-2", "-1", "-1" },
+
+	{ &int_test_sum, "2147483647", "1073741823", "1073741824" },
+	{ &int_test_sum, "-2147483648", "-1073741824", "-1073741824" },
+
+	{ &int_test_sum, "2147483648", "2147483647", "1" },
+	{ &int_test_sum, "-2147483648", "-2147483647", "-1" },
+
+	{ &int_test_product, "0", "0", "0" },
+	{ &int_test_product, "0", "0", "1" },
+	{ &int_test_product, "1", "1", "1" },
+
+	{ &int_test_product, "6", "2", "3" },
+	{ &int_test_product, "-6", "2", "-3" },
+	{ &int_test_product, "-6", "-2", "3" },
+	{ &int_test_product, "6", "-2", "-3" },
+
+	{ &int_test_product, "2147483648", "65536", "32768" },
+	{ &int_test_product, "-2147483648", "65536", "-32768" },
+
+	{ &int_test_product,
+	  "4611686014132420609", "2147483647", "2147483647" },
+	{ &int_test_product,
+	  "-4611686014132420609", "-2147483647", "2147483647" },
+
+	{ &int_test_product,
+	  "4611686016279904256", "2147483647", "2147483648" },
+	{ &int_test_product,
+	  "-4611686016279904256", "-2147483647", "2147483648" },
+	{ &int_test_product,
+	  "-4611686016279904256", "2147483647", "-2147483648" },
+	{ &int_test_product,
+	  "4611686016279904256", "-2147483647", "-2147483648" },
+
+	{ &int_test_product, "85070591730234615847396907784232501249",
+	  "9223372036854775807", "9223372036854775807" },
+	{ &int_test_product, "-85070591730234615847396907784232501249",
+	  "-9223372036854775807", "9223372036854775807" },
+
+	{ &int_test_product, "85070591730234615856620279821087277056",
+	  "9223372036854775807", "9223372036854775808" },
+	{ &int_test_product, "-85070591730234615856620279821087277056",
+	  "-9223372036854775807", "9223372036854775808" },
+	{ &int_test_product, "-85070591730234615856620279821087277056",
+	  "9223372036854775807", "-9223372036854775808" },
+	{ &int_test_product, "85070591730234615856620279821087277056",
+	  "-9223372036854775807", "-9223372036854775808" },
+
+	{ &int_test_product, "340282366920938463426481119284349108225",
+	  "18446744073709551615", "18446744073709551615" },
+	{ &int_test_product, "-340282366920938463426481119284349108225",
+	  "-18446744073709551615", "18446744073709551615" },
+
+	{ &int_test_product, "340282366920938463444927863358058659840",
+	  "18446744073709551615", "18446744073709551616" },
+	{ &int_test_product, "-340282366920938463444927863358058659840",
+	  "-18446744073709551615", "18446744073709551616" },
+	{ &int_test_product, "-340282366920938463444927863358058659840",
+	  "18446744073709551615", "-18446744073709551616" },
+	{ &int_test_product, "340282366920938463444927863358058659840",
+	  "-18446744073709551615", "-18446744073709551616" },
+
+	{ &int_test_fdiv, "0", "1", "2" },
+	{ &int_test_fdiv_r, "1", "1", "3" },
+	{ &int_test_fdiv, "-1", "-1", "2" },
+	{ &int_test_fdiv_r, "2", "-1", "3" },
+	{ &int_test_fdiv, "-1", "1", "-2" },
+	{ &int_test_fdiv_r, "-2", "1", "-3" },
+	{ &int_test_fdiv, "0", "-1", "-2" },
+	{ &int_test_fdiv_r, "-1", "-1", "-3" },
+
+	{ &int_test_cdiv, "1", "1", "2" },
+	{ &int_test_cdiv, "0", "-1", "2" },
+	{ &int_test_cdiv, "0", "1", "-2" },
+	{ &int_test_cdiv, "1", "-1", "-2" },
+
+	{ &int_test_cdiv, "1073741824", "2147483647", "2" },
+	{ &int_test_cdiv, "1073741824", "2147483648", "2" },
+	{ &int_test_cdiv, "-1073741824", "-2147483648", "2" },
+	{ &int_test_cdiv, "-1073741823", "-2147483647", "2" },
+
+	{ &int_test_tdiv, "0", "1", "2" },
+	{ &int_test_tdiv, "0", "-1", "2" },
+	{ &int_test_tdiv, "0", "1", "-2" },
+	{ &int_test_tdiv, "0", "-1", "-2" },
+
+	{ &int_test_gcd, "0", "0", "0" },
+	{ &int_test_lcm, "0", "0", "0" },
+	{ &int_test_gcd, "7", "0", "7" },
+	{ &int_test_lcm, "0", "0", "7" },
+	{ &int_test_gcd, "1", "1", "1" },
+	{ &int_test_lcm, "1", "1", "1" },
+	{ &int_test_gcd, "1", "1", "-1" },
+	{ &int_test_lcm, "1", "1", "-1" },
+	{ &int_test_gcd, "1", "-1", "-1" },
+	{ &int_test_lcm, "1", "-1", "-1" },
+	{ &int_test_gcd, "3", "6", "9" },
+	{ &int_test_lcm, "18", "6", "9" },
+	{ &int_test_gcd, "1", "14", "2147483647" },
+	{ &int_test_lcm, "15032385529", "7", "2147483647" },
+	{ &int_test_gcd, "2", "6", "-2147483648" },
+	{ &int_test_lcm, "6442450944", "6", "-2147483648" },
+	{ &int_test_gcd, "1", "6", "9223372036854775807" },
+	{ &int_test_lcm, "55340232221128654842", "6", "9223372036854775807" },
+	{ &int_test_gcd, "2", "6", "-9223372036854775808" },
+	{ &int_test_lcm, "27670116110564327424", "6", "-9223372036854775808" },
+	{ &int_test_gcd, "1", "18446744073709551616", "18446744073709551615" },
+	{ &int_test_lcm, "340282366920938463444927863358058659840",
+	  "18446744073709551616", "18446744073709551615" },
+
+	{ &int_test_cmps, "0", "0", "0" },
+	{ &int_test_abs_cmp, "0", "0", "0" },
+	{ &int_test_cmps, "1", "1", "0" },
+	{ &int_test_abs_cmp, "1", "1", "0" },
+	{ &int_test_cmps, "-1", "-1", "0" },
+	{ &int_test_abs_cmp, "1", "-1", "0" },
+	{ &int_test_cmps, "-1", "-1", "1" },
+	{ &int_test_abs_cmp, "0", "-1", "1" },
+
+	{ &int_test_cmps, "-1", "5", "2147483647" },
+	{ &int_test_abs_cmp, "-1", "5", "2147483647" },
+	{ &int_test_cmps, "1", "5", "-2147483648" },
+	{ &int_test_abs_cmp, "-1", "5", "-2147483648" },
+	{ &int_test_cmps, "-1", "5", "9223372036854775807" },
+	{ &int_test_abs_cmp, "-1", "5", "9223372036854775807" },
+	{ &int_test_cmps, "1", "5", "-9223372036854775809" },
+	{ &int_test_abs_cmp, "-1", "5", "-9223372036854775809" },
+
+	{ &int_test_divisible, "1", "0", "0" },
+	{ &int_test_divisible, "0", "1", "0" },
+	{ &int_test_divisible, "0", "2", "0" },
+	{ &int_test_divisible, "0", "2147483647", "0" },
+	{ &int_test_divisible, "0", "9223372036854775807", "0" },
+	{ &int_test_divisible, "1", "0", "1" },
+	{ &int_test_divisible, "1", "1", "1" },
+	{ &int_test_divisible, "1", "2", "1" },
+	{ &int_test_divisible, "1", "2147483647", "1" },
+	{ &int_test_divisible, "1", "9223372036854775807", "1" },
+	{ &int_test_divisible, "1", "0", "2" },
+	{ &int_test_divisible, "0", "1", "2" },
+	{ &int_test_divisible, "1", "2", "2" },
+	{ &int_test_divisible, "0", "2147483647", "2" },
+	{ &int_test_divisible, "0", "9223372036854775807", "2" },
+};
+
+/* Tests the isl_int_* function to give the expected results. Tests are
+ * grouped by the number of arguments they take.
+ *
+ * If small integer optimization is enabled, we also test whether the results
+ * are the same in small and big representation.
+ */
+int main()
+{
+	int i;
+
+	int_test_single_value();
+
+	for (i = 0; i < ARRAY_SIZE(int_unary_tests); i += 1) {
+		invoke_alternate_representations_2args(
+		    int_unary_testsi.expected, int_unary_testsi.arg,
+		    int_unary_testsi.fn);
+	}
+
+	for (i = 0; i < ARRAY_SIZE(int_binary_tests); i += 1) {
+		invoke_alternate_representations_3args(
+		    int_binary_testsi.expected, int_binary_testsi.lhs,
+		    int_binary_testsi.rhs, int_binary_testsi.fn);
+	}
+
+	return 0;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_list_templ.c Added

@@ -0,0 +1,51 @@
+#define xCAT(A,B) A ## B
+#define CAT(A,B) xCAT(A,B)
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+#define xLIST(EL) EL ## _list
+#define LIST(EL) xLIST(EL)
+
+#undef SET
+#define SET	CAT(isl_,SET_BASE)
+#undef EL
+#define EL	CAT(isl_,EL_BASE)
+
+/* Check that the conversion from SET to list of EL works as expected,
+ * using input described by "str".
+ */
+static isl_stat FN(FN(FN(test_get_list,EL_BASE),from),SET_BASE)(isl_ctx *ctx,
+	const char *str)
+{
+	int i;
+	isl_size n;
+	isl_bool equal;
+	SET *set, *set2;
+	LIST(EL) *list;
+
+	set = FN(SET,read_from_str)(ctx, str);
+	list = FN(FN(SET,get),LIST(EL_BASE))(set);
+
+	set2 = FN(SET,empty)(FN(SET,get_space)(set));
+
+	n = FN(LIST(EL),size)(list);
+	for (i = 0; i < n; i++) {
+		EL *el;
+		el = FN(LIST(EL),get_at)(list, i);
+		set2 = FN(SET,union)(set2, FN(FN(SET,from),EL_BASE)(el));
+	}
+
+	equal = FN(SET,is_equal)(set, set2);
+
+	FN(SET,free)(set);
+	FN(SET,free)(set2);
+	FN(LIST(EL),free)(list);
+
+	if (n < 0 || equal < 0)
+		return isl_stat_error;
+
+	if (!equal)
+		isl_die(ctx, isl_error_unknown, "collections are not equal",
+			return isl_stat_error);
+
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_plain_equal_templ.c Added

@@ -0,0 +1,50 @@
+/*
+ * Copyright 2012      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege,
+ * Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#define xCAT(A,B) A ## B
+#define CAT(A,B) xCAT(A,B)
+#undef TYPE
+#define TYPE CAT(isl_,BASE)
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Is "obj" obviously equal to the object represented by "str"?
+ */
+static isl_bool FN(BASE,plain_is_equal)(__isl_keep TYPE *obj, const char *str)
+{
+	isl_ctx *ctx;
+	TYPE *obj2;
+	isl_bool equal;
+
+	if (!obj)
+		return isl_bool_error;
+
+	ctx = FN(TYPE,get_ctx)(obj);
+	obj2 = FN(TYPE,read_from_str)(ctx, str);
+	equal = FN(TYPE,plain_is_equal)(obj, obj2);
+	FN(TYPE,free)(obj2);
+
+	return equal;
+}
+
+/* Check that "obj" is obviously equal to the object represented by "str".
+ */
+static isl_stat FN(BASE,check_plain_equal)(__isl_keep TYPE *obj,
+	const char *str)
+{
+	isl_bool equal;
+
+	equal = FN(BASE,plain_is_equal)(obj, str);
+	if (equal < 0)
+		return isl_stat_error;
+	if (!equal)
+		isl_die(FN(TYPE,get_ctx)(obj), isl_error_unknown,
+			"result not as expected", return isl_stat_error);
+	return isl_stat_ok;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_test_python.py Added

@@ -0,0 +1,449 @@
+# Copyright 2016-2017 Tobias Grosser
+#
+# Use of this software is governed by the MIT license
+#
+# Written by Tobias Grosser, Weststrasse 47, CH-8003, Zurich
+
+import sys
+import isl
+
+# Test that isl objects can be constructed.
+#
+# This tests:
+#  - construction from a string
+#  - construction from an integer
+#  - static constructor without a parameter
+#  - conversion construction
+#  - construction of empty union set
+#
+#  The tests to construct from integers and strings cover functionality that
+#  is also tested in the parameter type tests, but here the presence of
+#  multiple overloaded constructors and overload resolution is tested.
+#
+def test_constructors():
+	zero1 = isl.val("0")
+	assert(zero1.is_zero())
+
+	zero2 = isl.val(0)
+	assert(zero2.is_zero())
+
+	zero3 = isl.val.zero()
+	assert(zero3.is_zero())
+
+	bs = isl.basic_set("{ 1 }")
+	result = isl.set("{ 1 }")
+	s = isl.set(bs)
+	assert(s.is_equal(result))
+
+	us = isl.union_set("{ A1; B2, 3 }")
+	empty = isl.union_set.empty()
+	assert(us.is_equal(us.union(empty)))
+
+# Test integer function parameters for a particular integer value.
+#
+def test_int(i):
+	val_int = isl.val(i)
+	val_str = isl.val(str(i))
+	assert(val_int.eq(val_str))
+
+# Test integer function parameters.
+#
+# Verify that extreme values and zero work.
+#
+def test_parameters_int():
+	test_int(sys.maxsize)
+	test_int(-sys.maxsize - 1)
+	test_int(0)
+
+# Test isl objects parameters.
+#
+# Verify that isl objects can be passed as lvalue and rvalue parameters.
+# Also verify that isl object parameters are automatically type converted if
+# there is an inheritance relation. Finally, test function calls without
+# any additional parameters, apart from the isl object on which
+# the method is called.
+#
+def test_parameters_obj():
+	a = isl.set("{ 0 }")
+	b = isl.set("{ 1 }")
+	c = isl.set("{ 2 }")
+	expected = isl.set("{ i : 0 <= i <= 2 }")
+
+	tmp = a.union(b)
+	res_lvalue_param = tmp.union(c)
+	assert(res_lvalue_param.is_equal(expected))
+
+	res_rvalue_param = a.union(b).union(c)
+	assert(res_rvalue_param.is_equal(expected))
+
+	a2 = isl.basic_set("{ 0 }")
+	assert(a.is_equal(a2))
+
+	two = isl.val(2)
+	half = isl.val("1/2")
+	res_only_this_param = two.inv()
+	assert(res_only_this_param.eq(half))
+
+# Test different kinds of parameters to be passed to functions.
+#
+# This includes integer and isl object parameters.
+#
+def test_parameters():
+	test_parameters_int()
+	test_parameters_obj()
+
+# Test that isl objects are returned correctly.
+#
+# This only tests that after combining two objects, the result is successfully
+# returned.
+#
+def test_return_obj():
+	one = isl.val("1")
+	two = isl.val("2")
+	three = isl.val("3")
+
+	res = one.add(two)
+
+	assert(res.eq(three))
+
+# Test that integer values are returned correctly.
+#
+def test_return_int():
+	one = isl.val("1")
+	neg_one = isl.val("-1")
+	zero = isl.val("0")
+
+	assert(one.sgn() > 0)
+	assert(neg_one.sgn() < 0)
+	assert(zero.sgn() == 0)
+
+# Test that isl_bool values are returned correctly.
+#
+# In particular, check the conversion to bool in case of true and false.
+#
+def test_return_bool():
+	empty = isl.set("{ : false }")
+	univ = isl.set("{ : }")
+
+	b_true = empty.is_empty()
+	b_false = univ.is_empty()
+
+	assert(b_true)
+	assert(not b_false)
+
+# Test that strings are returned correctly.
+# Do so by calling overloaded isl.ast_build.from_expr methods.
+#
+def test_return_string():
+	context = isl.set("n -> { : }")
+	build = isl.ast_build.from_context(context)
+	pw_aff = isl.pw_aff("n -> { n }")
+	set = isl.set("n -> { : n >= 0 }")
+
+	expr = build.expr_from(pw_aff)
+	expected_string = "n"
+	assert(expected_string == expr.to_C_str())
+
+	expr = build.expr_from(set)
+	expected_string = "n >= 0"
+	assert(expected_string == expr.to_C_str())
+
+# Test that return values are handled correctly.
+#
+# Test that isl objects, integers, boolean values, and strings are
+# returned correctly.
+#
+def test_return():
+	test_return_obj()
+	test_return_int()
+	test_return_bool()
+	test_return_string()
+
+# Test that foreach functions are modeled correctly.
+#
+# Verify that closures are correctly called as callback of a 'foreach'
+# function and that variables captured by the closure work correctly. Also
+# check that the foreach function handles exceptions thrown from
+# the closure and that it propagates the exception.
+#
+def test_foreach():
+	s = isl.set("{ 0; 1; 2 }")
+
+	list = 
+	def add(bs):
+		list.append(bs)
+	s.foreach_basic_set(add)
+
+	assert(len(list) == 3)
+	assert(list0.is_subset(s))
+	assert(list1.is_subset(s))
+	assert(list2.is_subset(s))
+	assert(not list0.is_equal(list1))
+	assert(not list0.is_equal(list2))
+	assert(not list1.is_equal(list2))
+
+	def fail(bs):
+		raise "fail"
+
+	caught = False
+	try:
+		s.foreach_basic_set(fail)
+	except:
+		caught = True
+	assert(caught)
+
+# Test the functionality of "every" functions.
+#
+# In particular, test the generic functionality and
+# test that exceptions are properly propagated.
+#
+def test_every():
+	us = isl.union_set("{ Ai; Bj }")
+
+	def is_empty(s):
+		return s.is_empty()
+	assert(not us.every_set(is_empty))
+
+	def is_non_empty(s):
+		return not s.is_empty()
+	assert(us.every_set(is_non_empty))
+
+	def in_A(s):
+		return s.is_subset(isl.set("{ Ax }"))
+	assert(not us.every_set(in_A))
+
+	def not_in_A(s):
+		return not s.is_subset(isl.set("{ Ax }"))
+	assert(not us.every_set(not_in_A))
+
+	def fail(s):
+		raise "fail"
+
+	caught = False
+	try:
+		us.ever_set(fail)
+	except:
+		caught = True
+	assert(caught)
+
+# Check basic construction of spaces.
+#
+def test_space():
+	unit = isl.space.unit()
+	set_space = unit.add_named_tuple("A", 3)
+	map_space = set_space.add_named_tuple("B", 2)
+
+	set = isl.set.universe(set_space)
+	map = isl.map.universe(map_space)
+	assert(set.is_equal(isl.set("{ A*,*,* }")))
+	assert(map.is_equal(isl.map("{ A*,*,* -> B*,* }")))
+
+# Construct a simple schedule tree with an outer sequence node and
+# a single-dimensional band node in each branch, with one of them
+# marked coincident.
+#
+def construct_schedule_tree():
+	A = isl.union_set("{ Ai : 0 <= i < 10 }")
+	B = isl.union_set("{ Bi : 0 <= i < 20 }")
+
+	node = isl.schedule_node.from_domain(A.union(B))
+	node = node.child(0)
+
+	filters = isl.union_set_list(A).add(B)
+	node = node.insert_sequence(filters)
+
+	f_A = isl.multi_union_pw_aff(" { Ai -> i } ")
+	node = node.child(0)
+	node = node.child(0)
+	node = node.insert_partial_schedule(f_A)
+	node = node.member_set_coincident(0, True)
+	node = node.ancestor(2)
+
+	f_B = isl.multi_union_pw_aff(" { Bi -> i } ")
+	node = node.child(1)
+	node = node.child(0)
+	node = node.insert_partial_schedule(f_B)
+	node = node.ancestor(2)
+
+	return node.schedule()
+
+# Test basic schedule tree functionality.
+#
+# In particular, create a simple schedule tree and
+# - check that the root node is a domain node
+# - test map_descendant_bottom_up
+# - test foreach_descendant_top_down
+# - test every_descendant
+#
+def test_schedule_tree():
+	schedule = construct_schedule_tree()
+	root = schedule.root()
+
+	assert(type(root) == isl.schedule_node_domain)
+
+	count = 0
+	def inc_count(node):
+		count0 += 1
+		return node
+	root = root.map_descendant_bottom_up(inc_count)
+	assert(count0 == 8)
+
+	def fail_map(node):
+		raise "fail"
+		return node
+	caught = False
+	try:
+		root.map_descendant_bottom_up(fail_map)
+	except:
+		caught = True
+	assert(caught)
+
+	count = 0
+	def inc_count(node):
+		count0 += 1
+		return True
+	root.foreach_descendant_top_down(inc_count)
+	assert(count0 == 8)
+
+	count = 0
+	def inc_count(node):
+		count0 += 1
+		return False
+	root.foreach_descendant_top_down(inc_count)
+	assert(count0 == 1)
+
+	def is_not_domain(node):
+		return type(node) != isl.schedule_node_domain
+	assert(root.child(0).every_descendant(is_not_domain))
+	assert(not root.every_descendant(is_not_domain))
+
+	def fail(node):
+		raise "fail"
+	caught = False
+	try:
+		root.every_descendant(fail)
+	except:
+		caught = True
+	assert(caught)
+
+	domain = root.domain()
+	filters = isl.union_set("{}")
+	def collect_filters(node):
+		if type(node) == isl.schedule_node_filter:
+			filters0 = filters0.union(node.filter())
+		return True
+	root.every_descendant(collect_filters)
+	assert(domain.is_equal(filters0))
+
+# Test marking band members for unrolling.
+# "schedule" is the schedule created by construct_schedule_tree.
+# It schedules two statements, with 10 and 20 instances, respectively.
+# Unrolling all band members therefore results in 30 at-domain calls
+# by the AST generator.
+#
+def test_ast_build_unroll(schedule):
+	root = schedule.root()
+	def mark_unroll(node):
+		if type(node) == isl.schedule_node_band:
+			node = node.member_set_ast_loop_unroll(0)
+		return node
+	root = root.map_descendant_bottom_up(mark_unroll)
+	schedule = root.schedule()
+
+	count_ast = 0
+	def inc_count_ast(node, build):
+		count_ast0 += 1
+		return node
+
+	build = isl.ast_build()
+	build = build.set_at_each_domain(inc_count_ast)
+	ast = build.node_from(schedule)
+	assert(count_ast0 == 30)
+
+# Test basic AST generation from a schedule tree.
+#
+# In particular, create a simple schedule tree and
+# - generate an AST from the schedule tree
+# - test at_each_domain
+# - test unrolling
+#
+def test_ast_build():
+	schedule = construct_schedule_tree()
+
+	count_ast = 0
+	def inc_count_ast(node, build):
+		count_ast0 += 1
+		return node
+
+	build = isl.ast_build()
+	build_copy = build.set_at_each_domain(inc_count_ast)
+	ast = build.node_from(schedule)
+	assert(count_ast0 == 0)
+	count_ast0 = 0
+	ast = build_copy.node_from(schedule)
+	assert(count_ast0 == 2)
+	build = build_copy
+	count_ast0 = 0
+	ast = build.node_from(schedule)
+	assert(count_ast0 == 2)
+
+	do_fail = True
+	count_ast_fail = 0
+	def fail_inc_count_ast(node, build):
+		count_ast_fail0 += 1
+		if do_fail:
+			raise "fail"
+		return node
+	build = isl.ast_build()
+	build = build.set_at_each_domain(fail_inc_count_ast)
+	caught = False
+	try:
+		ast = build.node_from(schedule)
+	except:
+		caught = True
+	assert(caught)
+	assert(count_ast_fail0 > 0)
+	build_copy = build
+	build_copy = build_copy.set_at_each_domain(inc_count_ast)
+	count_ast0 = 0
+	ast = build_copy.node_from(schedule)
+	assert(count_ast0 == 2)
+	count_ast_fail0 = 0
+	do_fail = False
+	ast = build.node_from(schedule)
+	assert(count_ast_fail0 == 2)
+
+	test_ast_build_unroll(schedule)
+
+# Test basic AST expression generation from an affine expression.
+#
+def test_ast_build_expr():
+	pa = isl.pw_aff("n -> { n + 1 }")
+	build = isl.ast_build.from_context(pa.domain())
+
+	op = build.expr_from(pa)
+	assert(type(op) == isl.ast_expr_op_add)
+	assert(op.n_arg() == 2)
+
+# Test the isl Python interface
+#
+# This includes:
+#  - Object construction
+#  - Different parameter types
+#  - Different return types
+#  - Foreach functions
+#  - Every functions
+#  - Spaces
+#  - Schedule trees
+#  - AST generation
+#  - AST expression generation
+#
+test_constructors()
+test_parameters()
+test_return()
+test_foreach()
+test_every()
+test_space()
+test_schedule_tree()
+test_ast_build()
+test_ast_build_expr()

_service:tar_scm:isl-0.14.tar.xz/isl_transitive_closure.c -> _service:tar_scm:isl-0.24.tar.gz/isl_transitive_closure.c Changed

@@ -20,10 +20,10 @@
 #include <isl_options_private.h>
 #include <isl_tarjan.h>
 
-int isl_map_is_transitively_closed(__isl_keep isl_map *map)
+isl_bool isl_map_is_transitively_closed(__isl_keep isl_map *map)
 {
 	isl_map *map2;
-	int closed;
+	isl_bool closed;
 
 	map2 = isl_map_apply_range(isl_map_copy(map), isl_map_copy(map));
 	closed = isl_map_is_subset(map2, map);
@@ -32,10 +32,10 @@
 	return closed;
 }
 
-int isl_union_map_is_transitively_closed(__isl_keep isl_union_map *umap)
+isl_bool isl_union_map_is_transitively_closed(__isl_keep isl_union_map *umap)
 {
 	isl_union_map *umap2;
-	int closed;
+	isl_bool closed;
 
 	umap2 = isl_union_map_apply_range(isl_union_map_copy(umap),
 					  isl_union_map_copy(umap));
@@ -54,30 +54,36 @@
 static __isl_give isl_map *set_path_length(__isl_take isl_map *map,
 	int exactly, int length)
 {
-	isl_space *dim;
+	isl_space *space;
 	struct isl_basic_map *bmap;
-	unsigned d;
-	unsigned nparam;
+	isl_size d;
+	isl_size nparam;
+	isl_size total;
 	int k;
 	isl_int *c;
 
 	if (!map)
 		return NULL;
 
-	dim = isl_map_get_space(map);
-	d = isl_space_dim(dim, isl_dim_in);
-	nparam = isl_space_dim(dim, isl_dim_param);
-	bmap = isl_basic_map_alloc_space(dim, 0, 1, 1);
+	space = isl_map_get_space(map);
+	d = isl_space_dim(space, isl_dim_in);
+	nparam = isl_space_dim(space, isl_dim_param);
+	total = isl_space_dim(space, isl_dim_all);
+	if (d < 0 || nparam < 0 || total < 0)
+		space = isl_space_free(space);
+	bmap = isl_basic_map_alloc_space(space, 0, 1, 1);
 	if (exactly) {
 		k = isl_basic_map_alloc_equality(bmap);
+		if (k < 0)
+			goto error;
 		c = bmap->eqk;
 	} else {
 		k = isl_basic_map_alloc_inequality(bmap);
+		if (k < 0)
+			goto error;
 		c = bmap->ineqk;
 	}
-	if (k < 0)
-		goto error;
-	isl_seq_clr(c, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(c, 1 + total);
 	isl_int_set_si(c0, -length);
 	isl_int_set_si(c1 + nparam + d - 1, -1);
 	isl_int_set_si(c1 + nparam + d + d - 1, 1);
@@ -109,10 +115,10 @@
  * this coordinate to "map" and set the length of the path to
  * one.
  */
-static int check_power_exactness(__isl_take isl_map *map,
+static isl_bool check_power_exactness(__isl_take isl_map *map,
 	__isl_take isl_map *app)
 {
-	int exact;
+	isl_bool exact;
 	isl_map *app_1;
 	isl_map *app_2;
 
@@ -164,17 +170,19 @@
  * the length of the part.  If we are only interested in the transitive
  * closure, then we can simply project out these coordinates first.
  */
-static int check_exactness(__isl_take isl_map *map, __isl_take isl_map *app,
-	int project)
+static isl_bool check_exactness(__isl_take isl_map *map,
+	__isl_take isl_map *app, int project)
 {
 	isl_map *test;
-	int exact;
-	unsigned d;
+	isl_bool exact;
+	isl_size d;
 
 	if (!project)
 		return check_power_exactness(map, app);
 
 	d = isl_map_dim(map, isl_dim_in);
+	if (d < 0)
+		app = isl_map_free(app);
 	app = set_path_length(app, 0, 1);
 	app = isl_map_project_out(app, isl_dim_in, d, 1);
 	app = isl_map_project_out(app, isl_dim_out, d, 1);
@@ -213,23 +221,24 @@
  * For any element in this relation, the number of steps taken
  * is equal to the difference in the final coordinates.
  */
-static __isl_give isl_map *path_along_steps(__isl_take isl_space *dim,
+static __isl_give isl_map *path_along_steps(__isl_take isl_space *space,
 	__isl_keep isl_mat *steps)
 {
 	int i, j, k;
 	struct isl_basic_map *path = NULL;
-	unsigned d;
+	isl_size d;
 	unsigned n;
-	unsigned nparam;
+	isl_size nparam;
+	isl_size total;
 
-	if (!dim || !steps)
+	d = isl_space_dim(space, isl_dim_in);
+	nparam = isl_space_dim(space, isl_dim_param);
+	if (d < 0 || nparam < 0 || !steps)
 		goto error;
 
-	d = isl_space_dim(dim, isl_dim_in);
 	n = steps->n_row;
-	nparam = isl_space_dim(dim, isl_dim_param);
 
-	path = isl_basic_map_alloc_space(isl_space_copy(dim), n, d, n);
+	path = isl_basic_map_alloc_space(isl_space_copy(space), n, d, n);
 
 	for (i = 0; i < n; ++i) {
 		k = isl_basic_map_alloc_div(path);
@@ -239,11 +248,14 @@
 		isl_int_set_si(path->divk0, 0);
 	}
 
+	total = isl_basic_map_dim(path, isl_dim_all);
+	if (total < 0)
+		goto error;
 	for (i = 0; i < d; ++i) {
 		k = isl_basic_map_alloc_equality(path);
 		if (k < 0)
 			goto error;
-		isl_seq_clr(path->eqk, 1 + isl_basic_map_total_dim(path));
+		isl_seq_clr(path->eqk, 1 + total);
 		isl_int_set_si(path->eqk1 + nparam + i, 1);
 		isl_int_set_si(path->eqk1 + nparam + d + i, -1);
 		if (i == d - 1)
@@ -259,17 +271,17 @@
 		k = isl_basic_map_alloc_inequality(path);
 		if (k < 0)
 			goto error;
-		isl_seq_clr(path->ineqk, 1 + isl_basic_map_total_dim(path));
+		isl_seq_clr(path->ineqk, 1 + total);
 		isl_int_set_si(path->ineqk1 + nparam + 2 * d + i, 1);
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 
 	path = isl_basic_map_simplify(path);
 	path = isl_basic_map_finalize(path);
 	return isl_map_from_basic_map(path);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_basic_map_free(path);
 	return NULL;
 }
@@ -282,19 +294,23 @@
 /* Check whether the parametric constant term of constraint c is never
  * positive in "bset".
  */
-static int parametric_constant_never_positive(__isl_keep isl_basic_set *bset,
-	isl_int *c, int *div_purity)
+static isl_bool parametric_constant_never_positive(
+	__isl_keep isl_basic_set *bset, isl_int *c, int *div_purity)
 {
-	unsigned d;
-	unsigned n_div;
-	unsigned nparam;
+	isl_size d;
+	isl_size n_div;
+	isl_size nparam;
+	isl_size total;
 	int i;
 	int k;
-	int empty;
+	isl_bool empty;
 
 	n_div = isl_basic_set_dim(bset, isl_dim_div);
 	d = isl_basic_set_dim(bset, isl_dim_set);
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (n_div < 0 || d < 0 || nparam < 0 || total < 0)
+		return isl_bool_error;
 
 	bset = isl_basic_set_copy(bset);
 	bset = isl_basic_set_cow(bset);
@@ -302,7 +318,7 @@
 	k = isl_basic_set_alloc_inequality(bset);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(bset->ineqk, 1 + isl_basic_set_total_dim(bset));
+	isl_seq_clr(bset->ineqk, 1 + total);
 	isl_seq_cpy(bset->ineqk, c, 1 + nparam);
 	for (i = 0; i < n_div; ++i) {
 		if (div_purityi != PURE_PARAM)
@@ -317,7 +333,7 @@
 	return empty;
 error:
 	isl_basic_set_free(bset);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Return PURE_PARAM if only the coefficients of the parameters are non-zero.
@@ -330,16 +346,18 @@
 static int purity(__isl_keep isl_basic_set *bset, isl_int *c, int *div_purity,
 	int eq)
 {
-	unsigned d;
-	unsigned n_div;
-	unsigned nparam;
-	int empty;
+	isl_size d;
+	isl_size n_div;
+	isl_size nparam;
+	isl_bool empty;
 	int i;
 	int p = 0, v = 0;
 
 	n_div = isl_basic_set_dim(bset, isl_dim_div);
 	d = isl_basic_set_dim(bset, isl_dim_set);
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (n_div < 0 || d < 0 || nparam < 0)
+		return -1;
 
 	for (i = 0; i < n_div; ++i) {
 		if (isl_int_is_zero(c1 + nparam + d + i))
@@ -375,16 +393,15 @@
 {
 	int i, j;
 	int *div_purity;
-	unsigned d;
-	unsigned n_div;
-	unsigned nparam;
-
-	if (!bset)
-		return NULL;
+	isl_size d;
+	isl_size n_div;
+	isl_size nparam;
 
 	n_div = isl_basic_set_dim(bset, isl_dim_div);
 	d = isl_basic_set_dim(bset, isl_dim_set);
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (n_div < 0 || d < 0 || nparam < 0)
+		return NULL;
 
 	div_purity = isl_alloc_array(bset->ctx, int, n_div);
 	if (n_div && !div_purity)
@@ -415,32 +432,24 @@
 	return div_purity;
 }
 
-/* Given a path with the as yet unconstrained length at position "pos",
+/* Given a path with the as yet unconstrained length at div position "pos",
  * check if setting the length to zero results in only the identity
  * mapping.
  */
-static int empty_path_is_identity(__isl_keep isl_basic_map *path, unsigned pos)
+static isl_bool empty_path_is_identity(__isl_keep isl_basic_map *path,
+	unsigned pos)
 {
 	isl_basic_map *test = NULL;
 	isl_basic_map *id = NULL;
-	int k;
-	int is_id;
+	isl_bool is_id;
 
 	test = isl_basic_map_copy(path);
-	test = isl_basic_map_extend_constraints(test, 1, 0);
-	k = isl_basic_map_alloc_equality(test);
-	if (k < 0)
-		goto error;
-	isl_seq_clr(test->eqk, 1 + isl_basic_map_total_dim(test));
-	isl_int_set_si(test->eqkpos, 1);
+	test = isl_basic_map_fix_si(test, isl_dim_div, pos, 0);
 	id = isl_basic_map_identity(isl_basic_map_get_space(path));
 	is_id = isl_basic_map_is_equal(test, id);
 	isl_basic_map_free(test);
 	isl_basic_map_free(id);
 	return is_id;
-error:
-	isl_basic_map_free(test);
-	return -1;
 }
 
 /* If any of the constraints is found to be impure then this function
@@ -457,9 +466,12 @@
 	int i, k;
 	int n = eq ? delta->n_eq : delta->n_ineq;
 	isl_int **delta_c = eq ? delta->eq : delta->ineq;
-	unsigned n_div;
+	isl_size n_div, total;
 
 	n_div = isl_basic_set_dim(delta, isl_dim_div);
+	total = isl_basic_map_dim(path, isl_dim_all);
+	if (n_div < 0 || total < 0)
+		return isl_basic_map_free(path);
 
 	for (i = 0; i < n; ++i) {
 		isl_int *path_c;
@@ -474,14 +486,16 @@
 			continue;
 		if (eq && p != MIXED) {
 			k = isl_basic_map_alloc_equality(path);
+			if (k < 0)
+				goto error;
 			path_c = path->eqk;
 		} else {
 			k = isl_basic_map_alloc_inequality(path);
+			if (k < 0)
+				goto error;
 			path_c = path->ineqk;
 		}
-		if (k < 0)
-			goto error;
-		isl_seq_clr(path_c, 1 + isl_basic_map_total_dim(path));
+		isl_seq_clr(path_c, 1 + total);
 		if (p == PURE_VAR) {
 			isl_seq_cpy(path_c + off,
 				    delta_ci + 1 + nparam, d);
@@ -558,25 +572,26 @@
  *
  * to the constructed relation.
  */
-static __isl_give isl_map *path_along_delta(__isl_take isl_space *dim,
+static __isl_give isl_map *path_along_delta(__isl_take isl_space *space,
 	__isl_take isl_basic_set *delta)
 {
 	isl_basic_map *path = NULL;
-	unsigned d;
-	unsigned n_div;
-	unsigned nparam;
+	isl_size d;
+	isl_size n_div;
+	isl_size nparam;
+	isl_size total;
 	unsigned off;
 	int i, k;
-	int is_id;
+	isl_bool is_id;
 	int *div_purity = NULL;
 	int impurity = 0;
 
-	if (!delta)
-		goto error;
 	n_div = isl_basic_set_dim(delta, isl_dim_div);
 	d = isl_basic_set_dim(delta, isl_dim_set);
 	nparam = isl_basic_set_dim(delta, isl_dim_param);
-	path = isl_basic_map_alloc_space(isl_space_copy(dim), n_div + d + 1,
+	if (n_div < 0 || d < 0 || nparam < 0)
+		goto error;
+	path = isl_basic_map_alloc_space(isl_space_copy(space), n_div + d + 1,
 			d + 1 + delta->n_eq, delta->n_eq + delta->n_ineq + 1);
 	off = 1 + nparam + 2 * (d + 1) + n_div;
 
@@ -587,11 +602,14 @@
 		isl_int_set_si(path->divk0, 0);
 	}
 
+	total = isl_basic_map_dim(path, isl_dim_all);
+	if (total < 0)
+		goto error;
 	for (i = 0; i < d + 1; ++i) {
 		k = isl_basic_map_alloc_equality(path);
 		if (k < 0)
 			goto error;
-		isl_seq_clr(path->eqk, 1 + isl_basic_map_total_dim(path));
+		isl_seq_clr(path->eqk, 1 + total);
 		isl_int_set_si(path->eqk1 + nparam + i, 1);
 		isl_int_set_si(path->eqk1 + nparam + d + 1 + i, -1);
 		isl_int_set_si(path->eqkoff + i, 1);
@@ -606,11 +624,11 @@
 	path = add_delta_constraints(path, delta, off, nparam, d,
 				     div_purity, 0, &impurity);
 	if (impurity) {
-		isl_space *dim = isl_basic_set_get_space(delta);
+		isl_space *space = isl_basic_set_get_space(delta);
 		delta = isl_basic_set_project_out(delta,
 						  isl_dim_param, 0, nparam);
 		delta = isl_basic_set_add_dims(delta, isl_dim_param, nparam);
-		delta = isl_basic_set_reset_space(delta, dim);
+		delta = isl_basic_set_reset_space(delta, space);
 		if (!delta)
 			goto error;
 		path = isl_basic_map_extend_constraints(path, delta->n_eq,
@@ -622,14 +640,14 @@
 		path = isl_basic_map_gauss(path, NULL);
 	}
 
-	is_id = empty_path_is_identity(path, off + d);
+	is_id = empty_path_is_identity(path, n_div + d);
 	if (is_id < 0)
 		goto error;
 
 	k = isl_basic_map_alloc_inequality(path);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(path->ineqk, 1 + isl_basic_map_total_dim(path));
+	isl_seq_clr(path->ineqk, 1 + total);
 	if (!is_id)
 		isl_int_set_si(path->ineqk0, -1);
 	isl_int_set_si(path->ineqkoff + d, 1);
@@ -638,13 +656,13 @@
 	isl_basic_set_free(delta);
 	path = isl_basic_map_finalize(path);
 	if (is_id) {
-		isl_space_free(dim);
+		isl_space_free(space);
 		return isl_map_from_basic_map(path);
 	}
-	return isl_basic_map_union(path, isl_basic_map_identity(dim));
+	return isl_basic_map_union(path, isl_basic_map_identity(space));
 error:
 	free(div_purity);
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_basic_set_free(delta);
 	isl_basic_map_free(path);
 	return NULL;
@@ -657,21 +675,25 @@
  *
  *	{ x,x_s -> y,y_s : k = y_s - x_s > 0 }
  */
-static __isl_give isl_map *equate_parameter_to_length(__isl_take isl_space *dim,
-	unsigned param)
+static __isl_give isl_map *equate_parameter_to_length(
+	__isl_take isl_space *space, unsigned param)
 {
 	struct isl_basic_map *bmap;
-	unsigned d;
-	unsigned nparam;
+	isl_size d;
+	isl_size nparam;
+	isl_size total;
 	int k;
 
-	d = isl_space_dim(dim, isl_dim_in);
-	nparam = isl_space_dim(dim, isl_dim_param);
-	bmap = isl_basic_map_alloc_space(dim, 0, 1, 1);
+	d = isl_space_dim(space, isl_dim_in);
+	nparam = isl_space_dim(space, isl_dim_param);
+	total = isl_space_dim(space, isl_dim_all);
+	if (d < 0 || nparam < 0 || total < 0)
+		space = isl_space_free(space);
+	bmap = isl_basic_map_alloc_space(space, 0, 1, 1);
 	k = isl_basic_map_alloc_equality(bmap);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(bmap->eqk, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->eqk, 1 + total);
 	isl_int_set_si(bmap->eqk1 + param, -1);
 	isl_int_set_si(bmap->eqk1 + nparam + d - 1, -1);
 	isl_int_set_si(bmap->eqk1 + nparam + d + d - 1, 1);
@@ -679,7 +701,7 @@
 	k = isl_basic_map_alloc_inequality(bmap);
 	if (k < 0)
 		goto error;
-	isl_seq_clr(bmap->ineqk, 1 + isl_basic_map_total_dim(bmap));
+	isl_seq_clr(bmap->ineqk, 1 + total);
 	isl_int_set_si(bmap->ineqk1 + param, 1);
 	isl_int_set_si(bmap->ineqk0, -1);
 
@@ -699,15 +721,17 @@
  * does not contain any element with positive last coordinate (positive length)
  * and zero remaining coordinates (cycle).
  */
-static int is_acyclic(__isl_take isl_map *path)
+static isl_bool is_acyclic(__isl_take isl_map *path)
 {
 	int i;
-	int acyclic;
-	unsigned dim;
+	isl_bool acyclic;
+	isl_size dim;
 	struct isl_set *delta;
 
 	delta = isl_map_deltas(path);
 	dim = isl_set_dim(delta, isl_dim_set);
+	if (dim < 0)
+		delta = isl_set_free(delta);
 	for (i = 0; i < dim; ++i) {
 		if (i == dim -1)
 			delta = isl_set_lower_bound_si(delta, isl_dim_set, i, 1);
@@ -746,17 +770,19 @@
  * Since each of these paths performs an addition, composition is
  * symmetric and we can simply compose all resulting paths in any order.
  */
-static __isl_give isl_map *construct_extended_path(__isl_take isl_space *dim,
+static __isl_give isl_map *construct_extended_path(__isl_take isl_space *space,
 	__isl_keep isl_map *map, int *project)
 {
 	struct isl_mat *steps = NULL;
 	struct isl_map *path = NULL;
-	unsigned d;
+	isl_size d;
 	int i, j, n;
 
 	d = isl_map_dim(map, isl_dim_in);
+	if (d < 0)
+		goto error;
 
-	path = isl_map_identity(isl_space_copy(dim));
+	path = isl_map_identity(isl_space_copy(space));
 
 	steps = isl_mat_alloc(map->ctx, map->n, d);
 	if (!steps)
@@ -769,7 +795,7 @@
 		delta = isl_basic_map_deltas(isl_basic_map_copy(map->pi));
 
 		for (j = 0; j < d; ++j) {
-			int fixed;
+			isl_bool fixed;
 
 			fixed = isl_basic_set_plain_dim_is_fixed(delta, j,
 							    &steps->rownj);
@@ -784,7 +810,7 @@
 
 		if (j < d) {
 			path = isl_map_apply_range(path,
-				path_along_delta(isl_space_copy(dim), delta));
+				path_along_delta(isl_space_copy(space), delta));
 			path = isl_map_coalesce(path);
 		} else {
 			isl_basic_set_free(delta);
@@ -795,7 +821,7 @@
 	if (n > 0) {
 		steps->n_row = n;
 		path = isl_map_apply_range(path,
-				path_along_steps(isl_space_copy(dim), steps));
+				path_along_steps(isl_space_copy(space), steps));
 	}
 
 	if (project && *project) {
@@ -804,30 +830,20 @@
 			goto error;
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(steps);
 	return path;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_mat_free(steps);
 	isl_map_free(path);
 	return NULL;
 }
 
-static int isl_set_overlaps(__isl_keep isl_set *set1, __isl_keep isl_set *set2)
+static isl_bool isl_set_overlaps(__isl_keep isl_set *set1,
+	__isl_keep isl_set *set2)
 {
-	isl_set *i;
-	int no_overlap;
-
-	if (!isl_space_tuple_is_equal(set1->dim, isl_dim_set,
-					set2->dim, isl_dim_set))
-		return 0;
-
-	i = isl_set_intersect(isl_set_copy(set1), isl_set_copy(set2));
-	no_overlap = isl_set_is_empty(i);
-	isl_set_free(i);
-
-	return no_overlap < 0 ? -1 : !no_overlap;
+	return isl_bool_not(isl_set_is_disjoint(set1, set2));
 }
 
 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
@@ -849,23 +865,28 @@
  *				x in dom R and x + d in ran R and
  *				\sum_i k_i >= 1 }
  */
-static __isl_give isl_map *construct_component(__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project)
+static __isl_give isl_map *construct_component(__isl_take isl_space *space,
+	__isl_keep isl_map *map, isl_bool *exact, int project)
 {
 	struct isl_set *domain = NULL;
 	struct isl_set *range = NULL;
 	struct isl_map *app = NULL;
 	struct isl_map *path = NULL;
+	isl_bool overlaps;
+	int check;
 
 	domain = isl_map_domain(isl_map_copy(map));
 	domain = isl_set_coalesce(domain);
 	range = isl_map_range(isl_map_copy(map));
 	range = isl_set_coalesce(range);
-	if (!isl_set_overlaps(domain, range)) {
+	overlaps = isl_set_overlaps(domain, range);
+	if (overlaps < 0 || !overlaps) {
 		isl_set_free(domain);
 		isl_set_free(range);
-		isl_space_free(dim);
+		isl_space_free(space);
 
+		if (overlaps < 0)
+			map = NULL;
 		map = isl_map_copy(map);
 		map = isl_map_add_dims(map, isl_dim_in, 1);
 		map = isl_map_add_dims(map, isl_dim_out, 1);
@@ -876,20 +897,21 @@
 	app = isl_map_add_dims(app, isl_dim_in, 1);
 	app = isl_map_add_dims(app, isl_dim_out, 1);
 
-	path = construct_extended_path(isl_space_copy(dim), map,
-					exact && *exact ? &project : NULL);
+	check = exact && *exact == isl_bool_true;
+	path = construct_extended_path(isl_space_copy(space), map,
+					check ? &project : NULL);
 	app = isl_map_intersect(app, path);
 
-	if (exact && *exact &&
+	if (check &&
 	    (*exact = check_exactness(isl_map_copy(map), isl_map_copy(app),
 				      project)) < 0)
 		goto error;
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	app = set_path_length(app, 0, 1);
 	return app;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_map_free(app);
 	return NULL;
 }
@@ -898,17 +920,17 @@
  * the final coordinates.
  */
 static __isl_give isl_map *construct_projected_component(
-	__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project)
+	__isl_take isl_space *space,
+	__isl_keep isl_map *map, isl_bool *exact, int project)
 {
 	isl_map *app;
 	unsigned d;
 
-	if (!dim)
+	if (!space)
 		return NULL;
-	d = isl_space_dim(dim, isl_dim_in);
+	d = isl_space_dim(space, isl_dim_in);
 
-	app = construct_component(dim, map, exact, project);
+	app = construct_component(space, map, exact, project);
 	if (project) {
 		app = isl_map_project_out(app, isl_dim_in, d - 1, 1);
 		app = isl_map_project_out(app, isl_dim_out, d - 1, 1);
@@ -921,8 +943,9 @@
  * with path lengths greater than or equal to zero and with
  * domain and range equal to "dom".
  */
-static __isl_give isl_map *q_closure(__isl_take isl_space *dim,
-	__isl_take isl_set *dom, __isl_keep isl_basic_map *bmap, int *exact)
+static __isl_give isl_map *q_closure(__isl_take isl_space *space,
+	__isl_take isl_set *dom, __isl_keep isl_basic_map *bmap,
+	isl_bool *exact)
 {
 	int project = 1;
 	isl_map *path;
@@ -932,7 +955,7 @@
 	dom = isl_set_add_dims(dom, isl_dim_set, 1);
 	app = isl_map_from_domain_and_range(dom, isl_set_copy(dom));
 	map = isl_map_from_basic_map(isl_basic_map_copy(bmap));
-	path = construct_extended_path(dim, map, &project);
+	path = construct_extended_path(space, map, &project);
 	app = isl_map_intersect(app, path);
 
 	if ((*exact = check_exactness(map, isl_map_copy(app), project)) < 0)
@@ -947,17 +970,16 @@
 /* Check whether qc has any elements of length at least one
  * with domain and/or range outside of dom and ran.
  */
-static int has_spurious_elements(__isl_keep isl_map *qc,
+static isl_bool has_spurious_elements(__isl_keep isl_map *qc,
 	__isl_keep isl_set *dom, __isl_keep isl_set *ran)
 {
 	isl_set *s;
-	int subset;
-	unsigned d;
-
-	if (!qc || !dom || !ran)
-		return -1;
+	isl_bool subset;
+	isl_size d;
 
 	d = isl_map_dim(qc, isl_dim_in);
+	if (d < 0 || !dom || !ran)
+		return isl_bool_error;
 
 	qc = isl_map_copy(qc);
 	qc = set_path_length(qc, 0, 1);
@@ -971,17 +993,17 @@
 		goto error;
 	if (!subset) {
 		isl_map_free(qc);
-		return 1;
+		return isl_bool_true;
 	}
 
 	s = isl_map_range(qc);
 	subset = isl_set_is_subset(s, ran);
 	isl_set_free(s);
 
-	return subset < 0 ? -1 : !subset;
+	return isl_bool_not(subset);
 error:
 	isl_map_free(qc);
-	return -1;
+	return isl_bool_error;
 }
 
 #define LEFT	2
@@ -1025,7 +1047,7 @@
 
 	ok = LEFT | RIGHT;
 	for (j = 0; j < map->n && ok; ++j) {
-		int overlaps, subset;
+		isl_bool overlaps, subset;
 		if (j == i)
 			continue;
 
@@ -1136,8 +1158,8 @@
  * depending on whether left or right are NULL.
  */
 static __isl_give isl_map *compute_incremental(
-	__isl_take isl_space *dim, __isl_keep isl_map *map,
-	int i, __isl_take isl_map *qc, int *left, int *right, int *exact)
+	__isl_take isl_space *space, __isl_keep isl_map *map,
+	int i, __isl_take isl_map *qc, int *left, int *right, isl_bool *exact)
 {
 	isl_map *map_i;
 	isl_map *tc;
@@ -1148,7 +1170,7 @@
 	isl_assert(map->ctx, left || right, goto error);
 
 	map_i = isl_map_from_basic_map(isl_basic_map_copy(map->pi));
-	tc = construct_projected_component(isl_space_copy(dim), map_i,
+	tc = construct_projected_component(isl_space_copy(space), map_i,
 						exact, 1);
 	isl_map_free(map_i);
 
@@ -1156,7 +1178,7 @@
 		qc = isl_map_transitive_closure(qc, exact);
 
 	if (!*exact) {
-		isl_space_free(dim);
+		isl_space_free(space);
 		isl_map_free(tc);
 		isl_map_free(qc);
 		return isl_map_universe(isl_map_get_space(map));
@@ -1171,11 +1193,11 @@
 		qc = isl_map_apply_range(qc, rtc);
 	qc = isl_map_union(tc, qc);
 
-	isl_space_free(dim);
+	isl_space_free(space);
 
 	return qc;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_map_free(qc);
 	return NULL;
 }
@@ -1195,38 +1217,41 @@
  * after computing the integer divisions, is smaller than the number
  * of basic maps in the input map.
  */
-static int incemental_on_entire_domain(__isl_keep isl_space *dim,
+static isl_bool incremental_on_entire_domain(__isl_keep isl_space *space,
 	__isl_keep isl_map *map,
 	isl_set **dom, isl_set **ran, int *left, int *right,
 	__isl_give isl_map **res)
 {
 	int i;
 	isl_set *C;
-	unsigned d;
+	isl_size d;
 
 	*res = NULL;
 
+	d = isl_map_dim(map, isl_dim_in);
+	if (d < 0)
+		return isl_bool_error;
+
 	C = isl_set_union(isl_map_domain(isl_map_copy(map)),
 			  isl_map_range(isl_map_copy(map)));
 	C = isl_set_from_basic_set(isl_set_simple_hull(C));
 	if (!C)
-		return -1;
+		return isl_bool_error;
 	if (C->n != 1) {
 		isl_set_free(C);
-		return 0;
+		return isl_bool_false;
 	}
 
-	d = isl_map_dim(map, isl_dim_in);
-
 	for (i = 0; i < map->n; ++i) {
 		isl_map *qc;
-		int exact_i, spurious;
+		isl_bool exact_i;
+		isl_bool spurious;
 		int j;
 		domi = isl_set_from_basic_set(isl_basic_map_domain(
 					isl_basic_map_copy(map->pi)));
 		rani = isl_set_from_basic_set(isl_basic_map_range(
 					isl_basic_map_copy(map->pi)));
-		qc = q_closure(isl_space_copy(dim), isl_set_copy(C),
+		qc = q_closure(isl_space_copy(space), isl_set_copy(C),
 				map->pi, &exact_i);
 		if (!qc)
 			goto error;
@@ -1253,7 +1278,7 @@
 			isl_map_free(qc);
 			continue;
 		}
-		*res = compute_incremental(isl_space_copy(dim), map, i, qc,
+		*res = compute_incremental(isl_space_copy(space), map, i, qc,
 				left, right, &exact_i);
 		if (!*res)
 			goto error;
@@ -1265,10 +1290,10 @@
 
 	isl_set_free(C);
 
-	return *res != NULL;
+	return isl_bool_ok(*res != NULL);
 error:
 	isl_set_free(C);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Try and compute the transitive closure of "map" as
@@ -1279,8 +1304,8 @@
  * with C either the simple hull of the domain and range of the entire
  * map or the simple hull of domain and range of map_i.
  */
-static __isl_give isl_map *incremental_closure(__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project)
+static __isl_give isl_map *incremental_closure(__isl_take isl_space *space,
+	__isl_keep isl_map *map, isl_bool *exact, int project)
 {
 	int i;
 	isl_set **dom = NULL;
@@ -1288,18 +1313,22 @@
 	int *left = NULL;
 	int *right = NULL;
 	isl_set *C;
-	unsigned d;
+	isl_size d;
 	isl_map *res = NULL;
 
 	if (!project)
-		return construct_projected_component(dim, map, exact, project);
+		return construct_projected_component(space, map, exact,
+							project);
 
 	if (!map)
 		goto error;
 	if (map->n <= 1)
-		return construct_projected_component(dim, map, exact, project);
+		return construct_projected_component(space, map, exact,
+							project);
 
 	d = isl_map_dim(map, isl_dim_in);
+	if (d < 0)
+		goto error;
 
 	dom = isl_calloc_array(map->ctx, isl_set *, map->n);
 	ran = isl_calloc_array(map->ctx, isl_set *, map->n);
@@ -1308,12 +1337,14 @@
 	if (!ran || !dom || !left || !right)
 		goto error;
 
-	if (incemental_on_entire_domain(dim, map, dom, ran, left, right, &res) < 0)
+	if (incremental_on_entire_domain(space, map, dom, ran, left, right,
+					&res) < 0)
 		goto error;
 
 	for (i = 0; !res && i < map->n; ++i) {
 		isl_map *qc;
-		int exact_i, spurious, comp;
+		int comp;
+		isl_bool exact_i, spurious;
 		if (!domi)
 			domi = isl_set_from_basic_set(
 					isl_basic_map_domain(
@@ -1342,7 +1373,7 @@
 				goto error;
 			continue;
 		}
-		qc = q_closure(isl_space_copy(dim), C, map->pi, &exact_i);
+		qc = q_closure(isl_space_copy(space), C, map->pi, &exact_i);
 		if (!qc)
 			goto error;
 		if (!exact_i) {
@@ -1367,7 +1398,7 @@
 			isl_map_free(qc);
 			continue;
 		}
-		res = compute_incremental(isl_space_copy(dim), map, i, qc,
+		res = compute_incremental(isl_space_copy(space), map, i, qc,
 				(comp & LEFT) ? left : NULL,
 				(comp & RIGHT) ? right : NULL, &exact_i);
 		if (!res)
@@ -1388,11 +1419,11 @@
 	free(right);
 
 	if (res) {
-		isl_space_free(dim);
+		isl_space_free(space);
 		return res;
 	}
 
-	return construct_projected_component(dim, map, exact, project);
+	return construct_projected_component(space, map, exact, project);
 error:
 	if (dom)
 		for (i = 0; i < map->n; ++i)
@@ -1404,7 +1435,7 @@
 	free(ran);
 	free(left);
 	free(right);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -1425,7 +1456,7 @@
 	setpos = isl_set_copy(dom);
 
 	for (i = pos - 1; i >= 0; --i) {
-		int o;
+		isl_bool o;
 
 		if (groupi != i)
 			continue;
@@ -1451,38 +1482,46 @@
 	return -1;
 }
 
+/* Construct a map x -> x+1, with parameters prescribed by "space".
+ */
+static __isl_give isl_map *increment(__isl_take isl_space *space)
+{
+	int k;
+	isl_basic_map *bmap;
+	isl_size total;
+
+	space = isl_space_set_from_params(space);
+	space = isl_space_add_dims(space, isl_dim_set, 1);
+	space = isl_space_map_from_set(space);
+	bmap = isl_basic_map_alloc_space(space, 0, 1, 0);
+	total = isl_basic_map_dim(bmap, isl_dim_all);
+	k = isl_basic_map_alloc_equality(bmap);
+	if (total < 0 || k < 0)
+		goto error;
+	isl_seq_clr(bmap->eqk, 1 + total);
+	isl_int_set_si(bmap->eqk0, 1);
+	isl_int_set_si(bmap->eqkisl_basic_map_offset(bmap, isl_dim_in), 1);
+	isl_int_set_si(bmap->eqkisl_basic_map_offset(bmap, isl_dim_out), -1);
+	return isl_map_from_basic_map(bmap);
+error:
+	isl_basic_map_free(bmap);
+	return NULL;
+}
+
 /* Replace each entry in the n by n grid of maps by the cross product
  * with the relation { i -> i + 1 }.
  */
-static int add_length(__isl_keep isl_map *map, isl_map ***grid, int n)
+static isl_stat add_length(__isl_keep isl_map *map, isl_map ***grid, int n)
 {
-	int i, j, k;
-	isl_space *dim;
-	isl_basic_map *bstep;
+	int i, j;
+	isl_space *space;
 	isl_map *step;
-	unsigned nparam;
 
-	if (!map)
-		return -1;
+	space = isl_space_params(isl_map_get_space(map));
+	step = increment(space);
 
-	dim = isl_map_get_space(map);
-	nparam = isl_space_dim(dim, isl_dim_param);
-	dim = isl_space_drop_dims(dim, isl_dim_in, 0, isl_space_dim(dim, isl_dim_in));
-	dim = isl_space_drop_dims(dim, isl_dim_out, 0, isl_space_dim(dim, isl_dim_out));
-	dim = isl_space_add_dims(dim, isl_dim_in, 1);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	bstep = isl_basic_map_alloc_space(dim, 0, 1, 0);
-	k = isl_basic_map_alloc_equality(bstep);
-	if (k < 0) {
-		isl_basic_map_free(bstep);
-		return -1;
-	}
-	isl_seq_clr(bstep->eqk, 1 + isl_basic_map_total_dim(bstep));
-	isl_int_set_si(bstep->eqk0, 1);
-	isl_int_set_si(bstep->eqk1 + nparam, 1);
-	isl_int_set_si(bstep->eqk1 + nparam + 1, -1);
-	bstep = isl_basic_map_finalize(bstep);
-	step = isl_map_from_basic_map(bstep);
+	if (!step)
+		return isl_stat_error;
 
 	for (i = 0; i < n; ++i)
 		for (j = 0; j < n; ++j)
@@ -1491,7 +1530,7 @@
 
 	isl_map_free(step);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* The core of the Floyd-Warshall algorithm.
@@ -1505,16 +1544,17 @@
  * transitive closure to account for all indirect paths that stay
  * in the current vertex.
  */
-static void floyd_warshall_iterate(isl_map ***grid, int n, int *exact)
+static void floyd_warshall_iterate(isl_map ***grid, int n, isl_bool *exact)
 {
 	int r, p, q;
 
 	for (r = 0; r < n; ++r) {
-		int r_exact;
+		isl_bool r_exact;
+		int check = exact && *exact == isl_bool_true;
 		gridrr = isl_map_transitive_closure(gridrr,
-				(exact && *exact) ? &r_exact : NULL);
-		if (exact && *exact && !r_exact)
-			*exact = 0;
+				check ? &r_exact : NULL);
+		if (check && !r_exact)
+			*exact = isl_bool_false;
 
 		for (p = 0; p < n; ++p)
 			for (q = 0; q < n; ++q) {
@@ -1555,8 +1595,9 @@
  * the input relation by the cross product with the unit length relation
  * { i -> i + 1 }.
  */
-static __isl_give isl_map *floyd_warshall_with_groups(__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project, int *group, int n)
+static __isl_give isl_map *floyd_warshall_with_groups(
+	__isl_take isl_space *space, __isl_keep isl_map *map,
+	isl_bool *exact, int project, int *group, int n)
 {
 	int i, j, k;
 	isl_map ***grid = NULL;
@@ -1567,7 +1608,7 @@
 
 	if (n == 1) {
 		free(group);
-		return incremental_closure(dim, map, exact, project);
+		return incremental_closure(space, map, exact, project);
 	}
 
 	grid = isl_calloc_array(map->ctx, isl_map **, n);
@@ -1594,7 +1635,7 @@
 
 	floyd_warshall_iterate(grid, n, exact);
 
-	app = isl_map_empty(isl_map_get_space(map));
+	app = isl_map_empty(isl_map_get_space(grid00));
 
 	for (i = 0; i < n; ++i) {
 		for (j = 0; j < n; ++j)
@@ -1604,7 +1645,7 @@
 	free(grid);
 
 	free(group);
-	isl_space_free(dim);
+	isl_space_free(space);
 
 	return app;
 error:
@@ -1618,7 +1659,7 @@
 		}
 	free(grid);
 	free(group);
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -1694,8 +1735,8 @@
  * calls inside the Floyd-Warshall algorithm typically result in
  * non-linear path lengths quite quickly.
  */
-static __isl_give isl_map *floyd_warshall(__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project)
+static __isl_give isl_map *floyd_warshall(__isl_take isl_space *space,
+	__isl_keep isl_map *map, isl_bool *exact, int project)
 {
 	int i;
 	isl_set **set = NULL;
@@ -1705,7 +1746,7 @@
 	if (!map)
 		goto error;
 	if (map->n <= 1)
-		return incremental_closure(dim, map, exact, project);
+		return incremental_closure(space, map, exact, project);
 
 	group = setup_groups(map->ctx, map->p, map->n, &set, &n);
 	if (!group)
@@ -1716,9 +1757,9 @@
 
 	free(set);
 
-	return floyd_warshall_with_groups(dim, map, exact, project, group, n);
+	return floyd_warshall_with_groups(space, map, exact, project, group, n);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
@@ -1752,16 +1793,18 @@
  * *check_closed is set if the subset relation holds while
  * R_1 \circ R_2 is not empty.
  */
-static int basic_map_follows(int i, int j, void *user)
+static isl_bool basic_map_follows(int i, int j, void *user)
 {
 	struct isl_tc_follows_data *data = user;
 	struct isl_map *map12 = NULL;
 	struct isl_map *map21 = NULL;
-	int subset;
+	isl_bool applies, subset;
 
-	if (!isl_space_tuple_is_equal(data->listi->dim, isl_dim_in,
-				    data->listj->dim, isl_dim_out))
-		return 0;
+	applies = isl_basic_map_applies_range(data->listj, data->listi);
+	if (applies < 0)
+		return isl_bool_error;
+	if (!applies)
+		return isl_bool_false;
 
 	map21 = isl_map_from_basic_map(
 			isl_basic_map_apply_range(
@@ -1772,15 +1815,13 @@
 		goto error;
 	if (subset) {
 		isl_map_free(map21);
-		return 0;
+		return isl_bool_false;
 	}
 
-	if (!isl_space_tuple_is_equal(data->listi->dim, isl_dim_in,
-				    data->listi->dim, isl_dim_out) ||
-	    !isl_space_tuple_is_equal(data->listj->dim, isl_dim_in,
-				    data->listj->dim, isl_dim_out)) {
+	if (!isl_basic_map_is_transformation(data->listi) ||
+	    !isl_basic_map_is_transformation(data->listj)) {
 		isl_map_free(map21);
-		return 1;
+		return isl_bool_true;
 	}
 
 	map12 = isl_map_from_basic_map(
@@ -1796,10 +1837,10 @@
 	if (subset)
 		data->check_closed = 1;
 
-	return subset < 0 ? -1 : !subset;
+	return isl_bool_not(subset);
 error:
 	isl_map_free(map21);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Given a union of basic maps R = \cup_i R_i \subseteq D \times D
@@ -1835,20 +1876,21 @@
  * order, at each join also taking in the union of both arguments
  * to allow for paths that do not go through one of the two arguments.
  */
-static __isl_give isl_map *construct_power_components(__isl_take isl_space *dim,
-	__isl_keep isl_map *map, int *exact, int project)
+static __isl_give isl_map *construct_power_components(
+	__isl_take isl_space *space, __isl_keep isl_map *map, isl_bool *exact,
+	int project)
 {
 	int i, n, c;
 	struct isl_map *path = NULL;
 	struct isl_tc_follows_data data;
 	struct isl_tarjan_graph *g = NULL;
-	int *orig_exact;
-	int local_exact;
+	isl_bool *orig_exact;
+	isl_bool local_exact;
 
 	if (!map)
 		goto error;
 	if (map->n <= 1)
-		return floyd_warshall(dim, map, exact, project);
+		return floyd_warshall(space, map, exact, project);
 
 	data.list = map->p;
 	data.check_closed = 0;
@@ -1866,7 +1908,7 @@
 	if (project)
 		path = isl_map_empty(isl_map_get_space(map));
 	else
-		path = isl_map_empty(isl_space_copy(dim));
+		path = isl_map_empty(isl_space_copy(space));
 	path = anonymize(path);
 	while (n) {
 		struct isl_map *comp;
@@ -1878,7 +1920,7 @@
 			--n;
 			++i;
 		}
-		path_comp = floyd_warshall(isl_space_copy(dim),
+		path_comp = floyd_warshall(isl_space_copy(space),
 						comp, exact, project);
 		path_comp = anonymize(path_comp);
 		path_comb = isl_map_apply_range(isl_map_copy(path),
@@ -1891,7 +1933,7 @@
 	}
 
 	if (c > 1 && data.check_closed && !*exact) {
-		int closed;
+		isl_bool closed;
 
 		closed = isl_map_is_transitively_closed(path);
 		if (closed < 0)
@@ -1899,17 +1941,17 @@
 		if (!closed) {
 			isl_tarjan_graph_free(g);
 			isl_map_free(path);
-			return floyd_warshall(dim, map, orig_exact, project);
+			return floyd_warshall(space, map, orig_exact, project);
 		}
 	}
 
 	isl_tarjan_graph_free(g);
-	isl_space_free(dim);
+	isl_space_free(space);
 
 	return path;
 error:
 	isl_tarjan_graph_free(g);
-	isl_space_free(dim);
+	isl_space_free(space);
 	isl_map_free(path);
 	return NULL;
 }
@@ -1944,25 +1986,23 @@
  * image element(s).
  */
 static __isl_give isl_map *construct_power(__isl_keep isl_map *map,
-	int *exact, int project)
+	isl_bool *exact, int project)
 {
 	struct isl_map *app = NULL;
-	isl_space *dim = NULL;
-	unsigned d;
+	isl_space *space = NULL;
 
 	if (!map)
 		return NULL;
 
-	dim = isl_map_get_space(map);
+	space = isl_map_get_space(map);
 
-	d = isl_space_dim(dim, isl_dim_in);
-	dim = isl_space_add_dims(dim, isl_dim_in, 1);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
+	space = isl_space_add_dims(space, isl_dim_in, 1);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
 
-	app = construct_power_components(isl_space_copy(dim), map,
+	app = construct_power_components(isl_space_copy(space), map,
 					exact, project);
 
-	isl_space_free(dim);
+	isl_space_free(space);
 
 	return app;
 }
@@ -1976,28 +2016,20 @@
  * encoded as the difference between an extra pair of final coordinates.
  */
 static __isl_give isl_map *map_power(__isl_take isl_map *map,
-	int *exact, int project)
+	isl_bool *exact, int project)
 {
 	struct isl_map *app = NULL;
 
 	if (exact)
-		*exact = 1;
-
-	if (!map)
-		return NULL;
+		*exact = isl_bool_true;
 
-	isl_assert(map->ctx,
-		isl_map_dim(map, isl_dim_in) == isl_map_dim(map, isl_dim_out),
-		goto error);
+	if (isl_map_check_transformation(map) < 0)
+		return isl_map_free(map);
 
 	app = construct_power(map, exact, project);
 
 	isl_map_free(map);
 	return app;
-error:
-	isl_map_free(map);
-	isl_map_free(app);
-	return NULL;
 }
 
 /* Compute the positive powers of "map", or an overapproximation.
@@ -2009,19 +2041,18 @@
  * and made positive.  The extra coordinates are subsequently projected out
  * and the parameter is turned into the domain of the result.
  */
-__isl_give isl_map *isl_map_power(__isl_take isl_map *map, int *exact)
+__isl_give isl_map *isl_map_power(__isl_take isl_map *map, isl_bool *exact)
 {
-	isl_space *target_dim;
-	isl_space *dim;
+	isl_space *target_space;
+	isl_space *space;
 	isl_map *diff;
-	unsigned d;
-	unsigned param;
-
-	if (!map)
-		return NULL;
+	isl_size d;
+	isl_size param;
 
 	d = isl_map_dim(map, isl_dim_in);
 	param = isl_map_dim(map, isl_dim_param);
+	if (d < 0 || param < 0)
+		return isl_map_free(map);
 
 	map = isl_map_compute_divs(map);
 	map = isl_map_coalesce(map);
@@ -2033,23 +2064,23 @@
 		return map;
 	}
 
-	target_dim = isl_map_get_space(map);
-	target_dim = isl_space_from_range(isl_space_wrap(target_dim));
-	target_dim = isl_space_add_dims(target_dim, isl_dim_in, 1);
-	target_dim = isl_space_set_dim_name(target_dim, isl_dim_in, 0, "k");
+	target_space = isl_map_get_space(map);
+	target_space = isl_space_from_range(isl_space_wrap(target_space));
+	target_space = isl_space_add_dims(target_space, isl_dim_in, 1);
+	target_space = isl_space_set_dim_name(target_space, isl_dim_in, 0, "k");
 
 	map = map_power(map, exact, 0);
 
 	map = isl_map_add_dims(map, isl_dim_param, 1);
-	dim = isl_map_get_space(map);
-	diff = equate_parameter_to_length(dim, param);
+	space = isl_map_get_space(map);
+	diff = equate_parameter_to_length(space, param);
 	map = isl_map_intersect(map, diff);
 	map = isl_map_project_out(map, isl_dim_in, d, 1);
 	map = isl_map_project_out(map, isl_dim_out, d, 1);
 	map = isl_map_from_range(isl_map_wrap(map));
 	map = isl_map_move_dims(map, isl_dim_in, 0, isl_dim_param, param, 1);
 
-	map = isl_map_reset_space(map, target_dim);
+	map = isl_map_reset_space(map, target_space);
 
 	return map;
 }
@@ -2064,25 +2095,24 @@
  * of a parameter.
  */
 __isl_give isl_map *isl_map_reaching_path_lengths(__isl_take isl_map *map,
-	int *exact)
+	isl_bool *exact)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_map *diff;
-	unsigned d;
-	unsigned param;
-
-	if (!map)
-		return NULL;
+	isl_size d;
+	isl_size param;
 
 	d = isl_map_dim(map, isl_dim_in);
 	param = isl_map_dim(map, isl_dim_param);
+	if (d < 0 || param < 0)
+		return isl_map_free(map);
 
 	map = isl_map_compute_divs(map);
 	map = isl_map_coalesce(map);
 
 	if (isl_map_plain_is_empty(map)) {
 		if (exact)
-			*exact = 1;
+			*exact = isl_bool_true;
 		map = isl_map_project_out(map, isl_dim_out, 0, d);
 		map = isl_map_add_dims(map, isl_dim_out, 1);
 		return map;
@@ -2091,8 +2121,8 @@
 	map = map_power(map, exact, 0);
 
 	map = isl_map_add_dims(map, isl_dim_param, 1);
-	dim = isl_map_get_space(map);
-	diff = equate_parameter_to_length(dim, param);
+	space = isl_map_get_space(map);
+	diff = equate_parameter_to_length(space, param);
 	map = isl_map_intersect(map, diff);
 	map = isl_map_project_out(map, isl_dim_in, 0, d + 1);
 	map = isl_map_project_out(map, isl_dim_out, d, 1);
@@ -2102,53 +2132,6 @@
 	return map;
 }
 
-/* Check whether equality i of bset is a pure stride constraint
- * on a single dimensions, i.e., of the form
- *
- *	v = k e
- *
- * with k a constant and e an existentially quantified variable.
- */
-static int is_eq_stride(__isl_keep isl_basic_set *bset, int i)
-{
-	unsigned nparam;
-	unsigned d;
-	unsigned n_div;
-	int pos1;
-	int pos2;
-
-	if (!bset)
-		return -1;
-
-	if (!isl_int_is_zero(bset->eqi0))
-		return 0;
-
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-	d = isl_basic_set_dim(bset, isl_dim_set);
-	n_div = isl_basic_set_dim(bset, isl_dim_div);
-
-	if (isl_seq_first_non_zero(bset->eqi + 1, nparam) != -1)
-		return 0;
-	pos1 = isl_seq_first_non_zero(bset->eqi + 1 + nparam, d);
-	if (pos1 == -1)
-		return 0;
-	if (isl_seq_first_non_zero(bset->eqi + 1 + nparam + pos1 + 1, 
-					d - pos1 - 1) != -1)
-		return 0;
-
-	pos2 = isl_seq_first_non_zero(bset->eqi + 1 + nparam + d, n_div);
-	if (pos2 == -1)
-		return 0;
-	if (isl_seq_first_non_zero(bset->eqi + 1 + nparam + d  + pos2 + 1,
-				   n_div - pos2 - 1) != -1)
-		return 0;
-	if (!isl_int_is_one(bset->eqi1 + nparam + pos1) &&
-	    !isl_int_is_negone(bset->eqi1 + nparam + pos1))
-		return 0;
-
-	return 1;
-}
-
 /* Given a map, compute the smallest superset of this map that is of the form
  *
  *	{ i -> j : L <= j - i <= U and exists a_p: j_p - i_p = M_p a_p }
@@ -2186,7 +2169,7 @@
 	unsigned d;
 	unsigned nparam;
 	unsigned total;
-	isl_space *dim;
+	isl_space *space;
 	isl_set *delta;
 	isl_map *app = NULL;
 	isl_basic_set *aff = NULL;
@@ -2201,11 +2184,11 @@
 	aff = isl_set_affine_hull(isl_set_copy(delta));
 	if (!aff)
 		goto error;
-	dim = isl_map_get_space(map);
-	d = isl_space_dim(dim, isl_dim_in);
-	nparam = isl_space_dim(dim, isl_dim_param);
-	total = isl_space_dim(dim, isl_dim_all);
-	bmap = isl_basic_map_alloc_space(dim,
+	space = isl_map_get_space(map);
+	d = isl_space_dim(space, isl_dim_in);
+	nparam = isl_space_dim(space, isl_dim_param);
+	total = isl_space_dim(space, isl_dim_all);
+	bmap = isl_basic_map_alloc_space(space,
 					aff->n_div + 1, aff->n_div, 2 * d + 1);
 	for (i = 0; i < aff->n_div + 1; ++i) {
 		k = isl_basic_map_alloc_div(bmap);
@@ -2214,7 +2197,7 @@
 		isl_int_set_si(bmap->divk0, 0);
 	}
 	for (i = 0; i < aff->n_eq; ++i) {
-		if (!is_eq_stride(aff, i))
+		if (!isl_basic_set_eq_is_stride(aff, i))
 			continue;
 		k = isl_basic_map_alloc_equality(bmap);
 		if (k < 0)
@@ -2354,25 +2337,25 @@
  *
  *	app \subset (map \cup (map \circ app))
  */
-static int check_exactness_omega(__isl_keep isl_map *map,
+static isl_bool check_exactness_omega(__isl_keep isl_map *map,
 	__isl_keep isl_map *app)
 {
 	isl_set *delta;
 	int i;
-	int is_empty, is_exact;
-	unsigned d;
+	isl_bool is_empty, is_exact;
+	isl_size d;
 	isl_map *test;
 
 	delta = isl_map_deltas(isl_map_copy(app));
 	d = isl_set_dim(delta, isl_dim_set);
+	if (d < 0)
+		delta = isl_set_free(delta);
 	for (i = 0; i < d; ++i)
 		delta = isl_set_fix_si(delta, isl_dim_set, i, 0);
 	is_empty = isl_set_is_empty(delta);
 	isl_set_free(delta);
-	if (is_empty < 0)
-		return -1;
-	if (!is_empty)
-		return 0;
+	if (is_empty < 0 || !is_empty)
+		return is_empty;
 
 	test = isl_map_apply_range(isl_map_copy(app), isl_map_copy(map));
 	test = isl_map_union(test, isl_map_copy(map));
@@ -2477,13 +2460,19 @@
 }
 
 static __isl_give isl_map *box_closure_with_check(__isl_take isl_map *map,
-	int *exact)
+	isl_bool *exact)
 {
 	isl_map *app;
 
 	app = box_closure(isl_map_copy(map));
-	if (exact)
-		*exact = check_exactness_omega(map, app);
+	if (exact) {
+		isl_bool is_exact = check_exactness_omega(map, app);
+
+		if (is_exact < 0)
+			app = isl_map_free(app);
+		else
+			*exact = is_exact;
+	}
 
 	isl_map_free(map);
 	return app;
@@ -2508,10 +2497,10 @@
  * If not, we simply call box_closure on the whole map.
  */
 static __isl_give isl_map *transitive_closure_omega(__isl_take isl_map *map,
-	int *exact)
+	isl_bool *exact)
 {
 	int i, j;
-	int exact_i;
+	isl_bool exact_i;
 	isl_map *app;
 
 	if (!map)
@@ -2542,7 +2531,7 @@
 
 		app = isl_map_union(tc, transitive_closure_omega(app, NULL));
 		exact_i = check_exactness_omega(map, app);
-		if (exact_i == 1) {
+		if (exact_i == isl_bool_true) {
 			if (exact)
 				*exact = exact_i;
 			isl_map_free(map);
@@ -2566,10 +2555,10 @@
  * the length to a parameter.
  */
 __isl_give isl_map *isl_map_transitive_closure(__isl_take isl_map *map,
-	int *exact)
+	isl_bool *exact)
 {
 	isl_space *target_dim;
-	int closed;
+	isl_bool closed;
 
 	if (!map)
 		goto error;
@@ -2584,7 +2573,7 @@
 		goto error;
 	if (closed) {
 		if (exact)
-			*exact = 1;
+			*exact = isl_bool_true;
 		return map;
 	}
 
@@ -2598,7 +2587,7 @@
 	return NULL;
 }
 
-static int inc_count(__isl_take isl_map *map, void *user)
+static isl_stat inc_count(__isl_take isl_map *map, void *user)
 {
 	int *n = user;
 
@@ -2606,10 +2595,10 @@
 
 	isl_map_free(map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int collect_basic_map(__isl_take isl_map *map, void *user)
+static isl_stat collect_basic_map(__isl_take isl_map *map, void *user)
 {
 	int i;
 	isl_basic_map ***next = user;
@@ -2622,10 +2611,10 @@
 	}
 
 	isl_map_free(map);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_map_free(map);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Perform Floyd-Warshall on the given list of basic relations.
@@ -2634,10 +2623,10 @@
  * grid have domains and ranges of the same dimension and so
  * the standard algorithm can be used because the nested transitive
  * closures are only applied to diagonal elements and because all
- * compositions are peformed on relations with compatible domains and ranges.
+ * compositions are performed on relations with compatible domains and ranges.
  */
 static __isl_give isl_union_map *union_floyd_warshall_on_list(isl_ctx *ctx,
-	__isl_keep isl_basic_map **list, int n, int *exact)
+	__isl_keep isl_basic_map **list, int n, isl_bool *exact)
 {
 	int i, j, k;
 	int n_group;
@@ -2658,11 +2647,11 @@
 		if (!gridi)
 			goto error;
 		for (j = 0; j < n_group; ++j) {
-			isl_space *dim1, *dim2, *dim;
-			dim1 = isl_space_reverse(isl_set_get_space(seti));
-			dim2 = isl_set_get_space(setj);
-			dim = isl_space_join(dim1, dim2);
-			gridij = isl_map_empty(dim);
+			isl_space *space1, *space2, *space;
+			space1 = isl_space_reverse(isl_set_get_space(seti));
+			space2 = isl_set_get_space(setj);
+			space = isl_space_join(space1, space2);
+			gridij = isl_map_empty(space);
 		}
 	}
 
@@ -2717,7 +2706,7 @@
  * and then perform the algorithm on this list.
  */
 static __isl_give isl_union_map *union_floyd_warshall(
-	__isl_take isl_union_map *umap, int *exact)
+	__isl_take isl_union_map *umap, isl_bool *exact)
 {
 	int i, n;
 	isl_ctx *ctx;
@@ -2764,7 +2753,7 @@
  * operations are performed on union maps.
  */
 static __isl_give isl_union_map *union_components(
-	__isl_take isl_union_map *umap, int *exact)
+	__isl_take isl_union_map *umap, isl_bool *exact)
 {
 	int i;
 	int n;
@@ -2826,7 +2815,7 @@
 	}
 
 	if (c > 1 && data.check_closed && !*exact) {
-		int closed;
+		isl_bool closed;
 
 		closed = isl_union_map_is_transitively_closed(path);
 		if (closed < 0)
@@ -2864,15 +2853,15 @@
  * If the result is exact, then *exact is set to 1.
  */
 __isl_give isl_union_map *isl_union_map_transitive_closure(
-	__isl_take isl_union_map *umap, int *exact)
+	__isl_take isl_union_map *umap, isl_bool *exact)
 {
-	int closed;
+	isl_bool closed;
 
 	if (!umap)
 		return NULL;
 
 	if (exact)
-		*exact = 1;
+		*exact = isl_bool_true;
 
 	umap = isl_union_map_compute_divs(umap);
 	umap = isl_union_map_coalesce(umap);
@@ -2890,51 +2879,28 @@
 
 struct isl_union_power {
 	isl_union_map *pow;
-	int *exact;
+	isl_bool *exact;
 };
 
-static int power(__isl_take isl_map *map, void *user)
+static isl_stat power(__isl_take isl_map *map, void *user)
 {
 	struct isl_union_power *up = user;
 
 	map = isl_map_power(map, up->exact);
 	up->pow = isl_union_map_from_map(map);
 
-	return -1;
-}
-
-/* Construct a map x -> x+1, with parameters prescribed by "dim".
- */
-static __isl_give isl_union_map *increment(__isl_take isl_space *dim)
-{
-	int k;
-	isl_basic_map *bmap;
-
-	dim = isl_space_add_dims(dim, isl_dim_in, 1);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	bmap = isl_basic_map_alloc_space(dim, 0, 1, 0);
-	k = isl_basic_map_alloc_equality(bmap);
-	if (k < 0)
-		goto error;
-	isl_seq_clr(bmap->eqk, isl_basic_map_total_dim(bmap));
-	isl_int_set_si(bmap->eqk0, 1);
-	isl_int_set_si(bmap->eqkisl_basic_map_offset(bmap, isl_dim_in), 1);
-	isl_int_set_si(bmap->eqkisl_basic_map_offset(bmap, isl_dim_out), -1);
-	return isl_union_map_from_map(isl_map_from_basic_map(bmap));
-error:
-	isl_basic_map_free(bmap);
-	return NULL;
+	return isl_stat_error;
 }
 
-/* Construct a map x->y -> y-x, with parameters prescribed by "dim".
+/* Construct a map x->y -> y-x, with parameters prescribed by "space".
  */
-static __isl_give isl_union_map *deltas_map(__isl_take isl_space *dim)
+static __isl_give isl_union_map *deltas_map(__isl_take isl_space *space)
 {
 	isl_basic_map *bmap;
 
-	dim = isl_space_add_dims(dim, isl_dim_in, 1);
-	dim = isl_space_add_dims(dim, isl_dim_out, 1);
-	bmap = isl_basic_map_universe(dim);
+	space = isl_space_add_dims(space, isl_dim_in, 1);
+	space = isl_space_add_dims(space, isl_dim_out, 1);
+	bmap = isl_basic_map_universe(space);
 	bmap = isl_basic_map_deltas_map(bmap);
 
 	return isl_union_map_from_map(isl_map_from_basic_map(bmap));
@@ -2945,15 +2911,15 @@
  * If the result is exact, then *exact is set to 1.
  */
 __isl_give isl_union_map *isl_union_map_power(__isl_take isl_union_map *umap,
-	int *exact)
+	isl_bool *exact)
 {
-	int n;
+	isl_size n;
 	isl_union_map *inc;
 	isl_union_map *dm;
 
-	if (!umap)
-		return NULL;
 	n = isl_union_map_n_map(umap);
+	if (n < 0)
+		return isl_union_map_free(umap);
 	if (n == 0)
 		return umap;
 	if (n == 1) {
@@ -2962,7 +2928,7 @@
 		isl_union_map_free(umap);
 		return up.pow;
 	}
-	inc = increment(isl_union_map_get_space(umap));
+	inc = isl_union_map_from_map(increment(isl_union_map_get_space(umap)));
 	umap = isl_union_map_product(inc, umap);
 	umap = isl_union_map_transitive_closure(umap, exact);
 	umap = isl_union_map_zip(umap);

_service:tar_scm:isl-0.24.tar.gz/isl_type_check_equal_space_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_type_has_equal_space_bin_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_type_has_equal_space_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_type_has_space_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_unbind_params_templ.c Added

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2018      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* Given a function "obj" defined over a parameter domain,
+ * convert it to a function defined over a domain corresponding
+ * to "domain".
+ * Any parameters with identifiers in "domain" are reinterpreted
+ * as the corresponding domain dimensions.
+ */
+__isl_give TYPE *FN(TYPE,unbind_params_insert_domain)(
+	__isl_take TYPE *obj, __isl_take isl_multi_id *domain)
+{
+	isl_bool is_params;
+	isl_space *space;
+	isl_reordering *r;
+
+	space = FN(TYPE,get_domain_space)(obj);
+	is_params = isl_space_is_params(space);
+	if (is_params < 0)
+		domain = isl_multi_id_free(domain);
+	else if (!is_params)
+		isl_die(FN(TYPE,get_ctx)(obj), isl_error_invalid,
+			"expecting function with parameter domain",
+			domain = isl_multi_id_free(domain));
+	r = isl_reordering_unbind_params_insert_domain(space, domain);
+	isl_space_free(space);
+	isl_multi_id_free(domain);
+
+	return FN(TYPE,realign_domain)(obj, r);
+}

_service:tar_scm:isl-0.24.tar.gz/isl_union_eval.c Added

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ */
+
+#include <isl_union_macro.h>
+
+/* Evaluate "u" in the void point "pnt".
+ * In particular, return the value NaN.
+ */
+static __isl_give isl_val *FN(UNION,eval_void)(__isl_take UNION *u,
+	__isl_take isl_point *pnt)
+{
+	isl_ctx *ctx;
+
+	ctx = isl_point_get_ctx(pnt);
+	FN(UNION,free)(u);
+	isl_point_free(pnt);
+	return isl_val_nan(ctx);
+}
+
+/* Internal data structure for isl_union_*_eval.
+ *
+ * "pnt" is the point in which the function is evaluated.
+ * "v" stores the result and is initialized to zero.
+ */
+S(UNION,eval_data) {
+	isl_point *pnt;
+	isl_val *v;
+};
+
+/* Update the evaluation in data->v based on the evaluation of "part".
+ *
+ * Only (at most) a single part on which this function is called
+ * is assumed to evaluate to anything other than zero.
+ * Since the value is initialized to zero, the evaluation of "part"
+ * can simply be added.
+ */
+static isl_stat FN(UNION,eval_entry)(__isl_take PART *part, void *user)
+{
+	S(UNION,eval_data) *data = user;
+	isl_val *v;
+
+	v = FN(PART,eval)(part, isl_point_copy(data->pnt));
+	data->v = isl_val_add(data->v, v);
+
+	return isl_stat_non_null(data->v);
+}
+
+/* Evaluate "u" in the point "pnt".
+ */
+__isl_give isl_val *FN(UNION,eval)(__isl_take UNION *u,
+	__isl_take isl_point *pnt)
+{
+	S(UNION,eval_data) data = { pnt };
+	isl_bool is_void;
+	isl_space *space;
+
+	is_void = isl_point_is_void(pnt);
+	if (is_void < 0)
+		goto error;
+	if (is_void)
+		return FN(UNION,eval_void)(u, pnt);
+
+	data.v = isl_val_zero(isl_point_get_ctx(pnt));
+	space = isl_point_peek_space(pnt);
+	if (FN(UNION,foreach_on_domain)(u, space,
+					&FN(UNION,eval_entry), &data) < 0)
+		data.v = isl_val_free(data.v);
+	FN(UNION,free)(u);
+	isl_point_free(pnt);
+	return data.v;
+error:
+	FN(UNION,free)(u);
+	isl_point_free(pnt);
+	return NULL;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_union_locals_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_union_macro.h Added

_service:tar_scm:isl-0.14.tar.xz/isl_union_map.c -> _service:tar_scm:isl-0.24.tar.gz/isl_union_map.c Changed

@@ -1,42 +1,69 @@
 /*
  * Copyright 2010-2011 INRIA Saclay
  * Copyright 2013-2014 Ecole Normale Superieure
+ * Copyright 2014      INRIA Rocquencourt
+ * Copyright 2016-2017 Sven Verdoolaege
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
  * 91893 Orsay, France 
+ * and Inria Paris - Rocquencourt, Domaine de Voluceau - Rocquencourt,
+ * B.P. 105 - 78153 Le Chesnay, France
  */
 
-#define ISL_DIM_H
 #include <isl_map_private.h>
+#include <isl_union_map_private.h>
 #include <isl/ctx.h>
 #include <isl/hash.h>
-#include <isl/aff.h>
+#include <isl_aff_private.h>
 #include <isl/map.h>
 #include <isl/set.h>
 #include <isl_space_private.h>
-#include <isl_union_map_private.h>
 #include <isl/union_set.h>
-#include <isl/deprecated/union_map_int.h>
+#include <isl_maybe_map.h>
+#include <isl_id_private.h>
+
+#include <bset_from_bmap.c>
+#include <set_to_map.c>
+#include <set_from_map.c>
+#include <uset_to_umap.c>
+#include <uset_from_umap.c>
+#include <set_list_from_map_list_inl.c>
+
+#undef TYPE
+#define TYPE	isl_union_map
+static
+#include "has_single_reference_templ.c"
+static
+#include "check_single_reference_templ.c"
 
 /* Return the number of parameters of "umap", where "type"
  * is required to be set to isl_dim_param.
  */
-unsigned isl_union_map_dim(__isl_keep isl_union_map *umap,
+isl_size isl_union_map_dim(__isl_keep isl_union_map *umap,
 	enum isl_dim_type type)
 {
 	if (!umap)
-		return 0;
+		return isl_size_error;
 
 	if (type != isl_dim_param)
 		isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,
-			"can only reference parameters", return 0);
+			"can only reference parameters", return isl_size_error);
 
 	return isl_space_dim(umap->dim, type);
 }
 
+/* Return the number of parameters of "uset", where "type"
+ * is required to be set to isl_dim_param.
+ */
+isl_size isl_union_set_dim(__isl_keep isl_union_set *uset,
+	enum isl_dim_type type)
+{
+	return isl_union_map_dim(uset, type);
+}
+
 /* Return the id of the specified dimension.
  */
 __isl_give isl_id *isl_union_map_get_dim_id(__isl_keep isl_union_map *umap,
@@ -54,15 +81,15 @@
 
 /* Is this union set a parameter domain?
  */
-int isl_union_set_is_params(__isl_keep isl_union_set *uset)
+isl_bool isl_union_set_is_params(__isl_keep isl_union_set *uset)
 {
 	isl_set *set;
-	int params;
+	isl_bool params;
 
 	if (!uset)
-		return -1;
+		return isl_bool_error;
 	if (uset->table.n != 1)
-		return 0;
+		return isl_bool_false;
 
 	set = isl_set_from_union_set(isl_union_set_copy(uset));
 	params = isl_set_is_params(set);
@@ -70,6 +97,15 @@
 	return params;
 }
 
+/* Is this union map actually a parameter domain?
+ * Users should never call this function.  Outside of isl,
+ * a union map can never be a parameter domain.
+ */
+isl_bool isl_union_map_is_params(__isl_keep isl_union_map *umap)
+{
+	return isl_union_set_is_params(uset_from_umap(umap));
+}
+
 static __isl_give isl_union_map *isl_union_map_alloc(
 	__isl_take isl_space *space, int size)
 {
@@ -93,14 +129,42 @@
 	return umap;
 }
 
-__isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *dim)
+/* Create an empty union map without specifying any parameters.
+ */
+__isl_give isl_union_map *isl_union_map_empty_ctx(isl_ctx *ctx)
+{
+	return isl_union_map_empty_space(isl_space_unit(ctx));
+}
+
+__isl_give isl_union_map *isl_union_map_empty_space(__isl_take isl_space *space)
+{
+	return isl_union_map_alloc(space, 16);
+}
+
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_union_map *isl_union_map_empty(__isl_take isl_space *space)
+{
+	return isl_union_map_empty_space(space);
+}
+
+/* Create an empty union set without specifying any parameters.
+ */
+__isl_give isl_union_set *isl_union_set_empty_ctx(isl_ctx *ctx)
 {
-	return isl_union_map_alloc(dim, 16);
+	return uset_from_umap(isl_union_map_empty_ctx(ctx));
 }
 
-__isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *dim)
+__isl_give isl_union_set *isl_union_set_empty_space(__isl_take isl_space *space)
+{
+	return uset_from_umap(isl_union_map_empty_space(space));
+}
+
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_union_set *isl_union_set_empty(__isl_take isl_space *space)
 {
-	return isl_union_map_empty(dim);
+	return isl_union_set_empty_space(space);
 }
 
 isl_ctx *isl_union_map_get_ctx(__isl_keep isl_union_map *umap)
@@ -113,11 +177,35 @@
 	return uset ? uset->dim->ctx : NULL;
 }
 
+/* Return the space of "umap".
+ */
+__isl_keep isl_space *isl_union_map_peek_space(__isl_keep isl_union_map *umap)
+{
+	return umap ? umap->dim : NULL;
+}
+
+/* Return the space of "uset".
+ */
+__isl_keep isl_space *isl_union_set_peek_space(__isl_keep isl_union_set *uset)
+{
+	return isl_union_map_peek_space(uset_to_umap(uset));
+}
+
 __isl_give isl_space *isl_union_map_get_space(__isl_keep isl_union_map *umap)
 {
+	return isl_space_copy(isl_union_map_peek_space(umap));
+}
+
+/* Return the position of the parameter with the given name
+ * in "umap".
+ * Return -1 if no such dimension can be found.
+ */
+int isl_union_map_find_dim_by_name(__isl_keep isl_union_map *umap,
+	enum isl_dim_type type, const char *name)
+{
 	if (!umap)
-		return NULL;
-	return isl_space_copy(umap->dim);
+		return -1;
+	return isl_space_find_dim_by_name(umap->dim, type, name);
 }
 
 __isl_give isl_space *isl_union_set_get_space(__isl_keep isl_union_set *uset)
@@ -125,20 +213,20 @@
 	return isl_union_map_get_space(uset);
 }
 
-static int free_umap_entry(void **entry, void *user)
+static isl_stat free_umap_entry(void **entry, void *user)
 {
 	isl_map *map = *entry;
 	isl_map_free(map);
-	return 0;
+	return isl_stat_ok;
 }
 
-static int add_map(__isl_take isl_map *map, void *user)
+static isl_stat add_map(__isl_take isl_map *map, void *user)
 {
 	isl_union_map **umap = (isl_union_map **)user;
 
 	*umap = isl_union_map_add_map(*umap, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_dup(__isl_keep isl_union_map *umap)
@@ -173,7 +261,7 @@
 	isl_union_map *res;
 };
 
-static int align_entry(void **entry, void *user)
+static isl_stat align_entry(void **entry, void *user)
 {
 	isl_map *map = *entry;
 	isl_reordering *exp;
@@ -185,7 +273,7 @@
 	data->res = isl_union_map_add_map(data->res,
 					isl_map_realign(isl_map_copy(map), exp));
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Align the parameters of umap along those of model.
@@ -197,21 +285,24 @@
 	__isl_take isl_union_map *umap, __isl_take isl_space *model)
 {
 	struct isl_union_align data = { NULL, NULL };
+	isl_bool equal_params;
 
 	if (!umap || !model)
 		goto error;
 
-	if (isl_space_match(umap->dim, isl_dim_param, model, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(umap->dim, model);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params) {
 		isl_space_free(model);
 		return umap;
 	}
 
-	model = isl_space_params(model);
 	data.exp = isl_parameter_alignment_reordering(umap->dim, model);
 	if (!data.exp)
 		goto error;
 
-	data.res = isl_union_map_alloc(isl_space_copy(data.exp->dim),
+	data.res = isl_union_map_alloc(isl_reordering_get_space(data.exp),
 					umap->table.n);
 	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 					&align_entry, &data) < 0)
@@ -299,19 +390,77 @@
 	return isl_union_map_free(uset);
 }
 
-static int has_dim(const void *entry, const void *val)
+/* Do "umap" and "space" have the same parameters?
+ */
+isl_bool isl_union_map_space_has_equal_params(__isl_keep isl_union_map *umap,
+	__isl_keep isl_space *space)
+{
+	isl_space *umap_space;
+
+	umap_space = isl_union_map_peek_space(umap);
+	return isl_space_has_equal_params(umap_space, space);
+}
+
+/* Do "uset" and "space" have the same parameters?
+ */
+isl_bool isl_union_set_space_has_equal_params(__isl_keep isl_union_set *uset,
+	__isl_keep isl_space *space)
+{
+	return isl_union_map_space_has_equal_params(uset_to_umap(uset), space);
+}
+
+/* Is the space of the map at "entry" equal to "space", ignoring parameters?
+ */
+static isl_bool has_space_tuples(const void *entry, const void *val)
 {
 	isl_map *map = (isl_map *)entry;
-	isl_space *dim = (isl_space *)val;
+	isl_space *space = (isl_space *) val;
 
-	return isl_space_is_equal(map->dim, dim);
+	return isl_map_has_space_tuples(map, space);
+}
+
+/* Find the entry in "umap" with space "space" (ignoring parameters),
+ * returning isl_hash_table_entry_none if no such entry appears in "umap" and
+ * NULL on error.
+ * If "reserve" is set, then an entry is created if it does
+ * not exist already.  Since this modifies the hash table in-place,
+ * this means "umap" must have a single reference when "reserve" is set.
+ */
+static struct isl_hash_table_entry *isl_union_map_find_entry(
+	__isl_keep isl_union_map *umap, __isl_keep isl_space *space,
+	int reserve)
+{
+	uint32_t hash;
+
+	if (!umap || !space)
+		return NULL;
+	if (reserve && isl_union_map_check_single_reference(umap) < 0)
+		return NULL;
+
+	hash = isl_space_get_tuple_hash(space);
+	return isl_hash_table_find(isl_union_map_get_ctx(umap), &umap->table,
+				    hash, &has_space_tuples, space, reserve);
+}
+
+/* Find the entry in "uset" with space "space" (ignoring parameters),
+ * returning isl_hash_table_entry_none if no such entry appears in "uset" and
+ * NULL on error.
+ * If "reserve" is set, then an entry is created if it does
+ * not exist already.  In this case, a NULL return indicates an error.
+ */
+struct isl_hash_table_entry *isl_union_set_find_entry(
+	__isl_keep isl_union_set *uset, __isl_keep isl_space *space,
+	int reserve)
+{
+	return isl_union_map_find_entry(uset_to_umap(uset), space, reserve);
 }
 
 __isl_give isl_union_map *isl_union_map_add_map(__isl_take isl_union_map *umap,
 	__isl_take isl_map *map)
 {
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
+	isl_bool aligned;
+	isl_space *space;
 
 	if (!map || !umap)
 		goto error;
@@ -321,19 +470,18 @@
 		return umap;
 	}
 
-	if (!isl_space_match(map->dim, isl_dim_param, umap->dim, isl_dim_param)) {
+	aligned = isl_map_space_has_equal_params(map, umap->dim);
+	if (aligned < 0)
+		goto error;
+	if (!aligned) {
 		umap = isl_union_map_align_params(umap, isl_map_get_space(map));
 		map = isl_map_align_params(map, isl_union_map_get_space(umap));
 	}
 
 	umap = isl_union_map_cow(umap);
 
-	if (!map || !umap)
-		goto error;
-
-	hash = isl_space_get_hash(map->dim);
-	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-				    &has_dim, map->dim, 1);
+	space = isl_map_peek_space(map);
+	entry = isl_union_map_find_entry(umap, space, 1);
 	if (!entry)
 		goto error;
 
@@ -356,28 +504,44 @@
 __isl_give isl_union_set *isl_union_set_add_set(__isl_take isl_union_set *uset,
 	__isl_take isl_set *set)
 {
-	return isl_union_map_add_map(uset, (isl_map *)set);
+	return isl_union_map_add_map(uset, set_to_map(set));
 }
 
 __isl_give isl_union_map *isl_union_map_from_map(__isl_take isl_map *map)
 {
-	isl_space *dim;
+	isl_space *space;
 	isl_union_map *umap;
 
 	if (!map)
 		return NULL;
 
-	dim = isl_map_get_space(map);
-	dim = isl_space_params(dim);
-	umap = isl_union_map_empty(dim);
+	space = isl_map_get_space(map);
+	space = isl_space_params(space);
+	umap = isl_union_map_empty(space);
 	umap = isl_union_map_add_map(umap, map);
 
 	return umap;
 }
 
+/* This function performs the same operation as isl_union_map_from_map,
+ * but is considered as a function on an isl_map when exported.
+ */
+__isl_give isl_union_map *isl_map_to_union_map(__isl_take isl_map *map)
+{
+	return isl_union_map_from_map(map);
+}
+
 __isl_give isl_union_set *isl_union_set_from_set(__isl_take isl_set *set)
 {
-	return isl_union_map_from_map((isl_map *)set);
+	return isl_union_map_from_map(set_to_map(set));
+}
+
+/* This function performs the same operation as isl_union_set_from_set,
+ * but is considered as a function on an isl_set when exported.
+ */
+__isl_give isl_union_set *isl_set_to_union_set(__isl_take isl_set *set)
+{
+	return isl_union_set_from_set(set);
 }
 
 __isl_give isl_union_map *isl_union_map_from_basic_map(
@@ -394,11 +558,11 @@
 
 struct isl_union_map_foreach_data
 {
-	int (*fn)(__isl_take isl_map *map, void *user);
+	isl_stat (*fn)(__isl_take isl_map *map, void *user);
 	void *user;
 };
 
-static int call_on_copy(void **entry, void *user)
+static isl_stat call_on_copy(void **entry, void *user)
 {
 	isl_map *map = *entry;
 	struct isl_union_map_foreach_data *data;
@@ -407,47 +571,168 @@
 	return data->fn(isl_map_copy(map), data->user);
 }
 
-int isl_union_map_n_map(__isl_keep isl_union_map *umap)
+isl_size isl_union_map_n_map(__isl_keep isl_union_map *umap)
 {
-	return umap ? umap->table.n : 0;
+	return umap ? umap->table.n : isl_size_error;
 }
 
-int isl_union_set_n_set(__isl_keep isl_union_set *uset)
+isl_size isl_union_set_n_set(__isl_keep isl_union_set *uset)
 {
-	return uset ? uset->table.n : 0;
+	return uset ? uset->table.n : isl_size_error;
 }
 
-int isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
-	int (*fn)(__isl_take isl_map *map, void *user), void *user)
+isl_stat isl_union_map_foreach_map(__isl_keep isl_union_map *umap,
+	isl_stat (*fn)(__isl_take isl_map *map, void *user), void *user)
 {
 	struct isl_union_map_foreach_data data = { fn, user };
 
 	if (!umap)
-		return -1;
+		return isl_stat_error;
 
 	return isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 				      &call_on_copy, &data);
 }
 
-static int copy_map(void **entry, void *user)
+/* Internal data structure for isl_union_map_every_map.
+ *
+ * "test" is the user-specified callback function.
+ * "user" is the user-specified callback function argument.
+ *
+ * "failed" is initialized to 0 and set to 1 if "test" fails
+ * on any map.
+ */
+struct isl_union_map_every_data {
+	isl_bool (*test)(__isl_keep isl_map *map, void *user);
+	void *user;
+	int failed;
+};
+
+/* Call data->test on "map".
+ * If this fails, then set data->failed and abort.
+ */
+static isl_stat call_every(void **entry, void *user)
+{
+	isl_map *map = *entry;
+	struct isl_union_map_every_data *data = user;
+	isl_bool r;
+
+	r = data->test(map, data->user);
+	if (r < 0)
+		return isl_stat_error;
+	if (r)
+		return isl_stat_ok;
+	data->failed = 1;
+	return isl_stat_error;
+}
+
+/* Does "test" succeed on every map in "umap"?
+ */
+isl_bool isl_union_map_every_map(__isl_keep isl_union_map *umap,
+	isl_bool (*test)(__isl_keep isl_map *map, void *user), void *user)
+{
+	struct isl_union_map_every_data data = { test, user, 0 };
+	isl_stat r;
+
+	if (!umap)
+		return isl_bool_error;
+
+	r = isl_hash_table_foreach(isl_union_map_get_ctx(umap), &umap->table,
+				      &call_every, &data);
+	if (r >= 0)
+		return isl_bool_true;
+	if (data.failed)
+		return isl_bool_false;
+	return isl_bool_error;
+}
+
+/* Add "map" to "list".
+ */
+static isl_stat add_list_map(__isl_take isl_map *map, void *user)
+{
+	isl_map_list **list = user;
+
+	*list = isl_map_list_add(*list, map);
+
+	if (!*list)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Return the maps in "umap" as a list.
+ *
+ * First construct a list of the appropriate size and then add all the
+ * elements.
+ */
+__isl_give isl_map_list *isl_union_map_get_map_list(
+	__isl_keep isl_union_map *umap)
+{
+	isl_size n_maps;
+	isl_ctx *ctx;
+	isl_map_list *list;
+
+	n_maps = isl_union_map_n_map(umap);
+	if (n_maps < 0)
+		return NULL;
+	ctx = isl_union_map_get_ctx(umap);
+	list = isl_map_list_alloc(ctx, n_maps);
+
+	if (isl_union_map_foreach_map(umap, &add_list_map, &list) < 0)
+		list = isl_map_list_free(list);
+
+	return list;
+}
+
+/* Return the sets in "uset" as a list.
+ */
+__isl_give isl_set_list *isl_union_set_get_set_list(
+	__isl_keep isl_union_set *uset)
+{
+	return set_list_from_map_list(
+		isl_union_map_get_map_list(uset_to_umap(uset)));
+}
+
+/* Can "umap" be converted to an isl_map?
+ * That is, does it contain elements in exactly one space?
+ */
+isl_bool isl_union_map_isa_map(__isl_keep isl_union_map *umap)
+{
+	isl_size n;
+
+	n = isl_union_map_n_map(umap);
+	if (n < 0)
+		return isl_bool_error;
+	return isl_bool_ok(n == 1);
+}
+
+/* Can "uset" be converted to an isl_set?
+ * That is, does it contain elements in exactly one space?
+ */
+isl_bool isl_union_set_isa_set(__isl_keep isl_union_set *uset)
+{
+	return isl_union_map_isa_map(uset_to_umap(uset));
+}
+
+static isl_stat copy_map(void **entry, void *user)
 {
 	isl_map *map = *entry;
 	isl_map **map_p = user;
 
 	*map_p = isl_map_copy(map);
 
-	return -1;
+	return isl_stat_error;
 }
 
 __isl_give isl_map *isl_map_from_union_map(__isl_take isl_union_map *umap)
 {
+	isl_bool is_map;
 	isl_ctx *ctx;
 	isl_map *map = NULL;
 
-	if (!umap)
-		return NULL;
+	is_map = isl_union_map_isa_map(umap);
+	if (is_map < 0)
+		goto error;
 	ctx = isl_union_map_get_ctx(umap);
-	if (umap->table.n != 1)
+	if (!is_map)
 		isl_die(ctx, isl_error_invalid,
 			"union map needs to contain elements in exactly "
 			"one space", goto error);
@@ -462,30 +747,39 @@
 	return NULL;
 }
 
+/* This function performs the same operation as isl_map_from_union_map,
+ * but is considered as a function on an isl_union_map when exported.
+ */
+__isl_give isl_map *isl_union_map_as_map(__isl_take isl_union_map *umap)
+{
+	return isl_map_from_union_map(umap);
+}
+
 __isl_give isl_set *isl_set_from_union_set(__isl_take isl_union_set *uset)
 {
 	return isl_map_from_union_map(uset);
 }
 
+/* This function performs the same operation as isl_set_from_union_set,
+ * but is considered as a function on an isl_union_set when exported.
+ */
+__isl_give isl_set *isl_union_set_as_set(__isl_take isl_union_set *uset)
+{
+	return isl_set_from_union_set(uset);
+}
+
 /* Extract the map in "umap" that lives in the given space (ignoring
  * parameters).
  */
 __isl_give isl_map *isl_union_map_extract_map(__isl_keep isl_union_map *umap,
 	__isl_take isl_space *space)
 {
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
-	space = isl_space_drop_dims(space, isl_dim_param,
-					0, isl_space_dim(space, isl_dim_param));
-	space = isl_space_align_params(space, isl_union_map_get_space(umap));
-	if (!umap || !space)
-		goto error;
-
-	hash = isl_space_get_hash(space);
-	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-				    &has_dim, space, 0);
+	entry = isl_union_map_find_entry(umap, space, 0);
 	if (!entry)
+		goto error;
+	if (entry == isl_hash_table_entry_none)
 		return isl_map_empty(space);
 	isl_space_free(space);
 	return isl_map_copy(entry->data);
@@ -495,50 +789,80 @@
 }
 
 __isl_give isl_set *isl_union_set_extract_set(__isl_keep isl_union_set *uset,
-	__isl_take isl_space *dim)
+	__isl_take isl_space *space)
 {
-	return (isl_set *)isl_union_map_extract_map(uset, dim);
+	return set_from_map(isl_union_map_extract_map(uset, space));
 }
 
-/* Check if umap contains a map in the given space.
+/* Check if umap contains a map in the given space (ignoring parameters).
  */
-__isl_give int isl_union_map_contains(__isl_keep isl_union_map *umap,
-	__isl_keep isl_space *dim)
+isl_bool isl_union_map_contains(__isl_keep isl_union_map *umap,
+	__isl_keep isl_space *space)
 {
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
-	if (!umap || !dim)
-		return -1;
-
-	hash = isl_space_get_hash(dim);
-	entry = isl_hash_table_find(umap->dim->ctx, &umap->table, hash,
-				    &has_dim, dim, 0);
-	return !!entry;
+	space = isl_space_drop_all_params(isl_space_copy(space));
+	space = isl_space_align_params(space, isl_union_map_get_space(umap));
+	entry = isl_union_map_find_entry(umap, space, 0);
+	isl_space_free(space);
+	if (!entry)
+		return isl_bool_error;
+	return isl_bool_ok(entry != isl_hash_table_entry_none);
 }
 
-__isl_give int isl_union_set_contains(__isl_keep isl_union_set *uset,
-	__isl_keep isl_space *dim)
+isl_bool isl_union_set_contains(__isl_keep isl_union_set *uset,
+	__isl_keep isl_space *space)
 {
-	return isl_union_map_contains(uset, dim);
+	return isl_union_map_contains(uset, space);
 }
 
-int isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
-	int (*fn)(__isl_take isl_set *set, void *user), void *user)
+isl_stat isl_union_set_foreach_set(__isl_keep isl_union_set *uset,
+	isl_stat (*fn)(__isl_take isl_set *set, void *user), void *user)
 {
 	return isl_union_map_foreach_map(uset,
-		(int(*)(__isl_take isl_map *, void*))fn, user);
+		(isl_stat(*)(__isl_take isl_map *, void*))fn, user);
+}
+
+/* Internal data structure for isl_union_set_every_set.
+ *
+ * "test" is the user-specified callback function.
+ * "user" is the user-specified callback function argument.
+ */
+struct isl_test_set_from_map_data {
+	isl_bool (*test)(__isl_keep isl_set *set, void *user);
+	void *user;
+};
+
+/* Call data->test on "map", which is part of an isl_union_set and
+ * therefore known to be an isl_set.
+ */
+static isl_bool test_set_from_map(__isl_keep isl_map *map, void *user)
+{
+	struct isl_test_set_from_map_data *data = user;
+
+	return data->test(set_from_map(map), data->user);
+}
+
+/* Does "test" succeed on every set in "uset"?
+ */
+isl_bool isl_union_set_every_set(__isl_keep isl_union_set *uset,
+	isl_bool (*test)(__isl_keep isl_set *set, void *user), void *user)
+{
+	struct isl_test_set_from_map_data data = { test, user };
+
+	return isl_union_map_every_map(uset_to_umap(uset),
+					&test_set_from_map, &data);
 }
 
 struct isl_union_set_foreach_point_data {
-	int (*fn)(__isl_take isl_point *pnt, void *user);
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user);
 	void *user;
 };
 
-static int foreach_point(__isl_take isl_set *set, void *user)
+static isl_stat foreach_point(__isl_take isl_set *set, void *user)
 {
 	struct isl_union_set_foreach_point_data *data = user;
-	int r;
+	isl_stat r;
 
 	r = isl_set_foreach_point(set, data->fn, data->user);
 	isl_set_free(set);
@@ -546,52 +870,161 @@
 	return r;
 }
 
-int isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
-	int (*fn)(__isl_take isl_point *pnt, void *user), void *user)
+isl_stat isl_union_set_foreach_point(__isl_keep isl_union_set *uset,
+	isl_stat (*fn)(__isl_take isl_point *pnt, void *user), void *user)
 {
 	struct isl_union_set_foreach_point_data data = { fn, user };
 	return isl_union_set_foreach_set(uset, &foreach_point, &data);
 }
 
+/* Data structure that specifies how gen_bin_op should
+ * construct results from the inputs.
+ *
+ * If "subtract" is set, then a map in the first input is copied to the result
+ * if there is no corresponding map in the second input.
+ * Otherwise, a map in the first input with no corresponding map
+ * in the second input is ignored.
+ * If "filter" is not NULL, then it specifies which maps in the first
+ * input may have a matching map in the second input.
+ * In particular, it makes sure that "match_space" can be called
+ * on the space of the map.
+ * "match_space" specifies how to transform the space of a map
+ * in the first input to the space of the corresponding map
+ * in the second input.
+ * "fn_map" specifies how the matching maps, one from each input,
+ * should be combined to form a map in the result.
+ */
+struct isl_bin_op_control {
+	int subtract;
+	isl_bool (*filter)(__isl_keep isl_map *map);
+	__isl_give isl_space *(*match_space)(__isl_take isl_space *space);
+	__isl_give isl_map *(*fn_map)(__isl_take isl_map *map1,
+		__isl_take isl_map *map2);
+};
+
+/* Internal data structure for gen_bin_op.
+ * "control" specifies how the maps in the result should be constructed.
+ * "umap2" is a pointer to the second argument.
+ * "res" collects the results.
+ */
 struct isl_union_map_gen_bin_data {
+	struct isl_bin_op_control *control;
 	isl_union_map *umap2;
 	isl_union_map *res;
 };
 
-static int subtract_entry(void **entry, void *user)
+/* Add a copy of "map" to "res" and return the result.
+ */
+static __isl_give isl_union_map *bin_add_map(__isl_take isl_union_map *res,
+	__isl_keep isl_map *map)
+{
+	return isl_union_map_add_map(res, isl_map_copy(map));
+}
+
+/* Combine "map1" and "map2", add the result to "res" and return the result.
+ * Check whether the result is empty before adding it to "res".
+ */
+static __isl_give isl_union_map *bin_add_pair(__isl_take isl_union_map *res,
+	__isl_keep isl_map *map1, __isl_keep isl_map *map2,
+	struct isl_union_map_gen_bin_data *data)
+{
+	isl_bool empty;
+	isl_map *map;
+
+	map = data->control->fn_map(isl_map_copy(map1), isl_map_copy(map2));
+	empty = isl_map_is_empty(map);
+	if (empty < 0 || empty) {
+		isl_map_free(map);
+		if (empty < 0)
+			return isl_union_map_free(res);
+		return res;
+	}
+	return isl_union_map_add_map(res, map);
+}
+
+/* Dummy match_space function that simply returns the input space.
+ */
+static __isl_give isl_space *identity(__isl_take isl_space *space)
+{
+	return space;
+}
+
+/* Look for the map in data->umap2 that corresponds to "map", if any.
+ * Return (isl_bool_true, matching map) if there is one,
+ * (isl_bool_false, NULL) if there is no matching map and
+ * (isl_bool_error, NULL) on error.
+ *
+ * If not NULL, then data->control->filter specifies whether "map"
+ * can have any matching map.  If so,
+ * data->control->match_space specifies which map in data->umap2
+ * corresponds to "map".
+ */
+static __isl_keep isl_maybe_isl_map bin_try_get_match(
+	struct isl_union_map_gen_bin_data *data, __isl_keep isl_map *map)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry2;
-	isl_map *map = *entry;
+	isl_space *space;
+	isl_maybe_isl_map res = { isl_bool_error, NULL };
 
-	hash = isl_space_get_hash(map->dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, map->dim, 0);
-	map = isl_map_copy(map);
-	if (entry2) {
-		int empty;
-		map = isl_map_subtract(map, isl_map_copy(entry2->data));
-
-		empty = isl_map_is_empty(map);
-		if (empty < 0) {
-			isl_map_free(map);
-			return -1;
-		}
-		if (empty) {
-			isl_map_free(map);
-			return 0;
-		}
+	if (data->control->filter) {
+		res.valid = data->control->filter(map);
+		if (res.valid < 0 || !res.valid)
+			return res;
+		res.valid = isl_bool_error;
 	}
-	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	space = isl_map_get_space(map);
+	if (data->control->match_space != &identity)
+		space = data->control->match_space(space);
+	entry2 = isl_union_map_find_entry(data->umap2, space, 0);
+	isl_space_free(space);
+	if (entry2)
+		res.valid = isl_bool_ok(entry2 != isl_hash_table_entry_none);
+	if (res.valid >= 0 && res.valid)
+		res.value = entry2->data;
+
+	return res;
+}
+
+/* isl_hash_table_foreach callback for gen_bin_op.
+ * Look for the map in data->umap2 that corresponds
+ * to the map that "entry" points to, apply the binary operation and
+ * add the result to data->res.
+ *
+ * If no corresponding map can be found, then the effect depends
+ * on data->control->subtract.  If it is set, then the current map
+ * is added directly to the result.  Otherwise, it is ignored.
+ */
+static isl_stat gen_bin_entry(void **entry, void *user)
+{
+	struct isl_union_map_gen_bin_data *data = user;
+	isl_map *map = *entry;
+	isl_maybe_isl_map m;
+
+	m = bin_try_get_match(data, map);
+	if (m.valid < 0)
+		return isl_stat_error;
+	if (!m.valid && !data->control->subtract)
+		return isl_stat_ok;
+
+	if (!m.valid)
+		data->res = bin_add_map(data->res, map);
+	else
+		data->res = bin_add_pair(data->res, map, m.value, data);
+	if (!data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
 }
 
+/* Apply a binary operation to "umap1" and "umap2" based on "control".
+ * Run over all maps in "umap1" and look for the corresponding map in "umap2"
+ * in gen_bin_entry.
+ */
 static __isl_give isl_union_map *gen_bin_op(__isl_take isl_union_map *umap1,
-	__isl_take isl_union_map *umap2, int (*fn)(void **, void *))
+	__isl_take isl_union_map *umap2, struct isl_bin_op_control *control)
 {
-	struct isl_union_map_gen_bin_data data = { NULL, NULL };
+	struct isl_union_map_gen_bin_data data = { control, NULL, NULL };
 
 	umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
 	umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
@@ -603,7 +1036,7 @@
 	data.res = isl_union_map_alloc(isl_space_copy(umap1->dim),
 				       umap1->table.n);
 	if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
-				   fn, &data) < 0)
+				   &gen_bin_entry, &data) < 0)
 		goto error;
 
 	isl_union_map_free(umap1);
@@ -619,7 +1052,13 @@
 __isl_give isl_union_map *isl_union_map_subtract(
 	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
 {
-	return gen_bin_op(umap1, umap2, &subtract_entry);
+	struct isl_bin_op_control control = {
+		.subtract = 1,
+		.match_space = &identity,
+		.fn_map = &isl_map_subtract,
+	};
+
+	return gen_bin_op(umap1, umap2, &control);
 }
 
 __isl_give isl_union_set *isl_union_set_subtract(
@@ -633,7 +1072,7 @@
 	isl_union_map *res;
 };
 
-static int intersect_params_entry(void **entry, void *user)
+static isl_stat intersect_params_entry(void **entry, void *user)
 {
 	struct isl_union_map_gen_bin_set_data *data = user;
 	isl_map *map = *entry;
@@ -645,16 +1084,16 @@
 	empty = isl_map_is_empty(map);
 	if (empty < 0) {
 		isl_map_free(map);
-		return -1;
+		return isl_stat_error;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_union_map *gen_bin_set_op(__isl_take isl_union_map *umap,
-	__isl_take isl_set *set, int (*fn)(void **, void *))
+	__isl_take isl_set *set, isl_stat (*fn)(void **, void *))
 {
 	struct isl_union_map_gen_bin_set_data data = { NULL, NULL };
 
@@ -681,10 +1120,28 @@
 	return NULL;
 }
 
+/* Intersect "umap" with the parameter domain "set".
+ *
+ * If "set" does not have any constraints, then we can return immediately.
+ */
 __isl_give isl_union_map *isl_union_map_intersect_params(
 	__isl_take isl_union_map *umap, __isl_take isl_set *set)
 {
+	int is_universe;
+
+	is_universe = isl_set_plain_is_universe(set);
+	if (is_universe < 0)
+		goto error;
+	if (is_universe) {
+		isl_set_free(set);
+		return umap;
+	}
+
 	return gen_bin_set_op(umap, set, &intersect_params_entry);
+error:
+	isl_union_map_free(umap);
+	isl_set_free(set);
+	return NULL;
 }
 
 __isl_give isl_union_set *isl_union_set_intersect_params(
@@ -712,19 +1169,20 @@
 	__isl_give isl_map *(*fn)(__isl_take isl_map*, __isl_take isl_map*);
 };
 
-static int match_bin_entry(void **entry, void *user)
+static isl_stat match_bin_entry(void **entry, void *user)
 {
 	struct isl_union_map_match_bin_data *data = user;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry2;
+	isl_space *space;
 	isl_map *map = *entry;
 	int empty;
 
-	hash = isl_space_get_hash(map->dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, map->dim, 0);
+	space = isl_map_peek_space(map);
+	entry2 = isl_union_map_find_entry(data->umap2, space, 0);
 	if (!entry2)
-		return 0;
+		return isl_stat_error;
+	if (entry2 == isl_hash_table_entry_none)
+		return isl_stat_ok;
 
 	map = isl_map_copy(map);
 	map = data->fn(map, isl_map_copy(entry2->data));
@@ -732,16 +1190,16 @@
 	empty = isl_map_is_empty(map);
 	if (empty < 0) {
 		isl_map_free(map);
-		return -1;
+		return isl_stat_error;
 	}
 	if (empty) {
 		isl_map_free(map);
-		return 0;
+		return isl_stat_ok;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_union_map *match_bin_op(__isl_take isl_union_map *umap1,
@@ -804,7 +1262,7 @@
 	return NULL;
 }
 
-static int gist_params_entry(void **entry, void *user)
+static isl_stat gist_params_entry(void **entry, void *user)
 {
 	struct isl_union_map_gen_bin_set_data *data = user;
 	isl_map *map = *entry;
@@ -816,12 +1274,12 @@
 	empty = isl_map_is_empty(map);
 	if (empty < 0) {
 		isl_map_free(map);
-		return -1;
+		return isl_stat_error;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_gist_params(
@@ -850,16 +1308,38 @@
 	return isl_union_map_gist(uset, context);
 }
 
+/* For each map in "umap", remove the constraints in the corresponding map
+ * of "context".
+ * Each map in "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_union_map *isl_union_map_plain_gist(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *context)
+{
+	return match_bin_op(umap, context, &isl_map_plain_gist);
+}
+
+/* For each set in "uset", remove the constraints in the corresponding set
+ * of "context".
+ * Each set in "context" is assumed to consist of a single disjunct and
+ * to have explicit representations for all local variables.
+ */
+__isl_give isl_union_set *isl_union_set_plain_gist(
+	__isl_take isl_union_set *uset, __isl_take isl_union_set *context)
+{
+	return isl_union_map_plain_gist(uset, context);
+}
+
 static __isl_give isl_map *lex_le_set(__isl_take isl_map *set1,
 	__isl_take isl_map *set2)
 {
-	return isl_set_lex_le_set((isl_set *)set1, (isl_set *)set2);
+	return isl_set_lex_le_set(set_from_map(set1), set_from_map(set2));
 }
 
 static __isl_give isl_map *lex_lt_set(__isl_take isl_map *set1,
 	__isl_take isl_map *set2)
 {
-	return isl_set_lex_lt_set((isl_set *)set1, (isl_set *)set2);
+	return isl_set_lex_lt_set(set_from_map(set1), set_from_map(set2));
 }
 
 __isl_give isl_union_map *isl_union_set_lex_lt_union_set(
@@ -898,95 +1378,38 @@
 	return isl_union_map_reverse(isl_union_map_lex_le_union_map(umap2, umap1));
 }
 
-static int intersect_domain_entry(void **entry, void *user)
+/* Intersect the domain of "umap" with "uset".
+ */
+static __isl_give isl_union_map *union_map_intersect_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *dim;
-	isl_map *map = *entry;
-	int empty;
-
-	dim = isl_map_get_space(map);
-	dim = isl_space_domain(dim);
-	hash = isl_space_get_hash(dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, dim, 0);
-	isl_space_free(dim);
-	if (!entry2)
-		return 0;
-
-	map = isl_map_copy(map);
-	map = isl_map_intersect_domain(map, isl_set_copy(entry2->data));
+	struct isl_bin_op_control control = {
+		.match_space = &isl_space_domain,
+		.fn_map = &isl_map_intersect_domain,
+	};
 
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
-	if (empty) {
-		isl_map_free(map);
-		return 0;
-	}
-
-	data->res = isl_union_map_add_map(data->res, map);
-
-	return 0;
+	return gen_bin_op(umap, uset, &control);
 }
 
 /* Intersect the domain of "umap" with "uset".
  * If "uset" is a parameters domain, then intersect the parameter
  * domain of "umap" with this set.
  */
-__isl_give isl_union_map *isl_union_map_intersect_domain(
+__isl_give isl_union_map *isl_union_map_intersect_domain_union_set(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
 	if (isl_union_set_is_params(uset))
 		return union_map_intersect_params(umap, uset);
-	return gen_bin_op(umap, uset, &intersect_domain_entry);
+	else
+		return union_map_intersect_domain(umap, uset);
 }
 
-/* Remove the elements of data->umap2 from the domain of *entry
- * and add the result to data->res.
+/* This is an alternative name for the function above.
  */
-static int subtract_domain_entry(void **entry, void *user)
+__isl_give isl_union_map *isl_union_map_intersect_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *dim;
-	isl_map *map = *entry;
-	int empty;
-
-	dim = isl_map_get_space(map);
-	dim = isl_space_domain(dim);
-	hash = isl_space_get_hash(dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, dim, 0);
-	isl_space_free(dim);
-
-	map = isl_map_copy(map);
-
-	if (!entry2) {
-		data->res = isl_union_map_add_map(data->res, map);
-		return 0;
-	}
-
-	map = isl_map_subtract_domain(map, isl_set_copy(entry2->data));
-
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
-	if (empty) {
-		isl_map_free(map);
-		return 0;
-	}
-
-	data->res = isl_union_map_add_map(data->res, map);
-
-	return 0;
+	return isl_union_map_intersect_domain_union_set(umap, uset);
 }
 
 /* Remove the elements of "uset" from the domain of "umap".
@@ -994,50 +1417,13 @@
 __isl_give isl_union_map *isl_union_map_subtract_domain(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *dom)
 {
-	return gen_bin_op(umap, dom, &subtract_domain_entry);
-}
-
-/* Remove the elements of data->umap2 from the range of *entry
- * and add the result to data->res.
- */
-static int subtract_range_entry(void **entry, void *user)
-{
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *space;
-	isl_map *map = *entry;
-	int empty;
+	struct isl_bin_op_control control = {
+		.subtract = 1,
+		.match_space = &isl_space_domain,
+		.fn_map = &isl_map_subtract_domain,
+	};
 
-	space = isl_map_get_space(map);
-	space = isl_space_range(space);
-	hash = isl_space_get_hash(space);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, space, 0);
-	isl_space_free(space);
-
-	map = isl_map_copy(map);
-
-	if (!entry2) {
-		data->res = isl_union_map_add_map(data->res, map);
-		return 0;
-	}
-
-	map = isl_map_subtract_range(map, isl_set_copy(entry2->data));
-
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
-	if (empty) {
-		isl_map_free(map);
-		return 0;
-	}
-
-	data->res = isl_union_map_add_map(data->res, map);
-
-	return 0;
+	return gen_bin_op(umap, dom, &control);
 }
 
 /* Remove the elements of "uset" from the range of "umap".
@@ -1045,39 +1431,26 @@
 __isl_give isl_union_map *isl_union_map_subtract_range(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *dom)
 {
-	return gen_bin_op(umap, dom, &subtract_range_entry);
+	struct isl_bin_op_control control = {
+		.subtract = 1,
+		.match_space = &isl_space_range,
+		.fn_map = &isl_map_subtract_range,
+	};
+
+	return gen_bin_op(umap, dom, &control);
 }
 
-static int gist_domain_entry(void **entry, void *user)
+/* Compute the gist of "umap" with respect to the domain "uset".
+ */
+static __isl_give isl_union_map *union_map_gist_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *dim;
-	isl_map *map = *entry;
-	int empty;
-
-	dim = isl_map_get_space(map);
-	dim = isl_space_domain(dim);
-	hash = isl_space_get_hash(dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, dim, 0);
-	isl_space_free(dim);
-	if (!entry2)
-		return 0;
-
-	map = isl_map_copy(map);
-	map = isl_map_gist_domain(map, isl_set_copy(entry2->data));
+	struct isl_bin_op_control control = {
+		.match_space = &isl_space_domain,
+		.fn_map = &isl_map_gist_domain,
+	};
 
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
-
-	data->res = isl_union_map_add_map(data->res, map);
-
-	return 0;
+	return gen_bin_op(umap, uset, &control);
 }
 
 /* Compute the gist of "umap" with respect to the domain "uset".
@@ -1089,126 +1462,144 @@
 {
 	if (isl_union_set_is_params(uset))
 		return union_map_gist_params(umap, uset);
-	return gen_bin_op(umap, uset, &gist_domain_entry);
+	else
+		return union_map_gist_domain(umap, uset);
 }
 
-static int gist_range_entry(void **entry, void *user)
+/* Compute the gist of "umap" with respect to the range "uset".
+ */
+__isl_give isl_union_map *isl_union_map_gist_range(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *space;
-	isl_map *map = *entry;
-	int empty;
+	struct isl_bin_op_control control = {
+		.match_space = &isl_space_range,
+		.fn_map = &isl_map_gist_range,
+	};
 
-	space = isl_map_get_space(map);
-	space = isl_space_range(space);
-	hash = isl_space_get_hash(space);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, space, 0);
-	isl_space_free(space);
-	if (!entry2)
-		return 0;
-
-	map = isl_map_copy(map);
-	map = isl_map_gist_range(map, isl_set_copy(entry2->data));
-
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
+	return gen_bin_op(umap, uset, &control);
+}
 
-	data->res = isl_union_map_add_map(data->res, map);
+__isl_give isl_union_map *isl_union_map_intersect_range_union_set(
+	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
+{
+	struct isl_bin_op_control control = {
+		.match_space = &isl_space_range,
+		.fn_map = &isl_map_intersect_range,
+	};
 
-	return 0;
+	return gen_bin_op(umap, uset, &control);
 }
 
-/* Compute the gist of "umap" with respect to the range "uset".
+/* This is an alternative name for the function above.
  */
-__isl_give isl_union_map *isl_union_map_gist_range(
+__isl_give isl_union_map *isl_union_map_intersect_range(
 	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
 {
-	return gen_bin_op(umap, uset, &gist_range_entry);
+	return isl_union_map_intersect_range_union_set(umap, uset);
 }
 
-static int intersect_range_entry(void **entry, void *user)
+/* Intersect each map in "umap" in a space A -> B -> C
+ * with the corresponding map in "factor" in the space A -> C and
+ * collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_intersect_domain_factor_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor)
 {
-	struct isl_union_map_gen_bin_data *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	isl_space *dim;
-	isl_map *map = *entry;
-	int empty;
+	struct isl_bin_op_control control = {
+		.filter = &isl_map_domain_is_wrapping,
+		.match_space = &isl_space_domain_factor_domain,
+		.fn_map = &isl_map_intersect_domain_factor_domain,
+	};
 
-	dim = isl_map_get_space(map);
-	dim = isl_space_range(dim);
-	hash = isl_space_get_hash(dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, dim, 0);
-	isl_space_free(dim);
-	if (!entry2)
-		return 0;
+	return gen_bin_op(umap, factor, &control);
+}
 
-	map = isl_map_copy(map);
-	map = isl_map_intersect_range(map, isl_set_copy(entry2->data));
+/* Intersect each map in "umap" in a space A -> B -> C
+ * with the corresponding map in "factor" in the space B -> C and
+ * collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_intersect_domain_factor_range(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor)
+{
+	struct isl_bin_op_control control = {
+		.filter = &isl_map_domain_is_wrapping,
+		.match_space = &isl_space_domain_factor_range,
+		.fn_map = &isl_map_intersect_domain_factor_range,
+	};
 
-	empty = isl_map_is_empty(map);
-	if (empty < 0) {
-		isl_map_free(map);
-		return -1;
-	}
-	if (empty) {
-		isl_map_free(map);
-		return 0;
-	}
+	return gen_bin_op(umap, factor, &control);
+}
 
-	data->res = isl_union_map_add_map(data->res, map);
+/* Intersect each map in "umap" in a space A -> B -> C
+ * with the corresponding map in "factor" in the space A -> B and
+ * collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_domain(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor)
+{
+	struct isl_bin_op_control control = {
+		.filter = &isl_map_range_is_wrapping,
+		.match_space = &isl_space_range_factor_domain,
+		.fn_map = &isl_map_intersect_range_factor_domain,
+	};
 
-	return 0;
+	return gen_bin_op(umap, factor, &control);
 }
 
-__isl_give isl_union_map *isl_union_map_intersect_range(
-	__isl_take isl_union_map *umap, __isl_take isl_union_set *uset)
+/* Intersect each map in "umap" in a space A -> B -> C
+ * with the corresponding map in "factor" in the space A -> C and
+ * collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_intersect_range_factor_range(
+	__isl_take isl_union_map *umap, __isl_take isl_union_map *factor)
 {
-	return gen_bin_op(umap, uset, &intersect_range_entry);
+	struct isl_bin_op_control control = {
+		.filter = &isl_map_range_is_wrapping,
+		.match_space = &isl_space_range_factor_range,
+		.fn_map = &isl_map_intersect_range_factor_range,
+	};
+
+	return gen_bin_op(umap, factor, &control);
 }
 
 struct isl_union_map_bin_data {
 	isl_union_map *umap2;
 	isl_union_map *res;
 	isl_map *map;
-	int (*fn)(void **entry, void *user);
+	isl_stat (*fn)(void **entry, void *user);
 };
 
-static int apply_range_entry(void **entry, void *user)
+static isl_stat apply_range_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
-	int empty;
+	isl_bool empty, match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_out,
-				 map2->dim, isl_dim_in))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_out,
+				map2, isl_dim_in);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_apply_range(isl_map_copy(data->map), isl_map_copy(map2));
 
 	empty = isl_map_is_empty(map2);
 	if (empty < 0) {
 		isl_map_free(map2);
-		return -1;
+		return isl_stat_error;
 	}
 	if (empty) {
 		isl_map_free(map2);
-		return 0;
+		return isl_stat_ok;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int bin_entry(void **entry, void *user)
+static isl_stat bin_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map = *entry;
@@ -1216,13 +1607,14 @@
 	data->map = map;
 	if (isl_hash_table_foreach(data->umap2->dim->ctx, &data->umap2->table,
 				   data->fn, data) < 0)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 static __isl_give isl_union_map *bin_op(__isl_take isl_union_map *umap1,
-	__isl_take isl_union_map *umap2, int (*fn)(void **entry, void *user))
+	__isl_take isl_union_map *umap2,
+	isl_stat (*fn)(void **entry, void *user))
 {
 	struct isl_union_map_bin_data data = { NULL, NULL, NULL, fn };
 
@@ -1269,20 +1661,24 @@
 	return isl_union_map_apply_range(uset, umap);
 }
 
-static int map_lex_lt_entry(void **entry, void *user)
+static isl_stat map_lex_lt_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
+	isl_bool match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_out,
-				 map2->dim, isl_dim_out))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_out,
+				 map2, isl_dim_out);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_lex_lt_map(isl_map_copy(data->map), isl_map_copy(map2));
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_lex_lt_union_map(
@@ -1291,20 +1687,24 @@
 	return bin_op(umap1, umap2, &map_lex_lt_entry);
 }
 
-static int map_lex_le_entry(void **entry, void *user)
+static isl_stat map_lex_le_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
+	isl_bool match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_out,
-				 map2->dim, isl_dim_out))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_out,
+				 map2, isl_dim_out);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_lex_le_map(isl_map_copy(data->map), isl_map_copy(map2));
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_lex_le_union_map(
@@ -1313,7 +1713,7 @@
 	return bin_op(umap1, umap2, &map_lex_le_entry);
 }
 
-static int product_entry(void **entry, void *user)
+static isl_stat product_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
@@ -1322,7 +1722,7 @@
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_product(__isl_take isl_union_map *umap1,
@@ -1331,7 +1731,7 @@
 	return bin_op(umap1, umap2, &product_entry);
 }
 
-static int set_product_entry(void **entry, void *user)
+static isl_stat set_product_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_set *set2 = *entry;
@@ -1340,7 +1740,7 @@
 
 	data->res = isl_union_set_add_set(data->res, set2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_set *isl_union_set_product(__isl_take isl_union_set *uset1,
@@ -1349,21 +1749,25 @@
 	return bin_op(uset1, uset2, &set_product_entry);
 }
 
-static int domain_product_entry(void **entry, void *user)
+static isl_stat domain_product_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
+	isl_bool match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_out,
-				 map2->dim, isl_dim_out))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_out,
+				 map2, isl_dim_out);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_domain_product(isl_map_copy(data->map),
 				     isl_map_copy(map2));
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Given two maps A -> B and C -> D, construct a map A -> C -> (B * D)
@@ -1374,21 +1778,24 @@
 	return bin_op(umap1, umap2, &domain_product_entry);
 }
 
-static int range_product_entry(void **entry, void *user)
+static isl_stat range_product_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
+	isl_bool match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_in,
-				 map2->dim, isl_dim_in))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_in, map2, isl_dim_in);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_range_product(isl_map_copy(data->map),
 				     isl_map_copy(map2));
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_range_product(
@@ -1397,21 +1804,56 @@
 	return bin_op(umap1, umap2, &range_product_entry);
 }
 
-static int flat_range_product_entry(void **entry, void *user)
+/* If data->map A -> B and "map2" C -> D have the same range space,
+ * then add (A, C) -> (B * D) to data->res.
+ */
+static isl_stat flat_domain_product_entry(void **entry, void *user)
 {
 	struct isl_union_map_bin_data *data = user;
 	isl_map *map2 = *entry;
+	isl_bool match;
 
-	if (!isl_space_tuple_is_equal(data->map->dim, isl_dim_in,
-				 map2->dim, isl_dim_in))
-		return 0;
+	match = isl_map_tuple_is_equal(data->map, isl_dim_out,
+				 map2, isl_dim_out);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
+
+	map2 = isl_map_flat_domain_product(isl_map_copy(data->map),
+					  isl_map_copy(map2));
+
+	data->res = isl_union_map_add_map(data->res, map2);
+
+	return isl_stat_ok;
+}
+
+/* Given two maps A -> B and C -> D, construct a map (A, C) -> (B * D).
+ */
+__isl_give isl_union_map *isl_union_map_flat_domain_product(
+	__isl_take isl_union_map *umap1, __isl_take isl_union_map *umap2)
+{
+	return bin_op(umap1, umap2, &flat_domain_product_entry);
+}
+
+static isl_stat flat_range_product_entry(void **entry, void *user)
+{
+	struct isl_union_map_bin_data *data = user;
+	isl_map *map2 = *entry;
+	isl_bool match;
+
+	match = isl_map_tuple_is_equal(data->map, isl_dim_in, map2, isl_dim_in);
+	if (match < 0)
+		return isl_stat_error;
+	if (!match)
+		return isl_stat_ok;
 
 	map2 = isl_map_flat_range_product(isl_map_copy(data->map),
 					  isl_map_copy(map2));
 
 	data->res = isl_union_map_add_map(data->res, map2);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_map *isl_union_map_flat_range_product(
@@ -1420,41 +1862,154 @@
 	return bin_op(umap1, umap2, &flat_range_product_entry);
 }
 
-static __isl_give isl_union_set *cond_un_op(__isl_take isl_union_map *umap,
-	int (*fn)(void **, void *))
+/* Data structure that specifies how un_op should modify
+ * the maps in the union map.
+ *
+ * If "inplace" is set, then the maps in the input union map
+ * are modified in place.  This means that "fn_map" should not
+ * change the meaning of the map or that the union map only
+ * has a single reference.
+ * If "total" is set, then all maps need to be modified and
+ * the results need to live in the same space.
+ * Otherwise, a new union map is constructed to store the results.
+ * If "filter" is not NULL, then only the input maps that satisfy "filter"
+ * are taken into account.  "filter_user" is passed as the second argument
+ * to "filter".  No filter can be set if "inplace" or
+ * "total" is set.
+ * At most one of "fn_map" or "fn_map2" can be set, specifying
+ * how the maps (selected by "filter") should be transformed.
+ * If "fn_map2" is set, then "fn_map2_user" is passed as the second argument.
+ */
+struct isl_un_op_control {
+	int inplace;
+	int total;
+	isl_bool (*filter)(__isl_keep isl_map *map, void *user);
+	void *filter_user;
+	__isl_give isl_map *(*fn_map)(__isl_take isl_map *map);
+	__isl_give isl_map *(*fn_map2)(__isl_take isl_map *map, void *user);
+	void *fn_map2_user;
+};
+
+/* Data structure for wrapping the data for un_op_filter_drop_user.
+ * "filter" is the function that is being wrapped.
+ */
+struct isl_un_op_drop_user_data {
+	isl_bool (*filter)(__isl_keep isl_map *map);
+};
+
+/* Wrapper for isl_un_op_control filters that do not require
+ * a second argument.
+ * Simply call data->filter without the second argument.
+ */
+static isl_bool un_op_filter_drop_user(__isl_keep isl_map *map, void *user)
 {
-	isl_union_set *res;
+	struct isl_un_op_drop_user_data *data = user;
+	return data->filter(map);
+}
 
-	if (!umap)
-		return NULL;
+/* Internal data structure for "un_op".
+ * "control" specifies how the maps in the union map should be modified.
+ * "res" collects the results.
+ */
+struct isl_union_map_un_data {
+	struct isl_un_op_control *control;
+	isl_union_map *res;
+};
 
-	res = isl_union_map_alloc(isl_space_copy(umap->dim), umap->table.n);
-	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, &res) < 0)
-		goto error;
+/* isl_hash_table_foreach callback for un_op.
+ * Handle the map that "entry" points to.
+ *
+ * If control->filter is set, then check if this map satisfies the filter.
+ * If so (or if control->filter is not set), modify the map
+ * by calling control->fn_map or control->fn_map2 (if set) and
+ * either add the result to data->res or
+ * replace the original entry by the result (if control->inplace is set).
+ */
+static isl_stat un_entry(void **entry, void *user)
+{
+	struct isl_union_map_un_data *data = user;
+	struct isl_un_op_control *control = data->control;
+	isl_map *map = *entry;
 
-	isl_union_map_free(umap);
-	return res;
-error:
-	isl_union_map_free(umap);
-	isl_union_set_free(res);
-	return NULL;
+	if (control->filter) {
+		isl_bool ok;
+
+		ok = control->filter(map, control->filter_user);
+		if (ok < 0)
+			return isl_stat_error;
+		if (!ok)
+			return isl_stat_ok;
+	}
+
+	map = isl_map_copy(map);
+	if (control->fn_map2 != NULL)
+		map = control->fn_map2(map, control->fn_map2_user);
+	else if (control->fn_map != NULL)
+		map = control->fn_map(map);
+	if (!map)
+		return isl_stat_error;
+	if (control->inplace) {
+		isl_map_free(*entry);
+		*entry = map;
+	} else {
+		data->res = isl_union_map_add_map(data->res, map);
+		if (!data->res)
+			return isl_stat_error;
+	}
+
+	return isl_stat_ok;
 }
 
-static int from_range_entry(void **entry, void *user)
+/* Modify the maps in "umap" based on "control".
+ * If control->inplace is set, then modify the maps in "umap" in-place.
+ * Otherwise, create a new union map to hold the results.
+ * If control->total is set, then perform an inplace computation
+ * if "umap" is only referenced once.  Otherwise, create a new union map
+ * to store the results.
+ */
+static __isl_give isl_union_map *un_op(__isl_take isl_union_map *umap,
+	struct isl_un_op_control *control)
 {
-	isl_map *set = *entry;
-	isl_union_set **res = user;
+	struct isl_union_map_un_data data = { control };
+
+	if (!umap)
+		return NULL;
+	if (!!control->fn_map && !!control->fn_map2)
+		isl_die(isl_union_map_get_ctx(umap), isl_error_internal,
+			"at most one mapping function can be specified",
+			return isl_union_map_free(umap));
+	if ((control->inplace || control->total) && control->filter)
+		isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,
+			"inplace/total modification cannot be filtered",
+			return isl_union_map_free(umap));
+
+	if (control->total && umap->ref == 1)
+		control->inplace = 1;
+	if (control->inplace) {
+		data.res = umap;
+	} else {
+		isl_space *space;
 
-	*res = isl_union_map_add_map(*res,
-					isl_map_from_range(isl_set_copy(set)));
+		space = isl_union_map_get_space(umap);
+		data.res = isl_union_map_alloc(space, umap->table.n);
+	}
+	if (isl_hash_table_foreach(isl_union_map_get_ctx(umap),
+				    &umap->table, &un_entry, &data) < 0)
+		data.res = isl_union_map_free(data.res);
 
-	return 0;
+	if (control->inplace)
+		return data.res;
+	isl_union_map_free(umap);
+	return data.res;
 }
 
 __isl_give isl_union_map *isl_union_map_from_range(
 	__isl_take isl_union_set *uset)
 {
-	return cond_un_op(uset, &from_range_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_from_range,
+	};
+	return un_op(uset, &control);
 }
 
 __isl_give isl_union_map *isl_union_map_from_domain(
@@ -1470,35 +2025,31 @@
 				         isl_union_map_from_range(range));
 }
 
-static __isl_give isl_union_map *un_op(__isl_take isl_union_map *umap,
-	int (*fn)(void **, void *))
+/* Modify the maps in "umap" by applying "fn" on them.
+ * "fn" should apply to all maps in "umap" and should not modify the space.
+ */
+static __isl_give isl_union_map *total(__isl_take isl_union_map *umap,
+	__isl_give isl_map *(*fn)(__isl_take isl_map *))
 {
-	umap = isl_union_map_cow(umap);
-	if (!umap)
-		return NULL;
+	struct isl_un_op_control control = {
+		.total = 1,
+		.fn_map = fn,
+	};
 
-	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table, fn, NULL) < 0)
-		goto error;
-
-	return umap;
-error:
-	isl_union_map_free(umap);
-	return NULL;
+	return un_op(umap, &control);
 }
 
-static int affine_entry(void **entry, void *user)
+/* Compute the affine hull of "map" and return the result as an isl_map.
+ */
+static __isl_give isl_map *isl_map_affine_hull_map(__isl_take isl_map *map)
 {
-	isl_map **map = (isl_map **)entry;
-
-	*map = isl_map_from_basic_map(isl_map_affine_hull(*map));
-
-	return *map ? 0 : -1;
+	return isl_map_from_basic_map(isl_map_affine_hull(map));
 }
 
 __isl_give isl_union_map *isl_union_map_affine_hull(
 	__isl_take isl_union_map *umap)
 {
-	return un_op(umap, &affine_entry);
+	return total(umap, &isl_map_affine_hull_map);
 }
 
 __isl_give isl_union_set *isl_union_set_affine_hull(
@@ -1507,19 +2058,39 @@
 	return isl_union_map_affine_hull(uset);
 }
 
-static int polyhedral_entry(void **entry, void *user)
+/* Wrapper around isl_set_combined_lineality_space
+ * that returns the combined lineality space in the form of an isl_set
+ * instead of an isl_basic_set.
+ */
+static __isl_give isl_set *combined_lineality_space(__isl_take isl_set *set)
 {
-	isl_map **map = (isl_map **)entry;
+	return isl_set_from_basic_set(isl_set_combined_lineality_space(set));
+}
 
-	*map = isl_map_from_basic_map(isl_map_polyhedral_hull(*map));
+/* For each set in "uset", compute the (linear) hull
+ * of the lineality spaces of its basic sets and
+ * collect and return the results.
+ */
+__isl_give isl_union_set *isl_union_set_combined_lineality_space(
+	__isl_take isl_union_set *uset)
+{
+	struct isl_un_op_control control = {
+		.fn_map = &combined_lineality_space,
+	};
+	return un_op(uset, &control);
+}
 
-	return *map ? 0 : -1;
+/* Compute the polyhedral hull of "map" and return the result as an isl_map.
+ */
+static __isl_give isl_map *isl_map_polyhedral_hull_map(__isl_take isl_map *map)
+{
+	return isl_map_from_basic_map(isl_map_polyhedral_hull(map));
 }
 
 __isl_give isl_union_map *isl_union_map_polyhedral_hull(
 	__isl_take isl_union_map *umap)
 {
-	return un_op(umap, &polyhedral_entry);
+	return total(umap, &isl_map_polyhedral_hull_map);
 }
 
 __isl_give isl_union_set *isl_union_set_polyhedral_hull(
@@ -1528,19 +2099,19 @@
 	return isl_union_map_polyhedral_hull(uset);
 }
 
-static int simple_entry(void **entry, void *user)
+/* Compute a superset of the convex hull of "map" that is described
+ * by only translates of the constraints in the constituents of "map" and
+ * return the result as an isl_map.
+ */
+static __isl_give isl_map *isl_map_simple_hull_map(__isl_take isl_map *map)
 {
-	isl_map **map = (isl_map **)entry;
-
-	*map = isl_map_from_basic_map(isl_map_simple_hull(*map));
-
-	return *map ? 0 : -1;
+	return isl_map_from_basic_map(isl_map_simple_hull(map));
 }
 
 __isl_give isl_union_map *isl_union_map_simple_hull(
 	__isl_take isl_union_map *umap)
 {
-	return un_op(umap, &simple_entry);
+	return total(umap, &isl_map_simple_hull_map);
 }
 
 __isl_give isl_union_set *isl_union_set_simple_hull(
@@ -1549,37 +2120,33 @@
 	return isl_union_map_simple_hull(uset);
 }
 
-static int inplace_entry(void **entry, void *user)
+static __isl_give isl_union_map *inplace(__isl_take isl_union_map *umap,
+	__isl_give isl_map *(*fn)(__isl_take isl_map *))
 {
-	__isl_give isl_map *(*fn)(__isl_take isl_map *);
-	isl_map **map = (isl_map **)entry;
-	isl_map *copy;
-
-	fn = *(__isl_give isl_map *(**)(__isl_take isl_map *)) user;
-	copy = fn(isl_map_copy(*map));
-	if (!copy)
-		return -1;
+	struct isl_un_op_control control = {
+		.inplace = 1,
+		.fn_map = fn,
+	};
 
-	isl_map_free(*map);
-	*map = copy;
-
-	return 0;
+	return un_op(umap, &control);
 }
 
-static __isl_give isl_union_map *inplace(__isl_take isl_union_map *umap,
-	__isl_give isl_map *(*fn)(__isl_take isl_map *))
+/* Remove redundant constraints in each of the basic maps of "umap".
+ * Since removing redundant constraints does not change the meaning
+ * or the space, the operation can be performed in-place.
+ */
+__isl_give isl_union_map *isl_union_map_remove_redundancies(
+	__isl_take isl_union_map *umap)
 {
-	if (!umap)
-		return NULL;
-
-	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
-				    &inplace_entry, &fn) < 0)
-		goto error;
+	return inplace(umap, &isl_map_remove_redundancies);
+}
 
-	return umap;
-error:
-	isl_union_map_free(umap);
-	return NULL;
+/* Remove redundant constraints in each of the basic sets of "uset".
+ */
+__isl_give isl_union_set *isl_union_set_remove_redundancies(
+	__isl_take isl_union_set *uset)
+{
+	return isl_union_map_remove_redundancies(uset);
 }
 
 __isl_give isl_union_map *isl_union_map_coalesce(
@@ -1618,19 +2185,10 @@
 	return isl_union_map_compute_divs(uset);
 }
 
-static int lexmin_entry(void **entry, void *user)
-{
-	isl_map **map = (isl_map **)entry;
-
-	*map = isl_map_lexmin(*map);
-
-	return *map ? 0 : -1;
-}
-
 __isl_give isl_union_map *isl_union_map_lexmin(
 	__isl_take isl_union_map *umap)
 {
-	return un_op(umap, &lexmin_entry);
+	return total(umap, &isl_map_lexmin);
 }
 
 __isl_give isl_union_set *isl_union_set_lexmin(
@@ -1639,19 +2197,10 @@
 	return isl_union_map_lexmin(uset);
 }
 
-static int lexmax_entry(void **entry, void *user)
-{
-	isl_map **map = (isl_map **)entry;
-
-	*map = isl_map_lexmax(*map);
-
-	return *map ? 0 : -1;
-}
-
 __isl_give isl_union_map *isl_union_map_lexmax(
 	__isl_take isl_union_map *umap)
 {
-	return un_op(umap, &lexmax_entry);
+	return total(umap, &isl_map_lexmax);
 }
 
 __isl_give isl_union_set *isl_union_set_lexmax(
@@ -1660,20 +2209,23 @@
 	return isl_union_map_lexmax(uset);
 }
 
-static int universe_entry(void **entry, void *user)
+/* Return the universe in the space of "map".
+ */
+static __isl_give isl_map *universe(__isl_take isl_map *map)
 {
-	isl_map *map = *entry;
-	isl_union_map **res = user;
-
-	map = isl_map_universe(isl_map_get_space(map));
-	*res = isl_union_map_add_map(*res, map);
+	isl_space *space;
 
-	return 0;
+	space = isl_map_get_space(map);
+	isl_map_free(map);
+	return isl_map_universe(space);
 }
 
 __isl_give isl_union_map *isl_union_map_universe(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &universe_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &universe,
+	};
+	return un_op(umap, &control);
 }
 
 __isl_give isl_union_set *isl_union_set_universe(__isl_take isl_union_set *uset)
@@ -1681,35 +2233,36 @@
 	return isl_union_map_universe(uset);
 }
 
-static int reverse_entry(void **entry, void *user)
-{
-	isl_map *map = *entry;
-	isl_union_map **res = user;
-
-	*res = isl_union_map_add_map(*res, isl_map_reverse(isl_map_copy(map)));
-
-	return 0;
-}
-
 __isl_give isl_union_map *isl_union_map_reverse(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &reverse_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_reverse,
+	};
+	return un_op(umap, &control);
 }
 
-static int params_entry(void **entry, void *user)
+/* Given a union map, take the maps of the form A -> (B -> C) and
+ * return the union of the corresponding maps A -> (C -> B).
+ */
+__isl_give isl_union_map *isl_union_map_range_reverse(
+	__isl_take isl_union_map *umap)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
-
-	*res = isl_union_set_add_set(*res, isl_map_params(isl_map_copy(map)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_range_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_range_reverse,
+	};
+	return un_op(umap, &control);
 }
 
 /* Compute the parameter domain of the given union map.
  */
 __isl_give isl_set *isl_union_map_params(__isl_take isl_union_map *umap)
 {
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_params,
+	};
 	int empty;
 
 	empty = isl_union_map_is_empty(umap);
@@ -1721,7 +2274,7 @@
 		isl_union_map_free(umap);
 		return isl_set_empty(space);
 	}
-	return isl_set_from_union_set(cond_un_op(umap, &params_entry));
+	return isl_set_from_union_set(un_op(umap, &control));
 error:
 	isl_union_map_free(umap);
 	return NULL;
@@ -1734,278 +2287,445 @@
 	return isl_union_map_params(uset);
 }
 
-static int domain_entry(void **entry, void *user)
+__isl_give isl_union_set *isl_union_map_domain(__isl_take isl_union_map *umap)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
-
-	*res = isl_union_set_add_set(*res, isl_map_domain(isl_map_copy(map)));
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_domain,
+	};
+	return un_op(umap, &control);
+}
 
-	return 0;
+__isl_give isl_union_set *isl_union_map_range(__isl_take isl_union_map *umap)
+{
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_range,
+	};
+	return un_op(umap, &control);
 }
 
-__isl_give isl_union_set *isl_union_map_domain(__isl_take isl_union_map *umap)
+__isl_give isl_union_map *isl_union_map_domain_map(
+	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &domain_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_domain_map,
+	};
+	return un_op(umap, &control);
 }
 
-static int range_entry(void **entry, void *user)
+/* Construct an isl_pw_multi_aff that maps "map" to its domain and
+ * add the result to "res".
+ */
+static isl_stat domain_map_upma(__isl_take isl_map *map, void *user)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
+	isl_union_pw_multi_aff **res = user;
+	isl_multi_aff *ma;
+	isl_pw_multi_aff *pma;
 
-	*res = isl_union_set_add_set(*res, isl_map_range(isl_map_copy(map)));
+	ma = isl_multi_aff_domain_map(isl_map_get_space(map));
+	pma = isl_pw_multi_aff_alloc(isl_map_wrap(map), ma);
+	*res = isl_union_pw_multi_aff_add_pw_multi_aff(*res, pma);
 
-	return 0;
-}
+	return *res ? isl_stat_ok : isl_stat_error;
 
-__isl_give isl_union_set *isl_union_map_range(__isl_take isl_union_map *umap)
-{
-	return cond_un_op(umap, &range_entry);
 }
 
-static int domain_map_entry(void **entry, void *user)
+/* Return an isl_union_pw_multi_aff that maps a wrapped copy of "umap"
+ * to its domain.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_map_domain_map_union_pw_multi_aff(
+	__isl_take isl_union_map *umap)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
+	isl_union_pw_multi_aff *res;
 
-	*res = isl_union_map_add_map(*res,
-					isl_map_domain_map(isl_map_copy(map)));
+	res = isl_union_pw_multi_aff_empty(isl_union_map_get_space(umap));
+	if (isl_union_map_foreach_map(umap, &domain_map_upma, &res) < 0)
+		res = isl_union_pw_multi_aff_free(res);
 
-	return 0;
+	isl_union_map_free(umap);
+	return res;
 }
 
-__isl_give isl_union_map *isl_union_map_domain_map(
+__isl_give isl_union_map *isl_union_map_range_map(
 	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &domain_map_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_range_map,
+	};
+	return un_op(umap, &control);
 }
 
-static int range_map_entry(void **entry, void *user)
+/* Given a collection of wrapped maps of the form AB -> C,
+ * return the collection of maps AB -> C -> B.
+ */
+__isl_give isl_union_map *isl_union_set_wrapped_domain_map(
+	__isl_take isl_union_set *uset)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
+	struct isl_un_op_drop_user_data data = { &isl_set_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_set_wrapped_domain_map,
+	};
+	return un_op(uset, &control);
+}
 
-	*res = isl_union_map_add_map(*res,
-					isl_map_range_map(isl_map_copy(map)));
+/* Does "map" relate elements from the same space?
+ */
+static isl_bool equal_tuples(__isl_keep isl_map *map, void *user)
+{
+	return isl_map_tuple_is_equal(map, isl_dim_in, map, isl_dim_out);
+}
 
-	return 0;
+__isl_give isl_union_set *isl_union_map_deltas(__isl_take isl_union_map *umap)
+{
+	struct isl_un_op_control control = {
+		.filter = &equal_tuples,
+		.fn_map = &isl_map_deltas,
+	};
+	return un_op(umap, &control);
 }
 
-__isl_give isl_union_map *isl_union_map_range_map(
+__isl_give isl_union_map *isl_union_map_deltas_map(
 	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &range_map_entry);
+	struct isl_un_op_control control = {
+		.filter = &equal_tuples,
+		.fn_map = &isl_map_deltas_map,
+	};
+	return un_op(umap, &control);
 }
 
-static int deltas_entry(void **entry, void *user)
+__isl_give isl_union_map *isl_union_set_identity(__isl_take isl_union_set *uset)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
-
-	if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
-					map->dim, isl_dim_out))
-		return 0;
-
-	*res = isl_union_set_add_set(*res, isl_map_deltas(isl_map_copy(map)));
-
-	return 0;
+	struct isl_un_op_control control = {
+		.fn_map = &isl_set_identity,
+	};
+	return un_op(uset, &control);
 }
 
-__isl_give isl_union_set *isl_union_map_deltas(__isl_take isl_union_map *umap)
+/* Construct an identity isl_pw_multi_aff on "set" and add it to *res.
+ */
+static isl_stat identity_upma(__isl_take isl_set *set, void *user)
 {
-	return cond_un_op(umap, &deltas_entry);
+	isl_union_pw_multi_aff **res = user;
+	isl_space *space;
+	isl_pw_multi_aff *pma;
+
+	space = isl_space_map_from_set(isl_set_get_space(set));
+	pma = isl_pw_multi_aff_identity(space);
+	pma = isl_pw_multi_aff_intersect_domain(pma, set);
+	*res = isl_union_pw_multi_aff_add_pw_multi_aff(*res, pma);
+
+	return *res ? isl_stat_ok : isl_stat_error;
 }
 
-static int deltas_map_entry(void **entry, void *user)
+/* Return an identity function on "uset" in the form
+ * of an isl_union_pw_multi_aff.
+ */
+__isl_give isl_union_pw_multi_aff *isl_union_set_identity_union_pw_multi_aff(
+	__isl_take isl_union_set *uset)
 {
-	isl_map *map = *entry;
-	isl_union_map **res = user;
+	isl_union_pw_multi_aff *res;
 
-	if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
-					map->dim, isl_dim_out))
-		return 0;
-
-	*res = isl_union_map_add_map(*res,
-				     isl_map_deltas_map(isl_map_copy(map)));
+	res = isl_union_pw_multi_aff_empty(isl_union_set_get_space(uset));
+	if (isl_union_set_foreach_set(uset, &identity_upma, &res) < 0)
+		res = isl_union_pw_multi_aff_free(res);
 
-	return 0;
+	isl_union_set_free(uset);
+	return res;
 }
 
-__isl_give isl_union_map *isl_union_map_deltas_map(
+/* For each map in "umap" of the form A -> B -> C,
+ * construct the map A -> C and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_domain_factor_domain(
 	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &deltas_map_entry);
+	struct isl_un_op_drop_user_data data = { &isl_map_domain_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_domain_factor_domain,
+	};
+	return un_op(umap, &control);
 }
 
-static int identity_entry(void **entry, void *user)
+/* For each map in "umap" of the form A -> B -> C,
+ * construct the map B -> C and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_domain_factor_range(
+	__isl_take isl_union_map *umap)
 {
-	isl_set *set = *entry;
-	isl_union_map **res = user;
-
-	*res = isl_union_map_add_map(*res, isl_set_identity(isl_set_copy(set)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_domain_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_domain_factor_range,
+	};
+	return un_op(umap, &control);
 }
 
-__isl_give isl_union_map *isl_union_set_identity(__isl_take isl_union_set *uset)
+/* For each map in "umap" of the form A -> B -> C,
+ * construct the map A -> B and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_range_factor_domain(
+	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(uset, &identity_entry);
+	struct isl_un_op_drop_user_data data = { &isl_map_range_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_range_factor_domain,
+	};
+	return un_op(umap, &control);
 }
 
-static int unwrap_entry(void **entry, void *user)
+/* For each map in "umap" of the form A -> B -> C,
+ * construct the map A -> C and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_range_factor_range(
+	__isl_take isl_union_map *umap)
 {
-	isl_set *set = *entry;
-	isl_union_set **res = user;
-
-	if (!isl_set_is_wrapping(set))
-		return 0;
-
-	*res = isl_union_map_add_map(*res, isl_set_unwrap(isl_set_copy(set)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_range_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_range_factor_range,
+	};
+	return un_op(umap, &control);
 }
 
-__isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset)
+/* For each map in "umap" of the form A -> B -> C -> D,
+ * construct the map A -> C and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_factor_domain(
+	__isl_take isl_union_map *umap)
 {
-	return cond_un_op(uset, &unwrap_entry);
+	struct isl_un_op_drop_user_data data = { &isl_map_is_product };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_factor_domain,
+	};
+	return un_op(umap, &control);
 }
 
-static int wrap_entry(void **entry, void *user)
+/* For each map in "umap" of the form A -> B -> C -> D,
+ * construct the map B -> D and collect the results.
+ */
+__isl_give isl_union_map *isl_union_map_factor_range(
+	__isl_take isl_union_map *umap)
 {
-	isl_map *map = *entry;
-	isl_union_set **res = user;
-
-	*res = isl_union_set_add_set(*res, isl_map_wrap(isl_map_copy(map)));
+	struct isl_un_op_drop_user_data data = { &isl_map_is_product };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_factor_range,
+	};
+	return un_op(umap, &control);
+}
 
-	return 0;
+__isl_give isl_union_map *isl_union_set_unwrap(__isl_take isl_union_set *uset)
+{
+	struct isl_un_op_drop_user_data data = { &isl_set_is_wrapping };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_set_unwrap,
+	};
+	return un_op(uset, &control);
 }
 
 __isl_give isl_union_set *isl_union_map_wrap(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &wrap_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_map_wrap,
+	};
+	return un_op(umap, &control);
 }
 
 struct isl_union_map_is_subset_data {
 	isl_union_map *umap2;
-	int is_subset;
+	isl_bool is_subset;
 };
 
-static int is_subset_entry(void **entry, void *user)
+static isl_stat is_subset_entry(void **entry, void *user)
 {
 	struct isl_union_map_is_subset_data *data = user;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry2;
+	isl_space *space;
 	isl_map *map = *entry;
 
-	hash = isl_space_get_hash(map->dim);
-	entry2 = isl_hash_table_find(data->umap2->dim->ctx, &data->umap2->table,
-				     hash, &has_dim, map->dim, 0);
-	if (!entry2) {
+	space = isl_map_peek_space(map);
+	entry2 = isl_union_map_find_entry(data->umap2, space, 0);
+	if (!entry2)
+		return isl_stat_error;
+	if (entry2 == isl_hash_table_entry_none) {
 		int empty = isl_map_is_empty(map);
 		if (empty < 0)
-			return -1;
+			return isl_stat_error;
 		if (empty)
-			return 0;
-		data->is_subset = 0;
-		return -1;
+			return isl_stat_ok;
+		data->is_subset = isl_bool_false;
+		return isl_stat_error;
 	}
 
 	data->is_subset = isl_map_is_subset(map, entry2->data);
 	if (data->is_subset < 0 || !data->is_subset)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-int isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_subset(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2)
 {
-	struct isl_union_map_is_subset_data data = { NULL, 1 };
-
-	umap1 = isl_union_map_copy(umap1);
-	umap2 = isl_union_map_copy(umap2);
-	umap1 = isl_union_map_align_params(umap1, isl_union_map_get_space(umap2));
-	umap2 = isl_union_map_align_params(umap2, isl_union_map_get_space(umap1));
+	struct isl_union_map_is_subset_data data = { NULL, isl_bool_true };
 
 	if (!umap1 || !umap2)
-		goto error;
+		return isl_bool_error;
 
 	data.umap2 = umap2;
 	if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
 				   &is_subset_entry, &data) < 0 &&
 	    data.is_subset)
-		goto error;
-
-	isl_union_map_free(umap1);
-	isl_union_map_free(umap2);
+		return isl_bool_error;
 
 	return data.is_subset;
-error:
-	isl_union_map_free(umap1);
-	isl_union_map_free(umap2);
-	return -1;
 }
 
-int isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_subset(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2)
 {
 	return isl_union_map_is_subset(uset1, uset2);
 }
 
-int isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_equal(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!umap1 || !umap2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_union_map_is_subset(umap1, umap2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_union_map_is_subset(umap2, umap1);
 	return is_subset;
 }
 
-int isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_equal(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2)
 {
 	return isl_union_map_is_equal(uset1, uset2);
 }
 
-int isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
+isl_bool isl_union_map_is_strict_subset(__isl_keep isl_union_map *umap1,
 	__isl_keep isl_union_map *umap2)
 {
-	int is_subset;
+	isl_bool is_subset;
 
 	if (!umap1 || !umap2)
-		return -1;
+		return isl_bool_error;
 	is_subset = isl_union_map_is_subset(umap1, umap2);
-	if (is_subset != 1)
+	if (is_subset != isl_bool_true)
 		return is_subset;
 	is_subset = isl_union_map_is_subset(umap2, umap1);
-	if (is_subset == -1)
-		return is_subset;
-	return !is_subset;
+	return isl_bool_not(is_subset);
 }
 
-int isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
+isl_bool isl_union_set_is_strict_subset(__isl_keep isl_union_set *uset1,
 	__isl_keep isl_union_set *uset2)
 {
 	return isl_union_map_is_strict_subset(uset1, uset2);
 }
 
-static int sample_entry(void **entry, void *user)
+/* Internal data structure for isl_union_map_is_disjoint.
+ * umap2 is the union map with which we are comparing.
+ * is_disjoint is initialized to 1 and is set to 0 as soon
+ * as the union maps turn out not to be disjoint.
+ */
+struct isl_union_map_is_disjoint_data {
+	isl_union_map *umap2;
+	isl_bool is_disjoint;
+};
+
+/* Check if "map" is disjoint from data->umap2 and abort
+ * the search if it is not.
+ */
+static isl_stat is_disjoint_entry(void **entry, void *user)
+{
+	struct isl_union_map_is_disjoint_data *data = user;
+	struct isl_hash_table_entry *entry2;
+	isl_space *space;
+	isl_map *map = *entry;
+
+	space = isl_map_peek_space(map);
+	entry2 = isl_union_map_find_entry(data->umap2, space, 0);
+	if (!entry2)
+		return isl_stat_error;
+	if (entry2 == isl_hash_table_entry_none)
+		return isl_stat_ok;
+
+	data->is_disjoint = isl_map_is_disjoint(map, entry2->data);
+	if (data->is_disjoint < 0 || !data->is_disjoint)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Are "umap1" and "umap2" disjoint?
+ */
+isl_bool isl_union_map_is_disjoint(__isl_keep isl_union_map *umap1,
+	__isl_keep isl_union_map *umap2)
+{
+	struct isl_union_map_is_disjoint_data data = { NULL, isl_bool_true };
+
+	umap1 = isl_union_map_copy(umap1);
+	umap2 = isl_union_map_copy(umap2);
+	umap1 = isl_union_map_align_params(umap1,
+						isl_union_map_get_space(umap2));
+	umap2 = isl_union_map_align_params(umap2,
+						isl_union_map_get_space(umap1));
+
+	if (!umap1 || !umap2)
+		goto error;
+
+	data.umap2 = umap2;
+	if (isl_hash_table_foreach(umap1->dim->ctx, &umap1->table,
+				   &is_disjoint_entry, &data) < 0 &&
+	    data.is_disjoint)
+		goto error;
+
+	isl_union_map_free(umap1);
+	isl_union_map_free(umap2);
+
+	return data.is_disjoint;
+error:
+	isl_union_map_free(umap1);
+	isl_union_map_free(umap2);
+	return isl_bool_error;
+}
+
+/* Are "uset1" and "uset2" disjoint?
+ */
+isl_bool isl_union_set_is_disjoint(__isl_keep isl_union_set *uset1,
+	__isl_keep isl_union_set *uset2)
+{
+	return isl_union_map_is_disjoint(uset1, uset2);
+}
+
+static isl_stat sample_entry(void **entry, void *user)
 {
 	isl_basic_map **sample = (isl_basic_map **)user;
 	isl_map *map = *entry;
 
 	*sample = isl_map_sample(isl_map_copy(map));
 	if (!*sample)
-		return -1;
+		return isl_stat_error;
 	if (!isl_basic_map_plain_is_empty(*sample))
-		return -1;
-	return 0;
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 __isl_give isl_basic_map *isl_union_map_sample(__isl_take isl_union_map *umap)
@@ -2033,107 +2753,127 @@
 
 __isl_give isl_basic_set *isl_union_set_sample(__isl_take isl_union_set *uset)
 {
-	return (isl_basic_set *)isl_union_map_sample(uset);
+	return bset_from_bmap(isl_union_map_sample(uset));
+}
+
+/* Return an element in "uset" in the form of an isl_point.
+ * Return a void isl_point if "uset" is empty.
+ */
+__isl_give isl_point *isl_union_set_sample_point(__isl_take isl_union_set *uset)
+{
+	return isl_basic_set_sample_point(isl_union_set_sample(uset));
 }
 
 struct isl_forall_data {
-	int res;
-	int (*fn)(__isl_keep isl_map *map);
+	isl_bool res;
+	isl_bool (*fn)(__isl_keep isl_map *map);
 };
 
-static int forall_entry(void **entry, void *user)
+static isl_stat forall_entry(void **entry, void *user)
 {
 	struct isl_forall_data *data = user;
 	isl_map *map = *entry;
 
 	data->res = data->fn(map);
 	if (data->res < 0)
-		return -1;
+		return isl_stat_error;
 
 	if (!data->res)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-static int union_map_forall(__isl_keep isl_union_map *umap,
-	int (*fn)(__isl_keep isl_map *map))
+static isl_bool union_map_forall(__isl_keep isl_union_map *umap,
+	isl_bool (*fn)(__isl_keep isl_map *map))
 {
-	struct isl_forall_data data = { 1, fn };
+	struct isl_forall_data data = { isl_bool_true, fn };
 
 	if (!umap)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 				   &forall_entry, &data) < 0 && data.res)
-		return -1;
+		return isl_bool_error;
 
 	return data.res;
 }
 
 struct isl_forall_user_data {
-	int res;
-	int (*fn)(__isl_keep isl_map *map, void *user);
+	isl_bool res;
+	isl_bool (*fn)(__isl_keep isl_map *map, void *user);
 	void *user;
 };
 
-static int forall_user_entry(void **entry, void *user)
+static isl_stat forall_user_entry(void **entry, void *user)
 {
 	struct isl_forall_user_data *data = user;
 	isl_map *map = *entry;
 
 	data->res = data->fn(map, data->user);
 	if (data->res < 0)
-		return -1;
+		return isl_stat_error;
 
 	if (!data->res)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Check if fn(map, user) returns true for all maps "map" in umap.
  */
-static int union_map_forall_user(__isl_keep isl_union_map *umap,
-	int (*fn)(__isl_keep isl_map *map, void *user), void *user)
+static isl_bool union_map_forall_user(__isl_keep isl_union_map *umap,
+	isl_bool (*fn)(__isl_keep isl_map *map, void *user), void *user)
 {
-	struct isl_forall_user_data data = { 1, fn, user };
+	struct isl_forall_user_data data = { isl_bool_true, fn, user };
 
 	if (!umap)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_hash_table_foreach(umap->dim->ctx, &umap->table,
 				   &forall_user_entry, &data) < 0 && data.res)
-		return -1;
+		return isl_bool_error;
 
 	return data.res;
 }
 
-int isl_union_map_is_empty(__isl_keep isl_union_map *umap)
+/* Is "umap" obviously empty?
+ */
+isl_bool isl_union_map_plain_is_empty(__isl_keep isl_union_map *umap)
+{
+	isl_size n;
+
+	n = isl_union_map_n_map(umap);
+	if (n < 0)
+		return isl_bool_error;
+	return n == 0;
+}
+
+isl_bool isl_union_map_is_empty(__isl_keep isl_union_map *umap)
 {
 	return union_map_forall(umap, &isl_map_is_empty);
 }
 
-int isl_union_set_is_empty(__isl_keep isl_union_set *uset)
+isl_bool isl_union_set_is_empty(__isl_keep isl_union_set *uset)
 {
 	return isl_union_map_is_empty(uset);
 }
 
-static int is_subset_of_identity(__isl_keep isl_map *map)
+static isl_bool is_subset_of_identity(__isl_keep isl_map *map)
 {
-	int is_subset;
-	isl_space *dim;
+	isl_bool is_subset;
+	isl_space *space;
 	isl_map *id;
+	isl_bool match;
 
-	if (!map)
-		return -1;
+	match = isl_map_tuple_is_equal(map, isl_dim_in, map, isl_dim_out);
+	if (match < 0)
+		return isl_bool_error;
+	if (!match)
+		return isl_bool_false;
 
-	if (!isl_space_tuple_is_equal(map->dim, isl_dim_in,
-					map->dim, isl_dim_out))
-		return 0;
-
-	dim = isl_map_get_space(map);
-	id = isl_map_identity(dim);
+	space = isl_map_get_space(map);
+	id = isl_map_identity(space);
 
 	is_subset = isl_map_is_subset(map, id);
 
@@ -2145,10 +2885,10 @@
 /* Given an isl_union_map that consists of a single map, check
  * if it is single-valued.
  */
-static int single_map_is_single_valued(__isl_keep isl_union_map *umap)
+static isl_bool single_map_is_single_valued(__isl_keep isl_union_map *umap)
 {
 	isl_map *map;
-	int sv;
+	isl_bool sv;
 
 	umap = isl_union_map_copy(umap);
 	map = isl_map_from_union_map(umap);
@@ -2165,7 +2905,7 @@
  */
 struct isl_union_map_is_sv_data {
 	isl_union_map *umap;
-	int sv;
+	isl_bool sv;
 };
 
 /* Check if the data->umap is single-valued on "set".
@@ -2183,16 +2923,20 @@
  * Terminate as soon as data->umap has been determined not to
  * be single-valued.
  */
-static int single_valued_on_domain(__isl_take isl_set *set, void *user)
+static isl_stat single_valued_on_domain(__isl_take isl_set *set, void *user)
 {
 	struct isl_union_map_is_sv_data *data = user;
 	isl_union_map *umap, *test;
+	isl_size n;
 
 	umap = isl_union_map_copy(data->umap);
 	umap = isl_union_map_intersect_domain(umap,
 						isl_union_set_from_set(set));
 
-	if (isl_union_map_n_map(umap) == 1) {
+	n = isl_union_map_n_map(umap);
+	if (n < 0) {
+		data->sv = isl_bool_error;
+	} else if (n == 1) {
 		data->sv = single_map_is_single_valued(umap);
 		isl_union_map_free(umap);
 	} else {
@@ -2205,8 +2949,8 @@
 	}
 
 	if (data->sv < 0 || !data->sv)
-		return -1;
-	return 0;
+		return isl_stat_error;
+	return isl_stat_ok;
 }
 
 /* Check if the given map is single-valued.
@@ -2215,31 +2959,35 @@
  * Otherwise, check if the union map is single-valued on each of its
  * domain spaces.
  */
-int isl_union_map_is_single_valued(__isl_keep isl_union_map *umap)
+isl_bool isl_union_map_is_single_valued(__isl_keep isl_union_map *umap)
 {
 	isl_union_map *universe;
 	isl_union_set *domain;
 	struct isl_union_map_is_sv_data data;
+	isl_size n;
 
-	if (isl_union_map_n_map(umap) == 1)
+	n = isl_union_map_n_map(umap);
+	if (n < 0)
+		return isl_bool_error;
+	if (n == 1)
 		return single_map_is_single_valued(umap);
 
 	universe = isl_union_map_universe(isl_union_map_copy(umap));
 	domain = isl_union_map_domain(universe);
 
-	data.sv = 1;
+	data.sv = isl_bool_true;
 	data.umap = umap;
 	if (isl_union_set_foreach_set(domain,
 			    &single_valued_on_domain, &data) < 0 && data.sv)
-		data.sv = -1;
+		data.sv = isl_bool_error;
 	isl_union_set_free(domain);
 
 	return data.sv;
 }
 
-int isl_union_map_is_injective(__isl_keep isl_union_map *umap)
+isl_bool isl_union_map_is_injective(__isl_keep isl_union_map *umap)
 {
-	int in;
+	isl_bool in;
 
 	umap = isl_union_map_copy(umap);
 	umap = isl_union_map_reverse(umap);
@@ -2249,6 +2997,98 @@
 	return in;
 }
 
+/* Is "map" obviously not an identity relation because
+ * it maps elements from one space to another space?
+ * Update *non_identity accordingly.
+ *
+ * In particular, if the domain and range spaces are the same,
+ * then the map is not considered to obviously not be an identity relation.
+ * Otherwise, the map is considered to obviously not be an identity relation
+ * if it is is non-empty.
+ *
+ * If "map" is determined to obviously not be an identity relation,
+ * then the search is aborted.
+ */
+static isl_stat map_plain_is_not_identity(__isl_take isl_map *map, void *user)
+{
+	isl_bool *non_identity = user;
+	isl_bool equal;
+
+	equal = isl_map_tuple_is_equal(map, isl_dim_in, map, isl_dim_out);
+	if (equal >= 0 && !equal)
+		*non_identity = isl_bool_not(isl_map_is_empty(map));
+	else
+		*non_identity = isl_bool_not(equal);
+	isl_map_free(map);
+
+	if (*non_identity < 0 || *non_identity)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Is "umap" obviously not an identity relation because
+ * it maps elements from one space to another space?
+ *
+ * As soon as a map has been found that maps elements to a different space,
+ * non_identity is changed and the search is aborted.
+ */
+static isl_bool isl_union_map_plain_is_not_identity(
+	__isl_keep isl_union_map *umap)
+{
+	isl_bool non_identity;
+
+	non_identity = isl_bool_false;
+	if (isl_union_map_foreach_map(umap, &map_plain_is_not_identity,
+					&non_identity) < 0 &&
+	    non_identity == isl_bool_false)
+		return isl_bool_error;
+
+	return non_identity;
+}
+
+/* Does "map" only map elements to themselves?
+ * Update *identity accordingly.
+ *
+ * If "map" is determined not to be an identity relation,
+ * then the search is aborted.
+ */
+static isl_stat map_is_identity(__isl_take isl_map *map, void *user)
+{
+	isl_bool *identity = user;
+
+	*identity = isl_map_is_identity(map);
+	isl_map_free(map);
+
+	if (*identity < 0 || !*identity)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Does "umap" only map elements to themselves?
+ *
+ * First check if there are any maps that map elements to different spaces.
+ * If not, then check that all the maps (between identical spaces)
+ * are identity relations.
+ */
+isl_bool isl_union_map_is_identity(__isl_keep isl_union_map *umap)
+{
+	isl_bool non_identity;
+	isl_bool identity;
+
+	non_identity = isl_union_map_plain_is_not_identity(umap);
+	if (non_identity < 0 || non_identity)
+		return isl_bool_not(non_identity);
+
+	identity = isl_bool_true;
+	if (isl_union_map_foreach_map(umap, &map_is_identity, &identity) < 0 &&
+	    identity == isl_bool_true)
+		return isl_bool_error;
+
+	return identity;
+}
+
 /* Represents a map that has a fixed value (v) for one of its
  * range dimensions.
  * The map in this structure is not reference counted, so it
@@ -2307,7 +3147,7 @@
 	int pos;
 };
 
-static int fixed_at_pos(__isl_keep isl_map *map, void *user)
+static isl_bool fixed_at_pos(__isl_keep isl_map *map, void *user)
 {
 	struct isl_fixed_dim_data *data = user;
 
@@ -2316,7 +3156,7 @@
 				      &data->vdata->n++.v);
 }
 
-static int plain_injective_on_range(__isl_take isl_union_map *umap,
+static isl_bool plain_injective_on_range(__isl_take isl_union_map *umap,
 	int first, int n_range);
 
 /* Given a list of the maps, with their fixed values at output dimension "pos",
@@ -2330,7 +3170,7 @@
  * based on later dimensions.
  */
 static int separates(struct isl_fixed_map *v, int n,
-	__isl_take isl_space *dim, int pos, int n_range)
+	__isl_take isl_space *space, int pos, int n_range)
 {
 	int i;
 
@@ -2351,7 +3191,7 @@
 		if (j == i + 1)
 			continue;
 
-		part = isl_union_map_alloc(isl_space_copy(dim), j - i);
+		part = isl_union_map_alloc(isl_space_copy(space), j - i);
 		for (k = i; k < j; ++k)
 			part = isl_union_map_add_map(part,
 						     isl_map_copy(vk.map));
@@ -2365,11 +3205,11 @@
 		i = j - 1;
 	}
 
-	isl_space_free(dim);
+	isl_space_free(space);
 	free_isl_fixed_map_array(v, n);
 	return i + 1 >= n;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	free_isl_fixed_map_array(v, n);
 	return -1;
 }
@@ -2380,27 +3220,27 @@
  * and then check if these values, possibly along with fixed values
  * at later dimensions, entail distinct ranges.
  */
-static int plain_injective_on_range(__isl_take isl_union_map *umap,
+static isl_bool plain_injective_on_range(__isl_take isl_union_map *umap,
 	int first, int n_range)
 {
 	isl_ctx *ctx;
-	int n;
+	isl_size n;
 	struct isl_fixed_dim_data data = { NULL };
 
 	ctx = isl_union_map_get_ctx(umap);
 
 	n = isl_union_map_n_map(umap);
-	if (!umap)
+	if (n < 0)
 		goto error;
 
 	if (n <= 1) {
 		isl_union_map_free(umap);
-		return 1;
+		return isl_bool_true;
 	}
 
 	if (first >= n_range) {
 		isl_union_map_free(umap);
-		return 0;
+		return isl_bool_false;
 	}
 
 	data.v = alloc_isl_fixed_map_array(ctx, n);
@@ -2408,9 +3248,9 @@
 		goto error;
 
 	for (data.pos = first; data.pos < n_range; ++data.pos) {
-		int fixed;
+		isl_bool fixed;
 		int injective;
-		isl_space *dim;
+		isl_space *space;
 
 		data.n = 0;
 		fixed = union_map_forall_user(umap, &fixed_at_pos, &data);
@@ -2418,8 +3258,8 @@
 			goto error;
 		if (!fixed)
 			continue;
-		dim = isl_union_map_get_space(umap);
-		injective = separates(data.v, n, dim, data.pos, n_range);
+		space = isl_union_map_get_space(umap);
+		injective = separates(data.v, n, space, data.pos, n_range);
 		isl_union_map_free(umap);
 		return injective;
 	}
@@ -2427,24 +3267,30 @@
 	free_isl_fixed_map_array(data.v, n);
 	isl_union_map_free(umap);
 
-	return 0;
+	return isl_bool_false;
 error:
 	free_isl_fixed_map_array(data.v, n);
 	isl_union_map_free(umap);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Check whether the maps in umap that map to subsets of "ran"
  * have obviously distinct ranges.
  */
-static int plain_injective_on_range_wrap(__isl_keep isl_set *ran, void *user)
+static isl_bool plain_injective_on_range_wrap(__isl_keep isl_set *ran,
+	void *user)
 {
+	isl_size dim;
 	isl_union_map *umap = user;
 
+	dim = isl_set_dim(ran, isl_dim_set);
+	if (dim < 0)
+		return isl_bool_error;
+
 	umap = isl_union_map_copy(umap);
 	umap = isl_union_map_intersect_range(umap,
 			isl_union_set_from_set(isl_set_copy(ran)));
-	return plain_injective_on_range(umap, 0, isl_set_dim(ran, isl_dim_set));
+	return plain_injective_on_range(umap, 0, dim);
 }
 
 /* Check if the given union_map is obviously injective.
@@ -2453,17 +3299,17 @@
  * injective and then check if all the ranges of these maps are
  * obviously disjoint.
  */
-int isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap)
+isl_bool isl_union_map_plain_is_injective(__isl_keep isl_union_map *umap)
 {
-	int in;
+	isl_bool in;
 	isl_union_map *univ;
 	isl_union_set *ran;
 
 	in = union_map_forall(umap, &isl_map_plain_is_injective);
 	if (in < 0)
-		return -1;
+		return isl_bool_error;
 	if (!in)
-		return 0;
+		return isl_bool_false;
 
 	univ = isl_union_map_universe(isl_union_map_copy(umap));
 	ran = isl_union_map_range(univ);
@@ -2475,9 +3321,9 @@
 	return in;
 }
 
-int isl_union_map_is_bijective(__isl_keep isl_union_map *umap)
+isl_bool isl_union_map_is_bijective(__isl_keep isl_union_map *umap)
 {
-	int sv;
+	isl_bool sv;
 
 	sv = isl_union_map_is_single_valued(umap);
 	if (sv < 0 || !sv)
@@ -2486,35 +3332,15 @@
 	return isl_union_map_is_injective(umap);
 }
 
-static int zip_entry(void **entry, void *user)
-{
-	isl_map *map = *entry;
-	isl_union_map **res = user;
-
-	if (!isl_map_can_zip(map))
-		return 0;
-
-	*res = isl_union_map_add_map(*res, isl_map_zip(isl_map_copy(map)));
-
-	return 0;
-}
-
 __isl_give isl_union_map *isl_union_map_zip(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &zip_entry);
-}
-
-static int uncurry_entry(void **entry, void *user)
-{
-	isl_map *map = *entry;
-	isl_union_map **res = user;
-
-	if (!isl_map_can_uncurry(map))
-		return 0;
-
-	*res = isl_union_map_add_map(*res, isl_map_uncurry(isl_map_copy(map)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_can_zip };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_zip,
+	};
+	return un_op(umap, &control);
 }
 
 /* Given a union map, take the maps of the form A -> (B -> C) and
@@ -2522,20 +3348,13 @@
  */
 __isl_give isl_union_map *isl_union_map_uncurry(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &uncurry_entry);
-}
-
-static int curry_entry(void **entry, void *user)
-{
-	isl_map *map = *entry;
-	isl_union_map **res = user;
-
-	if (!isl_map_can_curry(map))
-		return 0;
-
-	*res = isl_union_map_add_map(*res, isl_map_curry(isl_map_copy(map)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_can_uncurry };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_uncurry,
+	};
+	return un_op(umap, &control);
 }
 
 /* Given a union map, take the maps of the form (A -> B) -> C and
@@ -2543,25 +3362,39 @@
  */
 __isl_give isl_union_map *isl_union_map_curry(__isl_take isl_union_map *umap)
 {
-	return cond_un_op(umap, &curry_entry);
+	struct isl_un_op_drop_user_data data = { &isl_map_can_curry };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_curry,
+	};
+	return un_op(umap, &control);
 }
 
-static int lift_entry(void **entry, void *user)
+/* Given a union map, take the maps of the form A -> ((B -> C) -> D) and
+ * return the union of the corresponding maps A -> (B -> (C -> D)).
+ */
+__isl_give isl_union_map *isl_union_map_range_curry(
+	__isl_take isl_union_map *umap)
 {
-	isl_set *set = *entry;
-	isl_union_set **res = user;
-
-	*res = isl_union_set_add_set(*res, isl_set_lift(isl_set_copy(set)));
-
-	return 0;
+	struct isl_un_op_drop_user_data data = { &isl_map_can_range_curry };
+	struct isl_un_op_control control = {
+		.filter = &un_op_filter_drop_user,
+		.filter_user = &data,
+		.fn_map = &isl_map_range_curry,
+	};
+	return un_op(umap, &control);
 }
 
 __isl_give isl_union_set *isl_union_set_lift(__isl_take isl_union_set *uset)
 {
-	return cond_un_op(uset, &lift_entry);
+	struct isl_un_op_control control = {
+		.fn_map = &isl_set_lift,
+	};
+	return un_op(uset, &control);
 }
 
-static int coefficients_entry(void **entry, void *user)
+static isl_stat coefficients_entry(void **entry, void *user)
 {
 	isl_set *set = *entry;
 	isl_union_set **res = user;
@@ -2570,22 +3403,22 @@
 	set = isl_set_from_basic_set(isl_set_coefficients(set));
 	*res = isl_union_set_add_set(*res, set);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_set *isl_union_set_coefficients(
 	__isl_take isl_union_set *uset)
 {
 	isl_ctx *ctx;
-	isl_space *dim;
+	isl_space *space;
 	isl_union_set *res;
 
 	if (!uset)
 		return NULL;
 
 	ctx = isl_union_set_get_ctx(uset);
-	dim = isl_space_set_alloc(ctx, 0, 0);
-	res = isl_union_map_alloc(dim, uset->table.n);
+	space = isl_space_set_alloc(ctx, 0, 0);
+	res = isl_union_map_alloc(space, uset->table.n);
 	if (isl_hash_table_foreach(uset->dim->ctx, &uset->table,
 				   &coefficients_entry, &res) < 0)
 		goto error;
@@ -2598,7 +3431,7 @@
 	return NULL;
 }
 
-static int solutions_entry(void **entry, void *user)
+static isl_stat solutions_entry(void **entry, void *user)
 {
 	isl_set *set = *entry;
 	isl_union_set **res = user;
@@ -2611,9 +3444,9 @@
 		*res = isl_union_set_add_set(*res, set);
 
 	if (!*res)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_set *isl_union_set_solutions(
@@ -2646,7 +3479,7 @@
  */
 static int domain_match(__isl_keep isl_map *map, __isl_keep isl_space *space)
 {
-	return isl_space_tuple_is_equal(map->dim, isl_dim_in,
+	return isl_map_space_tuple_is_equal(map, isl_dim_in,
 					space, isl_dim_out);
 }
 
@@ -2654,7 +3487,7 @@
  */
 static int range_match(__isl_keep isl_map *map, __isl_keep isl_space *space)
 {
-	return isl_space_tuple_is_equal(map->dim, isl_dim_out,
+	return isl_map_space_tuple_is_equal(map, isl_dim_out,
 					space, isl_dim_out);
 }
 
@@ -2662,7 +3495,7 @@
  */
 static int set_match(__isl_keep isl_map *map, __isl_keep isl_space *space)
 {
-	return isl_space_tuple_is_equal(map->dim, isl_dim_set,
+	return isl_map_space_tuple_is_equal(map, isl_dim_set,
 					space, isl_dim_out);
 }
 
@@ -2688,18 +3521,18 @@
  * space of *entry matches the target space of data->pma
  * (as given by data->match), and add the result to data->res.
  */
-static int preimage_entry(void **entry, void *user)
+static isl_stat preimage_entry(void **entry, void *user)
 {
 	int m;
 	isl_map *map = *entry;
 	struct isl_union_map_preimage_data *data = user;
-	int empty;
+	isl_bool empty;
 
 	m = data->match(map, data->space);
 	if (m < 0)
-		return -1;
+		return isl_stat_error;
 	if (!m)
-		return 0;
+		return isl_stat_ok;
 
 	map = isl_map_copy(map);
 	map = data->fn(map, isl_pw_multi_aff_copy(data->pma));
@@ -2707,12 +3540,12 @@
 	empty = isl_map_is_empty(map);
 	if (empty < 0 || empty) {
 		isl_map_free(map);
-		return empty < 0 ? -1 : 0;
+		return empty < 0 ? isl_stat_error : isl_stat_ok;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Compute the preimage of the domain or range of "umap" under the function
@@ -2863,18 +3696,18 @@
  * space of *entry matches the target space of data->mpa
  * (as given by data->match), and add the result to data->res.
  */
-static int preimage_mpa_entry(void **entry, void *user)
+static isl_stat preimage_mpa_entry(void **entry, void *user)
 {
 	int m;
 	isl_map *map = *entry;
 	struct isl_union_map_preimage_mpa_data *data = user;
-	int empty;
+	isl_bool empty;
 
 	m = data->match(map, data->space);
 	if (m < 0)
-		return -1;
+		return isl_stat_error;
 	if (!m)
-		return 0;
+		return isl_stat_ok;
 
 	map = isl_map_copy(map);
 	map = data->fn(map, isl_multi_pw_aff_copy(data->mpa));
@@ -2882,12 +3715,12 @@
 	empty = isl_map_is_empty(map);
 	if (empty < 0 || empty) {
 		isl_map_free(map);
-		return empty < 0 ? -1 : 0;
+		return empty < 0 ? isl_stat_error : isl_stat_ok;
 	}
 
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Compute the preimage of the domain or range of "umap" under the function
@@ -2964,7 +3797,7 @@
 /* Call data->fn to compute the preimage of the domain or range of data->umap
  * under the function represented by pma and add the result to data->res.
  */
-static int preimage_upma(__isl_take isl_pw_multi_aff *pma, void *user)
+static isl_stat preimage_upma(__isl_take isl_pw_multi_aff *pma, void *user)
 {
 	struct isl_union_map_preimage_upma_data *data = user;
 	isl_union_map *umap;
@@ -2973,7 +3806,7 @@
 	umap = data->fn(umap, pma);
 	data->res = isl_union_map_union(data->res, umap);
 
-	return data->res ? 0 : -1;
+	return data->res ? isl_stat_ok : isl_stat_error;
 }
 
 /* Compute the preimage of the domain or range of "umap" under the function
@@ -3008,8 +3841,8 @@
  * In other words, plug in "upma" in the domain of "umap".
  * The result contains maps that live in the same spaces as the maps of "umap"
  * with domain space equal to one of the target spaces of "upma",
- * except that the domain has been replaced by one of the the domain spaces that
- * corresponds to that target space of "upma".
+ * except that the domain has been replaced by one of the domain spaces that
+ * correspond to that target space of "upma".
  */
 __isl_give isl_union_map *isl_union_map_preimage_domain_union_pw_multi_aff(
 	__isl_take isl_union_map *umap,
@@ -3024,8 +3857,8 @@
  * In other words, plug in "upma" in the range of "umap".
  * The result contains maps that live in the same spaces as the maps of "umap"
  * with range space equal to one of the target spaces of "upma",
- * except that the range has been replaced by one of the the domain spaces that
- * corresponds to that target space of "upma".
+ * except that the range has been replaced by one of the domain spaces that
+ * correspond to that target space of "upma".
  */
 __isl_give isl_union_map *isl_union_map_preimage_range_union_pw_multi_aff(
 	__isl_take isl_union_map *umap,
@@ -3039,8 +3872,8 @@
  * In other words, plug in "upma" in the range of "uset".
  * The result contains sets that live in the same spaces as the sets of "uset"
  * with space equal to one of the target spaces of "upma",
- * except that the space has been replaced by one of the the domain spaces that
- * corresponds to that target space of "upma".
+ * except that the space has been replaced by one of the domain spaces that
+ * correspond to that target space of "upma".
  */
 __isl_give isl_union_set *isl_union_set_preimage_union_pw_multi_aff(
 	__isl_take isl_union_set *uset,
@@ -3051,18 +3884,6 @@
 }
 
 /* Reset the user pointer on all identifiers of parameters and tuples
- * of the space of *entry.
- */
-static int reset_user(void **entry, void *user)
-{
-	isl_map **map = (isl_map **)entry;
-
-	*map = isl_map_reset_user(*map);
-
-	return *map ? 0 : -1;
-}
-
-/* Reset the user pointer on all identifiers of parameters and tuples
  * of the spaces of "umap".
  */
 __isl_give isl_union_map *isl_union_map_reset_user(
@@ -3074,9 +3895,7 @@
 	umap->dim = isl_space_reset_user(umap->dim);
 	if (!umap->dim)
 		return isl_union_map_free(umap);
-	umap = un_op(umap, &reset_user);
-
-	return umap;
+	return total(umap, &isl_map_reset_user);
 }
 
 /* Reset the user pointer on all identifiers of parameters and tuples
@@ -3088,6 +3907,24 @@
 	return isl_union_map_reset_user(uset);
 }
 
+/* Remove all existentially quantified variables and integer divisions
+ * from "umap" using Fourier-Motzkin elimination.
+ */
+__isl_give isl_union_map *isl_union_map_remove_divs(
+	__isl_take isl_union_map *umap)
+{
+	return total(umap, &isl_map_remove_divs);
+}
+
+/* Remove all existentially quantified variables and integer divisions
+ * from "uset" using Fourier-Motzkin elimination.
+ */
+__isl_give isl_union_set *isl_union_set_remove_divs(
+	__isl_take isl_union_set *uset)
+{
+	return isl_union_map_remove_divs(uset);
+}
+
 /* Internal data structure for isl_union_map_project_out.
  * "type", "first" and "n" are the arguments for the isl_map_project_out
  * call.
@@ -3104,14 +3941,14 @@
 /* Turn the data->n dimensions of type data->type, starting at data->first
  * into existentially quantified variables and add the result to data->res.
  */
-static int project_out(__isl_take isl_map *map, void *user)
+static isl_stat project_out(__isl_take isl_map *map, void *user)
 {
 	struct isl_union_map_project_out_data *data = user;
 
 	map = isl_map_project_out(map, data->type, data->first, data->n);
 	data->res = isl_union_map_add_map(data->res, map);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Turn the "n" dimensions of type "type", starting at "first"
@@ -3144,3 +3981,584 @@
 
 	return data.res;
 }
+
+#undef TYPE
+#define TYPE	isl_union_map
+#include "isl_project_out_all_params_templ.c"
+
+/* Turn the "n" dimensions of type "type", starting at "first"
+ * into existentially quantified variables.
+ * Since the space of an isl_union_set only contains parameters,
+ * "type" is required to be equal to isl_dim_param.
+ */
+__isl_give isl_union_set *isl_union_set_project_out(
+	__isl_take isl_union_set *uset,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	return isl_union_map_project_out(uset, type, first, n);
+}
+
+/* Project out all parameters from "uset" by existentially quantifying
+ * over them.
+ */
+__isl_give isl_union_set *isl_union_set_project_out_all_params(
+	__isl_take isl_union_set *uset)
+{
+	return uset_from_umap(
+		    isl_union_map_project_out_all_params(uset_to_umap(uset)));
+}
+
+/* Internal data structure for isl_union_map_involves_dims.
+ * "first" and "n" are the arguments for the isl_map_involves_dims calls.
+ */
+struct isl_union_map_involves_dims_data {
+	unsigned first;
+	unsigned n;
+};
+
+/* Does "map" _not_ involve the data->n parameters starting at data->first?
+ */
+static isl_bool map_excludes(__isl_keep isl_map *map, void *user)
+{
+	struct isl_union_map_involves_dims_data *data = user;
+	isl_bool involves;
+
+	involves = isl_map_involves_dims(map,
+					isl_dim_param, data->first, data->n);
+	return isl_bool_not(involves);
+}
+
+/* Does "umap" involve any of the n parameters starting at first?
+ * "type" is required to be set to isl_dim_param.
+ *
+ * "umap" involves any of those parameters if any of its maps
+ * involve the parameters.  In other words, "umap" does not
+ * involve any of the parameters if all its maps to not
+ * involve the parameters.
+ */
+isl_bool isl_union_map_involves_dims(__isl_keep isl_union_map *umap,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	struct isl_union_map_involves_dims_data data = { first, n };
+	isl_bool excludes;
+
+	if (type != isl_dim_param)
+		isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,
+			"can only reference parameters", return isl_bool_error);
+
+	excludes = union_map_forall_user(umap, &map_excludes, &data);
+
+	return isl_bool_not(excludes);
+}
+
+/* Internal data structure for isl_union_map_reset_range_space.
+ * "range" is the space from which to set the range space.
+ * "res" collects the results.
+ */
+struct isl_union_map_reset_range_space_data {
+	isl_space *range;
+	isl_union_map *res;
+};
+
+/* Replace the range space of "map" by the range space of data->range and
+ * add the result to data->res.
+ */
+static isl_stat reset_range_space(__isl_take isl_map *map, void *user)
+{
+	struct isl_union_map_reset_range_space_data *data = user;
+	isl_space *space;
+
+	space = isl_map_get_space(map);
+	space = isl_space_domain(space);
+	space = isl_space_extend_domain_with_range(space,
+						isl_space_copy(data->range));
+	map = isl_map_reset_space(map, space);
+	data->res = isl_union_map_add_map(data->res, map);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Replace the range space of all the maps in "umap" by
+ * the range space of "space".
+ *
+ * This assumes that all maps have the same output dimension.
+ * This function should therefore not be made publicly available.
+ *
+ * Since the spaces of the maps change, so do their hash value.
+ * We therefore need to create a new isl_union_map.
+ */
+__isl_give isl_union_map *isl_union_map_reset_range_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space)
+{
+	struct isl_union_map_reset_range_space_data data = { space };
+
+	data.res = isl_union_map_empty(isl_union_map_get_space(umap));
+	if (isl_union_map_foreach_map(umap, &reset_range_space, &data) < 0)
+		data.res = isl_union_map_free(data.res);
+
+	isl_space_free(space);
+	isl_union_map_free(umap);
+	return data.res;
+}
+
+/* Check that "umap" and "space" have the same number of parameters.
+ */
+static isl_stat check_union_map_space_equal_dim(__isl_keep isl_union_map *umap,
+	__isl_keep isl_space *space)
+{
+	isl_size dim1, dim2;
+
+	dim1 = isl_union_map_dim(umap, isl_dim_param);
+	dim2 = isl_space_dim(space, isl_dim_param);
+	if (dim1 < 0 || dim2 < 0)
+		return isl_stat_error;
+	if (dim1 == dim2)
+		return isl_stat_ok;
+	isl_die(isl_union_map_get_ctx(umap), isl_error_invalid,
+		"number of parameters does not match", return isl_stat_error);
+}
+
+/* Internal data structure for isl_union_map_reset_equal_dim_space.
+ * "space" is the target space.
+ * "res" collects the results.
+ */
+struct isl_union_map_reset_params_data {
+	isl_space *space;
+	isl_union_map *res;
+};
+
+/* Replace the parameters of "map" by those of data->space and
+ * add the result to data->res.
+ */
+static isl_stat reset_params(__isl_take isl_map *map, void *user)
+{
+	struct isl_union_map_reset_params_data *data = user;
+	isl_space *space;
+
+	space = isl_map_get_space(map);
+	space = isl_space_replace_params(space, data->space);
+	map = isl_map_reset_equal_dim_space(map, space);
+	data->res = isl_union_map_add_map(data->res, map);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* Replace the space of "umap" by "space", without modifying
+ * the dimension of "umap", i.e., the number of parameters of "umap".
+ *
+ * Since the hash values of the maps in the union map depend
+ * on the parameters, a new union map needs to be constructed.
+ */
+__isl_give isl_union_map *isl_union_map_reset_equal_dim_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space)
+{
+	struct isl_union_map_reset_params_data data = { space };
+	isl_bool equal;
+	isl_space *umap_space;
+
+	umap_space = isl_union_map_peek_space(umap);
+	equal = isl_space_is_equal(umap_space, space);
+	if (equal < 0)
+		goto error;
+	if (equal) {
+		isl_space_free(space);
+		return umap;
+	}
+	if (check_union_map_space_equal_dim(umap, space) < 0)
+		goto error;
+
+	data.res = isl_union_map_empty(isl_space_copy(space));
+	if (isl_union_map_foreach_map(umap, &reset_params, &data) < 0)
+		data.res = isl_union_map_free(data.res);
+
+	isl_space_free(space);
+	isl_union_map_free(umap);
+	return data.res;
+error:
+	isl_union_map_free(umap);
+	isl_space_free(space);
+	return NULL;
+}
+
+/* Internal data structure for isl_union_map_order_at_multi_union_pw_aff.
+ * "mupa" is the function from which the isl_multi_pw_affs are extracted.
+ * "order" is applied to the extracted isl_multi_pw_affs that correspond
+ * to the domain and the range of each map.
+ * "res" collects the results.
+ */
+struct isl_union_order_at_data {
+	isl_multi_union_pw_aff *mupa;
+	__isl_give isl_map *(*order)(__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2);
+	isl_union_map *res;
+};
+
+/* Intersect "map" with the result of applying data->order to
+ * the functions in data->mupa that apply to the domain and the range
+ * of "map" and add the result to data->res.
+ */
+static isl_stat order_at(__isl_take isl_map *map, void *user)
+{
+	struct isl_union_order_at_data *data = user;
+	isl_space *space;
+	isl_multi_pw_aff *mpa1, *mpa2;
+	isl_map *order;
+
+	space = isl_space_domain(isl_map_get_space(map));
+	mpa1 = isl_multi_union_pw_aff_extract_multi_pw_aff(data->mupa, space);
+	space = isl_space_range(isl_map_get_space(map));
+	mpa2 = isl_multi_union_pw_aff_extract_multi_pw_aff(data->mupa, space);
+	order = data->order(mpa1, mpa2);
+	map = isl_map_intersect(map, order);
+	data->res = isl_union_map_add_map(data->res, map);
+
+	return data->res ? isl_stat_ok : isl_stat_error;
+}
+
+/* If "mupa" has a non-trivial explicit domain, then intersect
+ * domain and range of "umap" with this explicit domain.
+ * If the explicit domain only describes constraints on the parameters,
+ * then the intersection only needs to be performed once.
+ */
+static __isl_give isl_union_map *intersect_explicit_domain(
+	__isl_take isl_union_map *umap, __isl_keep isl_multi_union_pw_aff *mupa)
+{
+	isl_bool non_trivial, is_params;
+	isl_union_set *dom;
+
+	non_trivial = isl_multi_union_pw_aff_has_non_trivial_domain(mupa);
+	if (non_trivial < 0)
+		return isl_union_map_free(umap);
+	if (!non_trivial)
+		return umap;
+	mupa = isl_multi_union_pw_aff_copy(mupa);
+	dom = isl_multi_union_pw_aff_domain(mupa);
+	is_params = isl_union_set_is_params(dom);
+	if (is_params < 0) {
+		isl_union_set_free(dom);
+		return isl_union_map_free(umap);
+	}
+	if (is_params) {
+		isl_set *set;
+
+		set = isl_union_set_params(dom);
+		umap = isl_union_map_intersect_params(umap, set);
+		return umap;
+	}
+	umap = isl_union_map_intersect_domain(umap, isl_union_set_copy(dom));
+	umap = isl_union_map_intersect_range(umap, dom);
+	return umap;
+}
+
+/* Intersect each map in "umap" with the result of calling "order"
+ * on the functions is "mupa" that apply to the domain and the range
+ * of the map.
+ */
+static __isl_give isl_union_map *isl_union_map_order_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap, __isl_take isl_multi_union_pw_aff *mupa,
+	__isl_give isl_map *(*order)(__isl_take isl_multi_pw_aff *mpa1,
+		__isl_take isl_multi_pw_aff *mpa2))
+{
+	struct isl_union_order_at_data data;
+
+	umap = isl_union_map_align_params(umap,
+				isl_multi_union_pw_aff_get_space(mupa));
+	mupa = isl_multi_union_pw_aff_align_params(mupa,
+				isl_union_map_get_space(umap));
+	umap = intersect_explicit_domain(umap, mupa);
+	data.mupa = mupa;
+	data.order = order;
+	data.res = isl_union_map_empty(isl_union_map_get_space(umap));
+	if (isl_union_map_foreach_map(umap, &order_at, &data) < 0)
+		data.res = isl_union_map_free(data.res);
+
+	isl_multi_union_pw_aff_free(mupa);
+	isl_union_map_free(umap);
+	return data.res;
+}
+
+/* Return the subset of "umap" where the domain and the range
+ * have equal "mupa" values.
+ */
+__isl_give isl_union_map *isl_union_map_eq_at_multi_union_pw_aff(
+	__isl_take isl_union_map *umap,
+	__isl_take isl_multi_union_pw_aff *mupa)
+{
+	return isl_union_map_order_at_multi_union_pw_aff(umap, mupa,
+						&isl_multi_pw_aff_eq_map);
+}
+
+#undef ORDER
+#define ORDER		le
+#include "isl_union_map_lex_templ.c"
+
+#undef ORDER
+#define ORDER		lt
+#include "isl_union_map_lex_templ.c"
+
+#undef ORDER
+#define ORDER		ge
+#include "isl_union_map_lex_templ.c"
+
+#undef ORDER
+#define ORDER		gt
+#include "isl_union_map_lex_templ.c"
+
+/* Return the union of the elements in the list "list".
+ */
+__isl_give isl_union_set *isl_union_set_list_union(
+	__isl_take isl_union_set_list *list)
+{
+	int i;
+	isl_size n;
+	isl_ctx *ctx;
+	isl_space *space;
+	isl_union_set *res;
+
+	n = isl_union_set_list_n_union_set(list);
+	if (n < 0)
+		goto error;
+
+	ctx = isl_union_set_list_get_ctx(list);
+	space = isl_space_params_alloc(ctx, 0);
+	res = isl_union_set_empty(space);
+
+	for (i = 0; i < n; ++i) {
+		isl_union_set *uset_i;
+
+		uset_i = isl_union_set_list_get_union_set(list, i);
+		res = isl_union_set_union(res, uset_i);
+	}
+
+	isl_union_set_list_free(list);
+	return res;
+error:
+	isl_union_set_list_free(list);
+	return NULL;
+}
+
+/* Update *hash with the hash value of "map".
+ */
+static isl_stat add_hash(__isl_take isl_map *map, void *user)
+{
+	uint32_t *hash = user;
+	uint32_t map_hash;
+
+	map_hash = isl_map_get_hash(map);
+	isl_hash_hash(*hash, map_hash);
+
+	isl_map_free(map);
+	return isl_stat_ok;
+}
+
+/* Return a hash value that digests "umap".
+ */
+uint32_t isl_union_map_get_hash(__isl_keep isl_union_map *umap)
+{
+	uint32_t hash;
+
+	if (!umap)
+		return 0;
+
+	hash = isl_hash_init();
+	if (isl_union_map_foreach_map(umap, &add_hash, &hash) < 0)
+		return 0;
+
+	return hash;
+}
+
+/* Return a hash value that digests "uset".
+ */
+uint32_t isl_union_set_get_hash(__isl_keep isl_union_set *uset)
+{
+	return isl_union_map_get_hash(uset);
+}
+
+/* Add the number of basic sets in "set" to "n".
+ */
+static isl_stat add_n(__isl_take isl_set *set, void *user)
+{
+	int *n = user;
+	isl_size set_n;
+
+	set_n = isl_set_n_basic_set(set);
+	*n += set_n;
+	isl_set_free(set);
+
+	return set_n < 0 ? isl_stat_error : isl_stat_ok;
+}
+
+/* Return the total number of basic sets in "uset".
+ */
+int isl_union_set_n_basic_set(__isl_keep isl_union_set *uset)
+{
+	int n = 0;
+
+	if (isl_union_set_foreach_set(uset, &add_n, &n) < 0)
+		return -1;
+
+	return n;
+}
+
+/* Add the basic sets in "set" to "list".
+ */
+static isl_stat add_list(__isl_take isl_set *set, void *user)
+{
+	isl_basic_set_list **list = user;
+	isl_basic_set_list *list_i;
+
+	list_i = isl_set_get_basic_set_list(set);
+	*list = isl_basic_set_list_concat(*list, list_i);
+	isl_set_free(set);
+
+	if (!*list)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Return a list containing all the basic sets in "uset".
+ *
+ * First construct a list of the appropriate size and
+ * then add all the elements.
+ */
+__isl_give isl_basic_set_list *isl_union_set_get_basic_set_list(
+	__isl_keep isl_union_set *uset)
+{
+	int n;
+	isl_ctx *ctx;
+	isl_basic_set_list *list;
+
+	if (!uset)
+		return NULL;
+	ctx = isl_union_set_get_ctx(uset);
+	n = isl_union_set_n_basic_set(uset);
+	if (n < 0)
+		return NULL;
+	list = isl_basic_set_list_alloc(ctx, n);
+	if (isl_union_set_foreach_set(uset, &add_list, &list) < 0)
+		list = isl_basic_set_list_free(list);
+
+	return list;
+}
+
+/* Internal data structure for isl_union_map_remove_map_if.
+ * "fn" and "user" are the arguments to isl_union_map_remove_map_if.
+ */
+struct isl_union_map_remove_map_if_data {
+	isl_bool (*fn)(__isl_keep isl_map *map, void *user);
+	void *user;
+};
+
+/* isl_un_op_control filter that negates the result of data->fn
+ * called on "map".
+ */
+static isl_bool not(__isl_keep isl_map *map, void *user)
+{
+	struct isl_union_map_remove_map_if_data *data = user;
+
+	return isl_bool_not(data->fn(map, data->user));
+}
+
+/* Dummy isl_un_op_control transformation callback that
+ * simply returns the input.
+ */
+static __isl_give isl_map *map_id(__isl_take isl_map *map)
+{
+	return map;
+}
+
+/* Call "fn" on every map in "umap" and remove those maps
+ * for which the callback returns true.
+ *
+ * Use un_op to keep only those maps that are not filtered out,
+ * applying an identity transformation on them.
+ */
+__isl_give isl_union_map *isl_union_map_remove_map_if(
+	__isl_take isl_union_map *umap,
+	isl_bool (*fn)(__isl_keep isl_map *map, void *user), void *user)
+{
+	struct isl_union_map_remove_map_if_data data = { fn, user };
+	struct isl_un_op_control control = {
+		.filter = &not,
+		.filter_user = &data,
+		.fn_map = &map_id,
+	};
+	return un_op(umap, &control);
+}
+
+/* Does "map" have "space" as domain (ignoring parameters)?
+ */
+static isl_bool has_domain_space_tuples(__isl_keep isl_map *map, void *user)
+{
+	isl_space *space = user;
+
+	return isl_space_has_domain_tuples(space, isl_map_peek_space(map));
+}
+
+/* Does "map" have "space" as range (ignoring parameters)?
+ */
+static isl_bool has_range_space_tuples(__isl_keep isl_map *map, void *user)
+{
+	isl_space *space = user;
+
+	return isl_space_has_range_tuples(space, isl_map_peek_space(map));
+}
+
+/* Wrapper around isl_map_bind_range for use as a un_op callback.
+ */
+static __isl_give isl_map *bind_range(__isl_take isl_map *map, void *user)
+{
+	isl_multi_id *tuple = user;
+
+	return isl_map_bind_range(map, isl_multi_id_copy(tuple));
+}
+
+/* Bind the output dimensions of "umap" to parameters with identifiers
+ * specified by "tuple", living in the range space of "umap",
+ * for those maps that have a matching range space.
+ */
+__isl_give isl_union_set *isl_union_map_bind_range(
+	__isl_take isl_union_map *umap, __isl_take isl_multi_id *tuple)
+{
+	struct isl_un_op_control control = {
+		.filter = &has_range_space_tuples,
+		.filter_user = isl_multi_id_peek_space(tuple),
+		.fn_map2 = &bind_range,
+		.fn_map2_user = tuple,
+	};
+	isl_union_set *bound;
+
+	bound = uset_from_umap(un_op(umap, &control));
+	isl_multi_id_free(tuple);
+	return bound;
+}
+
+/* Only keep those elements in "umap" that have a domain in "space".
+ */
+__isl_give isl_union_map *isl_union_map_intersect_domain_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space)
+{
+	struct isl_un_op_control control = {
+		.filter = &has_domain_space_tuples,
+		.filter_user = space,
+	};
+
+	umap = un_op(umap, &control);
+	isl_space_free(space);
+	return umap;
+}
+
+/* Only keep those elements in "umap" that have a range in "space".
+ */
+__isl_give isl_union_map *isl_union_map_intersect_range_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space)
+{
+	struct isl_un_op_control control = {
+		.filter = &has_range_space_tuples,
+		.filter_user = space,
+	};
+
+	umap = un_op(umap, &control);
+	isl_space_free(space);
+	return umap;
+}

_service:tar_scm:isl-0.24.tar.gz/isl_union_map_lex_templ.c Added

_service:tar_scm:isl-0.14.tar.xz/isl_union_map_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_union_map_private.h Changed

@@ -1,3 +1,4 @@
+#define isl_union_set_list	isl_union_map_list
 #define isl_union_set	isl_union_map
 #include <isl/union_map.h>
 #include <isl/union_set.h>
@@ -8,3 +9,19 @@
 
 	struct isl_hash_table	table;
 };
+
+struct isl_hash_table_entry *isl_union_set_find_entry(
+	__isl_keep isl_union_set *uset, __isl_keep isl_space *space,
+	int reserve);
+
+__isl_keep isl_space *isl_union_map_peek_space(__isl_keep isl_union_map *umap);
+__isl_keep isl_space *isl_union_set_peek_space(__isl_keep isl_union_set *uset);
+isl_bool isl_union_map_is_params(__isl_keep isl_union_map *umap);
+isl_bool isl_union_map_space_has_equal_params(__isl_keep isl_union_map *umap,
+	__isl_keep isl_space *space);
+isl_bool isl_union_set_space_has_equal_params(__isl_keep isl_union_set *uset,
+	__isl_keep isl_space *space);
+__isl_give isl_union_map *isl_union_map_reset_range_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space);
+__isl_give isl_union_map *isl_union_map_reset_equal_dim_space(
+	__isl_take isl_union_map *umap, __isl_take isl_space *space);

_service:tar_scm:isl-0.24.tar.gz/isl_union_multi.c Added

@@ -0,0 +1,549 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ * Copyright 2015      INRIA Paris-Rocquencourt
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ * and INRIA Paris-Rocquencourt, Domaine de Voluceau, Rocquenqourt, B.P. 105,
+ * 78153 Le Chesnay Cedex France
+ */
+
+#include <isl/hash.h>
+#include <isl_union_macro.h>
+
+/* A group of expressions defined over the same domain space "domain_space".
+ * The entries of "part_table" are the individual expressions,
+ * keyed on the entire space of the expression (ignoring parameters).
+ *
+ * Each UNION has its own groups, so there can only ever be a single
+ * reference to each group.
+ */
+S(UNION,group) {
+	isl_space *domain_space;
+	struct isl_hash_table	part_table;
+};
+
+/* A union of expressions defined over different disjoint domains.
+ * "space" describes the parameters.
+ * The entries of "table" are keyed on the domain space of the entry
+ * (ignoring parameters) and
+ * contain groups of expressions that are defined over the same domain space.
+ */
+struct UNION {
+	int ref;
+	isl_space *space;
+
+	struct isl_hash_table	table;
+};
+
+/* Internal data structure for isl_union_*_foreach_group.
+ * "fn" is the function that needs to be called on each group.
+ */
+S(UNION,foreach_group_data)
+{
+	isl_stat (*fn)(__isl_keep S(UNION,group) *group, void *user);
+	void *user;
+};
+
+/* Call data->fn on the group stored at *entry.
+ */
+static isl_stat FN(UNION,call_on_group)(void **entry, void *user)
+{
+	S(UNION,group) *group = *entry;
+	S(UNION,foreach_group_data) *data;
+
+	data = (S(UNION,foreach_group_data) *) user;
+	return data->fn(group, data->user);
+}
+
+/* Call "fn" on each group of expressions in "u".
+ */
+static isl_stat FN(UNION,foreach_group)(__isl_keep UNION *u,
+	isl_stat (*fn)(__isl_keep S(UNION,group) *group, void *user),
+	void *user)
+{
+	S(UNION,foreach_group_data) data = { fn, user };
+
+	if (!u)
+		return isl_stat_error;
+
+	return isl_hash_table_foreach(u->space->ctx, &u->table,
+				      &FN(UNION,call_on_group), &data);
+}
+
+/* A isl_union_*_foreach_group callback for counting the total number
+ * of expressions in a UNION.  Add the number of expressions in "group"
+ * to *n.
+ */
+static isl_stat FN(UNION,count_part)(__isl_keep S(UNION,group) *group,
+	void *user)
+{
+	int *n = user;
+
+	if (!group)
+		return isl_stat_error;
+
+	*n += group->part_table.n;
+	return isl_stat_ok;
+}
+
+/* Return the number of base expressions in "u".
+ */
+isl_size FN(FN(UNION,n),BASE)(__isl_keep UNION *u)
+{
+	int n;
+
+	n = 0;
+	if (FN(UNION,foreach_group)(u, &FN(UNION,count_part), &n) < 0)
+		return isl_size_error;
+	return n;
+}
+
+/* Free an entry in a group of expressions.
+ * Each entry in such a group is a single expression.
+ */
+static isl_stat FN(UNION,free_group_entry)(void **entry, void *user)
+{
+	PART *part = *entry;
+
+	FN(PART,free)(part);
+	return isl_stat_ok;
+}
+
+/* Free all memory allocated for "group" and return NULL.
+ */
+static __isl_null S(UNION,group) *FN(UNION,group_free)(
+	__isl_take S(UNION,group) *group)
+{
+	isl_ctx *ctx;
+
+	if (!group)
+		return NULL;
+
+	ctx = isl_space_get_ctx(group->domain_space);
+	isl_hash_table_foreach(ctx, &group->part_table,
+				&FN(UNION,free_group_entry), NULL);
+	isl_hash_table_clear(&group->part_table);
+	isl_space_free(group->domain_space);
+	free(group);
+	return NULL;
+}
+
+/* Allocate a group of expressions defined over the same domain space
+ * with domain space "domain_space" and initial size "size".
+ */
+static __isl_give S(UNION,group) *FN(UNION,group_alloc)(
+	__isl_take isl_space *domain_space, int size)
+{
+	isl_ctx *ctx;
+	S(UNION,group) *group;
+
+	if (!domain_space)
+		return NULL;
+	ctx = isl_space_get_ctx(domain_space);
+	group = isl_calloc_type(ctx, S(UNION,group));
+	if (!group)
+		goto error;
+	group->domain_space = domain_space;
+	if (isl_hash_table_init(ctx, &group->part_table, size) < 0)
+		return FN(UNION,group_free)(group);
+
+	return group;
+error:
+	isl_space_free(domain_space);
+	return NULL;
+}
+
+/* Is the space of "entry" equal to "space", ignoring parameters?
+ */
+static isl_bool FN(UNION,has_space_tuples)(const void *entry, const void *val)
+{
+	PART *part = (PART *) entry;
+	isl_space *space = (isl_space *) val;
+	isl_space *part_space;
+
+	part_space = FN(PART,peek_space)(part);
+	return isl_space_has_equal_tuples(part_space, space);
+}
+
+/* Return a group equal to "group", but with a single reference.
+ * Since all groups have only a single reference, simply return "group".
+ */
+static __isl_give S(UNION,group) *FN(UNION,group_cow)(
+	__isl_take S(UNION,group) *group)
+{
+	return group;
+}
+
+S(UNION,foreach_data)
+{
+	isl_stat (*fn)(__isl_take PART *part, void *user);
+	void *user;
+};
+
+static isl_stat FN(UNION,call_on_copy)(void **entry, void *user)
+{
+	PART *part = *entry;
+	S(UNION,foreach_data) *data = (S(UNION,foreach_data) *) user;
+
+	part = FN(PART,copy)(part);
+	if (!part)
+		return isl_stat_error;
+	return data->fn(part, data->user);
+}
+
+/* Call data->fn on a copy of each expression in "group".
+ */
+static isl_stat FN(UNION,group_call_on_copy)(__isl_keep S(UNION,group) *group,
+	void *user)
+{
+	isl_ctx *ctx;
+
+	if (!group)
+		return isl_stat_error;
+
+	ctx = isl_space_get_ctx(group->domain_space);
+	return isl_hash_table_foreach(ctx, &group->part_table,
+				      &FN(UNION,call_on_copy), user);
+}
+
+isl_stat FN(FN(UNION,foreach),BASE)(__isl_keep UNION *u,
+	isl_stat (*fn)(__isl_take PART *part, void *user), void *user)
+{
+	S(UNION,foreach_data) data = { fn, user };
+
+	if (!u)
+		return isl_stat_error;
+
+	return FN(UNION,foreach_group)(u, &FN(UNION,group_call_on_copy), &data);
+}
+
+/* Is the domain space of the group of expressions at "entry"
+ * equal to that of "space", ignoring parameters?
+ */
+static isl_bool FN(UNION,group_has_same_domain_space_tuples)(const void *entry,
+	const void *val)
+{
+	S(UNION,group) *group = (S(UNION,group) *) entry;
+	isl_space *space = (isl_space *) val;
+
+	return isl_space_has_domain_tuples(group->domain_space, space);
+}
+
+/* Return the entry, if any, in "u" that lives in "space".
+ * If "reserve" is set, then an entry is created if it does not exist yet.
+ * Return NULL on error and isl_hash_table_entry_none if no entry was found.
+ * Note that when "reserve" is set, the function will never return
+ * isl_hash_table_entry_none.
+ *
+ * First look for the group of expressions with the same domain space,
+ * creating one if needed.
+ * Then look for the expression living in the specified space in that group.
+ */
+static struct isl_hash_table_entry *FN(UNION,find_part_entry)(
+	__isl_keep UNION *u, __isl_keep isl_space *space, int reserve)
+{
+	isl_ctx *ctx;
+	uint32_t hash;
+	struct isl_hash_table_entry *group_entry;
+	S(UNION,group) *group;
+
+	if (!u || !space)
+		return NULL;
+
+	ctx = FN(UNION,get_ctx)(u);
+	hash = isl_space_get_tuple_domain_hash(space);
+	group_entry = isl_hash_table_find(ctx, &u->table, hash,
+		&FN(UNION,group_has_same_domain_space_tuples), space, reserve);
+	if (!group_entry || group_entry == isl_hash_table_entry_none)
+		return group_entry;
+	if (reserve && !group_entry->data) {
+		isl_space *domain = isl_space_domain(isl_space_copy(space));
+		group = FN(UNION,group_alloc)(domain, 1);
+		group_entry->data = group;
+	} else {
+		group = group_entry->data;
+		if (reserve)
+			group = FN(UNION,group_cow)(group);
+	}
+	if (!group)
+		return NULL;
+	hash = isl_space_get_tuple_hash(space);
+	return isl_hash_table_find(ctx, &group->part_table, hash,
+				&FN(UNION,has_space_tuples), space, reserve);
+}
+
+/* Remove "part_entry" from the hash table of "u".
+ *
+ * First look the group_entry in "u" holding the group that
+ * contains "part_entry".  Remove "part_entry" from that group.
+ * If the group becomes empty, then also remove the group_entry from "u".
+ */
+static __isl_give UNION *FN(UNION,remove_part_entry)(__isl_take UNION *u,
+	struct isl_hash_table_entry *part_entry)
+{
+	isl_ctx *ctx;
+	uint32_t hash;
+	isl_space *space;
+	PART *part;
+	struct isl_hash_table_entry *group_entry;
+	S(UNION,group) *group;
+
+	if (!u || !part_entry)
+		return FN(UNION,free)(u);
+
+	part = part_entry->data;
+	ctx = FN(UNION,get_ctx)(u);
+	space = FN(PART,peek_space)(part);
+	hash = isl_space_get_tuple_domain_hash(space);
+	group_entry = isl_hash_table_find(ctx, &u->table, hash,
+		    &FN(UNION,group_has_same_domain_space_tuples), space, 0);
+	if (!group_entry)
+		return FN(UNION,free)(u);
+	if (group_entry == isl_hash_table_entry_none)
+		isl_die(ctx, isl_error_internal, "missing group",
+			return FN(UNION,free)(u));
+	group = group_entry->data;
+	isl_hash_table_remove(ctx, &group->part_table, part_entry);
+	FN(PART,free)(part);
+
+	if (group->part_table.n != 0)
+		return u;
+
+	isl_hash_table_remove(ctx, &u->table, group_entry);
+	FN(UNION,group_free)(group);
+
+	return u;
+}
+
+/* Are the domains of "part1" and "part2" disjoint?
+ */
+static isl_bool FN(UNION,disjoint_domain)(__isl_keep PART *part1,
+	__isl_keep PART *part2)
+{
+	isl_set *dom1, *dom2;
+	isl_bool disjoint;
+
+	if (!part1 || !part2)
+		return isl_bool_error;
+	dom1 = FN(PART,domain)(FN(PART,copy)(part1));
+	dom2 = FN(PART,domain)(FN(PART,copy)(part2));
+	disjoint = isl_set_is_disjoint(dom1, dom2);
+	isl_set_free(dom1);
+	isl_set_free(dom2);
+
+	return disjoint;
+}
+
+/* Check that the expression at *entry has a domain that is disjoint
+ * from that of "part", unless they also have the same target space.
+ */
+static isl_stat FN(UNION,check_disjoint_domain_entry)(void **entry, void *user)
+{
+	PART *part = user;
+	PART *other = *entry;
+	isl_bool equal;
+	isl_bool disjoint;
+
+	equal = isl_space_is_equal(part->dim, other->dim);
+	if (equal < 0)
+		return isl_stat_error;
+	if (equal)
+		return isl_stat_ok;
+
+	disjoint = FN(UNION,disjoint_domain)(part, other);
+	if (disjoint < 0)
+		return isl_stat_error;
+	if (!disjoint)
+		isl_die(FN(PART,get_ctx)(part), isl_error_invalid,
+			"overlapping domain with other part",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Check that the domain of "part" is disjoint from the domain of the entries
+ * in "u" that are defined on the same domain space, but have a different
+ * target space.
+ * If there is no group of expressions in "u" with the same domain space,
+ * then everything is fine.  Otherwise, check the individual expressions
+ * in that group.
+ */
+static isl_stat FN(UNION,check_disjoint_domain_other)(__isl_keep UNION *u,
+	__isl_keep PART *part)
+{
+	isl_ctx *ctx;
+	uint32_t hash;
+	isl_space *space;
+	struct isl_hash_table_entry *group_entry;
+	S(UNION,group) *group;
+
+	if (!u || !part)
+		return isl_stat_error;
+	ctx = FN(UNION,get_ctx)(u);
+	space = FN(PART,peek_space)(part);
+	hash = isl_space_get_tuple_domain_hash(space);
+	group_entry = isl_hash_table_find(ctx, &u->table, hash,
+		    &FN(UNION,group_has_same_domain_space_tuples), space, 0);
+	if (!group_entry)
+		return isl_stat_error;
+	if (group_entry == isl_hash_table_entry_none)
+		return isl_stat_ok;
+	group = group_entry->data;
+	return isl_hash_table_foreach(ctx, &group->part_table,
+			      &FN(UNION,check_disjoint_domain_entry), part);
+}
+
+/* Check that the domain of "part1" is disjoint from the domain of "part2".
+ * This check is performed before "part2" is added to a UNION to ensure
+ * that the UNION expression remains a function.
+ */
+static isl_stat FN(UNION,check_disjoint_domain)(__isl_keep PART *part1,
+	__isl_keep PART *part2)
+{
+	isl_bool disjoint;
+
+	disjoint = FN(UNION,disjoint_domain)(part1, part2);
+	if (disjoint < 0)
+		return isl_stat_error;
+	if (!disjoint)
+		isl_die(FN(PART,get_ctx)(part1), isl_error_invalid,
+			"domain of additional part should be disjoint",
+			return isl_stat_error);
+	return isl_stat_ok;
+}
+
+/* Internal data structure for isl_union_*_foreach_inplace.
+ * "fn" is the function that needs to be called on each entry.
+ */
+S(UNION,foreach_inplace_data)
+{
+	isl_stat (*fn)(void **entry, void *user);
+	void *user;
+};
+
+/* isl_union_*_foreach_group callback for calling data->fn on
+ * each part entry in the group.
+ */
+static isl_stat FN(UNION,group_call_inplace)(__isl_keep S(UNION,group) *group,
+	void *user)
+{
+	isl_ctx *ctx;
+	S(UNION,foreach_inplace_data) *data;
+
+	if (!group)
+		return isl_stat_error;
+
+	data = (S(UNION,foreach_inplace_data) *) user;
+	ctx = isl_space_get_ctx(group->domain_space);
+	return isl_hash_table_foreach(ctx, &group->part_table,
+				      data->fn, data->user);
+}
+
+/* Call "fn" on each part entry of "u".
+ */
+static isl_stat FN(UNION,foreach_inplace)(__isl_keep UNION *u,
+	isl_stat (*fn)(void **part, void *user), void *user)
+{
+	S(UNION,foreach_inplace_data) data = { fn, user };
+
+	return FN(UNION,foreach_group)(u, &FN(UNION,group_call_inplace), &data);
+}
+
+static isl_stat FN(UNION,free_u_entry)(void **entry, void *user)
+{
+	S(UNION,group) *group = *entry;
+	FN(UNION,group_free)(group);
+	return isl_stat_ok;
+}
+
+/* Does "u" have an obviously empty definition domain?
+ */
+isl_bool FN(UNION,plain_is_empty)(__isl_take UNION *u)
+{
+	if (!u)
+		return isl_bool_error;
+	return isl_bool_ok(u->table.n == 0);
+}
+
+/* Set "single" to true if this group of expressions
+ * contains an expression living in exactly one space.
+ */
+static isl_stat FN(UNION,group_single_space)(__isl_keep S(UNION,group) *group,
+	void *user)
+{
+	isl_bool *single = user;
+
+	if (!group)
+		return isl_stat_error;
+	*single = isl_bool_ok(group->part_table.n == 1);
+	return isl_stat_ok;
+}
+
+/* Can this union expression be converted to a single base expression?
+ * That is, does it contain a base expression in exactly one space?
+ * In particular, is only one domain space involved and
+ * is only a single expression associated to that domain?
+ */
+isl_bool FN(FN(UNION,isa),BASE)(__isl_take UNION *u)
+{
+	isl_bool single;
+
+	if (!u)
+		return isl_bool_error;
+	if (u->table.n != 1)
+		return isl_bool_false;
+	if (FN(UNION,foreach_group)(u,
+				&FN(UNION,group_single_space), &single) < 0)
+		return isl_bool_error;
+	return single;
+}
+
+/* Callback for isl_union_*_foreach_inplace call
+ * on a union expression with a single base expression.
+ * Store that base expression in "user".
+ * This callback should only be called once
+ * for any given isl_union_*_foreach_inplace call.
+ */
+static isl_stat FN(UNION,extract_part)(void **entry, void *user)
+{
+	PART **part_p = user;
+	PART *part = *entry;
+
+	if (*part_p)
+		isl_die(FN(PART,get_ctx)(part), isl_error_internal,
+			"more than one part", return isl_stat_error);
+	*part_p = FN(PART,copy)(part);
+	if (!*part_p)
+		return isl_stat_error;
+	return isl_stat_ok;
+}
+
+/* Convert the union expression to its single base expression.
+ */
+__isl_give PART *FN(FN(UNION,as),BASE)(__isl_take UNION *u)
+{
+	isl_bool has_single_space;
+	PART *part = NULL;
+
+	has_single_space = FN(FN(UNION,isa),BASE)(u);
+	if (has_single_space < 0)
+		goto error;
+	if (!has_single_space)
+		isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
+			"expecting elements in exactly one space",
+			goto error);
+	if (FN(UNION,foreach_inplace)(u, &FN(UNION,extract_part), &part) < 0)
+		part = FN(PART,free)(part);
+	FN(UNION,free)(u);
+	return part;
+error:
+	FN(UNION,free)(u);
+	return NULL;
+}
+
+#include <isl_union_templ.c>

_service:tar_scm:isl-0.24.tar.gz/isl_union_neg.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_union_pw_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/isl_union_set_private.h Added

_service:tar_scm:isl-0.24.tar.gz/isl_union_single.c Added

@@ -0,0 +1,231 @@
+/*
+ * Copyright 2010      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
+ * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
+ * 91893 Orsay, France
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
+ */
+
+#include <isl/hash.h>
+#include <isl_union_macro.h>
+
+/* A union of expressions defined over different domain spaces.
+ * "space" describes the parameters.
+ * The entries of "table" are keyed on the domain space of the entry
+ * (ignoring parameters).
+ */
+struct UNION {
+	int ref;
+#ifdef HAS_TYPE
+	enum isl_fold type;
+#endif
+	isl_space *space;
+
+	struct isl_hash_table	table;
+};
+
+/* Return the number of base expressions in "u".
+ */
+isl_size FN(FN(UNION,n),BASE)(__isl_keep UNION *u)
+{
+	return u ? u->table.n : isl_size_error;
+}
+
+S(UNION,foreach_data)
+{
+	isl_stat (*fn)(__isl_take PART *part, void *user);
+	void *user;
+};
+
+static isl_stat FN(UNION,call_on_copy)(void **entry, void *user)
+{
+	PART *part = *entry;
+	S(UNION,foreach_data) *data = (S(UNION,foreach_data) *)user;
+
+	part = FN(PART,copy)(part);
+	if (!part)
+		return isl_stat_error;
+	return data->fn(part, data->user);
+}
+
+isl_stat FN(FN(UNION,foreach),BASE)(__isl_keep UNION *u,
+	isl_stat (*fn)(__isl_take PART *part, void *user), void *user)
+{
+	S(UNION,foreach_data) data = { fn, user };
+
+	if (!u)
+		return isl_stat_error;
+
+	return isl_hash_table_foreach(u->space->ctx, &u->table,
+				      &FN(UNION,call_on_copy), &data);
+}
+
+/* Is the domain space of "entry" equal to the domain of "space",
+ * ignoring parameters?
+ */
+static isl_bool FN(UNION,has_same_domain_space_tuples)(const void *entry,
+	const void *val)
+{
+	PART *part = (PART *)entry;
+	isl_space *space = (isl_space *) val;
+
+	if (isl_space_is_set(space))
+		return isl_space_is_set(part->dim);
+
+	return isl_space_tuple_is_equal(part->dim, isl_dim_in,
+					space, isl_dim_in);
+}
+
+/* Return the entry, if any, in "u" that lives in "space".
+ * If "reserve" is set, then an entry is created if it does not exist yet.
+ * Return NULL on error and isl_hash_table_entry_none if no entry was found.
+ * Note that when "reserve" is set, the function will never return
+ * isl_hash_table_entry_none.
+ *
+ * First look for the entry (if any) with the same domain space.
+ * If it exists, then check if the range space also matches.
+ */
+static struct isl_hash_table_entry *FN(UNION,find_part_entry)(
+	__isl_keep UNION *u, __isl_keep isl_space *space, int reserve)
+{
+	isl_ctx *ctx;
+	uint32_t hash;
+	struct isl_hash_table_entry *entry;
+	isl_bool equal;
+	PART *part;
+
+	if (!u || !space)
+		return NULL;
+
+	ctx = FN(UNION,get_ctx)(u);
+	hash = isl_space_get_tuple_domain_hash(space);
+	entry = isl_hash_table_find(ctx, &u->table, hash,
+		&FN(UNION,has_same_domain_space_tuples), space, reserve);
+	if (!entry || entry == isl_hash_table_entry_none)
+		return entry;
+	if (reserve && !entry->data)
+		return entry;
+	part = entry->data;
+	equal = isl_space_tuple_is_equal(part->dim, isl_dim_out,
+					    space, isl_dim_out);
+	if (equal < 0)
+		return NULL;
+	if (equal)
+		return entry;
+	if (!reserve)
+		return isl_hash_table_entry_none;
+	isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
+		"union expression can only contain a single "
+		"expression over a given domain", return NULL);
+}
+
+/* Remove "part_entry" from the hash table of "u".
+ */
+static __isl_give UNION *FN(UNION,remove_part_entry)(__isl_take UNION *u,
+	struct isl_hash_table_entry *part_entry)
+{
+	isl_ctx *ctx;
+
+	if (!u || !part_entry)
+		return FN(UNION,free)(u);
+
+	ctx = FN(UNION,get_ctx)(u);
+	isl_hash_table_remove(ctx, &u->table, part_entry);
+	FN(PART,free)(part_entry->data);
+
+	return u;
+}
+
+/* Check that the domain of "part" is disjoint from the domain of the entries
+ * in "u" that are defined on the same domain space, but have a different
+ * target space.
+ * Since a UNION with a single entry per domain space is not allowed
+ * to contain two entries with the same domain space, there cannot be
+ * any such other entry.
+ */
+static isl_stat FN(UNION,check_disjoint_domain_other)(__isl_keep UNION *u,
+	__isl_keep PART *part)
+{
+	return isl_stat_ok;
+}
+
+/* Check that the domain of "part1" is disjoint from the domain of "part2".
+ * This check is performed before "part2" is added to a UNION to ensure
+ * that the UNION expression remains a function.
+ * Since a UNION with a single entry per domain space is not allowed
+ * to contain two entries with the same domain space, fail unconditionally.
+ */
+static isl_stat FN(UNION,check_disjoint_domain)(__isl_keep PART *part1,
+	__isl_keep PART *part2)
+{
+	isl_die(FN(PART,get_ctx)(part1), isl_error_invalid,
+		"additional part should live on separate space",
+		return isl_stat_error);
+}
+
+/* Call "fn" on each part entry of "u".
+ */
+static isl_stat FN(UNION,foreach_inplace)(__isl_keep UNION *u,
+	isl_stat (*fn)(void **part, void *user), void *user)
+{
+	isl_ctx *ctx;
+
+	if (!u)
+		return isl_stat_error;
+	ctx = FN(UNION,get_ctx)(u);
+	return isl_hash_table_foreach(ctx, &u->table, fn, user);
+}
+
+static isl_bool FN(PART,has_domain_space_tuples)(__isl_keep PART *part,
+	__isl_keep isl_space *space);
+
+/* Do the tuples of "space" correspond to those of the domain of "part"?
+ * That is, is the domain space of "part" equal to "space", ignoring parameters?
+ */
+static isl_bool FN(UNION,has_domain_space_tuples)(const void *entry,
+	const void *val)
+{
+	PART *part = (PART *)entry;
+	isl_space *space = (isl_space *) val;
+
+	return FN(PART,has_domain_space_tuples)(part, space);
+}
+
+/* Call "fn" on each part of "u" that has domain space "space".
+ *
+ * Since each entry is defined over a different domain space,
+ * simply look for an entry with the given domain space and
+ * call "fn" on the corresponding part if there is one.
+ */
+isl_stat FN(UNION,foreach_on_domain)(__isl_keep UNION *u,
+	__isl_keep isl_space *space,
+	isl_stat (*fn)(__isl_take PART *part, void *user), void *user)
+{
+	uint32_t hash;
+	struct isl_hash_table_entry *entry;
+
+	if (!u || !space)
+		return isl_stat_error;
+	hash = isl_space_get_tuple_hash(space);
+	entry = isl_hash_table_find(FN(UNION,get_ctx)(u), &u->table,
+				    hash, &FN(UNION,has_domain_space_tuples),
+				    space, 0);
+	if (!entry)
+		return isl_stat_error;
+	if (entry == isl_hash_table_entry_none)
+		return isl_stat_ok;
+	return fn(FN(PART,copy)(entry->data), user);
+}
+
+static isl_stat FN(UNION,free_u_entry)(void **entry, void *user)
+{
+	PART *part = *entry;
+	FN(PART,free)(part);
+	return isl_stat_ok;
+}
+
+#include <isl_union_templ.c>

_service:tar_scm:isl-0.14.tar.xz/isl_union_templ.c -> _service:tar_scm:isl-0.24.tar.gz/isl_union_templ.c Changed

@@ -1,158 +1,171 @@
 /*
  * Copyright 2010      INRIA Saclay
+ * Copyright 2013      Ecole Normale Superieure
  *
  * Use of this software is governed by the MIT license
  *
  * Written by Sven Verdoolaege, INRIA Saclay - Ile-de-France,
  * Parc Club Orsay Universite, ZAC des vignes, 4 rue Jacques Monod,
  * 91893 Orsay, France 
+ * and Ecole Normale Superieure, 45 rue d'Ulm, 75230 Paris, France
  */
 
-#define xFN(TYPE,NAME) TYPE ## _ ## NAME
-#define FN(TYPE,NAME) xFN(TYPE,NAME)
-#define xS(TYPE,NAME) struct TYPE ## _ ## NAME
-#define S(TYPE,NAME) xS(TYPE,NAME)
-
-struct UNION {
-	int ref;
-#ifdef HAS_TYPE
-	enum isl_fold type;
-#endif
-	isl_space *dim;
-
-	struct isl_hash_table	table;
-};
+#undef TYPE
+#define TYPE	UNION
+static
+#include "has_single_reference_templ.c"
 
 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u);
 
 isl_ctx *FN(UNION,get_ctx)(__isl_keep UNION *u)
 {
-	return u ? u->dim->ctx : NULL;
+	return u ? u->space->ctx : NULL;
 }
 
-__isl_give isl_space *FN(UNION,get_space)(__isl_keep UNION *u)
+/* Return the space of "u".
+ */
+static __isl_keep isl_space *FN(UNION,peek_space)(__isl_keep UNION *u)
 {
 	if (!u)
 		return NULL;
-	return isl_space_copy(u->dim);
+	return u->space;
 }
 
-#ifdef HAS_TYPE
-static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_space *dim,
-	enum isl_fold type, int size)
-#else
-static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_space *dim, int size)
-#endif
+/* Return a copy of the space of "u".
+ */
+__isl_give isl_space *FN(UNION,get_space)(__isl_keep UNION *u)
+{
+	return isl_space_copy(FN(UNION,peek_space)(u));
+}
+
+/* Return the number of parameters of "u", where "type"
+ * is required to be set to isl_dim_param.
+ */
+isl_size FN(UNION,dim)(__isl_keep UNION *u, enum isl_dim_type type)
+{
+	if (!u)
+		return isl_size_error;
+
+	if (type != isl_dim_param)
+		isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
+			"can only reference parameters", return isl_size_error);
+
+	return isl_space_dim(u->space, type);
+}
+
+/* Return the position of the parameter with the given name
+ * in "u".
+ * Return -1 if no such dimension can be found.
+ */
+int FN(UNION,find_dim_by_name)(__isl_keep UNION *u, enum isl_dim_type type,
+	const char *name)
+{
+	if (!u)
+		return -1;
+	return isl_space_find_dim_by_name(u->space, type, name);
+}
+
+#include "opt_type.h"
+
+static __isl_give UNION *FN(UNION,alloc)(__isl_take isl_space *space
+	OPT_TYPE_PARAM, int size)
 {
 	UNION *u;
 
-	dim = isl_space_params(dim);
-	if (!dim)
+	space = isl_space_params(space);
+	if (!space)
 		return NULL;
 
-	u = isl_calloc_type(dim->ctx, UNION);
+	u = isl_calloc_type(space->ctx, UNION);
 	if (!u)
 		goto error;
 
 	u->ref = 1;
-#ifdef HAS_TYPE
-	u->type = type;
-#endif
-	u->dim = dim;
-	if (isl_hash_table_init(dim->ctx, &u->table, size) < 0)
+	OPT_SET_TYPE(u->, type);
+	u->space = space;
+	if (isl_hash_table_init(space->ctx, &u->table, size) < 0)
 		return FN(UNION,free)(u);
 
 	return u;
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-#ifdef HAS_TYPE
-__isl_give UNION *FN(UNION,ZERO)(__isl_take isl_space *dim, enum isl_fold type)
-{
-	return FN(UNION,alloc)(dim, type, 16);
-}
-#else
-__isl_give UNION *FN(UNION,ZERO)(__isl_take isl_space *dim)
-{
-	return FN(UNION,alloc)(dim, 16);
-}
-#endif
-
-__isl_give UNION *FN(UNION,copy)(__isl_keep UNION *u)
+/* Create an empty/zero union without specifying any parameters.
+ */
+__isl_give UNION *FN(FN(UNION,ZERO),ctx)(isl_ctx *ctx OPT_TYPE_PARAM)
 {
-	if (!u)
-		return NULL;
+	isl_space *space;
 
-	u->ref++;
-	return u;
+	space = isl_space_unit(ctx);
+	return FN(FN(UNION,ZERO),space)(space OPT_TYPE_ARG(NO_LOC));
 }
 
-S(UNION,foreach_data)
+__isl_give UNION *FN(FN(UNION,ZERO),space)(__isl_take isl_space *space
+	OPT_TYPE_PARAM)
 {
-	int (*fn)(__isl_take PART *part, void *user);
-	void *user;
-};
+	return FN(UNION,alloc)(space OPT_TYPE_ARG(NO_LOC), 16);
+}
 
-static int call_on_copy(void **entry, void *user)
+/* This is an alternative name for the function above.
+ */
+__isl_give UNION *FN(UNION,ZERO)(__isl_take isl_space *space OPT_TYPE_PARAM)
 {
-	PART *part = *entry;
-	S(UNION,foreach_data) *data = (S(UNION,foreach_data) *)user;
-
-	return data->fn(FN(PART,copy)(part), data->user);
+	return FN(FN(UNION,ZERO),space)(space OPT_TYPE_ARG(NO_LOC));
 }
 
-int FN(FN(UNION,foreach),PARTS)(__isl_keep UNION *u,
-	int (*fn)(__isl_take PART *part, void *user), void *user)
+__isl_give UNION *FN(UNION,copy)(__isl_keep UNION *u)
 {
-	S(UNION,foreach_data) data = { fn, user };
-
 	if (!u)
-		return -1;
+		return NULL;
 
-	return isl_hash_table_foreach(u->dim->ctx, &u->table,
-				      &call_on_copy, &data);
+	u->ref++;
+	return u;
 }
 
-static int has_dim(const void *entry, const void *val)
+/* Do the tuples of "space" correspond to those of the domain of "part"?
+ * That is, is the domain space of "part" equal to "space", ignoring parameters?
+ */
+static isl_bool FN(PART,has_domain_space_tuples)(__isl_keep PART *part,
+	__isl_keep isl_space *space)
 {
-	PART *part = (PART *)entry;
-	isl_space *dim = (isl_space *)val;
-
-	return isl_space_is_equal(part->dim, dim);
+	return isl_space_has_domain_tuples(space, FN(PART,peek_space)(part));
 }
 
-__isl_give PART *FN(FN(UNION,extract),PARTS)(__isl_keep UNION *u,
-	__isl_take isl_space *dim)
+/* Extract the element of "u" living in "space" (ignoring parameters).
+ *
+ * Return the ZERO element if "u" does not contain any element
+ * living in "space".
+ */
+__isl_give PART *FN(FN(UNION,extract),BASE)(__isl_keep UNION *u,
+	__isl_take isl_space *space)
 {
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
-	if (!u || !dim)
-		goto error;
-
-	hash = isl_space_get_hash(dim);
-	entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
-				    &has_dim, dim, 0);
+	entry = FN(UNION,find_part_entry)(u, space, 0);
 	if (!entry)
-#ifdef HAS_TYPE
-		return FN(PART,ZERO)(dim, u->type);
-#else
-		return FN(PART,ZERO)(dim);
-#endif
-	isl_space_free(dim);
+		goto error;
+	if (entry == isl_hash_table_entry_none)
+		return FN(PART,ZERO)(space OPT_TYPE_ARG(u->));
+	isl_space_free(space);
 	return FN(PART,copy)(entry->data);
 error:
-	isl_space_free(dim);
+	isl_space_free(space);
 	return NULL;
 }
 
-__isl_give UNION *FN(FN(UNION,add),PARTS)(__isl_take UNION *u,
-	__isl_take PART *part)
+/* Add "part" to "u".
+ * If "disjoint" is set, then "u" is not allowed to already have
+ * a part that is defined over a domain that overlaps with the domain
+ * of "part".
+ * Otherwise, compute the union sum of "part" and the part in "u"
+ * defined on the same space.
+ */
+static __isl_give UNION *FN(UNION,add_part_generic)(__isl_take UNION *u,
+	__isl_take PART *part, int disjoint)
 {
 	int empty;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry;
 
 	if (!part)
@@ -174,25 +187,27 @@
 	if (!u)
 		goto error;
 
-	hash = isl_space_get_hash(part->dim);
-	entry = isl_hash_table_find(u->dim->ctx, &u->table, hash,
-				    &has_dim, part->dim, 1);
+	if (FN(UNION,check_disjoint_domain_other)(u, part) < 0)
+		goto error;
+	entry = FN(UNION,find_part_entry)(u, part->dim, 1);
 	if (!entry)
 		goto error;
 
 	if (!entry->data)
 		entry->data = part;
 	else {
-		entry->data = FN(PART,add)(entry->data, FN(PART,copy)(part));
+		if (disjoint &&
+		    FN(UNION,check_disjoint_domain)(entry->data, part) < 0)
+			goto error;
+		entry->data = FN(PART,union_add_)(entry->data,
+						FN(PART,copy)(part));
 		if (!entry->data)
 			goto error;
 		empty = FN(PART,IS_ZERO)(part);
 		if (empty < 0)
 			goto error;
-		if (empty) {
-			FN(PART,free)(entry->data);
-			isl_hash_table_remove(u->dim->ctx, &u->table, entry);
-		}
+		if (empty)
+			u = FN(UNION,remove_part_entry)(u, entry);
 		FN(PART,free)(part);
 	}
 
@@ -203,35 +218,178 @@
 	return NULL;
 }
 
-static int add_part(__isl_take PART *part, void *user)
+/* Add "part" to "u", where "u" is assumed not to already have
+ * a part that is defined on the same space as "part".
+ */
+__isl_give UNION *FN(FN(UNION,add),BASE)(__isl_take UNION *u,
+	__isl_take PART *part)
 {
-	UNION **u = (UNION **)user;
-
-	*u = FN(FN(UNION,add),PARTS)(*u, part);
-
-	return 0;
+	return FN(UNION,add_part_generic)(u, part, 1);
 }
 
-__isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
+/* Allocate a UNION with the same type (if any) and the same size as "u" and
+ * with space "space".
+ */
+static __isl_give UNION *FN(UNION,alloc_same_size_on_space)(__isl_keep UNION *u,
+	__isl_take isl_space *space)
 {
-	UNION *dup;
-
 	if (!u)
-		return NULL;
-
-#ifdef HAS_TYPE
-	dup = FN(UNION,ZERO)(isl_space_copy(u->dim), u->type);
-#else
-	dup = FN(UNION,ZERO)(isl_space_copy(u->dim));
-#endif
-	if (FN(FN(UNION,foreach),PARTS)(u, &add_part, &dup) < 0)
 		goto error;
-	return dup;
+	return FN(UNION,alloc)(space OPT_TYPE_ARG(u->), u->table.n);
 error:
-	FN(UNION,free)(dup);
+	isl_space_free(space);
 	return NULL;
 }
 
+/* Allocate a UNION with the same space, the same type (if any) and
+ * the same size as "u".
+ */
+static __isl_give UNION *FN(UNION,alloc_same_size)(__isl_keep UNION *u)
+{
+	return FN(UNION,alloc_same_size_on_space)(u, FN(UNION,get_space)(u));
+}
+
+/* Data structure that specifies how isl_union_*_transform
+ * should modify the base expressions in the union expression.
+ *
+ * If "inplace" is set, then the base expression in the input union
+ * are modified in place.  This means that "fn" should not
+ * change the meaning of the union or that the union only
+ * has a single reference.
+ * If "space" is not NULL, then a new union is created in this space.
+ * If "filter" is not NULL, then only the base expressions that satisfy "filter"
+ * are taken into account.
+ * "filter_user" is passed as the second argument to "filter".
+ * If "fn" it not NULL, then it is applied to each entry in the input.
+ * "fn_user" is passed as the second argument to "fn".
+ */
+S(UNION,transform_control) {
+	int inplace;
+	isl_space *space;
+	isl_bool (*filter)(__isl_keep PART *part, void *user);
+	void *filter_user;
+	__isl_give PART *(*fn)(__isl_take PART *part, void *user);
+	void *fn_user;
+};
+
+/* Internal data structure for isl_union_*_transform_space.
+ * "control" specifies how the base expressions should be modified.
+ * "res" collects the results (if control->inplace is not set).
+ */
+S(UNION,transform_data)
+{
+	S(UNION,transform_control) *control;
+	UNION *res;
+};
+
+/* Apply control->fn to "part" and add the result to data->res or
+ * place it back into the input union if control->inplace is set.
+ */
+static isl_stat FN(UNION,transform_entry)(void **entry, void *user)
+{
+	S(UNION,transform_data) *data = (S(UNION,transform_data) *)user;
+	S(UNION,transform_control) *control = data->control;
+	PART *part = *entry;
+
+	if (control->filter) {
+		isl_bool handle;
+
+		handle = control->filter(part, control->filter_user);
+		if (handle < 0)
+			return isl_stat_error;
+		if (!handle)
+			return isl_stat_ok;
+	}
+
+	if (!control->inplace)
+		part = FN(PART,copy)(part);
+	if (control->fn)
+		part = control->fn(part, control->fn_user);
+	if (control->inplace)
+		*entry = part;
+	else
+		data->res = FN(FN(UNION,add),BASE)(data->res, part);
+	if (!part || !data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Return a UNION that is obtained by modifying "u" according to "control".
+ */
+static __isl_give UNION *FN(UNION,transform)(__isl_take UNION *u,
+	S(UNION,transform_control) *control)
+{
+	S(UNION,transform_data) data = { control };
+	isl_space *space;
+
+	if (control->inplace) {
+		data.res = u;
+	} else {
+		if (control->space)
+			space = isl_space_copy(control->space);
+		else
+			space = FN(UNION,get_space)(u);
+		data.res = FN(UNION,alloc_same_size_on_space)(u, space);
+	}
+	if (FN(UNION,foreach_inplace)(u, &FN(UNION,transform_entry), &data) < 0)
+		data.res = FN(UNION,free)(data.res);
+	if (!control->inplace)
+		FN(UNION,free)(u);
+	return data.res;
+}
+
+/* Return a UNION living in "space" that is otherwise obtained by modifying "u"
+ * according to "control".
+ */
+static __isl_give UNION *FN(UNION,transform_space)(__isl_take UNION *u,
+	__isl_take isl_space *space, S(UNION,transform_control) *control)
+{
+	if (!space)
+		return FN(UNION,free)(u);
+	control->space = space;
+	u = FN(UNION,transform)(u, control);
+	isl_space_free(space);
+	return u;
+}
+
+/* Update "u" by applying "fn" to each entry.
+ * This operation is assumed not to change the number of entries nor
+ * the spaces of the entries.
+ *
+ * If there is only one reference to "u", then change "u" inplace.
+ * Otherwise, create a new UNION from "u" and discard the original.
+ */
+static __isl_give UNION *FN(UNION,transform_inplace)(__isl_take UNION *u,
+	__isl_give PART *(*fn)(__isl_take PART *part, void *user), void *user)
+{
+	S(UNION,transform_control) control = { .fn = fn, .fn_user = user };
+	isl_bool single_ref;
+
+	single_ref = FN(UNION,has_single_reference)(u);
+	if (single_ref < 0)
+		return FN(UNION,free)(u);
+	if (single_ref)
+		control.inplace = 1;
+	return FN(UNION,transform)(u, &control);
+}
+
+/* An isl_union_*_transform callback for use in isl_union_*_dup
+ * that simply returns "part".
+ */
+static __isl_give PART *FN(UNION,copy_part)(__isl_take PART *part, void *user)
+{
+	return part;
+}
+
+__isl_give UNION *FN(UNION,dup)(__isl_keep UNION *u)
+{
+	S(UNION,transform_control) control = { .fn = &FN(UNION,copy_part) };
+
+	u = FN(UNION,copy)(u);
+	return FN(UNION,transform)(u, &control);
+}
+
 __isl_give UNION *FN(UNION,cow)(__isl_take UNION *u)
 {
 	if (!u)
@@ -243,13 +401,6 @@
 	return FN(UNION,dup)(u);
 }
 
-static int free_u_entry(void **entry, void *user)
-{
-	PART *part = *entry;
-	FN(PART,free)(part);
-	return 0;
-}
-
 __isl_null UNION *FN(UNION,free)(__isl_take UNION *u)
 {
 	if (!u)
@@ -258,88 +409,100 @@
 	if (--u->ref > 0)
 		return NULL;
 
-	isl_hash_table_foreach(u->dim->ctx, &u->table, &free_u_entry, NULL);
+	isl_hash_table_foreach(u->space->ctx, &u->table,
+				&FN(UNION,free_u_entry), NULL);
 	isl_hash_table_clear(&u->table);
-	isl_space_free(u->dim);
+	isl_space_free(u->space);
 	free(u);
 	return NULL;
 }
 
-S(UNION,align) {
-	isl_reordering *exp;
-	UNION *res;
-};
-
-#ifdef ALIGN_DOMAIN
-static int align_entry(__isl_take PART *part, void *user)
+static __isl_give PART *FN(UNION,align_entry)(__isl_take PART *part, void *user)
 {
-	isl_reordering *exp;
-	S(UNION,align) *data = user;
+	isl_reordering *exp = user;
 
-	exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
+	exp = isl_reordering_extend_space(isl_reordering_copy(exp),
 				    FN(PART,get_domain_space)(part));
-
-	data->res = FN(FN(UNION,add),PARTS)(data->res,
-					    FN(PART,realign_domain)(part, exp));
-
-	return 0;
+	return FN(PART,realign_domain)(part, exp);
 }
-#else
-static int align_entry(__isl_take PART *part, void *user)
-{
-	isl_reordering *exp;
-	S(UNION,align) *data = user;
 
-	exp = isl_reordering_extend_space(isl_reordering_copy(data->exp),
-				    FN(PART,get_space)(part));
+/* Reorder the parameters of "u" according to the given reordering.
+ */
+static __isl_give UNION *FN(UNION,realign_domain)(__isl_take UNION *u,
+	__isl_take isl_reordering *r)
+{
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,align_entry),
+		.fn_user = r,
+	};
+	isl_space *space;
 
-	data->res = FN(FN(UNION,add),PARTS)(data->res,
-					    FN(PART,realign)(part, exp));
+	if (!u || !r)
+		goto error;
 
-	return 0;
+	space = isl_reordering_get_space(r);
+	u = FN(UNION,transform_space)(u, space, &control);
+	isl_reordering_free(r);
+	return u;
+error:
+	FN(UNION,free)(u);
+	isl_reordering_free(r);
+	return NULL;
 }
-#endif
 
+/* Align the parameters of "u" to those of "model".
+ */
 __isl_give UNION *FN(UNION,align_params)(__isl_take UNION *u,
 	__isl_take isl_space *model)
 {
-	S(UNION,align) data = { NULL, NULL };
+	isl_bool equal_params;
+	isl_reordering *r;
 
 	if (!u || !model)
 		goto error;
 
-	if (isl_space_match(u->dim, isl_dim_param, model, isl_dim_param)) {
+	equal_params = isl_space_has_equal_params(u->space, model);
+	if (equal_params < 0)
+		goto error;
+	if (equal_params) {
 		isl_space_free(model);
 		return u;
 	}
 
-	model = isl_space_params(model);
-	data.exp = isl_parameter_alignment_reordering(u->dim, model);
-	if (!data.exp)
-		goto error;
-
-#ifdef HAS_TYPE
-	data.res = FN(UNION,alloc)(isl_space_copy(data.exp->dim),
-						u->type, u->table.n);
-#else
-	data.res = FN(UNION,alloc)(isl_space_copy(data.exp->dim), u->table.n);
-#endif
-	if (FN(FN(UNION,foreach),PARTS)(u, &align_entry, &data) < 0)
-		goto error;
-
-	isl_reordering_free(data.exp);
-	FN(UNION,free)(u);
+	r = isl_parameter_alignment_reordering(u->space, model);
 	isl_space_free(model);
-	return data.res;
+
+	return FN(UNION,realign_domain)(u, r);
 error:
-	isl_reordering_free(data.exp);
-	FN(UNION,free)(u);
-	FN(UNION,free)(data.res);
 	isl_space_free(model);
+	FN(UNION,free)(u);
 	return NULL;
 }
 
-__isl_give UNION *FN(UNION,add)(__isl_take UNION *u1, __isl_take UNION *u2)
+/* Add "part" to *u, taking the union sum if "u" already has
+ * a part defined on the same space as "part".
+ */
+static isl_stat FN(UNION,union_add_part)(__isl_take PART *part, void *user)
+{
+	UNION **u = (UNION **)user;
+
+	*u = FN(UNION,add_part_generic)(*u, part, 0);
+
+	return isl_stat_ok;
+}
+
+/* Compute the sum of "u1" and "u2" on the union of their domains,
+ * with the actual sum on the shared domain and
+ * the defined expression on the symmetric difference of the domains.
+ *
+ * This is an internal function that is exposed under different
+ * names depending on whether the base expressions have a zero default
+ * value.
+ * If they do, then this function is called "add".
+ * Otherwise, it is called "union_add".
+ */
+static __isl_give UNION *FN(UNION,union_add_)(__isl_take UNION *u1,
+	__isl_take UNION *u2)
 {
 	u1 = FN(UNION,align_params)(u1, FN(UNION,get_space)(u2));
 	u2 = FN(UNION,align_params)(u2, FN(UNION,get_space)(u1));
@@ -349,7 +512,7 @@
 	if (!u1 || !u2)
 		goto error;
 
-	if (FN(FN(UNION,foreach),PARTS)(u2, &add_part, &u1) < 0)
+	if (FN(FN(UNION,foreach),BASE)(u2, &FN(UNION,union_add_part), &u1) < 0)
 		goto error;
 
 	FN(UNION,free)(u2);
@@ -361,74 +524,90 @@
 	return NULL;
 }
 
-__isl_give UNION *FN(FN(UNION,from),PARTS)(__isl_take PART *part)
+__isl_give UNION *FN(FN(UNION,from),BASE)(__isl_take PART *part)
 {
-	isl_space *dim;
+	isl_space *space;
 	UNION *u;
 
 	if (!part)
 		return NULL;
 
-	dim = FN(PART,get_space)(part);
-	dim = isl_space_drop_dims(dim, isl_dim_in, 0, isl_space_dim(dim, isl_dim_in));
-	dim = isl_space_drop_dims(dim, isl_dim_out, 0, isl_space_dim(dim, isl_dim_out));
-#ifdef HAS_TYPE
-	u = FN(UNION,ZERO)(dim, part->type);
-#else
-	u = FN(UNION,ZERO)(dim);
-#endif
-	u = FN(FN(UNION,add),PARTS)(u, part);
+	space = FN(PART,get_space)(part);
+	space = isl_space_drop_dims(space, isl_dim_in, 0,
+					isl_space_dim(space, isl_dim_in));
+	space = isl_space_drop_dims(space, isl_dim_out, 0,
+					isl_space_dim(space, isl_dim_out));
+	u = FN(UNION,ZERO)(space OPT_TYPE_ARG(part->));
+	u = FN(FN(UNION,add),BASE)(u, part);
 
 	return u;
 }
 
+/* This function performs the same operation as isl_union_pw_*_from_pw_*,
+ * but is considered as a function on an isl_pw_* when exported.
+ */
+__isl_give UNION *FN(FN(PART,to_union),BASE)(__isl_take PART *part)
+{
+	return FN(FN(UNION,from),BASE)(part);
+}
+
 S(UNION,match_bin_data) {
 	UNION *u2;
 	UNION *res;
 	__isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *);
 };
 
-/* Check if data->u2 has an element living in the same space as *entry.
+/* Check if data->u2 has an element living in the same space as "part".
  * If so, call data->fn on the two elements and add the result to
  * data->res.
  */
-static int match_bin_entry(void **entry, void *user)
+static isl_stat FN(UNION,match_bin_entry)(__isl_take PART *part, void *user)
 {
 	S(UNION,match_bin_data) *data = user;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry2;
 	isl_space *space;
-	PART *part = *entry;
+	PART *part2;
 
 	space = FN(PART,get_space)(part);
-	hash = isl_space_get_hash(space);
-	entry2 = isl_hash_table_find(data->u2->dim->ctx, &data->u2->table,
-				     hash, &has_dim, space, 0);
+	entry2 = FN(UNION,find_part_entry)(data->u2, space, 0);
 	isl_space_free(space);
 	if (!entry2)
-		return 0;
+		goto error;
+	if (entry2 == isl_hash_table_entry_none) {
+		FN(PART,free)(part);
+		return isl_stat_ok;
+	}
+
+	part2 = entry2->data;
+	if (!isl_space_tuple_is_equal(part->dim, isl_dim_out,
+					part2->dim, isl_dim_out))
+		isl_die(FN(UNION,get_ctx)(data->u2), isl_error_invalid,
+			"entries should have the same range space",
+			goto error);
 
-	part = FN(PART, copy)(part);
 	part = data->fn(part, FN(PART, copy)(entry2->data));
 
-	data->res = FN(FN(UNION,add),PARTS)(data->res, part);
+	data->res = FN(FN(UNION,add),BASE)(data->res, part);
 	if (!data->res)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
+error:
+	FN(PART,free)(part);
+	return isl_stat_error;
 }
 
 /* This function is currently only used from isl_polynomial.c
  * and not from isl_fold.c.
  */
-static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
+static __isl_give UNION *FN(UNION,match_bin_op)(__isl_take UNION *u1,
 	__isl_take UNION *u2,
 	__isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *))
 	__attribute__ ((unused));
 /* For each pair of elements in "u1" and "u2" living in the same space,
  * call "fn" and collect the results.
  */
-static __isl_give UNION *match_bin_op(__isl_take UNION *u1,
+static __isl_give UNION *FN(UNION,match_bin_op)(__isl_take UNION *u1,
 	__isl_take UNION *u2,
 	__isl_give PART *(*fn)(__isl_take PART *, __isl_take PART *))
 {
@@ -441,13 +620,9 @@
 		goto error;
 
 	data.u2 = u2;
-#ifdef HAS_TYPE
-	data.res = FN(UNION,alloc)(isl_space_copy(u1->dim), u1->type, u1->table.n);
-#else
-	data.res = FN(UNION,alloc)(isl_space_copy(u1->dim), u1->table.n);
-#endif
-	if (isl_hash_table_foreach(u1->dim->ctx, &u1->table,
-				    &match_bin_entry, &data) < 0)
+	data.res = FN(UNION,alloc_same_size)(u1);
+	if (FN(FN(UNION,foreach),BASE)(u1,
+				    &FN(UNION,match_bin_entry), &data) < 0)
 		goto error;
 
 	FN(UNION,free)(u1);
@@ -460,43 +635,54 @@
 	return NULL;
 }
 
+/* Compute the sum of "u1" and "u2".
+ *
+ * If the base expressions have a default zero value, then the sum
+ * is computed on the union of the domains of "u1" and "u2".
+ * Otherwise, it is computed on their shared domains.
+ */
+__isl_give UNION *FN(UNION,add)(__isl_take UNION *u1, __isl_take UNION *u2)
+{
+#if DEFAULT_IS_ZERO
+	return FN(UNION,union_add_)(u1, u2);
+#else
+	return FN(UNION,match_bin_op)(u1, u2, &FN(PART,add));
+#endif
+}
+
 #ifndef NO_SUB
 /* Subtract "u2" from "u1" and return the result.
  */
 __isl_give UNION *FN(UNION,sub)(__isl_take UNION *u1, __isl_take UNION *u2)
 {
-	return match_bin_op(u1, u2, &FN(PART,sub));
+	return FN(UNION,match_bin_op)(u1, u2, &FN(PART,sub));
 }
 #endif
 
 S(UNION,any_set_data) {
 	isl_set *set;
-	UNION *res;
 	__isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
 };
 
-static int any_set_entry(void **entry, void *user)
+static __isl_give PART *FN(UNION,any_set_entry)(__isl_take PART *part,
+	void *user)
 {
 	S(UNION,any_set_data) *data = user;
-	PW *pw = *entry;
 
-	pw = FN(PW,copy)(pw);
-	pw = data->fn(pw, isl_set_copy(data->set));
-
-	data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
-	if (!data->res)
-		return -1;
-
-	return 0;
+	return data->fn(part, isl_set_copy(data->set));
 }
 
 /* Update each element of "u" by calling "fn" on the element and "set".
  */
-static __isl_give UNION *any_set_op(__isl_take UNION *u,
+static __isl_give UNION *FN(UNION,any_set_op)(__isl_take UNION *u,
 	__isl_take isl_set *set,
 	__isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
 {
-	S(UNION,any_set_data) data = { NULL, NULL, fn };
+	S(UNION,any_set_data) data = { NULL, fn };
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,any_set_entry),
+		.fn_user = &data,
+	};
 
 	u = FN(UNION,align_params)(u, isl_set_get_space(set));
 	set = isl_set_align_params(set, FN(UNION,get_space)(u));
@@ -505,22 +691,12 @@
 		goto error;
 
 	data.set = set;
-#ifdef HAS_TYPE
-	data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->type, u->table.n);
-#else
-	data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->table.n);
-#endif
-	if (isl_hash_table_foreach(u->dim->ctx, &u->table,
-				   &any_set_entry, &data) < 0)
-		goto error;
-
-	FN(UNION,free)(u);
+	u = FN(UNION,transform)(u, &control);
 	isl_set_free(set);
-	return data.res;
+	return u;
 error:
 	FN(UNION,free)(u);
 	isl_set_free(set);
-	FN(UNION,free)(data.res);
 	return NULL;
 }
 
@@ -529,7 +705,7 @@
 __isl_give UNION *FN(UNION,intersect_params)(__isl_take UNION *u,
 	__isl_take isl_set *set)
 {
-	return any_set_op(u, set, &FN(PW,intersect_params));
+	return FN(UNION,any_set_op)(u, set, &FN(PW,intersect_params));
 }
 
 /* Compute the gist of the domain of "u" with respect to
@@ -538,77 +714,86 @@
 __isl_give UNION *FN(UNION,gist_params)(__isl_take UNION *u,
 	__isl_take isl_set *set)
 {
-	return any_set_op(u, set, &FN(PW,gist_params));
+	return FN(UNION,any_set_op)(u, set, &FN(PW,gist_params));
 }
 
+/* Data structure that specifies how isl_union_*_match_domain_op
+ * should combine its arguments.
+ *
+ * If "filter" is not NULL, then only parts that pass the given
+ * filter are considered for matching.
+ * "fn" is applied to each part in the union and each corresponding
+ * set in the union set, i.e., such that the set lives in the same space
+ * as the domain of the part.
+ * If "match_space" is not NULL, then the set extracted from the union set
+ * does not live in the same space as the domain of the part,
+ * but rather in the space that results from calling "match_space"
+ * on this domain space.
+ */
+S(UNION,match_domain_control) {
+	isl_bool (*filter)(__isl_keep PART *part);
+	__isl_give isl_space *(*match_space)(__isl_take isl_space *space);
+	__isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
+};
+
 S(UNION,match_domain_data) {
 	isl_union_set *uset;
 	UNION *res;
-	__isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*);
+	S(UNION,match_domain_control) *control;
 };
 
-static int set_has_dim(const void *entry, const void *val)
-{
-	isl_set *set = (isl_set *)entry;
-	isl_space *dim = (isl_space *)val;
-
-	return isl_space_is_equal(set->dim, dim);
-}
-
 /* Find the set in data->uset that lives in the same space as the domain
- * of *entry, apply data->fn to *entry and this set (if any), and add
- * the result to data->res.
+ * of "part" (ignoring parameters), apply data->fn to *entry and this set
+ * (if any), and add the result to data->res.
  */
-static int match_domain_entry(void **entry, void *user)
+static isl_stat FN(UNION,match_domain_entry)(__isl_take PART *part, void *user)
 {
 	S(UNION,match_domain_data) *data = user;
-	uint32_t hash;
 	struct isl_hash_table_entry *entry2;
-	PW *pw = *entry;
 	isl_space *space;
 
-	space = FN(PW,get_domain_space)(pw);
-	hash = isl_space_get_hash(space);
-	entry2 = isl_hash_table_find(data->uset->dim->ctx, &data->uset->table,
-				     hash, &set_has_dim, space, 0);
+	if (data->control->filter) {
+		isl_bool pass = data->control->filter(part);
+		if (pass < 0 || !pass) {
+			FN(PART,free)(part);
+			return pass < 0 ? isl_stat_error : isl_stat_ok;
+		}
+	}
+
+	space = FN(PART,get_domain_space)(part);
+	if (data->control->match_space)
+		space = data->control->match_space(space);
+	entry2 = isl_union_set_find_entry(data->uset, space, 0);
 	isl_space_free(space);
-	if (!entry2)
-		return 0;
+	if (!entry2 || entry2 == isl_hash_table_entry_none) {
+		FN(PART,free)(part);
+		return isl_stat_non_null(entry2);
+	}
 
-	pw = FN(PW,copy)(pw);
-	pw = data->fn(pw, isl_set_copy(entry2->data));
+	part = data->control->fn(part, isl_set_copy(entry2->data));
 
-	data->res = FN(FN(UNION,add),PARTS)(data->res, pw);
+	data->res = FN(FN(UNION,add),BASE)(data->res, part);
 	if (!data->res)
-		return -1;
+		return isl_stat_error;
 
-	return 0;
+	return isl_stat_ok;
 }
 
-/* Apply fn to each pair of PW in u and set in uset such that
- * the set lives in the same space as the domain of PW
+/* Combine "u" and "uset" according to "control"
  * and collect the results.
  */
-static __isl_give UNION *match_domain_op(__isl_take UNION *u,
-	__isl_take isl_union_set *uset,
-	__isl_give PW *(*fn)(__isl_take PW*, __isl_take isl_set*))
+static __isl_give UNION *FN(UNION,match_domain_op)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset, S(UNION,match_domain_control) *control)
 {
-	S(UNION,match_domain_data) data = { NULL, NULL, fn };
-
-	u = FN(UNION,align_params)(u, isl_union_set_get_space(uset));
-	uset = isl_union_set_align_params(uset, FN(UNION,get_space)(u));
+	S(UNION,match_domain_data) data = { NULL, NULL, control };
 
 	if (!u || !uset)
 		goto error;
 
 	data.uset = uset;
-#ifdef HAS_TYPE
-	data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->type, u->table.n);
-#else
-	data.res = FN(UNION,alloc)(isl_space_copy(u->dim), u->table.n);
-#endif
-	if (isl_hash_table_foreach(u->dim->ctx, &u->table,
-				   &match_domain_entry, &data) < 0)
+	data.res = FN(UNION,alloc_same_size)(u);
+	if (FN(FN(UNION,foreach),BASE)(u,
+				   &FN(UNION,match_domain_entry), &data) < 0)
 		goto error;
 
 	FN(UNION,free)(u);
@@ -625,77 +810,197 @@
  * If "uset" is a parameters domain, then intersect the parameter
  * domain of "u" with this set.
  */
-__isl_give UNION *FN(UNION,intersect_domain)(__isl_take UNION *u,
+__isl_give UNION *FN(UNION,intersect_domain_union_set)(__isl_take UNION *u,
 	__isl_take isl_union_set *uset)
 {
+	S(UNION,match_domain_control) control = {
+		.fn = &FN(PW,intersect_domain),
+	};
+
 	if (isl_union_set_is_params(uset))
 		return FN(UNION,intersect_params)(u,
 						isl_set_from_union_set(uset));
-	return match_domain_op(u, uset, &FN(PW,intersect_domain));
+	return FN(UNION,match_domain_op)(u, uset, &control);
 }
 
-__isl_give UNION *FN(UNION,gist)(__isl_take UNION *u,
+/* This is an alternative name for the function above.
+ */
+__isl_give UNION *FN(UNION,intersect_domain)(__isl_take UNION *u,
 	__isl_take isl_union_set *uset)
 {
-	if (isl_union_set_is_params(uset))
-		return FN(UNION,gist_params)(u, isl_set_from_union_set(uset));
-	return match_domain_op(u, uset, &FN(PW,gist));
+	return FN(UNION,intersect_domain_union_set)(u, uset);
 }
 
-#ifndef NO_EVAL
-__isl_give isl_val *FN(UNION,eval)(__isl_take UNION *u,
-	__isl_take isl_point *pnt)
+/* Return true if this part should be kept.
+ *
+ * In particular, it should be kept if its domain space
+ * corresponds to "space".
+ */
+static isl_bool FN(UNION,select_entry)(__isl_keep PART *part, void *user)
 {
-	uint32_t hash;
-	struct isl_hash_table_entry *entry;
+	isl_space *space = user;
+
+	return FN(PW,has_domain_space_tuples)(part, space);
+}
+
+/* Remove any not element in "space" from the domain of "u".
+ *
+ * In particular, select any part of the function defined
+ * on this domain space.
+ */
+__isl_give UNION *FN(UNION,intersect_domain_space)(__isl_take UNION *u,
+	__isl_take isl_space *space)
+{
+	S(UNION,transform_control) control = {
+		.filter = &FN(UNION,select_entry),
+		.filter_user = space,
+	};
+
+	u = FN(UNION,transform)(u, &control);
+	isl_space_free(space);
+	return u;
+}
+
+/* Is the domain of "pw" a wrapped relation?
+ */
+static isl_bool FN(PW,domain_is_wrapping)(__isl_keep PW *pw)
+{
+	return isl_space_domain_is_wrapping(FN(PW,peek_space)(pw));
+}
+
+/* Intersect the domain of the wrapped relation inside the domain of "u"
+ * with "uset".
+ */
+__isl_give UNION *FN(UNION,intersect_domain_wrapped_domain)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset)
+{
+	S(UNION,match_domain_control) control = {
+		.filter = &FN(PART,domain_is_wrapping),
+		.match_space = &isl_space_factor_domain,
+		.fn = &FN(PW,intersect_domain_wrapped_domain),
+	};
+
+	return FN(UNION,match_domain_op)(u, uset, &control);
+}
+
+/* Intersect the range of the wrapped relation inside the domain of "u"
+ * with "uset".
+ */
+__isl_give UNION *FN(UNION,intersect_domain_wrapped_range)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset)
+{
+	S(UNION,match_domain_control) control = {
+		.filter = &FN(PART,domain_is_wrapping),
+		.match_space = &isl_space_factor_range,
+		.fn = &FN(PW,intersect_domain_wrapped_range),
+	};
+
+	return FN(UNION,match_domain_op)(u, uset, &control);
+}
+
+/* Take the set (which may be empty) in data->uset that lives
+ * in the same space as the domain of "pw", subtract it from the domain
+ * of "part" and return the result.
+ */
+static __isl_give PART *FN(UNION,subtract_domain_entry)(__isl_take PART *part,
+	void *user)
+{
+	isl_union_set *uset = user;
 	isl_space *space;
-	isl_val *v;
+	isl_set *set;
 
-	if (!u || !pnt)
-		goto error;
+	space = FN(PART,get_domain_space)(part);
+	set = isl_union_set_extract_set(uset, space);
+	return FN(PART,subtract_domain)(part, set);
+}
 
-	space = isl_space_copy(pnt->dim);
-	space = isl_space_from_domain(space);
-	space = isl_space_add_dims(space, isl_dim_out, 1);
-	if (!space)
-		goto error;
-	hash = isl_space_get_hash(space);
-	entry = isl_hash_table_find(u->dim->ctx, &u->table,
-				    hash, &has_dim, space, 0);
+/* Subtract "uset" from the domain of "u".
+ */
+__isl_give UNION *FN(UNION,subtract_domain_union_set)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset)
+{
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,subtract_domain_entry),
+		.fn_user = uset,
+	};
+
+	u = FN(UNION,transform)(u, &control);
+	isl_union_set_free(uset);
+	return u;
+}
+
+/* This is an alternative name for the function above.
+ */
+__isl_give UNION *FN(UNION,subtract_domain)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset)
+{
+	return FN(UNION,subtract_domain_union_set)(u, uset);
+}
+
+/* Return true if this part should be kept.
+ *
+ * In particular, it should be kept if its domain space
+ * does not correspond to "space".
+ */
+static isl_bool FN(UNION,filter_out_entry)(__isl_keep PART *part, void *user)
+{
+	isl_space *space = user;
+
+	return isl_bool_not(FN(PW,has_domain_space_tuples)(part, space));
+}
+
+/* Remove any element in "space" from the domain of "u".
+ *
+ * In particular, filter out any part of the function defined
+ * on this domain space.
+ */
+__isl_give UNION *FN(UNION,subtract_domain_space)(__isl_take UNION *u,
+	__isl_take isl_space *space)
+{
+	S(UNION,transform_control) control = {
+		.filter = &FN(UNION,filter_out_entry),
+		.filter_user = space,
+	};
+
+	u = FN(UNION,transform)(u, &control);
 	isl_space_free(space);
-	if (!entry) {
-		v = isl_val_zero(isl_point_get_ctx(pnt));
-		isl_point_free(pnt);
-	} else {
-		v = FN(PART,eval)(FN(PART,copy)(entry->data), pnt);
-	}
-	FN(UNION,free)(u);
-	return v;
-error:
-	FN(UNION,free)(u);
-	isl_point_free(pnt);
-	return NULL;
+	return u;
 }
-#endif
 
-static int coalesce_entry(void **entry, void *user)
+__isl_give UNION *FN(UNION,gist)(__isl_take UNION *u,
+	__isl_take isl_union_set *uset)
 {
-	PW **pw = (PW **)entry;
+	S(UNION,match_domain_control) control = {
+		.fn = &FN(PW,gist),
+	};
 
-	*pw = FN(PW,coalesce)(*pw);
-	if (!*pw)
-		return -1;
+	if (isl_union_set_is_params(uset))
+		return FN(UNION,gist_params)(u, isl_set_from_union_set(uset));
+	return FN(UNION,match_domain_op)(u, uset, &control);
+}
+
+/* Coalesce an entry in a UNION.  Coalescing is performed in-place.
+ * Since the UNION may have several references, the entry is only
+ * replaced if the coalescing is successful.
+ */
+static isl_stat FN(UNION,coalesce_entry)(void **entry, void *user)
+{
+	PART **part_p = (PART **) entry;
+	PART *part;
 
-	return 0;
+	part = FN(PART,copy)(*part_p);
+	part = FN(PW,coalesce)(part);
+	if (!part)
+		return isl_stat_error;
+	FN(PART,free)(*part_p);
+	*part_p = part;
+
+	return isl_stat_ok;
 }
 
 __isl_give UNION *FN(UNION,coalesce)(__isl_take UNION *u)
 {
-	if (!u)
-		return NULL;
-
-	if (isl_hash_table_foreach(u->dim->ctx, &u->table,
-				   &coalesce_entry, NULL) < 0)
+	if (FN(UNION,foreach_inplace)(u, &FN(UNION,coalesce_entry), NULL) < 0)
 		goto error;
 
 	return u;
@@ -704,13 +1009,13 @@
 	return NULL;
 }
 
-static int domain(__isl_take PART *part, void *user)
+static isl_stat FN(UNION,domain_entry)(__isl_take PART *part, void *user)
 {
 	isl_union_set **uset = (isl_union_set **)user;
 
 	*uset = isl_union_set_add_set(*uset, FN(PART,domain)(part));
 
-	return 0;
+	return isl_stat_ok;
 }
 
 __isl_give isl_union_set *FN(UNION,domain)(__isl_take UNION *u)
@@ -718,7 +1023,7 @@
 	isl_union_set *uset;
 
 	uset = isl_union_set_empty(FN(UNION,get_space)(u));
-	if (FN(FN(UNION,foreach),PARTS)(u, &domain, &uset) < 0)
+	if (FN(FN(UNION,foreach),BASE)(u, &FN(UNION,domain_entry), &uset) < 0)
 		goto error;
 
 	FN(UNION,free)(u);
@@ -730,72 +1035,87 @@
 	return NULL;
 }
 
-static int mul_isl_int(void **entry, void *user)
+#ifdef HAS_TYPE
+/* Negate the type of "u".
+ */
+static __isl_give UNION *FN(UNION,negate_type)(__isl_take UNION *u)
+{
+	u = FN(UNION,cow)(u);
+	if (!u)
+		return NULL;
+	u->type = isl_fold_type_negate(u->type);
+	return u;
+}
+#else
+/* Negate the type of "u".
+ * Since "u" does not have a type, do nothing.
+ */
+static __isl_give UNION *FN(UNION,negate_type)(__isl_take UNION *u)
 {
-	PW **pw = (PW **)entry;
-	isl_int *v = user;
+	return u;
+}
+#endif
 
-	*pw = FN(PW,mul_isl_int)(*pw, *v);
-	if (!*pw)
-		return -1;
+/* Multiply "part" by the isl_val "user" and return the result.
+ */
+static __isl_give PART *FN(UNION,scale_val_entry)(__isl_take PART *part,
+	void *user)
+{
+	isl_val *v = user;
 
-	return 0;
+	return FN(PART,scale_val)(part, isl_val_copy(v));
 }
 
-__isl_give UNION *FN(UNION,mul_isl_int)(__isl_take UNION *u, isl_int v)
+/* Multiply "u" by "v" and return the result.
+ */
+__isl_give UNION *FN(UNION,scale_val)(__isl_take UNION *u,
+	__isl_take isl_val *v)
 {
-	if (isl_int_is_one(v))
+	if (!u || !v)
+		goto error;
+	if (isl_val_is_one(v)) {
+		isl_val_free(v);
 		return u;
+	}
 
-	if (DEFAULT_IS_ZERO && u && isl_int_is_zero(v)) {
+	if (DEFAULT_IS_ZERO && u && isl_val_is_zero(v)) {
 		UNION *zero;
-		isl_space *dim = FN(UNION,get_space)(u);
-#ifdef HAS_TYPE
-		zero = FN(UNION,ZERO)(dim, u->type);
-#else
-		zero = FN(UNION,ZERO)(dim);
-#endif
+		isl_space *space = FN(UNION,get_space)(u);
+		zero = FN(UNION,ZERO)(space OPT_TYPE_ARG(u->));
 		FN(UNION,free)(u);
+		isl_val_free(v);
 		return zero;
 	}
 
-	u = FN(UNION,cow)(u);
-	if (!u)
-		return NULL;
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational factor", goto error);
 
-#ifdef HAS_TYPE
-	if (isl_int_is_neg(v))
-		u->type = isl_fold_type_negate(u->type);
-#endif
-	if (isl_hash_table_foreach(u->dim->ctx, &u->table,
-				    &mul_isl_int, &v) < 0)
-		goto error;
+	u = FN(UNION,transform_inplace)(u, &FN(UNION,scale_val_entry), v);
+	if (isl_val_is_neg(v))
+		u = FN(UNION,negate_type)(u);
 
+	isl_val_free(v);
 	return u;
 error:
+	isl_val_free(v);
 	FN(UNION,free)(u);
 	return NULL;
 }
 
-/* Multiply *entry by the isl_val "user".
- *
- * Return 0 on success and -1 on error.
+/* Divide "part" by the isl_val "user" and return the result.
  */
-static int scale_val(void **entry, void *user)
+static __isl_give PART *FN(UNION,scale_down_val_entry)(__isl_take PART *part,
+	void *user)
 {
-	PW **pw = (PW **)entry;
 	isl_val *v = user;
 
-	*pw = FN(PW,scale_val)(*pw, isl_val_copy(v));
-	if (!*pw)
-		return -1;
-
-	return 0;
+	return FN(PART,scale_down_val)(part, isl_val_copy(v));
 }
 
-/* Multiply "u" by "v" and return the result.
+/* Divide "u" by "v" and return the result.
  */
-__isl_give UNION *FN(UNION,scale_val)(__isl_take UNION *u,
+__isl_give UNION *FN(UNION,scale_down_val)(__isl_take UNION *u,
 	__isl_take isl_val *v)
 {
 	if (!u || !v)
@@ -805,33 +1125,16 @@
 		return u;
 	}
 
-	if (DEFAULT_IS_ZERO && u && isl_val_is_zero(v)) {
-		UNION *zero;
-		isl_space *space = FN(UNION,get_space)(u);
-#ifdef HAS_TYPE
-		zero = FN(UNION,ZERO)(space, u->type);
-#else
-		zero = FN(UNION,ZERO)(space);
-#endif
-		FN(UNION,free)(u);
-		isl_val_free(v);
-		return zero;
-	}
-
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
 			"expecting rational factor", goto error);
+	if (isl_val_is_zero(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"cannot scale down by zero", goto error);
 
-	u = FN(UNION,cow)(u);
-	if (!u)
-		return NULL;
-
-#ifdef HAS_TYPE
+	u = FN(UNION,transform_inplace)(u, &FN(UNION,scale_down_val_entry), v);
 	if (isl_val_is_neg(v))
-		u->type = isl_fold_type_negate(u->type);
-#endif
-	if (isl_hash_table_foreach(u->dim->ctx, &u->table, &scale_val, v) < 0)
-		goto error;
+		u = FN(UNION,negate_type)(u);
 
 	isl_val_free(v);
 	return u;
@@ -841,44 +1144,88 @@
 	return NULL;
 }
 
+/* Internal data structure for isl_union_*_every_*.
+ *
+ * "test" is the user-specified callback function.
+ * "user" is the user-specified callback function argument.
+ *
+ * "res" is the final result, initialized to isl_bool_true.
+ */
+S(UNION,every_data) {
+	isl_bool (*test)(__isl_keep PW *pw, void *user);
+	void *user;
+
+	isl_bool res;
+};
+
+/* Call data->test on the piecewise expression at *entry,
+ * updating the result in data->res.
+ * Abort if this result is no longer isl_bool_true.
+ */
+static isl_stat FN(UNION,every_entry)(void **entry, void *user)
+{
+	S(UNION,every_data) *data = user;
+	PW *pw = *entry;
+
+	data->res = data->test(pw, data->user);
+	if (data->res < 0 || !data->res)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Does "test" succeed on every piecewise expression in "u"?
+ */
+isl_bool FN(FN(UNION,every),BASE)(__isl_keep UNION *u,
+	isl_bool (*test)(__isl_keep PW *pw, void *user), void *user)
+{
+	S(UNION,every_data) data = { test, user };
+
+	data.res = isl_bool_true;
+	if (FN(UNION,foreach_inplace)(u, &FN(UNION,every_entry), &data) < 0 &&
+	    data.res == isl_bool_true)
+		return isl_bool_error;
+
+	return data.res;
+}
+
 S(UNION,plain_is_equal_data)
 {
 	UNION *u2;
-	int is_equal;
 };
 
-static int plain_is_equal_entry(void **entry, void *user)
+static isl_bool FN(UNION,plain_is_equal_el)(__isl_keep PW *pw, void *user)
 {
 	S(UNION,plain_is_equal_data) *data = user;
-	uint32_t hash;
-	struct isl_hash_table_entry *entry2;
-	PW *pw = *entry;
-
-	hash = isl_space_get_hash(pw->dim);
-	entry2 = isl_hash_table_find(data->u2->dim->ctx, &data->u2->table,
-				     hash, &has_dim, pw->dim, 0);
-	if (!entry2) {
-		data->is_equal = 0;
-		return -1;
-	}
+	struct isl_hash_table_entry *entry;
 
-	data->is_equal = FN(PW,plain_is_equal)(pw, entry2->data);
-	if (data->is_equal < 0 || !data->is_equal)
-		return -1;
+	entry = FN(UNION,find_part_entry)(data->u2, pw->dim, 0);
+	if (!entry)
+		return isl_bool_error;
+	if (entry == isl_hash_table_entry_none)
+		return isl_bool_false;
 
-	return 0;
+	return FN(PW,plain_is_equal)(pw, entry->data);
 }
 
-int FN(UNION,plain_is_equal)(__isl_keep UNION *u1, __isl_keep UNION *u2)
+isl_bool FN(UNION,plain_is_equal)(__isl_keep UNION *u1, __isl_keep UNION *u2)
 {
-	S(UNION,plain_is_equal_data) data = { NULL, 1 };
+	S(UNION,plain_is_equal_data) data;
+	isl_size n1, n2;
+	isl_bool is_equal;
 
 	if (!u1 || !u2)
-		return -1;
+		return isl_bool_error;
 	if (u1 == u2)
-		return 1;
+		return isl_bool_true;
 	if (u1->table.n != u2->table.n)
-		return 0;
+		return isl_bool_false;
+	n1 = FN(FN(UNION,n),BASE)(u1);
+	n2 = FN(FN(UNION,n),BASE)(u2);
+	if (n1 < 0 || n2 < 0)
+		return isl_bool_error;
+	if (n1 != n2)
+		return isl_bool_false;
 
 	u1 = FN(UNION,copy)(u1);
 	u2 = FN(UNION,copy)(u2);
@@ -888,17 +1235,185 @@
 		goto error;
 
 	data.u2 = u2;
-	if (isl_hash_table_foreach(u1->dim->ctx, &u1->table,
-				   &plain_is_equal_entry, &data) < 0 &&
-	    data.is_equal)
-		goto error;
+	is_equal = FN(FN(UNION,every),BASE)(u1,
+					  &FN(UNION,plain_is_equal_el), &data);
 
 	FN(UNION,free)(u1);
 	FN(UNION,free)(u2);
 
-	return data.is_equal;
+	return is_equal;
 error:
 	FN(UNION,free)(u1);
 	FN(UNION,free)(u2);
-	return -1;
+	return isl_bool_error;
+}
+
+/* An isl_union_*_every_* callback that checks whether "pw"
+ * does not involve any NaNs.
+ */
+static isl_bool FN(UNION,no_nan_el)(__isl_keep PW *pw, void *user)
+{
+	return isl_bool_not(FN(PW,involves_nan)(pw));
+}
+
+/* Does "u" involve any NaNs?
+ */
+isl_bool FN(UNION,involves_nan)(__isl_keep UNION *u)
+{
+	isl_bool no_nan;
+
+	no_nan = FN(FN(UNION,every),BASE)(u, &FN(UNION,no_nan_el), NULL);
+
+	return isl_bool_not(no_nan);
+}
+
+/* Internal data structure for isl_union_*_drop_dims.
+ * type, first and n are passed to isl_*_drop_dims.
+ */
+S(UNION,drop_dims_data) {
+	enum isl_dim_type type;
+	unsigned first;
+	unsigned n;
+};
+
+/* Drop the parameters specified by "data" from "part" and return the result.
+ */
+static __isl_give PART *FN(UNION,drop_dims_entry)(__isl_take PART *part,
+	void *user)
+{
+	S(UNION,drop_dims_data) *data = user;
+
+	return FN(PART,drop_dims)(part, data->type, data->first, data->n);
+}
+
+/* Drop the specified parameters from "u".
+ * That is, type is required to be isl_dim_param.
+ */
+__isl_give UNION *FN(UNION,drop_dims)( __isl_take UNION *u,
+	enum isl_dim_type type, unsigned first, unsigned n)
+{
+	isl_space *space;
+	S(UNION,drop_dims_data) data = { type, first, n };
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,drop_dims_entry),
+		.fn_user = &data,
+	};
+
+	if (!u)
+		return NULL;
+
+	if (type != isl_dim_param)
+		isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
+			"can only project out parameters",
+			return FN(UNION,free)(u));
+
+	space = FN(UNION,get_space)(u);
+	space = isl_space_drop_dims(space, type, first, n);
+	return FN(UNION,transform_space)(u, space, &control);
+}
+
+/* Internal data structure for isl_union_*_set_dim_name.
+ * pos is the position of the parameter that needs to be renamed.
+ * s is the new name.
+ */
+S(UNION,set_dim_name_data) {
+	unsigned pos;
+	const char *s;
+};
+
+/* Change the name of the parameter at position data->pos of "part" to data->s
+ * and return the result.
+ */
+static __isl_give PART *FN(UNION,set_dim_name_entry)(__isl_take PART *part,
+	void *user)
+{
+	S(UNION,set_dim_name_data) *data = user;
+
+	return FN(PART,set_dim_name)(part, isl_dim_param, data->pos, data->s);
+}
+
+/* Change the name of the parameter at position "pos" to "s".
+ * That is, type is required to be isl_dim_param.
+ */
+__isl_give UNION *FN(UNION,set_dim_name)(__isl_take UNION *u,
+	enum isl_dim_type type, unsigned pos, const char *s)
+{
+	S(UNION,set_dim_name_data) data = { pos, s };
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,set_dim_name_entry),
+		.fn_user = &data,
+	};
+	isl_space *space;
+
+	if (!u)
+		return NULL;
+
+	if (type != isl_dim_param)
+		isl_die(FN(UNION,get_ctx)(u), isl_error_invalid,
+			"can only set parameter names",
+			return FN(UNION,free)(u));
+
+	space = FN(UNION,get_space)(u);
+	space = isl_space_set_dim_name(space, type, pos, s);
+	return FN(UNION,transform_space)(u, space, &control);
+}
+
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * of the space of "part" and return the result.
+ */
+static __isl_give PART *FN(UNION,reset_user_entry)(__isl_take PART *part,
+	void *user)
+{
+	return FN(PART,reset_user)(part);
+}
+
+/* Reset the user pointer on all identifiers of parameters and tuples
+ * of the spaces of "u".
+ */
+__isl_give UNION *FN(UNION,reset_user)(__isl_take UNION *u)
+{
+	S(UNION,transform_control) control = {
+		.fn = &FN(UNION,reset_user_entry),
+	};
+	isl_space *space;
+
+	space = FN(UNION,get_space)(u);
+	space = isl_space_reset_user(space);
+	return FN(UNION,transform_space)(u, space, &control);
+}
+
+/* Add the base expression held by "entry" to "list".
+ */
+static isl_stat FN(UNION,add_to_list)(void **entry, void *user)
+{
+	PW *pw = *entry;
+	LIST(PART) **list = user;
+
+	*list = FN(LIST(PART),add)(*list, FN(PART,copy)(pw));
+	if (!*list)
+		return isl_stat_error;
+
+	return isl_stat_ok;
+}
+
+/* Return a list containing all the base expressions in "u".
+ *
+ * First construct a list of the appropriate size and
+ * then add all the elements.
+ */
+__isl_give LIST(PART) *FN(FN(UNION,get),LIST(BASE))(__isl_keep UNION *u)
+{
+	isl_size n;
+	LIST(PART) *list;
+
+	if (!u)
+		return NULL;
+	n = FN(FN(UNION,n),BASE)(u);
+	if (n < 0)
+		return NULL;
+	list = FN(LIST(PART),alloc)(FN(UNION,get_ctx(u)), n);
+	if (FN(UNION,foreach_inplace)(u, &FN(UNION,add_to_list), &list) < 0)
+		return FN(LIST(PART),free)(list);
+
+	return list;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_val.c -> _service:tar_scm:isl-0.24.tar.gz/isl_val.c Changed

@@ -11,8 +11,8 @@
 #include <isl_ctx_private.h>
 #include <isl_val_private.h>
 
-#undef BASE
-#define BASE val
+#undef EL_BASE
+#define EL_BASE val
 
 #include <isl_list_templ.c>
 
@@ -295,15 +295,15 @@
  *
  * If "v" is not a rational value, then the result is undefined.
  */
-int isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
+isl_stat isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n)
 {
 	if (!v)
-		return -1;
+		return isl_stat_error;
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational value", return -1);
+			"expecting rational value", return isl_stat_error);
 	isl_int_set(*n, v->n);
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Extract the denominator of a rational value "v" as an integer.
@@ -323,6 +323,20 @@
 	return isl_int_get_si(v->d);
 }
 
+/* Extract the denominator of a rational value "v" as an isl_val.
+ *
+ * If "v" is not a rational value, then the result is undefined.
+ */
+__isl_give isl_val *isl_val_get_den_val(__isl_keep isl_val *v)
+{
+	if (!v)
+		return NULL;
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational value", return NULL);
+	return isl_val_int_from_isl_int(isl_val_get_ctx(v), v->d);
+}
+
 /* Return an approximation of "v" as a double.
  */
 double isl_val_get_d(__isl_keep isl_val *v)
@@ -342,6 +356,22 @@
 	return val ? val->ctx : NULL;
 }
 
+/* Return a hash value that digests "val".
+ */
+uint32_t isl_val_get_hash(__isl_keep isl_val *val)
+{
+	uint32_t hash;
+
+	if (!val)
+		return 0;
+
+	hash = isl_hash_init();
+	hash = isl_int_hash(val->n, hash);
+	hash = isl_int_hash(val->d, hash);
+
+	return hash;
+}
+
 /* Normalize "v".
  *
  * In particular, make sure that the denominator of a rational value
@@ -393,6 +423,33 @@
 	return v;
 }
 
+/* Return the inverse of "v".
+ */
+__isl_give isl_val *isl_val_inv(__isl_take isl_val *v)
+{
+	if (!v)
+		return NULL;
+	if (isl_val_is_nan(v))
+		return v;
+	if (isl_val_is_zero(v)) {
+		isl_ctx *ctx = isl_val_get_ctx(v);
+		isl_val_free(v);
+		return isl_val_nan(ctx);
+	}
+	if (isl_val_is_infty(v) || isl_val_is_neginfty(v)) {
+		isl_ctx *ctx = isl_val_get_ctx(v);
+		isl_val_free(v);
+		return isl_val_zero(ctx);
+	}
+
+	v = isl_val_cow(v);
+	if (!v)
+		return NULL;
+	isl_int_swap(v->n, v->d);
+
+	return isl_val_normalize(v);
+}
+
 /* Return the absolute value of "v".
  */
 __isl_give isl_val *isl_val_abs(__isl_take isl_val *v)
@@ -471,7 +528,7 @@
 
 /* Return 2^v, where v is an integer (that is not too large).
  */
-__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
+__isl_give isl_val *isl_val_pow2(__isl_take isl_val *v)
 {
 	unsigned long exp;
 	int neg;
@@ -500,6 +557,13 @@
 	return v;
 }
 
+/* This is an alternative name for the function above.
+ */
+__isl_give isl_val *isl_val_2exp(__isl_take isl_val *v)
+{
+	return isl_val_pow2(v);
+}
+
 /* Return the minimum of "v1" and "v2".
  */
 __isl_give isl_val *isl_val_min(__isl_take isl_val *v1, __isl_take isl_val *v2)
@@ -859,6 +923,31 @@
 }
 
 /* Divide "v1" by "v2".
+ */
+__isl_give isl_val *isl_val_div_ui(__isl_take isl_val *v1, unsigned long v2)
+{
+	if (!v1)
+		return NULL;
+	if (isl_val_is_nan(v1))
+		return v1;
+	if (v2 == 0)
+		return isl_val_set_nan(v1);
+	if (v2 == 1)
+		return v1;
+	if (isl_val_is_zero(v1))
+		return v1;
+	if (isl_val_is_infty(v1) || isl_val_is_neginfty(v1))
+		return v1;
+	v1 = isl_val_cow(v1);
+	if (!v1)
+		return NULL;
+
+	isl_int_mul_ui(v1->d, v1->d, v2);
+
+	return isl_val_normalize(v1);
+}
+
+/* Divide "v1" by "v2".
  *
  * This is a private copy of isl_val_div for use in the generic
  * isl_multi_*_scale_down_val instantiated for isl_val.
@@ -871,16 +960,16 @@
 
 /* Given two integer values "v1" and "v2", check if "v1" is divisible by "v2".
  */
-int isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_is_divisible_by(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	if (!v1 || !v2)
-		return -1;
+		return isl_bool_error;
 
 	if (!isl_val_is_int(v1) || !isl_val_is_int(v2))
 		isl_die(isl_val_get_ctx(v1), isl_error_invalid,
-			"expecting two integers", return -1);
+			"expecting two integers", return isl_bool_error);
 
-	return isl_int_is_divisible_by(v1->n, v2->n);
+	return isl_bool_ok(isl_int_is_divisible_by(v1->n, v2->n));
 }
 
 /* Given two integer values "v1" and "v2", return the residue of "v1"
@@ -909,6 +998,18 @@
 	return NULL;
 }
 
+/* Given two integer values "v1" and "v2", return the residue of "v1"
+ * modulo "v2".
+ *
+ * This is a private copy of isl_val_mod for use in the generic
+ * isl_multi_*_mod_multi_val instantiated for isl_val.
+ */
+__isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
+	__isl_take isl_val *v2)
+{
+	return isl_val_mod(v1, v2);
+}
+
 /* Given two integer values, return their greatest common divisor.
  */
 __isl_give isl_val *isl_val_gcd(__isl_take isl_val *v1, __isl_take isl_val *v2)
@@ -944,7 +1045,7 @@
 
 /* Compute x, y and g such that g = gcd(a,b) and a*x+b*y = g.
  */
-static void isl_int_gcdext(isl_int g, isl_int x, isl_int y,
+static void isl_int_gcdext(isl_int *g, isl_int *x, isl_int *y,
 	isl_int a, isl_int b)
 {
 	isl_int d, tmp;
@@ -956,27 +1057,27 @@
 	isl_int_init(tmp);
 	isl_int_set(a_copy, a);
 	isl_int_set(b_copy, b);
-	isl_int_abs(g, a_copy);
+	isl_int_abs(*g, a_copy);
 	isl_int_abs(d, b_copy);
-	isl_int_set_si(x, 1);
-	isl_int_set_si(y, 0);
+	isl_int_set_si(*x, 1);
+	isl_int_set_si(*y, 0);
 	while (isl_int_is_pos(d)) {
-		isl_int_fdiv_q(tmp, g, d);
-		isl_int_submul(x, tmp, y);
-		isl_int_submul(g, tmp, d);
-		isl_int_swap(g, d);
-		isl_int_swap(x, y);
+		isl_int_fdiv_q(tmp, *g, d);
+		isl_int_submul(*x, tmp, *y);
+		isl_int_submul(*g, tmp, d);
+		isl_int_swap(*g, d);
+		isl_int_swap(*x, *y);
 	}
 	if (isl_int_is_zero(a_copy))
-		isl_int_set_si(x, 0);
+		isl_int_set_si(*x, 0);
 	else if (isl_int_is_neg(a_copy))
-		isl_int_neg(x, x);
+		isl_int_neg(*x, *x);
 	if (isl_int_is_zero(b_copy))
-		isl_int_set_si(y, 0);
+		isl_int_set_si(*y, 0);
 	else {
-		isl_int_mul(tmp, a_copy, x);
-		isl_int_sub(tmp, g, tmp);
-		isl_int_divexact(y, tmp, b_copy);
+		isl_int_mul(tmp, a_copy, *x);
+		isl_int_sub(tmp, *g, tmp);
+		isl_int_divexact(*y, tmp, b_copy);
 	}
 	isl_int_clear(d);
 	isl_int_clear(tmp);
@@ -1009,7 +1110,7 @@
 	b = isl_val_alloc(ctx);
 	if (!v1 || !a || !b)
 		goto error;
-	isl_int_gcdext(v1->n, a->n, b->n, v1->n, v2->n);
+	isl_int_gcdext(&v1->n, &a->n, &b->n, v1->n, v2->n);
 	if (x) {
 		isl_int_set_si(a->d, 1);
 		*x = a;
@@ -1036,128 +1137,131 @@
 
 /* Does "v" represent an integer value?
  */
-int isl_val_is_int(__isl_keep isl_val *v)
+isl_bool isl_val_is_int(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_one(v->d);
+	return isl_bool_ok(isl_int_is_one(v->d));
 }
 
 /* Does "v" represent a rational value?
  */
-int isl_val_is_rat(__isl_keep isl_val *v)
+isl_bool isl_val_is_rat(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return !isl_int_is_zero(v->d);
+	return isl_bool_ok(!isl_int_is_zero(v->d));
 }
 
 /* Does "v" represent NaN?
  */
-int isl_val_is_nan(__isl_keep isl_val *v)
+isl_bool isl_val_is_nan(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_zero(v->n) && isl_int_is_zero(v->d);
+	return isl_bool_ok(isl_int_is_zero(v->n) && isl_int_is_zero(v->d));
 }
 
 /* Does "v" represent +infinity?
  */
-int isl_val_is_infty(__isl_keep isl_val *v)
+isl_bool isl_val_is_infty(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_pos(v->n) && isl_int_is_zero(v->d);
+	return isl_bool_ok(isl_int_is_pos(v->n) && isl_int_is_zero(v->d));
 }
 
 /* Does "v" represent -infinity?
  */
-int isl_val_is_neginfty(__isl_keep isl_val *v)
+isl_bool isl_val_is_neginfty(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_neg(v->n) && isl_int_is_zero(v->d);
+	return isl_bool_ok(isl_int_is_neg(v->n) && isl_int_is_zero(v->d));
 }
 
 /* Does "v" represent the integer zero?
  */
-int isl_val_is_zero(__isl_keep isl_val *v)
+isl_bool isl_val_is_zero(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_zero(v->n) && !isl_int_is_zero(v->d);
+	return isl_bool_ok(isl_int_is_zero(v->n) && !isl_int_is_zero(v->d));
 }
 
 /* Does "v" represent the integer one?
  */
-int isl_val_is_one(__isl_keep isl_val *v)
+isl_bool isl_val_is_one(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
+
+	if (isl_val_is_nan(v))
+		return isl_bool_false;
 
-	return isl_int_eq(v->n, v->d);
+	return isl_bool_ok(isl_int_eq(v->n, v->d));
 }
 
 /* Does "v" represent the integer negative one?
  */
-int isl_val_is_negone(__isl_keep isl_val *v)
+isl_bool isl_val_is_negone(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d);
+	return isl_bool_ok(isl_int_is_neg(v->n) && isl_int_abs_eq(v->n, v->d));
 }
 
 /* Is "v" (strictly) positive?
  */
-int isl_val_is_pos(__isl_keep isl_val *v)
+isl_bool isl_val_is_pos(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_pos(v->n);
+	return isl_bool_ok(isl_int_is_pos(v->n));
 }
 
 /* Is "v" (strictly) negative?
  */
-int isl_val_is_neg(__isl_keep isl_val *v)
+isl_bool isl_val_is_neg(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return isl_int_is_neg(v->n);
+	return isl_bool_ok(isl_int_is_neg(v->n));
 }
 
 /* Is "v" non-negative?
  */
-int isl_val_is_nonneg(__isl_keep isl_val *v)
+isl_bool isl_val_is_nonneg(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_val_is_nan(v))
-		return 0;
+		return isl_bool_false;
 
-	return isl_int_is_nonneg(v->n);
+	return isl_bool_ok(isl_int_is_nonneg(v->n));
 }
 
 /* Is "v" non-positive?
  */
-int isl_val_is_nonpos(__isl_keep isl_val *v)
+isl_bool isl_val_is_nonpos(__isl_keep isl_val *v)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
 	if (isl_val_is_nan(v))
-		return 0;
+		return isl_bool_false;
 
-	return isl_int_is_nonpos(v->n);
+	return isl_bool_ok(isl_int_is_nonpos(v->n));
 }
 
 /* Return the sign of "v".
@@ -1177,32 +1281,32 @@
 
 /* Is "v1" (strictly) less than "v2"?
  */
-int isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_lt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	isl_int t;
-	int lt;
+	isl_bool lt;
 
 	if (!v1 || !v2)
-		return -1;
+		return isl_bool_error;
 	if (isl_val_is_int(v1) && isl_val_is_int(v2))
-		return isl_int_lt(v1->n, v2->n);
+		return isl_bool_ok(isl_int_lt(v1->n, v2->n));
 	if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
-		return 0;
+		return isl_bool_false;
 	if (isl_val_eq(v1, v2))
-		return 0;
+		return isl_bool_false;
 	if (isl_val_is_infty(v2))
-		return 1;
+		return isl_bool_true;
 	if (isl_val_is_infty(v1))
-		return 0;
+		return isl_bool_false;
 	if (isl_val_is_neginfty(v1))
-		return 1;
+		return isl_bool_true;
 	if (isl_val_is_neginfty(v2))
-		return 0;
+		return isl_bool_false;
 
 	isl_int_init(t);
 	isl_int_mul(t, v1->n, v2->d);
 	isl_int_submul(t, v2->n, v1->d);
-	lt = isl_int_is_neg(t);
+	lt = isl_bool_ok(isl_int_is_neg(t));
 	isl_int_clear(t);
 
 	return lt;
@@ -1210,39 +1314,64 @@
 
 /* Is "v1" (strictly) greater than "v2"?
  */
-int isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_gt(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	return isl_val_lt(v2, v1);
 }
 
+/* Is "v" (strictly) greater than "i"?
+ */
+isl_bool isl_val_gt_si(__isl_keep isl_val *v, long i)
+{
+	isl_val *vi;
+	isl_bool res;
+
+	if (!v)
+		return isl_bool_error;
+	if (isl_val_is_int(v))
+		return isl_bool_ok(isl_int_cmp_si(v->n, i) > 0);
+	if (isl_val_is_nan(v))
+		return isl_bool_false;
+	if (isl_val_is_infty(v))
+		return isl_bool_true;
+	if (isl_val_is_neginfty(v))
+		return isl_bool_false;
+
+	vi = isl_val_int_from_si(isl_val_get_ctx(v), i);
+	res = isl_bool_ok(isl_val_gt(v, vi));
+	isl_val_free(vi);
+
+	return res;
+}
+
 /* Is "v1" less than or equal to "v2"?
  */
-int isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_le(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	isl_int t;
-	int le;
+	isl_bool le;
 
 	if (!v1 || !v2)
-		return -1;
+		return isl_bool_error;
 	if (isl_val_is_int(v1) && isl_val_is_int(v2))
-		return isl_int_le(v1->n, v2->n);
+		return isl_bool_ok(isl_int_le(v1->n, v2->n));
 	if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
-		return 0;
+		return isl_bool_false;
 	if (isl_val_eq(v1, v2))
-		return 1;
+		return isl_bool_true;
 	if (isl_val_is_infty(v2))
-		return 1;
+		return isl_bool_true;
 	if (isl_val_is_infty(v1))
-		return 0;
+		return isl_bool_false;
 	if (isl_val_is_neginfty(v1))
-		return 1;
+		return isl_bool_true;
 	if (isl_val_is_neginfty(v2))
-		return 0;
+		return isl_bool_false;
 
 	isl_int_init(t);
 	isl_int_mul(t, v1->n, v2->d);
 	isl_int_submul(t, v2->n, v1->d);
-	le = isl_int_is_nonpos(t);
+	le = isl_bool_ok(isl_int_is_nonpos(t));
 	isl_int_clear(t);
 
 	return le;
@@ -1250,7 +1379,7 @@
 
 /* Is "v1" greater than or equal to "v2"?
  */
-int isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_ge(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	return isl_val_le(v2, v1);
 }
@@ -1288,26 +1417,52 @@
 
 /* Is "v1" equal to "v2"?
  */
-int isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	if (!v1 || !v2)
-		return -1;
+		return isl_bool_error;
 	if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
-		return 0;
+		return isl_bool_false;
+
+	return isl_bool_ok(isl_int_eq(v1->n, v2->n) &&
+			   isl_int_eq(v1->d, v2->d));
+}
+
+/* Is "v" equal to "i"?
+ */
+isl_bool isl_val_eq_si(__isl_keep isl_val *v, long i)
+{
+	if (!v)
+		return isl_bool_error;
+	if (!isl_val_is_int(v))
+		return isl_bool_false;
+	return isl_bool_ok(isl_int_cmp_si(v->n, i) == 0);
+}
+
+/* Is "v1" equal to "v2" in absolute value?
+ */
+isl_bool isl_val_abs_eq(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+{
+	if (!v1 || !v2)
+		return isl_bool_error;
+	if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
+		return isl_bool_false;
 
-	return isl_int_eq(v1->n, v2->n) && isl_int_eq(v1->d, v2->d);
+	return isl_bool_ok(isl_int_abs_eq(v1->n, v2->n) &&
+			   isl_int_eq(v1->d, v2->d));
 }
 
 /* Is "v1" different from "v2"?
  */
-int isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
+isl_bool isl_val_ne(__isl_keep isl_val *v1, __isl_keep isl_val *v2)
 {
 	if (!v1 || !v2)
-		return -1;
+		return isl_bool_error;
 	if (isl_val_is_nan(v1) || isl_val_is_nan(v2))
-		return 0;
+		return isl_bool_false;
 
-	return isl_int_ne(v1->n, v2->n) || isl_int_ne(v1->d, v2->d);
+	return isl_bool_ok(isl_int_ne(v1->n, v2->n) ||
+			   isl_int_ne(v1->d, v2->d));
 }
 
 /* Print a textual representation of "v" onto "p".
@@ -1346,7 +1501,8 @@
  * This is a private copy of isl_val_eq for use in the generic
  * isl_multi_*_plain_is_equal instantiated for isl_val.
  */
-int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2)
+isl_bool isl_val_plain_is_equal(__isl_keep isl_val *val1,
+	__isl_keep isl_val *val2)
 {
 	return isl_val_eq(val1, val2);
 }
@@ -1357,15 +1513,15 @@
  * This function is only meant to be used in the generic isl_multi_*
  * functions which have to deal with base objects that have an associated
  * space.  Since an isl_val does not have any coefficients, this function
- * always return 0.
+ * always returns isl_bool_false.
  */
-int isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
+isl_bool isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
 	unsigned first, unsigned n)
 {
 	if (!v)
-		return -1;
+		return isl_bool_error;
 
-	return 0;
+	return isl_bool_false;
 }
 
 /* Insert "n" dimensions of type "type" at position "first".
@@ -1381,19 +1537,6 @@
 	return v;
 }
 
-/* Drop the the "n" first dimensions of type "type" at position "first".
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * does not do anything.
- */
-__isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
-	enum isl_dim_type type, unsigned first, unsigned n)
-{
-	return v;
-}
-
 /* Change the name of the dimension of type "type" at position "pos" to "s".
  *
  * This function is only meant to be used in the generic isl_multi_*
@@ -1407,73 +1550,6 @@
 	return v;
 }
 
-/* Return the space of "v".
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  The conditions surrounding the call to this function make sure
- * that this function will never actually get called.  We return a valid
- * space anyway, just in case.
- */
-__isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v)
-{
-	if (!v)
-		return NULL;
-
-	return isl_space_params_alloc(isl_val_get_ctx(v), 0);
-}
-
-/* Reset the domain space of "v" to "space".
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * does not do anything, apart from error handling and cleaning up memory.
- */
-__isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
-	__isl_take isl_space *space)
-{
-	if (!space)
-		return isl_val_free(v);
-	isl_space_free(space);
-	return v;
-}
-
-/* Align the parameters of "v" to those of "space".
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * does not do anything, apart from error handling and cleaning up memory.
- * Note that the conditions surrounding the call to this function make sure
- * that this function will never actually get called.
- */
-__isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
-	__isl_take isl_space *space)
-{
-	if (!space)
-		return isl_val_free(v);
-	isl_space_free(space);
-	return v;
-}
-
-/* Reorder the dimensions of the domain of "v" according
- * to the given reordering.
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * does not do anything, apart from error handling and cleaning up memory.
- */
-__isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
-	__isl_take isl_reordering *r)
-{
-	if (!r)
-		return isl_val_free(v);
-	isl_reordering_free(r);
-	return v;
-}
-
 /* Return an isl_val that is zero on "ls".
  *
  * This function is only meant to be used in the generic isl_multi_*
@@ -1492,47 +1568,30 @@
 	return isl_val_zero(ctx);
 }
 
-/* Do the parameters of "v" match those of "space"?
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * simply returns 1, except if "v" or "space" are NULL.
- */
-int isl_val_matching_params(__isl_keep isl_val *v, __isl_keep isl_space *space)
-{
-	if (!v || !space)
-		return -1;
-	return 1;
-}
-
-/* Check that the domain space of "v" matches "space".
- *
- * Return 0 on success and -1 on error.
- *
- * This function is only meant to be used in the generic isl_multi_*
- * functions which have to deal with base objects that have an associated
- * space.  Since an isl_val does not have an associated space, this function
- * simply returns 0, except if "v" or "space" are NULL.
- */
-int isl_val_check_match_domain_space(__isl_keep isl_val *v,
-	__isl_keep isl_space *space)
-{
-	if (!v || !space)
-		return -1;
-	return 0;
-}
+#define isl_val_involves_nan isl_val_is_nan
 
 #undef BASE
 #define BASE val
 
-#define NO_DOMAIN
-#define NO_INTERSECT_DOMAIN
-#define NO_GIST
-#define NO_IDENTITY
-#define NO_FROM_BASE
-#define NO_MOVE_DIMS
+#include <isl_multi_no_domain_templ.c>
+#include <isl_multi_no_explicit_domain.c>
 #include <isl_multi_templ.c>
+#include <isl_multi_arith_templ.c>
+#include <isl_multi_dim_id_templ.c>
+#include <isl_multi_dims.c>
+#include <isl_multi_min_max_templ.c>
+#include <isl_multi_nan_templ.c>
+#include <isl_multi_product_templ.c>
+#include <isl_multi_splice_templ.c>
+#include <isl_multi_tuple_id_templ.c>
+#include <isl_multi_zero_templ.c>
+
+/* Does "mv" consist of only zeros?
+ */
+isl_bool isl_multi_val_is_zero(__isl_keep isl_multi_val *mv)
+{
+	return isl_multi_val_every(mv, &isl_val_is_zero);
+}
 
 /* Apply "fn" to each of the elements of "mv" with as second argument "v".
  */
@@ -1549,8 +1608,8 @@
 		goto error;
 
 	for (i = 0; i < mv->n; ++i) {
-		mv->pi = fn(mv->pi, isl_val_copy(v));
-		if (!mv->pi)
+		mv->u.pi = fn(mv->u.pi, isl_val_copy(v));
+		if (!mv->u.pi)
 			goto error;
 	}

_service:tar_scm:isl-0.14.tar.xz/isl_val_gmp.c -> _service:tar_scm:isl-0.24.tar.gz/isl_val_gmp.c Changed

@@ -86,14 +86,14 @@
 /* Return the number of chunks of size "size" required to
  * store the absolute value of the numerator of "v".
  */
-size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
+isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
 {
 	if (!v)
-		return 0;
+		return isl_size_error;
 
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational value", return 0);
+			"expecting rational value", return isl_size_error);
 
 	size *= 8;
 	return (mpz_sizeinbase(v->n, 2) + size - 1) / size;
@@ -110,19 +110,19 @@
  * return one, while mpz_export will not fill in any chunks.  We therefore
  * do it ourselves.
  */
-int isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
+isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
 	void *chunks)
 {
 	if (!v || !chunks)
-		return -1;
+		return isl_stat_error;
 
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational value", return -1);
+			"expecting rational value", return isl_stat_error);
 
 	mpz_export(chunks, NULL, -1, size, 0, 0, v->n);
 	if (isl_val_is_zero(v))
 		memset(chunks, 0, size);
 
-	return 0;
+	return isl_stat_ok;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_val_imath.c -> _service:tar_scm:isl-0.24.tar.gz/isl_val_imath.c Changed

@@ -30,34 +30,34 @@
  * return one, while impz_export will not fill in any chunks.  We therefore
  * do it ourselves.
  */
-int isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
+isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
 	void *chunks)
 {
 	if (!v || !chunks)
-		return -1;
+		return isl_stat_error;
 
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational value", return -1);
+			"expecting rational value", return isl_stat_error);
 
 	impz_export(chunks, NULL, -1, size, 0, 0, v->n);
 	if (isl_val_is_zero(v))
 		memset(chunks, 0, size);
 
-	return 0;
+	return isl_stat_ok;
 }
 
 /* Return the number of chunks of size "size" required to
  * store the absolute value of the numerator of "v".
  */
-size_t isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
+isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
 {
 	if (!v)
-		return 0;
+		return isl_size_error;
 
 	if (!isl_val_is_rat(v))
 		isl_die(isl_val_get_ctx(v), isl_error_invalid,
-			"expecting rational value", return 0);
+			"expecting rational value", return isl_size_error);
 
 	size *= 8;
 	return (impz_sizeinbase(v->n, 2) + size - 1) / size;

_service:tar_scm:isl-0.14.tar.xz/isl_val_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_val_private.h Changed

@@ -34,33 +34,24 @@
 	isl_int n, isl_int d);
 __isl_give isl_val *isl_val_cow(__isl_take isl_val *val);
 
-int isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
+isl_stat isl_val_get_num_isl_int(__isl_keep isl_val *v, isl_int *n);
+
+isl_bool isl_val_involves_dims(__isl_keep isl_val *v, enum isl_dim_type type,
 	unsigned first, unsigned n);
 __isl_give isl_val *isl_val_insert_dims(__isl_take isl_val *v,
 	enum isl_dim_type type, unsigned first, unsigned n);
-__isl_give isl_val *isl_val_drop_dims(__isl_take isl_val *v,
-	enum isl_dim_type type, unsigned first, unsigned n);
 __isl_give isl_val *isl_val_set_dim_name(__isl_take isl_val *v,
 	enum isl_dim_type type, unsigned pos, const char *s);
-__isl_give isl_space *isl_val_get_space(__isl_keep isl_val *v);
-__isl_give isl_val *isl_val_reset_domain_space(__isl_take isl_val *v,
-	__isl_take isl_space *space);
-__isl_give isl_val *isl_val_align_params(__isl_take isl_val *v,
-	__isl_take isl_space *space);
-__isl_give isl_val *isl_val_realign_domain(__isl_take isl_val *v,
-	__isl_take isl_reordering *r);
-__isl_give isl_val *isl_val_zero_on_domain(__isl_take isl_local_space *ls);
 
 __isl_give isl_val *isl_val_scale_val(__isl_take isl_val *v1,
 	__isl_take isl_val *v2);
 __isl_give isl_val *isl_val_scale_down_val(__isl_take isl_val *v1,
 	__isl_take isl_val *v2);
+__isl_give isl_val *isl_val_mod_val(__isl_take isl_val *v1,
+	__isl_take isl_val *v2);
 
-int isl_val_plain_is_equal(__isl_keep isl_val *val1, __isl_keep isl_val *val2);
-
-int isl_val_matching_params(__isl_keep isl_val *v, __isl_keep isl_space *space);
-int isl_val_check_match_domain_space(__isl_keep isl_val *v,
-	__isl_keep isl_space *space);
+isl_bool isl_val_plain_is_equal(__isl_keep isl_val *val1,
+	__isl_keep isl_val *val2);
 
 #undef BASE
 #define BASE val

_service:tar_scm:isl-0.24.tar.gz/isl_val_sioimath.c Added

@@ -0,0 +1,68 @@
+#include <isl_val_private.h>
+
+/* Return a reference to an isl_val representing the unsigned
+ * integer value stored in the "n" chunks of size "size" at "chunks".
+ * The least significant chunk is assumed to be stored first.
+ */
+__isl_give isl_val *isl_val_int_from_chunks(isl_ctx *ctx, size_t n,
+	size_t size, const void *chunks)
+{
+	isl_val *v;
+
+	v = isl_val_alloc(ctx);
+	if (!v)
+		return NULL;
+
+	impz_import(isl_sioimath_reinit_big(v->n), n, -1, size, 0, 0, chunks);
+	isl_sioimath_try_demote(v->n);
+	isl_int_set_si(v->d, 1);
+
+	return v;
+}
+
+/* Store a representation of the absolute value of the numerator of "v"
+ * in terms of chunks of size "size" at "chunks".
+ * The least significant chunk is stored first.
+ * The number of chunks in the result can be obtained by calling
+ * isl_val_n_abs_num_chunks.  The user is responsible for allocating
+ * enough memory to store the results.
+ *
+ * In the special case of a zero value, isl_val_n_abs_num_chunks will
+ * return one, while impz_export will not fill in any chunks.  We therefore
+ * do it ourselves.
+ */
+isl_stat isl_val_get_abs_num_chunks(__isl_keep isl_val *v, size_t size,
+	void *chunks)
+{
+	isl_sioimath_scratchspace_t scratch;
+
+	if (!v || !chunks)
+		return isl_stat_error;
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational value", return isl_stat_error);
+
+	impz_export(chunks, NULL, -1, size, 0, 0,
+	    isl_sioimath_bigarg_src(*v->n, &scratch));
+	if (isl_val_is_zero(v))
+		memset(chunks, 0, size);
+
+	return isl_stat_ok;
+}
+
+/* Return the number of chunks of size "size" required to
+ * store the absolute value of the numerator of "v".
+ */
+isl_size isl_val_n_abs_num_chunks(__isl_keep isl_val *v, size_t size)
+{
+	if (!v)
+		return isl_size_error;
+
+	if (!isl_val_is_rat(v))
+		isl_die(isl_val_get_ctx(v), isl_error_invalid,
+			"expecting rational value", return isl_size_error);
+
+	size *= 8;
+	return (isl_sioimath_sizeinbase(*v->n, 2) + size - 1) / size;
+}

_service:tar_scm:isl-0.14.tar.xz/isl_vec.c -> _service:tar_scm:isl-0.24.tar.gz/isl_vec.c Changed

@@ -13,14 +13,23 @@
 #include <isl_seq.h>
 #include <isl_val_private.h>
 #include <isl_vec_private.h>
-#include <isl/deprecated/vec_int.h>
 
 isl_ctx *isl_vec_get_ctx(__isl_keep isl_vec *vec)
 {
 	return vec ? vec->ctx : NULL;
 }
 
-struct isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size)
+/* Return a hash value that digests "vec".
+ */
+uint32_t isl_vec_get_hash(__isl_keep isl_vec *vec)
+{
+	if (!vec)
+		return 0;
+
+	return isl_seq_get_hash(vec->el, vec->size);
+}
+
+__isl_give isl_vec *isl_vec_alloc(struct isl_ctx *ctx, unsigned size)
 {
 	struct isl_vec *vec;
 
@@ -41,6 +50,7 @@
 	return vec;
 error:
 	isl_blk_free(ctx, vec->block);
+	free(vec);
 	return NULL;
 }
 
@@ -68,6 +78,66 @@
 	return NULL;
 }
 
+/* Apply the expansion specified by "exp" to the "n" elements starting at "pos".
+ * "expanded" it the number of elements that need to replace those "n"
+ * elements.  The entries in "exp" have increasing values between
+ * 0 and "expanded".
+ */
+__isl_give isl_vec *isl_vec_expand(__isl_take isl_vec *vec, int pos, int n,
+	int *exp, int expanded)
+{
+	int i, j;
+	int old_size, extra;
+
+	if (!vec)
+		return NULL;
+	if (expanded < n)
+		isl_die(isl_vec_get_ctx(vec), isl_error_invalid,
+			"not an expansion", return isl_vec_free(vec));
+	if (expanded == n)
+		return vec;
+	if (pos < 0 || n < 0 || pos + n > vec->size)
+		isl_die(isl_vec_get_ctx(vec), isl_error_invalid,
+			"position out of bounds", return isl_vec_free(vec));
+
+	old_size = vec->size;
+	extra = expanded - n;
+	vec = isl_vec_extend(vec, old_size + extra);
+	vec = isl_vec_cow(vec);
+	if (!vec)
+		return NULL;
+
+	for (i = old_size - 1; i >= pos + n; --i)
+		isl_int_set(vec->eli + extra, vec->eli);
+
+	j = n - 1;
+	for (i = expanded - 1; i >= 0; --i) {
+		if (j >= 0 && expj == i) {
+			if (i != j)
+				isl_int_swap(vec->elpos + i,
+					     vec->elpos + j);
+			j--;
+		} else {
+			isl_int_set_si(vec->elpos + i, 0);
+		}
+	}
+
+	return vec;
+}
+
+/* Create a vector of size "size" with zero-valued elements.
+ */
+__isl_give isl_vec *isl_vec_zero(isl_ctx *ctx, unsigned size)
+{
+	isl_vec *vec;
+
+	vec = isl_vec_alloc(ctx, size);
+	if (!vec)
+		return NULL;
+	isl_seq_clr(vec->el, size);
+	return vec;
+}
+
 __isl_give isl_vec *isl_vec_zero_extend(__isl_take isl_vec *vec, unsigned size)
 {
 	int extra;
@@ -124,7 +194,7 @@
 	return NULL;
 }
 
-struct isl_vec *isl_vec_copy(struct isl_vec *vec)
+__isl_give isl_vec *isl_vec_copy(__isl_keep isl_vec *vec)
 {
 	if (!vec)
 		return NULL;
@@ -133,7 +203,7 @@
 	return vec;
 }
 
-struct isl_vec *isl_vec_dup(struct isl_vec *vec)
+__isl_give isl_vec *isl_vec_dup(__isl_keep isl_vec *vec)
 {
 	struct isl_vec *vec2;
 
@@ -146,7 +216,7 @@
 	return vec2;
 }
 
-struct isl_vec *isl_vec_cow(struct isl_vec *vec)
+__isl_give isl_vec *isl_vec_cow(__isl_take isl_vec *vec)
 {
 	struct isl_vec *vec2;
 	if (!vec)
@@ -175,21 +245,9 @@
 	return NULL;
 }
 
-int isl_vec_size(__isl_keep isl_vec *vec)
+isl_size isl_vec_size(__isl_keep isl_vec *vec)
 {
-	return vec ? vec->size : -1;
-}
-
-int isl_vec_get_element(__isl_keep isl_vec *vec, int pos, isl_int *v)
-{
-	if (!vec)
-		return -1;
-
-	if (pos < 0 || pos >= vec->size)
-		isl_die(vec->ctx, isl_error_invalid, "position out of range",
-			return -1);
-	isl_int_set(*v, vec->elpos);
-	return 0;
+	return vec ? vec->size : isl_size_error;
 }
 
 /* Extract the element at position "pos" of "vec".
@@ -270,15 +328,24 @@
 	return isl_int_cmp(vec1->elpos, vec2->elpos);
 }
 
-int isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2)
+/* Does "vec" contain only zero elements?
+ */
+isl_bool isl_vec_is_zero(__isl_keep isl_vec *vec)
+{
+	if (!vec)
+		return isl_bool_error;
+	return isl_bool_ok(isl_seq_first_non_zero(vec->el, vec->size) < 0);
+}
+
+isl_bool isl_vec_is_equal(__isl_keep isl_vec *vec1, __isl_keep isl_vec *vec2)
 {
 	if (!vec1 || !vec2)
-		return -1;
+		return isl_bool_error;
 
 	if (vec1->size != vec2->size)
-		return 0;
+		return isl_bool_false;
 
-	return isl_seq_eq(vec1->el, vec2->el, vec1->size);
+	return isl_bool_ok(isl_seq_eq(vec1->el, vec2->el, vec1->size));
 }
 
 __isl_give isl_printer *isl_printer_print_vec(__isl_take isl_printer *printer,
@@ -303,7 +370,7 @@
 	return NULL;
 }
 
-void isl_vec_dump(struct isl_vec *vec)
+void isl_vec_dump(__isl_keep isl_vec *vec)
 {
 	isl_printer *printer;
 
@@ -364,7 +431,7 @@
 	return vec;
 }
 
-void isl_vec_lcm(struct isl_vec *vec, isl_int *lcm)
+void isl_vec_lcm(__isl_keep isl_vec *vec, isl_int *lcm)
 {
 	isl_seq_lcm(vec->block.data, vec->size, lcm);
 }
@@ -372,7 +439,7 @@
 /* Given a rational vector, with the denominator in the first element
  * of the vector, round up all coordinates.
  */
-struct isl_vec *isl_vec_ceil(struct isl_vec *vec)
+__isl_give isl_vec *isl_vec_ceil(__isl_take isl_vec *vec)
 {
 	vec = isl_vec_cow(vec);
 	if (!vec)
@@ -385,7 +452,7 @@
 	return vec;
 }
 
-struct isl_vec *isl_vec_normalize(struct isl_vec *vec)
+__isl_give isl_vec *isl_vec_normalize(__isl_take isl_vec *vec)
 {
 	if (!vec)
 		return NULL;
@@ -518,6 +585,15 @@
 	return NULL;
 }
 
+/* Add "n" elements at the end of "vec".
+ */
+__isl_give isl_vec *isl_vec_add_els(__isl_take isl_vec *vec, unsigned n)
+{
+	if (!vec)
+		return NULL;
+	return isl_vec_insert_els(vec, vec->size, n);
+}
+
 __isl_give isl_vec *isl_vec_insert_zero_els(__isl_take isl_vec *vec,
 	unsigned pos, unsigned n)
 {

_service:tar_scm:isl-0.14.tar.xz/isl_vec_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_vec_private.h Changed

_service:tar_scm:isl-0.14.tar.xz/isl_version.c -> _service:tar_scm:isl-0.24.tar.gz/isl_version.c Changed

_service:tar_scm:isl-0.14.tar.xz/isl_vertices.c -> _service:tar_scm:isl-0.24.tar.gz/isl_vertices.c Changed

@@ -35,15 +35,15 @@
 	return vertices;
 }
 
-void isl_vertices_free(__isl_take isl_vertices *vertices)
+__isl_null isl_vertices *isl_vertices_free(__isl_take isl_vertices *vertices)
 {
 	int i;
 
 	if (!vertices)
-		return;
+		return NULL;
 
 	if (--vertices->ref > 0)
-		return;
+		return NULL;
 
 	for (i = 0; i < vertices->n_vertices; ++i) {
 		isl_basic_set_free(vertices->vi.vertex);
@@ -59,6 +59,8 @@
 
 	isl_basic_set_free(vertices->bset);
 	free(vertices);
+
+	return NULL;
 }
 
 struct isl_vertex_list {
@@ -66,7 +68,7 @@
 	struct isl_vertex_list *next;
 };
 
-static void free_vertex_list(struct isl_vertex_list *list)
+static struct isl_vertex_list *free_vertex_list(struct isl_vertex_list *list)
 {
 	struct isl_vertex_list *next;
 
@@ -76,6 +78,8 @@
 		isl_basic_set_free(list->v.dom);
 		free(list);
 	}
+
+	return NULL;
 }
 
 static __isl_give isl_vertices *vertices_from_list(__isl_keep isl_basic_set *bset,
@@ -109,19 +113,24 @@
 }
 
 /* Prepend a vertex to the linked list "list" based on the equalities in "tab".
+ * Return isl_bool_true if the vertex was actually added and
+ * isl_bool_false otherwise.
+ * In particular, vertices with a lower-dimensional activity domain are
+ * not added to the list because they would not be included in any chamber.
+ * Return isl_bool_error on error.
  */
-static int add_vertex(struct isl_vertex_list **list,
+static isl_bool add_vertex(struct isl_vertex_list **list,
 	__isl_keep isl_basic_set *bset, struct isl_tab *tab)
 {
-	unsigned nvar;
-	unsigned nparam;
+	isl_size nvar;
 	struct isl_vertex_list *v = NULL;
 
 	if (isl_tab_detect_implicit_equalities(tab) < 0)
-		return -1;
+		return isl_bool_error;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nvar < 0)
+		return isl_bool_error;
 
 	v = isl_calloc_type(tab->mat->ctx, struct isl_vertex_list);
 	if (!v)
@@ -140,13 +149,18 @@
 	if (!v->v.dom)
 		goto error;
 
+	if (v->v.dom->n_eq > 0) {
+		free_vertex_list(v);
+		return isl_bool_false;
+	}
+
 	v->next = *list;
 	*list = v;
 
-	return 0;
+	return isl_bool_true;
 error:
 	free_vertex_list(v);
-	return -1;
+	return isl_bool_error;
 }
 
 /* Compute the parametric vertices and the chamber decomposition
@@ -155,13 +169,10 @@
 static __isl_give isl_vertices *vertices_empty(__isl_keep isl_basic_set *bset)
 {
 	isl_vertices *vertices;
-	unsigned nparam;
 
 	if (!bset)
 		return NULL;
 
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-
 	vertices = isl_calloc_type(bset->ctx, isl_vertices);
 	if (!vertices)
 		return NULL;
@@ -183,13 +194,10 @@
 static __isl_give isl_vertices *vertices_0D(__isl_keep isl_basic_set *bset)
 {
 	isl_vertices *vertices;
-	unsigned nparam;
 
 	if (!bset)
 		return NULL;
 
-	nparam = isl_basic_set_dim(bset, isl_dim_param);
-
 	vertices = isl_calloc_type(bset->ctx, isl_vertices);
 	if (!vertices)
 		return NULL;
@@ -223,45 +231,23 @@
 	return NULL;
 }
 
-static int isl_mat_rank(__isl_keep isl_mat *mat)
-{
-	int row, col;
-	isl_mat *H;
-
-	H = isl_mat_left_hermite(isl_mat_copy(mat), 0, NULL, NULL);
-	if (!H)
-		return -1;
-
-	for (col = 0; col < H->n_col; ++col) {
-		for (row = 0; row < H->n_row; ++row)
-			if (!isl_int_is_zero(H->rowrowcol))
-				break;
-		if (row == H->n_row)
-			break;
-	}
-
-	isl_mat_free(H);
-
-	return col;
-}
-
 /* Is the row pointed to by "f" linearly independent of the "n" first
  * rows in "facets"?
  */
-static int is_independent(__isl_keep isl_mat *facets, int n, isl_int *f)
+static isl_bool is_independent(__isl_keep isl_mat *facets, int n, isl_int *f)
 {
-	int rank;
+	isl_size rank;
 
 	if (isl_seq_first_non_zero(f, facets->n_col) < 0)
-		return 0;
+		return isl_bool_false;
 
 	isl_seq_cpy(facets->rown, f, facets->n_col);
 	facets->n_row = n + 1;
 	rank = isl_mat_rank(facets);
 	if (rank < 0)
-		return -1;
+		return isl_bool_error;
 
-	return rank == n + 1;
+	return isl_bool_ok(rank == n + 1);
 }
 
 /* Check whether we can select constraint "level", given the current selection
@@ -270,7 +256,7 @@
  *
  * If the constraint is (strictly) redundant in the tableau, selecting it would
  * result in an empty tableau, so it can't be selected.
- * If the set variable part of the constraint is not linearly indepedent
+ * If the set variable part of the constraint is not linearly independent
  * of the set variable parts of the already selected constraints,
  * the constraint cannot be selected.
  * If selecting the constraint results in an empty tableau, the constraint
@@ -279,34 +265,32 @@
  * deselected constraints turning into equalities, then the corresponding
  * vertices have already been generated, so the constraint cannot be selected.
  */
-static int can_select(__isl_keep isl_basic_set *bset, int level,
+static isl_bool can_select(__isl_keep isl_basic_set *bset, int level,
 	struct isl_tab *tab, __isl_keep isl_mat *facets, int selected,
 	int *selection)
 {
 	int i;
-	int indep;
+	isl_bool indep;
 	unsigned ovar;
 	struct isl_tab_undo *snap;
 
 	if (isl_tab_is_redundant(tab, level))
-		return 0;
+		return isl_bool_false;
 
 	ovar = isl_space_offset(bset->dim, isl_dim_set);
 
 	indep = is_independent(facets, selected, bset->ineqlevel + 1 + ovar);
-	if (indep < 0)
-		return -1;
-	if (!indep)
-		return 0;
+	if (indep < 0 || !indep)
+		return indep;
 
 	snap = isl_tab_snap(tab);
 	if (isl_tab_select_facet(tab, level) < 0)
-		return -1;
+		return isl_bool_error;
 
 	if (tab->empty) {
 		if (isl_tab_rollback(tab, snap) < 0)
-			return -1;
-		return 0;
+			return isl_bool_error;
+		return isl_bool_false;
 	}
 
 	for (i = 0; i < level; ++i) {
@@ -322,15 +306,15 @@
 		else
 			sgn = isl_tab_sign_of_max(tab, i);
 		if (sgn < -1)
-			return -1;
+			return isl_bool_error;
 		if (sgn <= 0) {
 			if (isl_tab_rollback(tab, snap) < 0)
-				return -1;
-			return 0;
+				return isl_bool_error;
+			return isl_bool_false;
 		}
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 /* Compute the parametric vertices and the chamber decomposition
@@ -340,12 +324,11 @@
  * and map the resulting vertices back.
  */
 static __isl_give isl_vertices *lower_dim_vertices(
-	__isl_keep isl_basic_set *bset)
+	__isl_take isl_basic_set *bset)
 {
 	isl_morph *morph;
 	isl_vertices *vertices;
 
-	bset = isl_basic_set_copy(bset);
 	morph = isl_basic_set_full_compression(bset);
 	bset = isl_morph_basic_set(isl_morph_copy(morph), bset);
 
@@ -360,6 +343,37 @@
 }
 
 /* Compute the parametric vertices and the chamber decomposition
+ * of a parametric polytope "bset" that is not full-dimensional.
+ * Additionally, free both "copy" and "tab".
+ */
+static __isl_give isl_vertices *lower_dim_vertices_free(
+	__isl_take isl_basic_set *bset, __isl_take isl_basic_set *copy,
+	struct isl_tab *tab)
+{
+	isl_basic_set_free(copy);
+	isl_tab_free(tab);
+	return lower_dim_vertices(bset);
+}
+
+/* Detect implicit equality constraints in "bset" using the tableau
+ * representation "tab".
+ * Return a copy of "bset" with the implicit equality constraints
+ * made explicit, leaving the original "bset" unmodified.
+ */
+static __isl_give isl_basic_set *detect_implicit_equality_constraints(
+	__isl_keep isl_basic_set *bset, struct isl_tab *tab)
+{
+	if (isl_tab_detect_implicit_equalities(tab) < 0)
+		return NULL;
+
+	bset = isl_basic_set_copy(bset);
+	bset = isl_basic_set_cow(bset);
+	bset = isl_basic_set_update_from_tab(bset, tab);
+
+	return bset;
+}
+
+/* Compute the parametric vertices and the chamber decomposition
  * of the parametric polytope defined using the same constraints
  * as "bset".  "bset" is assumed to have no existentially quantified
  * variables.
@@ -372,6 +386,19 @@
  * we make sure we only generate the vertex for the d constraints with
  * smallest index.
  *
+ * Only potential vertices with a full-dimensional activity domain
+ * are considered.  However, if the input has (implicit) equality
+ * constraints among the parameters, then activity domain
+ * should be considered full-dimensional if it does not satisfy
+ * any extra equality constraints beyond those of the input.
+ * The implicit equality constraints of the input are therefore first detected.
+ * If there are any, then the input is mapped to a lower dimensional space
+ * such that the check for full-dimensional activity domains
+ * can be performed with respect to a full-dimensional space.
+ * Note that it is important to leave "bset" unmodified while detecting
+ * equality constraints since the inequality constraints of "bset"
+ * are assumed to correspond to those of the tableau.
+ *
  * We set up a tableau and keep track of which facets have been
  * selected.  The tableau is marked strict_redundant so that we can be
  * sure that any constraint that is marked redundant (and that is not
@@ -394,7 +421,8 @@
 	struct isl_tab *tab;
 	int level;
 	int init;
-	unsigned nvar;
+	isl_size n_eq;
+	isl_size nvar;
 	int *selection = NULL;
 	int selected;
 	struct isl_tab_undo **snap = NULL;
@@ -402,6 +430,8 @@
 	struct isl_vertex_list *list = NULL;
 	int n_vertices = 0;
 	isl_vertices *vertices;
+	isl_basic_set *copy;
+	isl_basic_set *test;
 
 	if (!bset)
 		return NULL;
@@ -410,37 +440,46 @@
 		return vertices_empty(bset);
 
 	if (bset->n_eq != 0)
-		return lower_dim_vertices(bset);
+		return lower_dim_vertices(isl_basic_set_copy(bset));
 
-	isl_assert(bset->ctx, isl_basic_set_dim(bset, isl_dim_div) == 0,
-		return NULL);
-
-	if (isl_basic_set_dim(bset, isl_dim_set) == 0)
-		return vertices_0D(bset);
+	if (isl_basic_set_check_no_locals(bset) < 0)
+		return NULL;
 
 	nvar = isl_basic_set_dim(bset, isl_dim_set);
+	if (nvar < 0)
+		return NULL;
+	if (nvar == 0)
+		return vertices_0D(bset);
 
-	bset = isl_basic_set_copy(bset);
-	bset = isl_basic_set_set_rational(bset);
-	if (!bset)
+	copy = isl_basic_set_copy(bset);
+	copy = isl_basic_set_set_rational(copy);
+	if (!copy)
 		return NULL;
 
-	tab = isl_tab_from_basic_set(bset, 0);
+	tab = isl_tab_from_basic_set(copy, 0);
 	if (!tab)
 		goto error;
 	tab->strict_redundant = 1;
 
 	if (tab->empty)	{
-		vertices = vertices_empty(bset);
-		isl_basic_set_free(bset);
+		vertices = vertices_empty(copy);
+		isl_basic_set_free(copy);
 		isl_tab_free(tab);
 		return vertices;
 	}
 
-	selection = isl_alloc_array(bset->ctx, int, bset->n_ineq);
-	snap = isl_alloc_array(bset->ctx, struct isl_tab_undo *, bset->n_ineq);
-	facets = isl_mat_alloc(bset->ctx, nvar, nvar);
-	if ((bset->n_ineq && (!selection || !snap)) || !facets)
+	test = detect_implicit_equality_constraints(bset, tab);
+	n_eq = isl_basic_set_n_equality(test);
+	if (n_eq < 0)
+		test = isl_basic_set_free(test);
+	if (n_eq < 0 || n_eq > 0)
+		return lower_dim_vertices_free(test, copy, tab);
+	isl_basic_set_free(test);
+
+	selection = isl_alloc_array(copy->ctx, int, copy->n_ineq);
+	snap = isl_alloc_array(copy->ctx, struct isl_tab_undo *, copy->n_ineq);
+	facets = isl_mat_alloc(copy->ctx, nvar, nvar);
+	if ((copy->n_ineq && (!selection || !snap)) || !facets)
 		goto error;
 
 	level = 0;
@@ -448,16 +487,16 @@
 	selected = 0;
 
 	while (level >= 0) {
-		if (level >= bset->n_ineq ||
+		if (level >= copy->n_ineq ||
 		    (!init && selectionlevel != SELECTED)) {
 			--level;
 			init = 0;
 			continue;
 		}
 		if (init) {
-			int ok;
+			isl_bool ok;
 			snaplevel = isl_tab_snap(tab);
-			ok = can_select(bset, level, tab, facets, selected,
+			ok = can_select(copy, level, tab, facets, selected,
 					selection);
 			if (ok < 0)
 				goto error;
@@ -474,9 +513,11 @@
 		}
 		if (selected == nvar) {
 			if (tab->n_dead == nvar) {
-				if (add_vertex(&list, bset, tab) < 0)
+				isl_bool added = add_vertex(&list, copy, tab);
+				if (added < 0)
 					goto error;
-				n_vertices++;
+				if (added)
+					n_vertices++;
 			}
 			init = 0;
 			continue;
@@ -491,9 +532,9 @@
 
 	isl_tab_free(tab);
 
-	vertices = vertices_from_list(bset, n_vertices, list);
+	vertices = vertices_from_list(copy, n_vertices, list);
 
-	vertices = compute_chambers(bset, vertices);
+	vertices = compute_chambers(copy, vertices);
 
 	return vertices;
 error:
@@ -502,7 +543,7 @@
 	free(selection);
 	free(snap);
 	isl_tab_free(tab);
-	isl_basic_set_free(bset);
+	isl_basic_set_free(copy);
 	return NULL;
 }
 
@@ -526,23 +567,24 @@
 /* Check whether the basic set "bset" is a superset of the basic set described
  * by "tab", i.e., check whether all constraints of "bset" are redundant.
  */
-static int bset_covers_tab(__isl_keep isl_basic_set *bset, struct isl_tab *tab)
+static isl_bool bset_covers_tab(__isl_keep isl_basic_set *bset,
+	struct isl_tab *tab)
 {
 	int i;
 
 	if (!bset || !tab)
-		return -1;
+		return isl_bool_error;
 
 	for (i = 0; i < bset->n_ineq; ++i) {
 		enum isl_ineq_type type = isl_tab_ineq_type(tab, bset->ineqi);
 		switch (type) {
-		case isl_ineq_error:		return -1;
+		case isl_ineq_error:		return isl_bool_error;
 		case isl_ineq_redundant:	continue;
-		default:			return 0;
+		default:			return isl_bool_false;
 		}
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 static __isl_give isl_vertices *vertices_add_chambers(
@@ -574,33 +616,45 @@
 
 /* Can "tab" be intersected with "bset" without resulting in
  * a lower-dimensional set.
+ * "bset" itself is assumed to be full-dimensional.
  */
-static int can_intersect(struct isl_tab *tab, __isl_keep isl_basic_set *bset)
+static isl_bool can_intersect(struct isl_tab *tab,
+	__isl_keep isl_basic_set *bset)
 {
 	int i;
 	struct isl_tab_undo *snap;
 
+	if (bset->n_eq > 0)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_internal,
+			"expecting full-dimensional input",
+			return isl_bool_error);
+
 	if (isl_tab_extend_cons(tab, bset->n_ineq) < 0)
-		return -1;
+		return isl_bool_error;
 
 	snap = isl_tab_snap(tab);
 
 	for (i = 0; i < bset->n_ineq; ++i) {
-		if (isl_tab_ineq_type(tab, bset->ineqi) == isl_ineq_redundant)
+		enum isl_ineq_type type;
+
+		type = isl_tab_ineq_type(tab, bset->ineqi);
+		if (type < 0)
+			return isl_bool_error;
+		if (type == isl_ineq_redundant)
 			continue;
 		if (isl_tab_add_ineq(tab, bset->ineqi) < 0)
-			return -1;
+			return isl_bool_error;
 	}
 
 	if (isl_tab_detect_implicit_equalities(tab) < 0)
-		return -1;
+		return isl_bool_error;
 	if (tab->n_dead) {
 		if (isl_tab_rollback(tab, snap) < 0)
-			return -1;
-		return 0;
+			return isl_bool_error;
+		return isl_bool_false;
 	}
 
-	return 1;
+	return isl_bool_true;
 }
 
 static int add_chamber(struct isl_chamber_list **list,
@@ -631,7 +685,7 @@
 	c->c.vertices = isl_alloc_array(tab->mat->ctx, int, n_vertices);
 	if (n_vertices && !c->c.vertices)
 		goto error;
-	c->c.dom = isl_basic_set_from_basic_map(isl_basic_map_copy(tab->bmap));
+	c->c.dom = isl_basic_set_copy(isl_tab_peek_bset(tab));
 	c->c.dom = isl_basic_set_set_rational(c->c.dom);
 	c->c.dom = isl_basic_set_cow(c->c.dom);
 	c->c.dom = isl_basic_set_update_from_tab(c->c.dom, tab);
@@ -708,7 +762,7 @@
 	if (!todo->constraint)
 		goto error;
 	isl_seq_neg(todo->constraint->el, tab->bmap->ineqcon, 1 + tab->n_var);
-	todo->bset = isl_basic_set_from_basic_map(isl_basic_map_copy(tab->bmap));
+	todo->bset = isl_basic_set_copy(isl_tab_peek_bset(tab));
 	todo->bset = isl_basic_set_set_rational(todo->bset);
 	todo->bset = isl_basic_set_cow(todo->bset);
 	todo->bset = isl_basic_set_update_from_tab(todo->bset, tab);
@@ -716,7 +770,7 @@
 	todo->bset = isl_basic_set_sort_constraints(todo->bset);
 	if (!todo->bset)
 		goto error;
-	ISL_F_SET(todo->bset, ISL_BASIC_SET_NORMALIZED);
+	ISL_F_SET(todo->bset, ISL_BASIC_SET_NO_REDUNDANT);
 	todo->tab = isl_tab_dup(tab);
 	if (!todo->tab)
 		goto error;
@@ -848,7 +902,7 @@
  * set.  As a minor optimization, we only consider those activity domains
  * that contain some arbitrary point.
  *
- * For each of interior facets of the chamber, we construct a todo item,
+ * For each of the interior facets of the chamber, we construct a todo item,
  * containing the facet and a constraint containing the other side of the facet,
  * for constructing the chamber on the other side.
  * While their are any todo items left, we pick a todo item and
@@ -862,6 +916,7 @@
 {
 	int i;
 	isl_ctx *ctx;
+	isl_size n_eq;
 	isl_vec *sample = NULL;
 	struct isl_tab *tab = NULL;
 	struct isl_tab_undo *snap;
@@ -879,6 +934,12 @@
 		goto error;
 
 	bset = isl_basic_set_params(bset);
+	n_eq = isl_basic_set_n_equality(bset);
+	if (n_eq < 0)
+		goto error;
+	if (n_eq > 0)
+		isl_die(isl_basic_set_get_ctx(bset), isl_error_internal,
+			"expecting full-dimensional input", goto error);
 
 	tab = isl_tab_from_basic_set(bset, 1);
 	if (!tab)
@@ -982,26 +1043,9 @@
 	return vertex ? isl_vertices_get_ctx(vertex->vertices) : NULL;
 }
 
-int isl_vertex_get_id(__isl_keep isl_vertex *vertex)
+isl_size isl_vertex_get_id(__isl_keep isl_vertex *vertex)
 {
-	return vertex ? vertex->id : -1;
-}
-
-__isl_give isl_basic_set *isl_basic_set_set_integral(__isl_take isl_basic_set *bset)
-{
-	if (!bset)
-		return NULL;
-
-	if (!ISL_F_ISSET(bset, ISL_BASIC_MAP_RATIONAL))
-		return bset;
-
-	bset = isl_basic_set_cow(bset);
-	if (!bset)
-		return NULL;
-
-	ISL_F_CLR(bset, ISL_BASIC_MAP_RATIONAL);
-
-	return isl_basic_set_finalize(bset);
+	return vertex ? vertex->id : isl_size_error;
 }
 
 /* Return the activity domain of the vertex "vertex".
@@ -1063,12 +1107,14 @@
 	return NULL;
 }
 
-void isl_vertex_free(__isl_take isl_vertex *vertex)
+__isl_null isl_vertex *isl_vertex_free(__isl_take isl_vertex *vertex)
 {
 	if (!vertex)
-		return;
+		return NULL;
 	isl_vertices_free(vertex->vertices);
 	free(vertex);
+
+	return NULL;
 }
 
 isl_ctx *isl_cell_get_ctx(__isl_keep isl_cell *cell)
@@ -1111,15 +1157,17 @@
 	return NULL;
 }
 
-void isl_cell_free(__isl_take isl_cell *cell)
+__isl_null isl_cell *isl_cell_free(__isl_take isl_cell *cell)
 {
 	if (!cell)
-		return;
+		return NULL;
 
 	isl_vertices_free(cell->vertices);
 	free(cell->ids);
 	isl_basic_set_free(cell->dom);
 	free(cell);
+
+	return NULL;
 }
 
 /* Create a tableau of the cone obtained by first homogenizing the given
@@ -1131,11 +1179,13 @@
 	int i;
 	isl_vec *c = NULL;
 	struct isl_tab *tab;
+	isl_size total;
 
-	if (!bset)
+	total = isl_basic_set_dim(bset, isl_dim_all);
+	if (total < 0)
 		return NULL;
-	tab = isl_tab_alloc(bset->ctx, bset->n_ineq + 1,
-			    1 + isl_basic_set_total_dim(bset), 0);
+	tab = isl_tab_alloc(bset->ctx, bset->n_eq + bset->n_ineq + 1,
+			    1 + total, 0);
 	if (!tab)
 		return NULL;
 	tab->rational = ISL_F_ISSET(bset, ISL_BASIC_SET_RATIONAL);
@@ -1145,7 +1195,7 @@
 		return tab;
 	}
 
-	c = isl_vec_alloc(bset->ctx, 1 + 1 + isl_basic_set_total_dim(bset));
+	c = isl_vec_alloc(bset->ctx, 1 + 1 + total);
 	if (!c)
 		goto error;
 
@@ -1206,49 +1256,41 @@
  *
  * We pick an interior point from one of the chambers and then make
  * all constraints that do not satisfy this point strict.
+ * For constraints that saturate the interior point, the sign
+ * of the first non-zero coefficient is used to determine which
+ * of the two (internal) constraints should be tightened.
  */
-int isl_vertices_foreach_disjoint_cell(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_cell *cell, void *user), void *user)
+isl_stat isl_vertices_foreach_disjoint_cell(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_cell *cell, void *user), void *user)
 {
-	int i, j;
+	int i;
 	isl_vec *vec;
-	isl_int v;
 	isl_cell *cell;
 
 	if (!vertices)
-		return -1;
+		return isl_stat_error;
 
 	if (vertices->n_chambers == 0)
-		return 0;
+		return isl_stat_ok;
 
 	if (vertices->n_chambers == 1) {
 		isl_basic_set *dom = isl_basic_set_copy(vertices->c0.dom);
 		dom = isl_basic_set_set_integral(dom);
 		cell = isl_cell_alloc(isl_vertices_copy(vertices), dom, 0);
 		if (!cell)
-			return -1;
+			return isl_stat_error;
 		return fn(cell, user);
 	}
 
 	vec = isl_basic_set_interior_point(vertices->c0.dom);
 	if (!vec)
-		return -1;
-
-	isl_int_init(v);
+		return isl_stat_error;
 
 	for (i = 0; i < vertices->n_chambers; ++i) {
 		int r;
 		isl_basic_set *dom = isl_basic_set_copy(vertices->ci.dom);
-		dom = isl_basic_set_cow(dom);
-		if (!dom)
-			goto error;
-		for (j = 0; i && j < dom->n_ineq; ++j) {
-			isl_seq_inner_product(vec->el, dom->ineqj, vec->size,
-						&v);
-			if (!isl_int_is_neg(v))
-				continue;
-			isl_int_sub_ui(dom->ineqj0, dom->ineqj0, 1);
-		}
+		if (i)
+			dom = isl_basic_set_tighten_outward(dom, vec);
 		dom = isl_basic_set_set_integral(dom);
 		cell = isl_cell_alloc(isl_vertices_copy(vertices), dom, i);
 		if (!cell)
@@ -1258,97 +1300,95 @@
 			goto error;
 	}
 
-	isl_int_clear(v);
 	isl_vec_free(vec);
 
-	return 0;
+	return isl_stat_ok;
 error:
-	isl_int_clear(v);
 	isl_vec_free(vec);
-	return -1;
+	return isl_stat_error;
 }
 
-int isl_vertices_foreach_cell(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_cell *cell, void *user), void *user)
+isl_stat isl_vertices_foreach_cell(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_cell *cell, void *user), void *user)
 {
 	int i;
 	isl_cell *cell;
 
 	if (!vertices)
-		return -1;
+		return isl_stat_error;
 
 	if (vertices->n_chambers == 0)
-		return 0;
+		return isl_stat_ok;
 
 	for (i = 0; i < vertices->n_chambers; ++i) {
-		int r;
+		isl_stat r;
 		isl_basic_set *dom = isl_basic_set_copy(vertices->ci.dom);
 
 		cell = isl_cell_alloc(isl_vertices_copy(vertices), dom, i);
 		if (!cell)
-			return -1;
+			return isl_stat_error;
 
 		r = fn(cell, user);
 		if (r < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
-int isl_vertices_foreach_vertex(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_vertex *vertex, void *user), void *user)
+isl_stat isl_vertices_foreach_vertex(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_vertex *vertex, void *user), void *user)
 {
 	int i;
 	isl_vertex *vertex;
 
 	if (!vertices)
-		return -1;
+		return isl_stat_error;
 
 	if (vertices->n_vertices == 0)
-		return 0;
+		return isl_stat_ok;
 
 	for (i = 0; i < vertices->n_vertices; ++i) {
-		int r;
+		isl_stat r;
 
 		vertex = isl_vertex_alloc(isl_vertices_copy(vertices), i);
 		if (!vertex)
-			return -1;
+			return isl_stat_error;
 
 		r = fn(vertex, user);
 		if (r < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
-int isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
-	int (*fn)(__isl_take isl_vertex *vertex, void *user), void *user)
+isl_stat isl_cell_foreach_vertex(__isl_keep isl_cell *cell,
+	isl_stat (*fn)(__isl_take isl_vertex *vertex, void *user), void *user)
 {
 	int i;
 	isl_vertex *vertex;
 
 	if (!cell)
-		return -1;
+		return isl_stat_error;
 
 	if (cell->n_vertices == 0)
-		return 0;
+		return isl_stat_ok;
 
 	for (i = 0; i < cell->n_vertices; ++i) {
-		int r;
+		isl_stat r;
 
 		vertex = isl_vertex_alloc(isl_vertices_copy(cell->vertices),
 					  cell->idsi);
 		if (!vertex)
-			return -1;
+			return isl_stat_error;
 
 		r = fn(vertex, user);
 		if (r < 0)
-			return -1;
+			return isl_stat_error;
 	}
 
-	return 0;
+	return isl_stat_ok;
 }
 
 isl_ctx *isl_vertices_get_ctx(__isl_keep isl_vertices *vertices)
@@ -1356,9 +1396,9 @@
 	return vertices ? vertices->bset->ctx : NULL;
 }
 
-int isl_vertices_get_n_vertices(__isl_keep isl_vertices *vertices)
+isl_size isl_vertices_get_n_vertices(__isl_keep isl_vertices *vertices)
 {
-	return vertices ? vertices->n_vertices : -1;
+	return vertices ? vertices->n_vertices : isl_size_error;
 }
 
 __isl_give isl_vertices *isl_morph_vertices(__isl_take isl_morph *morph,
@@ -1405,9 +1445,9 @@
 /* Construct a simplex isl_cell spanned by the vertices with indices in
  * "simplex_ids" and "other_ids" and call "fn" on this isl_cell.
  */
-static int call_on_simplex(__isl_keep isl_cell *cell,
+static isl_stat call_on_simplex(__isl_keep isl_cell *cell,
 	int *simplex_ids, int n_simplex, int *other_ids, int n_other,
-	int (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
+	isl_stat (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
 {
 	int i;
 	isl_ctx *ctx;
@@ -1417,7 +1457,7 @@
 
 	simplex = isl_calloc_type(ctx, struct isl_cell);
 	if (!simplex)
-		return -1;
+		return isl_stat_error;
 	simplex->vertices = isl_vertices_copy(cell->vertices);
 	if (!simplex->vertices)
 		goto error;
@@ -1437,7 +1477,7 @@
 	return fn(simplex, user);
 error:
 	isl_cell_free(simplex);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Check whether the parametric vertex described by "vertex"
@@ -1480,12 +1520,12 @@
  * and call ourselves recursively on the polytope spanned by the new
  * "simplex_ids" and those points in "other_ids" that lie on the facet.
  */
-static int triangulate(__isl_keep isl_cell *cell, __isl_keep isl_vec *v,
+static isl_stat triangulate(__isl_keep isl_cell *cell, __isl_keep isl_vec *v,
 	int *simplex_ids, int n_simplex, int *other_ids, int n_other,
-	int (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
+	isl_stat (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
 {
 	int i, j, k;
-	int d, nparam;
+	isl_size d, nparam;
 	int *ids;
 	isl_ctx *ctx;
 	isl_basic_set *vertex;
@@ -1494,6 +1534,8 @@
 	ctx = isl_cell_get_ctx(cell);
 	d = isl_basic_set_dim(cell->vertices->bset, isl_dim_set);
 	nparam = isl_basic_set_dim(cell->vertices->bset, isl_dim_param);
+	if (d < 0 || nparam < 0)
+		return isl_stat_error;
 
 	if (n_simplex + n_other == d + 1)
 		return call_on_simplex(cell, simplex_ids, n_simplex,
@@ -1504,6 +1546,8 @@
 	bset = cell->vertices->bset;
 
 	ids = isl_alloc_array(ctx, int, n_other - 1);
+	if (!ids)
+		goto error;
 	for (i = 0; i < bset->n_ineq; ++i) {
 		if (isl_seq_first_non_zero(bset->ineqi + 1 + nparam, d) == -1)
 			continue;
@@ -1525,29 +1569,31 @@
 	}
 	free(ids);
 
-	return 0;
+	return isl_stat_ok;
 error:
 	free(ids);
-	return -1;
+	return isl_stat_error;
 }
 
 /* Triangulate the given cell and call "fn" on each of the resulting
  * simplices.
  */
-int isl_cell_foreach_simplex(__isl_take isl_cell *cell,
-	int (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
+isl_stat isl_cell_foreach_simplex(__isl_take isl_cell *cell,
+	isl_stat (*fn)(__isl_take isl_cell *simplex, void *user), void *user)
 {
-	int d, total;
-	int r;
+	isl_size d, total;
+	isl_stat r;
 	isl_ctx *ctx;
 	isl_vec *v = NULL;
 	int *simplex_ids = NULL;
 
 	if (!cell)
-		return -1;
+		return isl_stat_error;
 
 	d = isl_basic_set_dim(cell->vertices->bset, isl_dim_set);
-	total = isl_basic_set_total_dim(cell->vertices->bset);
+	total = isl_basic_set_dim(cell->vertices->bset, isl_dim_all);
+	if (d < 0 || total < 0)
+		return isl_stat_error;
 
 	if (cell->n_vertices == d + 1)
 		return fn(cell, user);
@@ -1574,5 +1620,5 @@
 	free(simplex_ids);
 	isl_vec_free(v);
 	isl_cell_free(cell);
-	return -1;
+	return isl_stat_error;
 }

_service:tar_scm:isl-0.14.tar.xz/isl_vertices_private.h -> _service:tar_scm:isl-0.24.tar.gz/isl_vertices_private.h Changed

@@ -1,3 +1,6 @@
+#ifndef ISL_VERTICES_PRIVATE_H
+#define ISL_VERTICES_PRIVATE_H
+
 #include <isl/set.h>
 #include <isl/vertices.h>
 
@@ -11,6 +14,8 @@
  * of the vertex as a singleton parametric set.  "dom" is the projection
  * of "vertex" onto the parameter space, i.e., the activity domain
  * of the vertex.
+ * During the construction of vertices and chambers, the activity domain
+ * of every parametric vertex is full-dimensional.
  */
 struct isl_vertex {
 	isl_basic_set *dom;
@@ -51,10 +56,10 @@
 	int id;
 };
 
-int isl_vertices_foreach_disjoint_cell(__isl_keep isl_vertices *vertices,
-	int (*fn)(__isl_take isl_cell *cell, void *user), void *user);
-int isl_cell_foreach_simplex(__isl_take isl_cell *cell,
-	int (*fn)(__isl_take isl_cell *simplex, void *user), void *user);
+isl_stat isl_vertices_foreach_disjoint_cell(__isl_keep isl_vertices *vertices,
+	isl_stat (*fn)(__isl_take isl_cell *cell, void *user), void *user);
+isl_stat isl_cell_foreach_simplex(__isl_take isl_cell *cell,
+	isl_stat (*fn)(__isl_take isl_cell *simplex, void *user), void *user);
 
 __isl_give isl_vertices *isl_morph_vertices(__isl_take struct isl_morph *morph,
 	__isl_take isl_vertices *vertices);
@@ -62,3 +67,5 @@
 #if defined(__cplusplus)
 }
 #endif
+
+#endif

_service:tar_scm:isl-0.24.tar.gz/isl_yaml.h Added

_service:tar_scm:isl-0.24.tar.gz/libisl-gdb.py Added

@@ -0,0 +1,100 @@
+import gdb
+import re
+
+# GDB Pretty Printers for most isl objects
+class IslObjectPrinter:
+	"""Print an isl object"""
+	def __init__ (self, val, type):
+		self.val = val
+		self.type = type
+
+	def to_string (self):
+		# Cast val to a void pointer to stop gdb using this pretty
+		# printer for the pointer which would lead to an infinite loop.
+		void_ptr = gdb.lookup_type('void').pointer()
+		value = str(self.val.cast(void_ptr))
+		printer = gdb.parse_and_eval("isl_printer_to_str(isl_"
+					     + str(self.type)
+					     + "_get_ctx(" + value + "))")
+		printer = gdb.parse_and_eval("isl_printer_print_"
+					     + str(self.type) + "("
+					     + str(printer) + ", "
+					     + value + ")")
+		string = gdb.parse_and_eval("(char*)isl_printer_get_str("
+					    + str(printer) + ")")
+		gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
+		return string
+
+	def display_hint (self):
+		return 'string'
+
+class IslIntPrinter:
+	"""Print an isl_int """
+	def __init__ (self, val):
+		self.val = val
+
+	def to_string (self):
+		# Cast val to a void pointer to stop gdb using this pretty
+		# printer for the pointer which would lead to an infinite loop.
+		void_ptr = gdb.lookup_type('void').pointer()
+		value = str(self.val.cast(void_ptr))
+
+		context = gdb.parse_and_eval("isl_ctx_alloc()")
+		printer = gdb.parse_and_eval("isl_printer_to_str("
+					     + str(context) + ")")
+		printer = gdb.parse_and_eval("isl_printer_print_isl_int("
+					     + str(printer) + ", "
+					     + value + ")")
+		string = gdb.parse_and_eval("(char*)isl_printer_get_str("
+					    + str(printer) + ")")
+		gdb.parse_and_eval("isl_printer_free(" + str(printer) + ")")
+		gdb.parse_and_eval("isl_ctx_free(" + str(context) + ")")
+		return string
+
+	def display_hint (self):
+		return 'string'
+
+class IslPrintCommand (gdb.Command):
+	"""Print an isl value."""
+	def __init__ (self):
+		super (IslPrintCommand, self).__init__ ("islprint",
+							gdb.COMMAND_OBSCURE)
+	def invoke (self, arg, from_tty):
+		arg = gdb.parse_and_eval(arg);
+		printer = str_lookup_function(arg)
+
+		if printer == None:
+			print("No isl printer for this type")
+			return
+
+		print(printer.to_string())
+
+IslPrintCommand()
+
+def str_lookup_function (val):
+	if val.type.code != gdb.TYPE_CODE_PTR:
+		if str(val.type) == "isl_int":
+			return IslIntPrinter(val)
+		else:
+			return None
+
+	lookup_tag = val.type.target()
+	regex = re.compile ("^isl_(.*)$")
+
+	if lookup_tag == None:
+		return None
+
+	m = regex.match (str(lookup_tag))
+
+	if m:
+		# Those types of printers defined in isl.
+		if m.group(1) in "basic_set", "set", "union_set", "basic_map",
+				  "map", "union_map", "qpolynomial",
+				  "pw_qpolynomial", "pw_qpolynomial_fold",
+				  "union_pw_qpolynomial",
+				  "union_pw_qpolynomial_fold":
+			return IslObjectPrinter(val, m.group(1))
+	return None
+
+# Do not register the pretty printer.
+# gdb.current_objfile().pretty_printers.append(str_lookup_function)

_service:tar_scm:isl-0.14.tar.xz/ltmain.sh -> _service:tar_scm:isl-0.24.tar.gz/ltmain.sh Changed

@@ -1,10 +1,12 @@
 #! /bin/sh
+## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
+##               by inline-source v2014-01-03.01
 
-# libtool (GNU libtool) 2.4.2.418
+# libtool (GNU libtool) 2.4.6
 # Provide generalized library-building support services.
 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2015 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
@@ -29,8 +31,8 @@
 
 PROGRAM=libtool
 PACKAGE=libtool
-VERSION=2.4.2.418
-package_revision=2.4.2.418
+VERSION="2.4.6 Debian-2.4.6-14"
+package_revision=2.4.6
 
 
 ## ------ ##
@@ -62,12 +64,12 @@
 # libraries, which are installed to $pkgauxdir.
 
 # Set a version string for this script.
-scriptversion=2013-08-23.20; # UTC
+scriptversion=2015-01-20.17; # UTC
 
 # General shell script boiler plate, and helper functions.
 # Written by Gary V. Vaughan, 2004
 
-# Copyright (C) 2004-2013 Free Software Foundation, Inc.
+# Copyright (C) 2004-2015 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
@@ -147,47 +149,157 @@
 '
 IFS="$sp	$nl"
 
-# There are still modern systems that have problems with 'echo' mis-
-# handling backslashes, among others, so make sure $bs_echo is set to a
-# command that correctly interprets backslashes.
-# (this code from Autoconf 2.68)
-
-# Printing a long string crashes Solaris 7 /usr/bin/printf.
-bs_echo='\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\\'
-bs_echo=$bs_echo$bs_echo$bs_echo$bs_echo$bs_echo
-bs_echo=$bs_echo$bs_echo$bs_echo$bs_echo$bs_echo$bs_echo
-# Prefer a ksh shell builtin over an external printf program on Solaris,
-# but without wasting forks for bash or zsh.
-if test -z "$BASH_VERSION$ZSH_VERSION" \
-    && (test "X`print -r -- $bs_echo`" = "X$bs_echo") 2>/dev/null; then
-  bs_echo='print -r --'
-  bs_echo_n='print -rn --'
-elif (test "X`printf %s $bs_echo`" = "X$bs_echo") 2>/dev/null; then
-  bs_echo='printf %s\n'
-  bs_echo_n='printf %s'
-else
-  if test "X`(/usr/ucb/echo -n -n $bs_echo) 2>/dev/null`" = "X-n $bs_echo"; then
-    bs_echo_body='eval /usr/ucb/echo -n "$1$nl"'
-    bs_echo_n='/usr/ucb/echo -n'
-  else
-    bs_echo_body='eval expr "X$1" : "X\$.*\$"'
-    bs_echo_n_body='eval
-      arg=$1;
-      case $arg in #(
-      *"$nl"*)
-	expr "X$arg" : "X\$.*\$$nl";
-	arg=`expr "X$arg" : ".*$nl\$.*\$"`;;
-      esac;
-      expr "X$arg" : "X\$.*\$" | tr -d "$nl"
-    '
-    export bs_echo_n_body
-    bs_echo_n='sh -c $bs_echo_n_body bs_echo'
-  fi
-  export bs_echo_body
-  bs_echo='sh -c $bs_echo_body bs_echo'
+# There are apparently some retarded systems that use ';' as a PATH separator!
+if test "${PATH_SEPARATOR+set}" != set; then
+  PATH_SEPARATOR=:
+  (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
+    (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
+      PATH_SEPARATOR=';'
+  }
 fi
 
 
+
+## ------------------------- ##
+## Locate command utilities. ##
+## ------------------------- ##
+
+
+# func_executable_p FILE
+# ----------------------
+# Check that FILE is an executable regular file.
+func_executable_p ()
+{
+    test -f "$1" && test -x "$1"
+}
+
+
+# func_path_progs PROGS_LIST CHECK_FUNC PATH
+# --------------------------------------------
+# Search for either a program that responds to --version with output
+# containing "GNU", or else returned by CHECK_FUNC otherwise, by
+# trying all the directories in PATH with each of the elements of
+# PROGS_LIST.
+#
+# CHECK_FUNC should accept the path to a candidate program, and
+# set $func_check_prog_result if it truncates its output less than
+# $_G_path_prog_max characters.
+func_path_progs ()
+{
+    _G_progs_list=$1
+    _G_check_func=$2
+    _G_PATH=${3-"$PATH"}
+
+    _G_path_prog_max=0
+    _G_path_prog_found=false
+    _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
+    for _G_dir in $_G_PATH; do
+      IFS=$_G_save_IFS
+      test -z "$_G_dir" && _G_dir=.
+      for _G_prog_name in $_G_progs_list; do
+        for _exeext in '' .EXE; do
+          _G_path_prog=$_G_dir/$_G_prog_name$_exeext
+          func_executable_p "$_G_path_prog" || continue
+          case `"$_G_path_prog" --version 2>&1` in
+            *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
+            *)     $_G_check_func $_G_path_prog
+		   func_path_progs_result=$func_check_prog_result
+		   ;;
+          esac
+          $_G_path_prog_found && break 3
+        done
+      done
+    done
+    IFS=$_G_save_IFS
+    test -z "$func_path_progs_result" && {
+      echo "no acceptable sed could be found in \$PATH" >&2
+      exit 1
+    }
+}
+
+
+# We want to be able to use the functions in this file before configure
+# has figured out where the best binaries are kept, which means we have
+# to search for them ourselves - except when the results are already set
+# where we skip the searches.
+
+# Unless the user overrides by setting SED, search the path for either GNU
+# sed, or the sed that truncates its output the least.
+test -z "$SED" && {
+  _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
+  for _G_i in 1 2 3 4 5 6 7; do
+    _G_sed_script=$_G_sed_script$nl$_G_sed_script
+  done
+  echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
+  _G_sed_script=
+
+  func_check_prog_sed ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo '' >> conftest.nl
+      "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
+  rm -f conftest.sed
+  SED=$func_path_progs_result
+}
+
+
+# Unless the user overrides by setting GREP, search the path for either GNU
+# grep, or the grep that truncates its output the least.
+test -z "$GREP" && {
+  func_check_prog_grep ()
+  {
+    _G_path_prog=$1
+
+    _G_count=0
+    _G_path_prog_max=0
+    printf 0123456789 >conftest.in
+    while :
+    do
+      cat conftest.in conftest.in >conftest.tmp
+      mv conftest.tmp conftest.in
+      cp conftest.in conftest.nl
+      echo 'GREP' >> conftest.nl
+      "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
+      diff conftest.out conftest.nl >/dev/null 2>&1 || break
+      _G_count=`expr $_G_count + 1`
+      if test "$_G_count" -gt "$_G_path_prog_max"; then
+        # Best one so far, save it but keep looking for a better one
+        func_check_prog_result=$_G_path_prog
+        _G_path_prog_max=$_G_count
+      fi
+      # 10*(2^10) chars as input seems more than enough
+      test 10 -lt "$_G_count" && break
+    done
+    rm -f conftest.in conftest.tmp conftest.nl conftest.out
+  }
+
+  func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
+  GREP=$func_path_progs_result
+}
+
+
 ## ------------------------------- ##
 ## User overridable command paths. ##
 ## ------------------------------- ##
@@ -198,16 +310,14 @@
 # in the command search PATH.
 
 : ${CP="cp -f"}
-: ${ECHO="$bs_echo"}
-: ${EGREP="grep -E"}
-: ${FGREP="grep -F"}
-: ${GREP="grep"}
+: ${ECHO="printf %s\n"}
+: ${EGREP="$GREP -E"}
+: ${FGREP="$GREP -F"}
 : ${LN_S="ln -s"}
 : ${MAKE="make"}
 : ${MKDIR="mkdir"}
 : ${MV="mv -f"}
 : ${RM="rm -f"}
-: ${SED="sed"}
 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 
 
@@ -277,7 +387,7 @@
 # putting '$debug_cmd' at the start of all your functions, you can get
 # bash to show function call trace with:
 #
-#    debug_cmd='eval echo "${FUNCNAME0} $*" >&2' bash your-script-name
+#    debug_cmd='echo "${FUNCNAME0} $*" >&2' bash your-script-name
 debug_cmd=${debug_cmd-":"}
 exit_cmd=:
 
@@ -298,13 +408,13 @@
 progpath=$0
 
 # The name of this program.
-progname=`$bs_echo "$progpath" |$SED "$sed_basename"`
+progname=`$ECHO "$progpath" |$SED "$sed_basename"`
 
 # Make sure we have an absolute progpath for reexecution:
 case $progpath in
   \\/*|A-Za-z:\\*) ;;
   *\\/*)
-     progdir=`$bs_echo "$progpath" |$SED "$sed_dirname"`
+     progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
      progdir=`cd "$progdir" && pwd`
      progpath=$progdir/$progname
      ;;
@@ -498,7 +608,7 @@
 {
     $debug_cmd
 
-    eval _G_current_value='`$bs_echo $'$1'`'
+    eval _G_current_value='`$ECHO $'$1'`'
     _G_delim=`expr "$2" : '$.$'`
 
     case $_G_delim$_G_current_value$_G_delim in
@@ -611,7 +721,7 @@
     IFS=$nl
     for _G_line in $_G_message; do
       IFS=$func_echo_IFS
-      $bs_echo "$progname: $_G_line"
+      $ECHO "$progname: $_G_line"
     done
     IFS=$func_echo_IFS
 }
@@ -645,17 +755,17 @@
     for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
     do
       test -n "$_G_tc" && {
-        _G_esc_tc=`$bs_echo "$_G_tc" | sed "$sed_make_literal_regex"`
-        _G_indent=`$bs_echo "$_G_indent" | sed "s|$_G_esc_tc||g"`
+        _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
+        _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
       }
     done
-    _G_indent="$progname: "`echo "$_G_indent" | sed 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
+    _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
 
     func_echo_infix_1_IFS=$IFS
     IFS=$nl
     for _G_line in $_G_message; do
       IFS=$func_echo_infix_1_IFS
-      $bs_echo "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
+      $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
       _G_prefix=$_G_indent
     done
     IFS=$func_echo_infix_1_IFS
@@ -1232,56 +1342,40 @@
 {
     $debug_cmd
 
-    ver1=$1
-    ver2=$2
+    printf '%s\n%s\n' "$1" "$2" \
+      | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
+}
 
-    # Split on '.' and compare each component.
-    i=1
-    while :; do
-      p1=`echo "$ver1" |cut -d. -f$i`
-      p2=`echo "$ver2" |cut -d. -f$i`
-      if test ! "$p1"; then
-        echo "$1 $2"
-        break
-      elif test ! "$p2"; then
-        echo "$2 $1"
-        break
-      elif test ! "$p1" = "$p2"; then
-        if test "$p1" -gt "$p2" 2>/dev/null; then # numeric comparison
-          echo "$2 $1"
-        elif test "$p2" -gt "$p1" 2>/dev/null; then # numeric comparison
-          echo "$1 $2"
-        else # numeric, then lexicographic comparison
-          lp=`printf "$p1\n$p2\n" |sort -n |tail -n1`
-          if test "$lp" = "$p2"; then
-            echo "$1 $2"
-          else
-            echo "$2 $1"
-          fi
-        fi
-        break
-      fi
-      i=`expr $i + 1`
-    done
+# func_lt_ver PREV CURR
+# ---------------------
+# Return true if PREV and CURR are in the correct order according to
+# func_sort_ver, otherwise false.  Use it like this:
+#
+#  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
+func_lt_ver ()
+{
+    $debug_cmd
+
+    test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
 }
 
 
 # Local variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
 # time-stamp-time-zone: "UTC"
 # End:
 #! /bin/sh
 
 # Set a version string for this script.
-scriptversion=2012-10-21.11; # UTC
+scriptversion=2015-10-07.11; # UTC
 
 # A portable, pluggable option parser for Bourne shell.
 # Written by Gary V. Vaughan, 2010
 
-# Copyright (C) 2010-2013 Free Software Foundation, Inc.
+# Copyright (C) 2010-2015 Free Software Foundation, Inc.
 # This is free software; see the source for copying conditions.  There is NO
 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
@@ -1421,7 +1515,7 @@
 {
     $debug_cmd
 
-    eval ${1}_hooks='`$bs_echo "\$'$1'_hooks" |$SED "s| '$2'||"`'
+    eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
 }
 
 
@@ -1436,6 +1530,8 @@
 {
     $debug_cmd
 
+    _G_rc_run_hooks=false
+
     case " $hookable_fns " in
       *" $1 "*) ;;
       *) func_fatal_error "'$1' does not support hook funcions.n" ;;
@@ -1444,16 +1540,16 @@
     eval _G_hook_fns=\$$1_hooks; shift
 
     for _G_hook in $_G_hook_fns; do
-      eval $_G_hook '"$@"'
-
-      # store returned options list back into positional
-      # parameters for next 'cmd' execution.
-      eval _G_hook_result=\$${_G_hook}_result
-      eval set dummy "$_G_hook_result"; shift
+      if eval $_G_hook '"$@"'; then
+        # store returned options list back into positional
+        # parameters for next 'cmd' execution.
+        eval _G_hook_result=\$${_G_hook}_result
+        eval set dummy "$_G_hook_result"; shift
+        _G_rc_run_hooks=:
+      fi
     done
 
-    func_quote_for_eval ${1+"$@"}
-    func_run_hooks_result=$func_quote_for_eval_result
+    $_G_rc_run_hooks && func_run_hooks_result=$_G_hook_result
 }
 
 
@@ -1463,10 +1559,16 @@
 ## --------------- ##
 
 # In order to add your own option parsing hooks, you must accept the
-# full positional parameter list in your hook function, remove any
-# options that you action, and then pass back the remaining unprocessed
+# full positional parameter list in your hook function, you may remove/edit
+# any options that you action, and then pass back the remaining unprocessed
 # options in '<hooked_function_name>_result', escaped suitably for
-# 'eval'.  Like this:
+# 'eval'.  In this case you also must return $EXIT_SUCCESS to let the
+# hook's caller know that it should pay attention to
+# '<hooked_function_name>_result'.  Returning $EXIT_FAILURE signalizes that
+# arguments are left untouched by the hook and therefore caller will ignore the
+# result variable.
+#
+# Like this:
 #
 #    my_options_prep ()
 #    {
@@ -1476,9 +1578,11 @@
 #        usage_message=$usage_message'
 #      -s, --silent       don'\''t print informational messages
 #    '
-#
-#        func_quote_for_eval ${1+"$@"}
-#        my_options_prep_result=$func_quote_for_eval_result
+#        # No change in '$@' (ignored completely by this hook).  There is
+#        # no need to do the equivalent (but slower) action:
+#        # func_quote_for_eval ${1+"$@"}
+#        # my_options_prep_result=$func_quote_for_eval_result
+#        false
 #    }
 #    func_add_hook func_options_prep my_options_prep
 #
@@ -1487,25 +1591,37 @@
 #    {
 #        $debug_cmd
 #
+#        args_changed=false
+#
 #        # Note that for efficiency, we parse as many options as we can
 #        # recognise in a loop before passing the remainder back to the
 #        # caller on the first unrecognised argument we encounter.
 #        while test $# -gt 0; do
 #          opt=$1; shift
 #          case $opt in
-#            --silent|-s) opt_silent=: ;;
+#            --silent|-s) opt_silent=:
+#                         args_changed=:
+#                         ;;
 #            # Separate non-argument short options:
 #            -s*)         func_split_short_opt "$_G_opt"
 #                         set dummy "$func_split_short_opt_name" \
 #                             "-$func_split_short_opt_arg" ${1+"$@"}
 #                         shift
+#                         args_changed=:
 #                         ;;
-#            *)            set dummy "$_G_opt" "$*"; shift; break ;;
+#            *)           # Make sure the first unrecognised option "$_G_opt"
+#                         # is added back to "$@", we could need that later
+#                         # if $args_changed is true.
+#                         set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
 #          esac
 #        done
 #
-#        func_quote_for_eval ${1+"$@"}
-#        my_silent_option_result=$func_quote_for_eval_result
+#        if $args_changed; then
+#          func_quote_for_eval ${1+"$@"}
+#          my_silent_option_result=$func_quote_for_eval_result
+#        fi
+#
+#        $args_changed
 #    }
 #    func_add_hook func_parse_options my_silent_option
 #
@@ -1517,16 +1633,32 @@
 #        $opt_silent && $opt_verbose && func_fatal_help "\
 #    '--silent' and '--verbose' options are mutually exclusive."
 #
-#        func_quote_for_eval ${1+"$@"}
-#        my_option_validation_result=$func_quote_for_eval_result
+#        false
 #    }
 #    func_add_hook func_validate_options my_option_validation
 #
-# You'll alse need to manually amend $usage_message to reflect the extra
+# You'll also need to manually amend $usage_message to reflect the extra
 # options you parse.  It's preferable to append if you can, so that
 # multiple option parsing hooks can be added safely.
 
 
+# func_options_finish ARG...
+# ----------------------------
+# Finishing the option parse loop (call 'func_options' hooks ATM).
+func_options_finish ()
+{
+    $debug_cmd
+
+    _G_func_options_finish_exit=false
+    if func_run_hooks func_options ${1+"$@"}; then
+      func_options_finish_result=$func_run_hooks_result
+      _G_func_options_finish_exit=:
+    fi
+
+    $_G_func_options_finish_exit
+}
+
+
 # func_options ARG...
 # ---------------------
 # All the functions called inside func_options are hookable. See the
@@ -1536,17 +1668,28 @@
 {
     $debug_cmd
 
-    func_options_prep ${1+"$@"}
-    eval func_parse_options \
-        ${func_options_prep_result+"$func_options_prep_result"}
-    eval func_validate_options \
-        ${func_parse_options_result+"$func_parse_options_result"}
+    _G_rc_options=false
 
-    eval func_run_hooks func_options \
-        ${func_validate_options_result+"$func_validate_options_result"}
+    for my_func in options_prep parse_options validate_options options_finish
+    do
+      if eval func_$my_func '${1+"$@"}'; then
+        eval _G_res_var='$'"func_${my_func}_result"
+        eval set dummy "$_G_res_var" ; shift
+        _G_rc_options=:
+      fi
+    done
+
+    # Save modified positional parameters for caller.  As a top-level
+    # options-parser function we always need to set the 'func_options_result'
+    # variable (regardless the $_G_rc_options value).
+    if $_G_rc_options; then
+      func_options_result=$_G_res_var
+    else
+      func_quote_for_eval ${1+"$@"}
+      func_options_result=$func_quote_for_eval_result
+    fi
 
-    # save modified positional parameters for caller
-    func_options_result=$func_run_hooks_result
+    $_G_rc_options
 }
 
 
@@ -1555,9 +1698,9 @@
 # All initialisations required before starting the option parse loop.
 # Note that when calling hook functions, we pass through the list of
 # positional parameters.  If a hook function modifies that list, and
-# needs to propogate that back to rest of this script, then the complete
+# needs to propagate that back to rest of this script, then the complete
 # modified list must be put in 'func_run_hooks_result' before
-# returning.
+# returning $EXIT_SUCCESS (otherwise $EXIT_FAILURE is returned).
 func_hookable func_options_prep
 func_options_prep ()
 {
@@ -1567,10 +1710,14 @@
     opt_verbose=false
     opt_warning_types=
 
-    func_run_hooks func_options_prep ${1+"$@"}
+    _G_rc_options_prep=false
+    if func_run_hooks func_options_prep ${1+"$@"}; then
+      _G_rc_options_prep=:
+      # save modified positional parameters for caller
+      func_options_prep_result=$func_run_hooks_result
+    fi
 
-    # save modified positional parameters for caller
-    func_options_prep_result=$func_run_hooks_result
+    $_G_rc_options_prep
 }
 
 
@@ -1584,18 +1731,20 @@
 
     func_parse_options_result=
 
+    _G_rc_parse_options=false
     # this just eases exit handling
     while test $# -gt 0; do
       # Defer to hook functions for initial option parsing, so they
       # get priority in the event of reusing an option name.
-      func_run_hooks func_parse_options ${1+"$@"}
-
-      # Adjust func_parse_options positional parameters to match
-      eval set dummy "$func_run_hooks_result"; shift
+      if func_run_hooks func_parse_options ${1+"$@"}; then
+        eval set dummy "$func_run_hooks_result"; shift
+        _G_rc_parse_options=:
+      fi
 
       # Break out of the loop if we already parsed every option.
       test $# -gt 0 || break
 
+      _G_match_parse_options=:
       _G_opt=$1
       shift
       case $_G_opt in
@@ -1610,7 +1759,10 @@
 		      ;;
 
         --warnings|--warning|-W)
-                      test $# = 0 && func_missing_arg $_G_opt && break
+                      if test $# = 0 && func_missing_arg $_G_opt; then
+                        _G_rc_parse_options=:
+                        break
+                      fi
                       case " $warning_categories $1" in
                         *" $1 "*)
                           # trailing space prevents matching last $1 above
@@ -1663,15 +1815,25 @@
                       shift
                       ;;
 
-        --)           break ;;
+        --)           _G_rc_parse_options=: ; break ;;
         -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
-        *)            set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
+        *)            set dummy "$_G_opt" ${1+"$@"}; shift
+                      _G_match_parse_options=false
+                      break
+                      ;;
       esac
+
+      $_G_match_parse_options && _G_rc_parse_options=:
     done
 
-    # save modified positional parameters for caller
-    func_quote_for_eval ${1+"$@"}
-    func_parse_options_result=$func_quote_for_eval_result
+
+    if $_G_rc_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      func_parse_options_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_parse_options
 }
 
 
@@ -1684,23 +1846,28 @@
 {
     $debug_cmd
 
+    _G_rc_validate_options=false
+
     # Display all warnings if -W was not given.
     test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
 
-    func_run_hooks func_validate_options ${1+"$@"}
+    if func_run_hooks func_validate_options ${1+"$@"}; then
+      # save modified positional parameters for caller
+      func_validate_options_result=$func_run_hooks_result
+      _G_rc_validate_options=:
+    fi
 
     # Bail if the options were screwed!
     $exit_cmd $EXIT_FAILURE
 
-    # save modified positional parameters for caller
-    func_validate_options_result=$func_run_hooks_result
+    $_G_rc_validate_options
 }
 
 
 
-## ------------------##
+## ----------------- ##
 ## Helper functions. ##
-## ------------------##
+## ----------------- ##
 
 # This section contains the helper functions used by the rest of the
 # hookable option parser framework in ascii-betical order.
@@ -1714,8 +1881,8 @@
 {
     $debug_cmd
 
-    eval \$bs_echo \""Usage: $usage"\"
-    eval \$bs_echo \""$fatal_help"\"
+    eval \$ECHO \""Usage: $usage"\"
+    eval \$ECHO \""$fatal_help"\"
     func_error ${1+"$@"}
     exit $EXIT_FAILURE
 }
@@ -1729,7 +1896,7 @@
     $debug_cmd
 
     func_usage_message
-    $bs_echo "$long_help_message"
+    $ECHO "$long_help_message"
     exit 0
 }
 
@@ -1816,7 +1983,7 @@
     $debug_cmd
 
     func_usage_message
-    $bs_echo "Run '$progname --help |${PAGER-more}' for full usage"
+    $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
     exit 0
 }
 
@@ -1828,7 +1995,7 @@
 {
     $debug_cmd
 
-    eval \$bs_echo \""Usage: $usage"\"
+    eval \$ECHO \""Usage: $usage"\"
     echo
     $SED -n 's|^# ||
         /^Written by/{
@@ -1837,7 +2004,7 @@
 	h
 	/^Written by/q' < "$progpath"
     echo
-    eval \$bs_echo \""$usage_message"\"
+    eval \$ECHO \""$usage_message"\"
 }
 
 
@@ -1849,7 +2016,7 @@
     $debug_cmd
 
     printf '%s\n' "$progname $scriptversion"
-    $SED -n '/^##/q
+    $SED -n '
         /(C)/!b go
         :more
         /\./!{
@@ -1877,13 +2044,13 @@
 # Local variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
 # time-stamp-time-zone: "UTC"
 # End:
 
 # Set a version string.
-scriptversion='(GNU libtool) 2.4.2.418'
+scriptversion='(GNU libtool) 2.4.6'
 
 
 # func_echo ARG...
@@ -1900,7 +2067,7 @@
     IFS=$nl
     for _G_line in $_G_message; do
       IFS=$func_echo_IFS
-      $bs_echo "$progname${opt_mode+: $opt_mode}: $_G_line"
+      $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
     done
     IFS=$func_echo_IFS
 }
@@ -1945,7 +2112,12 @@
 "
 
 # Additional text appended to 'usage_message' in response to '--help'.
-long_help_message=$long_help_message"
+func_help ()
+{
+    $debug_cmd
+
+    func_usage_message
+    $ECHO "$long_help_message
 
 MODE must be one of the following:
 
@@ -1969,13 +2141,15 @@
        compiler:       $LTCC
        compiler flags: $LTCFLAGS
        linker:         $LD (gnu? $with_gnu_ld)
-       version:        $progname (GNU libtool) 2.4.2.418
+       version:        $progname $scriptversion Debian-2.4.6-14
        automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
        autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
 
 Report bugs to <bug-libtool@gnu.org>.
-GNU libtool home page: <http://www.gnu.org/software/libtool/>.
+GNU libtool home page: <http://www.gnu.org/s/libtool/>.
 General help using GNU software: <http://www.gnu.org/gethelp/>."
+    exit 0
+}
 
 
 # func_lo2o OBJECT-NAME
@@ -2169,6 +2343,8 @@
     nonopt=
     preserve_args=
 
+    _G_rc_lt_options_prep=:
+
     # Shorthand for --mode=foo, only valid as the first argument
     case $1 in
     clean|clea|cle|cl)
@@ -2192,11 +2368,18 @@
     uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
       shift; set dummy --mode uninstall ${1+"$@"}; shift
       ;;
+    *)
+      _G_rc_lt_options_prep=false
+      ;;
     esac
 
-    # Pass back the list of options.
-    func_quote_for_eval ${1+"$@"}
-    libtool_options_prep_result=$func_quote_for_eval_result
+    if $_G_rc_lt_options_prep; then
+      # Pass back the list of options.
+      func_quote_for_eval ${1+"$@"}
+      libtool_options_prep_result=$func_quote_for_eval_result
+    fi
+
+    $_G_rc_lt_options_prep
 }
 func_add_hook func_options_prep libtool_options_prep
 
@@ -2208,9 +2391,12 @@
 {
     $debug_cmd
 
+    _G_rc_lt_parse_options=false
+
     # Perform our own loop to consume as many options as possible in
     # each iteration.
     while test $# -gt 0; do
+      _G_match_lt_parse_options=:
       _G_opt=$1
       shift
       case $_G_opt in
@@ -2285,15 +2471,22 @@
                         func_append preserve_args " $_G_opt"
                         ;;
 
-	# An option not handled by this hook function:
-        *)		set dummy "$_G_opt" ${1+"$@"};	shift; break  ;;
+        # An option not handled by this hook function:
+        *)              set dummy "$_G_opt" ${1+"$@"} ; shift
+                        _G_match_lt_parse_options=false
+                        break
+                        ;;
       esac
+      $_G_match_lt_parse_options && _G_rc_lt_parse_options=:
     done
 
+    if $_G_rc_lt_parse_options; then
+      # save modified positional parameters for caller
+      func_quote_for_eval ${1+"$@"}
+      libtool_parse_options_result=$func_quote_for_eval_result
+    fi
 
-    # save modified positional parameters for caller
-    func_quote_for_eval ${1+"$@"}
-    libtool_parse_options_result=$func_quote_for_eval_result
+    $_G_rc_lt_parse_options
 }
 func_add_hook func_parse_options libtool_parse_options
 
@@ -2315,7 +2508,9 @@
     test : = "$debug_cmd" || func_append preserve_args " --debug"
 
     case $host in
-      *cygwin* | *mingw* | *pw32* | *cegcc*)
+      # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
+      # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
+      *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
         # don't eliminate duplications in $postdeps and $predeps
         opt_duplicate_compiler_generated_deps=:
         ;;
@@ -2386,6 +2581,14 @@
 _LTECHO_EOF'
 }
 
+# func_generated_by_libtool
+# True iff stdin has been generated by Libtool. This function is only
+# a basic sanity check; it will hardly flush out determined imposters.
+func_generated_by_libtool_p ()
+{
+  $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+}
+
 # func_lalib_p file
 # True iff FILE is a libtool '.la' library or '.lo' object file.
 # This function is only a basic sanity check; it will hardly flush out
@@ -2393,8 +2596,7 @@
 func_lalib_p ()
 {
     test -f "$1" &&
-      $SED -e 4q "$1" 2>/dev/null \
-        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
+      $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
 }
 
 # func_lalib_unsafe_p file
@@ -2426,7 +2628,8 @@
 # determined imposters.
 func_ltwrapper_script_p ()
 {
-    func_lalib_p "$1"
+    test -f "$1" &&
+      $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
 }
 
 # func_ltwrapper_executable_p file
@@ -3626,7 +3829,8 @@
   -no-install       link a not-installable executable
   -no-undefined     declare that a library does not refer to external symbols
   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
-  -objectlist FILE  Use a list of object files found in FILE to specify objects
+  -objectlist FILE  use a list of object files found in FILE to specify objects
+  -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
   -precious-files-regex REGEX
                     don't remove output files matching REGEX
   -release RELEASE  specify package release information
@@ -3696,7 +3900,7 @@
       for opt_mode in compile link execute install finish uninstall clean; do
 	func_mode_help
       done
-    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
+    } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
     {
       func_help noexit
       for opt_mode in compile link execute install finish uninstall clean; do
@@ -3704,7 +3908,7 @@
 	func_mode_help
       done
     } |
-    sed '1d
+    $SED '1d
       /^When reporting/,/^Report/{
 	H
 	d
@@ -3894,7 +4098,7 @@
       else
         tmpdir=`func_mktempdir`
         for lib in $libs; do
-	  sed -e "$sysroot_cmd s/$ '-LR$=/\1/g; s/$ '$=/\1/g" $lib \
+	  $SED -e "$sysroot_cmd s/$ '-LR$=/\1/g; s/$ '$=/\1/g" $lib \
 	    > $tmpdir/tmp-la
 	  mv -f $tmpdir/tmp-la $lib
 	done
@@ -4208,6 +4412,13 @@
 	      ;;
 	    esac
 	    ;;
+	  os2*)
+	    case $realname in
+	    *_dll.a)
+	      tstripme=
+	      ;;
+	    esac
+	    ;;
 	  esac
 	  if test -n "$tstripme" && test -n "$striplib"; then
 	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
@@ -4449,7 +4660,7 @@
     my_outputname=$1
     my_originator=$2
     my_pic_p=${3-false}
-    my_prefix=`$ECHO "$my_originator" | sed 's%^a-zA-Z0-9%_%g'`
+    my_prefix=`$ECHO "$my_originator" | $SED 's%^a-zA-Z0-9%_%g'`
     my_dlsyms=
 
     if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
@@ -5049,7 +5260,7 @@
 	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
 	    done # $darwin_arches
             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
-	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
+	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
 	    darwin_file=
 	    darwin_files=
 	    for darwin_file in $darwin_filelist; do
@@ -5322,7 +5533,7 @@
     if test -n \"\$relink_command\"; then
       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
       else
-	$ECHO \"\$relink_command_output\" >&2
+	\$ECHO \"\$relink_command_output\" >&2
 	$RM \"\$progdir/\$file\"
 	exit 1
       fi
@@ -5554,7 +5765,12 @@
 EOF
 
 	    cat <<EOF
-volatile const char * MAGIC_EXE = "$magic_exe";
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
+# define externally_visible volatile
+#else
+# define externally_visible __attribute__((externally_visible)) volatile
+#endif
+externally_visible const char * MAGIC_EXE = "$magic_exe";
 const char * LIB_PATH_VARNAME = "$shlibpath_var";
 EOF
 
@@ -6344,6 +6560,24 @@
     esac
 }
 
+# func_suncc_cstd_abi
+# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
+# Several compiler flags select an ABI that is incompatible with the
+# Cstd library. Avoid specifying it if any are in CXXFLAGS.
+func_suncc_cstd_abi ()
+{
+    $debug_cmd
+
+    case " $compile_command " in
+    *" -compat=g "*|*\ -std=c++0-90-9\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
+      suncc_use_cstd_abi=no
+      ;;
+    *)
+      suncc_use_cstd_abi=yes
+      ;;
+    esac
+}
+
 # func_mode_link arg...
 func_mode_link ()
 {
@@ -6402,6 +6636,7 @@
     module=no
     no_install=no
     objs=
+    os2dllname=
     non_pic_objects=
     precious_files_regex=
     prefer_static_libs=no
@@ -6659,6 +6894,11 @@
 	  prev=
 	  continue
 	  ;;
+	os2dllname)
+	  os2dllname=$arg
+	  prev=
+	  continue
+	  ;;
 	precious_regex)
 	  precious_files_regex=$arg
 	  prev=
@@ -6968,6 +7208,11 @@
 	continue
 	;;
 
+      -os2dllname)
+	prev=os2dllname
+	continue
+	;;
+
       -o) prev=output ;;
 
       -precious-files-regex)
@@ -7114,14 +7359,21 @@
       # -m*, -t45*, -txscale* architecture-specific flags for GCC
       # -F/path              path to uninstalled frameworks, gcc on darwin
       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
+      # -fstack-protector*   stack protector flags for GCC
       # @file                GCC response files
       # -tp=*                Portland pgcc target processor selection
       # --sysroot=*          for sysroot support
       # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
+      # -specs=*             GCC specs files
       # -stdlib=*            select c++ std lib with clang
+      # -fsanitize=*         Clang/GCC memory and address sanitizer
+      # -fuse-ld=*           Linker select flags for GCC
+      # -static-*            direct GCC to link specific libraries statically
+      # -fcilkplus           Cilk Plus language extension features for C/C++
       -64|-mips0-9|-r0-90-9*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
       -t45*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
-      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-stdlib=*)
+      -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \
+      -specs=*|-fsanitize=*|-fuse-ld=*|-static-*|-fcilkplus)
         func_quote_for_eval "$arg"
 	arg=$func_quote_for_eval_result
         func_append compile_command " $arg"
@@ -7130,6 +7382,25 @@
         continue
         ;;
 
+      -Z*)
+        if test os2 = "`expr $host : '.*$os2$'`"; then
+          # OS/2 uses -Zxxx to specify OS/2-specific options
+	  compiler_flags="$compiler_flags $arg"
+	  func_append compile_command " $arg"
+	  func_append finalize_command " $arg"
+	  case $arg in
+	  -Zlinker | -Zstack)
+	    prev=xcompiler
+	    ;;
+	  esac
+	  continue
+        else
+	  # Otherwise treat like 'Some other compiler flag' below
+	  func_quote_for_eval "$arg"
+	  arg=$func_quote_for_eval_result
+        fi
+	;;
+
       # Some other compiler flag.
       -* | +*)
         func_quote_for_eval "$arg"
@@ -7289,6 +7560,9 @@
     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 
+    # Definition is injected by LT_CONFIG during libtool generation.
+    func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
+
     func_dirname "$output" "/" ""
     output_objdir=$func_dirname_result$objdir
     func_to_tool_file "$output_objdir/"
@@ -7392,7 +7666,10 @@
 	case $pass in
 	dlopen) libs=$dlfiles ;;
 	dlpreopen) libs=$dlprefiles ;;
-	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
+	link)
+	  libs="$deplibs %DEPLIBS%"
+	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
+	  ;;
 	esac
       fi
       if test lib,dlpreopen = "$linkmode,$pass"; then
@@ -7711,19 +7988,19 @@
 	    # It is a libtool convenience library, so add in its objects.
 	    func_append convenience " $ladir/$objdir/$old_library"
 	    func_append old_convenience " $ladir/$objdir/$old_library"
+	    tmp_libs=
+	    for deplib in $dependency_libs; do
+	      deplibs="$deplib $deplibs"
+	      if $opt_preserve_dup_deps; then
+		case "$tmp_libs " in
+		*" $deplib "*) func_append specialdeplibs " $deplib" ;;
+		esac
+	      fi
+	      func_append tmp_libs " $deplib"
+	    done
 	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
 	    func_fatal_error "'$lib' is not a convenience library"
 	  fi
-	  tmp_libs=
-	  for deplib in $dependency_libs; do
-	    deplibs="$deplib $deplibs"
-	    if $opt_preserve_dup_deps; then
-	      case "$tmp_libs " in
-	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
-	      esac
-	    fi
-	    func_append tmp_libs " $deplib"
-	  done
 	  continue
 	fi # $pass = conv
 
@@ -7956,7 +8233,7 @@
 	if test -n "$library_names" &&
 	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
 	  case $host in
-	  *cygwin* | *mingw* | *cegcc*)
+	  *cygwin* | *mingw* | *cegcc* | *os2*)
 	      # No point in relinking DLLs because paths are not encoded
 	      func_append notinst_deplibs " $lib"
 	      need_relink=no
@@ -8026,7 +8303,7 @@
 	    elif test -n "$soname_spec"; then
 	      # bleh windows
 	      case $host in
-	      *cygwin* | mingw* | *cegcc*)
+	      *cygwin* | mingw* | *cegcc* | *os2*)
 	        func_arith $current - $age
 		major=$func_arith_result
 		versuffix=-$major
@@ -8451,6 +8728,37 @@
 	  eval $var=\"$tmp_libs\"
 	done # for var
       fi
+
+      # Add Sun CC postdeps if required:
+      test CXX = "$tagname" && {
+        case $host_os in
+        linux*)
+          case `$CC -V 2>&1 | sed 5q` in
+          *Sun\ C*) # Sun C++ 5.9
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+
+        solaris*)
+          func_cc_basename "$CC"
+          case $func_cc_basename_result in
+          CC* | sunCC*)
+            func_suncc_cstd_abi
+
+            if test no != "$suncc_use_cstd_abi"; then
+              func_append postdeps ' -library=Cstd -library=Crun'
+            fi
+            ;;
+          esac
+          ;;
+        esac
+      }
+
       # Last step: remove runtime libs from dependency_libs
       # (they stay in deplibs)
       tmp_libs=
@@ -8598,13 +8906,13 @@
 	  #
 	  case $version_type in
 	  # correct linux to gnu/linux during the next big refactor
-	  darwin|linux|osf|windows|none)
+	  darwin|freebsd-elf|linux|osf|windows|none)
 	    func_arith $number_major + $number_minor
 	    current=$func_arith_result
 	    age=$number_minor
 	    revision=$number_revision
 	    ;;
-	  freebsd-aout|freebsd-elf|qnx|sunos)
+	  freebsd-aout|qnx|sunos)
 	    current=$number_major
 	    revision=$number_minor
 	    age=0
@@ -8616,6 +8924,9 @@
 	    revision=$number_minor
 	    lt_irix_increment=no
 	    ;;
+	  *)
+	    func_fatal_configuration "$modename: unknown library version type '$version_type'"
+	    ;;
 	  esac
 	  ;;
 	no)
@@ -8690,8 +9001,9 @@
 	  ;;
 
 	freebsd-elf)
-	  major=.$current
-	  versuffix=.$current
+	  func_arith $current - $age
+	  major=.$func_arith_result
+	  versuffix=$major.$age.$revision
 	  ;;
 
 	irix | nonstopux)
@@ -8754,6 +9066,11 @@
 	  versuffix=.$current
 	  ;;
 
+	sco)
+	  major=.$current
+	  versuffix=.$current
+	  ;;
+
 	sunos)
 	  major=.$current
 	  versuffix=.$current.$revision
@@ -9906,15 +10223,17 @@
       # the extraction.
       reload_conv_objs=
       gentop=
-      # reload_cmds runs $LD directly, so let us get rid of
-      # -Wl from whole_archive_flag_spec and hope we can get by with
-      # turning comma into space..
-      wl=
-
+      # if reload_cmds runs $LD directly, get rid of -Wl from
+      # whole_archive_flag_spec and hope we can get by with turning comma
+      # into space.
+      case $reload_cmds in
+        *\$LD\ \$*) wl= ;;
+      esac
       if test -n "$convenience"; then
 	if test -n "$whole_archive_flag_spec"; then
 	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
-	  reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
+	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
 	else
 	  gentop=$output_objdir/${obj}x
 	  func_append generated " $gentop"

_service:tar_scm:isl-0.24.tar.gz/m4/ax_cxx_compile_stdcxx.m4 Added

@@ -0,0 +1,982 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX(VERSION, ext|noext, mandatory|optional)
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the specified
+#   version of the C++ standard.  If necessary, add switches to CXX and
+#   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
+#   or '14' (for the C++14 standard).
+#
+#   The second argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The third argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline support for the specified C++ standard is
+#   required and that the macro should error out if no mode with that
+#   support is found.  If specified 'optional', then configuration proceeds
+#   regardless, after defining HAVE_CXX${VERSION} if and only if a
+#   supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#   Copyright (c) 2016 Krzesimir Nowak <qdlacz@gmail.com>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved.  This file is offered as-is, without any
+#   warranty.
+
+#serial 7
+
+dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
+dnl  (serial version number 13).
+
+AX_REQUIRE_DEFINED(AC_MSG_WARN)
+AC_DEFUN(AX_CXX_COMPILE_STDCXX, dnl
+  m4_if($1, 11, ax_cxx_compile_alternatives="11 0x",
+        $1, 14, ax_cxx_compile_alternatives="14 1y",
+        $1, 17, ax_cxx_compile_alternatives="17 1z",
+        m4_fatal(invalid first argument `$1' to AX_CXX_COMPILE_STDCXX))dnl
+  m4_if($2, , ,
+        $2, ext, ,
+        $2, noext, ,
+        m4_fatal(invalid second argument `$2' to AX_CXX_COMPILE_STDCXX))dnl
+  m4_if($3, , ax_cxx_compile_cxx$1_required=true,
+        $3, mandatory, ax_cxx_compile_cxx$1_required=true,
+        $3, optional, ax_cxx_compile_cxx$1_required=false,
+        m4_fatal(invalid third argument `$3' to AX_CXX_COMPILE_STDCXX))
+  AC_LANG_PUSH(C++)dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
+  ax_cv_cxx_compile_cxx$1,
+  AC_COMPILE_IFELSE(AC_LANG_SOURCE(_AX_CXX_COMPILE_STDCXX_testbody_$1),
+    ax_cv_cxx_compile_cxx$1=yes,
+    ax_cv_cxx_compile_cxx$1=no))
+  if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if($2, noext, , dnl
+  if test x$ac_success = xno; then
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      switch="-std=gnu++${alternative}"
+      cachevar=AS_TR_SH(ax_cv_cxx_compile_cxx$1_$switch)
+      AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                     $cachevar,
+        ac_save_CXX="$CXX"
+         CXX="$CXX $switch"
+         AC_COMPILE_IFELSE(AC_LANG_SOURCE(_AX_CXX_COMPILE_STDCXX_testbody_$1),
+          eval $cachevar=yes,
+          eval $cachevar=no)
+         CXX="$ac_save_CXX")
+      if eval test x\$$cachevar = xyes; then
+        CXX="$CXX $switch"
+        if test -n "$CXXCPP" ; then
+          CXXCPP="$CXXCPP $switch"
+        fi
+        ac_success=yes
+        break
+      fi
+    done
+  fi)
+
+  m4_if($2, ext, , dnl
+  if test x$ac_success = xno; then
+    dnl HP's aCC needs +std=c++11 according to:
+    dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
+    dnl Cray's crayCC needs "-h std=c++11"
+    for alternative in ${ax_cxx_compile_alternatives}; do
+      for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
+        cachevar=AS_TR_SH(ax_cv_cxx_compile_cxx$1_$switch)
+        AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
+                       $cachevar,
+          ac_save_CXX="$CXX"
+           CXX="$CXX $switch"
+           AC_COMPILE_IFELSE(AC_LANG_SOURCE(_AX_CXX_COMPILE_STDCXX_testbody_$1),
+            eval $cachevar=yes,
+            eval $cachevar=no)
+           CXX="$ac_save_CXX")
+        if eval test x\$$cachevar = xyes; then
+          CXX="$CXX $switch"
+          if test -n "$CXXCPP" ; then
+            CXXCPP="$CXXCPP $switch"
+          fi
+          ac_success=yes
+          break
+        fi
+      done
+      if test x$ac_success = xyes; then
+        break
+      fi
+    done
+  fi)
+  AC_LANG_POP(C++)
+  if test x$ax_cxx_compile_cxx$1_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR(*** A compiler with support for C++$1 language features is required.)
+    fi
+  fi
+  if test x$ac_success = xno; then
+    HAVE_CXX$1=0
+    AC_MSG_NOTICE(No compiler with C++$1 support was found)
+  else
+    HAVE_CXX$1=1
+    AC_DEFINE(HAVE_CXX$1,1,
+              define if the compiler supports basic C++$1 syntax)
+  fi
+  AC_SUBST(HAVE_CXX$1)
+  m4_if($1, 17, AC_MSG_WARN(C++17 is not yet standardized, so the checks may change in incompatible ways anytime))
+)
+
+
+dnl  Test body for checking C++11 support
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_11,
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+)
+
+
+dnl  Test body for checking C++14 support
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_14,
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+)
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_17,
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+  _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+)
+
+dnl  Tests for new features in C++11
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_new_in_11, 
+
+// If the compiler admits that it is not ready for C++11, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201103L
+
+#error "This is not a C++11 compiler"
+
+#else
+
+namespace cxx11
+{
+
+  namespace test_static_assert
+  {
+
+    template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+  }
+
+  namespace test_final_override
+  {
+
+    struct Base
+    {
+      virtual void f() {}
+    };
+
+    struct Derived : public Base
+    {
+      virtual void f() override {}
+    };
+
+  }
+
+  namespace test_double_right_angle_brackets
+  {
+
+    template < typename T >
+    struct check {};
+
+    typedef check<void> single_type;
+    typedef check<check<void>> double_type;
+    typedef check<check<check<void>>> triple_type;
+    typedef check<check<check<check<void>>>> quadruple_type;
+
+  }
+
+  namespace test_decltype
+  {
+
+    int
+    f()
+    {
+      int a = 1;
+      decltype(a) b = 2;
+      return a + b;
+    }
+
+  }
+
+  namespace test_type_deduction
+  {
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static const bool value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static const bool value = true;
+    };
+
+    template < typename T1, typename T2 >
+    auto
+    add(T1 a1, T2 a2) -> decltype(a1 + a2)
+    {
+      return a1 + a2;
+    }
+
+    int
+    test(const int c, volatile int v)
+    {
+      static_assert(is_same<int, decltype(0)>::value == true, "");
+      static_assert(is_same<int, decltype(c)>::value == false, "");
+      static_assert(is_same<int, decltype(v)>::value == false, "");
+      auto ac = c;
+      auto av = v;
+      auto sumi = ac + av + 'x';
+      auto sumf = ac + av + 1.0;
+      static_assert(is_same<int, decltype(ac)>::value == true, "");
+      static_assert(is_same<int, decltype(av)>::value == true, "");
+      static_assert(is_same<int, decltype(sumi)>::value == true, "");
+      static_assert(is_same<int, decltype(sumf)>::value == false, "");
+      static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
+      return (sumf > 0.0) ? sumi : add(c, v);
+    }
+
+  }
+
+  namespace test_noexcept
+  {
+
+    int f() { return 0; }
+    int g() noexcept { return 0; }
+
+    static_assert(noexcept(f()) == false, "");
+    static_assert(noexcept(g()) == true, "");
+
+  }
+
+  namespace test_constexpr
+  {
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+    {
+      return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+    }
+
+    template < typename CharT >
+    unsigned long constexpr
+    strlen_c(const CharT *const s) noexcept
+    {
+      return strlen_c_r(s, 0UL);
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("1") == 1UL, "");
+    static_assert(strlen_c("example") == 7UL, "");
+    static_assert(strlen_c("another\0example") == 7UL, "");
+
+  }
+
+  namespace test_rvalue_references
+  {
+
+    template < int N >
+    struct answer
+    {
+      static constexpr int value = N;
+    };
+
+    answer<1> f(int&)       { return answer<1>(); }
+    answer<2> f(const int&) { return answer<2>(); }
+    answer<3> f(int&&)      { return answer<3>(); }
+
+    void
+    test()
+    {
+      int i = 0;
+      const int c = 0;
+      static_assert(decltype(f(i))::value == 1, "");
+      static_assert(decltype(f(c))::value == 2, "");
+      static_assert(decltype(f(0))::value == 3, "");
+    }
+
+  }
+
+  namespace test_uniform_initialization
+  {
+
+    struct test
+    {
+      static const int zero {};
+      static const int one {1};
+    };
+
+    static_assert(test::zero == 0, "");
+    static_assert(test::one == 1, "");
+
+  }
+
+  namespace test_lambdas
+  {
+
+    void
+    test1()
+    {
+      auto lambda1 = (){};
+      auto lambda2 = lambda1;
+      lambda1();
+      lambda2();
+    }
+
+    int
+    test2()
+    {
+      auto a = (int i, int j){ return i + j; }(1, 2);
+      auto b = () -> int { return '0'; }();
+      auto c = =(){ return a + b; }();
+      auto d = &(){ return c; }();
+      auto e = a, &b(int x) mutable {
+        const auto identity = (int y){ return y; };
+        for (auto i = 0; i < a; ++i)
+          a += b--;
+        return x + identity(a + b);
+      }(0);
+      return a + b + c + d + e;
+    }
+
+    int
+    test3()
+    {
+      const auto nullary = (){ return 0; };
+      const auto unary = (int x){ return x; };
+      using nullary_t = decltype(nullary);
+      using unary_t = decltype(unary);
+      const auto higher1st = (nullary_t f){ return f(); };
+      const auto higher2nd = unary(nullary_t f1){
+        return unary, f1(unary_t f2){ return f2(unary(f1())); };
+      };
+      return higher1st(nullary) + higher2nd(nullary)(unary);
+    }
+
+  }
+
+  namespace test_variadic_templates
+  {
+
+    template <int...>
+    struct sum;
+
+    template <int N0, int... N1toN>
+    struct sum<N0, N1toN...>
+    {
+      static constexpr auto value = N0 + sum<N1toN...>::value;
+    };
+
+    template <>
+    struct sum<>
+    {
+      static constexpr auto value = 0;
+    };
+
+    static_assert(sum<>::value == 0, "");
+    static_assert(sum<1>::value == 1, "");
+    static_assert(sum<23>::value == 23, "");
+    static_assert(sum<1, 2>::value == 3, "");
+    static_assert(sum<5, 5, 11>::value == 21, "");
+    static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+
+  }
+
+  // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
+  // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
+  // because of this.
+  namespace test_template_alias_sfinae
+  {
+
+    struct foo {};
+
+    template<typename T>
+    using member = typename T::member_type;
+
+    template<typename T>
+    void func(...) {}
+
+    template<typename T>
+    void func(member<T>*) {}
+
+    void test();
+
+    void test() { func<foo>(0); }
+
+  }
+
+}  // namespace cxx11
+
+#endif  // __cplusplus >= 201103L
+
+)
+
+
+dnl  Tests for new features in C++14
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_new_in_14, 
+
+// If the compiler admits that it is not ready for C++14, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus < 201402L
+
+#error "This is not a C++14 compiler"
+
+#else
+
+namespace cxx14
+{
+
+  namespace test_polymorphic_lambdas
+  {
+
+    int
+    test()
+    {
+      const auto lambda = (auto&&... args){
+        const auto istiny = (auto x){
+          return (sizeof(x) == 1UL) ? 1 : 0;
+        };
+        const int aretiny = { istiny(args)... };
+        return aretiny0;
+      };
+      return lambda(1, 1L, 1.0f, '1');
+    }
+
+  }
+
+  namespace test_binary_literals
+  {
+
+    constexpr auto ivii = 0b0000000000101010;
+    static_assert(ivii == 42, "wrong value");
+
+  }
+
+  namespace test_generalized_constexpr
+  {
+
+    template < typename CharT >
+    constexpr unsigned long
+    strlen_c(const CharT *const s) noexcept
+    {
+      auto length = 0UL;
+      for (auto p = s; *p; ++p)
+        ++length;
+      return length;
+    }
+
+    static_assert(strlen_c("") == 0UL, "");
+    static_assert(strlen_c("x") == 1UL, "");
+    static_assert(strlen_c("test") == 4UL, "");
+    static_assert(strlen_c("another\0test") == 7UL, "");
+
+  }
+
+  namespace test_lambda_init_capture
+  {
+
+    int
+    test()
+    {
+      auto x = 0;
+      const auto lambda1 = a = x(int b){ return a + b; };
+      const auto lambda2 = a = lambda1(x)(){ return a; };
+      return lambda2();
+    }
+
+  }
+
+  namespace test_digit_separators
+  {
+
+    constexpr auto ten_million = 100'000'000;
+    static_assert(ten_million == 100000000, "");
+
+  }
+
+  namespace test_return_type_deduction
+  {
+
+    auto f(int& x) { return x; }
+    decltype(auto) g(int& x) { return x; }
+
+    template < typename T1, typename T2 >
+    struct is_same
+    {
+      static constexpr auto value = false;
+    };
+
+    template < typename T >
+    struct is_same<T, T>
+    {
+      static constexpr auto value = true;
+    };
+
+    int
+    test()
+    {
+      auto x = 0;
+      static_assert(is_same<int, decltype(f(x))>::value, "");
+      static_assert(is_same<int&, decltype(g(x))>::value, "");
+      return x;
+    }
+
+  }
+
+}  // namespace cxx14
+
+#endif  // __cplusplus >= 201402L
+
+)
+
+
+dnl  Tests for new features in C++17
+
+m4_define(_AX_CXX_COMPILE_STDCXX_testbody_new_in_17, 
+
+// If the compiler admits that it is not ready for C++17, why torture it?
+// Hopefully, this will speed up the test.
+
+#ifndef __cplusplus
+
+#error "This is not a C++ compiler"
+
+#elif __cplusplus <= 201402L
+
+#error "This is not a C++17 compiler"
+
+#else
+
+#if defined(__clang__)
+  #define REALLY_CLANG
+#else
+  #if defined(__GNUC__)
+    #define REALLY_GCC
+  #endif
+#endif
+
+#include <initializer_list>
+#include <utility>
+#include <type_traits>
+
+namespace cxx17
+{
+
+#if !defined(REALLY_CLANG)
+  namespace test_constexpr_lambdas
+  {
+
+    // TODO: test it with clang++ from git
+
+    constexpr int foo = (){return 42;}();
+
+  }
+#endif // !defined(REALLY_CLANG)
+
+  namespace test::nested_namespace::definitions
+  {
+
+  }
+
+  namespace test_fold_expression
+  {
+
+    template<typename... Args>
+    int multiply(Args... args)
+    {
+      return (args * ... * 1);
+    }
+
+    template<typename... Args>
+    bool all(Args... args)
+    {
+      return (args && ...);
+    }
+
+  }
+
+  namespace test_extended_static_assert
+  {
+
+    static_assert (true);
+
+  }
+
+  namespace test_auto_brace_init_list
+  {
+
+    auto foo = {5};
+    auto bar {5};
+
+    static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
+    static_assert(std::is_same<int, decltype(bar)>::value);
+  }
+
+  namespace test_typename_in_template_template_parameter
+  {
+
+    template<template<typename> typename X> struct D;
+
+  }
+
+  namespace test_fallthrough_nodiscard_maybe_unused_attributes
+  {
+
+    int f1()
+    {
+      return 42;
+    }
+
+    nodiscard int f2()
+    {
+      maybe_unused auto unused = f1();
+
+      switch (f1())
+      {
+      case 17:
+        f1();
+        fallthrough;
+      case 42:
+        f1();
+      }
+      return f1();
+    }
+
+  }
+
+  namespace test_extended_aggregate_initialization
+  {
+
+    struct base1
+    {
+      int b1, b2 = 42;
+    };
+
+    struct base2
+    {
+      base2() {
+        b3 = 42;
+      }
+      int b3;
+    };
+
+    struct derived : base1, base2
+    {
+        int d;
+    };
+
+    derived d1 {{1, 2}, {}, 4};  // full initialization
+    derived d2 {{}, {}, 4};      // value-initialized bases
+
+  }
+
+  namespace test_general_range_based_for_loop
+  {
+
+    struct iter
+    {
+      int i;
+
+      int& operator* ()
+      {
+        return i;
+      }
+
+      const int& operator* () const
+      {
+        return i;
+      }
+
+      iter& operator++()
+      {
+        ++i;
+        return *this;
+      }
+    };
+
+    struct sentinel
+    {
+      int i;
+    };
+
+    bool operator== (const iter& i, const sentinel& s)
+    {
+      return i.i == s.i;
+    }
+
+    bool operator!= (const iter& i, const sentinel& s)
+    {
+      return !(i == s);
+    }
+
+    struct range
+    {
+      iter begin() const
+      {
+        return {0};
+      }
+
+      sentinel end() const
+      {
+        return {5};
+      }
+    };
+
+    void f()
+    {
+      range r {};
+
+      for (auto i : r)
+      {
+        maybe_unused auto v = i;
+      }
+    }
+
+  }
+
+  namespace test_lambda_capture_asterisk_this_by_value
+  {
+
+    struct t
+    {
+      int i;
+      int foo()
+      {
+        return *this()
+        {
+          return i;
+        }();
+      }
+    };
+
+  }
+
+  namespace test_enum_class_construction
+  {
+
+    enum class byte : unsigned char
+    {};
+
+    byte foo {42};
+
+  }
+
+  namespace test_constexpr_if
+  {
+
+    template <bool cond>
+    int f ()
+    {
+      if constexpr(cond)
+      {
+        return 13;
+      }
+      else
+      {
+        return 42;
+      }
+    }
+
+  }
+
+  namespace test_selection_statement_with_initializer
+  {
+
+    int f()
+    {
+      return 13;
+    }
+
+    int f2()
+    {
+      if (auto i = f(); i > 0)
+      {
+        return 3;
+      }
+
+      switch (auto i = f(); i + 4)
+      {
+      case 17:
+        return 2;
+
+      default:
+        return 1;
+      }
+    }
+
+  }
+
+#if !defined(REALLY_CLANG)
+  namespace test_template_argument_deduction_for_class_templates
+  {
+
+    // TODO: test it with clang++ from git
+
+    template <typename T1, typename T2>
+    struct pair
+    {
+      pair (T1 p1, T2 p2)
+        : m1 {p1},
+          m2 {p2}
+      {}
+
+      T1 m1;
+      T2 m2;
+    };
+
+    void f()
+    {
+      maybe_unused auto p = pair{13, 42u};
+    }
+
+  }
+#endif // !defined(REALLY_CLANG)
+
+  namespace test_non_type_auto_template_parameters
+  {
+
+    template <auto n>
+    struct B
+    {};
+
+    B<5> b1;
+    B<'a'> b2;
+
+  }
+
+#if !defined(REALLY_CLANG)
+  namespace test_structured_bindings
+  {
+
+    // TODO: test it with clang++ from git
+
+    int arr2 = { 1, 2 };
+    std::pair<int, int> pr = { 1, 2 };
+
+    auto f1() -> int(&)2
+    {
+      return arr;
+    }
+
+    auto f2() -> std::pair<int, int>&
+    {
+      return pr;
+    }
+
+    struct S
+    {
+      int x1 : 2;
+      volatile double y1;
+    };
+
+    S f3()
+    {
+      return {};
+    }
+
+    auto  x1, y1  = f1();
+    auto&  xr1, yr1  = f1();
+    auto  x2, y2  = f2();
+    auto&  xr2, yr2  = f2();
+    const auto  x3, y3  = f3();
+
+  }
+#endif // !defined(REALLY_CLANG)
+
+#if !defined(REALLY_CLANG)
+  namespace test_exception_spec_type_system
+  {
+
+    // TODO: test it with clang++ from git
+
+    struct Good {};
+    struct Bad {};
+
+    void g1() noexcept;
+    void g2();
+
+    template<typename T>
+    Bad
+    f(T*, T*);
+
+    template<typename T1, typename T2>
+    Good
+    f(T1*, T2*);
+
+    static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+
+  }
+#endif // !defined(REALLY_CLANG)
+
+  namespace test_inline_variables
+  {
+
+    template<class T> void f(T)
+    {}
+
+    template<class T> inline T g(T)
+    {
+      return T{};
+    }
+
+    template<> inline void f<>(int)
+    {}
+
+    template<> int g<>(int)
+    {
+      return 5;
+    }
+
+  }
+
+}  // namespace cxx17
+
+#endif  // __cplusplus <= 201402L
+
+)

_service:tar_scm:isl-0.24.tar.gz/m4/ax_cxx_compile_stdcxx_11.m4 Added

@@ -0,0 +1,39 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11(ext|noext, mandatory|optional)
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXX and CXXCPP to enable
+#   support.
+#
+#   This macro is a convenience alias for calling the AX_CXX_COMPILE_STDCXX
+#   macro with the version set to C++11.  The two optional arguments are
+#   forwarded literally as the second and third argument respectively.
+#   Please see the documentation for the AX_CXX_COMPILE_STDCXX macro for
+#   more information.  If you want to use this macro, you also need to
+#   download the ax_cxx_compile_stdcxx.m4 file.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
+#   Copyright (c) 2015 Paul Norman <penorman@mac.com>
+#   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 17
+
+AX_REQUIRE_DEFINED(AX_CXX_COMPILE_STDCXX)
+AC_DEFUN(AX_CXX_COMPILE_STDCXX_11, AX_CXX_COMPILE_STDCXX(11, $1, $2))

_service:tar_scm:isl-0.24.tar.gz/m4/ax_cxx_compile_stdcxx_11_no_override.m4 Added

@@ -0,0 +1,37 @@
+# Check if $CXX does or can be made to support C++11 by adding switches.
+# If $CXX explicitly selects a language standard, then
+# refrain from overriding this choice.
+AC_DEFUN(AX_CXX_COMPILE_STDCXX_11_NO_OVERRIDE, dnl
+	AC_PROG_GREP
+	echo $CXX | $GREP -e "-std=" > /dev/null 2> /dev/null
+	if test $? -eq 0; then
+		_AX_CXX_COMPILE_STDCXX_11_DEFAULT
+	else
+		AX_CXX_COMPILE_STDCXX_11(noext, optional)
+	fi
+)
+
+# Check if $CXX supports C++11 by default (without adding switches).
+# This is a trimmed down version of AX_CXX_COMPILE_STDCXX_11
+# that reuses its _AX_CXX_COMPILE_STDCXX_testbody_11.
+AC_DEFUN(_AX_CXX_COMPILE_STDCXX_11_DEFAULT, dnl
+  AC_LANG_PUSH(C++)dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+  ax_cv_cxx_compile_cxx11,
+  AC_COMPILE_IFELSE(AC_LANG_SOURCE(_AX_CXX_COMPILE_STDCXX_testbody_11),
+    ax_cv_cxx_compile_cxx11=yes,
+    ax_cv_cxx_compile_cxx11=no))
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+  AC_LANG_POP(C++)
+  if test x$ac_success = xno; then
+    HAVE_CXX11=0
+  else
+    HAVE_CXX11=1
+    AC_DEFINE(HAVE_CXX11,1,
+              define if the compiler supports basic C++11 syntax)
+  fi
+  AC_SUBST(HAVE_CXX11)
+)

_service:tar_scm:isl-0.24.tar.gz/m4/ax_detect_clang.m4 Added

@@ -0,0 +1,246 @@
+AC_DEFUN(AX_DETECT_CLANG, 
+AC_SUBST(CLANG_CXXFLAGS)
+AC_SUBST(CLANG_LDFLAGS)
+AC_SUBST(CLANG_RFLAG)
+AC_SUBST(CLANG_LIBS)
+AC_PROG_GREP
+AC_PROG_SED
+if test "x$with_clang_prefix" != "x"; then
+	LLVM_CONFIG="$with_clang_prefix/bin/llvm-config"
+fi
+AC_PATH_PROG(LLVM_CONFIG, "llvm-config")
+if test -z "$LLVM_CONFIG" || test ! -x "$LLVM_CONFIG"; then
+	AC_MSG_ERROR(llvm-config not found)
+fi
+CLANG_CXXFLAGS=`$LLVM_CONFIG --cxxflags | \
+	$SED -e 's/-Wcovered-switch-default//;s/-gsplit-dwarf//'`
+CLANG_LDFLAGS=`$LLVM_CONFIG --ldflags`
+# Construct a -R argument for libtool.
+# This is needed in case some of the clang libraries are shared libraries.
+CLANG_RFLAG=`echo "$CLANG_LDFLAGS" | $SED -e 's/-L/-R/g'`
+targets=`$LLVM_CONFIG --targets-built`
+components="$targets asmparser bitreader support mc"
+# Link in option and frontendopenmp components when available
+# since they may be used by the clang libraries.
+for c in option frontendopenmp; do
+	$LLVM_CONFIG --components | $GREP $c > /dev/null 2> /dev/null
+	if test $? -eq 0; then
+		components="$components $c"
+	fi
+done
+CLANG_LIBS=`$LLVM_CONFIG --libs $components`
+systemlibs=`$LLVM_CONFIG --system-libs 2> /dev/null | tail -1`
+if test $? -eq 0; then
+	CLANG_LIBS="$CLANG_LIBS $systemlibs"
+fi
+CLANG_PREFIX=`$LLVM_CONFIG --prefix`
+AC_DEFINE_UNQUOTED(CLANG_PREFIX, "$CLANG_PREFIX", Clang installation prefix)
+
+# If $CLANG_PREFIX/bin/clang cannot find the standard include files,
+# then see if setting sysroot to `xcode-select -p`/SDKs/MacOSX.sdk helps.
+# This may be required on some versions of OS X since they lack /usr/include.
+# If so, set CLANG_SYSROOT accordingly.
+SAVE_CC="$CC"
+CC="$CLANG_PREFIX/bin/clang"
+AC_MSG_CHECKING(
+	whether $CLANG_PREFIX/bin/clang can find standard include files)
+found_header=no
+AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <stdio.h>, ),
+	found_header=yes)
+AC_MSG_RESULT($found_header)
+if test "x$found_header" != "xyes"; then
+	AC_CHECK_PROG(XCODE_SELECT, xcode-select, xcode-select, )
+	if test -z "$XCODE_SELECT"; then
+		AC_MSG_ERROR(Cannot find xcode-select)
+	fi
+	sysroot=`$XCODE_SELECT -p`/SDKs/MacOSX.sdk
+	SAVE_CPPFLAGS="$CPPFLAGS"
+	CPPFLAGS="$CPPFLAGS -isysroot $sysroot"
+	AC_MSG_CHECKING(
+		whether standard include files can be found with sysroot set)
+	found_header=no
+	AC_COMPILE_IFELSE(AC_LANG_PROGRAM(#include <stdio.h>, ),
+		found_header=yes)
+	AC_MSG_RESULT($found_header)
+	CPPFLAGS="$SAVE_CPPFLAGS"
+	if test "x$found_header" != "xyes"; then
+		AC_MSG_ERROR(Cannot find standard include files)
+	else
+		AC_DEFINE_UNQUOTED(CLANG_SYSROOT, "$sysroot",
+			Define to sysroot if needed)
+	fi
+fi
+CC="$SAVE_CC"
+
+AC_LANG_PUSH(C++)
+
+SAVE_CPPFLAGS="$CPPFLAGS"
+CPPFLAGS="$CLANG_CXXFLAGS -I$srcdir $CPPFLAGS"
+AC_CHECK_HEADER(clang/Basic/SourceLocation.h, ,
+	AC_ERROR(clang header file not found))
+AC_EGREP_HEADER(getDefaultTargetTriple, llvm/Support/Host.h, ,
+	AC_DEFINE(getDefaultTargetTriple, getHostTriple,
+	Define to getHostTriple for older versions of clang))
+AC_EGREP_HEADER(getExpansionLineNumber, clang/Basic/SourceLocation.h, ,
+	AC_DEFINE(getExpansionLineNumber, getInstantiationLineNumber,
+	Define to getInstantiationLineNumber for older versions of clang))
+AC_EGREP_HEADER(getImmediateExpansionRange, clang/Basic/SourceManager.h,
+	,
+	AC_DEFINE(getImmediateExpansionRange,
+	getImmediateInstantiationRange,
+	Define to getImmediateInstantiationRange for older versions of clang)
+)
+AC_EGREP_HEADER(DiagnosticsEngine, clang/Basic/Diagnostic.h, ,
+	AC_DEFINE(DiagnosticsEngine, Diagnostic,
+	Define to Diagnostic for older versions of clang))
+AC_EGREP_HEADER(ArrayRef, clang/Driver/Driver.h,
+	AC_DEFINE(USE_ARRAYREF, ,
+		Define if Driver::BuildCompilation takes ArrayRef)
+	AC_EGREP_HEADER(ArrayRef.*CommandLineArgs,
+		clang/Frontend/CompilerInvocation.h,
+		AC_DEFINE(CREATE_FROM_ARGS_TAKES_ARRAYREF, ,
+			Define if CompilerInvocation::CreateFromArgs takes
+			 ArrayRef)
+		)
+	)
+AC_EGREP_HEADER(CXXIsProduction, clang/Driver/Driver.h,
+	AC_DEFINE(HAVE_CXXISPRODUCTION, ,
+		Define if Driver constructor takes CXXIsProduction argument))
+AC_EGREP_HEADER( IsProduction, clang/Driver/Driver.h,
+	AC_DEFINE(HAVE_ISPRODUCTION, ,
+		Define if Driver constructor takes IsProduction argument))
+AC_TRY_COMPILE(#include <clang/Driver/Driver.h>, 
+	using namespace clang;
+	DiagnosticsEngine *Diags;
+	new driver::Driver("", "", "", *Diags);
+, AC_DEFINE(DRIVER_CTOR_TAKES_DEFAULTIMAGENAME, ,
+	      Define if Driver constructor takes default image name))
+AC_EGREP_HEADER(void HandleTopLevelDecl\(, clang/AST/ASTConsumer.h,
+	AC_DEFINE(HandleTopLevelDeclReturn, void,
+		   Return type of HandleTopLevelDeclReturn)
+	 AC_DEFINE(HandleTopLevelDeclContinue, ,
+		   Return type of HandleTopLevelDeclReturn),
+	AC_DEFINE(HandleTopLevelDeclReturn, bool,
+		   Return type of HandleTopLevelDeclReturn)
+	 AC_DEFINE(HandleTopLevelDeclContinue, true,
+		   Return type of HandleTopLevelDeclReturn))
+AC_CHECK_HEADER(clang/Basic/DiagnosticOptions.h,
+	AC_DEFINE(HAVE_BASIC_DIAGNOSTICOPTIONS_H, ,
+		   Define if clang/Basic/DiagnosticOptions.h exists))
+AC_CHECK_HEADER(clang/Lex/PreprocessorOptions.h,
+	AC_DEFINE(HAVE_LEX_PREPROCESSOROPTIONS_H, ,
+		   Define if clang/Lex/PreprocessorOptions.h exists), ,
+	#include <clang/Basic/LLVM.h>)
+AC_TRY_COMPILE(#include <clang/Basic/TargetInfo.h>, 
+	using namespace clang;
+	std::shared_ptr<TargetOptions> TO;
+	DiagnosticsEngine *Diags;
+	TargetInfo::CreateTargetInfo(*Diags, TO);
+, AC_DEFINE(CREATETARGETINFO_TAKES_SHARED_PTR, ,
+	      Define if TargetInfo::CreateTargetInfo takes shared_ptr))
+AC_TRY_COMPILE(#include <clang/Basic/TargetInfo.h>, 
+	using namespace clang;
+	TargetOptions *TO;
+	DiagnosticsEngine *Diags;
+	TargetInfo::CreateTargetInfo(*Diags, TO);
+, AC_DEFINE(CREATETARGETINFO_TAKES_POINTER, ,
+	      Define if TargetInfo::CreateTargetInfo takes pointer))
+AC_TRY_COMPILE(#include <clang/Frontend/CompilerInstance.h>, 
+	using namespace clang;
+	DiagnosticConsumer *client;
+	CompilerInstance *Clang;
+	Clang->createDiagnostics(client);
+, , AC_DEFINE(CREATEDIAGNOSTICS_TAKES_ARG, ,
+	Define if CompilerInstance::createDiagnostics takes argc and argv))
+AC_TRY_COMPILE(#include <clang/Lex/HeaderSearchOptions.h>, 
+	using namespace clang;
+	HeaderSearchOptions HSO;
+	HSO.AddPath("", frontend::Angled, false, false);
+, AC_DEFINE(ADDPATH_TAKES_4_ARGUMENTS, ,
+	Define if HeaderSearchOptions::AddPath takes 4 arguments))
+AC_EGREP_HEADER(getNumParams,
+	clang/AST/CanonicalType.h,
+	AC_DEFINE(getNumArgs, getNumParams,
+	    Define to getNumParams for newer versions of clang)
+	 AC_DEFINE(getArgType, getParamType,
+	    Define to getParamType for newer versions of clang))
+AC_EGREP_HEADER(getReturnType,
+	clang/AST/CanonicalType.h, ,
+	AC_DEFINE(getReturnType, getResultType,
+	    Define to getResultType for older versions of clang))
+AC_TRY_COMPILE(#include <clang/Frontend/CompilerInstance.h>, 
+	using namespace clang;
+	CompilerInstance *Clang;
+	Clang->createPreprocessor(TU_Complete);
+, AC_DEFINE(CREATEPREPROCESSOR_TAKES_TUKIND, ,
+Define if CompilerInstance::createPreprocessor takes TranslationUnitKind))
+AC_EGREP_HEADER(setMainFileID, clang/Basic/SourceManager.h,
+	AC_DEFINE(HAVE_SETMAINFILEID, ,
+	Define if SourceManager has a setMainFileID method))
+AC_CHECK_HEADER(llvm/ADT/OwningPtr.h,
+	AC_DEFINE(HAVE_ADT_OWNINGPTR_H, ,
+		   Define if llvm/ADT/OwningPtr.h exists))
+AC_EGREP_HEADER(initializeBuiltins,
+	clang/Basic/Builtins.h, ,
+	AC_DEFINE(initializeBuiltins, InitializeBuiltins,
+		Define to InitializeBuiltins for older versions of clang))
+AC_EGREP_HEADER(IK_C, clang/Frontend/FrontendOptions.h, ,
+	AC_CHECK_HEADER(clang/Basic/LangStandard.h,
+		IK_C=Language::C, IK_C=InputKind::C)
+	 AC_DEFINE_UNQUOTED(IK_C, $IK_C,
+	 Define to Language::C or InputKind::C for newer versions of clang)
+	)
+AC_TRY_COMPILE(
+	#include <clang/Basic/TargetOptions.h>
+	#include <clang/Lex/PreprocessorOptions.h>
+	#include <clang/Frontend/CompilerInstance.h>
+
+	#include "set_lang_defaults_arg4.h"
+, 
+	using namespace clang;
+	CompilerInstance *Clang;
+	TargetOptions TO;
+	llvm::Triple T(TO.Triple);
+	PreprocessorOptions PO;
+	CompilerInvocation::setLangDefaults(Clang->getLangOpts(), IK_C,
+			T, setLangDefaultsArg4(PO),
+			LangStandard::lang_unspecified);
+, AC_DEFINE(SETLANGDEFAULTS_TAKES_5_ARGUMENTS, ,
+	Define if CompilerInvocation::setLangDefaults takes 5 arguments))
+AC_TRY_COMPILE(
+	#include <clang/Frontend/CompilerInstance.h>
+	#include <clang/Frontend/CompilerInvocation.h>
+, 
+	using namespace clang;
+	CompilerInvocation *invocation;
+	CompilerInstance *Clang;
+	Clang->setInvocation(std::make_shared<CompilerInvocation>(*invocation));
+, AC_DEFINE(SETINVOCATION_TAKES_SHARED_PTR, ,
+	Defined if CompilerInstance::setInvocation takes a shared_ptr))
+AC_CHECK_HEADER(llvm/Option/Arg.h,
+	AC_DEFINE(HAVE_LLVM_OPTION_ARG_H, ,
+		   Define if llvm/Option/Arg.h exists))
+CPPFLAGS="$SAVE_CPPFLAGS"
+
+SAVE_LDFLAGS="$LDFLAGS"
+LDFLAGS="$CLANG_LDFLAGS $LDFLAGS"
+
+# Use single libclang-cpp shared library when available.
+# Otherwise, use a selection of clang libraries that appears to work.
+AC_CHECK_LIB(clang-cpp, main, have_lib_clang=yes, have_lib_clang=no)
+if test "$have_lib_clang" = yes; then
+	CLANG_LIBS="-lclang-cpp $CLANG_LIBS"
+else
+	CLANG_LIBS="-lclangBasic -lclangDriver $CLANG_LIBS"
+	CLANG_LIBS="-lclangAnalysis -lclangAST -lclangLex $CLANG_LIBS"
+	LDFLAGS="$CLANG_LDFLAGS $CLANG_LIBS $SAVE_LDFLAGS"
+	AC_CHECK_LIB(clangEdit, main, LIB_CLANG_EDIT=-lclangEdit, )
+	CLANG_LIBS="$LIB_CLANG_EDIT $CLANG_LIBS"
+	CLANG_LIBS="-lclangParse -lclangSema $CLANG_LIBS"
+	CLANG_LIBS="-lclangFrontend -lclangSerialization $CLANG_LIBS"
+fi
+
+LDFLAGS="$SAVE_LDFLAGS"
+
+AC_LANG_POP
+)

_service:tar_scm:isl-0.14.tar.xz/m4/ax_detect_gmp.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/ax_detect_gmp.m4 Changed

_service:tar_scm:isl-0.24.tar.gz/m4/ax_prog_cc_for_build.m4 Added

@@ -0,0 +1,145 @@
+# ===========================================================================
+#   https://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PROG_CC_FOR_BUILD
+#
+# DESCRIPTION
+#
+#   This macro searches for a C compiler that generates native executables,
+#   that is a C compiler that surely is not a cross-compiler. This can be
+#   useful if you have to generate source code at compile-time like for
+#   example GCC does.
+#
+#   The macro sets the CC_FOR_BUILD and CPP_FOR_BUILD macros to anything
+#   needed to compile or link (CC_FOR_BUILD) and preprocess (CPP_FOR_BUILD).
+#   The value of these variables can be overridden by the user by specifying
+#   a compiler with an environment variable (like you do for standard CC).
+#
+#   It also sets BUILD_EXEEXT and BUILD_OBJEXT to the executable and object
+#   file extensions for the build platform, and GCC_FOR_BUILD to `yes' if
+#   the compiler we found is GCC. All these variables but GCC_FOR_BUILD are
+#   substituted in the Makefile.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 18
+
+AU_ALIAS(AC_PROG_CC_FOR_BUILD, AX_PROG_CC_FOR_BUILD)
+AC_DEFUN(AX_PROG_CC_FOR_BUILD, dnl
+AC_REQUIRE(AC_PROG_CC)dnl
+AC_REQUIRE(AC_PROG_CPP)dnl
+AC_REQUIRE(AC_CANONICAL_BUILD)dnl
+
+dnl Use the standard macros, but make them use other variable names
+dnl
+pushdef(ac_cv_prog_CPP, ac_cv_build_prog_CPP)dnl
+pushdef(ac_cv_prog_cc_c89, ac_cv_build_prog_cc_c89)dnl
+pushdef(ac_cv_prog_gcc, ac_cv_build_prog_gcc)dnl
+pushdef(ac_cv_prog_cc_works, ac_cv_build_prog_cc_works)dnl
+pushdef(ac_cv_prog_cc_cross, ac_cv_build_prog_cc_cross)dnl
+pushdef(ac_cv_prog_cc_g, ac_cv_build_prog_cc_g)dnl
+pushdef(ac_cv_c_compiler_gnu, ac_cv_build_c_compiler_gnu)dnl
+pushdef(ac_cv_exeext, ac_cv_build_exeext)dnl
+pushdef(ac_cv_objext, ac_cv_build_objext)dnl
+pushdef(ac_exeext, ac_build_exeext)dnl
+pushdef(ac_objext, ac_build_objext)dnl
+pushdef(CC, CC_FOR_BUILD)dnl
+pushdef(CCDEPMODE, CCDEPMODE_FOR_BUILD)dnl
+pushdef(CPP, CPP_FOR_BUILD)dnl
+pushdef(GCC, GCC_FOR_BUILD)dnl
+pushdef(CFLAGS, CFLAGS_FOR_BUILD)dnl
+pushdef(CPPFLAGS, CPPFLAGS_FOR_BUILD)dnl
+pushdef(EXEEXT, BUILD_EXEEXT)dnl
+pushdef(LDFLAGS, LDFLAGS_FOR_BUILD)dnl
+pushdef(OBJEXT, BUILD_OBJEXT)dnl
+pushdef(host, build)dnl
+pushdef(host_alias, build_alias)dnl
+pushdef(host_cpu, build_cpu)dnl
+pushdef(host_vendor, build_vendor)dnl
+pushdef(host_os, build_os)dnl
+pushdef(ac_cv_host, ac_cv_build)dnl
+pushdef(ac_cv_host_alias, ac_cv_build_alias)dnl
+pushdef(ac_cv_host_cpu, ac_cv_build_cpu)dnl
+pushdef(ac_cv_host_vendor, ac_cv_build_vendor)dnl
+pushdef(ac_cv_host_os, ac_cv_build_os)dnl
+pushdef(ac_tool_prefix, ac_build_tool_prefix)dnl
+pushdef(am_cv_CC_dependencies_compiler_type, am_cv_build_CC_dependencies_compiler_type)dnl
+pushdef(am__fastdepCC_FALSE, am__fastdepCC_build_FALSE)dnl
+pushdef(am__fastdepCC_TRUE, am__fastdepCC_build_TRUE)dnl
+pushdef(am_cv_prog_cc_c_o, am_cv_build_prog_cc_c_o)dnl
+pushdef(cross_compiling, cross_compiling_build)dnl
+
+cross_compiling_build=no
+
+ac_build_tool_prefix=
+AS_IF(test -n "$build",      ac_build_tool_prefix="$build-",
+      test -n "$build_alias",ac_build_tool_prefix="$build_alias-")
+
+AC_LANG_PUSH(C)
+AC_PROG_CC
+_AC_COMPILER_EXEEXT
+_AC_COMPILER_OBJEXT
+AC_PROG_CPP
+
+dnl Restore the old definitions
+dnl
+popdef(cross_compiling)dnl
+popdef(am_cv_prog_cc_c_o)dnl
+popdef(am__fastdepCC_TRUE)dnl
+popdef(am__fastdepCC_FALSE)dnl
+popdef(am_cv_CC_dependencies_compiler_type)dnl
+popdef(ac_tool_prefix)dnl
+popdef(ac_cv_host_os)dnl
+popdef(ac_cv_host_vendor)dnl
+popdef(ac_cv_host_cpu)dnl
+popdef(ac_cv_host_alias)dnl
+popdef(ac_cv_host)dnl
+popdef(host_os)dnl
+popdef(host_vendor)dnl
+popdef(host_cpu)dnl
+popdef(host_alias)dnl
+popdef(host)dnl
+popdef(OBJEXT)dnl
+popdef(LDFLAGS)dnl
+popdef(EXEEXT)dnl
+popdef(CPPFLAGS)dnl
+popdef(CFLAGS)dnl
+popdef(GCC)dnl
+popdef(CPP)dnl
+popdef(CCDEPMODE)dnl
+popdef(CC)dnl
+popdef(ac_objext)dnl
+popdef(ac_exeext)dnl
+popdef(ac_cv_objext)dnl
+popdef(ac_cv_exeext)dnl
+popdef(ac_cv_c_compiler_gnu)dnl
+popdef(ac_cv_prog_cc_g)dnl
+popdef(ac_cv_prog_cc_cross)dnl
+popdef(ac_cv_prog_cc_works)dnl
+popdef(ac_cv_prog_cc_c89)dnl
+popdef(ac_cv_prog_gcc)dnl
+popdef(ac_cv_prog_CPP)dnl
+
+dnl restore global variables ac_ext, ac_cpp, ac_compile,
+dnl ac_link, ac_compiler_gnu (dependant on the current
+dnl language after popping):
+AC_LANG_POP(C)
+
+dnl Finally, set Makefile variables
+dnl
+AC_SUBST(BUILD_EXEEXT)dnl
+AC_SUBST(BUILD_OBJEXT)dnl
+AC_SUBST(CFLAGS_FOR_BUILD)dnl
+AC_SUBST(CPPFLAGS_FOR_BUILD)dnl
+AC_SUBST(LDFLAGS_FOR_BUILD)dnl
+)

_service:tar_scm:isl-0.24.tar.gz/m4/ax_prog_cxx_for_build.m4 Added

@@ -0,0 +1,110 @@
+# ===========================================================================
+#  https://www.gnu.org/software/autoconf-archive/ax_prog_cxx_for_build.html
+# ===========================================================================
+#
+# SYNOPSIS
+#
+#   AX_PROG_CXX_FOR_BUILD
+#
+# DESCRIPTION
+#
+#   This macro searches for a C++ compiler that generates native
+#   executables, that is a C++ compiler that surely is not a cross-compiler.
+#   This can be useful if you have to generate source code at compile-time
+#   like for example GCC does.
+#
+#   The macro sets the CXX_FOR_BUILD and CXXCPP_FOR_BUILD macros to anything
+#   needed to compile or link (CXX_FOR_BUILD) and preprocess
+#   (CXXCPP_FOR_BUILD). The value of these variables can be overridden by
+#   the user by specifying a compiler with an environment variable (like you
+#   do for standard CXX).
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Paolo Bonzini <bonzini@gnu.org>
+#   Copyright (c) 2012 Avionic Design GmbH
+#
+#   Based on the AX_PROG_CC_FOR_BUILD macro by Paolo Bonzini.
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 3
+
+AU_ALIAS(AC_PROG_CXX_FOR_BUILD, AX_PROG_CXX_FOR_BUILD)
+AC_DEFUN(AX_PROG_CXX_FOR_BUILD, dnl
+AC_REQUIRE(AX_PROG_CC_FOR_BUILD)dnl
+AC_REQUIRE(AC_PROG_CXX)dnl
+AC_REQUIRE(AC_PROG_CXXCPP)dnl
+AC_REQUIRE(AC_CANONICAL_HOST)dnl
+
+dnl Use the standard macros, but make them use other variable names
+dnl
+pushdef(ac_cv_prog_CXXCPP, ac_cv_build_prog_CXXCPP)dnl
+pushdef(ac_cv_prog_gxx, ac_cv_build_prog_gxx)dnl
+pushdef(ac_cv_prog_cxx_works, ac_cv_build_prog_cxx_works)dnl
+pushdef(ac_cv_prog_cxx_cross, ac_cv_build_prog_cxx_cross)dnl
+pushdef(ac_cv_prog_cxx_g, ac_cv_build_prog_cxx_g)dnl
+pushdef(CXX, CXX_FOR_BUILD)dnl
+pushdef(CXXCPP, CXXCPP_FOR_BUILD)dnl
+pushdef(CXXFLAGS, CXXFLAGS_FOR_BUILD)dnl
+pushdef(CPPFLAGS, CPPFLAGS_FOR_BUILD)dnl
+pushdef(CXXCPPFLAGS, CXXCPPFLAGS_FOR_BUILD)dnl
+pushdef(host, build)dnl
+pushdef(host_alias, build_alias)dnl
+pushdef(host_cpu, build_cpu)dnl
+pushdef(host_vendor, build_vendor)dnl
+pushdef(host_os, build_os)dnl
+pushdef(ac_cv_host, ac_cv_build)dnl
+pushdef(ac_cv_host_alias, ac_cv_build_alias)dnl
+pushdef(ac_cv_host_cpu, ac_cv_build_cpu)dnl
+pushdef(ac_cv_host_vendor, ac_cv_build_vendor)dnl
+pushdef(ac_cv_host_os, ac_cv_build_os)dnl
+pushdef(ac_cxxcpp, ac_build_cxxcpp)dnl
+pushdef(ac_compile, ac_build_compile)dnl
+pushdef(ac_link, ac_build_link)dnl
+
+save_cross_compiling=$cross_compiling
+save_ac_tool_prefix=$ac_tool_prefix
+cross_compiling=no
+ac_tool_prefix=
+
+AC_PROG_CXX
+AC_PROG_CXXCPP
+
+ac_tool_prefix=$save_ac_tool_prefix
+cross_compiling=$save_cross_compiling
+
+dnl Restore the old definitions
+dnl
+popdef(ac_link)dnl
+popdef(ac_compile)dnl
+popdef(ac_cxxcpp)dnl
+popdef(ac_cv_host_os)dnl
+popdef(ac_cv_host_vendor)dnl
+popdef(ac_cv_host_cpu)dnl
+popdef(ac_cv_host_alias)dnl
+popdef(ac_cv_host)dnl
+popdef(host_os)dnl
+popdef(host_vendor)dnl
+popdef(host_cpu)dnl
+popdef(host_alias)dnl
+popdef(host)dnl
+popdef(CXXCPPFLAGS)dnl
+popdef(CPPFLAGS)dnl
+popdef(CXXFLAGS)dnl
+popdef(CXXCPP)dnl
+popdef(CXX)dnl
+popdef(ac_cv_prog_cxx_g)dnl
+popdef(ac_cv_prog_cxx_cross)dnl
+popdef(ac_cv_prog_cxx_works)dnl
+popdef(ac_cv_prog_gxx)dnl
+popdef(ac_cv_prog_CXXCPP)dnl
+
+dnl Finally, set Makefile variables
+dnl
+AC_SUBST(CXXFLAGS_FOR_BUILD)dnl
+AC_SUBST(CXXCPPFLAGS_FOR_BUILD)dnl
+)

_service:tar_scm:isl-0.14.tar.xz/m4/libtool.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/libtool.m4 Changed

@@ -1,6 +1,6 @@
 # libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
 #
-#   Copyright (C) 1996-2001, 2003-2013 Free Software Foundation, Inc.
+#   Copyright (C) 1996-2001, 2003-2015 Free Software Foundation, Inc.
 #   Written by Gordon Matzigkeit, 1996
 #
 # This file is free software; the Free Software Foundation gives
@@ -8,33 +8,27 @@
 # modifications, as long as this notice is preserved.
 
 m4_define(_LT_COPYING, dnl
-#   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
-#                 2006, 2007, 2008, 2009, 2010, 2011 Free Software
-#                 Foundation, Inc.
-#   Written by Gordon Matzigkeit, 1996
-#
-#   This file is part of GNU Libtool.
-#
-# GNU Libtool is free software; you can redistribute it and/or
-# modify it under the terms of the GNU General Public License as
-# published by the Free Software Foundation; either version 2 of
-# the License, or (at your option) any later version.
+# Copyright (C) 2014 Free Software Foundation, Inc.
+# This is free software; see the source for copying conditions.  There is NO
+# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+
+# GNU Libtool is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of of the License, or
+# (at your option) any later version.
 #
-# As a special exception to the GNU General Public License,
-# if you distribute this file as part of a program or library that
-# is built using GNU Libtool, you may include this file under the
-# same distribution terms that you use for the rest of that program.
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program or library that is built
+# using GNU Libtool, you may include this file under the  same
+# distribution terms that you use for the rest of that program.
 #
-# GNU Libtool is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# GNU Libtool is distributed in the hope that it will be useful, but
+# WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with GNU Libtool; see the file COPYING.  If not, a copy
-# can be downloaded from http://www.gnu.org/licenses/gpl.html, or
-# obtained by writing to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 )
 
 # serial 58 LT_INIT
@@ -65,7 +59,7 @@
 # LT_INIT(OPTIONS)
 # ------------------
 AC_DEFUN(LT_INIT,
-AC_PREREQ(2.58)dnl We use AC_INCLUDES_DEFAULT
+AC_PREREQ(2.62)dnl We use AC_PATH_PROGS_FEATURE_CHECK
 AC_REQUIRE(AC_CONFIG_AUX_DIR_DEFAULT)dnl
 AC_BEFORE($0, LT_LANG)dnl
 AC_BEFORE($0, LT_OUTPUT)dnl
@@ -109,19 +103,36 @@
 dnl AC_DEFUN(AM_PROG_LIBTOOL, )
 
 
+# _LT_PREPARE_CC_BASENAME
+# -----------------------
+m4_defun(_LT_PREPARE_CC_BASENAME, 
+# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+func_cc_basename ()
+{
+    for cc_temp in @S|@*""; do
+      case $cc_temp in
+        compile | *\\/compile | ccache | *\\/ccache ) ;;
+        distcc | *\\/distcc | purify | *\\/purify ) ;;
+        \-*) ;;
+        *) break;;
+      esac
+    done
+    func_cc_basename_result=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+}
+)# _LT_PREPARE_CC_BASENAME
+
+
 # _LT_CC_BASENAME(CC)
 # -------------------
-# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
+# It would be clearer to call AC_REQUIREs from _LT_PREPARE_CC_BASENAME,
+# but that macro is also expanded into generated libtool script, which
+# arranges for $SED and $ECHO to be set by different means.
 m4_defun(_LT_CC_BASENAME,
-for cc_temp in $1""; do
-  case $cc_temp in
-    compile | *\\/compile | ccache | *\\/ccache ) ;;
-    distcc | *\\/distcc | purify | *\\/purify ) ;;
-    \-*) ;;
-    *) break;;
-  esac
-done
-cc_basename=`$ECHO "$cc_temp" | $SED "s%.*/%%; s%^$host_alias-%%"`
+m4_require(_LT_PREPARE_CC_BASENAME)dnl
+AC_REQUIRE(_LT_DECL_SED)dnl
+AC_REQUIRE(_LT_PROG_ECHO_BACKSLASH)dnl
+func_cc_basename $1
+cc_basename=$func_cc_basename_result
 )
 
 
@@ -175,6 +186,7 @@
 m4_require(_LT_CMD_OLD_ARCHIVE)dnl
 m4_require(_LT_CMD_GLOBAL_SYMBOLS)dnl
 m4_require(_LT_WITH_SYSROOT)dnl
+m4_require(_LT_CMD_TRUNCATE)dnl
 
 _LT_CONFIG_LIBTOOL_INIT(
 # See if we are running on zsh, and set the options that allow our
@@ -715,15 +727,18 @@
 
     cat <<_LT_EOF >> "$cfgfile"
 #! $SHELL
-
-# `$ECHO "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
 # Generated automatically by $as_me ($PACKAGE) $VERSION
-# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
-#
+
+# Provide generalized library-building support services.
+# Written by Gordon Matzigkeit, 1996
+
 _LT_COPYING
 _LT_LIBTOOL_TAGS
 
+# Configured defaults for sys_lib_dlsearch_path munging.
+: \${LT_SYS_LIBRARY_PATH="$configure_time_lt_sys_library_path"}
+
 # ### BEGIN LIBTOOL CONFIG
 _LT_LIBTOOL_CONFIG_VARS
 _LT_LIBTOOL_TAG_VARS
@@ -731,6 +746,17 @@
 
 _LT_EOF
 
+    cat <<'_LT_EOF' >> "$cfgfile"
+
+# ### BEGIN FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_PREPARE_MUNGE_PATH_LIST
+_LT_PREPARE_CC_BASENAME
+
+# ### END FUNCTIONS SHARED WITH CONFIGURE
+
+_LT_EOF
+
   case $host_os in
   aix3*)
     cat <<\_LT_EOF >> "$cfgfile"
@@ -1015,8 +1041,8 @@
 _LT_EOF
       echo "$LTCC $LTCFLAGS -c -o conftest.o conftest.c" >&AS_MESSAGE_LOG_FD
       $LTCC $LTCFLAGS -c -o conftest.o conftest.c 2>&AS_MESSAGE_LOG_FD
-      echo "$AR cru libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
-      $AR cru libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
+      echo "$AR cr libconftest.a conftest.o" >&AS_MESSAGE_LOG_FD
+      $AR cr libconftest.a conftest.o 2>&AS_MESSAGE_LOG_FD
       echo "$RANLIB libconftest.a" >&AS_MESSAGE_LOG_FD
       $RANLIB libconftest.a 2>&AS_MESSAGE_LOG_FD
       cat > conftest.c << _LT_EOF
@@ -1047,7 +1073,7 @@
       case ${MACOSX_DEPLOYMENT_TARGET-10.0},$host in
 	10.0,*86*-darwin8*|10.0,*-darwin91*)
 	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
-	10.012*)
+	10.012,.*)
 	  _lt_dar_allow_undefined='$wl-flat_namespace $wl-undefined ${wl}suppress' ;;
 	10.*)
 	  _lt_dar_allow_undefined='$wl-undefined ${wl}dynamic_lookup' ;;
@@ -1466,7 +1492,7 @@
 m4_defun(_LT_PROG_AR,
 AC_CHECK_TOOLS(AR, ar, false)
 : ${AR=ar}
-: ${AR_FLAGS=cru}
+: ${AR_FLAGS=cr}
 _LT_DECL(, AR, 1, The archiver)
 _LT_DECL(, AR_FLAGS, 1, Flags to create an archive)
 
@@ -1844,7 +1870,7 @@
 #  endif
 #endif
 
-/* When -fvisbility=hidden is used, assume the code has been annotated
+/* When -fvisibility=hidden is used, assume the code has been annotated
    correspondingly for the symbols needed.  */
 #if defined __GNUC__ && (((__GNUC__ == 3) && (__GNUC_MINOR__ >= 3)) || (__GNUC__ > 3))
 int fnord () __attribute__((visibility("default")));
@@ -2206,6 +2232,47 @@
 )# _LT_CMD_STRIPLIB
 
 
+# _LT_PREPARE_MUNGE_PATH_LIST
+# ---------------------------
+# Make sure func_munge_path_list() is defined correctly.
+m4_defun(_LT_PREPARE_MUNGE_PATH_LIST,
+# func_munge_path_list VARIABLE PATH
+# -----------------------------------
+# VARIABLE is name of variable containing _space_ separated list of
+# directories to be munged by the contents of PATH, which is string
+# having a format:
+# "DIR:DIR:"
+#       string "DIR DIR" will be prepended to VARIABLE
+# ":DIR:DIR"
+#       string "DIR DIR" will be appended to VARIABLE
+# "DIRP:DIRP::DIRA:DIRA"
+#       string "DIRP DIRP" will be prepended to VARIABLE and string
+#       "DIRA DIRA" will be appended to VARIABLE
+# "DIR:DIR"
+#       VARIABLE will be replaced by "DIR DIR"
+func_munge_path_list ()
+{
+    case x@S|@2 in
+    x)
+        ;;
+    *:)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'` \@S|@@S|@1\"
+        ;;
+    x:*)
+        eval @S|@1=\"\@S|@@S|@1 `$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    *::*)
+        eval @S|@1=\"\@S|@@S|@1\ `$ECHO @S|@2 | $SED -e 's/.*:://' -e 's/:/ /g'`\"
+        eval @S|@1=\"`$ECHO @S|@2 | $SED -e 's/::.*//' -e 's/:/ /g'`\ \@S|@@S|@1\"
+        ;;
+    *)
+        eval @S|@1=\"`$ECHO @S|@2 | $SED 's/:/ /g'`\"
+        ;;
+    esac
+}
+)# _LT_PREPARE_PATH_LIST
+
+
 # _LT_SYS_DYNAMIC_LINKER(TAG)
 # -----------------------------
 # PORTME Fill in your ld.so characteristics
@@ -2216,6 +2283,7 @@
 m4_require(_LT_DECL_OBJDUMP)dnl
 m4_require(_LT_DECL_SED)dnl
 m4_require(_LT_CHECK_SHELL_FEATURES)dnl
+m4_require(_LT_PREPARE_MUNGE_PATH_LIST)dnl
 AC_MSG_CHECKING(dynamic linker characteristics)
 m4_if($1,
 	, 
@@ -2310,6 +2378,9 @@
 # flags to be left without arguments
 need_version=unknown
 
+AC_ARG_VAR(LT_SYS_LIBRARY_PATH,
+User-defined run-time library search path.)
+
 case $host_os in
 aix3*)
   version_type=linux # correct to gnu/linux during the next big refactor
@@ -2346,20 +2417,70 @@
       fi
       ;;
     esac
+    # Using Import Files as archive members, it is possible to support
+    # filename-based versioning of shared library archives on AIX. While
+    # this would work for both with and without runtime linking, it will
+    # prevent static linking of such archives. So we do filename-based
+    # shared library versioning with .so extension only, which is used
+    # when both runtime linking and shared linking is enabled.
+    # Unfortunately, runtime linking may impact performance, so we do
+    # not want this to be the default eventually. Also, we use the
+    # versioned .so libs for executables only if there is the -brtl
+    # linker flag in LDFLAGS as well, or --with-aix-soname=svr4 only.
+    # To allow for filename-based versioning support, we need to create
+    # libNAME.so.V as an archive file, containing:
+    # *) an Import File, referring to the versioned filename of the
+    #    archive as well as the shared archive member, telling the
+    #    bitwidth (32 or 64) of that shared object, and providing the
+    #    list of exported symbols of that shared object, eventually
+    #    decorated with the 'weak' keyword
+    # *) the shared object with the F_LOADONLY flag set, to really avoid
+    #    it being seen by the linker.
+    # At run time we better use the real file rather than another symlink,
+    # but for link time we create the symlink libNAME.so -> libNAME.so.V
+
+    case $with_aix_soname,$aix_use_runtimelinking in
     # AIX (on Power*) has no versioning support, so currently we cannot hardcode correct
     # soname into executable. Probably we can add versioning support to
     # collect2, so additional links can be useful in future.
-    if test yes = "$aix_use_runtimelinking"; then
+    aix,yes) # traditional libtool
+      dynamic_linker='AIX unversionable lib.so'
       # If using run time linking (on AIX 4.2 or later) use lib<name>.so
       # instead of lib<name>.a to let people know that these are not
       # typical AIX shared libraries.
       library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
-    else
+      ;;
+    aix,no) # traditional AIX only
+      dynamic_linker='AIX lib.a(lib.so.V)'
       # We preserve .a as extension for shared libraries through AIX4.2
       # and later when we are not doing run time linking.
       library_names_spec='$libname$release.a $libname.a'
       soname_spec='$libname$release$shared_ext$major'
-    fi
+      ;;
+    svr4,*) # full svr4 only
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,yes) # both, prefer svr4
+      dynamic_linker="AIX lib.so.V($shared_archive_member_spec.o), lib.a(lib.so.V)"
+      library_names_spec='$libname$release$shared_ext$major $libname$shared_ext'
+      # unpreferred sharedlib libNAME.a needs extra handling
+      postinstall_cmds='test -n "$linkname" || linkname="$realname"~func_stripname "" ".so" "$linkname"~$install_shared_prog "$dir/$func_stripname_result.$libext" "$destdir/$func_stripname_result.$libext"~test -z "$tstripme" || test -z "$striplib" || $striplib "$destdir/$func_stripname_result.$libext"'
+      postuninstall_cmds='for n in $library_names $old_library; do :; done~func_stripname "" ".so" "$n"~test "$func_stripname_result" = "$n" || func_append rmfiles " $odir/$func_stripname_result.$libext"'
+      # We do not specify a path in Import Files, so LIBPATH fires.
+      shlibpath_overrides_runpath=yes
+      ;;
+    *,no) # both, prefer aix
+      dynamic_linker="AIX lib.a(lib.so.V), lib.so.V($shared_archive_member_spec.o)"
+      library_names_spec='$libname$release.a $libname.a'
+      soname_spec='$libname$release$shared_ext$major'
+      # unpreferred sharedlib libNAME.so.V and symlink libNAME.so need extra handling
+      postinstall_cmds='test -z "$dlname" || $install_shared_prog $dir/$dlname $destdir/$dlname~test -z "$tstripme" || test -z "$striplib" || $striplib $destdir/$dlname~test -n "$linkname" || linkname=$realname~func_stripname "" ".a" "$linkname"~(cd "$destdir" && $LN_S -f $dlname $func_stripname_result.so)'
+      postuninstall_cmds='test -z "$dlname" || func_append rmfiles " $odir/$dlname"~for n in $old_library $library_names; do :; done~func_stripname "" ".a" "$n"~func_append rmfiles " $odir/$func_stripname_result.so"'
+      ;;
+    esac
     shlibpath_var=LIBPATH
   fi
   ;;
@@ -2547,7 +2668,8 @@
   version_type=freebsd-$objformat
   case $version_type in
     freebsd-elf*)
-      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
+      library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext$major $libname$shared_ext'
+      soname_spec='$libname$release$shared_ext$major'
       need_version=no
       need_lib_prefix=no
       ;;
@@ -2607,10 +2729,11 @@
     soname_spec='$libname$release$shared_ext$major'
     if test 32 = "$HPUX_IA64_MODE"; then
       sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux32
     else
       sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
+      sys_lib_dlsearch_path_spec=/usr/lib/hpux64
     fi
-    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
     ;;
   hppa*64*)
     shrext_cmds='.sl'
@@ -2743,7 +2866,12 @@
   # before this can be enabled.
   hardcode_into_libs=yes
 
-  # Append ld.so.conf contents to the search path
+  # Ideally, we could use ldconfig to report *all* directores which are
+  # searched for libraries, however this is still not possible.  Aside from not
+  # being certain /sbin/ldconfig is available, command
+  # 'ldconfig -N -X -v | grep ^/' on 64bit Fedora does not report /usr/lib64,
+  # even though it is searched at run-time.  Try to do the best guess by
+  # appending ld.so.conf contents (and includes) to the search path.
   if test -f /etc/ld.so.conf; then
     lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s 2>/dev/null", \$2)); skip = 1; } { if (!skip) print \$0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;/^	 *hwcap	 /d;s/:,	/ /g;s/=^=*$//;s/=^= * / /g;s/"//g;/^$/d' | tr '\n' ' '`
     sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
@@ -2758,6 +2886,18 @@
   dynamic_linker='GNU/Linux ld.so'
   ;;
 
+netbsdelf*-gnu)
+  version_type=linux
+  need_lib_prefix=no
+  need_version=no
+  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
+  soname_spec='${libname}${release}${shared_ext}$major'
+  shlibpath_var=LD_LIBRARY_PATH
+  shlibpath_overrides_runpath=no
+  hardcode_into_libs=yes
+  dynamic_linker='NetBSD ld.elf_so'
+  ;;
+
 netbsd*)
   version_type=sunos
   need_lib_prefix=no
@@ -2812,11 +2952,32 @@
 
 os2*)
   libname_spec='$name'
+  version_type=windows
   shrext_cmds=.dll
+  need_version=no
   need_lib_prefix=no
-  library_names_spec='$libname$shared_ext $libname.a'
+  # OS/2 can only load a DLL with a base name of 8 characters or less.
+  soname_spec='`test -n "$os2dllname" && libname="$os2dllname";
+    v=$($ECHO $release$versuffix | tr -d .-);
+    n=$($ECHO $libname | cut -b -$((8 - ${#v})) | tr . _);
+    $ECHO $n$v`$shared_ext'
+  library_names_spec='${libname}_dll.$libext'
   dynamic_linker='OS/2 ld.exe'
-  shlibpath_var=LIBPATH
+  shlibpath_var=BEGINLIBPATH
+  sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
+  sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
+  postinstall_cmds='base_file=`basename \$file`~
+    dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\$base_file'\''i; $ECHO \$dlname'\''`~
+    dldir=$destdir/`dirname \$dlpath`~
+    test -d \$dldir || mkdir -p \$dldir~
+    $install_prog $dir/$dlname \$dldir/$dlname~
+    chmod a+x \$dldir/$dlname~
+    if test -n '\''$stripme'\'' && test -n '\''$striplib'\''; then
+      eval '\''$striplib \$dldir/$dlname'\'' || exit \$?;
+    fi'
+  postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; $ECHO \$dlname'\''`~
+    dlpath=$dir/\$dldll~
+    $RM \$dlpath'
   ;;
 
 osf3* | osf4* | osf5*)
@@ -2892,7 +3053,7 @@
   ;;
 
 sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
-  version_type=freebsd-elf
+  version_type=sco
   need_lib_prefix=no
   need_version=no
   library_names_spec='$libname$release$shared_ext$versuffix $libname$release$shared_ext $libname$shared_ext'
@@ -2946,10 +3107,20 @@
 if test set = "${lt_cv_sys_lib_search_path_spec+set}"; then
   sys_lib_search_path_spec=$lt_cv_sys_lib_search_path_spec
 fi
+
 if test set = "${lt_cv_sys_lib_dlsearch_path_spec+set}"; then
   sys_lib_dlsearch_path_spec=$lt_cv_sys_lib_dlsearch_path_spec
 fi
 
+# remember unaugmented sys_lib_dlsearch_path content for libtool script decls...
+configure_time_dlsearch_path=$sys_lib_dlsearch_path_spec
+
+# ... but it needs LT_SYS_LIBRARY_PATH munging for other configure-time code
+func_munge_path_list sys_lib_dlsearch_path_spec "$LT_SYS_LIBRARY_PATH"
+
+# to be used as default LT_SYS_LIBRARY_PATH value in generated libtool
+configure_time_lt_sys_library_path=$LT_SYS_LIBRARY_PATH
+
 _LT_DECL(, variables_saved_for_relink, 1,
     Variables whose values should be saved in libtool wrapper scripts and
     restored at link time)
@@ -2982,8 +3153,10 @@
     Whether we should hardcode library paths into libraries)
 _LT_DECL(, sys_lib_search_path_spec, 2,
     Compile-time system search path for libraries)
-_LT_DECL(, sys_lib_dlsearch_path_spec, 2,
-    Run-time system search path for libraries)
+_LT_DECL(sys_lib_dlsearch_path_spec, configure_time_dlsearch_path, 2,
+    Detected run-time system search path for libraries)
+_LT_DECL(, configure_time_lt_sys_library_path, 2,
+    Explicit LT_SYS_LIBRARY_PATH set during ./configure time)
 )# _LT_SYS_DYNAMIC_LINKER
 
 
@@ -3221,6 +3394,43 @@
 )# _LT_CMD_RELOAD
 
 
+# _LT_PATH_DD
+# -----------
+# find a working dd
+m4_defun(_LT_PATH_DD,
+AC_CACHE_CHECK(for a working dd, ac_cv_path_lt_DD,
+printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+: ${lt_DD:=$DD}
+AC_PATH_PROGS_FEATURE_CHECK(lt_DD, dd,
+if "$ac_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && ac_cv_path_lt_DD="$ac_path_lt_DD" ac_path_lt_DD_found=:
+fi)
+rm -f conftest.i conftest2.i conftest.out)
+)# _LT_PATH_DD
+
+
+# _LT_CMD_TRUNCATE
+# ----------------
+# find command to truncate a binary pipe
+m4_defun(_LT_CMD_TRUNCATE,
+m4_require(_LT_PATH_DD)
+AC_CACHE_CHECK(how to truncate binary pipes, lt_cv_truncate_bin,
+printf 0123456789abcdef0123456789abcdef >conftest.i
+cat conftest.i conftest.i >conftest2.i
+lt_cv_truncate_bin=
+if "$ac_cv_path_lt_DD" bs=32 count=1 <conftest2.i >conftest.out 2>/dev/null; then
+  cmp -s conftest.i conftest.out \
+  && lt_cv_truncate_bin="$ac_cv_path_lt_DD bs=4096 count=1"
+fi
+rm -f conftest.i conftest2.i conftest.out
+test -z "$lt_cv_truncate_bin" && lt_cv_truncate_bin="$SED -e 4q")
+_LT_DECL(lt_truncate_bin, lt_cv_truncate_bin, 1,
+  Command to truncate a binary pipe)
+)# _LT_CMD_TRUNCATE
+
+
 # _LT_CHECK_MAGIC_METHOD
 # ----------------------
 # how to check for library dependencies
@@ -3347,7 +3557,7 @@
   lt_cv_deplibs_check_method=pass_all
   ;;
 
-netbsd*)
+netbsd* | netbsdelf*-gnu)
   if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
     lt_cv_deplibs_check_method='match_pattern /lib^/+(\.so\.0-9+\.0-9+|_pic\.a)$'
   else
@@ -3419,6 +3629,9 @@
 tpf*)
   lt_cv_deplibs_check_method=pass_all
   ;;
+os2*)
+  lt_cv_deplibs_check_method=pass_all
+  ;;
 esac
 )
 
@@ -3476,8 +3689,13 @@
 	# Adding the 'sed 1q' prevents false positives on HP-UX, which says:
 	#   nm: unknown option "B" ignored
 	# Tru64's nm complains that /dev/null is an invalid object file
-	case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
-	*/dev/null* | *'Invalid file or object type'*)
+	# MSYS converts /dev/null to NUL, MinGW nm treats NUL as empty
+	case $build_os in
+	mingw*) lt_bad_file=conftest.nm/nofile ;;
+	*) lt_bad_file=/dev/null ;;
+	esac
+	case `"$tmp_nm" -B $lt_bad_file 2>&1 | sed '1q'` in
+	*$lt_bad_file* | *'Invalid file or object type'*)
 	  lt_cv_path_NM="$tmp_nm -B"
 	  break 2
 	  ;;
@@ -3845,7 +4063,8 @@
   if AC_TRY_EVAL(ac_compile); then
     # Now try to grab the symbols.
     nlist=conftest.nm
-    if AC_TRY_EVAL(NM conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist) && test -s "$nlist"; then
+    $ECHO "$as_me:$LINENO: $NM conftest.$ac_objext | $lt_cv_sys_global_symbol_pipe > $nlist" >&AS_MESSAGE_LOG_FD
+    if eval "$NM" conftest.$ac_objext \| "$lt_cv_sys_global_symbol_pipe" \> $nlist 2>&AS_MESSAGE_LOG_FD && test -s "$nlist"; then
       # Try sorting and uniquifying the output.
       if sort "$nlist" | uniq > "$nlist"T; then
 	mv -f "$nlist"T "$nlist"
@@ -4022,6 +4241,11 @@
       # (--disable-auto-import) libraries
       m4_if($1, GCJ, ,
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT')
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
     darwin* | rhapsody*)
       # PIC is the default on this platform
@@ -4212,7 +4436,7 @@
 	    ;;
 	esac
 	;;
-      netbsd*)
+      netbsd* | netbsdelf*-gnu)
 	;;
       *qnx* | *nto*)
         # QNX uses GNU C++, but need to define -shared option too, otherwise
@@ -4341,6 +4565,11 @@
       # (--disable-auto-import) libraries
       m4_if($1, GCJ, ,
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT')
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
 
     darwin* | rhapsody*)
@@ -4438,6 +4667,11 @@
       # built for inclusion in a dll (and should export symbols for example).
       m4_if($1, GCJ, ,
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT')
+      case $host_os in
+      os2*)
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='$wl-static'
+	;;
+      esac
       ;;
 
     hpux9* | hpux10* | hpux11*)
@@ -4470,6 +4704,12 @@
 	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
 	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
         ;;
+      # flang / f18. f95 an alias for gfortran or flang on Debian
+      flang* | f18* | f95*)
+	_LT_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
+	_LT_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
+	_LT_TAGVAR(lt_prog_compiler_static, $1)='-static'
+        ;;
       # icc used to be incompatible with GCC.
       # ICC 10 doesn't accept -KPIC any more.
       icc* | ifort*)
@@ -4687,13 +4927,17 @@
   case $host_os in
   aix4-9*)
     # If we're using GNU nm, then we don't want the "-C" option.
-    # -C means demangle to AIX nm, but means don't demangle with GNU nm
-    # Also, AIX nm treats weak defined symbols like other global defined
-    # symbols, whereas GNU nm marks them as "W".
+    # -C means demangle to GNU nm, but means don't demangle to AIX nm.
+    # Without the "-l" option, or with the "-B" option, AIX nm treats
+    # weak defined symbols like other global defined symbols, whereas
+    # GNU nm marks them as "W".
+    # While the 'weak' keyword is ignored in the Export File, we need
+    # it in the Import File for the 'aix-soname' feature, so we have
+    # to replace the "-B" option with "-P" for AIX nm.
     if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
     else
-      _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+      _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
     fi
     ;;
   pw32*)
@@ -4710,6 +4954,9 @@
       ;;
     esac
     ;;
+  linux* | k*bsd*-gnu | gnu*)
+    _LT_TAGVAR(link_all_deplibs, $1)=no
+    ;;
   *)
     _LT_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
     ;;
@@ -4772,6 +5019,9 @@
   openbsd* | bitrig*)
     with_gnu_ld=no
     ;;
+  linux* | k*bsd*-gnu | gnu*)
+    _LT_TAGVAR(link_all_deplibs, $1)=no
+    ;;
   esac
 
   _LT_TAGVAR(ld_shlibs, $1)=yes
@@ -4904,6 +5154,34 @@
       _LT_TAGVAR(link_all_deplibs, $1)=yes
       ;;
 
+    os2*)
+      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+      _LT_TAGVAR(hardcode_minus_L, $1)=yes
+      _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+      ;;
+
     interix3-9*)
       _LT_TAGVAR(hardcode_direct, $1)=no
       _LT_TAGVAR(hardcode_shlibpath_var, $1)=no
@@ -4977,6 +5255,9 @@
         fi
 
 	case $cc_basename in
+	tcc*)
+	  _LT_TAGVAR(export_dynamic_flag_spec, $1)='-rdynamic'
+	  ;;
 	xlf* | bgf* | bgxlf* | mpixlf*)
 	  # IBM XL Fortran 10.1 on PPC cannot create shared libs itself
 	  _LT_TAGVAR(whole_archive_flag_spec, $1)='--whole-archive$convenience --no-whole-archive'
@@ -4995,7 +5276,7 @@
       fi
       ;;
 
-    netbsd*)
+    netbsd* | netbsdelf*-gnu)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
 	wlarc=
@@ -5106,19 +5387,35 @@
 	no_entry_flag=
       else
 	# If we're using GNU nm, then we don't want the "-C" option.
-	# -C means demangle to AIX nm, but means don't demangle with GNU nm
-	# Also, AIX nm treats weak defined symbols like other global
-	# defined symbols, whereas GNU nm marks them as "W".
+	# -C means demangle to GNU nm, but means don't demangle to AIX nm.
+	# Without the "-l" option, or with the "-B" option, AIX nm treats
+	# weak defined symbols like other global defined symbols, whereas
+	# GNU nm marks them as "W".
+	# While the 'weak' keyword is ignored in the Export File, we need
+	# it in the Import File for the 'aix-soname' feature, so we have
+	# to replace the "-B" option with "-P" for AIX nm.
 	if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
-	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W")) && (substr(\$ 3,1,1) != ".")) { if (\$ 2 == "W") { print \$ 3 " weak" } else { print \$ 3 } } }'\'' | sort -u > $export_symbols'
 	else
-	  _LT_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B")) && (substr(\$ 3,1,1) != ".")) { print \$ 3 } }'\'' | sort -u > $export_symbols'
+	  _LT_TAGVAR(export_symbols_cmds, $1)='`func_echo_all $NM | $SED -e '\''s/B$^B*$$/P\1/'\''` -PCpgl $libobjs $convenience | awk '\''{ if (((\$ 2 == "T") || (\$ 2 == "D") || (\$ 2 == "B") || (\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) && (substr(\$ 1,1,1) != ".")) { if ((\$ 2 == "W") || (\$ 2 == "V") || (\$ 2 == "Z")) { print \$ 1 " weak" } else { print \$ 1 } } }'\'' | sort -u > $export_symbols'
 	fi
 	aix_use_runtimelinking=no
 
 	# Test if we are trying to use run time linking or normal
 	# AIX style linking. If -brtl is somewhere in LDFLAGS, we
-	# need to do runtime linking.
+	# have runtime linking enabled, and use it for executables.
+	# For shared libraries, we enable/disable runtime linking
+	# depending on the kind of the shared library created -
+	# when "with_aix_soname,aix_use_runtimelinking" is:
+	# "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "aix,yes"  lib.so          shared, rtl:yes, for executables
+	#            lib.a           static archive
+	# "both,no"  lib.so.V(shr.o) shared, rtl:yes
+	#            lib.a(lib.so.V) shared, rtl:no,  for executables
+	# "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a(lib.so.V) shared, rtl:no
+	# "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+	#            lib.a           static archive
 	case $host_os in aix4.23|aix4.23.*|aix5-9*)
 	  for ld_flag in $LDFLAGS; do
 	  if (test x-brtl = "x$ld_flag" || test x-Wl,-brtl = "x$ld_flag"); then
@@ -5126,6 +5423,13 @@
 	    break
 	  fi
 	  done
+	  if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	    # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	    # so we don't have lib.a shared libs to link our executables.
+	    # We have to force runtime linking in this case.
+	    aix_use_runtimelinking=yes
+	    LDFLAGS="$LDFLAGS -Wl,-brtl"
+	  fi
 	  ;;
 	esac
 
@@ -5145,6 +5449,14 @@
       _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
       _LT_TAGVAR(link_all_deplibs, $1)=yes
       _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+      case $with_aix_soname,$aix_use_runtimelinking in
+      aix,*) ;; # traditional, no import file
+      svr4,* | *,yes) # use import file
+	# The Import File defines what to hardcode.
+	_LT_TAGVAR(hardcode_direct, $1)=no
+	_LT_TAGVAR(hardcode_direct_absolute, $1)=no
+	;;
+      esac
 
       if test yes = "$GCC"; then
 	case $host_os in aix4.012|aix4.012.*)
@@ -5172,6 +5484,11 @@
 	if test yes = "$aix_use_runtimelinking"; then
 	  shared_flag="$shared_flag "'$wl-G'
 	fi
+	# Need to ensure runtime linking is disabled for the traditional
+	# shared library, or the linker may eventually find shared libraries
+	# /with/ Import File - we do not want to mix them.
+	shared_flag_aix='-shared'
+	shared_flag_svr4='-shared $wl-G'
       else
 	# not using gcc
 	if test ia64 = "$host_cpu"; then
@@ -5184,6 +5501,8 @@
 	  else
 	    shared_flag='$wl-bM:SRE'
 	  fi
+	  shared_flag_aix='$wl-bM:SRE'
+	  shared_flag_svr4='$wl-G'
 	fi
       fi
 
@@ -5191,7 +5510,7 @@
       # It seems that -bexpall does not export symbols beginning with
       # underscore (_), so it is better to generate a list of symbols to export.
       _LT_TAGVAR(always_export_symbols, $1)=yes
-      if test yes = "$aix_use_runtimelinking"; then
+      if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
 	# Warning - without using the other runtime loading flags (-brtl),
 	# -berok will link without error, but may produce a broken library.
 	_LT_TAGVAR(allow_undefined_flag, $1)='-berok'
@@ -5222,8 +5541,20 @@
 	    _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
 	  fi
 	  _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	  # This is similar to how AIX traditionally builds its shared libraries.
-	  _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $wl-bnoentry $compiler_flags $wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	  _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	  # -brtl affects multiple linker settings, -berok does not and is overridden later
+	  compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	  if test svr4 != "$with_aix_soname"; then
+	    # This is similar to how AIX traditionally builds its shared libraries.
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	  fi
+	  if test aix != "$with_aix_soname"; then
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	  else
+	    # used by -dlpreopen to get the symbols
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	  fi
+	  _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
 	fi
       fi
       ;;
@@ -5466,6 +5797,7 @@
 	if test yes = "$lt_cv_irix_exported_symbol"; then
           _LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags $wl-soname $wl$soname `test -n "$verstring" && func_echo_all "$wl-set_version $wl$verstring"` $wl-update_registry $wl$output_objdir/so_locations $wl-exports_file $wl$export_symbols -o $lib'
 	fi
+	_LT_TAGVAR(link_all_deplibs, $1)=no
       else
 	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -o $lib'
 	_LT_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -soname $soname `test -n "$verstring" && func_echo_all "-set_version $verstring"` -update_registry $output_objdir/so_locations -exports_file $export_symbols -o $lib'
@@ -5477,7 +5809,17 @@
       _LT_TAGVAR(link_all_deplibs, $1)=yes
       ;;
 
-    netbsd*)
+    linux*)
+      case $cc_basename in
+      tcc*)
+	# Fabrice Bellard et al's Tiny C Compiler
+	_LT_TAGVAR(ld_shlibs, $1)=yes
+	_LT_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
+	;;
+      esac
+      ;;
+
+    netbsd* | netbsdelf*-gnu)
       if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
 	_LT_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
       else
@@ -5522,8 +5864,28 @@
       _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
       _LT_TAGVAR(hardcode_minus_L, $1)=yes
       _LT_TAGVAR(allow_undefined_flag, $1)=unsupported
-      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~echo DATA >> $output_objdir/$libname.def~echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
-      _LT_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
+      shrext_cmds=.dll
+      _LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	$ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	$ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	$ECHO EXPORTS >> $output_objdir/$libname.def~
+	prefix_cmds="$SED"~
+	if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	  prefix_cmds="$prefix_cmds -e 1d";
+	fi~
+	prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	$CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	emximp -o $lib $output_objdir/$libname.def'
+      _LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+      _LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
       ;;
 
     osf3*)
@@ -5918,8 +6280,12 @@
     ;;
 
   aix4-9*)
-    if test ia64 != "$host_cpu" && test no = "$aix_use_runtimelinking"; then
-      test yes = "$enable_shared" && enable_static=no
+    if test ia64 != "$host_cpu"; then
+      case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+      yes,aix,yes) ;;			# shared object as lib.so file only
+      yes,svr4,*) ;;			# shared object as lib.so archive member only
+      yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+      esac
     fi
     ;;
   esac
@@ -6079,7 +6445,7 @@
       # Commands to make compiler produce verbose output that lists
       # what "hidden" libraries, object files and flags are used when
       # linking a shared library.
-      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 
     else
       GXX=no
@@ -6107,7 +6473,19 @@
 
           # Test if we are trying to use run time linking or normal
           # AIX style linking. If -brtl is somewhere in LDFLAGS, we
-          # need to do runtime linking.
+          # have runtime linking enabled, and use it for executables.
+          # For shared libraries, we enable/disable runtime linking
+          # depending on the kind of the shared library created -
+          # when "with_aix_soname,aix_use_runtimelinking" is:
+          # "aix,no"   lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "aix,yes"  lib.so          shared, rtl:yes, for executables
+          #            lib.a           static archive
+          # "both,no"  lib.so.V(shr.o) shared, rtl:yes
+          #            lib.a(lib.so.V) shared, rtl:no,  for executables
+          # "both,yes" lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a(lib.so.V) shared, rtl:no
+          # "svr4,*"   lib.so.V(shr.o) shared, rtl:yes, for executables
+          #            lib.a           static archive
           case $host_os in aix4.23|aix4.23.*|aix5-9*)
 	    for ld_flag in $LDFLAGS; do
 	      case $ld_flag in
@@ -6117,6 +6495,13 @@
 	        ;;
 	      esac
 	    done
+	    if test svr4,no = "$with_aix_soname,$aix_use_runtimelinking"; then
+	      # With aix-soname=svr4, we create the lib.so.V shared archives only,
+	      # so we don't have lib.a shared libs to link our executables.
+	      # We have to force runtime linking in this case.
+	      aix_use_runtimelinking=yes
+	      LDFLAGS="$LDFLAGS -Wl,-brtl"
+	    fi
 	    ;;
           esac
 
@@ -6136,6 +6521,14 @@
         _LT_TAGVAR(hardcode_libdir_separator, $1)=':'
         _LT_TAGVAR(link_all_deplibs, $1)=yes
         _LT_TAGVAR(file_list_spec, $1)='$wl-f,'
+        case $with_aix_soname,$aix_use_runtimelinking in
+        aix,*) ;;	# no import file
+        svr4,* | *,yes) # use import file
+          # The Import File defines what to hardcode.
+          _LT_TAGVAR(hardcode_direct, $1)=no
+          _LT_TAGVAR(hardcode_direct_absolute, $1)=no
+          ;;
+        esac
 
         if test yes = "$GXX"; then
           case $host_os in aix4.012|aix4.012.*)
@@ -6162,6 +6555,11 @@
 	  if test yes = "$aix_use_runtimelinking"; then
 	    shared_flag=$shared_flag' $wl-G'
 	  fi
+	  # Need to ensure runtime linking is disabled for the traditional
+	  # shared library, or the linker may eventually find shared libraries
+	  # /with/ Import File - we do not want to mix them.
+	  shared_flag_aix='-shared'
+	  shared_flag_svr4='-shared $wl-G'
         else
           # not using gcc
           if test ia64 = "$host_cpu"; then
@@ -6174,6 +6572,8 @@
 	    else
 	      shared_flag='$wl-bM:SRE'
 	    fi
+	    shared_flag_aix='$wl-bM:SRE'
+	    shared_flag_svr4='$wl-G'
           fi
         fi
 
@@ -6182,10 +6582,11 @@
         # underscore (_), so it is better to generate a list of symbols to
 	# export.
         _LT_TAGVAR(always_export_symbols, $1)=yes
-        if test yes = "$aix_use_runtimelinking"; then
+	if test aix,yes = "$with_aix_soname,$aix_use_runtimelinking"; then
           # Warning - without using the other runtime loading flags (-brtl),
           # -berok will link without error, but may produce a broken library.
-          _LT_TAGVAR(allow_undefined_flag, $1)='-berok'
+          # The "-G" linker flag allows undefined symbols.
+          _LT_TAGVAR(no_undefined_flag, $1)='-bernotok'
           # Determine the default libpath from the value encoded in an empty
           # executable.
           _LT_SYS_MODULE_PATH_AIX($1)
@@ -6214,9 +6615,21 @@
 	      _LT_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
 	    fi
 	    _LT_TAGVAR(archive_cmds_need_lc, $1)=yes
-	    # This is similar to how AIX traditionally builds its shared
-	    # libraries.
-	    _LT_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $wl-bnoentry $compiler_flags $wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
+	    _LT_TAGVAR(archive_expsym_cmds, $1)='$RM -r $output_objdir/$realname.d~$MKDIR $output_objdir/$realname.d'
+	    # -brtl affects multiple linker settings, -berok does not and is overridden later
+	    compiler_flags_filtered='`func_echo_all "$compiler_flags " | $SED -e "s%-brtl\$, \$%-berok\\1%g"`'
+	    if test svr4 != "$with_aix_soname"; then
+	      # This is similar to how AIX traditionally builds its shared
+	      # libraries. Need -bnortl late, we may have -brtl in LDFLAGS.
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_aix' -o $output_objdir/$realname.d/$soname $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$realname.d/$soname'
+	    fi
+	    if test aix != "$with_aix_soname"; then
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$CC '$shared_flag_svr4' -o $output_objdir/$realname.d/$shared_archive_member_spec.o $libobjs $deplibs $wl-bnoentry '$compiler_flags_filtered'$wl-bE:$export_symbols$allow_undefined_flag~$STRIP -e $output_objdir/$realname.d/$shared_archive_member_spec.o~( func_echo_all "#! $soname($shared_archive_member_spec.o)"; if test shr_64 = "$shared_archive_member_spec"; then func_echo_all "# 64"; else func_echo_all "# 32"; fi; cat $export_symbols ) > $output_objdir/$realname.d/$shared_archive_member_spec.imp~$AR $AR_FLAGS $output_objdir/$soname $output_objdir/$realname.d/$shared_archive_member_spec.o $output_objdir/$realname.d/$shared_archive_member_spec.imp'
+	    else
+	      # used by -dlpreopen to get the symbols
+	      _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$MV  $output_objdir/$realname.d/$soname $output_objdir'
+	    fi
+	    _LT_TAGVAR(archive_expsym_cmds, $1)="$_LT_TAGVAR(archive_expsym_cmds, $1)"'~$RM -r $output_objdir/$realname.d'
           fi
         fi
         ;;
@@ -6316,6 +6729,34 @@
         _LT_DARWIN_LINKER_FEATURES($1)
 	;;
 
+      os2*)
+	_LT_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
+	_LT_TAGVAR(hardcode_minus_L, $1)=yes
+	_LT_TAGVAR(allow_undefined_flag, $1)=unsupported
+	shrext_cmds=.dll
+	_LT_TAGVAR(archive_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  emxexp $libobjs | $SED /"_DLL_InitTerm"/d >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(archive_expsym_cmds, $1)='$ECHO "LIBRARY ${soname%$shared_ext} INITINSTANCE TERMINSTANCE" > $output_objdir/$libname.def~
+	  $ECHO "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~
+	  $ECHO "DATA MULTIPLE NONSHARED" >> $output_objdir/$libname.def~
+	  $ECHO EXPORTS >> $output_objdir/$libname.def~
+	  prefix_cmds="$SED"~
+	  if test EXPORTS = "`$SED 1q $export_symbols`"; then
+	    prefix_cmds="$prefix_cmds -e 1d";
+	  fi~
+	  prefix_cmds="$prefix_cmds -e \"s/^$.*$$/_\1/g\""~
+	  cat $export_symbols | $prefix_cmds >> $output_objdir/$libname.def~
+	  $CC -Zdll -Zcrtdll -o $output_objdir/$soname $libobjs $deplibs $compiler_flags $output_objdir/$libname.def~
+	  emximp -o $lib $output_objdir/$libname.def'
+	_LT_TAGVAR(old_archive_From_new_cmds, $1)='emximp -o $output_objdir/${libname}_dll.a $output_objdir/$libname.def'
+	_LT_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
+	;;
+
       dgux*)
         case $cc_basename in
           ec++*)
@@ -6379,7 +6820,7 @@
             # explicitly linking system object files so we need to strip them
             # from the output so that they don't get included in the library
             # dependencies.
-            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+            output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
             ;;
           *)
             if test yes = "$GXX"; then
@@ -6444,7 +6885,7 @@
 	    # explicitly linking system object files so we need to strip them
 	    # from the output so that they don't get included in the library
 	    # dependencies.
-	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
+	    output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP " \-L"`; list= ; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; func_echo_all "$list"'
 	    ;;
           *)
 	    if test yes = "$GXX"; then
@@ -6783,7 +7224,7 @@
 	      # Commands to make compiler produce verbose output that lists
 	      # what "hidden" libraries, object files and flags are used when
 	      # linking a shared library.
-	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	      output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 
 	    else
 	      # FIXME: insert proper C++ library support
@@ -6867,7 +7308,7 @@
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	        output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 	      else
 	        # g++ 2.7 appears to require '-G' NOT '-shared' on this
 	        # platform.
@@ -6878,7 +7319,7 @@
 	        # Commands to make compiler produce verbose output that lists
 	        # what "hidden" libraries, object files and flags are used when
 	        # linking a shared library.
-	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP "\-L"'
+	        output_verbose_link_cmd='$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP -v "^Configured with:" | $GREP " \-L"'
 	      fi
 
 	      _LT_TAGVAR(hardcode_libdir_flag_spec, $1)='$wl-R $wl$libdir'
@@ -7029,6 +7470,7 @@
 } # func_stripname_cnf
 )# _LT_FUNC_STRIPNAME_CNF
 
+
 # _LT_SYS_HIDDEN_LIBDEPS(TAGNAME)
 # ---------------------------------
 # Figure out "hidden" library dependencies from verbose
@@ -7207,51 +7649,6 @@
   _LT_TAGVAR(postdep_objects,$1)=
   _LT_TAGVAR(postdeps,$1)=
   ;;
-
-linux*)
-  case `$CC -V 2>&1 | sed 5q` in
-  *Sun\ C*)
-    # Sun C++ 5.9
-
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    if test yes != "$solaris_use_stlport4"; then
-      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
-
-solaris*)
-  case $cc_basename in
-  CC* | sunCC*)
-    # The more standards-conforming stlport4 library is
-    # incompatible with the Cstd library. Avoid specifying
-    # it if it's in CXXFLAGS. Ignore libCrun as
-    # -library=stlport4 depends on it.
-    case " $CXX $CXXFLAGS " in
-    *" -library=stlport4 "*)
-      solaris_use_stlport4=yes
-      ;;
-    esac
-
-    # Adding this requires a known-good setup of shared libraries for
-    # Sun compiler versions before 5.6, else PIC objects from an old
-    # archive will be linked into the output, leading to subtle bugs.
-    if test yes != "$solaris_use_stlport4"; then
-      _LT_TAGVAR(postdeps,$1)='-library=Cstd -library=Crun'
-    fi
-    ;;
-  esac
-  ;;
 esac
 )
 
@@ -7369,8 +7766,12 @@
         fi
         ;;
       aix4-9*)
-	if test ia64 != "$host_cpu" && test no = "$aix_use_runtimelinking"; then
-	  test yes = "$enable_shared" && enable_static=no
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
 	fi
         ;;
     esac
@@ -7503,8 +7904,12 @@
         fi
         ;;
       aix4-9*)
-	if test ia64 != "$host_cpu" && test no = "$aix_use_runtimelinking"; then
-	  test yes = "$enable_shared" && enable_static=no
+	if test ia64 != "$host_cpu"; then
+	  case $enable_shared,$with_aix_soname,$aix_use_runtimelinking in
+	  yes,aix,yes) ;;		# shared object as lib.so file only
+	  yes,svr4,*) ;;		# shared object as lib.so archive member only
+	  yes,*) enable_static=no ;;	# shared object in lib.a archive as well
+	  esac
 	fi
         ;;
     esac

_service:tar_scm:isl-0.14.tar.xz/m4/ltoptions.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/ltoptions.m4 Changed

@@ -1,6 +1,6 @@
 # Helper functions for option handling.                    -*- Autoconf -*-
 #
-#   Copyright (C) 2004-2005, 2007-2009, 2011-2013 Free Software
+#   Copyright (C) 2004-2005, 2007-2009, 2011-2015 Free Software
 #   Foundation, Inc.
 #   Written by Gary V. Vaughan, 2004
 #
@@ -82,6 +82,8 @@
   _LT_UNLESS_OPTIONS(LT_INIT, pic-only no-pic, _LT_WITH_PIC)
   _LT_UNLESS_OPTIONS(LT_INIT, fast-install disable-fast-install,
 		   _LT_ENABLE_FAST_INSTALL)
+  _LT_UNLESS_OPTIONS(LT_INIT, aix-soname=aix aix-soname=both aix-soname=svr4,
+		   _LT_WITH_AIX_SONAME(aix))
   )
 )# _LT_SET_OPTIONS
 
@@ -319,6 +321,59 @@
 dnl AC_DEFUN(AM_DISABLE_FAST_INSTALL, )
 
 
+# _LT_WITH_AIX_SONAME(DEFAULT)
+# ----------------------------------
+# implement the --with-aix-soname flag, and support the `aix-soname=aix'
+# and `aix-soname=both' and `aix-soname=svr4' LT_INIT options. DEFAULT
+# is either `aix', `both' or `svr4'.  If omitted, it defaults to `aix'.
+m4_define(_LT_WITH_AIX_SONAME,
+m4_define(_LT_WITH_AIX_SONAME_DEFAULT, m4_if($1, svr4, svr4, m4_if($1, both, both, aix)))dnl
+shared_archive_member_spec=
+case $host,$enable_shared in
+power*-*-aix5-9*,yes)
+  AC_MSG_CHECKING(which variant of shared library versioning to provide)
+  AC_ARG_WITH(aix-soname,
+    AS_HELP_STRING(--with-aix-soname=aix|svr4|both,
+      shared library versioning (aka "SONAME") variant to provide on AIX, @<:@default=_LT_WITH_AIX_SONAME_DEFAULT@:>@.),
+    case $withval in
+    aix|svr4|both)
+      ;;
+    *)
+      AC_MSG_ERROR(Unknown argument to --with-aix-soname)
+      ;;
+    esac
+    lt_cv_with_aix_soname=$with_aix_soname,
+    AC_CACHE_VAL(lt_cv_with_aix_soname,
+      lt_cv_with_aix_soname=_LT_WITH_AIX_SONAME_DEFAULT)
+    with_aix_soname=$lt_cv_with_aix_soname)
+  AC_MSG_RESULT($with_aix_soname)
+  if test aix != "$with_aix_soname"; then
+    # For the AIX way of multilib, we name the shared archive member
+    # based on the bitwidth used, traditionally 'shr.o' or 'shr_64.o',
+    # and 'shr.imp' or 'shr_64.imp', respectively, for the Import File.
+    # Even when GNU compilers ignore OBJECT_MODE but need '-maix64' flag,
+    # the AIX toolchain works better with OBJECT_MODE set (default 32).
+    if test 64 = "${OBJECT_MODE-32}"; then
+      shared_archive_member_spec=shr_64
+    else
+      shared_archive_member_spec=shr
+    fi
+  fi
+  ;;
+*)
+  with_aix_soname=aix
+  ;;
+esac
+
+_LT_DECL(, shared_archive_member_spec, 0,
+    Shared archive member basename, for filename based shared library versioning on AIX)dnl
+)# _LT_WITH_AIX_SONAME
+
+LT_OPTION_DEFINE(LT_INIT, aix-soname=aix, _LT_WITH_AIX_SONAME(aix))
+LT_OPTION_DEFINE(LT_INIT, aix-soname=both, _LT_WITH_AIX_SONAME(both))
+LT_OPTION_DEFINE(LT_INIT, aix-soname=svr4, _LT_WITH_AIX_SONAME(svr4))
+
+
 # _LT_WITH_PIC(MODE)
 # --------------------
 # implement the --with-pic flag, and support the 'pic-only' and 'no-pic'

_service:tar_scm:isl-0.14.tar.xz/m4/ltsugar.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/ltsugar.m4 Changed

_service:tar_scm:isl-0.14.tar.xz/m4/ltversion.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/ltversion.m4 Changed

_service:tar_scm:isl-0.14.tar.xz/m4/lt~obsolete.m4 -> _service:tar_scm:isl-0.24.tar.gz/m4/lt~obsolete.m4 Changed

_service:tar_scm:isl-0.14.tar.xz/missing -> _service:tar_scm:isl-0.24.tar.gz/missing Changed

@@ -1,9 +1,9 @@
 #! /bin/sh
 # Common wrapper for a few potentially missing GNU programs.
 
-scriptversion=2013-10-28.13; # UTC
+scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 1996-2013 Free Software Foundation, Inc.
+# Copyright (C) 1996-2018 Free Software Foundation, Inc.
 # Originally written by Fran,cois Pinard <pinard@iro.umontreal.ca>, 1996.
 
 # This program is free software; you can redistribute it and/or modify
@@ -17,7 +17,7 @@
 # GNU General Public License for more details.
 
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -101,9 +101,9 @@
   exit $st
 fi
 
-perl_URL=http://www.perl.org/
-flex_URL=http://flex.sourceforge.net/
-gnu_software_URL=http://www.gnu.org/software
+perl_URL=https://www.perl.org/
+flex_URL=https://github.com/westes/flex
+gnu_software_URL=https://www.gnu.org/software
 
 program_details ()
 {
@@ -207,9 +207,9 @@
 exit $st
 
 # Local variables:
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:

_service:tar_scm:isl-0.24.tar.gz/opt_type.h Added

_service:tar_scm:isl-0.14.tar.xz/pip.c -> _service:tar_scm:isl-0.24.tar.gz/pip.c Changed

@@ -9,7 +9,6 @@
 
 #include <assert.h>
 #include <string.h>
-#include <strings.h>
 #include <isl_map_private.h>
 #include <isl/aff.h>
 #include <isl/set.h>
@@ -22,6 +21,7 @@
 #include <isl_point_private.h>
 #include <isl_vec_private.h>
 #include <isl/options.h>
+#include <isl_config.h>
 
 /* The input of this program is the same as that of the "example" program
  * from the PipLib distribution, except that the "big parameter column"
@@ -65,12 +65,14 @@
 
 static __isl_give isl_basic_set *set_bounds(__isl_take isl_basic_set *bset)
 {
-	unsigned nparam;
+	isl_size nparam;
 	int i, r;
 	isl_point *pt, *pt2;
 	isl_basic_set *box;
 
 	nparam = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0)
+		return isl_basic_set_free(bset);
 	r = nparam >= 8 ? 4 : nparam >= 5 ? 6 : 30;
 
 	pt = isl_basic_set_sample_point(isl_basic_set_copy(bset));
@@ -86,38 +88,85 @@
 	return isl_basic_set_intersect(bset, box);
 }
 
-static struct isl_basic_set *to_parameter_domain(struct isl_basic_set *context)
+static __isl_give isl_basic_set *to_parameter_domain(
+	__isl_take isl_basic_set *context)
 {
+	isl_size dim;
+
+	dim = isl_basic_set_dim(context, isl_dim_set);
+	if (dim < 0)
+		return isl_basic_set_free(context);
 	context = isl_basic_set_move_dims(context, isl_dim_param, 0,
-		    isl_dim_set, 0, isl_basic_set_dim(context, isl_dim_set));
+		    isl_dim_set, 0, dim);
 	context = isl_basic_set_params(context);
 	return context;
 }
 
-isl_basic_set *plug_in_parameters(isl_basic_set *bset, struct isl_vec *params)
+/* If "context" has more parameters than "bset", then reinterpret
+ * the last dimensions of "bset" as parameters.
+ */
+static __isl_give isl_basic_set *move_parameters(__isl_take isl_basic_set *bset,
+	__isl_keep isl_basic_set *context)
+{
+	isl_size nparam, nparam_bset, dim;
+
+	nparam = isl_basic_set_dim(context, isl_dim_param);
+	nparam_bset = isl_basic_set_dim(bset, isl_dim_param);
+	if (nparam < 0 | nparam_bset < 0)
+		return isl_basic_set_free(bset);
+	if (nparam == nparam_bset)
+		return bset;
+	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		return isl_basic_set_free(bset);
+	bset = isl_basic_set_move_dims(bset, isl_dim_param, 0,
+					    isl_dim_set, dim - nparam, nparam);
+	return bset;
+}
+
+/* Plug in the initial values of "params" for the parameters in "bset" and
+ * return the result.  The remaining entries in "params", if any,
+ * correspond to the existentially quantified variables in the description
+ * of the original context and can be ignored.
+ */
+static __isl_give isl_basic_set *plug_in_parameters(
+	__isl_take isl_basic_set *bset, __isl_take isl_vec *params)
 {
 	int i;
+	isl_size n;
 
-	for (i = 0; i < params->size - 1; ++i)
+	n = isl_basic_set_dim(bset, isl_dim_param);
+	if (n < 0)
+		bset = isl_basic_set_free(bset);
+	for (i = 0; i < n; ++i)
 		bset = isl_basic_set_fix(bset,
 					 isl_dim_param, i, params->el1 + i);
 
-	bset = isl_basic_set_remove_dims(bset,
-					 isl_dim_param, 0, params->size - 1);
+	bset = isl_basic_set_remove_dims(bset, isl_dim_param, 0, n);
 
 	isl_vec_free(params);
 
 	return bset;
 }
 
-isl_set *set_plug_in_parameters(isl_set *set, struct isl_vec *params)
+/* Plug in the initial values of "params" for the parameters in "set" and
+ * return the result.  The remaining entries in "params", if any,
+ * correspond to the existentially quantified variables in the description
+ * of the original context and can be ignored.
+ */
+static __isl_give isl_set *set_plug_in_parameters(__isl_take isl_set *set,
+	__isl_take isl_vec *params)
 {
 	int i;
+	isl_size n;
 
-	for (i = 0; i < params->size - 1; ++i)
+	n = isl_set_dim(set, isl_dim_param);
+	if (n < 0)
+		set = isl_set_free(set);
+	for (i = 0; i < n; ++i)
 		set = isl_set_fix(set, isl_dim_param, i, params->el1 + i);
 
-	set = isl_set_remove_dims(set, isl_dim_param, 0, params->size - 1);
+	set = isl_set_remove_dims(set, isl_dim_param, 0, n);
 
 	isl_vec_free(params);
 
@@ -128,28 +177,32 @@
  * element of bset for the given values of the parameters, by
  * successively solving an ilp problem in each direction.
  */
-struct isl_vec *opt_at(struct isl_basic_set *bset,
-	struct isl_vec *params, int max)
+static __isl_give isl_vec *opt_at(__isl_take isl_basic_set *bset,
+	__isl_take isl_vec *params, int max)
 {
-	unsigned dim;
+	isl_size dim;
+	isl_ctx *ctx;
 	struct isl_vec *opt;
 	struct isl_vec *obj;
 	int i;
 
 	dim = isl_basic_set_dim(bset, isl_dim_set);
+	if (dim < 0)
+		goto error;
 
 	bset = plug_in_parameters(bset, params);
 
+	ctx = isl_basic_set_get_ctx(bset);
 	if (isl_basic_set_plain_is_empty(bset)) {
-		opt = isl_vec_alloc(bset->ctx, 0);
+		opt = isl_vec_alloc(ctx, 0);
 		isl_basic_set_free(bset);
 		return opt;
 	}
 
-	opt = isl_vec_alloc(bset->ctx, 1 + dim);
+	opt = isl_vec_alloc(ctx, 1 + dim);
 	assert(opt);
 
-	obj = isl_vec_alloc(bset->ctx, 1 + dim);
+	obj = isl_vec_alloc(ctx, 1 + dim);
 	assert(obj);
 
 	isl_int_set_si(opt->el0, 1);
@@ -172,9 +225,13 @@
 	isl_vec_free(obj);
 
 	return opt;
+error:
+	isl_basic_set_free(bset);
+	isl_vec_free(params);
+	return NULL;
 empty:
 	isl_vec_free(opt);
-	opt = isl_vec_alloc(bset->ctx, 0);
+	opt = isl_vec_alloc(ctx, 0);
 	isl_basic_set_free(bset);
 	isl_vec_free(obj);
 
@@ -199,7 +256,7 @@
  * Otherwise, the optimal solution, should be equal to the result of
  * plugging in the value of the parameters in "sol".
  */
-static int scan_one(struct isl_scan_callback *callback,
+static isl_stat scan_one(struct isl_scan_callback *callback,
 	__isl_take isl_vec *sample)
 {
 	struct isl_scan_pip *sp = (struct isl_scan_pip *)callback;
@@ -231,7 +288,7 @@
 		fflush(stdout);
 	}
 
-	return sp->n >= 1 ? 0 : -1;
+	return sp->n >= 1 ? isl_stat_ok : isl_stat_error;
 }
 
 static void check_solution(isl_basic_set *bset, isl_basic_set *context,
@@ -290,7 +347,6 @@
 	int max = 0;
 	int rational = 0;
 	int n;
-	int nparam;
 	struct options *options;
 
 	options = options_new_with_defaults();
@@ -322,12 +378,7 @@
 		context = isl_basic_set_intersect(context,
 		isl_basic_set_positive_orthant(isl_basic_set_get_space(context)));
 	context = to_parameter_domain(context);
-	nparam = isl_basic_set_dim(context, isl_dim_param);
-	if (nparam != isl_basic_set_dim(bset, isl_dim_param)) {
-		int dim = isl_basic_set_dim(bset, isl_dim_set);
-		bset = isl_basic_set_move_dims(bset, isl_dim_param, 0,
-					    isl_dim_set, dim - nparam, nparam);
-	}
+	bset = move_parameters(bset, context);
 	if (!urs_unknowns)
 		bset = isl_basic_set_intersect(bset,
 		isl_basic_set_positive_orthant(isl_basic_set_get_space(bset)));

_service:tar_scm:isl-0.14.tar.xz/pip_test.sh.in -> _service:tar_scm:isl-0.24.tar.gz/pip_test.sh.in Changed

_service:tar_scm:isl-0.14.tar.xz/polyhedron_detect_equalities.c -> _service:tar_scm:isl-0.24.tar.gz/polyhedron_detect_equalities.c Changed

_service:tar_scm:isl-0.14.tar.xz/polyhedron_minimize.c -> _service:tar_scm:isl-0.24.tar.gz/polyhedron_minimize.c Changed

@@ -21,7 +21,7 @@
  * Linear or affine objective function in PolyLib format.
  */
 
-static struct isl_vec *isl_vec_lin_to_aff(struct isl_vec *vec)
+static __isl_give isl_vec *isl_vec_lin_to_aff(__isl_take isl_vec *vec)
 {
 	struct isl_vec *aff;
 
@@ -43,7 +43,7 @@
  * In particular, move the constant term from the end of the
  * vector to the start of the vector.
  */
-static struct isl_vec *vec_ror(struct isl_vec *vec)
+static __isl_give isl_vec *vec_ror(__isl_take isl_vec *vec)
 {
 	int i;
 
@@ -61,16 +61,16 @@
 	struct isl_vec *obj;
 	struct isl_vec *sol;
 	isl_int opt;
-	unsigned dim;
+	isl_size dim;
 	enum isl_lp_result res;
 	isl_printer *p;
 
 	isl_int_init(opt);
 	bset = isl_basic_set_read_from_file(ctx, stdin);
-	assert(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	assert(dim >= 0);
 	obj = isl_vec_read_from_file(ctx, stdin);
 	assert(obj);
-	dim = isl_basic_set_total_dim(bset);
 	assert(obj->size >= dim && obj->size <= dim + 1);
 	if (obj->size != dim + 1)
 		obj = isl_vec_lin_to_aff(obj);

_service:tar_scm:isl-0.14.tar.xz/polytope_scan.c -> _service:tar_scm:isl-0.24.tar.gz/polytope_scan.c Changed

@@ -28,7 +28,7 @@
 	struct isl_mat *samples;
 };
 
-static int scan_samples_add_sample(struct isl_scan_callback *cb,
+static isl_stat scan_samples_add_sample(struct isl_scan_callback *cb,
 	__isl_take isl_vec *sample)
 {
 	struct scan_samples *ss = (struct scan_samples *)cb;
@@ -42,20 +42,23 @@
 		    sample->el, sample->size);
 
 	isl_vec_free(sample);
-	return 0;
+	return isl_stat_ok;
 error:
 	isl_vec_free(sample);
-	return -1;
+	return isl_stat_error;
 }
 
-static struct isl_mat *isl_basic_set_scan_samples(struct isl_basic_set *bset)
+static __isl_give isl_mat *isl_basic_set_scan_samples(
+	__isl_take isl_basic_set *bset)
 {
 	isl_ctx *ctx;
-	unsigned dim;
+	isl_size dim;
 	struct scan_samples ss;
 
 	ctx = isl_basic_set_get_ctx(bset);
-	dim = isl_basic_set_total_dim(bset);
+	dim = isl_basic_set_dim(bset, isl_dim_all);
+	if (dim < 0)
+		goto error;
 	ss.callback.add = scan_samples_add_sample;
 	ss.samples = isl_mat_alloc(ctx, 0, 1 + dim);
 	if (!ss.samples)
@@ -72,7 +75,7 @@
 	return NULL;
 }
 
-static struct isl_mat *isl_basic_set_samples(struct isl_basic_set *bset)
+static __isl_give isl_mat *isl_basic_set_samples(__isl_take isl_basic_set *bset)
 {
 	struct isl_mat *T;
 	struct isl_mat *samples;

_service:tar_scm:isl-0.14.tar.xz/print.c -> _service:tar_scm:isl-0.24.tar.gz/print.c Changed

@@ -7,7 +7,6 @@
 #include <isl/union_set.h>
 #include <isl/union_map.h>
 #include <isl/polynomial.h>
-#include <isl/band.h>
 #include <isl/constraint.h>
 #include <isl/aff.h>
 #include <isl/ast.h>
@@ -18,6 +17,9 @@
 #define BASE id
 #include <print_templ.c>
 #undef BASE
+#define BASE multi_id
+#include <print_templ.c>
+#undef BASE
 #define BASE val
 #include <print_templ.c>
 #undef BASE
@@ -66,9 +68,6 @@
 #define BASE union_pw_qpolynomial_fold
 #include <print_templ.c>
 #undef BASE
-#define BASE band
-#include <print_templ.c>
-#undef BASE
 #define BASE constraint
 #include <print_templ.c>
 #undef BASE
@@ -90,11 +89,17 @@
 #define BASE multi_pw_aff
 #include <print_templ.c>
 #undef BASE
+#define BASE union_pw_aff
+#include <print_templ.c>
+#undef BASE
+#define BASE multi_union_pw_aff
+#include <print_templ.c>
+#undef BASE
 #define BASE point
 #include <print_templ.c>
 #undef BASE
 #define BASE ast_expr
-#include <print_templ.c>
+#include <print_templ_yaml.c>
 #undef BASE
 #define BASE ast_node
-#include <print_templ.c>
+#include <print_templ_yaml.c>

_service:tar_scm:isl-0.14.tar.xz/print_templ.c -> _service:tar_scm:isl-0.24.tar.gz/print_templ.c Changed

_service:tar_scm:isl-0.24.tar.gz/print_templ_yaml.c Added

_service:tar_scm:isl-0.24.tar.gz/print_yaml_field_templ.c Added

_service:tar_scm:isl-0.24.tar.gz/py-compile Added

@@ -0,0 +1,170 @@
+#!/bin/sh
+# py-compile - Compile a Python program
+
+scriptversion=2018-03-07.03; # UTC
+
+# Copyright (C) 2000-2018 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2, or (at your option)
+# any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+# As a special exception to the GNU General Public License, if you
+# distribute this file as part of a program that contains a
+# configuration script generated by Autoconf, you may include it under
+# the same distribution terms that you use for the rest of that program.
+
+# This file is maintained in Automake, please report
+# bugs to <bug-automake@gnu.org> or send patches to
+# <automake-patches@gnu.org>.
+
+if  -z "$PYTHON" ; then
+  PYTHON=python
+fi
+
+me=py-compile
+
+usage_error ()
+{
+  echo "$me: $*" >&2
+  echo "Try '$me --help' for more information." >&2
+  exit 1
+}
+
+basedir=
+destdir=
+while test $# -ne 0; do
+  case "$1" in
+    --basedir)
+      if test $# -lt 2; then
+        usage_error "option '--basedir' requires an argument"
+      else
+        basedir=$2
+      fi
+      shift
+      ;;
+    --destdir)
+      if test $# -lt 2; then
+        usage_error "option '--destdir' requires an argument"
+      else
+        destdir=$2
+      fi
+      shift
+      ;;
+    -h|--help)
+      cat <<\EOF
+Usage: py-compile --help --version --basedir DIR --destdir DIR FILES..."
+
+Byte compile some python scripts FILES.  Use --destdir to specify any
+leading directory path to the FILES that you don't want to include in the
+byte compiled file.  Specify --basedir for any additional path information you
+do want to be shown in the byte compiled file.
+
+Example:
+  py-compile --destdir /tmp/pkg-root --basedir /usr/share/test test.py test2.py
+
+Report bugs to <bug-automake@gnu.org>.
+EOF
+      exit $?
+      ;;
+    -v|--version)
+      echo "$me $scriptversion"
+      exit $?
+      ;;
+    --)
+      shift
+      break
+      ;;
+    -*)
+      usage_error "unrecognized option '$1'"
+      ;;
+    *)
+      break
+      ;;
+  esac
+  shift
+done
+
+files=$*
+if test -z "$files"; then
+    usage_error "no files given"
+fi
+
+# if basedir was given, then it should be prepended to filenames before
+# byte compilation.
+if  -z "$basedir" ; then
+    pathtrans="path = file"
+else
+    pathtrans="path = os.path.join('$basedir', file)"
+fi
+
+# if destdir was given, then it needs to be prepended to the filename to
+# byte compile but not go into the compiled file.
+if  -z "$destdir" ; then
+    filetrans="filepath = path"
+else
+    filetrans="filepath = os.path.normpath('$destdir' + os.sep + path)"
+fi
+
+$PYTHON -c "
+import sys, os, py_compile, imp
+
+files = '''$files'''
+
+sys.stdout.write('Byte-compiling python modules...\n')
+for file in files.split():
+    $pathtrans
+    $filetrans
+    if not os.path.exists(filepath) or not (len(filepath) >= 3
+                                            and filepath-3: == '.py'):
+	    continue
+    sys.stdout.write(file)
+    sys.stdout.flush()
+    if hasattr(imp, 'get_tag'):
+        py_compile.compile(filepath, imp.cache_from_source(filepath), path)
+    else:
+        py_compile.compile(filepath, filepath + 'c', path)
+sys.stdout.write('\n')" || exit $?
+
+# this will fail for python < 1.5, but that doesn't matter ...
+$PYTHON -O -c "
+import sys, os, py_compile, imp
+
+# pypy does not use .pyo optimization
+if hasattr(sys, 'pypy_translation_info'):
+    sys.exit(0)
+
+files = '''$files'''
+sys.stdout.write('Byte-compiling python modules (optimized versions) ...\n')
+for file in files.split():
+    $pathtrans
+    $filetrans
+    if not os.path.exists(filepath) or not (len(filepath) >= 3
+                                            and filepath-3: == '.py'):
+	    continue
+    sys.stdout.write(file)
+    sys.stdout.flush()
+    if hasattr(imp, 'get_tag'):
+        py_compile.compile(filepath, imp.cache_from_source(filepath, False), path)
+    else:
+        py_compile.compile(filepath, filepath + 'o', path)
+sys.stdout.write('\n')" 2>/dev/null || :
+
+# Local Variables:
+# mode: shell-script
+# sh-indentation: 2
+# eval: (add-hook 'before-save-hook 'time-stamp)
+# time-stamp-start: "scriptversion="
+# time-stamp-format: "%:y-%02m-%02d.%02H"
+# time-stamp-time-zone: "UTC0"
+# time-stamp-end: "; # UTC"
+# End:

_service:tar_scm:isl-0.24.tar.gz/python Added

_service:tar_scm:isl-0.24.tar.gz/python/isl.py.top Added

_service:tar_scm:isl-0.24.tar.gz/read_in_string_templ.c Added

@@ -0,0 +1,38 @@
+#include <isl/stream.h>
+
+#define xCAT(A,B) A ## B
+#define CAT(A,B) xCAT(A,B)
+#undef TYPE
+#define TYPE CAT(isl_,BASE)
+#define xFN(TYPE,NAME) TYPE ## _ ## NAME
+#define FN(TYPE,NAME) xFN(TYPE,NAME)
+
+/* Read an object of type TYPE from "s", where the object may
+ * either be specified directly or as a string.
+ *
+ * First check if the next token in "s" is a string.  If so, try and
+ * extract the object from the string.
+ * Otherwise, try and read the object directly from "s".
+ */
+static __isl_give TYPE *FN(read,BASE)(__isl_keep isl_stream *s)
+{
+	struct isl_token *tok;
+	int type;
+
+	tok = isl_stream_next_token(s);
+	type = isl_token_get_type(tok);
+	if (type == ISL_TOKEN_STRING) {
+		char *str;
+		isl_ctx *ctx;
+		TYPE *res;
+
+		ctx = isl_stream_get_ctx(s);
+		str = isl_token_get_str(ctx, tok);
+		res = FN(TYPE,read_from_str)(ctx, str);
+		free(str);
+		isl_token_free(tok);
+		return res;
+	}
+	isl_stream_push_token(s, tok);
+	return FN(isl_stream_read,BASE)(s);
+}

_service:tar_scm:isl-0.24.tar.gz/schedule.c Added

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+/* This program takes an isl_schedule_constraints object as input and
+ * prints a schedule that satisfies those constraints.
+ */
+
+#include <stdlib.h>
+#include <isl/options.h>
+#include <isl/schedule.h>
+#include <isl/printer.h>
+
+int main(int argc, char **argv)
+{
+	isl_ctx *ctx;
+	isl_printer *p;
+	isl_schedule_constraints *sc;
+	isl_schedule *schedule;
+	struct isl_options *options;
+
+	options = isl_options_new_with_defaults();
+	argc = isl_options_parse(options, argc, argv, ISL_ARG_ALL);
+	ctx = isl_ctx_alloc_with_options(&isl_options_args, options);
+
+	sc = isl_schedule_constraints_read_from_file(ctx, stdin);
+	schedule = isl_schedule_constraints_compute_schedule(sc);
+
+	p = isl_printer_to_file(ctx, stdout);
+	p = isl_printer_set_yaml_style(p, ISL_YAML_STYLE_BLOCK);
+	p = isl_printer_print_schedule(p, schedule);
+	isl_printer_free(p);
+
+	isl_schedule_free(schedule);
+
+	isl_ctx_free(ctx);
+
+	return p ? EXIT_SUCCESS : EXIT_FAILURE;
+}

_service:tar_scm:isl-0.24.tar.gz/schedule_cmp.c Added

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2017      Sven Verdoolaege
+ *
+ * Use of this software is governed by the MIT license
+ *
+ * Written by Sven Verdoolaege.
+ */
+
+#include <stdlib.h>
+
+#include <isl/arg.h>
+#include <isl/options.h>
+#include <isl/schedule.h>
+
+struct options {
+	struct isl_options *isl;
+	char *schedule1;
+	char *schedule2;
+};
+
+ISL_ARGS_START(struct options, options_args)
+ISL_ARG_CHILD(struct options, isl, "isl", &isl_options_args, "isl options")
+ISL_ARG_ARG(struct options, schedule1, "schedule1", NULL)
+ISL_ARG_ARG(struct options, schedule2, "schedule2", NULL)
+ISL_ARGS_END
+
+ISL_ARG_DEF(options, struct options, options_args)
+
+static void die(const char *msg)
+{
+	fprintf(stderr, "%s\n", msg);
+	exit(EXIT_FAILURE);
+}
+
+static FILE *open_or_die(const char *filename)
+{
+	FILE *file;
+
+	file = fopen(filename, "r");
+	if (!file) {
+		fprintf(stderr, "Unable to open %s\n", filename);
+		exit(EXIT_FAILURE);
+	}
+	return file;
+}
+
+/* Given two YAML descriptions of isl_schedule objects, check whether
+ * they are equivalent.
+ * Return EXIT_SUCCESS if they are and EXIT_FAILURE if they are not
+ * or if anything else went wrong.
+ */
+int main(int argc, char **argv)
+{
+	isl_ctx *ctx;
+	struct options *options;
+	FILE *input1, *input2;
+	isl_bool equal;
+	isl_schedule *s1, *s2;
+
+	options = options_new_with_defaults();
+	if (!options)
+		return EXIT_FAILURE;
+
+	ctx = isl_ctx_alloc_with_options(&options_args, options);
+	argc = options_parse(options, argc, argv, ISL_ARG_ALL);
+
+	input1 = open_or_die(options->schedule1);
+	input2 = open_or_die(options->schedule2);
+	s1 = isl_schedule_read_from_file(ctx, input1);
+	s2 = isl_schedule_read_from_file(ctx, input2);
+
+	equal = isl_schedule_plain_is_equal(s1, s2);
+	if (equal < 0)
+		return EXIT_FAILURE;
+	if (!equal)
+		die("schedules differ");
+
+	isl_schedule_free(s1);
+	isl_schedule_free(s2);
+	fclose(input1);
+	fclose(input2);
+	isl_ctx_free(ctx);
+
+	return EXIT_SUCCESS;
+}

_service:tar_scm:isl-0.24.tar.gz/schedule_test.sh.in Added

_service:tar_scm:isl-0.24.tar.gz/set_from_map.c Added

_service:tar_scm:isl-0.24.tar.gz/set_list_from_map_list_inl.c Added

_service:tar_scm:isl-0.24.tar.gz/set_to_map.c Added

_service:tar_scm:isl-0.14.tar.xz/test-driver -> _service:tar_scm:isl-0.24.tar.gz/test-driver Changed

@@ -1,9 +1,9 @@
 #! /bin/sh
 # test-driver - basic testsuite driver script.
 
-scriptversion=2012-06-27.10; # UTC
+scriptversion=2018-03-07.03; # UTC
 
-# Copyright (C) 2011-2013 Free Software Foundation, Inc.
+# Copyright (C) 2011-2018 Free Software Foundation, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -16,7 +16,7 @@
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+# along with this program.  If not, see <https://www.gnu.org/licenses/>.
 
 # As a special exception to the GNU General Public License, if you
 # distribute this file as part of a program that contains a
@@ -44,13 +44,12 @@
 Usage:
   test-driver --test-name=NAME --log-file=PATH --trs-file=PATH
               --expect-failure={yes|no} --color-tests={yes|no}
-              --enable-hard-errors={yes|no} -- TEST-SCRIPT
+              --enable-hard-errors={yes|no} --
+              TEST-SCRIPT TEST-SCRIPT-ARGUMENTS
 The '--test-name', '--log-file' and '--trs-file' options are mandatory.
 END
 }
 
-# TODO: better error handling in option parsing (in particular, ensure
-# TODO: $log_file, $trs_file and $test_name are defined).
 test_name= # Used for reporting.
 log_file=  # Where to save the output of the test script.
 trs_file=  # Where to save the metadata of the test run.
@@ -69,10 +68,23 @@
   --enable-hard-errors) enable_hard_errors=$2; shift;;
   --) shift; break;;
   -*) usage_error "invalid option: '$1'";;
+   *) break;;
   esac
   shift
 done
 
+missing_opts=
+test x"$test_name" = x && missing_opts="$missing_opts --test-name"
+test x"$log_file"  = x && missing_opts="$missing_opts --log-file"
+test x"$trs_file"  = x && missing_opts="$missing_opts --trs-file"
+if test x"$missing_opts" != x; then
+  usage_error "the following mandatory options are missing:$missing_opts"
+fi
+
+if test $# -eq 0; then
+  usage_error "missing argument"
+fi
+
 if test $color_tests = yes; then
   # Keep this in sync with 'lib/am/check.am:$(am__tty_colors)'.
   red='&#x1b;0;31m' # Red.
@@ -94,11 +106,14 @@
 # Test script is run here.
 "$@" >$log_file 2>&1
 estatus=$?
+
 if test $enable_hard_errors = no && test $estatus -eq 99; then
-  estatus=1
+  tweaked_estatus=1
+else
+  tweaked_estatus=$estatus
 fi
 
-case $estatus:$expect_failure in
+case $tweaked_estatus:$expect_failure in
   0:yes) col=$red res=XPASS recheck=yes gcopy=yes;;
   0:*)   col=$grn res=PASS  recheck=no  gcopy=no;;
   77:*)  col=$blu res=SKIP  recheck=no  gcopy=yes;;
@@ -107,6 +122,12 @@
   *:*)   col=$red res=FAIL  recheck=yes gcopy=yes;;
 esac
 
+# Report the test outcome and exit status in the logs, so that one can
+# know whether the test passed or failed simply by looking at the '.log'
+# file, without the need of also peaking into the corresponding '.trs'
+# file (automake bug#11814).
+echo "$res $test_name (exit status: $estatus)" >>$log_file
+
 # Report outcome to console.
 echo "${col}${res}${std}: $test_name"
 
@@ -119,9 +140,9 @@
 # Local Variables:
 # mode: shell-script
 # sh-indentation: 2
-# eval: (add-hook 'write-file-hooks 'time-stamp)
+# eval: (add-hook 'before-save-hook 'time-stamp)
 # time-stamp-start: "scriptversion="
 # time-stamp-format: "%:y-%02m-%02d.%02H"
-# time-stamp-time-zone: "UTC"
+# time-stamp-time-zone: "UTC0"
 # time-stamp-end: "; # UTC"
 # End:

_service:tar_scm:isl-0.14.tar.xz/test_inputs/brisebarre.pip -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/brisebarre.pip Changed

@@ -1,34 +1,34 @@
-# ---------------------- CONTEXT ----------------------
-1 2
-1    0
-
--1
-
-# ----------------------- DOMAIN ----------------------
-26 6
-1    3    0    0     0    -98300
-1   -3    0    0     0     98308
-1  432   36    6     1 -14757611
-1 -432  -36   -6    -1  14758510
-1   54    9    3     1  -1923190
-1  -54   -9   -3    -1   1923303
-1   48   12    6     3  -1782238
-1  -48  -12   -6    -3   1782339
-1   27    9    6     4  -1045164
-1  -27   -9   -6    -4   1045221
-1  432  180  150   125 -17434139
-1 -432 -180 -150  -125  17435038
-1    6    3    3     3   -252443
-1   -6   -3   -3    -3    252456
-1  432  252  294   343 -18949275
-1 -432 -252 -294  -343  18950174
-1   27   18   24    32  -1234720
-1  -27  -18  -24   -32   1234777
-1   48   36   54    81  -2288453
-1  -48  -36  -54   -81   2288554
-1   54   45   75   125  -2684050
-1  -54  -45  -75  -125   2684163
-1  432  396  726  1331 -22386005
-1 -432 -396 -726 -1331  22386904
-1    3    3    6    12   -162072
-1   -3   -3   -6   -12    162080
+# ---------------------- CONTEXT ----------------------
+1 2
+1    0
+
+-1
+
+# ----------------------- DOMAIN ----------------------
+26 6
+1    3    0    0     0    -98300
+1   -3    0    0     0     98308
+1  432   36    6     1 -14757611
+1 -432  -36   -6    -1  14758510
+1   54    9    3     1  -1923190
+1  -54   -9   -3    -1   1923303
+1   48   12    6     3  -1782238
+1  -48  -12   -6    -3   1782339
+1   27    9    6     4  -1045164
+1  -27   -9   -6    -4   1045221
+1  432  180  150   125 -17434139
+1 -432 -180 -150  -125  17435038
+1    6    3    3     3   -252443
+1   -6   -3   -3    -3    252456
+1  432  252  294   343 -18949275
+1 -432 -252 -294  -343  18950174
+1   27   18   24    32  -1234720
+1  -27  -18  -24   -32   1234777
+1   48   36   54    81  -2288453
+1  -48  -36  -54   -81   2288554
+1   54   45   75   125  -2684050
+1  -54  -45  -75  -125   2684163
+1  432  396  726  1331 -22386005
+1 -432 -396 -726 -1331  22386904
+1    3    3    6    12   -162072
+1   -3   -3   -6   -12    162080

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/atomic.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/atomic.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/atomic.in -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/atomic.in Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/atomic.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/atomic3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/atomic3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/bilinear.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/bilinear.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cholesky.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cholesky.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/0D-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/0D-2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/0D-3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/1point-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/1point-2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/4-param.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/4-param.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/4-param.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/backtrack.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-4.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-5.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-6.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/basic-bounds-6.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/block.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/block.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/block.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/block2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/block3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/block3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/block3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/byu98-1-2-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/byu98-1-2-3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/byu98-1-2-3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/cholesky.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/cholesky.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/cholesky.st Added

@@ -0,0 +1,26 @@
+domain: "n -> { S2i0, i1 : i0 >= 1 and i0 <= n and i1 >= 1 and i1 <= -1 + i0; S1i0 : i0 >= 1 and i0 <= n; S4i0, i1 : i0 >= 1 and i0 <= n and i1 >= 1 + i0 and i1 <= n; S5i0, i1, i2 : i0 >= 1 and i0 <= n and i1 >= 1 + i0 and i1 <= n and i2 >= 1 and i2 <= -1 + i0; S6i0, i1 : i0 >= 1 and i0 <= n and i1 >= 1 + i0 and i1 <= n; S3i0 : i0 >= 1 and i0 <= n }"
+child:
+  context: "n -> {  }"
+  child:
+    schedule: "n -> { S1i0 -> (i0); S4i0, i1 -> (i0); S6i0, i1 -> (i0); S3i0 -> (i0); S5i0, i1, i2 -> (i0); S2i0, i1 -> (i0) }"
+    options: "n -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "n -> { S1i0 }"
+      - filter: "n -> { S2i0, i1 }"
+        child:
+          schedule: "n -> { S2i0, i1 -> (i1) }"
+          options: "n -> { separatei0 }"
+      - filter: "n -> { S3i0 }"
+      - filter: "n -> { S4i0, i1; S5i0, i1, i2; S6i0, i1 }"
+        child:
+          schedule: "n -> { S4i0, i1 -> (i1); S6i0, i1 -> (i1); S5i0, i1, i2 -> (i1) }"
+          options: "n -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "n -> { S4i0, i1 }"
+            - filter: "n -> { S5i0, i1, i2 }"
+              child:
+                schedule: "n -> { S5i0, i1, i2 -> (i2) }"
+                options: "n -> { separatei0 }"
+            - filter: "n -> { S6i0, i1 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/cholesky2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/cholesky2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/cholesky2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/christian.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/christian.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/christian.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/classen.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/classen.c Changed

@@ -1,86 +1,63 @@
-{
-  if (m == 1) {
-    S1(0, 1, 1, 1);
-    S8(0, 1);
-  } else if (m >= 2) {
-    S1(0, 1, 1, 1);
-    S3(0, 1, 1, 2, 1, 1, 1, 2);
+if (m >= 1) {
+  S1(0, 1, 1, 1);
+  if (m >= 2) {
     S4(0, 1, 2, 2, 1, 1, 2, 2);
+    S3(0, 1, 1, 2, 1, 1, 1, 2);
     S2(0, 1, 1, 1, 1, 1, 2, 1);
-    S8(0, 1);
-  }
-  for (int c0 = 1; c0 < 2 * m - 3; c0 += 1) {
-    if (c0 + 1 == m) {
-      S5(m - 2, 1, m - 1, 1, m - 1, 1, m, 1);
-      S1(m - 1, 1, m, 1);
-      S3(m - 1, 1, m, 2, m, 1, m, 2);
-    } else if (m >= c0 + 2) {
-      S5(c0 - 1, 1, c0, 1, c0, 1, c0 + 1, 1);
-      S1(c0, 1, c0 + 1, 1);
-      S3(c0, 1, c0 + 1, 2, c0 + 1, 1, c0 + 1, 2);
-      S4(c0, 1, c0 + 2, 2, c0 + 1, 1, c0 + 2, 2);
-      S2(c0, 1, c0 + 1, 1, c0 + 1, 1, c0 + 2, 1);
-    } else {
-      S5(c0 - 1, -m + c0 + 2, c0, -m + c0 + 2, m - 1, -m + c0 + 2, m, -m + c0 + 2);
-      S6(c0 - 1, -m + c0 + 1, c0, -m + c0 + 2, m, -m + c0 + 1, m, -m + c0 + 2);
-      S1(c0, -m + c0 + 2, m, -m + c0 + 2);
-      S3(c0, -m + c0 + 2, c0 + 1, -m + c0 + 3, m, -m + c0 + 2, m, -m + c0 + 3);
-    }
-    for (int c2 = max(2, -m + c0 + 3); c2 <= min(m - 1, c0); c2 += 1) {
-      S5(c0 - 1, c2, c0, c2, c0 - c2 + 1, c2, c0 - c2 + 2, c2);
-      S7(c0 - 1, c2 - 1, c0 + 1, c2, c0 - c2 + 2, c2 - 1, c0 - c2 + 3, c2);
-      S6(c0 - 1, c2 - 1, c0, c2, c0 - c2 + 2, c2 - 1, c0 - c2 + 2, c2);
-      S1(c0, c2, c0 - c2 + 2, c2);
-      S3(c0, c2, c0 + 1, c2 + 1, c0 - c2 + 2, c2, c0 - c2 + 2, c2 + 1);
-      S4(c0, c2, c0 + 2, c2 + 1, c0 - c2 + 2, c2, c0 - c2 + 3, c2 + 1);
-      S2(c0, c2, c0 + 1, c2, c0 - c2 + 2, c2, c0 - c2 + 3, c2);
-    }
-    if (c0 + 1 == m) {
-      S7(m - 2, m - 1, m, m, 1, m - 1, 2, m);
-      S6(m - 2, m - 1, m - 1, m, 1, m - 1, 1, m);
-      S1(m - 1, m, 1, m);
-      S2(m - 1, m, m, m, 1, m, 2, m);
-    } else if (c0 >= m) {
-      S5(c0 - 1, m, c0, m, -m + c0 + 1, m, -m + c0 + 2, m);
-      S7(c0 - 1, m - 1, c0 + 1, m, -m + c0 + 2, m - 1, -m + c0 + 3, m);
-      S6(c0 - 1, m - 1, c0, m, -m + c0 + 2, m - 1, -m + c0 + 2, m);
-      S1(c0, m, -m + c0 + 2, m);
-      S2(c0, m, c0 + 1, m, -m + c0 + 2, m, -m + c0 + 3, m);
-    } else {
-      S7(c0 - 1, c0, c0 + 1, c0 + 1, 1, c0, 2, c0 + 1);
-      S6(c0 - 1, c0, c0, c0 + 1, 1, c0, 1, c0 + 1);
-      S1(c0, c0 + 1, 1, c0 + 1);
-      S3(c0, c0 + 1, c0 + 1, c0 + 2, 1, c0 + 1, 1, c0 + 2);
-      S4(c0, c0 + 1, c0 + 2, c0 + 2, 1, c0 + 1, 2, c0 + 2);
-      S2(c0, c0 + 1, c0 + 1, c0 + 1, 1, c0 + 1, 2, c0 + 1);
-    }
-    for (int c8 = max(1, -m + c0 + 2); c8 <= min(m, c0 + 1); c8 += 1)
-      S8(c0, c8);
   }
-  if (m >= 2) {
-    if (m >= 3) {
-      S5(2 * m - 4, m - 1, 2 * m - 3, m - 1, m - 1, m - 1, m, m - 1);
-      S6(2 * m - 4, m - 2, 2 * m - 3, m - 1, m, m - 2, m, m - 1);
-      S1(2 * m - 3, m - 1, m, m - 1);
-      S3(2 * m - 3, m - 1, 2 * m - 2, m, m, m - 1, m, m);
-      S5(2 * m - 4, m, 2 * m - 3, m, m - 2, m, m - 1, m);
-      S7(2 * m - 4, m - 1, 2 * m - 2, m, m - 1, m - 1, m, m);
-      S6(2 * m - 4, m - 1, 2 * m - 3, m, m - 1, m - 1, m - 1, m);
-      S1(2 * m - 3, m, m - 1, m);
+  S8(0, 1);
+  for (int c0 = 1; c0 < 2 * m - 1; c0 += 1) {
+    if (2 * m >= c0 + 3) {
+      if (c0 + 1 == m) {
+        S5(m - 2, 1, m - 1, 1, m - 1, 1, m, 1);
+        S1(m - 1, 1, m, 1);
+        S3(m - 1, 1, m, 2, m, 1, m, 2);
+      } else if (c0 >= m) {
+        S5(c0 - 1, -m + c0 + 2, c0, -m + c0 + 2, m - 1, -m + c0 + 2, m, -m + c0 + 2);
+        S6(c0 - 1, -m + c0 + 1, c0, -m + c0 + 2, m, -m + c0 + 1, m, -m + c0 + 2);
+        S1(c0, -m + c0 + 2, m, -m + c0 + 2);
+        S3(c0, -m + c0 + 2, c0 + 1, -m + c0 + 3, m, -m + c0 + 2, m, -m + c0 + 3);
+      } else {
+        S5(c0 - 1, 1, c0, 1, c0, 1, c0 + 1, 1);
+        S1(c0, 1, c0 + 1, 1);
+        S3(c0, 1, c0 + 1, 2, c0 + 1, 1, c0 + 1, 2);
+        S4(c0, 1, c0 + 2, 2, c0 + 1, 1, c0 + 2, 2);
+        S2(c0, 1, c0 + 1, 1, c0 + 1, 1, c0 + 2, 1);
+      }
+      for (int c1 = max(2, -m + c0 + 3); c1 <= min(m - 1, c0); c1 += 1) {
+        S5(c0 - 1, c1, c0, c1, c0 - c1 + 1, c1, c0 - c1 + 2, c1);
+        S6(c0 - 1, c1 - 1, c0, c1, c0 - c1 + 2, c1 - 1, c0 - c1 + 2, c1);
+        S7(c0 - 1, c1 - 1, c0 + 1, c1, c0 - c1 + 2, c1 - 1, c0 - c1 + 3, c1);
+        S1(c0, c1, c0 - c1 + 2, c1);
+        S3(c0, c1, c0 + 1, c1 + 1, c0 - c1 + 2, c1, c0 - c1 + 2, c1 + 1);
+        S4(c0, c1, c0 + 2, c1 + 1, c0 - c1 + 2, c1, c0 - c1 + 3, c1 + 1);
+        S2(c0, c1, c0 + 1, c1, c0 - c1 + 2, c1, c0 - c1 + 3, c1);
+      }
+      if (c0 + 1 == m) {
+        S6(m - 2, m - 1, m - 1, m, 1, m - 1, 1, m);
+        S7(m - 2, m - 1, m, m, 1, m - 1, 2, m);
+        S1(m - 1, m, 1, m);
+        S2(m - 1, m, m, m, 1, m, 2, m);
+      } else if (c0 >= m) {
+        S5(c0 - 1, m, c0, m, -m + c0 + 1, m, -m + c0 + 2, m);
+        S6(c0 - 1, m - 1, c0, m, -m + c0 + 2, m - 1, -m + c0 + 2, m);
+        S7(c0 - 1, m - 1, c0 + 1, m, -m + c0 + 2, m - 1, -m + c0 + 3, m);
+        S1(c0, m, -m + c0 + 2, m);
+        S2(c0, m, c0 + 1, m, -m + c0 + 2, m, -m + c0 + 3, m);
+      } else {
+        S6(c0 - 1, c0, c0, c0 + 1, 1, c0, 1, c0 + 1);
+        S7(c0 - 1, c0, c0 + 1, c0 + 1, 1, c0, 2, c0 + 1);
+        S1(c0, c0 + 1, 1, c0 + 1);
+        S3(c0, c0 + 1, c0 + 1, c0 + 2, 1, c0 + 1, 1, c0 + 2);
+        S4(c0, c0 + 1, c0 + 2, c0 + 2, 1, c0 + 1, 2, c0 + 2);
+        S2(c0, c0 + 1, c0 + 1, c0 + 1, 1, c0 + 1, 2, c0 + 1);
+      }
     } else {
-      S5(0, 1, 1, 1, 1, 1, 2, 1);
-      S1(1, 1, 2, 1);
-      S3(1, 1, 2, 2, 2, 1, 2, 2);
-      S7(0, 1, 2, 2, 1, 1, 2, 2);
-      S6(0, 1, 1, 2, 1, 1, 1, 2);
-      S1(1, 2, 1, 2);
+      S5(2 * m - 3, m, 2 * m - 2, m, m - 1, m, m, m);
+      S6(2 * m - 3, m - 1, 2 * m - 2, m, m, m - 1, m, m);
+      S1(2 * m - 2, m, m, m);
     }
-    S2(2 * m - 3, m, 2 * m - 2, m, m - 1, m, m, m);
-    for (int c8 = m - 1; c8 <= m; c8 += 1)
-      S8(2 * m - 3, c8);
-    S5(2 * m - 3, m, 2 * m - 2, m, m - 1, m, m, m);
-    S6(2 * m - 3, m - 1, 2 * m - 2, m, m, m - 1, m, m);
-    S1(2 * m - 2, m, m, m);
-    S8(2 * m - 2, m);
+    for (int c2 = max(1, -m + c0 + 2); c2 <= min(m, c0 + 1); c2 += 1)
+      S8(c0, c2);
   }
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/classen.st Added

@@ -0,0 +1,24 @@
+domain: "m -> { S2coordT1, coordP1, 1 + coordT1, coordP1, 2 + coordT1 - coordP1, coordP1, 3 + coordT1 - coordP1, coordP1 : m >= 1 and coordT1 <= -3 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= m and coordP1 >= 3 - m + coordT1 and coordP1 >= 1; S4coordT1, coordP1, 2 + coordT1, 1 + coordP1, 2 + coordT1 - coordP1, coordP1, 3 + coordT1 - coordP1, 1 + coordP1 : m >= 1 and coordT1 <= -4 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= -1 + m and coordP1 >= 3 - m + coordT1 and coordP1 >= 1; S6coordT1, coordP1, 1 + coordT1, 1 + coordP1, 2 + coordT1 - coordP1, coordP1, 2 + coordT1 - coordP1, 1 + coordP1 : m >= 1 and coordT1 <= -3 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= -1 + m and coordP1 >= 2 - m + coordT1 and coordP1 >= 1; S1coordT1, coordP1, 2 + coordT1 - coordP1, coordP1 : m >= 1 and coordP1 >= 2 - m + coordT1 and coordP1 <= 1 + coordT1 and coordP1 <= m and coordP1 >= 1; S8coordT1, coordP1 : coordT1 <= -2 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= m and coordP1 >= 2 - m + coordT1 and coordP1 >= 1; S5coordT1, coordP1, 1 + coordT1, coordP1, 2 + coordT1 - coordP1, coordP1, 3 + coordT1 - coordP1, coordP1 : m >= 1 and coordT1 <= -3 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= m and coordP1 >= 3 - m + coordT1 and coordP1 >= 1; S7coordT1, coordP1, 2 + coordT1, 1 + coordP1, 2 + coordT1 - coordP1, coordP1, 3 + coordT1 - coordP1, 1 + coordP1 : m >= 1 and coordT1 <= -4 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= -1 + m and coordP1 >= 3 - m + coordT1 and coordP1 >= 1; S3coordT1, coordP1, 1 + coordT1, 1 + coordP1, 2 + coordT1 - coordP1, coordP1, 2 + coordT1 - coordP1, 1 + coordP1 : m >= 1 and coordT1 <= -3 + 2m and coordT1 >= 0 and coordP1 <= 1 + coordT1 and coordP1 <= -1 + m and coordP1 >= 2 - m + coordT1 and coordP1 >= 1 }"
+child:
+  context: "m -> {  : m >= 0 }"
+  child:
+    schedule: "m -> { S7i0, i1, i2, i3, i4, i5, i6, i7 -> (1 + i0); S4i0, i1, i2, i3, i4, i5, i6, i7 -> (i0); S8i0, i1 -> (i0); S3i0, i1, i2, i3, i4, i5, i6, i7 -> (i0); S1i0, i1, i2, i3 -> (i0); S2i0, i1, i2, i3, i4, i5, i6, i7 -> (i0); S5i0, i1, i2, i3, i4, i5, i6, i7 -> (1 + i0); S6i0, i1, i2, i3, i4, i5, i6, i7 -> (1 + i0) }"
+    options: "m -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "m -> { S2i0, i1, i2, i3, i4, i5, i6, i7; S6i0, i1, i2, i3, i4, i5, i6, i7; S4i0, i1, i2, i3, i4, i5, i6, i7; S1i0, i1, i2, i3; S7i0, i1, i2, i3, i4, i5, i6, i7; S5i0, i1, i2, i3, i4, i5, i6, i7; S3i0, i1, i2, i3, i4, i5, i6, i7 }"
+        child:
+          schedule: "m -> { S7i0, i1, i2, i3, i4, i5, i6, i7 -> (i3); S4i0, i1, i2, i3, i4, i5, i6, i7 -> (i1); S3i0, i1, i2, i3, i4, i5, i6, i7 -> (i1); S1i0, i1, i2, i3 -> (i1); S2i0, i1, i2, i3, i4, i5, i6, i7 -> (i1); S5i0, i1, i2, i3, i4, i5, i6, i7 -> (i3); S6i0, i1, i2, i3, i4, i5, i6, i7 -> (i3) }"
+          options: "m -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "m -> { S6i0, i1, i2, i3, i4, i5, i6, i7; S5i0, i1, i2, i3, i4, i5, i6, i7; S7i0, i1, i2, i3, i4, i5, i6, i7 }"
+              child:
+                schedule: "m -> { S7i0, i1, i2, i3, i4, i5, i6, i7 -> (i4); S5i0, i1, i2, i3, i4, i5, i6, i7 -> (i4); S6i0, i1, i2, i3, i4, i5, i6, i7 -> (i4) }, { S7i0, i1, i2, i3, i4, i5, i6, i7 -> (i5); S5i0, i1, i2, i3, i4, i5, i6, i7 -> (i5); S6i0, i1, i2, i3, i4, i5, i6, i7 -> (i5) }"
+                options: "m -> { separatei0 }"
+            - filter: "m -> { S1i0, i1, i2, i3 }"
+            - filter: "m -> { S2i0, i1, i2, i3, i4, i5, i6, i7; S4i0, i1, i2, i3, i4, i5, i6, i7; S3i0, i1, i2, i3, i4, i5, i6, i7 }"
+              child:
+                schedule: "m -> { S4i0, i1, i2, i3, i4, i5, i6, i7 -> (i4); S3i0, i1, i2, i3, i4, i5, i6, i7 -> (i4); S2i0, i1, i2, i3, i4, i5, i6, i7 -> (i4) }, { S4i0, i1, i2, i3, i4, i5, i6, i7 -> (i5); S3i0, i1, i2, i3, i4, i5, i6, i7 -> (i5); S2i0, i1, i2, i3, i4, i5, i6, i7 -> (i5) }"
+                options: "m -> { separatei0 }"
+      - filter: "m -> { S8i0, i1 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/classen2.st Added

@@ -0,0 +1,6 @@
+domain: "outerTimeTileScatter, outerProcTileScatter1, outerProcTileScatter2, M, N -> { S1compIter1, compIter2, compIter3, 2compIter1 + compIter2 + compIter3, 1 + compIter1 + compIter2 + compIter3, 1 + compIter1 + compIter2 : N >= 3 and compIter3 <= 3 + 5outerProcTileScatter1 - compIter1 - compIter2 and compIter2 >= -1 + 5outerProcTileScatter2 - compIter1 and M >= 2 and compIter3 <= 4 + 5outerTimeTileScatter - 2compIter1 - compIter2 and compIter2 <= 3 + 5outerProcTileScatter2 - compIter1 and compIter3 >= 1 and compIter3 <= -2 + N and compIter2 >= 1 and compIter2 <= -2 + N and compIter1 >= 1 and compIter1 <= -1 + M and compIter3 >= 5outerTimeTileScatter - 2compIter1 - compIter2 and compIter3 >= -1 + 5outerProcTileScatter1 - compIter1 - compIter2 }"
+child:
+  context: "outerTimeTileScatter, outerProcTileScatter1, outerProcTileScatter2, M, N -> {  }"
+  child:
+    schedule: "outerTimeTileScatter, outerProcTileScatter1, outerProcTileScatter2, M, N -> { S1i0, i1, i2, i3, i4, i5 -> (i3) }, { S1i0, i1, i2, i3, i4, i5 -> (i4) }, { S1i0, i1, i2, i3, i4, i5 -> (i5) }"
+    options: "outerTimeTileScatter, outerProcTileScatter1, outerProcTileScatter2, M, N -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/constant.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/constant.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/constant.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/constbound.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/constbound.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/constbound.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/darte.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dealII.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dealII.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dealII.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/donotsimp.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/donotsimp.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/donotsimp.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dot.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dot.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dot.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/dot2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dot2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/dot2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/durbin_e_s.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/durbin_e_s.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/durbin_e_s.st Added

@@ -0,0 +1,16 @@
+domain: "{ S2i0, -7, 0 : i0 >= 2 and i0 <= 10; S41, 0, 0; S6i0, -9 + i0, 2 : i0 >= 2 and i0 <= 10; S110, i1, 4 : i1 >= 1 and i1 <= 10; S5i0, i1, 3 : i1 <= -1 + i0 and i0 <= 10 and i1 >= 1; S71, 0, 0; S8i0, 0, 3 : i0 >= 1 and i0 <= 9; S3i0, i1, 1 : i1 >= -7 and i0 <= 10 and i1 <= -9 + i0 }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S6i0, i1, i2 -> (i0); S8i0, i1, i2 -> (i0); S5i0, i1, i2 -> (i0); S4i0, i1, i2 -> (i0); S7i0, i1, i2 -> (i0); S3i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0); S2i0, i1, i2 -> (i0) }, { S6i0, i1, i2 -> (i1); S8i0, i1, i2 -> (i1); S5i0, i1, i2 -> (i1); S4i0, i1, i2 -> (i1); S7i0, i1, i2 -> (i1); S3i0, i1, i2 -> (i1); S1i0, i1, i2 -> (i1); S2i0, i1, i2 -> (i1) }, { S6i0, i1, i2 -> (i2); S8i0, i1, i2 -> (i2); S5i0, i1, i2 -> (i2); S4i0, i1, i2 -> (i2); S7i0, i1, i2 -> (i2); S3i0, i1, i2 -> (i2); S1i0, i1, i2 -> (i2); S2i0, i1, i2 -> (i2) }"
+    options: "{ separatei0 }"
+    child:
+      sequence:
+      - filter: "{ S1i0, i1, i2 }"
+      - filter: "{ S2i0, i1, i2 }"
+      - filter: "{ S3i0, i1, i2 }"
+      - filter: "{ S4i0, i1, i2 }"
+      - filter: "{ S5i0, i1, i2 }"
+      - filter: "{ S6i0, i1, i2 }"
+      - filter: "{ S7i0, i1, i2 }"
+      - filter: "{ S8i0, i1, i2 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/emploi.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/equality.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/equality.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/equality.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/equality2.st Added

@@ -0,0 +1,10 @@
+domain: "{ S1i0, i1, 1, 2, i0, i5, -999 + i1, i0, -999 + i1, i9, i10 : 2i5 = 2 + i1 and 2i9 = -998 + i1 and 2i10 = -998 + i1 and i0 >= 1 and i0 <= 10000 and i1 >= 1000 and i1 <= 1016; S2i0, i1, -1999 + 2i1, 1, i0, -1000 + 2i1, 1, 2, i0, -499 + i1, -1999 + 2i1, i0, -1999 + 2i1, -999 + i1, -999 + i1 : i0 >= 1 and i0 <= 10000 and i1 >= 1000 and i1 <= 1008 }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i0); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i0) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i1); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i1) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i2); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i2) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i3); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i3) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i4); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i4) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i5); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i5) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i6); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i6) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i7); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i7) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i8); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i8) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i9); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i9) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (i10); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i10) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (0); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i11) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (0); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i12) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (0); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i13) }, { S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 -> (0); S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 -> (i14) }"
+    options: "{ atomici0 }"
+    child:
+      sequence:
+      - filter: "{ S1i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10 }"
+      - filter: "{ S2i0, i1, i2, i3, i4, i5, i6, i7, i8, i9, i10, i11, i12, i13, i14 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/esced.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/ex1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/ex1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/ex1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/faber.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/faber.c Changed

@@ -1,155 +1,147 @@
-{
-  for (int c0 = 0; c0 <= 36; c0 += 1) {
-    for (int c1 = -6; c1 < c0 / 14 - 5; c1 += 1) {
-      for (int c2 = -((-2 * c1 + 3) / 5) + 9; c2 <= c1 + 12; c2 += 1)
-        S6(c0, c1, c2);
-      for (int c2 = c1 + 24; c2 <= -2 * c1 + 24; c2 += 1)
-        S2(c0, c1, c2);
-      for (int c2 = -2 * c1 + 30; c2 <= c1 + 48; c2 += 1)
-        S1(c0, c1, c2);
-    }
-    for (int c1 = c0 / 14 - 5; c1 < 0; c1 += 1) {
-      if (c1 >= -3 && 2 * c0 >= 7 * c1 + 42)
-        S7(c0, c1, 6);
-      for (int c2 = max(c1 - (6 * c0 + 77) / 77 + 13, -((-2 * c1 + 3) / 5) + 9); c2 <= c1 + 12; c2 += 1)
-        S6(c0, c1, c2);
-      for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 + 48; c2 += 1)
-        S1(c0, c1, c2);
-    }
-    S3(c0, 0, 0);
-    S10(c0, 0, 0);
-    for (int c2 = 1; c2 <= 5; c2 += 1)
-      S3(c0, 0, c2);
-    for (int c2 = 6; c2 <= 2 * c0 / 21 + 4; c2 += 1) {
-      S3(c0, 0, c2);
-      S7(c0, 0, c2);
-    }
-    for (int c2 = max(6, 2 * c0 / 21 + 5); c2 <= -((6 * c0 + 77) / 77) + 12; c2 += 1)
-      S3(c0, 0, c2);
-    for (int c2 = -((6 * c0 + 77) / 77) + 13; c2 <= 12; c2 += 1) {
-      S3(c0, 0, c2);
-      S6(c0, 0, c2);
-    }
-    for (int c2 = 13; c2 <= 24; c2 += 1)
-      S3(c0, 0, c2);
-    for (int c2 = -((3 * c0 + 14) / 14) + 49; c2 <= 48; c2 += 1)
-      S1(c0, 0, c2);
-    for (int c1 = 1; c1 <= 18; c1 += 1) {
-      for (int c2 = -8 * c1; c2 <= min(6, -8 * c1 + 24); c2 += 1)
-        S3(c0, c1, c2);
-      if (c1 == 2) {
-        S3(c0, 2, 7);
-      } else if (c0 >= 35 && c1 == 1) {
-        S3(c0, 1, 7);
-        S7(c0, 1, 7);
-      } else if (c0 <= 34 && c1 == 1)
-        S3(c0, 1, 7);
-      for (int c2 = 8; c2 <= min(-8 * c1 + 24, c1 - (6 * c0 + 77) / 77 + 12); c2 += 1)
-        S3(c0, c1, c2);
-      for (int c2 = max(-8 * c1 + 25, c1 - (6 * c0 + 77) / 77 + 13); c2 <= c1 + 12; c2 += 1)
-        S6(c0, c1, c2);
-      if (c1 == 1) {
-        for (int c2 = -((6 * c0 + 77) / 77) + 14; c2 <= 13; c2 += 1) {
-          S3(c0, 1, c2);
-          S6(c0, 1, c2);
-        }
-        for (int c2 = 14; c2 <= 16; c2 += 1)
-          S3(c0, 1, c2);
-      }
-      for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 + 48; c2 += 1)
-        S1(c0, c1, c2);
-    }
-    for (int c1 = 19; c1 <= 24; c1 += 1) {
-      for (int c2 = -8 * c1; c2 <= -8 * c1 + 24; c2 += 1)
-        S3(c0, c1, c2);
-      for (int c2 = c1 - (6 * c0 + 77) / 77 + 13; c2 <= 30; c2 += 1)
-        S6(c0, c1, c2);
-    }
+for (int c0 = 0; c0 <= 36; c0 += 1) {
+  for (int c1 = -6; c1 < c0 / 14 - 5; c1 += 1) {
+    for (int c2 = -((-2 * c1 + 3) / 5) + 9; c2 <= c1 + 12; c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = c1 + 24; c2 <= -2 * c1 + 24; c2 += 1)
+      S2(c0, c1, c2);
+    for (int c2 = -2 * c1 + 30; c2 <= c1 + 48; c2 += 1)
+      S1(c0, c1, c2);
   }
-  for (int c0 = 37; c0 <= 218; c0 += 1) {
-    for (int c1 = (c0 + 5) / 14 - 8; c1 < min(0, c0 / 14 - 5); c1 += 1) {
-      if (c0 <= 46 && c1 == -3)
-        S7(c0, -3, 6);
-      if (-77 * ((-3 * c1 + 1) / 5) + 447 >= 6 * c0)
-        S6(c0, c1, -((-2 * c1 + 3) / 5) + 9);
-      for (int c2 = c1 + 24; c2 <= -2 * c1 + 24; c2 += 1)
-        S2(c0, c1, c2);
-      for (int c2 = -2 * c1 + 30; c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
-        S1(c0, c1, c2);
+  for (int c1 = c0 / 14 - 5; c1 < 0; c1 += 1) {
+    if (c1 >= -3 && 2 * c0 >= 7 * c1 + 42)
+      S7(c0, c1, 6);
+    for (int c2 = max(c1 - (6 * c0 + 77) / 77 + 13, -((-2 * c1 + 3) / 5) + 9); c2 <= c1 + 12; c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 + 48; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  S3(c0, 0, 0);
+  S10(c0, 0, 0);
+  for (int c2 = 1; c2 <= 5; c2 += 1)
+    S3(c0, 0, c2);
+  for (int c2 = 6; c2 <= 2 * c0 / 21 + 4; c2 += 1) {
+    S3(c0, 0, c2);
+    S7(c0, 0, c2);
+  }
+  for (int c2 = max(6, 2 * c0 / 21 + 5); c2 <= -((6 * c0 + 77) / 77) + 12; c2 += 1)
+    S3(c0, 0, c2);
+  for (int c2 = -((6 * c0 + 77) / 77) + 13; c2 <= 12; c2 += 1) {
+    S3(c0, 0, c2);
+    S6(c0, 0, c2);
+  }
+  for (int c2 = 13; c2 <= 24; c2 += 1)
+    S3(c0, 0, c2);
+  for (int c2 = -((3 * c0 + 14) / 14) + 49; c2 <= 48; c2 += 1)
+    S1(c0, 0, c2);
+  for (int c1 = 1; c1 <= 18; c1 += 1) {
+    for (int c2 = -8 * c1; c2 <= min(6, -8 * c1 + 24); c2 += 1)
+      S3(c0, c1, c2);
+    if (c0 <= 34 && c1 == 1) {
+      S3(c0, 1, 7);
+    } else if (c1 == 2) {
+      S3(c0, 2, 7);
+    } else if (c0 >= 35 && c1 == 1) {
+      S3(c0, 1, 7);
+      S7(c0, 1, 7);
     }
-    if (c0 <= 148)
-      for (int c1 = max(0, (c0 + 5) / 14 - 8); c1 < c0 / 14 - 5; c1 += 1) {
-        if (c1 == 0)
-          S2(c0, 0, 24);
-        for (int c2 = max(c1 + 24, -2 * c1 + 30); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
-          S1(c0, c1, c2);
+    for (int c2 = 8; c2 <= min(-8 * c1 + 24, c1 - (6 * c0 + 77) / 77 + 12); c2 += 1)
+      S3(c0, c1, c2);
+    if (c1 == 1) {
+      for (int c2 = -((6 * c0 + 77) / 77) + 14; c2 <= 13; c2 += 1) {
+        S3(c0, 1, c2);
+        S6(c0, 1, c2);
       }
-    if (c0 >= 79 && c0 % 14 >= 9) {
-      for (int c2 = max((c0 - 70) / 14 + 24, (c0 - 70) / 14 - (3 * c0 + 14) / 14 + 49); c2 <= (c0 - 70) / 14 - (3 * c0 + 17) / 14 + 56; c2 += 1)
-        S1(c0, c0 / 14 - 5, c2);
-    } else if (c0 <= 69 && c0 % 14 >= 9) {
-      if (c0 <= 41)
-        S7(c0, -3, 6);
-      S6(c0, c0 / 14 - 5, 8);
-      for (int c2 = -((-c0 + 83) / 14) - (3 * c0 + 14) / 14 + 49; c2 <= -((-c0 + 83) / 14) - (3 * c0 + 17) / 14 + 56; c2 += 1)
-        S1(c0, c0 / 14 - 5, c2);
-    }
-    for (int c1 = (c0 + 5) / 14 - 5; c1 < 0; c1 += 1) {
-      if (7 * c1 + 114 >= 2 * c0)
-        S7(c0, c1, 6);
-      for (int c2 = max(8, c1 - (6 * c0 + 77) / 77 + 13); c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1)
-        S6(c0, c1, c2);
-      for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
-        S1(c0, c1, c2);
+      for (int c2 = 14; c2 <= 16; c2 += 1)
+        S3(c0, 1, c2);
     }
-    for (int c1 = max(0, (c0 + 5) / 14 - 5); c1 < c0 / 14 - 2; c1 += 1) {
-      for (int c2 = max(c1, -2 * c1 + 6); c2 <= min(-2 * c1 + 24, (2 * c0 - 7 * c1 - 10) / 21 + 1); c2 += 1)
-        S9(c0, c1, c2);
-      if (c1 >= 1 && c1 <= 6 && 14 * c1 + 46 >= c0)
-        S9(c0, c1, c1 + 5);
-      for (int c2 = max(c1 + 6, (2 * c0 - 7 * c1 - 10) / 21 + 2); c2 <= (2 * c1 + 1) / 5 + 7; c2 += 1) {
-        S7(c0, c1, c2);
-        S9(c0, c1, c2);
-      }
-      if (c1 <= 3 && 7 * c1 + 21 * ((2 * c1 + 41) / 5) >= 2 * c0 + 12)
-        S9(c0, c1, (2 * c1 + 1) / 5 + 8);
-      for (int c2 = (2 * c1 + 1) / 5 + 9; c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1) {
-        S6(c0, c1, c2);
-        S9(c0, c1, c2);
-      }
-      for (int c2 = max(max(c1 + 6, c1 - (6 * c0 + 91) / 77 + 16), (2 * c0 - 7 * c1 - 10) / 21 + 2); c2 <= -2 * c1 + 24; c2 += 1)
-        S9(c0, c1, c2);
-      for (int c2 = max(c1, -2 * c1 + 30); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
-        S8(c0, c1, c2);
-      for (int c2 = max(c1 + 24, c1 - (3 * c0 + 14) / 14 + 49); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
+    for (int c2 = max(-8 * c1 + 25, c1 - (6 * c0 + 77) / 77 + 13); c2 <= c1 + 12; c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 + 48; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  for (int c1 = 19; c1 <= 24; c1 += 1) {
+    for (int c2 = -8 * c1; c2 <= -8 * c1 + 24; c2 += 1)
+      S3(c0, c1, c2);
+    for (int c2 = c1 - (6 * c0 + 77) / 77 + 13; c2 <= 30; c2 += 1)
+      S6(c0, c1, c2);
+  }
+}
+for (int c0 = 37; c0 <= 218; c0 += 1) {
+  for (int c1 = (c0 + 5) / 14 - 8; c1 < min(0, c0 / 14 - 5); c1 += 1) {
+    if (c0 <= 46 && c1 == -3)
+      S7(c0, -3, 6);
+    if (77 * c1 + 77 * ((-2 * c1 - 2) / 5) + 524 >= 6 * c0)
+      S6(c0, c1, -((-2 * c1 + 3) / 5) + 9);
+    for (int c2 = c1 + 24; c2 <= -2 * c1 + 24; c2 += 1)
+      S2(c0, c1, c2);
+    for (int c2 = -2 * c1 + 30; c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  if (c0 <= 148)
+    for (int c1 = max(0, (c0 + 5) / 14 - 8); c1 < c0 / 14 - 5; c1 += 1) {
+      if (c1 == 0)
+        S2(c0, 0, 24);
+      for (int c2 = max(c1 + 24, -2 * c1 + 30); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
         S1(c0, c1, c2);
     }
-    for (int c1 = c0 / 14 - 2; c1 <= 18; c1 += 1) {
-      for (int c2 = c1 + 6; c2 <= min((2 * c1 + 1) / 5 + 7, floord(2 * c0 - 7 * c1, 21) + 4); c2 += 1)
-        S7(c0, c1, c2);
-      for (int c2 = max(6, (c0 + 5) / 14 + 1); c2 <= min(min(c1, c0 / 14 + 3), -c1 + c1 / 2 + 18); c2 += 1)
-        S5(c0, c1, c2);
-      for (int c2 = max(max(c1 + 6, c1 - (6 * c0 + 77) / 77 + 13), (2 * c1 + 1) / 5 + 9); c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1)
-        S6(c0, c1, c2);
-      for (int c2 = max(c1 + (3 * c0 + 3) / 14 - 40, -c1 + (c1 + 1) / 2 + 21); c2 <= min(c1, c1 + 3 * c0 / 14 - 33); c2 += 1)
-        S4(c0, c1, c2);
-      for (int c2 = max(c1, c1 - (3 * c0 + 14) / 14 + 40); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
-        S8(c0, c1, c2);
-      for (int c2 = max(c1 + 24, c1 - (3 * c0 + 14) / 14 + 49); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
-        S1(c0, c1, c2);
+  if (c0 >= 70 && c0 % 14 >= 9)
+    for (int c2 = max((c0 + 5) / 14 + 18, -((3 * c0 + 14) / 14) + c0 / 14 + 44); c2 <= -((3 * c0 + 17) / 14) + c0 / 14 + 51; c2 += 1)
+      S1(c0, c0 / 14 - 5, c2);
+  for (int c1 = c0 / 14 - 5; c1 < 0; c1 += 1) {
+    if (7 * c1 + 114 >= 2 * c0)
+      S7(c0, c1, 6);
+    for (int c2 = max(8, c1 - (6 * c0 + 77) / 77 + 13); c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = c1 - (3 * c0 + 14) / 14 + 49; c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  for (int c1 = max(0, (c0 + 5) / 14 - 5); c1 < c0 / 14 - 2; c1 += 1) {
+    for (int c2 = max(c1, -2 * c1 + 6); c2 <= min(c1 + 5, -2 * c1 + 24); c2 += 1)
+      S9(c0, c1, c2);
+    for (int c2 = c1 + 6; c2 <= min((2 * c1 + 1) / 5 + 7, (2 * c0 - 7 * c1 - 10) / 21 + 1); c2 += 1)
+      S9(c0, c1, c2);
+    for (int c2 = max(c1 + 6, (2 * c0 - 7 * c1 - 10) / 21 + 2); c2 <= (2 * c1 + 1) / 5 + 7; c2 += 1) {
+      S7(c0, c1, c2);
+      S9(c0, c1, c2);
     }
-    for (int c1 = 19; c1 <= 24; c1 += 1) {
-      for (int c2 = max(c1 - 12, (c0 + 5) / 14 + 1); c2 <= min(c0 / 14 + 3, -c1 + c1 / 2 + 18); c2 += 1)
-        S5(c0, c1, c2);
-      for (int c2 = max(max(c1 - 12, c1 + (3 * c0 + 3) / 14 - 40), -c1 + (c1 + 1) / 2 + 21); c2 <= min(c1, c1 + 3 * c0 / 14 - 33); c2 += 1)
-        S4(c0, c1, c2);
-      for (int c2 = max(c1 + 6, c1 - (6 * c0 + 77) / 77 + 13); c2 <= min(30, c1 - (6 * c0 + 91) / 77 + 15); c2 += 1)
-        S6(c0, c1, c2);
-      for (int c2 = max(c1, c1 - (3 * c0 + 14) / 14 + 40); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
-        S8(c0, c1, c2);
+    if (c1 <= 3)
+      S9(c0, c1, (2 * c1 + 1) / 5 + 8);
+    for (int c2 = (2 * c1 + 1) / 5 + 9; c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1) {
+      S6(c0, c1, c2);
+      S9(c0, c1, c2);
     }
-    for (int c1 = 25; c1 <= min(42, -((3 * c0 + 17) / 14) + 71); c1 += 1)
-      for (int c2 = max(c1 - 12, c1 + (3 * c0 + 3) / 14 - 40); c2 <= min(min(30, c1), c1 + 3 * c0 / 14 - 33); c2 += 1)
-        S4(c0, c1, c2);
+    for (int c2 = max(max(c1 + 6, c1 - (6 * c0 + 91) / 77 + 16), (2 * c1 + 1) / 5 + 9); c2 <= -2 * c1 + 24; c2 += 1)
+      S9(c0, c1, c2);
+    for (int c2 = max(c1, -2 * c1 + 30); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
+      S8(c0, c1, c2);
+    for (int c2 = max(c1 + 24, c1 - (3 * c0 + 14) / 14 + 49); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  for (int c1 = c0 / 14 - 2; c1 <= 18; c1 += 1) {
+    for (int c2 = max(6, (c0 + 5) / 14 + 1); c2 <= min(min(c1, c0 / 14 + 3), -c1 + c1 / 2 + 18); c2 += 1)
+      S5(c0, c1, c2);
+    for (int c2 = max(c1 + (3 * c0 + 3) / 14 - 40, -c1 + (c1 + 1) / 2 + 21); c2 <= min(c1, c1 + 3 * c0 / 14 - 33); c2 += 1)
+      S4(c0, c1, c2);
+    for (int c2 = c1 + 6; c2 <= min((2 * c1 + 1) / 5 + 7, (2 * c0 - 7 * c1 + 63) / 21 + 1); c2 += 1)
+      S7(c0, c1, c2);
+    for (int c2 = max(max(c1 + 6, c1 - (6 * c0 + 77) / 77 + 13), (2 * c1 + 1) / 5 + 9); c2 <= c1 - (6 * c0 + 91) / 77 + 15; c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = max(c1, c1 - (3 * c0 + 14) / 14 + 40); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
+      S8(c0, c1, c2);
+    for (int c2 = max(c1 + 24, c1 - (3 * c0 + 14) / 14 + 49); c2 <= c1 - (3 * c0 + 17) / 14 + 56; c2 += 1)
+      S1(c0, c1, c2);
+  }
+  for (int c1 = 19; c1 <= 24; c1 += 1) {
+    for (int c2 = max(c1 - 12, (c0 + 5) / 14 + 1); c2 <= min(c0 / 14 + 3, -c1 + c1 / 2 + 18); c2 += 1)
+      S5(c0, c1, c2);
+    for (int c2 = max(max(c1 - 12, c1 + (3 * c0 + 3) / 14 - 40), -c1 + (c1 + 1) / 2 + 21); c2 <= min(c1, c1 + 3 * c0 / 14 - 33); c2 += 1)
+      S4(c0, c1, c2);
+    for (int c2 = max(c1 + 6, c1 - (6 * c0 + 77) / 77 + 13); c2 <= min(30, c1 - (6 * c0 + 91) / 77 + 15); c2 += 1)
+      S6(c0, c1, c2);
+    for (int c2 = max(c1, c1 - (3 * c0 + 14) / 14 + 40); c2 <= min(c1 + 24, c1 - (3 * c0 + 17) / 14 + 47); c2 += 1)
+      S8(c0, c1, c2);
   }
+  for (int c1 = 25; c1 <= min(42, -((3 * c0 + 17) / 14) + 71); c1 += 1)
+    for (int c2 = max(c1 - 12, c1 + (3 * c0 + 3) / 14 - 40); c2 <= min(min(30, c1), c1 + 3 * c0 / 14 - 33); c2 += 1)
+      S4(c0, c1, c2);
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/faber.st Added

@@ -0,0 +1,18 @@
+domain: "{ S2idx4, idx5, idx6 : 14idx5 <= -84 + idx4 and 14idx5 >= -120 + idx4 and idx6 >= 24 + idx5 and idx6 <= 48 + idx5 and idx5 >= -6 and idx5 <= 18 and idx6 <= 24 - 2idx5; S4idx4, idx5, idx6 : 14idx6 <= -462 + 3idx4 + 14idx5 and 14idx6 >= -570 + 3idx4 + 14idx5 and idx6 <= idx5 and idx6 >= -12 + idx5 and idx6 >= 6 and idx6 <= 30 and 2idx6 >= 42 - idx5; S6idx4, idx5, idx6 : 77idx6 >= 924 - 6idx4 + 77idx5 and 77idx6 <= 1140 - 6idx4 + 77idx5 and idx6 <= 12 + idx5 and idx6 >= 6 + idx5 and idx6 >= 6 and idx6 <= 30 and 5idx6 >= 42 + 2idx5; S1idx4, idx5, idx6 : 14idx6 >= 672 - 3idx4 + 14idx5 and 14idx6 <= 780 - 3idx4 + 14idx5 and idx6 >= 24 + idx5 and idx6 <= 48 + idx5 and idx5 >= -6 and idx5 <= 18 and idx6 >= 30 - 2idx5; S5idx4, idx5, idx6 : 14idx6 <= 42 + idx4 and 14idx6 >= 6 + idx4 and idx6 <= idx5 and idx6 >= -12 + idx5 and idx6 >= 6 and idx6 <= 30 and 2idx6 <= 36 - idx5; S7idx4, idx5, idx6 : 21idx6 <= 84 + 2idx4 - 7idx5 and 21idx6 >= 12 + 2idx4 - 7idx5 and idx6 <= 12 + idx5 and idx6 >= 6 + idx5 and idx6 >= 6 and idx6 <= 30 and 5idx6 <= 36 + 2idx5; S8idx4, idx5, idx6 : 14idx6 >= 546 - 3idx4 + 14idx5 and 14idx6 <= 654 - 3idx4 + 14idx5 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 >= 30 - 2idx5; S3idx4, idx5, idx6 : idx4 >= 0 and idx4 <= 36 and idx6 >= -8idx5 and idx6 <= 24 - 8idx5 and idx5 >= 0 and idx5 <= 24; S9idx4, idx5, idx6 : 14idx5 <= -42 + idx4 and 14idx5 >= -78 + idx4 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 <= 24 - 2idx5 and idx6 >= 6 - 2idx5; S10idx4, idx5, idx6 : 7idx6 <= idx4 - 28idx5 and 7idx6 >= -36 + idx4 - 28idx5 and idx6 >= idx5 and idx6 <= 24 + idx5 and idx5 >= 0 and idx5 <= 24 and idx6 <= -2idx5 }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S6idx4, idx5, idx6 -> (idx4); S8idx4, idx5, idx6 -> (idx4); S5idx4, idx5, idx6 -> (idx4); S9idx4, idx5, idx6 -> (idx4); S4idx4, idx5, idx6 -> (idx4); S10idx4, idx5, idx6 -> (idx4); S7idx4, idx5, idx6 -> (idx4); S3idx4, idx5, idx6 -> (idx4); S1idx4, idx5, idx6 -> (idx4); S2idx4, idx5, idx6 -> (idx4) }, { S6idx4, idx5, idx6 -> (idx5); S8idx4, idx5, idx6 -> (idx5); S5idx4, idx5, idx6 -> (idx5); S9idx4, idx5, idx6 -> (idx5); S4idx4, idx5, idx6 -> (idx5); S10idx4, idx5, idx6 -> (idx5); S7idx4, idx5, idx6 -> (idx5); S3idx4, idx5, idx6 -> (idx5); S1idx4, idx5, idx6 -> (idx5); S2idx4, idx5, idx6 -> (idx5) }, { S6idx4, idx5, idx6 -> (idx6); S8idx4, idx5, idx6 -> (idx6); S5idx4, idx5, idx6 -> (idx6); S9idx4, idx5, idx6 -> (idx6); S4idx4, idx5, idx6 -> (idx6); S10idx4, idx5, idx6 -> (idx6); S7idx4, idx5, idx6 -> (idx6); S3idx4, idx5, idx6 -> (idx6); S1idx4, idx5, idx6 -> (idx6); S2idx4, idx5, idx6 -> (idx6) }"
+    options: "{ separatei0 }"
+    child:
+      sequence:
+      - filter: "{ S1idx4, idx5, idx6 }"
+      - filter: "{ S2idx4, idx5, idx6 }"
+      - filter: "{ S3idx4, idx5, idx6 }"
+      - filter: "{ S4idx4, idx5, idx6 }"
+      - filter: "{ S5idx4, idx5, idx6 }"
+      - filter: "{ S6idx4, idx5, idx6 }"
+      - filter: "{ S7idx4, idx5, idx6 }"
+      - filter: "{ S8idx4, idx5, idx6 }"
+      - filter: "{ S9idx4, idx5, idx6 }"
+      - filter: "{ S10idx4, idx5, idx6 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-1-1-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-1-1-2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-1-1-2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-2-1-2-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-2-1-2-3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-2-1-2-3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/forwardsub-3-1-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-3-1-2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/forwardsub-3-1-2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gauss.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gauss.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gauss.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced2.c Changed

@@ -1,20 +1,18 @@
-{
-  for (int c0 = 1; c0 <= 4; c0 += 1)
-    for (int c1 = 5; c1 < M - 9; c1 += 1)
-      S1(c0, c1);
-  for (int c0 = 5; c0 < M - 9; c0 += 1) {
-    for (int c1 = -c0 + 1; c1 <= 4; c1 += 1)
-      S2(c0 + c1, c0);
-    for (int c1 = 5; c1 <= min(M - 10, M - c0); c1 += 1) {
-      S1(c0, c1);
-      S2(c0 + c1, c0);
-    }
-    for (int c1 = M - c0 + 1; c1 < M - 9; c1 += 1)
-      S1(c0, c1);
-    for (int c1 = M - 9; c1 <= M - c0; c1 += 1)
-      S2(c0 + c1, c0);
+for (int c0 = 1; c0 <= 4; c0 += 1)
+  for (int c1 = 5; c1 < M - 9; c1 += 1)
+    S1(c0, c1);
+for (int c0 = 5; c0 < M - 9; c0 += 1) {
+  for (int c1 = -c0 + 1; c1 <= 4; c1 += 1)
+    S2(c0 + c1, c0);
+  for (int c1 = 5; c1 <= min(M - 10, M - c0); c1 += 1) {
+    S2(c0 + c1, c0);
+    S1(c0, c1);
   }
-  for (int c0 = M - 9; c0 <= M; c0 += 1)
-    for (int c1 = 5; c1 < M - 9; c1 += 1)
-      S1(c0, c1);
+  for (int c1 = M - c0 + 1; c1 < M - 9; c1 += 1)
+    S1(c0, c1);
+  for (int c1 = M - 9; c1 <= M - c0; c1 += 1)
+    S2(c0 + c1, c0);
 }
+for (int c0 = M - 9; c0 <= M; c0 += 1)
+  for (int c1 = 5; c1 < M - 9; c1 += 1)
+    S1(c0, c1);

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/gesced3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/gesced3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/guide.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/guide.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/guide.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/iftest.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/iftest2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/infinite2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/infinite2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/infinite2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/jacobi-shared.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/jacobi-shared.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/jacobi-shared.st Added

@@ -0,0 +1,6 @@
+domain: "T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1i0, i1 : exists (e0 = floor((-1 + h0)/2), e1 = floor((-32b0 + g1)/2048), e2 = floor((-32b1 + g2)/1024), e3 = floor((-15 - t0 + i0)/16), e4 = floor((-31 - t1 + i1)/32): g0 = h0 and 2e0 = -1 + h0 and 2048e1 = -32b0 + g1 and 1024e2 = -32b1 + g2 and 16e3 = -15 - t0 + i0 and 32e4 = -31 - t1 + i1 and h0 >= 1 and h0 <= -1 + 2T and i0 >= 2 and i0 <= -2 + N and i1 >= 2 and i1 <= -2 + N and b1 <= 31 and b1 >= 0 and b0 <= 63 and b0 >= 0 and i1 <= 31 + g2 and i1 >= g2 and N >= 4 and i0 >= g1 and i0 <= 31 + g1 and g2 <= -2 + N and g2 >= -29 and g1 <= -2 + N and g1 >= -29 and g1 >= 32b0 and g2 >= 32b1 and 32b0 <= -2 + N and 32b1 <= -2 + N and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 31) }"
+child:
+  context: "T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> {  : exists (e0 = floor((-32b0 + g1)/2048), e1 = floor((-32b1 + g2)/1024): g0 = h0 and 2048e0 = -32b0 + g1 and 1024e1 = -32b1 + g2 and g2 <= -2 + N and g2 >= -29 and g1 <= -2 + N and g1 >= -29 and b1 >= 0 and b1 <= 31 and b0 <= 63 and 32b1 <= -2 + N and 32b0 <= -2 + N and b0 >= 0 and N >= 4 and h0 >= 0 and h0 <= -1 + 2T and g2 >= 32b1 and g1 >= 32b0 and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 31) }"
+  child:
+    schedule: "T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1i0, i1 -> (1 - g1 + i0) }, { S1i0, i1 -> (1 - g2 + i1) }, { S1i0, i1 -> (t0) }, { S1i0, i1 -> (t1) }"
+    options: "T, N, h0, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { separatex : x >= 3 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/largeur.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/levenshtein-1-2-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/levenshtein-1-2-3.c Changed

@@ -1,32 +1,30 @@
-{
-  S1(0, 0);
-  for (int c0 = 1; c0 <= N; c0 += 1) {
-    S2(c0, 0);
-    for (int c1 = 1; c1 < c0; c1 += 1)
-      S6(c0, c1);
-    S3(c0, c0);
+S1(0, 0);
+for (int c0 = 1; c0 <= N; c0 += 1) {
+  S2(c0, 0);
+  for (int c1 = 1; c1 < c0; c1 += 1)
+    S6(c0, c1);
+  S3(c0, c0);
+}
+S7(N + 1, 0);
+for (int c1 = 1; c1 <= N; c1 += 1) {
+  S6(N + 1, c1);
+  S8(N + 1, c1);
+}
+for (int c0 = N + 2; c0 < 2 * M - N - 1; c0 += 1) {
+  S7(c0, -N + (N + c0 + 1) / 2 - 1);
+  if ((N + c0) % 2 == 0) {
+    S5(c0, (-N + c0) / 2);
+    S8(c0, (-N + c0) / 2);
   }
-  S7(N + 1, 0);
-  for (int c1 = 1; c1 <= N; c1 += 1) {
-    S6(N + 1, c1);
-    S8(N + 1, c1);
+  for (int c1 = -N + (N + c0) / 2 + 1; c1 < (N + c0 + 1) / 2; c1 += 1) {
+    S6(c0, c1);
+    S8(c0, c1);
   }
-  for (int c0 = N + 2; c0 < 2 * M - N - 1; c0 += 1) {
-    S7(c0, -N + (N + c0 + 1) / 2 - 1);
-    if ((-N + c0) % 2 == 0) {
-      S5(c0, (-N + c0) / 2);
-      S8(c0, (-N + c0) / 2);
-    }
-    for (int c1 = -N + (N + c0) / 2 + 1; c1 < (N + c0 + 1) / 2; c1 += 1) {
-      S6(c0, c1);
-      S8(c0, c1);
-    }
-    if ((-N + c0) % 2 == 0) {
-      S4(c0, (N + c0) / 2);
-      S8(c0, (N + c0) / 2);
-    }
+  if ((N + c0) % 2 == 0) {
+    S4(c0, (N + c0) / 2);
+    S8(c0, (N + c0) / 2);
   }
-  for (int c0 = 2 * M - N - 1; c0 < 2 * M - 1; c0 += 1)
-    for (int c1 = -M + c0 + 1; c1 < M; c1 += 1)
-      S6(c0, c1);
 }
+for (int c0 = 2 * M - N - 1; c0 < 2 * M - 1; c0 += 1)
+  for (int c1 = -M + c0 + 1; c1 < M; c1 += 1)
+    S6(c0, c1);

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/levenshtein-1-2-3.st Added

@@ -0,0 +1,16 @@
+domain: "M, N -> { S5i0, i1 : 2i1 = -N + i0 and i0 >= 2 + N and i0 <= -2 + 2M - N and N >= 1; S3i0, i0 : i0 >= 1 and i0 <= N and N <= -2 + M; S7i0, i1 : i0 >= 1 + N and 2i1 <= -1 - N + i0 and i0 <= -2 + 2M - N and 2i1 >= -2 - N + i0 and N <= -2 + M and N >= 1; S6i0, i1 : 2i1 <= -1 + N + i0 and i1 <= -1 + i0 and i1 >= 1 - M + i0 and 2i1 >= 1 - N + i0 and i1 >= 1 and i1 <= -1 + M and N <= -2 + M; S10, 0 : N <= -2 + M and N >= 1; S2i0, 0 : i0 >= 1 and i0 <= N and N <= -2 + M; S4i0, i1 : 2i1 = N + i0 and i0 >= 2 + N and i0 <= -2 + 2M - N and N >= 1; S8i0, i1 : i0 >= 1 + N and 2i1 <= N + i0 and 2i1 >= -N + i0 and i0 <= -2 + 2M - N and N <= -2 + M and N >= 1 }"
+child:
+  context: "M, N -> {  : N <= -2 + M and N >= 1 }"
+  child:
+    schedule: "M, N -> { S7i0, i1 -> (i0); S5i0, i1 -> (i0); S1i0, i1 -> (i0); S3i0, i1 -> (i0); S2i0, i1 -> (i0); S4i0, i1 -> (i0); S8i0, i1 -> (i0); S6i0, i1 -> (i0) }, { S7i0, i1 -> (i1); S5i0, i1 -> (i1); S1i0, i1 -> (i1); S3i0, i1 -> (i1); S2i0, i1 -> (i1); S4i0, i1 -> (i1); S8i0, i1 -> (i1); S6i0, i1 -> (i1) }"
+    options: "M, N -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M, N -> { S1i0, i1 }"
+      - filter: "M, N -> { S2i0, i1 }"
+      - filter: "M, N -> { S3i0, i1 }"
+      - filter: "M, N -> { S4i0, i1 }"
+      - filter: "M, N -> { S5i0, i1 }"
+      - filter: "M, N -> { S6i0, i1 }"
+      - filter: "M, N -> { S7i0, i1 }"
+      - filter: "M, N -> { S8i0, i1 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lex.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lineality-1-2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/lineality-2-1-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lineality-2-1-2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lineality-2-1-2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/logo.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/logo.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/logo.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/logopar.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/logopar.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/logopar.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lu.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lu2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/lux.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/merge.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/merge.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/merge.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/min-1-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/min-2-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/min-3-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/min-4-1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mod.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mod2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mod3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mod4.st Added

@@ -0,0 +1,11 @@
+domain: "{ S1j, div41, div42, 2, mod6_a : 3mod6_a = -2 + j and j >= 1 and j <= 10 and 3div41 >= j and 3div42 >= -1 + j and 3div42 <= 1 + j and 3div41 <= 2 + j; S2j, div41, div42, 2, mod6_a : 3div42 = 1 + j and 3mod6_a = -2 + j and 3div41 >= 1 + j and 3div41 <= 2 + j and j >= 1 and j <= 10; S3j, div41, div42, 2, mod6_a : 3mod6_a = -2 + j and j >= 1 and j <= 10 and 3div41 >= j and 3div42 >= -1 + j and 3div42 <= 1 + j and 3div41 <= 2 + j }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S1j, div41, div42, mod6, mod6_a -> (j); S3j, div41, div42, mod6, mod6_a -> (j); S2j, div41, div42, mod6, mod6_a -> (j) }, { S1j, div41, div42, mod6, mod6_a -> (div41); S3j, div41, div42, mod6, mod6_a -> (div41); S2j, div41, div42, mod6, mod6_a -> (div41) }, { S1j, div41, div42, mod6, mod6_a -> (div42); S3j, div41, div42, mod6, mod6_a -> (div42); S2j, div41, div42, mod6, mod6_a -> (div42) }, { S1j, div41, div42, mod6, mod6_a -> (mod6); S3j, div41, div42, mod6, mod6_a -> (mod6); S2j, div41, div42, mod6, mod6_a -> (mod6) }, { S1j, div41, div42, mod6, mod6_a -> (mod6_a); S3j, div41, div42, mod6, mod6_a -> (mod6_a); S2j, div41, div42, mod6, mod6_a -> (mod6_a) }"
+    options: "{ separatei0 }"
+    child:
+      sequence:
+      - filter: "{ S1j, div41, div42, mod6, mod6_a }"
+      - filter: "{ S2j, div41, div42, mod6, mod6_a }"
+      - filter: "{ S3j, div41, div42, mod6, mod6_a }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mode.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/multi-mm-1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/multi-stride.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/multi-stride.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/multi-stride.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/multi-stride2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/mxm-shared.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mxm-shared.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/mxm-shared.st Added

@@ -0,0 +1,6 @@
+domain: "N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1g0 + t1, i1 : (exists (e0 = floor((g1)/128), e1 = floor((128b1 - g1)/4096), e2 = floor((-8b0 + g0)/128), e3 = floor((-t0 + i1)/16): g3 = 128b1 and g4 = 0 and g2 = 8b0 and 128e0 = g1 and 4096e1 = 128b1 - g1 and 128e2 = -8b0 + g0 and 16e3 = -t0 + i1 and b0 <= 15 and b0 >= 0 and b1 <= 31 and b1 >= 0 and g0 >= 8b0 and g1 >= 128b1 and t0 <= 15 and t0 >= 0 and t1 <= 7 and t1 >= 0 and t1 <= -1 + N - g0 and i1 >= g1 and i1 <= 127 + g1 and i1 <= -1 + N)) or (exists (e0 = floor((g1)/128), e1 = floor((128b1 - g1)/4096), e2 = floor((g4)/4), e3 = floor((-8b0 + g0)/128), e4 = floor((-t0 + i1)/16): g3 = 128b1 and g2 = 8b0 and 128e0 = g1 and 4096e1 = 128b1 - g1 and 4e2 = g4 and 128e3 = -8b0 + g0 and 16e4 = -t0 + i1 and b0 <= 15 and b0 >= 0 and b1 <= 31 and b1 >= 0 and g0 >= 8b0 and g1 >= 128b1 and g4 >= 0 and g4 <= -1 + N and t0 <= 15 and t0 >= 0 and t1 <= 7 and t1 >= 0 and t1 <= -1 + N - g0 and i1 >= g1 and i1 <= 127 + g1 and i1 <= -1 + N)) }"
+child:
+  context: "N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> {  : exists (e0 = floor((g0)/8), e1 = floor((-128b1 + g1)/4096), e2 = floor((8b0 - g0)/128): g2 = 8b0 and g3 = 128b1 and 8e0 = g0 and 4096e1 = -128b1 + g1 and 128e2 = 8b0 - g0 and b0 >= 0 and g4 <= -1 + N and b0 <= 15 and g1 <= -1 + N and g4 >= 0 and b1 <= 31 and g0 <= -1 + N and g1 >= 128b1 and b1 >= 0 and g0 >= 8b0 and t0 >= 0 and t0 <= 15 and t1 >= 0 and t1 <= 15) }"
+  child:
+    schedule: "N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { S1i0, i1 -> (-g1 + i1) }, { S1i0, i1 -> (t1) }, { S1i0, i1 -> (t0) }, { S1i0, i1 -> (t1) }"
+    options: "N, b0, b1, g0, g1, g2, g3, g4, t0, t1 -> { separatei0 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/no_lindep.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_basic1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_basic2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_complex1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_complex1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_complex1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/nul_lcpc.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_lcpc.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/nul_lcpc.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/orc.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/orc.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/orc.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/otl.st Added

@@ -0,0 +1,6 @@
+domain: "M, N -> { S1outerTimeTileIter, outerProcTileIter1, outerProcTileIter2, innerTimeTileIter, innerProcTileIter1, outerProcTileIter2 : 5outerTimeTileIter <= -7 + 2M + 2N and innerProcTileIter1 >= outerTimeTileIter - outerProcTileIter2 and 10outerProcTileIter2 >= -2 - N + 5outerTimeTileIter and outerProcTileIter2 >= -1 + outerTimeTileIter - outerProcTileIter1 and 2innerProcTileIter1 >= outerTimeTileIter and outerTimeTileIter >= 1 and outerProcTileIter1 >= 1 and 2outerProcTileIter1 >= outerTimeTileIter and outerProcTileIter2 >= 0 and 5outerProcTileIter2 >= 1 - M - N + 5outerTimeTileIter and 5innerProcTileIter1 >= -1 - M + 5outerTimeTileIter and innerTimeTileIter >= outerTimeTileIter and 5outerProcTileIter1 >= -2 - M + 5outerTimeTileIter and innerTimeTileIter >= 1 and 5innerTimeTileIter >= -3 - N + 5outerProcTileIter1 + 5outerProcTileIter2 and 5outerProcTileIter2 <= 4 + N + 5outerTimeTileIter - 5outerProcTileIter1 and innerProcTileIter1 >= 1 and outerProcTileIter2 <= outerTimeTileIter and 5innerTimeTileIter >= -2N + 10outerProcTileIter1 and 5outerProcTileIter1 <= -5 + M + 2N and 10outerProcTileIter1 <= 1 + 2N + 5outerTimeTileIter and 5outerProcTileIter2 >= -1 - N + 5outerProcTileIter1 and innerProcTileIter1 >= outerProcTileIter1 and innerTimeTileIter >= outerProcTileIter1 and outerProcTileIter2 <= outerProcTileIter1 and outerProcTileIter1 <= outerTimeTileIter and 5innerProcTileIter1 <= 4 + N - 5outerProcTileIter2 + 5innerTimeTileIter and 5innerProcTileIter1 <= 5 + N + 5outerTimeTileIter - 5outerProcTileIter2 and 5innerTimeTileIter >= -2 - N + 10outerProcTileIter2 and 5outerProcTileIter2 <= -2 + M + N and 10outerProcTileIter2 <= 3 + N + 5outerTimeTileIter and N >= 4 and innerProcTileIter1 >= outerProcTileIter2 and innerTimeTileIter >= outerProcTileIter2 and M >= 3 and innerProcTileIter1 <= outerTimeTileIter and 5innerTimeTileIter <= -6 + 2M + 2N and innerProcTileIter1 >= -1 - outerProcTileIter2 + innerTimeTileIter and 5innerTimeTileIter <= 3 + N + 10outerProcTileIter2 and innerTimeTileIter <= 1 + outerProcTileIter1 + outerProcTileIter2 and innerProcTileIter1 <= 1 + outerProcTileIter1 and 2innerProcTileIter1 >= innerTimeTileIter and 5innerProcTileIter1 <= 2 + N + 5outerProcTileIter2 and innerTimeTileIter <= 1 + 2outerProcTileIter1 and innerProcTileIter1 <= innerTimeTileIter and 5innerTimeTileIter <= M + N + 5outerProcTileIter2 and 5innerProcTileIter1 >= -2 - M + 5innerTimeTileIter and 10innerProcTileIter1 <= 3 + 2N + 5outerTimeTileIter and innerTimeTileIter <= 1 + outerTimeTileIter and 5innerTimeTileIter <= 3 + M + 5outerProcTileIter1 and 5innerProcTileIter1 <= -4 + M + 2N and 10innerProcTileIter1 <= 2 + 2N + 5innerTimeTileIter }"
+child:
+  context: "M, N -> {  : M >= 1 and N >= 1 }"
+  child:
+    schedule: "M, N -> { S1i0, i1, i2, i3, i4, i5 -> (i0) }, { S1i0, i1, i2, i3, i4, i5 -> (i1) }, { S1i0, i1, i2, i3, i4, i5 -> (i2) }, { S1i0, i1, i2, i3, i4, i5 -> (i3) }, { S1i0, i1, i2, i3, i4, i5 -> (i4) }, { S1i0, i1, i2, i3, i4, i5 -> (i5) }"
+    options: "M, N -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/param-split.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/param-split.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/param-split.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/pouchet.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/pouchet.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/pouchet.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/rectangle.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-QR.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-QR.c Changed

@@ -1,53 +1,53 @@
 if (N >= 1) {
   S1(0);
   if (N == 1) {
-    for (int c3 = 0; c3 < M; c3 += 1)
-      S2(0, c3);
+    for (int c1 = 0; c1 < M; c1 += 1)
+      S2(0, c1);
     S3(0);
-    for (int c3 = 0; c3 < M; c3 += 1)
-      S4(0, c3);
+    for (int c1 = 0; c1 < M; c1 += 1)
+      S4(0, c1);
     S10(0);
     S5(0);
   } else {
-    for (int c3 = 0; c3 < M; c3 += 1)
-      S2(0, c3);
+    for (int c1 = 0; c1 < M; c1 += 1)
+      S2(0, c1);
     S3(0);
-    for (int c3 = 0; c3 < M; c3 += 1)
-      S4(0, c3);
+    for (int c1 = 0; c1 < M; c1 += 1)
+      S4(0, c1);
     S10(0);
     S1(1);
     S5(0);
   }
-  for (int c1 = 2; c1 < N; c1 += 1) {
-    for (int c3 = c1 - 1; c3 < N; c3 += 1) {
-      S6(c1 - 2, c3);
-      for (int c5 = c1 - 2; c5 < M; c5 += 1)
-        S7(c1 - 2, c3, c5);
-      S8(c1 - 2, c3);
-      for (int c5 = c1 - 2; c5 < M; c5 += 1)
-        S9(c1 - 2, c3, c5);
+  for (int c0 = 2; c0 < N; c0 += 1) {
+    for (int c1 = c0 - 1; c1 < N; c1 += 1) {
+      S6(c0 - 2, c1);
+      for (int c2 = c0 - 2; c2 < M; c2 += 1)
+        S7(c0 - 2, c1, c2);
+      S8(c0 - 2, c1);
+      for (int c2 = c0 - 2; c2 < M; c2 += 1)
+        S9(c0 - 2, c1, c2);
     }
-    for (int c3 = c1 - 1; c3 < M; c3 += 1)
-      S2(c1 - 1, c3);
-    S3(c1 - 1);
-    for (int c3 = c1 - 1; c3 < M; c3 += 1)
-      S4(c1 - 1, c3);
-    S10(c1 - 1);
-    S1(c1);
-    S5(c1 - 1);
+    for (int c1 = c0 - 1; c1 < M; c1 += 1)
+      S2(c0 - 1, c1);
+    S3(c0 - 1);
+    for (int c1 = c0 - 1; c1 < M; c1 += 1)
+      S4(c0 - 1, c1);
+    S10(c0 - 1);
+    S1(c0);
+    S5(c0 - 1);
   }
   if (N >= 2) {
     S6(N - 2, N - 1);
-    for (int c5 = N - 2; c5 < M; c5 += 1)
-      S7(N - 2, N - 1, c5);
+    for (int c2 = N - 2; c2 < M; c2 += 1)
+      S7(N - 2, N - 1, c2);
     S8(N - 2, N - 1);
-    for (int c5 = N - 2; c5 < M; c5 += 1)
-      S9(N - 2, N - 1, c5);
-    for (int c3 = N - 1; c3 < M; c3 += 1)
-      S2(N - 1, c3);
+    for (int c2 = N - 2; c2 < M; c2 += 1)
+      S9(N - 2, N - 1, c2);
+    for (int c1 = N - 1; c1 < M; c1 += 1)
+      S2(N - 1, c1);
     S3(N - 1);
-    for (int c3 = N - 1; c3 < M; c3 += 1)
-      S4(N - 1, c3);
+    for (int c1 = N - 1; c1 < M; c1 += 1)
+      S4(N - 1, c1);
     S10(N - 1);
     S5(N - 1);
   }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-QR.st Added

@@ -0,0 +1,36 @@
+domain: "M, N -> { S5i0 : i0 >= 0 and i0 <= -1 + N; S1i0 : i0 >= 0 and i0 <= -1 + N; S3i0 : i0 >= 0 and i0 <= -1 + N; S2i0, i1 : i0 >= 0 and i0 <= -1 + N and i1 >= i0 and i1 <= -1 + M; S6i0, i1 : i0 >= 0 and i1 >= 1 + i0 and i1 <= -1 + N; S9i0, i1, i2 : i0 >= 0 and i1 >= 1 + i0 and i1 <= -1 + N and i2 >= i0 and i2 <= -1 + M; S4i0, i1 : i0 >= 0 and i0 <= -1 + N and i1 >= i0 and i1 <= -1 + M; S8i0, i1 : i0 >= 0 and i1 >= 1 + i0 and i1 <= -1 + N; S10i0 : i0 >= 0 and i0 <= -1 + N; S7i0, i1, i2 : i0 >= 0 and i1 >= 1 + i0 and i1 <= -1 + N and i2 >= i0 and i2 <= -1 + M }"
+child:
+  context: "M, N -> {  }"
+  child:
+    schedule: "M, N -> { S3i0 -> (1 + i0); S10i0 -> (1 + i0); S5i0 -> (1 + i0); S7i0, i1, i2 -> (2 + i0); S9i0, i1, i2 -> (2 + i0); S2i0, i1 -> (1 + i0); S4i0, i1 -> (1 + i0); S8i0, i1 -> (2 + i0); S1i0 -> (i0); S6i0, i1 -> (2 + i0) }"
+    options: "M, N -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M, N -> { S6i0, i1; S9i0, i1, i2; S8i0, i1; S7i0, i1, i2 }"
+        child:
+          schedule: "M, N -> { S7i0, i1, i2 -> (i1); S9i0, i1, i2 -> (i1); S8i0, i1 -> (i1); S6i0, i1 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N -> { S6i0, i1 }"
+            - filter: "M, N -> { S7i0, i1, i2 }"
+              child:
+                schedule: "M, N -> { S7i0, i1, i2 -> (i2) }"
+                options: "M, N -> { separatei0 }"
+            - filter: "M, N -> { S8i0, i1 }"
+            - filter: "M, N -> { S9i0, i1, i2 }"
+              child:
+                schedule: "M, N -> { S9i0, i1, i2 -> (i2) }"
+                options: "M, N -> { separatei0 }"
+      - filter: "M, N -> { S2i0, i1 }"
+        child:
+          schedule: "M, N -> { S2i0, i1 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+      - filter: "M, N -> { S3i0 }"
+      - filter: "M, N -> { S4i0, i1 }"
+        child:
+          schedule: "M, N -> { S4i0, i1 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+      - filter: "M, N -> { S10i0 }"
+      - filter: "M, N -> { S1i0 }"
+      - filter: "M, N -> { S5i0 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-bastoul3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-cholesky2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-cholesky2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-cholesky2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-fusion1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-fusion1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-fusion1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-fusion2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-fusion2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-fusion2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-jacobi2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-jacobi2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-jacobi2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-jacobi3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-jacobi3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-jacobi3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam3.c Changed

@@ -1,11 +1,11 @@
-for (int c1 = 5; c1 <= 5 * M; c1 += 1) {
-  for (int c3 = max(2, floord(-M + c1, 4)); c3 < min(M, (c1 + 1) / 3 - 2); c3 += 1)
-    for (int c5 = max(1, -M - c3 + (M + c1) / 2 - 2); c5 < min(c3, -2 * c3 + (c1 + c3) / 2 - 2); c5 += 1)
-      S1(c1 - 2 * c3 - 2 * c5 - 5, c3, c5);
-  for (int c3 = max(1, floord(-M + c1, 4)); c3 < (c1 + 1) / 5; c3 += 1)
-    S2(c1 - 4 * c3 - 3, c3);
-  if (c1 % 5 == 0)
-    S4(c1 / 5);
-  for (int c3 = max(-3 * M - c1 + 3 * ((M + c1) / 2) + 1, -((c1 - 1) % 3) + 3); c3 < (c1 + 1) / 5; c3 += 3)
-    S3((c1 - 2 * c3 - 1) / 3, c3);
+for (int c0 = 5; c0 <= 5 * M; c0 += 1) {
+  for (int c1 = max(2, floord(-M + c0, 4)); c1 < min(-((5 * M - c0 + 1) % 2) + M, (c0 + 1) / 3 - 2); c1 += 1)
+    for (int c2 = max(1, -M - c1 + (M + c0) / 2 - 2); c2 < min(c1, -2 * c1 + (c0 + c1) / 2 - 2); c2 += 1)
+      S1(c0 - 2 * c1 - 2 * c2 - 5, c1, c2);
+  for (int c1 = max(1, floord(-M + c0, 4)); c1 < (c0 + 1) / 5; c1 += 1)
+    S2(c0 - 4 * c1 - 3, c1);
+  if (c0 % 5 == 0)
+    S4(c0 / 5);
+  for (int c1 = max(-3 * M - c0 + 3 * ((M + c0) / 2) + 1, -((c0 - 1) % 3) + 3); c1 < (c0 + 1) / 5; c1 += 3)
+    S3((c0 - 2 * c1 - 1) / 3, c1);
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam3.st Added

@@ -0,0 +1,23 @@
+domain: "M -> { S4i0 : i0 >= 1 and i0 <= M; S3i0, i1 : i0 <= M and i1 >= 1 and i1 <= -1 + i0; S2i0, i1 : i0 <= M and i1 >= 1 and i1 <= -1 + i0; S1i0, i1, i2 : i0 <= M and i1 <= -1 + i0 and i2 >= 1 and i2 <= -1 + i1 }"
+child:
+  context: "M -> {  : M >= 1 }"
+  child:
+    schedule: "M -> { S4i0 -> (5i0); S1i0, i1, i2 -> (5 + i0 + 2i1 + 2i2); S3i0, i1 -> (1 + 3i0 + 2i1); S2i0, i1 -> (3 + i0 + 4i1) }"
+    options: "M -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M -> { S1i0, i1, i2 }"
+        child:
+          schedule: "M -> { S1i0, i1, i2 -> (i1) }"
+          options: "M -> { separatei0 }"
+          child:
+            schedule: "M -> { S1i0, i1, i2 -> (i2) }"
+            options: "M -> { separatei0 }"
+      - filter: "M -> { S2i0, i1 }"
+        child:
+          schedule: "M -> { S2i0, i1 -> (i1) }"
+          options: "M -> { separatei0 }"
+      - filter: "M -> { S4i0; S3i0, i1 }"
+        child:
+          schedule: "M -> { S4i0 -> (0); S3i0, i1 -> (i1) }"
+          options: "M -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam4.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam4.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam5.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam5.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-lim-lam6.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam6.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-lim-lam6.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-liu-zhuge1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-liu-zhuge1.c Changed

@@ -1,17 +1,19 @@
 if (M >= 0 && N >= 0)
-  for (int c1 = -4; c1 <= 3 * M + N; c1 += 1) {
-    if (3 * M + N >= c1 + 1 && c1 >= 3 * M) {
-      S2(M, -3 * M + c1);
-    } else if (3 * M >= c1 + 4 && (c1 + 4) % 3 == 0)
-      S1((c1 + 4) / 3, 0);
-    for (int c3 = max(-3 * M + c1 + 3, (c1 + 6) % 3); c3 <= min(N - 1, c1); c3 += 3) {
-      S2((c1 - c3) / 3, c3);
-      S1(((c1 - c3) / 3) + 1, c3 + 1);
+  for (int c0 = -4; c0 <= 3 * M + N; c0 += 1) {
+    if (3 * M >= c0 + 4 && (c0 + 1) % 3 == 0) {
+      S1((c0 + 4) / 3, 0);
+    } else if (c0 >= 3 * M) {
+      S2(M, -3 * M + c0);
     }
-    if (c1 >= N && (-N + c1) % 3 == 0) {
-      S2((-N + c1) / 3, N);
-    } else if (N >= c1 + 4 && c1 >= -3)
-      S1(0, c1 + 4);
-    for (int c3 = max(-3 * M + c1, (c1 + 6) % 3); c3 <= min(N, c1); c3 += 3)
-      S3((c1 - c3) / 3, c3);
+    for (int c1 = max(-3 * M + c0 + 3, (c0 + 6) % 3); c1 <= min(N - 1, c0); c1 += 3) {
+      S2((c0 - c1) / 3, c1);
+      S1(((c0 - c1) / 3) + 1, c1 + 1);
+    }
+    if (N >= c0 + 4 && c0 >= -3) {
+      S1(0, c0 + 4);
+    } else if (3 * M + N >= c0 + 3 && c0 >= N && (N - c0) % 3 == 0) {
+      S2((-N + c0) / 3, N);
+    }
+    for (int c1 = max(-3 * M + c0, (c0 + 6) % 3); c1 <= min(N, c0); c1 += 3)
+      S3((c0 - c1) / 3, c1);
   }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-liu-zhuge1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner4.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner4.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-loechner5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner5.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-loechner5.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-long.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-long.st Added

@@ -0,0 +1,36 @@
+domain: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S3i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S4i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S2i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M }"
+child:
+  context: "M, N, O, P, Q, R, S, T, U -> {  : M >= 10 and N >= 10 and O >= 10 and P >= 1 and P <= 2 and Q >= 1 and Q <= 2 and R >= 1 and R <= 2 and S >= 0 and S <= 1 and T >= 0 and T <= 1 and U >= 0 and U <= 1 }"
+  child:
+    schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i0); S2i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0); S3i0, i1, i2 -> (i0) }"
+    options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2; S2i0, i1, i2 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i1); S1i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+      - filter: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2; S4i0, i1, i2 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i1); S3i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-interp.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-interp.c Changed

@@ -1,85 +1,83 @@
-{
-  if (N >= 2)
-    for (int c1 = 1; c1 < O; c1 += 1) {
-      for (int c5 = 1; c5 <= M; c5 += 1)
-        S1(c1, 1, c5);
-      for (int c5 = 1; c5 < M; c5 += 1) {
-        S6(c1, 1, c5);
-        S7(c1, 1, c5);
-      }
-      if (N >= 3) {
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S3(c1, 1, c5);
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S1(c1, 2, c5);
-        for (int c5 = 1; c5 < M; c5 += 1) {
-          S6(c1, 2, c5);
-          S7(c1, 2, c5);
-        }
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S11(c1, 1, c5);
-      } else {
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S3(c1, 1, c5);
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S11(c1, 1, c5);
-      }
-      for (int c3 = 3; c3 < 2 * N - 4; c3 += 2) {
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S10(c1, (c3 - 1) / 2, c5);
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S3(c1, (c3 + 1) / 2, c5);
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S1(c1, (c3 + 3) / 2, c5);
-        for (int c5 = 1; c5 < M; c5 += 1) {
-          S6(c1, (c3 + 3) / 2, c5);
-          S7(c1, (c3 + 3) / 2, c5);
-        }
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S11(c1, (c3 + 1) / 2, c5);
+if (N >= 2)
+  for (int c0 = 1; c0 < O; c0 += 1) {
+    for (int c3 = 1; c3 <= M; c3 += 1)
+      S1(c0, 1, c3);
+    for (int c3 = 1; c3 < M; c3 += 1) {
+      S6(c0, 1, c3);
+      S7(c0, 1, c3);
+    }
+    if (N >= 3) {
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S3(c0, 1, c3);
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S1(c0, 2, c3);
+      for (int c3 = 1; c3 < M; c3 += 1) {
+        S6(c0, 2, c3);
+        S7(c0, 2, c3);
       }
-      if (N >= 3) {
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S10(c1, N - 2, c5);
-        for (int c5 = 1; c5 <= M; c5 += 1)
-          S3(c1, N - 1, c5);
-        for (int c5 = 1; c5 < M; c5 += 1)
-          S11(c1, N - 1, c5);
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S11(c0, 1, c3);
+    } else {
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S3(c0, 1, c3);
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S11(c0, 1, c3);
+    }
+    for (int c1 = 3; c1 < 2 * N - 4; c1 += 2) {
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S10(c0, (c1 - 1) / 2, c3);
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S3(c0, (c1 + 1) / 2, c3);
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S1(c0, (c1 + 3) / 2, c3);
+      for (int c3 = 1; c3 < M; c3 += 1) {
+        S6(c0, (c1 + 3) / 2, c3);
+        S7(c0, (c1 + 3) / 2, c3);
       }
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S10(c1, N - 1, c5);
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S11(c0, (c1 + 1) / 2, c3);
     }
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1) {
-      for (int c5 = 1; c5 <= M; c5 += 1)
-        S2(c1, c3, c5);
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S8(c1, c3, c5);
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S9(c1, c3, c5);
+    if (N >= 3) {
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S10(c0, N - 2, c3);
+      for (int c3 = 1; c3 <= M; c3 += 1)
+        S3(c0, N - 1, c3);
+      for (int c3 = 1; c3 < M; c3 += 1)
+        S11(c0, N - 1, c3);
     }
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S4(c1, c3, c5);
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S5(c1, c3, c5);
-  for (int c1 = R; c1 < O; c1 += 1)
-    for (int c3 = Q; c3 < N; c3 += 1)
-      for (int c5 = P; c5 < M; c5 += 1)
-        S12(c1, c3, c5);
-  for (int c1 = R; c1 < O; c1 += 1)
-    for (int c3 = Q; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S13(c1, c3, c5);
-  for (int c1 = R; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = P; c5 < M; c5 += 1)
-        S14(c1, c3, c5);
-  for (int c1 = R; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S15(c1, c3, c5);
-}
+    for (int c3 = 1; c3 < M; c3 += 1)
+      S10(c0, N - 1, c3);
+  }
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1) {
+    for (int c3 = 1; c3 <= M; c3 += 1)
+      S2(c0, c1, c3);
+    for (int c3 = 1; c3 < M; c3 += 1)
+      S8(c0, c1, c3);
+    for (int c3 = 1; c3 < M; c3 += 1)
+      S9(c0, c1, c3);
+  }
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S4(c0, c1, c2);
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S5(c0, c1, c2);
+for (int c0 = R; c0 < O; c0 += 1)
+  for (int c1 = Q; c1 < N; c1 += 1)
+    for (int c2 = P; c2 < M; c2 += 1)
+      S12(c0, c1, c2);
+for (int c0 = R; c0 < O; c0 += 1)
+  for (int c1 = Q; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S13(c0, c1, c2);
+for (int c0 = R; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = P; c2 < M; c2 += 1)
+      S14(c0, c1, c2);
+for (int c0 = R; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S15(c0, c1, c2);

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-interp.st Added

@@ -0,0 +1,115 @@
+domain: "M, N, O, P, Q, R, S, T, U -> { S8i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S12i0, i1, i2 : i0 >= R and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S5i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S10i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S6i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S1i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S3i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S4i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S15i0, i1, i2 : i0 >= R and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S11i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S2i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S7i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S9i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S14i0, i1, i2 : i0 >= R and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S13i0, i1, i2 : i0 >= R and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M }"
+child:
+  context: "M, N, O, P, Q, R, S, T, U -> {  }"
+  child:
+    sequence:
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S10i0, i1, i2; S6i0, i1, i2; S3i0, i1, i2; S1i0, i1, i2; S11i0, i1, i2; S7i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S11i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0); S6i0, i1, i2 -> (i0); S10i0, i1, i2 -> (i0); S3i0, i1, i2 -> (i0); S7i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S11i0, i1, i2 -> (2i1); S1i0, i1, i2 -> (-3 + 2i1); S6i0, i1, i2 -> (-2 + 2i1); S10i0, i1, i2 -> (1 + 2i1); S3i0, i1, i2 -> (-1 + 2i1); S7i0, i1, i2 -> (-2 + 2i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S10i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S10i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S6i0, i1, i2; S1i0, i1, i2; S7i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 -> (i2); S6i0, i1, i2 -> (i2); S7i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+                child:
+                  sequence:
+                  - filter: "M, N, O, P, Q, R, S, T, U -> { S6i0, i1, i2; S1i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R, S, T, U -> { S7i0, i1, i2 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S11i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S11i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2; S9i0, i1, i2; S8i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i0); S8i0, i1, i2 -> (i0); S9i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (2i1); S8i0, i1, i2 -> (2i1); S9i0, i1, i2 -> (1 + 2i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S8i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S8i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+            - filter: "M, N, O, P, Q, R, S, T, U -> { S9i0, i1, i2 }"
+              child:
+                schedule: "M, N, O, P, Q, R, S, T, U -> { S9i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S5i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S5i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S5i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S5i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S12i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S12i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S12i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S12i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S13i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S13i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S13i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S13i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S14i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S14i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S14i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S14i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S15i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S15i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S15i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S15i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-interp2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-interp2.c Changed

@@ -1,18 +1,16 @@
-{
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = Q; c3 < N; c3 += 1)
-      for (int c5 = P; c5 < M; c5 += 1)
-        S1(c1, c3, c5);
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = Q; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S2(c1, c3, c5);
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = P; c5 < M; c5 += 1)
-        S3(c1, c3, c5);
-  for (int c1 = 1; c1 < O; c1 += 1)
-    for (int c3 = 1; c3 < N; c3 += 1)
-      for (int c5 = 1; c5 < M; c5 += 1)
-        S4(c1, c3, c5);
-}
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = Q; c1 < N; c1 += 1)
+    for (int c2 = P; c2 < M; c2 += 1)
+      S1(c0, c1, c2);
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = Q; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S2(c0, c1, c2);
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = P; c2 < M; c2 += 1)
+      S3(c0, c1, c2);
+for (int c0 = 1; c0 < O; c0 += 1)
+  for (int c1 = 1; c1 < N; c1 += 1)
+    for (int c2 = 1; c2 < M; c2 += 1)
+      S4(c0, c1, c2);

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-interp2.st Added

@@ -0,0 +1,45 @@
+domain: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S3i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= P and i2 <= -1 + M; S4i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= 1 and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M; S2i0, i1, i2 : i0 >= 1 and i0 <= -1 + O and i1 >= Q and i1 <= -1 + N and i2 >= 1 and i2 <= -1 + M }"
+child:
+  context: "M, N, O, P, Q, R, S, T, U -> {  }"
+  child:
+    sequence:
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S1i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S2i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S3i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+    - filter: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 }"
+      child:
+        schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i0) }"
+        options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+        child:
+          schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i1) }"
+          options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"
+          child:
+            schedule: "M, N, O, P, Q, R, S, T, U -> { S4i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R, S, T, U -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-psinv.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-psinv.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-psinv.st Added

@@ -0,0 +1,23 @@
+domain: "M, N, O -> { S3i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + M; S2i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 1 and i2 <= M; S1i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 1 and i2 <= M }"
+child:
+  context: "M, N, O -> {  }"
+  child:
+    schedule: "M, N, O -> { S3i0, i1, i2 -> (i0); S2i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0) }"
+    options: "M, N, O -> { separatei0 }"
+    child:
+      schedule: "M, N, O -> { S3i0, i1, i2 -> (2i1); S2i0, i1, i2 -> (-1 + 2i1); S1i0, i1, i2 -> (-1 + 2i1) }"
+      options: "M, N, O -> { separatei0 }"
+      child:
+        sequence:
+        - filter: "M, N, O -> { S2i0, i1, i2; S1i0, i1, i2 }"
+          child:
+            schedule: "M, N, O -> { S2i0, i1, i2 -> (i2); S1i0, i1, i2 -> (i2) }"
+            options: "M, N, O -> { separatei0 }"
+            child:
+              sequence:
+              - filter: "M, N, O -> { S1i0, i1, i2 }"
+              - filter: "M, N, O -> { S2i0, i1, i2 }"
+        - filter: "M, N, O -> { S3i0, i1, i2 }"
+          child:
+            schedule: "M, N, O -> { S3i0, i1, i2 -> (i2) }"
+            options: "M, N, O -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-resid.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-resid.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-resid.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-mg-rprj3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-rprj3.c Changed

@@ -1,33 +1,35 @@
 if (M >= 2 && N >= 3)
-  for (int c1 = 2; c1 < O; c1 += 1) {
-    for (int c5 = 2; c5 <= M; c5 += 1)
-      S1(c1, 2, c5);
-    for (int c3 = 3; c3 < N; c3 += 1) {
-      for (int c5 = 2; c5 <= M; c5 += 1)
-        S2(c1, c3 - 1, c5);
+  for (int c0 = 2; c0 < O; c0 += 1) {
+    for (int c2 = 2; c2 <= M; c2 += 1)
+      S1(c0, 2, c2);
+    for (int c1 = 3; c1 < N; c1 += 1) {
+      for (int c2 = 2; c2 <= M; c2 += 1)
+        S2(c0, c1 - 1, c2);
+      if (M >= 3)
+        S4(c0, c1 - 1, 2);
+      for (int c2 = 2; c2 < M - 1; c2 += 1) {
+        S3(c0, c1 - 1, c2);
+        S5(c0, c1 - 1, c2);
+        S4(c0, c1 - 1, c2 + 1);
+      }
       if (M >= 3) {
-        S4(c1, c3 - 1, 2);
-        for (int c5 = 2; c5 < M - 1; c5 += 1) {
-          S3(c1, c3 - 1, c5);
-          S5(c1, c3 - 1, c5);
-          S4(c1, c3 - 1, c5 + 1);
-        }
-        S3(c1, c3 - 1, M - 1);
-        S5(c1, c3 - 1, M - 1);
+        S3(c0, c1 - 1, M - 1);
+        S5(c0, c1 - 1, M - 1);
       }
-      for (int c5 = 2; c5 <= M; c5 += 1)
-        S1(c1, c3, c5);
+      for (int c2 = 2; c2 <= M; c2 += 1)
+        S1(c0, c1, c2);
+    }
+    for (int c2 = 2; c2 <= M; c2 += 1)
+      S2(c0, N - 1, c2);
+    if (M >= 3)
+      S4(c0, N - 1, 2);
+    for (int c2 = 2; c2 < M - 1; c2 += 1) {
+      S3(c0, N - 1, c2);
+      S5(c0, N - 1, c2);
+      S4(c0, N - 1, c2 + 1);
     }
-    for (int c5 = 2; c5 <= M; c5 += 1)
-      S2(c1, N - 1, c5);
     if (M >= 3) {
-      S4(c1, N - 1, 2);
-      for (int c5 = 2; c5 < M - 1; c5 += 1) {
-        S3(c1, N - 1, c5);
-        S5(c1, N - 1, c5);
-        S4(c1, N - 1, c5 + 1);
-      }
-      S3(c1, N - 1, M - 1);
-      S5(c1, N - 1, M - 1);
+      S3(c0, N - 1, M - 1);
+      S5(c0, N - 1, M - 1);
     }
   }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-mg-rprj3.st Added

@@ -0,0 +1,28 @@
+domain: "M, N, O, P, Q, R -> { S2i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= M; S4i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + M; S1i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= M; S5i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + M; S3i0, i1, i2 : i0 >= 2 and i0 <= -1 + O and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + M }"
+child:
+  context: "M, N, O, P, Q, R -> {  }"
+  child:
+    schedule: "M, N, O, P, Q, R -> { S5i0, i1, i2 -> (i0); S3i0, i1, i2 -> (i0); S4i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0); S2i0, i1, i2 -> (i0) }"
+    options: "M, N, O, P, Q, R -> { separatei0 }"
+    child:
+      schedule: "M, N, O, P, Q, R -> { S5i0, i1, i2 -> (1 + i1); S3i0, i1, i2 -> (1 + i1); S4i0, i1, i2 -> (1 + i1); S1i0, i1, i2 -> (i1); S2i0, i1, i2 -> (1 + i1) }"
+      options: "M, N, O, P, Q, R -> { separatei0 }"
+      child:
+        sequence:
+        - filter: "M, N, O, P, Q, R -> { S2i0, i1, i2 }"
+          child:
+            schedule: "M, N, O, P, Q, R -> { S2i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R -> { separatei0 }"
+        - filter: "M, N, O, P, Q, R -> { S4i0, i1, i2; S5i0, i1, i2; S3i0, i1, i2 }"
+          child:
+            schedule: "M, N, O, P, Q, R -> { S5i0, i1, i2 -> (i2); S3i0, i1, i2 -> (i2); S4i0, i1, i2 -> (-1 + i2) }"
+            options: "M, N, O, P, Q, R -> { separatei0 }"
+            child:
+              sequence:
+              - filter: "M, N, O, P, Q, R -> { S3i0, i1, i2 }"
+              - filter: "M, N, O, P, Q, R -> { S5i0, i1, i2 }"
+              - filter: "M, N, O, P, Q, R -> { S4i0, i1, i2 }"
+        - filter: "M, N, O, P, Q, R -> { S1i0, i1, i2 }"
+          child:
+            schedule: "M, N, O, P, Q, R -> { S1i0, i1, i2 -> (i2) }"
+            options: "M, N, O, P, Q, R -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali1.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali4.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali4.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali5.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali5.st Added

@@ -0,0 +1,26 @@
+domain: "M -> { S3i0, i1, i2 : i1 >= 1 and i1 <= -1 + i0 and i2 >= 1 + i0 and i2 <= M; S2i0, i1 : i0 <= M and i1 >= 1 and i1 <= -1 + i0; S1i0, i1, i2 : i1 >= 1 and i1 <= -1 + i0 and i2 >= 1 + i0 and i2 <= M }"
+child:
+  context: "M -> {  }"
+  child:
+    schedule: "M -> { S1i0, i1, i2 -> (i0 + i1); S3i0, i1, i2 -> (i0 + i1); S2i0, i1 -> (i0 + i1) }"
+    options: "M -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M -> { S1i0, i1, i2 }"
+        child:
+          schedule: "M -> { S1i0, i1, i2 -> (i2) }"
+          options: "M -> { separatei0 }"
+          child:
+            schedule: "M -> { S1i0, i1, i2 -> (i2) }"
+            options: "M -> { separatei0 }"
+      - filter: "M -> { S2i0, i1 }"
+        child:
+          schedule: "M -> { S2i0, i1 -> (i1) }"
+          options: "M -> { separatei0 }"
+      - filter: "M -> { S3i0, i1, i2 }"
+        child:
+          schedule: "M -> { S3i0, i1, i2 -> (i2) }"
+          options: "M -> { separatei0 }"
+          child:
+            schedule: "M -> { S3i0, i1, i2 -> (i2) }"
+            options: "M -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-pingali6.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali6.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-pingali6.st Added

@@ -0,0 +1,22 @@
+domain: "M, N -> { S2i0, i1, i2 : i0 >= 1 and i0 <= M and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + N; S1i0, i1, i2 : i0 >= 1 and i0 <= M and i1 >= 2 and i1 <= -1 + N and i2 >= 2 and i2 <= -1 + N }"
+child:
+  context: "M, N -> {  : M >= 1 and N >= 1 }"
+  child:
+    schedule: "M, N -> { S1i0, i1, i2 -> (2i0); S2i0, i1, i2 -> (1 + 2i0) }"
+    options: "M, N -> { separatei0 }"
+    child:
+      sequence:
+      - filter: "M, N -> { S1i0, i1, i2 }"
+        child:
+          schedule: "M, N -> { S1i0, i1, i2 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+          child:
+            schedule: "M, N -> { S1i0, i1, i2 -> (i2) }"
+            options: "M, N -> { separatei0 }"
+      - filter: "M, N -> { S2i0, i1, i2 }"
+        child:
+          schedule: "M, N -> { S2i0, i1, i2 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+          child:
+            schedule: "M, N -> { S2i0, i1, i2 -> (i2) }"
+            options: "M, N -> { separatei0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-stride.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-stride.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-stride.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-stride2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-stride2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-stride2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/reservoir-tang-xue1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-tang-xue1.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-tang-xue1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/reservoir-two.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/singleton.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/singleton.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/singleton.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/sor1d.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/sor1d.st Added

@@ -0,0 +1,24 @@
+domain: "M, N -> { S2i0, i1, 1 + i1, 99 + 100i1, i4 : i4 >= 3 and i4 >= -193 - 200i1 and i4 >= -194 + 100i0 - 200i1 and 100i0 >= -284 - 3N and i4 <= -1 + N and i4 <= -201 + 2M + N - 200i1 and i4 <= -95 + 100i0 - 200i1 and 100i0 >= -94 - N and 50i0 >= -45 - N and 3N >= -134 - M and i1 >= 0 and N >= 4 and 200i1 >= -192 - N and 200i1 >= -193 - N + 100i0 and 100i0 <= -7 + 2M + N and 7N >= -463 - 2M and 100i1 <= -100 + M and i0 >= 0 and 200i1 <= -204 + 2M + N and 2i1 <= -1 + i0 and 5N >= -75 - 2M and N >= 8 - 2M and 50i0 <= -6 + M + N and 50i0 <= 89 + M + 2N and 100i0 <= -15 + 2M + 3N and M >= 2 and 100i1 <= -5 + M + N and 2N >= -39 - M and 200i1 <= 96 + N + 100i0 and 3N >= 16 - 2M and 100i1 >= -94 - N + 50i0 and N >= 6 - M and 100i1 >= -94 - N; S3i0, i1, 1 + i1, 99 + 100i1, i4 : i4 >= 3 and i4 >= -193 - 200i1 and i4 >= -194 + 100i0 - 200i1 and 100i0 >= -284 - 3N and i4 <= -1 + N and i4 <= -201 + 2M + N - 200i1 and i4 <= -95 + 100i0 - 200i1 and 100i0 >= -94 - N and 50i0 >= -45 - N and 3N >= -134 - M and i1 >= 0 and N >= 4 and 200i1 >= -192 - N and 200i1 >= -193 - N + 100i0 and 100i0 <= -7 + 2M + N and 7N >= -463 - 2M and 100i1 <= -100 + M and i0 >= 0 and 200i1 <= -204 + 2M + N and 2i1 <= -1 + i0 and 5N >= -75 - 2M and N >= 8 - 2M and 50i0 <= -6 + M + N and 50i0 <= 89 + M + 2N and 100i0 <= -15 + 2M + 3N and M >= 2 and 100i1 <= -5 + M + N and 2N >= -39 - M and 200i1 <= 96 + N + 100i0 and 3N >= 16 - 2M and 100i1 >= -94 - N + 50i0 and N >= 6 - M and 100i1 >= -94 - N; S4i0 : 200i0 >= -781 - 3N and 200i0 >= -391 - N and 50i0 >= -268 - N and 100i0 >= -392 - N and i0 >= -1 and 200i0 <= 377 + 6M + 5N and 100i0 <= 335 + 3M + 3N and 100i0 <= 190 + 3M + 2N and 200i0 <= -13 + 6M + 3N and 100i0 <= -5 + 3M + N and 3N >= -484 - 2M and N >= -95 - M and N >= -192 - 3M and 5N >= -873 - 3M and 2N >= -189 - 3M and 7N >= -1062 - 6M and 5N >= -771 - 6M and 4N >= -579 - 3M and N >= 3 and N >= 5 - 2M and M >= 1; S1i0, i1, i2, i3 : i3 >= 4 + 100i0 - 2i2 and i3 >= 2 and i3 <= 103 + 100i0 - 2i2 and i3 <= -1 + N and i2 >= 1 and i2 >= 100i1 and 2i2 >= 5 - N + 100i0 and i2 <= M and i2 <= 99 + 100i1 and i2 <= 50 + 50i0 and i1 >= 0 and 200i1 >= -193 - N + 100i0 and 100i1 <= M and 2i1 <= 1 + i0 and i0 >= 0 and 100i0 <= -5 + 2M + N and N >= 3 and N >= -94 - 2M and M >= 1 }"
+child:
+  context: "M, N -> {  : M >= 0 and N >= 0 }"
+  child:
+    schedule: "M, N -> { S2i0, i1, i2, i3, i4 -> (i0 + i1); S1i0, i1, i2, i3 -> (i0 + i1); S3i0, i1, i2, i3, i4 -> (1 + i0 + i1); S4i0 -> (i0) }"
+    options: "M, N -> { atomici0 }"
+    child:
+      sequence:
+      - filter: "M, N -> { S2i0, i1, i2, i3, i4; S3i0, i1, i2, i3, i4; S1i0, i1, i2, i3 }"
+        child:
+          schedule: "M, N -> { S2i0, i1, i2, i3, i4 -> (i1); S1i0, i1, i2, i3 -> (i1); S3i0, i1, i2, i3, i4 -> (i2) }, { S2i0, i1, i2, i3, i4 -> (-4 + 2i3 + i4); S1i0, i1, i2, i3 -> (-4 + 2i2 + i3); S3i0, i1, i2, i3, i4 -> (-4 + 2i3 + i4) }, { S2i0, i1, i2, i3, i4 -> (i3); S1i0, i1, i2, i3 -> (i2); S3i0, i1, i2, i3, i4 -> (i3) }"
+          options: "M, N -> { atomici0 }"
+          child:
+            sequence:
+            - filter: "M, N -> { S3i0, i1, i2, i3, i4 }"
+              child:
+                schedule: "M, N -> { S3i0, i1, i2, i3, i4 -> (i1) }, { S3i0, i1, i2, i3, i4 -> (i4) }"
+                options: "M, N -> { atomici0 }"
+            - filter: "M, N -> { S1i0, i1, i2, i3 }"
+            - filter: "M, N -> { S2i0, i1, i2, i3, i4 }"
+              child:
+                schedule: "M, N -> { S2i0, i1, i2, i3, i4 -> (i2) }, { S2i0, i1, i2, i3, i4 -> (i4) }"
+                options: "M, N -> { atomici0 }"
+      - filter: "M, N -> { S4i0 }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/square+triangle-1-1-2-3.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/stride2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/stride4.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/swim.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/swim.c Changed

@@ -26,13 +26,13 @@
   S25();
   S26();
   S27();
-  for (int c1 = 1; c1 <= N; c1 += 1) {
-    for (int c3 = 1; c3 <= N; c3 += 1) {
-      S28(c1, c3);
-      S29(c1, c3);
-      S30(c1, c3);
+  for (int c0 = 1; c0 <= N; c0 += 1) {
+    for (int c1 = 1; c1 <= N; c1 += 1) {
+      S28(c0, c1);
+      S29(c0, c1);
+      S30(c0, c1);
     }
-    S31(c1);
+    S31(c0);
   }
   S32();
   S33();
@@ -41,119 +41,119 @@
     S35();
   S36();
   S37();
-  for (int c1 = 2; c1 <= P; c1 += 1) {
-    S38(c1);
-    S39(c1);
-    for (int c3 = 1; c3 <= Q; c3 += 1)
-      for (int c5 = 1; c5 <= R; c5 += 1) {
-        S40(c1, c3, c5);
-        S41(c1, c3, c5);
-        S42(c1, c3, c5);
-        S43(c1, c3, c5);
+  for (int c0 = 2; c0 <= P; c0 += 1) {
+    S38(c0);
+    S39(c0);
+    for (int c1 = 1; c1 <= Q; c1 += 1)
+      for (int c2 = 1; c2 <= R; c2 += 1) {
+        S40(c0, c1, c2);
+        S41(c0, c1, c2);
+        S42(c0, c1, c2);
+        S43(c0, c1, c2);
       }
-    for (int c3 = 1; c3 <= Q; c3 += 1) {
-      S44(c1, c3);
-      S45(c1, c3);
-      S46(c1, c3);
-      S47(c1, c3);
+    for (int c1 = 1; c1 <= Q; c1 += 1) {
+      S44(c0, c1);
+      S45(c0, c1);
+      S46(c0, c1);
+      S47(c0, c1);
     }
-    for (int c3 = 1; c3 <= R; c3 += 1) {
-      S48(c1, c3);
-      S49(c1, c3);
-      S50(c1, c3);
-      S51(c1, c3);
+    for (int c1 = 1; c1 <= R; c1 += 1) {
+      S48(c0, c1);
+      S49(c0, c1);
+      S50(c0, c1);
+      S51(c0, c1);
     }
-    S52(c1);
-    S53(c1);
-    S54(c1);
-    S55(c1);
-    S56(c1);
-    S57(c1);
-    S58(c1);
-    for (int c3 = 1; c3 <= Q; c3 += 1)
-      for (int c5 = 1; c5 <= R; c5 += 1) {
-        S59(c1, c3, c5);
-        S60(c1, c3, c5);
-        S61(c1, c3, c5);
+    S52(c0);
+    S53(c0);
+    S54(c0);
+    S55(c0);
+    S56(c0);
+    S57(c0);
+    S58(c0);
+    for (int c1 = 1; c1 <= Q; c1 += 1)
+      for (int c2 = 1; c2 <= R; c2 += 1) {
+        S59(c0, c1, c2);
+        S60(c0, c1, c2);
+        S61(c0, c1, c2);
       }
-    for (int c3 = 1; c3 <= Q; c3 += 1) {
-      S62(c1, c3);
-      S63(c1, c3);
-      S64(c1, c3);
+    for (int c1 = 1; c1 <= Q; c1 += 1) {
+      S62(c0, c1);
+      S63(c0, c1);
+      S64(c0, c1);
     }
-    for (int c3 = 1; c3 <= R; c3 += 1) {
-      S65(c1, c3);
-      S66(c1, c3);
-      S67(c1, c3);
+    for (int c1 = 1; c1 <= R; c1 += 1) {
+      S65(c0, c1);
+      S66(c0, c1);
+      S67(c0, c1);
     }
-    S68(c1);
-    S69(c1);
-    S70(c1);
-    S71(c1);
-    S72(c1);
-    S73(c1);
-    S74(c1);
-    S75(c1);
-    S76(c1);
-    S77(c1);
-    S78(c1);
-    S79(c1);
-    S80(c1);
-    S81(c1);
-    S82(c1);
-    S83(c1);
-    S84(c1);
-    S85(c1);
-    S86(c1);
-    S87(c1);
-    S88(c1);
-    S89(c1);
-    S90(c1);
-    S91(c1);
-    S92(c1);
-    S93(c1);
-    S94(c1);
-    for (int c3 = 1; c3 <= N; c3 += 1) {
-      for (int c5 = 1; c5 <= N; c5 += 1) {
-        S95(c1, c3, c5);
-        S96(c1, c3, c5);
-        S97(c1, c3, c5);
+    S68(c0);
+    S69(c0);
+    S70(c0);
+    S71(c0);
+    S72(c0);
+    S73(c0);
+    S74(c0);
+    S75(c0);
+    S76(c0);
+    S77(c0);
+    S78(c0);
+    S79(c0);
+    S80(c0);
+    S81(c0);
+    S82(c0);
+    S83(c0);
+    S84(c0);
+    S85(c0);
+    S86(c0);
+    S87(c0);
+    S88(c0);
+    S89(c0);
+    S90(c0);
+    S91(c0);
+    S92(c0);
+    S93(c0);
+    S94(c0);
+    for (int c1 = 1; c1 <= N; c1 += 1) {
+      for (int c2 = 1; c2 <= N; c2 += 1) {
+        S95(c0, c1, c2);
+        S96(c0, c1, c2);
+        S97(c0, c1, c2);
       }
-      S98(c1, c3);
+      S98(c0, c1);
     }
-    S99(c1);
-    S100(c1);
-    S101(c1);
-    for (int c3 = 1; c3 <= Q; c3 += 1)
-      for (int c5 = 1; c5 <= R; c5 += 1) {
-        S102(c1, c3, c5);
-        S103(c1, c3, c5);
-        S104(c1, c3, c5);
-        S105(c1, c3, c5);
-        S106(c1, c3, c5);
-        S107(c1, c3, c5);
+    S99(c0);
+    S100(c0);
+    S101(c0);
+    for (int c1 = 1; c1 <= Q; c1 += 1)
+      for (int c2 = 1; c2 <= R; c2 += 1) {
+        S102(c0, c1, c2);
+        S103(c0, c1, c2);
+        S104(c0, c1, c2);
+        S105(c0, c1, c2);
+        S106(c0, c1, c2);
+        S107(c0, c1, c2);
       }
-    for (int c3 = 1; c3 <= Q; c3 += 1) {
-      S108(c1, c3);
-      S109(c1, c3);
-      S110(c1, c3);
-      S111(c1, c3);
-      S112(c1, c3);
-      S113(c1, c3);
+    for (int c1 = 1; c1 <= Q; c1 += 1) {
+      S108(c0, c1);
+      S109(c0, c1);
+      S110(c0, c1);
+      S111(c0, c1);
+      S112(c0, c1);
+      S113(c0, c1);
     }
-    for (int c3 = 1; c3 <= R; c3 += 1) {
-      S114(c1, c3);
-      S115(c1, c3);
-      S116(c1, c3);
-      S117(c1, c3);
-      S118(c1, c3);
-      S119(c1, c3);
+    for (int c1 = 1; c1 <= R; c1 += 1) {
+      S114(c0, c1);
+      S115(c0, c1);
+      S116(c0, c1);
+      S117(c0, c1);
+      S118(c0, c1);
+      S119(c0, c1);
     }
-    S120(c1);
-    S121(c1);
-    S122(c1);
-    S123(c1);
-    S124(c1);
-    S125(c1);
+    S120(c0);
+    S121(c0);
+    S122(c0);
+    S123(c0);
+    S124(c0);
+    S125(c0);
   }
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/swim.st Added

@@ -0,0 +1,223 @@
+domain: "M, N, O, P, Q, R -> { S40i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S106i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S99i0 : M = 1 and i0 >= 2 and i0 <= P; S83i0 : M = 1 and i0 >= 2 and i0 <= P; S86i0 : M = 1 and i0 >= 2 and i0 <= P; S56i0 : M = 1 and i0 >= 2 and i0 <= P; S124i0 : M = 1 and i0 >= 2 and i0 <= P; S66i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S46i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S64i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S22 : M = 1; S15 : M = 1; S30i0, i1 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S14 : M = 1; S12 : M = 1; S87i0 : M = 1 and i0 >= 2 and i0 <= P; S110i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S73i0 : M = 1 and i0 >= 2 and i0 <= P; S44i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S31i0 : M = 1 and i0 >= 1 and i0 <= N; S118i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S8 : M = 1; S125i0 : M = 1 and i0 >= 2 and i0 <= P; S63i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S25 : M = 1; S51i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S91i0 : M = 1 and i0 >= 2 and i0 <= P; S84i0 : M = 1 and i0 >= 2 and i0 <= P; S35 : M = 1 and O <= 1; S97i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S75i0 : M = 1 and i0 >= 2 and i0 <= P; S19 : M = 1; S50i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S114i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S13 : M = 1; S72i0 : M = 1 and i0 >= 2 and i0 <= P; S78i0 : M = 1 and i0 >= 2 and i0 <= P; S39i0 : M = 1 and i0 >= 2 and i0 <= P; S102i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S107i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S68i0 : M = 1 and i0 >= 2 and i0 <= P; S32 : M = 1; S41i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S69i0 : M = 1 and i0 >= 2 and i0 <= P; S3 : M = 1; S100i0 : M = 1 and i0 >= 2 and i0 <= P; S11 : M = 1; S76i0 : M = 1 and i0 >= 2 and i0 <= P; S88i0 : M = 1 and i0 >= 2 and i0 <= P; S49i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S45i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S10 : M = 1; S80i0 : M = 1 and i0 >= 2 and i0 <= P; S61i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S67i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S70i0 : M = 1 and i0 >= 2 and i0 <= P; S29i0, i1 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S60i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S21 : M = 1; S92i0 : M = 1 and i0 >= 2 and i0 <= P; S47i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S24 : M = 1; S16 : M = 1; S105i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S18 : M = 1; S48i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S5 : M = 1; S113i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S7 : M = 1; S38i0 : M = 1 and i0 >= 2 and i0 <= P; S54i0 : M = 1 and i0 >= 2 and i0 <= P; S109i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S23 : M = 1; S82i0 : M = 1 and i0 >= 2 and i0 <= P; S59i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S77i0 : M = 1 and i0 >= 2 and i0 <= P; S101i0 : M = 1 and i0 >= 2 and i0 <= P; S37 : M = 1; S71i0 : M = 1 and i0 >= 2 and i0 <= P; S121i0 : M = 1 and i0 >= 2 and i0 <= P; S115i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S104i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S94i0 : M = 1 and i0 >= 2 and i0 <= P; S6 : M = 1; S43i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S1 : M = 1; S98i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N; S55i0 : M = 1 and i0 >= 2 and i0 <= P; S58i0 : M = 1 and i0 >= 2 and i0 <= P; S42i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S89i0 : M = 1 and i0 >= 2 and i0 <= P; S53i0 : M = 1 and i0 >= 2 and i0 <= P; S111i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S52i0 : M = 1 and i0 >= 2 and i0 <= P; S85i0 : M = 1 and i0 >= 2 and i0 <= P; S26 : M = 1; S79i0 : M = 1 and i0 >= 2 and i0 <= P; S81i0 : M = 1 and i0 >= 2 and i0 <= P; S57i0 : M = 1 and i0 >= 2 and i0 <= P; S4 : M = 1; S123i0 : M = 1 and i0 >= 2 and i0 <= P; S36 : M = 1; S65i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S34 : M = 1; S119i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S9 : M = 1; S28i0, i1 : M = 1 and i0 >= 1 and i0 <= N and i1 >= 1 and i1 <= N; S20 : M = 1; S117i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S112i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S103i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q and i2 >= 1 and i2 <= R; S17 : M = 1; S96i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S95i0, i1, i2 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= N and i2 >= 1 and i2 <= N; S62i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S90i0 : M = 1 and i0 >= 2 and i0 <= P; S120i0 : M = 1 and i0 >= 2 and i0 <= P; S116i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= R; S108i0, i1 : M = 1 and i0 >= 2 and i0 <= P and i1 >= 1 and i1 <= Q; S74i0 : M = 1 and i0 >= 2 and i0 <= P; S93i0 : M = 1 and i0 >= 2 and i0 <= P; S2 : M = 1; S27 : M = 1; S122i0 : M = 1 and i0 >= 2 and i0 <= P; S33 : M = 1 }"
+child:
+  context: "M, N, O, P, Q, R -> {  }"
+  child:
+    sequence:
+    - filter: "M, N, O, P, Q, R -> { S1 }"
+    - filter: "M, N, O, P, Q, R -> { S2 }"
+    - filter: "M, N, O, P, Q, R -> { S3 }"
+    - filter: "M, N, O, P, Q, R -> { S4 }"
+    - filter: "M, N, O, P, Q, R -> { S5 }"
+    - filter: "M, N, O, P, Q, R -> { S6 }"
+    - filter: "M, N, O, P, Q, R -> { S7 }"
+    - filter: "M, N, O, P, Q, R -> { S8 }"
+    - filter: "M, N, O, P, Q, R -> { S9 }"
+    - filter: "M, N, O, P, Q, R -> { S10 }"
+    - filter: "M, N, O, P, Q, R -> { S11 }"
+    - filter: "M, N, O, P, Q, R -> { S12 }"
+    - filter: "M, N, O, P, Q, R -> { S13 }"
+    - filter: "M, N, O, P, Q, R -> { S14 }"
+    - filter: "M, N, O, P, Q, R -> { S15 }"
+    - filter: "M, N, O, P, Q, R -> { S16 }"
+    - filter: "M, N, O, P, Q, R -> { S17 }"
+    - filter: "M, N, O, P, Q, R -> { S18 }"
+    - filter: "M, N, O, P, Q, R -> { S19 }"
+    - filter: "M, N, O, P, Q, R -> { S20 }"
+    - filter: "M, N, O, P, Q, R -> { S21 }"
+    - filter: "M, N, O, P, Q, R -> { S22 }"
+    - filter: "M, N, O, P, Q, R -> { S23 }"
+    - filter: "M, N, O, P, Q, R -> { S24 }"
+    - filter: "M, N, O, P, Q, R -> { S25 }"
+    - filter: "M, N, O, P, Q, R -> { S26 }"
+    - filter: "M, N, O, P, Q, R -> { S27 }"
+    - filter: "M, N, O, P, Q, R -> { S30i0, i1; S28i0, i1; S31i0; S29i0, i1 }"
+      child:
+        schedule: "M, N, O, P, Q, R -> { S31i0 -> (i0); S29i0, i1 -> (i0); S30i0, i1 -> (i0); S28i0, i1 -> (i0) }"
+        options: "M, N, O, P, Q, R -> { separatei0 }"
+        child:
+          sequence:
+          - filter: "M, N, O, P, Q, R -> { S30i0, i1; S28i0, i1; S29i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S29i0, i1 -> (i1); S30i0, i1 -> (i1); S28i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S28i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S29i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S30i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S31i0 }"
+    - filter: "M, N, O, P, Q, R -> { S32 }"
+    - filter: "M, N, O, P, Q, R -> { S33 }"
+    - filter: "M, N, O, P, Q, R -> { S34 }"
+    - filter: "M, N, O, P, Q, R -> { S35 }"
+    - filter: "M, N, O, P, Q, R -> { S36 }"
+    - filter: "M, N, O, P, Q, R -> { S37 }"
+    - filter: "M, N, O, P, Q, R -> { S58i0; S116i0, i1; S120i0; S106i0, i1, i2; S102i0, i1, i2; S114i0, i1; S113i0, i1; S122i0; S83i0; S103i0, i1, i2; S71i0; S50i0, i1; S98i0, i1; S65i0, i1; S82i0; S109i0, i1; S51i0, i1; S60i0, i1, i2; S91i0; S78i0; S101i0; S123i0; S111i0, i1; S97i0, i1, i2; S67i0, i1; S117i0, i1; S88i0; S79i0; S46i0, i1; S56i0; S45i0, i1; S74i0; S49i0, i1; S75i0; S115i0, i1; S119i0, i1; S42i0, i1, i2; S57i0; S62i0, i1; S99i0; S107i0, i1, i2; S100i0; S104i0, i1, i2; S70i0; S89i0; S125i0; S44i0, i1; S93i0; S90i0; S84i0; S105i0, i1, i2; S95i0, i1, i2; S66i0, i1; S77i0; S38i0; S41i0, i1, i2; S92i0; S87i0; S47i0, i1; S108i0, i1; S54i0; S76i0; S112i0, i1; S80i0; S55i0; S39i0; S59i0, i1, i2; S121i0; S86i0; S110i0, i1; S48i0, i1; S68i0; S53i0; S72i0; S85i0; S52i0; S69i0; S61i0, i1, i2; S43i0, i1, i2; S124i0; S73i0; S81i0; S63i0, i1; S118i0, i1; S96i0, i1, i2; S40i0, i1, i2; S94i0; S64i0, i1 }"
+      child:
+        schedule: "M, N, O, P, Q, R -> { S99i0 -> (i0); S97i0, i1, i2 -> (i0); S53i0 -> (i0); S101i0 -> (i0); S60i0, i1, i2 -> (i0); S40i0, i1, i2 -> (i0); S103i0, i1, i2 -> (i0); S55i0 -> (i0); S89i0 -> (i0); S56i0 -> (i0); S87i0 -> (i0); S115i0, i1 -> (i0); S123i0 -> (i0); S88i0 -> (i0); S70i0 -> (i0); S59i0, i1, i2 -> (i0); S52i0 -> (i0); S54i0 -> (i0); S63i0, i1 -> (i0); S92i0 -> (i0); S93i0 -> (i0); S119i0, i1 -> (i0); S76i0 -> (i0); S57i0 -> (i0); S44i0, i1 -> (i0); S79i0 -> (i0); S61i0, i1, i2 -> (i0); S69i0 -> (i0); S117i0, i1 -> (i0); S121i0 -> (i0); S84i0 -> (i0); S83i0 -> (i0); S43i0, i1, i2 -> (i0); S98i0, i1 -> (i0); S78i0 -> (i0); S114i0, i1 -> (i0); S66i0, i1 -> (i0); S77i0 -> (i0); S109i0, i1 -> (i0); S42i0, i1, i2 -> (i0); S58i0 -> (i0); S71i0 -> (i0); S68i0 -> (i0); S116i0, i1 -> (i0); S81i0 -> (i0); S125i0 -> (i0); S80i0 -> (i0); S73i0 -> (i0); S110i0, i1 -> (i0); S72i0 -> (i0); S51i0, i1 -> (i0); S122i0 -> (i0); S38i0 -> (i0); S39i0 -> (i0); S90i0 -> (i0); S113i0, i1 -> (i0); S46i0, i1 -> (i0); S47i0, i1 -> (i0); S96i0, i1, i2 -> (i0); S45i0, i1 -> (i0); S49i0, i1 -> (i0); S118i0, i1 -> (i0); S50i0, i1 -> (i0); S102i0, i1, i2 -> (i0); S112i0, i1 -> (i0); S86i0 -> (i0); S124i0 -> (i0); S41i0, i1, i2 -> (i0); S100i0 -> (i0); S104i0, i1, i2 -> (i0); S75i0 -> (i0); S62i0, i1 -> (i0); S85i0 -> (i0); S105i0, i1, i2 -> (i0); S82i0 -> (i0); S111i0, i1 -> (i0); S48i0, i1 -> (i0); S65i0, i1 -> (i0); S120i0 -> (i0); S107i0, i1, i2 -> (i0); S106i0, i1, i2 -> (i0); S95i0, i1, i2 -> (i0); S108i0, i1 -> (i0); S91i0 -> (i0); S67i0, i1 -> (i0); S74i0 -> (i0); S64i0, i1 -> (i0); S94i0 -> (i0) }"
+        options: "M, N, O, P, Q, R -> { separatei0 }"
+        child:
+          sequence:
+          - filter: "M, N, O, P, Q, R -> { S38i0 }"
+          - filter: "M, N, O, P, Q, R -> { S39i0 }"
+          - filter: "M, N, O, P, Q, R -> { S40i0, i1, i2; S41i0, i1, i2; S43i0, i1, i2; S42i0, i1, i2 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S43i0, i1, i2 -> (i1); S41i0, i1, i2 -> (i1); S40i0, i1, i2 -> (i1); S42i0, i1, i2 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                schedule: "M, N, O, P, Q, R -> { S43i0, i1, i2 -> (i2); S41i0, i1, i2 -> (i2); S40i0, i1, i2 -> (i2); S42i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R -> { separatei0 }"
+                child:
+                  sequence:
+                  - filter: "M, N, O, P, Q, R -> { S40i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S41i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S42i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S43i0, i1, i2 }"
+          - filter: "M, N, O, P, Q, R -> { S46i0, i1; S45i0, i1; S44i0, i1; S47i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S47i0, i1 -> (i1); S46i0, i1 -> (i1); S44i0, i1 -> (i1); S45i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S44i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S45i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S46i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S47i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S51i0, i1; S49i0, i1; S50i0, i1; S48i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S51i0, i1 -> (i1); S49i0, i1 -> (i1); S48i0, i1 -> (i1); S50i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S48i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S49i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S50i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S51i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S52i0 }"
+          - filter: "M, N, O, P, Q, R -> { S53i0 }"
+          - filter: "M, N, O, P, Q, R -> { S54i0 }"
+          - filter: "M, N, O, P, Q, R -> { S55i0 }"
+          - filter: "M, N, O, P, Q, R -> { S56i0 }"
+          - filter: "M, N, O, P, Q, R -> { S57i0 }"
+          - filter: "M, N, O, P, Q, R -> { S58i0 }"
+          - filter: "M, N, O, P, Q, R -> { S60i0, i1, i2; S59i0, i1, i2; S61i0, i1, i2 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S61i0, i1, i2 -> (i1); S59i0, i1, i2 -> (i1); S60i0, i1, i2 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                schedule: "M, N, O, P, Q, R -> { S61i0, i1, i2 -> (i2); S59i0, i1, i2 -> (i2); S60i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R -> { separatei0 }"
+                child:
+                  sequence:
+                  - filter: "M, N, O, P, Q, R -> { S59i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S60i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S61i0, i1, i2 }"
+          - filter: "M, N, O, P, Q, R -> { S62i0, i1; S63i0, i1; S64i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S64i0, i1 -> (i1); S62i0, i1 -> (i1); S63i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S62i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S63i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S64i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S65i0, i1; S66i0, i1; S67i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S66i0, i1 -> (i1); S65i0, i1 -> (i1); S67i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S65i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S66i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S67i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S68i0 }"
+          - filter: "M, N, O, P, Q, R -> { S69i0 }"
+          - filter: "M, N, O, P, Q, R -> { S70i0 }"
+          - filter: "M, N, O, P, Q, R -> { S71i0 }"
+          - filter: "M, N, O, P, Q, R -> { S72i0 }"
+          - filter: "M, N, O, P, Q, R -> { S73i0 }"
+          - filter: "M, N, O, P, Q, R -> { S74i0 }"
+          - filter: "M, N, O, P, Q, R -> { S75i0 }"
+          - filter: "M, N, O, P, Q, R -> { S76i0 }"
+          - filter: "M, N, O, P, Q, R -> { S77i0 }"
+          - filter: "M, N, O, P, Q, R -> { S78i0 }"
+          - filter: "M, N, O, P, Q, R -> { S79i0 }"
+          - filter: "M, N, O, P, Q, R -> { S80i0 }"
+          - filter: "M, N, O, P, Q, R -> { S81i0 }"
+          - filter: "M, N, O, P, Q, R -> { S82i0 }"
+          - filter: "M, N, O, P, Q, R -> { S83i0 }"
+          - filter: "M, N, O, P, Q, R -> { S84i0 }"
+          - filter: "M, N, O, P, Q, R -> { S85i0 }"
+          - filter: "M, N, O, P, Q, R -> { S86i0 }"
+          - filter: "M, N, O, P, Q, R -> { S87i0 }"
+          - filter: "M, N, O, P, Q, R -> { S88i0 }"
+          - filter: "M, N, O, P, Q, R -> { S89i0 }"
+          - filter: "M, N, O, P, Q, R -> { S90i0 }"
+          - filter: "M, N, O, P, Q, R -> { S91i0 }"
+          - filter: "M, N, O, P, Q, R -> { S92i0 }"
+          - filter: "M, N, O, P, Q, R -> { S93i0 }"
+          - filter: "M, N, O, P, Q, R -> { S94i0 }"
+          - filter: "M, N, O, P, Q, R -> { S96i0, i1, i2; S98i0, i1; S97i0, i1, i2; S95i0, i1, i2 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S98i0, i1 -> (i1); S95i0, i1, i2 -> (i1); S96i0, i1, i2 -> (i1); S97i0, i1, i2 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S96i0, i1, i2; S97i0, i1, i2; S95i0, i1, i2 }"
+                  child:
+                    schedule: "M, N, O, P, Q, R -> { S95i0, i1, i2 -> (i2); S96i0, i1, i2 -> (i2); S97i0, i1, i2 -> (i2) }"
+                    options: "M, N, O, P, Q, R -> { separatei0 }"
+                    child:
+                      sequence:
+                      - filter: "M, N, O, P, Q, R -> { S95i0, i1, i2 }"
+                      - filter: "M, N, O, P, Q, R -> { S96i0, i1, i2 }"
+                      - filter: "M, N, O, P, Q, R -> { S97i0, i1, i2 }"
+                - filter: "M, N, O, P, Q, R -> { S98i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S99i0 }"
+          - filter: "M, N, O, P, Q, R -> { S100i0 }"
+          - filter: "M, N, O, P, Q, R -> { S101i0 }"
+          - filter: "M, N, O, P, Q, R -> { S107i0, i1, i2; S105i0, i1, i2; S102i0, i1, i2; S104i0, i1, i2; S106i0, i1, i2; S103i0, i1, i2 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S102i0, i1, i2 -> (i1); S103i0, i1, i2 -> (i1); S104i0, i1, i2 -> (i1); S107i0, i1, i2 -> (i1); S106i0, i1, i2 -> (i1); S105i0, i1, i2 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                schedule: "M, N, O, P, Q, R -> { S102i0, i1, i2 -> (i2); S103i0, i1, i2 -> (i2); S104i0, i1, i2 -> (i2); S107i0, i1, i2 -> (i2); S106i0, i1, i2 -> (i2); S105i0, i1, i2 -> (i2) }"
+                options: "M, N, O, P, Q, R -> { separatei0 }"
+                child:
+                  sequence:
+                  - filter: "M, N, O, P, Q, R -> { S102i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S103i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S104i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S105i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S106i0, i1, i2 }"
+                  - filter: "M, N, O, P, Q, R -> { S107i0, i1, i2 }"
+          - filter: "M, N, O, P, Q, R -> { S113i0, i1; S112i0, i1; S108i0, i1; S111i0, i1; S110i0, i1; S109i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S110i0, i1 -> (i1); S112i0, i1 -> (i1); S111i0, i1 -> (i1); S113i0, i1 -> (i1); S109i0, i1 -> (i1); S108i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S108i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S109i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S110i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S111i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S112i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S113i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S119i0, i1; S114i0, i1; S117i0, i1; S115i0, i1; S118i0, i1; S116i0, i1 }"
+            child:
+              schedule: "M, N, O, P, Q, R -> { S115i0, i1 -> (i1); S116i0, i1 -> (i1); S118i0, i1 -> (i1); S117i0, i1 -> (i1); S119i0, i1 -> (i1); S114i0, i1 -> (i1) }"
+              options: "M, N, O, P, Q, R -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N, O, P, Q, R -> { S114i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S115i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S116i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S117i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S118i0, i1 }"
+                - filter: "M, N, O, P, Q, R -> { S119i0, i1 }"
+          - filter: "M, N, O, P, Q, R -> { S120i0 }"
+          - filter: "M, N, O, P, Q, R -> { S121i0 }"
+          - filter: "M, N, O, P, Q, R -> { S122i0 }"
+          - filter: "M, N, O, P, Q, R -> { S123i0 }"
+          - filter: "M, N, O, P, Q, R -> { S124i0 }"
+          - filter: "M, N, O, P, Q, R -> { S125i0 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/test.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/test.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/test.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/thomasset.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/thomasset.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/thomasset.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/tiling.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/uday_scalars.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/uday_scalars.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/uday_scalars.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/union.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/union.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/union.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/unroll.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/unroll.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/unroll.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/unroll2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/unroll2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/unroll2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/usvd_e_t.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/usvd_e_t.c Changed

@@ -1,348 +1,346 @@
-{
-  for (int c0 = 0; c0 <= 2; c0 += 1) {
-    S1(c0, 0, 0);
-    for (int c1 = 0; c1 <= 4; c1 += 1)
-      S2(c0, c1, 0);
-  }
-  S1(3, 0, 0);
+for (int c0 = 0; c0 <= 2; c0 += 1) {
+  S1(c0, 0, 0);
   for (int c1 = 0; c1 <= 4; c1 += 1)
-    S2(3, c1, 0);
-  for (int c1 = 7; c1 <= 11; c1 += 1)
-    S8(3, c1, 0);
-  S1(4, 0, 0);
-  S2(4, 0, 0);
-  S3(4, 0, 0);
-  S5(4, 0, 0);
-  for (int c1 = 1; c1 <= 4; c1 += 1) {
-    S2(4, c1, 0);
-    S5(4, c1, 0);
-  }
+    S2(c0, c1, 0);
+}
+S1(3, 0, 0);
+for (int c1 = 0; c1 <= 4; c1 += 1)
+  S2(3, c1, 0);
+for (int c1 = 7; c1 <= 11; c1 += 1)
+  S8(3, c1, 0);
+S1(4, 0, 0);
+S2(4, 0, 0);
+S3(4, 0, 0);
+S5(4, 0, 0);
+for (int c1 = 1; c1 <= 4; c1 += 1) {
+  S2(4, c1, 0);
+  S5(4, c1, 0);
+}
+for (int c1 = 7; c1 <= 11; c1 += 1)
+  S8(4, c1, 0);
+for (int c0 = 5; c0 <= 6; c0 += 1) {
+  for (int c1 = -4; c1 < c0 - 8; c1 += 1)
+    S6(c0, c1, 0);
+  for (int c1 = c0 - 9; c1 < 0; c1 += 1)
+    S7(c0, c1, 0);
+  S3(c0, 0, 0);
+  S7(c0, 0, 0);
+  for (int c1 = 1; c1 < c0 - 3; c1 += 1)
+    S4(c0, c1, -1);
+  for (int c1 = c0 - 4; c1 <= 4; c1 += 1)
+    S5(c0, c1, 0);
   for (int c1 = 7; c1 <= 11; c1 += 1)
-    S8(4, c1, 0);
-  for (int c0 = 5; c0 <= 6; c0 += 1) {
-    for (int c1 = -4; c1 < c0 - 8; c1 += 1)
-      S6(c0, c1, 0);
-    for (int c1 = c0 - 9; c1 < 0; c1 += 1)
-      S7(c0, c1, 0);
-    S3(c0, 0, 0);
-    S7(c0, 0, 0);
-    for (int c1 = 1; c1 < c0 - 3; c1 += 1)
-      S4(c0, c1, -1);
-    for (int c1 = c0 - 4; c1 <= 4; c1 += 1)
-      S5(c0, c1, 0);
-    for (int c1 = 7; c1 <= 11; c1 += 1)
-      S8(c0, c1, 0);
-  }
-  for (int c1 = -4; c1 < -1; c1 += 1)
-    S6(7, c1, 0);
-  for (int c1 = -2; c1 < 0; c1 += 1)
-    S7(7, c1, 0);
-  S3(7, 0, 0);
-  S7(7, 0, 0);
-  for (int c1 = 1; c1 <= 3; c1 += 1)
-    S4(7, c1, -1);
-  for (int c1 = 3; c1 <= 4; c1 += 1)
-    S5(7, c1, 0);
-  S9(7, 4, 0);
-  S10(7, 4, 0);
-  S11(7, 4, 0);
-  S21(7, 4, 0);
-  S23(7, 4, 0);
-  S11(7, 4, 1);
-  S16(7, 4, 1);
-  S17(7, 4, 1);
-  for (int c2 = 2; c2 <= 4; c2 += 1)
-    S11(7, 4, c2);
-  S12(7, 5, 0);
-  S21(7, 5, 0);
-  S22(7, 5, 0);
-  S23(7, 5, 0);
-  S12(7, 5, 1);
-  S16(7, 5, 1);
-  S17(7, 5, 1);
-  for (int c2 = 2; c2 <= 4; c2 += 1)
-    S12(7, 5, c2);
-  S21(7, 6, 0);
-  S22(7, 6, 0);
-  S23(7, 6, 0);
-  for (int c1 = 7; c1 <= 8; c1 += 1) {
-    S8(7, c1, 0);
-    S21(7, c1, 0);
-    S22(7, c1, 0);
-    S23(7, c1, 0);
-  }
-  S8(7, 9, 0);
-  S22(7, 9, 0);
-  for (int c1 = 10; c1 <= 11; c1 += 1)
-    S8(7, c1, 0);
-  for (int c1 = -4; c1 < 0; c1 += 1)
-    S6(8, c1, 0);
-  S7(8, -1, 0);
-  S3(8, 0, 0);
-  S7(8, 0, 0);
-  S19(8, 1, -2);
-  S4(8, 1, -1);
-  S19(8, 1, -1);
-  S19(8, 1, 0);
-  S15(8, 1, 4);
-  S18(8, 1, 4);
-  for (int c2 = -4; c2 < -2; c2 += 1) {
-    S14(8, 2, c2);
-    S20(8, 2, c2);
-  }
-  S14(8, 2, -2);
-  S19(8, 2, -2);
-  S20(8, 2, -2);
-  S4(8, 2, -1);
-  S14(8, 2, -1);
-  S19(8, 2, -1);
-  S20(8, 2, -1);
-  S14(8, 2, 0);
-  S19(8, 2, 0);
-  S20(8, 2, 0);
-  S15(8, 2, 4);
-  S18(8, 2, 4);
-  for (int c2 = -4; c2 < -1; c2 += 1) {
-    S14(8, 3, c2);
-    S20(8, 3, c2);
-  }
-  S4(8, 3, -1);
-  S14(8, 3, -1);
-  S20(8, 3, -1);
-  S14(8, 3, 0);
-  S20(8, 3, 0);
-  S15(8, 3, 4);
-  S18(8, 3, 4);
-  for (int c2 = -4; c2 < -1; c2 += 1) {
-    S14(8, 4, c2);
-    S20(8, 4, c2);
-  }
-  S4(8, 4, -1);
-  S14(8, 4, -1);
-  S20(8, 4, -1);
-  S5(8, 4, 0);
-  S9(8, 4, 0);
-  S10(8, 4, 0);
-  S14(8, 4, 0);
-  S20(8, 4, 0);
-  S23(8, 4, 0);
-  S13(8, 4, 1);
-  S21(8, 4, 1);
-  S23(8, 4, 1);
-  S24(8, 4, 1);
-  S13(8, 4, 2);
-  S16(8, 4, 2);
-  S17(8, 4, 2);
-  S24(8, 4, 2);
-  S13(8, 4, 3);
-  S24(8, 4, 3);
-  S13(8, 4, 4);
-  S15(8, 4, 4);
-  S23(8, 5, 0);
-  S11(8, 5, 1);
-  S21(8, 5, 1);
-  S22(8, 5, 1);
-  S23(8, 5, 1);
-  S24(8, 5, 1);
-  S11(8, 5, 2);
-  S16(8, 5, 2);
-  S17(8, 5, 2);
-  S24(8, 5, 2);
-  S11(8, 5, 3);
-  S24(8, 5, 3);
-  S11(8, 5, 4);
-  S15(8, 5, 4);
-  S23(8, 6, 0);
-  S12(8, 6, 1);
-  S21(8, 6, 1);
-  S22(8, 6, 1);
-  S23(8, 6, 1);
-  S24(8, 6, 1);
-  S12(8, 6, 2);
-  S16(8, 6, 2);
-  S17(8, 6, 2);
-  S24(8, 6, 2);
-  S12(8, 6, 3);
-  S24(8, 6, 3);
-  S12(8, 6, 4);
-  for (int c1 = 7; c1 <= 8; c1 += 1) {
-    S23(8, c1, 0);
-    S21(8, c1, 1);
-    S22(8, c1, 1);
-    S23(8, c1, 1);
-    for (int c2 = 1; c2 <= 3; c2 += 1)
-      S24(8, c1, c2);
-  }
-  S22(8, 9, 1);
-  S7(9, 0, 0);
-  for (int c1 = 1; c1 <= 2; c1 += 1) {
-    for (int c2 = -1; c2 <= 0; c2 += 1)
-      S19(9, c1, c2);
-    for (int c2 = 4; c2 <= 5; c2 += 1) {
-      S15(9, c1, c2);
-      S18(9, c1, c2);
-    }
-  }
-  S20(9, 3, -4);
-  for (int c2 = -3; c2 < -1; c2 += 1) {
-    S14(9, 3, c2);
-    S20(9, 3, c2);
-  }
-  for (int c2 = -1; c2 <= 0; c2 += 1) {
-    S14(9, 3, c2);
-    S19(9, 3, c2);
-    S20(9, 3, c2);
-  }
-  for (int c2 = 4; c2 <= 5; c2 += 1) {
-    S15(9, 3, c2);
-    S18(9, 3, c2);
-  }
-  S20(9, 4, -4);
-  for (int c2 = -3; c2 < 0; c2 += 1) {
-    S14(9, 4, c2);
-    S20(9, 4, c2);
-  }
-  S9(9, 4, 0);
-  S10(9, 4, 0);
-  S14(9, 4, 0);
-  S20(9, 4, 0);
-  for (int c2 = 0; c2 <= 1; c2 += 1)
-    S23(9, 4, c2);
-  S13(9, 4, 2);
-  S21(9, 4, 2);
-  S23(9, 4, 2);
-  S24(9, 4, 2);
-  S13(9, 4, 3);
-  S16(9, 4, 3);
-  S17(9, 4, 3);
-  S24(9, 4, 3);
-  S13(9, 4, 4);
+    S8(c0, c1, 0);
+}
+for (int c1 = -4; c1 < -1; c1 += 1)
+  S6(7, c1, 0);
+for (int c1 = -2; c1 < 0; c1 += 1)
+  S7(7, c1, 0);
+S3(7, 0, 0);
+S7(7, 0, 0);
+for (int c1 = 1; c1 <= 3; c1 += 1)
+  S4(7, c1, -1);
+for (int c1 = 3; c1 <= 4; c1 += 1)
+  S5(7, c1, 0);
+S9(7, 4, 0);
+S10(7, 4, 0);
+S11(7, 4, 0);
+S21(7, 4, 0);
+S23(7, 4, 0);
+S11(7, 4, 1);
+S16(7, 4, 1);
+S17(7, 4, 1);
+for (int c2 = 2; c2 <= 4; c2 += 1)
+  S11(7, 4, c2);
+S12(7, 5, 0);
+S21(7, 5, 0);
+S22(7, 5, 0);
+S23(7, 5, 0);
+S12(7, 5, 1);
+S16(7, 5, 1);
+S17(7, 5, 1);
+for (int c2 = 2; c2 <= 4; c2 += 1)
+  S12(7, 5, c2);
+S21(7, 6, 0);
+S22(7, 6, 0);
+S23(7, 6, 0);
+for (int c1 = 7; c1 <= 8; c1 += 1) {
+  S8(7, c1, 0);
+  S21(7, c1, 0);
+  S22(7, c1, 0);
+  S23(7, c1, 0);
+}
+S8(7, 9, 0);
+S22(7, 9, 0);
+for (int c1 = 10; c1 <= 11; c1 += 1)
+  S8(7, c1, 0);
+for (int c1 = -4; c1 < 0; c1 += 1)
+  S6(8, c1, 0);
+S7(8, -1, 0);
+S3(8, 0, 0);
+S7(8, 0, 0);
+S19(8, 1, -2);
+S4(8, 1, -1);
+S19(8, 1, -1);
+S19(8, 1, 0);
+S15(8, 1, 4);
+S18(8, 1, 4);
+for (int c2 = -4; c2 < -2; c2 += 1) {
+  S14(8, 2, c2);
+  S20(8, 2, c2);
+}
+S14(8, 2, -2);
+S19(8, 2, -2);
+S20(8, 2, -2);
+S4(8, 2, -1);
+S14(8, 2, -1);
+S19(8, 2, -1);
+S20(8, 2, -1);
+S14(8, 2, 0);
+S19(8, 2, 0);
+S20(8, 2, 0);
+S15(8, 2, 4);
+S18(8, 2, 4);
+for (int c2 = -4; c2 < -1; c2 += 1) {
+  S14(8, 3, c2);
+  S20(8, 3, c2);
+}
+S4(8, 3, -1);
+S14(8, 3, -1);
+S20(8, 3, -1);
+S14(8, 3, 0);
+S20(8, 3, 0);
+S15(8, 3, 4);
+S18(8, 3, 4);
+for (int c2 = -4; c2 < -1; c2 += 1) {
+  S14(8, 4, c2);
+  S20(8, 4, c2);
+}
+S4(8, 4, -1);
+S14(8, 4, -1);
+S20(8, 4, -1);
+S5(8, 4, 0);
+S9(8, 4, 0);
+S10(8, 4, 0);
+S14(8, 4, 0);
+S20(8, 4, 0);
+S23(8, 4, 0);
+S13(8, 4, 1);
+S21(8, 4, 1);
+S23(8, 4, 1);
+S24(8, 4, 1);
+S13(8, 4, 2);
+S16(8, 4, 2);
+S17(8, 4, 2);
+S24(8, 4, 2);
+S13(8, 4, 3);
+S24(8, 4, 3);
+S13(8, 4, 4);
+S15(8, 4, 4);
+S23(8, 5, 0);
+S11(8, 5, 1);
+S21(8, 5, 1);
+S22(8, 5, 1);
+S23(8, 5, 1);
+S24(8, 5, 1);
+S11(8, 5, 2);
+S16(8, 5, 2);
+S17(8, 5, 2);
+S24(8, 5, 2);
+S11(8, 5, 3);
+S24(8, 5, 3);
+S11(8, 5, 4);
+S15(8, 5, 4);
+S23(8, 6, 0);
+S12(8, 6, 1);
+S21(8, 6, 1);
+S22(8, 6, 1);
+S23(8, 6, 1);
+S24(8, 6, 1);
+S12(8, 6, 2);
+S16(8, 6, 2);
+S17(8, 6, 2);
+S24(8, 6, 2);
+S12(8, 6, 3);
+S24(8, 6, 3);
+S12(8, 6, 4);
+for (int c1 = 7; c1 <= 8; c1 += 1) {
+  S23(8, c1, 0);
+  S21(8, c1, 1);
+  S22(8, c1, 1);
+  S23(8, c1, 1);
+  for (int c2 = 1; c2 <= 3; c2 += 1)
+    S24(8, c1, c2);
+}
+S22(8, 9, 1);
+S7(9, 0, 0);
+for (int c1 = 1; c1 <= 2; c1 += 1) {
+  for (int c2 = -1; c2 <= 0; c2 += 1)
+    S19(9, c1, c2);
   for (int c2 = 4; c2 <= 5; c2 += 1) {
-    S15(9, 4, c2);
-    S18(9, 4, c2);
-  }
-  for (int c2 = 0; c2 <= 1; c2 += 1)
-    S23(9, 5, c2);
-  S13(9, 5, 2);
-  S21(9, 5, 2);
-  S22(9, 5, 2);
-  S23(9, 5, 2);
-  S24(9, 5, 2);
-  S13(9, 5, 3);
-  S16(9, 5, 3);
-  S17(9, 5, 3);
-  S24(9, 5, 3);
-  S13(9, 5, 4);
-  for (int c2 = 4; c2 <= 5; c2 += 1)
-    S15(9, 5, c2);
-  for (int c2 = 0; c2 <= 1; c2 += 1)
-    S23(9, 6, c2);
-  S11(9, 6, 2);
-  S21(9, 6, 2);
-  S22(9, 6, 2);
-  S23(9, 6, 2);
-  S24(9, 6, 2);
-  S11(9, 6, 3);
-  S16(9, 6, 3);
-  S17(9, 6, 3);
-  S24(9, 6, 3);
-  S11(9, 6, 4);
-  for (int c2 = 0; c2 <= 1; c2 += 1)
-    S23(9, 7, c2);
-  S12(9, 7, 2);
-  S21(9, 7, 2);
-  S22(9, 7, 2);
-  S23(9, 7, 2);
-  S24(9, 7, 2);
-  S12(9, 7, 3);
-  S16(9, 7, 3);
-  S17(9, 7, 3);
-  S24(9, 7, 3);
-  S12(9, 7, 4);
-  for (int c2 = 0; c2 <= 1; c2 += 1)
-    S23(9, 8, c2);
-  S21(9, 8, 2);
-  S22(9, 8, 2);
-  S23(9, 8, 2);
-  for (int c2 = 2; c2 <= 3; c2 += 1)
-    S24(9, 8, c2);
-  S22(9, 9, 2);
-  for (int c1 = 1; c1 <= 3; c1 += 1) {
-    S19(10, c1, 0);
-    S26(10, c1, 3);
-    S15(10, c1, 4);
-    S18(10, c1, 4);
-    S25(10, c1, 4);
-    for (int c2 = 5; c2 <= 6; c2 += 1) {
-      S15(10, c1, c2);
-      S18(10, c1, c2);
-    }
+    S15(9, c1, c2);
+    S18(9, c1, c2);
   }
-  for (int c2 = -4; c2 < -2; c2 += 1)
-    S20(10, 4, c2);
-  for (int c2 = -2; c2 < 0; c2 += 1) {
-    S14(10, 4, c2);
-    S20(10, 4, c2);
-  }
-  S9(10, 4, 0);
-  S10(10, 4, 0);
-  S14(10, 4, 0);
-  S19(10, 4, 0);
-  S20(10, 4, 0);
-  S13(10, 4, 3);
-  S21(10, 4, 3);
-  S24(10, 4, 3);
-  S26(10, 4, 3);
-  S13(10, 4, 4);
-  S15(10, 4, 4);
-  S16(10, 4, 4);
-  S17(10, 4, 4);
-  S18(10, 4, 4);
-  S25(10, 4, 4);
-  for (int c2 = 5; c2 <= 6; c2 += 1) {
-    S15(10, 4, c2);
-    S18(10, 4, c2);
-  }
-  S13(10, 5, 3);
-  S21(10, 5, 3);
-  S22(10, 5, 3);
-  S24(10, 5, 3);
-  S26(10, 5, 3);
-  S13(10, 5, 4);
-  S15(10, 5, 4);
-  S16(10, 5, 4);
-  S17(10, 5, 4);
-  S18(10, 5, 4);
-  S25(10, 5, 4);
+}
+S20(9, 3, -4);
+for (int c2 = -3; c2 < -1; c2 += 1) {
+  S14(9, 3, c2);
+  S20(9, 3, c2);
+}
+for (int c2 = -1; c2 <= 0; c2 += 1) {
+  S14(9, 3, c2);
+  S19(9, 3, c2);
+  S20(9, 3, c2);
+}
+for (int c2 = 4; c2 <= 5; c2 += 1) {
+  S15(9, 3, c2);
+  S18(9, 3, c2);
+}
+S20(9, 4, -4);
+for (int c2 = -3; c2 < 0; c2 += 1) {
+  S14(9, 4, c2);
+  S20(9, 4, c2);
+}
+S9(9, 4, 0);
+S10(9, 4, 0);
+S14(9, 4, 0);
+S20(9, 4, 0);
+for (int c2 = 0; c2 <= 1; c2 += 1)
+  S23(9, 4, c2);
+S13(9, 4, 2);
+S21(9, 4, 2);
+S23(9, 4, 2);
+S24(9, 4, 2);
+S13(9, 4, 3);
+S16(9, 4, 3);
+S17(9, 4, 3);
+S24(9, 4, 3);
+S13(9, 4, 4);
+for (int c2 = 4; c2 <= 5; c2 += 1) {
+  S15(9, 4, c2);
+  S18(9, 4, c2);
+}
+for (int c2 = 0; c2 <= 1; c2 += 1)
+  S23(9, 5, c2);
+S13(9, 5, 2);
+S21(9, 5, 2);
+S22(9, 5, 2);
+S23(9, 5, 2);
+S24(9, 5, 2);
+S13(9, 5, 3);
+S16(9, 5, 3);
+S17(9, 5, 3);
+S24(9, 5, 3);
+S13(9, 5, 4);
+for (int c2 = 4; c2 <= 5; c2 += 1)
+  S15(9, 5, c2);
+for (int c2 = 0; c2 <= 1; c2 += 1)
+  S23(9, 6, c2);
+S11(9, 6, 2);
+S21(9, 6, 2);
+S22(9, 6, 2);
+S23(9, 6, 2);
+S24(9, 6, 2);
+S11(9, 6, 3);
+S16(9, 6, 3);
+S17(9, 6, 3);
+S24(9, 6, 3);
+S11(9, 6, 4);
+for (int c2 = 0; c2 <= 1; c2 += 1)
+  S23(9, 7, c2);
+S12(9, 7, 2);
+S21(9, 7, 2);
+S22(9, 7, 2);
+S23(9, 7, 2);
+S24(9, 7, 2);
+S12(9, 7, 3);
+S16(9, 7, 3);
+S17(9, 7, 3);
+S24(9, 7, 3);
+S12(9, 7, 4);
+for (int c2 = 0; c2 <= 1; c2 += 1)
+  S23(9, 8, c2);
+S21(9, 8, 2);
+S22(9, 8, 2);
+S23(9, 8, 2);
+for (int c2 = 2; c2 <= 3; c2 += 1)
+  S24(9, 8, c2);
+S22(9, 9, 2);
+for (int c1 = 1; c1 <= 3; c1 += 1) {
+  S19(10, c1, 0);
+  S26(10, c1, 3);
+  S15(10, c1, 4);
+  S18(10, c1, 4);
+  S25(10, c1, 4);
   for (int c2 = 5; c2 <= 6; c2 += 1) {
-    S15(10, 5, c2);
-    S18(10, 5, c2);
+    S15(10, c1, c2);
+    S18(10, c1, c2);
   }
-  S13(10, 6, 3);
-  S21(10, 6, 3);
-  S22(10, 6, 3);
-  S24(10, 6, 3);
-  S13(10, 6, 4);
-  S16(10, 6, 4);
-  S17(10, 6, 4);
-  S11(10, 7, 3);
-  S21(10, 7, 3);
-  S22(10, 7, 3);
-  S24(10, 7, 3);
-  S11(10, 7, 4);
-  S16(10, 7, 4);
-  S17(10, 7, 4);
-  S12(10, 8, 3);
-  S21(10, 8, 3);
-  S22(10, 8, 3);
-  S24(10, 8, 3);
-  S12(10, 8, 4);
-  S16(10, 8, 4);
-  S17(10, 8, 4);
-  S22(10, 9, 3);
-  for (int c0 = 11; c0 <= 14; c0 += 1)
-    for (int c1 = 1; c1 <= 5; c1 += 1) {
-      S26(c0, c1, 3);
-      S25(c0, c1, 4);
-    }
 }
+for (int c2 = -4; c2 < -2; c2 += 1)
+  S20(10, 4, c2);
+for (int c2 = -2; c2 < 0; c2 += 1) {
+  S14(10, 4, c2);
+  S20(10, 4, c2);
+}
+S9(10, 4, 0);
+S10(10, 4, 0);
+S14(10, 4, 0);
+S19(10, 4, 0);
+S20(10, 4, 0);
+S13(10, 4, 3);
+S21(10, 4, 3);
+S24(10, 4, 3);
+S26(10, 4, 3);
+S13(10, 4, 4);
+S15(10, 4, 4);
+S16(10, 4, 4);
+S17(10, 4, 4);
+S18(10, 4, 4);
+S25(10, 4, 4);
+for (int c2 = 5; c2 <= 6; c2 += 1) {
+  S15(10, 4, c2);
+  S18(10, 4, c2);
+}
+S13(10, 5, 3);
+S21(10, 5, 3);
+S22(10, 5, 3);
+S24(10, 5, 3);
+S26(10, 5, 3);
+S13(10, 5, 4);
+S15(10, 5, 4);
+S16(10, 5, 4);
+S17(10, 5, 4);
+S18(10, 5, 4);
+S25(10, 5, 4);
+for (int c2 = 5; c2 <= 6; c2 += 1) {
+  S15(10, 5, c2);
+  S18(10, 5, c2);
+}
+S13(10, 6, 3);
+S21(10, 6, 3);
+S22(10, 6, 3);
+S24(10, 6, 3);
+S13(10, 6, 4);
+S16(10, 6, 4);
+S17(10, 6, 4);
+S11(10, 7, 3);
+S21(10, 7, 3);
+S22(10, 7, 3);
+S24(10, 7, 3);
+S11(10, 7, 4);
+S16(10, 7, 4);
+S17(10, 7, 4);
+S12(10, 8, 3);
+S21(10, 8, 3);
+S22(10, 8, 3);
+S24(10, 8, 3);
+S12(10, 8, 4);
+S16(10, 8, 4);
+S17(10, 8, 4);
+S22(10, 9, 3);
+for (int c0 = 11; c0 <= 14; c0 += 1)
+  for (int c1 = 1; c1 <= 5; c1 += 1) {
+    S26(c0, c1, 3);
+    S25(c0, c1, 4);
+  }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/usvd_e_t.st Added

@@ -0,0 +1,34 @@
+domain: "{ S22i0, i1, -7 + i0 : i0 >= 7 and i1 >= 5 and i1 <= 9 and i0 <= 10; S21i0, i1, -7 + i0 : i0 <= 10 and i1 >= 4 and i1 <= 8 and i0 >= 7; S4i0, i1, -1 : i0 <= 8 and i1 >= 1 and i1 <= -4 + i0; S8i0, i1, 0 : i0 >= 3 and i0 <= 7 and i1 >= 7 and i1 <= 11; S25i0, i1, 4 : i0 >= 10 and i0 <= 14 and i1 >= 1 and i1 <= 5; S15i0, i1, i2 : i0 <= 10 and i1 >= 1 and i1 <= 5 and i2 >= 4 and i2 <= -4 + i0; S6i0, i1, 0 : i0 <= 8 and i1 >= -4 and i1 <= -9 + i0; S16i0, i1, -6 + i0 : i0 <= 10 and i1 >= 4 and i0 >= 7 and i1 <= -2 + i0; S7i0, i1, 0 : i0 >= 5 and i1 <= 0 and i1 >= -9 + i0; S1i0, 0, 0 : i0 >= 0 and i0 <= 4; S2i0, i1, 0 : i0 >= 0 and i0 <= 4 and i1 >= 0 and i1 <= 4; S26i0, i1, 3 : i0 >= 10 and i0 <= 14 and i1 >= 1 and i1 <= 5; S10i0, 4, 0 : i0 >= 7 and i0 <= 10; S12i0, -2 + i0, i2 : i0 >= 7 and i0 <= 10 and i2 <= 4 and i2 >= -7 + i0; S23i0, i1, i2 : i0 <= 9 and i1 >= 4 and i1 <= 8 and i2 >= 0 and i2 <= -7 + i0; S13i0, i1, i2 : i0 <= 10 and i1 >= 4 and i2 <= 4 and i2 >= -7 + i0 and i1 <= -4 + i0; S20i0, i1, i2 : i0 >= 8 and i1 <= 4 and i2 >= -4 and i2 <= 0 and i1 >= -6 + i0; S24i0, i1, i2 : i0 >= 8 and i1 >= 4 and i1 <= 8 and i2 <= 3 and i2 >= -7 + i0; S19i0, i1, i2 : i0 >= 8 and i1 >= 1 and i2 <= 0 and i2 >= -10 + i0 and i1 <= -6 + i0; S11i0, -3 + i0, i2 : i0 <= 10 and i0 >= 7 and i2 <= 4 and i2 >= -7 + i0; S14i0, i1, i2 : i0 >= 8 and i1 <= 4 and i2 <= 0 and i2 >= -12 + i0 and i1 >= -6 + i0; S3i0, 0, 0 : i0 >= 4 and i0 <= 8; S9i0, 4, 0 : i0 >= 7 and i0 <= 10; S18i0, i1, i2 : i0 <= 10 and i1 >= 1 and i2 >= 4 and i2 <= -4 + i0 and i1 <= -5 + i0; S5i0, i1, 0 : i0 >= 4 and i1 <= 4 and i1 >= -4 + i0; S17i0, i1, -6 + i0 : i0 >= 7 and i1 >= 4 and i0 <= 10 and i1 <= -2 + i0 }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S8i0, i1, i2 -> (i0); S21i0, i1, i2 -> (i0); S9i0, i1, i2 -> (i0); S10i0, i1, i2 -> (i0); S24i0, i1, i2 -> (i0); S15i0, i1, i2 -> (i0); S12i0, i1, i2 -> (i0); S7i0, i1, i2 -> (i0); S6i0, i1, i2 -> (i0); S23i0, i1, i2 -> (i0); S22i0, i1, i2 -> (i0); S16i0, i1, i2 -> (i0); S17i0, i1, i2 -> (i0); S25i0, i1, i2 -> (i0); S18i0, i1, i2 -> (i0); S26i0, i1, i2 -> (i0); S5i0, i1, i2 -> (i0); S2i0, i1, i2 -> (i0); S4i0, i1, i2 -> (i0); S13i0, i1, i2 -> (i0); S3i0, i1, i2 -> (i0); S14i0, i1, i2 -> (i0); S19i0, i1, i2 -> (i0); S20i0, i1, i2 -> (i0); S11i0, i1, i2 -> (i0); S1i0, i1, i2 -> (i0) }, { S8i0, i1, i2 -> (i1); S21i0, i1, i2 -> (i1); S9i0, i1, i2 -> (i1); S10i0, i1, i2 -> (i1); S24i0, i1, i2 -> (i1); S15i0, i1, i2 -> (i1); S12i0, i1, i2 -> (i1); S7i0, i1, i2 -> (i1); S6i0, i1, i2 -> (i1); S23i0, i1, i2 -> (i1); S22i0, i1, i2 -> (i1); S16i0, i1, i2 -> (i1); S17i0, i1, i2 -> (i1); S25i0, i1, i2 -> (i1); S18i0, i1, i2 -> (i1); S26i0, i1, i2 -> (i1); S5i0, i1, i2 -> (i1); S2i0, i1, i2 -> (i1); S4i0, i1, i2 -> (i1); S13i0, i1, i2 -> (i1); S3i0, i1, i2 -> (i1); S14i0, i1, i2 -> (i1); S19i0, i1, i2 -> (i1); S20i0, i1, i2 -> (i1); S11i0, i1, i2 -> (i1); S1i0, i1, i2 -> (i1) }, { S8i0, i1, i2 -> (i2); S21i0, i1, i2 -> (i2); S9i0, i1, i2 -> (i2); S10i0, i1, i2 -> (i2); S24i0, i1, i2 -> (i2); S15i0, i1, i2 -> (i2); S12i0, i1, i2 -> (i2); S7i0, i1, i2 -> (i2); S6i0, i1, i2 -> (i2); S23i0, i1, i2 -> (i2); S22i0, i1, i2 -> (i2); S16i0, i1, i2 -> (i2); S17i0, i1, i2 -> (i2); S25i0, i1, i2 -> (i2); S18i0, i1, i2 -> (i2); S26i0, i1, i2 -> (i2); S5i0, i1, i2 -> (i2); S2i0, i1, i2 -> (i2); S4i0, i1, i2 -> (i2); S13i0, i1, i2 -> (i2); S3i0, i1, i2 -> (i2); S14i0, i1, i2 -> (i2); S19i0, i1, i2 -> (i2); S20i0, i1, i2 -> (i2); S11i0, i1, i2 -> (i2); S1i0, i1, i2 -> (i2) }"
+    options: "{ separatei0 }"
+    child:
+      sequence:
+      - filter: "{ S1i0, i1, i2 }"
+      - filter: "{ S2i0, i1, i2 }"
+      - filter: "{ S3i0, i1, i2 }"
+      - filter: "{ S4i0, i1, i2 }"
+      - filter: "{ S5i0, i1, i2 }"
+      - filter: "{ S6i0, i1, i2 }"
+      - filter: "{ S7i0, i1, i2 }"
+      - filter: "{ S8i0, i1, i2 }"
+      - filter: "{ S9i0, i1, i2 }"
+      - filter: "{ S10i0, i1, i2 }"
+      - filter: "{ S11i0, i1, i2 }"
+      - filter: "{ S12i0, i1, i2 }"
+      - filter: "{ S13i0, i1, i2 }"
+      - filter: "{ S14i0, i1, i2 }"
+      - filter: "{ S15i0, i1, i2 }"
+      - filter: "{ S16i0, i1, i2 }"
+      - filter: "{ S17i0, i1, i2 }"
+      - filter: "{ S18i0, i1, i2 }"
+      - filter: "{ S19i0, i1, i2 }"
+      - filter: "{ S20i0, i1, i2 }"
+      - filter: "{ S21i0, i1, i2 }"
+      - filter: "{ S22i0, i1, i2 }"
+      - filter: "{ S23i0, i1, i2 }"
+      - filter: "{ S24i0, i1, i2 }"
+      - filter: "{ S25i0, i1, i2 }"
+      - filter: "{ S26i0, i1, i2 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vasilache.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vasilache.c Changed

@@ -1,23 +1,22 @@
-{
-  S1();
-  S2();
+S1();
+S2();
+for (int c0 = 0; c0 < N; c0 += 1)
+  for (int c1 = 0; c1 < N; c1 += 1) {
+    S4(c0, c1);
+    S5(c0, c1);
+  }
+for (int c0 = 0; c0 < N; c0 += 1)
   for (int c1 = 0; c1 < N; c1 += 1)
-    for (int c3 = 0; c3 < N; c3 += 1) {
-      S4(c1, c3);
-      S5(c1, c3);
-    }
-  for (int c1 = 0; c1 < N; c1 += 1)
-    for (int c3 = 0; c3 < N; c3 += 1)
-      for (int c5 = 0; c5 <= (N - 1) / 32; c5 += 1) {
-        S7(c1, c3, c5, 32 * c5);
-        for (int c7 = 32 * c5 + 1; c7 <= min(N - 1, 32 * c5 + 31); c7 += 1) {
-          S6(c1, c3, c5, c7 - 1);
-          S7(c1, c3, c5, c7);
-        }
-        if (32 * c5 + 31 >= N) {
-          S6(c1, c3, c5, N - 1);
-        } else
-          S6(c1, c3, c5, 32 * c5 + 31);
+    for (int c2 = 0; c2 <= (N - 1) / 32; c2 += 1) {
+      S7(c0, c1, c2, 32 * c2);
+      for (int c3 = 32 * c2 + 1; c3 <= min(N - 1, 32 * c2 + 31); c3 += 1) {
+        S6(c0, c1, c2, c3 - 1);
+        S7(c0, c1, c2, c3);
       }
-  S8();
-}
+      if (32 * c2 + 31 >= N) {
+        S6(c0, c1, c2, N - 1);
+      } else {
+        S6(c0, c1, c2, 32 * c2 + 31);
+      }
+    }
+S8();

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vasilache.st Added

@@ -0,0 +1,37 @@
+domain: "M, N -> { S5i0, i1 : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N; S8; S2; S7i0, i1, i2, i3 : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N and i3 >= 0 and i3 <= -1 + N and i3 >= 32i2 and i3 <= 31 + 32i2; S4i0, i1 : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N; S1; S3 : M >= 79; S6i0, i1, i2, i3 : i0 >= 0 and i0 <= -1 + N and i1 >= 0 and i1 <= -1 + N and i3 >= 0 and i3 <= -1 + N and i3 >= 32i2 and i3 <= 31 + 32i2 }"
+child:
+  context: "M, N -> {  : M <= 3 and N >= 100 }"
+  child:
+    sequence:
+    - filter: "M, N -> { S1 }"
+    - filter: "M, N -> { S2 }"
+    - filter: "M, N -> { S3 }"
+    - filter: "M, N -> { S5i0, i1; S4i0, i1 }"
+      child:
+        schedule: "M, N -> { S5i0, i1 -> (i0); S4i0, i1 -> (i0) }"
+        options: "M, N -> { separatei0 }"
+        child:
+          schedule: "M, N -> { S5i0, i1 -> (i1); S4i0, i1 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+          child:
+            sequence:
+            - filter: "M, N -> { S4i0, i1 }"
+            - filter: "M, N -> { S5i0, i1 }"
+    - filter: "M, N -> { S7i0, i1, i2, i3; S6i0, i1, i2, i3 }"
+      child:
+        schedule: "M, N -> { S7i0, i1, i2, i3 -> (i0); S6i0, i1, i2, i3 -> (i0) }"
+        options: "M, N -> { separatei0 }"
+        child:
+          schedule: "M, N -> { S7i0, i1, i2, i3 -> (i1); S6i0, i1, i2, i3 -> (i1) }"
+          options: "M, N -> { separatei0 }"
+          child:
+            schedule: "M, N -> { S7i0, i1, i2, i3 -> (i2); S6i0, i1, i2, i3 -> (i2) }"
+            options: "M, N -> { separatei0 }"
+            child:
+              schedule: "M, N -> { S7i0, i1, i2, i3 -> (i3); S6i0, i1, i2, i3 -> (1 + i3) }"
+              options: "M, N -> { separatei0 }"
+              child:
+                sequence:
+                - filter: "M, N -> { S6i0, i1, i2, i3 }"
+                - filter: "M, N -> { S7i0, i1, i2, i3 }"
+    - filter: "M, N -> { S8 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vivien.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vivien.c Changed

@@ -1,85 +1,85 @@
-{
-  for (int c0 = -27 * n + 2; c0 <= 1; c0 += 1)
-    S1(c0 - 1);
-  for (int c0 = 2; c0 <= min(2 * n, n + 29); c0 += 1) {
-    if (c0 >= 3) {
-      if (2 * n >= c0 + 1) {
-        S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
-        if (c0 + 2 >= 2 * n) {
-          for (int c2 = 1; c2 < -n + c0; c2 += 1)
-            S5(-n + c0, n, c2);
-        } else if (c0 >= 5) {
-          S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
-          for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
-            S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
-        }
-      }
-      for (int c1 = -c0 + c0 / 2 + 3; c1 <= min(-1, n - c0); c1 += 1) {
-        S4(-c1, c0 + c1);
-        S6(-c1 + 2, c0 + c1 - 2);
-        for (int c2 = 1; c2 <= -c1; c2 += 1)
-          S5(-c1 + 1, c0 + c1 - 1, c2);
-      }
-      if (2 * n >= c0 + 3 && c0 >= n + 2) {
-        S6(-n + c0 + 1, n - 1);
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
-      }
-      if (c0 >= n + 3 && 2 * n >= c0 + 1) {
-        S6(-n + c0, n);
-      } else {
-        if (c0 >= 5 && n + 1 >= c0) {
-          S6(2, c0 - 2);
-          S1(c0 - 1);
-        } else if (n + 1 >= c0 && c0 <= 4)
-          S1(c0 - 1);
-        if (n + 1 >= c0) {
-          S6(1, c0 - 1);
-        } else if (n >= 3 && c0 == n + 2) {
-          S6(2, n);
-          S1(n + 1);
-        }
-      }
-      if (c0 >= n + 3)
-        S1(c0 - 1);
-      if (n == 2 && c0 == 4)
-        S1(3);
-    } else
-      S1(1);
-    if (c0 % 2 == 0)
-      S3(c0 / 2);
-    for (int c1 = max(1, -n + c0); c1 < (c0 + 1) / 2; c1 += 1)
-      S2(c0 - c1, c1);
-  }
-  for (int c0 = max(2 * n + 1, -27 * n + 2); c0 <= n + 29; c0 += 1)
-    S1(c0 - 1);
-  for (int c0 = n + 30; c0 <= 2 * n; c0 += 1) {
+for (int c0 = -27 * n + 2; c0 <= 1; c0 += 1)
+  S1(c0 - 1);
+for (int c0 = 2; c0 <= min(2 * n, n + 29); c0 += 1) {
+  if (c0 >= 3) {
     if (2 * n >= c0 + 1) {
       S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
       if (c0 + 2 >= 2 * n) {
         for (int c2 = 1; c2 < -n + c0; c2 += 1)
           S5(-n + c0, n, c2);
-      } else {
+      } else if (c0 >= 5) {
         S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
         for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
           S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
       }
-      for (int c1 = -c0 + c0 / 2 + 3; c1 <= n - c0; c1 += 1) {
-        S4(-c1, c0 + c1);
-        S6(-c1 + 2, c0 + c1 - 2);
-        for (int c2 = 1; c2 <= -c1; c2 += 1)
-          S5(-c1 + 1, c0 + c1 - 1, c2);
+    }
+    for (int c1 = -c0 + c0 / 2 + 3; c1 <= min(-1, n - c0); c1 += 1) {
+      S4(-c1, c0 + c1);
+      S6(-c1 + 2, c0 + c1 - 2);
+      for (int c2 = 1; c2 <= -c1; c2 += 1)
+        S5(-c1 + 1, c0 + c1 - 1, c2);
+    }
+    if (2 * n >= c0 + 3 && c0 >= n + 2) {
+      S6(-n + c0 + 1, n - 1);
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    }
+    if (c0 >= n + 3 && 2 * n >= c0 + 1)
+      S6(-n + c0, n);
+    if (c0 >= n + 3) {
+      S1(c0 - 1);
+    } else {
+      if (n + 1 >= c0 && c0 <= 4) {
+        S1(c0 - 1);
+      } else if (c0 >= 5 && n + 1 >= c0) {
+        S1(c0 - 1);
+        S6(2, c0 - 2);
       }
-      if (2 * n >= c0 + 3) {
-        S6(-n + c0 + 1, n - 1);
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
+      if (n + 1 >= c0) {
+        S6(1, c0 - 1);
+      } else if (n >= 3) {
+        S1(n + 1);
+        S6(2, n);
       }
-      S6(-n + c0, n);
     }
-    if (c0 % 2 == 0)
-      S3(c0 / 2);
-    for (int c1 = -n + c0; c1 < (c0 + 1) / 2; c1 += 1)
-      S2(c0 - c1, c1);
+    if (n == 2 && c0 == 4)
+      S1(3);
+  } else {
+    S1(1);
+  }
+  if (c0 % 2 == 0)
+    S3(c0 / 2);
+  for (int c1 = max(1, -n + c0); c1 < (c0 + 1) / 2; c1 += 1)
+    S2(c0 - c1, c1);
+}
+for (int c0 = max(2 * n + 1, -27 * n + 2); c0 <= n + 29; c0 += 1)
+  S1(c0 - 1);
+for (int c0 = n + 30; c0 <= 2 * n; c0 += 1) {
+  if (2 * n >= c0 + 1) {
+    S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
+    if (c0 + 2 >= 2 * n) {
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    } else {
+      S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
+      for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
+        S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
+    }
+    for (int c1 = -c0 + c0 / 2 + 3; c1 <= n - c0; c1 += 1) {
+      S4(-c1, c0 + c1);
+      S6(-c1 + 2, c0 + c1 - 2);
+      for (int c2 = 1; c2 <= -c1; c2 += 1)
+        S5(-c1 + 1, c0 + c1 - 1, c2);
+    }
+    if (2 * n >= c0 + 3) {
+      S6(-n + c0 + 1, n - 1);
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    }
+    S6(-n + c0, n);
   }
+  if (c0 % 2 == 0)
+    S3(c0 / 2);
+  for (int c1 = -n + c0; c1 < (c0 + 1) / 2; c1 += 1)
+    S2(c0 - c1, c1);
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vivien.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/vivien2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vivien2.c Changed

@@ -1,77 +1,76 @@
-{
-  for (int c0 = -27 * n + 2; c0 <= 1; c0 += 1)
-    S1(c0 - 1);
-  for (int c0 = 2; c0 <= n + 29; c0 += 1) {
-    if (c0 >= 3) {
-      S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
-      if (c0 >= 5 && 2 * n >= c0 + 3) {
-        S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
-        for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
-          S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
-      }
-      for (int c1 = -c0 + c0 / 2 + 3; c1 <= min(-1, n - c0); c1 += 1) {
-        S4(-c1, c0 + c1);
-        S6(-c1 + 2, c0 + c1 - 2);
-        for (int c2 = 1; c2 <= -c1; c2 += 1)
-          S5(-c1 + 1, c0 + c1 - 1, c2);
-      }
-      if (2 * n >= c0 + 3 && c0 >= n + 2) {
-        S6(-n + c0 + 1, n - 1);
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
-      } else if (c0 + 2 >= 2 * n)
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
-      if (c0 >= n + 3) {
-        S6(-n + c0, n);
+for (int c0 = -27 * n + 2; c0 <= 1; c0 += 1)
+  S1(c0 - 1);
+for (int c0 = 2; c0 <= n + 29; c0 += 1) {
+  if (c0 >= 3) {
+    S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
+    if (c0 <= 4) {
+      S1(c0 - 1);
+    } else if (c0 + 2 >= 2 * n) {
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    } else {
+      S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
+      for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
+        S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
+    }
+    for (int c1 = -c0 + c0 / 2 + 3; c1 <= min(-1, n - c0); c1 += 1) {
+      S4(-c1, c0 + c1);
+      S6(-c1 + 2, c0 + c1 - 2);
+      for (int c2 = 1; c2 <= -c1; c2 += 1)
+        S5(-c1 + 1, c0 + c1 - 1, c2);
+    }
+    if (2 * n >= c0 + 3 && c0 >= n + 2) {
+      S6(-n + c0 + 1, n - 1);
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    }
+    if (c0 >= n + 3) {
+      S6(-n + c0, n);
+      S1(c0 - 1);
+    } else if (c0 == n + 2) {
+      S1(n + 1);
+      S6(2, n);
+    } else {
+      if (c0 >= 5) {
         S1(c0 - 1);
-      } else {
-        if (c0 >= 5 && n + 1 >= c0) {
-          S6(2, c0 - 2);
-          S1(c0 - 1);
-        } else if (c0 <= 4)
-          S1(c0 - 1);
-        if (n + 1 >= c0) {
-          S6(1, c0 - 1);
-        } else {
-          S6(2, n);
-          S1(n + 1);
-        }
+        S6(2, c0 - 2);
       }
-    } else
-      S1(1);
-    if (c0 % 2 == 0)
-      S3(c0 / 2);
-    for (int c1 = max(1, -n + c0); c1 < (c0 + 1) / 2; c1 += 1)
-      S2(c0 - c1, c1);
+      S6(1, c0 - 1);
+    }
+  } else {
+    S1(1);
   }
-  for (int c0 = n + 30; c0 <= 2 * n; c0 += 1) {
-    if (2 * n >= c0 + 1) {
-      S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
-      if (c0 + 2 >= 2 * n) {
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
-      } else {
-        S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
-        for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
-          S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
-      }
-      for (int c1 = -c0 + c0 / 2 + 3; c1 <= n - c0; c1 += 1) {
-        S4(-c1, c0 + c1);
-        S6(-c1 + 2, c0 + c1 - 2);
-        for (int c2 = 1; c2 <= -c1; c2 += 1)
-          S5(-c1 + 1, c0 + c1 - 1, c2);
-      }
-      if (2 * n >= c0 + 3) {
-        S6(-n + c0 + 1, n - 1);
-        for (int c2 = 1; c2 < -n + c0; c2 += 1)
-          S5(-n + c0, n, c2);
-      }
-      S6(-n + c0, n);
+  if (c0 % 2 == 0)
+    S3(c0 / 2);
+  for (int c1 = max(1, -n + c0); c1 < (c0 + 1) / 2; c1 += 1)
+    S2(c0 - c1, c1);
+}
+for (int c0 = n + 30; c0 <= 2 * n; c0 += 1) {
+  if (2 * n >= c0 + 1) {
+    S4(c0 - c0 / 2 - 1, c0 / 2 + 1);
+    if (c0 + 2 >= 2 * n) {
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
+    } else {
+      S4(c0 - c0 / 2 - 2, c0 / 2 + 2);
+      for (int c2 = 1; c2 < c0 - c0 / 2 - 1; c2 += 1)
+        S5(c0 - c0 / 2 - 1, c0 / 2 + 1, c2);
+    }
+    for (int c1 = -c0 + c0 / 2 + 3; c1 <= n - c0; c1 += 1) {
+      S4(-c1, c0 + c1);
+      S6(-c1 + 2, c0 + c1 - 2);
+      for (int c2 = 1; c2 <= -c1; c2 += 1)
+        S5(-c1 + 1, c0 + c1 - 1, c2);
+    }
+    if (2 * n >= c0 + 3) {
+      S6(-n + c0 + 1, n - 1);
+      for (int c2 = 1; c2 < -n + c0; c2 += 1)
+        S5(-n + c0, n, c2);
     }
-    if (c0 % 2 == 0)
-      S3(c0 / 2);
-    for (int c1 = -n + c0; c1 < (c0 + 1) / 2; c1 += 1)
-      S2(c0 - c1, c1);
+    S6(-n + c0, n);
   }
+  if (c0 % 2 == 0)
+    S3(c0 / 2);
+  for (int c1 = -n + c0; c1 < (c0 + 1) / 2; c1 += 1)
+    S2(c0 - c1, c1);
 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/vivien2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters.st Added

@@ -0,0 +1,12 @@
+domain: "{ S2i, div36, div37, div38 : 3div37 = 2 + i and i >= 1 and i <= 10 and 3div36 >= -2 + i and 3div38 <= 1 + i and 3div38 >= -1 + i and 3div36 <= i; S4i, div36, div37, div38 : i >= 1 and i <= 10 and 3div36 <= i and 3div36 >= -2 + i and 3div37 <= 2 + i and 3div37 >= i and 3div38 <= 1 + i and 3div38 >= -1 + i; S1i, div36, div37, div38 : 3div36 = i and i >= 3 and i <= 10 and 3div37 >= i and 3div38 <= 1 + i and 3div37 <= 2 + i and 3div38 >= -1 + i; S3i, div36, div37, div38 : 3div38 = 1 + i and i <= 10 and i >= 2 and 3div36 >= -2 + i and 3div37 <= 2 + i and 3div36 <= i and 3div37 >= i }"
+child:
+  context: "{  }"
+  child:
+    schedule: "{ S1i, div36, div37, div38 -> (i); S4i, div36, div37, div38 -> (i); S3i, div36, div37, div38 -> (i); S2i, div36, div37, div38 -> (i) }, { S1i, div36, div37, div38 -> (div36); S4i, div36, div37, div38 -> (div36); S3i, div36, div37, div38 -> (div36); S2i, div36, div37, div38 -> (div36) }, { S1i, div36, div37, div38 -> (div37); S4i, div36, div37, div38 -> (div37); S3i, div36, div37, div38 -> (div37); S2i, div36, div37, div38 -> (div37) }, { S1i, div36, div37, div38 -> (div38); S4i, div36, div37, div38 -> (div38); S3i, div36, div37, div38 -> (div38); S2i, div36, div37, div38 -> (div38) }"
+    options: "{ separatei0 }"
+    child:
+      sequence:
+      - filter: "{ S1i, div36, div37, div38 }"
+      - filter: "{ S2i, div36, div37, div38 }"
+      - filter: "{ S3i, div36, div37, div38 }"
+      - filter: "{ S4i, div36, div37, div38 }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/walters3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters3.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/walters3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/wavefront.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/yosr.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/yosr.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/yosr.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/yosr2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/yosr2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/yosr2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/youcef.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/cloog/youcefn.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/youcefn.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/cloog/youcefn.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component0.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component0.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component1.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component2.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component3.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component4.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component4.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component5.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component5.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component6.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component6.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component7.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/component7.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/correlation.c Added

@@ -0,0 +1,55 @@
+for (int c0 = 0; c0 < m; c0 += 32)
+  for (int c1 = (n >= 32 && m >= c0 + 2) || (m == 1 && c0 == 0) ? 0 : 32 * n - 32 * floord(31 * n + 31, 32); c1 <= ((n <= 0 && c0 == 0) || (m == 1 && n >= 1 && c0 == 0) ? max(0, n - 1) : n); c1 += 32)
+    for (int c2 = c0; c2 <= (m >= 2 && c0 + 31 >= m && n >= c1 && c1 + 31 >= n ? 2 * m - 3 : (m >= 2 * c0 + 63 && c1 <= -32 && n >= c1 && c1 + 31 >= n) || (m >= c0 + 32 && 2 * c0 + 62 >= m && n >= c1 && c1 + 31 >= n) || (n >= 0 && c0 >= 32 && m >= 2 * c0 + 63 && c1 == n) || (m >= 63 && n >= 32 && c0 == 0 && c1 == n) ? 2 * c0 + 61 : m - 1); c2 += 32) {
+      if (m >= 2) {
+        if (n <= 0 && c0 == 0 && c1 == 0)
+          for (int c5 = 0; c5 <= min(31, m - c2 - 1); c5 += 1)
+            S_14(c2 + c5);
+        if (n >= 0 && c1 == n) {
+          for (int c3 = max(0, (c2 / 2) - c0 + 1); c3 <= min(31, m - c0 - 2); c3 += 1)
+            for (int c5 = max(0, c0 - c2 + c3); c5 <= min(31, 2 * c0 - c2 + 2 * c3 - 1); c5 += 1)
+              S_29(-c0 + c2 - c3 + c5, c0 + c3);
+        } else if (n >= c1 + 1 && c1 >= 0 && c1 + 31 >= n && c2 >= m) {
+          for (int c3 = max(0, (c2 / 2) - c0 + 1); c3 <= min(31, m - c0 - 2); c3 += 1)
+            for (int c5 = 0; c5 <= min(31, 2 * c0 - c2 + 2 * c3 - 1); c5 += 1)
+              S_29(-c0 + c2 - c3 + c5, c0 + c3);
+        } else if (c1 <= -32 && n >= c1 && c1 + 31 >= n) {
+          for (int c3 = max(0, (c2 / 2) - c0 + 1); c3 <= min(31, m - c0 - 2); c3 += 1)
+            for (int c5 = max(0, c0 - c2 + c3); c5 <= min(31, 2 * c0 - c2 + 2 * c3 - 1); c5 += 1)
+              S_29(-c0 + c2 - c3 + c5, c0 + c3);
+        } else if (n >= c1 + 1 && c1 >= 0 && m >= c2 + 1) {
+          for (int c3 = 0; c3 <= min(min(31, m - c0 - 2), -c0 + c2 + 30); c3 += 1) {
+            for (int c4 = 0; c4 <= min(31, n - c1 - 1); c4 += 1) {
+              if (c0 == 0 && c2 == 0 && c3 == 0) {
+                if (c1 == 0 && c4 == 0)
+                  S_14(0);
+                S_19(c1 + c4, 0);
+              }
+              for (int c5 = max(0, c0 - c2 + c3 + 1); c5 <= min(31, m - c2 - 1); c5 += 1) {
+                if (c0 == 0 && c1 == 0 && c3 == 0 && c4 == 0)
+                  S_14(c2 + c5);
+                if (c0 == 0 && c3 == 0)
+                  S_19(c1 + c4, c2 + c5);
+                S_27(c0 + c3, c2 + c5, c1 + c4);
+              }
+            }
+            if (c1 + 31 >= n)
+              for (int c5 = max(0, c0 - c2 + c3); c5 <= min(31, 2 * c0 - c2 + 2 * c3 - 1); c5 += 1)
+                S_29(-c0 + c2 - c3 + c5, c0 + c3);
+          }
+        }
+        if (c0 + 32 >= m && n >= c1 && c1 + 31 >= n) {
+          for (int c5 = max(0, m - c2 - 1); c5 <= min(31, 2 * m - c2 - 3); c5 += 1)
+            S_29(-m + c2 + c5 + 1, m - 1);
+        } else if (m >= c0 + 33 && n >= c1 + 1 && c1 >= 0 && c1 + 31 >= n && c2 == c0) {
+          S_29(0, c0 + 31);
+        }
+      } else if (c1 >= 32 && c2 == 0) {
+        for (int c4 = 0; c4 <= min(31, n - c1 - 1); c4 += 1)
+          S_19(c1 + c4, 0);
+      } else if (c1 == 0 && c2 == 0) {
+        S_14(0);
+        for (int c4 = 0; c4 <= min(31, n - 1); c4 += 1)
+          S_19(c4, 0);
+      }
+    }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/correlation.st Added

@@ -0,0 +1,18 @@
+domain: "m, n -> { S_14j : 0 <= j < m; S_19i, j : 0 <= i < n and 0 <= j < m; S_27i, j, k : i >= 0 and i < j < m and 0 <= k < n; S_29i, j : i >= 0 and i < j < m }"
+child:
+  context: "m, n -> {  : 0 < m <= 2147483647 and -2147483648 <= n <= 2147483647 }"
+  child:
+            schedule: "m, n -> { S_19i, j -> (0); S_29i, j -> (32*floor((j)/32)); S_27i, j, k -> (32*floor((i)/32)); S_14j -> (0) }, { S_19i, j -> (32*floor((i)/32)); S_29i, j -> (32*floor((n)/32)); S_27i, j, k -> (32*floor((k)/32)); S_14j -> (0) }, { S_19i, j -> (32*floor((j)/32)); S_29i, j -> (32*floor((i + j)/32)); S_27i, j, k -> (32*floor((j)/32)); S_14j -> (32*floor((j)/32)) }"
+            permutable: 1
+            coincident:  1, 1, 1 
+            options: "{ atomici0 : 0 <= i0 <= 2 }"
+            child:
+              schedule: "m, n -> { S_19i, j -> (0); S_29i, j -> (j - 32*floor((j)/32)); S_27i, j, k -> (i - 32*floor((i)/32)); S_14j -> (0) }, { S_19i, j -> (i - 32*floor((i)/32)); S_29i, j -> (n - 32*floor((n)/32)); S_27i, j, k -> (k - 32*floor((k)/32)); S_14j -> (0) }, { S_19i, j -> (j - 32*floor((j)/32)); S_29i, j -> (i + j - 32*floor((i + j)/32)); S_27i, j, k -> (j - 32*floor((j)/32)); S_14j -> (j - 32*floor((j)/32)) }"
+              permutable: 1
+              coincident:  1, 1, 1 
+              child:
+                sequence:
+                - filter: "m, n -> { S_29i, j }"
+                - filter: "m, n -> { S_14j }"
+                - filter: "m, n -> { S_19i, j }"
+                - filter: "m, n -> { S_27i, j, k }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/disjuncts2.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/disjuncts2.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/dwt.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/dwt.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/filter.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/filter.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/gemm.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/gemm.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/group.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/group.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/hoist2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/hoist2.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate1.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate2.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate3.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate4.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate4.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate5.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate5.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate6.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate6.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate7.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/isolate7.st Added

@@ -0,0 +1,16 @@
+# Check that no expressions of the form ((-n + 2147483648) % 32) are produced.
+domain: "n -> { S_2i : i >= 0 and i <= -1 + n; S_1i, j : j >= 0 and j <= -1 + n and i >= 0 and i <= -1 + n }"
+child:
+  context: "n -> {  : n <= 2147483647 and n >= 0 }"
+  child:
+    schedule: "n -> { S_1i, j -> (32*floor((i)/32)); S_2i -> (32*floor((i)/32)) }, { S_1i, j -> (32*floor((j)/32)); S_2i -> (32*floor((n)/32)) }"
+    permutable: 1
+    options: "n -> { atomici0 : i0 >= 0 and i0 <= 1; isolate -> i0, i1 : (exists (e0 = floor((i0)/32), e1 = floor((i1)/32): 32e0 = i0 and 32e1 = i1 and i0 >= 0 and i0 <= -32 + n and i1 >= 0 and i1 <= n)) or (exists (e0 = floor((i0)/32), e1 = floor((i1)/32): 32e0 = i0 and 32e1 = i1 and i0 >= 0 and i0 <= -32 + n and i1 >= -31 + n and i1 <= -31 + 2n)) }"
+    child:
+          schedule: "n -> { S_1i, j -> (i - 32*floor((i)/32)); S_2i -> (i - 32*floor((i)/32)) }, { S_1i, j -> (j - 32*floor((j)/32)); S_2i -> (n - 32*floor((n)/32)) }"
+          permutable: 1
+          options: "{ separatei0 : i0 >= 0 and i0 <= 1 }"
+          child:
+            sequence:
+            - filter: "n -> { S_1i, j }"
+            - filter: "n -> { S_2i }"

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/jacobi_kernel4.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/jacobi_kernel4.in Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/lu.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/lu.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/basics-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/basics-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/chosol-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/chosol-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/chosol-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/chosol-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/code_gen-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/code_gen-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/code_gen-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/code_gen-2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/collard-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/collard-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/dagstuhl1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/dagstuhl1-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/fc1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/fc1-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/fc1-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/fc1-2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/fc2-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/fc2-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/guard1-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/guard1-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/guard1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/guard1-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/if_then-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/if_then-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/if_then-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/if_then-2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/if_then-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/if_then-3.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/iter9-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/iter9-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lefur00-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lefur00-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lefur01-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lefur01-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lefur01-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lefur01-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lefur03-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lefur03-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lefur04-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lefur04-0.c Changed

@@ -1,7 +1,7 @@
 for (int c0 = 0; c0 <= 3; c0 += 1)
-  for (int c1 = max(2 * c0 - 3, c0 / 2); c1 <= min(3, c0 + 1); c1 += 1)
+  for (int c1 = max(0, 2 * c0 - 3); c1 <= min(c0 + 1, -c0 + 6); c1 += 1)
     for (int c2 = c0; c2 <= min(min(3, 2 * c0 - c1 + 1), 3 * c1 + 2); c2 += 1)
-      for (int c3 = max(max(max(c1 - (-c1 + 3) / 3, c0 - (-c2 + 3) / 3), c2 - (c2 + 2) / 3), c2 + floord(3 * c1 - c2 - 1, 6)); c3 <= min(3, c0 + c2 / 3 + 1); c3 += 1)
+      for (int c3 = max(max(max(0, c1 - (-c1 + 3) / 3), c0 - (-c2 + 3) / 3), c2 + floord(3 * c1 - c2 - 1, 6)); c3 <= min(3, c0 + 1); c3 += 1)
         for (int c5 = max(max(max(max(0, 2 * c3 - 4), c1 - (-c1 + 3) / 3), c2 - (c2 + 3) / 3), c3 - (c3 + 3) / 3); c5 <= min(min(c1 + 1, c3), -c2 + 2 * c3 - (c2 + 3) / 3 + 2); c5 += 1)
           for (int c6 = max(max(max(max(max(-200 * c1 + 400 * c3 - 199, 250 * c3 + 1), 1000 * c0 - 500 * c5 - 501), 667 * c0 - 333 * c1 - (c0 + c1 + 3) / 3 - 332), 333 * c1 + c1 / 3), 333 * c2 + (c2 + 1) / 3); c6 <= min(min(min(min(min(min(1000, 500 * c0 + 499), -200 * c1 + 400 * c3 + 400), 500 * c5 + 501), 1000 * c0 - 500 * c5 + 997), 333 * c2 - (-c2 + 3) / 3 + 333), 333 * c3 - (-c3 + 3) / 3 + 334); c6 += 1)
             for (int c7 = max(max(max(max(500 * c5 + 2, c6), 1000 * c0 - c6), 1000 * c3 - 2 * c6 + 2), 500 * c1 + (c6 + 1) / 2); c7 <= min(min(min(min(500 * c5 + 501, 2 * c6 + 1), 1000 * c0 - c6 + 999), 1000 * c3 - 2 * c6 + 1001), 500 * c1 + (c6 + 1) / 2 + 499); c7 += 1)

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift1-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift1-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift1-2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift1-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift1-3.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift1-4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift1-4.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift1-5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift1-5.c Changed

@@ -1,16 +1,14 @@
-{
-  for (int c0 = 1; c0 <= 60; c0 += 1)
-    for (int c1 = 1; c1 <= 100; c1 += 1)
-      for (int c2 = 1; c2 <= 100; c2 += 1)
-        for (int c3 = 1; c3 <= 100; c3 += 1)
-          for (int c4 = 1; c4 <= 100; c4 += 1) {
-            s1(c0, c1, c2, c3, c4);
-            s0(c0, c1, c2, c3, c4);
-          }
-  for (int c0 = 61; c0 <= 100; c0 += 1)
-    for (int c1 = 1; c1 <= 100; c1 += 1)
-      for (int c2 = 1; c2 <= 100; c2 += 1)
-        for (int c3 = 1; c3 <= 100; c3 += 1)
-          for (int c4 = 1; c4 <= 100; c4 += 1)
-            s1(c0, c1, c2, c3, c4);
-}
+for (int c0 = 1; c0 <= 60; c0 += 1)
+  for (int c1 = 1; c1 <= 100; c1 += 1)
+    for (int c2 = 1; c2 <= 100; c2 += 1)
+      for (int c3 = 1; c3 <= 100; c3 += 1)
+        for (int c4 = 1; c4 <= 100; c4 += 1) {
+          s1(c0, c1, c2, c3, c4);
+          s0(c0, c1, c2, c3, c4);
+        }
+for (int c0 = 61; c0 <= 100; c0 += 1)
+  for (int c1 = 1; c1 <= 100; c1 += 1)
+    for (int c2 = 1; c2 <= 100; c2 += 1)
+      for (int c3 = 1; c3 <= 100; c3 += 1)
+        for (int c4 = 1; c4 <= 100; c4 += 1)
+          s1(c0, c1, c2, c3, c4);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift2-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift2-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift2-2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift2-2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift2-3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift2-3.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift2-4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift2-4.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lift2-5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lift2-5.c Changed

@@ -1,22 +1,20 @@
-{
-  for (int c0 = 1; c0 <= 4; c0 += 1)
-    for (int c1 = 1; c1 <= 100; c1 += 1)
-      for (int c2 = 1; c2 <= 100; c2 += 1)
-        for (int c3 = 1; c3 <= 100; c3 += 1)
-          for (int c4 = 1; c4 <= 100; c4 += 1)
-            s1(c0, c1, c2, c3, c4);
-  for (int c0 = 5; c0 <= 60; c0 += 1)
-    for (int c1 = 1; c1 <= 100; c1 += 1)
-      for (int c2 = 1; c2 <= 100; c2 += 1)
-        for (int c3 = 1; c3 <= 100; c3 += 1)
-          for (int c4 = 1; c4 <= 100; c4 += 1) {
-            s1(c0, c1, c2, c3, c4);
-            s0(c0, c1, c2, c3, c4);
-          }
-  for (int c0 = 61; c0 <= 100; c0 += 1)
-    for (int c1 = 1; c1 <= 100; c1 += 1)
-      for (int c2 = 1; c2 <= 100; c2 += 1)
-        for (int c3 = 1; c3 <= 100; c3 += 1)
-          for (int c4 = 1; c4 <= 100; c4 += 1)
-            s1(c0, c1, c2, c3, c4);
-}
+for (int c0 = 1; c0 <= 4; c0 += 1)
+  for (int c1 = 1; c1 <= 100; c1 += 1)
+    for (int c2 = 1; c2 <= 100; c2 += 1)
+      for (int c3 = 1; c3 <= 100; c3 += 1)
+        for (int c4 = 1; c4 <= 100; c4 += 1)
+          s1(c0, c1, c2, c3, c4);
+for (int c0 = 5; c0 <= 60; c0 += 1)
+  for (int c1 = 1; c1 <= 100; c1 += 1)
+    for (int c2 = 1; c2 <= 100; c2 += 1)
+      for (int c3 = 1; c3 <= 100; c3 += 1)
+        for (int c4 = 1; c4 <= 100; c4 += 1) {
+          s1(c0, c1, c2, c3, c4);
+          s0(c0, c1, c2, c3, c4);
+        }
+for (int c0 = 61; c0 <= 100; c0 += 1)
+  for (int c1 = 1; c1 <= 100; c1 += 1)
+    for (int c2 = 1; c2 <= 100; c2 += 1)
+      for (int c3 = 1; c3 <= 100; c3 += 1)
+        for (int c4 = 1; c4 <= 100; c4 += 1)
+          s1(c0, c1, c2, c3, c4);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lu_spmd-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lu_spmd-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/lu_spmd-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/lu_spmd-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m1-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m10-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m10-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m11-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m11-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m12-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m12-1.c Changed

@@ -1,25 +1,23 @@
-{
-  for (int c1 = 1; c1 <= n; c1 += 1)
-    for (int c2 = 1; c2 <= m; c2 += 1) {
-      s0(1, c1, c2, 0);
-      s1(1, c1, c2, 0);
-    }
-  for (int c1 = 1; c1 <= n; c1 += 1) {
-    s3(2, c1, 0, 0);
-    s2(2, c1, 0, 0);
+for (int c1 = 1; c1 <= n; c1 += 1)
+  for (int c2 = 1; c2 <= m; c2 += 1) {
+    s0(1, c1, c2, 0);
+    s1(1, c1, c2, 0);
   }
-  for (int c1 = 1; c1 <= m; c1 += 1) {
-    for (int c3 = 1; c3 <= n; c3 += 1) {
-      s5(3, c1, 1, c3);
-      s4(3, c1, 1, c3);
-    }
-    for (int c3 = 1; c3 <= n; c3 += 1) {
-      s7(3, c1, 2, c3);
-      s6(3, c1, 2, c3);
-    }
+for (int c1 = 1; c1 <= n; c1 += 1) {
+  s2(2, c1, 0, 0);
+  s3(2, c1, 0, 0);
+}
+for (int c1 = 1; c1 <= m; c1 += 1) {
+  for (int c3 = 1; c3 <= n; c3 += 1) {
+    s4(3, c1, 1, c3);
+    s5(3, c1, 1, c3);
   }
-  for (int c1 = 1; c1 <= m; c1 += 1) {
-    s8(4, c1, 0, 0);
-    s9(4, c1, 0, 0);
+  for (int c3 = 1; c3 <= n; c3 += 1) {
+    s6(3, c1, 2, c3);
+    s7(3, c1, 2, c3);
   }
 }
+for (int c1 = 1; c1 <= m; c1 += 1) {
+  s8(4, c1, 0, 0);
+  s9(4, c1, 0, 0);
+}

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m2-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m2-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m2-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m2-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m7-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m7-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/m8-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/m8-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/p.delft2-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/p.delft2-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/p6-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/p6-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/stride6-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/stride6-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/stride7-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/stride7-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/stride7-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/stride7-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/substitution-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/substitution-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/ts1d-check-sblock-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/ts1d-check-sblock-0.c Changed

@@ -1,14 +1,13 @@
-{
-  for (int c1 = 0; c1 <= 1; c1 += 1) {
-    if (c1 == 1) {
-      s0(1, 1, 1, 0, 0);
-      s0(1, 1, 1, N - 1, 0);
-    } else
-      for (int c3 = 0; c3 < N; c3 += 1)
-        s0(1, 0, 1, c3, 0);
+for (int c1 = 0; c1 <= 1; c1 += 1) {
+  if (c1 == 1) {
+    s0(1, 1, 1, 0, 0);
+    s0(1, 1, 1, N - 1, 0);
+  } else {
+    for (int c3 = 0; c3 < N; c3 += 1)
+      s0(1, 0, 1, c3, 0);
   }
-  for (int c1 = 0; c1 <= floord(T - 1, 1000); c1 += 1)
-    for (int c2 = 1000 * c1 + 1; c2 <= min(N + T - 3, N + 1000 * c1 + 997); c2 += 1)
-      for (int c3 = max(0, -N - 1000 * c1 + c2 + 2); c3 <= min(min(999, T - 1000 * c1 - 1), -1000 * c1 + c2 - 1); c3 += 1)
-        s1(2, 1000 * c1 + c3, 1, -1000 * c1 + c2 - c3, 1);
 }
+for (int c1 = 0; c1 <= floord(T - 1, 1000); c1 += 1)
+  for (int c2 = 1000 * c1 + 1; c2 <= min(N + T - 3, N + 1000 * c1 + 997); c2 += 1)
+    for (int c3 = max(0, -N - 1000 * c1 + c2 + 2); c3 <= min(min(999, T - 1000 * c1 - 1), -1000 * c1 + c2 - 1); c3 += 1)
+      s1(2, 1000 * c1 + c3, 1, -1000 * c1 + c2 - c3, 1);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/ts1d-check0-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/ts1d-check0-0.c Changed

@@ -1,13 +1,11 @@
-{
-  for (int c1 = 0; c1 < N; c1 += 1)
-    s0(1, c1, 1, 0, 0);
-  for (int c1 = 0; c1 <= floord(T - 1, 500); c1 += 1)
-    for (int c2 = 1000 * c1; c2 <= min(N + 2 * T - 3, N + 1000 * c1 + 997); c2 += 1) {
-      for (int c3 = max(0, -((N + c2) % 2) - N - 1000 * c1 + c2 + 2); c3 <= min(min(998, 2 * T - 1000 * c1 - 2), -1000 * c1 + c2 - 2); c3 += 2) {
-        s1(2, 1000 * c1 + c3, 0, -1000 * c1 + c2 - c3, 1);
-        s2(2, 1000 * c1 + c3 + 1, 0, -1000 * c1 + c2 - c3 - 1, 1);
-      }
-      if (2 * T >= c2 + 1 && 1000 * c1 + 999 >= c2)
-        s1(2, -(c2 % 2) + c2, 0, c2 % 2, 1);
+for (int c1 = 0; c1 < N; c1 += 1)
+  s0(1, c1, 1, 0, 0);
+for (int c1 = 0; c1 <= floord(T - 1, 500); c1 += 1)
+  for (int c2 = 1000 * c1; c2 <= min(N + 2 * T - 3, N + 1000 * c1 + 997); c2 += 1) {
+    for (int c3 = max(0, -((N + c2) % 2) - N - 1000 * c1 + c2 + 2); c3 <= min(min(998, 2 * T - 1000 * c1 - 2), -1000 * c1 + c2 - 2); c3 += 2) {
+      s1(2, 1000 * c1 + c3, 0, -1000 * c1 + c2 - c3, 1);
+      s2(2, 1000 * c1 + c3 + 1, 0, -1000 * c1 + c2 - c3 - 1, 1);
     }
-}
+    if (2 * T >= c2 + 1 && 1000 * c1 + 999 >= c2)
+      s1(2, ((c2 + 1) % 2) + c2 - 1, 0, -((c2 + 1) % 2) + 1, 1);
+  }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/ts1d-mp-i_ts-m_b-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/ts1d-mp-i_ts-m_b-0.c Changed

@@ -1,35 +1,34 @@
-{
-  for (int c1 = -1; c1 < T; c1 += 1)
-    for (int c2 = 0; c2 < N; c2 += 1) {
-      if (c1 == -1) {
-        s0(1, -1, c2, 0, 0);
-      } else if (c2 == 0) {
-        s0(1, c1, 0, 0, 0);
-      } else if (c2 + 1 == N)
-        s0(1, c1, N - 1, 0, 0);
+for (int c1 = -1; c1 < T; c1 += 1)
+  for (int c2 = 0; c2 < N; c2 += 1) {
+    if (c1 == -1) {
+      s0(1, -1, c2, 0, 0);
+    } else if (c2 == 0) {
+      s0(1, c1, 0, 0, 0);
+    } else if (c2 + 1 == N) {
+      s0(1, c1, N - 1, 0, 0);
     }
-  for (int c1 = 0; c1 <= floord(T - 1, 500); c1 += 1) {
-    for (int c3 = -((c1 + 9) / 8) + 2; c3 <= floord(N - 500 * c1 - 3, 4000) + 1; c3 += 1)
-      for (int c4 = max(500 * c1 + 1, 1000 * c1 + 4000 * c3 - 3999); c4 <= min(min(N + T - 3, 1000 * c1 + 4000 * c3 - 3000), 2 * N - 4000 * c3 + 3995); c4 += 1)
-        for (int c5 = max(0, -N - 500 * c1 + c4 + 2); c5 <= min(min(T - 500 * c1 - 1, -500 * c1 + c4 - 1), -500 * c1 - 2000 * c3 + (c4 + 1) / 2 + 1999); c5 += 1)
-          s1(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
-    for (int c3 = max(-((T + 4000) / 4000) + 2, -((c1 + 9) / 8) + 2); c3 <= floord(N - 500 * c1 - 3, 4000) + 1; c3 += 1)
-      for (int c4 = max(1000 * c1 + 4000 * c3 - 3999, -4000 * c3 + 4000); c4 <= min(min(2 * T + 4000 * c3 - 4000, 1000 * c1 + 4000 * c3 - 3000), 2 * N - 4000 * c3 + 3995); c4 += 1)
-        s2(2, -2000 * c3 + (c4 + 1) / 2 + 1999, 1, 2000 * c3 + c4 - (c4 + 1) / 2 - 1999, 1);
-    for (int c3 = -((c1 + 7) / 8) + 1; c3 <= min(floord(N + T - 1000 * c1 - 1004, 4000) + 1, floord(N - 500 * c1 - 504, 4000) + 1); c3 += 1)
-      for (int c4 = max(500 * c1 + 1, 1000 * c1 + 4000 * c3 - 2999); c4 <= min(min(N + T - 3, N + 500 * c1 + 497), 1000 * c1 + 4000 * c3); c4 += 1)
-        for (int c5 = max(0, -N - 500 * c1 + c4 + 2); c5 <= min(min(499, T - 500 * c1 - 1), -500 * c1 + c4 - 1); c5 += 1)
-          s3(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
-    for (int c3 = max(-((T + 4000) / 4000) + 1, -((c1 + 9) / 8) + 1); c3 <= floord(N - 500 * c1 - 3, 4000); c3 += 1)
-      for (int c4 = max(-4000 * c3, 1000 * c1 + 4000 * c3 + 1); c4 <= min(min(2 * N - 4000 * c3 - 5, 2 * T + 4000 * c3), 1000 * c1 + 4000 * c3 + 1000); c4 += 1)
-        s4(2, -2000 * c3 + (c4 + 1) / 2 - 1, 1, 2000 * c3 + c4 - (c4 + 1) / 2 + 1, 1);
-    for (int c3 = -((c1 + 8) / 8) + 1; c3 <= min(floord(N + T - 1000 * c1 - 4, 4000), floord(N - 500 * c1 + 496, 4000)); c3 += 1)
-      for (int c4 = max(1000 * c1 + 4000 * c3 + 1, -4000 * c3 + 2); c4 <= min(min(min(N + T - 3, N + 500 * c1 + 497), 2 * T + 4000 * c3 - 2), 1000 * c1 + 4000 * c3 + 998); c4 += 1)
-        for (int c5 = max(-N - 500 * c1 + c4 + 2, -500 * c1 - 2000 * c3 + (c4 + 1) / 2); c5 <= min(min(499, T - 500 * c1 - 1), -500 * c1 + c4 - 1); c5 += 1)
-          s5(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
   }
-  if (T >= 1)
-    for (int c3 = -((T + 3998) / 4000) + 1; c3 <= floord(N - T - 2, 4000) + 1; c3 += 1)
-      for (int c4 = max(T, 2 * T + 4000 * c3 - 4001); c4 < min(N + T - 2, 2 * T + 4000 * c3 - 1); c4 += 1)
-        s6(2, T - 1, 1, -T + c4 + 1, 1);
+for (int c1 = 0; c1 <= floord(T - 1, 500); c1 += 1) {
+  for (int c3 = -((c1 + 9) / 8) + 2; c3 <= floord(N - 500 * c1 - 3, 4000) + 1; c3 += 1)
+    for (int c4 = max(500 * c1 + 1, 1000 * c1 + 4000 * c3 - 3999); c4 <= min(min(N + T - 3, 1000 * c1 + 4000 * c3 - 3000), 2 * N - 4000 * c3 + 3995); c4 += 1)
+      for (int c5 = max(0, -N - 500 * c1 + c4 + 2); c5 <= min(min(T - 500 * c1 - 1, -500 * c1 + c4 - 1), -500 * c1 - 2000 * c3 + (c4 + 1) / 2 + 1999); c5 += 1)
+        s1(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
+  for (int c3 = max(-((T + 4000) / 4000) + 2, -((c1 + 9) / 8) + 2); c3 <= floord(N - 500 * c1 - 3, 4000) + 1; c3 += 1)
+    for (int c4 = max(1000 * c1 + 4000 * c3 - 3999, -4000 * c3 + 4000); c4 <= min(min(2 * T + 4000 * c3 - 4000, 1000 * c1 + 4000 * c3 - 3000), 2 * N - 4000 * c3 + 3995); c4 += 1)
+      s2(2, -2000 * c3 + (c4 + 1) / 2 + 1999, 1, 2000 * c3 + c4 - (c4 + 1) / 2 - 1999, 1);
+  for (int c3 = -((c1 + 7) / 8) + 1; c3 <= min(floord(N + T - 1000 * c1 - 1004, 4000) + 1, floord(N - 500 * c1 - 504, 4000) + 1); c3 += 1)
+    for (int c4 = max(500 * c1 + 1, 1000 * c1 + 4000 * c3 - 2999); c4 <= min(min(N + T - 3, N + 500 * c1 + 497), 1000 * c1 + 4000 * c3); c4 += 1)
+      for (int c5 = max(0, -N - 500 * c1 + c4 + 2); c5 <= min(min(499, T - 500 * c1 - 1), -500 * c1 + c4 - 1); c5 += 1)
+        s3(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
+  for (int c3 = max(-((T + 4000) / 4000) + 1, -((c1 + 9) / 8) + 1); c3 <= floord(N - 500 * c1 - 3, 4000); c3 += 1)
+    for (int c4 = max(-4000 * c3, 1000 * c1 + 4000 * c3 + 1); c4 <= min(min(2 * N - 4000 * c3 - 5, 2 * T + 4000 * c3), 1000 * c1 + 4000 * c3 + 1000); c4 += 1)
+      s4(2, -2000 * c3 + (c4 + 1) / 2 - 1, 1, 2000 * c3 + c4 - (c4 + 1) / 2 + 1, 1);
+  for (int c3 = -((c1 + 8) / 8) + 1; c3 <= min(floord(N + T - 1000 * c1 - 4, 4000), floord(N - 500 * c1 + 496, 4000)); c3 += 1)
+    for (int c4 = max(1000 * c1 + 4000 * c3 + 1, -4000 * c3 + 2); c4 <= min(min(min(N + T - 3, N + 500 * c1 + 497), 2 * T + 4000 * c3 - 2), 1000 * c1 + 4000 * c3 + 998); c4 += 1)
+      for (int c5 = max(-N - 500 * c1 + c4 + 2, -500 * c1 - 2000 * c3 + (c4 + 1) / 2); c5 <= min(min(499, T - 500 * c1 - 1), -500 * c1 + c4 - 1); c5 += 1)
+        s5(2, 500 * c1 + c5, 1, -500 * c1 + c4 - c5, 1);
 }
+if (T >= 1)
+  for (int c3 = -((T + 3998) / 4000) + 1; c3 <= floord(N - T - 2, 4000) + 1; c3 += 1)
+    for (int c4 = max(T, 2 * T + 4000 * c3 - 4001); c4 < min(N + T - 2, 2 * T + 4000 * c3 - 1); c4 += 1)
+      s6(2, T - 1, 1, -T + c4 + 1, 1);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/ts1d-orig0-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/ts1d-orig0-0.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/wak1-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/wak1-0.c Changed

@@ -1,27 +1,25 @@
-{
-  for (int c0 = a2; c0 <= min(min(a1 - 1, a3 - 1), b2); c0 += 1)
-    s1(c0);
-  for (int c0 = a1; c0 <= min(b1, a3 - 1); c0 += 1) {
+for (int c0 = a1; c0 <= min(min(b1, a3 - 1), a2 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = a2; c0 <= min(a3 - 1, b2); c0 += 1) {
+  if (c0 >= a1 && b1 >= c0)
     s0(c0);
-    if (c0 >= a2 && b2 >= c0)
-      s1(c0);
-  }
-  for (int c0 = max(max(a1, b1 + 1), a2); c0 <= min(a3 - 1, b2); c0 += 1)
-    s1(c0);
-  for (int c0 = a3; c0 <= b3; c0 += 1) {
-    if (c0 >= a1 && b1 >= c0)
-      s0(c0);
-    if (c0 >= a2 && b2 >= c0)
-      s1(c0);
-    s2(c0);
-  }
-  for (int c0 = max(max(a3, b3 + 1), a2); c0 <= min(a1 - 1, b2); c0 += 1)
-    s1(c0);
-  for (int c0 = max(max(a1, a3), b3 + 1); c0 <= b1; c0 += 1) {
+  s1(c0);
+}
+for (int c0 = max(max(a1, a2), b2 + 1); c0 <= min(b1, a3 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = a3; c0 <= b3; c0 += 1) {
+  if (c0 >= a1 && b1 >= c0)
     s0(c0);
-    if (c0 >= a2 && b2 >= c0)
-      s1(c0);
-  }
-  for (int c0 = max(max(max(max(a1, b1 + 1), a3), b3 + 1), a2); c0 <= b2; c0 += 1)
+  if (c0 >= a2 && b2 >= c0)
     s1(c0);
+  s2(c0);
+}
+for (int c0 = max(max(a1, a3), b3 + 1); c0 <= min(b1, a2 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = max(max(a3, b3 + 1), a2); c0 <= b2; c0 += 1) {
+  if (c0 >= a1 && b1 >= c0)
+    s0(c0);
+  s1(c0);
 }
+for (int c0 = max(max(max(max(a1, a3), b3 + 1), a2), b2 + 1); c0 <= b1; c0 += 1)
+  s0(c0);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/wak1-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/wak1-1.c Changed

@@ -1,55 +1,53 @@
-{
-  for (int c0 = a2; c0 <= min(min(a1 - 1, a3 - 1), b2); c0 += 1)
-    s1(c0);
-  for (int c0 = a3; c0 <= min(min(a1 - 1, b3), a2 - 1); c0 += 1)
-    s2(c0);
-  for (int c0 = max(a3, a2); c0 <= min(min(a1 - 1, b3), b2); c0 += 1) {
-    s1(c0);
-    s2(c0);
-  }
-  for (int c0 = a1; c0 <= min(min(b1, a3 - 1), a2 - 1); c0 += 1)
-    s0(c0);
-  for (int c0 = max(a1, a2); c0 <= min(min(b1, a3 - 1), b2); c0 += 1) {
-    s0(c0);
-    s1(c0);
-  }
-  for (int c0 = max(max(a1, b1 + 1), a2); c0 <= min(a3 - 1, b2); c0 += 1)
-    s1(c0);
-  for (int c0 = max(a1, a3); c0 <= min(min(b1, b3), a2 - 1); c0 += 1) {
-    s0(c0);
-    s2(c0);
-  }
-  for (int c0 = max(max(a1, b1 + 1), a3); c0 <= min(b3, a2 - 1); c0 += 1)
-    s2(c0);
-  for (int c0 = max(max(a1, a3), a2); c0 <= min(min(b1, b3), b2); c0 += 1) {
-    s0(c0);
-    s1(c0);
-    s2(c0);
-  }
-  for (int c0 = max(max(max(a1, b1 + 1), a3), a2); c0 <= min(b3, b2); c0 += 1) {
-    s1(c0);
-    s2(c0);
-  }
-  for (int c0 = max(max(a3, a2), b2 + 1); c0 <= min(a1 - 1, b3); c0 += 1)
-    s2(c0);
-  for (int c0 = max(max(a1, a2), b2 + 1); c0 <= min(b1, a3 - 1); c0 += 1)
-    s0(c0);
-  for (int c0 = max(max(max(a1, a3), a2), b2 + 1); c0 <= min(b1, b3); c0 += 1) {
-    s0(c0);
-    s2(c0);
-  }
-  for (int c0 = max(max(max(max(a1, b1 + 1), a3), a2), b2 + 1); c0 <= b3; c0 += 1)
-    s2(c0);
-  for (int c0 = max(max(a3, b3 + 1), a2); c0 <= min(a1 - 1, b2); c0 += 1)
-    s1(c0);
-  for (int c0 = max(max(a1, a3), b3 + 1); c0 <= min(b1, a2 - 1); c0 += 1)
-    s0(c0);
-  for (int c0 = max(max(max(a1, a3), b3 + 1), a2); c0 <= min(b1, b2); c0 += 1) {
-    s0(c0);
-    s1(c0);
-  }
-  for (int c0 = max(max(max(max(a1, b1 + 1), a3), b3 + 1), a2); c0 <= b2; c0 += 1)
-    s1(c0);
-  for (int c0 = max(max(max(max(a1, a3), b3 + 1), a2), b2 + 1); c0 <= b1; c0 += 1)
-    s0(c0);
+for (int c0 = a2; c0 <= min(min(a1 - 1, a3 - 1), b2); c0 += 1)
+  s1(c0);
+for (int c0 = a3; c0 <= min(min(a1 - 1, b3), a2 - 1); c0 += 1)
+  s2(c0);
+for (int c0 = max(a3, a2); c0 <= min(min(a1 - 1, b3), b2); c0 += 1) {
+  s1(c0);
+  s2(c0);
 }
+for (int c0 = max(max(a3, b3 + 1), a2); c0 <= min(a1 - 1, b2); c0 += 1)
+  s1(c0);
+for (int c0 = a1; c0 <= min(min(b1, a3 - 1), a2 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = max(a1, a2); c0 <= min(min(b1, a3 - 1), b2); c0 += 1) {
+  s0(c0);
+  s1(c0);
+}
+for (int c0 = max(a1, a3); c0 <= min(min(b1, b3), a2 - 1); c0 += 1) {
+  s0(c0);
+  s2(c0);
+}
+for (int c0 = max(max(a1, a3), b3 + 1); c0 <= min(b1, a2 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = max(max(a1, a3), a2); c0 <= min(min(b1, b3), b2); c0 += 1) {
+  s0(c0);
+  s1(c0);
+  s2(c0);
+}
+for (int c0 = max(max(max(a1, a3), b3 + 1), a2); c0 <= min(b1, b2); c0 += 1) {
+  s0(c0);
+  s1(c0);
+}
+for (int c0 = max(max(a1, a2), b2 + 1); c0 <= min(b1, a3 - 1); c0 += 1)
+  s0(c0);
+for (int c0 = max(max(a3, a2), b2 + 1); c0 <= min(a1 - 1, b3); c0 += 1)
+  s2(c0);
+for (int c0 = max(max(max(a1, a3), a2), b2 + 1); c0 <= min(b1, b3); c0 += 1) {
+  s0(c0);
+  s2(c0);
+}
+for (int c0 = max(max(max(max(a1, a3), b3 + 1), a2), b2 + 1); c0 <= b1; c0 += 1)
+  s0(c0);
+for (int c0 = max(max(a1, b1 + 1), a2); c0 <= min(a3 - 1, b2); c0 += 1)
+  s1(c0);
+for (int c0 = max(max(a1, b1 + 1), a3); c0 <= min(b3, a2 - 1); c0 += 1)
+  s2(c0);
+for (int c0 = max(max(max(a1, b1 + 1), a3), a2); c0 <= min(b3, b2); c0 += 1) {
+  s1(c0);
+  s2(c0);
+}
+for (int c0 = max(max(max(max(a1, b1 + 1), a3), b3 + 1), a2); c0 <= b2; c0 += 1)
+  s1(c0);
+for (int c0 = max(max(max(max(a1, b1 + 1), a3), a2), b2 + 1); c0 <= b3; c0 += 1)
+  s2(c0);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/wak2-0.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/wak2-0.c Changed

@@ -1,25 +1,24 @@
-{
+if (c2 >= d2 + 1) {
+  for (int c0 = a1; c0 <= b1; c0 += 1)
+    for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
+      s0(c0, c1_0);
+} else {
   for (int c0 = a1; c0 <= min(b1, a2 - 1); c0 += 1)
     for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
       s0(c0, c1_0);
-  if (c2 >= d2 + 1) {
-    for (int c0 = max(a1, a2); c0 <= min(b1, b2); c0 += 1)
-      for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
+  for (int c0 = a2; c0 <= b2; c0 += 1) {
+    if (c0 >= a1 && b1 >= c0)
+      for (int c1_0 = c1; c1_0 <= min(d1, c2 - 1); c1_0 += 1)
         s0(c0, c1_0);
-  } else
-    for (int c0 = a2; c0 <= b2; c0 += 1) {
-      if (c0 >= a1 && b1 >= c0)
-        for (int c1_0 = c1; c1_0 <= min(d1, c2 - 1); c1_0 += 1)
-          s0(c0, c1_0);
-      for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1) {
-        if (c0 >= a1 && b1 >= c0 && c1_0 >= c1 && d1 >= c1_0)
-          s0(c0, c1_0);
-        s1(c0, c1_0);
-      }
-      if (c0 >= a1 && b1 >= c0)
-        for (int c1_0 = max(c1, d2 + 1); c1_0 <= d1; c1_0 += 1)
-          s0(c0, c1_0);
+    for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1) {
+      if (c0 >= a1 && b1 >= c0 && c1_0 >= c1 && d1 >= c1_0)
+        s0(c0, c1_0);
+      s1(c0, c1_0);
     }
+    if (c0 >= a1 && b1 >= c0)
+      for (int c1_0 = max(c1, d2 + 1); c1_0 <= d1; c1_0 += 1)
+        s0(c0, c1_0);
+  }
   for (int c0 = max(max(a1, a2), b2 + 1); c0 <= b1; c0 += 1)
     for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
       s0(c0, c1_0);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/wak2-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/wak2-1.c Changed

@@ -1,34 +1,33 @@
-{
+if (c2 >= d2 + 1) {
+  for (int c0 = a1; c0 <= b1; c0 += 1)
+    for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
+      s0(c0, c1_0);
+} else {
   for (int c0 = a1; c0 <= min(b1, a2 - 1); c0 += 1)
     for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
       s0(c0, c1_0);
-  if (c2 >= d2 + 1) {
-    for (int c0 = max(a1, a2); c0 <= min(b1, b2); c0 += 1)
-      for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
+  for (int c0 = a2; c0 <= b2; c0 += 1) {
+    if (a1 >= c0 + 1) {
+      for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1)
+        s1(c0, c1_0);
+    } else if (c0 >= b1 + 1) {
+      for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1)
+        s1(c0, c1_0);
+    } else {
+      for (int c1_0 = c2; c1_0 <= min(c1 - 1, d2); c1_0 += 1)
+        s1(c0, c1_0);
+      for (int c1_0 = c1; c1_0 <= min(d1, c2 - 1); c1_0 += 1)
         s0(c0, c1_0);
-  } else
-    for (int c0 = a2; c0 <= b2; c0 += 1) {
-      if (a1 >= c0 + 1) {
-        for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1)
-          s1(c0, c1_0);
-      } else if (c0 >= b1 + 1) {
-        for (int c1_0 = c2; c1_0 <= d2; c1_0 += 1)
-          s1(c0, c1_0);
-      } else {
-        for (int c1_0 = c1; c1_0 <= min(d1, c2 - 1); c1_0 += 1)
-          s0(c0, c1_0);
-        for (int c1_0 = c2; c1_0 <= min(c1 - 1, d2); c1_0 += 1)
-          s1(c0, c1_0);
-        for (int c1_0 = max(c1, c2); c1_0 <= min(d1, d2); c1_0 += 1) {
-          s0(c0, c1_0);
-          s1(c0, c1_0);
-        }
-        for (int c1_0 = max(c1, d2 + 1); c1_0 <= d1; c1_0 += 1)
-          s0(c0, c1_0);
-        for (int c1_0 = max(max(c1, d1 + 1), c2); c1_0 <= d2; c1_0 += 1)
-          s1(c0, c1_0);
+      for (int c1_0 = max(c1, c2); c1_0 <= min(d1, d2); c1_0 += 1) {
+        s0(c0, c1_0);
+        s1(c0, c1_0);
       }
+      for (int c1_0 = max(max(c1, d1 + 1), c2); c1_0 <= d2; c1_0 += 1)
+        s1(c0, c1_0);
+      for (int c1_0 = max(c1, d2 + 1); c1_0 <= d1; c1_0 += 1)
+        s0(c0, c1_0);
     }
+  }
   for (int c0 = max(max(a1, a2), b2 + 1); c0 <= b1; c0 += 1)
     for (int c1_0 = c1; c1_0 <= d1; c1_0 += 1)
       s0(c0, c1_0);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/omega/wak3-1.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/omega/wak3-1.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/pldi2012/figure7_c.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/pldi2012/figure7_c.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/pldi2012/figure7_d.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/pldi2012/figure7_d.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/pldi2012/figure8_b.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/pldi2012/figure8_b.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/pldi2012/figure8_b.in -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/pldi2012/figure8_b.in Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/redundant.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/redundant.st Added

@@ -0,0 +1,6 @@
+# Check that b1 >= 1 is not dropped by mistake in 4 * c0 + c1 >= 1 part
+domain: "b0 -> { writei0, o1, o2, o3 : ((exists (e0 = floor((4 + o2)/8), e1 = floor((5 + o2)/8), e2 = floor((4 + o2)/262144), e3, e4: o1 <= 1 and o1 >= 0 and o2 <= 12 and o2 >= 1 and o3 <= 14 and o3 >= 1 and 8e0 <= 4 + o2 and 8e1 <= 5 + o2 and 262144e2 <= 4 - 8b0 + o2 and 262144e2 >= -262139 + o2 and 262144e2 <= 4 + o2 and 262144e2 >= -3 - 8b0 + o2 and 4e4 <= 1 - 8i0 + 2o1 - o2 + 8e0 and 4e4 <= 4 - 8i0 + 2o1 + o2 - 8e0 and 4e4 >= 2o1 + o2 - 8e1 - 8e3 and 4e4 >= -3 + 2o1 + o2 - 8e0 - 8e3 and 4e4 >= -6 + 2o1 - o2 + 8e0 - 8e3 and 2e4 >= -9 + o1 and 2e4 <= -1 + o1 and 4e4 <= -6 + 2o1 - o2 + 8e1 - 8e3 and 4e4 >= -3 - 8i0 + 2o1 + o2 - 8e0 and 4e4 >= -6 - 8i0 + 2o1 - o2 + 8e0)) or (exists (e0 = floor((4 + o2)/8), e1 = floor((5 + o2)/8), e2 = floor((4 + o2)/262144), e3, e4: o1 <= 1 and o1 >= 0 and o2 <= 12 and o2 >= 1 and o3 <= 14 and o3 >= 1 and 8e0 <= 4 + o2 and 8e1 >= -2 + o2 and 262144e2 <= 4 - 8b0 + o2 and 262144e2 >= -262139 + o2 and 262144e2 <= 4 + o2 and 262144e2 >= -3 - 8b0 + o2 and 4e4 <= 1 - 8i0 + 2o1 - o2 + 8e0 and 4e4 <= 4 - 8i0 + 2o1 + o2 - 8e0 and 4e4 >= -3 + 2o1 + o2 - 8e0 - 8e3 and 4e4 >= -6 + 2o1 - o2 + 8e0 - 8e3 and 2e4 >= -9 + o1 and 2e4 <= -1 + o1 and 4e4 <= 1 + 2o1 - o2 + 8e0 - 8e3 and 4e4 <= 4 + 2o1 + o2 - 8e0 - 8e3 and 4e4 <= -1 + 2o1 + o2 - 8e1 - 8e3 and 4e4 >= -3 - 8i0 + 2o1 + o2 - 8e0 and 4e4 >= -6 - 8i0 + 2o1 - o2 + 8e0)) or (exists (e0 = floor((2 + o2)/8), e1 = floor((4 + o2)/8), e2 = floor((4 + o2)/262144), e3, e4: o1 <= 1 and o1 >= 0 and o2 <= 13 and o2 >= 3 and o3 <= 14 and o3 >= 1 and 8e0 >= -5 + o2 and 8e1 <= 4 + o2 and 262144e2 <= 4 - 8b0 + o2 and 262144e2 >= -262139 + o2 and 262144e2 <= 4 + o2 and 262144e2 >= -3 - 8b0 + o2 and 4e4 <= 1 - 8i0 + 2o1 - o2 + 8e1 and 4e4 <= 4 - 8i0 + 2o1 + o2 - 8e1 and 4e4 >= -3 + 2o1 + o2 - 8e1 - 8e3 and 4e4 >= -6 + 2o1 - o2 + 8e1 - 8e3 and 2e4 >= -9 + o1 and 2e4 <= -1 + o1 and 4e4 <= 1 + 2o1 - o2 + 8e1 - 8e3 and 4e4 <= -4 + 2o1 + o2 - 8e0 - 8e3 and 4e4 <= 4 + 2o1 + o2 - 8e1 - 8e3 and 4e4 >= -3 - 8i0 + 2o1 + o2 - 8e1 and 4e4 >= -6 - 8i0 + 2o1 - o2 + 8e1))) and b0 >= 0 and i0 <= 2 and i0 >= 0 and b0 <= 2 }"
+child:
+  context: "b0 -> {  : b0 <= 2 and b0 >= 0 }"
+  child:
+    schedule: "b0 -> { writei0, o1, o2, o3 -> i0 }, { writei0, i1, i2, i3 -> (i1) }, { writei0, i1, i2, i3 -> (5 - 8b0 + i2) }, { writei0,i1, i2, i3 -> (i3) }"

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/roman.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/roman.c Changed

@@ -1,32 +1,30 @@
-{
-  for (int c1 = 0; c1 <= min(np1 - i, -i + 1); c1 += 1) {
-    S_9(c1);
-    S_12(c1);
-  }
-  for (int c1 = max(0, -i + 2); c1 <= -((-np1 + i + 4294967295) % 4294967296) + 4294967295; c1 += 1) {
-    S_9(c1);
-    S_10(c1);
-    for (int c3 = 0; c3 <= min(19, i + c1 - 3); c3 += 1) {
-      S_15(c1, c3);
-      for (int c5 = 0; c5 < c3; c5 += 1) {
-        S_16(c1, c3, c5);
-        S_17(c1, c3, c5);
-      }
-      S_16(c1, c3, c3);
-      S_18(c1, c3);
-      S_24(c1, c3);
-      S_19(c1, c3);
+for (int c1 = 0; c1 <= min(np1 - i, -i + 1); c1 += 1) {
+  S_9(c1);
+  S_12(c1);
+}
+for (int c1 = max(0, -i + 2); c1 <= -((-np1 + i + 4294967295) % 4294967296) + 4294967295; c1 += 1) {
+  S_9(c1);
+  S_10(c1);
+  for (int c3 = 0; c3 <= min(19, i + c1 - 3); c3 += 1) {
+    S_15(c1, c3);
+    for (int c5 = 0; c5 < c3; c5 += 1) {
+      S_16(c1, c3, c5);
+      S_17(c1, c3, c5);
     }
-    if (np1 >= i && i + c1 <= 21) {
-      S_15(c1, i + c1 - 2);
-      for (int c5 = 0; c5 < i + c1 - 2; c5 += 1) {
-        S_16(c1, i + c1 - 2, c5);
-        S_17(c1, i + c1 - 2, c5);
-      }
-      S_16(c1, i + c1 - 2, i + c1 - 2);
-      S_18(c1, i + c1 - 2);
-      S_24(c1, i + c1 - 2);
+    S_16(c1, c3, c3);
+    S_18(c1, c3);
+    S_24(c1, c3);
+    S_19(c1, c3);
+  }
+  if (i + c1 <= 21) {
+    S_15(c1, i + c1 - 2);
+    for (int c5 = 0; c5 < i + c1 - 2; c5 += 1) {
+      S_16(c1, i + c1 - 2, c5);
+      S_17(c1, i + c1 - 2, c5);
     }
-    S_12(c1);
+    S_16(c1, i + c1 - 2, i + c1 - 2);
+    S_18(c1, i + c1 - 2);
+    S_24(c1, i + c1 - 2);
   }
+  S_12(c1);
 }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separate.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separate.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separate.in -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separate.in Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separate.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separate2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separate2.c Changed

@@ -1,9 +1,8 @@
-if ((length - 1) % 16 <= 14)
-  for (int c0 = 0; c0 <= 1; c0 += 1)
-    for (int c5 = 0; c5 <= 31; c5 += 1)
-      for (int c6 = max(0, 2 * ((length - 1) % 16) + 2 * c5 - 60); c6 <= 30; c6 += 1) {
-        if (length + c5 >= ((length - 1) % 32) + 2 && (length - 1) % 32 >= c5 && 2 * ((length - 1) % 32) + c6 >= 2 * c5 && 2 * c5 + 30 >= 2 * ((length - 1) % 32) + c6 && 2 * ((length - 1) % 32) + c6 == 2 * ((length - 1) % 16) + 2 * c5 && (2 * c5 - c6 + 31) % 32 == 31)
-          S_3(c0, 0, (c6 / 2) - ((length - 1) % 16) + length - 1);
-        if (length <= 16 && length >= c5 + 1 && c6 >= 1 && length >= c6)
-          S_0(c0, c5, c6 - 1);
-      }
+for (int c0 = 0; c0 <= 1; c0 += 1)
+  for (int c5 = 0; c5 <= 31; c5 += 1)
+    for (int c6 = max(0, 2 * (length % 16) + 2 * c5 - 62); c6 <= 30; c6 += 1) {
+      if (2 * length + c6 >= 2 * (length % 16) + 2 && c6 + 62 >= 2 * (length % 16) + 2 * c5 && 2 * (length % 16) >= c6 + 2 && 2 * (length % 16) + 2 * c5 >= c6 && 2 * (length % 32) + c6 == 2 * (length % 16) + 2 * c5 && (2 * c5 - c6) % 32 == 0)
+        S_3(c0, 0, (c6 / 2) - (length % 16) + length);
+      if (length <= 15 && length >= c5 + 1 && c6 >= 1 && length >= c6)
+        S_0(c0, c5, c6 - 1);
+    }

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separation_class.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separation_class.c Changed

@@ -1,17 +1,15 @@
-{
-  for (int c0 = 0; c0 <= 8; c0 += 1) {
-    for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
-      for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1)
-        for (int c3 = 10 * c1; c3 <= 10 * c1 + 9; c3 += 1)
-          A(c2, c3);
-    for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
-      for (int c2 = 10 * c0; c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
-        for (int c3 = 10 * c1; c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
-          A(c2, c3);
-  }
-  for (int c0 = 9; c0 <= 10; c0 += 1)
-    for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
-      for (int c2 = 10 * c0; c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
-        for (int c3 = 10 * c1; c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
-          A(c2, c3);
+for (int c0 = 0; c0 <= 8; c0 += 1) {
+  for (int c1 = 0; c1 <= -c0 + 8; c1 += 1)
+    for (int c2 = 10 * c0; c2 <= 10 * c0 + 9; c2 += 1)
+      for (int c3 = 10 * c1; c3 <= 10 * c1 + 9; c3 += 1)
+        A(c2, c3);
+  for (int c1 = -c0 + 9; c1 <= -c0 + 10; c1 += 1)
+    for (int c2 = 10 * c0; c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+      for (int c3 = 10 * c1; c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+        A(c2, c3);
 }
+for (int c0 = 9; c0 <= 10; c0 += 1)
+  for (int c1 = 0; c1 <= -c0 + 10; c1 += 1)
+    for (int c2 = 10 * c0; c2 <= min(10 * c0 + 9, -10 * c1 + 100); c2 += 1)
+      for (int c3 = 10 * c1; c3 <= min(10 * c1 + 9, -c2 + 100); c3 += 1)
+        A(c2, c3);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separation_class2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separation_class2.c Changed

@@ -1,15 +1,13 @@
-{
-  for (int c0 = 0; c0 < -(n % 8) + n; c0 += 8) {
-    for (int c1 = 0; c1 < -(n % 8) + n; c1 += 8)
-      for (int c2 = 0; c2 <= 7; c2 += 1)
-        for (int c3 = 0; c3 <= 7; c3 += 1)
-          A(c0 + c2, c1 + c3);
+for (int c0 = 0; c0 < -(n % 8) + n; c0 += 8) {
+  for (int c1 = 0; c1 < -(n % 8) + n; c1 += 8)
     for (int c2 = 0; c2 <= 7; c2 += 1)
-      for (int c3 = 0; c3 < n % 8; c3 += 1)
-        A(c0 + c2, -((n - 1) % 8) + n + c3 - 1);
-  }
-  for (int c1 = 0; c1 < n; c1 += 8)
-    for (int c2 = 0; c2 < n % 8; c2 += 1)
-      for (int c3 = 0; c3 <= min(7, n - c1 - 1); c3 += 1)
-        A(-((n - 1) % 8) + n + c2 - 1, c1 + c3);
+      for (int c3 = 0; c3 <= 7; c3 += 1)
+        A(c0 + c2, c1 + c3);
+  for (int c2 = 0; c2 <= 7; c2 += 1)
+    for (int c3 = 0; c3 < n % 8; c3 += 1)
+      A(c0 + c2, -(n % 8) + n + c3);
 }
+for (int c1 = 0; c1 < n; c1 += 8)
+  for (int c2 = 0; c2 < n % 8; c2 += 1)
+    for (int c3 = 0; c3 <= min(7, n - c1 - 1); c3 += 1)
+      A(-(n % 8) + n + c2, c1 + c3);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separation_class3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separation_class3.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/separation_class4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/separation_class4.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/shift2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/shift2.c Changed

@@ -2,17 +2,24 @@
   for (int c2 = 0; c2 <= length; c2 += 32) {
     if (length >= c2 + 1) {
       for (int c3 = 0; c3 <= length; c3 += 32) {
-        for (int c5 = 0; c5 <= min(31, length - c2 - 1); c5 += 1) {
-          for (int c6 = max(0, -c3 + 1); c6 <= min(min(31, length - c3), 2 * c2 - c3 + 2 * c5 - 1); c6 += 1)
+        if (c2 == 0)
+          for (int c6 = max(0, -c3 + 1); c6 <= min(31, length - c3); c6 += 1)
+            S_0(c0, 0, c3 + c6 - 1);
+        for (int c5 = max(0, -c2 + 1); c5 <= min(31, (c3 / 2) - c2 - 1); c5 += 1)
+          for (int c6 = 0; c6 <= min(31, length - c3); c6 += 1)
             S_0(c0, c2 + c5, c3 + c6 - 1);
-          if (c2 + c5 >= 1 && 2 * c2 + 2 * c5 >= c3 && c3 + 30 >= 2 * c2 + 2 * c5) {
-            S_3(c0, 0, c2 + c5);
-            if (length >= 2 * c2 + 2 * c5)
-              S_0(c0, c2 + c5, 2 * c2 + 2 * c5 - 1);
-          }
-          for (int c6 = max(0, 2 * c2 - c3 + 2 * c5 + 1); c6 <= min(31, length - c3); c6 += 1)
+        for (int c5 = max(max(0, -c2 + 1), (c3 / 2) - c2); c5 <= min(min(31, length - c2 - 1), (c3 / 2) - c2 + 15); c5 += 1) {
+          for (int c6 = max(0, -c3 + 1); c6 <= min(length - c3, 2 * c2 - c3 + 2 * c5 - 1); c6 += 1)
+            S_0(c0, c2 + c5, c3 + c6 - 1);
+          S_3(c0, 0, c2 + c5);
+          if (length >= 2 * c2 + 2 * c5)
+            S_0(c0, c2 + c5, 2 * c2 + 2 * c5 - 1);
+          for (int c6 = 2 * c2 - c3 + 2 * c5 + 1; c6 <= min(31, length - c3); c6 += 1)
             S_0(c0, c2 + c5, c3 + c6 - 1);
         }
+        for (int c5 = max(0, (c3 / 2) - c2 + 16); c5 <= min(31, length - c2 - 1); c5 += 1)
+          for (int c6 = max(0, -c3 + 1); c6 <= min(31, length - c3); c6 += 1)
+            S_0(c0, c2 + c5, c3 + c6 - 1);
         if (length <= 15 && c2 == 0 && c3 == 0)
           S_4(c0);
         if (c3 >= 2 * c2 && 2 * c2 + 32 >= c3)
@@ -27,12 +34,13 @@
           if (c3 + 30 >= 2 * length && c4 == 0)
             S_4(c0);
         }
-      if (c2 + 16 == length && (length + 16) % 32 == 0)
+      if (c2 + 16 == length)
         S_4(c0);
-    } else if (length == 0) {
+    } else if (length >= 32) {
       S_4(c0);
-    } else
+    } else {
       S_4(c0);
+    }
   }
   for (int c1 = 32; c1 < length - 1; c1 += 32)
     for (int c2 = c1; c2 < length; c2 += 32)

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/sor1d-part.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/sor1d-part.st Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/stride5.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/stride5.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/stride7.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/stride7.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll10.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll11.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll11.in Added

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll2.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll2.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll3.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll3.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll4.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll4.c Changed

@@ -1,22 +1,14 @@
-{
-  write_shared_A(3, ((t1 + 3) % 4) + 1, ((t2 + 31) % 32) + 1);
-  if (t2 >= 1 && t2 <= 2 && t1 % 3 == 0)
-    write_shared_A(3, (-t1 / 3) + 4, t2 + 32);
-  {
-    int c3 = t2 >= 2 && ((t1 + 3) % 4) + 1 >= t2 ? t2 + 32 : ((t2 + 30) % 32) + 2;
-    if (c3 == t2 + 32 || (c3 == t2 && t2 >= ((t1 + 3) % 4) + ((t2 - 1) % 2) + 2))
-      write_shared_A(3, ((t1 + 3) % 4) + 5, c3);
-  }
-  if (t1 >= 1 && t2 >= t1 + 1 && t2 <= 4)
-    write_shared_A(3, t1 + 4, t2 + 32);
-  write_shared_A(4, ((t1 + 3) % 4) + 1, ((t2 + 31) % 32) + 1);
-  if (t2 >= 1 && t2 <= 2 && t1 % 3 == 0)
-    write_shared_A(4, (-t1 / 3) + 4, t2 + 32);
-  {
-    int c3 = t2 >= 2 && ((t1 + 3) % 4) + 1 >= t2 ? t2 + 32 : ((t2 + 30) % 32) + 2;
-    if (c3 == t2 + 32 || (c3 == t2 && t2 >= ((t1 + 3) % 4) + ((t2 - 1) % 2) + 2))
-      write_shared_A(4, ((t1 + 3) % 4) + 5, c3);
-  }
-  if (t1 >= 1 && t2 >= t1 + 1 && t2 <= 4)
-    write_shared_A(4, t1 + 4, t2 + 32);
-}
+write_shared_A(3, ((t1 + 3) % 4) + 1, ((t2 + 31) % 32) + 1);
+if (t2 >= 1 && t2 <= 2 && t1 % 3 == 0)
+  write_shared_A(3, (-t1 / 3) + 4, t2 + 32);
+if (((t1 + 3) % 4) + 1 >= t2 || t2 >= ((t1 + 3) % 4) + ((t2 + 1) % 2) + 2)
+  write_shared_A(3, ((t1 + 3) % 4) + 5, -((((t1 + 3) % 4) - t2 + 33) % 32) + t1 + 4 * ((-t1 + 4) / 4) + 32);
+if (t1 >= 1 && t2 >= t1 + 1 && t2 <= 4)
+  write_shared_A(3, t1 + 4, t2 + 32);
+write_shared_A(4, ((t1 + 3) % 4) + 1, ((t2 + 31) % 32) + 1);
+if (t2 >= 1 && t2 <= 2 && t1 % 3 == 0)
+  write_shared_A(4, (-t1 / 3) + 4, t2 + 32);
+if (((t1 + 3) % 4) + 1 >= t2 || t2 >= ((t1 + 3) % 4) + ((t2 + 1) % 2) + 2)
+  write_shared_A(4, ((t1 + 3) % 4) + 5, -((((t1 + 3) % 4) - t2 + 33) % 32) + t1 + 4 * ((-t1 + 4) / 4) + 32);
+if (t1 >= 1 && t2 >= t1 + 1 && t2 <= 4)
+  write_shared_A(4, t1 + 4, t2 + 32);

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll6.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll6.c Changed

_service:tar_scm:isl-0.14.tar.xz/test_inputs/codegen/unroll7.c -> _service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll7.c Changed

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll8.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll8.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll9.c Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/codegen/unroll9.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/exist.pip Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/exist2.pip Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop2-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop2-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop2.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop2.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop3-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop3-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop3.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_loop3.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop2-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop2-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop2.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop2.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop3-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop3-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop3.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/kill_may_loop3.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/loop-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/loop-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/loop.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/loop.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/may_loop-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/may_loop-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/may_loop.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/may_loop.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/mixed_loop-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/mixed_loop-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/mixed_loop.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/mixed_loop.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source2-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source2-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source2.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source2.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source3-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source3-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source3.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source3.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source4-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source4-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source4.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/multi_source4.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source2-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source2-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source2.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/no_source2.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_may_source-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_may_source-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_may_source.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_may_source.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_source-tree.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_source-tree.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_source.ai Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/flow/single_source.flow Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/bounded_coefficients.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/bounded_coefficients.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/carry_bounded_coefficients.sc Added

@@ -0,0 +1,19 @@
+# Check that the dependence carrying step is not confused by
+# a bound on the coefficient size.
+# In particular, force the scheduler to move to a dependence carrying
+# step by demanding outer coincidence and bound the size of
+# the coefficients.  Earlier versions of isl would take this
+# bound into account while carrying dependences, breaking
+# fundamental assumptions.
+# On the other hand, the dependence carrying step now tries
+# to prevent loop coalescing by default, so check that indeed
+# no loop coalescing occurs by comparing the computed schedule
+# to the expected non-coalescing schedule.
+# OPTIONS: --schedule-outer-coincidence --schedule-max-coefficient=20
+domain: { Ci0, i1 : 2 <= i0 <= 3999 and 0 <= i1 <= -1 + i0 }
+validity: { Ci0, i1 -> Ci0, 1 + i1 : i0 <= 3999 and i1 >= 0 and
+						i1 <= -2 + i0;
+		Ci0, -1 + i0 -> C1 + i0, 0 : i0 <= 3998 and i0 >= 1 }
+coincidence: { Ci0, i1 -> Ci0, 1 + i1 : i0 <= 3999 and i1 >= 0 and
+						i1 <= -2 + i0;
+		Ci0, -1 + i0 -> C1 + i0, 0 : i0 <= 3998 and i0 >= 1 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/carry_bounded_coefficients.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/disjunctive_domain.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/disjunctive_domain.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/feautrier_compressed.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/feautrier_compressed.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat1.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat1.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat2.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat2.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat3.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat3.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat4.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat4.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat5.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat5.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat6.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/flat6.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/max_coincidence.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/max_coincidence.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/niewang.sc Added

@@ -0,0 +1,29 @@
+# In earlier version of isl, this test case would take an inordinate
+# amount of time (in the order of 30s versus 0.1s in later versions)
+# due to a call to isl_basic_set_coefficients.
+# Check that this no longer happens in the sense that this test case
+# would stand out if it were to take that long again.
+# The actual schedule that is produced is not that important,
+# but it is different depending on whether the whole-component scheduler
+# is being used, so pick a particular setting.
+# OPTIONS: --no-schedule-whole-component
+domain: { S_30:223, 0:223, 0:15, 0:3, 0:6, 0:6, 0:15; group00:3,
+0:223, 0:223, 0:15 }
+validity: { group0i0 = 0:3, i1 = 0:223, i2 = 0:223, i3 = 0:15
+-> S_3h = 0:223, w = 0:223, c0 = 0:15, kc1 = i0, kh = 3 + i1 - h,
+kw = 3 + i2 - w, kc0 = i3 : -3 + i1 <= h <= 3 + i1 and -3 + i2 <=
+w <= 3 + i2; group0i0 = 0:3, i1 = 0:223, i2 = 0:223, i3 = 0:15 ->
+group0i0, i1, i2, i3 : (i1) mod 2 = 0 and (i2) mod 2 = 0; S_3h =
+0:223, w = 0:223, c0 = 0:15, kc1 = 0:3, kh = 0:6, kw = 0:6, kc0 = 0:14
+-> S_3h' = h, w' = w, c0' = c0, kc1' = kc1, kh' = kh, kw' = kw, kc0'
+= 1 + kc0; S_3h = 0:223, w = 0:223, c0 = 0:15, kc1 = 0:3, kh = 0:6,
+kw = 0:5, kc0 = 15 -> S_3h' = h, w' = w, c0' = c0, kc1' = kc1, kh'
+= kh, kw' = 1 + kw, kc0' = 0; S_3h = 0:223, w = 0:223, c0 = 0:15,
+kc1 = 0:3, kh = 0:5, kw = 6, kc0 = 15 -> S_3h' = h, w' = w, c0' =
+c0, kc1' = kc1, kh' = 1 + kh, kw' = 0, kc0' = 0; S_3h = 0:223, w =
+0:223, c0 = 0:15, kc1 = 0:2, kh = 6, kw = 6, kc0 = 15 -> S_3h' =
+h, w' = w, c0' = c0, kc1' = 1 + kc1, kh' = 0, kw' = 0, kc0' = 0 }
+proximity: { group0i0 = 0:3, i1 = 0:223, i2 = 0:223, i3 = 0:15 ->
+S_3h = 0:223, w = 0:223, c0 = 0:15, kc1 = i0, kh = 3 + i1 - h, kw =
+3 + i2 - w, kc0 = i3 : -3 + i1 <= h <= 3 + i1 and -3 + i2 <= w <=
+3 + i2 }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/niewang.st Added

@@ -0,0 +1,25 @@
+domain: "{ S_3i0, i1, i2, i3, i4, i5, i6 : 0 <= i0 <= 223 and 0 <= i1 <= 223 and 0 <= i2 <= 15 and 0 <= i3 <= 3 and 0 <= i4 <= 6 and 0 <= i5 <= 6 and 0 <= i6 <= 15; group0i0, i1, i2, i3 : 0 <= i0 <= 3 and 0 <= i1 <= 223 and 0 <= i2 <= 223 and 0 <= i3 <= 15 }"
+child:
+  sequence:
+  - filter: "{ group0i0, i1, i2, i3 }"
+    child:
+      schedule: "{ group0i0, i1, i2, i3 -> (i0) }, { group0i0, i1, i2, i3 -> (i1) }, { group0i0, i1, i2, i3 -> (i2) }, { group0i0, i1, i2, i3 -> (i3) }"
+      permutable: 1
+      coincident:  1, 1, 1, 1 
+  - filter: "{ S_3i0, i1, i2, i3, i4, i5, i6 }"
+    child:
+      schedule: "{ S_3i0, i1, i2, i3, i4, i5, i6 -> (i0) }, { S_3i0, i1, i2, i3, i4, i5, i6 -> (i1) }, { S_3i0, i1, i2, i3, i4, i5, i6 -> (i2) }, { S_3i0, i1, i2, i3, i4, i5, i6 -> (i3) }"
+      permutable: 1
+      coincident:  1, 1, 1, 1 
+      child:
+        schedule: "{ S_3i0, i1, i2, i3, i4, i5, i6 -> (i4) }"
+        permutable: 1
+        coincident:  1 
+        child:
+          schedule: "{ S_3i0, i1, i2, i3, i4, i5, i6 -> (i5) }"
+          permutable: 1
+          coincident:  1 
+          child:
+            schedule: "{ S_3i0, i1, i2, i3, i4, i5, i6 -> (i6) }"
+            permutable: 1
+            coincident:  1

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/nomax_coincidence.sc Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/nomax_coincidence.st Added

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/poliwoda.sc Added

@@ -0,0 +1,47 @@
+# In earlier versions of isl, this test case would cause
+# the loop coalescing avoidance to break down because one of the dimensions
+# (Id2 in S_1) has a fixed value in terms of the other dimensions.
+# Check that this no longer happens.
+# The actual schedule that is produced is not that important,
+# but it is different depending on whether the whole-component scheduler
+# is being used, so pick a particular setting.
+# OPTIONS: --schedule-whole-component
+domain: _PB_M, _PB_N -> { S_0Id1, Id2, Id3 : _PB_M >= 2 and Id1 >=
+0 and 4Id1 < _PB_N and 2Id2 >= -_PB_M and 4Id2 <= -_PB_M and Id3 <=
+0 and 4Id3 >= -3 + _PB_M + 4Id2 and 4Id3 >= -1 - _PB_M; S_1Id1, Id2,
+Id3 : _PB_M >= 2 and Id1 >= 0 and 4Id1 < _PB_N and -_PB_M <= 2Id2 <=
+1 - _PB_M and Id3 <= 0 and 4Id3 >= -1 - _PB_M }
+validity: _PB_M, _PB_N -> { S_0Id1, Id2, Id3 -> S_0Id1' = Id1, Id2',
+Id3' : Id1 >= 0 and 4Id1 < _PB_N and Id3 <= 0 and 4Id3 >= -3 + _PB_M +
+4Id2 and Id2' <= Id2 and 2Id2' >= -_PB_M and Id3' < 0 and Id3' <= Id3
+and Id3' < Id2 + Id3 - Id2' and 4Id3' >= -4 + _PB_M + 4Id2 and 4Id3' >=
+-3 + _PB_M + 3Id2 + Id2' and -1 - _PB_M <= 4Id3' <= 2 + _PB_M + 4Id2;
+S_0Id1, Id2, Id3 -> S_0Id1' = Id1, Id2', Id3' = Id3 : Id1 >= 0 and
+4Id1 < _PB_N and 4Id2 <= -_PB_M and Id3 <= 0 and 4Id3 >= -3 + _PB_M +
+4Id2 and Id2' < Id2 and 2Id2' >= -_PB_M; S_0Id1, Id2, Id3 -> S_1Id1'
+= Id1, Id2', Id3' : Id1 >= 0 and 4Id1 < _PB_N and Id3 <= 0 and 4Id3 >=
+-3 + _PB_M + 4Id2 and Id2' < Id2 and -_PB_M <= 2Id2' <= 1 - _PB_M and
+Id3' < 0 and Id3' <= Id3 and -4 + _PB_M + 4Id2 <= 4Id3' <= 2 + _PB_M +
+4Id2; S_0Id1, Id2, Id3 -> S_1Id1' = Id1, Id2' = Id2, Id3' : Id1 >=
+0 and 4Id1 < _PB_N and -_PB_M <= 2Id2 <= 1 - _PB_M and Id3 <= 0 and Id3'
+< Id3 and -1 - _PB_M <= 4Id3' <= 2 + _PB_M + 4Id2; S_0Id1, Id2, Id3
+-> S_1Id1' = Id1, Id2', Id3' = Id3 : Id1 >= 0 and 4Id1 < _PB_N and
+4Id2 <= -_PB_M and Id3 <= 0 and 4Id3 >= -3 + _PB_M + 4Id2 and Id2' <
+Id2 and -_PB_M <= 2Id2' <= 1 - _PB_M }
+proximity: _PB_M, _PB_N -> { S_0Id1, Id2, Id3 -> S_0Id1' = Id1, Id2',
+Id3' : Id1 >= 0 and 4Id1 < _PB_N and Id3 <= 0 and 4Id3 >= -3 + _PB_M +
+4Id2 and Id2' <= Id2 and 2Id2' >= -_PB_M and Id3' < 0 and Id3' <= Id3
+and Id3' < Id2 + Id3 - Id2' and 4Id3' >= -4 + _PB_M + 4Id2 and 4Id3' >=
+-3 + _PB_M + 3Id2 + Id2' and -1 - _PB_M <= 4Id3' <= 2 + _PB_M + 4Id2;
+S_0Id1, Id2, Id3 -> S_0Id1' = Id1, Id2', Id3' = Id3 : Id1 >= 0 and
+4Id1 < _PB_N and 4Id2 <= -_PB_M and Id3 <= 0 and 4Id3 >= -3 + _PB_M +
+4Id2 and Id2' < Id2 and 2Id2' >= -_PB_M; S_0Id1, Id2, Id3 -> S_1Id1'
+= Id1, Id2', Id3' : Id1 >= 0 and 4Id1 < _PB_N and Id3 <= 0 and 4Id3 >=
+-3 + _PB_M + 4Id2 and Id2' < Id2 and -_PB_M <= 2Id2' <= 1 - _PB_M and
+Id3' < 0 and Id3' <= Id3 and -4 + _PB_M + 4Id2 <= 4Id3' <= 2 + _PB_M +
+4Id2; S_0Id1, Id2, Id3 -> S_1Id1' = Id1, Id2' = Id2, Id3' : Id1 >=
+0 and 4Id1 < _PB_N and -_PB_M <= 2Id2 <= 1 - _PB_M and Id3 <= 0 and Id3'
+< Id3 and -1 - _PB_M <= 4Id3' <= 2 + _PB_M + 4Id2; S_0Id1, Id2, Id3
+-> S_1Id1' = Id1, Id2', Id3' = Id3 : Id1 >= 0 and 4Id1 < _PB_N and
+4Id2 <= -_PB_M and Id3 <= 0 and 4Id3 >= -3 + _PB_M + 4Id2 and Id2' <
+Id2 and -_PB_M <= 2Id2' <= 1 - _PB_M }

_service:tar_scm:isl-0.24.tar.gz/test_inputs/schedule/poliwoda.st Added

_service:tar_scm:isl-0.24.tar.gz/uset_from_umap.c Added

_service:tar_scm:isl-0.24.tar.gz/uset_to_umap.c Added